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