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)
98#define PKA_NOTATION_NAME "pka-address@gnupg.org"
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)
123 const char *s = gpgme_get_ctx_flag(ctx,
"redraw");
140 const char *s =
"????????";
144 s = k->
kobj->subkeys->keyid;
146 if ((!c_pgp_long_ids) && (strlen(s) == 16))
165 const char *s =
"????????????????";
169 s = k->
kobj->subkeys->keyid;
182 const char *s =
"????????";
186 s = k->
kobj->subkeys->keyid;
204 s = k->
kobj->subkeys->fpr;
216 const char *s =
"????????????????";
220 if (k->
kobj->subkeys->fpr)
221 s = k->
kobj->subkeys->fpr;
223 s = k->
kobj->subkeys->keyid;
240 gpgme_key_ref(key->
kobj);
263 *keylist = (*keylist)->
next;
265 gpgme_key_unref(k->
kobj);
280 bool is_strong =
false;
287 case GPGME_VALIDITY_MARGINAL:
288 case GPGME_VALIDITY_NEVER:
289 case GPGME_VALIDITY_UNDEFINED:
290 case GPGME_VALIDITY_UNKNOWN:
294 case GPGME_VALIDITY_FULL:
295 case GPGME_VALIDITY_ULTIMATE:
363 gpgme_ctx_t ctx = NULL;
365 gpgme_error_t err = gpgme_new(&ctx);
370 err = gpgme_ctx_set_engine_info(ctx, GPGME_PROTOCOL_OpenPGP, NULL, c_autocrypt_dir);
373 if (err != GPG_ERR_NO_ERROR)
375 mutt_error(
_(
"error creating GPGME context: %s"), gpgme_strerror(err));
381 err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS);
382 if (err != GPG_ERR_NO_ERROR)
384 mutt_error(
_(
"error enabling CMS protocol: %s"), gpgme_strerror(err));
402 gpgme_data_t data = NULL;
404 gpgme_error_t err = gpgme_data_new(&data);
405 if (err != GPG_ERR_NO_ERROR)
407 mutt_error(
_(
"error creating GPGME data object: %s"), gpgme_strerror(err));
421 gpgme_error_t err = GPG_ERR_NO_ERROR;
422 gpgme_data_t data = NULL;
440 unsigned char buf[1];
444 while ((c = fgetc(fp_tmp)) != EOF)
452 if ((c ==
'\n') && !hadcr)
455 gpgme_data_write(
data, buf, 1);
462 gpgme_data_write(
data, buf, 1);
465 gpgme_data_seek(
data, 0, SEEK_SET);
471 if (err != GPG_ERR_NO_ERROR)
473 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
474 gpgme_data_release(
data);
495 gpgme_data_t
data = NULL;
497 gpgme_error_t err = gpgme_data_new_from_filepart(&
data, NULL, fp, offset, length);
498 if (err != GPG_ERR_NO_ERROR)
500 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
516 char buf[4096] = { 0 };
519 gpgme_error_t err = ((gpgme_data_seek(
data, 0, SEEK_SET) == -1) ?
520 gpgme_error_from_errno(errno) :
522 if (err != GPG_ERR_NO_ERROR)
524 mutt_error(
_(
"error rewinding data object: %s"), gpgme_strerror(err));
528 while ((nread = gpgme_data_read(
data, buf,
sizeof(buf))) > 0)
532 for (
char *p = buf; nread; p++, nread--)
546 mutt_error(
_(
"error reading data object: %s"), strerror(errno));
578 gpgme_error_t err = ((gpgme_data_seek(
data, 0, SEEK_SET) == -1) ?
579 gpgme_error_from_errno(errno) :
581 if (err == GPG_ERR_NO_ERROR)
583 char buf[4096] = { 0 };
585 while ((nread = gpgme_data_read(
data, buf,
sizeof(buf))) > 0)
587 if (fwrite(buf, nread, 1, fp) != 1)
602 mutt_error(
_(
"error reading data object: %s"), gpgme_strerror(err));
626 const char *s = keylist;
644 while ((*s !=
'\0') && (*s !=
' '))
647 }
while (*s !=
'\0');
660 gpgme_key_t key = NULL;
661 gpgme_key_t key2 = NULL;
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)
669 gpgme_release(listctx);
670 mutt_error(
_(
"secret key '%s' not found: %s"), address, gpgme_strerror(err));
676 fpr = key->subkeys->fpr ? key->subkeys->fpr : key->subkeys->keyid;
677 while (gpgme_op_keylist_next(listctx, &key2) == 0)
681 fpr2 = key2->subkeys->fpr ? key2->subkeys->fpr : key2->subkeys->keyid;
684 gpgme_key_unref(key);
685 gpgme_key_unref(key2);
686 gpgme_release(listctx);
687 mutt_error(
_(
"ambiguous specification of secret key '%s'"), address);
692 gpgme_key_unref(key2);
695 gpgme_op_keylist_end(listctx);
696 gpgme_release(listctx);
698 gpgme_signers_clear(ctx);
699 err = gpgme_signers_add(ctx, key);
700 gpgme_key_unref(key);
701 if (err != GPG_ERR_NO_ERROR)
703 mutt_error(
_(
"error setting secret key '%s': %s"), address, gpgme_strerror(err));
717static int set_signer(gpgme_ctx_t ctx,
const struct AddressList *al,
bool for_smime)
719 const char *signid = NULL;
726 signid = c_smime_sign_as ? c_smime_sign_as : c_smime_default_key;
732 signid = c_pgp_sign_as ? c_pgp_sign_as : c_pgp_default_key;
753 return (!signid && !al) ? 0 : -1;
764 if (err != GPG_ERR_NO_ERROR)
766 mutt_error(
_(
"error setting PKA signature notation: %s"), gpgme_strerror(err));
782 bool combined_signed,
const struct AddressList *from)
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;
799 gpgme_set_armor(ctx, 1);
812 if (err != GPG_ERR_NO_ERROR)
816 err = gpgme_op_encrypt_sign_ext(ctx, NULL,
buf_string(recpstring),
817 GPGME_ENCRYPT_ALWAYS_TRUST, plaintext, ciphertext);
821 err = gpgme_op_encrypt_ext(ctx, NULL,
buf_string(recpstring),
822 GPGME_ENCRYPT_ALWAYS_TRUST, plaintext, ciphertext);
826 if (err != GPG_ERR_NO_ERROR)
828 mutt_error(
_(
"error encrypting data: %s"), gpgme_strerror(err));
837 gpgme_data_release(ciphertext);
853static int get_micalg(gpgme_ctx_t ctx,
int use_smime,
char *buf,
size_t buflen)
855 gpgme_sign_result_t result = NULL;
856 const char *algorithm_name = NULL;
862 result = gpgme_op_sign_result(ctx);
863 if (result && result->signatures)
865 algorithm_name = gpgme_hash_algo_name(result->signatures->hash_algo);
871 snprintf(buf, buflen,
"%s", algorithm_name);
877 snprintf(buf, buflen,
"pgp-%s", algorithm_name);
883 return (buf[0] !=
'\0') ? 0 : -1;
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;
925 gpgme_set_armor(ctx, 1);
929 gpgme_data_release(signature);
930 gpgme_data_release(message);
939 if (err != GPG_ERR_NO_ERROR)
941 gpgme_data_release(signature);
942 gpgme_data_release(message);
948 err = gpgme_op_sign(ctx, message, signature, GPGME_SIG_MODE_DETACH);
950 gpgme_data_release(message);
951 if (err != GPG_ERR_NO_ERROR)
953 gpgme_data_release(signature);
955 mutt_error(
_(
"error signing data: %s"), gpgme_strerror(err));
960 sigres = gpgme_op_sign_result(ctx);
961 if (!sigres->signatures)
963 gpgme_data_release(signature);
965 mutt_error(
_(
"$pgp_sign_as unset and no default key specified in ~/.gnupg/gpg.conf"));
970 gpgme_data_release(signature);
986 use_smime ?
"application/pkcs7-signature" :
"application/pgp-signature");
989 if (
get_micalg(ctx, use_smime, buf,
sizeof(buf)) == 0)
1044 const struct AddressList *from)
1053 gpgme_data_release(plaintext);
1099 gpgme_data_release(plaintext);
1134 int idx,
struct State *state, gpgme_signature_t sig)
1139 bool severe =
false;
1141 if ((sum & GPGME_SIGSUM_KEY_REVOKED))
1143 state_puts(state,
_(
"Warning: One of the keys has been revoked\n"));
1147 if ((sum & GPGME_SIGSUM_KEY_EXPIRED))
1149 time_t at = key->subkeys->expires ? key->subkeys->expires : 0;
1152 state_puts(state,
_(
"Warning: The key used to create the signature expired at: "));
1158 state_puts(state,
_(
"Warning: At least one certification key has expired\n"));
1162 if ((sum & GPGME_SIGSUM_SIG_EXPIRED))
1164 gpgme_signature_t sig2 = NULL;
1167 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1169 for (sig2 = result->signatures, i = 0; sig2 && (i < idx); sig2 = sig2->next, i++)
1172 state_puts(state,
_(
"Warning: The signature expired at: "));
1173 print_time(sig2 ? sig2->exp_timestamp : 0, state);
1177 if ((sum & GPGME_SIGSUM_KEY_MISSING))
1179 state_puts(state,
_(
"Can't verify due to a missing key or certificate\n"));
1182 if ((sum & GPGME_SIGSUM_CRL_MISSING))
1184 state_puts(state,
_(
"The CRL is not available\n"));
1188 if ((sum & GPGME_SIGSUM_CRL_TOO_OLD))
1190 state_puts(state,
_(
"Available CRL is too old\n"));
1194 if ((sum & GPGME_SIGSUM_BAD_POLICY))
1195 state_puts(state,
_(
"A policy requirement was not met\n"));
1197 if ((sum & GPGME_SIGSUM_SYS_ERROR))
1199 const char *t0 = NULL, *t1 = NULL;
1200 gpgme_verify_result_t result = NULL;
1201 gpgme_signature_t sig2 = NULL;
1207 result = gpgme_op_verify_result(ctx);
1208 for (sig2 = result->signatures, i = 0; sig2 && (i < idx); sig2 = sig2->next, i++)
1214 t1 = sig2->wrong_key_usage ?
"Wrong_Key_Usage" :
"";
1233 if (c_crypt_use_pka)
1235 if ((sig->pka_trust == 1) && sig->pka_address)
1237 state_puts(state,
_(
"WARNING: PKA entry does not match signer's address: "));
1241 else if ((sig->pka_trust == 2) && sig->pka_address)
1243 state_puts(state,
_(
"PKA verified signer's address is: "));
1262 const char *prefix =
_(
"Fingerprint: ");
1264 const char *s = key->subkeys ? key->subkeys->fpr : NULL;
1267 bool is_pgp = (key->protocol == GPGME_PROTOCOL_OpenPGP);
1270 strcpy(buf, prefix);
1271 char *p = buf + strlen(buf);
1272 if (is_pgp && (strlen(s) == 40))
1274 for (
int i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++)
1287 for (
int i = 0; *s && s[1] && s[2]; s += 2, i++)
1291 *p++ = is_pgp ?
' ' :
':';
1292 if (is_pgp && (i == 7))
1314 gpgme_signature_t sig = NULL;
1315 const char *txt = NULL;
1317 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1319 for (sig = result->signatures; sig && (idx > 0); sig = sig->next, idx--)
1322 switch (sig ? sig->validity : 0)
1324 case GPGME_VALIDITY_UNKNOWN:
1325 txt =
_(
"WARNING: We have NO indication whether the key belongs to the person named as shown above\n");
1327 case GPGME_VALIDITY_UNDEFINED:
1329 case GPGME_VALIDITY_NEVER:
1330 txt =
_(
"WARNING: The key does NOT BELONG to the person named as shown above\n");
1332 case GPGME_VALIDITY_MARGINAL:
1333 txt =
_(
"WARNING: It is NOT certain that the key belongs to the person named as shown above\n");
1335 case GPGME_VALIDITY_FULL:
1336 case GPGME_VALIDITY_ULTIMATE:
1352 gpgme_key_t key,
struct State *state)
1362 for (gpgme_user_id_t uids = key->uids; uids; uids = uids->next)
1371 for (
int i = 0; i < msgwid; i++)
1392 state_puts(state,
_(
"no signature fingerprint available"));
1404 for (
int i = 0; i < msgwid; i++)
1426 const char *fpr = NULL;
1427 gpgme_key_t key = NULL;
1428 bool anybad =
false, anywarn =
false;
1429 gpgme_signature_t sig = NULL;
1430 gpgme_error_t err = GPG_ERR_NO_ERROR;
1432 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1439 for (i = 0, sig = result->signatures; sig && (i < idx); i++, sig = sig->next)
1452 const unsigned int sum = sig->summary;
1454 if (gpg_err_code(sig->status) != GPG_ERR_NO_ERROR)
1457 if (gpg_err_code(sig->status) != GPG_ERR_NO_PUBKEY)
1459 err = gpgme_get_key(ctx, fpr, &key, 0);
1460 if (err == GPG_ERR_NO_ERROR)
1480 else if (err != GPG_ERR_NO_ERROR)
1482 char buf[1024] = { 0 };
1483 snprintf(buf,
sizeof(buf),
_(
"Error getting key information for KeyID %s: %s\n"),
1484 fpr, gpgme_strerror(err));
1488 else if ((sum & GPGME_SIGSUM_GREEN))
1495 else if ((sum & GPGME_SIGSUM_RED))
1500 else if (!anybad && key && (key->protocol == GPGME_PROTOCOL_OpenPGP))
1515 if (sig->exp_timestamp)
1528 gpgme_key_unref(key);
1531 return anybad ? 1 : anywarn ? 2 : 0;
1551 gpgme_ctx_t ctx = NULL;
1552 gpgme_data_t message = NULL;
1561 gpgme_data_set_encoding(signature, GPGME_DATA_ENCODING_BASE64);
1563 gpgme_error_t err = gpgme_data_new_from_file(&message, tempfile, 1);
1564 if (err != GPG_ERR_NO_ERROR)
1566 gpgme_data_release(signature);
1567 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
1576 err = gpgme_op_verify(ctx, signature, message, NULL);
1577 gpgme_data_release(message);
1578 gpgme_data_release(signature);
1581 if (err != GPG_ERR_NO_ERROR)
1583 char buf[200] = { 0 };
1585 snprintf(buf,
sizeof(buf) - 1,
_(
"Error: verification failed: %s\n"),
1586 gpgme_strerror(err));
1591 gpgme_verify_result_t verify_result = NULL;
1599 verify_result = gpgme_op_verify_result(ctx);
1600 if (verify_result && verify_result->signatures)
1602 bool anybad =
false;
1618 gpgme_verify_result_t result = NULL;
1619 gpgme_sig_notation_t notation = NULL;
1620 gpgme_signature_t sig = NULL;
1622 result = gpgme_op_verify_result(ctx);
1625 for (sig = result->signatures; sig; sig = sig->next)
1627 int non_pka_notations = 0;
1628 for (notation = sig->notations; notation; notation = notation->next)
1630 non_pka_notations++;
1632 if (non_pka_notations)
1634 char buf[128] = { 0 };
1635 snprintf(buf,
sizeof(buf),
1636 _(
"*** Begin Notation (signature by: %s) ***\n"), sig->fpr);
1638 for (notation = sig->notations; notation; notation = notation->next)
1648 if (notation->value)
1651 if (!(*notation->value && (notation->value[strlen(notation->value) - 1] ==
'\n')))
1666 return badsig ? 1 : anywarn ? 2 : 0;
1674 return verify_one(b, state, tempfile,
false);
1699 FILE *fp_out,
bool is_smime,
int *r_is_signed)
1701 if (!b || !state || !fp_out)
1704 struct Body *tattach = NULL;
1705 gpgme_error_t err = GPG_ERR_NO_ERROR;
1706 gpgme_data_t ciphertext = NULL, plaintext = NULL;
1707 bool maybe_signed =
false;
1708 bool anywarn =
false;
1714 gpgme_ctx_t ctx = NULL;
1727 if ((!is_smime) || maybe_signed)
1730 err = gpgme_op_decrypt_verify(ctx, ciphertext, plaintext);
1731 else if (maybe_signed)
1732 err = gpgme_op_verify(ctx, ciphertext, NULL, plaintext);
1734 if (err == GPG_ERR_NO_ERROR)
1737 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
1738 if (verify_result->signatures)
1744 err = gpgme_op_decrypt(ctx, ciphertext, plaintext);
1746 gpgme_data_release(ciphertext);
1748 if (err != GPG_ERR_NO_ERROR)
1756 if (is_smime && !maybe_signed && (gpg_err_code(err) == GPG_ERR_NO_DATA))
1762 gpgme_decrypt_result_t result = NULL;
1764 result = gpgme_op_decrypt_result(ctx);
1765 if (result && !result->unsupported_algorithm)
1767 maybe_signed =
true;
1768 gpgme_data_release(plaintext);
1778 char buf[200] = { 0 };
1780 snprintf(buf,
sizeof(buf) - 1,
1781 _(
"[-- Error: decryption failed: %s --]\n\n"), gpgme_strerror(err));
1794 gpgme_data_release(plaintext);
1816 if (!anybad && idx && r_is_signed && *r_is_signed)
1817 *r_is_signed = anywarn ? 2 : 1;
1847 gpgme_data_release(ciphertext);
1848 gpgme_data_release(plaintext);
1859 struct State state = { 0 };
1860 struct Body *first_part = b;
1862 bool need_decode =
false;
1863 LOFF_T saved_offset = 0;
1864 size_t saved_length = 0;
1865 FILE *fp_decoded = NULL;
1888 state.
fp_in = fp_in;
1892 saved_offset = b->
offset;
1893 saved_length = b->
length;
1907 state.
fp_out = fp_decoded;
1912 b->
length = ftello(fp_decoded);
1915 state.
fp_in = fp_decoded;
1927 *b_dec =
decrypt_part(b, &state, *fp_out,
false, &is_signed);
1943 b->
length = saved_length;
1944 b->
offset = saved_offset;
1956 struct State state = { 0 };
1958 LOFF_T saved_b_offset;
1959 size_t saved_b_length;
1971 saved_b_offset = b->
offset;
1972 saved_b_length = b->
length;
1992 memset(&state, 0,
sizeof(state));
1993 state.
fp_in = fp_tmp;
2004 (*b_dec)->goodsig = is_signed > 0;
2005 b->
length = saved_b_length;
2006 b->
offset = saved_b_offset;
2018 struct Body *bb = *b_dec;
2020 saved_b_offset = bb->
offset;
2021 saved_b_length = bb->
length;
2022 memset(&state, 0,
sizeof(state));
2023 state.
fp_in = *fp_out;
2043 memset(&state, 0,
sizeof(state));
2044 state.
fp_in = fp_tmp2;
2055 b_tmp->
goodsig = is_signed > 0;
2056 bb->
length = saved_b_length;
2057 bb->
offset = saved_b_offset;
2063 return *b_dec ? 0 : -1;
2075 gpgme_ctx_t tmpctx = NULL;
2076 gpgme_key_t key = NULL;
2077 gpgme_user_id_t uid = NULL;
2078 gpgme_subkey_t subkey = NULL;
2079 const char *shortid = NULL;
2081 char date[256] = { 0 };
2095 gpgme_error_t err = gpgme_op_keylist_from_data_start(tmpctx, keydata, 0);
2096 while (err == GPG_ERR_NO_ERROR)
2098 err = gpgme_op_keylist_next(tmpctx, &key);
2099 if (err != GPG_ERR_NO_ERROR)
2102 subkey = key->subkeys;
2106 shortid = subkey->keyid;
2110 tt = subkey->timestamp;
2113 fprintf(*fp,
"%s %5.5s %u/%8s %s\n", more ?
"sub" :
"pub",
2114 gpgme_pubkey_algo_name(subkey->pubkey_algo), subkey->length, shortid, date);
2119 fprintf(*fp,
"uid %s\n",
NONULL(uid->uid));
2123 subkey = subkey->next;
2126 gpgme_key_unref(key);
2128 if (gpg_err_code(err) != GPG_ERR_EOF)
2140 gpgme_release(tmpctx);
2161 if ((b[n] ==
'\n') || ((b[n] ==
'\r') && (b[n + 1] ==
'\n')))
2176 char buf[8192] = { 0 };
2201 while (fgets(buf,
sizeof(buf), fp_tmp))
2242 for (; b; b = b->
next)
2269 gpgme_data_t keydata = NULL;
2270 gpgme_import_result_t impres = NULL;
2271 gpgme_import_status_t st = NULL;
2282 gpgme_error_t err = gpgme_data_new_from_stream(&keydata, fp_in);
2283 if (err != GPG_ERR_NO_ERROR)
2285 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
2289 err = gpgme_op_import(ctx, keydata);
2290 if (err != GPG_ERR_NO_ERROR)
2292 mutt_error(
_(
"Error importing key: %s"), gpgme_strerror(err));
2297 impres = gpgme_op_import_result(ctx);
2300 fputs(
"oops: no import result returned\n", stdout);
2304 for (st = impres->imports; st; st = st->next)
2308 printf(
"key %s imported (",
NONULL(st->fpr));
2312 if (st->status & GPGME_IMPORT_SECRET)
2314 printf(
"secret parts");
2317 if ((st->status & GPGME_IMPORT_NEW))
2319 printf(
"%snew key", any ?
", " :
"");
2322 if ((st->status & GPGME_IMPORT_UID))
2324 printf(
"%snew uid", any ?
", " :
"");
2327 if ((st->status & GPGME_IMPORT_SIG))
2329 printf(
"%snew sig", any ?
", " :
"");
2332 if ((st->status & GPGME_IMPORT_SUBKEY))
2334 printf(
"%snew subkey", any ?
", " :
"");
2337 printf(
"%s)\n", any ?
"" :
"not changed");
2346 for (st = impres->imports; st; st = st->next)
2348 if (st->result == 0)
2350 printf(
"key %s import failed: %s\n",
NONULL(st->fpr), gpgme_strerror(st->result));
2356 gpgme_data_release(keydata);
2377 char buf[8192] = { 0 };
2378 bool complete, armor_header;
2395 for (complete =
true, armor_header =
true;
2411 armor_header =
false;
2418 if ((buf[0] ==
'-') && (buf[1] ==
' '))
2434 bool pgp_keyblock =
false;
2435 bool clearsign =
false;
2440 char buf[8192] = { 0 };
2441 FILE *fp_out = NULL;
2443 gpgme_error_t err = GPG_ERR_NO_ERROR;
2444 gpgme_data_t armored_data = NULL;
2446 bool maybe_goodsig =
true;
2447 bool have_any_sigs =
false;
2449 char body_charset[256] = { 0 };
2450 char *gpgcharset = NULL;
2457 mutt_str_copy(body_charset,
"iso-8859-1",
sizeof(body_charset));
2465 for (bytes = b->
length; bytes > 0;)
2468 block_begin = last_pos;
2470 if (!fgets(buf,
sizeof(buf), state->
fp_in))
2473 LOFF_T offset = ftello(state->
fp_in);
2479 bytes -= (offset - last_pos);
2487 pgp_keyblock =
false;
2499 pgp_keyblock =
true;
2511 while ((bytes > 0) && (fgets(buf,
sizeof(buf) - 1, state->
fp_in) != NULL))
2513 offset = ftello(state->
fp_in);
2519 bytes -= (offset - last_pos);
2522 if (needpass &&
mutt_str_equal(
"-----END PGP MESSAGE-----\n", buf))
2527 if (!needpass && (
mutt_str_equal(
"-----END PGP SIGNATURE-----\n", buf) ||
2539 if ((l =
mutt_str_len(gpgcharset)) > 0 && gpgcharset[l - 1] ==
'\n')
2540 gpgcharset[l - 1] = 0;
2545 block_end = ftello(state->
fp_in);
2552 have_any_sigs = (have_any_sigs || (clearsign && (state->
flags &
STATE_VERIFY)));
2556 fseeko(state->
fp_in, block_end, 0);
2570 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2574 err = gpgme_op_decrypt_verify(ctx, armored_data, plaintext);
2575 if (gpg_err_code(err) == GPG_ERR_NO_DATA)
2578 gpgme_data_seek(armored_data, 0, SEEK_SET);
2580 gpgme_data_release(plaintext);
2582 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2587 if (err != GPG_ERR_NO_ERROR)
2589 char errbuf[200] = { 0 };
2591 snprintf(errbuf,
sizeof(errbuf) - 1,
2592 _(
"Error: decryption/verification failed: %s\n"), gpgme_strerror(err));
2601 bool sig_stat =
false;
2602 char *tmpfname = NULL;
2605 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
2606 if (verify_result->signatures)
2609 have_any_sigs =
false;
2610 maybe_goodsig =
false;
2614 bool anybad =
false;
2617 have_any_sigs =
true;
2624 maybe_goodsig =
true;
2638 state_puts(state,
_(
"Error: copy data failed\n"));
2641 gpgme_data_release(plaintext);
2652 else if (pgp_keyblock)
2665 char *expected_charset = gpgcharset && *gpgcharset ? gpgcharset :
"utf-8";
2672 if ((c ==
'\n') && state->
prefix)
2683 else if (pgp_keyblock)
2690 gpgme_data_release(armored_data);
2704 b->
goodsig = (maybe_goodsig && have_any_sigs);
2708 state_attach_puts(state,
_(
"[-- Error: could not find beginning of PGP message --]\n\n"));
2743 tattach->
goodsig = is_signed > 0;
2748 _(
"[-- The following data is PGP/MIME signed and encrypted --]\n\n") :
2749 _(
"[-- The following data is PGP/MIME encrypted --]\n\n"));
2761 FILE *fp_save = state->
fp_in;
2762 state->
fp_in = fp_out;
2764 state->
fp_in = fp_save;
2786 _(
"[-- End of PGP/MIME signed and encrypted data --]\n") :
2787 _(
"[-- End of PGP/MIME encrypted data --]\n"));
2837 tattach->
goodsig = is_signed > 0;
2842 _(
"[-- The following data is S/MIME signed --]\n\n") :
2843 _(
"[-- The following data is S/MIME encrypted --]\n\n"));
2855 FILE *fp_save = state->
fp_in;
2856 state->
fp_in = fp_out;
2858 state->
fp_in = fp_save;
2888 _(
"[-- End of S/MIME encrypted data --]\n"));
2908 unsigned int rc = 0;
2913 rc = key->can_encrypt;
2916 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2918 rc = subkey->can_encrypt;
2928 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2930 rc = subkey->can_sign;
2937 rc = key->can_certify;
2940 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2942 rc = subkey->can_certify;
2964 char *pattern = NULL, *p = NULL;
2965 const char *s = NULL;
2972 for (s = np->
data; *s; s++)
2974 if ((*s ==
'%') || (*s ==
'+'))
2990 for (s = np->
data; *s; s++)
3031 struct CryptKeyInfo *db = NULL, *k = NULL, **kend = NULL;
3032 gpgme_error_t err = GPG_ERR_NO_ERROR;
3033 gpgme_ctx_t ctx = NULL;
3034 gpgme_key_t key = NULL;
3036 gpgme_user_id_t
uid = NULL;
3069 err = gpgme_op_keylist_ext_start(ctx, (
const char **) patarr, secret, 0);
3070 for (n = 0; patarr[n]; n++)
3073 if (err != GPG_ERR_NO_ERROR)
3075 mutt_error(
_(
"gpgme_op_keylist_start failed: %s"), gpgme_strerror(err));
3081 while ((err = gpgme_op_keylist_next(ctx, &key)) == GPG_ERR_NO_ERROR)
3097 for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3101 gpgme_key_ref(k->kobj);
3107 k->validity = uid->validity;
3111 gpgme_key_unref(key);
3113 if (gpg_err_code(err) != GPG_ERR_EOF)
3114 mutt_error(
_(
"gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3115 gpgme_op_keylist_end(ctx);
3122 gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS);
3123 err = gpgme_op_keylist_start(ctx, pattern, 0);
3124 if (err != GPG_ERR_NO_ERROR)
3126 mutt_error(
_(
"gpgme_op_keylist_start failed: %s"), gpgme_strerror(err));
3132 while ((err = gpgme_op_keylist_next(ctx, &key)) == GPG_ERR_NO_ERROR)
3148 for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3152 gpgme_key_ref(k->kobj);
3158 k->validity = uid->validity;
3162 gpgme_key_unref(key);
3164 if (gpg_err_code(err) != GPG_ERR_EOF)
3165 mutt_error(
_(
"gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3166 gpgme_op_keylist_end(ctx);
3188 for (
char *t = strtok(scratch,
" ,.:\"()<>\n"); t; t = strtok(NULL,
" ,.:\"()<>\n"))
3207 KeyFlags abilities,
unsigned int app,
3208 bool *forced_valid,
bool oppenc_mode)
3213 int this_key_has_strong =
false;
3214 int this_key_has_addr_match =
false;
3240 for (k = keys; k; k = k->
next)
3244 if (abilities && !(k->flags & abilities))
3250 this_key_has_strong =
false;
3251 this_key_has_addr_match =
false;
3269 if (the_strong_valid_key && (the_strong_valid_key->
kobj != k->kobj))
3271 this_key_has_strong =
true;
3275 this_key_has_addr_match =
true;
3285 *matches_endp = tmp;
3286 matches_endp = &tmp->
next;
3288 if (this_key_has_strong)
3289 the_strong_valid_key = tmp;
3290 else if (this_key_has_addr_match)
3291 a_valid_addrmatch_key = tmp;
3299 if (oppenc_mode || !isatty(STDIN_FILENO))
3301 const bool c_crypt_opportunistic_encrypt_strong_keys =
3303 if (the_strong_valid_key)
3305 else if (a_valid_addrmatch_key && !c_crypt_opportunistic_encrypt_strong_keys)
3310 else if (the_strong_valid_key && !multi)
3319 k =
dlg_gpgme(matches, a, NULL, app, forced_valid);
3341 unsigned int app,
bool *forced_valid)
3347 const char *ps = NULL, *pl = NULL, *phint = NULL;
3362 for (k = keys; k; k = k->
next)
3364 if (abilities && !(k->
flags & abilities))
3377 *matches_endp = tmp;
3378 matches_endp = &tmp->
next;
3391 if (isatty(STDIN_FILENO))
3393 k =
dlg_gpgme(matches, NULL, p, app, forced_valid);
3425 unsigned int app,
bool *forced_valid)
3492static char *
find_keys(
const struct AddressList *addrlist,
unsigned int app,
bool oppenc_mode)
3495 struct ListNode *crypt_hook = NULL;
3496 const char *keyid = NULL;
3497 char *keylist = NULL;
3498 size_t keylist_size = 0;
3499 size_t keylist_used = 0;
3503 char buf[1024] = { 0 };
3504 bool forced_valid =
false;
3512 key_selected =
false;
3518 forced_valid =
false;
3523 keyid = crypt_hook->
data;
3525 if (!oppenc_mode && c_crypt_confirm_hook && isatty(STDIN_FILENO))
3527 snprintf(buf,
sizeof(buf),
_(
"Use keyID = \"%s\" for %s?"), keyid,
3537 goto bypass_selection;
3547 else if (!oppenc_mode)
3554 if (key_selected ||
STAILQ_NEXT(crypt_hook, entries))
3574 if (!k_info && !oppenc_mode && isatty(STDIN_FILENO))
3595 sprintf(keylist + keylist_used,
"%s0x%s%s", keylist_used ?
" " :
"",
3596 keyid, forced_valid ?
"!" :
"");
3599 key_selected =
true;
3607 }
while (crypt_hook);
3646 gpgme_error_t err = GPG_ERR_NO_ERROR;
3647 gpgme_key_t key = NULL;
3648 gpgme_user_id_t uid = NULL;
3656 if (gpgme_op_keylist_start(ctx, NULL, 1))
3661 while ((err = gpgme_op_keylist_next(ctx, &key)) == GPG_ERR_NO_ERROR)
3682 gpgme_key_ref(k->kobj);
3688 k->validity =
uid->validity;
3692 gpgme_key_unref(key);
3694 if (gpg_err_code(err) != GPG_ERR_EOF)
3695 mutt_error(
_(
"gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3696 gpgme_op_keylist_end(ctx);
3707 if (!(choice && choice->
kobj && choice->
kobj->subkeys && choice->
kobj->subkeys->fpr))
3726 gpgme_ctx_t ctx = NULL;
3727 gpgme_key_t export_keys[2] = { 0 };
3728 gpgme_data_t keydata = NULL;
3729 struct Body *att = NULL;
3730 char buf[1024] = { 0 };
3738 export_keys[0] = key->
kobj;
3739 export_keys[1] = NULL;
3742 gpgme_set_armor(ctx, 1);
3744 gpgme_error_t err = gpgme_op_export_keys(ctx, export_keys, 0, keydata);
3745 if (err != GPG_ERR_NO_ERROR)
3747 mutt_error(
_(
"Error exporting key: %s"), gpgme_strerror(err));
3765 snprintf(buf,
sizeof(buf),
_(
"PGP Key 0x%s"),
crypt_keyid(key));
3773 gpgme_data_release(keydata);
3786 static bool has_run =
false;
3790 gpgme_check_version(NULL);
3791 gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
3793 gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
3803 if (gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP) != GPG_ERR_NO_ERROR)
3805 mutt_error(
_(
"GPGME: OpenPGP protocol not available"));
3814 if (gpgme_engine_check_version(GPGME_PROTOCOL_CMS) != GPG_ERR_NO_ERROR)
3816 mutt_error(
_(
"GPGME: CMS protocol not available"));
3847 const char *prompt = NULL;
3848 const char *letters = NULL;
3849 const char *choices = NULL;
3867 prompt =
_(
"S/MIME (s)ign, sign (a)s, (p)gp, (c)lear, or (o)ppenc mode off?");
3869 letters =
_(
"sapco");
3875 prompt =
_(
"PGP (s)ign, sign (a)s, s/(m)ime, (c)lear, or (o)ppenc mode off?");
3877 letters =
_(
"samco");
3881 else if (c_crypt_opportunistic_encrypt)
3887 prompt =
_(
"S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp, (c)lear, or (o)ppenc mode?");
3889 letters =
_(
"esabpco");
3890 choices =
"esabpcO";
3895 prompt =
_(
"PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime, (c)lear, or (o)ppenc mode?");
3897 letters =
_(
"esabmco");
3898 choices =
"esabmcO";
3907 prompt =
_(
"S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp or (c)lear?");
3909 letters =
_(
"esabpc");
3915 prompt =
_(
"PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime or (c)lear?");
3917 letters =
_(
"esabmc");
3925 switch (choices[choice - 1])
3932 char input_signas[128] = { 0 };
3965 is_smime = !is_smime;
4025 struct Address *sender = NULL;
4044 gpgme_user_id_t uid = NULL;
4046 for (uid = key->uids; uid && rc; uid = uid->next)
4048 int uid_length = strlen(uid->email);
4049 if ((uid->email[0] ==
'<') && (uid->email[uid_length - 1] ==
'>') &&
4050 (uid_length == (sender_length + 2)))
4052 const char *at_sign = strchr(uid->email + 1,
'@');
4058 const char *tmp_email = uid->email + 1;
4061 int mailbox_length = at_sign - tmp_email + 1;
4062 int domainname_length = sender_length - mailbox_length;
4063 int mailbox_match, domainname_match;
4065 mailbox_match =
mutt_strn_equal(tmp_email, tmp_sender, mailbox_length);
4066 tmp_email += mailbox_length;
4067 tmp_sender += mailbox_length;
4068 domainname_match = (
mutt_istrn_cmp(tmp_email, tmp_sender, domainname_length) == 0);
4069 if (mailbox_match && domainname_match)
4123 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.
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?
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.
void crypt_convert_to_7bit(struct Body *b)
Convert an email to 7bit encoding.
SecurityFlags mutt_is_application_pgp(const struct Body *b)
Does the message use PGP?
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 int verify_one(struct Body *b, struct State *state, const char *tempfile, bool is_smime)
Do the actual verification step.
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.
static gpgme_data_t body_to_data_object(struct Body *b, bool convert)
Create GPGME object from the mail body.
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 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)
#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.
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.
#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 *b, const struct AddressList *from, bool use_smime)
Sign a message.
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.
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.
#define mutt_file_fclose(FP)
#define mutt_file_fopen(PATH, MODE)
bool OptAutocryptGpgme
(pseudo) use Autocrypt context inside ncrypt/crypt_gpgme.c
bool OptPgpCheckTrust
(pseudo) used by dlg_pgp()
bool crypt_keys_are_valid(struct CryptKeyInfo *keys)
Are all these keys valid?
int pgp_gpgme_application_handler(struct Body *b, struct State *state)
Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::applicat...
int smime_gpgme_application_handler(struct Body *b, struct State *state)
Manage the MIME type "application/pgp" or "application/smime" - Implements CryptModuleSpecs::applicat...
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() -.
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() -.
int pgp_gpgme_encrypted_handler(struct Body *b, struct State *state)
Manage a PGP or S/MIME encrypted MIME part - Implements CryptModuleSpecs::encrypted_handler() -.
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() -.
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() -.
void smime_gpgme_init(void)
Initialise the crypto module - Implements CryptModuleSpecs::init() -.
void pgp_gpgme_init(void)
Initialise the crypto module - Implements CryptModuleSpecs::init() -.
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() -.
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() -.
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...
struct Body * pgp_gpgme_make_key_attachment(void)
Generate a public key attachment - Implements CryptModuleSpecs::pgp_make_key_attachment() -.
void pgp_gpgme_set_sender(const char *sender)
Set the sender of the email - Implements CryptModuleSpecs::set_sender() -.
struct Body * smime_gpgme_sign_message(struct Body *b, const struct AddressList *from)
Cryptographically sign the Body of a message - Implements CryptModuleSpecs::sign_message() -.
struct Body * pgp_gpgme_sign_message(struct Body *b, const struct AddressList *from)
Cryptographically sign the Body of a message - Implements CryptModuleSpecs::sign_message() -.
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() -.
int smime_gpgme_verify_sender(struct Email *e, struct Message *msg)
Does the sender match the certificate? - Implements CryptModuleSpecs::smime_verify_sender() -.
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() -.
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() -.
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_email, struct State *state)
Handler for protected headers - 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(const 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.
bool mutt_ch_check_charset(const char *cs, bool strict)
Does iconv understand a character set?
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
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 *b, 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 *b, FILE *fp, struct ConfigSubset *sub)
Write a MIME part.
Convenience wrapper for the send headers.
void mutt_update_encoding(struct Body *b, struct ConfigSubset *sub)
Update the encoding type.
const char * mutt_fqdn(bool may_hide_host, const struct ConfigSubset *sub)
Get the Fully-Qualified Domain Name.
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.
FILE * fp_in
File to read from.
const char * prefix
String to add to the beginning of each output line.
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()