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