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