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