NeoMutt  2024-03-23-147-g885fbc
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
smime_build_smime_entity()

Encrypt the email body to all recipients. More...

+ Collaboration diagram for smime_build_smime_entity():

Functions

struct Bodysmime_gpgme_build_smime_entity (struct Body *b, char *keylist)
 Encrypt the email body to all recipients - Implements CryptModuleSpecs::smime_build_smime_entity() -.
 
struct Bodysmime_class_build_smime_entity (struct Body *b, char *certlist)
 Encrypt the email body to all recipients - Implements CryptModuleSpecs::smime_build_smime_entity() -.
 

Detailed Description

Encrypt the email body to all recipients.

Parameters
bBody of email
certlistList of key fingerprints (space separated)
Return values
ptrNew S/MIME encrypted Body
NULLError

Function Documentation

◆ smime_gpgme_build_smime_entity()

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

Definition at line 1084 of file crypt_gpgme.c.

1085{
1086 /* OpenSSL converts line endings to crlf when encrypting. Some clients
1087 * depend on this for signed+encrypted messages: they do not convert line
1088 * endings between decrypting and checking the signature. */
1089 gpgme_data_t plaintext = body_to_data_object(b, true);
1090 if (!plaintext)
1091 return NULL;
1092
1093 char *outfile = encrypt_gpgme_object(plaintext, keylist, true, false, NULL);
1094 gpgme_data_release(plaintext);
1095 if (!outfile)
1096 return NULL;
1097
1098 struct Body *b_enc = mutt_body_new();
1099 b_enc->type = TYPE_APPLICATION;
1100 b_enc->subtype = mutt_str_dup("pkcs7-mime");
1101 mutt_param_set(&b_enc->parameter, "name", "smime.p7m");
1102 mutt_param_set(&b_enc->parameter, "smime-type", "enveloped-data");
1103 b_enc->encoding = ENC_BASE64; /* The output of OpenSSL SHOULD be binary */
1104 b_enc->use_disp = true;
1105 b_enc->disposition = DISP_ATTACH;
1106 b_enc->d_filename = mutt_str_dup("smime.p7m");
1107 b_enc->filename = outfile;
1108 b_enc->unlink = true; /* delete after sending the message */
1109 b_enc->parts = 0;
1110 b_enc->next = 0;
1111
1112 return b_enc;
1113}
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_BASE64
Base-64 encoded text.
Definition: mime.h:52
@ TYPE_APPLICATION
Type: 'application/*'.
Definition: mime.h:33
@ DISP_ATTACH
Content is attached.
Definition: mime.h:63
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:

◆ smime_class_build_smime_entity()

struct Body * smime_class_build_smime_entity ( struct Body b,
char *  certlist 
)

Encrypt the email body to all recipients - Implements CryptModuleSpecs::smime_build_smime_entity() -.

Definition at line 1331 of file smime.c.

1332{
1333 char buf[1024] = { 0 };
1334 char certfile[PATH_MAX] = { 0 };
1335 char *cert_end = NULL;
1336 FILE *fp_smime_in = NULL, *fp_smime_err = NULL, *fp_out = NULL, *fp_tmp = NULL;
1337 struct Body *b_enc = NULL;
1338 int err = 0, empty, off;
1339 pid_t pid;
1340
1341 struct Buffer *tempfile = buf_pool_get();
1342 struct Buffer *smime_infile = buf_pool_get();
1343
1344 buf_mktemp(tempfile);
1345 fp_out = mutt_file_fopen(buf_string(tempfile), "w+");
1346 if (!fp_out)
1347 {
1348 mutt_perror("%s", buf_string(tempfile));
1349 goto cleanup;
1350 }
1351
1352 fp_smime_err = mutt_file_mkstemp();
1353 if (!fp_smime_err)
1354 {
1355 mutt_perror(_("Can't create temporary file"));
1356 goto cleanup;
1357 }
1358
1359 buf_mktemp(smime_infile);
1360 fp_tmp = mutt_file_fopen(buf_string(smime_infile), "w+");
1361 if (!fp_tmp)
1362 {
1363 mutt_perror("%s", buf_string(smime_infile));
1364 goto cleanup;
1365 }
1366
1367 *certfile = '\0';
1368 for (char *cert_start = certlist; cert_start; cert_start = cert_end)
1369 {
1370 cert_end = strchr(cert_start, ' ');
1371 if (cert_end)
1372 *cert_end = '\0';
1373 if (*cert_start)
1374 {
1375 off = mutt_str_len(certfile);
1376 const char *const c_smime_certificates = cs_subset_path(NeoMutt->sub, "smime_certificates");
1377 snprintf(certfile + off, sizeof(certfile) - off, "%s%s/%s",
1378 (off != 0) ? " " : "", NONULL(c_smime_certificates), cert_start);
1379 }
1380 if (cert_end)
1381 *cert_end++ = ' ';
1382 }
1383
1384 /* write a MIME entity */
1385 mutt_write_mime_header(b, fp_tmp, NeoMutt->sub);
1386 fputc('\n', fp_tmp);
1387 mutt_write_mime_body(b, fp_tmp, NeoMutt->sub);
1388 mutt_file_fclose(&fp_tmp);
1389
1390 pid = smime_invoke_encrypt(&fp_smime_in, NULL, NULL, -1, fileno(fp_out),
1391 fileno(fp_smime_err), buf_string(smime_infile), certfile);
1392 if (pid == -1)
1393 {
1394 mutt_file_unlink(buf_string(smime_infile));
1395 goto cleanup;
1396 }
1397
1398 mutt_file_fclose(&fp_smime_in);
1399
1400 filter_wait(pid);
1401 mutt_file_unlink(buf_string(smime_infile));
1402
1403 fflush(fp_out);
1404 rewind(fp_out);
1405 empty = (fgetc(fp_out) == EOF);
1406 mutt_file_fclose(&fp_out);
1407
1408 fflush(fp_smime_err);
1409 rewind(fp_smime_err);
1410 while (fgets(buf, sizeof(buf) - 1, fp_smime_err))
1411 {
1412 err = 1;
1413 fputs(buf, stdout);
1414 }
1415 mutt_file_fclose(&fp_smime_err);
1416
1417 /* pause if there is any error output from SMIME */
1418 if (err)
1420
1421 if (empty)
1422 {
1423 /* fatal error while trying to encrypt message */
1424 if (err == 0)
1425 mutt_any_key_to_continue(_("No output from OpenSSL..."));
1426 mutt_file_unlink(buf_string(tempfile));
1427 goto cleanup;
1428 }
1429
1430 b_enc = mutt_body_new();
1431 b_enc->type = TYPE_APPLICATION;
1432 b_enc->subtype = mutt_str_dup("pkcs7-mime");
1433 mutt_param_set(&b_enc->parameter, "name", "smime.p7m");
1434 mutt_param_set(&b_enc->parameter, "smime-type", "enveloped-data");
1435 b_enc->encoding = ENC_BASE64; /* The output of OpenSSL SHOULD be binary */
1436 b_enc->use_disp = true;
1437 b_enc->disposition = DISP_ATTACH;
1438 b_enc->d_filename = mutt_str_dup("smime.p7m");
1439 b_enc->filename = buf_strdup(tempfile);
1440 b_enc->unlink = true; /* delete after sending the message */
1441 b_enc->parts = NULL;
1442 b_enc->next = NULL;
1443
1444cleanup:
1445 if (fp_out)
1446 {
1447 mutt_file_fclose(&fp_out);
1448 mutt_file_unlink(buf_string(tempfile));
1449 }
1450 mutt_file_fclose(&fp_smime_err);
1451 if (fp_tmp)
1452 {
1453 mutt_file_fclose(&fp_tmp);
1454 mutt_file_unlink(buf_string(smime_infile));
1455 }
1456 buf_pool_release(&tempfile);
1457 buf_pool_release(&smime_infile);
1458
1459 return b_enc;
1460}
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
const char * cs_subset_path(const struct ConfigSubset *sub, const char *name)
Get a path config item by name.
Definition: helpers.c:169
int mutt_any_key_to_continue(const char *s)
Prompt the user to 'press any key' and wait.
Definition: curs_lib.c:173
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:220
#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
#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
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:545
#define PATH_MAX
Definition: mutt.h:42
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
static pid_t smime_invoke_encrypt(FILE **fp_smime_in, FILE **fp_smime_out, FILE **fp_smime_err, int fp_smime_infd, int fp_smime_outfd, int fp_smime_errfd, const char *fname, const char *uids)
Use SMIME to encrypt a file.
Definition: smime.c:1289
#define NONULL(x)
Definition: string2.h:37
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: