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