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