* keygen.c (do_add_key_flags, parse_parameter_usage): Add support
[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 modes 1001, 1002 we do not need an IV */
414             if( sk->protect.s2k.mode != 1001 
415               && sk->protect.s2k.mode != 1002 )
416                 iobuf_write(a, sk->protect.iv, sk->protect.ivlen );
417         }
418     }
419     else
420         iobuf_put(a, 0 );
421
422     if( sk->protect.s2k.mode == 1001 )
423         ; /* GnuPG extension - don't write a secret key at all */ 
424     else if( sk->protect.s2k.mode == 1002 )
425       {  /* GnuPG extension - divert to OpenPGP smartcard. */ 
426         iobuf_put(a, sk->protect.ivlen ); /* length of the serial
427                                              number or 0 for no serial
428                                              number. */
429         /* The serial number gets stored in the IV field. */
430         iobuf_write(a, sk->protect.iv, sk->protect.ivlen);
431       }
432     else if( sk->is_protected && sk->version >= 4 ) {
433         /* The secret key is protected - write it out as it is */
434         byte *p;
435         assert( mpi_is_opaque( sk->skey[npkey] ) );
436         p = mpi_get_opaque( sk->skey[npkey], &i );
437         iobuf_write(a, p, i );
438     }
439     else if( sk->is_protected ) {
440         /* The secret key is protected te old v4 way. */
441         for(   ; i < nskey; i++ ) {
442             byte *p;
443             int ndata;
444
445             assert (mpi_is_opaque (sk->skey[i]));
446             p = mpi_get_opaque (sk->skey[i], &ndata);
447             iobuf_write (a, p, ndata);
448         }
449         write_16(a, sk->csum );
450     }
451     else {
452         /* non-protected key */
453         for(   ; i < nskey; i++ )
454             mpi_write(a, sk->skey[i] );
455         write_16(a, sk->csum );
456     }
457
458   leave:
459     /* Build the header of the packet - which we must do after writing all
460        the other stuff, so that we know the length of the packet */
461     write_header2(out, ctb, iobuf_get_temp_length(a), sk->hdrbytes, 1 );
462     /* And finally write it out the real stream */
463     if( iobuf_write_temp( out, a ) )
464         rc = G10ERR_WRITE_FILE;
465
466     iobuf_close(a); /* close the remporary buffer */
467     return rc;
468 }
469
470 static int
471 do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
472 {
473     int rc = 0;
474     IOBUF a = iobuf_temp();
475
476     assert( enc->version == 4 );
477     switch( enc->s2k.mode ) {
478       case 0: case 1: case 3: break;
479       default: log_bug("do_symkey_enc: s2k=%d\n", enc->s2k.mode );
480     }
481     iobuf_put( a, enc->version );
482     iobuf_put( a, enc->cipher_algo );
483     iobuf_put( a, enc->s2k.mode );
484     iobuf_put( a, enc->s2k.hash_algo );
485     if( enc->s2k.mode == 1 || enc->s2k.mode == 3 ) {
486         iobuf_write(a, enc->s2k.salt, 8 );
487         if( enc->s2k.mode == 3 )
488             iobuf_put(a, enc->s2k.count);
489     }
490     if( enc->seskeylen )
491         iobuf_write(a, enc->seskey, enc->seskeylen );
492
493     write_header(out, ctb, iobuf_get_temp_length(a) );
494     if( iobuf_write_temp( out, a ) )
495         rc = G10ERR_WRITE_FILE;
496
497     iobuf_close(a);
498     return rc;
499 }
500
501
502
503
504 static int
505 do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
506 {
507     int rc = 0;
508     int n, i;
509     IOBUF a = iobuf_temp();
510
511     write_version( a, ctb );
512     if( enc->throw_keyid ) {
513         write_32(a, 0 );  /* don't tell Eve who can decrypt the message */
514         write_32(a, 0 );
515     }
516     else {
517         write_32(a, enc->keyid[0] );
518         write_32(a, enc->keyid[1] );
519     }
520     iobuf_put(a,enc->pubkey_algo );
521     n = pubkey_get_nenc( enc->pubkey_algo );
522     if( !n )
523         write_fake_data( a, enc->data[0] );
524     for(i=0; i < n; i++ )
525         mpi_write(a, enc->data[i] );
526
527     write_header(out, ctb, iobuf_get_temp_length(a) );
528     if( iobuf_write_temp( out, a ) )
529         rc = G10ERR_WRITE_FILE;
530
531     iobuf_close(a);
532     return rc;
533 }
534
535
536
537
538 static u32
539 calc_plaintext( PKT_plaintext *pt )
540 {
541     return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
542 }
543
544 static int
545 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
546 {
547     int i, rc = 0;
548     u32 n;
549     byte buf[1000]; /* this buffer has the plaintext! */
550     int nbytes;
551
552     /* Truncate namelen to the maximum 255 characters.  This does mean
553        that a function that calls build_packet with an illegal literal
554        packet will get it back legalized. */
555     if(pt->namelen>255)
556       pt->namelen=255;
557
558     write_header(out, ctb, calc_plaintext( pt ) );
559     iobuf_put(out, pt->mode );
560     iobuf_put(out, pt->namelen );
561     for(i=0; i < pt->namelen; i++ )
562         iobuf_put(out, pt->name[i] );
563     if( write_32(out, pt->timestamp ) )
564         rc = G10ERR_WRITE_FILE;
565
566     n = 0;
567     while( (nbytes=iobuf_read(pt->buf, buf, 1000)) != -1 ) {
568         if( iobuf_write(out, buf, nbytes) == -1 ) {
569             rc = G10ERR_WRITE_FILE;
570             break;
571         }
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 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 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 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_PREF_KS:
760         sig->flags.pref_ks=1;
761         break;
762
763       case SIGSUBPKT_EXPORTABLE:
764         if(buffer[0])
765           sig->flags.exportable=1;
766         else
767           sig->flags.exportable=0;
768         break;
769
770       case SIGSUBPKT_REVOCABLE:
771         if(buffer[0])
772           sig->flags.revocable=1;
773         else
774           sig->flags.revocable=0;
775         break;
776
777       case SIGSUBPKT_TRUST:
778         sig->trust_depth=buffer[0];
779         sig->trust_value=buffer[1];
780         break;
781
782       case SIGSUBPKT_REGEXP:
783         sig->trust_regexp=buffer;
784         break;
785
786         /* This should never happen since we don't currently allow
787            creating such a subpacket, but just in case... */
788       case SIGSUBPKT_SIG_EXPIRE:
789         if(buffer_to_u32(buffer)+sig->timestamp<=make_timestamp())
790           sig->flags.expired=1;
791         else
792           sig->flags.expired=0;
793         break;
794
795       default:
796         break;
797       }
798
799     if( (buflen+1) >= 8384 )
800         nlen = 5; /* write 5 byte length header */
801     else if( (buflen+1) >= 192 )
802         nlen = 2; /* write 2 byte length header */
803     else
804         nlen = 1; /* just a 1 byte length header */
805
806     switch( type ) {
807         /* The issuer being unhashed is a historical oddity.  It
808            should work equally as well hashed.  Of course, if even an
809            unhashed issuer is tampered with, it makes it awfully hard
810            to verify the sig... */
811       case SIGSUBPKT_ISSUER:
812         hashed = 0;
813         break;
814       default: 
815         hashed = 1;
816         break;
817     }
818
819     if( critical )
820         type |= SIGSUBPKT_FLAG_CRITICAL;
821
822     oldarea = hashed? sig->hashed : sig->unhashed;
823
824     /* Calculate new size of the area and allocate */
825     n0 = oldarea? oldarea->len : 0;
826     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
827     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
828         newarea = oldarea;
829         /*log_debug ("updating area for type %d\n", type );*/
830     }
831     else if (oldarea) {
832         newarea = m_realloc (oldarea, sizeof (*newarea) + n - 1);
833         newarea->size = n;
834         /*log_debug ("reallocating area for type %d\n", type );*/
835     }
836     else {
837         newarea = m_alloc (sizeof (*newarea) + n - 1);
838         newarea->size = n;
839         /*log_debug ("allocating area for type %d\n", type );*/
840     }
841     newarea->len = n;
842
843     p = newarea->data + n0;
844     if (nlen == 5) {
845         *p++ = 255;
846         *p++ = (buflen+1) >> 24;
847         *p++ = (buflen+1) >> 16;
848         *p++ = (buflen+1) >>  8;
849         *p++ = (buflen+1);
850         *p++ = type;
851         memcpy (p, buffer, buflen);
852     }
853     else if (nlen == 2) {
854         *p++ = (buflen+1-192) / 256 + 192;
855         *p++ = (buflen+1-192) % 256;
856         *p++ = type;
857         memcpy (p, buffer, buflen);
858     }
859     else {
860         *p++ = buflen+1;
861         *p++ = type;
862         memcpy (p, buffer, buflen);
863     }
864
865     if (hashed) 
866         sig->hashed = newarea;
867     else
868         sig->unhashed = newarea;
869 }
870
871 /****************
872  * Put all the required stuff from SIG into subpackets of sig.
873  * Hmmm, should we delete those subpackets which are in a wrong area?
874  */
875 void
876 build_sig_subpkt_from_sig( PKT_signature *sig )
877 {
878     u32  u;
879     byte buf[8];
880
881     u = sig->keyid[0];
882     buf[0] = (u >> 24) & 0xff;
883     buf[1] = (u >> 16) & 0xff;
884     buf[2] = (u >>  8) & 0xff;
885     buf[3] = u & 0xff;
886     u = sig->keyid[1];
887     buf[4] = (u >> 24) & 0xff;
888     buf[5] = (u >> 16) & 0xff;
889     buf[6] = (u >>  8) & 0xff;
890     buf[7] = u & 0xff;
891     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
892
893     u = sig->timestamp;
894     buf[0] = (u >> 24) & 0xff;
895     buf[1] = (u >> 16) & 0xff;
896     buf[2] = (u >>  8) & 0xff;
897     buf[3] = u & 0xff;
898     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
899
900     if(sig->expiredate)
901       {
902         if(sig->expiredate>sig->timestamp)
903           u=sig->expiredate-sig->timestamp;
904         else
905           u=0;
906
907         buf[0] = (u >> 24) & 0xff;
908         buf[1] = (u >> 16) & 0xff;
909         buf[2] = (u >>  8) & 0xff;
910         buf[3] = u & 0xff;
911
912         /* Mark this CRITICAL, so if any implementation doesn't
913            understand sigs that can expire, it'll just disregard this
914            sig altogether. */
915
916         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
917                           buf, 4 );
918       }
919 }
920
921 void
922 build_attribute_subpkt(PKT_user_id *uid,byte type,
923                        const void *buf,u32 buflen,
924                        const void *header,u32 headerlen)
925 {
926   byte *attrib;
927   int idx;
928
929   if(1+headerlen+buflen>8383)
930     idx=5;
931   else if(1+headerlen+buflen>191)
932     idx=2;
933   else
934     idx=1;
935
936   /* realloc uid->attrib_data to the right size */
937
938   uid->attrib_data=m_realloc(uid->attrib_data,
939                              uid->attrib_len+idx+1+headerlen+buflen);
940
941   attrib=&uid->attrib_data[uid->attrib_len];
942
943   if(idx==5)
944     {
945       attrib[0]=255;
946       attrib[1]=(1+headerlen+buflen) >> 24;
947       attrib[2]=(1+headerlen+buflen) >> 16;
948       attrib[3]=(1+headerlen+buflen) >> 8;
949       attrib[4]=1+headerlen+buflen;
950     }
951   else if(idx==2)
952     {
953       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
954       attrib[1]=(1+headerlen+buflen-192) % 256;
955     }
956   else
957     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
958
959   attrib[idx++]=type;
960
961   /* Tack on our data at the end */
962
963   if(headerlen>0)
964     memcpy(&attrib[idx],header,headerlen);
965   memcpy(&attrib[idx+headerlen],buf,buflen);
966   uid->attrib_len+=idx+headerlen+buflen;
967 }
968
969 static int
970 do_signature( IOBUF out, int ctb, PKT_signature *sig )
971 {
972     int rc = 0;
973     int n, i;
974     IOBUF a = iobuf_temp();
975
976     if( !sig->version )
977         iobuf_put( a, 3 );
978     else
979         iobuf_put( a, sig->version );
980     if( sig->version < 4 )
981         iobuf_put(a, 5 ); /* constant */
982     iobuf_put(a, sig->sig_class );
983     if( sig->version < 4 ) {
984         write_32(a, sig->timestamp );
985         write_32(a, sig->keyid[0] );
986         write_32(a, sig->keyid[1] );
987     }
988     iobuf_put(a, sig->pubkey_algo );
989     iobuf_put(a, sig->digest_algo );
990     if( sig->version >= 4 ) {
991         size_t nn;
992         /* timestamp and keyid must have been packed into the
993          * subpackets prior to the call of this function, because
994          * these subpackets are hashed */
995         nn = sig->hashed? sig->hashed->len : 0;
996         write_16(a, nn);
997         if( nn )
998             iobuf_write( a, sig->hashed->data, nn );
999         nn = sig->unhashed? sig->unhashed->len : 0;
1000         write_16(a, nn);
1001         if( nn )
1002             iobuf_write( a, sig->unhashed->data, nn );
1003     }
1004     iobuf_put(a, sig->digest_start[0] );
1005     iobuf_put(a, sig->digest_start[1] );
1006     n = pubkey_get_nsig( sig->pubkey_algo );
1007     if( !n )
1008         write_fake_data( a, sig->data[0] );
1009     for(i=0; i < n; i++ )
1010         mpi_write(a, sig->data[i] );
1011
1012     if( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1013         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1014     else
1015         write_header(out, ctb, iobuf_get_temp_length(a) );
1016     if( iobuf_write_temp( out, a ) )
1017         rc = G10ERR_WRITE_FILE;
1018
1019     iobuf_close(a);
1020     return rc;
1021 }
1022
1023
1024 static int
1025 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1026 {
1027     int rc = 0;
1028     IOBUF a = iobuf_temp();
1029
1030     write_version( a, ctb );
1031     iobuf_put(a, ops->sig_class );
1032     iobuf_put(a, ops->digest_algo );
1033     iobuf_put(a, ops->pubkey_algo );
1034     write_32(a, ops->keyid[0] );
1035     write_32(a, ops->keyid[1] );
1036     iobuf_put(a, ops->last );
1037
1038     write_header(out, ctb, iobuf_get_temp_length(a) );
1039     if( iobuf_write_temp( out, a ) )
1040         rc = G10ERR_WRITE_FILE;
1041
1042     iobuf_close(a);
1043     return rc;
1044 }
1045
1046
1047 static int
1048 write_16(IOBUF out, u16 a)
1049 {
1050     iobuf_put(out, a>>8);
1051     if( iobuf_put(out,a) )
1052         return -1;
1053     return 0;
1054 }
1055
1056 static int
1057 write_32(IOBUF out, u32 a)
1058 {
1059     iobuf_put(out, a>> 24);
1060     iobuf_put(out, a>> 16);
1061     iobuf_put(out, a>> 8);
1062     if( iobuf_put(out, a) )
1063         return -1;
1064     return 0;
1065 }
1066
1067
1068 /****************
1069  * calculate the length of a header
1070  */
1071 static int
1072 calc_header_length( u32 len, int new_ctb )
1073 {
1074     if( !len )
1075         return 1; /* only the ctb */
1076
1077     if( new_ctb ) {
1078         if( len < 192 )
1079             return 2;
1080         if( len < 8384 )
1081             return 3;
1082         else
1083             return 6;
1084     }
1085     if( len < 256 )
1086         return 2;
1087     if( len < 65536 )
1088         return 3;
1089
1090     return 5;
1091 }
1092
1093 /****************
1094  * Write the CTB and the packet length
1095  */
1096 static int
1097 write_header( IOBUF out, int ctb, u32 len )
1098 {
1099     return write_header2( out, ctb, len, 0, 1 );
1100 }
1101
1102
1103 static int
1104 write_sign_packet_header( IOBUF out, int ctb, u32 len )
1105 {
1106     /* work around a bug in the pgp read function for signature packets,
1107      * which are not correctly coded and silently assume at some
1108      * point 2 byte length headers.*/
1109     iobuf_put(out, 0x89 );
1110     iobuf_put(out, len >> 8 );
1111     return iobuf_put(out, len ) == -1 ? -1:0;
1112 }
1113
1114 /****************
1115  * if HDRLEN is > 0, try to build a header of this length.
1116  * we need this, so that we can hash packets without reading them again.
1117  */
1118 static int
1119 write_header2( IOBUF out, int ctb, u32 len, int hdrlen, int blkmode )
1120 {
1121     if( ctb & 0x40 )
1122         return write_new_header( out, ctb, len, hdrlen );
1123
1124     if( hdrlen ) {
1125         if( !len )
1126             ctb |= 3;
1127         else if( hdrlen == 2 && len < 256 )
1128             ;
1129         else if( hdrlen == 3 && len < 65536 )
1130             ctb |= 1;
1131         else
1132             ctb |= 2;
1133     }
1134     else {
1135         if( !len )
1136             ctb |= 3;
1137         else if( len < 256 )
1138             ;
1139         else if( len < 65536 )
1140             ctb |= 1;
1141         else
1142             ctb |= 2;
1143     }
1144     if( iobuf_put(out, ctb ) )
1145         return -1;
1146     if( !len ) {
1147         if( blkmode )
1148             iobuf_set_block_mode(out, 8196 );
1149     }
1150     else {
1151         if( ctb & 2 ) {
1152             iobuf_put(out, len >> 24 );
1153             iobuf_put(out, len >> 16 );
1154         }
1155         if( ctb & 3 )
1156             iobuf_put(out, len >> 8 );
1157         if( iobuf_put(out, len ) )
1158             return -1;
1159     }
1160     return 0;
1161 }
1162
1163
1164 static int
1165 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1166 {
1167     if( hdrlen )
1168         log_bug("can't cope with hdrlen yet\n");
1169
1170     if( iobuf_put(out, ctb ) )
1171         return -1;
1172     if( !len ) {
1173         iobuf_set_partial_block_mode(out, 512 );
1174     }
1175     else {
1176         if( len < 192 ) {
1177             if( iobuf_put(out, len ) )
1178                 return -1;
1179         }
1180         else if( len < 8384 ) {
1181             len -= 192;
1182             if( iobuf_put( out, (len / 256) + 192) )
1183                 return -1;
1184             if( iobuf_put( out, (len % 256) )  )
1185                 return -1;
1186         }
1187         else {
1188             if( iobuf_put( out, 0xff ) )
1189                 return -1;
1190             if( iobuf_put( out, (len >> 24)&0xff ) )
1191                 return -1;
1192             if( iobuf_put( out, (len >> 16)&0xff ) )
1193                 return -1;
1194             if( iobuf_put( out, (len >> 8)&0xff )  )
1195                 return -1;
1196             if( iobuf_put( out, len & 0xff ) )
1197                 return -1;
1198         }
1199     }
1200     return 0;
1201 }
1202
1203 static int
1204 write_version( IOBUF out, int ctb )
1205 {
1206     if( iobuf_put( out, 3 ) )
1207         return -1;
1208     return 0;
1209 }