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