* armor.c, g10.c, kbnode.c, misc.c, pkclist.c, sign.c, build-packet.c,
[gnupg.git] / g10 / sign.c
1 /* sign.c - sign data
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003 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 2 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, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include <unistd.h> /* need sleep() */
29
30 #include "options.h"
31 #include "packet.h"
32 #include "errors.h"
33 #include "iobuf.h"
34 #include "keydb.h"
35 #include "memory.h"
36 #include "util.h"
37 #include "main.h"
38 #include "filter.h"
39 #include "ttyio.h"
40 #include "trustdb.h"
41 #include "status.h"
42 #include "i18n.h"
43
44
45 #ifdef HAVE_DOSISH_SYSTEM
46 #define LF "\r\n"
47 void __stdcall Sleep(ulong);
48 #define sleep(a)  Sleep((a)*1000)
49 #else
50 #define LF "\n"
51 #endif
52
53 static int recipient_digest_algo=0;
54
55 /****************
56  * Create a notation.  It is assumed that the stings in STRLIST
57  * are already checked to contain only printable data and have a valid
58  * NAME=VALUE format.
59  */
60 static void
61 mk_notation_and_policy( PKT_signature *sig,
62                         PKT_public_key *pk, PKT_secret_key *sk )
63 {
64     const char *string;
65     char *s=NULL;
66     byte *buf;
67     unsigned n1, n2;
68     STRLIST nd=NULL,pu=NULL;
69     struct expando_args args;
70
71     memset(&args,0,sizeof(args));
72     args.pk=pk;
73     args.sk=sk;
74
75     /* notation data */
76     if(IS_SIG(sig) && opt.sig_notation_data)
77       {
78         if(sig->version<4)
79           log_info("can't put notation data into v3 signatures\n");
80         else
81           nd=opt.sig_notation_data;
82       }
83     else if( IS_CERT(sig) && opt.cert_notation_data )
84       {
85         if(sig->version<4)
86           log_info("can't put notation data into v3 key signatures\n");
87         else
88           nd=opt.cert_notation_data;
89       }
90
91     for( ; nd; nd = nd->next ) {
92         char *expanded;
93
94         string = nd->d;
95         s = strchr( string, '=' );
96         if( !s )
97           BUG(); /* we have already parsed this */
98         n1 = s - string;
99         s++;
100
101         expanded=pct_expando(s,&args);
102         if(!expanded)
103           {
104             log_error(_("WARNING: unable to %%-expand notation "
105                         "(too large).  Using unexpanded.\n"));
106             expanded=m_strdup(s);
107           }
108
109         n2 = strlen(expanded);
110         buf = m_alloc( 8 + n1 + n2 );
111         buf[0] = 0x80; /* human readable */
112         buf[1] = buf[2] = buf[3] = 0;
113         buf[4] = n1 >> 8;
114         buf[5] = n1;
115         buf[6] = n2 >> 8;
116         buf[7] = n2;
117         memcpy(buf+8, string, n1 );
118         memcpy(buf+8+n1, expanded, n2 );
119         build_sig_subpkt( sig, SIGSUBPKT_NOTATION
120                           | ((nd->flags & 1)? SIGSUBPKT_FLAG_CRITICAL:0),
121                           buf, 8+n1+n2 );
122         m_free(expanded);
123         m_free(buf);
124     }
125
126     if(opt.show_notation)
127       show_notation(sig,0);
128
129     /* set policy URL */
130     if( IS_SIG(sig) && opt.sig_policy_url )
131       {
132         if(sig->version<4)
133           log_info("can't put a policy URL into v3 signatures\n");
134         else
135           pu=opt.sig_policy_url;
136       }
137     else if( IS_CERT(sig) && opt.cert_policy_url )
138       {
139         if(sig->version<4)
140           log_info("can't put a policy URL into v3 key signatures\n");
141         else
142           pu=opt.cert_policy_url;
143       }
144
145     for(;pu;pu=pu->next)
146       {
147         string = pu->d;
148
149         s=pct_expando(string,&args);
150         if(!s)
151           {
152             log_error(_("WARNING: unable to %%-expand policy url "
153                         "(too large).  Using unexpanded.\n"));
154             s=m_strdup(string);
155           }
156
157         build_sig_subpkt(sig,SIGSUBPKT_POLICY|
158                          ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0),
159                          s,strlen(s));
160
161         m_free(s);
162       }
163
164     if(opt.show_policy_url)
165       show_policy_url(sig,0);
166 }
167
168
169 /*
170  * Helper to hash a user ID packet.  
171  */
172 static void
173 hash_uid (MD_HANDLE md, int sigversion, const PKT_user_id *uid)
174 {
175     if ( sigversion >= 4 ) {
176         byte buf[5];
177
178         if(uid->attrib_data) {
179           buf[0] = 0xd1;                   /* indicates an attribute packet */
180           buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
181           buf[2] = uid->attrib_len >> 16;
182           buf[3] = uid->attrib_len >>  8;
183           buf[4] = uid->attrib_len;
184         }
185         else {
186           buf[0] = 0xb4;            /* indicates a userid packet */
187           buf[1] = uid->len >> 24;  /* always use 4 length bytes */
188           buf[2] = uid->len >> 16;
189           buf[3] = uid->len >>  8;
190           buf[4] = uid->len;
191         }
192         md_write( md, buf, 5 );
193     }
194
195     if(uid->attrib_data)
196       md_write (md, uid->attrib_data, uid->attrib_len );
197     else
198       md_write (md, uid->name, uid->len );
199 }
200
201
202 /*
203  * Helper to hash some parts from the signature
204  */
205 static void
206 hash_sigversion_to_magic (MD_HANDLE md, const PKT_signature *sig)
207 {
208     if (sig->version >= 4) 
209         md_putc (md, sig->version);
210     md_putc (md, sig->sig_class);
211     if (sig->version < 4) {
212         u32 a = sig->timestamp;
213         md_putc (md, (a >> 24) & 0xff );
214         md_putc (md, (a >> 16) & 0xff );
215         md_putc (md, (a >>  8) & 0xff );
216         md_putc (md,  a        & 0xff );
217     }
218     else {
219         byte buf[6];
220         size_t n;
221         
222         md_putc (md, sig->pubkey_algo);
223         md_putc (md, sig->digest_algo);
224         if (sig->hashed) {
225             n = sig->hashed->len;
226             md_putc (md, (n >> 8) );
227             md_putc (md,  n       );
228             md_write (md, sig->hashed->data, n );
229             n += 6;
230         }
231         else {
232             md_putc (md, 0);  /* always hash the length of the subpacket*/
233             md_putc (md, 0);
234             n = 6;
235         }
236         /* add some magic */
237         buf[0] = sig->version;
238         buf[1] = 0xff;
239         buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
240         buf[3] = n >> 16;
241         buf[4] = n >>  8;
242         buf[5] = n;
243         md_write (md, buf, 6);
244     }
245 }
246
247
248 static int
249 do_sign( PKT_secret_key *sk, PKT_signature *sig,
250          MD_HANDLE md, int digest_algo )
251 {
252     MPI frame;
253     byte *dp;
254     int rc;
255
256     if( sk->timestamp > sig->timestamp ) {
257         ulong d = sk->timestamp - sig->timestamp;
258         log_info( d==1 ? _("key has been created %lu second "
259                            "in future (time warp or clock problem)\n")
260                        : _("key has been created %lu seconds "
261                            "in future (time warp or clock problem)\n"), d );
262         if( !opt.ignore_time_conflict )
263             return G10ERR_TIME_CONFLICT;
264     }
265
266
267     print_pubkey_algo_note(sk->pubkey_algo);
268
269     if( !digest_algo )
270         digest_algo = md_get_algo(md);
271
272     print_digest_algo_note( digest_algo );
273     dp = md_read( md, digest_algo );
274     sig->digest_algo = digest_algo;
275     sig->digest_start[0] = dp[0];
276     sig->digest_start[1] = dp[1];
277     frame = encode_md_value( sk->pubkey_algo, md,
278                              digest_algo, mpi_get_nbits(sk->skey[0]), 0 );
279     if (!frame)
280         return G10ERR_GENERAL;
281     rc = pubkey_sign( sk->pubkey_algo, sig->data, frame, sk->skey );
282     mpi_free(frame);
283     if (!rc && !opt.no_sig_create_check) {
284         /* check that the signature verification worked and nothing is
285          * fooling us e.g. by a bug in the signature create
286          * code or by deliberately introduced faults. */
287         PKT_public_key *pk = m_alloc_clear (sizeof *pk);
288
289         if( get_pubkey( pk, sig->keyid ) )
290             rc = G10ERR_NO_PUBKEY;
291         else {
292             frame = encode_md_value (pk->pubkey_algo, md,
293                                      sig->digest_algo,
294                                      mpi_get_nbits(pk->pkey[0]), 0);
295             if (!frame)
296                 rc = G10ERR_GENERAL;
297             else
298                 rc = pubkey_verify (pk->pubkey_algo, frame,
299                                     sig->data, pk->pkey,
300                                     NULL, NULL );
301             mpi_free (frame);
302         }
303         if (rc)
304             log_error (_("checking created signature failed: %s\n"),
305                          g10_errstr (rc));
306         free_public_key (pk);
307     }
308     if( rc )
309         log_error(_("signing failed: %s\n"), g10_errstr(rc) );
310     else {
311         if( opt.verbose ) {
312             char *ustr = get_user_id_string_printable (sig->keyid);
313             log_info(_("%s/%s signature from: \"%s\"\n"),
314                      pubkey_algo_to_string(sk->pubkey_algo),
315                      digest_algo_to_string(sig->digest_algo),
316                      ustr );
317             m_free(ustr);
318         }
319     }
320     return rc;
321 }
322
323
324
325 int
326 complete_sig( PKT_signature *sig, PKT_secret_key *sk, MD_HANDLE md )
327 {
328     int rc=0;
329
330     if( !(rc=check_secret_key( sk, 0 )) )
331         rc = do_sign( sk, sig, md, 0 );
332     return rc;
333 }
334
335 static int
336 hash_for(int pubkey_algo, int packet_version )
337 {
338   if( opt.def_digest_algo )
339     return opt.def_digest_algo;
340   else if( recipient_digest_algo )
341     return recipient_digest_algo;
342   else if(PGP2 && pubkey_algo == PUBKEY_ALGO_RSA && packet_version < 4 )
343     {
344       /* Old-style PGP only understands MD5 */
345       return DIGEST_ALGO_MD5;
346     }
347   else if( pubkey_algo == PUBKEY_ALGO_DSA )
348     {
349       /* We need a 160-bit hash for DSA, so we can't just take the first
350          in the pref list */
351
352       if(opt.personal_digest_prefs)
353         {
354           prefitem_t *prefs;
355
356           for(prefs=opt.personal_digest_prefs;prefs->type;prefs++)
357             if(md_digest_length(prefs->value)==20)
358               return prefs->value;
359         }
360
361       return DIGEST_ALGO_SHA1;
362     }
363   else if( opt.personal_digest_prefs )
364     {
365       /* It's not DSA, so we can use whatever the first hash algorithm
366          is in the pref list */
367       return opt.personal_digest_prefs[0].value;
368     }
369   else
370     return DEFAULT_DIGEST_ALGO;
371 }
372
373 static int
374 only_old_style( SK_LIST sk_list )
375 {
376     SK_LIST sk_rover = NULL;
377     int old_style = 0;
378
379     /* if there are only old style capable key we use the old sytle */
380     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
381         PKT_secret_key *sk = sk_rover->sk;
382         if( sk->pubkey_algo == PUBKEY_ALGO_RSA && sk->version < 4 )
383             old_style = 1;
384         else
385             return 0;
386     }
387     return old_style;
388 }
389
390
391 static void
392 print_status_sig_created ( PKT_secret_key *sk, PKT_signature *sig, int what )
393 {
394     byte array[MAX_FINGERPRINT_LEN], *p;
395     char buf[100+MAX_FINGERPRINT_LEN*2];
396     size_t i, n;
397
398     sprintf(buf, "%c %d %d %02x %lu ",
399             what, sig->pubkey_algo, sig->digest_algo, sig->sig_class,
400             (ulong)sig->timestamp );
401
402     fingerprint_from_sk( sk, array, &n );
403     p = buf + strlen(buf);
404     for(i=0; i < n ; i++ )
405         sprintf(p+2*i, "%02X", array[i] );
406
407     write_status_text( STATUS_SIG_CREATED, buf );
408 }
409
410
411 /*
412  * Loop over the secret certificates in SK_LIST and build the one pass
413  * signature packets.  OpenPGP says that the data should be bracket by
414  * the onepass-sig and signature-packet; so we build these onepass
415  * packet here in reverse order 
416  */
417 static int
418 write_onepass_sig_packets (SK_LIST sk_list, IOBUF out, int sigclass )
419 {
420     int skcount;
421     SK_LIST sk_rover;
422
423     for (skcount=0, sk_rover=sk_list; sk_rover; sk_rover = sk_rover->next)
424         skcount++;
425
426     for (; skcount; skcount--) {
427         PKT_secret_key *sk;
428         PKT_onepass_sig *ops;
429         PACKET pkt;
430         int i, rc;
431         
432         for (i=0, sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
433             if (++i == skcount)
434                 break;
435         }
436
437         sk = sk_rover->sk;
438         ops = m_alloc_clear (sizeof *ops);
439         ops->sig_class = sigclass;
440         ops->digest_algo = hash_for (sk->pubkey_algo, sk->version);
441         ops->pubkey_algo = sk->pubkey_algo;
442         keyid_from_sk (sk, ops->keyid);
443         ops->last = (skcount == 1);
444         
445         init_packet(&pkt);
446         pkt.pkttype = PKT_ONEPASS_SIG;
447         pkt.pkt.onepass_sig = ops;
448         rc = build_packet (out, &pkt);
449         free_packet (&pkt);
450         if (rc) {
451             log_error ("build onepass_sig packet failed: %s\n",
452                        g10_errstr(rc));
453             return rc;
454         }
455     }
456
457     return 0;
458 }
459
460 /*
461  * Helper to write the plaintext (literal data) packet
462  */
463 static int
464 write_plaintext_packet (IOBUF out, IOBUF inp, const char *fname, int ptmode)
465 {
466     PKT_plaintext *pt = NULL;
467     u32 filesize;
468     int rc = 0;
469
470     if (!opt.no_literal) {
471         if (fname || opt.set_filename) {
472             char *s = make_basename (opt.set_filename? opt.set_filename
473                                                      : fname,
474                                      iobuf_get_real_fname(inp));
475             pt = m_alloc (sizeof *pt + strlen(s) - 1);
476             pt->namelen = strlen (s);
477             memcpy (pt->name, s, pt->namelen);
478             m_free (s);
479         }
480         else { /* no filename */
481             pt = m_alloc (sizeof *pt - 1);
482             pt->namelen = 0;
483         }
484     }
485
486     /* try to calculate the length of the data */
487     if (fname && *fname && !(*fname=='-' && !fname[1])) {
488         if( !(filesize = iobuf_get_filelength(inp)) )
489             log_info (_("WARNING: `%s' is an empty file\n"), fname);
490
491         /* we can't yet encode the length of very large files,
492          * so we switch to partial length encoding in this case */
493         if (filesize >= IOBUF_FILELENGTH_LIMIT)
494             filesize = 0;
495
496         /* because the text_filter modifies the length of the
497          * data, it is not possible to know the used length
498          * without a double read of the file - to avoid that
499          * we simple use partial length packets.
500          */
501         if ( ptmode == 't' )
502             filesize = 0;
503     }
504     else {
505         filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
506     }
507
508     if (!opt.no_literal) {
509         PACKET pkt;
510
511         pt->timestamp = make_timestamp ();
512         pt->mode = ptmode;
513         pt->len = filesize;
514         pt->new_ctb = !pt->len && !RFC1991;
515         pt->buf = inp;
516         init_packet(&pkt);
517         pkt.pkttype = PKT_PLAINTEXT;
518         pkt.pkt.plaintext = pt;
519         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
520         if( (rc = build_packet (out, &pkt)) )
521             log_error ("build_packet(PLAINTEXT) failed: %s\n",
522                        g10_errstr(rc) );
523         pt->buf = NULL;
524     }
525     else {
526         byte copy_buffer[4096];
527         int  bytes_copied;
528
529         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
530             if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
531                 rc = G10ERR_WRITE_FILE;
532                 log_error ("copying input to output failed: %s\n",
533                            g10_errstr(rc));
534                 break;
535             }
536         wipememory(copy_buffer,4096); /* burn buffer */
537     }
538     /* fixme: it seems that we never freed pt/pkt */
539     
540     return rc;
541 }
542
543 /*
544  * Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
545  * hash which will not be changes here.
546  */
547 static int
548 write_signature_packets (SK_LIST sk_list, IOBUF out, MD_HANDLE hash,
549                          int sigclass, u32 timestamp, u32 duration,
550                          int status_letter)
551 {
552     SK_LIST sk_rover;
553
554     /* loop over the secret certificates */
555     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
556         PKT_secret_key *sk;
557         PKT_signature *sig;
558         MD_HANDLE md;
559         int rc;
560
561         sk = sk_rover->sk;
562
563         /* build the signature packet */
564         sig = m_alloc_clear (sizeof *sig);
565         if(opt.force_v3_sigs || RFC1991)
566           sig->version=3;
567         else if(duration || opt.sig_policy_url || opt.sig_notation_data)
568           sig->version=4;
569         else
570           sig->version=sk->version;
571         keyid_from_sk (sk, sig->keyid);
572         sig->digest_algo = hash_for (sk->pubkey_algo, sk->version);
573         sig->pubkey_algo = sk->pubkey_algo;
574         if(timestamp)
575           sig->timestamp = timestamp;
576         else
577           sig->timestamp = make_timestamp();
578         if(duration)
579           sig->expiredate = sig->timestamp+duration;
580         sig->sig_class = sigclass;
581
582         md = md_copy (hash);
583
584         if (sig->version >= 4)
585             build_sig_subpkt_from_sig (sig);
586         mk_notation_and_policy (sig, NULL, sk);
587
588         hash_sigversion_to_magic (md, sig);
589         md_final (md);
590
591         rc = do_sign( sk, sig, md, hash_for (sig->pubkey_algo, sk->version) );
592         md_close (md);
593
594         if( !rc ) { /* and write it */
595             PACKET pkt;
596
597             init_packet(&pkt);
598             pkt.pkttype = PKT_SIGNATURE;
599             pkt.pkt.signature = sig;
600             rc = build_packet (out, &pkt);
601             if (!rc && is_status_enabled()) {
602                 print_status_sig_created ( sk, sig, status_letter);
603             }
604             free_packet (&pkt);
605             if (rc)
606                 log_error ("build signature packet failed: %s\n",
607                            g10_errstr(rc) );
608         }
609         if( rc )
610             return rc;;
611     }
612
613     return 0;
614 }
615
616 /****************
617  * Sign the files whose names are in FILENAME.
618  * If DETACHED has the value true,
619  * make a detached signature.  If FILENAMES->d is NULL read from stdin
620  * and ignore the detached mode.  Sign the file with all secret keys
621  * which can be taken from LOCUSR, if this is NULL, use the default one
622  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
623  * signed data for these users.
624  * If OUTFILE is not NULL; this file is used for output and the function
625  * does not ask for overwrite permission; output is then always
626  * uncompressed, non-armored and in binary mode.
627  */
628 int
629 sign_file( STRLIST filenames, int detached, STRLIST locusr,
630            int encryptflag, STRLIST remusr, const char *outfile )
631 {
632     const char *fname;
633     armor_filter_context_t afx;
634     compress_filter_context_t zfx;
635     md_filter_context_t mfx;
636     text_filter_context_t tfx;
637     progress_filter_context_t pfx;
638     encrypt_filter_context_t efx;
639     IOBUF inp = NULL, out = NULL;
640     PACKET pkt;
641     int rc = 0;
642     PK_LIST pk_list = NULL;
643     SK_LIST sk_list = NULL;
644     SK_LIST sk_rover = NULL;
645     int multifile = 0;
646     u32 duration=0;
647
648     memset( &afx, 0, sizeof afx);
649     memset( &zfx, 0, sizeof zfx);
650     memset( &mfx, 0, sizeof mfx);
651     memset( &efx, 0, sizeof efx);
652     init_packet( &pkt );
653
654     if( filenames ) {
655         fname = filenames->d;
656         multifile = !!filenames->next;
657     }
658     else
659         fname = NULL;
660
661     if( fname && filenames->next && (!detached || encryptflag) )
662         log_bug("multiple files can only be detached signed");
663
664     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !RFC1991)
665       duration=ask_expire_interval(1);
666
667     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
668         goto leave;
669
670     if(PGP2 && !only_old_style(sk_list))
671       {
672         log_info(_("you can only detach-sign with PGP 2.x style keys "
673                    "while in --pgp2 mode\n"));
674         compliance_failure();
675       }
676
677     if(encryptflag && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
678       goto leave;
679
680     /* prepare iobufs */
681     if( multifile )  /* have list of filenames */
682         inp = NULL; /* we do it later */
683     else {
684         if( !(inp = iobuf_open(fname)) ) {
685             log_error("can't open %s: %s\n", fname? fname: "[stdin]",
686                       strerror(errno) );
687             rc = G10ERR_OPEN_FILE;
688             goto leave;
689         }
690
691         handle_progress (&pfx, inp, fname);
692     }
693
694     if( outfile ) {
695         if( !(out = iobuf_create( outfile )) ) {
696             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
697             rc = G10ERR_CREATE_FILE;
698             goto leave;
699         }
700         else if( opt.verbose )
701             log_info(_("writing to `%s'\n"), outfile );
702     }
703     else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
704         goto leave;
705
706     /* prepare to calculate the MD over the input */
707     if( opt.textmode && !outfile && !multifile )
708       {
709         memset( &tfx, 0, sizeof tfx);
710         iobuf_push_filter( inp, text_filter, &tfx );
711       }
712
713     mfx.md = md_open(0, 0);
714
715    /* If we're encrypting and signing, it is reasonable to pick the
716        hash algorithm to use out of the recepient key prefs. */
717     if(pk_list)
718       {
719         if(opt.def_digest_algo)
720           {
721             if(!opt.expert &&
722                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
723                                       opt.def_digest_algo,
724                                       NULL)!=opt.def_digest_algo)
725           log_info(_("forcing digest algorithm %s (%d) "
726                      "violates recipient preferences\n"),
727                    digest_algo_to_string(opt.def_digest_algo),
728                    opt.def_digest_algo);
729           }
730         else
731           {
732             int hashlen=0,algo;
733
734             /* Of course, if the recipient asks for something
735                unreasonable (like a non-160-bit hash for DSA, for
736                example), then don't do it.  Check all sk's - if any
737                are DSA, then the hash must be 160-bit.  In the future
738                this can be more complex with different hashes for each
739                sk, but so long as there is only one signing algorithm
740                with hash restrictions, this is ok. -dms */
741
742             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
743               if(sk_rover->sk->pubkey_algo==PUBKEY_ALGO_DSA)
744                 hashlen=20;
745
746             if((algo=
747                 select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,
748                                        hashlen?&hashlen:NULL))>0)
749               recipient_digest_algo=algo;
750           }
751       }
752
753     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
754         PKT_secret_key *sk = sk_rover->sk;
755         md_enable(mfx.md, hash_for(sk->pubkey_algo, sk->version ));
756     }
757
758     if( !multifile )
759         iobuf_push_filter( inp, md_filter, &mfx );
760
761     if( detached && !encryptflag && !RFC1991 )
762         afx.what = 2;
763
764     if( opt.armor && !outfile  )
765         iobuf_push_filter( out, armor_filter, &afx );
766
767     if( encryptflag ) {
768         efx.pk_list = pk_list;
769         /* fixme: set efx.cfx.datalen if known */
770         iobuf_push_filter( out, encrypt_filter, &efx );
771     }
772
773     if( opt.compress && !outfile && ( !detached || opt.compress_sigs) )
774       {
775         int compr_algo=opt.def_compress_algo;
776
777         /* If not forced by user */
778         if(compr_algo==-1)
779           {
780             /* If we're not encrypting, then select_algo_from_prefs
781                will fail and we'll end up with the default.  If we are
782                encrypting, select_algo_from_prefs cannot fail since
783                there is an assumed preference for uncompressed data.
784                Still, if it did fail, we'll also end up with the
785                default. */
786  
787             if((compr_algo=
788                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
789               compr_algo=default_compress_algo();
790           }
791         else if(!opt.expert && pk_list
792                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
793                                           compr_algo,NULL)!=compr_algo)
794           log_info(_("forcing compression algorithm %s (%d) "
795                      "violates recipient preferences\n"),
796                    compress_algo_to_string(compr_algo),compr_algo);
797
798         /* algo 0 means no compression */
799         if( compr_algo )
800           {
801             zfx.algo = compr_algo;
802             iobuf_push_filter( out, compress_filter, &zfx );
803           }
804       }
805
806     /* Write the one-pass signature packets if needed */
807     if (!detached && !RFC1991) {
808         rc = write_onepass_sig_packets (sk_list, out,
809                                         opt.textmode && !outfile ? 0x01:0x00);
810         if (rc)
811             goto leave;
812     }
813
814     /* setup the inner packet */
815     if( detached ) {
816         if( multifile ) {
817             STRLIST sl;
818
819             if( opt.verbose )
820                 log_info(_("signing:") );
821             /* must walk reverse trough this list */
822             for( sl = strlist_last(filenames); sl;
823                         sl = strlist_prev( filenames, sl ) ) {
824                 if( !(inp = iobuf_open(sl->d)) ) {
825                     log_error(_("can't open %s: %s\n"),
826                                             sl->d, strerror(errno) );
827                     rc = G10ERR_OPEN_FILE;
828                     goto leave;
829                 }
830                 handle_progress (&pfx, inp, sl->d);
831                 if( opt.verbose )
832                     fprintf(stderr, " `%s'", sl->d );
833                 if(opt.textmode)
834                   {
835                     memset( &tfx, 0, sizeof tfx);
836                     iobuf_push_filter( inp, text_filter, &tfx );
837                   }
838                 iobuf_push_filter( inp, md_filter, &mfx );
839                 while( iobuf_get(inp) != -1 )
840                     ;
841                 iobuf_close(inp); inp = NULL;
842             }
843             if( opt.verbose )
844                 putc( '\n', stderr );
845         }
846         else {
847             /* read, so that the filter can calculate the digest */
848             while( iobuf_get(inp) != -1 )
849                 ;
850         }
851     }
852     else {
853         rc = write_plaintext_packet (out, inp, fname,
854                                      opt.textmode && !outfile ? 't':'b');
855     }
856
857     /* catch errors from above */
858     if (rc)
859         goto leave;
860
861     /* write the signatures */
862     rc = write_signature_packets (sk_list, out, mfx.md,
863                                   opt.textmode && !outfile? 0x01 : 0x00,
864                                   0, duration, detached ? 'D':'S');
865     if( rc )
866         goto leave;
867
868
869   leave:
870     if( rc )
871         iobuf_cancel(out);
872     else {
873         iobuf_close(out);
874         if (encryptflag)
875             write_status( STATUS_END_ENCRYPTION );
876     }
877     iobuf_close(inp);
878     md_close( mfx.md );
879     release_sk_list( sk_list );
880     release_pk_list( pk_list );
881     recipient_digest_algo=0;
882     return rc;
883 }
884
885
886
887 /****************
888  * make a clear signature. note that opt.armor is not needed
889  */
890 int
891 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
892 {
893     armor_filter_context_t afx;
894     progress_filter_context_t pfx;
895     MD_HANDLE textmd = NULL;
896     IOBUF inp = NULL, out = NULL;
897     PACKET pkt;
898     int rc = 0;
899     SK_LIST sk_list = NULL;
900     SK_LIST sk_rover = NULL;
901     int old_style = RFC1991;
902     int only_md5 = 0;
903     u32 duration=0;
904
905     memset( &afx, 0, sizeof afx);
906     init_packet( &pkt );
907
908     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !RFC1991)
909       duration=ask_expire_interval(1);
910
911     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
912         goto leave;
913
914     if( !old_style && !duration )
915         old_style = only_old_style( sk_list );
916
917     if(PGP2 && !only_old_style(sk_list))
918       {
919         log_info(_("you can only clearsign with PGP 2.x style keys "
920                    "while in --pgp2 mode\n"));
921         compliance_failure();
922       }
923
924     /* prepare iobufs */
925     if( !(inp = iobuf_open(fname)) ) {
926         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
927                                         strerror(errno) );
928         rc = G10ERR_OPEN_FILE;
929         goto leave;
930     }
931     handle_progress (&pfx, inp, fname);
932
933     if( outfile ) {
934         if( !(out = iobuf_create( outfile )) ) {
935             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
936             rc = G10ERR_CREATE_FILE;
937             goto leave;
938         }
939         else if( opt.verbose )
940             log_info(_("writing to `%s'\n"), outfile );
941     }
942     else if( (rc = open_outfile( fname, 1, &out )) )
943         goto leave;
944
945     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
946
947     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
948         PKT_secret_key *sk = sk_rover->sk;
949         if( hash_for(sk->pubkey_algo, sk->version) == DIGEST_ALGO_MD5 )
950             only_md5 = 1;
951         else {
952             only_md5 = 0;
953             break;
954         }
955     }
956
957     if( !(old_style && only_md5) ) {
958         const char *s;
959         int any = 0;
960         byte hashs_seen[256];
961
962         memset( hashs_seen, 0, sizeof hashs_seen );
963         iobuf_writestr(out, "Hash: " );
964         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
965             PKT_secret_key *sk = sk_rover->sk;
966             int i = hash_for(sk->pubkey_algo, sk->version);
967
968             if( !hashs_seen[ i & 0xff ] ) {
969                 s = digest_algo_to_string( i );
970                 if( s ) {
971                     hashs_seen[ i & 0xff ] = 1;
972                     if( any )
973                         iobuf_put(out, ',' );
974                     iobuf_writestr(out, s );
975                     any = 1;
976                 }
977             }
978         }
979         assert(any);
980         iobuf_writestr(out, LF );
981     }
982
983     if( opt.not_dash_escaped )
984       iobuf_writestr( out,
985                   "NotDashEscaped: You need GnuPG to verify this message" LF );
986     iobuf_writestr(out, LF );
987
988     textmd = md_open(0, 0);
989     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
990         PKT_secret_key *sk = sk_rover->sk;
991         md_enable(textmd, hash_for(sk->pubkey_algo, sk->version));
992     }
993     if ( DBG_HASHING )
994         md_start_debug( textmd, "clearsign" );
995     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
996                         opt.escape_from, (old_style && only_md5) );
997     /* fixme: check for read errors */
998
999     /* now write the armor */
1000     afx.what = 2;
1001     iobuf_push_filter( out, armor_filter, &afx );
1002
1003     /* write the signatures */
1004     rc=write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C');
1005     if( rc )
1006         goto leave;
1007
1008   leave:
1009     if( rc )
1010         iobuf_cancel(out);
1011     else
1012         iobuf_close(out);
1013     iobuf_close(inp);
1014     md_close( textmd );
1015     release_sk_list( sk_list );
1016     return rc;
1017 }
1018
1019 /*
1020  * Sign and conventionally encrypt the given file.
1021  * FIXME: Far too much code is duplicated - revamp the whole file.
1022  */
1023 int
1024 sign_symencrypt_file (const char *fname, STRLIST locusr)
1025 {
1026     armor_filter_context_t afx;
1027     progress_filter_context_t pfx;
1028     compress_filter_context_t zfx;
1029     md_filter_context_t mfx;
1030     text_filter_context_t tfx;
1031     cipher_filter_context_t cfx;
1032     IOBUF inp = NULL, out = NULL;
1033     PACKET pkt;
1034     STRING2KEY *s2k = NULL;
1035     int rc = 0;
1036     SK_LIST sk_list = NULL;
1037     SK_LIST sk_rover = NULL;
1038     int algo;
1039     u32 duration=0;
1040
1041     memset( &afx, 0, sizeof afx);
1042     memset( &zfx, 0, sizeof zfx);
1043     memset( &mfx, 0, sizeof mfx);
1044     memset( &tfx, 0, sizeof tfx);
1045     memset( &cfx, 0, sizeof cfx);
1046     init_packet( &pkt );
1047
1048     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !RFC1991)
1049       duration=ask_expire_interval(1);
1050
1051     rc = build_sk_list (locusr, &sk_list, 1, PUBKEY_USAGE_SIG);
1052     if (rc) 
1053         goto leave;
1054
1055     /* prepare iobufs */
1056     inp = iobuf_open(fname);
1057     if( !inp ) {
1058         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
1059                                         strerror(errno) );
1060         rc = G10ERR_OPEN_FILE;
1061         goto leave;
1062     }
1063     handle_progress (&pfx, inp, fname);
1064
1065     /* prepare key */
1066     s2k = m_alloc_clear( sizeof *s2k );
1067     s2k->mode = RFC1991? 0:opt.s2k_mode;
1068     s2k->hash_algo = opt.s2k_digest_algo;
1069
1070     algo = default_cipher_algo();
1071     if (!opt.quiet || !opt.batch)
1072         log_info (_("%s encryption will be used\n"),
1073                     cipher_algo_to_string(algo) );
1074     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, NULL);
1075
1076     if (!cfx.dek || !cfx.dek->keylen) {
1077         rc = G10ERR_PASSPHRASE;
1078         log_error(_("error creating passphrase: %s\n"), g10_errstr(rc) );
1079         goto leave;
1080     }
1081
1082     /* now create the outfile */
1083     rc = open_outfile (fname, opt.armor? 1:0, &out);
1084     if (rc)
1085         goto leave;
1086
1087     /* prepare to calculate the MD over the input */
1088     if (opt.textmode)
1089         iobuf_push_filter (inp, text_filter, &tfx);
1090     mfx.md = md_open(0, 0);
1091
1092     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
1093         PKT_secret_key *sk = sk_rover->sk;
1094         md_enable (mfx.md, hash_for (sk->pubkey_algo, sk->version ));
1095     }
1096
1097     iobuf_push_filter (inp, md_filter, &mfx);
1098
1099     /* Push armor output filter */
1100     if (opt.armor)
1101         iobuf_push_filter (out, armor_filter, &afx);
1102
1103     /* Write the symmetric key packet */
1104     /*(current filters: armor)*/
1105     if (!RFC1991) {
1106         PKT_symkey_enc *enc = m_alloc_clear( sizeof *enc );
1107         enc->version = 4;
1108         enc->cipher_algo = cfx.dek->algo;
1109         enc->s2k = *s2k;
1110         pkt.pkttype = PKT_SYMKEY_ENC;
1111         pkt.pkt.symkey_enc = enc;
1112         if( (rc = build_packet( out, &pkt )) )
1113             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1114         m_free(enc);
1115     }
1116
1117     /* Push the encryption filter */
1118     iobuf_push_filter( out, cipher_filter, &cfx );
1119
1120     /* Push the Zip filter */
1121     if (opt.compress && default_compress_algo())
1122       {
1123         zfx.algo = default_compress_algo();
1124         iobuf_push_filter( out, compress_filter, &zfx );
1125       }
1126
1127     /* Write the one-pass signature packets */
1128     /*(current filters: zip - encrypt - armor)*/
1129     if (!RFC1991) {
1130         rc = write_onepass_sig_packets (sk_list, out,
1131                                         opt.textmode? 0x01:0x00);
1132         if (rc)
1133             goto leave;
1134     }
1135
1136     /* Pipe data through all filters; i.e. write the signed stuff */
1137     /*(current filters: zip - encrypt - armor)*/
1138     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1139     if (rc)
1140         goto leave;
1141     
1142     /* Write the signatures */
1143     /*(current filters: zip - encrypt - armor)*/
1144     rc = write_signature_packets (sk_list, out, mfx.md,
1145                                   opt.textmode? 0x01 : 0x00,
1146                                   0, duration, 'S');
1147     if( rc )
1148         goto leave;
1149
1150
1151   leave:
1152     if( rc )
1153         iobuf_cancel(out);
1154     else {
1155         iobuf_close(out);
1156         write_status( STATUS_END_ENCRYPTION );
1157     }
1158     iobuf_close(inp);
1159     release_sk_list( sk_list );
1160     md_close( mfx.md );
1161     m_free(cfx.dek);
1162     m_free(s2k);
1163     return rc;
1164 }
1165
1166
1167 /****************
1168  * Create a signature packet for the given public key certificate and
1169  * the user id and return it in ret_sig. User signature class SIGCLASS
1170  * user-id is not used (and may be NULL if sigclass is 0x20) If
1171  * DIGEST_ALGO is 0 the function selects an appropriate one.
1172  * SIGVERSION gives the minimal required signature packet version;
1173  * this is needed so that special properties like local sign are not
1174  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1175  * the timestamp to use for the signature. 0 means "now" */
1176 int
1177 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1178                     PKT_user_id *uid, PKT_public_key *subpk,
1179                     PKT_secret_key *sk,
1180                     int sigclass, int digest_algo,
1181                     int sigversion, u32 timestamp, u32 duration,
1182                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
1183                    )
1184 {
1185     PKT_signature *sig;
1186     int rc=0;
1187     MD_HANDLE md;
1188
1189     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1190             || sigclass == 0x20 || sigclass == 0x18
1191             || sigclass == 0x30 || sigclass == 0x28 );
1192
1193     if (opt.force_v4_certs)
1194         sigversion = 4;
1195
1196     if (sigversion < sk->version)
1197         sigversion = sk->version;
1198
1199     /* If you are making a signature on a v4 key using your v3 key, it
1200        doesn't make sense to generate a v3 sig.  After all, no v3-only
1201        PGP implementation could understand the v4 key in the first
1202        place.  Note that this implies that a signature on an attribute
1203        uid is usually going to be v4 as well, since they are not
1204        generally found on v3 keys. */
1205     if (sigversion < pk->version)
1206         sigversion = pk->version;
1207
1208     if( !digest_algo )
1209       {
1210         /* Basically, this means use SHA1 always unless it's a v3 RSA
1211            key making a v3 cert (use MD5), or the user specified
1212            something (use whatever they said).  They still must use a
1213            160-bit hash with DSA, or the signature will fail.  Note
1214            that this still allows the caller of make_keysig_packet to
1215            override the user setting if it must. */
1216
1217         if(opt.cert_digest_algo)
1218           digest_algo=opt.cert_digest_algo;
1219         else if((sk->pubkey_algo==PUBKEY_ALGO_RSA ||
1220                  sk->pubkey_algo==PUBKEY_ALGO_RSA_S) &&
1221                 pk->version<4 && sigversion < 4)
1222           digest_algo = DIGEST_ALGO_MD5;
1223         else
1224           digest_algo = DIGEST_ALGO_SHA1;
1225       }
1226
1227     md = md_open( digest_algo, 0 );
1228
1229     /* hash the public key certificate and the user id */
1230     hash_public_key( md, pk );
1231     if( sigclass == 0x18 || sigclass == 0x28 ) { /* subkey binding/revocation*/
1232         hash_public_key( md, subpk );
1233     }
1234     else if( sigclass != 0x1F && sigclass != 0x20 ) {
1235         hash_uid (md, sigversion, uid);
1236     }
1237     /* and make the signature packet */
1238     sig = m_alloc_clear( sizeof *sig );
1239     sig->version = sigversion;
1240     sig->flags.exportable=1;
1241     sig->flags.revocable=1;
1242     keyid_from_sk( sk, sig->keyid );
1243     sig->pubkey_algo = sk->pubkey_algo;
1244     sig->digest_algo = digest_algo;
1245     if(timestamp)
1246       sig->timestamp=timestamp;
1247     else
1248       sig->timestamp=make_timestamp();
1249     if(duration)
1250       sig->expiredate=sig->timestamp+duration;
1251     sig->sig_class = sigclass;
1252     if( sig->version >= 4 )
1253         build_sig_subpkt_from_sig( sig );
1254     mk_notation_and_policy( sig, pk, sk );
1255
1256     /* Crucial that the call to mksubpkt comes LAST before the calls
1257        to finalize the sig as that makes it possible for the mksubpkt
1258        function to get a reliable pointer to the subpacket area. */
1259     if( sig->version >= 4 && mksubpkt )
1260         rc = (*mksubpkt)( sig, opaque );
1261
1262     if( !rc ) {
1263         hash_sigversion_to_magic (md, sig);
1264         md_final(md);
1265
1266         rc = complete_sig( sig, sk, md );
1267     }
1268
1269     md_close( md );
1270     if( rc )
1271         free_seckey_enc( sig );
1272     else
1273         *ret_sig = sig;
1274     return rc;
1275 }
1276
1277
1278
1279 /****************
1280  * Create a new signature packet based on an existing one.
1281  * Only user ID signatures are supported for now.
1282  * TODO: Merge this with make_keysig_packet.
1283  */
1284 int
1285 update_keysig_packet( PKT_signature **ret_sig,
1286                       PKT_signature *orig_sig,
1287                       PKT_public_key *pk,
1288                       PKT_user_id *uid, 
1289                       PKT_public_key *subpk,
1290                       PKT_secret_key *sk,
1291                       int (*mksubpkt)(PKT_signature *, void *),
1292                       void *opaque
1293                    )
1294 {
1295     PKT_signature *sig;
1296     int rc=0;
1297     MD_HANDLE md;
1298
1299     if ((!orig_sig || !pk || !sk)
1300         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1301         || (orig_sig->sig_class == 0x18 && !subpk))
1302       return G10ERR_GENERAL;
1303
1304     md = md_open( orig_sig->digest_algo, 0 );
1305
1306     /* hash the public key certificate and the user id */
1307     hash_public_key( md, pk );
1308
1309     if( orig_sig->sig_class == 0x18 )
1310       hash_public_key( md, subpk );
1311     else
1312       hash_uid (md, orig_sig->version, uid);
1313
1314     /* create a new signature packet */
1315     sig = copy_signature (NULL, orig_sig);
1316
1317     /* We need to create a new timestamp so that new sig expiration
1318        calculations are done correctly... */
1319     sig->timestamp=make_timestamp();
1320
1321     /* ... but we won't make a timestamp earlier than the existing
1322        one. */
1323     while(sig->timestamp<=orig_sig->timestamp)
1324       {
1325         sleep(1);
1326         sig->timestamp=make_timestamp();
1327       }
1328
1329     /* Note that already expired sigs will remain expired (with a
1330        duration of 0) since build-packet.c:build_sig_subpkt_from_sig
1331        detects this case. */
1332
1333     if( sig->version >= 4 )
1334       {
1335         /* Put the updated timestamp into the sig.  Note that this
1336            will automagically lower any sig expiration dates to
1337            correctly correspond to the differences in the timestamps
1338            (i.e. the duration will shrink). */
1339         build_sig_subpkt_from_sig( sig );
1340
1341         if (mksubpkt)
1342           rc = (*mksubpkt)(sig, opaque);
1343       }
1344
1345     if (!rc) {
1346         hash_sigversion_to_magic (md, sig);
1347         md_final(md);
1348
1349         rc = complete_sig( sig, sk, md );
1350     }
1351
1352     md_close (md);
1353     if( rc )
1354         free_seckey_enc (sig);
1355     else
1356         *ret_sig = sig;
1357     return rc;
1358 }