* keygen.c (gen_elg, gen_dsa, gen_rsa, do_create, do_generate_keypair,
[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     return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
464 }
465
466 static int
467 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
468 {
469     int i, rc = 0;
470     u32 n;
471     byte buf[1000]; /* this buffer has the plaintext! */
472     int nbytes;
473
474     /* Truncate namelen to the maximum 255 characters.  This does mean
475        that a function that calls build_packet with an illegal literal
476        packet will get it back legalized. */
477     if(pt->namelen>255)
478       pt->namelen=255;
479
480     write_header(out, ctb, calc_plaintext( pt ) );
481     iobuf_put(out, pt->mode );
482     iobuf_put(out, pt->namelen );
483     for(i=0; i < pt->namelen; i++ )
484         iobuf_put(out, pt->name[i] );
485     if( write_32(out, pt->timestamp ) )
486         rc = G10ERR_WRITE_FILE;
487
488     n = 0;
489     while( (nbytes=iobuf_read(pt->buf, buf, 1000)) != -1 ) {
490         if( iobuf_write(out, buf, nbytes) == -1 ) {
491             rc = G10ERR_WRITE_FILE;
492             break;
493         }
494         n += nbytes;
495     }
496     wipememory(buf,1000); /* burn the buffer */
497     if( (ctb&0x40) && !pt->len )
498       iobuf_set_partial_block_mode(out, 0 ); /* turn off partial */
499     if( pt->len && n != pt->len )
500       log_error("do_plaintext(): wrote %lu bytes but expected %lu bytes\n",
501                 (ulong)n, (ulong)pt->len );
502
503     return rc;
504 }
505
506
507
508 static int
509 do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
510 {
511     int rc = 0;
512     u32 n;
513
514     n = ed->len ? (ed->len + ed->extralen) : 0;
515     write_header(out, ctb, n );
516
517     /* This is all. The caller has to write the real data */
518
519     return rc;
520 }
521
522 static int
523 do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
524 {
525     int rc = 0;
526     u32 n;
527
528     assert( ed->mdc_method );
529
530     /* Take version number and the following MDC packet in account. */
531     n = ed->len ? (ed->len + ed->extralen + 1 + 22) : 0;
532     write_header(out, ctb, n );
533     iobuf_put(out, 1 );  /* version */
534
535     /* This is all. The caller has to write the real data */
536
537     return rc;
538 }
539
540
541 static int
542 do_compressed( IOBUF out, int ctb, PKT_compressed *cd )
543 {
544     int rc = 0;
545
546     /* We must use the old convention and don't use blockmode for tyhe
547        sake of PGP 2 compatibility.  However if the new_ctb flag was
548        set, CTB is already formatted as new style and write_header2
549        does create a partial length encoding using new the new
550        style. */
551     write_header2(out, ctb, 0, 0);
552     iobuf_put(out, cd->algorithm );
553
554     /* This is all. The caller has to write the real data */
555
556     return rc;
557 }
558
559
560 /****************
561  * Delete all subpackets of type REQTYPE and return a bool whether a packet
562  * was deleted.
563  */
564 int
565 delete_sig_subpkt (subpktarea_t *area, sigsubpkttype_t reqtype )
566 {
567     int buflen;
568     sigsubpkttype_t type;
569     byte *buffer, *bufstart;
570     size_t n;
571     size_t unused = 0;
572     int okay = 0;
573
574     if( !area )
575         return 0;
576     buflen = area->len;
577     buffer = area->data;
578     for(;;) {
579         if( !buflen ) {
580             okay = 1;
581             break;
582         }
583         bufstart = buffer;
584         n = *buffer++; buflen--;
585         if( n == 255 ) {
586             if( buflen < 4 )
587                 break;
588             n = (buffer[0] << 24) | (buffer[1] << 16)
589                 | (buffer[2] << 8) | buffer[3];
590             buffer += 4;
591             buflen -= 4;
592         }
593         else if( n >= 192 ) {
594             if( buflen < 2 )
595                 break;
596             n = (( n - 192 ) << 8) + *buffer + 192;
597             buffer++;
598             buflen--;
599         }
600         if( buflen < n )
601             break;
602         
603         type = *buffer & 0x7f;
604         if( type == reqtype ) {
605             buffer++;
606             buflen--;
607             n--;
608             if( n > buflen )
609                 break;
610             buffer += n; /* point to next subpkt */
611             buflen -= n;
612             memmove (bufstart, buffer, buflen); /* shift */
613             unused +=  buffer - bufstart;
614             buffer = bufstart;
615         }
616         else {
617             buffer += n; buflen -=n;
618         }
619     }
620
621     if (!okay)
622         log_error ("delete_subpkt: buffer shorter than subpacket\n");
623     assert (unused <= area->len);
624     area->len -= unused;
625     return !!unused;
626 }
627
628
629 /****************
630  * Create or update a signature subpacket for SIG of TYPE.  This
631  * functions knows where to put the data (hashed or unhashed).  The
632  * function may move data from the unhashed part to the hashed one.
633  * Note: All pointers into sig->[un]hashed (e.g. returned by
634  * parse_sig_subpkt) are not valid after a call to this function.  The
635  * data to put into the subpaket should be in a buffer with a length
636  * of buflen. 
637  */
638 void
639 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
640                   const byte *buffer, size_t buflen )
641 {
642     byte *p;
643     int critical, hashed;
644     subpktarea_t *oldarea, *newarea;
645     size_t nlen, n, n0;
646
647     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
648     type &= ~SIGSUBPKT_FLAG_CRITICAL;
649
650     /* Sanity check buffer sizes */
651     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
652       BUG();
653
654     switch(type)
655       {
656       case SIGSUBPKT_NOTATION:
657       case SIGSUBPKT_POLICY:
658       case SIGSUBPKT_REV_KEY:
659       case SIGSUBPKT_SIGNATURE:
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       {
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       case SIGSUBPKT_SIGNATURE:
737         hashed = 0;
738         break;
739       default: 
740         hashed = 1;
741         break;
742       }
743
744     if( critical )
745         type |= SIGSUBPKT_FLAG_CRITICAL;
746
747     oldarea = hashed? sig->hashed : sig->unhashed;
748
749     /* Calculate new size of the area and allocate */
750     n0 = oldarea? oldarea->len : 0;
751     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
752     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
753         newarea = oldarea;
754         /*log_debug ("updating area for type %d\n", type );*/
755     }
756     else if (oldarea) {
757         newarea = m_realloc (oldarea, sizeof (*newarea) + n - 1);
758         newarea->size = n;
759         /*log_debug ("reallocating area for type %d\n", type );*/
760     }
761     else {
762         newarea = m_alloc (sizeof (*newarea) + n - 1);
763         newarea->size = n;
764         /*log_debug ("allocating area for type %d\n", type );*/
765     }
766     newarea->len = n;
767
768     p = newarea->data + n0;
769     if (nlen == 5) {
770         *p++ = 255;
771         *p++ = (buflen+1) >> 24;
772         *p++ = (buflen+1) >> 16;
773         *p++ = (buflen+1) >>  8;
774         *p++ = (buflen+1);
775         *p++ = type;
776         memcpy (p, buffer, buflen);
777     }
778     else if (nlen == 2) {
779         *p++ = (buflen+1-192) / 256 + 192;
780         *p++ = (buflen+1-192) % 256;
781         *p++ = type;
782         memcpy (p, buffer, buflen);
783     }
784     else {
785         *p++ = buflen+1;
786         *p++ = type;
787         memcpy (p, buffer, buflen);
788     }
789
790     if (hashed) 
791         sig->hashed = newarea;
792     else
793         sig->unhashed = newarea;
794 }
795
796 /****************
797  * Put all the required stuff from SIG into subpackets of sig.
798  * Hmmm, should we delete those subpackets which are in a wrong area?
799  */
800 void
801 build_sig_subpkt_from_sig( PKT_signature *sig )
802 {
803     u32  u;
804     byte buf[8];
805
806     u = sig->keyid[0];
807     buf[0] = (u >> 24) & 0xff;
808     buf[1] = (u >> 16) & 0xff;
809     buf[2] = (u >>  8) & 0xff;
810     buf[3] = u & 0xff;
811     u = sig->keyid[1];
812     buf[4] = (u >> 24) & 0xff;
813     buf[5] = (u >> 16) & 0xff;
814     buf[6] = (u >>  8) & 0xff;
815     buf[7] = u & 0xff;
816     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
817
818     u = sig->timestamp;
819     buf[0] = (u >> 24) & 0xff;
820     buf[1] = (u >> 16) & 0xff;
821     buf[2] = (u >>  8) & 0xff;
822     buf[3] = u & 0xff;
823     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
824
825     if(sig->expiredate)
826       {
827         if(sig->expiredate>sig->timestamp)
828           u=sig->expiredate-sig->timestamp;
829         else
830           u=0;
831
832         buf[0] = (u >> 24) & 0xff;
833         buf[1] = (u >> 16) & 0xff;
834         buf[2] = (u >>  8) & 0xff;
835         buf[3] = u & 0xff;
836
837         /* Mark this CRITICAL, so if any implementation doesn't
838            understand sigs that can expire, it'll just disregard this
839            sig altogether. */
840
841         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
842                           buf, 4 );
843       }
844 }
845
846 void
847 build_attribute_subpkt(PKT_user_id *uid,byte type,
848                        const void *buf,u32 buflen,
849                        const void *header,u32 headerlen)
850 {
851   byte *attrib;
852   int idx;
853
854   if(1+headerlen+buflen>8383)
855     idx=5;
856   else if(1+headerlen+buflen>191)
857     idx=2;
858   else
859     idx=1;
860
861   /* realloc uid->attrib_data to the right size */
862
863   uid->attrib_data=m_realloc(uid->attrib_data,
864                              uid->attrib_len+idx+1+headerlen+buflen);
865
866   attrib=&uid->attrib_data[uid->attrib_len];
867
868   if(idx==5)
869     {
870       attrib[0]=255;
871       attrib[1]=(1+headerlen+buflen) >> 24;
872       attrib[2]=(1+headerlen+buflen) >> 16;
873       attrib[3]=(1+headerlen+buflen) >> 8;
874       attrib[4]=1+headerlen+buflen;
875     }
876   else if(idx==2)
877     {
878       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
879       attrib[1]=(1+headerlen+buflen-192) % 256;
880     }
881   else
882     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
883
884   attrib[idx++]=type;
885
886   /* Tack on our data at the end */
887
888   if(headerlen>0)
889     memcpy(&attrib[idx],header,headerlen);
890   memcpy(&attrib[idx+headerlen],buf,buflen);
891   uid->attrib_len+=idx+headerlen+buflen;
892 }
893
894 static int
895 do_signature( IOBUF out, int ctb, PKT_signature *sig )
896 {
897     int rc = 0;
898     int n, i;
899     IOBUF a = iobuf_temp();
900
901     if( !sig->version )
902         iobuf_put( a, 3 );
903     else
904         iobuf_put( a, sig->version );
905     if( sig->version < 4 )
906         iobuf_put(a, 5 ); /* constant */
907     iobuf_put(a, sig->sig_class );
908     if( sig->version < 4 ) {
909         write_32(a, sig->timestamp );
910         write_32(a, sig->keyid[0] );
911         write_32(a, sig->keyid[1] );
912     }
913     iobuf_put(a, sig->pubkey_algo );
914     iobuf_put(a, sig->digest_algo );
915     if( sig->version >= 4 ) {
916         size_t nn;
917         /* timestamp and keyid must have been packed into the
918          * subpackets prior to the call of this function, because
919          * these subpackets are hashed */
920         nn = sig->hashed? sig->hashed->len : 0;
921         write_16(a, nn);
922         if( nn )
923             iobuf_write( a, sig->hashed->data, nn );
924         nn = sig->unhashed? sig->unhashed->len : 0;
925         write_16(a, nn);
926         if( nn )
927             iobuf_write( a, sig->unhashed->data, nn );
928     }
929     iobuf_put(a, sig->digest_start[0] );
930     iobuf_put(a, sig->digest_start[1] );
931     n = pubkey_get_nsig( sig->pubkey_algo );
932     if( !n )
933         write_fake_data( a, sig->data[0] );
934     for(i=0; i < n; i++ )
935         mpi_write(a, sig->data[i] );
936
937     if( is_RSA(sig->pubkey_algo) && sig->version < 4 )
938         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
939     else
940         write_header(out, ctb, iobuf_get_temp_length(a) );
941     if( iobuf_write_temp( out, a ) )
942         rc = G10ERR_WRITE_FILE;
943
944     iobuf_close(a);
945     return rc;
946 }
947
948
949 static int
950 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
951 {
952     int rc = 0;
953     IOBUF a = iobuf_temp();
954
955     write_version( a, ctb );
956     iobuf_put(a, ops->sig_class );
957     iobuf_put(a, ops->digest_algo );
958     iobuf_put(a, ops->pubkey_algo );
959     write_32(a, ops->keyid[0] );
960     write_32(a, ops->keyid[1] );
961     iobuf_put(a, ops->last );
962
963     write_header(out, ctb, iobuf_get_temp_length(a) );
964     if( iobuf_write_temp( out, a ) )
965         rc = G10ERR_WRITE_FILE;
966
967     iobuf_close(a);
968     return rc;
969 }
970
971
972 static int
973 write_16(IOBUF out, u16 a)
974 {
975     iobuf_put(out, a>>8);
976     if( iobuf_put(out,a) )
977         return -1;
978     return 0;
979 }
980
981 static int
982 write_32(IOBUF out, u32 a)
983 {
984     iobuf_put(out, a>> 24);
985     iobuf_put(out, a>> 16);
986     iobuf_put(out, a>> 8);
987     if( iobuf_put(out, a) )
988         return -1;
989     return 0;
990 }
991
992
993 /****************
994  * calculate the length of a header
995  */
996 static int
997 calc_header_length( u32 len, int new_ctb )
998 {
999     if( !len )
1000         return 1; /* only the ctb */
1001
1002     if( new_ctb ) {
1003         if( len < 192 )
1004             return 2;
1005         if( len < 8384 )
1006             return 3;
1007         else
1008             return 6;
1009     }
1010     if( len < 256 )
1011         return 2;
1012     if( len < 65536 )
1013         return 3;
1014
1015     return 5;
1016 }
1017
1018 /****************
1019  * Write the CTB and the packet length
1020  */
1021 static int
1022 write_header( IOBUF out, int ctb, u32 len )
1023 {
1024     return write_header2( out, ctb, len, 0 );
1025 }
1026
1027
1028 static int
1029 write_sign_packet_header( IOBUF out, int ctb, u32 len )
1030 {
1031     /* work around a bug in the pgp read function for signature packets,
1032      * which are not correctly coded and silently assume at some
1033      * point 2 byte length headers.*/
1034     iobuf_put(out, 0x89 );
1035     iobuf_put(out, len >> 8 );
1036     return iobuf_put(out, len ) == -1 ? -1:0;
1037 }
1038
1039 /****************
1040  * If HDRLEN is > 0, try to build a header of this length.  We need
1041  * this so that we can hash packets without reading them again.  If
1042  * len is 0, write a partial or indeterminate length header, unless
1043  * hdrlen is specified in which case write an actual zero length
1044  * (using the specified hdrlen).
1045  */
1046 static int
1047 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1048 {
1049   if( ctb & 0x40 )
1050     return write_new_header( out, ctb, len, hdrlen );
1051
1052   if( hdrlen )
1053     {
1054       if( hdrlen == 2 && len < 256 )
1055         ;
1056       else if( hdrlen == 3 && len < 65536 )
1057         ctb |= 1;
1058       else
1059         ctb |= 2;
1060     }
1061   else
1062     {
1063       if( !len )
1064         ctb |= 3;
1065       else if( len < 256 )
1066         ;
1067       else if( len < 65536 )
1068         ctb |= 1;
1069       else
1070         ctb |= 2;
1071     }
1072
1073   if( iobuf_put(out, ctb ) )
1074     return -1;
1075
1076   if( len || hdrlen )
1077     {
1078       if( ctb & 2 )
1079         {
1080           if(iobuf_put(out, len >> 24 ))
1081             return -1;
1082           if(iobuf_put(out, len >> 16 ))
1083             return -1;
1084         }
1085
1086       if( ctb & 3 )
1087         if(iobuf_put(out, len >> 8 ))
1088           return -1;
1089
1090       if( iobuf_put(out, len ) )
1091         return -1;
1092     }
1093
1094   return 0;
1095 }
1096
1097
1098 static int
1099 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1100 {
1101     if( hdrlen )
1102         log_bug("can't cope with hdrlen yet\n");
1103
1104     if( iobuf_put(out, ctb ) )
1105         return -1;
1106     if( !len ) {
1107         iobuf_set_partial_block_mode(out, 512 );
1108     }
1109     else {
1110         if( len < 192 ) {
1111             if( iobuf_put(out, len ) )
1112                 return -1;
1113         }
1114         else if( len < 8384 ) {
1115             len -= 192;
1116             if( iobuf_put( out, (len / 256) + 192) )
1117                 return -1;
1118             if( iobuf_put( out, (len % 256) )  )
1119                 return -1;
1120         }
1121         else {
1122             if( iobuf_put( out, 0xff ) )
1123                 return -1;
1124             if( iobuf_put( out, (len >> 24)&0xff ) )
1125                 return -1;
1126             if( iobuf_put( out, (len >> 16)&0xff ) )
1127                 return -1;
1128             if( iobuf_put( out, (len >> 8)&0xff )  )
1129                 return -1;
1130             if( iobuf_put( out, len & 0xff ) )
1131                 return -1;
1132         }
1133     }
1134     return 0;
1135 }
1136
1137 static int
1138 write_version( IOBUF out, int ctb )
1139 {
1140     if( iobuf_put( out, 3 ) )
1141         return -1;
1142     return 0;
1143 }