gpg: Do not abort on certain invalid packets.
[gnupg.git] / g10 / build-packet.c
1 /* build-packet.c - assemble packets and write them
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2010, 2011  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <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  * Hmmm, should we delete those subpackets which are in a wrong area?
978  */
979 void
980 build_sig_subpkt_from_sig( PKT_signature *sig )
981 {
982     u32  u;
983     byte buf[8];
984
985     u = sig->keyid[0];
986     buf[0] = (u >> 24) & 0xff;
987     buf[1] = (u >> 16) & 0xff;
988     buf[2] = (u >>  8) & 0xff;
989     buf[3] = u & 0xff;
990     u = sig->keyid[1];
991     buf[4] = (u >> 24) & 0xff;
992     buf[5] = (u >> 16) & 0xff;
993     buf[6] = (u >>  8) & 0xff;
994     buf[7] = u & 0xff;
995     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
996
997     u = sig->timestamp;
998     buf[0] = (u >> 24) & 0xff;
999     buf[1] = (u >> 16) & 0xff;
1000     buf[2] = (u >>  8) & 0xff;
1001     buf[3] = u & 0xff;
1002     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
1003
1004     if(sig->expiredate)
1005       {
1006         if(sig->expiredate>sig->timestamp)
1007           u=sig->expiredate-sig->timestamp;
1008         else
1009           u=1; /* A 1-second expiration time is the shortest one
1010                   OpenPGP has */
1011
1012         buf[0] = (u >> 24) & 0xff;
1013         buf[1] = (u >> 16) & 0xff;
1014         buf[2] = (u >>  8) & 0xff;
1015         buf[3] = u & 0xff;
1016
1017         /* Mark this CRITICAL, so if any implementation doesn't
1018            understand sigs that can expire, it'll just disregard this
1019            sig altogether. */
1020
1021         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
1022                           buf, 4 );
1023       }
1024 }
1025
1026 void
1027 build_attribute_subpkt(PKT_user_id *uid,byte type,
1028                        const void *buf,u32 buflen,
1029                        const void *header,u32 headerlen)
1030 {
1031   byte *attrib;
1032   int idx;
1033
1034   if(1+headerlen+buflen>8383)
1035     idx=5;
1036   else if(1+headerlen+buflen>191)
1037     idx=2;
1038   else
1039     idx=1;
1040
1041   /* realloc uid->attrib_data to the right size */
1042
1043   uid->attrib_data=xrealloc(uid->attrib_data,
1044                              uid->attrib_len+idx+1+headerlen+buflen);
1045
1046   attrib=&uid->attrib_data[uid->attrib_len];
1047
1048   if(idx==5)
1049     {
1050       attrib[0]=255;
1051       attrib[1]=(1+headerlen+buflen) >> 24;
1052       attrib[2]=(1+headerlen+buflen) >> 16;
1053       attrib[3]=(1+headerlen+buflen) >> 8;
1054       attrib[4]=1+headerlen+buflen;
1055     }
1056   else if(idx==2)
1057     {
1058       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
1059       attrib[1]=(1+headerlen+buflen-192) % 256;
1060     }
1061   else
1062     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
1063
1064   attrib[idx++]=type;
1065
1066   /* Tack on our data at the end */
1067
1068   if(headerlen>0)
1069     memcpy(&attrib[idx],header,headerlen);
1070   memcpy(&attrib[idx+headerlen],buf,buflen);
1071   uid->attrib_len+=idx+headerlen+buflen;
1072 }
1073
1074 /* Returns a human-readable string corresponding to the notation.
1075    This ignores notation->value.  The caller must free the result.  */
1076 static char *
1077 notation_value_to_human_readable_string (struct notation *notation)
1078 {
1079   if(notation->bdat)
1080     /* Binary data.  */
1081     {
1082       size_t len = notation->blen;
1083       int i;
1084       char preview[20];
1085
1086       for (i = 0; i < len && i < sizeof (preview) - 1; i ++)
1087         if (isprint (notation->bdat[i]))
1088           preview[i] = notation->bdat[i];
1089         else
1090           preview[i] = '?';
1091       preview[i] = 0;
1092
1093       return xasprintf (_("[ not human readable (%zu bytes: %s%s) ]"),
1094                         len, preview, i < len ? "..." : "");
1095     }
1096   else
1097     /* The value is human-readable.  */
1098     return xstrdup (notation->value);
1099 }
1100
1101 /* Turn the notation described by the string STRING into a notation.
1102
1103    STRING has the form:
1104
1105      - -name - Delete the notation.
1106      - name@domain.name=value - Normal notation
1107      - !name@domain.name=value - Notation with critical bit set.
1108
1109    The caller must free the result using free_notation().  */
1110 struct notation *
1111 string_to_notation(const char *string,int is_utf8)
1112 {
1113   const char *s;
1114   int saw_at=0;
1115   struct notation *notation;
1116
1117   notation=xmalloc_clear(sizeof(*notation));
1118
1119   if(*string=='-')
1120     {
1121       notation->flags.ignore=1;
1122       string++;
1123     }
1124
1125   if(*string=='!')
1126     {
1127       notation->flags.critical=1;
1128       string++;
1129     }
1130
1131   /* If and when the IETF assigns some official name tags, we'll have
1132      to add them here. */
1133
1134   for( s=string ; *s != '='; s++ )
1135     {
1136       if( *s=='@')
1137         saw_at++;
1138
1139       /* -notationname is legal without an = sign */
1140       if(!*s && notation->flags.ignore)
1141         break;
1142
1143       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
1144         {
1145           log_error(_("a notation name must have only printable characters"
1146                       " or spaces, and end with an '='\n") );
1147           goto fail;
1148         }
1149     }
1150
1151   notation->name=xmalloc((s-string)+1);
1152   strncpy(notation->name,string,s-string);
1153   notation->name[s-string]='\0';
1154
1155   if(!saw_at && !opt.expert)
1156     {
1157       log_error(_("a user notation name must contain the '@' character\n"));
1158       goto fail;
1159     }
1160
1161   if (saw_at > 1)
1162     {
1163       log_error(_("a notation name must not contain more than"
1164                   " one '@' character\n"));
1165       goto fail;
1166     }
1167
1168   if(*s)
1169     {
1170       const char *i=s+1;
1171       int highbit=0;
1172
1173       /* we only support printable text - therefore we enforce the use
1174          of only printable characters (an empty value is valid) */
1175       for(s++; *s ; s++ )
1176         {
1177           if ( !isascii (*s) )
1178             highbit=1;
1179           else if (iscntrl(*s))
1180             {
1181               log_error(_("a notation value must not use any"
1182                           " control characters\n"));
1183               goto fail;
1184             }
1185         }
1186
1187       if(!highbit || is_utf8)
1188         notation->value=xstrdup(i);
1189       else
1190         notation->value=native_to_utf8(i);
1191     }
1192
1193   return notation;
1194
1195  fail:
1196   free_notation(notation);
1197   return NULL;
1198 }
1199
1200 /* Like string_to_notation, but store opaque data rather than human
1201    readable data.  */
1202 struct notation *
1203 blob_to_notation(const char *name, const char *data, size_t len)
1204 {
1205   const char *s;
1206   int saw_at=0;
1207   struct notation *notation;
1208
1209   notation=xmalloc_clear(sizeof(*notation));
1210
1211   if(*name=='-')
1212     {
1213       notation->flags.ignore=1;
1214       name++;
1215     }
1216
1217   if(*name=='!')
1218     {
1219       notation->flags.critical=1;
1220       name++;
1221     }
1222
1223   /* If and when the IETF assigns some official name tags, we'll have
1224      to add them here. */
1225
1226   for( s=name ; *s; s++ )
1227     {
1228       if( *s=='@')
1229         saw_at++;
1230
1231       /* -notationname is legal without an = sign */
1232       if(!*s && notation->flags.ignore)
1233         break;
1234
1235       if (*s == '=')
1236         {
1237           log_error(_("a notation name may not contain an '=' character\n"));
1238           goto fail;
1239         }
1240
1241       if (!isascii (*s) || (!isgraph(*s) && !isspace(*s)))
1242         {
1243           log_error(_("a notation name must have only printable characters"
1244                       " or spaces\n") );
1245           goto fail;
1246         }
1247     }
1248
1249   notation->name=xstrdup (name);
1250
1251   if(!saw_at && !opt.expert)
1252     {
1253       log_error(_("a user notation name must contain the '@' character\n"));
1254       goto fail;
1255     }
1256
1257   if (saw_at > 1)
1258     {
1259       log_error(_("a notation name must not contain more than"
1260                   " one '@' character\n"));
1261       goto fail;
1262     }
1263
1264   notation->bdat = xmalloc (len);
1265   memcpy (notation->bdat, data, len);
1266   notation->blen = len;
1267
1268   notation->value = notation_value_to_human_readable_string (notation);
1269
1270   return notation;
1271
1272  fail:
1273   free_notation(notation);
1274   return NULL;
1275 }
1276
1277 struct notation *
1278 sig_to_notation(PKT_signature *sig)
1279 {
1280   const byte *p;
1281   size_t len;
1282   int seq = 0;
1283   int crit;
1284   notation_t list = NULL;
1285
1286   /* See RFC 4880, 5.2.3.16 for the format of notation data.  In
1287      short, a notation has:
1288
1289        - 4 bytes of flags
1290        - 2 byte name length (n1)
1291        - 2 byte value length (n2)
1292        - n1 bytes of name data
1293        - n2 bytes of value data
1294    */
1295   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
1296     {
1297       int n1,n2;
1298       struct notation *n=NULL;
1299
1300       if(len<8)
1301         {
1302           log_info(_("WARNING: invalid notation data found\n"));
1303           continue;
1304         }
1305
1306       /* name length.  */
1307       n1=(p[4]<<8)|p[5];
1308       /* value length.  */
1309       n2=(p[6]<<8)|p[7];
1310
1311       if(8+n1+n2!=len)
1312         {
1313           log_info(_("WARNING: invalid notation data found\n"));
1314           continue;
1315         }
1316
1317       n=xmalloc_clear(sizeof(*n));
1318       n->name=xmalloc(n1+1);
1319
1320       memcpy(n->name,&p[8],n1);
1321       n->name[n1]='\0';
1322
1323       if(p[0]&0x80)
1324         /* The value is human-readable.  */
1325         {
1326           n->value=xmalloc(n2+1);
1327           memcpy(n->value,&p[8+n1],n2);
1328           n->value[n2]='\0';
1329           n->flags.human = 1;
1330         }
1331       else
1332         /* Binary data.  */
1333         {
1334           n->bdat=xmalloc(n2);
1335           n->blen=n2;
1336           memcpy(n->bdat,&p[8+n1],n2);
1337
1338           n->value = notation_value_to_human_readable_string (n);
1339         }
1340
1341       n->flags.critical=crit;
1342
1343       n->next=list;
1344       list=n;
1345     }
1346
1347   return list;
1348 }
1349
1350 /* Release the resources associated with the *list* of notations.  To
1351    release a single notation, make sure that notation->next is
1352    NULL.  */
1353 void
1354 free_notation(struct notation *notation)
1355 {
1356   while(notation)
1357     {
1358       struct notation *n=notation;
1359
1360       xfree(n->name);
1361       xfree(n->value);
1362       xfree(n->altvalue);
1363       xfree(n->bdat);
1364       notation=n->next;
1365       xfree(n);
1366     }
1367 }
1368
1369 /* Serialize the signature packet (RFC 4880, Section 5.2) described by
1370    SIG and write it to OUT.  */
1371 static int
1372 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1373 {
1374   int rc = 0;
1375   int n, i;
1376   IOBUF a = iobuf_temp();
1377
1378   log_assert (ctb_pkttype (ctb) == PKT_SIGNATURE);
1379
1380   if ( !sig->version || sig->version == 3)
1381     {
1382       iobuf_put( a, 3 );
1383
1384       /* Version 3 packets don't support subpackets.  */
1385       log_assert (! sig->hashed);
1386       log_assert (! sig->unhashed);
1387     }
1388   else
1389     iobuf_put( a, sig->version );
1390   if ( sig->version < 4 )
1391     iobuf_put (a, 5 ); /* Constant */
1392   iobuf_put (a, sig->sig_class );
1393   if ( sig->version < 4 )
1394     {
1395       write_32(a, sig->timestamp );
1396       write_32(a, sig->keyid[0] );
1397       write_32(a, sig->keyid[1] );
1398     }
1399   iobuf_put(a, sig->pubkey_algo );
1400   iobuf_put(a, sig->digest_algo );
1401   if ( sig->version >= 4 )
1402     {
1403       size_t nn;
1404       /* Timestamp and keyid must have been packed into the subpackets
1405          prior to the call of this function, because these subpackets
1406          are hashed. */
1407       nn = sig->hashed? sig->hashed->len : 0;
1408       write_16(a, nn);
1409       if (nn)
1410         iobuf_write( a, sig->hashed->data, nn );
1411       nn = sig->unhashed? sig->unhashed->len : 0;
1412       write_16(a, nn);
1413       if (nn)
1414         iobuf_write( a, sig->unhashed->data, nn );
1415     }
1416   iobuf_put(a, sig->digest_start[0] );
1417   iobuf_put(a, sig->digest_start[1] );
1418   n = pubkey_get_nsig( sig->pubkey_algo );
1419   if ( !n )
1420     write_fake_data( a, sig->data[0] );
1421   for (i=0; i < n && !rc ; i++ )
1422     rc = gpg_mpi_write (a, sig->data[i] );
1423
1424   if (!rc)
1425     {
1426       if ( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1427         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1428       else
1429         write_header(out, ctb, iobuf_get_temp_length(a) );
1430       rc = iobuf_write_temp( out, a );
1431     }
1432
1433   iobuf_close(a);
1434   return rc;
1435 }
1436
1437
1438 /* Serialize the one-pass signature packet (RFC 4880, Section 5.4)
1439    described by OPS and write it to OUT.  */
1440 static int
1441 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1442 {
1443     log_assert (ctb_pkttype (ctb) == PKT_ONEPASS_SIG);
1444
1445     write_header(out, ctb, 4 + 8 + 1);
1446
1447     iobuf_put (out, 3);  /* Version.  */
1448     iobuf_put(out, ops->sig_class );
1449     iobuf_put(out, ops->digest_algo );
1450     iobuf_put(out, ops->pubkey_algo );
1451     write_32(out, ops->keyid[0] );
1452     write_32(out, ops->keyid[1] );
1453     iobuf_put(out, ops->last );
1454
1455     return 0;
1456 }
1457
1458
1459 /* Write a 16-bit quantity to OUT in big endian order.  */
1460 static int
1461 write_16(IOBUF out, u16 a)
1462 {
1463     iobuf_put(out, a>>8);
1464     if( iobuf_put(out,a) )
1465         return -1;
1466     return 0;
1467 }
1468
1469 /* Write a 32-bit quantity to OUT in big endian order.  */
1470 static int
1471 write_32(IOBUF out, u32 a)
1472 {
1473     iobuf_put(out, a>> 24);
1474     iobuf_put(out, a>> 16);
1475     iobuf_put(out, a>> 8);
1476     return iobuf_put(out, a);
1477 }
1478
1479
1480 /****************
1481  * calculate the length of a header.
1482  *
1483  * LEN is the length of the packet's body.  NEW_CTB is whether we are
1484  * using a new or old format packet.
1485  *
1486  * This function does not handle indeterminate lengths or partial body
1487  * lengths.  (If you pass LEN as 0, then this function assumes you
1488  * really mean an empty body.)
1489  */
1490 static int
1491 calc_header_length( u32 len, int new_ctb )
1492 {
1493     if( new_ctb ) {
1494         if( len < 192 )
1495             return 2;
1496         if( len < 8384 )
1497             return 3;
1498         else
1499             return 6;
1500     }
1501     if( len < 256 )
1502         return 2;
1503     if( len < 65536 )
1504         return 3;
1505
1506     return 5;
1507 }
1508
1509 /****************
1510  * Write the CTB and the packet length
1511  */
1512 static int
1513 write_header( IOBUF out, int ctb, u32 len )
1514 {
1515     return write_header2( out, ctb, len, 0 );
1516 }
1517
1518
1519 static int
1520 write_sign_packet_header (IOBUF out, int ctb, u32 len)
1521 {
1522   (void)ctb;
1523
1524   /* Work around a bug in the pgp read function for signature packets,
1525      which are not correctly coded and silently assume at some point 2
1526      byte length headers.*/
1527   iobuf_put (out, 0x89 );
1528   iobuf_put (out, len >> 8 );
1529   return iobuf_put (out, len) == -1 ? -1:0;
1530 }
1531
1532 /****************
1533  * Write a packet header to OUT.
1534  *
1535  * CTB is the ctb.  It determines whether a new or old format packet
1536  * header should be written.  The length field is adjusted, but the
1537  * CTB is otherwise written out as is.
1538  *
1539  * LEN is the length of the packet's body.
1540  *
1541  * If HDRLEN is set, then we don't necessarily use the most efficient
1542  * encoding to store LEN, but the specified length.  (If this is not
1543  * possible, this is a bug.)  In this case, LEN=0 means a 0 length
1544  * packet.  Note: setting HDRLEN is only supported for old format
1545  * packets!
1546  *
1547  * If HDRLEN is not set, then the shortest encoding is used.  In this
1548  * case, LEN=0 means the body has an indeterminate length and a
1549  * partial body length header (if a new format packet) or an
1550  * indeterminate length header (if an old format packet) is written
1551  * out.  Further, if using partial body lengths, this enables partial
1552  * body length mode on OUT.
1553  */
1554 static int
1555 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1556 {
1557   if (ctb_new_format_p (ctb))
1558     return write_new_header( out, ctb, len, hdrlen );
1559
1560   /* An old format packet.  Refer to RFC 4880, Section 4.2.1 to
1561      understand how lengths are encoded in this case.  */
1562
1563   /* The length encoding is stored in the two least significant bits.
1564      Make sure they are cleared.  */
1565   log_assert ((ctb & 3) == 0);
1566
1567   log_assert (hdrlen == 0 || hdrlen == 2 || hdrlen == 3 || hdrlen == 5);
1568
1569   if (hdrlen)
1570     /* Header length is given.  */
1571     {
1572       if( hdrlen == 2 && len < 256 )
1573         /* 00 => 1 byte length.  */
1574         ;
1575       else if( hdrlen == 3 && len < 65536 )
1576         /* 01 => 2 byte length.  If len < 256, this is not the most
1577            compact encoding, but it is a correct encoding.  */
1578         ctb |= 1;
1579       else if (hdrlen == 5)
1580         /* 10 => 4 byte length.  If len < 65536, this is not the most
1581            compact encoding, but it is a correct encoding.  */
1582         ctb |= 2;
1583       else
1584         log_bug ("Can't encode length=%d in a %d byte header!\n",
1585                  len, hdrlen);
1586     }
1587   else
1588     {
1589       if( !len )
1590         /* 11 => Indeterminate length.  */
1591         ctb |= 3;
1592       else if( len < 256 )
1593         /* 00 => 1 byte length.  */
1594         ;
1595       else if( len < 65536 )
1596         /* 01 => 2 byte length.  */
1597         ctb |= 1;
1598       else
1599         /* 10 => 4 byte length.  */
1600         ctb |= 2;
1601     }
1602
1603   if( iobuf_put(out, ctb ) )
1604     return -1;
1605
1606   if( len || hdrlen )
1607     {
1608       if( ctb & 2 )
1609         {
1610           if(iobuf_put(out, len >> 24 ))
1611             return -1;
1612           if(iobuf_put(out, len >> 16 ))
1613             return -1;
1614         }
1615
1616       if( ctb & 3 )
1617         if(iobuf_put(out, len >> 8 ))
1618           return -1;
1619
1620       if( iobuf_put(out, len ) )
1621         return -1;
1622     }
1623
1624   return 0;
1625 }
1626
1627
1628 /* Write a new format header to OUT.
1629
1630    CTB is the ctb.
1631
1632    LEN is the length of the packet's body.  If LEN is 0, then enables
1633    partial body length mode (i.e., the body is of an indeterminant
1634    length) on OUT.  Note: this function cannot be used to generate a
1635    header for a zero length packet.
1636
1637    HDRLEN is the length of the packet's header.  If HDRLEN is 0, the
1638    shortest encoding is chosen based on the length of the packet's
1639    body.  Currently, values other than 0 are not supported.
1640
1641    Returns 0 on success.  */
1642 static int
1643 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1644 {
1645     if( hdrlen )
1646         log_bug("can't cope with hdrlen yet\n");
1647
1648     if( iobuf_put(out, ctb ) )
1649         return -1;
1650     if( !len ) {
1651         iobuf_set_partial_body_length_mode(out, 512 );
1652     }
1653     else {
1654         if( len < 192 ) {
1655             if( iobuf_put(out, len ) )
1656                 return -1;
1657         }
1658         else if( len < 8384 ) {
1659             len -= 192;
1660             if( iobuf_put( out, (len / 256) + 192) )
1661                 return -1;
1662             if( iobuf_put( out, (len % 256) )  )
1663                 return -1;
1664         }
1665         else {
1666             if( iobuf_put( out, 0xff ) )
1667                 return -1;
1668             if( iobuf_put( out, (len >> 24)&0xff ) )
1669                 return -1;
1670             if( iobuf_put( out, (len >> 16)&0xff ) )
1671                 return -1;
1672             if( iobuf_put( out, (len >> 8)&0xff )  )
1673                 return -1;
1674             if( iobuf_put( out, len & 0xff ) )
1675                 return -1;
1676         }
1677     }
1678     return 0;
1679 }