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