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