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