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