b5314cccfa0b9f772393a520c6eae1e9ab58f55a
[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     if( recipient_digest_algo )
338         return recipient_digest_algo;
339     if( pubkey_algo == PUBKEY_ALGO_DSA )
340         return DIGEST_ALGO_SHA1;
341     if( pubkey_algo == PUBKEY_ALGO_RSA && packet_version < 4 )
342         return DIGEST_ALGO_MD5;
343     return DEFAULT_DIGEST_ALGO;
344 }
345
346 static int
347 only_old_style( SK_LIST sk_list )
348 {
349     SK_LIST sk_rover = NULL;
350     int old_style = 0;
351
352     /* if there are only old style capable key we use the old sytle */
353     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
354         PKT_secret_key *sk = sk_rover->sk;
355         if( sk->pubkey_algo == PUBKEY_ALGO_RSA && sk->version < 4 )
356             old_style = 1;
357         else
358             return 0;
359     }
360     return old_style;
361 }
362
363
364 static void
365 print_status_sig_created ( PKT_secret_key *sk, PKT_signature *sig, int what )
366 {
367     byte array[MAX_FINGERPRINT_LEN], *p;
368     char buf[100+MAX_FINGERPRINT_LEN*2];
369     size_t i, n;
370
371     sprintf(buf, "%c %d %d %02x %lu ",
372             what, sig->pubkey_algo, sig->digest_algo, sig->sig_class,
373             (ulong)sig->timestamp );
374
375     fingerprint_from_sk( sk, array, &n );
376     p = buf + strlen(buf);
377     for(i=0; i < n ; i++ )
378         sprintf(p+2*i, "%02X", array[i] );
379
380     write_status_text( STATUS_SIG_CREATED, buf );
381 }
382
383
384 /*
385  * Loop over the secret certificates in SK_LIST and build the one pass
386  * signature packets.  OpenPGP says that the data should be bracket by
387  * the onepass-sig and signature-packet; so we build these onepass
388  * packet here in reverse order 
389  */
390 static int
391 write_onepass_sig_packets (SK_LIST sk_list, IOBUF out, int sigclass )
392 {
393     int skcount;
394     SK_LIST sk_rover;
395
396     for (skcount=0, sk_rover=sk_list; sk_rover; sk_rover = sk_rover->next)
397         skcount++;
398
399     for (; skcount; skcount--) {
400         PKT_secret_key *sk;
401         PKT_onepass_sig *ops;
402         PACKET pkt;
403         int i, rc;
404         
405         for (i=0, sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
406             if (++i == skcount)
407                 break;
408         }
409
410         sk = sk_rover->sk;
411         ops = m_alloc_clear (sizeof *ops);
412         ops->sig_class = sigclass;
413         ops->digest_algo = hash_for (sk->pubkey_algo, sk->version);
414         ops->pubkey_algo = sk->pubkey_algo;
415         keyid_from_sk (sk, ops->keyid);
416         ops->last = (skcount == 1);
417         
418         init_packet(&pkt);
419         pkt.pkttype = PKT_ONEPASS_SIG;
420         pkt.pkt.onepass_sig = ops;
421         rc = build_packet (out, &pkt);
422         free_packet (&pkt);
423         if (rc) {
424             log_error ("build onepass_sig packet failed: %s\n",
425                        g10_errstr(rc));
426             return rc;
427         }
428     }
429
430     return 0;
431 }
432
433 /*
434  * Helper to write the plaintext (literal data) packet
435  */
436 static int
437 write_plaintext_packet (IOBUF out, IOBUF inp, const char *fname, int ptmode)
438 {
439     PKT_plaintext *pt = NULL;
440     u32 filesize;
441     int rc = 0;
442
443     if (!opt.no_literal) {
444         if (fname || opt.set_filename) {
445             char *s = make_basename (opt.set_filename? opt.set_filename
446                                                      : fname,
447                                      iobuf_get_real_fname(inp));
448             pt = m_alloc (sizeof *pt + strlen(s) - 1);
449             pt->namelen = strlen (s);
450             memcpy (pt->name, s, pt->namelen);
451             m_free (s);
452         }
453         else { /* no filename */
454             pt = m_alloc (sizeof *pt - 1);
455             pt->namelen = 0;
456         }
457     }
458
459     /* try to calculate the length of the data */
460     if (fname) {
461         if( !(filesize = iobuf_get_filelength(inp)) )
462             log_info (_("WARNING: `%s' is an empty file\n"), fname);
463
464         /* we can't yet encode the length of very large files,
465          * so we switch to partial length encoding in this case */
466         if (filesize >= IOBUF_FILELENGTH_LIMIT)
467             filesize = 0;
468
469         /* because the text_filter modifies the length of the
470          * data, it is not possible to know the used length
471          * without a double read of the file - to avoid that
472          * we simple use partial length packets.
473          */
474         if ( ptmode == 't' )
475             filesize = 0;
476     }
477     else {
478         filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
479     }
480
481     if (!opt.no_literal) {
482         PACKET pkt;
483
484         pt->timestamp = make_timestamp ();
485         pt->mode = ptmode;
486         pt->len = filesize;
487         pt->new_ctb = !pt->len && !opt.rfc1991;
488         pt->buf = inp;
489         init_packet(&pkt);
490         pkt.pkttype = PKT_PLAINTEXT;
491         pkt.pkt.plaintext = pt;
492         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
493         if( (rc = build_packet (out, &pkt)) )
494             log_error ("build_packet(PLAINTEXT) failed: %s\n",
495                        g10_errstr(rc) );
496         pt->buf = NULL;
497     }
498     else {
499         byte copy_buffer[4096];
500         int  bytes_copied;
501
502         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
503             if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
504                 rc = G10ERR_WRITE_FILE;
505                 log_error ("copying input to output failed: %s\n",
506                            g10_errstr(rc));
507                 break;
508             }
509         memset(copy_buffer, 0, 4096); /* burn buffer */
510     }
511     /* fixme: it seems that we never freed pt/pkt */
512     
513     return rc;
514 }
515
516 /*
517  * Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
518  * hash which will not be changes here.
519  */
520 static int
521 write_signature_packets (SK_LIST sk_list, IOBUF out, MD_HANDLE hash,
522                          int sigclass, u32 timestamp, u32 duration,
523                          int status_letter)
524 {
525     SK_LIST sk_rover;
526
527     /* loop over the secret certificates */
528     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
529         PKT_secret_key *sk;
530         PKT_signature *sig;
531         MD_HANDLE md;
532         int rc;
533
534         sk = sk_rover->sk;
535
536         /* build the signature packet */
537         sig = m_alloc_clear (sizeof *sig);
538         if(opt.force_v3_sigs || opt.rfc1991)
539           sig->version=3;
540         else if(duration || opt.sig_policy_url || opt.sig_notation_data)
541           sig->version=4;
542         else
543           sig->version=sk->version;
544         keyid_from_sk (sk, sig->keyid);
545         sig->digest_algo = hash_for (sk->pubkey_algo, sk->version);
546         sig->pubkey_algo = sk->pubkey_algo;
547         if(timestamp)
548           sig->timestamp = timestamp;
549         else
550           sig->timestamp = make_timestamp();
551         if(duration)
552           sig->expiredate = sig->timestamp+duration;
553         sig->sig_class = sigclass;
554
555         md = md_copy (hash);
556
557         if (sig->version >= 4)
558             build_sig_subpkt_from_sig (sig);
559         mk_notation_and_policy (sig, NULL, sk);
560
561         hash_sigversion_to_magic (md, sig);
562         md_final (md);
563
564         rc = do_sign( sk, sig, md, hash_for (sig->pubkey_algo, sk->version) );
565         md_close (md);
566
567         if( !rc ) { /* and write it */
568             PACKET pkt;
569
570             init_packet(&pkt);
571             pkt.pkttype = PKT_SIGNATURE;
572             pkt.pkt.signature = sig;
573             rc = build_packet (out, &pkt);
574             if (!rc && is_status_enabled()) {
575                 print_status_sig_created ( sk, sig, status_letter);
576             }
577             free_packet (&pkt);
578             if (rc)
579                 log_error ("build signature packet failed: %s\n",
580                            g10_errstr(rc) );
581         }
582         if( rc )
583             return rc;;
584     }
585
586     return 0;
587 }
588
589 /****************
590  * Sign the files whose names are in FILENAME.
591  * If DETACHED has the value true,
592  * make a detached signature.  If FILENAMES->d is NULL read from stdin
593  * and ignore the detached mode.  Sign the file with all secret keys
594  * which can be taken from LOCUSR, if this is NULL, use the default one
595  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
596  * signed data for these users.
597  * If OUTFILE is not NULL; this file is used for output and the function
598  * does not ask for overwrite permission; output is then always
599  * uncompressed, non-armored and in binary mode.
600  */
601 int
602 sign_file( STRLIST filenames, int detached, STRLIST locusr,
603            int encryptflag, STRLIST remusr, const char *outfile )
604 {
605     const char *fname;
606     armor_filter_context_t afx;
607     compress_filter_context_t zfx;
608     md_filter_context_t mfx;
609     text_filter_context_t tfx;
610     encrypt_filter_context_t efx;
611     IOBUF inp = NULL, out = NULL;
612     PACKET pkt;
613     int rc = 0;
614     PK_LIST pk_list = NULL;
615     SK_LIST sk_list = NULL;
616     SK_LIST sk_rover = NULL;
617     int multifile = 0;
618     u32 timestamp=0,duration=0;
619
620     memset( &afx, 0, sizeof afx);
621     memset( &zfx, 0, sizeof zfx);
622     memset( &mfx, 0, sizeof mfx);
623     memset( &tfx, 0, sizeof tfx);
624     memset( &efx, 0, sizeof efx);
625     init_packet( &pkt );
626
627     if( filenames ) {
628         fname = filenames->d;
629         multifile = !!filenames->next;
630     }
631     else
632         fname = NULL;
633
634     if( fname && filenames->next && (!detached || encryptflag) )
635         log_bug("multiple files can only be detached signed");
636
637     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !opt.rfc1991)
638       duration=ask_expire_interval(1);
639
640     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
641         goto leave;
642
643     if(opt.pgp2 && !only_old_style(sk_list))
644       {
645         log_info(_("you can only detach-sign with PGP 2.x style keys "
646                    "while in --pgp2 mode\n"));
647         log_info(_("this message may not be usable by %s\n"),"PGP 2.x");
648         opt.pgp2=0;
649       }
650
651     if(encryptflag && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
652       goto leave;
653
654     /* prepare iobufs */
655     if( multifile )  /* have list of filenames */
656         inp = NULL; /* we do it later */
657     else if( !(inp = iobuf_open(fname)) ) {
658         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
659                                         strerror(errno) );
660         rc = G10ERR_OPEN_FILE;
661         goto leave;
662     }
663
664     if( outfile ) {
665         if( !(out = iobuf_create( outfile )) ) {
666             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
667             rc = G10ERR_CREATE_FILE;
668             goto leave;
669         }
670         else if( opt.verbose )
671             log_info(_("writing to `%s'\n"), outfile );
672     }
673     else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
674         goto leave;
675
676     /* prepare to calculate the MD over the input */
677     if( opt.textmode && !outfile )
678         iobuf_push_filter( inp, text_filter, &tfx );
679     mfx.md = md_open(0, 0);
680
681    /* If we're encrypting and signing, it is reasonable to pick the
682        hash algorithm to use out of the recepient key prefs. */
683     if(pk_list)
684       {
685         if(opt.def_digest_algo)
686           {
687             if(!opt.expert &&
688                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
689                                       opt.def_digest_algo,
690                                       NULL)!=opt.def_digest_algo)
691           log_info(_("forcing digest algorithm %s (%d) "
692                      "violates recipient preferences\n"),
693                    digest_algo_to_string(opt.def_digest_algo),
694                    opt.def_digest_algo);
695           }
696         else
697           {
698             int hashlen=0,algo;
699
700             /* Of course, if the recipient asks for something
701                unreasonable (like a non-160-bit hash for DSA, for
702                example), then don't do it.  Check all sk's - if any
703                are DSA, then the hash must be 160-bit.  In the future
704                this can be more complex with different hashes for each
705                sk, but so long as there is only one signing algorithm
706                with hash restrictions, this is ok. -dms */
707
708             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
709               if(sk_rover->sk->pubkey_algo==PUBKEY_ALGO_DSA)
710                 hashlen=20;
711
712             if((algo=
713                 select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hashlen))>0)
714               recipient_digest_algo=algo;
715           }
716       }
717
718     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
719         PKT_secret_key *sk = sk_rover->sk;
720         md_enable(mfx.md, hash_for(sk->pubkey_algo, sk->version ));
721     }
722
723     if( !multifile )
724         iobuf_push_filter( inp, md_filter, &mfx );
725
726     if( detached && !encryptflag && !opt.rfc1991 )
727         afx.what = 2;
728
729     if( opt.armor && !outfile  )
730         iobuf_push_filter( out, armor_filter, &afx );
731
732     if( encryptflag ) {
733         efx.pk_list = pk_list;
734         /* fixme: set efx.cfx.datalen if known */
735         iobuf_push_filter( out, encrypt_filter, &efx );
736     }
737
738     if( opt.compress && !outfile && ( !detached || opt.compress_sigs) )
739       {
740         int compr_algo=opt.def_compress_algo;
741
742         /* If not forced by user */
743         if(compr_algo==-1)
744           {
745             /* If we're not encrypting, then select_algo_from_prefs
746                will fail and we'll end up with the default.  If we are
747                encrypting, select_algo_from_prefs cannot fail since
748                there is an assumed preference for uncompressed data.
749                Still, if it did fail, we'll also end up with the
750                default. */
751  
752             if((compr_algo=
753                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
754               compr_algo=DEFAULT_COMPRESS_ALGO;
755           }
756         else if(!opt.expert &&
757                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
758                                        compr_algo,NULL)!=compr_algo)
759           log_info(_("forcing compression algorithm %s (%d) "
760                      "violates recipient preferences\n"),
761                    compress_algo_to_string(compr_algo),compr_algo);
762
763         /* algo 0 means no compression */
764         if( compr_algo )
765           {
766             zfx.algo = compr_algo;
767             iobuf_push_filter( out, compress_filter, &zfx );
768           }
769       }
770
771     /* Write the one-pass signature packets if needed */
772     if (!detached && !opt.rfc1991) {
773         rc = write_onepass_sig_packets (sk_list, out,
774                                         opt.textmode && !outfile ? 0x01:0x00);
775         if (rc)
776             goto leave;
777     }
778
779     /* setup the inner packet */
780     if( detached ) {
781         if( multifile ) {
782             STRLIST sl;
783
784             if( opt.verbose )
785                 log_info(_("signing:") );
786             /* must walk reverse trough this list */
787             for( sl = strlist_last(filenames); sl;
788                         sl = strlist_prev( filenames, sl ) ) {
789                 if( !(inp = iobuf_open(sl->d)) ) {
790                     log_error(_("can't open %s: %s\n"),
791                                             sl->d, strerror(errno) );
792                     rc = G10ERR_OPEN_FILE;
793                     goto leave;
794                 }
795                 if( opt.verbose )
796                     fprintf(stderr, " `%s'", sl->d );
797                 iobuf_push_filter( inp, md_filter, &mfx );
798                 while( iobuf_get(inp) != -1 )
799                     ;
800                 iobuf_close(inp); inp = NULL;
801             }
802             if( opt.verbose )
803                 putc( '\n', stderr );
804         }
805         else {
806             /* read, so that the filter can calculate the digest */
807             while( iobuf_get(inp) != -1 )
808                 ;
809         }
810     }
811     else {
812         rc = write_plaintext_packet (out, inp, fname,
813                                      opt.textmode && !outfile ? 't':'b');
814     }
815
816     /* catch errors from above */
817     if (rc)
818         goto leave;
819
820     /* write the signatures */
821     rc = write_signature_packets (sk_list, out, mfx.md,
822                                   opt.textmode && !outfile? 0x01 : 0x00,
823                                   timestamp, duration, detached ? 'D':'S');
824     if( rc )
825         goto leave;
826
827
828   leave:
829     if( rc )
830         iobuf_cancel(out);
831     else {
832         iobuf_close(out);
833         if (encryptflag)
834             write_status( STATUS_END_ENCRYPTION );
835     }
836     iobuf_close(inp);
837     md_close( mfx.md );
838     release_sk_list( sk_list );
839     release_pk_list( pk_list );
840     recipient_digest_algo=0;
841     return rc;
842 }
843
844
845
846 /****************
847  * make a clear signature. note that opt.armor is not needed
848  */
849 int
850 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
851 {
852     armor_filter_context_t afx;
853     MD_HANDLE textmd = NULL;
854     IOBUF inp = NULL, out = NULL;
855     PACKET pkt;
856     int rc = 0;
857     SK_LIST sk_list = NULL;
858     SK_LIST sk_rover = NULL;
859     int old_style = opt.rfc1991;
860     int only_md5 = 0;
861     u32 timestamp=0,duration=0;
862
863     memset( &afx, 0, sizeof afx);
864     init_packet( &pkt );
865
866     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !opt.rfc1991)
867       duration=ask_expire_interval(1);
868
869     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
870         goto leave;
871
872     if( !old_style && !duration )
873         old_style = only_old_style( sk_list );
874
875     if(!old_style && opt.pgp2)
876       {
877         log_info(_("you can only clearsign with PGP 2.x style keys "
878                    "while in --pgp2 mode\n"));
879         log_info(_("this message may not be usable by %s\n"),"PGP 2.x");
880         opt.pgp2=0;
881       }
882
883     /* prepare iobufs */
884     if( !(inp = iobuf_open(fname)) ) {
885         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
886                                         strerror(errno) );
887         rc = G10ERR_OPEN_FILE;
888         goto leave;
889     }
890
891     if( outfile ) {
892         if( !(out = iobuf_create( outfile )) ) {
893             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
894             rc = G10ERR_CREATE_FILE;
895             goto leave;
896         }
897         else if( opt.verbose )
898             log_info(_("writing to `%s'\n"), outfile );
899     }
900     else if( (rc = open_outfile( fname, 1, &out )) )
901         goto leave;
902
903     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
904
905     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
906         PKT_secret_key *sk = sk_rover->sk;
907         if( hash_for(sk->pubkey_algo, sk->version) == DIGEST_ALGO_MD5 )
908             only_md5 = 1;
909         else {
910             only_md5 = 0;
911             break;
912         }
913     }
914
915     if( !(old_style && only_md5) ) {
916         const char *s;
917         int any = 0;
918         byte hashs_seen[256];
919
920         memset( hashs_seen, 0, sizeof hashs_seen );
921         iobuf_writestr(out, "Hash: " );
922         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
923             PKT_secret_key *sk = sk_rover->sk;
924             int i = hash_for(sk->pubkey_algo, sk->version);
925
926             if( !hashs_seen[ i & 0xff ] ) {
927                 s = digest_algo_to_string( i );
928                 if( s ) {
929                     hashs_seen[ i & 0xff ] = 1;
930                     if( any )
931                         iobuf_put(out, ',' );
932                     iobuf_writestr(out, s );
933                     any = 1;
934                 }
935             }
936         }
937         assert(any);
938         iobuf_writestr(out, LF );
939     }
940
941     if( opt.not_dash_escaped )
942       iobuf_writestr( out,
943                   "NotDashEscaped: You need GnuPG to verify this message" LF );
944     iobuf_writestr(out, LF );
945
946     textmd = md_open(0, 0);
947     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
948         PKT_secret_key *sk = sk_rover->sk;
949         md_enable(textmd, hash_for(sk->pubkey_algo, sk->version));
950     }
951     if ( DBG_HASHING )
952         md_start_debug( textmd, "clearsign" );
953     copy_clearsig_text( out, inp, textmd,
954                         !opt.not_dash_escaped, opt.escape_from, old_style );
955     /* fixme: check for read errors */
956
957     /* now write the armor */
958     afx.what = 2;
959     iobuf_push_filter( out, armor_filter, &afx );
960
961     /* write the signatures */
962     rc = write_signature_packets (sk_list, out, textmd, 0x01,
963                                   timestamp, duration, 'C');
964     if( rc )
965         goto leave;
966
967   leave:
968     if( rc )
969         iobuf_cancel(out);
970     else
971         iobuf_close(out);
972     iobuf_close(inp);
973     md_close( textmd );
974     release_sk_list( sk_list );
975     return rc;
976 }
977
978 /*
979  * Sign and conventionally encrypt the given file.
980  * FIXME: Far too much code is duplicated - revamp the whole file.
981  */
982 int
983 sign_symencrypt_file (const char *fname, STRLIST locusr)
984 {
985     armor_filter_context_t afx;
986     compress_filter_context_t zfx;
987     md_filter_context_t mfx;
988     text_filter_context_t tfx;
989     cipher_filter_context_t cfx;
990     IOBUF inp = NULL, out = NULL;
991     PACKET pkt;
992     STRING2KEY *s2k = NULL;
993     int rc = 0;
994     SK_LIST sk_list = NULL;
995     SK_LIST sk_rover = NULL;
996     int algo;
997     u32 timestamp=0,duration=0;
998
999     memset( &afx, 0, sizeof afx);
1000     memset( &zfx, 0, sizeof zfx);
1001     memset( &mfx, 0, sizeof mfx);
1002     memset( &tfx, 0, sizeof tfx);
1003     memset( &cfx, 0, sizeof cfx);
1004     init_packet( &pkt );
1005
1006     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !opt.rfc1991)
1007       duration=ask_expire_interval(1);
1008
1009     rc = build_sk_list (locusr, &sk_list, 1, PUBKEY_USAGE_SIG);
1010     if (rc) 
1011         goto leave;
1012
1013     /* prepare iobufs */
1014     inp = iobuf_open(fname);
1015     if( !inp ) {
1016         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
1017                                         strerror(errno) );
1018         rc = G10ERR_OPEN_FILE;
1019         goto leave;
1020     }
1021
1022     /* prepare key */
1023     s2k = m_alloc_clear( sizeof *s2k );
1024     s2k->mode = opt.rfc1991? 0:opt.s2k_mode;
1025     s2k->hash_algo = opt.def_digest_algo ? opt.def_digest_algo
1026                                          : opt.s2k_digest_algo;
1027
1028     algo = opt.def_cipher_algo ? opt.def_cipher_algo : opt.s2k_cipher_algo;
1029     if (!opt.quiet || !opt.batch)
1030         log_info (_("%s encryption will be used\n"),
1031                     cipher_algo_to_string(algo) );
1032     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL );
1033
1034     if (!cfx.dek || !cfx.dek->keylen) {
1035         rc = G10ERR_PASSPHRASE;
1036         log_error(_("error creating passphrase: %s\n"), g10_errstr(rc) );
1037         goto leave;
1038     }
1039
1040     /* now create the outfile */
1041     rc = open_outfile (fname, opt.armor? 1:0, &out);
1042     if (rc)
1043         goto leave;
1044
1045     /* prepare to calculate the MD over the input */
1046     if (opt.textmode)
1047         iobuf_push_filter (inp, text_filter, &tfx);
1048     mfx.md = md_open(0, 0);
1049
1050     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
1051         PKT_secret_key *sk = sk_rover->sk;
1052         md_enable (mfx.md, hash_for (sk->pubkey_algo, sk->version ));
1053     }
1054
1055     iobuf_push_filter (inp, md_filter, &mfx);
1056
1057     /* Push armor output filter */
1058     if (opt.armor)
1059         iobuf_push_filter (out, armor_filter, &afx);
1060
1061     /* Write the symmetric key packet */
1062     /*(current filters: armor)*/
1063     if (!opt.rfc1991) {
1064         PKT_symkey_enc *enc = m_alloc_clear( sizeof *enc );
1065         enc->version = 4;
1066         enc->cipher_algo = cfx.dek->algo;
1067         enc->s2k = *s2k;
1068         pkt.pkttype = PKT_SYMKEY_ENC;
1069         pkt.pkt.symkey_enc = enc;
1070         if( (rc = build_packet( out, &pkt )) )
1071             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1072         m_free(enc);
1073     }
1074
1075     /* Push the encryption filter */
1076     iobuf_push_filter( out, cipher_filter, &cfx );
1077
1078     /* Push the Zip filter */
1079     if (opt.compress)
1080       {
1081         int compr_algo=opt.def_compress_algo;
1082
1083         /* Default */
1084         if(compr_algo==-1)
1085           compr_algo=DEFAULT_COMPRESS_ALGO;
1086
1087         if (compr_algo)
1088           {
1089             zfx.algo = compr_algo;
1090             iobuf_push_filter( out, compress_filter, &zfx );
1091           }
1092       }
1093
1094     /* Write the one-pass signature packets */
1095     /*(current filters: zip - encrypt - armor)*/
1096     if (!opt.rfc1991) {
1097         rc = write_onepass_sig_packets (sk_list, out,
1098                                         opt.textmode? 0x01:0x00);
1099         if (rc)
1100             goto leave;
1101     }
1102
1103     /* Pipe data through all filters; i.e. write the signed stuff */
1104     /*(current filters: zip - encrypt - armor)*/
1105     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1106     if (rc)
1107         goto leave;
1108     
1109     /* Write the signatures */
1110     /*(current filters: zip - encrypt - armor)*/
1111     rc = write_signature_packets (sk_list, out, mfx.md,
1112                                   opt.textmode? 0x01 : 0x00,
1113                                   timestamp, duration, 'S');
1114     if( rc )
1115         goto leave;
1116
1117
1118   leave:
1119     if( rc )
1120         iobuf_cancel(out);
1121     else {
1122         iobuf_close(out);
1123         write_status( STATUS_END_ENCRYPTION );
1124     }
1125     iobuf_close(inp);
1126     release_sk_list( sk_list );
1127     md_close( mfx.md );
1128     m_free(cfx.dek);
1129     m_free(s2k);
1130     return rc;
1131 }
1132
1133
1134 /****************
1135  * Create a signature packet for the given public key certificate and
1136  * the user id and return it in ret_sig. User signature class SIGCLASS
1137  * user-id is not used (and may be NULL if sigclass is 0x20) If
1138  * DIGEST_ALGO is 0 the function selects an appropriate one.
1139  * SIGVERSION gives the minimal required signature packet version;
1140  * this is needed so that special properties like local sign are not
1141  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1142  * the timestamp to use for the signature. 0 means "now" */
1143 int
1144 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1145                     PKT_user_id *uid, PKT_public_key *subpk,
1146                     PKT_secret_key *sk,
1147                     int sigclass, int digest_algo,
1148                     int sigversion, u32 timestamp, u32 duration,
1149                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
1150                    )
1151 {
1152     PKT_signature *sig;
1153     int rc=0;
1154     MD_HANDLE md;
1155
1156     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1157             || sigclass == 0x20 || sigclass == 0x18
1158             || sigclass == 0x30 || sigclass == 0x28 );
1159
1160     if (opt.force_v4_certs)
1161         sigversion = 4;
1162
1163     if (sigversion < sk->version)
1164         sigversion = sk->version;
1165
1166     /* If you are making a signature on a v4 key using your v3 key, it
1167        doesn't make sense to generate a v3 sig.  After all, no v3-only
1168        PGP implementation could understand the v4 key in the first
1169        place.  Note that this implies that a signature on an attribute
1170        uid is usually going to be v4 as well, since they are not
1171        generally found on v3 keys. */
1172     if (sigversion < pk->version)
1173         sigversion = pk->version;
1174
1175     if( !digest_algo )
1176       {
1177         /* Basically, this means use SHA1 always unless it's a v3 RSA
1178            key making a v3 cert (use MD5), or the user specified
1179            something (use whatever they said).  They still must use a
1180            160-bit hash with DSA, or the signature will fail.  Note
1181            that this still allows the caller of make_keysig_packet to
1182            override the user setting if it must. */
1183
1184         if(opt.cert_digest_algo)
1185           digest_algo=opt.cert_digest_algo;
1186         else if((sk->pubkey_algo==PUBKEY_ALGO_RSA ||
1187                  sk->pubkey_algo==PUBKEY_ALGO_RSA_S) &&
1188                 pk->version<4 && sigversion < 4)
1189           digest_algo = DIGEST_ALGO_MD5;
1190         else
1191           digest_algo = DIGEST_ALGO_SHA1;
1192       }
1193
1194     md = md_open( digest_algo, 0 );
1195
1196     /* hash the public key certificate and the user id */
1197     hash_public_key( md, pk );
1198     if( sigclass == 0x18 || sigclass == 0x28 ) { /* subkey binding/revocation*/
1199         hash_public_key( md, subpk );
1200     }
1201     else if( sigclass != 0x1F && sigclass != 0x20 ) {
1202         hash_uid (md, sigversion, uid);
1203     }
1204     /* and make the signature packet */
1205     sig = m_alloc_clear( sizeof *sig );
1206     sig->version = sigversion;
1207     sig->flags.exportable=1;
1208     sig->flags.revocable=1;
1209     keyid_from_sk( sk, sig->keyid );
1210     sig->pubkey_algo = sk->pubkey_algo;
1211     sig->digest_algo = digest_algo;
1212     if(timestamp)
1213       sig->timestamp=timestamp;
1214     else
1215       sig->timestamp=make_timestamp();
1216     if(duration)
1217       sig->expiredate=sig->timestamp+duration;
1218     sig->sig_class = sigclass;
1219     if( sig->version >= 4 )
1220         build_sig_subpkt_from_sig( sig );
1221
1222     if( sig->version >= 4 && mksubpkt )
1223         rc = (*mksubpkt)( sig, opaque );
1224
1225     if( !rc ) {
1226         mk_notation_and_policy( sig, pk, sk );
1227         hash_sigversion_to_magic (md, sig);
1228         md_final(md);
1229
1230         rc = complete_sig( sig, sk, md );
1231     }
1232
1233     md_close( md );
1234     if( rc )
1235         free_seckey_enc( sig );
1236     else
1237         *ret_sig = sig;
1238     return rc;
1239 }
1240
1241
1242
1243 /****************
1244  * Create a new signature packet based on an existing one.
1245  * Only user ID signatures are supported for now.
1246  * TODO: Merge this with make_keysig_packet.
1247  */
1248 int
1249 update_keysig_packet( PKT_signature **ret_sig,
1250                       PKT_signature *orig_sig,
1251                       PKT_public_key *pk,
1252                       PKT_user_id *uid, 
1253                       PKT_secret_key *sk,
1254                       int (*mksubpkt)(PKT_signature *, void *),
1255                       void *opaque
1256                    )
1257 {
1258     PKT_signature *sig;
1259     int rc=0;
1260     MD_HANDLE md;
1261
1262     if (!orig_sig || !pk || !uid || !sk)
1263         return G10ERR_GENERAL;
1264     if (orig_sig->sig_class < 0x10 || orig_sig->sig_class > 0x13 )
1265         return G10ERR_GENERAL;
1266
1267     md = md_open( orig_sig->digest_algo, 0 );
1268
1269     /* hash the public key certificate and the user id */
1270     hash_public_key( md, pk );
1271     hash_uid (md, orig_sig->version, uid);
1272
1273     /* create a new signature packet */
1274     sig = copy_signature (NULL, orig_sig);
1275     if ( sig->version >= 4 && mksubpkt)
1276         rc = (*mksubpkt)(sig, opaque);
1277
1278     /* we increase the timestamp by one second so that a future import
1279        of this key will replace the existing one.  We also make sure that
1280        we don't create a timestamp in the future */
1281     sig->timestamp++; 
1282     while (sig->timestamp >= make_timestamp())
1283         sleep (1);
1284     /* put the updated timestamp back into the data */
1285     if( sig->version >= 4 )
1286         build_sig_subpkt_from_sig( sig );
1287
1288     if (!rc) {
1289         hash_sigversion_to_magic (md, sig);
1290         md_final(md);
1291
1292         rc = complete_sig( sig, sk, md );
1293     }
1294
1295     md_close (md);
1296     if( rc )
1297         free_seckey_enc (sig);
1298     else
1299         *ret_sig = sig;
1300     return rc;
1301 }