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