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