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