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