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