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