gpg: Fix a NULL-deref in export due to invalid packet lengths.
[gnupg.git] / g10 / build-packet.c
1 /* build-packet.c - assemble packets and write them
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2010, 2011  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <ctype.h>
27
28 #include "gpg.h"
29 #include "util.h"
30 #include "packet.h"
31 #include "status.h"
32 #include "iobuf.h"
33 #include "i18n.h"
34 #include "options.h"
35
36 static int do_user_id( IOBUF out, int ctb, PKT_user_id *uid );
37 static int do_key (iobuf_t out, int ctb, PKT_public_key *pk);
38 static int do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc );
39 static int do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc );
40 static u32 calc_plaintext( PKT_plaintext *pt );
41 static int do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt );
42 static int do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed );
43 static int do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed );
44 static int do_compressed( IOBUF out, int ctb, PKT_compressed *cd );
45 static int do_signature( IOBUF out, int ctb, PKT_signature *sig );
46 static int do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops );
47
48 static int calc_header_length( u32 len, int new_ctb );
49 static int write_16(IOBUF inp, u16 a);
50 static int write_32(IOBUF inp, u32 a);
51 static int write_header( IOBUF out, int ctb, u32 len );
52 static int write_sign_packet_header( IOBUF out, int ctb, u32 len );
53 static int write_header2( IOBUF out, int ctb, u32 len, int hdrlen );
54 static int write_new_header( IOBUF out, int ctb, u32 len, int hdrlen );
55
56 /****************
57  * Build a packet and write it to INP
58  * Returns: 0 := okay
59  *         >0 := error
60  * Note: Caller must free the packet
61  */
62 int
63 build_packet( IOBUF out, PACKET *pkt )
64 {
65     int new_ctb=0, rc=0, ctb;
66     int pkttype;
67
68     if( DBG_PACKET )
69         log_debug("build_packet() type=%d\n", pkt->pkttype );
70     assert( pkt->pkt.generic );
71
72     switch ((pkttype = pkt->pkttype))
73       {
74       case PKT_PUBLIC_KEY:
75         if (pkt->pkt.public_key->seckey_info)
76           pkttype = PKT_SECRET_KEY;
77         break;
78       case PKT_PUBLIC_SUBKEY:
79         if (pkt->pkt.public_key->seckey_info)
80           pkttype = PKT_SECRET_SUBKEY;
81         break;
82       case PKT_PLAINTEXT: new_ctb = pkt->pkt.plaintext->new_ctb; break;
83       case PKT_ENCRYPTED:
84       case PKT_ENCRYPTED_MDC: new_ctb = pkt->pkt.encrypted->new_ctb; break;
85       case PKT_COMPRESSED:new_ctb = pkt->pkt.compressed->new_ctb; break;
86       case PKT_USER_ID:
87         if( pkt->pkt.user_id->attrib_data )
88           pkttype = PKT_ATTRIBUTE;
89         break;
90       default: break;
91       }
92
93     if( new_ctb || pkttype > 15 ) /* new format */
94         ctb = 0xc0 | (pkttype & 0x3f);
95     else
96         ctb = 0x80 | ((pkttype & 15)<<2);
97     switch( pkttype )
98       {
99       case PKT_ATTRIBUTE:
100       case PKT_USER_ID:
101         rc = do_user_id( out, ctb, pkt->pkt.user_id );
102         break;
103       case PKT_OLD_COMMENT:
104       case PKT_COMMENT:
105         /*
106           Ignore these.  Theoretically, this will never be called as
107           we have no way to output comment packets any longer, but
108           just in case there is some code path that would end up
109           outputting a comment that was written before comments were
110           dropped (in the public key?) this is a no-op.
111         */
112         break;
113       case PKT_PUBLIC_SUBKEY:
114       case PKT_PUBLIC_KEY:
115       case PKT_SECRET_SUBKEY:
116       case PKT_SECRET_KEY:
117         rc = do_key (out, ctb, pkt->pkt.public_key);
118         break;
119       case PKT_SYMKEY_ENC:
120         rc = do_symkey_enc( out, ctb, pkt->pkt.symkey_enc );
121         break;
122       case PKT_PUBKEY_ENC:
123         rc = do_pubkey_enc( out, ctb, pkt->pkt.pubkey_enc );
124         break;
125       case PKT_PLAINTEXT:
126         rc = do_plaintext( out, ctb, pkt->pkt.plaintext );
127         break;
128       case PKT_ENCRYPTED:
129         rc = do_encrypted( out, ctb, pkt->pkt.encrypted );
130         break;
131       case PKT_ENCRYPTED_MDC:
132         rc = do_encrypted_mdc( out, ctb, pkt->pkt.encrypted );
133         break;
134       case PKT_COMPRESSED:
135         rc = do_compressed( out, ctb, pkt->pkt.compressed );
136         break;
137       case PKT_SIGNATURE:
138         rc = do_signature( out, ctb, pkt->pkt.signature );
139         break;
140       case PKT_ONEPASS_SIG:
141         rc = do_onepass_sig( out, ctb, pkt->pkt.onepass_sig );
142         break;
143       case PKT_RING_TRUST:
144         break; /* ignore it (keyring.c does write it directly)*/
145       case PKT_MDC: /* we write it directly, so we should never see it here. */
146       default:
147         log_bug("invalid packet type in build_packet()\n");
148         break;
149       }
150
151     return rc;
152 }
153
154
155 /*
156  * Write the mpi A to OUT.
157  */
158 gpg_error_t
159 gpg_mpi_write (iobuf_t out, gcry_mpi_t a)
160 {
161   int rc;
162
163   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
164     {
165       unsigned int nbits;
166       const void *p;
167       unsigned int lenhdr[2];
168
169       p = gcry_mpi_get_opaque (a, &nbits);
170       lenhdr[0] = nbits >> 8;
171       lenhdr[1] = nbits;
172       rc = iobuf_write (out, lenhdr, 2);
173       if (!rc)
174         rc = iobuf_write (out, p, (nbits+7)/8);
175     }
176   else
177     {
178       char buffer[(MAX_EXTERN_MPI_BITS+7)/8+2]; /* 2 is for the mpi length. */
179       size_t nbytes;
180
181       nbytes = DIM(buffer);
182       rc = gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, &nbytes, a );
183       if( !rc )
184         rc = iobuf_write( out, buffer, nbytes );
185       else if (gpg_err_code(rc) == GPG_ERR_TOO_SHORT )
186         {
187           log_info ("mpi too large (%u bits)\n", gcry_mpi_get_nbits (a));
188           /* The buffer was too small. We better tell the user about the MPI. */
189           rc = gpg_error (GPG_ERR_TOO_LARGE);
190         }
191     }
192
193   return rc;
194 }
195
196
197 /*
198  * Write an opaque MPI to the output stream without length info.
199  */
200 gpg_error_t
201 gpg_mpi_write_nohdr (iobuf_t out, gcry_mpi_t a)
202 {
203   int rc;
204
205   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
206     {
207       unsigned int nbits;
208       const void *p;
209
210       p = gcry_mpi_get_opaque (a, &nbits);
211       rc = iobuf_write (out, p, (nbits+7)/8);
212     }
213   else
214     rc = gpg_error (GPG_ERR_BAD_MPI);
215
216   return rc;
217 }
218
219
220 /* Calculate the length of a packet described by PKT.  */
221 u32
222 calc_packet_length( PACKET *pkt )
223 {
224     u32 n=0;
225     int new_ctb = 0;
226
227     assert( pkt->pkt.generic );
228     switch( pkt->pkttype ) {
229       case PKT_PLAINTEXT:
230         n = calc_plaintext( pkt->pkt.plaintext );
231         new_ctb = pkt->pkt.plaintext->new_ctb;
232         break;
233       case PKT_ATTRIBUTE:
234       case PKT_USER_ID:
235       case PKT_COMMENT:
236       case PKT_PUBLIC_KEY:
237       case PKT_SECRET_KEY:
238       case PKT_SYMKEY_ENC:
239       case PKT_PUBKEY_ENC:
240       case PKT_ENCRYPTED:
241       case PKT_SIGNATURE:
242       case PKT_ONEPASS_SIG:
243       case PKT_RING_TRUST:
244       case PKT_COMPRESSED:
245       default:
246         log_bug("invalid packet type in calc_packet_length()");
247         break;
248     }
249
250     n += calc_header_length(n, new_ctb);
251     return n;
252 }
253
254
255 static gpg_error_t
256 write_fake_data (IOBUF out, gcry_mpi_t a)
257 {
258   unsigned int n;
259   void *p;
260
261   if (!a)
262     return 0;
263   p = gcry_mpi_get_opaque ( a, &n);
264   if (!p)
265     return 0; /* For example due to a read error in
266                  parse-packet.c:read_rest.  */
267   return iobuf_write (out, p, (n+7)/8 );
268 }
269
270
271 static int
272 do_user_id( IOBUF out, int ctb, PKT_user_id *uid )
273 {
274   int rc;
275
276   if (uid->attrib_data)
277     {
278       write_header(out, ctb, uid->attrib_len);
279       rc = iobuf_write( out, uid->attrib_data, uid->attrib_len );
280     }
281   else
282     {
283       write_header2( out, ctb, uid->len, 2 );
284       rc = iobuf_write( out, uid->name, uid->len );
285     }
286   return rc;
287 }
288
289
290 static int
291 do_key (iobuf_t out, int ctb, PKT_public_key *pk)
292 {
293   gpg_error_t err = 0;
294   int i, nskey, npkey;
295   iobuf_t a = iobuf_temp(); /* Build in a self-enlarging buffer.  */
296
297   /* Write the version number - if none is specified, use 4 */
298   if ( !pk->version )
299     iobuf_put ( a, 4 );
300   else
301     iobuf_put ( a, pk->version );
302   write_32 (a, pk->timestamp );
303
304   iobuf_put (a, pk->pubkey_algo );
305
306   /* Get number of secret and public parameters.  They are held in one
307      array first the public ones, then the secret ones.  */
308   nskey = pubkey_get_nskey (pk->pubkey_algo);
309   npkey = pubkey_get_npkey (pk->pubkey_algo);
310
311   /* If we don't have any public parameters - which is for example the
312      case if we don't know the algorithm used - the parameters are
313      stored as one blob in a faked (opaque) MPI. */
314   if (!npkey)
315     {
316       write_fake_data (a, pk->pkey[0]);
317       goto leave;
318     }
319   assert (npkey < nskey);
320
321   for (i=0; i < npkey; i++ )
322     {
323       if (   (pk->pubkey_algo == PUBKEY_ALGO_ECDSA && (i == 0))
324           || (pk->pubkey_algo == PUBKEY_ALGO_EDDSA && (i == 0))
325           || (pk->pubkey_algo == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
326         err = gpg_mpi_write_nohdr (a, pk->pkey[i]);
327       else
328         err = gpg_mpi_write (a, pk->pkey[i]);
329       if (err)
330         goto leave;
331     }
332
333
334   if (pk->seckey_info)
335     {
336       /* This is a secret key packet.  */
337       struct seckey_info *ski = pk->seckey_info;
338
339       /* Build the header for protected (encrypted) secret parameters.  */
340       if (ski->is_protected)
341         {
342           /* OpenPGP protection according to rfc2440. */
343           iobuf_put (a, ski->sha1chk? 0xfe : 0xff);
344           iobuf_put (a, ski->algo);
345           if (ski->s2k.mode >= 1000)
346             {
347               /* These modes are not possible in OpenPGP, we use them
348                  to implement our extensions, 101 can be viewed as a
349                  private/experimental extension (this is not specified
350                  in rfc2440 but the same scheme is used for all other
351                  algorithm identifiers). */
352               iobuf_put (a, 101);
353               iobuf_put (a, ski->s2k.hash_algo);
354               iobuf_write (a, "GNU", 3 );
355               iobuf_put (a, ski->s2k.mode - 1000);
356             }
357           else
358             {
359               iobuf_put (a, ski->s2k.mode);
360               iobuf_put (a, ski->s2k.hash_algo);
361             }
362
363           if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
364             iobuf_write (a, ski->s2k.salt, 8);
365
366           if (ski->s2k.mode == 3)
367             iobuf_put (a, ski->s2k.count);
368
369           /* For our special modes 1001, 1002 we do not need an IV. */
370           if (ski->s2k.mode != 1001 && ski->s2k.mode != 1002)
371             iobuf_write (a, ski->iv, ski->ivlen);
372
373         }
374       else /* Not protected. */
375         iobuf_put (a, 0 );
376
377       if (ski->s2k.mode == 1001)
378         ; /* GnuPG extension - don't write a secret key at all. */
379       else if (ski->s2k.mode == 1002)
380         {
381           /* GnuPG extension - divert to OpenPGP smartcard. */
382           /* Length of the serial number or 0 for no serial number. */
383           iobuf_put (a, ski->ivlen );
384           /* The serial number gets stored in the IV field.  */
385           iobuf_write (a, ski->iv, ski->ivlen);
386         }
387       else if (ski->is_protected)
388         {
389           /* The secret key is protected - write it out as it is.  */
390           byte *p;
391           unsigned int ndatabits;
392
393           assert (gcry_mpi_get_flag (pk->pkey[npkey], GCRYMPI_FLAG_OPAQUE));
394           p = gcry_mpi_get_opaque (pk->pkey[npkey], &ndatabits);
395           iobuf_write (a, p, (ndatabits+7)/8 );
396         }
397       else
398         {
399           /* Non-protected key. */
400           for ( ; i < nskey; i++ )
401             if ( (err = gpg_mpi_write (a, pk->pkey[i])))
402               goto leave;
403           write_16 (a, ski->csum );
404         }
405     }
406
407  leave:
408   if (!err)
409     {
410       /* Build the header of the packet - which we must do after
411          writing all the other stuff, so that we know the length of
412          the packet */
413       write_header2 (out, ctb, iobuf_get_temp_length(a), pk->hdrbytes);
414       /* And finally write it out to the real stream. */
415       err = iobuf_write_temp (out, a);
416     }
417
418   iobuf_close (a); /* Close the temporary buffer */
419   return err;
420 }
421
422 static int
423 do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
424 {
425     int rc = 0;
426     IOBUF a = iobuf_temp();
427
428     assert( enc->version == 4 );
429     switch( enc->s2k.mode ) {
430       case 0: case 1: case 3: break;
431       default: log_bug("do_symkey_enc: s2k=%d\n", enc->s2k.mode );
432     }
433     iobuf_put( a, enc->version );
434     iobuf_put( a, enc->cipher_algo );
435     iobuf_put( a, enc->s2k.mode );
436     iobuf_put( a, enc->s2k.hash_algo );
437     if( enc->s2k.mode == 1 || enc->s2k.mode == 3 ) {
438         iobuf_write(a, enc->s2k.salt, 8 );
439         if( enc->s2k.mode == 3 )
440             iobuf_put(a, enc->s2k.count);
441     }
442     if( enc->seskeylen )
443         iobuf_write(a, enc->seskey, enc->seskeylen );
444
445     write_header(out, ctb, iobuf_get_temp_length(a) );
446     rc = iobuf_write_temp( out, a );
447
448     iobuf_close(a);
449     return rc;
450 }
451
452
453 static int
454 do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
455 {
456   int rc = 0;
457   int n, i;
458   IOBUF a = iobuf_temp();
459
460   iobuf_put (a, 3); /* Version.  */
461
462   if ( enc->throw_keyid )
463     {
464       write_32(a, 0 );  /* Don't tell Eve who can decrypt the message.  */
465       write_32(a, 0 );
466     }
467   else
468     {
469       write_32(a, enc->keyid[0] );
470       write_32(a, enc->keyid[1] );
471     }
472   iobuf_put(a,enc->pubkey_algo );
473   n = pubkey_get_nenc( enc->pubkey_algo );
474   if ( !n )
475     write_fake_data( a, enc->data[0] );
476
477   for (i=0; i < n && !rc ; i++ )
478     {
479       if (enc->pubkey_algo == PUBKEY_ALGO_ECDH && i == 1)
480         rc = gpg_mpi_write_nohdr (a, enc->data[i]);
481       else
482         rc = gpg_mpi_write (a, enc->data[i]);
483     }
484
485   if (!rc)
486     {
487       write_header (out, ctb, iobuf_get_temp_length(a) );
488       rc = iobuf_write_temp (out, a);
489     }
490   iobuf_close(a);
491   return rc;
492 }
493
494
495 static u32
496 calc_plaintext( PKT_plaintext *pt )
497 {
498   /* Truncate namelen to the maximum 255 characters.  Note this means
499      that a function that calls build_packet with an illegal literal
500      packet will get it back legalized. */
501
502   if(pt->namelen>255)
503     pt->namelen=255;
504
505   return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
506 }
507
508 static int
509 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
510 {
511     int i, rc = 0;
512     u32 n;
513     byte buf[1000]; /* this buffer has the plaintext! */
514     int nbytes;
515
516     write_header(out, ctb, calc_plaintext( pt ) );
517     iobuf_put(out, pt->mode );
518     iobuf_put(out, pt->namelen );
519     for(i=0; i < pt->namelen; i++ )
520         iobuf_put(out, pt->name[i] );
521     rc = write_32(out, pt->timestamp );
522     if (rc)
523       return rc;
524
525     n = 0;
526     while( (nbytes=iobuf_read(pt->buf, buf, 1000)) != -1 ) {
527       rc = iobuf_write (out, buf, nbytes);
528       if (rc)
529         break;
530       n += nbytes;
531     }
532     wipememory(buf,1000); /* burn the buffer */
533     if( (ctb&0x40) && !pt->len )
534       iobuf_set_partial_block_mode(out, 0 ); /* turn off partial */
535     if( pt->len && n != pt->len )
536       log_error("do_plaintext(): wrote %lu bytes but expected %lu bytes\n",
537                 (ulong)n, (ulong)pt->len );
538
539     return rc;
540 }
541
542
543
544 static int
545 do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
546 {
547     int rc = 0;
548     u32 n;
549
550     n = ed->len ? (ed->len + ed->extralen) : 0;
551     write_header(out, ctb, n );
552
553     /* This is all. The caller has to write the real data */
554
555     return rc;
556 }
557
558 static int
559 do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
560 {
561     int rc = 0;
562     u32 n;
563
564     assert( ed->mdc_method );
565
566     /* Take version number and the following MDC packet in account. */
567     n = ed->len ? (ed->len + ed->extralen + 1 + 22) : 0;
568     write_header(out, ctb, n );
569     iobuf_put(out, 1 );  /* version */
570
571     /* This is all. The caller has to write the real data */
572
573     return rc;
574 }
575
576
577 static int
578 do_compressed( IOBUF out, int ctb, PKT_compressed *cd )
579 {
580     int rc = 0;
581
582     /* We must use the old convention and don't use blockmode for the
583        sake of PGP 2 compatibility.  However if the new_ctb flag was
584        set, CTB is already formatted as new style and write_header2
585        does create a partial length encoding using new the new
586        style. */
587     write_header2(out, ctb, 0, 0);
588     iobuf_put(out, cd->algorithm );
589
590     /* This is all. The caller has to write the real data */
591
592     return rc;
593 }
594
595
596 /****************
597  * Delete all subpackets of type REQTYPE and return a bool whether a packet
598  * was deleted.
599  */
600 int
601 delete_sig_subpkt (subpktarea_t *area, sigsubpkttype_t reqtype )
602 {
603     int buflen;
604     sigsubpkttype_t type;
605     byte *buffer, *bufstart;
606     size_t n;
607     size_t unused = 0;
608     int okay = 0;
609
610     if( !area )
611         return 0;
612     buflen = area->len;
613     buffer = area->data;
614     for(;;) {
615         if( !buflen ) {
616             okay = 1;
617             break;
618         }
619         bufstart = buffer;
620         n = *buffer++; buflen--;
621         if( n == 255 ) {
622             if( buflen < 4 )
623                 break;
624             n = (((size_t)buffer[0] << 24)
625                  | (buffer[1] << 16)
626                  | (buffer[2] << 8)
627                  | buffer[3]);
628             buffer += 4;
629             buflen -= 4;
630         }
631         else if( n >= 192 ) {
632             if( buflen < 2 )
633                 break;
634             n = (( n - 192 ) << 8) + *buffer + 192;
635             buffer++;
636             buflen--;
637         }
638         if( buflen < n )
639             break;
640
641         type = *buffer & 0x7f;
642         if( type == reqtype ) {
643             buffer++;
644             buflen--;
645             n--;
646             if( n > buflen )
647                 break;
648             buffer += n; /* point to next subpkt */
649             buflen -= n;
650             memmove (bufstart, buffer, buflen); /* shift */
651             unused +=  buffer - bufstart;
652             buffer = bufstart;
653         }
654         else {
655             buffer += n; buflen -=n;
656         }
657     }
658
659     if (!okay)
660         log_error ("delete_subpkt: buffer shorter than subpacket\n");
661     assert (unused <= area->len);
662     area->len -= unused;
663     return !!unused;
664 }
665
666
667 /****************
668  * Create or update a signature subpacket for SIG of TYPE.  This
669  * functions knows where to put the data (hashed or unhashed).  The
670  * function may move data from the unhashed part to the hashed one.
671  * Note: All pointers into sig->[un]hashed (e.g. returned by
672  * parse_sig_subpkt) are not valid after a call to this function.  The
673  * data to put into the subpaket should be in a buffer with a length
674  * of buflen.
675  */
676 void
677 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
678                   const byte *buffer, size_t buflen )
679 {
680     byte *p;
681     int critical, hashed;
682     subpktarea_t *oldarea, *newarea;
683     size_t nlen, n, n0;
684
685     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
686     type &= ~SIGSUBPKT_FLAG_CRITICAL;
687
688     /* Sanity check buffer sizes */
689     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
690       BUG();
691
692     switch(type)
693       {
694       case SIGSUBPKT_NOTATION:
695       case SIGSUBPKT_POLICY:
696       case SIGSUBPKT_REV_KEY:
697       case SIGSUBPKT_SIGNATURE:
698         /* we do allow multiple subpackets */
699         break;
700
701       default:
702         /* we don't allow multiple subpackets */
703         delete_sig_subpkt(sig->hashed,type);
704         delete_sig_subpkt(sig->unhashed,type);
705         break;
706       }
707
708     /* Any special magic that needs to be done for this type so the
709        packet doesn't need to be reparsed? */
710     switch(type)
711       {
712       case SIGSUBPKT_NOTATION:
713         sig->flags.notation=1;
714         break;
715
716       case SIGSUBPKT_POLICY:
717         sig->flags.policy_url=1;
718         break;
719
720       case SIGSUBPKT_PREF_KS:
721         sig->flags.pref_ks=1;
722         break;
723
724       case SIGSUBPKT_EXPORTABLE:
725         if(buffer[0])
726           sig->flags.exportable=1;
727         else
728           sig->flags.exportable=0;
729         break;
730
731       case SIGSUBPKT_REVOCABLE:
732         if(buffer[0])
733           sig->flags.revocable=1;
734         else
735           sig->flags.revocable=0;
736         break;
737
738       case SIGSUBPKT_TRUST:
739         sig->trust_depth=buffer[0];
740         sig->trust_value=buffer[1];
741         break;
742
743       case SIGSUBPKT_REGEXP:
744         sig->trust_regexp=buffer;
745         break;
746
747         /* This should never happen since we don't currently allow
748            creating such a subpacket, but just in case... */
749       case SIGSUBPKT_SIG_EXPIRE:
750         if(buffer_to_u32(buffer)+sig->timestamp<=make_timestamp())
751           sig->flags.expired=1;
752         else
753           sig->flags.expired=0;
754         break;
755
756       default:
757         break;
758       }
759
760     if( (buflen+1) >= 8384 )
761         nlen = 5; /* write 5 byte length header */
762     else if( (buflen+1) >= 192 )
763         nlen = 2; /* write 2 byte length header */
764     else
765         nlen = 1; /* just a 1 byte length header */
766
767     switch( type )
768       {
769         /* The issuer being unhashed is a historical oddity.  It
770            should work equally as well hashed.  Of course, if even an
771            unhashed issuer is tampered with, it makes it awfully hard
772            to verify the sig... */
773       case SIGSUBPKT_ISSUER:
774       case SIGSUBPKT_SIGNATURE:
775         hashed = 0;
776         break;
777       default:
778         hashed = 1;
779         break;
780       }
781
782     if( critical )
783         type |= SIGSUBPKT_FLAG_CRITICAL;
784
785     oldarea = hashed? sig->hashed : sig->unhashed;
786
787     /* Calculate new size of the area and allocate */
788     n0 = oldarea? oldarea->len : 0;
789     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
790     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
791         newarea = oldarea;
792         /*log_debug ("updating area for type %d\n", type );*/
793     }
794     else if (oldarea) {
795         newarea = xrealloc (oldarea, sizeof (*newarea) + n - 1);
796         newarea->size = n;
797         /*log_debug ("reallocating area for type %d\n", type );*/
798     }
799     else {
800         newarea = xmalloc (sizeof (*newarea) + n - 1);
801         newarea->size = n;
802         /*log_debug ("allocating area for type %d\n", type );*/
803     }
804     newarea->len = n;
805
806     p = newarea->data + n0;
807     if (nlen == 5) {
808         *p++ = 255;
809         *p++ = (buflen+1) >> 24;
810         *p++ = (buflen+1) >> 16;
811         *p++ = (buflen+1) >>  8;
812         *p++ = (buflen+1);
813         *p++ = type;
814         memcpy (p, buffer, buflen);
815     }
816     else if (nlen == 2) {
817         *p++ = (buflen+1-192) / 256 + 192;
818         *p++ = (buflen+1-192) % 256;
819         *p++ = type;
820         memcpy (p, buffer, buflen);
821     }
822     else {
823         *p++ = buflen+1;
824         *p++ = type;
825         memcpy (p, buffer, buflen);
826     }
827
828     if (hashed)
829         sig->hashed = newarea;
830     else
831         sig->unhashed = newarea;
832 }
833
834 /****************
835  * Put all the required stuff from SIG into subpackets of sig.
836  * Hmmm, should we delete those subpackets which are in a wrong area?
837  */
838 void
839 build_sig_subpkt_from_sig( PKT_signature *sig )
840 {
841     u32  u;
842     byte buf[8];
843
844     u = sig->keyid[0];
845     buf[0] = (u >> 24) & 0xff;
846     buf[1] = (u >> 16) & 0xff;
847     buf[2] = (u >>  8) & 0xff;
848     buf[3] = u & 0xff;
849     u = sig->keyid[1];
850     buf[4] = (u >> 24) & 0xff;
851     buf[5] = (u >> 16) & 0xff;
852     buf[6] = (u >>  8) & 0xff;
853     buf[7] = u & 0xff;
854     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
855
856     u = sig->timestamp;
857     buf[0] = (u >> 24) & 0xff;
858     buf[1] = (u >> 16) & 0xff;
859     buf[2] = (u >>  8) & 0xff;
860     buf[3] = u & 0xff;
861     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
862
863     if(sig->expiredate)
864       {
865         if(sig->expiredate>sig->timestamp)
866           u=sig->expiredate-sig->timestamp;
867         else
868           u=1; /* A 1-second expiration time is the shortest one
869                   OpenPGP has */
870
871         buf[0] = (u >> 24) & 0xff;
872         buf[1] = (u >> 16) & 0xff;
873         buf[2] = (u >>  8) & 0xff;
874         buf[3] = u & 0xff;
875
876         /* Mark this CRITICAL, so if any implementation doesn't
877            understand sigs that can expire, it'll just disregard this
878            sig altogether. */
879
880         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
881                           buf, 4 );
882       }
883 }
884
885 void
886 build_attribute_subpkt(PKT_user_id *uid,byte type,
887                        const void *buf,u32 buflen,
888                        const void *header,u32 headerlen)
889 {
890   byte *attrib;
891   int idx;
892
893   if(1+headerlen+buflen>8383)
894     idx=5;
895   else if(1+headerlen+buflen>191)
896     idx=2;
897   else
898     idx=1;
899
900   /* realloc uid->attrib_data to the right size */
901
902   uid->attrib_data=xrealloc(uid->attrib_data,
903                              uid->attrib_len+idx+1+headerlen+buflen);
904
905   attrib=&uid->attrib_data[uid->attrib_len];
906
907   if(idx==5)
908     {
909       attrib[0]=255;
910       attrib[1]=(1+headerlen+buflen) >> 24;
911       attrib[2]=(1+headerlen+buflen) >> 16;
912       attrib[3]=(1+headerlen+buflen) >> 8;
913       attrib[4]=1+headerlen+buflen;
914     }
915   else if(idx==2)
916     {
917       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
918       attrib[1]=(1+headerlen+buflen-192) % 256;
919     }
920   else
921     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
922
923   attrib[idx++]=type;
924
925   /* Tack on our data at the end */
926
927   if(headerlen>0)
928     memcpy(&attrib[idx],header,headerlen);
929   memcpy(&attrib[idx+headerlen],buf,buflen);
930   uid->attrib_len+=idx+headerlen+buflen;
931 }
932
933 struct notation *
934 string_to_notation(const char *string,int is_utf8)
935 {
936   const char *s;
937   int saw_at=0;
938   struct notation *notation;
939
940   notation=xmalloc_clear(sizeof(*notation));
941
942   if(*string=='-')
943     {
944       notation->flags.ignore=1;
945       string++;
946     }
947
948   if(*string=='!')
949     {
950       notation->flags.critical=1;
951       string++;
952     }
953
954   /* If and when the IETF assigns some official name tags, we'll have
955      to add them here. */
956
957   for( s=string ; *s != '='; s++ )
958     {
959       if( *s=='@')
960         saw_at++;
961
962       /* -notationname is legal without an = sign */
963       if(!*s && notation->flags.ignore)
964         break;
965
966       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
967         {
968           log_error(_("a notation name must have only printable characters"
969                       " or spaces, and end with an '='\n") );
970           goto fail;
971         }
972     }
973
974   notation->name=xmalloc((s-string)+1);
975   strncpy(notation->name,string,s-string);
976   notation->name[s-string]='\0';
977
978   if(!saw_at && !opt.expert)
979     {
980       log_error(_("a user notation name must contain the '@' character\n"));
981       goto fail;
982     }
983
984   if (saw_at > 1)
985     {
986       log_error(_("a notation name must not contain more than"
987                   " one '@' character\n"));
988       goto fail;
989     }
990
991   if(*s)
992     {
993       const char *i=s+1;
994       int highbit=0;
995
996       /* we only support printable text - therefore we enforce the use
997          of only printable characters (an empty value is valid) */
998       for(s++; *s ; s++ )
999         {
1000           if ( !isascii (*s) )
1001             highbit=1;
1002           else if (iscntrl(*s))
1003             {
1004               log_error(_("a notation value must not use any"
1005                           " control characters\n"));
1006               goto fail;
1007             }
1008         }
1009
1010       if(!highbit || is_utf8)
1011         notation->value=xstrdup(i);
1012       else
1013         notation->value=native_to_utf8(i);
1014     }
1015
1016   return notation;
1017
1018  fail:
1019   free_notation(notation);
1020   return NULL;
1021 }
1022
1023 struct notation *
1024 sig_to_notation(PKT_signature *sig)
1025 {
1026   const byte *p;
1027   size_t len;
1028   int seq=0,crit;
1029   struct notation *list=NULL;
1030
1031   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
1032     {
1033       int n1,n2;
1034       struct notation *n=NULL;
1035
1036       if(len<8)
1037         {
1038           log_info(_("WARNING: invalid notation data found\n"));
1039           continue;
1040         }
1041
1042       n1=(p[4]<<8)|p[5];
1043       n2=(p[6]<<8)|p[7];
1044
1045       if(8+n1+n2!=len)
1046         {
1047           log_info(_("WARNING: invalid notation data found\n"));
1048           continue;
1049         }
1050
1051       n=xmalloc_clear(sizeof(*n));
1052       n->name=xmalloc(n1+1);
1053
1054       memcpy(n->name,&p[8],n1);
1055       n->name[n1]='\0';
1056
1057       if(p[0]&0x80)
1058         {
1059           n->value=xmalloc(n2+1);
1060           memcpy(n->value,&p[8+n1],n2);
1061           n->value[n2]='\0';
1062         }
1063       else
1064         {
1065           n->bdat=xmalloc(n2);
1066           n->blen=n2;
1067           memcpy(n->bdat,&p[8+n1],n2);
1068
1069           n->value=xmalloc(2+strlen(_("not human readable"))+2+1);
1070           strcpy(n->value,"[ ");
1071           strcat(n->value,_("not human readable"));
1072           strcat(n->value," ]");
1073         }
1074
1075       n->flags.critical=crit;
1076
1077       n->next=list;
1078       list=n;
1079     }
1080
1081   return list;
1082 }
1083
1084 void
1085 free_notation(struct notation *notation)
1086 {
1087   while(notation)
1088     {
1089       struct notation *n=notation;
1090
1091       xfree(n->name);
1092       xfree(n->value);
1093       xfree(n->altvalue);
1094       xfree(n->bdat);
1095       notation=n->next;
1096       xfree(n);
1097     }
1098 }
1099
1100 static int
1101 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1102 {
1103   int rc = 0;
1104   int n, i;
1105   IOBUF a = iobuf_temp();
1106
1107   if ( !sig->version )
1108     iobuf_put( a, 3 );
1109   else
1110     iobuf_put( a, sig->version );
1111   if ( sig->version < 4 )
1112     iobuf_put (a, 5 ); /* Constant */
1113   iobuf_put (a, sig->sig_class );
1114   if ( sig->version < 4 )
1115     {
1116       write_32(a, sig->timestamp );
1117       write_32(a, sig->keyid[0] );
1118       write_32(a, sig->keyid[1] );
1119     }
1120   iobuf_put(a, sig->pubkey_algo );
1121   iobuf_put(a, sig->digest_algo );
1122   if ( sig->version >= 4 )
1123     {
1124       size_t nn;
1125       /* Timestamp and keyid must have been packed into the subpackets
1126          prior to the call of this function, because these subpackets
1127          are hashed. */
1128       nn = sig->hashed? sig->hashed->len : 0;
1129       write_16(a, nn);
1130       if (nn)
1131         iobuf_write( a, sig->hashed->data, nn );
1132       nn = sig->unhashed? sig->unhashed->len : 0;
1133       write_16(a, nn);
1134       if (nn)
1135         iobuf_write( a, sig->unhashed->data, nn );
1136     }
1137   iobuf_put(a, sig->digest_start[0] );
1138   iobuf_put(a, sig->digest_start[1] );
1139   n = pubkey_get_nsig( sig->pubkey_algo );
1140   if ( !n )
1141     write_fake_data( a, sig->data[0] );
1142   for (i=0; i < n && !rc ; i++ )
1143     rc = gpg_mpi_write (a, sig->data[i] );
1144
1145   if (!rc)
1146     {
1147       if ( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1148         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1149       else
1150         write_header(out, ctb, iobuf_get_temp_length(a) );
1151       rc = iobuf_write_temp( out, a );
1152     }
1153
1154   iobuf_close(a);
1155   return rc;
1156 }
1157
1158
1159 static int
1160 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1161 {
1162     int rc = 0;
1163     IOBUF a = iobuf_temp();
1164
1165     iobuf_put (a, 3);  /* Version.  */
1166     iobuf_put(a, ops->sig_class );
1167     iobuf_put(a, ops->digest_algo );
1168     iobuf_put(a, ops->pubkey_algo );
1169     write_32(a, ops->keyid[0] );
1170     write_32(a, ops->keyid[1] );
1171     iobuf_put(a, ops->last );
1172
1173     write_header(out, ctb, iobuf_get_temp_length(a) );
1174     rc = iobuf_write_temp( out, a );
1175
1176     iobuf_close(a);
1177     return rc;
1178 }
1179
1180
1181 static int
1182 write_16(IOBUF out, u16 a)
1183 {
1184     iobuf_put(out, a>>8);
1185     if( iobuf_put(out,a) )
1186         return -1;
1187     return 0;
1188 }
1189
1190 static int
1191 write_32(IOBUF out, u32 a)
1192 {
1193     iobuf_put(out, a>> 24);
1194     iobuf_put(out, a>> 16);
1195     iobuf_put(out, a>> 8);
1196     return iobuf_put(out, a);
1197 }
1198
1199
1200 /****************
1201  * calculate the length of a header
1202  */
1203 static int
1204 calc_header_length( u32 len, int new_ctb )
1205 {
1206     if( !len )
1207         return 1; /* only the ctb */
1208
1209     if( new_ctb ) {
1210         if( len < 192 )
1211             return 2;
1212         if( len < 8384 )
1213             return 3;
1214         else
1215             return 6;
1216     }
1217     if( len < 256 )
1218         return 2;
1219     if( len < 65536 )
1220         return 3;
1221
1222     return 5;
1223 }
1224
1225 /****************
1226  * Write the CTB and the packet length
1227  */
1228 static int
1229 write_header( IOBUF out, int ctb, u32 len )
1230 {
1231     return write_header2( out, ctb, len, 0 );
1232 }
1233
1234
1235 static int
1236 write_sign_packet_header (IOBUF out, int ctb, u32 len)
1237 {
1238   (void)ctb;
1239
1240   /* Work around a bug in the pgp read function for signature packets,
1241      which are not correctly coded and silently assume at some point 2
1242      byte length headers.*/
1243   iobuf_put (out, 0x89 );
1244   iobuf_put (out, len >> 8 );
1245   return iobuf_put (out, len) == -1 ? -1:0;
1246 }
1247
1248 /****************
1249  * If HDRLEN is > 0, try to build a header of this length.  We need
1250  * this so that we can hash packets without reading them again.  If
1251  * len is 0, write a partial or indeterminate length header, unless
1252  * hdrlen is specified in which case write an actual zero length
1253  * (using the specified hdrlen).
1254  */
1255 static int
1256 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1257 {
1258   if( ctb & 0x40 )
1259     return write_new_header( out, ctb, len, hdrlen );
1260
1261   if( hdrlen )
1262     {
1263       if( hdrlen == 2 && len < 256 )
1264         ;
1265       else if( hdrlen == 3 && len < 65536 )
1266         ctb |= 1;
1267       else
1268         ctb |= 2;
1269     }
1270   else
1271     {
1272       if( !len )
1273         ctb |= 3;
1274       else if( len < 256 )
1275         ;
1276       else if( len < 65536 )
1277         ctb |= 1;
1278       else
1279         ctb |= 2;
1280     }
1281
1282   if( iobuf_put(out, ctb ) )
1283     return -1;
1284
1285   if( len || hdrlen )
1286     {
1287       if( ctb & 2 )
1288         {
1289           if(iobuf_put(out, len >> 24 ))
1290             return -1;
1291           if(iobuf_put(out, len >> 16 ))
1292             return -1;
1293         }
1294
1295       if( ctb & 3 )
1296         if(iobuf_put(out, len >> 8 ))
1297           return -1;
1298
1299       if( iobuf_put(out, len ) )
1300         return -1;
1301     }
1302
1303   return 0;
1304 }
1305
1306
1307 static int
1308 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1309 {
1310     if( hdrlen )
1311         log_bug("can't cope with hdrlen yet\n");
1312
1313     if( iobuf_put(out, ctb ) )
1314         return -1;
1315     if( !len ) {
1316         iobuf_set_partial_block_mode(out, 512 );
1317     }
1318     else {
1319         if( len < 192 ) {
1320             if( iobuf_put(out, len ) )
1321                 return -1;
1322         }
1323         else if( len < 8384 ) {
1324             len -= 192;
1325             if( iobuf_put( out, (len / 256) + 192) )
1326                 return -1;
1327             if( iobuf_put( out, (len % 256) )  )
1328                 return -1;
1329         }
1330         else {
1331             if( iobuf_put( out, 0xff ) )
1332                 return -1;
1333             if( iobuf_put( out, (len >> 24)&0xff ) )
1334                 return -1;
1335             if( iobuf_put( out, (len >> 16)&0xff ) )
1336                 return -1;
1337             if( iobuf_put( out, (len >> 8)&0xff )  )
1338                 return -1;
1339             if( iobuf_put( out, len & 0xff ) )
1340                 return -1;
1341         }
1342     }
1343     return 0;
1344 }