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