6192d598779b06e51fda6ce4b467683dc21f0269
[gnupg.git] / g10 / sign.c
1 /* sign.c - sign data
2  *      Copyright (C) 1998 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
28 #include "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "iobuf.h"
32 #include "keydb.h"
33 #include "memory.h"
34 #include "util.h"
35 #include "main.h"
36 #include "filter.h"
37 #include "ttyio.h"
38 #include "i18n.h"
39
40
41 static int
42 do_sign( PKT_secret_key *sk, PKT_signature *sig,
43          MD_HANDLE md, int digest_algo )
44 {
45     MPI frame;
46     byte *dp;
47     int rc;
48
49     if( is_RSA(sk->pubkey_algo) )
50         do_not_use_RSA();
51
52     if( !digest_algo )
53         digest_algo = md_get_algo(md);
54
55     dp = md_read( md, digest_algo );
56     sig->digest_algo = digest_algo;
57     sig->digest_start[0] = dp[0];
58     sig->digest_start[1] = dp[1];
59     frame = encode_md_value( sk->pubkey_algo, md,
60                              digest_algo, mpi_get_nbits(sk->skey[0]));
61     rc = pubkey_sign( sk->pubkey_algo, sig->data, frame, sk->skey );
62     mpi_free(frame);
63     if( rc )
64         log_error("pubkey_sign failed: %s\n", g10_errstr(rc) );
65     else {
66         if( opt.verbose ) {
67             char *ustr = get_user_id_string( sig->keyid );
68             log_info("%s signature from: %s\n",
69                       pubkey_algo_to_string(sk->pubkey_algo), ustr );
70             m_free(ustr);
71         }
72     }
73     return rc;
74 }
75
76
77
78 int
79 complete_sig( PKT_signature *sig, PKT_secret_key *sk, MD_HANDLE md )
80 {
81     int rc=0;
82
83     if( !(rc=check_secret_key( sk )) )
84         rc = do_sign( sk, sig, md, 0 );
85
86     /* fixme: should we check whether the signature is okay?
87      * maybe by using an option */
88
89     return rc;
90 }
91
92 static int
93 hash_for(int pubkey_algo )
94 {
95     if( opt.def_digest_algo )
96         return opt.def_digest_algo;
97     if( pubkey_algo == PUBKEY_ALGO_DSA )
98         return DIGEST_ALGO_SHA1;
99     if( pubkey_algo == PUBKEY_ALGO_RSA )
100         return DIGEST_ALGO_MD5;
101     return DEFAULT_DIGEST_ALGO;
102 }
103
104 static int
105 only_old_style( SK_LIST sk_list )
106 {
107     SK_LIST sk_rover = NULL;
108     int old_style = 0;
109
110     /* if there are only old style capable key we use the old sytle */
111     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
112         PKT_secret_key *sk = sk_rover->sk;
113         if( sk->pubkey_algo == PUBKEY_ALGO_RSA && sk->version < 4 )
114             old_style = 1;
115         else
116             return 0;
117     }
118     return old_style;
119 }
120
121 /****************
122  * Sign the files whose names are in FILENAME.
123  * If DETACHED has the value true,
124  * make a detached signature.  If FILENAMES->d is NULL read from stdin
125  * and ignore the detached mode.  Sign the file with all secret keys
126  * which can be taken from LOCUSR, if this is NULL, use the default one
127  * If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
128  * signed data for these users.
129  * If OUTFILE is not NULL; this file is used for output and the function
130  * does not ask for overwrite permission; output is then always
131  * uncompressed, non-armored and in binary mode.
132  */
133 int
134 sign_file( STRLIST filenames, int detached, STRLIST locusr,
135            int encrypt, STRLIST remusr, const char *outfile )
136 {
137     const char *fname;
138     armor_filter_context_t afx;
139     compress_filter_context_t zfx;
140     md_filter_context_t mfx;
141     text_filter_context_t tfx;
142     encrypt_filter_context_t efx;
143     IOBUF inp = NULL, out = NULL;
144     PACKET pkt;
145     PKT_plaintext *pt = NULL;
146     u32 filesize;
147     int rc = 0;
148     PK_LIST pk_list = NULL;
149     SK_LIST sk_list = NULL;
150     SK_LIST sk_rover = NULL;
151     int multifile = 0;
152     int old_style = opt.rfc1991;
153
154
155     memset( &afx, 0, sizeof afx);
156     memset( &zfx, 0, sizeof zfx);
157     memset( &mfx, 0, sizeof mfx);
158     memset( &tfx, 0, sizeof tfx);
159     memset( &efx, 0, sizeof efx);
160     init_packet( &pkt );
161
162     if( filenames ) {
163         fname = filenames->d;
164         multifile = !!filenames->next;
165     }
166     else
167         fname = NULL;
168
169     if( fname && filenames->next && (!detached || encrypt) )
170         log_bug("multiple files can only be detached signed");
171
172     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
173         goto leave;
174     if( !old_style )
175         old_style = only_old_style( sk_list );
176     if( encrypt ) {
177         if( (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )) )
178             goto leave;
179     }
180
181     /* prepare iobufs */
182     if( multifile )  /* have list of filenames */
183         inp = NULL; /* we do it later */
184     else if( !(inp = iobuf_open(fname)) ) {
185         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
186                                         strerror(errno) );
187         rc = G10ERR_OPEN_FILE;
188         goto leave;
189     }
190
191     if( outfile ) {
192         if( !(out = iobuf_create( outfile )) ) {
193             log_error("can't create %s: %s\n", outfile, strerror(errno) );
194             rc = G10ERR_CREATE_FILE;
195             goto leave;
196         }
197         else if( opt.verbose )
198             log_info("writing to '%s'\n", outfile );
199     }
200     else if( !(out = open_outfile( fname, opt.armor? 1: detached? 2:0 )) ) {
201         rc = G10ERR_CREATE_FILE;
202         goto leave;
203     }
204
205     /* prepare to calculate the MD over the input */
206     if( opt.textmode && !outfile )
207         iobuf_push_filter( inp, text_filter, &tfx );
208     mfx.md = md_open(0, 0);
209
210     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
211         PKT_secret_key *sk = sk_rover->sk;
212         md_enable(mfx.md, hash_for(sk->pubkey_algo));
213     }
214
215     if( !multifile )
216         iobuf_push_filter( inp, md_filter, &mfx );
217
218     if( opt.armor && !outfile  )
219         iobuf_push_filter( out, armor_filter, &afx );
220     else
221         write_comment( out, "#created by GNUPG v" VERSION " ("
222                                             PRINTABLE_OS_NAME ")");
223     if( encrypt ) {
224         efx.pk_list = pk_list;
225         /* fixme: set efx.cfx.datalen if known */
226         iobuf_push_filter( out, encrypt_filter, &efx );
227     }
228
229     if( opt.compress && !outfile && ( !detached || opt.compress_sigs) ) {
230         if( old_style )
231             zfx.algo = 1;
232         iobuf_push_filter( out, compress_filter, &zfx );
233     }
234
235     if( !detached && !old_style ) {
236         /* loop over the secret certificates and build headers */
237         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
238             PKT_secret_key *sk;
239             PKT_onepass_sig *ops;
240
241             sk = sk_rover->sk;
242             ops = m_alloc_clear( sizeof *ops );
243             ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
244             ops->digest_algo = hash_for(sk->pubkey_algo);
245             ops->pubkey_algo = sk->pubkey_algo;
246             keyid_from_sk( sk, ops->keyid );
247             ops->last = !sk_rover->next;
248
249             init_packet(&pkt);
250             pkt.pkttype = PKT_ONEPASS_SIG;
251             pkt.pkt.onepass_sig = ops;
252             rc = build_packet( out, &pkt );
253             free_packet( &pkt );
254             if( rc ) {
255                 log_error("build onepass_sig packet failed: %s\n",
256                                                         g10_errstr(rc));
257                 goto leave;
258             }
259         }
260     }
261
262
263     /* setup the inner packet */
264     if( detached ) {
265         if( multifile ) {
266             STRLIST sl;
267
268             if( opt.verbose )
269                 log_info("signing:" );
270             /* must walk reverse trough this list */
271             for( sl = strlist_last(filenames); sl;
272                         sl = strlist_prev( filenames, sl ) ) {
273                 if( !(inp = iobuf_open(sl->d)) ) {
274                     log_error("can't open %s: %s\n", sl->d, strerror(errno) );
275                     rc = G10ERR_OPEN_FILE;
276                     goto leave;
277                 }
278                 if( opt.verbose )
279                     fprintf(stderr, " '%s'", sl->d );
280                 iobuf_push_filter( inp, md_filter, &mfx );
281                 while( iobuf_get(inp) != -1 )
282                     ;
283                 iobuf_close(inp); inp = NULL;
284             }
285             if( opt.verbose )
286                 putc( '\n', stderr );
287         }
288         else {
289             /* read, so that the filter can calculate the digest */
290             while( iobuf_get(inp) != -1 )
291                 ;
292         }
293     }
294     else {
295         if( fname ) {
296             pt = m_alloc( sizeof *pt + strlen(fname) - 1 );
297             pt->namelen = strlen(fname);
298             memcpy(pt->name, fname, pt->namelen );
299             if( !(filesize = iobuf_get_filelength(inp)) )
300                 log_info("warning: '%s' is an empty file\n", fname );
301
302             /* because the text_filter modifies the length of the
303              * data, it is not possible to know the used length
304              * without a double read of the file - to avoid that
305              * we simple use partial length packets.
306              * FIXME: We have to do the double read when opt.rfc1991
307              *        is active.
308              */
309             if( opt.textmode && !outfile )
310                 filesize = 0;
311         }
312         else { /* no filename */
313             pt = m_alloc( sizeof *pt - 1 );
314             pt->namelen = 0;
315             filesize = 0; /* stdin */
316         }
317         pt->timestamp = make_timestamp();
318         pt->mode = opt.textmode && !outfile ? 't':'b';
319         pt->len = filesize;
320         pt->new_ctb = !pt->len && !opt.rfc1991;
321         pt->buf = inp;
322         pkt.pkttype = PKT_PLAINTEXT;
323         pkt.pkt.plaintext = pt;
324         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
325         if( (rc = build_packet( out, &pkt )) )
326             log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
327         pt->buf = NULL;
328     }
329
330     /* loop over the secret certificates */
331     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
332         PKT_secret_key *sk;
333         PKT_signature *sig;
334         MD_HANDLE md;
335
336         sk = sk_rover->sk;
337
338         /* build the signature packet */
339         /* fixme: this code is partly duplicated in make_keysig_packet */
340         sig = m_alloc_clear( sizeof *sig );
341         sig->version = sk->version;
342         keyid_from_sk( sk, sig->keyid );
343         sig->digest_algo = hash_for(sk->pubkey_algo);
344         sig->pubkey_algo = sk->pubkey_algo;
345         sig->timestamp = make_timestamp();
346         sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
347
348         md = md_copy( mfx.md );
349
350         if( sig->version >= 4 ) {
351             build_sig_subpkt_from_sig( sig );
352             md_putc( md, sig->version );
353         }
354         md_putc( md, sig->sig_class );
355         if( sig->version < 4 ) {
356             u32 a = sig->timestamp;
357             md_putc( md, (a >> 24) & 0xff );
358             md_putc( md, (a >> 16) & 0xff );
359             md_putc( md, (a >>  8) & 0xff );
360             md_putc( md,  a        & 0xff );
361         }
362         else {
363             byte buf[6];
364             size_t n;
365
366             md_putc( md, sig->pubkey_algo );
367             md_putc( md, sig->digest_algo );
368             if( sig->hashed_data ) {
369                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
370                 md_write( md, sig->hashed_data, n+2 );
371                 n += 6;
372             }
373             else
374                 n = 6;
375             /* add some magic */
376             buf[0] = sig->version;
377             buf[1] = 0xff;
378             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
379             buf[3] = n >> 16;
380             buf[4] = n >>  8;
381             buf[5] = n;
382             md_write( md, buf, 6 );
383
384         }
385         md_final( md );
386
387         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
388         md_close( md );
389
390         if( !rc ) { /* and write it */
391             init_packet(&pkt);
392             pkt.pkttype = PKT_SIGNATURE;
393             pkt.pkt.signature = sig;
394             rc = build_packet( out, &pkt );
395             free_packet( &pkt );
396             if( rc )
397                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
398         }
399         if( rc )
400             goto leave;
401     }
402
403
404   leave:
405     if( rc )
406         iobuf_cancel(out);
407     else
408         iobuf_close(out);
409     iobuf_close(inp);
410     md_close( mfx.md );
411     release_sk_list( sk_list );
412     release_pk_list( pk_list );
413     return rc;
414 }
415
416
417
418 /****************
419  * Note: We do not calculate the hash over the last CR,LF
420  */
421 static int
422 write_dash_escaped( IOBUF inp, IOBUF out, MD_HANDLE md )
423 {
424     int c;
425     int lastlf = 1;
426     int state = 0;
427
428     while( (c = iobuf_get(inp)) != -1 ) {
429         /* Note: We don't escape "From " because the MUA should cope with it */
430         if( lastlf ) {
431             if( c == '-' ) {
432                 iobuf_put( out, c );
433                 iobuf_put( out, ' ' );
434             }
435         }
436
437       again:
438         switch( state ) {
439           case 0:
440             if( c == '\r' )
441                 state = 1;
442             else
443                 md_putc(md, c );
444             break;
445           case 1:
446             if( c == '\n' )
447                 state = 2;
448             else {
449                 md_putc(md, '\r');
450                 state = 0;
451                 goto again;
452             }
453             break;
454           case 2:
455             md_putc(md, '\r');
456             md_putc(md, '\n');
457             state = 0;
458             goto again;
459           default: BUG();
460         }
461         iobuf_put( out, c );
462         lastlf = c == '\n';
463     }
464     if( state == 1 )
465         md_putc(md, '\r');
466     if( !lastlf )
467         iobuf_put( out, '\n' );
468
469     return 0; /* fixme: add error handling */
470 }
471
472
473 /****************
474  * make a clear signature. note that opt.armor is not needed
475  */
476 int
477 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
478 {
479     armor_filter_context_t afx;
480     text_filter_context_t tfx;
481     MD_HANDLE textmd = NULL;
482     IOBUF inp = NULL, out = NULL;
483     PACKET pkt;
484     int rc = 0;
485     SK_LIST sk_list = NULL;
486     SK_LIST sk_rover = NULL;
487     int old_style = opt.rfc1991;
488     int only_md5 = 0;
489
490     memset( &afx, 0, sizeof afx);
491     memset( &tfx, 0, sizeof tfx);
492     init_packet( &pkt );
493
494     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
495         goto leave;
496     if( !old_style )
497         old_style = only_old_style( sk_list );
498
499     /* prepare iobufs */
500     if( !(inp = iobuf_open(fname)) ) {
501         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
502                                         strerror(errno) );
503         rc = G10ERR_OPEN_FILE;
504         goto leave;
505     }
506
507     if( outfile ) {
508         if( !(out = iobuf_create( outfile )) ) {
509             log_error("can't create %s: %s\n", outfile, strerror(errno) );
510             rc = G10ERR_CREATE_FILE;
511             goto leave;
512         }
513         else if( opt.verbose )
514             log_info("writing to '%s'\n", outfile );
515     }
516     else if( !(out = open_outfile( fname, 1 )) ) {
517         rc = G10ERR_CREATE_FILE;
518         goto leave;
519     }
520
521     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n" );
522
523     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
524         PKT_secret_key *sk = sk_rover->sk;
525         if( hash_for(sk->pubkey_algo) == DIGEST_ALGO_MD5 )
526             only_md5 = 1;
527         else {
528             only_md5 = 0;
529             break;
530         }
531     }
532
533     if( old_style || only_md5 )
534         iobuf_writestr(out, "\n" );
535     else {
536         const char *s;
537         int any = 0;
538
539         iobuf_writestr(out, "Hash: " );
540         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
541             PKT_secret_key *sk = sk_rover->sk;
542             s = digest_algo_to_string( hash_for(sk->pubkey_algo) );
543             if( s ) {
544                 if( any )
545                     iobuf_put(out, ',' );
546                 iobuf_writestr(out, s );
547                 any = 1;
548             }
549         }
550         assert(any);
551         iobuf_writestr(out, "\n\n" );
552     }
553
554
555     textmd = md_open(0, 0);
556     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
557         PKT_secret_key *sk = sk_rover->sk;
558         md_enable(textmd, hash_for(sk->pubkey_algo));
559     }
560     iobuf_push_filter( inp, text_filter, &tfx );
561     rc = write_dash_escaped( inp, out, textmd );
562     if( rc )
563         goto leave;
564
565     afx.what = 2;
566     iobuf_push_filter( out, armor_filter, &afx );
567
568     /* loop over the secret certificates */
569     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
570         PKT_secret_key *sk;
571         PKT_signature *sig;
572         MD_HANDLE md;
573
574         sk = sk_rover->sk;
575
576         /* build the signature packet */
577         /* fixme: this code is duplicated above */
578         sig = m_alloc_clear( sizeof *sig );
579         sig->version = sk->version;
580         keyid_from_sk( sk, sig->keyid );
581         sig->digest_algo = hash_for(sk->pubkey_algo);
582         sig->pubkey_algo = sk->pubkey_algo;
583         sig->timestamp = make_timestamp();
584         sig->sig_class = 0x01;
585
586         md = md_copy( textmd );
587         if( sig->version >= 4 ) {
588             build_sig_subpkt_from_sig( sig );
589             md_putc( md, sig->version );
590         }
591         md_putc( md, sig->sig_class );
592         if( sig->version < 4 ) {
593             u32 a = sig->timestamp;
594             md_putc( md, (a >> 24) & 0xff );
595             md_putc( md, (a >> 16) & 0xff );
596             md_putc( md, (a >>  8) & 0xff );
597             md_putc( md,  a        & 0xff );
598         }
599         else {
600             byte buf[6];
601             size_t n;
602
603             md_putc( md, sig->pubkey_algo );
604             md_putc( md, sig->digest_algo );
605             if( sig->hashed_data ) {
606                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
607                 md_write( md, sig->hashed_data, n+2 );
608                 n += 6;
609             }
610             else
611                 n = 6;
612             /* add some magic */
613             buf[0] = sig->version;
614             buf[1] = 0xff;
615             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
616             buf[3] = n >> 16;
617             buf[4] = n >>  8;
618             buf[5] = n;
619             md_write( md, buf, 6 );
620
621         }
622         md_final( md );
623
624         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
625         md_close( md );
626
627         if( !rc ) { /* and write it */
628             init_packet(&pkt);
629             pkt.pkttype = PKT_SIGNATURE;
630             pkt.pkt.signature = sig;
631             rc = build_packet( out, &pkt );
632             free_packet( &pkt );
633             if( rc )
634                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
635         }
636         if( rc )
637             goto leave;
638     }
639
640
641   leave:
642     if( rc )
643         iobuf_cancel(out);
644     else
645         iobuf_close(out);
646     iobuf_close(inp);
647     md_close( textmd );
648     release_sk_list( sk_list );
649     return rc;
650 }
651
652
653