af97be423c3b83b2df6da4504502843f8c4bac08
[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 "packet.h"
29 #include "errors.h"
30 #include "iobuf.h"
31 #include "mpi.h"
32 #include "util.h"
33 #include "cipher.h"
34 #include "memory.h"
35 #include "options.h"
36
37
38 static int do_comment( IOBUF out, int ctb, PKT_comment *rem );
39 static int do_user_id( IOBUF out, int ctb, PKT_user_id *uid );
40 static int do_public_key( IOBUF out, int ctb, PKT_public_key *pk );
41 static int do_secret_key( IOBUF out, int ctb, PKT_secret_key *pk );
42 static int do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc );
43 static int do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc );
44 static u32 calc_plaintext( PKT_plaintext *pt );
45 static int do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt );
46 static int do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed );
47 static int do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed );
48 static int do_compressed( IOBUF out, int ctb, PKT_compressed *cd );
49 static int do_signature( IOBUF out, int ctb, PKT_signature *sig );
50 static int do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops );
51
52 static int calc_header_length( u32 len, int new_ctb );
53 static int write_16(IOBUF inp, u16 a);
54 static int write_32(IOBUF inp, u32 a);
55 static int write_header( IOBUF out, int ctb, u32 len );
56 static int write_sign_packet_header( IOBUF out, int ctb, u32 len );
57 static int write_header2( IOBUF out, int ctb, u32 len, int hdrlen, int blkmode );
58 static int write_new_header( IOBUF out, int ctb, u32 len, int hdrlen );
59 static int write_version( IOBUF out, int ctb );
60
61 /****************
62  * Build a packet and write it to INP
63  * Returns: 0 := okay
64  *         >0 := error
65  * Note: Caller must free the packet
66  */
67 int
68 build_packet( IOBUF out, PACKET *pkt )
69 {
70     int new_ctb=0, rc=0, ctb;
71     int pkttype;
72
73     if( DBG_PACKET )
74         log_debug("build_packet() type=%d\n", pkt->pkttype );
75     assert( pkt->pkt.generic );
76
77     switch( (pkttype = pkt->pkttype) ) {
78       case PKT_OLD_COMMENT: pkttype = pkt->pkttype = PKT_COMMENT; break;
79       case PKT_PLAINTEXT: new_ctb = pkt->pkt.plaintext->new_ctb; break;
80       case PKT_ENCRYPTED:
81       case PKT_ENCRYPTED_MDC: new_ctb = pkt->pkt.encrypted->new_ctb; break;
82       case PKT_COMPRESSED:new_ctb = pkt->pkt.compressed->new_ctb; break;
83       case PKT_USER_ID:
84             if( pkt->pkt.user_id->attrib_data )
85                 pkttype = PKT_ATTRIBUTE;
86             break;
87       default: break;
88     }
89
90     if( new_ctb || pkttype > 15 ) /* new format */
91         ctb = 0xc0 | (pkttype & 0x3f);
92     else
93         ctb = 0x80 | ((pkttype & 15)<<2);
94     switch( pkttype ) {
95       case PKT_ATTRIBUTE:
96       case PKT_USER_ID:
97         rc = do_user_id( out, ctb, pkt->pkt.user_id );
98         break;
99       case PKT_COMMENT:
100         rc = do_comment( out, ctb, pkt->pkt.comment );
101         break;
102       case PKT_PUBLIC_SUBKEY:
103       case PKT_PUBLIC_KEY:
104         rc = do_public_key( out, ctb, pkt->pkt.public_key );
105         break;
106       case PKT_SECRET_SUBKEY:
107       case PKT_SECRET_KEY:
108         rc = do_secret_key( out, ctb, pkt->pkt.secret_key );
109         break;
110       case PKT_SYMKEY_ENC:
111         rc = do_symkey_enc( out, ctb, pkt->pkt.symkey_enc );
112         break;
113       case PKT_PUBKEY_ENC:
114         rc = do_pubkey_enc( out, ctb, pkt->pkt.pubkey_enc );
115         break;
116       case PKT_PLAINTEXT:
117         rc = do_plaintext( out, ctb, pkt->pkt.plaintext );
118         break;
119       case PKT_ENCRYPTED:
120         rc = do_encrypted( out, ctb, pkt->pkt.encrypted );
121         break;
122       case PKT_ENCRYPTED_MDC:
123         rc = do_encrypted_mdc( out, ctb, pkt->pkt.encrypted );
124         break;
125       case PKT_COMPRESSED:
126         rc = do_compressed( out, ctb, pkt->pkt.compressed );
127         break;
128       case PKT_SIGNATURE:
129         rc = do_signature( out, ctb, pkt->pkt.signature );
130         break;
131       case PKT_ONEPASS_SIG:
132         rc = do_onepass_sig( out, ctb, pkt->pkt.onepass_sig );
133         break;
134       case PKT_RING_TRUST:
135         break; /* ignore it (keyring.c does write it directly)*/
136       case PKT_MDC: /* we write it directly, so we should never see it here. */
137       default:
138         log_bug("invalid packet type in build_packet()\n");
139         break;
140     }
141
142     return rc;
143 }
144
145 /****************
146  * calculate the length of a packet described by PKT
147  */
148 u32
149 calc_packet_length( PACKET *pkt )
150 {
151     u32 n=0;
152     int new_ctb = 0;
153
154     assert( pkt->pkt.generic );
155     switch( pkt->pkttype ) {
156       case PKT_PLAINTEXT:
157         n = calc_plaintext( pkt->pkt.plaintext );
158         new_ctb = pkt->pkt.plaintext->new_ctb;
159         break;
160       case PKT_ATTRIBUTE:
161       case PKT_USER_ID:
162       case PKT_COMMENT:
163       case PKT_PUBLIC_KEY:
164       case PKT_SECRET_KEY:
165       case PKT_SYMKEY_ENC:
166       case PKT_PUBKEY_ENC:
167       case PKT_ENCRYPTED:
168       case PKT_SIGNATURE:
169       case PKT_ONEPASS_SIG:
170       case PKT_RING_TRUST:
171       case PKT_COMPRESSED:
172       default:
173         log_bug("invalid packet type in calc_packet_length()");
174         break;
175     }
176
177     n += calc_header_length(n, new_ctb);
178     return n;
179 }
180
181 static void
182 write_fake_data( IOBUF out, MPI a )
183 {
184     if( a ) {
185         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         write_header(out, ctb, rem->len);
199         if( iobuf_write( out, rem->data, rem->len ) )
200             return G10ERR_WRITE_FILE;
201     }
202     return 0;
203 }
204
205 static int
206 do_user_id( IOBUF out, int ctb, PKT_user_id *uid )
207 {
208     if( uid->attrib_data ) {
209         write_header(out, ctb, uid->attrib_len);
210         if( iobuf_write( out, uid->attrib_data, uid->attrib_len ) )
211             return G10ERR_WRITE_FILE;
212     }
213     else {
214         write_header(out, ctb, uid->len);
215         if( iobuf_write( out, uid->name, uid->len ) )
216             return G10ERR_WRITE_FILE;
217     }
218     return 0;
219 }
220
221 static int
222 do_public_key( IOBUF out, int ctb, PKT_public_key *pk )
223 {
224     int rc = 0;
225     int n, i;
226     IOBUF a = iobuf_temp();
227
228     if( !pk->version )
229         iobuf_put( a, 3 );
230     else
231         iobuf_put( a, pk->version );
232     write_32(a, pk->timestamp );
233     if( pk->version < 4 ) {
234         u16 ndays;
235         if( pk->expiredate )
236             ndays = (u16)((pk->expiredate - pk->timestamp) / 86400L);
237         else
238             ndays = 0;
239         write_16(a, ndays );
240     }
241     iobuf_put(a, pk->pubkey_algo );
242     n = pubkey_get_npkey( pk->pubkey_algo );
243     if( !n )
244         write_fake_data( a, pk->pkey[0] );
245     for(i=0; i < n; i++ )
246         mpi_write(a, pk->pkey[i] );
247
248     write_header2(out, ctb, iobuf_get_temp_length(a), pk->hdrbytes, 1 );
249     if( iobuf_write_temp( out, a ) )
250         rc = G10ERR_WRITE_FILE;
251
252     iobuf_close(a);
253     return rc;
254 }
255
256
257 /****************
258  * Make a hash value from the public key certificate
259  */
260 void
261 hash_public_key( MD_HANDLE md, PKT_public_key *pk )
262 {
263     PACKET pkt;
264     int rc = 0;
265     int ctb;
266     ulong pktlen;
267     int c;
268     IOBUF a = iobuf_temp();
269 #if 0
270     FILE *fp = fopen("dump.pk", "a");
271     int i=0;
272
273     fprintf(fp, "\nHashing PK (v%d):\n", pk->version);
274 #endif
275
276     /* build the packet */
277     init_packet(&pkt);
278     pkt.pkttype = PKT_PUBLIC_KEY;
279     pkt.pkt.public_key = pk;
280     if( (rc = build_packet( a, &pkt )) )
281         log_fatal("build public_key for hashing failed: %s\n", g10_errstr(rc));
282
283     if( !(pk->version == 3 && pk->pubkey_algo == 16) ) {
284         /* skip the constructed header but don't do this for our very old
285          * v3 ElG keys */
286         ctb = iobuf_get_noeof(a);
287         pktlen = 0;
288         if( (ctb & 0x40) ) {
289             c = iobuf_get_noeof(a);
290             if( c < 192 )
291                 pktlen = c;
292             else if( c < 224 ) {
293                 pktlen = (c - 192) * 256;
294                 c = iobuf_get_noeof(a);
295                 pktlen += c + 192;
296             }
297             else if( c == 255 ) {
298                 pktlen  = iobuf_get_noeof(a) << 24;
299                 pktlen |= iobuf_get_noeof(a) << 16;
300                 pktlen |= iobuf_get_noeof(a) << 8;
301                 pktlen |= iobuf_get_noeof(a);
302             }
303         }
304         else {
305             int lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
306             for( ; lenbytes; lenbytes-- ) {
307                 pktlen <<= 8;
308                 pktlen |= iobuf_get_noeof(a);
309             }
310         }
311         /* hash a header */
312         md_putc( md, 0x99 );
313         pktlen &= 0xffff; /* can't handle longer packets */
314         md_putc( md, pktlen >> 8 );
315         md_putc( md, pktlen & 0xff );
316     }
317     /* hash the packet body */
318     while( (c=iobuf_get(a)) != -1 ) {
319 #if 0
320         fprintf( fp," %02x", c );
321         if( (++i == 24) ) {
322             putc('\n', fp);
323             i=0;
324         }
325 #endif
326         md_putc( md, c );
327     }
328 #if 0
329     putc('\n', fp);
330     fclose(fp);
331 #endif
332     iobuf_cancel(a);
333 }
334
335
336 static int
337 do_secret_key( IOBUF out, int ctb, PKT_secret_key *sk )
338 {
339     int rc = 0;
340     int i, nskey, npkey;
341     IOBUF a = iobuf_temp(); /* build in a self-enlarging buffer */
342
343     /* Write the version number - if none is specified, use 3 */
344     if( !sk->version )
345         iobuf_put( a, 3 );
346     else
347         iobuf_put( a, sk->version );
348     write_32(a, sk->timestamp );
349
350     /* v3  needs the expiration time */
351     if( sk->version < 4 ) {
352         u16 ndays;
353         if( sk->expiredate )
354             ndays = (u16)((sk->expiredate - sk->timestamp) / 86400L);
355         else
356             ndays = 0;
357         write_16(a, ndays);
358     }
359
360     iobuf_put(a, sk->pubkey_algo );
361
362     /* get number of secret and public parameters.  They are held in
363        one array first the public ones, then the secret ones */
364     nskey = pubkey_get_nskey( sk->pubkey_algo );
365     npkey = pubkey_get_npkey( sk->pubkey_algo );
366
367     /* If we don't have any public parameters - which is the case if
368        we don't know the algorithm used - the parameters are stored as
369        one blob in a faked (opaque) MPI */
370     if( !npkey ) {
371         write_fake_data( a, sk->skey[0] );
372         goto leave;
373     }
374     assert( npkey < nskey );
375
376     /* Writing the public parameters is easy */
377     for(i=0; i < npkey; i++ )
378         mpi_write(a, sk->skey[i] );
379
380     /* build the header for protected (encrypted) secret parameters */
381     if( sk->is_protected ) {
382         if( is_RSA(sk->pubkey_algo) && sk->version < 4
383                                     && !sk->protect.s2k.mode ) {
384             /* the simple rfc1991 (v3) way */
385             iobuf_put(a, sk->protect.algo );
386             iobuf_write(a, sk->protect.iv, sk->protect.ivlen );
387         }
388         else {
389           /* OpenPGP protection according to rfc2440 */
390             iobuf_put(a, sk->protect.sha1chk? 0xfe : 0xff );
391             iobuf_put(a, sk->protect.algo );
392             if( sk->protect.s2k.mode >= 1000 ) {
393                 /* These modes are not possible in OpenPGP, we use them
394                    to implement our extensions, 101 can be seen as a
395                    private/experimental extension (this is not
396                    specified in rfc2440 but the same scheme is used
397                    for all other algorithm identifiers) */
398                 iobuf_put(a, 101 ); 
399                 iobuf_put(a, sk->protect.s2k.hash_algo );
400                 iobuf_write(a, "GNU", 3 );
401                 iobuf_put(a, sk->protect.s2k.mode - 1000 );
402             }
403             else {
404                 iobuf_put(a, sk->protect.s2k.mode );
405                 iobuf_put(a, sk->protect.s2k.hash_algo );
406             }
407             if( sk->protect.s2k.mode == 1
408                 || sk->protect.s2k.mode == 3 )
409                 iobuf_write(a, sk->protect.s2k.salt, 8 );
410             if( sk->protect.s2k.mode == 3 )
411                 iobuf_put(a, sk->protect.s2k.count ); 
412
413             /* For out special mode 1001 we do not need an IV */
414             if( sk->protect.s2k.mode != 1001 )
415                 iobuf_write(a, sk->protect.iv, sk->protect.ivlen );
416         }
417     }
418     else
419         iobuf_put(a, 0 );
420
421     if( sk->protect.s2k.mode == 1001 )
422         ; /* GnuPG extension - don't write a secret key at all */ 
423     else if( sk->is_protected && sk->version >= 4 ) {
424         /* The secret key is protected - write it out as it is */
425         byte *p;
426         assert( mpi_is_opaque( sk->skey[npkey] ) );
427         p = mpi_get_opaque( sk->skey[npkey], &i );
428         iobuf_write(a, p, i );
429     }
430     else if( sk->is_protected ) {
431         /* The secret key is protected te old v4 way. */
432         for(   ; i < nskey; i++ ) {
433             byte *p;
434             int ndata;
435
436             assert (mpi_is_opaque (sk->skey[i]));
437             p = mpi_get_opaque (sk->skey[i], &ndata);
438             iobuf_write (a, p, ndata);
439         }
440         write_16(a, sk->csum );
441     }
442     else {
443         /* non-protected key */
444         for(   ; i < nskey; i++ )
445             mpi_write(a, sk->skey[i] );
446         write_16(a, sk->csum );
447     }
448
449   leave:
450     /* Build the header of the packet - which we must do after writing all
451        the other stuff, so that we know the length of the packet */
452     write_header2(out, ctb, iobuf_get_temp_length(a), sk->hdrbytes, 1 );
453     /* And finally write it out the real stream */
454     if( iobuf_write_temp( out, a ) )
455         rc = G10ERR_WRITE_FILE;
456
457     iobuf_close(a); /* close the remporary buffer */
458     return rc;
459 }
460
461 static int
462 do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
463 {
464     int rc = 0;
465     IOBUF a = iobuf_temp();
466
467     assert( enc->version == 4 );
468     switch( enc->s2k.mode ) {
469       case 0: case 1: case 3: break;
470       default: log_bug("do_symkey_enc: s2k=%d\n", enc->s2k.mode );
471     }
472     iobuf_put( a, enc->version );
473     iobuf_put( a, enc->cipher_algo );
474     iobuf_put( a, enc->s2k.mode );
475     iobuf_put( a, enc->s2k.hash_algo );
476     if( enc->s2k.mode == 1 || enc->s2k.mode == 3 ) {
477         iobuf_write(a, enc->s2k.salt, 8 );
478         if( enc->s2k.mode == 3 )
479             iobuf_put(a, enc->s2k.count);
480     }
481     if( enc->seskeylen )
482         iobuf_write(a, enc->seskey, enc->seskeylen );
483
484     write_header(out, ctb, iobuf_get_temp_length(a) );
485     if( iobuf_write_temp( out, a ) )
486         rc = G10ERR_WRITE_FILE;
487
488     iobuf_close(a);
489     return rc;
490 }
491
492
493
494
495 static int
496 do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
497 {
498     int rc = 0;
499     int n, i;
500     IOBUF a = iobuf_temp();
501
502     write_version( a, ctb );
503     if( enc->throw_keyid ) {
504         write_32(a, 0 );  /* don't tell Eve who can decrypt the message */
505         write_32(a, 0 );
506     }
507     else {
508         write_32(a, enc->keyid[0] );
509         write_32(a, enc->keyid[1] );
510     }
511     iobuf_put(a,enc->pubkey_algo );
512     n = pubkey_get_nenc( enc->pubkey_algo );
513     if( !n )
514         write_fake_data( a, enc->data[0] );
515     for(i=0; i < n; i++ )
516         mpi_write(a, enc->data[i] );
517
518     write_header(out, ctb, iobuf_get_temp_length(a) );
519     if( iobuf_write_temp( out, a ) )
520         rc = G10ERR_WRITE_FILE;
521
522     iobuf_close(a);
523     return rc;
524 }
525
526
527
528
529 static u32
530 calc_plaintext( PKT_plaintext *pt )
531 {
532     return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
533 }
534
535 static int
536 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
537 {
538     int i, rc = 0;
539     u32 n;
540     byte buf[1000]; /* this buffer has the plaintext! */
541     int nbytes;
542
543     /* Truncate namelen to the maximum 255 characters.  This does mean
544        that a function that calls build_packet with an illegal literal
545        packet will get it back legalized. */
546     if(pt->namelen>255)
547       pt->namelen=255;
548
549     write_header(out, ctb, calc_plaintext( pt ) );
550     iobuf_put(out, pt->mode );
551     iobuf_put(out, pt->namelen );
552     for(i=0; i < pt->namelen; i++ )
553         iobuf_put(out, pt->name[i] );
554     if( write_32(out, pt->timestamp ) )
555         rc = G10ERR_WRITE_FILE;
556
557     n = 0;
558     while( (nbytes=iobuf_read(pt->buf, buf, 1000)) != -1 ) {
559         if( iobuf_write(out, buf, nbytes) == -1 ) {
560             rc = G10ERR_WRITE_FILE;
561             break;
562         }
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 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 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 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_PREF_KS:
751         sig->flags.pref_ks=1;
752         break;
753
754       case SIGSUBPKT_EXPORTABLE:
755         if(buffer[0])
756           sig->flags.exportable=1;
757         else
758           sig->flags.exportable=0;
759         break;
760
761       case SIGSUBPKT_REVOCABLE:
762         if(buffer[0])
763           sig->flags.revocable=1;
764         else
765           sig->flags.revocable=0;
766         break;
767
768       case SIGSUBPKT_TRUST:
769         sig->trust_depth=buffer[0];
770         sig->trust_value=buffer[1];
771         break;
772
773       case SIGSUBPKT_REGEXP:
774         sig->trust_regexp=buffer;
775         break;
776
777         /* This should never happen since we don't currently allow
778            creating such a subpacket, but just in case... */
779       case SIGSUBPKT_SIG_EXPIRE:
780         if(buffer_to_u32(buffer)+sig->timestamp<=make_timestamp())
781           sig->flags.expired=1;
782         else
783           sig->flags.expired=0;
784         break;
785
786       default:
787         break;
788       }
789
790     if( (buflen+1) >= 8384 )
791         nlen = 5; /* write 5 byte length header */
792     else if( (buflen+1) >= 192 )
793         nlen = 2; /* write 2 byte length header */
794     else
795         nlen = 1; /* just a 1 byte length header */
796
797     switch( type ) {
798         /* The issuer being unhashed is a historical oddity.  It
799            should work equally as well hashed.  Of course, if even an
800            unhashed issuer is tampered with, it makes it awfully hard
801            to verify the sig... */
802       case SIGSUBPKT_ISSUER:
803         hashed = 0;
804         break;
805       default: 
806         hashed = 1;
807         break;
808     }
809
810     if( critical )
811         type |= SIGSUBPKT_FLAG_CRITICAL;
812
813     oldarea = hashed? sig->hashed : sig->unhashed;
814
815     /* Calculate new size of the area and allocate */
816     n0 = oldarea? oldarea->len : 0;
817     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
818     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
819         newarea = oldarea;
820         /*log_debug ("updating area for type %d\n", type );*/
821     }
822     else if (oldarea) {
823         newarea = m_realloc (oldarea, sizeof (*newarea) + n - 1);
824         newarea->size = n;
825         /*log_debug ("reallocating area for type %d\n", type );*/
826     }
827     else {
828         newarea = m_alloc (sizeof (*newarea) + n - 1);
829         newarea->size = n;
830         /*log_debug ("allocating area for type %d\n", type );*/
831     }
832     newarea->len = n;
833
834     p = newarea->data + n0;
835     if (nlen == 5) {
836         *p++ = 255;
837         *p++ = (buflen+1) >> 24;
838         *p++ = (buflen+1) >> 16;
839         *p++ = (buflen+1) >>  8;
840         *p++ = (buflen+1);
841         *p++ = type;
842         memcpy (p, buffer, buflen);
843     }
844     else if (nlen == 2) {
845         *p++ = (buflen+1-192) / 256 + 192;
846         *p++ = (buflen+1-192) % 256;
847         *p++ = type;
848         memcpy (p, buffer, buflen);
849     }
850     else {
851         *p++ = buflen+1;
852         *p++ = type;
853         memcpy (p, buffer, buflen);
854     }
855
856     if (hashed) 
857         sig->hashed = newarea;
858     else
859         sig->unhashed = newarea;
860 }
861
862 /****************
863  * Put all the required stuff from SIG into subpackets of sig.
864  * Hmmm, should we delete those subpackets which are in a wrong area?
865  */
866 void
867 build_sig_subpkt_from_sig( PKT_signature *sig )
868 {
869     u32  u;
870     byte buf[8];
871
872     u = sig->keyid[0];
873     buf[0] = (u >> 24) & 0xff;
874     buf[1] = (u >> 16) & 0xff;
875     buf[2] = (u >>  8) & 0xff;
876     buf[3] = u & 0xff;
877     u = sig->keyid[1];
878     buf[4] = (u >> 24) & 0xff;
879     buf[5] = (u >> 16) & 0xff;
880     buf[6] = (u >>  8) & 0xff;
881     buf[7] = u & 0xff;
882     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
883
884     u = sig->timestamp;
885     buf[0] = (u >> 24) & 0xff;
886     buf[1] = (u >> 16) & 0xff;
887     buf[2] = (u >>  8) & 0xff;
888     buf[3] = u & 0xff;
889     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
890
891     if(sig->expiredate)
892       {
893         if(sig->expiredate>sig->timestamp)
894           u=sig->expiredate-sig->timestamp;
895         else
896           u=0;
897
898         buf[0] = (u >> 24) & 0xff;
899         buf[1] = (u >> 16) & 0xff;
900         buf[2] = (u >>  8) & 0xff;
901         buf[3] = u & 0xff;
902
903         /* Mark this CRITICAL, so if any implementation doesn't
904            understand sigs that can expire, it'll just disregard this
905            sig altogether. */
906
907         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
908                           buf, 4 );
909       }
910 }
911
912 void
913 build_attribute_subpkt(PKT_user_id *uid,byte type,
914                        const void *buf,u32 buflen,
915                        const void *header,u32 headerlen)
916 {
917   byte *attrib;
918   int idx;
919
920   if(1+headerlen+buflen>8383)
921     idx=5;
922   else if(1+headerlen+buflen>191)
923     idx=2;
924   else
925     idx=1;
926
927   /* realloc uid->attrib_data to the right size */
928
929   uid->attrib_data=m_realloc(uid->attrib_data,
930                              uid->attrib_len+idx+1+headerlen+buflen);
931
932   attrib=&uid->attrib_data[uid->attrib_len];
933
934   if(idx==5)
935     {
936       attrib[0]=255;
937       attrib[1]=(1+headerlen+buflen) >> 24;
938       attrib[2]=(1+headerlen+buflen) >> 16;
939       attrib[3]=(1+headerlen+buflen) >> 8;
940       attrib[4]=1+headerlen+buflen;
941     }
942   else if(idx==2)
943     {
944       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
945       attrib[1]=(1+headerlen+buflen-192) % 256;
946     }
947   else
948     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
949
950   attrib[idx++]=type;
951
952   /* Tack on our data at the end */
953
954   if(headerlen>0)
955     memcpy(&attrib[idx],header,headerlen);
956   memcpy(&attrib[idx+headerlen],buf,buflen);
957   uid->attrib_len+=idx+headerlen+buflen;
958 }
959
960 static int
961 do_signature( IOBUF out, int ctb, PKT_signature *sig )
962 {
963     int rc = 0;
964     int n, i;
965     IOBUF a = iobuf_temp();
966
967     if( !sig->version )
968         iobuf_put( a, 3 );
969     else
970         iobuf_put( a, sig->version );
971     if( sig->version < 4 )
972         iobuf_put(a, 5 ); /* constant */
973     iobuf_put(a, sig->sig_class );
974     if( sig->version < 4 ) {
975         write_32(a, sig->timestamp );
976         write_32(a, sig->keyid[0] );
977         write_32(a, sig->keyid[1] );
978     }
979     iobuf_put(a, sig->pubkey_algo );
980     iobuf_put(a, sig->digest_algo );
981     if( sig->version >= 4 ) {
982         size_t nn;
983         /* timestamp and keyid must have been packed into the
984          * subpackets prior to the call of this function, because
985          * these subpackets are hashed */
986         nn = sig->hashed? sig->hashed->len : 0;
987         write_16(a, nn);
988         if( nn )
989             iobuf_write( a, sig->hashed->data, nn );
990         nn = sig->unhashed? sig->unhashed->len : 0;
991         write_16(a, nn);
992         if( nn )
993             iobuf_write( a, sig->unhashed->data, nn );
994     }
995     iobuf_put(a, sig->digest_start[0] );
996     iobuf_put(a, sig->digest_start[1] );
997     n = pubkey_get_nsig( sig->pubkey_algo );
998     if( !n )
999         write_fake_data( a, sig->data[0] );
1000     for(i=0; i < n; i++ )
1001         mpi_write(a, sig->data[i] );
1002
1003     if( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1004         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1005     else
1006         write_header(out, ctb, iobuf_get_temp_length(a) );
1007     if( iobuf_write_temp( out, a ) )
1008         rc = G10ERR_WRITE_FILE;
1009
1010     iobuf_close(a);
1011     return rc;
1012 }
1013
1014
1015 static int
1016 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1017 {
1018     int rc = 0;
1019     IOBUF a = iobuf_temp();
1020
1021     write_version( a, ctb );
1022     iobuf_put(a, ops->sig_class );
1023     iobuf_put(a, ops->digest_algo );
1024     iobuf_put(a, ops->pubkey_algo );
1025     write_32(a, ops->keyid[0] );
1026     write_32(a, ops->keyid[1] );
1027     iobuf_put(a, ops->last );
1028
1029     write_header(out, ctb, iobuf_get_temp_length(a) );
1030     if( iobuf_write_temp( out, a ) )
1031         rc = G10ERR_WRITE_FILE;
1032
1033     iobuf_close(a);
1034     return rc;
1035 }
1036
1037
1038 static int
1039 write_16(IOBUF out, u16 a)
1040 {
1041     iobuf_put(out, a>>8);
1042     if( iobuf_put(out,a) )
1043         return -1;
1044     return 0;
1045 }
1046
1047 static int
1048 write_32(IOBUF out, u32 a)
1049 {
1050     iobuf_put(out, a>> 24);
1051     iobuf_put(out, a>> 16);
1052     iobuf_put(out, a>> 8);
1053     if( iobuf_put(out, a) )
1054         return -1;
1055     return 0;
1056 }
1057
1058
1059 /****************
1060  * calculate the length of a header
1061  */
1062 static int
1063 calc_header_length( u32 len, int new_ctb )
1064 {
1065     if( !len )
1066         return 1; /* only the ctb */
1067
1068     if( new_ctb ) {
1069         if( len < 192 )
1070             return 2;
1071         if( len < 8384 )
1072             return 3;
1073         else
1074             return 6;
1075     }
1076     if( len < 256 )
1077         return 2;
1078     if( len < 65536 )
1079         return 3;
1080
1081     return 5;
1082 }
1083
1084 /****************
1085  * Write the CTB and the packet length
1086  */
1087 static int
1088 write_header( IOBUF out, int ctb, u32 len )
1089 {
1090     return write_header2( out, ctb, len, 0, 1 );
1091 }
1092
1093
1094 static int
1095 write_sign_packet_header( IOBUF out, int ctb, u32 len )
1096 {
1097     /* work around a bug in the pgp read function for signature packets,
1098      * which are not correctly coded and silently assume at some
1099      * point 2 byte length headers.*/
1100     iobuf_put(out, 0x89 );
1101     iobuf_put(out, len >> 8 );
1102     return iobuf_put(out, len ) == -1 ? -1:0;
1103 }
1104
1105 /****************
1106  * if HDRLEN is > 0, try to build a header of this length.
1107  * we need this, so that we can hash packets without reading them again.
1108  */
1109 static int
1110 write_header2( IOBUF out, int ctb, u32 len, int hdrlen, int blkmode )
1111 {
1112     if( ctb & 0x40 )
1113         return write_new_header( out, ctb, len, hdrlen );
1114
1115     if( hdrlen ) {
1116         if( !len )
1117             ctb |= 3;
1118         else if( hdrlen == 2 && len < 256 )
1119             ;
1120         else if( hdrlen == 3 && len < 65536 )
1121             ctb |= 1;
1122         else
1123             ctb |= 2;
1124     }
1125     else {
1126         if( !len )
1127             ctb |= 3;
1128         else if( len < 256 )
1129             ;
1130         else if( len < 65536 )
1131             ctb |= 1;
1132         else
1133             ctb |= 2;
1134     }
1135     if( iobuf_put(out, ctb ) )
1136         return -1;
1137     if( !len ) {
1138         if( blkmode )
1139             iobuf_set_block_mode(out, 8196 );
1140     }
1141     else {
1142         if( ctb & 2 ) {
1143             iobuf_put(out, len >> 24 );
1144             iobuf_put(out, len >> 16 );
1145         }
1146         if( ctb & 3 )
1147             iobuf_put(out, len >> 8 );
1148         if( iobuf_put(out, len ) )
1149             return -1;
1150     }
1151     return 0;
1152 }
1153
1154
1155 static int
1156 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1157 {
1158     if( hdrlen )
1159         log_bug("can't cope with hdrlen yet\n");
1160
1161     if( iobuf_put(out, ctb ) )
1162         return -1;
1163     if( !len ) {
1164         iobuf_set_partial_block_mode(out, 512 );
1165     }
1166     else {
1167         if( len < 192 ) {
1168             if( iobuf_put(out, len ) )
1169                 return -1;
1170         }
1171         else if( len < 8384 ) {
1172             len -= 192;
1173             if( iobuf_put( out, (len / 256) + 192) )
1174                 return -1;
1175             if( iobuf_put( out, (len % 256) )  )
1176                 return -1;
1177         }
1178         else {
1179             if( iobuf_put( out, 0xff ) )
1180                 return -1;
1181             if( iobuf_put( out, (len >> 24)&0xff ) )
1182                 return -1;
1183             if( iobuf_put( out, (len >> 16)&0xff ) )
1184                 return -1;
1185             if( iobuf_put( out, (len >> 8)&0xff )  )
1186                 return -1;
1187             if( iobuf_put( out, len & 0xff ) )
1188                 return -1;
1189         }
1190     }
1191     return 0;
1192 }
1193
1194 static int
1195 write_version( IOBUF out, int ctb )
1196 {
1197     if( iobuf_put( out, 3 ) )
1198         return -1;
1199     return 0;
1200 }