NeoMutt  2024-03-23-142-g2b2e76
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
pgp_encrypt_message()

PGP encrypt an email. More...

+ Collaboration diagram for pgp_encrypt_message():

Functions

struct Bodypgp_gpgme_encrypt_message (struct Body *b, char *keylist, bool sign, const struct AddressList *from)
 PGP encrypt an email - Implements CryptModuleSpecs::pgp_encrypt_message() -.
 
struct Bodypgp_class_encrypt_message (struct Body *b, char *keylist, bool sign, const struct AddressList *from)
 PGP encrypt an email - Implements CryptModuleSpecs::pgp_encrypt_message() -.
 

Detailed Description

PGP encrypt an email.

Parameters
bBody of email to encrypt
keylistList of keys, or fingerprints (space separated)
signIf true, sign the message too
fromFrom line, to choose the key to sign
Return values
ptrEncrypted Body
NULLError

Encrypt the mail body to all the given keys.

Function Documentation

◆ pgp_gpgme_encrypt_message()

struct Body * pgp_gpgme_encrypt_message ( struct Body b,
char *  keylist,
bool  sign,
const struct AddressList *  from 
)

PGP encrypt an email - Implements CryptModuleSpecs::pgp_encrypt_message() -.

Definition at line 1038 of file crypt_gpgme.c.

1040{
1041 if (sign)
1043 gpgme_data_t plaintext = body_to_data_object(b, false);
1044 if (!plaintext)
1045 return NULL;
1046
1047 char *outfile = encrypt_gpgme_object(plaintext, keylist, false, sign, from);
1048 gpgme_data_release(plaintext);
1049 if (!outfile)
1050 return NULL;
1051
1052 struct Body *b_enc = mutt_body_new();
1053 b_enc->type = TYPE_MULTIPART;
1054 b_enc->subtype = mutt_str_dup("encrypted");
1055 b_enc->encoding = ENC_7BIT;
1056 b_enc->use_disp = false;
1057 b_enc->disposition = DISP_INLINE;
1058
1060 mutt_param_set(&b_enc->parameter, "protocol", "application/pgp-encrypted");
1061
1062 b_enc->parts = mutt_body_new();
1063 b_enc->parts->type = TYPE_APPLICATION;
1064 b_enc->parts->subtype = mutt_str_dup("pgp-encrypted");
1065 b_enc->parts->encoding = ENC_7BIT;
1066
1067 b_enc->parts->next = mutt_body_new();
1068 b_enc->parts->next->type = TYPE_APPLICATION;
1069 b_enc->parts->next->subtype = mutt_str_dup("octet-stream");
1070 b_enc->parts->next->encoding = ENC_7BIT;
1071 b_enc->parts->next->filename = outfile;
1072 b_enc->parts->next->use_disp = true;
1073 b_enc->parts->next->disposition = DISP_ATTACH;
1074 b_enc->parts->next->unlink = true; /* delete after sending the message */
1075 b_enc->parts->next->d_filename = mutt_str_dup("msg.asc"); /* non pgp/mime
1076 can save */
1077
1078 return b_enc;
1079}
void crypt_convert_to_7bit(struct Body *b)
Convert an email to 7bit encoding.
Definition: crypt.c:795
static gpgme_data_t body_to_data_object(struct Body *b, bool convert)
Create GPGME object from the mail body.
Definition: crypt_gpgme.c:419
static char * encrypt_gpgme_object(gpgme_data_t plaintext, char *keylist, bool use_smime, bool combined_signed, const struct AddressList *from)
Encrypt the GPGPME data object.
Definition: crypt_gpgme.c:776
struct Body * mutt_body_new(void)
Create a new Body.
Definition: body.c:44
@ ENC_7BIT
7-bit text
Definition: mime.h:49
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
@ TYPE_APPLICATION
Type: 'application/*'.
Definition: mime.h:33
@ DISP_ATTACH
Content is attached.
Definition: mime.h:63
@ DISP_INLINE
Content is inline.
Definition: mime.h:62
void mutt_generate_boundary(struct ParameterList *pl)
Create a unique boundary id for a MIME part.
Definition: multipart.c:86
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
void mutt_param_set(struct ParameterList *pl, const char *attribute, const char *value)
Set a Parameter.
Definition: parameter.c:111
The body of an email.
Definition: body.h:36
char * d_filename
filename to be used for the content-disposition header If NULL, filename is used instead.
Definition: body.h:56
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
bool unlink
If true, filename should be unlink()ed before free()ing this structure.
Definition: body.h:67
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:62
bool use_disp
Content-Disposition uses filename= ?
Definition: body.h:47
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
struct Body * next
next attachment in the list
Definition: body.h:71
char * subtype
content-type subtype
Definition: body.h:60
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:58
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pgp_class_encrypt_message()

struct Body * pgp_class_encrypt_message ( struct Body b,
char *  keylist,
bool  sign,
const struct AddressList *  from 
)

PGP encrypt an email - Implements CryptModuleSpecs::pgp_encrypt_message() -.

Warning
"b" is no longer freed in this routine, you need to free it later. This is necessary for $fcc_attach.

Definition at line 1590 of file pgp.c.

1592{
1593 char buf[1024] = { 0 };
1594 FILE *fp_pgp_in = NULL, *fp_tmp = NULL;
1595 struct Body *b_enc = NULL;
1596 int err = 0;
1597 bool empty = false;
1598 pid_t pid;
1599 struct Buffer *tempfile = buf_pool_get();
1600 struct Buffer *pgpinfile = buf_pool_get();
1601
1602 buf_mktemp(tempfile);
1603 FILE *fp_out = mutt_file_fopen(buf_string(tempfile), "w+");
1604 if (!fp_out)
1605 {
1606 mutt_perror("%s", buf_string(tempfile));
1607 goto cleanup;
1608 }
1609
1610 FILE *fp_pgp_err = mutt_file_mkstemp();
1611 if (!fp_pgp_err)
1612 {
1613 mutt_perror(_("Can't create temporary file"));
1614 unlink(buf_string(tempfile));
1615 mutt_file_fclose(&fp_out);
1616 goto cleanup;
1617 }
1618
1619 buf_mktemp(pgpinfile);
1620 fp_tmp = mutt_file_fopen(buf_string(pgpinfile), "w");
1621 if (!fp_tmp)
1622 {
1623 mutt_perror("%s", buf_string(pgpinfile));
1624 unlink(buf_string(tempfile));
1625 mutt_file_fclose(&fp_out);
1626 mutt_file_fclose(&fp_pgp_err);
1627 goto cleanup;
1628 }
1629
1630 if (sign)
1632
1633 mutt_write_mime_header(b, fp_tmp, NeoMutt->sub);
1634 fputc('\n', fp_tmp);
1635 mutt_write_mime_body(b, fp_tmp, NeoMutt->sub);
1636 mutt_file_fclose(&fp_tmp);
1637
1638 pid = pgp_invoke_encrypt(&fp_pgp_in, NULL, NULL, -1, fileno(fp_out),
1639 fileno(fp_pgp_err), buf_string(pgpinfile), keylist, sign);
1640 if (pid == -1)
1641 {
1642 mutt_file_fclose(&fp_out);
1643 mutt_file_fclose(&fp_pgp_err);
1644 unlink(buf_string(pgpinfile));
1645 goto cleanup;
1646 }
1647
1648 if (sign)
1649 {
1650 if (!pgp_use_gpg_agent())
1651 fputs(PgpPass, fp_pgp_in);
1652 fputc('\n', fp_pgp_in);
1653 }
1654 mutt_file_fclose(&fp_pgp_in);
1655
1656 const bool c_pgp_check_exit = cs_subset_bool(NeoMutt->sub, "pgp_check_exit");
1657 if (filter_wait(pid) && c_pgp_check_exit)
1658 empty = true;
1659
1660 unlink(buf_string(pgpinfile));
1661
1662 fflush(fp_out);
1663 rewind(fp_out);
1664 if (!empty)
1665 empty = (fgetc(fp_out) == EOF);
1666 mutt_file_fclose(&fp_out);
1667
1668 fflush(fp_pgp_err);
1669 rewind(fp_pgp_err);
1670 while (fgets(buf, sizeof(buf) - 1, fp_pgp_err))
1671 {
1672 err = 1;
1673 fputs(buf, stdout);
1674 }
1675 mutt_file_fclose(&fp_pgp_err);
1676
1677 /* pause if there is any error output from PGP */
1678 if (err)
1680
1681 if (empty)
1682 {
1683 /* fatal error while trying to encrypt message */
1684 if (sign)
1685 pgp_class_void_passphrase(); /* just in case */
1686 unlink(buf_string(tempfile));
1687 goto cleanup;
1688 }
1689
1690 b_enc = mutt_body_new();
1691 b_enc->type = TYPE_MULTIPART;
1692 b_enc->subtype = mutt_str_dup("encrypted");
1693 b_enc->encoding = ENC_7BIT;
1694 b_enc->use_disp = false;
1695 b_enc->disposition = DISP_INLINE;
1696
1698 mutt_param_set(&b_enc->parameter, "protocol", "application/pgp-encrypted");
1699
1700 b_enc->parts = mutt_body_new();
1701 b_enc->parts->type = TYPE_APPLICATION;
1702 b_enc->parts->subtype = mutt_str_dup("pgp-encrypted");
1703 b_enc->parts->encoding = ENC_7BIT;
1704
1705 b_enc->parts->next = mutt_body_new();
1706 b_enc->parts->next->type = TYPE_APPLICATION;
1707 b_enc->parts->next->subtype = mutt_str_dup("octet-stream");
1708 b_enc->parts->next->encoding = ENC_7BIT;
1709 b_enc->parts->next->filename = buf_strdup(tempfile);
1710 b_enc->parts->next->use_disp = true;
1711 b_enc->parts->next->disposition = DISP_ATTACH;
1712 b_enc->parts->next->unlink = true; /* delete after sending the message */
1713 b_enc->parts->next->d_filename = mutt_str_dup("msg.asc"); /* non pgp/mime can save */
1714
1715cleanup:
1716 buf_pool_release(&tempfile);
1717 buf_pool_release(&pgpinfile);
1718 return b_enc;
1719}
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:570
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:48
int mutt_any_key_to_continue(const char *s)
Prompt the user to 'press any key' and wait.
Definition: curs_lib.c:173
#define mutt_file_fclose(FP)
Definition: file.h:147
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:146
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:220
void pgp_class_void_passphrase(void)
Forget the cached passphrase - Implements CryptModuleSpecs::void_passphrase() -.
Definition: pgp.c:76
#define mutt_perror(...)
Definition: logging2.h:93
int mutt_write_mime_header(struct Body *b, FILE *fp, struct ConfigSubset *sub)
Create a MIME header.
Definition: header.c:756
#define _(a)
Definition: message.h:28
static char PgpPass[1024]
Cached PGP Passphrase.
Definition: pgp.c:69
bool pgp_use_gpg_agent(void)
Does the user want to use the gpg agent?
Definition: pgp.c:127
pid_t pgp_invoke_encrypt(FILE **fp_pgp_in, FILE **fp_pgp_out, FILE **fp_pgp_err, int fd_pgp_in, int fd_pgp_out, int fd_pgp_err, const char *fname, const char *uids, bool sign)
Use PGP to encrypt a file.
Definition: pgpinvoke.c:297
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
int mutt_write_mime_body(struct Body *b, FILE *fp, struct ConfigSubset *sub)
Write a MIME part.
Definition: body.c:300
String manipulation buffer.
Definition: buffer.h:36
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
#define buf_mktemp(buf)
Definition: tmp.h:33
#define mutt_file_mkstemp()
Definition: tmp.h:36
+ Here is the call graph for this function: