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