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