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