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