NeoMutt  2024-04-25-100-gcb3684
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
crypt_gpgme.c
Go to the documentation of this file.
1
35#include "config.h"
36#include <errno.h>
37#include <gpg-error.h>
38#include <gpgme.h>
39#include <langinfo.h>
40#include <locale.h>
41#include <stdbool.h>
42#include <stdio.h>
43#include <string.h>
44#include <sys/types.h>
45#include <unistd.h>
46#include "private.h"
47#include "mutt/lib.h"
48#include "address/lib.h"
49#include "config/lib.h"
50#include "email/lib.h"
51#include "core/lib.h"
52#include "alias/lib.h"
53#include "gui/lib.h"
54#include "mutt.h"
55#include "crypt_gpgme.h"
56#include "lib.h"
57#include "attach/lib.h"
58#include "editor/lib.h"
59#include "history/lib.h"
60#include "question/lib.h"
61#include "send/lib.h"
62#include "crypt.h"
63#include "globals.h"
64#include "gpgme_functions.h"
65#include "handler.h"
66#include "hook.h"
67#include "mutt_logging.h"
68#ifdef USE_AUTOCRYPT
69#include "autocrypt/lib.h"
70#endif
71
72// clang-format off
73/* Values used for comparing addresses. */
74#define CRYPT_KV_VALID (1 << 0)
75#define CRYPT_KV_ADDR (1 << 1)
76#define CRYPT_KV_STRING (1 << 2)
77#define CRYPT_KV_STRONGID (1 << 3)
78#define CRYPT_KV_MATCH (CRYPT_KV_ADDR | CRYPT_KV_STRING)
79// clang-format on
80
85{
86 char *what;
87 char *dflt;
89};
90
92static struct CryptCache *IdDefaults = NULL;
94static gpgme_key_t SignatureKey = NULL;
96static char *CurrentSender = NULL;
97
98#define PKA_NOTATION_NAME "pka-address@gnupg.org"
99
100#define _LINE_COMPARE(_x, _y) line_compare(_x, sizeof(_x) - 1, _y)
101#define MESSAGE(_y) _LINE_COMPARE("MESSAGE-----", _y)
102#define SIGNED_MESSAGE(_y) _LINE_COMPARE("SIGNED MESSAGE-----", _y)
103#define PUBLIC_KEY_BLOCK(_y) _LINE_COMPARE("PUBLIC KEY BLOCK-----", _y)
104#define BEGIN_PGP_SIGNATURE(_y) \
105 _LINE_COMPARE("-----BEGIN PGP SIGNATURE-----", _y)
106
112static bool is_pka_notation(gpgme_sig_notation_t notation)
113{
114 return mutt_str_equal(notation->name, PKA_NOTATION_NAME);
115}
116
121static void redraw_if_needed(gpgme_ctx_t ctx)
122{
123 const char *s = gpgme_get_ctx_flag(ctx, "redraw");
124 if (!s /* flag not known */ || *s /* flag true */)
125 {
127 }
128}
129
138const char *crypt_keyid(struct CryptKeyInfo *k)
139{
140 const char *s = "????????";
141
142 if (k->kobj && k->kobj->subkeys)
143 {
144 s = k->kobj->subkeys->keyid;
145 const bool c_pgp_long_ids = cs_subset_bool(NeoMutt->sub, "pgp_long_ids");
146 if ((!c_pgp_long_ids) && (strlen(s) == 16))
147 {
148 /* Return only the short keyID. */
149 s += 8;
150 }
151 }
152
153 return s;
154}
155
163static const char *crypt_long_keyid(struct CryptKeyInfo *k)
164{
165 const char *s = "????????????????";
166
167 if (k->kobj && k->kobj->subkeys)
168 {
169 s = k->kobj->subkeys->keyid;
170 }
171
172 return s;
173}
174
180static const char *crypt_short_keyid(struct CryptKeyInfo *k)
181{
182 const char *s = "????????";
183
184 if (k->kobj && k->kobj->subkeys)
185 {
186 s = k->kobj->subkeys->keyid;
187 if (strlen(s) == 16)
188 s += 8;
189 }
190
191 return s;
192}
193
199static const char *crypt_fpr(struct CryptKeyInfo *k)
200{
201 const char *s = "";
202
203 if (k->kobj && k->kobj->subkeys)
204 s = k->kobj->subkeys->fpr;
205
206 return s;
207}
208
214const char *crypt_fpr_or_lkeyid(struct CryptKeyInfo *k)
215{
216 const char *s = "????????????????";
217
218 if (k->kobj && k->kobj->subkeys)
219 {
220 if (k->kobj->subkeys->fpr)
221 s = k->kobj->subkeys->fpr;
222 else
223 s = k->kobj->subkeys->keyid;
224 }
225
226 return s;
227}
228
235{
236 struct CryptKeyInfo *k = NULL;
237
238 k = mutt_mem_calloc(1, sizeof(*k));
239 k->kobj = key->kobj;
240 gpgme_key_ref(key->kobj);
241 k->idx = key->idx;
242 k->uid = key->uid;
243 k->flags = key->flags;
244 k->validity = key->validity;
245
246 return k;
247}
248
253static void crypt_key_free(struct CryptKeyInfo **keylist)
254{
255 if (!keylist)
256 return;
257
258 struct CryptKeyInfo *k = NULL;
259
260 while (*keylist)
261 {
262 k = *keylist;
263 *keylist = (*keylist)->next;
264
265 gpgme_key_unref(k->kobj);
266 FREE(&k);
267 }
268}
269
276{
277 if (!key)
278 return false;
279
280 bool is_strong = false;
281
282 if ((key->flags & KEYFLAG_ISX509))
283 return true;
284
285 switch (key->validity)
286 {
287 case GPGME_VALIDITY_MARGINAL:
288 case GPGME_VALIDITY_NEVER:
289 case GPGME_VALIDITY_UNDEFINED:
290 case GPGME_VALIDITY_UNKNOWN:
291 is_strong = false;
292 break;
293
294 case GPGME_VALIDITY_FULL:
295 case GPGME_VALIDITY_ULTIMATE:
296 is_strong = true;
297 break;
298 }
299
300 return is_strong;
301}
302
311{
312 if (!key)
313 return 0;
314
315 return !(key->flags & KEYFLAG_CANTUSE);
316}
317
328static int crypt_id_matches_addr(struct Address *addr, struct Address *u_addr,
329 struct CryptKeyInfo *key)
330{
331 int rc = 0;
332
333 if (crypt_id_is_valid(key))
334 rc |= CRYPT_KV_VALID;
335
336 if (crypt_id_is_strong(key))
337 rc |= CRYPT_KV_STRONGID;
338
339 if (addr && u_addr)
340 {
341 if (addr->mailbox && u_addr->mailbox && buf_istr_equal(addr->mailbox, u_addr->mailbox))
342 {
343 rc |= CRYPT_KV_ADDR;
344 }
345
346 if (addr->personal && u_addr->personal &&
347 buf_istr_equal(addr->personal, u_addr->personal))
348 {
349 rc |= CRYPT_KV_STRING;
350 }
351 }
352
353 return rc;
354}
355
361gpgme_ctx_t create_gpgme_context(bool for_smime)
362{
363 gpgme_ctx_t ctx = NULL;
364
365 gpgme_error_t err = gpgme_new(&ctx);
366
367#ifdef USE_AUTOCRYPT
368 const char *const c_autocrypt_dir = cs_subset_path(NeoMutt->sub, "autocrypt_dir");
369 if ((err == GPG_ERR_NO_ERROR) && OptAutocryptGpgme)
370 err = gpgme_ctx_set_engine_info(ctx, GPGME_PROTOCOL_OpenPGP, NULL, c_autocrypt_dir);
371#endif
372
373 if (err != GPG_ERR_NO_ERROR)
374 {
375 mutt_error(_("error creating GPGME context: %s"), gpgme_strerror(err));
376 mutt_exit(1);
377 }
378
379 if (for_smime)
380 {
381 err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS);
382 if (err != GPG_ERR_NO_ERROR)
383 {
384 mutt_error(_("error enabling CMS protocol: %s"), gpgme_strerror(err));
385 mutt_exit(1);
386 }
387 }
388
389 return ctx;
390}
391
400static gpgme_data_t create_gpgme_data(void)
401{
402 gpgme_data_t data = NULL;
403
404 gpgme_error_t err = gpgme_data_new(&data);
405 if (err != GPG_ERR_NO_ERROR)
406 {
407 mutt_error(_("error creating GPGME data object: %s"), gpgme_strerror(err));
408 mutt_exit(1);
409 }
410 return data;
411}
412
419static gpgme_data_t body_to_data_object(struct Body *b, bool convert)
420{
421 gpgme_error_t err = GPG_ERR_NO_ERROR;
422 gpgme_data_t data = NULL;
423
424 struct Buffer *tempfile = buf_pool_get();
425 buf_mktemp(tempfile);
426 FILE *fp_tmp = mutt_file_fopen(buf_string(tempfile), "w+");
427 if (!fp_tmp)
428 {
429 mutt_perror("%s", buf_string(tempfile));
430 goto cleanup;
431 }
432
434 fputc('\n', fp_tmp);
435 mutt_write_mime_body(b, fp_tmp, NeoMutt->sub);
436
437 if (convert)
438 {
439 int c, hadcr = 0;
440 unsigned char buf[1];
441
443 rewind(fp_tmp);
444 while ((c = fgetc(fp_tmp)) != EOF)
445 {
446 if (c == '\r')
447 {
448 hadcr = 1;
449 }
450 else
451 {
452 if ((c == '\n') && !hadcr)
453 {
454 buf[0] = '\r';
455 gpgme_data_write(data, buf, 1);
456 }
457
458 hadcr = 0;
459 }
460 /* FIXME: This is quite suboptimal */
461 buf[0] = c;
462 gpgme_data_write(data, buf, 1);
463 }
464 mutt_file_fclose(&fp_tmp);
465 gpgme_data_seek(data, 0, SEEK_SET);
466 }
467 else
468 {
469 mutt_file_fclose(&fp_tmp);
470 err = gpgme_data_new_from_file(&data, buf_string(tempfile), 1);
471 if (err != GPG_ERR_NO_ERROR)
472 {
473 mutt_error(_("error allocating data object: %s"), gpgme_strerror(err));
474 gpgme_data_release(data);
475 data = NULL;
476 /* fall through to unlink the tempfile */
477 }
478 }
479 unlink(buf_string(tempfile));
480
481cleanup:
482 buf_pool_release(&tempfile);
483 return data;
484}
485
493static gpgme_data_t file_to_data_object(FILE *fp, long offset, size_t length)
494{
495 gpgme_data_t data = NULL;
496
497 gpgme_error_t err = gpgme_data_new_from_filepart(&data, NULL, fp, offset, length);
498 if (err != GPG_ERR_NO_ERROR)
499 {
500 mutt_error(_("error allocating data object: %s"), gpgme_strerror(err));
501 return NULL;
502 }
503
504 return data;
505}
506
514static int data_object_to_stream(gpgme_data_t data, FILE *fp)
515{
516 char buf[4096] = { 0 };
517 ssize_t nread;
518
519 gpgme_error_t err = ((gpgme_data_seek(data, 0, SEEK_SET) == -1) ?
520 gpgme_error_from_errno(errno) :
521 GPG_ERR_NO_ERROR);
522 if (err != GPG_ERR_NO_ERROR)
523 {
524 mutt_error(_("error rewinding data object: %s"), gpgme_strerror(err));
525 return -1;
526 }
527
528 while ((nread = gpgme_data_read(data, buf, sizeof(buf))) > 0)
529 {
530 /* fixme: we are not really converting CRLF to LF but just
531 * skipping CR. Doing it correctly needs a more complex logic */
532 for (char *p = buf; nread; p++, nread--)
533 {
534 if (*p != '\r')
535 putc(*p, fp);
536 }
537
538 if (ferror(fp))
539 {
540 mutt_perror(_("[tempfile]"));
541 return -1;
542 }
543 }
544 if (nread == -1)
545 {
546 mutt_error(_("error reading data object: %s"), strerror(errno));
547 return -1;
548 }
549 return 0;
550}
551
563static char *data_object_to_tempfile(gpgme_data_t data, FILE **fp_ret)
564{
565 ssize_t nread = 0;
566 char *rv = NULL;
567 struct Buffer *tempf = buf_pool_get();
568
569 buf_mktemp(tempf);
570
571 FILE *fp = mutt_file_fopen(buf_string(tempf), "w+");
572 if (!fp)
573 {
574 mutt_perror(_("Can't create temporary file"));
575 goto cleanup;
576 }
577
578 gpgme_error_t err = ((gpgme_data_seek(data, 0, SEEK_SET) == -1) ?
579 gpgme_error_from_errno(errno) :
580 GPG_ERR_NO_ERROR);
581 if (err == GPG_ERR_NO_ERROR)
582 {
583 char buf[4096] = { 0 };
584
585 while ((nread = gpgme_data_read(data, buf, sizeof(buf))) > 0)
586 {
587 if (fwrite(buf, nread, 1, fp) != 1)
588 {
589 mutt_perror("%s", buf_string(tempf));
590 mutt_file_fclose(&fp);
591 unlink(buf_string(tempf));
592 goto cleanup;
593 }
594 }
595 }
596 if (fp_ret)
597 rewind(fp);
598 else
599 mutt_file_fclose(&fp);
600 if (nread == -1)
601 {
602 mutt_error(_("error reading data object: %s"), gpgme_strerror(err));
603 unlink(buf_string(tempf));
604 mutt_file_fclose(&fp);
605 goto cleanup;
606 }
607 if (fp_ret)
608 *fp_ret = fp;
609 rv = buf_strdup(tempf);
610
611cleanup:
612 buf_pool_release(&tempf);
613 return rv;
614}
615
622static void create_recipient_string(const char *keylist, struct Buffer *recpstring, int use_smime)
623{
624 unsigned int n = 0;
625
626 const char *s = keylist;
627 do
628 {
629 while (*s == ' ')
630 s++;
631 if (*s != '\0')
632 {
633 if (n == 0)
634 {
635 if (!use_smime)
636 buf_addstr(recpstring, "--\n");
637 }
638 else
639 {
640 buf_addch(recpstring, '\n');
641 }
642 n++;
643
644 while ((*s != '\0') && (*s != ' '))
645 buf_addch(recpstring, *s++);
646 }
647 } while (*s != '\0');
648}
649
658static bool set_signer_from_address(gpgme_ctx_t ctx, const char *address, bool for_smime)
659{
660 gpgme_key_t key = NULL;
661 gpgme_key_t key2 = NULL;
662
663 gpgme_ctx_t listctx = create_gpgme_context(for_smime);
664 gpgme_error_t err = gpgme_op_keylist_start(listctx, address, 1);
665 if (err == GPG_ERR_NO_ERROR)
666 err = gpgme_op_keylist_next(listctx, &key);
667 if (err != GPG_ERR_NO_ERROR)
668 {
669 gpgme_release(listctx);
670 mutt_error(_("secret key '%s' not found: %s"), address, gpgme_strerror(err));
671 return false;
672 }
673
674 char *fpr = "fpr1";
675 if (key->subkeys)
676 fpr = key->subkeys->fpr ? key->subkeys->fpr : key->subkeys->keyid;
677 while (gpgme_op_keylist_next(listctx, &key2) == 0)
678 {
679 char *fpr2 = "fpr2";
680 if (key2->subkeys)
681 fpr2 = key2->subkeys->fpr ? key2->subkeys->fpr : key2->subkeys->keyid;
682 if (!mutt_str_equal(fpr, fpr2))
683 {
684 gpgme_key_unref(key);
685 gpgme_key_unref(key2);
686 gpgme_release(listctx);
687 mutt_error(_("ambiguous specification of secret key '%s'"), address);
688 return false;
689 }
690 else
691 {
692 gpgme_key_unref(key2);
693 }
694 }
695 gpgme_op_keylist_end(listctx);
696 gpgme_release(listctx);
697
698 gpgme_signers_clear(ctx);
699 err = gpgme_signers_add(ctx, key);
700 gpgme_key_unref(key);
701 if (err != GPG_ERR_NO_ERROR)
702 {
703 mutt_error(_("error setting secret key '%s': %s"), address, gpgme_strerror(err));
704 return false;
705 }
706 return true;
707}
708
717static int set_signer(gpgme_ctx_t ctx, const struct AddressList *al, bool for_smime)
718{
719 const char *signid = NULL;
720
721 const char *const c_smime_sign_as = cs_subset_string(NeoMutt->sub, "smime_sign_as");
722 const char *const c_pgp_sign_as = cs_subset_string(NeoMutt->sub, "pgp_sign_as");
723 const char *const c_pgp_default_key = cs_subset_string(NeoMutt->sub, "pgp_default_key");
724 const char *const c_smime_default_key = cs_subset_string(NeoMutt->sub, "smime_default_key");
725 if (for_smime)
726 signid = c_smime_sign_as ? c_smime_sign_as : c_smime_default_key;
727#ifdef USE_AUTOCRYPT
728 else if (OptAutocryptGpgme)
729 signid = AutocryptSignAs;
730#endif
731 else
732 signid = c_pgp_sign_as ? c_pgp_sign_as : c_pgp_default_key;
733
734 /* Try getting the signing key from config entries */
735 if (signid && set_signer_from_address(ctx, signid, for_smime))
736 {
737 return 0;
738 }
739
740 /* Try getting the signing key from the From line */
741 if (al)
742 {
743 struct Address *a;
744 TAILQ_FOREACH(a, al, entries)
745 {
746 if (a->mailbox && set_signer_from_address(ctx, buf_string(a->mailbox), for_smime))
747 {
748 return 0;
749 }
750 }
751 }
752
753 return (!signid && !al) ? 0 : -1;
754}
755
761static gpgme_error_t set_pka_sig_notation(gpgme_ctx_t ctx)
762{
763 gpgme_error_t err = gpgme_sig_notation_add(ctx, PKA_NOTATION_NAME, CurrentSender, 0);
764 if (err != GPG_ERR_NO_ERROR)
765 {
766 mutt_error(_("error setting PKA signature notation: %s"), gpgme_strerror(err));
767 }
768
769 return err;
770}
771
781static char *encrypt_gpgme_object(gpgme_data_t plaintext, char *keylist, bool use_smime,
782 bool combined_signed, const struct AddressList *from)
783{
784 gpgme_error_t err = GPG_ERR_NO_ERROR;
785 gpgme_ctx_t ctx = NULL;
786 gpgme_data_t ciphertext = NULL;
787 char *outfile = NULL;
788
789 struct Buffer *recpstring = buf_pool_get();
790 create_recipient_string(keylist, recpstring, use_smime);
791 if (buf_is_empty(recpstring))
792 {
793 buf_pool_release(&recpstring);
794 return NULL;
795 }
796
797 ctx = create_gpgme_context(use_smime);
798 if (!use_smime)
799 gpgme_set_armor(ctx, 1);
800
801 ciphertext = create_gpgme_data();
802
803 if (combined_signed)
804 {
805 if (set_signer(ctx, from, use_smime))
806 goto cleanup;
807
808 const bool c_crypt_use_pka = cs_subset_bool(NeoMutt->sub, "crypt_use_pka");
809 if (c_crypt_use_pka)
810 {
811 err = set_pka_sig_notation(ctx);
812 if (err != GPG_ERR_NO_ERROR)
813 goto cleanup;
814 }
815
816 err = gpgme_op_encrypt_sign_ext(ctx, NULL, buf_string(recpstring),
817 GPGME_ENCRYPT_ALWAYS_TRUST, plaintext, ciphertext);
818 }
819 else
820 {
821 err = gpgme_op_encrypt_ext(ctx, NULL, buf_string(recpstring),
822 GPGME_ENCRYPT_ALWAYS_TRUST, plaintext, ciphertext);
823 }
824
825 redraw_if_needed(ctx);
826 if (err != GPG_ERR_NO_ERROR)
827 {
828 mutt_error(_("error encrypting data: %s"), gpgme_strerror(err));
829 goto cleanup;
830 }
831
832 outfile = data_object_to_tempfile(ciphertext, NULL);
833
834cleanup:
835 buf_pool_release(&recpstring);
836 gpgme_release(ctx);
837 gpgme_data_release(ciphertext);
838 return outfile;
839}
840
853static int get_micalg(gpgme_ctx_t ctx, int use_smime, char *buf, size_t buflen)
854{
855 gpgme_sign_result_t result = NULL;
856 const char *algorithm_name = NULL;
857
858 if (buflen < 5)
859 return -1;
860
861 *buf = '\0';
862 result = gpgme_op_sign_result(ctx);
863 if (result && result->signatures)
864 {
865 algorithm_name = gpgme_hash_algo_name(result->signatures->hash_algo);
866 if (algorithm_name)
867 {
868 if (use_smime)
869 {
870 /* convert GPGME raw hash name to RFC2633 format */
871 snprintf(buf, buflen, "%s", algorithm_name);
872 mutt_str_lower(buf);
873 }
874 else
875 {
876 /* convert GPGME raw hash name to RFC3156 format */
877 snprintf(buf, buflen, "pgp-%s", algorithm_name);
878 mutt_str_lower(buf + 4);
879 }
880 }
881 }
882
883 return (buf[0] != '\0') ? 0 : -1;
884}
885
891static void print_time(time_t t, struct State *state)
892{
893 char p[256] = { 0 };
894 mutt_date_localtime_format(p, sizeof(p), nl_langinfo(D_T_FMT), t);
895 state_puts(state, p);
896}
897
906static struct Body *sign_message(struct Body *b, const struct AddressList *from, bool use_smime)
907{
908 struct Body *b_sign = NULL;
909 char *sigfile = NULL;
910 gpgme_error_t err = GPG_ERR_NO_ERROR;
911 char buf[100] = { 0 };
912 gpgme_ctx_t ctx = NULL;
913 gpgme_data_t message = NULL, signature = NULL;
914 gpgme_sign_result_t sigres = NULL;
915
916 crypt_convert_to_7bit(b); /* Signed data _must_ be in 7-bit format. */
917
918 message = body_to_data_object(b, true);
919 if (!message)
920 return NULL;
921 signature = create_gpgme_data();
922
923 ctx = create_gpgme_context(use_smime);
924 if (!use_smime)
925 gpgme_set_armor(ctx, 1);
926
927 if (set_signer(ctx, from, use_smime))
928 {
929 gpgme_data_release(signature);
930 gpgme_data_release(message);
931 gpgme_release(ctx);
932 return NULL;
933 }
934
935 const bool c_crypt_use_pka = cs_subset_bool(NeoMutt->sub, "crypt_use_pka");
936 if (c_crypt_use_pka)
937 {
938 err = set_pka_sig_notation(ctx);
939 if (err != GPG_ERR_NO_ERROR)
940 {
941 gpgme_data_release(signature);
942 gpgme_data_release(message);
943 gpgme_release(ctx);
944 return NULL;
945 }
946 }
947
948 err = gpgme_op_sign(ctx, message, signature, GPGME_SIG_MODE_DETACH);
949 redraw_if_needed(ctx);
950 gpgme_data_release(message);
951 if (err != GPG_ERR_NO_ERROR)
952 {
953 gpgme_data_release(signature);
954 gpgme_release(ctx);
955 mutt_error(_("error signing data: %s"), gpgme_strerror(err));
956 return NULL;
957 }
958 /* Check for zero signatures generated. This can occur when $pgp_sign_as is
959 * unset and there is no default key specified in ~/.gnupg/gpg.conf */
960 sigres = gpgme_op_sign_result(ctx);
961 if (!sigres->signatures)
962 {
963 gpgme_data_release(signature);
964 gpgme_release(ctx);
965 mutt_error(_("$pgp_sign_as unset and no default key specified in ~/.gnupg/gpg.conf"));
966 return NULL;
967 }
968
969 sigfile = data_object_to_tempfile(signature, NULL);
970 gpgme_data_release(signature);
971 if (!sigfile)
972 {
973 gpgme_release(ctx);
974 return NULL;
975 }
976
977 b_sign = mutt_body_new();
978 b_sign->type = TYPE_MULTIPART;
979 b_sign->subtype = mutt_str_dup("signed");
980 b_sign->encoding = ENC_7BIT;
981 b_sign->use_disp = false;
982 b_sign->disposition = DISP_INLINE;
983
985 mutt_param_set(&b_sign->parameter, "protocol",
986 use_smime ? "application/pkcs7-signature" : "application/pgp-signature");
987 /* Get the micalg from GPGME. Old gpgme versions don't support this
988 * for S/MIME so we assume sha-1 in this case. */
989 if (get_micalg(ctx, use_smime, buf, sizeof(buf)) == 0)
990 mutt_param_set(&b_sign->parameter, "micalg", buf);
991 else if (use_smime)
992 mutt_param_set(&b_sign->parameter, "micalg", "sha1");
993 gpgme_release(ctx);
994
995 b_sign->parts = b;
996 b = b_sign;
997
998 b_sign->parts->next = mutt_body_new();
999 b_sign = b_sign->parts->next;
1000 b_sign->type = TYPE_APPLICATION;
1001 if (use_smime)
1002 {
1003 b_sign->subtype = mutt_str_dup("pkcs7-signature");
1004 mutt_param_set(&b_sign->parameter, "name", "smime.p7s");
1005 b_sign->encoding = ENC_BASE64;
1006 b_sign->use_disp = true;
1007 b_sign->disposition = DISP_ATTACH;
1008 b_sign->d_filename = mutt_str_dup("smime.p7s");
1009 }
1010 else
1011 {
1012 b_sign->subtype = mutt_str_dup("pgp-signature");
1013 mutt_param_set(&b_sign->parameter, "name", "signature.asc");
1014 b_sign->use_disp = false;
1015 b_sign->disposition = DISP_NONE;
1016 b_sign->encoding = ENC_7BIT;
1017 }
1018 b_sign->filename = sigfile;
1019 b_sign->unlink = true; /* ok to remove this file after sending. */
1020
1021 return b;
1022}
1023
1027struct Body *pgp_gpgme_sign_message(struct Body *b, const struct AddressList *from)
1028{
1029 return sign_message(b, from, false);
1030}
1031
1035struct Body *smime_gpgme_sign_message(struct Body *b, const struct AddressList *from)
1036{
1037 return sign_message(b, from, true);
1038}
1039
1043struct Body *pgp_gpgme_encrypt_message(struct Body *b, char *keylist, bool sign,
1044 const struct AddressList *from)
1045{
1046 if (sign)
1048 gpgme_data_t plaintext = body_to_data_object(b, false);
1049 if (!plaintext)
1050 return NULL;
1051
1052 char *outfile = encrypt_gpgme_object(plaintext, keylist, false, sign, from);
1053 gpgme_data_release(plaintext);
1054 if (!outfile)
1055 return NULL;
1056
1057 struct Body *b_enc = mutt_body_new();
1058 b_enc->type = TYPE_MULTIPART;
1059 b_enc->subtype = mutt_str_dup("encrypted");
1060 b_enc->encoding = ENC_7BIT;
1061 b_enc->use_disp = false;
1062 b_enc->disposition = DISP_INLINE;
1063
1065 mutt_param_set(&b_enc->parameter, "protocol", "application/pgp-encrypted");
1066
1067 b_enc->parts = mutt_body_new();
1068 b_enc->parts->type = TYPE_APPLICATION;
1069 b_enc->parts->subtype = mutt_str_dup("pgp-encrypted");
1070 b_enc->parts->encoding = ENC_7BIT;
1071
1072 b_enc->parts->next = mutt_body_new();
1073 b_enc->parts->next->type = TYPE_APPLICATION;
1074 b_enc->parts->next->subtype = mutt_str_dup("octet-stream");
1075 b_enc->parts->next->encoding = ENC_7BIT;
1076 b_enc->parts->next->filename = outfile;
1077 b_enc->parts->next->use_disp = true;
1078 b_enc->parts->next->disposition = DISP_ATTACH;
1079 b_enc->parts->next->unlink = true; /* delete after sending the message */
1080 b_enc->parts->next->d_filename = mutt_str_dup("msg.asc"); /* non pgp/mime
1081 can save */
1082
1083 return b_enc;
1084}
1085
1089struct Body *smime_gpgme_build_smime_entity(struct Body *b, char *keylist)
1090{
1091 /* OpenSSL converts line endings to crlf when encrypting. Some clients
1092 * depend on this for signed+encrypted messages: they do not convert line
1093 * endings between decrypting and checking the signature. */
1094 gpgme_data_t plaintext = body_to_data_object(b, true);
1095 if (!plaintext)
1096 return NULL;
1097
1098 char *outfile = encrypt_gpgme_object(plaintext, keylist, true, false, NULL);
1099 gpgme_data_release(plaintext);
1100 if (!outfile)
1101 return NULL;
1102
1103 struct Body *b_enc = mutt_body_new();
1104 b_enc->type = TYPE_APPLICATION;
1105 b_enc->subtype = mutt_str_dup("pkcs7-mime");
1106 mutt_param_set(&b_enc->parameter, "name", "smime.p7m");
1107 mutt_param_set(&b_enc->parameter, "smime-type", "enveloped-data");
1108 b_enc->encoding = ENC_BASE64; /* The output of OpenSSL SHOULD be binary */
1109 b_enc->use_disp = true;
1110 b_enc->disposition = DISP_ATTACH;
1111 b_enc->d_filename = mutt_str_dup("smime.p7m");
1112 b_enc->filename = outfile;
1113 b_enc->unlink = true; /* delete after sending the message */
1114 b_enc->parts = 0;
1115 b_enc->next = 0;
1116
1117 return b_enc;
1118}
1119
1133static int show_sig_summary(unsigned long sum, gpgme_ctx_t ctx, gpgme_key_t key,
1134 int idx, struct State *state, gpgme_signature_t sig)
1135{
1136 if (!key)
1137 return 1;
1138
1139 bool severe = false;
1140
1141 if ((sum & GPGME_SIGSUM_KEY_REVOKED))
1142 {
1143 state_puts(state, _("Warning: One of the keys has been revoked\n"));
1144 severe = true;
1145 }
1146
1147 if ((sum & GPGME_SIGSUM_KEY_EXPIRED))
1148 {
1149 time_t at = key->subkeys->expires ? key->subkeys->expires : 0;
1150 if (at)
1151 {
1152 state_puts(state, _("Warning: The key used to create the signature expired at: "));
1153 print_time(at, state);
1154 state_puts(state, "\n");
1155 }
1156 else
1157 {
1158 state_puts(state, _("Warning: At least one certification key has expired\n"));
1159 }
1160 }
1161
1162 if ((sum & GPGME_SIGSUM_SIG_EXPIRED))
1163 {
1164 gpgme_signature_t sig2 = NULL;
1165 unsigned int i;
1166
1167 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1168
1169 for (sig2 = result->signatures, i = 0; sig2 && (i < idx); sig2 = sig2->next, i++)
1170 ; // do nothing
1171
1172 state_puts(state, _("Warning: The signature expired at: "));
1173 print_time(sig2 ? sig2->exp_timestamp : 0, state);
1174 state_puts(state, "\n");
1175 }
1176
1177 if ((sum & GPGME_SIGSUM_KEY_MISSING))
1178 {
1179 state_puts(state, _("Can't verify due to a missing key or certificate\n"));
1180 }
1181
1182 if ((sum & GPGME_SIGSUM_CRL_MISSING))
1183 {
1184 state_puts(state, _("The CRL is not available\n"));
1185 severe = true;
1186 }
1187
1188 if ((sum & GPGME_SIGSUM_CRL_TOO_OLD))
1189 {
1190 state_puts(state, _("Available CRL is too old\n"));
1191 severe = true;
1192 }
1193
1194 if ((sum & GPGME_SIGSUM_BAD_POLICY))
1195 state_puts(state, _("A policy requirement was not met\n"));
1196
1197 if ((sum & GPGME_SIGSUM_SYS_ERROR))
1198 {
1199 const char *t0 = NULL, *t1 = NULL;
1200 gpgme_verify_result_t result = NULL;
1201 gpgme_signature_t sig2 = NULL;
1202 unsigned int i;
1203
1204 state_puts(state, _("A system error occurred"));
1205
1206 /* Try to figure out some more detailed system error information. */
1207 result = gpgme_op_verify_result(ctx);
1208 for (sig2 = result->signatures, i = 0; sig2 && (i < idx); sig2 = sig2->next, i++)
1209 ; // do nothing
1210
1211 if (sig2)
1212 {
1213 t0 = "";
1214 t1 = sig2->wrong_key_usage ? "Wrong_Key_Usage" : "";
1215 }
1216
1217 if (t0 || t1)
1218 {
1219 state_puts(state, ": ");
1220 if (t0)
1221 state_puts(state, t0);
1222 if (t1 && !(t0 && (mutt_str_equal(t0, t1))))
1223 {
1224 if (t0)
1225 state_puts(state, ",");
1226 state_puts(state, t1);
1227 }
1228 }
1229 state_puts(state, "\n");
1230 }
1231
1232 const bool c_crypt_use_pka = cs_subset_bool(NeoMutt->sub, "crypt_use_pka");
1233 if (c_crypt_use_pka)
1234 {
1235 if ((sig->pka_trust == 1) && sig->pka_address)
1236 {
1237 state_puts(state, _("WARNING: PKA entry does not match signer's address: "));
1238 state_puts(state, sig->pka_address);
1239 state_puts(state, "\n");
1240 }
1241 else if ((sig->pka_trust == 2) && sig->pka_address)
1242 {
1243 state_puts(state, _("PKA verified signer's address is: "));
1244 state_puts(state, sig->pka_address);
1245 state_puts(state, "\n");
1246 }
1247 }
1248
1249 return severe;
1250}
1251
1257static void show_fingerprint(gpgme_key_t key, struct State *state)
1258{
1259 if (!key)
1260 return;
1261
1262 const char *prefix = _("Fingerprint: ");
1263
1264 const char *s = key->subkeys ? key->subkeys->fpr : NULL;
1265 if (!s)
1266 return;
1267 bool is_pgp = (key->protocol == GPGME_PROTOCOL_OpenPGP);
1268
1269 char *buf = mutt_mem_malloc(strlen(prefix) + strlen(s) * 4 + 2);
1270 strcpy(buf, prefix);
1271 char *p = buf + strlen(buf);
1272 if (is_pgp && (strlen(s) == 40))
1273 { /* PGP v4 style formatted. */
1274 for (int i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++)
1275 {
1276 *p++ = s[0];
1277 *p++ = s[1];
1278 *p++ = s[2];
1279 *p++ = s[3];
1280 *p++ = ' ';
1281 if (i == 4)
1282 *p++ = ' ';
1283 }
1284 }
1285 else
1286 {
1287 for (int i = 0; *s && s[1] && s[2]; s += 2, i++)
1288 {
1289 *p++ = s[0];
1290 *p++ = s[1];
1291 *p++ = is_pgp ? ' ' : ':';
1292 if (is_pgp && (i == 7))
1293 *p++ = ' ';
1294 }
1295 }
1296
1297 /* just in case print remaining odd digits */
1298 for (; *s; s++)
1299 *p++ = *s;
1300 *p++ = '\n';
1301 *p = '\0';
1302 state_puts(state, buf);
1303 FREE(&buf);
1304}
1305
1312static void show_one_sig_validity(gpgme_ctx_t ctx, int idx, struct State *state)
1313{
1314 gpgme_signature_t sig = NULL;
1315 const char *txt = NULL;
1316
1317 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1318 if (result)
1319 for (sig = result->signatures; sig && (idx > 0); sig = sig->next, idx--)
1320 ; // do nothing
1321
1322 switch (sig ? sig->validity : 0)
1323 {
1324 case GPGME_VALIDITY_UNKNOWN:
1325 txt = _("WARNING: We have NO indication whether the key belongs to the person named as shown above\n");
1326 break;
1327 case GPGME_VALIDITY_UNDEFINED:
1328 break;
1329 case GPGME_VALIDITY_NEVER:
1330 txt = _("WARNING: The key does NOT BELONG to the person named as shown above\n");
1331 break;
1332 case GPGME_VALIDITY_MARGINAL:
1333 txt = _("WARNING: It is NOT certain that the key belongs to the person named as shown above\n");
1334 break;
1335 case GPGME_VALIDITY_FULL:
1336 case GPGME_VALIDITY_ULTIMATE:
1337 txt = NULL;
1338 break;
1339 }
1340 if (txt)
1341 state_puts(state, txt);
1342}
1343
1351static void print_smime_keyinfo(const char *msg, gpgme_signature_t sig,
1352 gpgme_key_t key, struct State *state)
1353{
1354 int msgwid;
1355
1356 state_puts(state, msg);
1357 state_puts(state, " ");
1358 /* key is NULL when not present in the user's keyring */
1359 if (key)
1360 {
1361 bool aka = false;
1362 for (gpgme_user_id_t uids = key->uids; uids; uids = uids->next)
1363 {
1364 if (uids->revoked)
1365 continue;
1366 if (aka)
1367 {
1368 msgwid = mutt_strwidth(msg) - mutt_strwidth(_("aka: ")) + 1;
1369 if (msgwid < 0)
1370 msgwid = 0;
1371 for (int i = 0; i < msgwid; i++)
1372 state_puts(state, " ");
1373 state_puts(state, _("aka: "));
1374 }
1375 state_puts(state, uids->uid);
1376 state_puts(state, "\n");
1377
1378 aka = true;
1379 }
1380 }
1381 else
1382 {
1383 if (sig->fpr)
1384 {
1385 state_puts(state, _("KeyID "));
1386 state_puts(state, sig->fpr);
1387 }
1388 else
1389 {
1390 /* L10N: You will see this message in place of "KeyID "
1391 if the S/MIME key has no ID. This is quite an error. */
1392 state_puts(state, _("no signature fingerprint available"));
1393 }
1394 state_puts(state, "\n");
1395 }
1396
1397 /* timestamp is 0 when verification failed.
1398 * "Jan 1 1970" is not the created date. */
1399 if (sig->timestamp)
1400 {
1401 msgwid = mutt_strwidth(msg) - mutt_strwidth(_("created: ")) + 1;
1402 if (msgwid < 0)
1403 msgwid = 0;
1404 for (int i = 0; i < msgwid; i++)
1405 state_puts(state, " ");
1406 state_puts(state, _("created: "));
1407 print_time(sig->timestamp, state);
1408 state_puts(state, "\n");
1409 }
1410}
1411
1417static void show_one_recipient(struct State *state, gpgme_recipient_t r)
1418{
1419 const char *algo = gpgme_pubkey_algo_name(r->pubkey_algo);
1420 if (!algo)
1421 algo = "?";
1422
1423 // L10N: Show the algorithm and key ID of the encryption recipients, e.g
1424 // Recipient: RSA key, ID 1111111111111111
1425 state_printf(state, _("Recipient: %s key, ID %s\n"), algo, r->keyid);
1426}
1427
1433static void show_encryption_info(struct State *state, gpgme_decrypt_result_t result)
1434{
1435 if (!cs_subset_bool(NeoMutt->sub, "crypt_encryption_info"))
1436 return;
1437
1438 state_attach_puts(state, _("[-- Begin encryption information --]\n"));
1439
1440 for (gpgme_recipient_t r = result->recipients; r; r = r->next)
1441 show_one_recipient(state, r);
1442
1443 state_attach_puts(state, _("[-- End encryption information --]\n\n"));
1444}
1445
1458static int show_one_sig_status(gpgme_ctx_t ctx, int idx, struct State *state)
1459{
1460 const char *fpr = NULL;
1461 gpgme_key_t key = NULL;
1462 bool anybad = false, anywarn = false;
1463 gpgme_signature_t sig = NULL;
1464 gpgme_error_t err = GPG_ERR_NO_ERROR;
1465
1466 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1467 if (result)
1468 {
1469 /* FIXME: this code should use a static variable and remember
1470 * the current position in the list of signatures, IMHO.
1471 * -moritz. */
1472 int i;
1473 for (i = 0, sig = result->signatures; sig && (i < idx); i++, sig = sig->next)
1474 ; // do nothing
1475
1476 if (!sig)
1477 return -1; /* Signature not found. */
1478
1479 if (SignatureKey)
1480 {
1481 gpgme_key_unref(SignatureKey);
1482 SignatureKey = NULL;
1483 }
1484
1485 fpr = sig->fpr;
1486 const unsigned int sum = sig->summary;
1487
1488 if (gpg_err_code(sig->status) != GPG_ERR_NO_ERROR)
1489 anybad = true;
1490
1491 if (gpg_err_code(sig->status) != GPG_ERR_NO_PUBKEY)
1492 {
1493 err = gpgme_get_key(ctx, fpr, &key, 0); /* secret key? */
1494 if (err == GPG_ERR_NO_ERROR)
1495 {
1496 if (!SignatureKey)
1497 SignatureKey = key;
1498 }
1499 else
1500 {
1501 key = NULL; /* Old GPGME versions did not set KEY to NULL on
1502 error. Do it here to avoid a double free. */
1503 }
1504 }
1505 else
1506 {
1507 /* pubkey not present */
1508 }
1509
1510 if (!state || !state->fp_out || !(state->flags & STATE_DISPLAY))
1511 {
1512 ; /* No state information so no way to print anything. */
1513 }
1514 else if (err != GPG_ERR_NO_ERROR)
1515 {
1516 char buf[1024] = { 0 };
1517 snprintf(buf, sizeof(buf), _("Error getting key information for KeyID %s: %s\n"),
1518 fpr, gpgme_strerror(err));
1519 state_puts(state, buf);
1520 anybad = true;
1521 }
1522 else if ((sum & GPGME_SIGSUM_GREEN))
1523 {
1524 print_smime_keyinfo(_("Good signature from:"), sig, key, state);
1525 if (show_sig_summary(sum, ctx, key, idx, state, sig))
1526 anywarn = true;
1527 show_one_sig_validity(ctx, idx, state);
1528 }
1529 else if ((sum & GPGME_SIGSUM_RED))
1530 {
1531 print_smime_keyinfo(_("*BAD* signature from:"), sig, key, state);
1532 show_sig_summary(sum, ctx, key, idx, state, sig);
1533 }
1534 else if (!anybad && key && (key->protocol == GPGME_PROTOCOL_OpenPGP))
1535 { /* We can't decide (yellow) but this is a PGP key with a good
1536 signature, so we display what a PGP user expects: The name,
1537 fingerprint and the key validity (which is neither fully or
1538 ultimate). */
1539 print_smime_keyinfo(_("Good signature from:"), sig, key, state);
1540 show_one_sig_validity(ctx, idx, state);
1541 show_fingerprint(key, state);
1542 if (show_sig_summary(sum, ctx, key, idx, state, sig))
1543 anywarn = true;
1544 }
1545 else /* can't decide (yellow) */
1546 {
1547 print_smime_keyinfo(_("Problem signature from:"), sig, key, state);
1548 /* 0 indicates no expiration */
1549 if (sig->exp_timestamp)
1550 {
1551 /* L10N: This is trying to match the width of the
1552 "Problem signature from:" translation just above. */
1553 state_puts(state, _(" expires: "));
1554 print_time(sig->exp_timestamp, state);
1555 state_puts(state, "\n");
1556 }
1557 show_sig_summary(sum, ctx, key, idx, state, sig);
1558 anywarn = true;
1559 }
1560
1561 if (key != SignatureKey)
1562 gpgme_key_unref(key);
1563 }
1564
1565 return anybad ? 1 : anywarn ? 2 : 0;
1566}
1567
1581static int verify_one(struct Body *b, struct State *state, const char *tempfile, bool is_smime)
1582{
1583 int badsig = -1;
1584 int anywarn = 0;
1585 gpgme_ctx_t ctx = NULL;
1586 gpgme_data_t message = NULL;
1587
1588 gpgme_data_t signature = file_to_data_object(state->fp_in, b->offset, b->length);
1589 if (!signature)
1590 return -1;
1591
1592 /* We need to tell GPGME about the encoding because the backend can't
1593 * auto-detect plain base-64 encoding which is used by S/MIME. */
1594 if (is_smime)
1595 gpgme_data_set_encoding(signature, GPGME_DATA_ENCODING_BASE64);
1596
1597 gpgme_error_t err = gpgme_data_new_from_file(&message, tempfile, 1);
1598 if (err != GPG_ERR_NO_ERROR)
1599 {
1600 gpgme_data_release(signature);
1601 mutt_error(_("error allocating data object: %s"), gpgme_strerror(err));
1602 return -1;
1603 }
1604 ctx = create_gpgme_context(is_smime);
1605
1606 /* Note: We don't need a current time output because GPGME avoids
1607 * such an attack by separating the meta information from the data. */
1608 state_attach_puts(state, _("[-- Begin signature information --]\n"));
1609
1610 err = gpgme_op_verify(ctx, signature, message, NULL);
1611 gpgme_data_release(message);
1612 gpgme_data_release(signature);
1613
1614 redraw_if_needed(ctx);
1615 if (err != GPG_ERR_NO_ERROR)
1616 {
1617 char buf[200] = { 0 };
1618
1619 snprintf(buf, sizeof(buf) - 1, _("Error: verification failed: %s\n"),
1620 gpgme_strerror(err));
1621 state_puts(state, buf);
1622 }
1623 else
1624 { /* Verification succeeded, see what the result is. */
1625 gpgme_verify_result_t verify_result = NULL;
1626
1627 if (SignatureKey)
1628 {
1629 gpgme_key_unref(SignatureKey);
1630 SignatureKey = NULL;
1631 }
1632
1633 verify_result = gpgme_op_verify_result(ctx);
1634 if (verify_result && verify_result->signatures)
1635 {
1636 bool anybad = false;
1637 int res;
1638 for (int idx = 0; (res = show_one_sig_status(ctx, idx, state)) != -1; idx++)
1639 {
1640 if (res == 1)
1641 anybad = true;
1642 else if (res == 2)
1643 anywarn = 2;
1644 }
1645 if (!anybad)
1646 badsig = 0;
1647 }
1648 }
1649
1650 if (badsig == 0)
1651 {
1652 gpgme_verify_result_t result = NULL;
1653 gpgme_sig_notation_t notation = NULL;
1654 gpgme_signature_t sig = NULL;
1655
1656 result = gpgme_op_verify_result(ctx);
1657 if (result)
1658 {
1659 for (sig = result->signatures; sig; sig = sig->next)
1660 {
1661 int non_pka_notations = 0;
1662 for (notation = sig->notations; notation; notation = notation->next)
1663 if (!is_pka_notation(notation))
1664 non_pka_notations++;
1665
1666 if (non_pka_notations)
1667 {
1668 char buf[128] = { 0 };
1669 snprintf(buf, sizeof(buf),
1670 _("*** Begin Notation (signature by: %s) ***\n"), sig->fpr);
1671 state_puts(state, buf);
1672 for (notation = sig->notations; notation; notation = notation->next)
1673 {
1674 if (is_pka_notation(notation))
1675 continue;
1676
1677 if (notation->name)
1678 {
1679 state_puts(state, notation->name);
1680 state_puts(state, "=");
1681 }
1682 if (notation->value)
1683 {
1684 state_puts(state, notation->value);
1685 if (!(*notation->value && (notation->value[strlen(notation->value) - 1] == '\n')))
1686 state_puts(state, "\n");
1687 }
1688 }
1689 state_puts(state, _("*** End Notation ***\n"));
1690 }
1691 }
1692 }
1693 }
1694
1695 gpgme_release(ctx);
1696
1697 state_attach_puts(state, _("[-- End signature information --]\n\n"));
1698 mutt_debug(LL_DEBUG1, "returning %d\n", badsig);
1699
1700 return badsig ? 1 : anywarn ? 2 : 0;
1701}
1702
1706int pgp_gpgme_verify_one(struct Body *b, struct State *state, const char *tempfile)
1707{
1708 return verify_one(b, state, tempfile, false);
1709}
1710
1714int smime_gpgme_verify_one(struct Body *b, struct State *state, const char *tempfile)
1715{
1716 return verify_one(b, state, tempfile, true);
1717}
1718
1732static struct Body *decrypt_part(struct Body *b, struct State *state,
1733 FILE *fp_out, bool is_smime, int *r_is_signed)
1734{
1735 if (!b || !state || !fp_out)
1736 return NULL;
1737
1738 struct Body *tattach = NULL;
1739 gpgme_error_t err = GPG_ERR_NO_ERROR;
1740 gpgme_data_t ciphertext = NULL, plaintext = NULL;
1741 gpgme_decrypt_result_t result = NULL;
1742 bool maybe_signed = false;
1743 bool anywarn = false;
1744 int sig_stat = 0;
1745
1746 if (r_is_signed)
1747 *r_is_signed = 0;
1748
1749 gpgme_ctx_t ctx = NULL;
1750restart:
1751 ctx = create_gpgme_context(is_smime);
1752
1753 if (b->length < 0)
1754 return NULL;
1755 /* Make a data object from the body, create context etc. */
1756 ciphertext = file_to_data_object(state->fp_in, b->offset, b->length);
1757 if (!ciphertext)
1758 goto cleanup;
1759 plaintext = create_gpgme_data();
1760
1761 /* Do the decryption or the verification in case of the S/MIME hack. */
1762 if ((!is_smime) || maybe_signed)
1763 {
1764 if (!is_smime)
1765 err = gpgme_op_decrypt_verify(ctx, ciphertext, plaintext);
1766 else if (maybe_signed)
1767 err = gpgme_op_verify(ctx, ciphertext, NULL, plaintext);
1768
1769 if (err == GPG_ERR_NO_ERROR)
1770 {
1771 /* Check whether signatures have been verified. */
1772 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
1773 if (verify_result->signatures)
1774 sig_stat = 1;
1775 }
1776 }
1777 else
1778 {
1779 err = gpgme_op_decrypt(ctx, ciphertext, plaintext);
1780 }
1781 gpgme_data_release(ciphertext);
1782 ciphertext = NULL;
1783
1784#ifdef USE_AUTOCRYPT
1785 // Abort right away and silently. Autocrypt will retry on the normal keyring.
1786 if (OptAutocryptGpgme && (err != GPG_ERR_NO_ERROR))
1787 goto cleanup;
1788#endif
1789
1790 const bool c_devel_security = cs_subset_bool(NeoMutt->sub, "devel_security");
1791
1792 result = gpgme_op_decrypt_result(ctx);
1793 if (c_devel_security && result && (state->flags & STATE_DISPLAY))
1794 show_encryption_info(state, result);
1795
1796 if (err != GPG_ERR_NO_ERROR)
1797 {
1798 if (is_smime && !maybe_signed && (gpg_err_code(err) == GPG_ERR_NO_DATA))
1799 {
1800 /* Check whether this might be a signed message despite what the mime
1801 * header told us. Retry then. gpgsm returns the error information
1802 * "unsupported Algorithm '?'" but GPGME will not store this unknown
1803 * algorithm, thus we test that it has not been set. */
1804 if (result && !result->unsupported_algorithm)
1805 {
1806 maybe_signed = true;
1807 gpgme_data_release(plaintext);
1808 plaintext = NULL;
1809 /* gpgsm ends the session after an error; restart it */
1810 gpgme_release(ctx);
1811 goto restart;
1812 }
1813 }
1814 redraw_if_needed(ctx);
1815 if ((state->flags & STATE_DISPLAY))
1816 {
1817 char buf[200] = { 0 };
1818
1819 snprintf(buf, sizeof(buf) - 1,
1820 _("[-- Error: decryption failed: %s --]\n\n"), gpgme_strerror(err));
1821 state_attach_puts(state, buf);
1822 }
1823 goto cleanup;
1824 }
1825 redraw_if_needed(ctx);
1826
1827 /* Read the output from GPGME, and make sure to change CRLF to LF,
1828 * otherwise read_mime_header has a hard time parsing the message. */
1829 if (data_object_to_stream(plaintext, fp_out))
1830 {
1831 goto cleanup;
1832 }
1833 gpgme_data_release(plaintext);
1834 plaintext = NULL;
1835
1836 if (sig_stat)
1837 {
1838 int res, idx;
1839 int anybad = 0;
1840
1841 if (r_is_signed)
1842 *r_is_signed = -1; /* A signature exists. */
1843
1844 if ((state->flags & STATE_DISPLAY))
1845 {
1846 state_attach_puts(state, _("[-- Begin signature information --]\n"));
1847 }
1848 for (idx = 0; (res = show_one_sig_status(ctx, idx, state)) != -1; idx++)
1849 {
1850 if (res == 1)
1851 anybad = 1;
1852 else if (res == 2)
1853 anywarn = true;
1854 }
1855 if (!anybad && idx && r_is_signed && *r_is_signed)
1856 *r_is_signed = anywarn ? 2 : 1; /* Good signature. */
1857
1858 if ((state->flags & STATE_DISPLAY))
1859 {
1860 state_attach_puts(state, _("[-- End signature information --]\n\n"));
1861 }
1862 }
1863 gpgme_release(ctx);
1864 ctx = NULL;
1865
1866 fflush(fp_out);
1867 rewind(fp_out);
1868 const long size = mutt_file_get_size_fp(fp_out);
1869 if (size == 0)
1870 {
1871 goto cleanup;
1872 }
1873 tattach = mutt_read_mime_header(fp_out, 0);
1874 if (tattach)
1875 {
1876 /* Need to set the length of this body part. */
1877 tattach->length = size - tattach->offset;
1878
1879 tattach->warnsig = anywarn;
1880
1881 /* See if we need to recurse on this MIME part. */
1882 mutt_parse_part(fp_out, tattach);
1883 }
1884
1885cleanup:
1886 gpgme_data_release(ciphertext);
1887 gpgme_data_release(plaintext);
1888 gpgme_release(ctx);
1889
1890 return tattach;
1891}
1892
1896int pgp_gpgme_decrypt_mime(FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **b_dec)
1897{
1898 struct State state = { 0 };
1899 struct Body *first_part = b;
1900 int is_signed = 0;
1901 bool need_decode = false;
1902 LOFF_T saved_offset = 0;
1903 size_t saved_length = 0;
1904 FILE *fp_decoded = NULL;
1905 int rc = 0;
1906
1907 first_part->goodsig = false;
1908 first_part->warnsig = false;
1909
1911 {
1912 b = b->parts->next;
1913 /* Some clients improperly encode the octetstream part. */
1914 if (b->encoding != ENC_7BIT)
1915 need_decode = true;
1916 }
1918 {
1919 b = b->parts->next->next;
1920 need_decode = true;
1921 }
1922 else
1923 {
1924 return -1;
1925 }
1926
1927 state.fp_in = fp_in;
1928
1929 if (need_decode)
1930 {
1931 saved_offset = b->offset;
1932 saved_length = b->length;
1933
1934 fp_decoded = mutt_file_mkstemp();
1935 if (!fp_decoded)
1936 {
1937 mutt_perror(_("Can't create temporary file"));
1938 return -1;
1939 }
1940
1941 if (!mutt_file_seek(state.fp_in, b->offset, SEEK_SET))
1942 {
1943 rc = -1;
1944 goto bail;
1945 }
1946 state.fp_out = fp_decoded;
1947
1948 mutt_decode_attachment(b, &state);
1949
1950 fflush(fp_decoded);
1951 b->length = ftello(fp_decoded);
1952 b->offset = 0;
1953 rewind(fp_decoded);
1954 state.fp_in = fp_decoded;
1955 state.fp_out = 0;
1956 }
1957
1958 *fp_out = mutt_file_mkstemp();
1959 if (!*fp_out)
1960 {
1961 mutt_perror(_("Can't create temporary file"));
1962 rc = -1;
1963 goto bail;
1964 }
1965
1966 *b_dec = decrypt_part(b, &state, *fp_out, false, &is_signed);
1967 if (*b_dec)
1968 {
1969 rewind(*fp_out);
1970 if (is_signed > 0)
1971 first_part->goodsig = true;
1972 }
1973 else
1974 {
1975 rc = -1;
1976 mutt_file_fclose(fp_out);
1977 }
1978
1979bail:
1980 if (need_decode)
1981 {
1982 b->length = saved_length;
1983 b->offset = saved_offset;
1984 mutt_file_fclose(&fp_decoded);
1985 }
1986
1987 return rc;
1988}
1989
1993int smime_gpgme_decrypt_mime(FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **b_dec)
1994{
1995 struct State state = { 0 };
1996 int is_signed;
1997 LOFF_T saved_b_offset;
1998 size_t saved_b_length;
1999
2001 return -1;
2002
2003 if (b->parts)
2004 return -1;
2005
2006 /* Decode the body - we need to pass binary CMS to the
2007 * backend. The backend allows for Base64 encoded data but it does
2008 * not allow for QP which I have seen in some messages. So better
2009 * do it here. */
2010 saved_b_offset = b->offset;
2011 saved_b_length = b->length;
2012 state.fp_in = fp_in;
2013 if (!mutt_file_seek(state.fp_in, b->offset, SEEK_SET))
2014 {
2015 return -1;
2016 }
2017 FILE *fp_tmp = mutt_file_mkstemp();
2018 if (!fp_tmp)
2019 {
2020 mutt_perror(_("Can't create temporary file"));
2021 return -1;
2022 }
2023
2024 state.fp_out = fp_tmp;
2025 mutt_decode_attachment(b, &state);
2026 fflush(fp_tmp);
2027 b->length = ftello(state.fp_out);
2028 b->offset = 0;
2029 rewind(fp_tmp);
2030
2031 memset(&state, 0, sizeof(state));
2032 state.fp_in = fp_tmp;
2033 state.fp_out = 0;
2035 if (!*fp_out)
2036 {
2037 mutt_perror(_("Can't create temporary file"));
2038 return -1;
2039 }
2040
2041 *b_dec = decrypt_part(b, &state, *fp_out, true, &is_signed);
2042 if (*b_dec)
2043 (*b_dec)->goodsig = is_signed > 0;
2044 b->length = saved_b_length;
2045 b->offset = saved_b_offset;
2046 mutt_file_fclose(&fp_tmp);
2047 rewind(*fp_out);
2048 if (*b_dec && !is_signed && !(*b_dec)->parts && mutt_is_application_smime(*b_dec))
2049 {
2050 /* Assume that this is a opaque signed s/mime message. This is an ugly way
2051 * of doing it but we have anyway a problem with arbitrary encoded S/MIME
2052 * messages: Only the outer part may be encrypted. The entire mime parsing
2053 * should be revamped, probably by keeping the temporary files so that we
2054 * don't need to decrypt them all the time. Inner parts of an encrypted
2055 * part can then point into this file and there won't ever be a need to
2056 * decrypt again. This needs a partial rewrite of the MIME engine. */
2057 struct Body *bb = *b_dec;
2058
2059 saved_b_offset = bb->offset;
2060 saved_b_length = bb->length;
2061 memset(&state, 0, sizeof(state));
2062 state.fp_in = *fp_out;
2063 if (!mutt_file_seek(state.fp_in, bb->offset, SEEK_SET))
2064 {
2065 return -1;
2066 }
2067 FILE *fp_tmp2 = mutt_file_mkstemp();
2068 if (!fp_tmp2)
2069 {
2070 mutt_perror(_("Can't create temporary file"));
2071 return -1;
2072 }
2073
2074 state.fp_out = fp_tmp2;
2075 mutt_decode_attachment(bb, &state);
2076 fflush(fp_tmp2);
2077 bb->length = ftello(state.fp_out);
2078 bb->offset = 0;
2079 rewind(fp_tmp2);
2080 mutt_file_fclose(fp_out);
2081
2082 memset(&state, 0, sizeof(state));
2083 state.fp_in = fp_tmp2;
2084 state.fp_out = 0;
2085 *fp_out = mutt_file_mkstemp();
2086 if (!*fp_out)
2087 {
2088 mutt_perror(_("Can't create temporary file"));
2089 return -1;
2090 }
2091
2092 struct Body *b_tmp = decrypt_part(bb, &state, *fp_out, true, &is_signed);
2093 if (b_tmp)
2094 b_tmp->goodsig = is_signed > 0;
2095 bb->length = saved_b_length;
2096 bb->offset = saved_b_offset;
2097 mutt_file_fclose(&fp_tmp2);
2098 rewind(*fp_out);
2099 mutt_body_free(b_dec);
2100 *b_dec = b_tmp;
2101 }
2102 return *b_dec ? 0 : -1;
2103}
2104
2112static int pgp_gpgme_extract_keys(gpgme_data_t keydata, FILE **fp)
2113{
2114 gpgme_ctx_t tmpctx = NULL;
2115 gpgme_key_t key = NULL;
2116 gpgme_user_id_t uid = NULL;
2117 gpgme_subkey_t subkey = NULL;
2118 const char *shortid = NULL;
2119 size_t len;
2120 char date[256] = { 0 };
2121 bool more;
2122 int rc = -1;
2123 time_t tt;
2124
2125 *fp = mutt_file_mkstemp();
2126 if (!*fp)
2127 {
2128 mutt_perror(_("Can't create temporary file"));
2129 return -1;
2130 }
2131
2132 tmpctx = create_gpgme_context(false);
2133
2134 gpgme_error_t err = gpgme_op_keylist_from_data_start(tmpctx, keydata, 0);
2135 while (err == GPG_ERR_NO_ERROR)
2136 {
2137 err = gpgme_op_keylist_next(tmpctx, &key);
2138 if (err != GPG_ERR_NO_ERROR)
2139 break;
2140 uid = key->uids;
2141 subkey = key->subkeys;
2142 more = false;
2143 while (subkey)
2144 {
2145 shortid = subkey->keyid;
2146 len = mutt_str_len(subkey->keyid);
2147 if (len > 8)
2148 shortid += len - 8;
2149 tt = subkey->timestamp;
2150 mutt_date_localtime_format(date, sizeof(date), "%Y-%m-%d", tt);
2151
2152 fprintf(*fp, "%s %5.5s %u/%8s %s\n", more ? "sub" : "pub",
2153 gpgme_pubkey_algo_name(subkey->pubkey_algo), subkey->length, shortid, date);
2154 if (!more)
2155 {
2156 while (uid)
2157 {
2158 fprintf(*fp, "uid %s\n", NONULL(uid->uid));
2159 uid = uid->next;
2160 }
2161 }
2162 subkey = subkey->next;
2163 more = true;
2164 }
2165 gpgme_key_unref(key);
2166 }
2167 if (gpg_err_code(err) != GPG_ERR_EOF)
2168 {
2169 mutt_debug(LL_DEBUG1, "Error listing keys\n");
2170 goto err_fp;
2171 }
2172
2173 rc = 0;
2174
2175err_fp:
2176 if (rc)
2177 mutt_file_fclose(fp);
2178
2179 gpgme_release(tmpctx);
2180
2181 return rc;
2182}
2183
2195static int line_compare(const char *a, size_t n, const char *b)
2196{
2197 if (mutt_strn_equal(a, b, n))
2198 {
2199 /* at this point we know that 'b' is at least 'n' chars long */
2200 if ((b[n] == '\n') || ((b[n] == '\r') && (b[n + 1] == '\n')))
2201 return true;
2202 }
2203 return false;
2204}
2205
2213static int pgp_check_traditional_one_body(FILE *fp, struct Body *b)
2214{
2215 char buf[8192] = { 0 };
2216 bool rc = false;
2217
2218 bool sgn = false;
2219 bool enc = false;
2220
2221 if (b->type != TYPE_TEXT)
2222 return 0;
2223
2224 struct Buffer *tempfile = buf_pool_get();
2225 buf_mktemp(tempfile);
2227 MUTT_SAVE_NO_FLAGS) != 0)
2228 {
2229 unlink(buf_string(tempfile));
2230 goto cleanup;
2231 }
2232
2233 FILE *fp_tmp = mutt_file_fopen(buf_string(tempfile), "r");
2234 if (!fp_tmp)
2235 {
2236 unlink(buf_string(tempfile));
2237 goto cleanup;
2238 }
2239
2240 while (fgets(buf, sizeof(buf), fp_tmp))
2241 {
2242 size_t plen = mutt_str_startswith(buf, "-----BEGIN PGP ");
2243 if (plen != 0)
2244 {
2245 if (MESSAGE(buf + plen))
2246 {
2247 enc = true;
2248 break;
2249 }
2250 else if (SIGNED_MESSAGE(buf + plen))
2251 {
2252 sgn = true;
2253 break;
2254 }
2255 }
2256 }
2257 mutt_file_fclose(&fp_tmp);
2258 unlink(buf_string(tempfile));
2259
2260 if (!enc && !sgn)
2261 goto cleanup;
2262
2263 /* fix the content type */
2264
2265 mutt_param_set(&b->parameter, "format", "fixed");
2266 mutt_param_set(&b->parameter, "x-action", enc ? "pgp-encrypted" : "pgp-signed");
2267
2268 rc = true;
2269
2270cleanup:
2271 buf_pool_release(&tempfile);
2272 return rc;
2273}
2274
2278bool pgp_gpgme_check_traditional(FILE *fp, struct Body *b, bool just_one)
2279{
2280 bool rc = false;
2281 for (; b; b = b->next)
2282 {
2283 if (!just_one && is_multipart(b))
2284 {
2285 rc = (pgp_gpgme_check_traditional(fp, b->parts, false) || rc);
2286 }
2287 else if (b->type == TYPE_TEXT)
2288 {
2290 if (r)
2291 rc = (rc || r);
2292 else
2293 rc = (pgp_check_traditional_one_body(fp, b) || rc);
2294 }
2295
2296 if (just_one)
2297 break;
2298 }
2299 return rc;
2300}
2301
2305void pgp_gpgme_invoke_import(const char *fname)
2306{
2307 gpgme_ctx_t ctx = create_gpgme_context(false);
2308 gpgme_data_t keydata = NULL;
2309 gpgme_import_result_t impres = NULL;
2310 gpgme_import_status_t st = NULL;
2311 bool any;
2312
2313 FILE *fp_in = mutt_file_fopen(fname, "r");
2314 if (!fp_in)
2315 {
2316 mutt_perror("%s", fname);
2317 goto leave;
2318 }
2319 /* Note that the stream, "fp_in", needs to be kept open while the keydata
2320 * is used. */
2321 gpgme_error_t err = gpgme_data_new_from_stream(&keydata, fp_in);
2322 if (err != GPG_ERR_NO_ERROR)
2323 {
2324 mutt_error(_("error allocating data object: %s"), gpgme_strerror(err));
2325 goto leave;
2326 }
2327
2328 err = gpgme_op_import(ctx, keydata);
2329 if (err != GPG_ERR_NO_ERROR)
2330 {
2331 mutt_error(_("Error importing key: %s"), gpgme_strerror(err));
2332 goto leave;
2333 }
2334
2335 /* Print infos about the imported keys to stdout. */
2336 impres = gpgme_op_import_result(ctx);
2337 if (!impres)
2338 {
2339 fputs("oops: no import result returned\n", stdout);
2340 goto leave;
2341 }
2342
2343 for (st = impres->imports; st; st = st->next)
2344 {
2345 if (st->result)
2346 continue;
2347 printf("key %s imported (", NONULL(st->fpr));
2348 /* Note that we use the singular even if it is possible that
2349 * several uids etc are new. This simply looks better. */
2350 any = false;
2351 if (st->status & GPGME_IMPORT_SECRET)
2352 {
2353 printf("secret parts");
2354 any = true;
2355 }
2356 if ((st->status & GPGME_IMPORT_NEW))
2357 {
2358 printf("%snew key", any ? ", " : "");
2359 any = true;
2360 }
2361 if ((st->status & GPGME_IMPORT_UID))
2362 {
2363 printf("%snew uid", any ? ", " : "");
2364 any = true;
2365 }
2366 if ((st->status & GPGME_IMPORT_SIG))
2367 {
2368 printf("%snew sig", any ? ", " : "");
2369 any = true;
2370 }
2371 if ((st->status & GPGME_IMPORT_SUBKEY))
2372 {
2373 printf("%snew subkey", any ? ", " : "");
2374 any = true;
2375 }
2376 printf("%s)\n", any ? "" : "not changed");
2377 /* Fixme: Should we lookup each imported key and print more infos? */
2378 }
2379 /* Now print keys which failed the import. Unfortunately in most
2380 * cases gpg will bail out early and not tell GPGME about. */
2381 /* FIXME: We could instead use the new GPGME_AUDITLOG_DIAG to show
2382 * the actual gpg diagnostics. But I fear that would clutter the
2383 * output too much. Maybe a dedicated prompt or option to do this
2384 * would be helpful. */
2385 for (st = impres->imports; st; st = st->next)
2386 {
2387 if (st->result == 0)
2388 continue;
2389 printf("key %s import failed: %s\n", NONULL(st->fpr), gpgme_strerror(st->result));
2390 }
2391 fflush(stdout);
2392
2393leave:
2394 gpgme_release(ctx);
2395 gpgme_data_release(keydata);
2396 mutt_file_fclose(&fp_in);
2397}
2398
2414static void copy_clearsigned(gpgme_data_t data, struct State *state, char *charset)
2415{
2416 char buf[8192] = { 0 };
2417 bool complete, armor_header;
2418 FILE *fp = NULL;
2419
2420 char *fname = data_object_to_tempfile(data, &fp);
2421 if (!fname)
2422 {
2423 mutt_file_fclose(&fp);
2424 return;
2425 }
2426 unlink(fname);
2427 FREE(&fname);
2428
2429 /* fromcode comes from the MIME Content-Type charset label. It might
2430 * be a wrong label, so we want the ability to do corrections via
2431 * charset-hooks. Therefore we set flags to MUTT_ICONV_HOOK_FROM. */
2433
2434 for (complete = true, armor_header = true;
2435 mutt_ch_fgetconvs(buf, sizeof(buf), fc); complete = (strchr(buf, '\n')))
2436 {
2437 if (!complete)
2438 {
2439 if (!armor_header)
2440 state_puts(state, buf);
2441 continue;
2442 }
2443
2444 if (BEGIN_PGP_SIGNATURE(buf))
2445 break;
2446
2447 if (armor_header)
2448 {
2449 if (buf[0] == '\n')
2450 armor_header = false;
2451 continue;
2452 }
2453
2454 if (state->prefix)
2455 state_puts(state, state->prefix);
2456
2457 if ((buf[0] == '-') && (buf[1] == ' '))
2458 state_puts(state, buf + 2);
2459 else
2460 state_puts(state, buf);
2461 }
2462
2465}
2466
2470int pgp_gpgme_application_handler(struct Body *b, struct State *state)
2471{
2472 int needpass = -1;
2473 bool pgp_keyblock = false;
2474 bool clearsign = false;
2475 long bytes;
2476 LOFF_T last_pos;
2477 LOFF_T block_begin;
2478 LOFF_T block_end;
2479 char buf[8192] = { 0 };
2480 FILE *fp_out = NULL;
2481
2482 gpgme_error_t err = GPG_ERR_NO_ERROR;
2483 gpgme_data_t armored_data = NULL;
2484
2485 bool maybe_goodsig = true;
2486 bool have_any_sigs = false;
2487
2488 char body_charset[256] = { 0 }; /* Only used for clearsigned messages. */
2489 char *gpgcharset = NULL;
2490
2491 mutt_debug(LL_DEBUG2, "Entering handler\n");
2492
2493 /* For clearsigned messages we won't be able to get a character set
2494 * but we know that this may only be text thus we assume Latin-1 here. */
2495 if (!mutt_body_get_charset(b, body_charset, sizeof(body_charset)))
2496 mutt_str_copy(body_charset, "iso-8859-1", sizeof(body_charset));
2497
2498 if (!mutt_file_seek(state->fp_in, b->offset, SEEK_SET))
2499 {
2500 return -1;
2501 }
2502 last_pos = b->offset;
2503
2504 for (bytes = b->length; bytes > 0;)
2505 {
2506 // record before the fgets in case it is a BEGIN block
2507 block_begin = last_pos;
2508
2509 if (!fgets(buf, sizeof(buf), state->fp_in))
2510 break;
2511
2512 LOFF_T offset = ftello(state->fp_in);
2513 if (offset < 0)
2514 {
2515 mutt_debug(LL_DEBUG1, "ftello() failed on fd %d\n", fileno(state->fp_in));
2516 offset = 0;
2517 }
2518 bytes -= (offset - last_pos); /* don't rely on mutt_str_len(buf) */
2519 last_pos = offset;
2520
2521 size_t plen = mutt_str_startswith(buf, "-----BEGIN PGP ");
2522 if (plen != 0)
2523 {
2524 needpass = 0;
2525 clearsign = false;
2526 pgp_keyblock = false;
2527
2528 if (MESSAGE(buf + plen))
2529 {
2530 needpass = 1;
2531 }
2532 else if (SIGNED_MESSAGE(buf + plen))
2533 {
2534 clearsign = true;
2535 }
2536 else if (PUBLIC_KEY_BLOCK(buf + plen))
2537 {
2538 pgp_keyblock = true;
2539 }
2540 else
2541 {
2542 /* XXX we may wish to recode here */
2543 if (state->prefix)
2544 state_puts(state, state->prefix);
2545 state_puts(state, buf);
2546 continue;
2547 }
2548
2549 /* Find the end of armored block. */
2550 while ((bytes > 0) && (fgets(buf, sizeof(buf) - 1, state->fp_in) != NULL))
2551 {
2552 offset = ftello(state->fp_in);
2553 if (offset < 0)
2554 {
2555 mutt_debug(LL_DEBUG1, "ftello() failed on fd %d\n", fileno(state->fp_in));
2556 offset = 0;
2557 }
2558 bytes -= (offset - last_pos); /* don't rely on mutt_strlen(buf) */
2559 last_pos = offset;
2560
2561 if (needpass && mutt_str_equal("-----END PGP MESSAGE-----\n", buf))
2562 {
2563 break;
2564 }
2565
2566 if (!needpass && (mutt_str_equal("-----END PGP SIGNATURE-----\n", buf) ||
2567 mutt_str_equal("-----END PGP PUBLIC KEY BLOCK-----\n", buf)))
2568 {
2569 break;
2570 }
2571
2572 // remember optional Charset: armor header as defined by rfc4880
2573 if (mutt_strn_equal("Charset: ", buf, 9))
2574 {
2575 size_t l = 0;
2576 FREE(&gpgcharset);
2577 gpgcharset = mutt_str_dup(buf + 9);
2578 if ((l = mutt_str_len(gpgcharset)) > 0 && gpgcharset[l - 1] == '\n')
2579 gpgcharset[l - 1] = 0;
2580 if (!mutt_ch_check_charset(gpgcharset, 0))
2581 mutt_str_replace(&gpgcharset, "UTF-8");
2582 }
2583 }
2584 block_end = ftello(state->fp_in);
2585 if (block_end < 0)
2586 {
2587 mutt_debug(LL_DEBUG1, "ftello() failed on fd %d\n", fileno(state->fp_in));
2588 block_end = 0;
2589 }
2590
2591 have_any_sigs = (have_any_sigs || (clearsign && (state->flags & STATE_VERIFY)));
2592
2593 /* Copy PGP material to an data container */
2594 armored_data = file_to_data_object(state->fp_in, block_begin, block_end - block_begin);
2595 fseeko(state->fp_in, block_end, 0);
2596
2597 /* Invoke PGP if needed */
2598 if (pgp_keyblock)
2599 {
2600 pgp_gpgme_extract_keys(armored_data, &fp_out);
2601 }
2602 else if (!clearsign || (state->flags & STATE_VERIFY))
2603 {
2604 gpgme_data_t plaintext = create_gpgme_data();
2605 gpgme_ctx_t ctx = create_gpgme_context(false);
2606
2607 if (clearsign)
2608 {
2609 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2610 }
2611 else
2612 {
2613 err = gpgme_op_decrypt_verify(ctx, armored_data, plaintext);
2614 if (gpg_err_code(err) == GPG_ERR_NO_DATA)
2615 {
2616 /* Decrypt verify can't handle signed only messages. */
2617 gpgme_data_seek(armored_data, 0, SEEK_SET);
2618 /* Must release plaintext so that we supply an uninitialized object. */
2619 gpgme_data_release(plaintext);
2620 plaintext = create_gpgme_data();
2621 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2622 }
2623 }
2624 redraw_if_needed(ctx);
2625
2626 const bool c_devel_security = cs_subset_bool(NeoMutt->sub, "devel_security");
2627 gpgme_decrypt_result_t result = gpgme_op_decrypt_result(ctx);
2628 if (c_devel_security && result && (state->flags & STATE_DISPLAY))
2629 show_encryption_info(state, result);
2630
2631 if (err != GPG_ERR_NO_ERROR)
2632 {
2633 char errbuf[200] = { 0 };
2634
2635 snprintf(errbuf, sizeof(errbuf) - 1,
2636 _("Error: decryption/verification failed: %s\n"), gpgme_strerror(err));
2637 state_puts(state, errbuf);
2638 }
2639 else
2640 {
2641 /* Decryption/Verification succeeded */
2642
2643 mutt_message(_("PGP message successfully decrypted"));
2644
2645 bool sig_stat = false;
2646 char *tmpfname = NULL;
2647
2648 /* Check whether signatures have been verified. */
2649 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
2650 if (verify_result->signatures)
2651 sig_stat = true;
2652
2653 have_any_sigs = false;
2654 maybe_goodsig = false;
2655 if ((state->flags & STATE_DISPLAY) && sig_stat)
2656 {
2657 int res, idx;
2658 bool anybad = false;
2659
2660 state_attach_puts(state, _("[-- Begin signature information --]\n"));
2661 have_any_sigs = true;
2662 for (idx = 0; (res = show_one_sig_status(ctx, idx, state)) != -1; idx++)
2663 {
2664 if (res == 1)
2665 anybad = true;
2666 }
2667 if (!anybad && idx)
2668 maybe_goodsig = true;
2669
2670 state_attach_puts(state, _("[-- End signature information --]\n\n"));
2671 }
2672
2673 tmpfname = data_object_to_tempfile(plaintext, &fp_out);
2674 if (tmpfname)
2675 {
2676 unlink(tmpfname);
2677 FREE(&tmpfname);
2678 }
2679 else
2680 {
2681 mutt_file_fclose(&fp_out);
2682 state_puts(state, _("Error: copy data failed\n"));
2683 }
2684 }
2685 gpgme_data_release(plaintext);
2686 gpgme_release(ctx);
2687 }
2688
2689 /* Now, copy cleartext to the screen. NOTE - we expect that PGP
2690 * outputs utf-8 cleartext. This may not always be true, but it
2691 * seems to be a reasonable guess. */
2692 if (state->flags & STATE_DISPLAY)
2693 {
2694 if (needpass)
2695 state_attach_puts(state, _("[-- BEGIN PGP MESSAGE --]\n\n"));
2696 else if (pgp_keyblock)
2697 state_attach_puts(state, _("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"));
2698 else
2699 state_attach_puts(state, _("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"));
2700 }
2701
2702 if (clearsign)
2703 {
2704 copy_clearsigned(armored_data, state, body_charset);
2705 }
2706 else if (fp_out)
2707 {
2708 int c;
2709 char *expected_charset = gpgcharset && *gpgcharset ? gpgcharset : "utf-8";
2710 rewind(fp_out);
2711 struct FgetConv *fc = mutt_ch_fgetconv_open(fp_out, expected_charset,
2713 while ((c = mutt_ch_fgetconv(fc)) != EOF)
2714 {
2715 state_putc(state, c);
2716 if ((c == '\n') && state->prefix)
2717 state_puts(state, state->prefix);
2718 }
2720 }
2721
2722 if (state->flags & STATE_DISPLAY)
2723 {
2724 state_putc(state, '\n');
2725 if (needpass)
2726 state_attach_puts(state, _("[-- END PGP MESSAGE --]\n"));
2727 else if (pgp_keyblock)
2728 state_attach_puts(state, _("[-- END PGP PUBLIC KEY BLOCK --]\n"));
2729 else
2730 state_attach_puts(state, _("[-- END PGP SIGNED MESSAGE --]\n"));
2731 }
2732
2733 // Multiple PGP blocks can exist, so clean these up in each loop
2734 gpgme_data_release(armored_data);
2735 mutt_file_fclose(&fp_out);
2736 }
2737 else
2738 {
2739 /* A traditional PGP part may mix signed and unsigned content */
2740 /* XXX we may wish to recode here */
2741 if (state->prefix)
2742 state_puts(state, state->prefix);
2743 state_puts(state, buf);
2744 }
2745 }
2746 FREE(&gpgcharset);
2747
2748 b->goodsig = (maybe_goodsig && have_any_sigs);
2749
2750 if (needpass == -1)
2751 {
2752 state_attach_puts(state, _("[-- Error: could not find beginning of PGP message --]\n\n"));
2753 return 1;
2754 }
2755 mutt_debug(LL_DEBUG2, "Leaving handler\n");
2756
2757 return err;
2758}
2759
2766int pgp_gpgme_encrypted_handler(struct Body *b, struct State *state)
2767{
2768 int is_signed;
2769 int rc = 0;
2770
2771 mutt_debug(LL_DEBUG2, "Entering handler\n");
2772
2773 FILE *fp_out = mutt_file_mkstemp();
2774 if (!fp_out)
2775 {
2776 mutt_perror(_("Can't create temporary file"));
2777 if (state->flags & STATE_DISPLAY)
2778 {
2779 state_attach_puts(state, _("[-- Error: could not create temporary file --]\n"));
2780 }
2781 return -1;
2782 }
2783
2784 struct Body *tattach = decrypt_part(b, state, fp_out, false, &is_signed);
2785 if (tattach)
2786 {
2787 tattach->goodsig = is_signed > 0;
2788
2789 if (state->flags & STATE_DISPLAY)
2790 {
2791 state_attach_puts(state, is_signed ?
2792 _("[-- The following data is PGP/MIME signed and encrypted --]\n") :
2793 _("[-- The following data is PGP/MIME encrypted --]\n"));
2794 mutt_protected_headers_handler(tattach, state);
2795 }
2796
2797 /* Store any protected headers in the parent so they can be
2798 * accessed for index updates after the handler recursion is done.
2799 * This is done before the handler to prevent a nested encrypted
2800 * handler from freeing the headers. */
2802 b->mime_headers = tattach->mime_headers;
2803 tattach->mime_headers = NULL;
2804
2805 FILE *fp_save = state->fp_in;
2806 state->fp_in = fp_out;
2807 rc = mutt_body_handler(tattach, state);
2808 state->fp_in = fp_save;
2809
2810 /* Embedded multipart signed protected headers override the
2811 * encrypted headers. We need to do this after the handler so
2812 * they can be printed in the pager. */
2813 if (mutt_is_multipart_signed(tattach) && tattach->parts && tattach->parts->mime_headers)
2814 {
2816 b->mime_headers = tattach->parts->mime_headers;
2817 tattach->parts->mime_headers = NULL;
2818 }
2819
2820 /* if a multipart/signed is the _only_ sub-part of a
2821 * multipart/encrypted, cache signature verification
2822 * status. */
2823 if (mutt_is_multipart_signed(tattach) && !tattach->next)
2824 b->goodsig |= tattach->goodsig;
2825
2826 if (state->flags & STATE_DISPLAY)
2827 {
2828 state_attach_puts(state, is_signed ?
2829 _("[-- End of PGP/MIME signed and encrypted data --]\n") :
2830 _("[-- End of PGP/MIME encrypted data --]\n"));
2831 }
2832
2833 mutt_body_free(&tattach);
2834 mutt_message(_("PGP message successfully decrypted"));
2835 }
2836 else
2837 {
2838#ifdef USE_AUTOCRYPT
2839 if (!OptAutocryptGpgme)
2840#endif
2841 {
2842 mutt_error(_("Could not decrypt PGP message"));
2843 }
2844 rc = -1;
2845 }
2846
2847 mutt_file_fclose(&fp_out);
2848 mutt_debug(LL_DEBUG2, "Leaving handler\n");
2849
2850 return rc;
2851}
2852
2856int smime_gpgme_application_handler(struct Body *b, struct State *state)
2857{
2858 int is_signed = 0;
2859 int rc = 0;
2860
2861 mutt_debug(LL_DEBUG2, "Entering handler\n");
2862
2863 /* clear out any mime headers before the handler, so they can't be spoofed. */
2865 b->warnsig = false;
2866 FILE *fp_out = mutt_file_mkstemp();
2867 if (!fp_out)
2868 {
2869 mutt_perror(_("Can't create temporary file"));
2870 if (state->flags & STATE_DISPLAY)
2871 {
2872 state_attach_puts(state, _("[-- Error: could not create temporary file --]\n"));
2873 }
2874 return -1;
2875 }
2876
2877 struct Body *tattach = decrypt_part(b, state, fp_out, true, &is_signed);
2878 if (tattach)
2879 {
2880 tattach->goodsig = is_signed > 0;
2881
2882 if (state->flags & STATE_DISPLAY)
2883 {
2884 state_attach_puts(state, is_signed ?
2885 _("[-- The following data is S/MIME signed --]\n") :
2886 _("[-- The following data is S/MIME encrypted --]\n"));
2887 mutt_protected_headers_handler(tattach, state);
2888 }
2889
2890 /* Store any protected headers in the parent so they can be
2891 * accessed for index updates after the handler recursion is done.
2892 * This is done before the handler to prevent a nested encrypted
2893 * handler from freeing the headers. */
2895 b->mime_headers = tattach->mime_headers;
2896 tattach->mime_headers = NULL;
2897
2898 FILE *fp_save = state->fp_in;
2899 state->fp_in = fp_out;
2900 rc = mutt_body_handler(tattach, state);
2901 state->fp_in = fp_save;
2902
2903 /* Embedded multipart signed protected headers override the
2904 * encrypted headers. We need to do this after the handler so
2905 * they can be printed in the pager. */
2906 if (mutt_is_multipart_signed(tattach) && tattach->parts && tattach->parts->mime_headers)
2907 {
2909 b->mime_headers = tattach->parts->mime_headers;
2910 tattach->parts->mime_headers = NULL;
2911 }
2912
2913 /* if a multipart/signed is the _only_ sub-part of a multipart/encrypted,
2914 * cache signature verification status. */
2915 if (mutt_is_multipart_signed(tattach) && !tattach->next)
2916 {
2917 b->goodsig = tattach->goodsig;
2918 if (!b->goodsig)
2919 b->warnsig = tattach->warnsig;
2920 }
2921 else if (tattach->goodsig)
2922 {
2923 b->goodsig = true;
2924 b->warnsig = tattach->warnsig;
2925 }
2926
2927 if (state->flags & STATE_DISPLAY)
2928 {
2929 state_attach_puts(state, is_signed ? _("[-- End of S/MIME signed data --]\n") :
2930 _("[-- End of S/MIME encrypted data --]\n"));
2931 }
2932
2933 mutt_body_free(&tattach);
2934 }
2935
2936 mutt_file_fclose(&fp_out);
2937 mutt_debug(LL_DEBUG2, "Leaving handler\n");
2938
2939 return rc;
2940}
2941
2948unsigned int key_check_cap(gpgme_key_t key, enum KeyCap cap)
2949{
2950 unsigned int rc = 0;
2951
2952 switch (cap)
2953 {
2955 rc = key->can_encrypt;
2956 if (rc == 0)
2957 {
2958 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2959 {
2960 rc = subkey->can_encrypt;
2961 if (rc != 0)
2962 break;
2963 }
2964 }
2965 break;
2966 case KEY_CAP_CAN_SIGN:
2967 rc = key->can_sign;
2968 if (rc == 0)
2969 {
2970 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2971 {
2972 rc = subkey->can_sign;
2973 if (rc != 0)
2974 break;
2975 }
2976 }
2977 break;
2979 rc = key->can_certify;
2980 if (rc == 0)
2981 {
2982 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2983 {
2984 rc = subkey->can_certify;
2985 if (rc != 0)
2986 break;
2987 }
2988 }
2989 break;
2990 }
2991
2992 return rc;
2993}
2994
3004static char *list_to_pattern(struct ListHead *list)
3005{
3006 char *pattern = NULL, *p = NULL;
3007 const char *s = NULL;
3008 size_t n;
3009
3010 n = 0;
3011 struct ListNode *np = NULL;
3012 STAILQ_FOREACH(np, list, entries)
3013 {
3014 for (s = np->data; *s; s++)
3015 {
3016 if ((*s == '%') || (*s == '+'))
3017 n += 2;
3018 n++;
3019 }
3020 n++; /* delimiter or end of string */
3021 }
3022 n++; /* make sure to allocate at least one byte */
3023 p = mutt_mem_calloc(1, n);
3024 pattern = p;
3025 STAILQ_FOREACH(np, list, entries)
3026 {
3027 s = np->data;
3028 if (*s)
3029 {
3030 if (np != STAILQ_FIRST(list))
3031 *p++ = ' ';
3032 for (s = np->data; *s; s++)
3033 {
3034 if (*s == '%')
3035 {
3036 *p++ = '%';
3037 *p++ = '2';
3038 *p++ = '5';
3039 }
3040 else if (*s == '+')
3041 {
3042 *p++ = '%';
3043 *p++ = '2';
3044 *p++ = 'B';
3045 }
3046 else if (*s == ' ')
3047 {
3048 *p++ = '+';
3049 }
3050 else
3051 {
3052 *p++ = *s;
3053 }
3054 }
3055 }
3056 }
3057 *p = '\0';
3058 return pattern;
3059}
3060
3071static struct CryptKeyInfo *get_candidates(struct ListHead *hints, SecurityFlags app, int secret)
3072{
3073 struct CryptKeyInfo *db = NULL, *k = NULL, **kend = NULL;
3074 gpgme_error_t err = GPG_ERR_NO_ERROR;
3075 gpgme_ctx_t ctx = NULL;
3076 gpgme_key_t key = NULL;
3077 int idx;
3078 gpgme_user_id_t uid = NULL;
3079
3080 char *pattern = list_to_pattern(hints);
3081 if (!pattern)
3082 return NULL;
3083
3084 ctx = create_gpgme_context(0);
3085 db = NULL;
3086 kend = &db;
3087
3088 if ((app & APPLICATION_PGP))
3089 {
3090 /* It's all a mess. That old GPGME expects different things depending on
3091 * the protocol. For gpg we don't need percent escaped pappert but simple
3092 * strings passed in an array to the keylist_ext_start function. */
3093 size_t n = 0;
3094 struct ListNode *np = NULL;
3095 STAILQ_FOREACH(np, hints, entries)
3096 {
3097 if (np->data && *np->data)
3098 n++;
3099 }
3100 if (n == 0)
3101 goto no_pgphints;
3102
3103 char **patarr = mutt_mem_calloc(n + 1, sizeof(*patarr));
3104 n = 0;
3105 STAILQ_FOREACH(np, hints, entries)
3106 {
3107 if (np->data && *np->data)
3108 patarr[n++] = mutt_str_dup(np->data);
3109 }
3110 patarr[n] = NULL;
3111 err = gpgme_op_keylist_ext_start(ctx, (const char **) patarr, secret, 0);
3112 for (n = 0; patarr[n]; n++)
3113 FREE(&patarr[n]);
3114 FREE(&patarr);
3115 if (err != GPG_ERR_NO_ERROR)
3116 {
3117 mutt_error(_("gpgme_op_keylist_start failed: %s"), gpgme_strerror(err));
3118 gpgme_release(ctx);
3119 FREE(&pattern);
3120 return NULL;
3121 }
3122
3123 while ((err = gpgme_op_keylist_next(ctx, &key)) == GPG_ERR_NO_ERROR)
3124 {
3125 KeyFlags flags = KEYFLAG_NO_FLAGS;
3126
3128 flags |= KEYFLAG_CANENCRYPT;
3130 flags |= KEYFLAG_CANSIGN;
3131
3132 if (key->revoked)
3133 flags |= KEYFLAG_REVOKED;
3134 if (key->expired)
3135 flags |= KEYFLAG_EXPIRED;
3136 if (key->disabled)
3137 flags |= KEYFLAG_DISABLED;
3138
3139 for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3140 {
3141 k = mutt_mem_calloc(1, sizeof(*k));
3142 k->kobj = key;
3143 gpgme_key_ref(k->kobj);
3144 k->idx = idx;
3145 k->uid = uid->uid;
3146 k->flags = flags;
3147 if (uid->revoked)
3148 k->flags |= KEYFLAG_REVOKED;
3149 k->validity = uid->validity;
3150 *kend = k;
3151 kend = &k->next;
3152 }
3153 gpgme_key_unref(key);
3154 }
3155 if (gpg_err_code(err) != GPG_ERR_EOF)
3156 mutt_error(_("gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3157 gpgme_op_keylist_end(ctx);
3158 no_pgphints:;
3159 }
3160
3161 if ((app & APPLICATION_SMIME))
3162 {
3163 /* and now look for x509 certificates */
3164 gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS);
3165 err = gpgme_op_keylist_start(ctx, pattern, 0);
3166 if (err != GPG_ERR_NO_ERROR)
3167 {
3168 mutt_error(_("gpgme_op_keylist_start failed: %s"), gpgme_strerror(err));
3169 gpgme_release(ctx);
3170 FREE(&pattern);
3171 return NULL;
3172 }
3173
3174 while ((err = gpgme_op_keylist_next(ctx, &key)) == GPG_ERR_NO_ERROR)
3175 {
3176 KeyFlags flags = KEYFLAG_ISX509;
3177
3179 flags |= KEYFLAG_CANENCRYPT;
3181 flags |= KEYFLAG_CANSIGN;
3182
3183 if (key->revoked)
3184 flags |= KEYFLAG_REVOKED;
3185 if (key->expired)
3186 flags |= KEYFLAG_EXPIRED;
3187 if (key->disabled)
3188 flags |= KEYFLAG_DISABLED;
3189
3190 for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3191 {
3192 k = mutt_mem_calloc(1, sizeof(*k));
3193 k->kobj = key;
3194 gpgme_key_ref(k->kobj);
3195 k->idx = idx;
3196 k->uid = uid->uid;
3197 k->flags = flags;
3198 if (uid->revoked)
3199 k->flags |= KEYFLAG_REVOKED;
3200 k->validity = uid->validity;
3201 *kend = k;
3202 kend = &k->next;
3203 }
3204 gpgme_key_unref(key);
3205 }
3206 if (gpg_err_code(err) != GPG_ERR_EOF)
3207 mutt_error(_("gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3208 gpgme_op_keylist_end(ctx);
3209 }
3210
3211 gpgme_release(ctx);
3212 FREE(&pattern);
3213 return db;
3214}
3215
3224static void crypt_add_string_to_hints(const char *str, struct ListHead *hints)
3225{
3226 char *scratch = mutt_str_dup(str);
3227 if (!scratch)
3228 return;
3229
3230 for (char *t = strtok(scratch, " ,.:\"()<>\n"); t; t = strtok(NULL, " ,.:\"()<>\n"))
3231 {
3232 if (strlen(t) > 3)
3234 }
3235
3236 FREE(&scratch);
3237}
3238
3248static struct CryptKeyInfo *crypt_getkeybyaddr(struct Address *a,
3249 KeyFlags abilities, unsigned int app,
3250 bool *forced_valid, bool oppenc_mode)
3251{
3252 struct ListHead hints = STAILQ_HEAD_INITIALIZER(hints);
3253
3254 int multi = false;
3255 int this_key_has_strong = false;
3256 int this_key_has_addr_match = false;
3257 int match = false;
3258
3259 struct CryptKeyInfo *keys = NULL, *k = NULL;
3260 struct CryptKeyInfo *the_strong_valid_key = NULL;
3261 struct CryptKeyInfo *a_valid_addrmatch_key = NULL;
3262 struct CryptKeyInfo *matches = NULL;
3263 struct CryptKeyInfo **matches_endp = &matches;
3264
3265 if (a && a->mailbox)
3267 if (a && a->personal)
3269
3270 if (!oppenc_mode)
3271 mutt_message(_("Looking for keys matching \"%s\"..."), a ? buf_string(a->mailbox) : "");
3272 keys = get_candidates(&hints, app, (abilities & KEYFLAG_CANSIGN));
3273
3274 mutt_list_free(&hints);
3275
3276 if (!keys)
3277 return NULL;
3278
3279 mutt_debug(LL_DEBUG5, "looking for %s <%s>\n",
3280 a ? buf_string(a->personal) : "", a ? buf_string(a->mailbox) : "");
3281
3282 for (k = keys; k; k = k->next)
3283 {
3284 mutt_debug(LL_DEBUG5, " looking at key: %s '%.15s'\n", crypt_keyid(k), k->uid);
3285
3286 if (abilities && !(k->flags & abilities))
3287 {
3288 mutt_debug(LL_DEBUG2, " insufficient abilities: Has %x, want %x\n", k->flags, abilities);
3289 continue;
3290 }
3291
3292 this_key_has_strong = false; /* strong and valid match */
3293 this_key_has_addr_match = false;
3294 match = false; /* any match */
3295
3296 struct AddressList alist = TAILQ_HEAD_INITIALIZER(alist);
3297 mutt_addrlist_parse(&alist, k->uid);
3298 struct Address *ka = NULL;
3299 TAILQ_FOREACH(ka, &alist, entries)
3300 {
3301 int validity = crypt_id_matches_addr(a, ka, k);
3302
3303 if (validity & CRYPT_KV_MATCH) /* something matches */
3304 {
3305 match = true;
3306
3307 if ((validity & CRYPT_KV_VALID) && (validity & CRYPT_KV_ADDR))
3308 {
3309 if (validity & CRYPT_KV_STRONGID)
3310 {
3311 if (the_strong_valid_key && (the_strong_valid_key->kobj != k->kobj))
3312 multi = true;
3313 this_key_has_strong = true;
3314 }
3315 else
3316 {
3317 this_key_has_addr_match = true;
3318 }
3319 }
3320 }
3321 }
3322 mutt_addrlist_clear(&alist);
3323
3324 if (match)
3325 {
3326 struct CryptKeyInfo *tmp = crypt_copy_key(k);
3327 *matches_endp = tmp;
3328 matches_endp = &tmp->next;
3329
3330 if (this_key_has_strong)
3331 the_strong_valid_key = tmp;
3332 else if (this_key_has_addr_match)
3333 a_valid_addrmatch_key = tmp;
3334 }
3335 }
3336
3337 crypt_key_free(&keys);
3338
3339 if (matches)
3340 {
3341 if (oppenc_mode || !isatty(STDIN_FILENO))
3342 {
3343 const bool c_crypt_opportunistic_encrypt_strong_keys =
3344 cs_subset_bool(NeoMutt->sub, "crypt_opportunistic_encrypt_strong_keys");
3345 if (the_strong_valid_key)
3346 k = crypt_copy_key(the_strong_valid_key);
3347 else if (a_valid_addrmatch_key && !c_crypt_opportunistic_encrypt_strong_keys)
3348 k = crypt_copy_key(a_valid_addrmatch_key);
3349 else
3350 k = NULL;
3351 }
3352 else if (the_strong_valid_key && !multi)
3353 {
3354 /* There was precisely one strong match on a valid ID.
3355 * Proceed without asking the user. */
3356 k = crypt_copy_key(the_strong_valid_key);
3357 }
3358 else
3359 {
3360 /* Else: Ask the user. */
3361 k = dlg_gpgme(matches, a, NULL, app, forced_valid);
3362 }
3363
3364 crypt_key_free(&matches);
3365 }
3366 else
3367 {
3368 k = NULL;
3369 }
3370
3371 return k;
3372}
3373
3382static struct CryptKeyInfo *crypt_getkeybystr(const char *p, KeyFlags abilities,
3383 unsigned int app, bool *forced_valid)
3384{
3385 struct ListHead hints = STAILQ_HEAD_INITIALIZER(hints);
3386 struct CryptKeyInfo *matches = NULL;
3387 struct CryptKeyInfo **matches_endp = &matches;
3388 struct CryptKeyInfo *k = NULL;
3389 const char *ps = NULL, *pl = NULL, *phint = NULL;
3390
3391 mutt_message(_("Looking for keys matching \"%s\"..."), p);
3392
3393 const char *pfcopy = crypt_get_fingerprint_or_id(p, &phint, &pl, &ps);
3394 crypt_add_string_to_hints(phint, &hints);
3395 struct CryptKeyInfo *keys = get_candidates(&hints, app, (abilities & KEYFLAG_CANSIGN));
3396 mutt_list_free(&hints);
3397
3398 if (!keys)
3399 {
3400 FREE(&pfcopy);
3401 return NULL;
3402 }
3403
3404 for (k = keys; k; k = k->next)
3405 {
3406 if (abilities && !(k->flags & abilities))
3407 continue;
3408
3409 mutt_debug(LL_DEBUG5, "matching \"%s\" against key %s, \"%s\": ", p,
3410 crypt_long_keyid(k), k->uid);
3411
3412 if ((*p == '\0') || (pfcopy && mutt_istr_equal(pfcopy, crypt_fpr(k))) ||
3413 (pl && mutt_istr_equal(pl, crypt_long_keyid(k))) ||
3414 (ps && mutt_istr_equal(ps, crypt_short_keyid(k))) || mutt_istr_find(k->uid, p))
3415 {
3416 mutt_debug(LL_DEBUG5, "match\n");
3417
3418 struct CryptKeyInfo *tmp = crypt_copy_key(k);
3419 *matches_endp = tmp;
3420 matches_endp = &tmp->next;
3421 }
3422 else
3423 {
3424 mutt_debug(LL_DEBUG5, "no match\n");
3425 }
3426 }
3427
3428 FREE(&pfcopy);
3429 crypt_key_free(&keys);
3430
3431 if (matches)
3432 {
3433 if (isatty(STDIN_FILENO))
3434 {
3435 k = dlg_gpgme(matches, NULL, p, app, forced_valid);
3436
3437 crypt_key_free(&matches);
3438 return k;
3439 }
3440 else
3441 {
3442 if (crypt_keys_are_valid(matches))
3443 return matches;
3444
3445 crypt_key_free(&matches);
3446 return NULL;
3447 }
3448 }
3449
3450 return NULL;
3451}
3452
3465static struct CryptKeyInfo *crypt_ask_for_key(const char *tag, const char *whatfor,
3466 KeyFlags abilities,
3467 unsigned int app, bool *forced_valid)
3468{
3469 struct CryptKeyInfo *key = NULL;
3470 struct CryptCache *l = NULL;
3471 struct Buffer *resp = buf_pool_get();
3472
3474
3475 if (whatfor)
3476 {
3477 for (l = IdDefaults; l; l = l->next)
3478 {
3479 if (mutt_istr_equal(whatfor, l->what))
3480 {
3481 buf_strcpy(resp, l->dflt);
3482 break;
3483 }
3484 }
3485 }
3486
3487 while (true)
3488 {
3489 buf_reset(resp);
3490 if (mw_get_field(tag, resp, MUTT_COMP_NO_FLAGS, HC_OTHER, NULL, NULL) != 0)
3491 {
3492 goto done;
3493 }
3494
3495 if (whatfor)
3496 {
3497 if (l)
3498 {
3499 mutt_str_replace(&l->dflt, buf_string(resp));
3500 }
3501 else
3502 {
3503 l = mutt_mem_malloc(sizeof(struct CryptCache));
3504 l->next = IdDefaults;
3505 IdDefaults = l;
3506 l->what = mutt_str_dup(whatfor);
3507 l->dflt = buf_strdup(resp);
3508 }
3509 }
3510
3511 key = crypt_getkeybystr(buf_string(resp), abilities, app, forced_valid);
3512 if (key)
3513 goto done;
3514
3515 mutt_error(_("No matching keys found for \"%s\""), buf_string(resp));
3516 }
3517
3518done:
3519 buf_pool_release(&resp);
3520 return key;
3521}
3522
3534static char *find_keys(const struct AddressList *addrlist, unsigned int app, bool oppenc_mode)
3535{
3536 struct ListHead crypt_hook_list = STAILQ_HEAD_INITIALIZER(crypt_hook_list);
3537 struct ListNode *crypt_hook = NULL;
3538 const char *keyid = NULL;
3539 char *keylist = NULL;
3540 size_t keylist_size = 0;
3541 size_t keylist_used = 0;
3542 struct Address *p = NULL;
3543 struct CryptKeyInfo *k_info = NULL;
3544 const char *fqdn = mutt_fqdn(true, NeoMutt->sub);
3545 char buf[1024] = { 0 };
3546 bool forced_valid = false;
3547 bool key_selected;
3548 struct AddressList hookal = TAILQ_HEAD_INITIALIZER(hookal);
3549
3550 struct Address *a = NULL;
3551 const bool c_crypt_confirm_hook = cs_subset_bool(NeoMutt->sub, "crypt_confirm_hook");
3552 TAILQ_FOREACH(a, addrlist, entries)
3553 {
3554 key_selected = false;
3555 mutt_crypt_hook(&crypt_hook_list, a);
3556 crypt_hook = STAILQ_FIRST(&crypt_hook_list);
3557 do
3558 {
3559 p = a;
3560 forced_valid = false;
3561 k_info = NULL;
3562
3563 if (crypt_hook)
3564 {
3565 keyid = crypt_hook->data;
3566 enum QuadOption ans = MUTT_YES;
3567 if (!oppenc_mode && c_crypt_confirm_hook && isatty(STDIN_FILENO))
3568 {
3569 snprintf(buf, sizeof(buf), _("Use keyID = \"%s\" for %s?"), keyid,
3570 buf_string(p->mailbox));
3571 ans = query_yesorno_help(buf, MUTT_YES, NeoMutt->sub, "crypt_confirm_hook");
3572 }
3573 if (ans == MUTT_YES)
3574 {
3575 if (crypt_is_numerical_keyid(keyid))
3576 {
3577 if (mutt_strn_equal(keyid, "0x", 2))
3578 keyid += 2;
3579 goto bypass_selection; /* you don't see this. */
3580 }
3581
3582 /* check for e-mail address */
3583 mutt_addrlist_clear(&hookal);
3584 if (strchr(keyid, '@') && (mutt_addrlist_parse(&hookal, keyid) != 0))
3585 {
3586 mutt_addrlist_qualify(&hookal, fqdn);
3587 p = TAILQ_FIRST(&hookal);
3588 }
3589 else if (!oppenc_mode)
3590 {
3591 k_info = crypt_getkeybystr(keyid, KEYFLAG_CANENCRYPT, app, &forced_valid);
3592 }
3593 }
3594 else if (ans == MUTT_NO)
3595 {
3596 if (key_selected || STAILQ_NEXT(crypt_hook, entries))
3597 {
3598 crypt_hook = STAILQ_NEXT(crypt_hook, entries);
3599 continue;
3600 }
3601 }
3602 else if (ans == MUTT_ABORT)
3603 {
3604 FREE(&keylist);
3605 mutt_addrlist_clear(&hookal);
3606 mutt_list_free(&crypt_hook_list);
3607 return NULL;
3608 }
3609 }
3610
3611 if (!k_info)
3612 {
3613 k_info = crypt_getkeybyaddr(p, KEYFLAG_CANENCRYPT, app, &forced_valid, oppenc_mode);
3614 }
3615
3616 if (!k_info && !oppenc_mode && isatty(STDIN_FILENO))
3617 {
3618 snprintf(buf, sizeof(buf), _("Enter keyID for %s: "), buf_string(p->mailbox));
3619
3620 k_info = crypt_ask_for_key(buf, buf_string(p->mailbox),
3621 KEYFLAG_CANENCRYPT, app, &forced_valid);
3622 }
3623
3624 if (!k_info)
3625 {
3626 FREE(&keylist);
3627 mutt_addrlist_clear(&hookal);
3628 mutt_list_free(&crypt_hook_list);
3629 return NULL;
3630 }
3631
3632 keyid = crypt_fpr_or_lkeyid(k_info);
3633
3634 bypass_selection:
3635 keylist_size += mutt_str_len(keyid) + 4 + 1;
3636 mutt_mem_realloc(&keylist, keylist_size);
3637 sprintf(keylist + keylist_used, "%s0x%s%s", keylist_used ? " " : "",
3638 keyid, forced_valid ? "!" : "");
3639 keylist_used = mutt_str_len(keylist);
3640
3641 key_selected = true;
3642
3643 crypt_key_free(&k_info);
3644 mutt_addrlist_clear(&hookal);
3645
3646 if (crypt_hook)
3647 crypt_hook = STAILQ_NEXT(crypt_hook, entries);
3648
3649 } while (crypt_hook);
3650
3651 mutt_list_free(&crypt_hook_list);
3652 }
3653 return keylist;
3654}
3655
3659char *pgp_gpgme_find_keys(const struct AddressList *addrlist, bool oppenc_mode)
3660{
3661 return find_keys(addrlist, APPLICATION_PGP, oppenc_mode);
3662}
3663
3667char *smime_gpgme_find_keys(const struct AddressList *addrlist, bool oppenc_mode)
3668{
3669 return find_keys(addrlist, APPLICATION_SMIME, oppenc_mode);
3670}
3671
3672#ifdef USE_AUTOCRYPT
3686{
3687 int rc = -1;
3688 gpgme_error_t err = GPG_ERR_NO_ERROR;
3689 gpgme_key_t key = NULL;
3690 gpgme_user_id_t uid = NULL;
3691 struct CryptKeyInfo *results = NULL, *k = NULL;
3692 struct CryptKeyInfo **kend = NULL;
3693 struct CryptKeyInfo *choice = NULL;
3694
3695 gpgme_ctx_t ctx = create_gpgme_context(false);
3696
3697 /* list all secret keys */
3698 if (gpgme_op_keylist_start(ctx, NULL, 1))
3699 goto cleanup;
3700
3701 kend = &results;
3702
3703 while ((err = gpgme_op_keylist_next(ctx, &key)) == GPG_ERR_NO_ERROR)
3704 {
3706
3711
3712 if (key->revoked)
3714 if (key->expired)
3716 if (key->disabled)
3718
3719 int idx;
3720 for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3721 {
3722 k = mutt_mem_calloc(1, sizeof(*k));
3723 k->kobj = key;
3724 gpgme_key_ref(k->kobj);
3725 k->idx = idx;
3726 k->uid = uid->uid;
3727 k->flags = flags;
3728 if (uid->revoked)
3729 k->flags |= KEYFLAG_REVOKED;
3730 k->validity = uid->validity;
3731 *kend = k;
3732 kend = &k->next;
3733 }
3734 gpgme_key_unref(key);
3735 }
3736 if (gpg_err_code(err) != GPG_ERR_EOF)
3737 mutt_error(_("gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3738 gpgme_op_keylist_end(ctx);
3739
3740 if (!results)
3741 {
3742 /* L10N: mutt_gpgme_select_secret_key() tries to list all secret keys to choose
3743 from. This error is displayed if no results were found. */
3744 mutt_error(_("No secret keys found"));
3745 goto cleanup;
3746 }
3747
3748 choice = dlg_gpgme(results, NULL, "*", APPLICATION_PGP, NULL);
3749 if (!(choice && choice->kobj && choice->kobj->subkeys && choice->kobj->subkeys->fpr))
3750 goto cleanup;
3751 buf_strcpy(keyid, choice->kobj->subkeys->fpr);
3752
3753 rc = 0;
3754
3755cleanup:
3756 crypt_key_free(&choice);
3757 crypt_key_free(&results);
3758 gpgme_release(ctx);
3759 return rc;
3760}
3761#endif
3762
3767{
3768 gpgme_ctx_t ctx = NULL;
3769 gpgme_key_t export_keys[2] = { 0 };
3770 gpgme_data_t keydata = NULL;
3771 struct Body *att = NULL;
3772 char buf[1024] = { 0 };
3773
3774 OptPgpCheckTrust = false;
3775
3776 struct CryptKeyInfo *key = crypt_ask_for_key(_("Please enter the key ID: "), NULL,
3778 if (!key)
3779 goto bail;
3780 export_keys[0] = key->kobj;
3781 export_keys[1] = NULL;
3782
3783 ctx = create_gpgme_context(false);
3784 gpgme_set_armor(ctx, 1);
3785 keydata = create_gpgme_data();
3786 gpgme_error_t err = gpgme_op_export_keys(ctx, export_keys, 0, keydata);
3787 if (err != GPG_ERR_NO_ERROR)
3788 {
3789 mutt_error(_("Error exporting key: %s"), gpgme_strerror(err));
3790 goto bail;
3791 }
3792
3793 char *tempf = data_object_to_tempfile(keydata, NULL);
3794 if (!tempf)
3795 goto bail;
3796
3797 att = mutt_body_new();
3798 /* tempf is a newly allocated string, so this is correct: */
3799 att->filename = tempf;
3800 att->unlink = true;
3801 att->use_disp = false;
3802 att->type = TYPE_APPLICATION;
3803 att->subtype = mutt_str_dup("pgp-keys");
3804 /* L10N: MIME description for exported (attached) keys.
3805 You can translate this entry to a non-ASCII string (it will be encoded),
3806 but it may be safer to keep it untranslated. */
3807 snprintf(buf, sizeof(buf), _("PGP Key 0x%s"), crypt_keyid(key));
3808 att->description = mutt_str_dup(buf);
3810
3811 att->length = mutt_file_get_size(tempf);
3812
3813bail:
3814 crypt_key_free(&key);
3815 gpgme_data_release(keydata);
3816 gpgme_release(ctx);
3817
3818 return att;
3819}
3820
3824static void init_common(void)
3825{
3826 /* this initialization should only run one time, but it may be called by
3827 * either pgp_gpgme_init or smime_gpgme_init */
3828 static bool has_run = false;
3829 if (has_run)
3830 return;
3831
3832 gpgme_check_version(NULL);
3833 gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
3834#ifdef ENABLE_NLS
3835 gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
3836#endif
3837 has_run = true;
3838}
3839
3843static void init_pgp(void)
3844{
3845 if (gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP) != GPG_ERR_NO_ERROR)
3846 {
3847 mutt_error(_("GPGME: OpenPGP protocol not available"));
3848 }
3849}
3850
3854static void init_smime(void)
3855{
3856 if (gpgme_engine_check_version(GPGME_PROTOCOL_CMS) != GPG_ERR_NO_ERROR)
3857 {
3858 mutt_error(_("GPGME: CMS protocol not available"));
3859 }
3860}
3861
3866{
3867 init_common();
3868 init_pgp();
3869}
3870
3875{
3876 init_common();
3877 init_smime();
3878}
3879
3886static SecurityFlags gpgme_send_menu(struct Email *e, bool is_smime)
3887{
3888 struct CryptKeyInfo *p = NULL;
3889 const char *prompt = NULL;
3890 const char *letters = NULL;
3891 const char *choices = NULL;
3892 int choice;
3893
3894 if (is_smime)
3896 else
3898
3899 /* Opportunistic encrypt is controlling encryption.
3900 * NOTE: "Signing" and "Clearing" only adjust the sign bit, so we have different
3901 * letter choices for those.
3902 */
3903 const bool c_crypt_opportunistic_encrypt = cs_subset_bool(NeoMutt->sub, "crypt_opportunistic_encrypt");
3904 if (c_crypt_opportunistic_encrypt && (e->security & SEC_OPPENCRYPT))
3905 {
3906 if (is_smime)
3907 {
3908 /* L10N: S/MIME options (opportunistic encryption is on) */
3909 prompt = _("S/MIME (s)ign, sign (a)s, (p)gp, (c)lear, or (o)ppenc mode off?");
3910 /* L10N: S/MIME options (opportunistic encryption is on) */
3911 letters = _("sapco");
3912 choices = "SapCo";
3913 }
3914 else
3915 {
3916 /* L10N: PGP options (opportunistic encryption is on) */
3917 prompt = _("PGP (s)ign, sign (a)s, s/(m)ime, (c)lear, or (o)ppenc mode off?");
3918 /* L10N: PGP options (opportunistic encryption is on) */
3919 letters = _("samco");
3920 choices = "SamCo";
3921 }
3922 }
3923 else if (c_crypt_opportunistic_encrypt)
3924 {
3925 /* Opportunistic encryption option is set, but is toggled off for this message. */
3926 if (is_smime)
3927 {
3928 /* L10N: S/MIME options (opportunistic encryption is off) */
3929 prompt = _("S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp, (c)lear, or (o)ppenc mode?");
3930 /* L10N: S/MIME options (opportunistic encryption is off) */
3931 letters = _("esabpco");
3932 choices = "esabpcO";
3933 }
3934 else
3935 {
3936 /* L10N: PGP options (opportunistic encryption is off) */
3937 prompt = _("PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime, (c)lear, or (o)ppenc mode?");
3938 /* L10N: PGP options (opportunistic encryption is off) */
3939 letters = _("esabmco");
3940 choices = "esabmcO";
3941 }
3942 }
3943 else
3944 {
3945 /* Opportunistic encryption is unset */
3946 if (is_smime)
3947 {
3948 /* L10N: S/MIME options */
3949 prompt = _("S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp or (c)lear?");
3950 /* L10N: S/MIME options */
3951 letters = _("esabpc");
3952 choices = "esabpc";
3953 }
3954 else
3955 {
3956 /* L10N: PGP options */
3957 prompt = _("PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime or (c)lear?");
3958 /* L10N: PGP options */
3959 letters = _("esabmc");
3960 choices = "esabmc";
3961 }
3962 }
3963
3964 choice = mw_multi_choice(prompt, letters);
3965 if (choice > 0)
3966 {
3967 switch (choices[choice - 1])
3968 {
3969 case 'a': /* sign (a)s */
3970 p = crypt_ask_for_key(_("Sign as: "), NULL, KEYFLAG_CANSIGN,
3971 is_smime ? APPLICATION_SMIME : APPLICATION_PGP, NULL);
3972 if (p)
3973 {
3974 char input_signas[128] = { 0 };
3975 snprintf(input_signas, sizeof(input_signas), "0x%s", crypt_fpr_or_lkeyid(p));
3976
3977 if (is_smime)
3978 cs_subset_str_string_set(NeoMutt->sub, "smime_sign_as", input_signas, NULL);
3979 else
3980 cs_subset_str_string_set(NeoMutt->sub, "pgp_sign_as", input_signas, NULL);
3981
3982 crypt_key_free(&p);
3983
3984 e->security |= SEC_SIGN;
3985 }
3986 break;
3987
3988 case 'b': /* (b)oth */
3989 e->security |= (SEC_ENCRYPT | SEC_SIGN);
3990 break;
3991
3992 case 'C':
3993 e->security &= ~SEC_SIGN;
3994 break;
3995
3996 case 'c': /* (c)lear */
3997 e->security &= ~(SEC_ENCRYPT | SEC_SIGN);
3998 break;
3999
4000 case 'e': /* (e)ncrypt */
4001 e->security |= SEC_ENCRYPT;
4002 e->security &= ~SEC_SIGN;
4003 break;
4004
4005 case 'm': /* (p)gp or s/(m)ime */
4006 case 'p':
4007 is_smime = !is_smime;
4008 if (is_smime)
4009 {
4010 e->security &= ~APPLICATION_PGP;
4012 }
4013 else
4014 {
4015 e->security &= ~APPLICATION_SMIME;
4017 }
4019 break;
4020
4021 case 'O': /* oppenc mode on */
4024 break;
4025
4026 case 'o': /* oppenc mode off */
4027 e->security &= ~SEC_OPPENCRYPT;
4028 break;
4029
4030 case 'S': /* (s)ign in oppenc mode */
4031 e->security |= SEC_SIGN;
4032 break;
4033
4034 case 's': /* (s)ign */
4035 e->security &= ~SEC_ENCRYPT;
4036 e->security |= SEC_SIGN;
4037 break;
4038 }
4039 }
4040
4041 return e->security;
4042}
4043
4048{
4049 return gpgme_send_menu(e, false);
4050}
4051
4056{
4057 return gpgme_send_menu(e, true);
4058}
4059
4065static bool verify_sender(struct Email *e)
4066{
4067 struct Address *sender = NULL;
4068 bool rc = true;
4069
4070 if (!TAILQ_EMPTY(&e->env->from))
4071 {
4073 sender = TAILQ_FIRST(&e->env->from);
4074 }
4075 else if (!TAILQ_EMPTY(&e->env->sender))
4076 {
4078 sender = TAILQ_FIRST(&e->env->sender);
4079 }
4080
4081 if (sender)
4082 {
4083 if (SignatureKey)
4084 {
4085 gpgme_key_t key = SignatureKey;
4086 gpgme_user_id_t uid = NULL;
4087 int sender_length = buf_len(sender->mailbox);
4088 for (uid = key->uids; uid && rc; uid = uid->next)
4089 {
4090 int uid_length = strlen(uid->email);
4091 if ((uid->email[0] == '<') && (uid->email[uid_length - 1] == '>') &&
4092 (uid_length == (sender_length + 2)))
4093 {
4094 const char *at_sign = strchr(uid->email + 1, '@');
4095 if (at_sign)
4096 {
4097 /* Assume address is 'mailbox@domainname'.
4098 * The mailbox part is case-sensitive,
4099 * the domainname is not. (RFC2821) */
4100 const char *tmp_email = uid->email + 1;
4101 const char *tmp_sender = buf_string(sender->mailbox);
4102 /* length of mailbox part including '@' */
4103 int mailbox_length = at_sign - tmp_email + 1;
4104 int domainname_length = sender_length - mailbox_length;
4105 int mailbox_match, domainname_match;
4106
4107 mailbox_match = mutt_strn_equal(tmp_email, tmp_sender, mailbox_length);
4108 tmp_email += mailbox_length;
4109 tmp_sender += mailbox_length;
4110 domainname_match = (mutt_istrn_cmp(tmp_email, tmp_sender, domainname_length) == 0);
4111 if (mailbox_match && domainname_match)
4112 rc = false;
4113 }
4114 else
4115 {
4116 if (mutt_strn_equal(uid->email + 1, buf_string(sender->mailbox), sender_length))
4117 rc = false;
4118 }
4119 }
4120 }
4121 }
4122 else
4123 {
4124 mutt_any_key_to_continue(_("Failed to verify sender"));
4125 }
4126 }
4127 else
4128 {
4129 mutt_any_key_to_continue(_("Failed to figure out sender"));
4130 }
4131
4132 if (SignatureKey)
4133 {
4134 gpgme_key_unref(SignatureKey);
4135 SignatureKey = NULL;
4136 }
4137
4138 return rc;
4139}
4140
4144int smime_gpgme_verify_sender(struct Email *e, struct Message *msg)
4145{
4146 return verify_sender(e);
4147}
4148
4152void pgp_gpgme_set_sender(const char *sender)
4153{
4154 mutt_debug(LL_DEBUG2, "setting to: %s\n", sender);
4156 CurrentSender = mutt_str_dup(sender);
4157}
4158
4164{
4165 return GPGME_VERSION;
4166}
void mutt_addrlist_qualify(struct AddressList *al, const char *host)
Expand local names in an Address list using a hostname.
Definition: address.c:680
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1460
int mutt_addrlist_parse(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:480
Email Address Handling.
Email Aliases.
void mutt_expand_aliases(struct AddressList *al)
Expand aliases in a List of Addresses.
Definition: alias.c:295
GUI display the mailboxes in a side panel.
char * AutocryptSignAs
Autocrypt Key id to sign as.
Definition: config.c:37
Autocrypt end-to-end encryption.
bool buf_istr_equal(const struct Buffer *a, const struct Buffer *b)
Return if two buffers are equal, case insensitive.
Definition: buffer.c:697
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:491
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:241
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:571
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
const char * cs_subset_path(const struct ConfigSubset *sub, const char *name)
Get a path config item by name.
Definition: helpers.c:168
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
Convenience wrapper for the config headers.
const char * cc_charset(void)
Get the cached value of $charset.
Definition: config_cache.c:116
Convenience wrapper for the core headers.
void crypt_opportunistic_encrypt(struct Email *e)
Can all recipients be determined.
Definition: crypt.c:1045
bool crypt_is_numerical_keyid(const char *s)
Is this a numerical keyid.
Definition: crypt.c:1469
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
Definition: crypt.c:408
SecurityFlags mutt_is_application_smime(struct Body *b)
Does the message use S/MIME?
Definition: crypt.c:609
int mutt_is_valid_multipart_pgp_encrypted(struct Body *b)
Is this a valid multi-part encrypted message?
Definition: crypt.c:467
const char * crypt_get_fingerprint_or_id(const char *p, const char **pphint, const char **ppl, const char **pps)
Get the fingerprint or long key ID.
Definition: crypt.c:1380
SecurityFlags mutt_is_malformed_multipart_pgp_encrypted(struct Body *b)
Check for malformed layout.
Definition: crypt.c:504
void crypt_convert_to_7bit(struct Body *b)
Convert an email to 7bit encoding.
Definition: crypt.c:809
SecurityFlags mutt_is_application_pgp(const struct Body *b)
Does the message use PGP?
Definition: crypt.c:548
Signing/encryption multiplexor.
static const char * crypt_short_keyid(struct CryptKeyInfo *k)
Get the short keyID for a key.
Definition: crypt_gpgme.c:180
static gpgme_error_t set_pka_sig_notation(gpgme_ctx_t ctx)
Set the signature notation.
Definition: crypt_gpgme.c:761
static struct CryptKeyInfo * crypt_getkeybyaddr(struct Address *a, KeyFlags abilities, unsigned int app, bool *forced_valid, bool oppenc_mode)
Find a key by email address.
Definition: crypt_gpgme.c:3248
static char * find_keys(const struct AddressList *addrlist, unsigned int app, bool oppenc_mode)
Find keys of the recipients of the message.
Definition: crypt_gpgme.c:3534
static bool verify_sender(struct Email *e)
Verify the sender of a message.
Definition: crypt_gpgme.c:4065
static void init_common(void)
Initialise code common to PGP and SMIME parts of GPGME.
Definition: crypt_gpgme.c:3824
static struct CryptCache * IdDefaults
Cache of GPGME keys.
Definition: crypt_gpgme.c:92
struct CryptKeyInfo * crypt_copy_key(struct CryptKeyInfo *key)
Return a copy of KEY.
Definition: crypt_gpgme.c:234
#define CRYPT_KV_STRING
Definition: crypt_gpgme.c:76
static int verify_one(struct Body *b, struct State *state, const char *tempfile, bool is_smime)
Do the actual verification step.
Definition: crypt_gpgme.c:1581
static char * CurrentSender
Email address of the sender.
Definition: crypt_gpgme.c:96
int mutt_gpgme_select_secret_key(struct Buffer *keyid)
Select a private Autocrypt key for a new account.
Definition: crypt_gpgme.c:3685
const char * mutt_gpgme_print_version(void)
Get version of GPGME.
Definition: crypt_gpgme.c:4163
static void show_encryption_info(struct State *state, gpgme_decrypt_result_t result)
Show encryption information.
Definition: crypt_gpgme.c:1433
static gpgme_data_t body_to_data_object(struct Body *b, bool convert)
Create GPGME object from the mail body.
Definition: crypt_gpgme.c:419
int crypt_id_is_valid(struct CryptKeyInfo *key)
Is key ID valid.
Definition: crypt_gpgme.c:310
static gpgme_data_t create_gpgme_data(void)
Create a new GPGME data object.
Definition: crypt_gpgme.c:400
static int show_sig_summary(unsigned long sum, gpgme_ctx_t ctx, gpgme_key_t key, int idx, struct State *state, gpgme_signature_t sig)
Show a signature summary.
Definition: crypt_gpgme.c:1133
static void show_fingerprint(gpgme_key_t key, struct State *state)
Write a key's fingerprint.
Definition: crypt_gpgme.c:1257
gpgme_ctx_t create_gpgme_context(bool for_smime)
Create a new GPGME context.
Definition: crypt_gpgme.c:361
static void create_recipient_string(const char *keylist, struct Buffer *recpstring, int use_smime)
Create a string of recipients.
Definition: crypt_gpgme.c:622
static struct CryptKeyInfo * crypt_getkeybystr(const char *p, KeyFlags abilities, unsigned int app, bool *forced_valid)
Find a key by string.
Definition: crypt_gpgme.c:3382
static void print_smime_keyinfo(const char *msg, gpgme_signature_t sig, gpgme_key_t key, struct State *state)
Print key info about an SMIME key.
Definition: crypt_gpgme.c:1351
static int crypt_id_matches_addr(struct Address *addr, struct Address *u_addr, struct CryptKeyInfo *key)
Does the key ID match the address.
Definition: crypt_gpgme.c:328
bool crypt_id_is_strong(struct CryptKeyInfo *key)
Is the key strong.
Definition: crypt_gpgme.c:275
static void crypt_add_string_to_hints(const char *str, struct ListHead *hints)
Split a string and add the parts to a List.
Definition: crypt_gpgme.c:3224
const char * crypt_fpr_or_lkeyid(struct CryptKeyInfo *k)
Find the fingerprint of a key.
Definition: crypt_gpgme.c:214
static char * encrypt_gpgme_object(gpgme_data_t plaintext, char *keylist, bool use_smime, bool combined_signed, const struct AddressList *from)
Encrypt the GPGPME data object.
Definition: crypt_gpgme.c:781
static void show_one_recipient(struct State *state, gpgme_recipient_t r)
Show information about one encryption recipient.
Definition: crypt_gpgme.c:1417
#define BEGIN_PGP_SIGNATURE(_y)
Definition: crypt_gpgme.c:104
#define SIGNED_MESSAGE(_y)
Definition: crypt_gpgme.c:102
#define PKA_NOTATION_NAME
Definition: crypt_gpgme.c:98
static char * list_to_pattern(struct ListHead *list)
Convert STailQ to GPGME-compatible pattern.
Definition: crypt_gpgme.c:3004
#define CRYPT_KV_VALID
Definition: crypt_gpgme.c:74
static int get_micalg(gpgme_ctx_t ctx, int use_smime, char *buf, size_t buflen)
Find the "micalg" parameter from the last GPGME operation.
Definition: crypt_gpgme.c:853
static int data_object_to_stream(gpgme_data_t data, FILE *fp)
Write a GPGME data object to a file.
Definition: crypt_gpgme.c:514
static int pgp_check_traditional_one_body(FILE *fp, struct Body *b)
Check one inline PGP body part.
Definition: crypt_gpgme.c:2213
static const char * crypt_long_keyid(struct CryptKeyInfo *k)
Find the Long ID for the key.
Definition: crypt_gpgme.c:163
#define CRYPT_KV_STRONGID
Definition: crypt_gpgme.c:77
static struct CryptKeyInfo * get_candidates(struct ListHead *hints, SecurityFlags app, int secret)
Get a list of keys which are candidates for the selection.
Definition: crypt_gpgme.c:3071
static gpgme_data_t file_to_data_object(FILE *fp, long offset, size_t length)
Create GPGME data object from file.
Definition: crypt_gpgme.c:493
static struct Body * decrypt_part(struct Body *b, struct State *state, FILE *fp_out, bool is_smime, int *r_is_signed)
Decrypt a PGP or SMIME message.
Definition: crypt_gpgme.c:1732
#define PUBLIC_KEY_BLOCK(_y)
Definition: crypt_gpgme.c:103
static int set_signer(gpgme_ctx_t ctx, const struct AddressList *al, bool for_smime)
Make sure that the correct signer is set.
Definition: crypt_gpgme.c:717
static char * data_object_to_tempfile(gpgme_data_t data, FILE **fp_ret)
Copy a data object to a temporary file.
Definition: crypt_gpgme.c:563
static void show_one_sig_validity(gpgme_ctx_t ctx, int idx, struct State *state)
Show the validity of a key used for one signature.
Definition: crypt_gpgme.c:1312
static void init_smime(void)
Initialise the SMIME crypto backend.
Definition: crypt_gpgme.c:3854
static struct CryptKeyInfo * crypt_ask_for_key(const char *tag, const char *whatfor, KeyFlags abilities, unsigned int app, bool *forced_valid)
Ask the user for a key.
Definition: crypt_gpgme.c:3465
unsigned int key_check_cap(gpgme_key_t key, enum KeyCap cap)
Check the capabilities of a key.
Definition: crypt_gpgme.c:2948
static const char * crypt_fpr(struct CryptKeyInfo *k)
Get the hexstring fingerprint from a key.
Definition: crypt_gpgme.c:199
const char * crypt_keyid(struct CryptKeyInfo *k)
Find the ID for the key.
Definition: crypt_gpgme.c:138
static SecurityFlags gpgme_send_menu(struct Email *e, bool is_smime)
Show the user the encryption/signing menu.
Definition: crypt_gpgme.c:3886
#define CRYPT_KV_ADDR
Definition: crypt_gpgme.c:75
static struct Body * sign_message(struct Body *b, const struct AddressList *from, bool use_smime)
Sign a message.
Definition: crypt_gpgme.c:906
static bool is_pka_notation(gpgme_sig_notation_t notation)
Is this the standard pka email address.
Definition: crypt_gpgme.c:112
static void redraw_if_needed(gpgme_ctx_t ctx)
Accommodate for a redraw if needed.
Definition: crypt_gpgme.c:121
static int pgp_gpgme_extract_keys(gpgme_data_t keydata, FILE **fp)
Write PGP keys to a file.
Definition: crypt_gpgme.c:2112
static int line_compare(const char *a, size_t n, const char *b)
Compare two strings ignore line endings.
Definition: crypt_gpgme.c:2195
static gpgme_key_t SignatureKey
PGP Key to sign with.
Definition: crypt_gpgme.c:94
static void crypt_key_free(struct CryptKeyInfo **keylist)
Release all the keys in a list.
Definition: crypt_gpgme.c:253
static bool set_signer_from_address(gpgme_ctx_t ctx, const char *address, bool for_smime)
Try to set the context's signer from the address.
Definition: crypt_gpgme.c:658
#define CRYPT_KV_MATCH
Definition: crypt_gpgme.c:78
static void init_pgp(void)
Initialise the PGP crypto backend.
Definition: crypt_gpgme.c:3843
static void copy_clearsigned(gpgme_data_t data, struct State *state, char *charset)
Copy a clearsigned message.
Definition: crypt_gpgme.c:2414
static int show_one_sig_status(gpgme_ctx_t ctx, int idx, struct State *state)
Show information about one signature.
Definition: crypt_gpgme.c:1458
static void print_time(time_t t, struct State *state)
Print the date/time according to the locale.
Definition: crypt_gpgme.c:891
#define MESSAGE(_y)
Definition: crypt_gpgme.c:101
Wrapper for PGP/SMIME calls to GPGME.
KeyCap
PGP/SMIME Key Capabilities.
Definition: crypt_gpgme.h:75
@ KEY_CAP_CAN_CERTIFY
Key can be used to certify.
Definition: crypt_gpgme.h:78
@ KEY_CAP_CAN_ENCRYPT
Key can be used for encryption.
Definition: crypt_gpgme.h:76
@ KEY_CAP_CAN_SIGN
Key can be used for signing.
Definition: crypt_gpgme.h:77
int mutt_any_key_to_continue(const char *s)
Prompt the user to 'press any key' and wait.
Definition: curs_lib.c:173
void mutt_need_hard_redraw(void)
Force a hard refresh.
Definition: curs_lib.c:100
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:443
Edit a string.
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:58
struct Body * mutt_body_new(void)
Create a new Body.
Definition: body.c:44
char * mutt_body_get_charset(struct Body *b, char *buf, size_t buflen)
Get a body's character set.
Definition: body.c:133
Structs that make up an email.
void mutt_parse_part(FILE *fp, struct Body *b)
Parse a MIME part.
Definition: parse.c:1822
struct Body * mutt_read_mime_header(FILE *fp, bool digest)
Parse a MIME header.
Definition: parse.c:1362
void mutt_env_free(struct Envelope **ptr)
Free an Envelope.
Definition: envelope.c:126
long mutt_file_get_size_fp(FILE *fp)
Get the size of a file.
Definition: file.c:1537
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
Definition: file.c:778
long mutt_file_get_size(const char *path)
Get the size of a file.
Definition: file.c:1519
#define mutt_file_fclose(FP)
Definition: file.h:149
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:148
bool OptAutocryptGpgme
(pseudo) use Autocrypt context inside ncrypt/crypt_gpgme.c
Definition: globals.c:62
bool OptPgpCheckTrust
(pseudo) used by dlg_pgp()
Definition: globals.c:73
bool crypt_keys_are_valid(struct CryptKeyInfo *keys)
Are all these keys valid?
Gpgme functions.
int pgp_gpgme_application_handler(struct Body *b, struct State *state)
Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::applicat...
Definition: crypt_gpgme.c:2470
int smime_gpgme_application_handler(struct Body *b, struct State *state)
Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::applicat...
Definition: crypt_gpgme.c:2856
int smime_gpgme_decrypt_mime(FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **b_dec)
Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.
Definition: crypt_gpgme.c:1993
int pgp_gpgme_decrypt_mime(FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **b_dec)
Decrypt an encrypted MIME part - Implements CryptModuleSpecs::decrypt_mime() -.
Definition: crypt_gpgme.c:1896
int pgp_gpgme_encrypted_handler(struct Body *b, struct State *state)
Manage a PGP or S/MIME encrypted MIME part - Implements CryptModuleSpecs::encrypted_handler() -.
Definition: crypt_gpgme.c:2766
char * smime_gpgme_find_keys(const struct AddressList *addrlist, bool oppenc_mode)
Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.
Definition: crypt_gpgme.c:3667
char * pgp_gpgme_find_keys(const struct AddressList *addrlist, bool oppenc_mode)
Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.
Definition: crypt_gpgme.c:3659
void smime_gpgme_init(void)
Initialise the crypto module - Implements CryptModuleSpecs::init() -.
Definition: crypt_gpgme.c:3874
void pgp_gpgme_init(void)
Initialise the crypto module - Implements CryptModuleSpecs::init() -.
Definition: crypt_gpgme.c:3865
bool pgp_gpgme_check_traditional(FILE *fp, struct Body *b, bool just_one)
Look for inline (non-MIME) PGP content - Implements CryptModuleSpecs::pgp_check_traditional() -.
Definition: crypt_gpgme.c:2278
struct Body * pgp_gpgme_encrypt_message(struct Body *b, char *keylist, bool sign, const struct AddressList *from)
PGP encrypt an email - Implements CryptModuleSpecs::pgp_encrypt_message() -.
Definition: crypt_gpgme.c:1043
void pgp_gpgme_invoke_import(const char *fname)
Import a key from a message into the user's public key ring - Implements CryptModuleSpecs::pgp_invoke...
Definition: crypt_gpgme.c:2305
struct Body * pgp_gpgme_make_key_attachment(void)
Generate a public key attachment - Implements CryptModuleSpecs::pgp_make_key_attachment() -.
Definition: crypt_gpgme.c:3766
SecurityFlags pgp_gpgme_send_menu(struct Email *e)
Ask the user whether to sign and/or encrypt the email - Implements CryptModuleSpecs::send_menu() -.
Definition: crypt_gpgme.c:4047
SecurityFlags smime_gpgme_send_menu(struct Email *e)
Ask the user whether to sign and/or encrypt the email - Implements CryptModuleSpecs::send_menu() -.
Definition: crypt_gpgme.c:4055
void pgp_gpgme_set_sender(const char *sender)
Set the sender of the email - Implements CryptModuleSpecs::set_sender() -.
Definition: crypt_gpgme.c:4152
struct Body * smime_gpgme_sign_message(struct Body *b, const struct AddressList *from)
Cryptographically sign the Body of a message - Implements CryptModuleSpecs::sign_message() -.
Definition: crypt_gpgme.c:1035
struct Body * pgp_gpgme_sign_message(struct Body *b, const struct AddressList *from)
Cryptographically sign the Body of a message - Implements CryptModuleSpecs::sign_message() -.
Definition: crypt_gpgme.c:1027
struct Body * smime_gpgme_build_smime_entity(struct Body *b, char *keylist)
Encrypt the email body to all recipients - Implements CryptModuleSpecs::smime_build_smime_entity() -.
Definition: crypt_gpgme.c:1089
int smime_gpgme_verify_sender(struct Email *e, struct Message *msg)
Does the sender match the certificate? - Implements CryptModuleSpecs::smime_verify_sender() -.
Definition: crypt_gpgme.c:4144
int pgp_gpgme_verify_one(struct Body *b, struct State *state, const char *tempfile)
Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.
Definition: crypt_gpgme.c:1706
int smime_gpgme_verify_one(struct Body *b, struct State *state, const char *tempfile)
Check a signed MIME part against a signature - Implements CryptModuleSpecs::verify_one() -.
Definition: crypt_gpgme.c:1714
struct CryptKeyInfo * dlg_gpgme(struct CryptKeyInfo *keys, struct Address *p, const char *s, unsigned int app, bool *forced_valid)
Get the user to select a key -.
Definition: dlg_gpgme.c:636
int mw_get_field(const char *prompt, struct Buffer *buf, CompletionFlags complete, enum HistoryClass hclass, const struct CompleteOps *comp_api, void *cdata)
Ask the user for a string -.
Definition: window.c:274
int mw_multi_choice(const char *prompt, const char *letters)
Offer the user a multiple choice question -.
Definition: question.c:63
int mutt_protected_headers_handler(struct Body *b_email, struct State *state)
Handler for protected headers - Implements handler_t -.
Definition: crypt.c:1117
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_message(...)
Definition: logging2.h:91
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
#define mutt_perror(...)
Definition: logging2.h:93
Convenience wrapper for the gui headers.
int mutt_body_handler(struct Body *b, struct State *state)
Handler for the Body of an email.
Definition: handler.c:1631
void mutt_decode_attachment(const struct Body *b, struct State *state)
Decode an email's attachment.
Definition: handler.c:1905
Decide how to display email content.
int mutt_write_mime_header(struct Body *b, FILE *fp, struct ConfigSubset *sub)
Create a MIME header.
Definition: header.c:756
Read/write command history from/to a file.
@ HC_OTHER
Miscellaneous strings.
Definition: lib.h:56
void mutt_crypt_hook(struct ListHead *list, struct Address *addr)
Find crypto hooks for an Address.
Definition: hook.c:870
Parse and execute user-defined hooks.
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:65
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:123
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
void mutt_exit(int code)
Leave NeoMutt NOW.
Definition: main.c:269
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:51
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:91
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:115
#define FREE(x)
Definition: memory.h:45
@ ENC_7BIT
7-bit text
Definition: mime.h:49
@ ENC_BASE64
Base-64 encoded text.
Definition: mime.h:52
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
@ TYPE_APPLICATION
Type: 'application/*'.
Definition: mime.h:33
@ TYPE_TEXT
Type: 'text/*'.
Definition: mime.h:38
@ DISP_ATTACH
Content is attached.
Definition: mime.h:63
@ DISP_INLINE
Content is inline.
Definition: mime.h:62
@ DISP_NONE
No preferred disposition.
Definition: mime.h:65
#define is_multipart(body)
Definition: mime.h:82
void mutt_generate_boundary(struct ParameterList *pl)
Create a unique boundary id for a MIME part.
Definition: multipart.c:86
bool mutt_ch_check_charset(const char *cs, bool strict)
Does iconv understand a character set?
Definition: charset.c:894
int mutt_ch_fgetconv(struct FgetConv *fc)
Convert a file's character set.
Definition: charset.c:983
struct FgetConv * mutt_ch_fgetconv_open(FILE *fp, const char *from, const char *to, uint8_t flags)
Prepare a file for charset conversion.
Definition: charset.c:933
char * mutt_ch_fgetconvs(char *buf, size_t buflen, struct FgetConv *fc)
Convert a file's charset into a string buffer.
Definition: charset.c:1045
void mutt_ch_fgetconv_close(struct FgetConv **ptr)
Close an fgetconv handle.
Definition: charset.c:965
#define MUTT_ICONV_HOOK_FROM
apply charset-hooks to fromcode
Definition: charset.h:74
size_t mutt_date_localtime_format(char *buf, size_t buflen, const char *format, time_t t)
Format localtime.
Definition: date.c:951
Convenience wrapper for the library headers.
#define _(a)
Definition: message.h:28
void state_attach_puts(struct State *state, const char *t)
Write a string to the state.
Definition: state.c:103
int state_printf(struct State *state, const char *fmt,...)
Write a formatted string to the State.
Definition: state.c:186
#define state_puts(STATE, STR)
Definition: state.h:58
#define STATE_DISPLAY
Output is displayed to the user.
Definition: state.h:33
#define state_putc(STATE, STR)
Definition: state.h:59
#define STATE_VERIFY
Perform signature verification.
Definition: state.h:34
#define STATE_NO_FLAGS
No flags are set.
Definition: state.h:32
int mutt_istrn_cmp(const char *a, const char *b, size_t num)
Compare two strings ignoring case (to a maximum), safely.
Definition: string.c:439
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:672
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
char * mutt_str_lower(char *str)
Convert all characters in the string to lowercase.
Definition: string.c:313
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
Definition: string.c:425
const char * mutt_istr_find(const char *haystack, const char *needle)
Find first occurrence of string (ignoring case)
Definition: string.c:521
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:230
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:581
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:280
Many unsorted constants and some structs.
#define MUTT_COMP_NO_FLAGS
No flags are set.
Definition: mutt.h:56
int mutt_decode_save_attachment(FILE *fp, struct Body *b, const char *path, StateFlags flags, enum SaveAttach opt)
Decode, then save an attachment.
Definition: mutt_attach.c:1041
@ MUTT_SAVE_NO_FLAGS
No flags set.
Definition: mutt_attach.h:58
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
NeoMutt Logging.
#define KEYFLAG_EXPIRED
Key is expired.
Definition: lib.h:131
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: lib.h:76
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:86
#define KEYFLAG_ISX509
Key is an X.509 key.
Definition: lib.h:129
uint16_t KeyFlags
Flags describing PGP/SMIME keys, e.g. KEYFLAG_CANSIGN.
Definition: lib.h:125
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
#define KEYFLAG_CANENCRYPT
Key is suitable for encryption.
Definition: lib.h:128
#define KEYFLAG_CANTUSE
Definition: lib.h:139
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:91
#define KEYFLAG_NO_FLAGS
No flags are set.
Definition: lib.h:126
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:77
#define KEYFLAG_DISABLED
Key is marked disabled.
Definition: lib.h:133
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:78
#define KEYFLAG_REVOKED
Key is revoked.
Definition: lib.h:132
#define SEC_SIGN
Email is signed.
Definition: lib.h:79
#define KEYFLAG_CANSIGN
Key is suitable for signing.
Definition: lib.h:127
void mutt_param_set(struct ParameterList *pl, const char *attribute, const char *value)
Set a Parameter.
Definition: parameter.c:111
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition: quad.h:37
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition: quad.h:38
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
Ask the user a question.
enum QuadOption query_yesorno_help(const char *prompt, enum QuadOption def, struct ConfigSubset *sub, const char *name)
Ask the user a Yes/No question offering help.
Definition: question.c:341
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
#define STAILQ_FIRST(head)
Definition: queue.h:350
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:637
#define TAILQ_EMPTY(head)
Definition: queue.h:721
#define STAILQ_NEXT(elm, field)
Definition: queue.h:400
int mutt_write_mime_body(struct Body *b, FILE *fp, struct ConfigSubset *sub)
Write a MIME part.
Definition: body.c:300
Convenience wrapper for the send headers.
void mutt_update_encoding(struct Body *b, struct ConfigSubset *sub)
Update the encoding type.
Definition: sendlib.c:422
const char * mutt_fqdn(bool may_hide_host, const struct ConfigSubset *sub)
Get the Fully-Qualified Domain Name.
Definition: sendlib.c:707
GUI display the mailboxes in a side panel.
Key value store.
#define NONULL(x)
Definition: string2.h:37
An email address.
Definition: address.h:36
struct Buffer * personal
Real name of address.
Definition: address.h:37
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
The body of an email.
Definition: body.h:36
char * d_filename
filename to be used for the content-disposition header If NULL, filename is used instead.
Definition: body.h:56
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:73
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
bool unlink
If true, filename should be unlink()ed before free()ing this structure.
Definition: body.h:68
bool badsig
Bad cryptographic signature (needed to check encrypted s/mime-signatures)
Definition: body.h:43
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:76
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:63
bool use_disp
Content-Disposition uses filename= ?
Definition: body.h:47
char * description
content-description
Definition: body.h:55
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
struct Body * next
next attachment in the list
Definition: body.h:72
char * subtype
content-type subtype
Definition: body.h:61
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
bool goodsig
Good cryptographic signature.
Definition: body.h:45
bool warnsig
Maybe good signature.
Definition: body.h:48
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:59
String manipulation buffer.
Definition: buffer.h:36
char * data
Pointer to data.
Definition: buffer.h:37
Internal cache for GPGME.
Definition: crypt_gpgme.c:85
char * what
Definition: crypt_gpgme.c:86
char * dflt
Definition: crypt_gpgme.c:87
struct CryptCache * next
Definition: crypt_gpgme.c:88
A stored PGP key.
Definition: crypt_gpgme.h:44
gpgme_validity_t validity
uid validity (cached for convenience)
Definition: crypt_gpgme.h:50
KeyFlags flags
global and per uid flags (for convenience)
Definition: crypt_gpgme.h:49
int idx
and the user ID at this index
Definition: crypt_gpgme.h:47
struct CryptKeyInfo * next
Linked list.
Definition: crypt_gpgme.h:45
const char * uid
and for convenience point to this user ID
Definition: crypt_gpgme.h:48
gpgme_key_t kobj
Definition: crypt_gpgme.h:46
The envelope/body of an email.
Definition: email.h:39
struct Envelope * env
Envelope information.
Definition: email.h:68
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:43
struct AddressList sender
Email's sender.
Definition: envelope.h:63
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
Cursor for converting a file's encoding.
Definition: charset.h:43
FILE * fp
Definition: charset.h:44
A List node for strings.
Definition: list.h:37
char * data
String.
Definition: list.h:38
A local copy of an email.
Definition: message.h:34
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
Keep track when processing files.
Definition: state.h:48
StateFlags flags
Flags, e.g. STATE_DISPLAY.
Definition: state.h:52
FILE * fp_out
File to write to.
Definition: state.h:50
FILE * fp_in
File to read from.
Definition: state.h:49
const char * prefix
String to add to the beginning of each output line.
Definition: state.h:51
int cs_subset_str_string_set(const struct ConfigSubset *sub, const char *name, const char *value, struct Buffer *err)
Set a config item by string.
Definition: subset.c:386
#define buf_mktemp(buf)
Definition: tmp.h:33
#define mutt_file_mkstemp()
Definition: tmp.h:36