* packet.h, build-packet.c (hash_public_key): Remove function ...
[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 static int
258 do_secret_key( IOBUF out, int ctb, PKT_secret_key *sk )
259 {
260     int rc = 0;
261     int i, nskey, npkey;
262     IOBUF a = iobuf_temp(); /* build in a self-enlarging buffer */
263
264     /* Write the version number - if none is specified, use 3 */
265     if( !sk->version )
266         iobuf_put( a, 3 );
267     else
268         iobuf_put( a, sk->version );
269     write_32(a, sk->timestamp );
270
271     /* v3  needs the expiration time */
272     if( sk->version < 4 ) {
273         u16 ndays;
274         if( sk->expiredate )
275             ndays = (u16)((sk->expiredate - sk->timestamp) / 86400L);
276         else
277             ndays = 0;
278         write_16(a, ndays);
279     }
280
281     iobuf_put(a, sk->pubkey_algo );
282
283     /* get number of secret and public parameters.  They are held in
284        one array first the public ones, then the secret ones */
285     nskey = pubkey_get_nskey( sk->pubkey_algo );
286     npkey = pubkey_get_npkey( sk->pubkey_algo );
287
288     /* If we don't have any public parameters - which is the case if
289        we don't know the algorithm used - the parameters are stored as
290        one blob in a faked (opaque) MPI */
291     if( !npkey ) {
292         write_fake_data( a, sk->skey[0] );
293         goto leave;
294     }
295     assert( npkey < nskey );
296
297     /* Writing the public parameters is easy */
298     for(i=0; i < npkey; i++ )
299         mpi_write(a, sk->skey[i] );
300
301     /* build the header for protected (encrypted) secret parameters */
302     if( sk->is_protected ) {
303         if( is_RSA(sk->pubkey_algo) && sk->version < 4
304                                     && !sk->protect.s2k.mode ) {
305             /* the simple rfc1991 (v3) way */
306             iobuf_put(a, sk->protect.algo );
307             iobuf_write(a, sk->protect.iv, sk->protect.ivlen );
308         }
309         else {
310           /* OpenPGP protection according to rfc2440 */
311             iobuf_put(a, sk->protect.sha1chk? 0xfe : 0xff );
312             iobuf_put(a, sk->protect.algo );
313             if( sk->protect.s2k.mode >= 1000 ) {
314                 /* These modes are not possible in OpenPGP, we use them
315                    to implement our extensions, 101 can be seen as a
316                    private/experimental extension (this is not
317                    specified in rfc2440 but the same scheme is used
318                    for all other algorithm identifiers) */
319                 iobuf_put(a, 101 ); 
320                 iobuf_put(a, sk->protect.s2k.hash_algo );
321                 iobuf_write(a, "GNU", 3 );
322                 iobuf_put(a, sk->protect.s2k.mode - 1000 );
323             }
324             else {
325                 iobuf_put(a, sk->protect.s2k.mode );
326                 iobuf_put(a, sk->protect.s2k.hash_algo );
327             }
328             if( sk->protect.s2k.mode == 1
329                 || sk->protect.s2k.mode == 3 )
330                 iobuf_write(a, sk->protect.s2k.salt, 8 );
331             if( sk->protect.s2k.mode == 3 )
332                 iobuf_put(a, sk->protect.s2k.count ); 
333
334             /* For out special modes 1001, 1002 we do not need an IV */
335             if( sk->protect.s2k.mode != 1001 
336               && sk->protect.s2k.mode != 1002 )
337                 iobuf_write(a, sk->protect.iv, sk->protect.ivlen );
338         }
339     }
340     else
341         iobuf_put(a, 0 );
342
343     if( sk->protect.s2k.mode == 1001 )
344         ; /* GnuPG extension - don't write a secret key at all */ 
345     else if( sk->protect.s2k.mode == 1002 )
346       {  /* GnuPG extension - divert to OpenPGP smartcard. */ 
347         iobuf_put(a, sk->protect.ivlen ); /* length of the serial
348                                              number or 0 for no serial
349                                              number. */
350         /* The serial number gets stored in the IV field. */
351         iobuf_write(a, sk->protect.iv, sk->protect.ivlen);
352       }
353     else if( sk->is_protected && sk->version >= 4 ) {
354         /* The secret key is protected - write it out as it is */
355         byte *p;
356         assert( mpi_is_opaque( sk->skey[npkey] ) );
357         p = mpi_get_opaque( sk->skey[npkey], &i );
358         iobuf_write(a, p, i );
359     }
360     else if( sk->is_protected ) {
361         /* The secret key is protected te old v4 way. */
362         for(   ; i < nskey; i++ ) {
363             byte *p;
364             int ndata;
365
366             assert (mpi_is_opaque (sk->skey[i]));
367             p = mpi_get_opaque (sk->skey[i], &ndata);
368             iobuf_write (a, p, ndata);
369         }
370         write_16(a, sk->csum );
371     }
372     else {
373         /* non-protected key */
374         for(   ; i < nskey; i++ )
375             mpi_write(a, sk->skey[i] );
376         write_16(a, sk->csum );
377     }
378
379   leave:
380     /* Build the header of the packet - which we must do after writing all
381        the other stuff, so that we know the length of the packet */
382     write_header2(out, ctb, iobuf_get_temp_length(a), sk->hdrbytes, 1 );
383     /* And finally write it out the real stream */
384     if( iobuf_write_temp( out, a ) )
385         rc = G10ERR_WRITE_FILE;
386
387     iobuf_close(a); /* close the remporary buffer */
388     return rc;
389 }
390
391 static int
392 do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
393 {
394     int rc = 0;
395     IOBUF a = iobuf_temp();
396
397     assert( enc->version == 4 );
398     switch( enc->s2k.mode ) {
399       case 0: case 1: case 3: break;
400       default: log_bug("do_symkey_enc: s2k=%d\n", enc->s2k.mode );
401     }
402     iobuf_put( a, enc->version );
403     iobuf_put( a, enc->cipher_algo );
404     iobuf_put( a, enc->s2k.mode );
405     iobuf_put( a, enc->s2k.hash_algo );
406     if( enc->s2k.mode == 1 || enc->s2k.mode == 3 ) {
407         iobuf_write(a, enc->s2k.salt, 8 );
408         if( enc->s2k.mode == 3 )
409             iobuf_put(a, enc->s2k.count);
410     }
411     if( enc->seskeylen )
412         iobuf_write(a, enc->seskey, enc->seskeylen );
413
414     write_header(out, ctb, iobuf_get_temp_length(a) );
415     if( iobuf_write_temp( out, a ) )
416         rc = G10ERR_WRITE_FILE;
417
418     iobuf_close(a);
419     return rc;
420 }
421
422
423
424
425 static int
426 do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
427 {
428     int rc = 0;
429     int n, i;
430     IOBUF a = iobuf_temp();
431
432     write_version( a, ctb );
433     if( enc->throw_keyid ) {
434         write_32(a, 0 );  /* don't tell Eve who can decrypt the message */
435         write_32(a, 0 );
436     }
437     else {
438         write_32(a, enc->keyid[0] );
439         write_32(a, enc->keyid[1] );
440     }
441     iobuf_put(a,enc->pubkey_algo );
442     n = pubkey_get_nenc( enc->pubkey_algo );
443     if( !n )
444         write_fake_data( a, enc->data[0] );
445     for(i=0; i < n; i++ )
446         mpi_write(a, enc->data[i] );
447
448     write_header(out, ctb, iobuf_get_temp_length(a) );
449     if( iobuf_write_temp( out, a ) )
450         rc = G10ERR_WRITE_FILE;
451
452     iobuf_close(a);
453     return rc;
454 }
455
456
457
458
459 static u32
460 calc_plaintext( PKT_plaintext *pt )
461 {
462     return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
463 }
464
465 static int
466 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
467 {
468     int i, rc = 0;
469     u32 n;
470     byte buf[1000]; /* this buffer has the plaintext! */
471     int nbytes;
472
473     /* Truncate namelen to the maximum 255 characters.  This does mean
474        that a function that calls build_packet with an illegal literal
475        packet will get it back legalized. */
476     if(pt->namelen>255)
477       pt->namelen=255;
478
479     write_header(out, ctb, calc_plaintext( pt ) );
480     iobuf_put(out, pt->mode );
481     iobuf_put(out, pt->namelen );
482     for(i=0; i < pt->namelen; i++ )
483         iobuf_put(out, pt->name[i] );
484     if( write_32(out, pt->timestamp ) )
485         rc = G10ERR_WRITE_FILE;
486
487     n = 0;
488     while( (nbytes=iobuf_read(pt->buf, buf, 1000)) != -1 ) {
489         if( iobuf_write(out, buf, nbytes) == -1 ) {
490             rc = G10ERR_WRITE_FILE;
491             break;
492         }
493         n += nbytes;
494     }
495     wipememory(buf,1000); /* burn the buffer */
496     if( !pt->len )
497         iobuf_set_block_mode(out, 0 ); /* write end marker */
498     else if( n != pt->len )
499         log_error("do_plaintext(): wrote %lu bytes but expected %lu bytes\n",
500                         (ulong)n, (ulong)pt->len );
501
502     return rc;
503 }
504
505
506
507 static int
508 do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
509 {
510     int rc = 0;
511     u32 n;
512
513     n = ed->len ? (ed->len + ed->extralen) : 0;
514     write_header(out, ctb, n );
515
516     /* This is all. The caller has to write the real data */
517
518     return rc;
519 }
520
521 static int
522 do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
523 {
524     int rc = 0;
525     u32 n;
526
527     assert( ed->mdc_method );
528
529     /* Take version number and the following MDC packet in account. */
530     n = ed->len ? (ed->len + ed->extralen + 1 + 22) : 0;
531     write_header(out, ctb, n );
532     iobuf_put(out, 1 );  /* version */
533
534     /* This is all. The caller has to write the real data */
535
536     return rc;
537 }
538
539
540 static int
541 do_compressed( IOBUF out, int ctb, PKT_compressed *cd )
542 {
543     int rc = 0;
544
545     /* We must use the old convention and don't use blockmode for tyhe
546        sake of PGP 2 compatibility.  However if the new_ctb flag was
547        set, CTB is already formatted as new style and write_header2
548        does create a partial length encoding using new the new
549        style. */
550     write_header2(out, ctb, 0, 0, 0 );
551     iobuf_put(out, cd->algorithm );
552
553     /* This is all. The caller has to write the real data */
554
555     return rc;
556 }
557
558
559 /****************
560  * Delete all subpackets of type REQTYPE and return a bool whether a packet
561  * was deleted.
562  */
563 int
564 delete_sig_subpkt (subpktarea_t *area, sigsubpkttype_t reqtype )
565 {
566     int buflen;
567     sigsubpkttype_t type;
568     byte *buffer, *bufstart;
569     size_t n;
570     size_t unused = 0;
571     int okay = 0;
572
573     if( !area )
574         return 0;
575     buflen = area->len;
576     buffer = area->data;
577     for(;;) {
578         if( !buflen ) {
579             okay = 1;
580             break;
581         }
582         bufstart = buffer;
583         n = *buffer++; buflen--;
584         if( n == 255 ) {
585             if( buflen < 4 )
586                 break;
587             n = (buffer[0] << 24) | (buffer[1] << 16)
588                 | (buffer[2] << 8) | buffer[3];
589             buffer += 4;
590             buflen -= 4;
591         }
592         else if( n >= 192 ) {
593             if( buflen < 2 )
594                 break;
595             n = (( n - 192 ) << 8) + *buffer + 192;
596             buffer++;
597             buflen--;
598         }
599         if( buflen < n )
600             break;
601         
602         type = *buffer & 0x7f;
603         if( type == reqtype ) {
604             buffer++;
605             buflen--;
606             n--;
607             if( n > buflen )
608                 break;
609             buffer += n; /* point to next subpkt */
610             buflen -= n;
611             memmove (bufstart, buffer, buflen); /* shift */
612             unused +=  buffer - bufstart;
613             buffer = bufstart;
614         }
615         else {
616             buffer += n; buflen -=n;
617         }
618     }
619
620     if (!okay)
621         log_error ("delete_subpkt: buffer shorter than subpacket\n");
622     assert (unused <= area->len);
623     area->len -= unused;
624     return !!unused;
625 }
626
627
628 /****************
629  * Create or update a signature subpacket for SIG of TYPE.  This
630  * functions knows where to put the data (hashed or unhashed).  The
631  * function may move data from the unhashed part to the hashed one.
632  * Note: All pointers into sig->[un]hashed (e.g. returned by
633  * parse_sig_subpkt) are not valid after a call to this function.  The
634  * data to put into the subpaket should be in a buffer with a length
635  * of buflen. 
636  */
637 void
638 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
639                   const byte *buffer, size_t buflen )
640 {
641     byte *p;
642     int critical, hashed;
643     subpktarea_t *oldarea, *newarea;
644     size_t nlen, n, n0;
645
646     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
647     type &= ~SIGSUBPKT_FLAG_CRITICAL;
648
649     /* Sanity check buffer sizes */
650     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
651       BUG();
652
653     switch(type)
654       {
655       case SIGSUBPKT_NOTATION:
656       case SIGSUBPKT_POLICY:
657       case SIGSUBPKT_REV_KEY:
658         /* we do allow multiple subpackets */
659         break;
660
661       default:
662         /* we don't allow multiple subpackets */
663         delete_sig_subpkt(sig->hashed,type);
664         delete_sig_subpkt(sig->unhashed,type);
665         break;
666       }
667
668     /* Any special magic that needs to be done for this type so the
669        packet doesn't need to be reparsed? */
670     switch(type)
671       {
672       case SIGSUBPKT_NOTATION:
673         sig->flags.notation=1;
674         break;
675
676       case SIGSUBPKT_POLICY:
677         sig->flags.policy_url=1;
678         break;
679
680       case SIGSUBPKT_PREF_KS:
681         sig->flags.pref_ks=1;
682         break;
683
684       case SIGSUBPKT_EXPORTABLE:
685         if(buffer[0])
686           sig->flags.exportable=1;
687         else
688           sig->flags.exportable=0;
689         break;
690
691       case SIGSUBPKT_REVOCABLE:
692         if(buffer[0])
693           sig->flags.revocable=1;
694         else
695           sig->flags.revocable=0;
696         break;
697
698       case SIGSUBPKT_TRUST:
699         sig->trust_depth=buffer[0];
700         sig->trust_value=buffer[1];
701         break;
702
703       case SIGSUBPKT_REGEXP:
704         sig->trust_regexp=buffer;
705         break;
706
707         /* This should never happen since we don't currently allow
708            creating such a subpacket, but just in case... */
709       case SIGSUBPKT_SIG_EXPIRE:
710         if(buffer_to_u32(buffer)+sig->timestamp<=make_timestamp())
711           sig->flags.expired=1;
712         else
713           sig->flags.expired=0;
714         break;
715
716       default:
717         break;
718       }
719
720     if( (buflen+1) >= 8384 )
721         nlen = 5; /* write 5 byte length header */
722     else if( (buflen+1) >= 192 )
723         nlen = 2; /* write 2 byte length header */
724     else
725         nlen = 1; /* just a 1 byte length header */
726
727     switch( type ) {
728         /* The issuer being unhashed is a historical oddity.  It
729            should work equally as well hashed.  Of course, if even an
730            unhashed issuer is tampered with, it makes it awfully hard
731            to verify the sig... */
732       case SIGSUBPKT_ISSUER:
733         hashed = 0;
734         break;
735       default: 
736         hashed = 1;
737         break;
738     }
739
740     if( critical )
741         type |= SIGSUBPKT_FLAG_CRITICAL;
742
743     oldarea = hashed? sig->hashed : sig->unhashed;
744
745     /* Calculate new size of the area and allocate */
746     n0 = oldarea? oldarea->len : 0;
747     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
748     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
749         newarea = oldarea;
750         /*log_debug ("updating area for type %d\n", type );*/
751     }
752     else if (oldarea) {
753         newarea = m_realloc (oldarea, sizeof (*newarea) + n - 1);
754         newarea->size = n;
755         /*log_debug ("reallocating area for type %d\n", type );*/
756     }
757     else {
758         newarea = m_alloc (sizeof (*newarea) + n - 1);
759         newarea->size = n;
760         /*log_debug ("allocating area for type %d\n", type );*/
761     }
762     newarea->len = n;
763
764     p = newarea->data + n0;
765     if (nlen == 5) {
766         *p++ = 255;
767         *p++ = (buflen+1) >> 24;
768         *p++ = (buflen+1) >> 16;
769         *p++ = (buflen+1) >>  8;
770         *p++ = (buflen+1);
771         *p++ = type;
772         memcpy (p, buffer, buflen);
773     }
774     else if (nlen == 2) {
775         *p++ = (buflen+1-192) / 256 + 192;
776         *p++ = (buflen+1-192) % 256;
777         *p++ = type;
778         memcpy (p, buffer, buflen);
779     }
780     else {
781         *p++ = buflen+1;
782         *p++ = type;
783         memcpy (p, buffer, buflen);
784     }
785
786     if (hashed) 
787         sig->hashed = newarea;
788     else
789         sig->unhashed = newarea;
790 }
791
792 /****************
793  * Put all the required stuff from SIG into subpackets of sig.
794  * Hmmm, should we delete those subpackets which are in a wrong area?
795  */
796 void
797 build_sig_subpkt_from_sig( PKT_signature *sig )
798 {
799     u32  u;
800     byte buf[8];
801
802     u = sig->keyid[0];
803     buf[0] = (u >> 24) & 0xff;
804     buf[1] = (u >> 16) & 0xff;
805     buf[2] = (u >>  8) & 0xff;
806     buf[3] = u & 0xff;
807     u = sig->keyid[1];
808     buf[4] = (u >> 24) & 0xff;
809     buf[5] = (u >> 16) & 0xff;
810     buf[6] = (u >>  8) & 0xff;
811     buf[7] = u & 0xff;
812     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
813
814     u = sig->timestamp;
815     buf[0] = (u >> 24) & 0xff;
816     buf[1] = (u >> 16) & 0xff;
817     buf[2] = (u >>  8) & 0xff;
818     buf[3] = u & 0xff;
819     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
820
821     if(sig->expiredate)
822       {
823         if(sig->expiredate>sig->timestamp)
824           u=sig->expiredate-sig->timestamp;
825         else
826           u=0;
827
828         buf[0] = (u >> 24) & 0xff;
829         buf[1] = (u >> 16) & 0xff;
830         buf[2] = (u >>  8) & 0xff;
831         buf[3] = u & 0xff;
832
833         /* Mark this CRITICAL, so if any implementation doesn't
834            understand sigs that can expire, it'll just disregard this
835            sig altogether. */
836
837         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
838                           buf, 4 );
839       }
840 }
841
842 void
843 build_attribute_subpkt(PKT_user_id *uid,byte type,
844                        const void *buf,u32 buflen,
845                        const void *header,u32 headerlen)
846 {
847   byte *attrib;
848   int idx;
849
850   if(1+headerlen+buflen>8383)
851     idx=5;
852   else if(1+headerlen+buflen>191)
853     idx=2;
854   else
855     idx=1;
856
857   /* realloc uid->attrib_data to the right size */
858
859   uid->attrib_data=m_realloc(uid->attrib_data,
860                              uid->attrib_len+idx+1+headerlen+buflen);
861
862   attrib=&uid->attrib_data[uid->attrib_len];
863
864   if(idx==5)
865     {
866       attrib[0]=255;
867       attrib[1]=(1+headerlen+buflen) >> 24;
868       attrib[2]=(1+headerlen+buflen) >> 16;
869       attrib[3]=(1+headerlen+buflen) >> 8;
870       attrib[4]=1+headerlen+buflen;
871     }
872   else if(idx==2)
873     {
874       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
875       attrib[1]=(1+headerlen+buflen-192) % 256;
876     }
877   else
878     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
879
880   attrib[idx++]=type;
881
882   /* Tack on our data at the end */
883
884   if(headerlen>0)
885     memcpy(&attrib[idx],header,headerlen);
886   memcpy(&attrib[idx+headerlen],buf,buflen);
887   uid->attrib_len+=idx+headerlen+buflen;
888 }
889
890 static int
891 do_signature( IOBUF out, int ctb, PKT_signature *sig )
892 {
893     int rc = 0;
894     int n, i;
895     IOBUF a = iobuf_temp();
896
897     if( !sig->version )
898         iobuf_put( a, 3 );
899     else
900         iobuf_put( a, sig->version );
901     if( sig->version < 4 )
902         iobuf_put(a, 5 ); /* constant */
903     iobuf_put(a, sig->sig_class );
904     if( sig->version < 4 ) {
905         write_32(a, sig->timestamp );
906         write_32(a, sig->keyid[0] );
907         write_32(a, sig->keyid[1] );
908     }
909     iobuf_put(a, sig->pubkey_algo );
910     iobuf_put(a, sig->digest_algo );
911     if( sig->version >= 4 ) {
912         size_t nn;
913         /* timestamp and keyid must have been packed into the
914          * subpackets prior to the call of this function, because
915          * these subpackets are hashed */
916         nn = sig->hashed? sig->hashed->len : 0;
917         write_16(a, nn);
918         if( nn )
919             iobuf_write( a, sig->hashed->data, nn );
920         nn = sig->unhashed? sig->unhashed->len : 0;
921         write_16(a, nn);
922         if( nn )
923             iobuf_write( a, sig->unhashed->data, nn );
924     }
925     iobuf_put(a, sig->digest_start[0] );
926     iobuf_put(a, sig->digest_start[1] );
927     n = pubkey_get_nsig( sig->pubkey_algo );
928     if( !n )
929         write_fake_data( a, sig->data[0] );
930     for(i=0; i < n; i++ )
931         mpi_write(a, sig->data[i] );
932
933     if( is_RSA(sig->pubkey_algo) && sig->version < 4 )
934         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
935     else
936         write_header(out, ctb, iobuf_get_temp_length(a) );
937     if( iobuf_write_temp( out, a ) )
938         rc = G10ERR_WRITE_FILE;
939
940     iobuf_close(a);
941     return rc;
942 }
943
944
945 static int
946 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
947 {
948     int rc = 0;
949     IOBUF a = iobuf_temp();
950
951     write_version( a, ctb );
952     iobuf_put(a, ops->sig_class );
953     iobuf_put(a, ops->digest_algo );
954     iobuf_put(a, ops->pubkey_algo );
955     write_32(a, ops->keyid[0] );
956     write_32(a, ops->keyid[1] );
957     iobuf_put(a, ops->last );
958
959     write_header(out, ctb, iobuf_get_temp_length(a) );
960     if( iobuf_write_temp( out, a ) )
961         rc = G10ERR_WRITE_FILE;
962
963     iobuf_close(a);
964     return rc;
965 }
966
967
968 static int
969 write_16(IOBUF out, u16 a)
970 {
971     iobuf_put(out, a>>8);
972     if( iobuf_put(out,a) )
973         return -1;
974     return 0;
975 }
976
977 static int
978 write_32(IOBUF out, u32 a)
979 {
980     iobuf_put(out, a>> 24);
981     iobuf_put(out, a>> 16);
982     iobuf_put(out, a>> 8);
983     if( iobuf_put(out, a) )
984         return -1;
985     return 0;
986 }
987
988
989 /****************
990  * calculate the length of a header
991  */
992 static int
993 calc_header_length( u32 len, int new_ctb )
994 {
995     if( !len )
996         return 1; /* only the ctb */
997
998     if( new_ctb ) {
999         if( len < 192 )
1000             return 2;
1001         if( len < 8384 )
1002             return 3;
1003         else
1004             return 6;
1005     }
1006     if( len < 256 )
1007         return 2;
1008     if( len < 65536 )
1009         return 3;
1010
1011     return 5;
1012 }
1013
1014 /****************
1015  * Write the CTB and the packet length
1016  */
1017 static int
1018 write_header( IOBUF out, int ctb, u32 len )
1019 {
1020     return write_header2( out, ctb, len, 0, 1 );
1021 }
1022
1023
1024 static int
1025 write_sign_packet_header( IOBUF out, int ctb, u32 len )
1026 {
1027     /* work around a bug in the pgp read function for signature packets,
1028      * which are not correctly coded and silently assume at some
1029      * point 2 byte length headers.*/
1030     iobuf_put(out, 0x89 );
1031     iobuf_put(out, len >> 8 );
1032     return iobuf_put(out, len ) == -1 ? -1:0;
1033 }
1034
1035 /****************
1036  * if HDRLEN is > 0, try to build a header of this length.
1037  * we need this, so that we can hash packets without reading them again.
1038  */
1039 static int
1040 write_header2( IOBUF out, int ctb, u32 len, int hdrlen, int blkmode )
1041 {
1042     if( ctb & 0x40 )
1043         return write_new_header( out, ctb, len, hdrlen );
1044
1045     if( hdrlen ) {
1046         if( !len )
1047             ctb |= 3;
1048         else if( hdrlen == 2 && len < 256 )
1049             ;
1050         else if( hdrlen == 3 && len < 65536 )
1051             ctb |= 1;
1052         else
1053             ctb |= 2;
1054     }
1055     else {
1056         if( !len )
1057             ctb |= 3;
1058         else if( len < 256 )
1059             ;
1060         else if( len < 65536 )
1061             ctb |= 1;
1062         else
1063             ctb |= 2;
1064     }
1065     if( iobuf_put(out, ctb ) )
1066         return -1;
1067     if( !len ) {
1068         if( blkmode )
1069             iobuf_set_block_mode(out, 8196 );
1070     }
1071     else {
1072         if( ctb & 2 ) {
1073             iobuf_put(out, len >> 24 );
1074             iobuf_put(out, len >> 16 );
1075         }
1076         if( ctb & 3 )
1077             iobuf_put(out, len >> 8 );
1078         if( iobuf_put(out, len ) )
1079             return -1;
1080     }
1081     return 0;
1082 }
1083
1084
1085 static int
1086 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1087 {
1088     if( hdrlen )
1089         log_bug("can't cope with hdrlen yet\n");
1090
1091     if( iobuf_put(out, ctb ) )
1092         return -1;
1093     if( !len ) {
1094         iobuf_set_partial_block_mode(out, 512 );
1095     }
1096     else {
1097         if( len < 192 ) {
1098             if( iobuf_put(out, len ) )
1099                 return -1;
1100         }
1101         else if( len < 8384 ) {
1102             len -= 192;
1103             if( iobuf_put( out, (len / 256) + 192) )
1104                 return -1;
1105             if( iobuf_put( out, (len % 256) )  )
1106                 return -1;
1107         }
1108         else {
1109             if( iobuf_put( out, 0xff ) )
1110                 return -1;
1111             if( iobuf_put( out, (len >> 24)&0xff ) )
1112                 return -1;
1113             if( iobuf_put( out, (len >> 16)&0xff ) )
1114                 return -1;
1115             if( iobuf_put( out, (len >> 8)&0xff )  )
1116                 return -1;
1117             if( iobuf_put( out, len & 0xff ) )
1118                 return -1;
1119         }
1120     }
1121     return 0;
1122 }
1123
1124 static int
1125 write_version( IOBUF out, int ctb )
1126 {
1127     if( iobuf_put( out, 3 ) )
1128         return -1;
1129     return 0;
1130 }