Function name cleanups
[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 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 "cipher.h"
34 #include "i18n.h"
35 #include "options.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 static int write_version( IOBUF out, int ctb );
57
58 /****************
59  * Build a packet and write it to INP
60  * Returns: 0 := okay
61  *         >0 := error
62  * Note: Caller must free the packet
63  */
64 int
65 build_packet( IOBUF out, PACKET *pkt )
66 {
67     int new_ctb=0, rc=0, ctb;
68     int pkttype;
69
70     if( DBG_PACKET )
71         log_debug("build_packet() type=%d\n", pkt->pkttype );
72     assert( pkt->pkt.generic );
73
74     switch ((pkttype = pkt->pkttype))
75       {
76       case PKT_PUBLIC_KEY:
77         if (pkt->pkt.public_key->seckey_info)
78           pkttype = PKT_SECRET_KEY;
79         break;
80       case PKT_PUBLIC_SUBKEY:
81         if (pkt->pkt.public_key->seckey_info)
82           pkttype = PKT_SECRET_SUBKEY;
83         break;
84       case PKT_PLAINTEXT: new_ctb = pkt->pkt.plaintext->new_ctb; break;
85       case PKT_ENCRYPTED:
86       case PKT_ENCRYPTED_MDC: new_ctb = pkt->pkt.encrypted->new_ctb; break;
87       case PKT_COMPRESSED:new_ctb = pkt->pkt.compressed->new_ctb; break;
88       case PKT_USER_ID:
89         if( pkt->pkt.user_id->attrib_data )
90           pkttype = PKT_ATTRIBUTE;
91         break;
92       default: break;
93       }
94
95     if( new_ctb || pkttype > 15 ) /* new format */
96         ctb = 0xc0 | (pkttype & 0x3f);
97     else
98         ctb = 0x80 | ((pkttype & 15)<<2);
99     switch( pkttype )
100       {
101       case PKT_ATTRIBUTE:
102       case PKT_USER_ID:
103         rc = do_user_id( out, ctb, pkt->pkt.user_id );
104         break;
105       case PKT_OLD_COMMENT:
106       case PKT_COMMENT:
107         /*
108           Ignore these.  Theoretically, this will never be called as
109           we have no way to output comment packets any longer, but
110           just in case there is some code path that would end up
111           outputting a comment that was written before comments were
112           dropped (in the public key?) this is a no-op.
113         */
114         break;
115       case PKT_PUBLIC_SUBKEY:
116       case PKT_PUBLIC_KEY:
117       case PKT_SECRET_SUBKEY:
118       case PKT_SECRET_KEY:
119         rc = do_key (out, ctb, pkt->pkt.public_key);
120         break;
121       case PKT_SYMKEY_ENC:
122         rc = do_symkey_enc( out, ctb, pkt->pkt.symkey_enc );
123         break;
124       case PKT_PUBKEY_ENC:
125         rc = do_pubkey_enc( out, ctb, pkt->pkt.pubkey_enc );
126         break;
127       case PKT_PLAINTEXT:
128         rc = do_plaintext( out, ctb, pkt->pkt.plaintext );
129         break;
130       case PKT_ENCRYPTED:
131         rc = do_encrypted( out, ctb, pkt->pkt.encrypted );
132         break;
133       case PKT_ENCRYPTED_MDC:
134         rc = do_encrypted_mdc( out, ctb, pkt->pkt.encrypted );
135         break;
136       case PKT_COMPRESSED:
137         rc = do_compressed( out, ctb, pkt->pkt.compressed );
138         break;
139       case PKT_SIGNATURE:
140         rc = do_signature( out, ctb, pkt->pkt.signature );
141         break;
142       case PKT_ONEPASS_SIG:
143         rc = do_onepass_sig( out, ctb, pkt->pkt.onepass_sig );
144         break;
145       case PKT_RING_TRUST:
146         break; /* ignore it (keyring.c does write it directly)*/
147       case PKT_MDC: /* we write it directly, so we should never see it here. */
148       default:
149         log_bug("invalid packet type in build_packet()\n");
150         break;
151       }
152
153     return rc;
154 }
155
156
157 /*
158  * Write the mpi A to OUT.
159  */
160 static int
161 mpi_write (iobuf_t out, gcry_mpi_t a)
162 {
163   char buffer[(MAX_EXTERN_MPI_BITS+7)/8+2]; /* 2 is for the mpi length. */
164   size_t nbytes;
165   int rc;
166
167   nbytes = DIM(buffer);
168   rc = gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, &nbytes, a );
169   if( !rc )
170     rc = iobuf_write( out, buffer, nbytes );
171   else if (gpg_err_code(rc) == GPG_ERR_TOO_SHORT )
172     {
173       log_info ("mpi too large (%u bits)\n", gcry_mpi_get_nbits (a));
174       /* The buffer was too small. We better tell the user about the MPI. */
175       rc = gpg_error (GPG_ERR_TOO_LARGE);
176     }
177
178   return rc;
179 }
180
181
182 /*
183  * Write a special size+body mpi A, to OUT.  The format of the content
184  * of the MPI is one byte LEN, following by LEN bytes.
185  */
186 gpg_error_t
187 write_size_body_mpi (iobuf_t out, gcry_mpi_t a)
188 {
189   gpg_error_t err;
190   byte buffer[256]; /* Fixed buffer for a public parameter, max possible */
191   size_t nbytes = (mpi_get_nbits (a)+7)/8;
192
193   if (nbytes > sizeof(buffer))
194     {
195       log_error("mpi with size+body is too large (%u bytes)\n", nbytes);
196       return gpg_error (GPG_ERR_TOO_LARGE);
197     }
198
199   err = gcry_mpi_print (GCRYMPI_FMT_USG, buffer, sizeof(buffer), &nbytes, a);
200   if (err)
201     {
202       log_error ("failed to exported size+body mpi\n");
203       return err;
204     }
205   if (nbytes < 2 || buffer[0] != nbytes-1)
206     {
207       if (nbytes > 2)
208         log_error ("internal size mismatch in mpi size+body: "
209                    "%02x != %02x (other bytes: %02x %02x ... %02x %02x)\n",
210                    buffer[0], nbytes-1, buffer[1], buffer[2], buffer[nbytes-2],
211                    buffer[nbytes-1]);
212       else
213         log_error ("internal size mismatch in mpi size+body: "
214                    "only %d bytes\n", nbytes);
215       return gpg_error (GPG_ERR_INV_DATA);
216   }
217   return iobuf_write (out, buffer, nbytes);
218 }
219
220
221 /* Calculate the length of a packet described by PKT.  */
222 u32
223 calc_packet_length( PACKET *pkt )
224 {
225     u32 n=0;
226     int new_ctb = 0;
227
228     assert( pkt->pkt.generic );
229     switch( pkt->pkttype ) {
230       case PKT_PLAINTEXT:
231         n = calc_plaintext( pkt->pkt.plaintext );
232         new_ctb = pkt->pkt.plaintext->new_ctb;
233         break;
234       case PKT_ATTRIBUTE:
235       case PKT_USER_ID:
236       case PKT_COMMENT:
237       case PKT_PUBLIC_KEY:
238       case PKT_SECRET_KEY:
239       case PKT_SYMKEY_ENC:
240       case PKT_PUBKEY_ENC:
241       case PKT_ENCRYPTED:
242       case PKT_SIGNATURE:
243       case PKT_ONEPASS_SIG:
244       case PKT_RING_TRUST:
245       case PKT_COMPRESSED:
246       default:
247         log_bug("invalid packet type in calc_packet_length()");
248         break;
249     }
250
251     n += calc_header_length(n, new_ctb);
252     return n;
253 }
254
255 static void
256 write_fake_data (IOBUF out, gcry_mpi_t a)
257 {
258   if (a)
259     {
260       unsigned int n;
261       void *p;
262
263       p = gcry_mpi_get_opaque ( a, &n );
264       iobuf_write (out, p, (n+7)/8 );
265     }
266 }
267
268 static int
269 do_user_id( IOBUF out, int ctb, PKT_user_id *uid )
270 {
271     int rc;
272
273     if( uid->attrib_data )
274       {
275         write_header(out, ctb, uid->attrib_len);
276         rc = iobuf_write( out, uid->attrib_data, uid->attrib_len );
277       }
278     else
279       {
280         write_header2( out, ctb, uid->len, 2 );
281         rc = iobuf_write( out, uid->name, uid->len );
282       }
283     return 0;
284 }
285
286
287 static int
288 do_key (iobuf_t out, int ctb, PKT_public_key *pk)
289 {
290   gpg_error_t err = 0;
291   int i, nskey, npkey;
292   iobuf_t a = iobuf_temp(); /* Build in a self-enlarging buffer.  */
293
294   /* Write the version number - if none is specified, use 3 */
295   if ( !pk->version )
296     iobuf_put ( a, 3 );
297   else
298     iobuf_put ( a, pk->version );
299   write_32 (a, pk->timestamp );
300
301   /* v3 needs the expiration time. */
302   if ( pk->version < 4 )
303     {
304       u16 ndays;
305       if ( pk->expiredate )
306         ndays = (u16)((pk->expiredate - pk->timestamp) / 86400L);
307       else
308         ndays = 0;
309       write_16(a, ndays);
310     }
311
312   iobuf_put (a, pk->pubkey_algo );
313
314   /* Get number of secret and public parameters.  They are held in one
315      array first the public ones, then the secret ones.  */
316   nskey = pubkey_get_nskey (pk->pubkey_algo);
317   npkey = pubkey_get_npkey (pk->pubkey_algo);
318
319   /* If we don't have any public parameters - which is the case if we
320      don't know the algorithm used - the parameters are stored as one
321      blob in a faked (opaque) MPI. */
322   if (!npkey)
323     {
324       write_fake_data (a, pk->pkey[0]);
325       goto leave;
326     }
327   assert (npkey < nskey);
328
329   /* Writing the public parameters is easy.  Except if we do an
330      adjustment for ECC OID and possibly KEK params for ECDH.  */
331   if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
332       || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
333     {
334       /* Write DER of OID with preceeding length byte.  */
335       err = write_size_body_mpi (a, pk->pkey[0]);
336       if (err)
337         goto leave;
338       /* Write point Q, the public key.  */
339       err = mpi_write (a, pk->pkey[1]);
340       if (err)
341         goto leave;
342
343       /* Write one more public field for ECDH.  */
344       if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
345         {
346           err = write_size_body_mpi (a, pk->pkey[2]);
347           if (err)
348             goto leave;
349         }
350     }
351   else
352     {
353       for (i=0; i < npkey; i++ )
354         if ((err = mpi_write (a, pk->pkey[i])))
355           goto leave;
356     }
357
358
359   if (pk->seckey_info)
360     {
361       /* This is a secret key packet.  */
362       struct seckey_info *ski = pk->seckey_info;
363
364       /* Build the header for protected (encrypted) secret parameters.  */
365       if (ski->is_protected)
366         {
367           if ( is_RSA (pk->pubkey_algo) && pk->version < 4 && !ski->s2k.mode )
368             {
369               /* The simple rfc1991 (v3) way. */
370               iobuf_put (a, ski->algo );
371               iobuf_write (a, ski->iv, ski->ivlen);
372             }
373           else
374             {
375               /* OpenPGP protection according to rfc2440. */
376               iobuf_put (a, ski->sha1chk? 0xfe : 0xff);
377               iobuf_put (a, ski->algo);
378               if (ski->s2k.mode >= 1000)
379                 {
380                   /* These modes are not possible in OpenPGP, we use
381                      them to implement our extensions, 101 can be
382                      viewed as a private/experimental extension (this
383                      is not specified in rfc2440 but the same scheme
384                      is used for all other algorithm identifiers). */
385                   iobuf_put (a, 101);
386                   iobuf_put (a, ski->s2k.hash_algo);
387                   iobuf_write (a, "GNU", 3 );
388                   iobuf_put (a, ski->s2k.mode - 1000);
389                 }
390               else
391                 {
392                   iobuf_put (a, ski->s2k.mode);
393                   iobuf_put (a, ski->s2k.hash_algo);
394                 }
395
396               if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
397                 iobuf_write (a, ski->s2k.salt, 8);
398
399               if (ski->s2k.mode == 3)
400                 iobuf_put (a, ski->s2k.count);
401
402               /* For our special modes 1001, 1002 we do not need an IV. */
403               if (ski->s2k.mode != 1001 && ski->s2k.mode != 1002)
404                 iobuf_write (a, ski->iv, ski->ivlen);
405             }
406         }
407       else /* Not protected. */
408         iobuf_put (a, 0 );
409
410       if (ski->s2k.mode == 1001)
411         ; /* GnuPG extension - don't write a secret key at all. */
412       else if (ski->s2k.mode == 1002)
413         {
414           /* GnuPG extension - divert to OpenPGP smartcard. */
415           /* Length of the serial number or 0 for no serial number. */
416           iobuf_put (a, ski->ivlen );
417           /* The serial number gets stored in the IV field.  */
418           iobuf_write (a, ski->iv, ski->ivlen);
419         }
420       else if (ski->is_protected && pk->version >= 4)
421         {
422           /* The secret key is protected - write it out as it is.  */
423           byte *p;
424           unsigned int ndatabits;
425
426           assert (gcry_mpi_get_flag (pk->pkey[npkey], GCRYMPI_FLAG_OPAQUE));
427           p = gcry_mpi_get_opaque (pk->pkey[npkey], &ndatabits);
428           iobuf_write (a, p, (ndatabits+7)/8 );
429         }
430       else if (ski->is_protected)
431         {
432           /* The secret key is protected the old v4 way. */
433           for ( ; i < nskey; i++ )
434             {
435               byte *p;
436               unsigned int ndatabits;
437
438               assert (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_OPAQUE));
439               p = gcry_mpi_get_opaque (pk->pkey[i], &ndatabits);
440               iobuf_write (a, p, (ndatabits+7)/8);
441             }
442           write_16 (a, ski->csum );
443         }
444       else
445         {
446           /* Non-protected key. */
447           for ( ; i < nskey; i++ )
448             if ( (err = mpi_write (a, pk->pkey[i])))
449               goto leave;
450           write_16 (a, ski->csum );
451         }
452     }
453
454  leave:
455   if (!err)
456     {
457       /* Build the header of the packet - which we must do after
458          writing all the other stuff, so that we know the length of
459          the packet */
460       write_header2 (out, ctb, iobuf_get_temp_length(a), pk->hdrbytes);
461       /* And finally write it out to the real stream. */
462       err = iobuf_write_temp (out, a);
463     }
464
465   iobuf_close (a); /* Close the temporary buffer */
466   return err;
467 }
468
469 static int
470 do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
471 {
472     int rc = 0;
473     IOBUF a = iobuf_temp();
474
475     assert( enc->version == 4 );
476     switch( enc->s2k.mode ) {
477       case 0: case 1: case 3: break;
478       default: log_bug("do_symkey_enc: s2k=%d\n", enc->s2k.mode );
479     }
480     iobuf_put( a, enc->version );
481     iobuf_put( a, enc->cipher_algo );
482     iobuf_put( a, enc->s2k.mode );
483     iobuf_put( a, enc->s2k.hash_algo );
484     if( enc->s2k.mode == 1 || enc->s2k.mode == 3 ) {
485         iobuf_write(a, enc->s2k.salt, 8 );
486         if( enc->s2k.mode == 3 )
487             iobuf_put(a, enc->s2k.count);
488     }
489     if( enc->seskeylen )
490         iobuf_write(a, enc->seskey, enc->seskeylen );
491
492     write_header(out, ctb, iobuf_get_temp_length(a) );
493     rc = iobuf_write_temp( out, a );
494
495     iobuf_close(a);
496     return rc;
497 }
498
499
500 static int
501 do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
502 {
503   int rc = 0;
504   int n, i;
505   IOBUF a = iobuf_temp();
506
507   write_version( a, ctb );
508   if ( enc->throw_keyid )
509     {
510       write_32(a, 0 );  /* Don't tell Eve who can decrypt the message.  */
511       write_32(a, 0 );
512     }
513   else
514     {
515       write_32(a, enc->keyid[0] );
516       write_32(a, enc->keyid[1] );
517     }
518   iobuf_put(a,enc->pubkey_algo );
519   n = pubkey_get_nenc( enc->pubkey_algo );
520   if ( !n )
521     write_fake_data( a, enc->data[0] );
522
523   if (enc->pubkey_algo == PUBKEY_ALGO_ECDH )
524     {
525       /* The second field persists as a LEN+field structure, even
526        * though it is stored for uniformity as an MPI internally.  */
527       assert (n == 2);
528       rc = mpi_write (a, enc->data[0]);
529       if (!rc)
530         rc = write_size_body_mpi (a, enc->data[1]);
531     }
532   else
533     {
534       for (i=0; i < n && !rc ; i++ )
535         rc = mpi_write(a, enc->data[i] );
536     }
537
538   if (!rc)
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 static u32
549 calc_plaintext( PKT_plaintext *pt )
550 {
551   /* Truncate namelen to the maximum 255 characters.  Note this means
552      that a function that calls build_packet with an illegal literal
553      packet will get it back legalized. */
554
555   if(pt->namelen>255)
556     pt->namelen=255;
557
558   return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
559 }
560
561 static int
562 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
563 {
564     int i, rc = 0;
565     u32 n;
566     byte buf[1000]; /* this buffer has the plaintext! */
567     int nbytes;
568
569     write_header(out, ctb, calc_plaintext( pt ) );
570     iobuf_put(out, pt->mode );
571     iobuf_put(out, pt->namelen );
572     for(i=0; i < pt->namelen; i++ )
573         iobuf_put(out, pt->name[i] );
574     rc = write_32(out, pt->timestamp );
575     if (rc)
576       return rc;
577
578     n = 0;
579     while( (nbytes=iobuf_read(pt->buf, buf, 1000)) != -1 ) {
580       rc = iobuf_write (out, buf, nbytes);
581       if (rc)
582         break;
583       n += nbytes;
584     }
585     wipememory(buf,1000); /* burn the buffer */
586     if( (ctb&0x40) && !pt->len )
587       iobuf_set_partial_block_mode(out, 0 ); /* turn off partial */
588     if( pt->len && n != pt->len )
589       log_error("do_plaintext(): wrote %lu bytes but expected %lu bytes\n",
590                 (ulong)n, (ulong)pt->len );
591
592     return rc;
593 }
594
595
596
597 static int
598 do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
599 {
600     int rc = 0;
601     u32 n;
602
603     n = ed->len ? (ed->len + ed->extralen) : 0;
604     write_header(out, ctb, n );
605
606     /* This is all. The caller has to write the real data */
607
608     return rc;
609 }
610
611 static int
612 do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
613 {
614     int rc = 0;
615     u32 n;
616
617     assert( ed->mdc_method );
618
619     /* Take version number and the following MDC packet in account. */
620     n = ed->len ? (ed->len + ed->extralen + 1 + 22) : 0;
621     write_header(out, ctb, n );
622     iobuf_put(out, 1 );  /* version */
623
624     /* This is all. The caller has to write the real data */
625
626     return rc;
627 }
628
629
630 static int
631 do_compressed( IOBUF out, int ctb, PKT_compressed *cd )
632 {
633     int rc = 0;
634
635     /* We must use the old convention and don't use blockmode for the
636        sake of PGP 2 compatibility.  However if the new_ctb flag was
637        set, CTB is already formatted as new style and write_header2
638        does create a partial length encoding using new the new
639        style. */
640     write_header2(out, ctb, 0, 0);
641     iobuf_put(out, cd->algorithm );
642
643     /* This is all. The caller has to write the real data */
644
645     return rc;
646 }
647
648
649 /****************
650  * Delete all subpackets of type REQTYPE and return a bool whether a packet
651  * was deleted.
652  */
653 int
654 delete_sig_subpkt (subpktarea_t *area, sigsubpkttype_t reqtype )
655 {
656     int buflen;
657     sigsubpkttype_t type;
658     byte *buffer, *bufstart;
659     size_t n;
660     size_t unused = 0;
661     int okay = 0;
662
663     if( !area )
664         return 0;
665     buflen = area->len;
666     buffer = area->data;
667     for(;;) {
668         if( !buflen ) {
669             okay = 1;
670             break;
671         }
672         bufstart = buffer;
673         n = *buffer++; buflen--;
674         if( n == 255 ) {
675             if( buflen < 4 )
676                 break;
677             n = (buffer[0] << 24) | (buffer[1] << 16)
678                 | (buffer[2] << 8) | buffer[3];
679             buffer += 4;
680             buflen -= 4;
681         }
682         else if( n >= 192 ) {
683             if( buflen < 2 )
684                 break;
685             n = (( n - 192 ) << 8) + *buffer + 192;
686             buffer++;
687             buflen--;
688         }
689         if( buflen < n )
690             break;
691
692         type = *buffer & 0x7f;
693         if( type == reqtype ) {
694             buffer++;
695             buflen--;
696             n--;
697             if( n > buflen )
698                 break;
699             buffer += n; /* point to next subpkt */
700             buflen -= n;
701             memmove (bufstart, buffer, buflen); /* shift */
702             unused +=  buffer - bufstart;
703             buffer = bufstart;
704         }
705         else {
706             buffer += n; buflen -=n;
707         }
708     }
709
710     if (!okay)
711         log_error ("delete_subpkt: buffer shorter than subpacket\n");
712     assert (unused <= area->len);
713     area->len -= unused;
714     return !!unused;
715 }
716
717
718 /****************
719  * Create or update a signature subpacket for SIG of TYPE.  This
720  * functions knows where to put the data (hashed or unhashed).  The
721  * function may move data from the unhashed part to the hashed one.
722  * Note: All pointers into sig->[un]hashed (e.g. returned by
723  * parse_sig_subpkt) are not valid after a call to this function.  The
724  * data to put into the subpaket should be in a buffer with a length
725  * of buflen.
726  */
727 void
728 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
729                   const byte *buffer, size_t buflen )
730 {
731     byte *p;
732     int critical, hashed;
733     subpktarea_t *oldarea, *newarea;
734     size_t nlen, n, n0;
735
736     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
737     type &= ~SIGSUBPKT_FLAG_CRITICAL;
738
739     /* Sanity check buffer sizes */
740     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
741       BUG();
742
743     switch(type)
744       {
745       case SIGSUBPKT_NOTATION:
746       case SIGSUBPKT_POLICY:
747       case SIGSUBPKT_REV_KEY:
748       case SIGSUBPKT_SIGNATURE:
749         /* we do allow multiple subpackets */
750         break;
751
752       default:
753         /* we don't allow multiple subpackets */
754         delete_sig_subpkt(sig->hashed,type);
755         delete_sig_subpkt(sig->unhashed,type);
756         break;
757       }
758
759     /* Any special magic that needs to be done for this type so the
760        packet doesn't need to be reparsed? */
761     switch(type)
762       {
763       case SIGSUBPKT_NOTATION:
764         sig->flags.notation=1;
765         break;
766
767       case SIGSUBPKT_POLICY:
768         sig->flags.policy_url=1;
769         break;
770
771       case SIGSUBPKT_PREF_KS:
772         sig->flags.pref_ks=1;
773         break;
774
775       case SIGSUBPKT_EXPORTABLE:
776         if(buffer[0])
777           sig->flags.exportable=1;
778         else
779           sig->flags.exportable=0;
780         break;
781
782       case SIGSUBPKT_REVOCABLE:
783         if(buffer[0])
784           sig->flags.revocable=1;
785         else
786           sig->flags.revocable=0;
787         break;
788
789       case SIGSUBPKT_TRUST:
790         sig->trust_depth=buffer[0];
791         sig->trust_value=buffer[1];
792         break;
793
794       case SIGSUBPKT_REGEXP:
795         sig->trust_regexp=buffer;
796         break;
797
798         /* This should never happen since we don't currently allow
799            creating such a subpacket, but just in case... */
800       case SIGSUBPKT_SIG_EXPIRE:
801         if(buffer_to_u32(buffer)+sig->timestamp<=make_timestamp())
802           sig->flags.expired=1;
803         else
804           sig->flags.expired=0;
805         break;
806
807       default:
808         break;
809       }
810
811     if( (buflen+1) >= 8384 )
812         nlen = 5; /* write 5 byte length header */
813     else if( (buflen+1) >= 192 )
814         nlen = 2; /* write 2 byte length header */
815     else
816         nlen = 1; /* just a 1 byte length header */
817
818     switch( type )
819       {
820         /* The issuer being unhashed is a historical oddity.  It
821            should work equally as well hashed.  Of course, if even an
822            unhashed issuer is tampered with, it makes it awfully hard
823            to verify the sig... */
824       case SIGSUBPKT_ISSUER:
825       case SIGSUBPKT_SIGNATURE:
826         hashed = 0;
827         break;
828       default:
829         hashed = 1;
830         break;
831       }
832
833     if( critical )
834         type |= SIGSUBPKT_FLAG_CRITICAL;
835
836     oldarea = hashed? sig->hashed : sig->unhashed;
837
838     /* Calculate new size of the area and allocate */
839     n0 = oldarea? oldarea->len : 0;
840     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
841     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
842         newarea = oldarea;
843         /*log_debug ("updating area for type %d\n", type );*/
844     }
845     else if (oldarea) {
846         newarea = xrealloc (oldarea, sizeof (*newarea) + n - 1);
847         newarea->size = n;
848         /*log_debug ("reallocating area for type %d\n", type );*/
849     }
850     else {
851         newarea = xmalloc (sizeof (*newarea) + n - 1);
852         newarea->size = n;
853         /*log_debug ("allocating area for type %d\n", type );*/
854     }
855     newarea->len = n;
856
857     p = newarea->data + n0;
858     if (nlen == 5) {
859         *p++ = 255;
860         *p++ = (buflen+1) >> 24;
861         *p++ = (buflen+1) >> 16;
862         *p++ = (buflen+1) >>  8;
863         *p++ = (buflen+1);
864         *p++ = type;
865         memcpy (p, buffer, buflen);
866     }
867     else if (nlen == 2) {
868         *p++ = (buflen+1-192) / 256 + 192;
869         *p++ = (buflen+1-192) % 256;
870         *p++ = type;
871         memcpy (p, buffer, buflen);
872     }
873     else {
874         *p++ = buflen+1;
875         *p++ = type;
876         memcpy (p, buffer, buflen);
877     }
878
879     if (hashed)
880         sig->hashed = newarea;
881     else
882         sig->unhashed = newarea;
883 }
884
885 /****************
886  * Put all the required stuff from SIG into subpackets of sig.
887  * Hmmm, should we delete those subpackets which are in a wrong area?
888  */
889 void
890 build_sig_subpkt_from_sig( PKT_signature *sig )
891 {
892     u32  u;
893     byte buf[8];
894
895     u = sig->keyid[0];
896     buf[0] = (u >> 24) & 0xff;
897     buf[1] = (u >> 16) & 0xff;
898     buf[2] = (u >>  8) & 0xff;
899     buf[3] = u & 0xff;
900     u = sig->keyid[1];
901     buf[4] = (u >> 24) & 0xff;
902     buf[5] = (u >> 16) & 0xff;
903     buf[6] = (u >>  8) & 0xff;
904     buf[7] = u & 0xff;
905     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
906
907     u = sig->timestamp;
908     buf[0] = (u >> 24) & 0xff;
909     buf[1] = (u >> 16) & 0xff;
910     buf[2] = (u >>  8) & 0xff;
911     buf[3] = u & 0xff;
912     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
913
914     if(sig->expiredate)
915       {
916         if(sig->expiredate>sig->timestamp)
917           u=sig->expiredate-sig->timestamp;
918         else
919           u=1; /* A 1-second expiration time is the shortest one
920                   OpenPGP has */
921
922         buf[0] = (u >> 24) & 0xff;
923         buf[1] = (u >> 16) & 0xff;
924         buf[2] = (u >>  8) & 0xff;
925         buf[3] = u & 0xff;
926
927         /* Mark this CRITICAL, so if any implementation doesn't
928            understand sigs that can expire, it'll just disregard this
929            sig altogether. */
930
931         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
932                           buf, 4 );
933       }
934 }
935
936 void
937 build_attribute_subpkt(PKT_user_id *uid,byte type,
938                        const void *buf,u32 buflen,
939                        const void *header,u32 headerlen)
940 {
941   byte *attrib;
942   int idx;
943
944   if(1+headerlen+buflen>8383)
945     idx=5;
946   else if(1+headerlen+buflen>191)
947     idx=2;
948   else
949     idx=1;
950
951   /* realloc uid->attrib_data to the right size */
952
953   uid->attrib_data=xrealloc(uid->attrib_data,
954                              uid->attrib_len+idx+1+headerlen+buflen);
955
956   attrib=&uid->attrib_data[uid->attrib_len];
957
958   if(idx==5)
959     {
960       attrib[0]=255;
961       attrib[1]=(1+headerlen+buflen) >> 24;
962       attrib[2]=(1+headerlen+buflen) >> 16;
963       attrib[3]=(1+headerlen+buflen) >> 8;
964       attrib[4]=1+headerlen+buflen;
965     }
966   else if(idx==2)
967     {
968       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
969       attrib[1]=(1+headerlen+buflen-192) % 256;
970     }
971   else
972     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
973
974   attrib[idx++]=type;
975
976   /* Tack on our data at the end */
977
978   if(headerlen>0)
979     memcpy(&attrib[idx],header,headerlen);
980   memcpy(&attrib[idx+headerlen],buf,buflen);
981   uid->attrib_len+=idx+headerlen+buflen;
982 }
983
984 struct notation *
985 string_to_notation(const char *string,int is_utf8)
986 {
987   const char *s;
988   int saw_at=0;
989   struct notation *notation;
990
991   notation=xmalloc_clear(sizeof(*notation));
992
993   if(*string=='-')
994     {
995       notation->flags.ignore=1;
996       string++;
997     }
998
999   if(*string=='!')
1000     {
1001       notation->flags.critical=1;
1002       string++;
1003     }
1004
1005   /* If and when the IETF assigns some official name tags, we'll have
1006      to add them here. */
1007
1008   for( s=string ; *s != '='; s++ )
1009     {
1010       if( *s=='@')
1011         saw_at++;
1012
1013       /* -notationname is legal without an = sign */
1014       if(!*s && notation->flags.ignore)
1015         break;
1016
1017       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
1018         {
1019           log_error(_("a notation name must have only printable characters"
1020                       " or spaces, and end with an '='\n") );
1021           goto fail;
1022         }
1023     }
1024
1025   notation->name=xmalloc((s-string)+1);
1026   strncpy(notation->name,string,s-string);
1027   notation->name[s-string]='\0';
1028
1029   if(!saw_at && !opt.expert)
1030     {
1031       log_error(_("a user notation name must contain the '@' character\n"));
1032       goto fail;
1033     }
1034
1035   if (saw_at > 1)
1036     {
1037       log_error(_("a notation name must not contain more than"
1038                   " one '@' character\n"));
1039       goto fail;
1040     }
1041
1042   if(*s)
1043     {
1044       const char *i=s+1;
1045       int highbit=0;
1046
1047       /* we only support printable text - therefore we enforce the use
1048          of only printable characters (an empty value is valid) */
1049       for(s++; *s ; s++ )
1050         {
1051           if ( !isascii (*s) )
1052             highbit=1;
1053           else if (iscntrl(*s))
1054             {
1055               log_error(_("a notation value must not use any"
1056                           " control characters\n"));
1057               goto fail;
1058             }
1059         }
1060
1061       if(!highbit || is_utf8)
1062         notation->value=xstrdup(i);
1063       else
1064         notation->value=native_to_utf8(i);
1065     }
1066
1067   return notation;
1068
1069  fail:
1070   free_notation(notation);
1071   return NULL;
1072 }
1073
1074 struct notation *
1075 sig_to_notation(PKT_signature *sig)
1076 {
1077   const byte *p;
1078   size_t len;
1079   int seq=0,crit;
1080   struct notation *list=NULL;
1081
1082   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
1083     {
1084       int n1,n2;
1085       struct notation *n=NULL;
1086
1087       if(len<8)
1088         {
1089           log_info(_("WARNING: invalid notation data found\n"));
1090           continue;
1091         }
1092
1093       n1=(p[4]<<8)|p[5];
1094       n2=(p[6]<<8)|p[7];
1095
1096       if(8+n1+n2!=len)
1097         {
1098           log_info(_("WARNING: invalid notation data found\n"));
1099           continue;
1100         }
1101
1102       n=xmalloc_clear(sizeof(*n));
1103       n->name=xmalloc(n1+1);
1104
1105       memcpy(n->name,&p[8],n1);
1106       n->name[n1]='\0';
1107
1108       if(p[0]&0x80)
1109         {
1110           n->value=xmalloc(n2+1);
1111           memcpy(n->value,&p[8+n1],n2);
1112           n->value[n2]='\0';
1113         }
1114       else
1115         {
1116           n->bdat=xmalloc(n2);
1117           n->blen=n2;
1118           memcpy(n->bdat,&p[8+n1],n2);
1119
1120           n->value=xmalloc(2+strlen(_("not human readable"))+2+1);
1121           strcpy(n->value,"[ ");
1122           strcat(n->value,_("not human readable"));
1123           strcat(n->value," ]");
1124         }
1125
1126       n->flags.critical=crit;
1127
1128       n->next=list;
1129       list=n;
1130     }
1131
1132   return list;
1133 }
1134
1135 void
1136 free_notation(struct notation *notation)
1137 {
1138   while(notation)
1139     {
1140       struct notation *n=notation;
1141
1142       xfree(n->name);
1143       xfree(n->value);
1144       xfree(n->altvalue);
1145       xfree(n->bdat);
1146       notation=n->next;
1147       xfree(n);
1148     }
1149 }
1150
1151 static int
1152 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1153 {
1154   int rc = 0;
1155   int n, i;
1156   IOBUF a = iobuf_temp();
1157
1158   if ( !sig->version )
1159     iobuf_put( a, 3 );
1160   else
1161     iobuf_put( a, sig->version );
1162   if ( sig->version < 4 )
1163     iobuf_put (a, 5 ); /* Constant */
1164   iobuf_put (a, sig->sig_class );
1165   if ( sig->version < 4 )
1166     {
1167       write_32(a, sig->timestamp );
1168       write_32(a, sig->keyid[0] );
1169       write_32(a, sig->keyid[1] );
1170     }
1171   iobuf_put(a, sig->pubkey_algo );
1172   iobuf_put(a, sig->digest_algo );
1173   if ( sig->version >= 4 )
1174     {
1175       size_t nn;
1176       /* Timestamp and keyid must have been packed into the subpackets
1177          prior to the call of this function, because these subpackets
1178          are hashed. */
1179       nn = sig->hashed? sig->hashed->len : 0;
1180       write_16(a, nn);
1181       if (nn)
1182         iobuf_write( a, sig->hashed->data, nn );
1183       nn = sig->unhashed? sig->unhashed->len : 0;
1184       write_16(a, nn);
1185       if (nn)
1186         iobuf_write( a, sig->unhashed->data, nn );
1187     }
1188   iobuf_put(a, sig->digest_start[0] );
1189   iobuf_put(a, sig->digest_start[1] );
1190   n = pubkey_get_nsig( sig->pubkey_algo );
1191   if ( !n )
1192     write_fake_data( a, sig->data[0] );
1193   for (i=0; i < n && !rc ; i++ )
1194     rc = mpi_write(a, sig->data[i] );
1195
1196   if (!rc)
1197     {
1198       if ( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1199         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1200       else
1201         write_header(out, ctb, iobuf_get_temp_length(a) );
1202       rc = iobuf_write_temp( out, a );
1203     }
1204
1205   iobuf_close(a);
1206   return rc;
1207 }
1208
1209
1210 static int
1211 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1212 {
1213     int rc = 0;
1214     IOBUF a = iobuf_temp();
1215
1216     write_version( a, ctb );
1217     iobuf_put(a, ops->sig_class );
1218     iobuf_put(a, ops->digest_algo );
1219     iobuf_put(a, ops->pubkey_algo );
1220     write_32(a, ops->keyid[0] );
1221     write_32(a, ops->keyid[1] );
1222     iobuf_put(a, ops->last );
1223
1224     write_header(out, ctb, iobuf_get_temp_length(a) );
1225     rc = iobuf_write_temp( out, a );
1226
1227     iobuf_close(a);
1228     return rc;
1229 }
1230
1231
1232 static int
1233 write_16(IOBUF out, u16 a)
1234 {
1235     iobuf_put(out, a>>8);
1236     if( iobuf_put(out,a) )
1237         return -1;
1238     return 0;
1239 }
1240
1241 static int
1242 write_32(IOBUF out, u32 a)
1243 {
1244     iobuf_put(out, a>> 24);
1245     iobuf_put(out, a>> 16);
1246     iobuf_put(out, a>> 8);
1247     return iobuf_put(out, a);
1248 }
1249
1250
1251 /****************
1252  * calculate the length of a header
1253  */
1254 static int
1255 calc_header_length( u32 len, int new_ctb )
1256 {
1257     if( !len )
1258         return 1; /* only the ctb */
1259
1260     if( new_ctb ) {
1261         if( len < 192 )
1262             return 2;
1263         if( len < 8384 )
1264             return 3;
1265         else
1266             return 6;
1267     }
1268     if( len < 256 )
1269         return 2;
1270     if( len < 65536 )
1271         return 3;
1272
1273     return 5;
1274 }
1275
1276 /****************
1277  * Write the CTB and the packet length
1278  */
1279 static int
1280 write_header( IOBUF out, int ctb, u32 len )
1281 {
1282     return write_header2( out, ctb, len, 0 );
1283 }
1284
1285
1286 static int
1287 write_sign_packet_header (IOBUF out, int ctb, u32 len)
1288 {
1289   (void)ctb;
1290
1291   /* Work around a bug in the pgp read function for signature packets,
1292      which are not correctly coded and silently assume at some point 2
1293      byte length headers.*/
1294   iobuf_put (out, 0x89 );
1295   iobuf_put (out, len >> 8 );
1296   return iobuf_put (out, len) == -1 ? -1:0;
1297 }
1298
1299 /****************
1300  * If HDRLEN is > 0, try to build a header of this length.  We need
1301  * this so that we can hash packets without reading them again.  If
1302  * len is 0, write a partial or indeterminate length header, unless
1303  * hdrlen is specified in which case write an actual zero length
1304  * (using the specified hdrlen).
1305  */
1306 static int
1307 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1308 {
1309   if( ctb & 0x40 )
1310     return write_new_header( out, ctb, len, hdrlen );
1311
1312   if( hdrlen )
1313     {
1314       if( hdrlen == 2 && len < 256 )
1315         ;
1316       else if( hdrlen == 3 && len < 65536 )
1317         ctb |= 1;
1318       else
1319         ctb |= 2;
1320     }
1321   else
1322     {
1323       if( !len )
1324         ctb |= 3;
1325       else if( len < 256 )
1326         ;
1327       else if( len < 65536 )
1328         ctb |= 1;
1329       else
1330         ctb |= 2;
1331     }
1332
1333   if( iobuf_put(out, ctb ) )
1334     return -1;
1335
1336   if( len || hdrlen )
1337     {
1338       if( ctb & 2 )
1339         {
1340           if(iobuf_put(out, len >> 24 ))
1341             return -1;
1342           if(iobuf_put(out, len >> 16 ))
1343             return -1;
1344         }
1345
1346       if( ctb & 3 )
1347         if(iobuf_put(out, len >> 8 ))
1348           return -1;
1349
1350       if( iobuf_put(out, len ) )
1351         return -1;
1352     }
1353
1354   return 0;
1355 }
1356
1357
1358 static int
1359 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1360 {
1361     if( hdrlen )
1362         log_bug("can't cope with hdrlen yet\n");
1363
1364     if( iobuf_put(out, ctb ) )
1365         return -1;
1366     if( !len ) {
1367         iobuf_set_partial_block_mode(out, 512 );
1368     }
1369     else {
1370         if( len < 192 ) {
1371             if( iobuf_put(out, len ) )
1372                 return -1;
1373         }
1374         else if( len < 8384 ) {
1375             len -= 192;
1376             if( iobuf_put( out, (len / 256) + 192) )
1377                 return -1;
1378             if( iobuf_put( out, (len % 256) )  )
1379                 return -1;
1380         }
1381         else {
1382             if( iobuf_put( out, 0xff ) )
1383                 return -1;
1384             if( iobuf_put( out, (len >> 24)&0xff ) )
1385                 return -1;
1386             if( iobuf_put( out, (len >> 16)&0xff ) )
1387                 return -1;
1388             if( iobuf_put( out, (len >> 8)&0xff )  )
1389                 return -1;
1390             if( iobuf_put( out, len & 0xff ) )
1391                 return -1;
1392         }
1393     }
1394     return 0;
1395 }
1396
1397 static int
1398 write_version (IOBUF out, int ctb)
1399 {
1400   (void)ctb;
1401
1402   if (iobuf_put (out, 3))
1403     return -1;
1404   return 0;
1405 }