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