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