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