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