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