Finished the bulk of changes for gnupg 1.9. This included switching
[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 out special mode 1001 we do not need an IV */
419             if( sk->protect.s2k.mode != 1001 )
420                 iobuf_write(a, sk->protect.iv, sk->protect.ivlen );
421         }
422     }
423     else
424         iobuf_put(a, 0 );
425
426     if( sk->protect.s2k.mode == 1001 )
427         ; /* GnuPG extension - don't write a secret key at all */ 
428     else if( sk->is_protected && sk->version >= 4 ) {
429         /* The secret key is protected - write it out as it is */
430         byte *p;
431         assert( gcry_mpi_get_flag( sk->skey[npkey], GCRYMPI_FLAG_OPAQUE ) );
432         p = gcry_mpi_get_opaque( sk->skey[npkey], &i );
433         iobuf_write(a, p, (i+7)/8 );
434     }
435     else if( sk->is_protected ) {
436         /* The secret key is protected the old v4 way. */
437         for(   ; i < nskey; i++ ) {
438             byte *p;
439             size_t n;
440
441             assert( gcry_mpi_get_flag (sk->skey[i], GCRYMPI_FLAG_OPAQUE));
442             p = gcry_mpi_get_opaque( sk->skey[i], &n );
443             iobuf_write (a, p, (n+7)/8);
444         }
445         write_16(a, sk->csum );
446     }
447     else {
448         /* non-protected key */
449         for(   ; i < nskey; i++ )
450             mpi_write(a, sk->skey[i] );
451         write_16(a, sk->csum );
452     }
453
454   leave:
455     /* Build the header of the packet - which we must do after writing all
456        the other stuff, so that we know the length of the packet */
457     write_header2(out, ctb, iobuf_get_temp_length(a), sk->hdrbytes, 1 );
458     /* And finally write it out the real stream */
459     rc = iobuf_write_temp (out, a );
460
461     iobuf_close(a); /* close the remporary buffer */
462     return rc;
463 }
464
465 static int
466 do_symkey_enc( iobuf_t out, int ctb, PKT_symkey_enc *enc )
467 {
468     int rc = 0;
469     iobuf_t a = iobuf_temp();
470
471     assert( enc->version == 4 );
472     switch( enc->s2k.mode ) {
473       case 0: case 1: case 3: break;
474       default: log_bug("do_symkey_enc: s2k=%d\n", enc->s2k.mode );
475     }
476     iobuf_put( a, enc->version );
477     iobuf_put( a, enc->cipher_algo );
478     iobuf_put( a, enc->s2k.mode );
479     iobuf_put( a, enc->s2k.hash_algo );
480     if( enc->s2k.mode == 1 || enc->s2k.mode == 3 ) {
481         iobuf_write(a, enc->s2k.salt, 8 );
482         if( enc->s2k.mode == 3 )
483             iobuf_put(a, enc->s2k.count);
484     }
485     if( enc->seskeylen )
486         iobuf_write(a, enc->seskey, enc->seskeylen );
487
488     write_header(out, ctb, iobuf_get_temp_length(a) );
489     rc = iobuf_write_temp (out, a);
490
491     iobuf_close(a);
492     return rc;
493 }
494
495
496
497
498 static int
499 do_pubkey_enc( iobuf_t out, int ctb, PKT_pubkey_enc *enc )
500 {
501     int rc = 0;
502     int n, i;
503     iobuf_t a = iobuf_temp();
504
505     write_version( a, ctb );
506     if( enc->throw_keyid ) {
507         write_32(a, 0 );  /* don't tell Eve who can decrypt the message */
508         write_32(a, 0 );
509     }
510     else {
511         write_32(a, enc->keyid[0] );
512         write_32(a, enc->keyid[1] );
513     }
514     iobuf_put(a,enc->pubkey_algo );
515     n = pubkey_get_nenc( enc->pubkey_algo );
516     if( !n )
517         write_fake_data( a, enc->data[0] );
518     for(i=0; i < n; i++ )
519         mpi_write(a, enc->data[i] );
520
521     write_header(out, ctb, iobuf_get_temp_length(a) );
522     rc = iobuf_write_temp (out, a);
523
524     iobuf_close(a);
525     return rc;
526 }
527
528
529
530
531 static u32
532 calc_plaintext( PKT_plaintext *pt )
533 {
534     return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
535 }
536
537 static int
538 do_plaintext( iobuf_t out, int ctb, PKT_plaintext *pt )
539 {
540     int i, rc = 0;
541     u32 n;
542     byte buf[1000]; /* this buffer has the plaintext! */
543     int nbytes;
544
545     /* Truncate namelen to the maximum 255 characters.  This does mean
546        that a function that calls build_packet with an illegal literal
547        packet will get it back legalized. */
548     if(pt->namelen>255)
549       pt->namelen=255;
550
551     write_header(out, ctb, calc_plaintext( pt ) );
552     iobuf_put(out, pt->mode );
553     iobuf_put(out, pt->namelen );
554     for(i=0; i < pt->namelen; i++ )
555         iobuf_put(out, pt->name[i] );
556     rc = write_32 (out, pt->timestamp);
557
558     n = 0;
559     while( (nbytes=iobuf_read(pt->buf, buf, 1000)) != -1 ) {
560         rc = iobuf_write(out, buf, nbytes);
561         if (rc)
562           break;
563         n += nbytes;
564     }
565     wipememory(buf,1000); /* burn the buffer */
566     if( !pt->len )
567         iobuf_set_block_mode(out, 0 ); /* write end marker */
568     else if( n != pt->len )
569         log_error("do_plaintext(): wrote %lu bytes but expected %lu bytes\n",
570                         (ulong)n, (ulong)pt->len );
571
572     return rc;
573 }
574
575
576
577 static int
578 do_encrypted( iobuf_t out, int ctb, PKT_encrypted *ed )
579 {
580     int rc = 0;
581     u32 n;
582
583     n = ed->len ? (ed->len + ed->extralen) : 0;
584     write_header(out, ctb, n );
585
586     /* This is all. The caller has to write the real data */
587
588     return rc;
589 }
590
591 static int
592 do_encrypted_mdc( iobuf_t out, int ctb, PKT_encrypted *ed )
593 {
594     int rc = 0;
595     u32 n;
596
597     assert( ed->mdc_method );
598
599     /* Take version number and the following MDC packet in account. */
600     n = ed->len ? (ed->len + ed->extralen + 1 + 22) : 0;
601     write_header(out, ctb, n );
602     iobuf_put(out, 1 );  /* version */
603
604     /* This is all. The caller has to write the real data */
605
606     return rc;
607 }
608
609
610 static int
611 do_compressed( iobuf_t out, int ctb, PKT_compressed *cd )
612 {
613     int rc = 0;
614
615     /* We must use the old convention and don't use blockmode for tyhe
616        sake of PGP 2 compatibility.  However if the new_ctb flag was
617        set, CTB is already formatted as new style and write_header2
618        does create a partial length encoding using new the new
619        style. */
620     write_header2(out, ctb, 0, 0, 0 );
621     iobuf_put(out, cd->algorithm );
622
623     /* This is all. The caller has to write the real data */
624
625     return rc;
626 }
627
628
629 /****************
630  * Delete all subpackets of type REQTYPE and return a bool whether a packet
631  * was deleted.
632  */
633 int
634 delete_sig_subpkt (subpktarea_t *area, sigsubpkttype_t reqtype )
635 {
636     int buflen;
637     sigsubpkttype_t type;
638     byte *buffer, *bufstart;
639     size_t n;
640     size_t unused = 0;
641     int okay = 0;
642
643     if( !area )
644         return 0;
645     buflen = area->len;
646     buffer = area->data;
647     for(;;) {
648         if( !buflen ) {
649             okay = 1;
650             break;
651         }
652         bufstart = buffer;
653         n = *buffer++; buflen--;
654         if( n == 255 ) {
655             if( buflen < 4 )
656                 break;
657             n = (buffer[0] << 24) | (buffer[1] << 16)
658                 | (buffer[2] << 8) | buffer[3];
659             buffer += 4;
660             buflen -= 4;
661         }
662         else if( n >= 192 ) {
663             if( buflen < 2 )
664                 break;
665             n = (( n - 192 ) << 8) + *buffer + 192;
666             buffer++;
667             buflen--;
668         }
669         if( buflen < n )
670             break;
671         
672         type = *buffer & 0x7f;
673         if( type == reqtype ) {
674             buffer++;
675             buflen--;
676             n--;
677             if( n > buflen )
678                 break;
679             buffer += n; /* point to next subpkt */
680             buflen -= n;
681             memmove (bufstart, buffer, buflen); /* shift */
682             unused +=  buffer - bufstart;
683             buffer = bufstart;
684         }
685         else {
686             buffer += n; buflen -=n;
687         }
688     }
689
690     if (!okay)
691         log_error ("delete_subpkt: buffer shorter than subpacket\n");
692     assert (unused <= area->len);
693     area->len -= unused;
694     return !!unused;
695 }
696
697
698 /****************
699  * Create or update a signature subpacket for SIG of TYPE.  This
700  * functions knows where to put the data (hashed or unhashed).  The
701  * function may move data from the unhashed part to the hashed one.
702  * Note: All pointers into sig->[un]hashed (e.g. returned by
703  * parse_sig_subpkt) are not valid after a call to this function.  The
704  * data to put into the subpaket should be in a buffer with a length
705  * of buflen. 
706  */
707 void
708 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
709                   const byte *buffer, size_t buflen )
710 {
711     byte *p;
712     int critical, hashed;
713     subpktarea_t *oldarea, *newarea;
714     size_t nlen, n, n0;
715
716     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
717     type &= ~SIGSUBPKT_FLAG_CRITICAL;
718
719     /* Sanity check buffer sizes */
720     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
721       BUG();
722
723     switch(type)
724       {
725       case SIGSUBPKT_NOTATION:
726       case SIGSUBPKT_POLICY:
727       case SIGSUBPKT_REV_KEY:
728         /* we do allow multiple subpackets */
729         break;
730
731       default:
732         /* we don't allow multiple subpackets */
733         delete_sig_subpkt(sig->hashed,type);
734         delete_sig_subpkt(sig->unhashed,type);
735         break;
736       }
737
738     /* Any special magic that needs to be done for this type so the
739        packet doesn't need to be reparsed? */
740     switch(type)
741       {
742       case SIGSUBPKT_NOTATION:
743         sig->flags.notation=1;
744         break;
745
746       case SIGSUBPKT_POLICY:
747         sig->flags.policy_url=1;
748         break;
749
750       case SIGSUBPKT_EXPORTABLE:
751         if(buffer[0])
752           sig->flags.exportable=1;
753         else
754           sig->flags.exportable=0;
755         break;
756
757       case SIGSUBPKT_REVOCABLE:
758         if(buffer[0])
759           sig->flags.revocable=1;
760         else
761           sig->flags.revocable=0;
762         break;
763
764       case SIGSUBPKT_TRUST:
765         sig->trust_depth=buffer[0];
766         sig->trust_value=buffer[1];
767         break;
768
769       case SIGSUBPKT_REGEXP:
770         sig->trust_regexp=buffer;
771         break;
772
773         /* This should never happen since we don't currently allow
774            creating such a subpacket, but just in case... */
775       case SIGSUBPKT_SIG_EXPIRE:
776         if(buffer_to_u32(buffer)+sig->timestamp<=make_timestamp())
777           sig->flags.expired=1;
778         else
779           sig->flags.expired=0;
780         break;
781
782       default:
783         break;
784       }
785
786     if( (buflen+1) >= 8384 )
787         nlen = 5; /* write 5 byte length header */
788     else if( (buflen+1) >= 192 )
789         nlen = 2; /* write 2 byte length header */
790     else
791         nlen = 1; /* just a 1 byte length header */
792
793     switch( type ) {
794         /* The issuer being unhashed is a historical oddity.  It
795            should work equally as well hashed.  Of course, if even an
796            unhashed issuer is tampered with, it makes it awfully hard
797            to verify the sig... */
798       case SIGSUBPKT_ISSUER:
799         hashed = 0;
800         break;
801       default: 
802         hashed = 1;
803         break;
804     }
805
806     if( critical )
807         type |= SIGSUBPKT_FLAG_CRITICAL;
808
809     oldarea = hashed? sig->hashed : sig->unhashed;
810
811     /* Calculate new size of the area and allocate */
812     n0 = oldarea? oldarea->len : 0;
813     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
814     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
815         newarea = oldarea;
816         /*log_debug ("updating area for type %d\n", type );*/
817     }
818     else if (oldarea) {
819         newarea = xrealloc (oldarea, sizeof (*newarea) + n - 1);
820         newarea->size = n;
821         /*log_debug ("reallocating area for type %d\n", type );*/
822     }
823     else {
824         newarea = xmalloc (sizeof (*newarea) + n - 1);
825         newarea->size = n;
826         /*log_debug ("allocating area for type %d\n", type );*/
827     }
828     newarea->len = n;
829
830     p = newarea->data + n0;
831     if (nlen == 5) {
832         *p++ = 255;
833         *p++ = (buflen+1) >> 24;
834         *p++ = (buflen+1) >> 16;
835         *p++ = (buflen+1) >>  8;
836         *p++ = (buflen+1);
837         *p++ = type;
838         memcpy (p, buffer, buflen);
839     }
840     else if (nlen == 2) {
841         *p++ = (buflen+1-192) / 256 + 192;
842         *p++ = (buflen+1-192) % 256;
843         *p++ = type;
844         memcpy (p, buffer, buflen);
845     }
846     else {
847         *p++ = buflen+1;
848         *p++ = type;
849         memcpy (p, buffer, buflen);
850     }
851
852     if (hashed) 
853         sig->hashed = newarea;
854     else
855         sig->unhashed = newarea;
856 }
857
858 /****************
859  * Put all the required stuff from SIG into subpackets of sig.
860  * Hmmm, should we delete those subpackets which are in a wrong area?
861  */
862 void
863 build_sig_subpkt_from_sig( PKT_signature *sig )
864 {
865     u32  u;
866     byte buf[8];
867
868     u = sig->keyid[0];
869     buf[0] = (u >> 24) & 0xff;
870     buf[1] = (u >> 16) & 0xff;
871     buf[2] = (u >>  8) & 0xff;
872     buf[3] = u & 0xff;
873     u = sig->keyid[1];
874     buf[4] = (u >> 24) & 0xff;
875     buf[5] = (u >> 16) & 0xff;
876     buf[6] = (u >>  8) & 0xff;
877     buf[7] = u & 0xff;
878     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
879
880     u = sig->timestamp;
881     buf[0] = (u >> 24) & 0xff;
882     buf[1] = (u >> 16) & 0xff;
883     buf[2] = (u >>  8) & 0xff;
884     buf[3] = u & 0xff;
885     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
886
887     if(sig->expiredate)
888       {
889         if(sig->expiredate>sig->timestamp)
890           u=sig->expiredate-sig->timestamp;
891         else
892           u=0;
893
894         buf[0] = (u >> 24) & 0xff;
895         buf[1] = (u >> 16) & 0xff;
896         buf[2] = (u >>  8) & 0xff;
897         buf[3] = u & 0xff;
898
899         /* Mark this CRITICAL, so if any implementation doesn't
900            understand sigs that can expire, it'll just disregard this
901            sig altogether. */
902
903         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
904                           buf, 4 );
905       }
906 }
907
908 void
909 build_attribute_subpkt(PKT_user_id *uid,byte type,
910                        const void *buf,u32 buflen,
911                        const void *header,u32 headerlen)
912 {
913   byte *attrib;
914   int idx;
915
916   if(1+headerlen+buflen>8383)
917     idx=5;
918   else if(1+headerlen+buflen>191)
919     idx=2;
920   else
921     idx=1;
922
923   /* realloc uid->attrib_data to the right size */
924
925   uid->attrib_data=xrealloc(uid->attrib_data,
926                              uid->attrib_len+idx+1+headerlen+buflen);
927
928   attrib=&uid->attrib_data[uid->attrib_len];
929
930   if(idx==5)
931     {
932       attrib[0]=255;
933       attrib[1]=(1+headerlen+buflen) >> 24;
934       attrib[2]=(1+headerlen+buflen) >> 16;
935       attrib[3]=(1+headerlen+buflen) >> 8;
936       attrib[4]=1+headerlen+buflen;
937     }
938   else if(idx==2)
939     {
940       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
941       attrib[1]=(1+headerlen+buflen-192) % 256;
942     }
943   else
944     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
945
946   attrib[idx++]=type;
947
948   /* Tack on our data at the end */
949
950   if(headerlen>0)
951     memcpy(&attrib[idx],header,headerlen);
952   memcpy(&attrib[idx+headerlen],buf,buflen);
953   uid->attrib_len+=idx+headerlen+buflen;
954 }
955
956 static int
957 do_signature( iobuf_t out, int ctb, PKT_signature *sig )
958 {
959     int rc = 0;
960     int n, i;
961     iobuf_t a = iobuf_temp();
962
963     if( !sig->version )
964         iobuf_put( a, 3 );
965     else
966         iobuf_put( a, sig->version );
967     if( sig->version < 4 )
968         iobuf_put(a, 5 ); /* constant */
969     iobuf_put(a, sig->sig_class );
970     if( sig->version < 4 ) {
971         write_32(a, sig->timestamp );
972         write_32(a, sig->keyid[0] );
973         write_32(a, sig->keyid[1] );
974     }
975     iobuf_put(a, sig->pubkey_algo );
976     iobuf_put(a, sig->digest_algo );
977     if( sig->version >= 4 ) {
978         size_t nn;
979         /* timestamp and keyid must have been packed into the
980          * subpackets prior to the call of this function, because
981          * these subpackets are hashed */
982         nn = sig->hashed? sig->hashed->len : 0;
983         write_16(a, nn);
984         if( nn )
985             iobuf_write( a, sig->hashed->data, nn );
986         nn = sig->unhashed? sig->unhashed->len : 0;
987         write_16(a, nn);
988         if( nn )
989             iobuf_write( a, sig->unhashed->data, nn );
990     }
991     iobuf_put(a, sig->digest_start[0] );
992     iobuf_put(a, sig->digest_start[1] );
993     n = pubkey_get_nsig( sig->pubkey_algo );
994     if( !n )
995         write_fake_data( a, sig->data[0] );
996     for(i=0; i < n; i++ )
997         mpi_write(a, sig->data[i] );
998
999     if( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1000         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1001     else
1002         write_header(out, ctb, iobuf_get_temp_length(a) );
1003     rc = iobuf_write_temp (out, a);
1004
1005     iobuf_close(a);
1006     return rc;
1007 }
1008
1009
1010 static int
1011 do_onepass_sig( iobuf_t out, int ctb, PKT_onepass_sig *ops )
1012 {
1013     int rc = 0;
1014     iobuf_t a = iobuf_temp();
1015
1016     write_version( a, ctb );
1017     iobuf_put(a, ops->sig_class );
1018     iobuf_put(a, ops->digest_algo );
1019     iobuf_put(a, ops->pubkey_algo );
1020     write_32(a, ops->keyid[0] );
1021     write_32(a, ops->keyid[1] );
1022     iobuf_put(a, ops->last );
1023
1024     write_header(out, ctb, iobuf_get_temp_length(a) );
1025     rc = iobuf_write_temp (out, a);
1026
1027     iobuf_close(a);
1028     return rc;
1029 }
1030
1031
1032 static int
1033 write_16(iobuf_t out, u16 a)
1034 {
1035     iobuf_put(out, a>>8);
1036     return iobuf_put(out,a);
1037 }
1038
1039 static int
1040 write_32(iobuf_t out, u32 a)
1041 {
1042     iobuf_put(out, a>> 24);
1043     iobuf_put(out, a>> 16);
1044     iobuf_put(out, a>> 8);
1045     return iobuf_put (out, a);
1046 }
1047
1048
1049 /****************
1050  * calculate the length of a header
1051  */
1052 static int
1053 calc_header_length( u32 len, int new_ctb )
1054 {
1055     if( !len )
1056         return 1; /* only the ctb */
1057
1058     if( new_ctb ) {
1059         if( len < 192 )
1060             return 2;
1061         if( len < 8384 )
1062             return 3;
1063         else
1064             return 6;
1065     }
1066     if( len < 256 )
1067         return 2;
1068     if( len < 65536 )
1069         return 3;
1070
1071     return 5;
1072 }
1073
1074 /****************
1075  * Write the CTB and the packet length
1076  */
1077 static int
1078 write_header( iobuf_t out, int ctb, u32 len )
1079 {
1080     return write_header2( out, ctb, len, 0, 1 );
1081 }
1082
1083
1084 static int
1085 write_sign_packet_header( iobuf_t out, int ctb, u32 len )
1086 {
1087     /* work around a bug in the pgp read function for signature packets,
1088      * which are not correctly coded and silently assume at some
1089      * point 2 byte length headers.*/
1090     iobuf_put(out, 0x89 );
1091     iobuf_put(out, len >> 8 );
1092     return iobuf_put(out, len ) == -1 ? -1:0;
1093 }
1094
1095 /****************
1096  * if HDRLEN is > 0, try to build a header of this length.
1097  * we need this, so that we can hash packets without reading them again.
1098  */
1099 static int
1100 write_header2( iobuf_t out, int ctb, u32 len, int hdrlen, int blkmode )
1101 {
1102     if( ctb & 0x40 )
1103         return write_new_header( out, ctb, len, hdrlen );
1104
1105     if( hdrlen ) {
1106         if( !len )
1107             ctb |= 3;
1108         else if( hdrlen == 2 && len < 256 )
1109             ;
1110         else if( hdrlen == 3 && len < 65536 )
1111             ctb |= 1;
1112         else
1113             ctb |= 2;
1114     }
1115     else {
1116         if( !len )
1117             ctb |= 3;
1118         else if( len < 256 )
1119             ;
1120         else if( len < 65536 )
1121             ctb |= 1;
1122         else
1123             ctb |= 2;
1124     }
1125     if( iobuf_put(out, ctb ) )
1126         return -1;
1127     if( !len ) {
1128         if( blkmode )
1129             iobuf_set_block_mode(out, 8196 );
1130     }
1131     else {
1132         if( ctb & 2 ) {
1133             iobuf_put(out, len >> 24 );
1134             iobuf_put(out, len >> 16 );
1135         }
1136         if( ctb & 3 )
1137             iobuf_put(out, len >> 8 );
1138         if( iobuf_put(out, len ) )
1139             return -1;
1140     }
1141     return 0;
1142 }
1143
1144
1145 static int
1146 write_new_header( iobuf_t out, int ctb, u32 len, int hdrlen )
1147 {
1148     if( hdrlen )
1149         log_bug("can't cope with hdrlen yet\n");
1150
1151     if( iobuf_put(out, ctb ) )
1152         return -1;
1153     if( !len ) {
1154         iobuf_set_partial_block_mode(out, 512 );
1155     }
1156     else {
1157         if( len < 192 ) {
1158             if( iobuf_put(out, len ) )
1159                 return -1;
1160         }
1161         else if( len < 8384 ) {
1162             len -= 192;
1163             if( iobuf_put( out, (len / 256) + 192) )
1164                 return -1;
1165             if( iobuf_put( out, (len % 256) )  )
1166                 return -1;
1167         }
1168         else {
1169             if( iobuf_put( out, 0xff ) )
1170                 return -1;
1171             if( iobuf_put( out, (len >> 24)&0xff ) )
1172                 return -1;
1173             if( iobuf_put( out, (len >> 16)&0xff ) )
1174                 return -1;
1175             if( iobuf_put( out, (len >> 8)&0xff )  )
1176                 return -1;
1177             if( iobuf_put( out, len & 0xff ) )
1178                 return -1;
1179         }
1180     }
1181     return 0;
1182 }
1183
1184 static int
1185 write_version( iobuf_t out, int ctb )
1186 {
1187     if( iobuf_put( out, 3 ) )
1188         return -1;
1189     return 0;
1190 }