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