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