card: Suppress error message by agent_scd_cardlist.
[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 <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26
27 #include "gpg.h"
28 #include "../common/util.h"
29 #include "packet.h"
30 #include "../common/status.h"
31 #include "../common/iobuf.h"
32 #include "../common/i18n.h"
33 #include "options.h"
34 #include "../common/host2net.h"
35
36 static gpg_error_t do_ring_trust (iobuf_t out, PKT_ring_trust *rt);
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_encrypted_aead (iobuf_t out, int ctb, PKT_encrypted *ed);
46 static int do_compressed( IOBUF out, int ctb, PKT_compressed *cd );
47 static int do_signature( IOBUF out, int ctb, PKT_signature *sig );
48 static int do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops );
49
50 static int calc_header_length( u32 len, int new_ctb );
51 static int write_16(IOBUF inp, u16 a);
52 static int write_32(IOBUF inp, u32 a);
53 static int write_header( IOBUF out, int ctb, u32 len );
54 static int write_sign_packet_header( IOBUF out, int ctb, u32 len );
55 static int write_header2( IOBUF out, int ctb, u32 len, int hdrlen );
56 static int write_new_header( IOBUF out, int ctb, u32 len, int hdrlen );
57
58 /* Returns 1 if CTB is a new format ctb and 0 if CTB is an old format
59    ctb.  */
60 static int
61 ctb_new_format_p (int ctb)
62 {
63   /* Bit 7 must always be set.  */
64   log_assert ((ctb & (1 << 7)));
65   /* Bit 6 indicates whether the packet is a new format packet.  */
66   return (ctb & (1 << 6));
67 }
68
69 /* Extract the packet type from a CTB.  */
70 static int
71 ctb_pkttype (int ctb)
72 {
73   if (ctb_new_format_p (ctb))
74     /* Bits 0 through 5 are the packet type.  */
75     return (ctb & ((1 << 6) - 1));
76   else
77     /* Bits 2 through 5 are the packet type.  */
78     return (ctb & ((1 << 6) - 1)) >> 2;
79 }
80
81
82 /* Build a packet and write it to the stream OUT.
83  * Returns: 0 on success or on an error code.  */
84 int
85 build_packet (IOBUF out, PACKET *pkt)
86 {
87   int rc = 0;
88   int new_ctb = 0;
89   int ctb, pkttype;
90
91   if (DBG_PACKET)
92     log_debug ("build_packet() type=%d\n", pkt->pkttype);
93   log_assert (pkt->pkt.generic);
94
95   switch ((pkttype = pkt->pkttype))
96     {
97     case PKT_PUBLIC_KEY:
98       if (pkt->pkt.public_key->seckey_info)
99         pkttype = PKT_SECRET_KEY;
100       break;
101     case PKT_PUBLIC_SUBKEY:
102       if (pkt->pkt.public_key->seckey_info)
103         pkttype = PKT_SECRET_SUBKEY;
104       break;
105     case PKT_PLAINTEXT:
106       new_ctb = pkt->pkt.plaintext->new_ctb;
107       break;
108     case PKT_ENCRYPTED:
109     case PKT_ENCRYPTED_MDC:
110     case PKT_ENCRYPTED_AEAD:
111       new_ctb = pkt->pkt.encrypted->new_ctb;
112       break;
113     case PKT_COMPRESSED:
114       new_ctb = pkt->pkt.compressed->new_ctb;
115       break;
116     case PKT_USER_ID:
117       if (pkt->pkt.user_id->attrib_data)
118         pkttype = PKT_ATTRIBUTE;
119       break;
120     default:
121       break;
122     }
123
124   if (new_ctb || pkttype > 15) /* new format */
125     ctb = (0xc0 | (pkttype & 0x3f));
126   else
127     ctb = (0x80 | ((pkttype & 15)<<2));
128   switch (pkttype)
129     {
130     case PKT_ATTRIBUTE:
131     case PKT_USER_ID:
132       rc = do_user_id (out, ctb, pkt->pkt.user_id);
133       break;
134     case PKT_OLD_COMMENT:
135     case PKT_COMMENT:
136       /* Ignore these.  Theoretically, this will never be called as we
137        * have no way to output comment packets any longer, but just in
138        * case there is some code path that would end up outputting a
139        * comment that was written before comments were dropped (in the
140        * public key?) this is a no-op.  */
141       break;
142     case PKT_PUBLIC_SUBKEY:
143     case PKT_PUBLIC_KEY:
144     case PKT_SECRET_SUBKEY:
145     case PKT_SECRET_KEY:
146       rc = do_key (out, ctb, pkt->pkt.public_key);
147       break;
148     case PKT_SYMKEY_ENC:
149       rc = do_symkey_enc (out, ctb, pkt->pkt.symkey_enc);
150       break;
151     case PKT_PUBKEY_ENC:
152       rc = do_pubkey_enc (out, ctb, pkt->pkt.pubkey_enc);
153       break;
154     case PKT_PLAINTEXT:
155       rc = do_plaintext (out, ctb, pkt->pkt.plaintext);
156       break;
157     case PKT_ENCRYPTED:
158       rc = do_encrypted (out, ctb, pkt->pkt.encrypted);
159       break;
160     case PKT_ENCRYPTED_MDC:
161       rc = do_encrypted_mdc (out, ctb, pkt->pkt.encrypted);
162       break;
163     case PKT_ENCRYPTED_AEAD:
164       rc = do_encrypted_aead (out, ctb, pkt->pkt.encrypted);
165       break;
166     case PKT_COMPRESSED:
167       rc = do_compressed (out, ctb, pkt->pkt.compressed);
168       break;
169     case PKT_SIGNATURE:
170       rc = do_signature (out, ctb, pkt->pkt.signature);
171       break;
172     case PKT_ONEPASS_SIG:
173       rc = do_onepass_sig (out, ctb, pkt->pkt.onepass_sig);
174       break;
175     case PKT_RING_TRUST:
176       /* Ignore it (only written by build_packet_and_meta)  */
177       break;
178     case PKT_MDC:
179       /* We write it directly, so we should never see it here. */
180     default:
181       log_bug ("invalid packet type in build_packet()\n");
182       break;
183     }
184
185   return rc;
186 }
187
188
189 /* Build a packet and write it to the stream OUT.  This variant also
190  * writes the meta data using ring trust packets.  Returns: 0 on
191  * success or on error code.  */
192 gpg_error_t
193 build_packet_and_meta (iobuf_t out, PACKET *pkt)
194 {
195   gpg_error_t err;
196   PKT_ring_trust rt = {0};
197
198   err = build_packet (out, pkt);
199   if (err)
200     ;
201   else if (pkt->pkttype == PKT_SIGNATURE)
202     {
203       PKT_signature *sig = pkt->pkt.signature;
204
205       rt.subtype = RING_TRUST_SIG;
206       /* Note: trustval is not yet used.  */
207       if (sig->flags.checked)
208         {
209           rt.sigcache = 1;
210           if (sig->flags.valid)
211             rt.sigcache |= 2;
212         }
213       err = do_ring_trust (out, &rt);
214     }
215   else if (pkt->pkttype == PKT_USER_ID
216            || pkt->pkttype == PKT_ATTRIBUTE)
217     {
218       PKT_user_id *uid = pkt->pkt.user_id;
219
220       rt.subtype = RING_TRUST_UID;
221       rt.keyorg = uid->keyorg;
222       rt.keyupdate = uid->keyupdate;
223       rt.url = uid->updateurl;
224       err = do_ring_trust (out, &rt);
225       rt.url = NULL;
226     }
227   else if (pkt->pkttype == PKT_PUBLIC_KEY
228            || pkt->pkttype == PKT_SECRET_KEY)
229     {
230       PKT_public_key *pk = pkt->pkt.public_key;
231
232       rt.subtype = RING_TRUST_KEY;
233       rt.keyorg = pk->keyorg;
234       rt.keyupdate = pk->keyupdate;
235       rt.url = pk->updateurl;
236       err = do_ring_trust (out, &rt);
237       rt.url = NULL;
238
239     }
240
241   return err;
242 }
243
244
245 /*
246  * Write the mpi A to OUT.
247  */
248 gpg_error_t
249 gpg_mpi_write (iobuf_t out, gcry_mpi_t a)
250 {
251   int rc;
252
253   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
254     {
255       unsigned int nbits;
256       const unsigned char *p;
257       unsigned char lenhdr[2];
258
259       /* gcry_log_debugmpi ("a", a); */
260       p = gcry_mpi_get_opaque (a, &nbits);
261       if (p)
262         {
263           /* Strip leading zero bits.  */
264           for (; nbits >= 8 && !*p; p++, nbits -= 8)
265             ;
266           if (nbits >= 8 && !(*p & 0x80))
267             if (--nbits >= 7 && !(*p & 0x40))
268               if (--nbits >= 6 && !(*p & 0x20))
269                 if (--nbits >= 5 && !(*p & 0x10))
270                   if (--nbits >= 4 && !(*p & 0x08))
271                     if (--nbits >= 3 && !(*p & 0x04))
272                       if (--nbits >= 2 && !(*p & 0x02))
273                         if (--nbits >= 1 && !(*p & 0x01))
274                           --nbits;
275         }
276       /* gcry_log_debug ("   [%u bit]\n", nbits); */
277       /* gcry_log_debughex (" ", p, (nbits+7)/8); */
278       lenhdr[0] = nbits >> 8;
279       lenhdr[1] = nbits;
280       rc = iobuf_write (out, lenhdr, 2);
281       if (!rc && p)
282         rc = iobuf_write (out, p, (nbits+7)/8);
283     }
284   else
285     {
286       char buffer[(MAX_EXTERN_MPI_BITS+7)/8+2]; /* 2 is for the mpi length. */
287       size_t nbytes;
288
289       nbytes = DIM(buffer);
290       rc = gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, &nbytes, a );
291       if( !rc )
292         rc = iobuf_write( out, buffer, nbytes );
293       else if (gpg_err_code(rc) == GPG_ERR_TOO_SHORT )
294         {
295           log_info ("mpi too large (%u bits)\n", gcry_mpi_get_nbits (a));
296           /* The buffer was too small. We better tell the user about the MPI. */
297           rc = gpg_error (GPG_ERR_TOO_LARGE);
298         }
299     }
300
301   return rc;
302 }
303
304
305 /*
306  * Write an opaque MPI to the output stream without length info.
307  */
308 gpg_error_t
309 gpg_mpi_write_nohdr (iobuf_t out, gcry_mpi_t a)
310 {
311   int rc;
312
313   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
314     {
315       unsigned int nbits;
316       const void *p;
317
318       p = gcry_mpi_get_opaque (a, &nbits);
319       rc = p ? iobuf_write (out, p, (nbits+7)/8) : 0;
320     }
321   else
322     rc = gpg_error (GPG_ERR_BAD_MPI);
323
324   return rc;
325 }
326
327
328 /* Calculate the length of a packet described by PKT.  */
329 u32
330 calc_packet_length( PACKET *pkt )
331 {
332   u32 n = 0;
333   int new_ctb = 0;
334
335   log_assert (pkt->pkt.generic);
336   switch (pkt->pkttype)
337     {
338     case PKT_PLAINTEXT:
339       n = calc_plaintext (pkt->pkt.plaintext);
340       new_ctb = pkt->pkt.plaintext->new_ctb;
341       break;
342     case PKT_ATTRIBUTE:
343     case PKT_USER_ID:
344     case PKT_COMMENT:
345     case PKT_PUBLIC_KEY:
346     case PKT_SECRET_KEY:
347     case PKT_SYMKEY_ENC:
348     case PKT_PUBKEY_ENC:
349     case PKT_ENCRYPTED:
350     case PKT_SIGNATURE:
351     case PKT_ONEPASS_SIG:
352     case PKT_RING_TRUST:
353     case PKT_COMPRESSED:
354     default:
355       log_bug ("invalid packet type in calc_packet_length()");
356       break;
357     }
358
359   n += calc_header_length (n, new_ctb);
360   return n;
361 }
362
363
364 static gpg_error_t
365 write_fake_data (IOBUF out, gcry_mpi_t a)
366 {
367   unsigned int n;
368   void *p;
369
370   if (!a)
371     return 0;
372   if (!gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
373     return 0; /* e.g. due to generating a key with wrong usage.  */
374   p = gcry_mpi_get_opaque ( a, &n);
375   if (!p)
376     return 0; /* For example due to a read error in
377                  parse-packet.c:read_rest.  */
378   return iobuf_write (out, p, (n+7)/8 );
379 }
380
381
382 /* Write a ring trust meta packet.  */
383 static gpg_error_t
384 do_ring_trust (iobuf_t out, PKT_ring_trust *rt)
385 {
386   unsigned int namelen = 0;
387   unsigned int pktlen = 6;
388
389   if (rt->subtype == RING_TRUST_KEY || rt->subtype == RING_TRUST_UID)
390     {
391       if (rt->url)
392         namelen = strlen (rt->url);
393       pktlen += 1 + 4 + 1 + namelen;
394     }
395
396   write_header (out, (0x80 | ((PKT_RING_TRUST & 15)<<2)), pktlen);
397   iobuf_put (out, rt->trustval);
398   iobuf_put (out, rt->sigcache);
399   iobuf_write (out, "gpg", 3);
400   iobuf_put (out, rt->subtype);
401   if (rt->subtype == RING_TRUST_KEY || rt->subtype == RING_TRUST_UID)
402     {
403       iobuf_put (out, rt->keyorg);
404       write_32 (out, rt->keyupdate);
405       iobuf_put (out, namelen);
406       if (namelen)
407         iobuf_write (out, rt->url, namelen);
408     }
409
410   return 0;
411 }
412
413
414 /* Serialize the user id (RFC 4880, Section 5.11) or the user
415  * attribute UID (Section 5.12) and write it to OUT.
416  *
417  * CTB is the serialization's CTB.  It specifies the header format and
418  * the packet's type.  The header length must not be set.  */
419 static int
420 do_user_id( IOBUF out, int ctb, PKT_user_id *uid )
421 {
422   int rc;
423   int hdrlen;
424
425   log_assert (ctb_pkttype (ctb) == PKT_USER_ID
426               || ctb_pkttype (ctb) == PKT_ATTRIBUTE);
427
428   /* We need to take special care of a user ID with a length of 0:
429    * Without forcing HDRLEN to 2 in this case an indeterminate length
430    * packet would be written which is not allowed.  Note that we are
431    * always called with a CTB indicating an old packet header format,
432    * so that forcing a 2 octet header works.  */
433   if (uid->attrib_data)
434     {
435       hdrlen = uid->attrib_len? 0 : 2;
436       write_header2 (out, ctb, uid->attrib_len, hdrlen);
437       rc = iobuf_write( out, uid->attrib_data, uid->attrib_len );
438     }
439   else
440     {
441       hdrlen = uid->len? 0 : 2;
442       write_header2 (out, ctb, uid->len, hdrlen);
443       rc = iobuf_write( out, uid->name, uid->len );
444     }
445   return rc;
446 }
447
448
449 /* Serialize the key (RFC 4880, Section 5.5) described by PK and write
450  * it to OUT.
451  *
452  * This function serializes both primary keys and subkeys with or
453  * without a secret part.
454  *
455  * CTB is the serialization's CTB.  It specifies the header format and
456  * the packet's type.  The header length must not be set.
457  *
458  * PK->VERSION specifies the serialization format.  A value of 0 means
459  * to use the default version.  Currently, only version 4 packets are
460  * supported.
461  */
462 static int
463 do_key (iobuf_t out, int ctb, PKT_public_key *pk)
464 {
465   gpg_error_t err = 0;
466   /* The length of the body is stored in the packet's header, which
467      occurs before the body.  Unfortunately, we don't know the length
468      of the packet's body until we've written all of the data!  To
469      work around this, we first write the data into this temporary
470      buffer, then generate the header, and finally copy the contents
471      of this buffer to OUT.  */
472   iobuf_t a = iobuf_temp();
473   int i, nskey, npkey;
474
475   log_assert (pk->version == 0 || pk->version == 4);
476   log_assert (ctb_pkttype (ctb) == PKT_PUBLIC_KEY
477               || ctb_pkttype (ctb) == PKT_PUBLIC_SUBKEY
478               || ctb_pkttype (ctb) == PKT_SECRET_KEY
479               || ctb_pkttype (ctb) == PKT_SECRET_SUBKEY);
480
481   /* Write the version number - if none is specified, use 4 */
482   if ( !pk->version )
483     iobuf_put ( a, 4 );
484   else
485     iobuf_put ( a, pk->version );
486   write_32 (a, pk->timestamp );
487
488   iobuf_put (a, pk->pubkey_algo );
489
490   /* Get number of secret and public parameters.  They are held in one
491      array: the public ones followed by the secret ones.  */
492   nskey = pubkey_get_nskey (pk->pubkey_algo);
493   npkey = pubkey_get_npkey (pk->pubkey_algo);
494
495   /* If we don't have any public parameters - which is for example the
496      case if we don't know the algorithm used - the parameters are
497      stored as one blob in a faked (opaque) MPI. */
498   if (!npkey)
499     {
500       write_fake_data (a, pk->pkey[0]);
501       goto leave;
502     }
503   log_assert (npkey < nskey);
504
505   for (i=0; i < npkey; i++ )
506     {
507       if (   (pk->pubkey_algo == PUBKEY_ALGO_ECDSA && (i == 0))
508           || (pk->pubkey_algo == PUBKEY_ALGO_EDDSA && (i == 0))
509           || (pk->pubkey_algo == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
510         err = gpg_mpi_write_nohdr (a, pk->pkey[i]);
511       else
512         err = gpg_mpi_write (a, pk->pkey[i]);
513       if (err)
514         goto leave;
515     }
516
517
518   if (pk->seckey_info)
519     {
520       /* This is a secret key packet.  */
521       struct seckey_info *ski = pk->seckey_info;
522
523       /* Build the header for protected (encrypted) secret parameters.  */
524       if (ski->is_protected)
525         {
526           /* OpenPGP protection according to rfc2440. */
527           iobuf_put (a, ski->sha1chk? 0xfe : 0xff);
528           iobuf_put (a, ski->algo);
529           if (ski->s2k.mode >= 1000)
530             {
531               /* These modes are not possible in OpenPGP, we use them
532                  to implement our extensions, 101 can be viewed as a
533                  private/experimental extension (this is not specified
534                  in rfc2440 but the same scheme is used for all other
535                  algorithm identifiers). */
536               iobuf_put (a, 101);
537               iobuf_put (a, ski->s2k.hash_algo);
538               iobuf_write (a, "GNU", 3 );
539               iobuf_put (a, ski->s2k.mode - 1000);
540             }
541           else
542             {
543               iobuf_put (a, ski->s2k.mode);
544               iobuf_put (a, ski->s2k.hash_algo);
545             }
546
547           if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
548             iobuf_write (a, ski->s2k.salt, 8);
549
550           if (ski->s2k.mode == 3)
551             iobuf_put (a, ski->s2k.count);
552
553           /* For our special modes 1001, 1002 we do not need an IV. */
554           if (ski->s2k.mode != 1001 && ski->s2k.mode != 1002)
555             iobuf_write (a, ski->iv, ski->ivlen);
556
557         }
558       else /* Not protected. */
559         iobuf_put (a, 0 );
560
561       if (ski->s2k.mode == 1001)
562         ; /* GnuPG extension - don't write a secret key at all. */
563       else if (ski->s2k.mode == 1002)
564         {
565           /* GnuPG extension - divert to OpenPGP smartcard. */
566           /* Length of the serial number or 0 for no serial number. */
567           iobuf_put (a, ski->ivlen );
568           /* The serial number gets stored in the IV field.  */
569           iobuf_write (a, ski->iv, ski->ivlen);
570         }
571       else if (ski->is_protected)
572         {
573           /* The secret key is protected - write it out as it is.  */
574           byte *p;
575           unsigned int ndatabits;
576
577           log_assert (gcry_mpi_get_flag (pk->pkey[npkey], GCRYMPI_FLAG_OPAQUE));
578           p = gcry_mpi_get_opaque (pk->pkey[npkey], &ndatabits);
579           if (p)
580             iobuf_write (a, p, (ndatabits+7)/8 );
581         }
582       else
583         {
584           /* Non-protected key. */
585           for ( ; i < nskey; i++ )
586             if ( (err = gpg_mpi_write (a, pk->pkey[i])))
587               goto leave;
588           write_16 (a, ski->csum );
589         }
590     }
591
592  leave:
593   if (!err)
594     {
595       /* Build the header of the packet - which we must do after
596          writing all the other stuff, so that we know the length of
597          the packet */
598       write_header2 (out, ctb, iobuf_get_temp_length(a), 0);
599        /* And finally write it out to the real stream. */
600       err = iobuf_write_temp (out, a);
601     }
602
603   iobuf_close (a); /* Close the temporary buffer */
604   return err;
605 }
606
607
608 /* Serialize the symmetric-key encrypted session key packet (RFC 4880,
609  * 5.3) described by ENC and write it to OUT.
610  *
611  * CTB is the serialization's CTB.  It specifies the header format and
612  * the packet's type.  The header length must not be set.  */
613 static int
614 do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
615 {
616   int rc = 0;
617   IOBUF a = iobuf_temp();
618
619   log_assert (ctb_pkttype (ctb) == PKT_SYMKEY_ENC);
620   log_assert (enc->version == 4 || enc->version == 5);
621
622   switch (enc->s2k.mode)
623     {
624     case 0: /* Simple S2K.  */
625     case 1: /* Salted S2K.  */
626     case 3: /* Iterated and salted S2K.  */
627       break; /* Reasonable values.  */
628
629     default:
630       log_bug ("do_symkey_enc: s2k=%d\n", enc->s2k.mode);
631     }
632   iobuf_put (a, enc->version);
633   iobuf_put (a, enc->cipher_algo);
634   if (enc->version == 5)
635     iobuf_put (a, enc->aead_algo);
636   iobuf_put (a, enc->s2k.mode);
637   iobuf_put (a, enc->s2k.hash_algo);
638   if (enc->s2k.mode == 1 || enc->s2k.mode == 3)
639     {
640       iobuf_write (a, enc->s2k.salt, 8);
641       if (enc->s2k.mode == 3)
642         iobuf_put (a, enc->s2k.count);
643     }
644   if (enc->seskeylen)
645     iobuf_write (a, enc->seskey, enc->seskeylen);
646
647   write_header (out, ctb, iobuf_get_temp_length(a));
648   rc = iobuf_write_temp (out, a);
649
650   iobuf_close (a);
651   return rc;
652 }
653
654
655 /* Serialize the public-key encrypted session key packet (RFC 4880,
656    5.1) described by ENC and write it to OUT.
657
658    CTB is the serialization's CTB.  It specifies the header format and
659    the packet's type.  The header length must not be set.  */
660 static int
661 do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
662 {
663   int rc = 0;
664   int n, i;
665   IOBUF a = iobuf_temp();
666
667   log_assert (ctb_pkttype (ctb) == PKT_PUBKEY_ENC);
668
669   iobuf_put (a, 3); /* Version.  */
670
671   if ( enc->throw_keyid )
672     {
673       write_32(a, 0 );  /* Don't tell Eve who can decrypt the message.  */
674       write_32(a, 0 );
675     }
676   else
677     {
678       write_32(a, enc->keyid[0] );
679       write_32(a, enc->keyid[1] );
680     }
681   iobuf_put(a,enc->pubkey_algo );
682   n = pubkey_get_nenc( enc->pubkey_algo );
683   if ( !n )
684     write_fake_data( a, enc->data[0] );
685
686   for (i=0; i < n && !rc ; i++ )
687     {
688       if (enc->pubkey_algo == PUBKEY_ALGO_ECDH && i == 1)
689         rc = gpg_mpi_write_nohdr (a, enc->data[i]);
690       else
691         rc = gpg_mpi_write (a, enc->data[i]);
692     }
693
694   if (!rc)
695     {
696       write_header (out, ctb, iobuf_get_temp_length(a) );
697       rc = iobuf_write_temp (out, a);
698     }
699   iobuf_close(a);
700   return rc;
701 }
702
703
704 /* Calculate the length of the serialized plaintext packet PT (RFC
705    4480, Section 5.9).  */
706 static u32
707 calc_plaintext( PKT_plaintext *pt )
708 {
709   /* Truncate namelen to the maximum 255 characters.  Note this means
710      that a function that calls build_packet with an illegal literal
711      packet will get it back legalized. */
712
713   if(pt->namelen>255)
714     pt->namelen=255;
715
716   return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
717 }
718
719 /* Serialize the plaintext packet (RFC 4880, 5.9) described by PT and
720    write it to OUT.
721
722    The body of the message is stored in PT->BUF.  The amount of data
723    to write is PT->LEN.  (PT->BUF should be configured to return EOF
724    after this much data has been read.)  If PT->LEN is 0 and CTB
725    indicates that this is a new format packet, then partial block mode
726    is assumed to have been enabled on OUT.  On success, partial block
727    mode is disabled.
728
729    If PT->BUF is NULL, the caller must write out the data.  In
730    this case, if PT->LEN was 0, then partial body length mode was
731    enabled and the caller must disable it by calling
732    iobuf_set_partial_body_length_mode (out, 0).  */
733 static int
734 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
735 {
736     int rc = 0;
737     size_t nbytes;
738
739     log_assert (ctb_pkttype (ctb) == PKT_PLAINTEXT);
740
741     write_header(out, ctb, calc_plaintext( pt ) );
742     log_assert (pt->mode == 'b' || pt->mode == 't' || pt->mode == 'u'
743                 || pt->mode == 'm'
744                 || pt->mode == 'l' || pt->mode == '1');
745     iobuf_put(out, pt->mode );
746     iobuf_put(out, pt->namelen );
747     iobuf_write (out, pt->name, pt->namelen);
748     rc = write_32(out, pt->timestamp );
749     if (rc)
750       return rc;
751
752     if (pt->buf)
753       {
754         nbytes = iobuf_copy (out, pt->buf);
755         if(ctb_new_format_p (ctb) && !pt->len)
756           /* Turn off partial body length mode.  */
757           iobuf_set_partial_body_length_mode (out, 0);
758         if( pt->len && nbytes != pt->len )
759           log_error("do_plaintext(): wrote %lu bytes but expected %lu bytes\n",
760                     (ulong)nbytes, (ulong)pt->len );
761       }
762
763     return rc;
764 }
765
766
767
768 /* Serialize the symmetrically encrypted data packet (RFC 4880,
769    Section 5.7) described by ED and write it to OUT.
770
771    Note: this only writes the packets header!  The call must then
772    follow up and write the initial random data and the body to OUT.
773    (If you use the encryption iobuf filter (cipher_filter), then this
774    is done automatically.)  */
775 static int
776 do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
777 {
778     int rc = 0;
779     u32 n;
780
781     log_assert (! ed->mdc_method);
782     log_assert (ctb_pkttype (ctb) == PKT_ENCRYPTED);
783
784     n = ed->len ? (ed->len + ed->extralen) : 0;
785     write_header(out, ctb, n );
786
787     /* This is all. The caller has to write the real data */
788
789     return rc;
790 }
791
792 /* Serialize the symmetrically encrypted integrity protected data
793    packet (RFC 4880, Section 5.13) described by ED and write it to
794    OUT.
795
796    Note: this only writes the packet's header!  The caller must then
797    follow up and write the initial random data, the body and the MDC
798    packet to OUT.  (If you use the encryption iobuf filter
799    (cipher_filter), then this is done automatically.)  */
800 static int
801 do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
802 {
803     int rc = 0;
804     u32 n;
805
806     log_assert (ed->mdc_method);
807     log_assert (ctb_pkttype (ctb) == PKT_ENCRYPTED_MDC);
808
809     /* Take version number and the following MDC packet in account. */
810     n = ed->len ? (ed->len + ed->extralen + 1 + 22) : 0;
811     write_header(out, ctb, n );
812     iobuf_put(out, 1 );  /* version */
813
814     /* This is all. The caller has to write the real data */
815
816     return rc;
817 }
818
819
820 /* Serialize the symmetrically AEAD encrypted data packet
821  * (rfc4880bis-03, Section 5.16) described by ED and write it to OUT.
822  *
823  * Note: this only writes only packet's header.  The caller must then
824  * follow up and write the actual encrypted data.  This should be done
825  * by pushing the the cipher_filter_aead.  */
826 static int
827 do_encrypted_aead (iobuf_t out, int ctb, PKT_encrypted *ed)
828 {
829   u32 n;
830
831   log_assert (ctb_pkttype (ctb) == PKT_ENCRYPTED_AEAD);
832
833   n = ed->len ? (ed->len + ed->extralen + 4) : 0;
834   write_header (out, ctb, n );
835   iobuf_writebyte (out, 1); /* Version.  */
836   iobuf_writebyte (out, ed->cipher_algo);
837   iobuf_writebyte (out, ed->aead_algo);
838   iobuf_writebyte (out, ed->chunkbyte);
839
840   /* This is all. The caller has to write the encrypted data */
841
842   return 0;
843 }
844
845
846 /* Serialize the compressed packet (RFC 4880, Section 5.6) described
847    by CD and write it to OUT.
848
849    Note: this only writes the packet's header!  The caller must then
850    follow up and write the body to OUT.  */
851 static int
852 do_compressed( IOBUF out, int ctb, PKT_compressed *cd )
853 {
854     int rc = 0;
855
856     log_assert (ctb_pkttype (ctb) == PKT_COMPRESSED);
857
858     /* We must use the old convention and don't use blockmode for the
859        sake of PGP 2 compatibility.  However if the new_ctb flag was
860        set, CTB is already formatted as new style and write_header2
861        does create a partial length encoding using new the new
862        style. */
863     write_header2(out, ctb, 0, 0);
864     iobuf_put(out, cd->algorithm );
865
866     /* This is all. The caller has to write the real data */
867
868     return rc;
869 }
870
871
872 /****************
873  * Delete all subpackets of type REQTYPE and return a bool whether a packet
874  * was deleted.
875  */
876 int
877 delete_sig_subpkt (subpktarea_t *area, sigsubpkttype_t reqtype )
878 {
879     int buflen;
880     sigsubpkttype_t type;
881     byte *buffer, *bufstart;
882     size_t n;
883     size_t unused = 0;
884     int okay = 0;
885
886     if( !area )
887         return 0;
888     buflen = area->len;
889     buffer = area->data;
890     for(;;) {
891         if( !buflen ) {
892             okay = 1;
893             break;
894         }
895         bufstart = buffer;
896         n = *buffer++; buflen--;
897         if( n == 255 ) {
898             if( buflen < 4 )
899                 break;
900             n = buf32_to_size_t (buffer);
901             buffer += 4;
902             buflen -= 4;
903         }
904         else if( n >= 192 ) {
905             if( buflen < 2 )
906                 break;
907             n = (( n - 192 ) << 8) + *buffer + 192;
908             buffer++;
909             buflen--;
910         }
911         if( buflen < n )
912             break;
913
914         type = *buffer & 0x7f;
915         if( type == reqtype ) {
916             buffer++;
917             buflen--;
918             n--;
919             if( n > buflen )
920                 break;
921             buffer += n; /* point to next subpkt */
922             buflen -= n;
923             memmove (bufstart, buffer, buflen); /* shift */
924             unused +=  buffer - bufstart;
925             buffer = bufstart;
926         }
927         else {
928             buffer += n; buflen -=n;
929         }
930     }
931
932     if (!okay)
933         log_error ("delete_subpkt: buffer shorter than subpacket\n");
934     log_assert (unused <= area->len);
935     area->len -= unused;
936     return !!unused;
937 }
938
939
940 /****************
941  * Create or update a signature subpacket for SIG of TYPE.  This
942  * functions knows where to put the data (hashed or unhashed).  The
943  * function may move data from the unhashed part to the hashed one.
944  * Note: All pointers into sig->[un]hashed (e.g. returned by
945  * parse_sig_subpkt) are not valid after a call to this function.  The
946  * data to put into the subpaket should be in a buffer with a length
947  * of buflen.
948  */
949 void
950 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
951                   const byte *buffer, size_t buflen )
952 {
953     byte *p;
954     int critical, hashed;
955     subpktarea_t *oldarea, *newarea;
956     size_t nlen, n, n0;
957
958     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
959     type &= ~SIGSUBPKT_FLAG_CRITICAL;
960
961     /* Sanity check buffer sizes */
962     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
963       BUG();
964
965     switch(type)
966       {
967       case SIGSUBPKT_NOTATION:
968       case SIGSUBPKT_POLICY:
969       case SIGSUBPKT_REV_KEY:
970       case SIGSUBPKT_SIGNATURE:
971         /* we do allow multiple subpackets */
972         break;
973
974       default:
975         /* we don't allow multiple subpackets */
976         delete_sig_subpkt(sig->hashed,type);
977         delete_sig_subpkt(sig->unhashed,type);
978         break;
979       }
980
981     /* Any special magic that needs to be done for this type so the
982        packet doesn't need to be reparsed? */
983     switch(type)
984       {
985       case SIGSUBPKT_NOTATION:
986         sig->flags.notation=1;
987         break;
988
989       case SIGSUBPKT_POLICY:
990         sig->flags.policy_url=1;
991         break;
992
993       case SIGSUBPKT_PREF_KS:
994         sig->flags.pref_ks=1;
995         break;
996
997       case SIGSUBPKT_EXPORTABLE:
998         if(buffer[0])
999           sig->flags.exportable=1;
1000         else
1001           sig->flags.exportable=0;
1002         break;
1003
1004       case SIGSUBPKT_REVOCABLE:
1005         if(buffer[0])
1006           sig->flags.revocable=1;
1007         else
1008           sig->flags.revocable=0;
1009         break;
1010
1011       case SIGSUBPKT_TRUST:
1012         sig->trust_depth=buffer[0];
1013         sig->trust_value=buffer[1];
1014         break;
1015
1016       case SIGSUBPKT_REGEXP:
1017         sig->trust_regexp=buffer;
1018         break;
1019
1020         /* This should never happen since we don't currently allow
1021            creating such a subpacket, but just in case... */
1022       case SIGSUBPKT_SIG_EXPIRE:
1023         if(buf32_to_u32(buffer)+sig->timestamp<=make_timestamp())
1024           sig->flags.expired=1;
1025         else
1026           sig->flags.expired=0;
1027         break;
1028
1029       default:
1030         break;
1031       }
1032
1033     if( (buflen+1) >= 8384 )
1034         nlen = 5; /* write 5 byte length header */
1035     else if( (buflen+1) >= 192 )
1036         nlen = 2; /* write 2 byte length header */
1037     else
1038         nlen = 1; /* just a 1 byte length header */
1039
1040     switch( type )
1041       {
1042         /* The issuer being unhashed is a historical oddity.  It
1043            should work equally as well hashed.  Of course, if even an
1044            unhashed issuer is tampered with, it makes it awfully hard
1045            to verify the sig... */
1046       case SIGSUBPKT_ISSUER:
1047       case SIGSUBPKT_SIGNATURE:
1048         hashed = 0;
1049         break;
1050       default:
1051         hashed = 1;
1052         break;
1053       }
1054
1055     if( critical )
1056         type |= SIGSUBPKT_FLAG_CRITICAL;
1057
1058     oldarea = hashed? sig->hashed : sig->unhashed;
1059
1060     /* Calculate new size of the area and allocate */
1061     n0 = oldarea? oldarea->len : 0;
1062     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
1063     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
1064         newarea = oldarea;
1065         /*log_debug ("updating area for type %d\n", type );*/
1066     }
1067     else if (oldarea) {
1068         newarea = xrealloc (oldarea, sizeof (*newarea) + n - 1);
1069         newarea->size = n;
1070         /*log_debug ("reallocating area for type %d\n", type );*/
1071     }
1072     else {
1073         newarea = xmalloc (sizeof (*newarea) + n - 1);
1074         newarea->size = n;
1075         /*log_debug ("allocating area for type %d\n", type );*/
1076     }
1077     newarea->len = n;
1078
1079     p = newarea->data + n0;
1080     if (nlen == 5) {
1081         *p++ = 255;
1082         *p++ = (buflen+1) >> 24;
1083         *p++ = (buflen+1) >> 16;
1084         *p++ = (buflen+1) >>  8;
1085         *p++ = (buflen+1);
1086         *p++ = type;
1087         memcpy (p, buffer, buflen);
1088     }
1089     else if (nlen == 2) {
1090         *p++ = (buflen+1-192) / 256 + 192;
1091         *p++ = (buflen+1-192) % 256;
1092         *p++ = type;
1093         memcpy (p, buffer, buflen);
1094     }
1095     else {
1096         *p++ = buflen+1;
1097         *p++ = type;
1098         memcpy (p, buffer, buflen);
1099     }
1100
1101     if (hashed)
1102         sig->hashed = newarea;
1103     else
1104         sig->unhashed = newarea;
1105 }
1106
1107 /*
1108  * Put all the required stuff from SIG into subpackets of sig.
1109  * PKSK is the signing key.
1110  * Hmmm, should we delete those subpackets which are in a wrong area?
1111  */
1112 void
1113 build_sig_subpkt_from_sig (PKT_signature *sig, PKT_public_key *pksk)
1114 {
1115     u32  u;
1116     byte buf[1+MAX_FINGERPRINT_LEN];
1117     size_t fprlen;
1118
1119     /* For v4 keys we need to write the ISSUER subpacket.  We do not
1120      * want that for a future v5 format.  */
1121     if (pksk->version < 5)
1122       {
1123         u = sig->keyid[0];
1124         buf[0] = (u >> 24) & 0xff;
1125         buf[1] = (u >> 16) & 0xff;
1126         buf[2] = (u >>  8) & 0xff;
1127         buf[3] = u & 0xff;
1128         u = sig->keyid[1];
1129         buf[4] = (u >> 24) & 0xff;
1130         buf[5] = (u >> 16) & 0xff;
1131         buf[6] = (u >>  8) & 0xff;
1132         buf[7] = u & 0xff;
1133         build_sig_subpkt (sig, SIGSUBPKT_ISSUER, buf, 8);
1134       }
1135
1136     /* Write the new ISSUER_FPR subpacket.  */
1137     fingerprint_from_pk (pksk, buf+1, &fprlen);
1138     if (fprlen == 20)
1139       {
1140         buf[0] = pksk->version;
1141         build_sig_subpkt (sig, SIGSUBPKT_ISSUER_FPR, buf, 21);
1142       }
1143
1144     /* Write the timestamp.  */
1145     u = sig->timestamp;
1146     buf[0] = (u >> 24) & 0xff;
1147     buf[1] = (u >> 16) & 0xff;
1148     buf[2] = (u >>  8) & 0xff;
1149     buf[3] = u & 0xff;
1150     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
1151
1152     if(sig->expiredate)
1153       {
1154         if(sig->expiredate>sig->timestamp)
1155           u=sig->expiredate-sig->timestamp;
1156         else
1157           u=1; /* A 1-second expiration time is the shortest one
1158                   OpenPGP has */
1159
1160         buf[0] = (u >> 24) & 0xff;
1161         buf[1] = (u >> 16) & 0xff;
1162         buf[2] = (u >>  8) & 0xff;
1163         buf[3] = u & 0xff;
1164
1165         /* Mark this CRITICAL, so if any implementation doesn't
1166            understand sigs that can expire, it'll just disregard this
1167            sig altogether. */
1168
1169         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
1170                           buf, 4 );
1171       }
1172 }
1173
1174 void
1175 build_attribute_subpkt(PKT_user_id *uid,byte type,
1176                        const void *buf,u32 buflen,
1177                        const void *header,u32 headerlen)
1178 {
1179   byte *attrib;
1180   int idx;
1181
1182   if(1+headerlen+buflen>8383)
1183     idx=5;
1184   else if(1+headerlen+buflen>191)
1185     idx=2;
1186   else
1187     idx=1;
1188
1189   /* realloc uid->attrib_data to the right size */
1190
1191   uid->attrib_data=xrealloc(uid->attrib_data,
1192                              uid->attrib_len+idx+1+headerlen+buflen);
1193
1194   attrib=&uid->attrib_data[uid->attrib_len];
1195
1196   if(idx==5)
1197     {
1198       attrib[0]=255;
1199       attrib[1]=(1+headerlen+buflen) >> 24;
1200       attrib[2]=(1+headerlen+buflen) >> 16;
1201       attrib[3]=(1+headerlen+buflen) >> 8;
1202       attrib[4]=1+headerlen+buflen;
1203     }
1204   else if(idx==2)
1205     {
1206       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
1207       attrib[1]=(1+headerlen+buflen-192) % 256;
1208     }
1209   else
1210     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
1211
1212   attrib[idx++]=type;
1213
1214   /* Tack on our data at the end */
1215
1216   if(headerlen>0)
1217     memcpy(&attrib[idx],header,headerlen);
1218   memcpy(&attrib[idx+headerlen],buf,buflen);
1219   uid->attrib_len+=idx+headerlen+buflen;
1220 }
1221
1222 /* Returns a human-readable string corresponding to the notation.
1223    This ignores notation->value.  The caller must free the result.  */
1224 static char *
1225 notation_value_to_human_readable_string (struct notation *notation)
1226 {
1227   if(notation->bdat)
1228     /* Binary data.  */
1229     {
1230       size_t len = notation->blen;
1231       int i;
1232       char preview[20];
1233
1234       for (i = 0; i < len && i < sizeof (preview) - 1; i ++)
1235         if (isprint (notation->bdat[i]))
1236           preview[i] = notation->bdat[i];
1237         else
1238           preview[i] = '?';
1239       preview[i] = 0;
1240
1241       return xasprintf (_("[ not human readable (%zu bytes: %s%s) ]"),
1242                         len, preview, i < len ? "..." : "");
1243     }
1244   else
1245     /* The value is human-readable.  */
1246     return xstrdup (notation->value);
1247 }
1248
1249 /* Turn the notation described by the string STRING into a notation.
1250
1251    STRING has the form:
1252
1253      - -name - Delete the notation.
1254      - name@domain.name=value - Normal notation
1255      - !name@domain.name=value - Notation with critical bit set.
1256
1257    The caller must free the result using free_notation().  */
1258 struct notation *
1259 string_to_notation(const char *string,int is_utf8)
1260 {
1261   const char *s;
1262   int saw_at=0;
1263   struct notation *notation;
1264
1265   notation=xmalloc_clear(sizeof(*notation));
1266
1267   if(*string=='-')
1268     {
1269       notation->flags.ignore=1;
1270       string++;
1271     }
1272
1273   if(*string=='!')
1274     {
1275       notation->flags.critical=1;
1276       string++;
1277     }
1278
1279   /* If and when the IETF assigns some official name tags, we'll have
1280      to add them here. */
1281
1282   for( s=string ; *s != '='; s++ )
1283     {
1284       if( *s=='@')
1285         saw_at++;
1286
1287       /* -notationname is legal without an = sign */
1288       if(!*s && notation->flags.ignore)
1289         break;
1290
1291       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
1292         {
1293           log_error(_("a notation name must have only printable characters"
1294                       " or spaces, and end with an '='\n") );
1295           goto fail;
1296         }
1297     }
1298
1299   notation->name=xmalloc((s-string)+1);
1300   memcpy(notation->name,string,s-string);
1301   notation->name[s-string]='\0';
1302
1303   if(!saw_at && !opt.expert)
1304     {
1305       log_error(_("a user notation name must contain the '@' character\n"));
1306       goto fail;
1307     }
1308
1309   if (saw_at > 1)
1310     {
1311       log_error(_("a notation name must not contain more than"
1312                   " one '@' character\n"));
1313       goto fail;
1314     }
1315
1316   if(*s)
1317     {
1318       const char *i=s+1;
1319       int highbit=0;
1320
1321       /* we only support printable text - therefore we enforce the use
1322          of only printable characters (an empty value is valid) */
1323       for(s++; *s ; s++ )
1324         {
1325           if ( !isascii (*s) )
1326             highbit=1;
1327           else if (iscntrl(*s))
1328             {
1329               log_error(_("a notation value must not use any"
1330                           " control characters\n"));
1331               goto fail;
1332             }
1333         }
1334
1335       if(!highbit || is_utf8)
1336         notation->value=xstrdup(i);
1337       else
1338         notation->value=native_to_utf8(i);
1339     }
1340
1341   return notation;
1342
1343  fail:
1344   free_notation(notation);
1345   return NULL;
1346 }
1347
1348 /* Like string_to_notation, but store opaque data rather than human
1349    readable data.  */
1350 struct notation *
1351 blob_to_notation(const char *name, const char *data, size_t len)
1352 {
1353   const char *s;
1354   int saw_at=0;
1355   struct notation *notation;
1356
1357   notation=xmalloc_clear(sizeof(*notation));
1358
1359   if(*name=='-')
1360     {
1361       notation->flags.ignore=1;
1362       name++;
1363     }
1364
1365   if(*name=='!')
1366     {
1367       notation->flags.critical=1;
1368       name++;
1369     }
1370
1371   /* If and when the IETF assigns some official name tags, we'll have
1372      to add them here. */
1373
1374   for( s=name ; *s; s++ )
1375     {
1376       if( *s=='@')
1377         saw_at++;
1378
1379       /* -notationname is legal without an = sign */
1380       if(!*s && notation->flags.ignore)
1381         break;
1382
1383       if (*s == '=')
1384         {
1385           log_error(_("a notation name may not contain an '=' character\n"));
1386           goto fail;
1387         }
1388
1389       if (!isascii (*s) || (!isgraph(*s) && !isspace(*s)))
1390         {
1391           log_error(_("a notation name must have only printable characters"
1392                       " or spaces\n") );
1393           goto fail;
1394         }
1395     }
1396
1397   notation->name=xstrdup (name);
1398
1399   if(!saw_at && !opt.expert)
1400     {
1401       log_error(_("a user notation name must contain the '@' character\n"));
1402       goto fail;
1403     }
1404
1405   if (saw_at > 1)
1406     {
1407       log_error(_("a notation name must not contain more than"
1408                   " one '@' character\n"));
1409       goto fail;
1410     }
1411
1412   notation->bdat = xmalloc (len);
1413   memcpy (notation->bdat, data, len);
1414   notation->blen = len;
1415
1416   notation->value = notation_value_to_human_readable_string (notation);
1417
1418   return notation;
1419
1420  fail:
1421   free_notation(notation);
1422   return NULL;
1423 }
1424
1425 struct notation *
1426 sig_to_notation(PKT_signature *sig)
1427 {
1428   const byte *p;
1429   size_t len;
1430   int seq = 0;
1431   int crit;
1432   notation_t list = NULL;
1433
1434   /* See RFC 4880, 5.2.3.16 for the format of notation data.  In
1435      short, a notation has:
1436
1437        - 4 bytes of flags
1438        - 2 byte name length (n1)
1439        - 2 byte value length (n2)
1440        - n1 bytes of name data
1441        - n2 bytes of value data
1442    */
1443   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
1444     {
1445       int n1,n2;
1446       struct notation *n=NULL;
1447
1448       if(len<8)
1449         {
1450           log_info(_("WARNING: invalid notation data found\n"));
1451           continue;
1452         }
1453
1454       /* name length.  */
1455       n1=(p[4]<<8)|p[5];
1456       /* value length.  */
1457       n2=(p[6]<<8)|p[7];
1458
1459       if(8+n1+n2!=len)
1460         {
1461           log_info(_("WARNING: invalid notation data found\n"));
1462           continue;
1463         }
1464
1465       n=xmalloc_clear(sizeof(*n));
1466       n->name=xmalloc(n1+1);
1467
1468       memcpy(n->name,&p[8],n1);
1469       n->name[n1]='\0';
1470
1471       if(p[0]&0x80)
1472         /* The value is human-readable.  */
1473         {
1474           n->value=xmalloc(n2+1);
1475           memcpy(n->value,&p[8+n1],n2);
1476           n->value[n2]='\0';
1477           n->flags.human = 1;
1478         }
1479       else
1480         /* Binary data.  */
1481         {
1482           n->bdat=xmalloc(n2);
1483           n->blen=n2;
1484           memcpy(n->bdat,&p[8+n1],n2);
1485
1486           n->value = notation_value_to_human_readable_string (n);
1487         }
1488
1489       n->flags.critical=crit;
1490
1491       n->next=list;
1492       list=n;
1493     }
1494
1495   return list;
1496 }
1497
1498 /* Release the resources associated with the *list* of notations.  To
1499    release a single notation, make sure that notation->next is
1500    NULL.  */
1501 void
1502 free_notation(struct notation *notation)
1503 {
1504   while(notation)
1505     {
1506       struct notation *n=notation;
1507
1508       xfree(n->name);
1509       xfree(n->value);
1510       xfree(n->altvalue);
1511       xfree(n->bdat);
1512       notation=n->next;
1513       xfree(n);
1514     }
1515 }
1516
1517 /* Serialize the signature packet (RFC 4880, Section 5.2) described by
1518    SIG and write it to OUT.  */
1519 static int
1520 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1521 {
1522   int rc = 0;
1523   int n, i;
1524   IOBUF a = iobuf_temp();
1525
1526   log_assert (ctb_pkttype (ctb) == PKT_SIGNATURE);
1527
1528   if ( !sig->version || sig->version == 3)
1529     {
1530       iobuf_put( a, 3 );
1531
1532       /* Version 3 packets don't support subpackets.  */
1533       log_assert (! sig->hashed);
1534       log_assert (! sig->unhashed);
1535     }
1536   else
1537     iobuf_put( a, sig->version );
1538   if ( sig->version < 4 )
1539     iobuf_put (a, 5 ); /* Constant used by pre-v4 signatures. */
1540   iobuf_put (a, sig->sig_class );
1541   if ( sig->version < 4 )
1542     {
1543       write_32(a, sig->timestamp );
1544       write_32(a, sig->keyid[0] );
1545       write_32(a, sig->keyid[1] );
1546     }
1547   iobuf_put(a, sig->pubkey_algo );
1548   iobuf_put(a, sig->digest_algo );
1549   if ( sig->version >= 4 )
1550     {
1551       size_t nn;
1552       /* Timestamp and keyid must have been packed into the subpackets
1553          prior to the call of this function, because these subpackets
1554          are hashed. */
1555       nn = sig->hashed? sig->hashed->len : 0;
1556       write_16(a, nn);
1557       if (nn)
1558         iobuf_write( a, sig->hashed->data, nn );
1559       nn = sig->unhashed? sig->unhashed->len : 0;
1560       write_16(a, nn);
1561       if (nn)
1562         iobuf_write( a, sig->unhashed->data, nn );
1563     }
1564   iobuf_put(a, sig->digest_start[0] );
1565   iobuf_put(a, sig->digest_start[1] );
1566   n = pubkey_get_nsig( sig->pubkey_algo );
1567   if ( !n )
1568     write_fake_data( a, sig->data[0] );
1569   for (i=0; i < n && !rc ; i++ )
1570     rc = gpg_mpi_write (a, sig->data[i] );
1571
1572   if (!rc)
1573     {
1574       if ( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1575         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1576       else
1577         write_header(out, ctb, iobuf_get_temp_length(a) );
1578       rc = iobuf_write_temp( out, a );
1579     }
1580
1581   iobuf_close(a);
1582   return rc;
1583 }
1584
1585
1586 /* Serialize the one-pass signature packet (RFC 4880, Section 5.4)
1587    described by OPS and write it to OUT.  */
1588 static int
1589 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1590 {
1591     log_assert (ctb_pkttype (ctb) == PKT_ONEPASS_SIG);
1592
1593     write_header(out, ctb, 4 + 8 + 1);
1594
1595     iobuf_put (out, 3);  /* Version.  */
1596     iobuf_put(out, ops->sig_class );
1597     iobuf_put(out, ops->digest_algo );
1598     iobuf_put(out, ops->pubkey_algo );
1599     write_32(out, ops->keyid[0] );
1600     write_32(out, ops->keyid[1] );
1601     iobuf_put(out, ops->last );
1602
1603     return 0;
1604 }
1605
1606
1607 /* Write a 16-bit quantity to OUT in big endian order.  */
1608 static int
1609 write_16(IOBUF out, u16 a)
1610 {
1611     iobuf_put(out, a>>8);
1612     if( iobuf_put(out,a) )
1613         return -1;
1614     return 0;
1615 }
1616
1617 /* Write a 32-bit quantity to OUT in big endian order.  */
1618 static int
1619 write_32(IOBUF out, u32 a)
1620 {
1621     iobuf_put(out, a>> 24);
1622     iobuf_put(out, a>> 16);
1623     iobuf_put(out, a>> 8);
1624     return iobuf_put(out, a);
1625 }
1626
1627
1628 /****************
1629  * calculate the length of a header.
1630  *
1631  * LEN is the length of the packet's body.  NEW_CTB is whether we are
1632  * using a new or old format packet.
1633  *
1634  * This function does not handle indeterminate lengths or partial body
1635  * lengths.  (If you pass LEN as 0, then this function assumes you
1636  * really mean an empty body.)
1637  */
1638 static int
1639 calc_header_length( u32 len, int new_ctb )
1640 {
1641     if( new_ctb ) {
1642         if( len < 192 )
1643             return 2;
1644         if( len < 8384 )
1645             return 3;
1646         else
1647             return 6;
1648     }
1649     if( len < 256 )
1650         return 2;
1651     if( len < 65536 )
1652         return 3;
1653
1654     return 5;
1655 }
1656
1657 /****************
1658  * Write the CTB and the packet length
1659  */
1660 static int
1661 write_header( IOBUF out, int ctb, u32 len )
1662 {
1663     return write_header2( out, ctb, len, 0 );
1664 }
1665
1666
1667 static int
1668 write_sign_packet_header (IOBUF out, int ctb, u32 len)
1669 {
1670   (void)ctb;
1671
1672   /* Work around a bug in the pgp read function for signature packets,
1673      which are not correctly coded and silently assume at some point 2
1674      byte length headers.*/
1675   iobuf_put (out, 0x89 );
1676   iobuf_put (out, len >> 8 );
1677   return iobuf_put (out, len) == -1 ? -1:0;
1678 }
1679
1680 /****************
1681  * Write a packet header to OUT.
1682  *
1683  * CTB is the ctb.  It determines whether a new or old format packet
1684  * header should be written.  The length field is adjusted, but the
1685  * CTB is otherwise written out as is.
1686  *
1687  * LEN is the length of the packet's body.
1688  *
1689  * If HDRLEN is set, then we don't necessarily use the most efficient
1690  * encoding to store LEN, but the specified length.  (If this is not
1691  * possible, this is a bug.)  In this case, LEN=0 means a 0 length
1692  * packet.  Note: setting HDRLEN is only supported for old format
1693  * packets!
1694  *
1695  * If HDRLEN is not set, then the shortest encoding is used.  In this
1696  * case, LEN=0 means the body has an indeterminate length and a
1697  * partial body length header (if a new format packet) or an
1698  * indeterminate length header (if an old format packet) is written
1699  * out.  Further, if using partial body lengths, this enables partial
1700  * body length mode on OUT.
1701  */
1702 static int
1703 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1704 {
1705   if (ctb_new_format_p (ctb))
1706     return write_new_header( out, ctb, len, hdrlen );
1707
1708   /* An old format packet.  Refer to RFC 4880, Section 4.2.1 to
1709      understand how lengths are encoded in this case.  */
1710
1711   /* The length encoding is stored in the two least significant bits.
1712      Make sure they are cleared.  */
1713   log_assert ((ctb & 3) == 0);
1714
1715   log_assert (hdrlen == 0 || hdrlen == 2 || hdrlen == 3 || hdrlen == 5);
1716
1717   if (hdrlen)
1718     /* Header length is given.  */
1719     {
1720       if( hdrlen == 2 && len < 256 )
1721         /* 00 => 1 byte length.  */
1722         ;
1723       else if( hdrlen == 3 && len < 65536 )
1724         /* 01 => 2 byte length.  If len < 256, this is not the most
1725            compact encoding, but it is a correct encoding.  */
1726         ctb |= 1;
1727       else if (hdrlen == 5)
1728         /* 10 => 4 byte length.  If len < 65536, this is not the most
1729            compact encoding, but it is a correct encoding.  */
1730         ctb |= 2;
1731       else
1732         log_bug ("Can't encode length=%d in a %d byte header!\n",
1733                  len, hdrlen);
1734     }
1735   else
1736     {
1737       if( !len )
1738         /* 11 => Indeterminate length.  */
1739         ctb |= 3;
1740       else if( len < 256 )
1741         /* 00 => 1 byte length.  */
1742         ;
1743       else if( len < 65536 )
1744         /* 01 => 2 byte length.  */
1745         ctb |= 1;
1746       else
1747         /* 10 => 4 byte length.  */
1748         ctb |= 2;
1749     }
1750
1751   if( iobuf_put(out, ctb ) )
1752     return -1;
1753
1754   if( len || hdrlen )
1755     {
1756       if( ctb & 2 )
1757         {
1758           if(iobuf_put(out, len >> 24 ))
1759             return -1;
1760           if(iobuf_put(out, len >> 16 ))
1761             return -1;
1762         }
1763
1764       if( ctb & 3 )
1765         if(iobuf_put(out, len >> 8 ))
1766           return -1;
1767
1768       if( iobuf_put(out, len ) )
1769         return -1;
1770     }
1771
1772   return 0;
1773 }
1774
1775
1776 /* Write a new format header to OUT.
1777
1778    CTB is the ctb.
1779
1780    LEN is the length of the packet's body.  If LEN is 0, then enables
1781    partial body length mode (i.e., the body is of an indeterminant
1782    length) on OUT.  Note: this function cannot be used to generate a
1783    header for a zero length packet.
1784
1785    HDRLEN is the length of the packet's header.  If HDRLEN is 0, the
1786    shortest encoding is chosen based on the length of the packet's
1787    body.  Currently, values other than 0 are not supported.
1788
1789    Returns 0 on success.  */
1790 static int
1791 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1792 {
1793     if( hdrlen )
1794         log_bug("can't cope with hdrlen yet\n");
1795
1796     if( iobuf_put(out, ctb ) )
1797         return -1;
1798     if( !len ) {
1799         iobuf_set_partial_body_length_mode(out, 512 );
1800     }
1801     else {
1802         if( len < 192 ) {
1803             if( iobuf_put(out, len ) )
1804                 return -1;
1805         }
1806         else if( len < 8384 ) {
1807             len -= 192;
1808             if( iobuf_put( out, (len / 256) + 192) )
1809                 return -1;
1810             if( iobuf_put( out, (len % 256) )  )
1811                 return -1;
1812         }
1813         else {
1814             if( iobuf_put( out, 0xff ) )
1815                 return -1;
1816             if( iobuf_put( out, (len >> 24)&0xff ) )
1817                 return -1;
1818             if( iobuf_put( out, (len >> 16)&0xff ) )
1819                 return -1;
1820             if( iobuf_put( out, (len >> 8)&0xff )  )
1821                 return -1;
1822             if( iobuf_put( out, len & 0xff ) )
1823                 return -1;
1824         }
1825     }
1826     return 0;
1827 }