Use inline functions to convert buffer data to scalars.
[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 int 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)
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 = iobuf_write (out, p, (nbits+7)/8);
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           iobuf_write (a, p, (ndatabits+7)/8 );
397         }
398       else
399         {
400           /* Non-protected key. */
401           for ( ; i < nskey; i++ )
402             if ( (err = gpg_mpi_write (a, pk->pkey[i])))
403               goto leave;
404           write_16 (a, ski->csum );
405         }
406     }
407
408  leave:
409   if (!err)
410     {
411       /* Build the header of the packet - which we must do after
412          writing all the other stuff, so that we know the length of
413          the packet */
414       write_header2 (out, ctb, iobuf_get_temp_length(a), pk->hdrbytes);
415       /* And finally write it out to the real stream. */
416       err = iobuf_write_temp (out, a);
417     }
418
419   iobuf_close (a); /* Close the temporary buffer */
420   return err;
421 }
422
423 static int
424 do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
425 {
426     int rc = 0;
427     IOBUF a = iobuf_temp();
428
429     assert( enc->version == 4 );
430     switch( enc->s2k.mode ) {
431       case 0: case 1: case 3: break;
432       default: log_bug("do_symkey_enc: s2k=%d\n", enc->s2k.mode );
433     }
434     iobuf_put( a, enc->version );
435     iobuf_put( a, enc->cipher_algo );
436     iobuf_put( a, enc->s2k.mode );
437     iobuf_put( a, enc->s2k.hash_algo );
438     if( enc->s2k.mode == 1 || enc->s2k.mode == 3 ) {
439         iobuf_write(a, enc->s2k.salt, 8 );
440         if( enc->s2k.mode == 3 )
441             iobuf_put(a, enc->s2k.count);
442     }
443     if( enc->seskeylen )
444         iobuf_write(a, enc->seskey, enc->seskeylen );
445
446     write_header(out, ctb, iobuf_get_temp_length(a) );
447     rc = iobuf_write_temp( out, a );
448
449     iobuf_close(a);
450     return rc;
451 }
452
453
454 static int
455 do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
456 {
457   int rc = 0;
458   int n, i;
459   IOBUF a = iobuf_temp();
460
461   iobuf_put (a, 3); /* Version.  */
462
463   if ( enc->throw_keyid )
464     {
465       write_32(a, 0 );  /* Don't tell Eve who can decrypt the message.  */
466       write_32(a, 0 );
467     }
468   else
469     {
470       write_32(a, enc->keyid[0] );
471       write_32(a, enc->keyid[1] );
472     }
473   iobuf_put(a,enc->pubkey_algo );
474   n = pubkey_get_nenc( enc->pubkey_algo );
475   if ( !n )
476     write_fake_data( a, enc->data[0] );
477
478   for (i=0; i < n && !rc ; i++ )
479     {
480       if (enc->pubkey_algo == PUBKEY_ALGO_ECDH && i == 1)
481         rc = gpg_mpi_write_nohdr (a, enc->data[i]);
482       else
483         rc = gpg_mpi_write (a, enc->data[i]);
484     }
485
486   if (!rc)
487     {
488       write_header (out, ctb, iobuf_get_temp_length(a) );
489       rc = iobuf_write_temp (out, a);
490     }
491   iobuf_close(a);
492   return rc;
493 }
494
495
496 static u32
497 calc_plaintext( PKT_plaintext *pt )
498 {
499   /* Truncate namelen to the maximum 255 characters.  Note this means
500      that a function that calls build_packet with an illegal literal
501      packet will get it back legalized. */
502
503   if(pt->namelen>255)
504     pt->namelen=255;
505
506   return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
507 }
508
509 static int
510 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
511 {
512     int i, rc = 0;
513     u32 n;
514     byte buf[1000]; /* this buffer has the plaintext! */
515     int nbytes;
516
517     write_header(out, ctb, calc_plaintext( pt ) );
518     iobuf_put(out, pt->mode );
519     iobuf_put(out, pt->namelen );
520     for(i=0; i < pt->namelen; i++ )
521         iobuf_put(out, pt->name[i] );
522     rc = write_32(out, pt->timestamp );
523     if (rc)
524       return rc;
525
526     n = 0;
527     while( (nbytes=iobuf_read(pt->buf, buf, 1000)) != -1 ) {
528       rc = iobuf_write (out, buf, nbytes);
529       if (rc)
530         break;
531       n += nbytes;
532     }
533     wipememory(buf,1000); /* burn the buffer */
534     if( (ctb&0x40) && !pt->len )
535       iobuf_set_partial_block_mode(out, 0 ); /* turn off partial */
536     if( pt->len && n != pt->len )
537       log_error("do_plaintext(): wrote %lu bytes but expected %lu bytes\n",
538                 (ulong)n, (ulong)pt->len );
539
540     return rc;
541 }
542
543
544
545 static int
546 do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
547 {
548     int rc = 0;
549     u32 n;
550
551     n = ed->len ? (ed->len + ed->extralen) : 0;
552     write_header(out, ctb, n );
553
554     /* This is all. The caller has to write the real data */
555
556     return rc;
557 }
558
559 static int
560 do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
561 {
562     int rc = 0;
563     u32 n;
564
565     assert( ed->mdc_method );
566
567     /* Take version number and the following MDC packet in account. */
568     n = ed->len ? (ed->len + ed->extralen + 1 + 22) : 0;
569     write_header(out, ctb, n );
570     iobuf_put(out, 1 );  /* version */
571
572     /* This is all. The caller has to write the real data */
573
574     return rc;
575 }
576
577
578 static int
579 do_compressed( IOBUF out, int ctb, PKT_compressed *cd )
580 {
581     int rc = 0;
582
583     /* We must use the old convention and don't use blockmode for the
584        sake of PGP 2 compatibility.  However if the new_ctb flag was
585        set, CTB is already formatted as new style and write_header2
586        does create a partial length encoding using new the new
587        style. */
588     write_header2(out, ctb, 0, 0);
589     iobuf_put(out, cd->algorithm );
590
591     /* This is all. The caller has to write the real data */
592
593     return rc;
594 }
595
596
597 /****************
598  * Delete all subpackets of type REQTYPE and return a bool whether a packet
599  * was deleted.
600  */
601 int
602 delete_sig_subpkt (subpktarea_t *area, sigsubpkttype_t reqtype )
603 {
604     int buflen;
605     sigsubpkttype_t type;
606     byte *buffer, *bufstart;
607     size_t n;
608     size_t unused = 0;
609     int okay = 0;
610
611     if( !area )
612         return 0;
613     buflen = area->len;
614     buffer = area->data;
615     for(;;) {
616         if( !buflen ) {
617             okay = 1;
618             break;
619         }
620         bufstart = buffer;
621         n = *buffer++; buflen--;
622         if( n == 255 ) {
623             if( buflen < 4 )
624                 break;
625             n = buf32_to_size_t (buffer);
626             buffer += 4;
627             buflen -= 4;
628         }
629         else if( n >= 192 ) {
630             if( buflen < 2 )
631                 break;
632             n = (( n - 192 ) << 8) + *buffer + 192;
633             buffer++;
634             buflen--;
635         }
636         if( buflen < n )
637             break;
638
639         type = *buffer & 0x7f;
640         if( type == reqtype ) {
641             buffer++;
642             buflen--;
643             n--;
644             if( n > buflen )
645                 break;
646             buffer += n; /* point to next subpkt */
647             buflen -= n;
648             memmove (bufstart, buffer, buflen); /* shift */
649             unused +=  buffer - bufstart;
650             buffer = bufstart;
651         }
652         else {
653             buffer += n; buflen -=n;
654         }
655     }
656
657     if (!okay)
658         log_error ("delete_subpkt: buffer shorter than subpacket\n");
659     assert (unused <= area->len);
660     area->len -= unused;
661     return !!unused;
662 }
663
664
665 /****************
666  * Create or update a signature subpacket for SIG of TYPE.  This
667  * functions knows where to put the data (hashed or unhashed).  The
668  * function may move data from the unhashed part to the hashed one.
669  * Note: All pointers into sig->[un]hashed (e.g. returned by
670  * parse_sig_subpkt) are not valid after a call to this function.  The
671  * data to put into the subpaket should be in a buffer with a length
672  * of buflen.
673  */
674 void
675 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
676                   const byte *buffer, size_t buflen )
677 {
678     byte *p;
679     int critical, hashed;
680     subpktarea_t *oldarea, *newarea;
681     size_t nlen, n, n0;
682
683     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
684     type &= ~SIGSUBPKT_FLAG_CRITICAL;
685
686     /* Sanity check buffer sizes */
687     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
688       BUG();
689
690     switch(type)
691       {
692       case SIGSUBPKT_NOTATION:
693       case SIGSUBPKT_POLICY:
694       case SIGSUBPKT_REV_KEY:
695       case SIGSUBPKT_SIGNATURE:
696         /* we do allow multiple subpackets */
697         break;
698
699       default:
700         /* we don't allow multiple subpackets */
701         delete_sig_subpkt(sig->hashed,type);
702         delete_sig_subpkt(sig->unhashed,type);
703         break;
704       }
705
706     /* Any special magic that needs to be done for this type so the
707        packet doesn't need to be reparsed? */
708     switch(type)
709       {
710       case SIGSUBPKT_NOTATION:
711         sig->flags.notation=1;
712         break;
713
714       case SIGSUBPKT_POLICY:
715         sig->flags.policy_url=1;
716         break;
717
718       case SIGSUBPKT_PREF_KS:
719         sig->flags.pref_ks=1;
720         break;
721
722       case SIGSUBPKT_EXPORTABLE:
723         if(buffer[0])
724           sig->flags.exportable=1;
725         else
726           sig->flags.exportable=0;
727         break;
728
729       case SIGSUBPKT_REVOCABLE:
730         if(buffer[0])
731           sig->flags.revocable=1;
732         else
733           sig->flags.revocable=0;
734         break;
735
736       case SIGSUBPKT_TRUST:
737         sig->trust_depth=buffer[0];
738         sig->trust_value=buffer[1];
739         break;
740
741       case SIGSUBPKT_REGEXP:
742         sig->trust_regexp=buffer;
743         break;
744
745         /* This should never happen since we don't currently allow
746            creating such a subpacket, but just in case... */
747       case SIGSUBPKT_SIG_EXPIRE:
748         if(buf32_to_u32(buffer)+sig->timestamp<=make_timestamp())
749           sig->flags.expired=1;
750         else
751           sig->flags.expired=0;
752         break;
753
754       default:
755         break;
756       }
757
758     if( (buflen+1) >= 8384 )
759         nlen = 5; /* write 5 byte length header */
760     else if( (buflen+1) >= 192 )
761         nlen = 2; /* write 2 byte length header */
762     else
763         nlen = 1; /* just a 1 byte length header */
764
765     switch( type )
766       {
767         /* The issuer being unhashed is a historical oddity.  It
768            should work equally as well hashed.  Of course, if even an
769            unhashed issuer is tampered with, it makes it awfully hard
770            to verify the sig... */
771       case SIGSUBPKT_ISSUER:
772       case SIGSUBPKT_SIGNATURE:
773         hashed = 0;
774         break;
775       default:
776         hashed = 1;
777         break;
778       }
779
780     if( critical )
781         type |= SIGSUBPKT_FLAG_CRITICAL;
782
783     oldarea = hashed? sig->hashed : sig->unhashed;
784
785     /* Calculate new size of the area and allocate */
786     n0 = oldarea? oldarea->len : 0;
787     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
788     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
789         newarea = oldarea;
790         /*log_debug ("updating area for type %d\n", type );*/
791     }
792     else if (oldarea) {
793         newarea = xrealloc (oldarea, sizeof (*newarea) + n - 1);
794         newarea->size = n;
795         /*log_debug ("reallocating area for type %d\n", type );*/
796     }
797     else {
798         newarea = xmalloc (sizeof (*newarea) + n - 1);
799         newarea->size = n;
800         /*log_debug ("allocating area for type %d\n", type );*/
801     }
802     newarea->len = n;
803
804     p = newarea->data + n0;
805     if (nlen == 5) {
806         *p++ = 255;
807         *p++ = (buflen+1) >> 24;
808         *p++ = (buflen+1) >> 16;
809         *p++ = (buflen+1) >>  8;
810         *p++ = (buflen+1);
811         *p++ = type;
812         memcpy (p, buffer, buflen);
813     }
814     else if (nlen == 2) {
815         *p++ = (buflen+1-192) / 256 + 192;
816         *p++ = (buflen+1-192) % 256;
817         *p++ = type;
818         memcpy (p, buffer, buflen);
819     }
820     else {
821         *p++ = buflen+1;
822         *p++ = type;
823         memcpy (p, buffer, buflen);
824     }
825
826     if (hashed)
827         sig->hashed = newarea;
828     else
829         sig->unhashed = newarea;
830 }
831
832 /****************
833  * Put all the required stuff from SIG into subpackets of sig.
834  * Hmmm, should we delete those subpackets which are in a wrong area?
835  */
836 void
837 build_sig_subpkt_from_sig( PKT_signature *sig )
838 {
839     u32  u;
840     byte buf[8];
841
842     u = sig->keyid[0];
843     buf[0] = (u >> 24) & 0xff;
844     buf[1] = (u >> 16) & 0xff;
845     buf[2] = (u >>  8) & 0xff;
846     buf[3] = u & 0xff;
847     u = sig->keyid[1];
848     buf[4] = (u >> 24) & 0xff;
849     buf[5] = (u >> 16) & 0xff;
850     buf[6] = (u >>  8) & 0xff;
851     buf[7] = u & 0xff;
852     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
853
854     u = sig->timestamp;
855     buf[0] = (u >> 24) & 0xff;
856     buf[1] = (u >> 16) & 0xff;
857     buf[2] = (u >>  8) & 0xff;
858     buf[3] = u & 0xff;
859     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
860
861     if(sig->expiredate)
862       {
863         if(sig->expiredate>sig->timestamp)
864           u=sig->expiredate-sig->timestamp;
865         else
866           u=1; /* A 1-second expiration time is the shortest one
867                   OpenPGP has */
868
869         buf[0] = (u >> 24) & 0xff;
870         buf[1] = (u >> 16) & 0xff;
871         buf[2] = (u >>  8) & 0xff;
872         buf[3] = u & 0xff;
873
874         /* Mark this CRITICAL, so if any implementation doesn't
875            understand sigs that can expire, it'll just disregard this
876            sig altogether. */
877
878         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
879                           buf, 4 );
880       }
881 }
882
883 void
884 build_attribute_subpkt(PKT_user_id *uid,byte type,
885                        const void *buf,u32 buflen,
886                        const void *header,u32 headerlen)
887 {
888   byte *attrib;
889   int idx;
890
891   if(1+headerlen+buflen>8383)
892     idx=5;
893   else if(1+headerlen+buflen>191)
894     idx=2;
895   else
896     idx=1;
897
898   /* realloc uid->attrib_data to the right size */
899
900   uid->attrib_data=xrealloc(uid->attrib_data,
901                              uid->attrib_len+idx+1+headerlen+buflen);
902
903   attrib=&uid->attrib_data[uid->attrib_len];
904
905   if(idx==5)
906     {
907       attrib[0]=255;
908       attrib[1]=(1+headerlen+buflen) >> 24;
909       attrib[2]=(1+headerlen+buflen) >> 16;
910       attrib[3]=(1+headerlen+buflen) >> 8;
911       attrib[4]=1+headerlen+buflen;
912     }
913   else if(idx==2)
914     {
915       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
916       attrib[1]=(1+headerlen+buflen-192) % 256;
917     }
918   else
919     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
920
921   attrib[idx++]=type;
922
923   /* Tack on our data at the end */
924
925   if(headerlen>0)
926     memcpy(&attrib[idx],header,headerlen);
927   memcpy(&attrib[idx+headerlen],buf,buflen);
928   uid->attrib_len+=idx+headerlen+buflen;
929 }
930
931 struct notation *
932 string_to_notation(const char *string,int is_utf8)
933 {
934   const char *s;
935   int saw_at=0;
936   struct notation *notation;
937
938   notation=xmalloc_clear(sizeof(*notation));
939
940   if(*string=='-')
941     {
942       notation->flags.ignore=1;
943       string++;
944     }
945
946   if(*string=='!')
947     {
948       notation->flags.critical=1;
949       string++;
950     }
951
952   /* If and when the IETF assigns some official name tags, we'll have
953      to add them here. */
954
955   for( s=string ; *s != '='; s++ )
956     {
957       if( *s=='@')
958         saw_at++;
959
960       /* -notationname is legal without an = sign */
961       if(!*s && notation->flags.ignore)
962         break;
963
964       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
965         {
966           log_error(_("a notation name must have only printable characters"
967                       " or spaces, and end with an '='\n") );
968           goto fail;
969         }
970     }
971
972   notation->name=xmalloc((s-string)+1);
973   strncpy(notation->name,string,s-string);
974   notation->name[s-string]='\0';
975
976   if(!saw_at && !opt.expert)
977     {
978       log_error(_("a user notation name must contain the '@' character\n"));
979       goto fail;
980     }
981
982   if (saw_at > 1)
983     {
984       log_error(_("a notation name must not contain more than"
985                   " one '@' character\n"));
986       goto fail;
987     }
988
989   if(*s)
990     {
991       const char *i=s+1;
992       int highbit=0;
993
994       /* we only support printable text - therefore we enforce the use
995          of only printable characters (an empty value is valid) */
996       for(s++; *s ; s++ )
997         {
998           if ( !isascii (*s) )
999             highbit=1;
1000           else if (iscntrl(*s))
1001             {
1002               log_error(_("a notation value must not use any"
1003                           " control characters\n"));
1004               goto fail;
1005             }
1006         }
1007
1008       if(!highbit || is_utf8)
1009         notation->value=xstrdup(i);
1010       else
1011         notation->value=native_to_utf8(i);
1012     }
1013
1014   return notation;
1015
1016  fail:
1017   free_notation(notation);
1018   return NULL;
1019 }
1020
1021 struct notation *
1022 sig_to_notation(PKT_signature *sig)
1023 {
1024   const byte *p;
1025   size_t len;
1026   int seq=0,crit;
1027   struct notation *list=NULL;
1028
1029   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
1030     {
1031       int n1,n2;
1032       struct notation *n=NULL;
1033
1034       if(len<8)
1035         {
1036           log_info(_("WARNING: invalid notation data found\n"));
1037           continue;
1038         }
1039
1040       n1=(p[4]<<8)|p[5];
1041       n2=(p[6]<<8)|p[7];
1042
1043       if(8+n1+n2!=len)
1044         {
1045           log_info(_("WARNING: invalid notation data found\n"));
1046           continue;
1047         }
1048
1049       n=xmalloc_clear(sizeof(*n));
1050       n->name=xmalloc(n1+1);
1051
1052       memcpy(n->name,&p[8],n1);
1053       n->name[n1]='\0';
1054
1055       if(p[0]&0x80)
1056         {
1057           n->value=xmalloc(n2+1);
1058           memcpy(n->value,&p[8+n1],n2);
1059           n->value[n2]='\0';
1060         }
1061       else
1062         {
1063           n->bdat=xmalloc(n2);
1064           n->blen=n2;
1065           memcpy(n->bdat,&p[8+n1],n2);
1066
1067           n->value=xmalloc(2+strlen(_("not human readable"))+2+1);
1068           strcpy(n->value,"[ ");
1069           strcat(n->value,_("not human readable"));
1070           strcat(n->value," ]");
1071         }
1072
1073       n->flags.critical=crit;
1074
1075       n->next=list;
1076       list=n;
1077     }
1078
1079   return list;
1080 }
1081
1082 void
1083 free_notation(struct notation *notation)
1084 {
1085   while(notation)
1086     {
1087       struct notation *n=notation;
1088
1089       xfree(n->name);
1090       xfree(n->value);
1091       xfree(n->altvalue);
1092       xfree(n->bdat);
1093       notation=n->next;
1094       xfree(n);
1095     }
1096 }
1097
1098 static int
1099 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1100 {
1101   int rc = 0;
1102   int n, i;
1103   IOBUF a = iobuf_temp();
1104
1105   if ( !sig->version )
1106     iobuf_put( a, 3 );
1107   else
1108     iobuf_put( a, sig->version );
1109   if ( sig->version < 4 )
1110     iobuf_put (a, 5 ); /* Constant */
1111   iobuf_put (a, sig->sig_class );
1112   if ( sig->version < 4 )
1113     {
1114       write_32(a, sig->timestamp );
1115       write_32(a, sig->keyid[0] );
1116       write_32(a, sig->keyid[1] );
1117     }
1118   iobuf_put(a, sig->pubkey_algo );
1119   iobuf_put(a, sig->digest_algo );
1120   if ( sig->version >= 4 )
1121     {
1122       size_t nn;
1123       /* Timestamp and keyid must have been packed into the subpackets
1124          prior to the call of this function, because these subpackets
1125          are hashed. */
1126       nn = sig->hashed? sig->hashed->len : 0;
1127       write_16(a, nn);
1128       if (nn)
1129         iobuf_write( a, sig->hashed->data, nn );
1130       nn = sig->unhashed? sig->unhashed->len : 0;
1131       write_16(a, nn);
1132       if (nn)
1133         iobuf_write( a, sig->unhashed->data, nn );
1134     }
1135   iobuf_put(a, sig->digest_start[0] );
1136   iobuf_put(a, sig->digest_start[1] );
1137   n = pubkey_get_nsig( sig->pubkey_algo );
1138   if ( !n )
1139     write_fake_data( a, sig->data[0] );
1140   for (i=0; i < n && !rc ; i++ )
1141     rc = gpg_mpi_write (a, sig->data[i] );
1142
1143   if (!rc)
1144     {
1145       if ( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1146         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1147       else
1148         write_header(out, ctb, iobuf_get_temp_length(a) );
1149       rc = iobuf_write_temp( out, a );
1150     }
1151
1152   iobuf_close(a);
1153   return rc;
1154 }
1155
1156
1157 static int
1158 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1159 {
1160     int rc = 0;
1161     IOBUF a = iobuf_temp();
1162
1163     iobuf_put (a, 3);  /* Version.  */
1164     iobuf_put(a, ops->sig_class );
1165     iobuf_put(a, ops->digest_algo );
1166     iobuf_put(a, ops->pubkey_algo );
1167     write_32(a, ops->keyid[0] );
1168     write_32(a, ops->keyid[1] );
1169     iobuf_put(a, ops->last );
1170
1171     write_header(out, ctb, iobuf_get_temp_length(a) );
1172     rc = iobuf_write_temp( out, a );
1173
1174     iobuf_close(a);
1175     return rc;
1176 }
1177
1178
1179 static int
1180 write_16(IOBUF out, u16 a)
1181 {
1182     iobuf_put(out, a>>8);
1183     if( iobuf_put(out,a) )
1184         return -1;
1185     return 0;
1186 }
1187
1188 static int
1189 write_32(IOBUF out, u32 a)
1190 {
1191     iobuf_put(out, a>> 24);
1192     iobuf_put(out, a>> 16);
1193     iobuf_put(out, a>> 8);
1194     return iobuf_put(out, a);
1195 }
1196
1197
1198 /****************
1199  * calculate the length of a header
1200  */
1201 static int
1202 calc_header_length( u32 len, int new_ctb )
1203 {
1204     if( !len )
1205         return 1; /* only the ctb */
1206
1207     if( new_ctb ) {
1208         if( len < 192 )
1209             return 2;
1210         if( len < 8384 )
1211             return 3;
1212         else
1213             return 6;
1214     }
1215     if( len < 256 )
1216         return 2;
1217     if( len < 65536 )
1218         return 3;
1219
1220     return 5;
1221 }
1222
1223 /****************
1224  * Write the CTB and the packet length
1225  */
1226 static int
1227 write_header( IOBUF out, int ctb, u32 len )
1228 {
1229     return write_header2( out, ctb, len, 0 );
1230 }
1231
1232
1233 static int
1234 write_sign_packet_header (IOBUF out, int ctb, u32 len)
1235 {
1236   (void)ctb;
1237
1238   /* Work around a bug in the pgp read function for signature packets,
1239      which are not correctly coded and silently assume at some point 2
1240      byte length headers.*/
1241   iobuf_put (out, 0x89 );
1242   iobuf_put (out, len >> 8 );
1243   return iobuf_put (out, len) == -1 ? -1:0;
1244 }
1245
1246 /****************
1247  * If HDRLEN is > 0, try to build a header of this length.  We need
1248  * this so that we can hash packets without reading them again.  If
1249  * len is 0, write a partial or indeterminate length header, unless
1250  * hdrlen is specified in which case write an actual zero length
1251  * (using the specified hdrlen).
1252  */
1253 static int
1254 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1255 {
1256   if( ctb & 0x40 )
1257     return write_new_header( out, ctb, len, hdrlen );
1258
1259   if( hdrlen )
1260     {
1261       if( hdrlen == 2 && len < 256 )
1262         ;
1263       else if( hdrlen == 3 && len < 65536 )
1264         ctb |= 1;
1265       else
1266         ctb |= 2;
1267     }
1268   else
1269     {
1270       if( !len )
1271         ctb |= 3;
1272       else if( len < 256 )
1273         ;
1274       else if( len < 65536 )
1275         ctb |= 1;
1276       else
1277         ctb |= 2;
1278     }
1279
1280   if( iobuf_put(out, ctb ) )
1281     return -1;
1282
1283   if( len || hdrlen )
1284     {
1285       if( ctb & 2 )
1286         {
1287           if(iobuf_put(out, len >> 24 ))
1288             return -1;
1289           if(iobuf_put(out, len >> 16 ))
1290             return -1;
1291         }
1292
1293       if( ctb & 3 )
1294         if(iobuf_put(out, len >> 8 ))
1295           return -1;
1296
1297       if( iobuf_put(out, len ) )
1298         return -1;
1299     }
1300
1301   return 0;
1302 }
1303
1304
1305 static int
1306 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1307 {
1308     if( hdrlen )
1309         log_bug("can't cope with hdrlen yet\n");
1310
1311     if( iobuf_put(out, ctb ) )
1312         return -1;
1313     if( !len ) {
1314         iobuf_set_partial_block_mode(out, 512 );
1315     }
1316     else {
1317         if( len < 192 ) {
1318             if( iobuf_put(out, len ) )
1319                 return -1;
1320         }
1321         else if( len < 8384 ) {
1322             len -= 192;
1323             if( iobuf_put( out, (len / 256) + 192) )
1324                 return -1;
1325             if( iobuf_put( out, (len % 256) )  )
1326                 return -1;
1327         }
1328         else {
1329             if( iobuf_put( out, 0xff ) )
1330                 return -1;
1331             if( iobuf_put( out, (len >> 24)&0xff ) )
1332                 return -1;
1333             if( iobuf_put( out, (len >> 16)&0xff ) )
1334                 return -1;
1335             if( iobuf_put( out, (len >> 8)&0xff )  )
1336                 return -1;
1337             if( iobuf_put( out, len & 0xff ) )
1338                 return -1;
1339         }
1340     }
1341     return 0;
1342 }