NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
find_keys()

Find the keyids of the recipients of a message. More...

+ Collaboration diagram for find_keys():

Functions

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() -.
 
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_class_find_keys (const struct AddressList *addrlist, bool oppenc_mode)
 Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.
 
char * smime_class_find_keys (const struct AddressList *al, bool oppenc_mode)
 Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.
 

Detailed Description

Find the keyids of the recipients of a message.

Parameters
addrlistAddress List
oppenc_modeIf true, use opportunistic encryption
Return values
ptrSpace-separated string of keys
NULLAt least one of the keys can't be found

If oppenc_mode is true, only keys that can be determined without prompting will be used.

Function Documentation

◆ pgp_gpgme_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() -.

Definition at line 3659 of file crypt_gpgme.c.

3660{
3661 return find_keys(addrlist, APPLICATION_PGP, oppenc_mode);
3662}
static char * find_keys(const struct AddressList *addrlist, unsigned int app, bool oppenc_mode)
Find keys of the recipients of the message.
Definition: crypt_gpgme.c:3534
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
+ Here is the call graph for this function:

◆ smime_gpgme_find_keys()

char * smime_gpgme_find_keys ( const struct AddressList *  addrlist,
bool  oppenc_mode 
)

Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.

Definition at line 3667 of file crypt_gpgme.c.

3668{
3669 return find_keys(addrlist, APPLICATION_SMIME, oppenc_mode);
3670}
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:91
+ Here is the call graph for this function:

◆ pgp_class_find_keys()

char * pgp_class_find_keys ( const struct AddressList *  addrlist,
bool  oppenc_mode 
)

Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.

Definition at line 1463 of file pgp.c.

1464{
1465 struct ListHead crypt_hook_list = STAILQ_HEAD_INITIALIZER(crypt_hook_list);
1466 struct ListNode *crypt_hook = NULL;
1467 const char *keyid = NULL;
1468 char *keylist = NULL;
1469 size_t keylist_size = 0;
1470 size_t keylist_used = 0;
1471 struct Address *p = NULL;
1472 struct PgpKeyInfo *k_info = NULL;
1473 const char *fqdn = mutt_fqdn(true, NeoMutt->sub);
1474 char buf[1024] = { 0 };
1475 bool key_selected;
1476 struct AddressList hookal = TAILQ_HEAD_INITIALIZER(hookal);
1477
1478 struct Address *a = NULL;
1479 const bool c_crypt_confirm_hook = cs_subset_bool(NeoMutt->sub, "crypt_confirm_hook");
1480 TAILQ_FOREACH(a, addrlist, entries)
1481 {
1482 key_selected = false;
1483 mutt_crypt_hook(&crypt_hook_list, a);
1484 crypt_hook = STAILQ_FIRST(&crypt_hook_list);
1485 do
1486 {
1487 p = a;
1488 k_info = NULL;
1489
1490 if (crypt_hook)
1491 {
1492 keyid = crypt_hook->data;
1493 enum QuadOption ans = MUTT_YES;
1494 if (!oppenc_mode && c_crypt_confirm_hook && isatty(STDIN_FILENO))
1495 {
1496 snprintf(buf, sizeof(buf), _("Use keyID = \"%s\" for %s?"), keyid,
1497 buf_string(p->mailbox));
1498 ans = query_yesorno_help(buf, MUTT_YES, NeoMutt->sub, "crypt_confirm_hook");
1499 }
1500 if (ans == MUTT_YES)
1501 {
1502 if (crypt_is_numerical_keyid(keyid))
1503 {
1504 if (mutt_strn_equal(keyid, "0x", 2))
1505 keyid += 2;
1506 goto bypass_selection; /* you don't see this. */
1507 }
1508
1509 /* check for e-mail address */
1510 mutt_addrlist_clear(&hookal);
1511 if (strchr(keyid, '@') && (mutt_addrlist_parse(&hookal, keyid) != 0))
1512 {
1513 mutt_addrlist_qualify(&hookal, fqdn);
1514 p = TAILQ_FIRST(&hookal);
1515 }
1516 else if (!oppenc_mode)
1517 {
1519 }
1520 }
1521 else if (ans == MUTT_NO)
1522 {
1523 if (key_selected || STAILQ_NEXT(crypt_hook, entries))
1524 {
1525 crypt_hook = STAILQ_NEXT(crypt_hook, entries);
1526 continue;
1527 }
1528 }
1529 else if (ans == MUTT_ABORT)
1530 {
1531 FREE(&keylist);
1532 mutt_addrlist_clear(&hookal);
1533 mutt_list_free(&crypt_hook_list);
1534 return NULL;
1535 }
1536 }
1537
1538 if (!k_info)
1539 {
1541 k_info = pgp_getkeybyaddr(p, KEYFLAG_CANENCRYPT, PGP_PUBRING, oppenc_mode);
1542 }
1543
1544 if (!k_info && !oppenc_mode && isatty(STDIN_FILENO))
1545 {
1546 snprintf(buf, sizeof(buf), _("Enter keyID for %s: "), buf_string(p->mailbox));
1548 }
1549
1550 if (!k_info)
1551 {
1552 FREE(&keylist);
1553 mutt_addrlist_clear(&hookal);
1554 mutt_list_free(&crypt_hook_list);
1555 return NULL;
1556 }
1557
1558 keyid = pgp_fpr_or_lkeyid(k_info);
1559
1560 bypass_selection:
1561 keylist_size += mutt_str_len(keyid) + 4;
1562 mutt_mem_realloc(&keylist, keylist_size);
1563 sprintf(keylist + keylist_used, "%s0x%s", keylist_used ? " " : "", keyid);
1564 keylist_used = mutt_str_len(keylist);
1565
1566 key_selected = true;
1567
1568 pgp_key_free(&k_info);
1569 mutt_addrlist_clear(&hookal);
1570
1571 if (crypt_hook)
1572 crypt_hook = STAILQ_NEXT(crypt_hook, entries);
1573
1574 } while (crypt_hook);
1575
1576 mutt_list_free(&crypt_hook_list);
1577 }
1578 return keylist;
1579}
void mutt_addrlist_qualify(struct AddressList *al, const char *host)
Expand local names in an Address list using a hostname.
Definition: address.c:680
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1460
int mutt_addrlist_parse(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:480
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
bool crypt_is_numerical_keyid(const char *s)
Is this a numerical keyid.
Definition: crypt.c:1469
void pgp_class_invoke_getkeys(struct Address *addr)
Run a command to download a PGP key - Implements CryptModuleSpecs::pgp_invoke_getkeys() -.
Definition: pgpinvoke.c:383
void mutt_crypt_hook(struct ListHead *list, struct Address *addr)
Find crypto hooks for an Address.
Definition: hook.c:870
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:123
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:115
#define FREE(x)
Definition: memory.h:45
#define _(a)
Definition: message.h:28
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
Definition: string.c:425
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
#define KEYFLAG_CANENCRYPT
Key is suitable for encryption.
Definition: lib.h:128
char * pgp_fpr_or_lkeyid(struct PgpKeyInfo *k)
Get the fingerprint or long keyid.
Definition: pgp.c:234
struct PgpKeyInfo * pgp_ask_for_key(char *tag, const char *whatfor, KeyFlags abilities, enum PgpRing keyring)
Ask the user for a PGP key.
Definition: pgpkey.c:199
struct PgpKeyInfo * pgp_getkeybyaddr(struct Address *a, KeyFlags abilities, enum PgpRing keyring, bool oppenc_mode)
Find a PGP key by address.
Definition: pgpkey.c:376
struct PgpKeyInfo * pgp_getkeybystr(const char *cp, KeyFlags abilities, enum PgpRing keyring)
Find a PGP key by string.
Definition: pgpkey.c:515
@ PGP_PUBRING
Public keys.
Definition: pgpkey.h:39
void pgp_key_free(struct PgpKeyInfo **kpp)
Free a PGP key info.
Definition: pgplib.c:201
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition: quad.h:37
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition: quad.h:38
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption query_yesorno_help(const char *prompt, enum QuadOption def, struct ConfigSubset *sub, const char *name)
Ask the user a Yes/No question offering help.
Definition: question.c:341
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
#define STAILQ_FIRST(head)
Definition: queue.h:350
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:637
#define STAILQ_NEXT(elm, field)
Definition: queue.h:400
const char * mutt_fqdn(bool may_hide_host, const struct ConfigSubset *sub)
Get the Fully-Qualified Domain Name.
Definition: sendlib.c:707
An email address.
Definition: address.h:36
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
A List node for strings.
Definition: list.h:37
char * data
String.
Definition: list.h:38
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
Information about a PGP key.
Definition: pgplib.h:47
+ Here is the call graph for this function:

◆ smime_class_find_keys()

char * smime_class_find_keys ( const struct AddressList *  al,
bool  oppenc_mode 
)

Find the keyids of the recipients of a message - Implements CryptModuleSpecs::find_keys() -.

Definition at line 798 of file smime.c.

799{
800 struct SmimeKey *key = NULL;
801 char *keyid = NULL, *keylist = NULL;
802 size_t keylist_size = 0;
803 size_t keylist_used = 0;
804
805 struct Address *a = NULL;
806 TAILQ_FOREACH(a, al, entries)
807 {
808 key = smime_get_key_by_addr(buf_string(a->mailbox), KEYFLAG_CANENCRYPT, true, oppenc_mode);
809 if (!key && !oppenc_mode && isatty(STDIN_FILENO))
810 {
811 char buf[1024] = { 0 };
812 snprintf(buf, sizeof(buf), _("Enter keyID for %s: "), buf_string(a->mailbox));
813 key = smime_ask_for_key(buf, KEYFLAG_CANENCRYPT, true);
814 }
815 if (!key)
816 {
817 if (!oppenc_mode)
818 mutt_message(_("No (valid) certificate found for %s"), buf_string(a->mailbox));
819 FREE(&keylist);
820 return NULL;
821 }
822
823 keyid = key->hash;
824 keylist_size += mutt_str_len(keyid) + 2;
825 mutt_mem_realloc(&keylist, keylist_size);
826 sprintf(keylist + keylist_used, "%s%s", keylist_used ? " " : "", keyid);
827 keylist_used = mutt_str_len(keylist);
828
829 smime_key_free(&key);
830 }
831 return keylist;
832}
#define mutt_message(...)
Definition: logging2.h:91
static struct SmimeKey * smime_get_key_by_addr(const char *mailbox, KeyFlags abilities, bool only_public_key, bool oppenc_mode)
Find an SIME key by address.
Definition: smime.c:559
static struct SmimeKey * smime_ask_for_key(char *prompt, KeyFlags abilities, bool only_public_key)
Ask the user to select a key.
Definition: smime.c:686
static void smime_key_free(struct SmimeKey **keylist)
Free a list of SMIME keys.
Definition: smime.c:106
An SIME key.
Definition: smime.h:43
char * hash
Definition: smime.h:45
+ Here is the call graph for this function: