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