update from tobold
[gnupg.git] / g10 / encode.c
1 /* encode.c - encode 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
38
39 static int encode_simple( const char *filename, int mode );
40 static int write_pubkey_enc_from_list( PKC_LIST pkc_list, DEK *dek, IOBUF out );
41
42
43
44 /****************
45  * Encode FILENAME with only the symmetric cipher.  Take input from
46  * stdin if FILENAME is NULL.
47  */
48 int
49 encode_symmetric( const char *filename )
50 {
51     return encode_simple( filename, 1 );
52 }
53
54 /****************
55  * Encode FILENAME as a literal data packet only. Take input from
56  * stdin if FILENAME is NULL.
57  */
58 int
59 encode_store( const char *filename )
60 {
61     return encode_simple( filename, 0 );
62 }
63
64
65 static int
66 encode_simple( const char *filename, int mode )
67 {
68     IOBUF inp, out;
69     PACKET pkt;
70     PKT_plaintext *pt;
71     STRING2KEY *s2k = NULL;
72     int rc = 0;
73     u32 filesize;
74     cipher_filter_context_t cfx;
75     armor_filter_context_t afx;
76     compress_filter_context_t zfx;
77
78     memset( &cfx, 0, sizeof cfx);
79     memset( &afx, 0, sizeof afx);
80     memset( &zfx, 0, sizeof zfx);
81
82     /* prepare iobufs */
83     if( !(inp = iobuf_open(filename)) ) {
84         log_error("can't open %s: %s\n", filename? filename: "[stdin]",
85                                         strerror(errno) );
86         return G10ERR_OPEN_FILE;
87     }
88
89     cfx.dek = NULL;
90     if( mode ) {
91         s2k = m_alloc_clear( sizeof *s2k );
92         s2k->mode = opt.rfc1991? 0:1;
93         s2k->hash_algo = opt.def_digest_algo ? opt.def_digest_algo
94                                              : DEFAULT_DIGEST_ALGO;
95         cfx.dek = passphrase_to_dek( NULL, opt.def_cipher_algo, s2k, 2 );
96         if( !cfx.dek || !cfx.dek->keylen ) {
97             rc = G10ERR_PASSPHRASE;
98             m_free(cfx.dek);
99             m_free(s2k);
100             iobuf_close(inp);
101             log_error("error creating passphrase: %s\n", g10_errstr(rc) );
102             return rc;
103         }
104     }
105
106     if( !(out = open_outfile( filename, opt.armor? 1:0 )) ) {
107         iobuf_close(inp);
108         m_free(cfx.dek);
109         m_free(s2k);
110         return G10ERR_CREATE_FILE;  /* or user said: do not overwrite */
111     }
112
113     if( opt.armor )
114         iobuf_push_filter( out, armor_filter, &afx );
115     else
116         write_comment( out, "#created by GNUPG v" VERSION " ("
117                                             PRINTABLE_OS_NAME ")");
118
119     if( s2k && !opt.rfc1991 ) {
120         PKT_symkey_enc *enc = m_alloc_clear( sizeof *enc );
121         enc->version = 4;
122         enc->cipher_algo = cfx.dek->algo;
123         enc->s2k = *s2k;
124         pkt.pkttype = PKT_SYMKEY_ENC;
125         pkt.pkt.symkey_enc = enc;
126         if( (rc = build_packet( out, &pkt )) )
127             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
128         m_free(enc);
129     }
130
131     /* setup the inner packet */
132     if( filename ) {
133         pt = m_alloc( sizeof *pt + strlen(filename) - 1 );
134         pt->namelen = strlen(filename);
135         memcpy(pt->name, filename, pt->namelen );
136         if( !(filesize = iobuf_get_filelength(inp)) )
137             log_info("warning: '%s' is an empty file\n", filename );
138     }
139     else { /* no filename */
140         pt = m_alloc( sizeof *pt - 1 );
141         pt->namelen = 0;
142         filesize = 0; /* stdin */
143     }
144     pt->timestamp = make_timestamp();
145     pt->mode = 'b';
146     pt->len = filesize;
147     pt->buf = inp;
148     pkt.pkttype = PKT_PLAINTEXT;
149     pkt.pkt.plaintext = pt;
150     cfx.datalen = filesize && !opt.compress ? calc_packet_length( &pkt ) : 0;
151
152     /* register the cipher filter */
153     if( mode )
154         iobuf_push_filter( out, cipher_filter, &cfx );
155     /* register the compress filter */
156     if( opt.compress )
157         iobuf_push_filter( out, compress_filter, &zfx );
158
159     /* do the work */
160     if( (rc = build_packet( out, &pkt )) )
161         log_error("build_packet failed: %s\n", g10_errstr(rc) );
162
163     /* finish the stuff */
164     iobuf_close(inp);
165     iobuf_close(out); /* fixme: check returncode */
166     pt->buf = NULL;
167     free_packet(&pkt);
168     m_free(cfx.dek);
169     m_free(s2k);
170     return rc;
171 }
172
173 /****************
174  * Encrypt the file with the given userids (or ask if none
175  * is supplied).
176  */
177 int
178 encode_crypt( const char *filename, STRLIST remusr )
179 {
180     IOBUF inp = NULL, out = NULL;
181     PACKET pkt;
182     PKT_plaintext *pt = NULL;
183     int rc = 0;
184     u32 filesize;
185     cipher_filter_context_t cfx;
186     armor_filter_context_t afx;
187     compress_filter_context_t zfx;
188     PKC_LIST pkc_list;
189
190     memset( &cfx, 0, sizeof cfx);
191     memset( &afx, 0, sizeof afx);
192     memset( &zfx, 0, sizeof zfx);
193
194     if( (rc=build_pkc_list( remusr, &pkc_list, 2)) )
195         return rc;
196
197     /* prepare iobufs */
198     if( !(inp = iobuf_open(filename)) ) {
199         log_error("can't open %s: %s\n", filename? filename: "[stdin]",
200                                         strerror(errno) );
201         rc = G10ERR_OPEN_FILE;
202         goto leave;
203     }
204     else if( opt.verbose )
205         log_info("reading from '%s'\n", filename? filename: "[stdin]");
206
207     if( !(out = open_outfile( filename, opt.armor? 1:0 )) ) {
208         rc = G10ERR_CREATE_FILE;  /* or user said: do not overwrite */
209         goto leave;
210     }
211
212     if( opt.armor )
213         iobuf_push_filter( out, armor_filter, &afx );
214     else
215         write_comment( out, "#created by GNUPG v" VERSION " ("
216                                             PRINTABLE_OS_NAME ")");
217
218     /* create a session key */
219     cfx.dek = m_alloc_secure( sizeof *cfx.dek );
220     cfx.dek->algo = opt.def_cipher_algo;
221     make_session_key( cfx.dek );
222     if( DBG_CIPHER )
223         log_hexdump("DEK is: ", cfx.dek->key, cfx.dek->keylen );
224
225     rc = write_pubkey_enc_from_list( pkc_list, cfx.dek, out );
226     if( rc  )
227         goto leave;
228
229     /* setup the inner packet */
230     if( filename ) {
231         pt = m_alloc( sizeof *pt + strlen(filename) - 1 );
232         pt->namelen = strlen(filename);
233         memcpy(pt->name, filename, pt->namelen );
234         if( !(filesize = iobuf_get_filelength(inp)) )
235             log_info("warning: '%s' is an empty file\n", filename );
236     }
237     else { /* no filename */
238         pt = m_alloc( sizeof *pt - 1 );
239         pt->namelen = 0;
240         filesize = 0; /* stdin */
241     }
242     pt->timestamp = make_timestamp();
243     pt->mode = 'b';
244     pt->len = filesize;
245     pt->buf = inp;
246     init_packet(&pkt);
247     pkt.pkttype = PKT_PLAINTEXT;
248     pkt.pkt.plaintext = pt;
249     cfx.datalen = filesize && !opt.compress? calc_packet_length( &pkt ) : 0;
250
251     /* register the cipher filter */
252     iobuf_push_filter( out, cipher_filter, &cfx );
253     /* register the compress filter */
254     if( opt.compress )
255         iobuf_push_filter( out, compress_filter, &zfx );
256
257     /* do the work */
258     if( (rc = build_packet( out, &pkt )) )
259         log_error("build_packet failed: %s\n", g10_errstr(rc) );
260
261     /* finish the stuff */
262   leave:
263     iobuf_close(inp);
264     if( rc )
265         iobuf_cancel(out);
266     else
267         iobuf_close(out); /* fixme: check returncode */
268     if( pt )
269         pt->buf = NULL;
270     free_packet(&pkt);
271     m_free(cfx.dek);
272     release_pkc_list( pkc_list );
273     return rc;
274 }
275
276
277 /****************
278  * Filter to do a complete public key encryption.
279  */
280 int
281 encrypt_filter( void *opaque, int control,
282                IOBUF a, byte *buf, size_t *ret_len)
283 {
284     size_t size = *ret_len;
285     encrypt_filter_context_t *efx = opaque;
286     int rc=0;
287
288     if( control == IOBUFCTRL_UNDERFLOW ) { /* decrypt */
289         BUG(); /* not used */
290     }
291     else if( control == IOBUFCTRL_FLUSH ) { /* encrypt */
292         if( !efx->header_okay ) {
293             efx->cfx.dek = m_alloc_secure( sizeof *efx->cfx.dek );
294             efx->cfx.dek->algo = opt.def_cipher_algo;
295             make_session_key( efx->cfx.dek );
296             if( DBG_CIPHER )
297                 log_hexdump("DEK is: ",
298                              efx->cfx.dek->key, efx->cfx.dek->keylen );
299
300             rc = write_pubkey_enc_from_list( efx->pkc_list, efx->cfx.dek, a );
301             if( rc )
302                 return rc;
303
304             iobuf_push_filter( a, cipher_filter, &efx->cfx );
305
306             efx->header_okay = 1;
307         }
308         rc = iobuf_write( a, buf, size );
309
310     }
311     else if( control == IOBUFCTRL_FREE ) {
312     }
313     else if( control == IOBUFCTRL_DESC ) {
314         *(char**)buf = "encrypt_filter";
315     }
316     return rc;
317 }
318
319
320 /****************
321  * Write pubkey-enc packets from the list of PKCs to OUT.
322  */
323 static int
324 write_pubkey_enc_from_list( PKC_LIST pkc_list, DEK *dek, IOBUF out )
325 {
326     PACKET pkt;
327     PKT_public_cert *pkc;
328     PKT_pubkey_enc  *enc;
329     int rc;
330
331     for( ; pkc_list; pkc_list = pkc_list->next ) {
332
333         pkc = pkc_list->pkc;
334         enc = m_alloc_clear( sizeof *enc );
335         enc->pubkey_algo = pkc->pubkey_algo;
336         if( is_ELGAMAL(enc->pubkey_algo) )
337             g10_elg_encrypt( pkc, enc, dek );
338         else if( is_RSA(enc->pubkey_algo) )
339             g10_rsa_encrypt( pkc, enc, dek );
340         else
341             BUG();
342         /* and write it */
343         init_packet(&pkt);
344         pkt.pkttype = PKT_PUBKEY_ENC;
345         pkt.pkt.pubkey_enc = enc;
346         rc = build_packet( out, &pkt );
347         free_pubkey_enc(enc);
348         if( rc ) {
349             log_error("build pubkey_enc packet failed: %s\n", g10_errstr(rc) );
350             return rc;
351         }
352     }
353     return 0;
354 }
355