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