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