Switched to GPLv3.
[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, 2005,
3  *               2006 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 3 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, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <ctype.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 "i18n.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=1; /* A 1-second expiration time is the shortest one
826                   OpenPGP has */
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=xrealloc(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 struct notation *
891 string_to_notation(const char *string,int is_utf8)
892 {
893   const char *s;
894   int saw_at=0;
895   struct notation *notation;
896
897   notation=xmalloc_clear(sizeof(*notation));
898
899   if(*string=='-')
900     {
901       notation->flags.ignore=1;
902       string++;
903     }
904
905   if(*string=='!')
906     {
907       notation->flags.critical=1;
908       string++;
909     }
910
911   /* If and when the IETF assigns some official name tags, we'll have
912      to add them here. */
913
914   for( s=string ; *s != '='; s++ )
915     {
916       if( *s=='@')
917         saw_at++;
918
919       /* -notationname is legal without an = sign */
920       if(!*s && notation->flags.ignore)
921         break;
922
923       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
924         {
925           log_error(_("a notation name must have only printable characters"
926                       " or spaces, and end with an '='\n") );
927           goto fail;
928         }
929     }
930
931   notation->name=xmalloc((s-string)+1);
932   strncpy(notation->name,string,s-string);
933   notation->name[s-string]='\0';
934
935   if(!saw_at && !opt.expert)
936     {
937       log_error(_("a user notation name must contain the '@' character\n"));
938       goto fail;
939     }
940
941   if (saw_at > 1)
942     {
943       log_error(_("a notation name must not contain more than"
944                   " one '@' character\n"));
945       goto fail;
946     }
947
948   if(*s)
949     {
950       const char *i=s+1;
951       int highbit=0;
952
953       /* we only support printable text - therefore we enforce the use
954          of only printable characters (an empty value is valid) */
955       for(s++; *s ; s++ )
956         {
957           if ( !isascii (*s) )
958             highbit=1;
959           else if (iscntrl(*s))
960             {
961               log_error(_("a notation value must not use any"
962                           " control characters\n"));
963               goto fail;
964             }
965         }
966
967       if(!highbit || is_utf8)
968         notation->value=xstrdup(i);
969       else
970         notation->value=native_to_utf8(i);
971     }
972
973   return notation;
974
975  fail:
976   free_notation(notation);
977   return NULL;
978 }
979
980 struct notation *
981 sig_to_notation(PKT_signature *sig)
982 {
983   const byte *p;
984   size_t len;
985   int seq=0,crit;
986   struct notation *list=NULL;
987
988   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
989     {
990       int n1,n2;
991       struct notation *n=NULL;
992
993       if(len<8)
994         {
995           log_info(_("WARNING: invalid notation data found\n"));
996           continue;
997         }
998
999       n1=(p[4]<<8)|p[5];
1000       n2=(p[6]<<8)|p[7];
1001
1002       if(8+n1+n2!=len)
1003         {
1004           log_info(_("WARNING: invalid notation data found\n"));
1005           continue;
1006         }
1007
1008       n=xmalloc_clear(sizeof(*n));
1009       n->name=xmalloc(n1+1);
1010
1011       memcpy(n->name,&p[8],n1);
1012       n->name[n1]='\0';
1013
1014       if(p[0]&0x80)
1015         {
1016           n->value=xmalloc(n2+1);
1017           memcpy(n->value,&p[8+n1],n2);
1018           n->value[n2]='\0';
1019         }
1020       else
1021         {
1022           n->bdat=xmalloc(n2);
1023           n->blen=n2;
1024           memcpy(n->bdat,&p[8+n1],n2);
1025
1026           n->value=xmalloc(2+strlen(_("not human readable"))+2+1);
1027           strcpy(n->value,"[ ");
1028           strcat(n->value,_("not human readable"));
1029           strcat(n->value," ]");
1030         }
1031
1032       n->flags.critical=crit;
1033
1034       n->next=list;
1035       list=n;
1036     }
1037
1038   return list;
1039 }
1040
1041 void
1042 free_notation(struct notation *notation)
1043 {
1044   while(notation)
1045     {
1046       struct notation *n=notation;
1047
1048       xfree(n->name);
1049       xfree(n->value);
1050       xfree(n->altvalue);
1051       xfree(n->bdat);
1052       notation=n->next;
1053       xfree(n);
1054     }
1055 }
1056
1057 static int
1058 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1059 {
1060     int rc = 0;
1061     int n, i;
1062     IOBUF a = iobuf_temp();
1063
1064     if( !sig->version )
1065         iobuf_put( a, 3 );
1066     else
1067         iobuf_put( a, sig->version );
1068     if( sig->version < 4 )
1069         iobuf_put(a, 5 ); /* constant */
1070     iobuf_put(a, sig->sig_class );
1071     if( sig->version < 4 ) {
1072         write_32(a, sig->timestamp );
1073         write_32(a, sig->keyid[0] );
1074         write_32(a, sig->keyid[1] );
1075     }
1076     iobuf_put(a, sig->pubkey_algo );
1077     iobuf_put(a, sig->digest_algo );
1078     if( sig->version >= 4 ) {
1079         size_t nn;
1080         /* timestamp and keyid must have been packed into the
1081          * subpackets prior to the call of this function, because
1082          * these subpackets are hashed */
1083         nn = sig->hashed? sig->hashed->len : 0;
1084         write_16(a, nn);
1085         if( nn )
1086             iobuf_write( a, sig->hashed->data, nn );
1087         nn = sig->unhashed? sig->unhashed->len : 0;
1088         write_16(a, nn);
1089         if( nn )
1090             iobuf_write( a, sig->unhashed->data, nn );
1091     }
1092     iobuf_put(a, sig->digest_start[0] );
1093     iobuf_put(a, sig->digest_start[1] );
1094     n = pubkey_get_nsig( sig->pubkey_algo );
1095     if( !n )
1096         write_fake_data( a, sig->data[0] );
1097     for(i=0; i < n; i++ )
1098         mpi_write(a, sig->data[i] );
1099
1100     if( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1101         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1102     else
1103         write_header(out, ctb, iobuf_get_temp_length(a) );
1104     if( iobuf_write_temp( out, a ) )
1105         rc = G10ERR_WRITE_FILE;
1106
1107     iobuf_close(a);
1108     return rc;
1109 }
1110
1111
1112 static int
1113 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1114 {
1115     int rc = 0;
1116     IOBUF a = iobuf_temp();
1117
1118     write_version( a, ctb );
1119     iobuf_put(a, ops->sig_class );
1120     iobuf_put(a, ops->digest_algo );
1121     iobuf_put(a, ops->pubkey_algo );
1122     write_32(a, ops->keyid[0] );
1123     write_32(a, ops->keyid[1] );
1124     iobuf_put(a, ops->last );
1125
1126     write_header(out, ctb, iobuf_get_temp_length(a) );
1127     if( iobuf_write_temp( out, a ) )
1128         rc = G10ERR_WRITE_FILE;
1129
1130     iobuf_close(a);
1131     return rc;
1132 }
1133
1134
1135 static int
1136 write_16(IOBUF out, u16 a)
1137 {
1138     iobuf_put(out, a>>8);
1139     if( iobuf_put(out,a) )
1140         return -1;
1141     return 0;
1142 }
1143
1144 static int
1145 write_32(IOBUF out, u32 a)
1146 {
1147     iobuf_put(out, a>> 24);
1148     iobuf_put(out, a>> 16);
1149     iobuf_put(out, a>> 8);
1150     if( iobuf_put(out, a) )
1151         return -1;
1152     return 0;
1153 }
1154
1155
1156 /****************
1157  * calculate the length of a header
1158  */
1159 static int
1160 calc_header_length( u32 len, int new_ctb )
1161 {
1162     if( !len )
1163         return 1; /* only the ctb */
1164
1165     if( new_ctb ) {
1166         if( len < 192 )
1167             return 2;
1168         if( len < 8384 )
1169             return 3;
1170         else
1171             return 6;
1172     }
1173     if( len < 256 )
1174         return 2;
1175     if( len < 65536 )
1176         return 3;
1177
1178     return 5;
1179 }
1180
1181 /****************
1182  * Write the CTB and the packet length
1183  */
1184 static int
1185 write_header( IOBUF out, int ctb, u32 len )
1186 {
1187     return write_header2( out, ctb, len, 0 );
1188 }
1189
1190
1191 static int
1192 write_sign_packet_header( IOBUF out, int ctb, u32 len )
1193 {
1194     /* work around a bug in the pgp read function for signature packets,
1195      * which are not correctly coded and silently assume at some
1196      * point 2 byte length headers.*/
1197     iobuf_put(out, 0x89 );
1198     iobuf_put(out, len >> 8 );
1199     return iobuf_put(out, len ) == -1 ? -1:0;
1200 }
1201
1202 /****************
1203  * If HDRLEN is > 0, try to build a header of this length.  We need
1204  * this so that we can hash packets without reading them again.  If
1205  * len is 0, write a partial or indeterminate length header, unless
1206  * hdrlen is specified in which case write an actual zero length
1207  * (using the specified hdrlen).
1208  */
1209 static int
1210 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1211 {
1212   if( ctb & 0x40 )
1213     return write_new_header( out, ctb, len, hdrlen );
1214
1215   if( hdrlen )
1216     {
1217       if( hdrlen == 2 && len < 256 )
1218         ;
1219       else if( hdrlen == 3 && len < 65536 )
1220         ctb |= 1;
1221       else
1222         ctb |= 2;
1223     }
1224   else
1225     {
1226       if( !len )
1227         ctb |= 3;
1228       else if( len < 256 )
1229         ;
1230       else if( len < 65536 )
1231         ctb |= 1;
1232       else
1233         ctb |= 2;
1234     }
1235
1236   if( iobuf_put(out, ctb ) )
1237     return -1;
1238
1239   if( len || hdrlen )
1240     {
1241       if( ctb & 2 )
1242         {
1243           if(iobuf_put(out, len >> 24 ))
1244             return -1;
1245           if(iobuf_put(out, len >> 16 ))
1246             return -1;
1247         }
1248
1249       if( ctb & 3 )
1250         if(iobuf_put(out, len >> 8 ))
1251           return -1;
1252
1253       if( iobuf_put(out, len ) )
1254         return -1;
1255     }
1256
1257   return 0;
1258 }
1259
1260
1261 static int
1262 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1263 {
1264     if( hdrlen )
1265         log_bug("can't cope with hdrlen yet\n");
1266
1267     if( iobuf_put(out, ctb ) )
1268         return -1;
1269     if( !len ) {
1270         iobuf_set_partial_block_mode(out, 512 );
1271     }
1272     else {
1273         if( len < 192 ) {
1274             if( iobuf_put(out, len ) )
1275                 return -1;
1276         }
1277         else if( len < 8384 ) {
1278             len -= 192;
1279             if( iobuf_put( out, (len / 256) + 192) )
1280                 return -1;
1281             if( iobuf_put( out, (len % 256) )  )
1282                 return -1;
1283         }
1284         else {
1285             if( iobuf_put( out, 0xff ) )
1286                 return -1;
1287             if( iobuf_put( out, (len >> 24)&0xff ) )
1288                 return -1;
1289             if( iobuf_put( out, (len >> 16)&0xff ) )
1290                 return -1;
1291             if( iobuf_put( out, (len >> 8)&0xff )  )
1292                 return -1;
1293             if( iobuf_put( out, len & 0xff ) )
1294                 return -1;
1295         }
1296     }
1297     return 0;
1298 }
1299
1300 static int
1301 write_version( IOBUF out, int ctb )
1302 {
1303     if( iobuf_put( out, 3 ) )
1304         return -1;
1305     return 0;
1306 }