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