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