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