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