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