Line data Source code
1 : /* decrypt.c - Decrypt function.
2 : Copyright (C) 2000 Werner Koch (dd9jn)
3 : Copyright (C) 2001, 2002, 2003, 2004, 2017 g10 Code GmbH
4 :
5 : This file is part of GPGME.
6 :
7 : GPGME is free software; you can redistribute it and/or modify it
8 : under the terms of the GNU Lesser General Public License as
9 : published by the Free Software Foundation; either version 2.1 of
10 : the License, or (at your option) any later version.
11 :
12 : GPGME is distributed in the hope that it will be useful, but
13 : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : Lesser General Public License for more details.
16 :
17 : You should have received a copy of the GNU Lesser General Public
18 : License along with this program; if not, write to the Free Software
19 : Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20 : 02111-1307, USA. */
21 :
22 : #if HAVE_CONFIG_H
23 : #include <config.h>
24 : #endif
25 : #include <stdlib.h>
26 : #include <string.h>
27 : #include <errno.h>
28 : #include <assert.h>
29 :
30 : #include "debug.h"
31 : #include "gpgme.h"
32 : #include "util.h"
33 : #include "context.h"
34 : #include "ops.h"
35 : #include "data.h"
36 :
37 :
38 : typedef struct
39 : {
40 : struct _gpgme_op_decrypt_result result;
41 :
42 : /* The error code from a FAILURE status line or 0. */
43 : gpg_error_t failure_code;
44 :
45 : int okay;
46 :
47 : /* A flag telling that the a decryption failed and an optional error
48 : * code to further specify the failure. */
49 : int failed;
50 : gpg_error_t pkdecrypt_failed;
51 :
52 : /* At least one secret key is not available. gpg issues NO_SECKEY
53 : * status lines for each key the message has been encrypted to but
54 : * that secret key is not available. This can't be done for hidden
55 : * recipients, though. We track it here to allow for a better error
56 : * message than the general DECRYPTION_FAILED. */
57 : int any_no_seckey;
58 :
59 : /* If the engine emits a DECRYPTION_INFO status and that does not
60 : * indicate that an integrity protection mode is active, this flag
61 : * is set. */
62 : int not_integrity_protected;
63 :
64 : /* The error code from the first ERROR line. This is in some cases
65 : * used to return a better matching error code to the caller. */
66 : gpg_error_t first_status_error;
67 :
68 : /* A pointer to the next pointer of the last recipient in the list.
69 : This makes appending new invalid signers painless while
70 : preserving the order. */
71 : gpgme_recipient_t *last_recipient_p;
72 :
73 : /* The data object serial number of the plaintext. */
74 : uint64_t plaintext_dserial;
75 : } *op_data_t;
76 :
77 :
78 : static void
79 51 : release_op_data (void *hook)
80 : {
81 51 : op_data_t opd = (op_data_t) hook;
82 51 : gpgme_recipient_t recipient = opd->result.recipients;
83 :
84 51 : free (opd->result.unsupported_algorithm);
85 51 : free (opd->result.file_name);
86 51 : free (opd->result.session_key);
87 51 : free (opd->result.symkey_algo);
88 :
89 143 : while (recipient)
90 : {
91 41 : gpgme_recipient_t next = recipient->next;
92 41 : free (recipient);
93 41 : recipient = next;
94 : }
95 51 : }
96 :
97 :
98 : gpgme_decrypt_result_t
99 46 : gpgme_op_decrypt_result (gpgme_ctx_t ctx)
100 : {
101 : void *hook;
102 : op_data_t opd;
103 : gpgme_error_t err;
104 :
105 46 : TRACE_BEG (DEBUG_CTX, "gpgme_op_decrypt_result", ctx);
106 :
107 46 : ctx->ignore_mdc_error = 0; /* Always reset this flag. */
108 :
109 46 : err = _gpgme_op_data_lookup (ctx, OPDATA_DECRYPT, &hook, -1, NULL);
110 46 : opd = hook;
111 46 : if (err || !opd)
112 : {
113 0 : TRACE_SUC0 ("result=(null)");
114 0 : return NULL;
115 : }
116 :
117 : /* Make sure that SYMKEY_ALGO has a value. */
118 46 : if (!opd->result.symkey_algo)
119 : {
120 1 : opd->result.symkey_algo = strdup ("?.?");
121 1 : if (!opd->result.symkey_algo)
122 : {
123 0 : TRACE_SUC0 ("result=(null)");
124 0 : return NULL;
125 : }
126 : }
127 :
128 : if (_gpgme_debug_trace ())
129 : {
130 : gpgme_recipient_t rcp;
131 :
132 46 : if (opd->result.unsupported_algorithm)
133 : {
134 0 : TRACE_LOG1 ("result: unsupported_algorithm: %s",
135 : opd->result.unsupported_algorithm);
136 : }
137 46 : if (opd->result.wrong_key_usage)
138 : {
139 0 : TRACE_LOG ("result: wrong key usage");
140 : }
141 46 : rcp = opd->result.recipients;
142 133 : while (rcp)
143 : {
144 41 : TRACE_LOG3 ("result: recipient: keyid=%s, pubkey_algo=%i, "
145 : "status=%s", rcp->keyid, rcp->pubkey_algo,
146 : gpg_strerror (rcp->status));
147 41 : rcp = rcp->next;
148 : }
149 46 : if (opd->result.file_name)
150 : {
151 33 : TRACE_LOG1 ("result: original file name: %s", opd->result.file_name);
152 : }
153 : }
154 :
155 46 : TRACE_SUC1 ("result=%p", &opd->result);
156 46 : return &opd->result;
157 : }
158 :
159 :
160 :
161 : /* Parse the ARGS of an error status line and record some error
162 : * conditions at OPD. Returns 0 on success. */
163 : static gpgme_error_t
164 0 : parse_status_error (char *args, op_data_t opd)
165 : {
166 : gpgme_error_t err;
167 : char *field[3];
168 : int nfields;
169 : char *args2;
170 :
171 0 : if (!args)
172 0 : return trace_gpg_error (GPG_ERR_INV_ENGINE);
173 :
174 0 : args2 = strdup (args); /* Split modifies the input string. */
175 0 : nfields = _gpgme_split_fields (args2, field, DIM (field));
176 0 : if (nfields < 1)
177 : {
178 0 : free (args2);
179 0 : return trace_gpg_error (GPG_ERR_INV_ENGINE); /* Required arg missing. */
180 : }
181 0 : err = nfields < 2 ? 0 : atoi (field[1]);
182 :
183 0 : if (!strcmp (field[0], "decrypt.algorithm"))
184 : {
185 0 : if (gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM
186 0 : && nfields > 2
187 0 : && strcmp (field[2], "?"))
188 : {
189 0 : opd->result.unsupported_algorithm = strdup (field[2]);
190 0 : if (!opd->result.unsupported_algorithm)
191 : {
192 0 : free (args2);
193 0 : return gpg_error_from_syserror ();
194 : }
195 : }
196 : }
197 0 : else if (!strcmp (field[0], "decrypt.keyusage"))
198 : {
199 0 : if (gpg_err_code (err) == GPG_ERR_WRONG_KEY_USAGE)
200 0 : opd->result.wrong_key_usage = 1;
201 : }
202 0 : else if (!strcmp (field[0], "pkdecrypt_failed"))
203 : {
204 0 : switch (gpg_err_code (err))
205 : {
206 : case GPG_ERR_CANCELED:
207 : case GPG_ERR_FULLY_CANCELED:
208 : /* It is better to return with a cancel error code than the
209 : * general decryption failed error code. */
210 0 : opd->pkdecrypt_failed = gpg_err_make (gpg_err_source (err),
211 : GPG_ERR_CANCELED);
212 0 : break;
213 :
214 : case GPG_ERR_BAD_PASSPHRASE:
215 : /* A bad passphrase is severe enough that we return this
216 : * error code. */
217 0 : opd->pkdecrypt_failed = err;
218 0 : break;
219 :
220 : default:
221 : /* For now all other error codes are ignored and the
222 : * standard DECRYPT_FAILED is returned. */
223 0 : break;
224 : }
225 : }
226 0 : else if (!strcmp (field[0], "nomdc_with_legacy_cipher"))
227 : {
228 0 : opd->result.legacy_cipher_nomdc = 1;
229 0 : opd->not_integrity_protected = 1;
230 : }
231 :
232 : /* Record the first error code. */
233 0 : if (err && !opd->first_status_error)
234 0 : opd->first_status_error = err;
235 :
236 :
237 0 : free (args2);
238 0 : return 0;
239 : }
240 :
241 :
242 : static gpgme_error_t
243 41 : parse_enc_to (char *args, gpgme_recipient_t *recp, gpgme_protocol_t protocol)
244 : {
245 : gpgme_recipient_t rec;
246 : char *tail;
247 : int i;
248 :
249 41 : rec = malloc (sizeof (*rec));
250 41 : if (!rec)
251 0 : return gpg_error_from_syserror ();
252 :
253 41 : rec->next = NULL;
254 41 : rec->keyid = rec->_keyid;
255 41 : rec->status = 0;
256 :
257 697 : for (i = 0; i < sizeof (rec->_keyid) - 1; i++)
258 : {
259 656 : if (args[i] == '\0' || args[i] == ' ')
260 : break;
261 :
262 656 : rec->_keyid[i] = args[i];
263 : }
264 41 : rec->_keyid[i] = '\0';
265 :
266 41 : args = &args[i];
267 41 : if (*args != '\0' && *args != ' ')
268 : {
269 0 : free (rec);
270 0 : return trace_gpg_error (GPG_ERR_INV_ENGINE);
271 : }
272 :
273 123 : while (*args == ' ')
274 41 : args++;
275 :
276 41 : if (*args)
277 : {
278 41 : gpg_err_set_errno (0);
279 41 : rec->pubkey_algo = _gpgme_map_pk_algo (strtol (args, &tail, 0), protocol);
280 41 : if (errno || args == tail || *tail != ' ')
281 : {
282 : /* The crypto backend does not behave. */
283 0 : free (rec);
284 0 : return trace_gpg_error (GPG_ERR_INV_ENGINE);
285 : }
286 : }
287 :
288 : /* FIXME: The key length is always 0 right now, so no need to parse
289 : it. */
290 :
291 41 : *recp = rec;
292 41 : return 0;
293 : }
294 :
295 :
296 : /* Parse the ARGS of a
297 : * DECRYPTION_INFO <mdc_method> <sym_algo> [<aead_algo>]
298 : * status. Returns 0 on success and updates the OPD.
299 : */
300 : static gpgme_error_t
301 52 : parse_decryption_info (char *args, op_data_t opd, gpgme_protocol_t protocol)
302 : {
303 : char *field[3];
304 : int nfields;
305 : char *args2;
306 : int mdc, aead_algo;
307 : const char *algostr, *modestr;
308 :
309 52 : if (!args)
310 0 : return trace_gpg_error (GPG_ERR_INV_ENGINE);
311 :
312 52 : args2 = strdup (args); /* Split modifies the input string. */
313 52 : nfields = _gpgme_split_fields (args2, field, DIM (field));
314 52 : if (nfields < 2)
315 : {
316 0 : free (args2);
317 0 : return trace_gpg_error (GPG_ERR_INV_ENGINE); /* Required arg missing. */
318 : }
319 :
320 52 : mdc = atoi (field[0]);
321 52 : algostr = _gpgme_cipher_algo_name (atoi (field[1]), protocol);
322 52 : aead_algo = nfields < 3? 0 : atoi (field[2]);
323 52 : modestr = _gpgme_cipher_mode_name (aead_algo, protocol);
324 :
325 52 : free (args2);
326 :
327 52 : free (opd->result.symkey_algo);
328 52 : if (!aead_algo && mdc != 2)
329 0 : opd->result.symkey_algo = _gpgme_strconcat (algostr, ".PGPCFB", NULL);
330 : else
331 52 : opd->result.symkey_algo = _gpgme_strconcat (algostr, ".", modestr, NULL);
332 52 : if (!opd->result.symkey_algo)
333 0 : return gpg_error_from_syserror ();
334 :
335 52 : if (!mdc && !aead_algo)
336 0 : opd->not_integrity_protected = 1;
337 :
338 52 : return 0;
339 : }
340 :
341 :
342 : gpgme_error_t
343 868 : _gpgme_decrypt_status_handler (void *priv, gpgme_status_code_t code,
344 : char *args)
345 : {
346 868 : gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
347 : gpgme_error_t err;
348 : void *hook;
349 : op_data_t opd;
350 :
351 868 : err = _gpgme_passphrase_status_handler (priv, code, args);
352 868 : if (err)
353 0 : return err;
354 :
355 868 : err = _gpgme_op_data_lookup (ctx, OPDATA_DECRYPT, &hook, -1, NULL);
356 868 : opd = hook;
357 868 : if (err)
358 0 : return err;
359 :
360 868 : switch (code)
361 : {
362 : case GPGME_STATUS_FAILURE:
363 0 : opd->failure_code = _gpgme_parse_failure (args);
364 0 : break;
365 :
366 : case GPGME_STATUS_EOF:
367 : /* We force an encryption failure if we know that integrity
368 : * protection is missing. For modern version of gpg using
369 : * modern cipher algorithms this is not required because gpg
370 : * will issue a failure anyway. However older gpg versions emit
371 : * only a warning.
372 : * Fixme: These error values should probably be attributed to
373 : * the underlying crypto engine (as error source). */
374 52 : if (opd->failed)
375 : {
376 : /* This comes from a specialized ERROR status line. */
377 0 : if (opd->pkdecrypt_failed)
378 0 : return opd->pkdecrypt_failed;
379 :
380 : /* For an integrity failure return just DECRYPTION_FAILED;
381 : * the actual cause can be taken from an already set
382 : * decryption result flag. */
383 0 : if ((opd->not_integrity_protected && !ctx->ignore_mdc_error))
384 0 : return gpg_error (GPG_ERR_DECRYPT_FAILED);
385 :
386 : /* If we have any other ERROR code we prefer that over
387 : * NO_SECKEY because it is probably the better matching
388 : * code. For example a garbled message with multiple
389 : * plaintext will return BAD_DATA here but may also have
390 : * indicated a NO_SECKEY. */
391 0 : if (opd->first_status_error)
392 0 : return opd->first_status_error;
393 :
394 : /* No secret key is pretty common reason. */
395 0 : if (opd->any_no_seckey)
396 0 : return gpg_error (GPG_ERR_NO_SECKEY);
397 :
398 : /* Generic decryption failed error code. */
399 0 : return gpg_error (GPG_ERR_DECRYPT_FAILED);
400 : }
401 52 : else if (!opd->okay)
402 : {
403 : /* No data was found. */
404 0 : return gpg_error (GPG_ERR_NO_DATA);
405 : }
406 52 : else if (opd->failure_code)
407 : {
408 : /* The engine returned failure code at program exit. */
409 0 : return opd->failure_code;
410 : }
411 52 : break;
412 :
413 : case GPGME_STATUS_DECRYPTION_INFO:
414 52 : err = parse_decryption_info (args, opd, ctx->protocol);
415 52 : if (err)
416 0 : return err;
417 52 : break;
418 :
419 : case GPGME_STATUS_DECRYPTION_OKAY:
420 52 : opd->okay = 1;
421 52 : break;
422 :
423 : case GPGME_STATUS_DECRYPTION_FAILED:
424 0 : opd->failed = 1;
425 : /* Tell the data object that it shall not return any data. We
426 : * use the serial number because the data object may be owned by
427 : * another thread. We also don't check for an error because it
428 : * is possible that the data object has already been destroyed
429 : * and we are then not interested in returning an error. */
430 0 : if (!ctx->ignore_mdc_error)
431 0 : _gpgme_data_set_prop (NULL, opd->plaintext_dserial,
432 : DATA_PROP_BLANKOUT, 1);
433 0 : break;
434 :
435 : case GPGME_STATUS_ERROR:
436 : /* Note that this is an informational status code which should
437 : * not lead to an error return unless it is something not
438 : * related to the backend. However, it is used to return a
439 : * better matching final error code. */
440 0 : err = parse_status_error (args, opd);
441 0 : if (err)
442 0 : return err;
443 0 : break;
444 :
445 : case GPGME_STATUS_ENC_TO:
446 41 : err = parse_enc_to (args, opd->last_recipient_p, ctx->protocol);
447 41 : if (err)
448 0 : return err;
449 :
450 41 : opd->last_recipient_p = &(*opd->last_recipient_p)->next;
451 41 : break;
452 :
453 : case GPGME_STATUS_SESSION_KEY:
454 0 : if (opd->result.session_key)
455 0 : free (opd->result.session_key);
456 0 : opd->result.session_key = strdup(args);
457 0 : break;
458 :
459 : case GPGME_STATUS_NO_SECKEY:
460 : {
461 1 : gpgme_recipient_t rec = opd->result.recipients;
462 2 : while (rec)
463 : {
464 1 : if (!strcmp (rec->keyid, args))
465 : {
466 1 : rec->status = gpg_error (GPG_ERR_NO_SECKEY);
467 1 : break;
468 : }
469 0 : rec = rec->next;
470 : }
471 : /* FIXME: Is this ok? */
472 1 : if (!rec)
473 0 : return trace_gpg_error (GPG_ERR_INV_ENGINE);
474 1 : opd->any_no_seckey = 1;
475 : }
476 1 : break;
477 :
478 : case GPGME_STATUS_PLAINTEXT:
479 : {
480 50 : int mime = 0;
481 50 : err = _gpgme_parse_plaintext (args, &opd->result.file_name, &mime);
482 50 : if (err)
483 0 : return err;
484 50 : opd->result.is_mime = !!mime;
485 : }
486 50 : break;
487 :
488 : case GPGME_STATUS_INQUIRE_MAXLEN:
489 15 : if (ctx->status_cb && !ctx->full_status)
490 : {
491 0 : err = ctx->status_cb (ctx->status_cb_value, "INQUIRE_MAXLEN", args);
492 0 : if (err)
493 0 : return err;
494 : }
495 15 : break;
496 :
497 : case GPGME_STATUS_DECRYPTION_COMPLIANCE_MODE:
498 14 : PARSE_COMPLIANCE_FLAGS (args, &opd->result);
499 14 : break;
500 :
501 : default:
502 591 : break;
503 : }
504 :
505 868 : return 0;
506 : }
507 :
508 :
509 : static gpgme_error_t
510 507 : decrypt_status_handler (void *priv, gpgme_status_code_t code, char *args)
511 : {
512 : gpgme_error_t err;
513 :
514 507 : err = _gpgme_progress_status_handler (priv, code, args);
515 507 : if (!err)
516 507 : err = _gpgme_decrypt_status_handler (priv, code, args);
517 507 : return err;
518 : }
519 :
520 :
521 : gpgme_error_t
522 51 : _gpgme_op_decrypt_init_result (gpgme_ctx_t ctx, gpgme_data_t plaintext)
523 : {
524 : gpgme_error_t err;
525 : void *hook;
526 : op_data_t opd;
527 :
528 51 : err = _gpgme_op_data_lookup (ctx, OPDATA_DECRYPT, &hook,
529 : sizeof (*opd), release_op_data);
530 51 : opd = hook;
531 51 : if (err)
532 0 : return err;
533 :
534 51 : opd->last_recipient_p = &opd->result.recipients;
535 51 : opd->plaintext_dserial = _gpgme_data_get_dserial (plaintext);
536 51 : return 0;
537 : }
538 :
539 :
540 : gpgme_error_t
541 35 : _gpgme_decrypt_start (gpgme_ctx_t ctx, int synchronous,
542 : gpgme_decrypt_flags_t flags,
543 : gpgme_data_t cipher, gpgme_data_t plain)
544 : {
545 : gpgme_error_t err;
546 :
547 35 : assert (!(flags & GPGME_DECRYPT_VERIFY));
548 :
549 35 : err = _gpgme_op_reset (ctx, synchronous);
550 34 : if (err)
551 0 : return err;
552 :
553 34 : err = _gpgme_op_decrypt_init_result (ctx, plain);
554 34 : if (err)
555 0 : return err;
556 :
557 34 : if (!cipher)
558 0 : return gpg_error (GPG_ERR_NO_DATA);
559 34 : if (!plain)
560 0 : return gpg_error (GPG_ERR_INV_VALUE);
561 :
562 34 : if (err)
563 0 : return err;
564 :
565 34 : if (ctx->passphrase_cb)
566 : {
567 29 : err = _gpgme_engine_set_command_handler
568 : (ctx->engine, _gpgme_passphrase_command_handler, ctx);
569 29 : if (err)
570 0 : return err;
571 : }
572 :
573 34 : _gpgme_engine_set_status_handler (ctx->engine, decrypt_status_handler, ctx);
574 :
575 68 : return _gpgme_engine_op_decrypt (ctx->engine,
576 : flags,
577 : cipher, plain,
578 34 : ctx->export_session_keys,
579 34 : ctx->override_session_key,
580 34 : ctx->auto_key_retrieve);
581 : }
582 :
583 :
584 : gpgme_error_t
585 0 : gpgme_op_decrypt_start (gpgme_ctx_t ctx, gpgme_data_t cipher,
586 : gpgme_data_t plain)
587 : {
588 : gpgme_error_t err;
589 :
590 0 : TRACE_BEG2 (DEBUG_CTX, "gpgme_op_decrypt_start", ctx,
591 : "cipher=%p, plain=%p", cipher, plain);
592 :
593 0 : if (!ctx)
594 0 : return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
595 :
596 0 : err = _gpgme_decrypt_start (ctx, 0, 0, cipher, plain);
597 0 : return TRACE_ERR (err);
598 : }
599 :
600 :
601 : /* Decrypt ciphertext CIPHER within CTX and store the resulting
602 : plaintext in PLAIN. */
603 : gpgme_error_t
604 32 : gpgme_op_decrypt (gpgme_ctx_t ctx, gpgme_data_t cipher, gpgme_data_t plain)
605 : {
606 : gpgme_error_t err;
607 :
608 32 : TRACE_BEG2 (DEBUG_CTX, "gpgme_op_decrypt", ctx,
609 : "cipher=%p, plain=%p", cipher, plain);
610 :
611 32 : if (!ctx)
612 0 : return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
613 :
614 32 : err = _gpgme_decrypt_start (ctx, 1, 0, cipher, plain);
615 32 : if (!err)
616 32 : err = _gpgme_wait_one (ctx);
617 32 : ctx->ignore_mdc_error = 0; /* Always reset. */
618 32 : return TRACE_ERR (err);
619 : }
|
