73#define CRYPT_KV_VALID (1 << 0)
74#define CRYPT_KV_ADDR (1 << 1)
75#define CRYPT_KV_STRING (1 << 2)
76#define CRYPT_KV_STRONGID (1 << 3)
77#define CRYPT_KV_MATCH (CRYPT_KV_ADDR | CRYPT_KV_STRING)
97#define PKA_NOTATION_NAME "pka-address@gnupg.org"
99#define _LINE_COMPARE(_x, _y) line_compare(_x, sizeof(_x) - 1, _y)
100#define MESSAGE(_y) _LINE_COMPARE("MESSAGE-----", _y)
101#define SIGNED_MESSAGE(_y) _LINE_COMPARE("SIGNED MESSAGE-----", _y)
102#define PUBLIC_KEY_BLOCK(_y) _LINE_COMPARE("PUBLIC KEY BLOCK-----", _y)
103#define BEGIN_PGP_SIGNATURE(_y) \
104 _LINE_COMPARE("-----BEGIN PGP SIGNATURE-----", _y)
122 const char *s = gpgme_get_ctx_flag(ctx,
"redraw");
139 const char *s =
"????????";
143 s = k->
kobj->subkeys->keyid;
145 if ((!c_pgp_long_ids) && (strlen(s) == 16))
164 const char *s =
"????????????????";
168 s = k->
kobj->subkeys->keyid;
181 const char *s =
"????????";
185 s = k->
kobj->subkeys->keyid;
203 s = k->
kobj->subkeys->fpr;
215 const char *s =
"????????????????";
219 if (k->
kobj->subkeys->fpr)
220 s = k->
kobj->subkeys->fpr;
222 s = k->
kobj->subkeys->keyid;
239 gpgme_key_ref(key->
kobj);
262 *keylist = (*keylist)->
next;
264 gpgme_key_unref(k->
kobj);
279 bool is_strong =
false;
286 case GPGME_VALIDITY_MARGINAL:
287 case GPGME_VALIDITY_NEVER:
288 case GPGME_VALIDITY_UNDEFINED:
289 case GPGME_VALIDITY_UNKNOWN:
293 case GPGME_VALIDITY_FULL:
294 case GPGME_VALIDITY_ULTIMATE:
362 gpgme_ctx_t ctx = NULL;
364 gpgme_error_t err = gpgme_new(&ctx);
369 err = gpgme_ctx_set_engine_info(ctx, GPGME_PROTOCOL_OpenPGP, NULL, c_autocrypt_dir);
374 mutt_error(
_(
"error creating GPGME context: %s"), gpgme_strerror(err));
380 err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS);
383 mutt_error(
_(
"error enabling CMS protocol: %s"), gpgme_strerror(err));
401 gpgme_data_t data = NULL;
403 gpgme_error_t err = gpgme_data_new(&data);
406 mutt_error(
_(
"error creating GPGME data object: %s"), gpgme_strerror(err));
421 gpgme_data_t data = NULL;
439 unsigned char buf[1];
443 while ((c = fgetc(fp_tmp)) != EOF)
451 if ((c ==
'\n') && !hadcr)
454 gpgme_data_write(
data, buf, 1);
461 gpgme_data_write(
data, buf, 1);
464 gpgme_data_seek(
data, 0, SEEK_SET);
472 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
473 gpgme_data_release(
data);
494 gpgme_data_t
data = NULL;
496 int err = gpgme_data_new_from_filepart(&
data, NULL, fp, offset, length);
499 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
515 char buf[4096] = { 0 };
518 int err = ((gpgme_data_seek(
data, 0, SEEK_SET) == -1) ? gpgme_error_from_errno(errno) : 0);
521 mutt_error(
_(
"error rewinding data object: %s"), gpgme_strerror(err));
525 while ((nread = gpgme_data_read(
data, buf,
sizeof(buf))) > 0)
529 for (
char *p = buf; nread; p++, nread--)
543 mutt_error(
_(
"error reading data object: %s"), strerror(errno));
575 int err = ((gpgme_data_seek(
data, 0, SEEK_SET) == -1) ? gpgme_error_from_errno(errno) : 0);
578 char buf[4096] = { 0 };
580 while ((nread = gpgme_data_read(
data, buf,
sizeof(buf))) > 0)
582 if (fwrite(buf, nread, 1, fp) != 1)
597 mutt_error(
_(
"error reading data object: %s"), gpgme_strerror(err));
621 const char *s = keylist;
639 while ((*s !=
'\0') && (*s !=
' '))
642 }
while (*s !=
'\0');
656 gpgme_key_t key = NULL, key2 = NULL;
658 err = gpgme_op_keylist_start(listctx, address, 1);
660 err = gpgme_op_keylist_next(listctx, &key);
663 gpgme_release(listctx);
664 mutt_error(
_(
"secret key '%s' not found: %s"), address, gpgme_strerror(err));
670 fpr = key->subkeys->fpr ? key->subkeys->fpr : key->subkeys->keyid;
671 while (gpgme_op_keylist_next(listctx, &key2) == 0)
675 fpr2 = key2->subkeys->fpr ? key2->subkeys->fpr : key2->subkeys->keyid;
678 gpgme_key_unref(key);
679 gpgme_key_unref(key2);
680 gpgme_release(listctx);
681 mutt_error(
_(
"ambiguous specification of secret key '%s'"), address);
686 gpgme_key_unref(key2);
689 gpgme_op_keylist_end(listctx);
690 gpgme_release(listctx);
692 gpgme_signers_clear(ctx);
693 err = gpgme_signers_add(ctx, key);
694 gpgme_key_unref(key);
697 mutt_error(
_(
"error setting secret key '%s': %s"), address, gpgme_strerror(err));
711static int set_signer(gpgme_ctx_t ctx,
const struct AddressList *al,
bool for_smime)
713 const char *signid = NULL;
720 signid = c_smime_sign_as ? c_smime_sign_as : c_smime_default_key;
726 signid = c_pgp_sign_as ? c_pgp_sign_as : c_pgp_default_key;
747 return (!signid && !al) ? 0 : -1;
760 mutt_error(
_(
"error setting PKA signature notation: %s"), gpgme_strerror(err));
776 bool combined_signed,
const struct AddressList *from)
779 gpgme_ctx_t ctx = NULL;
780 gpgme_data_t ciphertext = NULL;
781 char *outfile = NULL;
793 gpgme_set_armor(ctx, 1);
810 err = gpgme_op_encrypt_sign_ext(ctx, NULL,
buf_string(recpstring),
811 GPGME_ENCRYPT_ALWAYS_TRUST, plaintext, ciphertext);
815 err = gpgme_op_encrypt_ext(ctx, NULL,
buf_string(recpstring),
816 GPGME_ENCRYPT_ALWAYS_TRUST, plaintext, ciphertext);
822 mutt_error(
_(
"error encrypting data: %s"), gpgme_strerror(err));
831 gpgme_data_release(ciphertext);
847static int get_micalg(gpgme_ctx_t ctx,
int use_smime,
char *buf,
size_t buflen)
849 gpgme_sign_result_t result = NULL;
850 const char *algorithm_name = NULL;
856 result = gpgme_op_sign_result(ctx);
857 if (result && result->signatures)
859 algorithm_name = gpgme_hash_algo_name(result->signatures->hash_algo);
865 snprintf(buf, buflen,
"%s", algorithm_name);
871 snprintf(buf, buflen,
"pgp-%s", algorithm_name);
877 return (buf[0] !=
'\0') ? 0 : -1;
902 struct Body *t = NULL;
903 char *sigfile = NULL;
905 char buf[100] = { 0 };
906 gpgme_ctx_t ctx = NULL;
907 gpgme_data_t message = NULL, signature = NULL;
908 gpgme_sign_result_t sigres = NULL;
919 gpgme_set_armor(ctx, 1);
923 gpgme_data_release(signature);
924 gpgme_data_release(message);
935 gpgme_data_release(signature);
936 gpgme_data_release(message);
942 err = gpgme_op_sign(ctx, message, signature, GPGME_SIG_MODE_DETACH);
944 gpgme_data_release(message);
947 gpgme_data_release(signature);
949 mutt_error(
_(
"error signing data: %s"), gpgme_strerror(err));
954 sigres = gpgme_op_sign_result(ctx);
955 if (!sigres->signatures)
957 gpgme_data_release(signature);
959 mutt_error(
_(
"$pgp_sign_as unset and no default key specified in ~/.gnupg/gpg.conf"));
964 gpgme_data_release(signature);
980 use_smime ?
"application/pkcs7-signature" :
"application/pgp-signature");
983 if (
get_micalg(ctx, use_smime, buf,
sizeof(buf)) == 0)
1038 const struct AddressList *from)
1047 gpgme_data_release(plaintext);
1093 gpgme_data_release(plaintext);
1128 int idx,
struct State *state, gpgme_signature_t sig)
1133 bool severe =
false;
1135 if ((sum & GPGME_SIGSUM_KEY_REVOKED))
1137 state_puts(state,
_(
"Warning: One of the keys has been revoked\n"));
1141 if ((sum & GPGME_SIGSUM_KEY_EXPIRED))
1143 time_t at = key->subkeys->expires ? key->subkeys->expires : 0;
1146 state_puts(state,
_(
"Warning: The key used to create the signature expired at: "));
1152 state_puts(state,
_(
"Warning: At least one certification key has expired\n"));
1156 if ((sum & GPGME_SIGSUM_SIG_EXPIRED))
1158 gpgme_signature_t sig2 = NULL;
1161 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1163 for (sig2 = result->signatures, i = 0; sig2 && (i < idx); sig2 = sig2->next, i++)
1166 state_puts(state,
_(
"Warning: The signature expired at: "));
1167 print_time(sig2 ? sig2->exp_timestamp : 0, state);
1171 if ((sum & GPGME_SIGSUM_KEY_MISSING))
1173 state_puts(state,
_(
"Can't verify due to a missing key or certificate\n"));
1176 if ((sum & GPGME_SIGSUM_CRL_MISSING))
1178 state_puts(state,
_(
"The CRL is not available\n"));
1182 if ((sum & GPGME_SIGSUM_CRL_TOO_OLD))
1184 state_puts(state,
_(
"Available CRL is too old\n"));
1188 if ((sum & GPGME_SIGSUM_BAD_POLICY))
1189 state_puts(state,
_(
"A policy requirement was not met\n"));
1191 if ((sum & GPGME_SIGSUM_SYS_ERROR))
1193 const char *t0 = NULL, *t1 = NULL;
1194 gpgme_verify_result_t result = NULL;
1195 gpgme_signature_t sig2 = NULL;
1201 result = gpgme_op_verify_result(ctx);
1202 for (sig2 = result->signatures, i = 0; sig2 && (i < idx); sig2 = sig2->next, i++)
1208 t1 = sig2->wrong_key_usage ?
"Wrong_Key_Usage" :
"";
1227 if (c_crypt_use_pka)
1229 if ((sig->pka_trust == 1) && sig->pka_address)
1231 state_puts(state,
_(
"WARNING: PKA entry does not match signer's address: "));
1235 else if ((sig->pka_trust == 2) && sig->pka_address)
1237 state_puts(state,
_(
"PKA verified signer's address is: "));
1256 const char *prefix =
_(
"Fingerprint: ");
1258 const char *s = key->subkeys ? key->subkeys->fpr : NULL;
1261 bool is_pgp = (key->protocol == GPGME_PROTOCOL_OpenPGP);
1264 strcpy(buf, prefix);
1265 char *p = buf + strlen(buf);
1266 if (is_pgp && (strlen(s) == 40))
1268 for (
int i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++)
1281 for (
int i = 0; *s && s[1] && s[2]; s += 2, i++)
1285 *p++ = is_pgp ?
' ' :
':';
1286 if (is_pgp && (i == 7))
1308 gpgme_signature_t sig = NULL;
1309 const char *txt = NULL;
1311 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1313 for (sig = result->signatures; sig && (idx > 0); sig = sig->next, idx--)
1316 switch (sig ? sig->validity : 0)
1318 case GPGME_VALIDITY_UNKNOWN:
1319 txt =
_(
"WARNING: We have NO indication whether the key belongs to the person named as shown above\n");
1321 case GPGME_VALIDITY_UNDEFINED:
1323 case GPGME_VALIDITY_NEVER:
1324 txt =
_(
"WARNING: The key does NOT BELONG to the person named as shown above\n");
1326 case GPGME_VALIDITY_MARGINAL:
1327 txt =
_(
"WARNING: It is NOT certain that the key belongs to the person named as shown above\n");
1329 case GPGME_VALIDITY_FULL:
1330 case GPGME_VALIDITY_ULTIMATE:
1346 gpgme_key_t key,
struct State *state)
1356 for (gpgme_user_id_t uids = key->uids; uids; uids = uids->next)
1365 for (
int i = 0; i < msgwid; i++)
1386 state_puts(state,
_(
"no signature fingerprint available"));
1398 for (
int i = 0; i < msgwid; i++)
1420 const char *fpr = NULL;
1421 gpgme_key_t key = NULL;
1422 bool anybad =
false, anywarn =
false;
1423 gpgme_signature_t sig = NULL;
1424 gpgme_error_t err = GPG_ERR_NO_ERROR;
1426 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1433 for (i = 0, sig = result->signatures; sig && (i < idx); i++, sig = sig->next)
1446 const unsigned int sum = sig->summary;
1448 if (gpg_err_code(sig->status) != GPG_ERR_NO_ERROR)
1451 if (gpg_err_code(sig->status) != GPG_ERR_NO_PUBKEY)
1453 err = gpgme_get_key(ctx, fpr, &key, 0);
1476 char buf[1024] = { 0 };
1477 snprintf(buf,
sizeof(buf),
_(
"Error getting key information for KeyID %s: %s\n"),
1478 fpr, gpgme_strerror(err));
1482 else if ((sum & GPGME_SIGSUM_GREEN))
1489 else if ((sum & GPGME_SIGSUM_RED))
1494 else if (!anybad && key && (key->protocol == GPGME_PROTOCOL_OpenPGP))
1509 if (sig->exp_timestamp)
1522 gpgme_key_unref(key);
1525 return anybad ? 1 : anywarn ? 2 : 0;
1542 const char *tempfile,
bool is_smime)
1546 gpgme_ctx_t ctx = NULL;
1547 gpgme_data_t message = NULL;
1557 gpgme_data_set_encoding(signature, GPGME_DATA_ENCODING_BASE64);
1559 int err = gpgme_data_new_from_file(&message, tempfile, 1);
1562 gpgme_data_release(signature);
1563 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
1572 err = gpgme_op_verify(ctx, signature, message, NULL);
1573 gpgme_data_release(message);
1574 gpgme_data_release(signature);
1579 char buf[200] = { 0 };
1581 snprintf(buf,
sizeof(buf) - 1,
_(
"Error: verification failed: %s\n"),
1582 gpgme_strerror(err));
1587 gpgme_verify_result_t verify_result = NULL;
1595 verify_result = gpgme_op_verify_result(ctx);
1596 if (verify_result && verify_result->signatures)
1598 bool anybad =
false;
1614 gpgme_verify_result_t result = NULL;
1615 gpgme_sig_notation_t notation = NULL;
1616 gpgme_signature_t sig = NULL;
1618 result = gpgme_op_verify_result(ctx);
1621 for (sig = result->signatures; sig; sig = sig->next)
1623 int non_pka_notations = 0;
1624 for (notation = sig->notations; notation; notation = notation->next)
1626 non_pka_notations++;
1628 if (non_pka_notations)
1630 char buf[128] = { 0 };
1631 snprintf(buf,
sizeof(buf),
1632 _(
"*** Begin Notation (signature by: %s) ***\n"), sig->fpr);
1634 for (notation = sig->notations; notation; notation = notation->next)
1644 if (notation->value)
1647 if (!(*notation->value && (notation->value[strlen(notation->value) - 1] ==
'\n')))
1662 return badsig ? 1 : anywarn ? 2 : 0;
1670 return verify_one(sigbdy, state, tempfile,
false);
1678 return verify_one(sigbdy, state, tempfile,
true);
1695 FILE *fp_out,
bool is_smime,
int *r_is_signed)
1697 if (!a || !state || !fp_out)
1700 struct Body *tattach = NULL;
1702 gpgme_data_t ciphertext = NULL, plaintext = NULL;
1703 bool maybe_signed =
false;
1704 bool anywarn =
false;
1710 gpgme_ctx_t ctx = NULL;
1723 if ((!is_smime) || maybe_signed)
1726 err = gpgme_op_decrypt_verify(ctx, ciphertext, plaintext);
1727 else if (maybe_signed)
1728 err = gpgme_op_verify(ctx, ciphertext, NULL, plaintext);
1730 if (err == GPG_ERR_NO_ERROR)
1733 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
1734 if (verify_result->signatures)
1740 err = gpgme_op_decrypt(ctx, ciphertext, plaintext);
1742 gpgme_data_release(ciphertext);
1752 if (is_smime && !maybe_signed && (gpg_err_code(err) == GPG_ERR_NO_DATA))
1758 gpgme_decrypt_result_t result = NULL;
1760 result = gpgme_op_decrypt_result(ctx);
1761 if (!result->unsupported_algorithm)
1763 maybe_signed =
true;
1764 gpgme_data_release(plaintext);
1774 char buf[200] = { 0 };
1776 snprintf(buf,
sizeof(buf) - 1,
1777 _(
"[-- Error: decryption failed: %s --]\n\n"), gpgme_strerror(err));
1790 gpgme_data_release(plaintext);
1812 if (!anybad && idx && r_is_signed && *r_is_signed)
1813 *r_is_signed = anywarn ? 2 : 1;
1843 gpgme_data_release(ciphertext);
1844 gpgme_data_release(plaintext);
1855 struct State state = { 0 };
1856 struct Body *first_part = b;
1858 bool need_decode =
false;
1859 LOFF_T saved_offset = 0;
1860 size_t saved_length = 0;
1861 FILE *fp_decoded = NULL;
1884 state.
fp_in = fp_in;
1888 saved_offset = b->
offset;
1889 saved_length = b->
length;
1903 state.
fp_out = fp_decoded;
1908 b->
length = ftello(fp_decoded);
1911 state.
fp_in = fp_decoded;
1923 *cur =
decrypt_part(b, &state, *fp_out,
false, &is_signed);
1939 b->
length = saved_length;
1940 b->
offset = saved_offset;
1952 struct State state = { 0 };
1954 LOFF_T saved_b_offset;
1955 size_t saved_b_length;
1967 saved_b_offset = b->
offset;
1968 saved_b_length = b->
length;
1988 memset(&state, 0,
sizeof(state));
1989 state.
fp_in = fp_tmp;
2000 (*cur)->goodsig = is_signed > 0;
2001 b->
length = saved_b_length;
2002 b->
offset = saved_b_offset;
2014 struct Body *bb = *cur;
2016 saved_b_offset = bb->
offset;
2017 saved_b_length = bb->
length;
2018 memset(&state, 0,
sizeof(state));
2019 state.
fp_in = *fp_out;
2039 memset(&state, 0,
sizeof(state));
2040 state.
fp_in = fp_tmp2;
2051 b_tmp->
goodsig = is_signed > 0;
2052 bb->
length = saved_b_length;
2053 bb->
offset = saved_b_offset;
2059 return *cur ? 0 : -1;
2071 gpgme_ctx_t tmpctx = NULL;
2073 gpgme_key_t key = NULL;
2074 gpgme_user_id_t uid = NULL;
2075 gpgme_subkey_t subkey = NULL;
2076 const char *shortid = NULL;
2078 char date[256] = { 0 };
2092 err = gpgme_op_keylist_from_data_start(tmpctx, keydata, 0);
2095 err = gpgme_op_keylist_next(tmpctx, &key);
2099 subkey = key->subkeys;
2103 shortid = subkey->keyid;
2107 tt = subkey->timestamp;
2112 fprintf(*fp,
"sub %5.5s %u/%8s %s\n", gpgme_pubkey_algo_name(subkey->pubkey_algo),
2113 subkey->length, shortid, date);
2117 fprintf(*fp,
"pub %5.5s %u/%8s %s %s\n", gpgme_pubkey_algo_name(subkey->pubkey_algo),
2118 subkey->length, shortid, date, (uid ? uid->uid :
""));
2120 subkey = subkey->next;
2123 gpgme_key_unref(key);
2125 if (gpg_err_code(err) != GPG_ERR_EOF)
2137 gpgme_release(tmpctx);
2158 if ((b[n] ==
'\n') || ((b[n] ==
'\r') && (b[n + 1] ==
'\n')))
2173 char buf[8192] = { 0 };
2191 FILE *fp_tmp = fopen(
buf_string(tempfile),
"r");
2198 while (fgets(buf,
sizeof(buf), fp_tmp))
2239 for (; b; b = b->
next)
2266 gpgme_data_t keydata = NULL;
2267 gpgme_import_result_t impres = NULL;
2268 gpgme_import_status_t st = NULL;
2279 gpgme_error_t err = gpgme_data_new_from_stream(&keydata, fp_in);
2280 if (err != GPG_ERR_NO_ERROR)
2282 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
2286 err = gpgme_op_import(ctx, keydata);
2289 mutt_error(
_(
"Error importing key: %s"), gpgme_strerror(err));
2294 impres = gpgme_op_import_result(ctx);
2297 fputs(
"oops: no import result returned\n", stdout);
2301 for (st = impres->imports; st; st = st->next)
2305 printf(
"key %s imported (",
NONULL(st->fpr));
2309 if (st->status & GPGME_IMPORT_SECRET)
2311 printf(
"secret parts");
2314 if ((st->status & GPGME_IMPORT_NEW))
2316 printf(
"%snew key", any ?
", " :
"");
2319 if ((st->status & GPGME_IMPORT_UID))
2321 printf(
"%snew uid", any ?
", " :
"");
2324 if ((st->status & GPGME_IMPORT_SIG))
2326 printf(
"%snew sig", any ?
", " :
"");
2329 if ((st->status & GPGME_IMPORT_SUBKEY))
2331 printf(
"%snew subkey", any ?
", " :
"");
2334 printf(
"%s)\n", any ?
"" :
"not changed");
2343 for (st = impres->imports; st; st = st->next)
2345 if (st->result == 0)
2347 printf(
"key %s import failed: %s\n",
NONULL(st->fpr), gpgme_strerror(st->result));
2353 gpgme_data_release(keydata);
2374 char buf[8192] = { 0 };
2375 bool complete, armor_header;
2392 for (complete =
true, armor_header =
true;
2408 armor_header =
false;
2415 if ((buf[0] ==
'-') && (buf[1] ==
' '))
2431 bool pgp_keyblock =
false;
2432 bool clearsign =
false;
2435 char buf[8192] = { 0 };
2436 FILE *fp_out = NULL;
2438 gpgme_error_t err = 0;
2439 gpgme_data_t armored_data = NULL;
2441 bool maybe_goodsig =
true;
2442 bool have_any_sigs =
false;
2444 char body_charset[256] = { 0 };
2451 mutt_str_copy(body_charset,
"iso-8859-1",
sizeof(body_charset));
2459 for (bytes = m->
length; bytes > 0;)
2461 if (!fgets(buf,
sizeof(buf), state->
fp_in))
2464 LOFF_T offset = ftello(state->
fp_in);
2465 bytes -= (offset - last_pos);
2485 pgp_keyblock =
true;
2496 have_any_sigs = (have_any_sigs || (clearsign && (state->
flags &
STATE_VERIFY)));
2512 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2516 err = gpgme_op_decrypt_verify(ctx, armored_data, plaintext);
2517 if (gpg_err_code(err) == GPG_ERR_NO_DATA)
2520 gpgme_data_seek(armored_data, 0, SEEK_SET);
2522 gpgme_data_release(plaintext);
2524 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2531 char errbuf[200] = { 0 };
2533 snprintf(errbuf,
sizeof(errbuf) - 1,
2534 _(
"Error: decryption/verification failed: %s\n"), gpgme_strerror(err));
2543 bool sig_stat =
false;
2544 char *tmpfname = NULL;
2547 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
2548 if (verify_result->signatures)
2551 have_any_sigs =
false;
2552 maybe_goodsig =
false;
2556 bool anybad =
false;
2559 have_any_sigs =
true;
2566 maybe_goodsig =
true;
2580 state_puts(state,
_(
"Error: copy data failed\n"));
2583 gpgme_data_release(plaintext);
2594 else if (pgp_keyblock)
2613 if ((c ==
'\n') && state->
prefix)
2624 else if (pgp_keyblock)
2630 gpgme_data_release(armored_data);
2643 m->
goodsig = (maybe_goodsig && have_any_sigs);
2647 state_attach_puts(state,
_(
"[-- Error: could not find beginning of PGP message --]\n\n"));
2682 tattach->
goodsig = is_signed > 0;
2687 _(
"[-- The following data is PGP/MIME signed and encrypted --]\n\n") :
2688 _(
"[-- The following data is PGP/MIME encrypted --]\n\n"));
2700 FILE *fp_save = state->
fp_in;
2701 state->
fp_in = fp_out;
2703 state->
fp_in = fp_save;
2725 _(
"[-- End of PGP/MIME signed and encrypted data --]\n") :
2726 _(
"[-- End of PGP/MIME encrypted data --]\n"));
2776 tattach->
goodsig = is_signed > 0;
2781 _(
"[-- The following data is S/MIME signed --]\n\n") :
2782 _(
"[-- The following data is S/MIME encrypted --]\n\n"));
2794 FILE *fp_save = state->
fp_in;
2795 state->
fp_in = fp_out;
2797 state->
fp_in = fp_save;
2827 _(
"[-- End of S/MIME encrypted data --]\n"));
2847 unsigned int rc = 0;
2852 rc = key->can_encrypt;
2855 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2857 rc = subkey->can_encrypt;
2867 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2869 rc = subkey->can_sign;
2876 rc = key->can_certify;
2879 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2881 rc = subkey->can_certify;
2903 char *pattern = NULL, *p = NULL;
2904 const char *s = NULL;
2911 for (s = np->
data; *s; s++)
2913 if ((*s ==
'%') || (*s ==
'+'))
2929 for (s = np->
data; *s; s++)
2970 struct CryptKeyInfo *db = NULL, *k = NULL, **kend = NULL;
2972 gpgme_ctx_t ctx = NULL;
2973 gpgme_key_t key = NULL;
2975 gpgme_user_id_t
uid = NULL;
3008 err = gpgme_op_keylist_ext_start(ctx, (
const char **) patarr, secret, 0);
3009 for (n = 0; patarr[n]; n++)
3014 mutt_error(
_(
"gpgme_op_keylist_start failed: %s"), gpgme_strerror(err));
3020 while ((err = gpgme_op_keylist_next(ctx, &key)) == 0)
3036 for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3040 gpgme_key_ref(k->kobj);
3046 k->validity = uid->validity;
3050 gpgme_key_unref(key);
3052 if (gpg_err_code(err) != GPG_ERR_EOF)
3053 mutt_error(
_(
"gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3054 gpgme_op_keylist_end(ctx);
3061 gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS);
3062 err = gpgme_op_keylist_start(ctx, pattern, 0);
3065 mutt_error(
_(
"gpgme_op_keylist_start failed: %s"), gpgme_strerror(err));
3071 while ((err = gpgme_op_keylist_next(ctx, &key)) == 0)
3087 for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3091 gpgme_key_ref(k->kobj);
3097 k->validity = uid->validity;
3101 gpgme_key_unref(key);
3103 if (gpg_err_code(err) != GPG_ERR_EOF)
3104 mutt_error(
_(
"gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3105 gpgme_op_keylist_end(ctx);
3127 for (
char *t = strtok(scratch,
" ,.:\"()<>\n"); t; t = strtok(NULL,
" ,.:\"()<>\n"))
3146 KeyFlags abilities,
unsigned int app,
3147 bool *forced_valid,
bool oppenc_mode)
3152 int this_key_has_strong =
false;
3153 int this_key_has_addr_match =
false;
3179 for (k = keys; k; k = k->
next)
3183 if (abilities && !(k->flags & abilities))
3189 this_key_has_strong =
false;
3190 this_key_has_addr_match =
false;
3208 if (the_strong_valid_key && (the_strong_valid_key->
kobj != k->kobj))
3210 this_key_has_strong =
true;
3214 this_key_has_addr_match =
true;
3224 *matches_endp = tmp;
3225 matches_endp = &tmp->
next;
3227 if (this_key_has_strong)
3228 the_strong_valid_key = tmp;
3229 else if (this_key_has_addr_match)
3230 a_valid_addrmatch_key = tmp;
3240 const bool c_crypt_opportunistic_encrypt_strong_keys =
3242 if (the_strong_valid_key)
3244 else if (a_valid_addrmatch_key && !c_crypt_opportunistic_encrypt_strong_keys)
3249 else if (the_strong_valid_key && !multi)
3258 k =
dlg_gpgme(matches, a, NULL, app, forced_valid);
3280 unsigned int app,
bool *forced_valid)
3286 const char *ps = NULL, *pl = NULL, *phint = NULL;
3301 for (k = keys; k; k = k->
next)
3303 if (abilities && !(k->
flags & abilities))
3316 *matches_endp = tmp;
3317 matches_endp = &tmp->
next;
3330 k =
dlg_gpgme(matches, NULL, p, app, forced_valid);
3352 unsigned int app,
bool *forced_valid)
3419static char *
find_keys(
const struct AddressList *addrlist,
unsigned int app,
bool oppenc_mode)
3422 struct ListNode *crypt_hook = NULL;
3423 const char *keyid = NULL;
3424 char *keylist = NULL;
3425 size_t keylist_size = 0;
3426 size_t keylist_used = 0;
3430 char buf[1024] = { 0 };
3431 bool forced_valid =
false;
3439 key_selected =
false;
3445 forced_valid =
false;
3450 keyid = crypt_hook->
data;
3452 if (!oppenc_mode && c_crypt_confirm_hook)
3454 snprintf(buf,
sizeof(buf),
_(
"Use keyID = \"%s\" for %s?"), keyid,
3464 goto bypass_selection;
3474 else if (!oppenc_mode)
3481 if (key_selected ||
STAILQ_NEXT(crypt_hook, entries))
3501 if (!k_info && !oppenc_mode)
3522 sprintf(keylist + keylist_used,
"%s0x%s%s", keylist_used ?
" " :
"",
3523 keyid, forced_valid ?
"!" :
"");
3526 key_selected =
true;
3534 }
while (crypt_hook);
3574 gpgme_key_t key = NULL;
3575 gpgme_user_id_t uid = NULL;
3583 if (gpgme_op_keylist_start(ctx, NULL, 1))
3588 while (!(err = gpgme_op_keylist_next(ctx, &key)))
3609 gpgme_key_ref(k->kobj);
3615 k->validity =
uid->validity;
3619 gpgme_key_unref(key);
3621 if (gpg_err_code(err) != GPG_ERR_EOF)
3622 mutt_error(
_(
"gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3623 gpgme_op_keylist_end(ctx);
3634 if (!(choice && choice->
kobj && choice->
kobj->subkeys && choice->
kobj->subkeys->fpr))
3653 gpgme_ctx_t context = NULL;
3654 gpgme_key_t export_keys[2] = { 0 };
3655 gpgme_data_t keydata = NULL;
3657 struct Body *att = NULL;
3658 char buf[1024] = { 0 };
3666 export_keys[0] = key->
kobj;
3667 export_keys[1] = NULL;
3670 gpgme_set_armor(context, 1);
3672 err = gpgme_op_export_keys(context, export_keys, 0, keydata);
3673 if (err != GPG_ERR_NO_ERROR)
3675 mutt_error(
_(
"Error exporting key: %s"), gpgme_strerror(err));
3693 snprintf(buf,
sizeof(buf),
_(
"PGP Key 0x%s"),
crypt_keyid(key));
3701 gpgme_data_release(keydata);
3702 gpgme_release(context);
3714 static bool has_run =
false;
3718 gpgme_check_version(NULL);
3719 gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
3721 gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
3731 if (gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP) != GPG_ERR_NO_ERROR)
3733 mutt_error(
_(
"GPGME: OpenPGP protocol not available"));
3742 if (gpgme_engine_check_version(GPGME_PROTOCOL_CMS) != GPG_ERR_NO_ERROR)
3744 mutt_error(
_(
"GPGME: CMS protocol not available"));
3775 const char *prompt = NULL;
3776 const char *letters = NULL;
3777 const char *choices = NULL;
3795 prompt =
_(
"S/MIME (s)ign, sign (a)s, (p)gp, (c)lear, or (o)ppenc mode off?");
3797 letters =
_(
"sapco");
3803 prompt =
_(
"PGP (s)ign, sign (a)s, s/(m)ime, (c)lear, or (o)ppenc mode off?");
3805 letters =
_(
"samco");
3809 else if (c_crypt_opportunistic_encrypt)
3815 prompt =
_(
"S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp, (c)lear, or (o)ppenc mode?");
3817 letters =
_(
"esabpco");
3818 choices =
"esabpcO";
3823 prompt =
_(
"PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime, (c)lear, or (o)ppenc mode?");
3825 letters =
_(
"esabmco");
3826 choices =
"esabmcO";
3835 prompt =
_(
"S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp or (c)lear?");
3837 letters =
_(
"esabpc");
3843 prompt =
_(
"PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime or (c)lear?");
3845 letters =
_(
"esabmc");
3853 switch (choices[choice - 1])
3860 char input_signas[128] = { 0 };
3893 is_smime = !is_smime;
3953 struct Address *sender = NULL;
3972 gpgme_user_id_t uid = NULL;
3974 for (uid = key->uids; uid && rc; uid = uid->next)
3976 int uid_length = strlen(uid->email);
3977 if ((uid->email[0] ==
'<') && (uid->email[uid_length - 1] ==
'>') &&
3978 (uid_length == (sender_length + 2)))
3980 const char *at_sign = strchr(uid->email + 1,
'@');
3986 const char *tmp_email = uid->email + 1;
3989 int mailbox_length = at_sign - tmp_email + 1;
3990 int domainname_length = sender_length - mailbox_length;
3991 int mailbox_match, domainname_match;
3993 mailbox_match =
mutt_strn_equal(tmp_email, tmp_sender, mailbox_length);
3994 tmp_email += mailbox_length;
3995 tmp_sender += mailbox_length;
3996 domainname_match = (
mutt_istrn_cmp(tmp_email, tmp_sender, domainname_length) == 0);
3997 if (mailbox_match && domainname_match)
4051 return GPGME_VERSION;
void mutt_addrlist_qualify(struct AddressList *al, const char *host)
Expand local names in an Address list using a hostname.
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
int mutt_addrlist_parse(struct AddressList *al, const char *s)
Parse a list of email addresses.
void mutt_expand_aliases(struct AddressList *al)
Expand aliases in a List of Addresses.
GUI display the mailboxes in a side panel.
char * AutocryptSignAs
Autocrypt Key id to sign as.
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.
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
const char * cs_subset_path(const struct ConfigSubset *sub, const char *name)
Get a path config item by name.
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Convenience wrapper for the config headers.
const char * cc_charset(void)
Get the cached value of $charset.
Convenience wrapper for the core headers.
SecurityFlags mutt_is_application_pgp(struct Body *b)
Does the message use PGP?
void crypt_opportunistic_encrypt(struct Email *e)
Can all recipients be determined.
bool crypt_is_numerical_keyid(const char *s)
Is this a numerical keyid.
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
SecurityFlags mutt_is_application_smime(struct Body *b)
Does the message use S/MIME?
int mutt_is_valid_multipart_pgp_encrypted(struct Body *b)
Is this a valid multi-part encrypted message?
void crypt_convert_to_7bit(struct Body *a)
Convert an email to 7bit encoding.
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.
SecurityFlags mutt_is_malformed_multipart_pgp_encrypted(struct Body *b)
Check for malformed layout.
Signing/encryption multiplexor.
static const char * crypt_short_keyid(struct CryptKeyInfo *k)
Get the short keyID for a key.
static gpgme_error_t set_pka_sig_notation(gpgme_ctx_t ctx)
Set the signature notation.
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.
static char * find_keys(const struct AddressList *addrlist, unsigned int app, bool oppenc_mode)
Find keys of the recipients of the message.
static bool verify_sender(struct Email *e)
Verify the sender of a message.
static void init_common(void)
Initialise code common to PGP and SMIME parts of GPGME.
static struct CryptCache * IdDefaults
Cache of GPGME keys.
struct CryptKeyInfo * crypt_copy_key(struct CryptKeyInfo *key)
Return a copy of KEY.
static char * CurrentSender
Email address of the sender.
int mutt_gpgme_select_secret_key(struct Buffer *keyid)
Select a private Autocrypt key for a new account.
const char * mutt_gpgme_print_version(void)
Get version of GPGME.
int crypt_id_is_valid(struct CryptKeyInfo *key)
Is key ID valid.
static gpgme_data_t create_gpgme_data(void)
Create a new GPGME data object.
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.
static void show_fingerprint(gpgme_key_t key, struct State *state)
Write a key's fingerprint.
gpgme_ctx_t create_gpgme_context(bool for_smime)
Create a new GPGME context.
static void create_recipient_string(const char *keylist, struct Buffer *recpstring, int use_smime)
Create a string of recipients.
static gpgme_data_t body_to_data_object(struct Body *a, bool convert)
Create GPGME object from the mail body.
static struct CryptKeyInfo * crypt_getkeybystr(const char *p, KeyFlags abilities, unsigned int app, bool *forced_valid)
Find a key by string.
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.
static int crypt_id_matches_addr(struct Address *addr, struct Address *u_addr, struct CryptKeyInfo *key)
Does the key ID match the address.
bool crypt_id_is_strong(struct CryptKeyInfo *key)
Is the key strong.
static void crypt_add_string_to_hints(const char *str, struct ListHead *hints)
Split a string and add the parts to a List.
const char * crypt_fpr_or_lkeyid(struct CryptKeyInfo *k)
Find the fingerprint of a key.
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.
#define BEGIN_PGP_SIGNATURE(_y)
#define SIGNED_MESSAGE(_y)
static struct Body * decrypt_part(struct Body *a, struct State *state, FILE *fp_out, bool is_smime, int *r_is_signed)
Decrypt a PGP or SMIME message.
#define PKA_NOTATION_NAME
static char * list_to_pattern(struct ListHead *list)
Convert STailQ to GPGME-compatible pattern.
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.
static int data_object_to_stream(gpgme_data_t data, FILE *fp)
Write a GPGME data object to a file.
static int pgp_check_traditional_one_body(FILE *fp, struct Body *b)
Check one inline PGP body part.
static const char * crypt_long_keyid(struct CryptKeyInfo *k)
Find the Long ID for the key.
#define CRYPT_KV_STRONGID
static struct CryptKeyInfo * get_candidates(struct ListHead *hints, SecurityFlags app, int secret)
Get a list of keys which are candidates for the selection.
static gpgme_data_t file_to_data_object(FILE *fp, long offset, size_t length)
Create GPGME data object from file.
#define PUBLIC_KEY_BLOCK(_y)
static int set_signer(gpgme_ctx_t ctx, const struct AddressList *al, bool for_smime)
Make sure that the correct signer is set.
static char * data_object_to_tempfile(gpgme_data_t data, FILE **fp_ret)
Copy a data object to a temporary file.
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.
static void init_smime(void)
Initialise the SMIME crypto backend.
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.
unsigned int key_check_cap(gpgme_key_t key, enum KeyCap cap)
Check the capabilities of a key.
static const char * crypt_fpr(struct CryptKeyInfo *k)
Get the hexstring fingerprint from a key.
const char * crypt_keyid(struct CryptKeyInfo *k)
Find the ID for the key.
static SecurityFlags gpgme_send_menu(struct Email *e, bool is_smime)
Show the user the encryption/signing menu.
static struct Body * sign_message(struct Body *a, const struct AddressList *from, bool use_smime)
Sign a message.
static int verify_one(struct Body *sigbdy, struct State *state, const char *tempfile, bool is_smime)
Do the actual verification step.
static bool is_pka_notation(gpgme_sig_notation_t notation)
Is this the standard pka email address.
static void redraw_if_needed(gpgme_ctx_t ctx)
Accommodate for a redraw if needed.
static int pgp_gpgme_extract_keys(gpgme_data_t keydata, FILE **fp)
Write PGP keys to a file.
static int line_compare(const char *a, size_t n, const char *b)
Compare two strings ignore line endings.
static gpgme_key_t SignatureKey
PGP Key to sign with.
static void crypt_key_free(struct CryptKeyInfo **keylist)
Release all the keys in a list.
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.
static void init_pgp(void)
Initialise the PGP crypto backend.
static void copy_clearsigned(gpgme_data_t data, struct State *state, char *charset)
Copy a clearsigned message.
static int show_one_sig_status(gpgme_ctx_t ctx, int idx, struct State *state)
Show information about one signature.
static void print_time(time_t t, struct State *state)
Print the date/time according to the locale.
Wrapper for PGP/SMIME calls to GPGME.
KeyCap
PGP/SMIME Key Capabilities.
@ KEY_CAP_CAN_CERTIFY
Key can be used to certify.
@ KEY_CAP_CAN_ENCRYPT
Key can be used for encryption.
@ KEY_CAP_CAN_SIGN
Key can be used for signing.
int mutt_any_key_to_continue(const char *s)
Prompt the user to 'press any key' and wait.
void mutt_need_hard_redraw(void)
Force a hard refresh.
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
void mutt_body_free(struct Body **ptr)
Free a Body.
struct Body * mutt_body_new(void)
Create a new Body.
char * mutt_body_get_charset(struct Body *b, char *buf, size_t buflen)
Get a body's character set.
Structs that make up an email.
void mutt_parse_part(FILE *fp, struct Body *b)
Parse a MIME part.
struct Body * mutt_read_mime_header(FILE *fp, bool digest)
Parse a MIME header.
void mutt_env_free(struct Envelope **ptr)
Free an Envelope.
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
long mutt_file_get_size_fp(FILE *fp)
Get the size of a file.
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
long mutt_file_get_size(const char *path)
Get the size of a file.
bool OptAutocryptGpgme
(pseudo) use Autocrypt context inside ncrypt/crypt_gpgme.c
bool OptPgpCheckTrust
(pseudo) used by dlg_pgp()
int pgp_gpgme_application_handler(struct Body *m, struct State *state)
Implements CryptModuleSpecs::application_handler() -.
int smime_gpgme_application_handler(struct Body *a, struct State *state)
Implements CryptModuleSpecs::application_handler() -.
int pgp_gpgme_decrypt_mime(FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **cur)
Implements CryptModuleSpecs::decrypt_mime() -.
int smime_gpgme_decrypt_mime(FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **cur)
Implements CryptModuleSpecs::decrypt_mime() -.
int pgp_gpgme_encrypted_handler(struct Body *a, struct State *state)
Implements CryptModuleSpecs::encrypted_handler() -.
char * smime_gpgme_find_keys(const struct AddressList *addrlist, bool oppenc_mode)
Implements CryptModuleSpecs::find_keys() -.
char * pgp_gpgme_find_keys(const struct AddressList *addrlist, bool oppenc_mode)
Implements CryptModuleSpecs::find_keys() -.
void smime_gpgme_init(void)
Implements CryptModuleSpecs::init() -.
void pgp_gpgme_init(void)
Implements CryptModuleSpecs::init() -.
bool pgp_gpgme_check_traditional(FILE *fp, struct Body *b, bool just_one)
Implements CryptModuleSpecs::pgp_check_traditional() -.
struct Body * pgp_gpgme_encrypt_message(struct Body *a, char *keylist, bool sign, const struct AddressList *from)
Implements CryptModuleSpecs::pgp_encrypt_message() -.
void pgp_gpgme_invoke_import(const char *fname)
Implements CryptModuleSpecs::pgp_invoke_import() -.
struct Body * pgp_gpgme_make_key_attachment(void)
Implements CryptModuleSpecs::pgp_make_key_attachment() -.
void pgp_gpgme_set_sender(const char *sender)
Implements CryptModuleSpecs::set_sender() -.
struct Body * smime_gpgme_sign_message(struct Body *a, const struct AddressList *from)
Implements CryptModuleSpecs::sign_message() -.
struct Body * pgp_gpgme_sign_message(struct Body *a, const struct AddressList *from)
Implements CryptModuleSpecs::sign_message() -.
struct Body * smime_gpgme_build_smime_entity(struct Body *a, char *keylist)
Implements CryptModuleSpecs::smime_build_smime_entity() -.
int smime_gpgme_verify_sender(struct Email *e, struct Message *msg)
Implements CryptModuleSpecs::smime_verify_sender() -.
int smime_gpgme_verify_one(struct Body *sigbdy, struct State *state, const char *tempfile)
Implements CryptModuleSpecs::verify_one() -.
int pgp_gpgme_verify_one(struct Body *sigbdy, struct State *state, const char *tempfile)
Implements CryptModuleSpecs::verify_one() -.
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 -.
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 -.
int mw_multi_choice(const char *prompt, const char *letters)
Offer the user a multiple choice question -.
int mutt_protected_headers_handler(struct Body *b, struct State *state)
Process a protected header - Implements handler_t -.
#define mutt_message(...)
#define mutt_debug(LEVEL,...)
Convenience wrapper for the gui headers.
int mutt_body_handler(struct Body *b, struct State *state)
Handler for the Body of an email.
void mutt_decode_attachment(struct Body *b, struct State *state)
Decode an email's attachment.
Decide how to display email content.
Read/write command history from/to a file.
@ HC_OTHER
Miscellaneous strings.
void mutt_crypt_hook(struct ListHead *list, struct Address *addr)
Find crypto hooks for an Address.
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.
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
@ LL_DEBUG5
Log at debug level 5.
@ LL_DEBUG2
Log at debug level 2.
@ LL_DEBUG1
Log at debug level 1.
void mutt_exit(int code)
Leave NeoMutt NOW.
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
@ ENC_BASE64
Base-64 encoded text.
@ TYPE_MULTIPART
Type: 'multipart/*'.
@ TYPE_APPLICATION
Type: 'application/*'.
@ TYPE_TEXT
Type: 'text/*'.
@ DISP_ATTACH
Content is attached.
@ DISP_INLINE
Content is inline.
@ DISP_NONE
No preferred disposition.
#define is_multipart(body)
void mutt_generate_boundary(struct ParameterList *pl)
Create a unique boundary id for a MIME part.
int mutt_ch_fgetconv(struct FgetConv *fc)
Convert a file's character set.
struct FgetConv * mutt_ch_fgetconv_open(FILE *fp, const char *from, const char *to, uint8_t flags)
Prepare a file for charset conversion.
char * mutt_ch_fgetconvs(char *buf, size_t buflen, struct FgetConv *fc)
Convert a file's charset into a string buffer.
void mutt_ch_fgetconv_close(struct FgetConv **ptr)
Close an fgetconv handle.
#define MUTT_ICONV_HOOK_FROM
apply charset-hooks to fromcode
#define MUTT_ICONV_NO_FLAGS
No flags are set.
size_t mutt_date_localtime_format(char *buf, size_t buflen, const char *format, time_t t)
Format localtime.
Convenience wrapper for the library headers.
void state_attach_puts(struct State *state, const char *t)
Write a string to the state.
#define state_puts(STATE, STR)
#define STATE_DISPLAY
Output is displayed to the user.
#define state_putc(STATE, STR)
#define STATE_VERIFY
Perform signature verification.
#define STATE_NO_FLAGS
No flags are set.
int mutt_istrn_cmp(const char *a, const char *b, size_t num)
Compare two strings ignoring case (to a maximum), safely.
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
char * mutt_str_dup(const char *str)
Copy a string, safely.
char * mutt_str_lower(char *str)
Convert all characters in the string to lowercase.
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
const char * mutt_istr_find(const char *haystack, const char *needle)
Find first occurrence of string (ignoring case)
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Many unsorted constants and some structs.
#define MUTT_COMP_NO_FLAGS
No flags are set.
int mutt_decode_save_attachment(FILE *fp, struct Body *m, const char *path, StateFlags flags, enum SaveAttach opt)
Decode, then save an attachment.
@ MUTT_SAVE_NO_FLAGS
No flags set.
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
#define KEYFLAG_EXPIRED
Key is expired.
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
#define KEYFLAG_ISX509
Key is an X.509 key.
uint16_t KeyFlags
Flags describing PGP/SMIME keys, e.g. KEYFLAG_CANSIGN.
#define APPLICATION_PGP
Use PGP to encrypt/sign.
#define KEYFLAG_CANENCRYPT
Key is suitable for encryption.
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
#define KEYFLAG_NO_FLAGS
No flags are set.
#define SEC_NO_FLAGS
No flags are set.
#define KEYFLAG_DISABLED
Key is marked disabled.
#define SEC_ENCRYPT
Email is encrypted.
#define KEYFLAG_REVOKED
Key is revoked.
#define SEC_SIGN
Email is signed.
#define KEYFLAG_CANSIGN
Key is suitable for signing.
void mutt_param_set(struct ParameterList *pl, const char *attribute, const char *value)
Set a Parameter.
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
QuadOption
Possible values for a quad-option.
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
@ MUTT_NO
User answered 'No', or assume 'No'.
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
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.
#define TAILQ_FOREACH(var, head, field)
#define STAILQ_HEAD_INITIALIZER(head)
#define STAILQ_FIRST(head)
#define STAILQ_FOREACH(var, head, field)
#define TAILQ_FIRST(head)
#define TAILQ_HEAD_INITIALIZER(head)
#define TAILQ_EMPTY(head)
#define STAILQ_NEXT(elm, field)
int mutt_write_mime_body(struct Body *a, FILE *fp, struct ConfigSubset *sub)
Write a MIME part.
Convenience wrapper for the send headers.
const char * mutt_fqdn(bool may_hide_host, const struct ConfigSubset *sub)
Get the Fully-Qualified Domain Name.
void mutt_update_encoding(struct Body *a, struct ConfigSubset *sub)
Update the encoding type.
struct Buffer * personal
Real name of address.
struct Buffer * mailbox
Mailbox and host address.
char * d_filename
filename to be used for the content-disposition header If NULL, filename is used instead.
struct Body * parts
parts of a multipart or message/rfc822
LOFF_T offset
offset where the actual data begins
bool unlink
If true, filename should be unlink()ed before free()ing this structure.
bool badsig
Bad cryptographic signature (needed to check encrypted s/mime-signatures)
struct Envelope * mime_headers
Memory hole protected headers.
LOFF_T length
length (in bytes) of attachment
struct ParameterList parameter
Parameters of the content-type.
bool use_disp
Content-Disposition uses filename= ?
char * description
content-description
unsigned int disposition
content-disposition, ContentDisposition
struct Body * next
next attachment in the list
char * subtype
content-type subtype
unsigned int encoding
content-transfer-encoding, ContentEncoding
bool goodsig
Good cryptographic signature.
bool warnsig
Maybe good signature.
unsigned int type
content-type primary type, ContentType
char * filename
When sending a message, this is the file to which this structure refers.
String manipulation buffer.
char * data
Pointer to data.
Internal cache for GPGME.
gpgme_validity_t validity
uid validity (cached for convenience)
KeyFlags flags
global and per uid flags (for convenience)
int idx
and the user ID at this index
struct CryptKeyInfo * next
Linked list.
const char * uid
and for convenience point to this user ID
The envelope/body of an email.
struct Envelope * env
Envelope information.
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
struct AddressList sender
Email's sender.
struct AddressList from
Email's 'From' list.
Cursor for converting a file's encoding.
A local copy of an email.
Container for Accounts, Notifications.
struct ConfigSubset * sub
Inherited config items.
Keep track when processing files.
StateFlags flags
Flags, e.g. STATE_DISPLAY.
FILE * fp_out
File to write to.
char * prefix
String to add to the beginning of each output line.
FILE * fp_in
File to read from.
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.
#define mutt_file_mkstemp()