* packet.h, build-packet.c (build_sig_subpkt), export.c
[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(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 && !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 || 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 && !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(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         compliance_failure();
674       }
675
676     if(encryptflag && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
677       goto leave;
678
679     /* prepare iobufs */
680     if( multifile )  /* have list of filenames */
681         inp = NULL; /* we do it later */
682     else {
683         if( !(inp = iobuf_open(fname)) ) {
684             log_error("can't open %s: %s\n", fname? fname: "[stdin]",
685                       strerror(errno) );
686             rc = G10ERR_OPEN_FILE;
687             goto leave;
688         }
689
690         handle_progress (&pfx, inp, fname);
691     }
692
693     if( outfile ) {
694         if( !(out = iobuf_create( outfile )) ) {
695             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
696             rc = G10ERR_CREATE_FILE;
697             goto leave;
698         }
699         else if( opt.verbose )
700             log_info(_("writing to `%s'\n"), outfile );
701     }
702     else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
703         goto leave;
704
705     /* prepare to calculate the MD over the input */
706     if( opt.textmode && !outfile && !multifile )
707       {
708         memset( &tfx, 0, sizeof tfx);
709         iobuf_push_filter( inp, text_filter, &tfx );
710       }
711
712     mfx.md = md_open(0, 0);
713
714    /* If we're encrypting and signing, it is reasonable to pick the
715        hash algorithm to use out of the recepient key prefs. */
716     if(pk_list)
717       {
718         if(opt.def_digest_algo)
719           {
720             if(!opt.expert &&
721                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
722                                       opt.def_digest_algo,
723                                       NULL)!=opt.def_digest_algo)
724           log_info(_("forcing digest algorithm %s (%d) "
725                      "violates recipient preferences\n"),
726                    digest_algo_to_string(opt.def_digest_algo),
727                    opt.def_digest_algo);
728           }
729         else
730           {
731             int hashlen=0,algo;
732
733             /* Of course, if the recipient asks for something
734                unreasonable (like a non-160-bit hash for DSA, for
735                example), then don't do it.  Check all sk's - if any
736                are DSA, then the hash must be 160-bit.  In the future
737                this can be more complex with different hashes for each
738                sk, but so long as there is only one signing algorithm
739                with hash restrictions, this is ok. -dms */
740
741             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
742               if(sk_rover->sk->pubkey_algo==PUBKEY_ALGO_DSA)
743                 hashlen=20;
744
745             if((algo=
746                 select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,
747                                        hashlen?&hashlen:NULL))>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 && !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 && pk_list
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 && !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 = 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 && !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(PGP2 && !only_old_style(sk_list))
917       {
918         log_info(_("you can only clearsign with PGP 2.x style keys "
919                    "while in --pgp2 mode\n"));
920         compliance_failure();
921       }
922
923     /* prepare iobufs */
924     if( !(inp = iobuf_open(fname)) ) {
925         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
926                                         strerror(errno) );
927         rc = G10ERR_OPEN_FILE;
928         goto leave;
929     }
930     handle_progress (&pfx, inp, fname);
931
932     if( outfile ) {
933         if( !(out = iobuf_create( outfile )) ) {
934             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
935             rc = G10ERR_CREATE_FILE;
936             goto leave;
937         }
938         else if( opt.verbose )
939             log_info(_("writing to `%s'\n"), outfile );
940     }
941     else if( (rc = open_outfile( fname, 1, &out )) )
942         goto leave;
943
944     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
945
946     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
947         PKT_secret_key *sk = sk_rover->sk;
948         if( hash_for(sk->pubkey_algo, sk->version) == DIGEST_ALGO_MD5 )
949             only_md5 = 1;
950         else {
951             only_md5 = 0;
952             break;
953         }
954     }
955
956     if( !(old_style && only_md5) ) {
957         const char *s;
958         int any = 0;
959         byte hashs_seen[256];
960
961         memset( hashs_seen, 0, sizeof hashs_seen );
962         iobuf_writestr(out, "Hash: " );
963         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
964             PKT_secret_key *sk = sk_rover->sk;
965             int i = hash_for(sk->pubkey_algo, sk->version);
966
967             if( !hashs_seen[ i & 0xff ] ) {
968                 s = digest_algo_to_string( i );
969                 if( s ) {
970                     hashs_seen[ i & 0xff ] = 1;
971                     if( any )
972                         iobuf_put(out, ',' );
973                     iobuf_writestr(out, s );
974                     any = 1;
975                 }
976             }
977         }
978         assert(any);
979         iobuf_writestr(out, LF );
980     }
981
982     if( opt.not_dash_escaped )
983       iobuf_writestr( out,
984                   "NotDashEscaped: You need GnuPG to verify this message" LF );
985     iobuf_writestr(out, LF );
986
987     textmd = md_open(0, 0);
988     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
989         PKT_secret_key *sk = sk_rover->sk;
990         md_enable(textmd, hash_for(sk->pubkey_algo, sk->version));
991     }
992     if ( DBG_HASHING )
993         md_start_debug( textmd, "clearsign" );
994     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
995                         opt.escape_from, (old_style && only_md5) );
996     /* fixme: check for read errors */
997
998     /* now write the armor */
999     afx.what = 2;
1000     iobuf_push_filter( out, armor_filter, &afx );
1001
1002     /* write the signatures */
1003     rc=write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C');
1004     if( rc )
1005         goto leave;
1006
1007   leave:
1008     if( rc )
1009         iobuf_cancel(out);
1010     else
1011         iobuf_close(out);
1012     iobuf_close(inp);
1013     md_close( textmd );
1014     release_sk_list( sk_list );
1015     return rc;
1016 }
1017
1018 /*
1019  * Sign and conventionally encrypt the given file.
1020  * FIXME: Far too much code is duplicated - revamp the whole file.
1021  */
1022 int
1023 sign_symencrypt_file (const char *fname, STRLIST locusr)
1024 {
1025     armor_filter_context_t afx;
1026     progress_filter_context_t pfx;
1027     compress_filter_context_t zfx;
1028     md_filter_context_t mfx;
1029     text_filter_context_t tfx;
1030     cipher_filter_context_t cfx;
1031     IOBUF inp = NULL, out = NULL;
1032     PACKET pkt;
1033     STRING2KEY *s2k = NULL;
1034     int rc = 0;
1035     SK_LIST sk_list = NULL;
1036     SK_LIST sk_rover = NULL;
1037     int algo;
1038     u32 duration=0;
1039
1040     memset( &afx, 0, sizeof afx);
1041     memset( &zfx, 0, sizeof zfx);
1042     memset( &mfx, 0, sizeof mfx);
1043     memset( &tfx, 0, sizeof tfx);
1044     memset( &cfx, 0, sizeof cfx);
1045     init_packet( &pkt );
1046
1047     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !RFC1991)
1048       duration=ask_expire_interval(1);
1049
1050     rc = build_sk_list (locusr, &sk_list, 1, PUBKEY_USAGE_SIG);
1051     if (rc) 
1052         goto leave;
1053
1054     /* prepare iobufs */
1055     inp = iobuf_open(fname);
1056     if( !inp ) {
1057         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
1058                                         strerror(errno) );
1059         rc = G10ERR_OPEN_FILE;
1060         goto leave;
1061     }
1062     handle_progress (&pfx, inp, fname);
1063
1064     /* prepare key */
1065     s2k = m_alloc_clear( sizeof *s2k );
1066     s2k->mode = RFC1991? 0:opt.s2k_mode;
1067     s2k->hash_algo = opt.s2k_digest_algo;
1068
1069     algo = default_cipher_algo();
1070     if (!opt.quiet || !opt.batch)
1071         log_info (_("%s encryption will be used\n"),
1072                     cipher_algo_to_string(algo) );
1073     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, NULL);
1074
1075     if (!cfx.dek || !cfx.dek->keylen) {
1076         rc = G10ERR_PASSPHRASE;
1077         log_error(_("error creating passphrase: %s\n"), g10_errstr(rc) );
1078         goto leave;
1079     }
1080
1081     /* now create the outfile */
1082     rc = open_outfile (fname, opt.armor? 1:0, &out);
1083     if (rc)
1084         goto leave;
1085
1086     /* prepare to calculate the MD over the input */
1087     if (opt.textmode)
1088         iobuf_push_filter (inp, text_filter, &tfx);
1089     mfx.md = md_open(0, 0);
1090
1091     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
1092         PKT_secret_key *sk = sk_rover->sk;
1093         md_enable (mfx.md, hash_for (sk->pubkey_algo, sk->version ));
1094     }
1095
1096     iobuf_push_filter (inp, md_filter, &mfx);
1097
1098     /* Push armor output filter */
1099     if (opt.armor)
1100         iobuf_push_filter (out, armor_filter, &afx);
1101
1102     /* Write the symmetric key packet */
1103     /*(current filters: armor)*/
1104     if (!RFC1991) {
1105         PKT_symkey_enc *enc = m_alloc_clear( sizeof *enc );
1106         enc->version = 4;
1107         enc->cipher_algo = cfx.dek->algo;
1108         enc->s2k = *s2k;
1109         pkt.pkttype = PKT_SYMKEY_ENC;
1110         pkt.pkt.symkey_enc = enc;
1111         if( (rc = build_packet( out, &pkt )) )
1112             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1113         m_free(enc);
1114     }
1115
1116     /* Push the encryption filter */
1117     iobuf_push_filter( out, cipher_filter, &cfx );
1118
1119     /* Push the Zip filter */
1120     if (opt.compress && default_compress_algo())
1121       {
1122         zfx.algo = default_compress_algo();
1123         iobuf_push_filter( out, compress_filter, &zfx );
1124       }
1125
1126     /* Write the one-pass signature packets */
1127     /*(current filters: zip - encrypt - armor)*/
1128     if (!RFC1991) {
1129         rc = write_onepass_sig_packets (sk_list, out,
1130                                         opt.textmode? 0x01:0x00);
1131         if (rc)
1132             goto leave;
1133     }
1134
1135     /* Pipe data through all filters; i.e. write the signed stuff */
1136     /*(current filters: zip - encrypt - armor)*/
1137     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1138     if (rc)
1139         goto leave;
1140     
1141     /* Write the signatures */
1142     /*(current filters: zip - encrypt - armor)*/
1143     rc = write_signature_packets (sk_list, out, mfx.md,
1144                                   opt.textmode? 0x01 : 0x00,
1145                                   0, duration, 'S');
1146     if( rc )
1147         goto leave;
1148
1149
1150   leave:
1151     if( rc )
1152         iobuf_cancel(out);
1153     else {
1154         iobuf_close(out);
1155         write_status( STATUS_END_ENCRYPTION );
1156     }
1157     iobuf_close(inp);
1158     release_sk_list( sk_list );
1159     md_close( mfx.md );
1160     m_free(cfx.dek);
1161     m_free(s2k);
1162     return rc;
1163 }
1164
1165
1166 /****************
1167  * Create a signature packet for the given public key certificate and
1168  * the user id and return it in ret_sig. User signature class SIGCLASS
1169  * user-id is not used (and may be NULL if sigclass is 0x20) If
1170  * DIGEST_ALGO is 0 the function selects an appropriate one.
1171  * SIGVERSION gives the minimal required signature packet version;
1172  * this is needed so that special properties like local sign are not
1173  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1174  * the timestamp to use for the signature. 0 means "now" */
1175 int
1176 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1177                     PKT_user_id *uid, PKT_public_key *subpk,
1178                     PKT_secret_key *sk,
1179                     int sigclass, int digest_algo,
1180                     int sigversion, u32 timestamp, u32 duration,
1181                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
1182                    )
1183 {
1184     PKT_signature *sig;
1185     int rc=0;
1186     MD_HANDLE md;
1187
1188     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1189             || sigclass == 0x20 || sigclass == 0x18
1190             || sigclass == 0x30 || sigclass == 0x28 );
1191
1192     if (opt.force_v4_certs)
1193         sigversion = 4;
1194
1195     if (sigversion < sk->version)
1196         sigversion = sk->version;
1197
1198     /* If you are making a signature on a v4 key using your v3 key, it
1199        doesn't make sense to generate a v3 sig.  After all, no v3-only
1200        PGP implementation could understand the v4 key in the first
1201        place.  Note that this implies that a signature on an attribute
1202        uid is usually going to be v4 as well, since they are not
1203        generally found on v3 keys. */
1204     if (sigversion < pk->version)
1205         sigversion = pk->version;
1206
1207     if( !digest_algo )
1208       {
1209         /* Basically, this means use SHA1 always unless it's a v3 RSA
1210            key making a v3 cert (use MD5), or the user specified
1211            something (use whatever they said).  They still must use a
1212            160-bit hash with DSA, or the signature will fail.  Note
1213            that this still allows the caller of make_keysig_packet to
1214            override the user setting if it must. */
1215
1216         if(opt.cert_digest_algo)
1217           digest_algo=opt.cert_digest_algo;
1218         else if((sk->pubkey_algo==PUBKEY_ALGO_RSA ||
1219                  sk->pubkey_algo==PUBKEY_ALGO_RSA_S) &&
1220                 pk->version<4 && sigversion < 4)
1221           digest_algo = DIGEST_ALGO_MD5;
1222         else
1223           digest_algo = DIGEST_ALGO_SHA1;
1224       }
1225
1226     md = md_open( digest_algo, 0 );
1227
1228     /* hash the public key certificate and the user id */
1229     hash_public_key( md, pk );
1230     if( sigclass == 0x18 || sigclass == 0x28 ) { /* subkey binding/revocation*/
1231         hash_public_key( md, subpk );
1232     }
1233     else if( sigclass != 0x1F && sigclass != 0x20 ) {
1234         hash_uid (md, sigversion, uid);
1235     }
1236     /* and make the signature packet */
1237     sig = m_alloc_clear( sizeof *sig );
1238     sig->version = sigversion;
1239     sig->flags.exportable=1;
1240     sig->flags.revocable=1;
1241     keyid_from_sk( sk, sig->keyid );
1242     sig->pubkey_algo = sk->pubkey_algo;
1243     sig->digest_algo = digest_algo;
1244     if(timestamp)
1245       sig->timestamp=timestamp;
1246     else
1247       sig->timestamp=make_timestamp();
1248     if(duration)
1249       sig->expiredate=sig->timestamp+duration;
1250     sig->sig_class = sigclass;
1251     if( sig->version >= 4 )
1252         build_sig_subpkt_from_sig( sig );
1253     mk_notation_and_policy( sig, pk, sk );
1254
1255     /* Crucial that the call to mksubpkt comes LAST before the calls
1256        to finalize the sig as that makes it possible for the mksubpkt
1257        function to get a reliable pointer to the subpacket area. */
1258     if( sig->version >= 4 && mksubpkt )
1259         rc = (*mksubpkt)( sig, opaque );
1260
1261     if( !rc ) {
1262         hash_sigversion_to_magic (md, sig);
1263         md_final(md);
1264
1265         rc = complete_sig( sig, sk, md );
1266     }
1267
1268     md_close( md );
1269     if( rc )
1270         free_seckey_enc( sig );
1271     else
1272         *ret_sig = sig;
1273     return rc;
1274 }
1275
1276
1277
1278 /****************
1279  * Create a new signature packet based on an existing one.
1280  * Only user ID signatures are supported for now.
1281  * TODO: Merge this with make_keysig_packet.
1282  */
1283 int
1284 update_keysig_packet( PKT_signature **ret_sig,
1285                       PKT_signature *orig_sig,
1286                       PKT_public_key *pk,
1287                       PKT_user_id *uid, 
1288                       PKT_public_key *subpk,
1289                       PKT_secret_key *sk,
1290                       int (*mksubpkt)(PKT_signature *, void *),
1291                       void *opaque
1292                    )
1293 {
1294     PKT_signature *sig;
1295     int rc=0;
1296     MD_HANDLE md;
1297
1298     if ((!orig_sig || !pk || !sk)
1299         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1300         || (orig_sig->sig_class == 0x18 && !subpk))
1301       return G10ERR_GENERAL;
1302
1303     md = md_open( orig_sig->digest_algo, 0 );
1304
1305     /* hash the public key certificate and the user id */
1306     hash_public_key( md, pk );
1307
1308     if( orig_sig->sig_class == 0x18 )
1309       hash_public_key( md, subpk );
1310     else
1311       hash_uid (md, orig_sig->version, uid);
1312
1313     /* create a new signature packet */
1314     sig = copy_signature (NULL, orig_sig);
1315
1316     /* We need to create a new timestamp so that new sig expiration
1317        calculations are done correctly... */
1318     sig->timestamp=make_timestamp();
1319
1320     /* ... but we won't make a timestamp earlier than the existing
1321        one. */
1322     while(sig->timestamp<=orig_sig->timestamp)
1323       {
1324         sleep(1);
1325         sig->timestamp=make_timestamp();
1326       }
1327
1328     /* Note that already expired sigs will remain expired (with a
1329        duration of 0) since build-packet.c:build_sig_subpkt_from_sig
1330        detects this case. */
1331
1332     if( sig->version >= 4 )
1333       {
1334         /* Put the updated timestamp into the sig.  Note that this
1335            will automagically lower any sig expiration dates to
1336            correctly correspond to the differences in the timestamps
1337            (i.e. the duration will shrink). */
1338         build_sig_subpkt_from_sig( sig );
1339
1340         if (mksubpkt)
1341           rc = (*mksubpkt)(sig, opaque);
1342       }
1343
1344     if (!rc) {
1345         hash_sigversion_to_magic (md, sig);
1346         md_final(md);
1347
1348         rc = complete_sig( sig, sk, md );
1349     }
1350
1351     md_close (md);
1352     if( rc )
1353         free_seckey_enc (sig);
1354     else
1355         *ret_sig = sig;
1356     return rc;
1357 }