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