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