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