* keylist.c (status_one_subpacket): New. Send the subpacket data to 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,
3  *               2004 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 );
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       {
199         write_header2(out, ctb, rem->len, 2);
200         if( iobuf_write( out, rem->data, rem->len ) )
201           return G10ERR_WRITE_FILE;
202       }
203     return 0;
204 }
205
206 static int
207 do_user_id( IOBUF out, int ctb, PKT_user_id *uid )
208 {
209     if( uid->attrib_data )
210       {
211         write_header(out, ctb, uid->attrib_len);
212         if( iobuf_write( out, uid->attrib_data, uid->attrib_len ) )
213           return G10ERR_WRITE_FILE;
214       }
215     else
216       {
217         write_header2( out, ctb, uid->len, 2 );
218         if( iobuf_write( out, uid->name, uid->len ) )
219           return G10ERR_WRITE_FILE;
220       }
221     return 0;
222 }
223
224 static int
225 do_public_key( IOBUF out, int ctb, PKT_public_key *pk )
226 {
227     int rc = 0;
228     int n, i;
229     IOBUF a = iobuf_temp();
230
231     if( !pk->version )
232         iobuf_put( a, 3 );
233     else
234         iobuf_put( a, pk->version );
235     write_32(a, pk->timestamp );
236     if( pk->version < 4 ) {
237         u16 ndays;
238         if( pk->expiredate )
239             ndays = (u16)((pk->expiredate - pk->timestamp) / 86400L);
240         else
241             ndays = 0;
242         write_16(a, ndays );
243     }
244     iobuf_put(a, pk->pubkey_algo );
245     n = pubkey_get_npkey( pk->pubkey_algo );
246     if( !n )
247         write_fake_data( a, pk->pkey[0] );
248     for(i=0; i < n; i++ )
249         mpi_write(a, pk->pkey[i] );
250
251     write_header2(out, ctb, iobuf_get_temp_length(a), pk->hdrbytes);
252     if( iobuf_write_temp( out, a ) )
253         rc = G10ERR_WRITE_FILE;
254
255     iobuf_close(a);
256     return rc;
257 }
258
259
260 static int
261 do_secret_key( IOBUF out, int ctb, PKT_secret_key *sk )
262 {
263     int rc = 0;
264     int i, nskey, npkey;
265     IOBUF a = iobuf_temp(); /* build in a self-enlarging buffer */
266
267     /* Write the version number - if none is specified, use 3 */
268     if( !sk->version )
269         iobuf_put( a, 3 );
270     else
271         iobuf_put( a, sk->version );
272     write_32(a, sk->timestamp );
273
274     /* v3  needs the expiration time */
275     if( sk->version < 4 ) {
276         u16 ndays;
277         if( sk->expiredate )
278             ndays = (u16)((sk->expiredate - sk->timestamp) / 86400L);
279         else
280             ndays = 0;
281         write_16(a, ndays);
282     }
283
284     iobuf_put(a, sk->pubkey_algo );
285
286     /* get number of secret and public parameters.  They are held in
287        one array first the public ones, then the secret ones */
288     nskey = pubkey_get_nskey( sk->pubkey_algo );
289     npkey = pubkey_get_npkey( sk->pubkey_algo );
290
291     /* If we don't have any public parameters - which is the case if
292        we don't know the algorithm used - the parameters are stored as
293        one blob in a faked (opaque) MPI */
294     if( !npkey ) {
295         write_fake_data( a, sk->skey[0] );
296         goto leave;
297     }
298     assert( npkey < nskey );
299
300     /* Writing the public parameters is easy */
301     for(i=0; i < npkey; i++ )
302         mpi_write(a, sk->skey[i] );
303
304     /* build the header for protected (encrypted) secret parameters */
305     if( sk->is_protected ) {
306         if( is_RSA(sk->pubkey_algo) && sk->version < 4
307                                     && !sk->protect.s2k.mode ) {
308             /* the simple rfc1991 (v3) way */
309             iobuf_put(a, sk->protect.algo );
310             iobuf_write(a, sk->protect.iv, sk->protect.ivlen );
311         }
312         else {
313           /* OpenPGP protection according to rfc2440 */
314             iobuf_put(a, sk->protect.sha1chk? 0xfe : 0xff );
315             iobuf_put(a, sk->protect.algo );
316             if( sk->protect.s2k.mode >= 1000 ) {
317                 /* These modes are not possible in OpenPGP, we use them
318                    to implement our extensions, 101 can be seen as a
319                    private/experimental extension (this is not
320                    specified in rfc2440 but the same scheme is used
321                    for all other algorithm identifiers) */
322                 iobuf_put(a, 101 ); 
323                 iobuf_put(a, sk->protect.s2k.hash_algo );
324                 iobuf_write(a, "GNU", 3 );
325                 iobuf_put(a, sk->protect.s2k.mode - 1000 );
326             }
327             else {
328                 iobuf_put(a, sk->protect.s2k.mode );
329                 iobuf_put(a, sk->protect.s2k.hash_algo );
330             }
331             if( sk->protect.s2k.mode == 1
332                 || sk->protect.s2k.mode == 3 )
333                 iobuf_write(a, sk->protect.s2k.salt, 8 );
334             if( sk->protect.s2k.mode == 3 )
335                 iobuf_put(a, sk->protect.s2k.count ); 
336
337             /* For out special modes 1001, 1002 we do not need an IV */
338             if( sk->protect.s2k.mode != 1001 
339               && sk->protect.s2k.mode != 1002 )
340                 iobuf_write(a, sk->protect.iv, sk->protect.ivlen );
341         }
342     }
343     else
344         iobuf_put(a, 0 );
345
346     if( sk->protect.s2k.mode == 1001 )
347         ; /* GnuPG extension - don't write a secret key at all */ 
348     else if( sk->protect.s2k.mode == 1002 )
349       {  /* GnuPG extension - divert to OpenPGP smartcard. */ 
350         iobuf_put(a, sk->protect.ivlen ); /* length of the serial
351                                              number or 0 for no serial
352                                              number. */
353         /* The serial number gets stored in the IV field. */
354         iobuf_write(a, sk->protect.iv, sk->protect.ivlen);
355       }
356     else if( sk->is_protected && sk->version >= 4 ) {
357         /* The secret key is protected - write it out as it is */
358         byte *p;
359         unsigned int ndata;
360
361         assert( mpi_is_opaque( sk->skey[npkey] ) );
362         p = mpi_get_opaque( sk->skey[npkey], &ndata );
363         iobuf_write(a, p, ndata );
364     }
365     else if( sk->is_protected ) {
366         /* The secret key is protected te old v4 way. */
367         for(   ; i < nskey; i++ ) {
368             byte *p;
369             unsigned int ndata;
370
371             assert (mpi_is_opaque (sk->skey[i]));
372             p = mpi_get_opaque (sk->skey[i], &ndata);
373             iobuf_write (a, p, ndata);
374         }
375         write_16(a, sk->csum );
376     }
377     else {
378         /* non-protected key */
379         for(   ; i < nskey; i++ )
380             mpi_write(a, sk->skey[i] );
381         write_16(a, sk->csum );
382     }
383
384   leave:
385     /* Build the header of the packet - which we must do after writing all
386        the other stuff, so that we know the length of the packet */
387     write_header2(out, ctb, iobuf_get_temp_length(a), sk->hdrbytes);
388     /* And finally write it out the real stream */
389     if( iobuf_write_temp( out, a ) )
390         rc = G10ERR_WRITE_FILE;
391
392     iobuf_close(a); /* close the remporary buffer */
393     return rc;
394 }
395
396 static int
397 do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
398 {
399     int rc = 0;
400     IOBUF a = iobuf_temp();
401
402     assert( enc->version == 4 );
403     switch( enc->s2k.mode ) {
404       case 0: case 1: case 3: break;
405       default: log_bug("do_symkey_enc: s2k=%d\n", enc->s2k.mode );
406     }
407     iobuf_put( a, enc->version );
408     iobuf_put( a, enc->cipher_algo );
409     iobuf_put( a, enc->s2k.mode );
410     iobuf_put( a, enc->s2k.hash_algo );
411     if( enc->s2k.mode == 1 || enc->s2k.mode == 3 ) {
412         iobuf_write(a, enc->s2k.salt, 8 );
413         if( enc->s2k.mode == 3 )
414             iobuf_put(a, enc->s2k.count);
415     }
416     if( enc->seskeylen )
417         iobuf_write(a, enc->seskey, enc->seskeylen );
418
419     write_header(out, ctb, iobuf_get_temp_length(a) );
420     if( iobuf_write_temp( out, a ) )
421         rc = G10ERR_WRITE_FILE;
422
423     iobuf_close(a);
424     return rc;
425 }
426
427
428 static int
429 do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
430 {
431     int rc = 0;
432     int n, i;
433     IOBUF a = iobuf_temp();
434
435     write_version( a, ctb );
436     if( enc->throw_keyid ) {
437         write_32(a, 0 );  /* don't tell Eve who can decrypt the message */
438         write_32(a, 0 );
439     }
440     else {
441         write_32(a, enc->keyid[0] );
442         write_32(a, enc->keyid[1] );
443     }
444     iobuf_put(a,enc->pubkey_algo );
445     n = pubkey_get_nenc( enc->pubkey_algo );
446     if( !n )
447         write_fake_data( a, enc->data[0] );
448     for(i=0; i < n; i++ )
449         mpi_write(a, enc->data[i] );
450
451     write_header(out, ctb, iobuf_get_temp_length(a) );
452     if( iobuf_write_temp( out, a ) )
453         rc = G10ERR_WRITE_FILE;
454
455     iobuf_close(a);
456     return rc;
457 }
458
459
460 static u32
461 calc_plaintext( PKT_plaintext *pt )
462 {
463   /* Truncate namelen to the maximum 255 characters.  Note this means
464      that a function that calls build_packet with an illegal literal
465      packet will get it back legalized. */
466
467   if(pt->namelen>255)
468     pt->namelen=255;
469
470   return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
471 }
472
473 static int
474 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
475 {
476     int i, rc = 0;
477     u32 n;
478     byte buf[1000]; /* this buffer has the plaintext! */
479     int nbytes;
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( (ctb&0x40) && !pt->len )
499       iobuf_set_partial_block_mode(out, 0 ); /* turn off partial */
500     if( pt->len && 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);
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       case SIGSUBPKT_SIGNATURE:
661       case SIGSUBPKT_PREF_KS:
662         /* we do allow multiple subpackets */
663         break;
664
665       default:
666         /* we don't allow multiple subpackets */
667         delete_sig_subpkt(sig->hashed,type);
668         delete_sig_subpkt(sig->unhashed,type);
669         break;
670       }
671
672     /* Any special magic that needs to be done for this type so the
673        packet doesn't need to be reparsed? */
674     switch(type)
675       {
676       case SIGSUBPKT_NOTATION:
677         sig->flags.notation=1;
678         break;
679
680       case SIGSUBPKT_POLICY:
681         sig->flags.policy_url=1;
682         break;
683
684       case SIGSUBPKT_PREF_KS:
685         sig->flags.pref_ks=1;
686         break;
687
688       case SIGSUBPKT_EXPORTABLE:
689         if(buffer[0])
690           sig->flags.exportable=1;
691         else
692           sig->flags.exportable=0;
693         break;
694
695       case SIGSUBPKT_REVOCABLE:
696         if(buffer[0])
697           sig->flags.revocable=1;
698         else
699           sig->flags.revocable=0;
700         break;
701
702       case SIGSUBPKT_TRUST:
703         sig->trust_depth=buffer[0];
704         sig->trust_value=buffer[1];
705         break;
706
707       case SIGSUBPKT_REGEXP:
708         sig->trust_regexp=buffer;
709         break;
710
711         /* This should never happen since we don't currently allow
712            creating such a subpacket, but just in case... */
713       case SIGSUBPKT_SIG_EXPIRE:
714         if(buffer_to_u32(buffer)+sig->timestamp<=make_timestamp())
715           sig->flags.expired=1;
716         else
717           sig->flags.expired=0;
718         break;
719
720       default:
721         break;
722       }
723
724     if( (buflen+1) >= 8384 )
725         nlen = 5; /* write 5 byte length header */
726     else if( (buflen+1) >= 192 )
727         nlen = 2; /* write 2 byte length header */
728     else
729         nlen = 1; /* just a 1 byte length header */
730
731     switch( type )
732       {
733         /* The issuer being unhashed is a historical oddity.  It
734            should work equally as well hashed.  Of course, if even an
735            unhashed issuer is tampered with, it makes it awfully hard
736            to verify the sig... */
737       case SIGSUBPKT_ISSUER:
738       case SIGSUBPKT_SIGNATURE:
739         hashed = 0;
740         break;
741       default: 
742         hashed = 1;
743         break;
744       }
745
746     if( critical )
747         type |= SIGSUBPKT_FLAG_CRITICAL;
748
749     oldarea = hashed? sig->hashed : sig->unhashed;
750
751     /* Calculate new size of the area and allocate */
752     n0 = oldarea? oldarea->len : 0;
753     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
754     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
755         newarea = oldarea;
756         /*log_debug ("updating area for type %d\n", type );*/
757     }
758     else if (oldarea) {
759         newarea = m_realloc (oldarea, sizeof (*newarea) + n - 1);
760         newarea->size = n;
761         /*log_debug ("reallocating area for type %d\n", type );*/
762     }
763     else {
764         newarea = m_alloc (sizeof (*newarea) + n - 1);
765         newarea->size = n;
766         /*log_debug ("allocating area for type %d\n", type );*/
767     }
768     newarea->len = n;
769
770     p = newarea->data + n0;
771     if (nlen == 5) {
772         *p++ = 255;
773         *p++ = (buflen+1) >> 24;
774         *p++ = (buflen+1) >> 16;
775         *p++ = (buflen+1) >>  8;
776         *p++ = (buflen+1);
777         *p++ = type;
778         memcpy (p, buffer, buflen);
779     }
780     else if (nlen == 2) {
781         *p++ = (buflen+1-192) / 256 + 192;
782         *p++ = (buflen+1-192) % 256;
783         *p++ = type;
784         memcpy (p, buffer, buflen);
785     }
786     else {
787         *p++ = buflen+1;
788         *p++ = type;
789         memcpy (p, buffer, buflen);
790     }
791
792     if (hashed) 
793         sig->hashed = newarea;
794     else
795         sig->unhashed = newarea;
796 }
797
798 /****************
799  * Put all the required stuff from SIG into subpackets of sig.
800  * Hmmm, should we delete those subpackets which are in a wrong area?
801  */
802 void
803 build_sig_subpkt_from_sig( PKT_signature *sig )
804 {
805     u32  u;
806     byte buf[8];
807
808     u = sig->keyid[0];
809     buf[0] = (u >> 24) & 0xff;
810     buf[1] = (u >> 16) & 0xff;
811     buf[2] = (u >>  8) & 0xff;
812     buf[3] = u & 0xff;
813     u = sig->keyid[1];
814     buf[4] = (u >> 24) & 0xff;
815     buf[5] = (u >> 16) & 0xff;
816     buf[6] = (u >>  8) & 0xff;
817     buf[7] = u & 0xff;
818     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
819
820     u = sig->timestamp;
821     buf[0] = (u >> 24) & 0xff;
822     buf[1] = (u >> 16) & 0xff;
823     buf[2] = (u >>  8) & 0xff;
824     buf[3] = u & 0xff;
825     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
826
827     if(sig->expiredate)
828       {
829         if(sig->expiredate>sig->timestamp)
830           u=sig->expiredate-sig->timestamp;
831         else
832           u=0;
833
834         buf[0] = (u >> 24) & 0xff;
835         buf[1] = (u >> 16) & 0xff;
836         buf[2] = (u >>  8) & 0xff;
837         buf[3] = u & 0xff;
838
839         /* Mark this CRITICAL, so if any implementation doesn't
840            understand sigs that can expire, it'll just disregard this
841            sig altogether. */
842
843         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
844                           buf, 4 );
845       }
846 }
847
848 void
849 build_attribute_subpkt(PKT_user_id *uid,byte type,
850                        const void *buf,u32 buflen,
851                        const void *header,u32 headerlen)
852 {
853   byte *attrib;
854   int idx;
855
856   if(1+headerlen+buflen>8383)
857     idx=5;
858   else if(1+headerlen+buflen>191)
859     idx=2;
860   else
861     idx=1;
862
863   /* realloc uid->attrib_data to the right size */
864
865   uid->attrib_data=m_realloc(uid->attrib_data,
866                              uid->attrib_len+idx+1+headerlen+buflen);
867
868   attrib=&uid->attrib_data[uid->attrib_len];
869
870   if(idx==5)
871     {
872       attrib[0]=255;
873       attrib[1]=(1+headerlen+buflen) >> 24;
874       attrib[2]=(1+headerlen+buflen) >> 16;
875       attrib[3]=(1+headerlen+buflen) >> 8;
876       attrib[4]=1+headerlen+buflen;
877     }
878   else if(idx==2)
879     {
880       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
881       attrib[1]=(1+headerlen+buflen-192) % 256;
882     }
883   else
884     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
885
886   attrib[idx++]=type;
887
888   /* Tack on our data at the end */
889
890   if(headerlen>0)
891     memcpy(&attrib[idx],header,headerlen);
892   memcpy(&attrib[idx+headerlen],buf,buflen);
893   uid->attrib_len+=idx+headerlen+buflen;
894 }
895
896 static int
897 do_signature( IOBUF out, int ctb, PKT_signature *sig )
898 {
899     int rc = 0;
900     int n, i;
901     IOBUF a = iobuf_temp();
902
903     if( !sig->version )
904         iobuf_put( a, 3 );
905     else
906         iobuf_put( a, sig->version );
907     if( sig->version < 4 )
908         iobuf_put(a, 5 ); /* constant */
909     iobuf_put(a, sig->sig_class );
910     if( sig->version < 4 ) {
911         write_32(a, sig->timestamp );
912         write_32(a, sig->keyid[0] );
913         write_32(a, sig->keyid[1] );
914     }
915     iobuf_put(a, sig->pubkey_algo );
916     iobuf_put(a, sig->digest_algo );
917     if( sig->version >= 4 ) {
918         size_t nn;
919         /* timestamp and keyid must have been packed into the
920          * subpackets prior to the call of this function, because
921          * these subpackets are hashed */
922         nn = sig->hashed? sig->hashed->len : 0;
923         write_16(a, nn);
924         if( nn )
925             iobuf_write( a, sig->hashed->data, nn );
926         nn = sig->unhashed? sig->unhashed->len : 0;
927         write_16(a, nn);
928         if( nn )
929             iobuf_write( a, sig->unhashed->data, nn );
930     }
931     iobuf_put(a, sig->digest_start[0] );
932     iobuf_put(a, sig->digest_start[1] );
933     n = pubkey_get_nsig( sig->pubkey_algo );
934     if( !n )
935         write_fake_data( a, sig->data[0] );
936     for(i=0; i < n; i++ )
937         mpi_write(a, sig->data[i] );
938
939     if( is_RSA(sig->pubkey_algo) && sig->version < 4 )
940         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
941     else
942         write_header(out, ctb, iobuf_get_temp_length(a) );
943     if( iobuf_write_temp( out, a ) )
944         rc = G10ERR_WRITE_FILE;
945
946     iobuf_close(a);
947     return rc;
948 }
949
950
951 static int
952 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
953 {
954     int rc = 0;
955     IOBUF a = iobuf_temp();
956
957     write_version( a, ctb );
958     iobuf_put(a, ops->sig_class );
959     iobuf_put(a, ops->digest_algo );
960     iobuf_put(a, ops->pubkey_algo );
961     write_32(a, ops->keyid[0] );
962     write_32(a, ops->keyid[1] );
963     iobuf_put(a, ops->last );
964
965     write_header(out, ctb, iobuf_get_temp_length(a) );
966     if( iobuf_write_temp( out, a ) )
967         rc = G10ERR_WRITE_FILE;
968
969     iobuf_close(a);
970     return rc;
971 }
972
973
974 static int
975 write_16(IOBUF out, u16 a)
976 {
977     iobuf_put(out, a>>8);
978     if( iobuf_put(out,a) )
979         return -1;
980     return 0;
981 }
982
983 static int
984 write_32(IOBUF out, u32 a)
985 {
986     iobuf_put(out, a>> 24);
987     iobuf_put(out, a>> 16);
988     iobuf_put(out, a>> 8);
989     if( iobuf_put(out, a) )
990         return -1;
991     return 0;
992 }
993
994
995 /****************
996  * calculate the length of a header
997  */
998 static int
999 calc_header_length( u32 len, int new_ctb )
1000 {
1001     if( !len )
1002         return 1; /* only the ctb */
1003
1004     if( new_ctb ) {
1005         if( len < 192 )
1006             return 2;
1007         if( len < 8384 )
1008             return 3;
1009         else
1010             return 6;
1011     }
1012     if( len < 256 )
1013         return 2;
1014     if( len < 65536 )
1015         return 3;
1016
1017     return 5;
1018 }
1019
1020 /****************
1021  * Write the CTB and the packet length
1022  */
1023 static int
1024 write_header( IOBUF out, int ctb, u32 len )
1025 {
1026     return write_header2( out, ctb, len, 0 );
1027 }
1028
1029
1030 static int
1031 write_sign_packet_header( IOBUF out, int ctb, u32 len )
1032 {
1033     /* work around a bug in the pgp read function for signature packets,
1034      * which are not correctly coded and silently assume at some
1035      * point 2 byte length headers.*/
1036     iobuf_put(out, 0x89 );
1037     iobuf_put(out, len >> 8 );
1038     return iobuf_put(out, len ) == -1 ? -1:0;
1039 }
1040
1041 /****************
1042  * If HDRLEN is > 0, try to build a header of this length.  We need
1043  * this so that we can hash packets without reading them again.  If
1044  * len is 0, write a partial or indeterminate length header, unless
1045  * hdrlen is specified in which case write an actual zero length
1046  * (using the specified hdrlen).
1047  */
1048 static int
1049 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1050 {
1051   if( ctb & 0x40 )
1052     return write_new_header( out, ctb, len, hdrlen );
1053
1054   if( hdrlen )
1055     {
1056       if( hdrlen == 2 && len < 256 )
1057         ;
1058       else if( hdrlen == 3 && len < 65536 )
1059         ctb |= 1;
1060       else
1061         ctb |= 2;
1062     }
1063   else
1064     {
1065       if( !len )
1066         ctb |= 3;
1067       else if( len < 256 )
1068         ;
1069       else if( len < 65536 )
1070         ctb |= 1;
1071       else
1072         ctb |= 2;
1073     }
1074
1075   if( iobuf_put(out, ctb ) )
1076     return -1;
1077
1078   if( len || hdrlen )
1079     {
1080       if( ctb & 2 )
1081         {
1082           if(iobuf_put(out, len >> 24 ))
1083             return -1;
1084           if(iobuf_put(out, len >> 16 ))
1085             return -1;
1086         }
1087
1088       if( ctb & 3 )
1089         if(iobuf_put(out, len >> 8 ))
1090           return -1;
1091
1092       if( iobuf_put(out, len ) )
1093         return -1;
1094     }
1095
1096   return 0;
1097 }
1098
1099
1100 static int
1101 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1102 {
1103     if( hdrlen )
1104         log_bug("can't cope with hdrlen yet\n");
1105
1106     if( iobuf_put(out, ctb ) )
1107         return -1;
1108     if( !len ) {
1109         iobuf_set_partial_block_mode(out, 512 );
1110     }
1111     else {
1112         if( len < 192 ) {
1113             if( iobuf_put(out, len ) )
1114                 return -1;
1115         }
1116         else if( len < 8384 ) {
1117             len -= 192;
1118             if( iobuf_put( out, (len / 256) + 192) )
1119                 return -1;
1120             if( iobuf_put( out, (len % 256) )  )
1121                 return -1;
1122         }
1123         else {
1124             if( iobuf_put( out, 0xff ) )
1125                 return -1;
1126             if( iobuf_put( out, (len >> 24)&0xff ) )
1127                 return -1;
1128             if( iobuf_put( out, (len >> 16)&0xff ) )
1129                 return -1;
1130             if( iobuf_put( out, (len >> 8)&0xff )  )
1131                 return -1;
1132             if( iobuf_put( out, len & 0xff ) )
1133                 return -1;
1134         }
1135     }
1136     return 0;
1137 }
1138
1139 static int
1140 write_version( IOBUF out, int ctb )
1141 {
1142     if( iobuf_put( out, 3 ) )
1143         return -1;
1144     return 0;
1145 }