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)
94#define PKA_NOTATION_NAME "pka-address@gnupg.org"
96#define _LINE_COMPARE(_x, _y) line_compare(_x, sizeof(_x) - 1, _y)
97#define MESSAGE(_y) _LINE_COMPARE("MESSAGE-----", _y)
98#define SIGNED_MESSAGE(_y) _LINE_COMPARE("SIGNED MESSAGE-----", _y)
99#define PUBLIC_KEY_BLOCK(_y) _LINE_COMPARE("PUBLIC KEY BLOCK-----", _y)
100#define BEGIN_PGP_SIGNATURE(_y) \
101 _LINE_COMPARE("-----BEGIN PGP SIGNATURE-----", _y)
119 const char *s = gpgme_get_ctx_flag(ctx,
"redraw");
136 const char *s =
"????????";
140 s = k->
kobj->subkeys->keyid;
142 if ((!c_pgp_long_ids) && (strlen(s) == 16))
161 const char *s =
"????????????????";
165 s = k->
kobj->subkeys->keyid;
178 const char *s =
"????????";
182 s = k->
kobj->subkeys->keyid;
200 s = k->
kobj->subkeys->fpr;
212 const char *s =
"????????????????";
216 if (k->
kobj->subkeys->fpr)
217 s = k->
kobj->subkeys->fpr;
219 s = k->
kobj->subkeys->keyid;
236 gpgme_key_ref(key->
kobj);
259 *keylist = (*keylist)->
next;
261 gpgme_key_unref(k->
kobj);
276 bool is_strong =
false;
283 case GPGME_VALIDITY_MARGINAL:
284 case GPGME_VALIDITY_NEVER:
285 case GPGME_VALIDITY_UNDEFINED:
286 case GPGME_VALIDITY_UNKNOWN:
290 case GPGME_VALIDITY_FULL:
291 case GPGME_VALIDITY_ULTIMATE:
360 gpgme_ctx_t ctx = NULL;
362 gpgme_error_t err = gpgme_new(&ctx);
367 err = gpgme_ctx_set_engine_info(ctx, GPGME_PROTOCOL_OpenPGP, NULL, c_autocrypt_dir);
372 mutt_error(
_(
"error creating GPGME context: %s"), gpgme_strerror(err));
378 err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS);
381 mutt_error(
_(
"error enabling CMS protocol: %s"), gpgme_strerror(err));
399 gpgme_data_t data = NULL;
401 gpgme_error_t err = gpgme_data_new(&data);
404 mutt_error(
_(
"error creating GPGME data object: %s"), gpgme_strerror(err));
419 gpgme_data_t data = NULL;
437 unsigned char buf[1];
441 while ((c = fgetc(fp_tmp)) != EOF)
447 if ((c ==
'\n') && !hadcr)
450 gpgme_data_write(
data, buf, 1);
457 gpgme_data_write(
data, buf, 1);
460 gpgme_data_seek(
data, 0, SEEK_SET);
468 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
469 gpgme_data_release(
data);
490 gpgme_data_t
data = NULL;
492 int err = gpgme_data_new_from_filepart(&
data, NULL, fp, offset, length);
495 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
511 char buf[4096] = { 0 };
514 int err = ((gpgme_data_seek(
data, 0, SEEK_SET) == -1) ? gpgme_error_from_errno(errno) : 0);
517 mutt_error(
_(
"error rewinding data object: %s"), gpgme_strerror(err));
521 while ((nread = gpgme_data_read(
data, buf,
sizeof(buf))) > 0)
525 for (
char *p = buf; nread; p++, nread--)
539 mutt_error(
_(
"error reading data object: %s"), strerror(errno));
571 int err = ((gpgme_data_seek(
data, 0, SEEK_SET) == -1) ? gpgme_error_from_errno(errno) : 0);
574 char buf[4096] = { 0 };
576 while ((nread = gpgme_data_read(
data, buf,
sizeof(buf))) > 0)
578 if (fwrite(buf, nread, 1, fp) != 1)
593 mutt_error(
_(
"error reading data object: %s"), gpgme_strerror(err));
617 const char *s = keylist;
633 while ((*s !=
'\0') && (*s !=
' '))
636 }
while (*s !=
'\0');
650 gpgme_key_t key = NULL, key2 = NULL;
652 err = gpgme_op_keylist_start(listctx, address, 1);
654 err = gpgme_op_keylist_next(listctx, &key);
657 gpgme_release(listctx);
658 mutt_error(
_(
"secret key '%s' not found: %s"), address, gpgme_strerror(err));
664 fpr = key->subkeys->fpr ? key->subkeys->fpr : key->subkeys->keyid;
665 while (gpgme_op_keylist_next(listctx, &key2) == 0)
669 fpr2 = key2->subkeys->fpr ? key2->subkeys->fpr : key2->subkeys->keyid;
672 gpgme_key_unref(key);
673 gpgme_key_unref(key2);
674 gpgme_release(listctx);
675 mutt_error(
_(
"ambiguous specification of secret key '%s'"), address);
680 gpgme_key_unref(key2);
683 gpgme_op_keylist_end(listctx);
684 gpgme_release(listctx);
686 gpgme_signers_clear(ctx);
687 err = gpgme_signers_add(ctx, key);
688 gpgme_key_unref(key);
691 mutt_error(
_(
"error setting secret key '%s': %s"), address, gpgme_strerror(err));
705static int set_signer(gpgme_ctx_t ctx,
const struct AddressList *al,
bool for_smime)
707 const char *signid = NULL;
714 signid = c_smime_sign_as ? c_smime_sign_as : c_smime_default_key;
720 signid = c_pgp_sign_as ? c_pgp_sign_as : c_pgp_default_key;
741 return (!signid && !al) ? 0 : -1;
754 mutt_error(
_(
"error setting PKA signature notation: %s"), gpgme_strerror(err));
770 bool combined_signed,
const struct AddressList *from)
773 gpgme_ctx_t ctx = NULL;
774 gpgme_data_t ciphertext = NULL;
775 char *outfile = NULL;
787 gpgme_set_armor(ctx, 1);
805 GPGME_ENCRYPT_ALWAYS_TRUST, plaintext, ciphertext);
810 GPGME_ENCRYPT_ALWAYS_TRUST, plaintext, ciphertext);
816 mutt_error(
_(
"error encrypting data: %s"), gpgme_strerror(err));
825 gpgme_data_release(ciphertext);
841static int get_micalg(gpgme_ctx_t ctx,
int use_smime,
char *buf,
size_t buflen)
843 gpgme_sign_result_t result = NULL;
844 const char *algorithm_name = NULL;
850 result = gpgme_op_sign_result(ctx);
851 if (result && result->signatures)
853 algorithm_name = gpgme_hash_algo_name(result->signatures->hash_algo);
859 snprintf(buf, buflen,
"%s", algorithm_name);
865 snprintf(buf, buflen,
"pgp-%s", algorithm_name);
871 return (buf[0] !=
'\0') ? 0 : -1;
896 struct Body *t = NULL;
897 char *sigfile = NULL;
899 char buf[100] = { 0 };
900 gpgme_ctx_t ctx = NULL;
901 gpgme_data_t message = NULL, signature = NULL;
902 gpgme_sign_result_t sigres = NULL;
913 gpgme_set_armor(ctx, 1);
917 gpgme_data_release(signature);
918 gpgme_data_release(message);
929 gpgme_data_release(signature);
930 gpgme_data_release(message);
936 err = gpgme_op_sign(ctx, message, signature, GPGME_SIG_MODE_DETACH);
938 gpgme_data_release(message);
941 gpgme_data_release(signature);
943 mutt_error(
_(
"error signing data: %s"), gpgme_strerror(err));
948 sigres = gpgme_op_sign_result(ctx);
949 if (!sigres->signatures)
951 gpgme_data_release(signature);
953 mutt_error(
_(
"$pgp_sign_as unset and no default key specified in ~/.gnupg/gpg.conf"));
958 gpgme_data_release(signature);
974 use_smime ?
"application/pkcs7-signature" :
"application/pgp-signature");
977 if (
get_micalg(ctx, use_smime, buf,
sizeof(buf)) == 0)
1032 const struct AddressList *from)
1041 gpgme_data_release(plaintext);
1087 gpgme_data_release(plaintext);
1122 int idx,
struct State *state, gpgme_signature_t sig)
1127 bool severe =
false;
1129 if ((sum & GPGME_SIGSUM_KEY_REVOKED))
1131 state_puts(state,
_(
"Warning: One of the keys has been revoked\n"));
1135 if ((sum & GPGME_SIGSUM_KEY_EXPIRED))
1137 time_t at = key->subkeys->expires ? key->subkeys->expires : 0;
1140 state_puts(state,
_(
"Warning: The key used to create the signature expired at: "));
1146 state_puts(state,
_(
"Warning: At least one certification key has expired\n"));
1150 if ((sum & GPGME_SIGSUM_SIG_EXPIRED))
1152 gpgme_signature_t sig2 = NULL;
1155 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1157 for (sig2 = result->signatures, i = 0; sig2 && (i < idx); sig2 = sig2->next, i++)
1160 state_puts(state,
_(
"Warning: The signature expired at: "));
1161 print_time(sig2 ? sig2->exp_timestamp : 0, state);
1165 if ((sum & GPGME_SIGSUM_KEY_MISSING))
1167 state_puts(state,
_(
"Can't verify due to a missing key or certificate\n"));
1170 if ((sum & GPGME_SIGSUM_CRL_MISSING))
1172 state_puts(state,
_(
"The CRL is not available\n"));
1176 if ((sum & GPGME_SIGSUM_CRL_TOO_OLD))
1178 state_puts(state,
_(
"Available CRL is too old\n"));
1182 if ((sum & GPGME_SIGSUM_BAD_POLICY))
1183 state_puts(state,
_(
"A policy requirement was not met\n"));
1185 if ((sum & GPGME_SIGSUM_SYS_ERROR))
1187 const char *t0 = NULL, *t1 = NULL;
1188 gpgme_verify_result_t result = NULL;
1189 gpgme_signature_t sig2 = NULL;
1195 result = gpgme_op_verify_result(ctx);
1196 for (sig2 = result->signatures, i = 0; sig2 && (i < idx); sig2 = sig2->next, i++)
1202 t1 = sig2->wrong_key_usage ?
"Wrong_Key_Usage" :
"";
1210 if (t1 && !(t0 && (strcmp(t0, t1) == 0)))
1221 if (c_crypt_use_pka)
1223 if ((sig->pka_trust == 1) && sig->pka_address)
1225 state_puts(state,
_(
"WARNING: PKA entry does not match signer's address: "));
1229 else if ((sig->pka_trust == 2) && sig->pka_address)
1231 state_puts(state,
_(
"PKA verified signer's address is: "));
1250 const char *prefix =
_(
"Fingerprint: ");
1252 const char *s = key->subkeys ? key->subkeys->fpr : NULL;
1255 bool is_pgp = (key->protocol == GPGME_PROTOCOL_OpenPGP);
1258 strcpy(buf, prefix);
1259 char *p = buf + strlen(buf);
1260 if (is_pgp && (strlen(s) == 40))
1262 for (
int i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++)
1275 for (
int i = 0; *s && s[1] && s[2]; s += 2, i++)
1279 *p++ = is_pgp ?
' ' :
':';
1280 if (is_pgp && (i == 7))
1302 gpgme_signature_t sig = NULL;
1303 const char *txt = NULL;
1305 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1307 for (sig = result->signatures; sig && (idx > 0); sig = sig->next, idx--)
1310 switch (sig ? sig->validity : 0)
1312 case GPGME_VALIDITY_UNKNOWN:
1313 txt =
_(
"WARNING: We have NO indication whether the key belongs to the person named as shown above\n");
1315 case GPGME_VALIDITY_UNDEFINED:
1317 case GPGME_VALIDITY_NEVER:
1318 txt =
_(
"WARNING: The key does NOT BELONG to the person named as shown above\n");
1320 case GPGME_VALIDITY_MARGINAL:
1321 txt =
_(
"WARNING: It is NOT certain that the key belongs to the person named as shown above\n");
1323 case GPGME_VALIDITY_FULL:
1324 case GPGME_VALIDITY_ULTIMATE:
1340 gpgme_key_t key,
struct State *state)
1350 for (gpgme_user_id_t uids = key->uids; uids; uids = uids->next)
1359 for (
int i = 0; i < msgwid; i++)
1380 state_puts(state,
_(
"no signature fingerprint available"));
1392 for (
int i = 0; i < msgwid; i++)
1414 const char *fpr = NULL;
1415 gpgme_key_t key = NULL;
1416 bool anybad =
false, anywarn =
false;
1417 gpgme_signature_t sig = NULL;
1418 gpgme_error_t err = GPG_ERR_NO_ERROR;
1420 gpgme_verify_result_t result = gpgme_op_verify_result(ctx);
1427 for (i = 0, sig = result->signatures; sig && (i < idx); i++, sig = sig->next)
1440 const unsigned int sum = sig->summary;
1442 if (gpg_err_code(sig->status) != GPG_ERR_NO_ERROR)
1445 if (gpg_err_code(sig->status) != GPG_ERR_NO_PUBKEY)
1447 err = gpgme_get_key(ctx, fpr, &key, 0);
1468 char buf[1024] = { 0 };
1469 snprintf(buf,
sizeof(buf),
_(
"Error getting key information for KeyID %s: %s\n"),
1470 fpr, gpgme_strerror(err));
1474 else if ((sum & GPGME_SIGSUM_GREEN))
1481 else if ((sum & GPGME_SIGSUM_RED))
1486 else if (!anybad && key && (key->protocol == GPGME_PROTOCOL_OpenPGP))
1501 if (sig->exp_timestamp)
1514 gpgme_key_unref(key);
1517 return anybad ? 1 : anywarn ? 2 : 0;
1534 const char *tempfile,
bool is_smime)
1538 gpgme_ctx_t ctx = NULL;
1539 gpgme_data_t message = NULL;
1549 gpgme_data_set_encoding(signature, GPGME_DATA_ENCODING_BASE64);
1551 int err = gpgme_data_new_from_file(&message, tempfile, 1);
1554 gpgme_data_release(signature);
1555 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
1564 err = gpgme_op_verify(ctx, signature, message, NULL);
1565 gpgme_data_release(message);
1566 gpgme_data_release(signature);
1571 char buf[200] = { 0 };
1573 snprintf(buf,
sizeof(buf) - 1,
_(
"Error: verification failed: %s\n"),
1574 gpgme_strerror(err));
1579 gpgme_verify_result_t verify_result = NULL;
1587 verify_result = gpgme_op_verify_result(ctx);
1588 if (verify_result && verify_result->signatures)
1590 bool anybad =
false;
1606 gpgme_verify_result_t result = NULL;
1607 gpgme_sig_notation_t notation = NULL;
1608 gpgme_signature_t sig = NULL;
1610 result = gpgme_op_verify_result(ctx);
1613 for (sig = result->signatures; sig; sig = sig->next)
1615 int non_pka_notations = 0;
1616 for (notation = sig->notations; notation; notation = notation->next)
1618 non_pka_notations++;
1620 if (non_pka_notations)
1622 char buf[128] = { 0 };
1623 snprintf(buf,
sizeof(buf),
1624 _(
"*** Begin Notation (signature by: %s) ***\n"), sig->fpr);
1626 for (notation = sig->notations; notation; notation = notation->next)
1636 if (notation->value)
1639 if (!(*notation->value && (notation->value[strlen(notation->value) - 1] ==
'\n')))
1654 return badsig ? 1 : anywarn ? 2 : 0;
1662 return verify_one(sigbdy, state, tempfile,
false);
1670 return verify_one(sigbdy, state, tempfile,
true);
1687 FILE *fp_out,
bool is_smime,
int *r_is_signed)
1689 if (!a || !state || !fp_out)
1692 struct Body *tattach = NULL;
1694 gpgme_data_t ciphertext = NULL, plaintext = NULL;
1695 bool maybe_signed =
false;
1696 bool anywarn =
false;
1702 gpgme_ctx_t ctx = NULL;
1715 if ((!is_smime) || maybe_signed)
1718 err = gpgme_op_decrypt_verify(ctx, ciphertext, plaintext);
1719 else if (maybe_signed)
1720 err = gpgme_op_verify(ctx, ciphertext, NULL, plaintext);
1722 if (err == GPG_ERR_NO_ERROR)
1725 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
1726 if (verify_result->signatures)
1731 err = gpgme_op_decrypt(ctx, ciphertext, plaintext);
1732 gpgme_data_release(ciphertext);
1742 if (is_smime && !maybe_signed && (gpg_err_code(err) == GPG_ERR_NO_DATA))
1748 gpgme_decrypt_result_t result = NULL;
1750 result = gpgme_op_decrypt_result(ctx);
1751 if (!result->unsupported_algorithm)
1753 maybe_signed =
true;
1754 gpgme_data_release(plaintext);
1765 char buf[200] = { 0 };
1767 snprintf(buf,
sizeof(buf) - 1,
1768 _(
"[-- Error: decryption failed: %s --]\n\n"), gpgme_strerror(err));
1781 gpgme_data_release(plaintext);
1803 if (!anybad && idx && r_is_signed && *r_is_signed)
1804 *r_is_signed = anywarn ? 2 : 1;
1834 gpgme_data_release(ciphertext);
1835 gpgme_data_release(plaintext);
1846 struct State state = { 0 };
1847 struct Body *first_part = b;
1849 bool need_decode =
false;
1850 LOFF_T saved_offset = 0;
1851 size_t saved_length = 0;
1852 FILE *fp_decoded = NULL;
1873 state.
fp_in = fp_in;
1877 saved_offset = b->
offset;
1878 saved_length = b->
length;
1892 state.
fp_out = fp_decoded;
1897 b->
length = ftello(fp_decoded);
1900 state.
fp_in = fp_decoded;
1912 *cur =
decrypt_part(b, &state, *fp_out,
false, &is_signed);
1928 b->
length = saved_length;
1929 b->
offset = saved_offset;
1941 struct State state = { 0 };
1943 LOFF_T saved_b_offset;
1944 size_t saved_b_length;
1956 saved_b_offset = b->
offset;
1957 saved_b_length = b->
length;
1977 memset(&state, 0,
sizeof(state));
1978 state.
fp_in = fp_tmp;
1989 (*cur)->goodsig = is_signed > 0;
1990 b->
length = saved_b_length;
1991 b->
offset = saved_b_offset;
2003 struct Body *bb = *cur;
2005 saved_b_offset = bb->
offset;
2006 saved_b_length = bb->
length;
2007 memset(&state, 0,
sizeof(state));
2008 state.
fp_in = *fp_out;
2028 memset(&state, 0,
sizeof(state));
2029 state.
fp_in = fp_tmp2;
2040 b_tmp->
goodsig = is_signed > 0;
2041 bb->
length = saved_b_length;
2042 bb->
offset = saved_b_offset;
2048 return *cur ? 0 : -1;
2060 gpgme_ctx_t tmpctx = NULL;
2062 gpgme_key_t key = NULL;
2063 gpgme_user_id_t uid = NULL;
2064 gpgme_subkey_t subkey = NULL;
2065 const char *shortid = NULL;
2067 char date[256] = { 0 };
2081 err = gpgme_op_keylist_from_data_start(tmpctx, keydata, 0);
2084 err = gpgme_op_keylist_next(tmpctx, &key);
2088 subkey = key->subkeys;
2092 shortid = subkey->keyid;
2096 tt = subkey->timestamp;
2101 fprintf(*fp,
"sub %5.5s %u/%8s %s\n", gpgme_pubkey_algo_name(subkey->pubkey_algo),
2102 subkey->length, shortid, date);
2106 fprintf(*fp,
"pub %5.5s %u/%8s %s %s\n", gpgme_pubkey_algo_name(subkey->pubkey_algo),
2107 subkey->length, shortid, date, (uid ? uid->uid :
""));
2109 subkey = subkey->next;
2112 gpgme_key_unref(key);
2114 if (gpg_err_code(err) != GPG_ERR_EOF)
2126 gpgme_release(tmpctx);
2147 if ((b[n] ==
'\n') || ((b[n] ==
'\r') && (b[n + 1] ==
'\n')))
2162 char buf[8192] = { 0 };
2187 while (fgets(buf,
sizeof(buf), fp_tmp))
2228 for (; b; b = b->
next)
2253 gpgme_data_t keydata = NULL;
2254 gpgme_import_result_t impres = NULL;
2255 gpgme_import_status_t st = NULL;
2266 gpgme_error_t err = gpgme_data_new_from_stream(&keydata, fp_in);
2267 if (err != GPG_ERR_NO_ERROR)
2269 mutt_error(
_(
"error allocating data object: %s"), gpgme_strerror(err));
2273 err = gpgme_op_import(ctx, keydata);
2276 mutt_error(
_(
"Error importing key: %s"), gpgme_strerror(err));
2281 impres = gpgme_op_import_result(ctx);
2284 fputs(
"oops: no import result returned\n", stdout);
2288 for (st = impres->imports; st; st = st->next)
2292 printf(
"key %s imported (",
NONULL(st->fpr));
2296 if (st->status & GPGME_IMPORT_SECRET)
2298 printf(
"secret parts");
2301 if ((st->status & GPGME_IMPORT_NEW))
2303 printf(
"%snew key", any ?
", " :
"");
2306 if ((st->status & GPGME_IMPORT_UID))
2308 printf(
"%snew uid", any ?
", " :
"");
2311 if ((st->status & GPGME_IMPORT_SIG))
2313 printf(
"%snew sig", any ?
", " :
"");
2316 if ((st->status & GPGME_IMPORT_SUBKEY))
2318 printf(
"%snew subkey", any ?
", " :
"");
2321 printf(
"%s)\n", any ?
"" :
"not changed");
2330 for (st = impres->imports; st; st = st->next)
2332 if (st->result == 0)
2334 printf(
"key %s import failed: %s\n",
NONULL(st->fpr), gpgme_strerror(st->result));
2340 gpgme_data_release(keydata);
2361 char buf[8192] = { 0 };
2362 bool complete, armor_header;
2380 for (complete =
true, armor_header =
true;
2396 armor_header =
false;
2403 if ((buf[0] ==
'-') && (buf[1] ==
' '))
2419 bool pgp_keyblock =
false;
2420 bool clearsign =
false;
2423 char buf[8192] = { 0 };
2424 FILE *fp_out = NULL;
2426 gpgme_error_t err = 0;
2427 gpgme_data_t armored_data = NULL;
2429 bool maybe_goodsig =
true;
2430 bool have_any_sigs =
false;
2432 char body_charset[256] = { 0 };
2439 mutt_str_copy(body_charset,
"iso-8859-1",
sizeof(body_charset));
2447 for (bytes = m->
length; bytes > 0;)
2449 if (!fgets(buf,
sizeof(buf), state->
fp_in))
2452 LOFF_T offset = ftello(state->
fp_in);
2453 bytes -= (offset - last_pos);
2471 pgp_keyblock =
true;
2482 have_any_sigs = (have_any_sigs || (clearsign && (state->
flags &
STATE_VERIFY)));
2497 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2500 err = gpgme_op_decrypt_verify(ctx, armored_data, plaintext);
2501 if (gpg_err_code(err) == GPG_ERR_NO_DATA)
2504 gpgme_data_seek(armored_data, 0, SEEK_SET);
2506 gpgme_data_release(plaintext);
2508 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2515 char errbuf[200] = { 0 };
2517 snprintf(errbuf,
sizeof(errbuf) - 1,
2518 _(
"Error: decryption/verification failed: %s\n"), gpgme_strerror(err));
2527 bool sig_stat =
false;
2528 char *tmpfname = NULL;
2532 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
2533 if (verify_result->signatures)
2537 have_any_sigs =
false;
2538 maybe_goodsig =
false;
2542 bool anybad =
false;
2545 have_any_sigs =
true;
2552 maybe_goodsig =
true;
2566 state_puts(state,
_(
"Error: copy data failed\n"));
2569 gpgme_data_release(plaintext);
2580 else if (pgp_keyblock)
2600 if ((c ==
'\n') && state->
prefix)
2611 else if (pgp_keyblock)
2617 gpgme_data_release(armored_data);
2630 m->
goodsig = (maybe_goodsig && have_any_sigs);
2634 state_attach_puts(state,
_(
"[-- Error: could not find beginning of PGP message --]\n\n"));
2669 tattach->
goodsig = is_signed > 0;
2674 _(
"[-- The following data is PGP/MIME signed and encrypted --]\n\n") :
2675 _(
"[-- The following data is PGP/MIME encrypted --]\n\n"));
2688 FILE *fp_save = state->
fp_in;
2689 state->
fp_in = fp_out;
2691 state->
fp_in = fp_save;
2714 _(
"[-- End of PGP/MIME signed and encrypted data --]\n") :
2715 _(
"[-- End of PGP/MIME encrypted data --]\n"));
2765 tattach->
goodsig = is_signed > 0;
2770 _(
"[-- The following data is S/MIME signed --]\n\n") :
2771 _(
"[-- The following data is S/MIME encrypted --]\n\n"));
2784 FILE *fp_save = state->
fp_in;
2785 state->
fp_in = fp_out;
2787 state->
fp_in = fp_save;
2818 _(
"[-- End of S/MIME encrypted data --]\n"));
2838 unsigned int rc = 0;
2843 rc = key->can_encrypt;
2846 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2848 rc = subkey->can_encrypt;
2858 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2860 rc = subkey->can_sign;
2867 rc = key->can_certify;
2870 for (gpgme_subkey_t subkey = key->subkeys; subkey; subkey = subkey->next)
2872 rc = subkey->can_certify;
2894 char *pattern = NULL, *p = NULL;
2895 const char *s = NULL;
2902 for (s = np->
data; *s; s++)
2904 if ((*s ==
'%') || (*s ==
'+'))
2920 for (s = np->
data; *s; s++)
2957 struct CryptKeyInfo *db = NULL, *k = NULL, **kend = NULL;
2959 gpgme_ctx_t ctx = NULL;
2960 gpgme_key_t key = NULL;
2962 gpgme_user_id_t
uid = NULL;
2995 err = gpgme_op_keylist_ext_start(ctx, (
const char **) patarr, secret, 0);
2996 for (n = 0; patarr[n]; n++)
3001 mutt_error(
_(
"gpgme_op_keylist_start failed: %s"), gpgme_strerror(err));
3007 while ((err = gpgme_op_keylist_next(ctx, &key)) == 0)
3023 for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3027 gpgme_key_ref(k->kobj);
3033 k->validity = uid->validity;
3037 gpgme_key_unref(key);
3039 if (gpg_err_code(err) != GPG_ERR_EOF)
3040 mutt_error(
_(
"gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3041 gpgme_op_keylist_end(ctx);
3048 gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS);
3049 err = gpgme_op_keylist_start(ctx, pattern, 0);
3052 mutt_error(
_(
"gpgme_op_keylist_start failed: %s"), gpgme_strerror(err));
3058 while ((err = gpgme_op_keylist_next(ctx, &key)) == 0)
3074 for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
3078 gpgme_key_ref(k->kobj);
3084 k->validity = uid->validity;
3088 gpgme_key_unref(key);
3090 if (gpg_err_code(err) != GPG_ERR_EOF)
3091 mutt_error(
_(
"gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3092 gpgme_op_keylist_end(ctx);
3114 for (
char *t = strtok(scratch,
" ,.:\"()<>\n"); t; t = strtok(NULL,
" ,.:\"()<>\n"))
3133 KeyFlags abilities,
unsigned int app,
3134 bool *forced_valid,
bool oppenc_mode)
3139 int this_key_has_strong =
false;
3140 int this_key_has_addr_match =
false;
3166 for (k = keys; k; k = k->
next)
3170 if (abilities && !(k->flags & abilities))
3176 this_key_has_strong =
false;
3177 this_key_has_addr_match =
false;
3195 if (the_strong_valid_key && (the_strong_valid_key->
kobj != k->kobj))
3197 this_key_has_strong =
true;
3200 this_key_has_addr_match =
true;
3209 *matches_endp = tmp;
3210 matches_endp = &tmp->
next;
3212 if (this_key_has_strong)
3213 the_strong_valid_key = tmp;
3214 else if (this_key_has_addr_match)
3215 a_valid_addrmatch_key = tmp;
3225 const bool c_crypt_opportunistic_encrypt_strong_keys =
3227 if (the_strong_valid_key)
3229 else if (a_valid_addrmatch_key && !c_crypt_opportunistic_encrypt_strong_keys)
3234 else if (the_strong_valid_key && !multi)
3263 unsigned int app,
bool *forced_valid)
3269 const char *ps = NULL, *pl = NULL, *phint = NULL;
3284 for (k = keys; k; k = k->
next)
3286 if (abilities && !(k->
flags & abilities))
3299 *matches_endp = tmp;
3300 matches_endp = &tmp->
next;
3334 unsigned int app,
bool *forced_valid)
3399static char *
find_keys(
const struct AddressList *addrlist,
unsigned int app,
bool oppenc_mode)
3402 struct ListNode *crypt_hook = NULL;
3403 const char *keyid = NULL;
3404 char *keylist = NULL;
3405 size_t keylist_size = 0;
3406 size_t keylist_used = 0;
3410 char buf[1024] = { 0 };
3411 bool forced_valid =
false;
3418 key_selected =
false;
3424 forced_valid =
false;
3429 keyid = crypt_hook->
data;
3432 if (!oppenc_mode && c_crypt_confirm_hook)
3434 snprintf(buf,
sizeof(buf),
_(
"Use keyID = \"%s\" for %s?"), keyid, p->
mailbox);
3443 goto bypass_selection;
3453 else if (!oppenc_mode)
3460 if (key_selected ||
STAILQ_NEXT(crypt_hook, entries))
3480 if (!k_info && !oppenc_mode)
3482 snprintf(buf,
sizeof(buf),
_(
"Enter keyID for %s: "), p->
mailbox);
3500 sprintf(keylist + keylist_used,
"%s0x%s%s", keylist_used ?
" " :
"",
3501 keyid, forced_valid ?
"!" :
"");
3504 key_selected =
true;
3512 }
while (crypt_hook);
3552 gpgme_key_t key = NULL;
3553 gpgme_user_id_t uid = NULL;
3561 if (gpgme_op_keylist_start(ctx, NULL, 1))
3566 while (!(err = gpgme_op_keylist_next(ctx, &key)))
3587 gpgme_key_ref(k->kobj);
3593 k->validity =
uid->validity;
3597 gpgme_key_unref(key);
3599 if (gpg_err_code(err) != GPG_ERR_EOF)
3600 mutt_error(
_(
"gpgme_op_keylist_next failed: %s"), gpgme_strerror(err));
3601 gpgme_op_keylist_end(ctx);
3612 if (!(choice && choice->
kobj && choice->
kobj->subkeys && choice->
kobj->subkeys->fpr))
3631 gpgme_ctx_t context = NULL;
3632 gpgme_key_t export_keys[2] = { 0 };
3633 gpgme_data_t keydata = NULL;
3635 struct Body *att = NULL;
3636 char buf[1024] = { 0 };
3644 export_keys[0] = key->
kobj;
3645 export_keys[1] = NULL;
3648 gpgme_set_armor(context, 1);
3650 err = gpgme_op_export_keys(context, export_keys, 0, keydata);
3651 if (err != GPG_ERR_NO_ERROR)
3653 mutt_error(
_(
"Error exporting key: %s"), gpgme_strerror(err));
3671 snprintf(buf,
sizeof(buf),
_(
"PGP Key 0x%s"),
crypt_keyid(key));
3679 gpgme_data_release(keydata);
3680 gpgme_release(context);
3692 static bool has_run =
false;
3696 gpgme_check_version(NULL);
3697 gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
3699 gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
3709 if (gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP) != GPG_ERR_NO_ERROR)
3711 mutt_error(
_(
"GPGME: OpenPGP protocol not available"));
3720 if (gpgme_engine_check_version(GPGME_PROTOCOL_CMS) != GPG_ERR_NO_ERROR)
3722 mutt_error(
_(
"GPGME: CMS protocol not available"));
3753 const char *prompt = NULL;
3754 const char *letters = NULL;
3755 const char *choices = NULL;
3773 prompt =
_(
"S/MIME (s)ign, sign (a)s, (p)gp, (c)lear, or (o)ppenc mode off?");
3775 letters =
_(
"sapco");
3781 prompt =
_(
"PGP (s)ign, sign (a)s, s/(m)ime, (c)lear, or (o)ppenc mode off?");
3783 letters =
_(
"samco");
3788 else if (c_crypt_opportunistic_encrypt)
3793 prompt =
_(
"S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp, (c)lear, or (o)ppenc mode?");
3795 letters =
_(
"esabpco");
3796 choices =
"esabpcO";
3801 prompt =
_(
"PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime, (c)lear, or (o)ppenc mode?");
3803 letters =
_(
"esabmco");
3804 choices =
"esabmcO";
3813 prompt =
_(
"S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp or (c)lear?");
3815 letters =
_(
"esabpc");
3821 prompt =
_(
"PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime or (c)lear?");
3823 letters =
_(
"esabmc");
3831 switch (choices[choice - 1])
3838 char input_signas[128] = { 0 };
3871 is_smime = !is_smime;
3931 struct Address *sender = NULL;
3950 gpgme_user_id_t uid = NULL;
3951 int sender_length = strlen(sender->
mailbox);
3952 for (uid = key->uids; uid && rc; uid = uid->next)
3954 int uid_length = strlen(uid->email);
3955 if ((uid->email[0] ==
'<') && (uid->email[uid_length - 1] ==
'>') &&
3956 (uid_length == (sender_length + 2)))
3958 const char *at_sign = strchr(uid->email + 1,
'@');
3964 const char *tmp_email = uid->email + 1;
3965 const char *tmp_sender = sender->
mailbox;
3967 int mailbox_length = at_sign - tmp_email + 1;
3968 int domainname_length = sender_length - mailbox_length;
3969 int mailbox_match, domainname_match;
3971 mailbox_match =
mutt_strn_equal(tmp_email, tmp_sender, mailbox_length);
3972 tmp_email += mailbox_length;
3973 tmp_sender += mailbox_length;
3974 domainname_match = (
mutt_istrn_cmp(tmp_email, tmp_sender, domainname_length) == 0);
3975 if (mailbox_match && domainname_match)
4025 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 mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
size_t mutt_buffer_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
char * mutt_buffer_strdup(const struct Buffer *buf)
Copy a Buffer's string.
static const char * mutt_buffer_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.
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.
struct CryptKeyInfo * crypt_copy_key(struct CryptKeyInfo *key)
Return a copy of KEY.
static struct CryptKeyInfo * crypt_ask_for_key(char *tag, char *whatfor, KeyFlags abilities, unsigned int app, bool *forced_valid)
Ask the user for a key.
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 struct CryptCache * id_defaults
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 char * current_sender
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 gpgme_key_t signature_key
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.
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 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.
size_t mutt_date_localtime_format(char *buf, size_t buflen, const char *format, time_t t)
Format localtime.
struct CryptKeyInfo * dlg_select_gpgme_key(struct CryptKeyInfo *keys, struct Address *p, const char *s, unsigned int app, bool *forced_valid)
Get the user to select a key.
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.
int mutt_buffer_get_field(const char *field, struct Buffer *buf, CompletionFlags complete, bool multiple, struct Mailbox *m, char ***files, int *numfiles)
Ask the user for a string.
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.
#define mutt_file_mkstemp()
bool OptAutocryptGpgme
(pseudo) use Autocrypt context inside ncrypt/crypt_gpgme.c
bool OptPgpCheckTrust
(pseudo) used by dlg_select_pgp_key()
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() -.
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.
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.
void mutt_ch_fgetconv_close(struct FgetConv **fc)
Close an fgetconv handle.
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.
#define MUTT_ICONV_HOOK_FROM
apply charset-hooks to fromcode
#define MUTT_ICONV_NO_FLAGS
No flags are set.
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)
Some miscellaneous functions.
#define mutt_buffer_mktemp(buf)
#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.
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.
static size_t plen
Length of cached packet.
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from 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 mutt_yesorno(const char *msg, enum QuadOption def)
Ask the user a Yes/No question.
int mutt_multi_choice(const char *prompt, const char *letters)
Offer the user a multiple choice question.
#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.
char * mailbox
Mailbox and host address.
char * personal
Real name of 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.