gpg: Minor cleanup for key listing related code.
[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 = (buffer[0] << 24) | (buffer[1] << 16)
622                 | (buffer[2] << 8) | buffer[3];
623             buffer += 4;
624             buflen -= 4;
625         }
626         else if( n >= 192 ) {
627             if( buflen < 2 )
628                 break;
629             n = (( n - 192 ) << 8) + *buffer + 192;
630             buffer++;
631             buflen--;
632         }
633         if( buflen < n )
634             break;
635
636         type = *buffer & 0x7f;
637         if( type == reqtype ) {
638             buffer++;
639             buflen--;
640             n--;
641             if( n > buflen )
642                 break;
643             buffer += n; /* point to next subpkt */
644             buflen -= n;
645             memmove (bufstart, buffer, buflen); /* shift */
646             unused +=  buffer - bufstart;
647             buffer = bufstart;
648         }
649         else {
650             buffer += n; buflen -=n;
651         }
652     }
653
654     if (!okay)
655         log_error ("delete_subpkt: buffer shorter than subpacket\n");
656     assert (unused <= area->len);
657     area->len -= unused;
658     return !!unused;
659 }
660
661
662 /****************
663  * Create or update a signature subpacket for SIG of TYPE.  This
664  * functions knows where to put the data (hashed or unhashed).  The
665  * function may move data from the unhashed part to the hashed one.
666  * Note: All pointers into sig->[un]hashed (e.g. returned by
667  * parse_sig_subpkt) are not valid after a call to this function.  The
668  * data to put into the subpaket should be in a buffer with a length
669  * of buflen.
670  */
671 void
672 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
673                   const byte *buffer, size_t buflen )
674 {
675     byte *p;
676     int critical, hashed;
677     subpktarea_t *oldarea, *newarea;
678     size_t nlen, n, n0;
679
680     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
681     type &= ~SIGSUBPKT_FLAG_CRITICAL;
682
683     /* Sanity check buffer sizes */
684     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
685       BUG();
686
687     switch(type)
688       {
689       case SIGSUBPKT_NOTATION:
690       case SIGSUBPKT_POLICY:
691       case SIGSUBPKT_REV_KEY:
692       case SIGSUBPKT_SIGNATURE:
693         /* we do allow multiple subpackets */
694         break;
695
696       default:
697         /* we don't allow multiple subpackets */
698         delete_sig_subpkt(sig->hashed,type);
699         delete_sig_subpkt(sig->unhashed,type);
700         break;
701       }
702
703     /* Any special magic that needs to be done for this type so the
704        packet doesn't need to be reparsed? */
705     switch(type)
706       {
707       case SIGSUBPKT_NOTATION:
708         sig->flags.notation=1;
709         break;
710
711       case SIGSUBPKT_POLICY:
712         sig->flags.policy_url=1;
713         break;
714
715       case SIGSUBPKT_PREF_KS:
716         sig->flags.pref_ks=1;
717         break;
718
719       case SIGSUBPKT_EXPORTABLE:
720         if(buffer[0])
721           sig->flags.exportable=1;
722         else
723           sig->flags.exportable=0;
724         break;
725
726       case SIGSUBPKT_REVOCABLE:
727         if(buffer[0])
728           sig->flags.revocable=1;
729         else
730           sig->flags.revocable=0;
731         break;
732
733       case SIGSUBPKT_TRUST:
734         sig->trust_depth=buffer[0];
735         sig->trust_value=buffer[1];
736         break;
737
738       case SIGSUBPKT_REGEXP:
739         sig->trust_regexp=buffer;
740         break;
741
742         /* This should never happen since we don't currently allow
743            creating such a subpacket, but just in case... */
744       case SIGSUBPKT_SIG_EXPIRE:
745         if(buffer_to_u32(buffer)+sig->timestamp<=make_timestamp())
746           sig->flags.expired=1;
747         else
748           sig->flags.expired=0;
749         break;
750
751       default:
752         break;
753       }
754
755     if( (buflen+1) >= 8384 )
756         nlen = 5; /* write 5 byte length header */
757     else if( (buflen+1) >= 192 )
758         nlen = 2; /* write 2 byte length header */
759     else
760         nlen = 1; /* just a 1 byte length header */
761
762     switch( type )
763       {
764         /* The issuer being unhashed is a historical oddity.  It
765            should work equally as well hashed.  Of course, if even an
766            unhashed issuer is tampered with, it makes it awfully hard
767            to verify the sig... */
768       case SIGSUBPKT_ISSUER:
769       case SIGSUBPKT_SIGNATURE:
770         hashed = 0;
771         break;
772       default:
773         hashed = 1;
774         break;
775       }
776
777     if( critical )
778         type |= SIGSUBPKT_FLAG_CRITICAL;
779
780     oldarea = hashed? sig->hashed : sig->unhashed;
781
782     /* Calculate new size of the area and allocate */
783     n0 = oldarea? oldarea->len : 0;
784     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
785     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
786         newarea = oldarea;
787         /*log_debug ("updating area for type %d\n", type );*/
788     }
789     else if (oldarea) {
790         newarea = xrealloc (oldarea, sizeof (*newarea) + n - 1);
791         newarea->size = n;
792         /*log_debug ("reallocating area for type %d\n", type );*/
793     }
794     else {
795         newarea = xmalloc (sizeof (*newarea) + n - 1);
796         newarea->size = n;
797         /*log_debug ("allocating area for type %d\n", type );*/
798     }
799     newarea->len = n;
800
801     p = newarea->data + n0;
802     if (nlen == 5) {
803         *p++ = 255;
804         *p++ = (buflen+1) >> 24;
805         *p++ = (buflen+1) >> 16;
806         *p++ = (buflen+1) >>  8;
807         *p++ = (buflen+1);
808         *p++ = type;
809         memcpy (p, buffer, buflen);
810     }
811     else if (nlen == 2) {
812         *p++ = (buflen+1-192) / 256 + 192;
813         *p++ = (buflen+1-192) % 256;
814         *p++ = type;
815         memcpy (p, buffer, buflen);
816     }
817     else {
818         *p++ = buflen+1;
819         *p++ = type;
820         memcpy (p, buffer, buflen);
821     }
822
823     if (hashed)
824         sig->hashed = newarea;
825     else
826         sig->unhashed = newarea;
827 }
828
829 /****************
830  * Put all the required stuff from SIG into subpackets of sig.
831  * Hmmm, should we delete those subpackets which are in a wrong area?
832  */
833 void
834 build_sig_subpkt_from_sig( PKT_signature *sig )
835 {
836     u32  u;
837     byte buf[8];
838
839     u = sig->keyid[0];
840     buf[0] = (u >> 24) & 0xff;
841     buf[1] = (u >> 16) & 0xff;
842     buf[2] = (u >>  8) & 0xff;
843     buf[3] = u & 0xff;
844     u = sig->keyid[1];
845     buf[4] = (u >> 24) & 0xff;
846     buf[5] = (u >> 16) & 0xff;
847     buf[6] = (u >>  8) & 0xff;
848     buf[7] = u & 0xff;
849     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
850
851     u = sig->timestamp;
852     buf[0] = (u >> 24) & 0xff;
853     buf[1] = (u >> 16) & 0xff;
854     buf[2] = (u >>  8) & 0xff;
855     buf[3] = u & 0xff;
856     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
857
858     if(sig->expiredate)
859       {
860         if(sig->expiredate>sig->timestamp)
861           u=sig->expiredate-sig->timestamp;
862         else
863           u=1; /* A 1-second expiration time is the shortest one
864                   OpenPGP has */
865
866         buf[0] = (u >> 24) & 0xff;
867         buf[1] = (u >> 16) & 0xff;
868         buf[2] = (u >>  8) & 0xff;
869         buf[3] = u & 0xff;
870
871         /* Mark this CRITICAL, so if any implementation doesn't
872            understand sigs that can expire, it'll just disregard this
873            sig altogether. */
874
875         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
876                           buf, 4 );
877       }
878 }
879
880 void
881 build_attribute_subpkt(PKT_user_id *uid,byte type,
882                        const void *buf,u32 buflen,
883                        const void *header,u32 headerlen)
884 {
885   byte *attrib;
886   int idx;
887
888   if(1+headerlen+buflen>8383)
889     idx=5;
890   else if(1+headerlen+buflen>191)
891     idx=2;
892   else
893     idx=1;
894
895   /* realloc uid->attrib_data to the right size */
896
897   uid->attrib_data=xrealloc(uid->attrib_data,
898                              uid->attrib_len+idx+1+headerlen+buflen);
899
900   attrib=&uid->attrib_data[uid->attrib_len];
901
902   if(idx==5)
903     {
904       attrib[0]=255;
905       attrib[1]=(1+headerlen+buflen) >> 24;
906       attrib[2]=(1+headerlen+buflen) >> 16;
907       attrib[3]=(1+headerlen+buflen) >> 8;
908       attrib[4]=1+headerlen+buflen;
909     }
910   else if(idx==2)
911     {
912       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
913       attrib[1]=(1+headerlen+buflen-192) % 256;
914     }
915   else
916     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
917
918   attrib[idx++]=type;
919
920   /* Tack on our data at the end */
921
922   if(headerlen>0)
923     memcpy(&attrib[idx],header,headerlen);
924   memcpy(&attrib[idx+headerlen],buf,buflen);
925   uid->attrib_len+=idx+headerlen+buflen;
926 }
927
928 struct notation *
929 string_to_notation(const char *string,int is_utf8)
930 {
931   const char *s;
932   int saw_at=0;
933   struct notation *notation;
934
935   notation=xmalloc_clear(sizeof(*notation));
936
937   if(*string=='-')
938     {
939       notation->flags.ignore=1;
940       string++;
941     }
942
943   if(*string=='!')
944     {
945       notation->flags.critical=1;
946       string++;
947     }
948
949   /* If and when the IETF assigns some official name tags, we'll have
950      to add them here. */
951
952   for( s=string ; *s != '='; s++ )
953     {
954       if( *s=='@')
955         saw_at++;
956
957       /* -notationname is legal without an = sign */
958       if(!*s && notation->flags.ignore)
959         break;
960
961       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
962         {
963           log_error(_("a notation name must have only printable characters"
964                       " or spaces, and end with an '='\n") );
965           goto fail;
966         }
967     }
968
969   notation->name=xmalloc((s-string)+1);
970   strncpy(notation->name,string,s-string);
971   notation->name[s-string]='\0';
972
973   if(!saw_at && !opt.expert)
974     {
975       log_error(_("a user notation name must contain the '@' character\n"));
976       goto fail;
977     }
978
979   if (saw_at > 1)
980     {
981       log_error(_("a notation name must not contain more than"
982                   " one '@' character\n"));
983       goto fail;
984     }
985
986   if(*s)
987     {
988       const char *i=s+1;
989       int highbit=0;
990
991       /* we only support printable text - therefore we enforce the use
992          of only printable characters (an empty value is valid) */
993       for(s++; *s ; s++ )
994         {
995           if ( !isascii (*s) )
996             highbit=1;
997           else if (iscntrl(*s))
998             {
999               log_error(_("a notation value must not use any"
1000                           " control characters\n"));
1001               goto fail;
1002             }
1003         }
1004
1005       if(!highbit || is_utf8)
1006         notation->value=xstrdup(i);
1007       else
1008         notation->value=native_to_utf8(i);
1009     }
1010
1011   return notation;
1012
1013  fail:
1014   free_notation(notation);
1015   return NULL;
1016 }
1017
1018 struct notation *
1019 sig_to_notation(PKT_signature *sig)
1020 {
1021   const byte *p;
1022   size_t len;
1023   int seq=0,crit;
1024   struct notation *list=NULL;
1025
1026   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
1027     {
1028       int n1,n2;
1029       struct notation *n=NULL;
1030
1031       if(len<8)
1032         {
1033           log_info(_("WARNING: invalid notation data found\n"));
1034           continue;
1035         }
1036
1037       n1=(p[4]<<8)|p[5];
1038       n2=(p[6]<<8)|p[7];
1039
1040       if(8+n1+n2!=len)
1041         {
1042           log_info(_("WARNING: invalid notation data found\n"));
1043           continue;
1044         }
1045
1046       n=xmalloc_clear(sizeof(*n));
1047       n->name=xmalloc(n1+1);
1048
1049       memcpy(n->name,&p[8],n1);
1050       n->name[n1]='\0';
1051
1052       if(p[0]&0x80)
1053         {
1054           n->value=xmalloc(n2+1);
1055           memcpy(n->value,&p[8+n1],n2);
1056           n->value[n2]='\0';
1057         }
1058       else
1059         {
1060           n->bdat=xmalloc(n2);
1061           n->blen=n2;
1062           memcpy(n->bdat,&p[8+n1],n2);
1063
1064           n->value=xmalloc(2+strlen(_("not human readable"))+2+1);
1065           strcpy(n->value,"[ ");
1066           strcat(n->value,_("not human readable"));
1067           strcat(n->value," ]");
1068         }
1069
1070       n->flags.critical=crit;
1071
1072       n->next=list;
1073       list=n;
1074     }
1075
1076   return list;
1077 }
1078
1079 void
1080 free_notation(struct notation *notation)
1081 {
1082   while(notation)
1083     {
1084       struct notation *n=notation;
1085
1086       xfree(n->name);
1087       xfree(n->value);
1088       xfree(n->altvalue);
1089       xfree(n->bdat);
1090       notation=n->next;
1091       xfree(n);
1092     }
1093 }
1094
1095 static int
1096 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1097 {
1098   int rc = 0;
1099   int n, i;
1100   IOBUF a = iobuf_temp();
1101
1102   if ( !sig->version )
1103     iobuf_put( a, 3 );
1104   else
1105     iobuf_put( a, sig->version );
1106   if ( sig->version < 4 )
1107     iobuf_put (a, 5 ); /* Constant */
1108   iobuf_put (a, sig->sig_class );
1109   if ( sig->version < 4 )
1110     {
1111       write_32(a, sig->timestamp );
1112       write_32(a, sig->keyid[0] );
1113       write_32(a, sig->keyid[1] );
1114     }
1115   iobuf_put(a, sig->pubkey_algo );
1116   iobuf_put(a, sig->digest_algo );
1117   if ( sig->version >= 4 )
1118     {
1119       size_t nn;
1120       /* Timestamp and keyid must have been packed into the subpackets
1121          prior to the call of this function, because these subpackets
1122          are hashed. */
1123       nn = sig->hashed? sig->hashed->len : 0;
1124       write_16(a, nn);
1125       if (nn)
1126         iobuf_write( a, sig->hashed->data, nn );
1127       nn = sig->unhashed? sig->unhashed->len : 0;
1128       write_16(a, nn);
1129       if (nn)
1130         iobuf_write( a, sig->unhashed->data, nn );
1131     }
1132   iobuf_put(a, sig->digest_start[0] );
1133   iobuf_put(a, sig->digest_start[1] );
1134   n = pubkey_get_nsig( sig->pubkey_algo );
1135   if ( !n )
1136     write_fake_data( a, sig->data[0] );
1137   for (i=0; i < n && !rc ; i++ )
1138     rc = gpg_mpi_write (a, sig->data[i] );
1139
1140   if (!rc)
1141     {
1142       if ( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1143         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1144       else
1145         write_header(out, ctb, iobuf_get_temp_length(a) );
1146       rc = iobuf_write_temp( out, a );
1147     }
1148
1149   iobuf_close(a);
1150   return rc;
1151 }
1152
1153
1154 static int
1155 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1156 {
1157     int rc = 0;
1158     IOBUF a = iobuf_temp();
1159
1160     iobuf_put (a, 3);  /* Version.  */
1161     iobuf_put(a, ops->sig_class );
1162     iobuf_put(a, ops->digest_algo );
1163     iobuf_put(a, ops->pubkey_algo );
1164     write_32(a, ops->keyid[0] );
1165     write_32(a, ops->keyid[1] );
1166     iobuf_put(a, ops->last );
1167
1168     write_header(out, ctb, iobuf_get_temp_length(a) );
1169     rc = iobuf_write_temp( out, a );
1170
1171     iobuf_close(a);
1172     return rc;
1173 }
1174
1175
1176 static int
1177 write_16(IOBUF out, u16 a)
1178 {
1179     iobuf_put(out, a>>8);
1180     if( iobuf_put(out,a) )
1181         return -1;
1182     return 0;
1183 }
1184
1185 static int
1186 write_32(IOBUF out, u32 a)
1187 {
1188     iobuf_put(out, a>> 24);
1189     iobuf_put(out, a>> 16);
1190     iobuf_put(out, a>> 8);
1191     return iobuf_put(out, a);
1192 }
1193
1194
1195 /****************
1196  * calculate the length of a header
1197  */
1198 static int
1199 calc_header_length( u32 len, int new_ctb )
1200 {
1201     if( !len )
1202         return 1; /* only the ctb */
1203
1204     if( new_ctb ) {
1205         if( len < 192 )
1206             return 2;
1207         if( len < 8384 )
1208             return 3;
1209         else
1210             return 6;
1211     }
1212     if( len < 256 )
1213         return 2;
1214     if( len < 65536 )
1215         return 3;
1216
1217     return 5;
1218 }
1219
1220 /****************
1221  * Write the CTB and the packet length
1222  */
1223 static int
1224 write_header( IOBUF out, int ctb, u32 len )
1225 {
1226     return write_header2( out, ctb, len, 0 );
1227 }
1228
1229
1230 static int
1231 write_sign_packet_header (IOBUF out, int ctb, u32 len)
1232 {
1233   (void)ctb;
1234
1235   /* Work around a bug in the pgp read function for signature packets,
1236      which are not correctly coded and silently assume at some point 2
1237      byte length headers.*/
1238   iobuf_put (out, 0x89 );
1239   iobuf_put (out, len >> 8 );
1240   return iobuf_put (out, len) == -1 ? -1:0;
1241 }
1242
1243 /****************
1244  * If HDRLEN is > 0, try to build a header of this length.  We need
1245  * this so that we can hash packets without reading them again.  If
1246  * len is 0, write a partial or indeterminate length header, unless
1247  * hdrlen is specified in which case write an actual zero length
1248  * (using the specified hdrlen).
1249  */
1250 static int
1251 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1252 {
1253   if( ctb & 0x40 )
1254     return write_new_header( out, ctb, len, hdrlen );
1255
1256   if( hdrlen )
1257     {
1258       if( hdrlen == 2 && len < 256 )
1259         ;
1260       else if( hdrlen == 3 && len < 65536 )
1261         ctb |= 1;
1262       else
1263         ctb |= 2;
1264     }
1265   else
1266     {
1267       if( !len )
1268         ctb |= 3;
1269       else if( len < 256 )
1270         ;
1271       else if( len < 65536 )
1272         ctb |= 1;
1273       else
1274         ctb |= 2;
1275     }
1276
1277   if( iobuf_put(out, ctb ) )
1278     return -1;
1279
1280   if( len || hdrlen )
1281     {
1282       if( ctb & 2 )
1283         {
1284           if(iobuf_put(out, len >> 24 ))
1285             return -1;
1286           if(iobuf_put(out, len >> 16 ))
1287             return -1;
1288         }
1289
1290       if( ctb & 3 )
1291         if(iobuf_put(out, len >> 8 ))
1292           return -1;
1293
1294       if( iobuf_put(out, len ) )
1295         return -1;
1296     }
1297
1298   return 0;
1299 }
1300
1301
1302 static int
1303 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1304 {
1305     if( hdrlen )
1306         log_bug("can't cope with hdrlen yet\n");
1307
1308     if( iobuf_put(out, ctb ) )
1309         return -1;
1310     if( !len ) {
1311         iobuf_set_partial_block_mode(out, 512 );
1312     }
1313     else {
1314         if( len < 192 ) {
1315             if( iobuf_put(out, len ) )
1316                 return -1;
1317         }
1318         else if( len < 8384 ) {
1319             len -= 192;
1320             if( iobuf_put( out, (len / 256) + 192) )
1321                 return -1;
1322             if( iobuf_put( out, (len % 256) )  )
1323                 return -1;
1324         }
1325         else {
1326             if( iobuf_put( out, 0xff ) )
1327                 return -1;
1328             if( iobuf_put( out, (len >> 24)&0xff ) )
1329                 return -1;
1330             if( iobuf_put( out, (len >> 16)&0xff ) )
1331                 return -1;
1332             if( iobuf_put( out, (len >> 8)&0xff )  )
1333                 return -1;
1334             if( iobuf_put( out, len & 0xff ) )
1335                 return -1;
1336         }
1337     }
1338     return 0;
1339 }