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