NeoMutt  2023-05-17-56-ga67199
Teaching an old dog new tricks
DOXYGEN
application_handler()

Manage the MIME type "application/pgp" or "application/smime". More...

+ Collaboration diagram for application_handler():

Functions

int pgp_gpgme_application_handler (struct Body *m, struct State *state)
 Implements CryptModuleSpecs::application_handler() -. More...
 
int smime_gpgme_application_handler (struct Body *a, struct State *state)
 Implements CryptModuleSpecs::application_handler() -. More...
 
int pgp_class_application_handler (struct Body *m, struct State *state)
 Implements CryptModuleSpecs::application_handler() -. More...
 
int smime_class_application_handler (struct Body *m, struct State *state)
 Implements CryptModuleSpecs::application_handler() -. More...
 

Detailed Description

Manage the MIME type "application/pgp" or "application/smime".

Parameters
mBody of the email
stateState of text being processed
Return values
0Success
-1Error

Function Documentation

◆ pgp_gpgme_application_handler()

int pgp_gpgme_application_handler ( struct Body m,
struct State state 
)

Implements CryptModuleSpecs::application_handler() -.

Definition at line 2428 of file crypt_gpgme.c.

2429{
2430 int needpass = -1;
2431 bool pgp_keyblock = false;
2432 bool clearsign = false;
2433 long bytes;
2434 LOFF_T last_pos;
2435 char buf[8192] = { 0 };
2436 FILE *fp_out = NULL;
2437
2438 gpgme_error_t err = 0;
2439 gpgme_data_t armored_data = NULL;
2440
2441 bool maybe_goodsig = true;
2442 bool have_any_sigs = false;
2443
2444 char body_charset[256] = { 0 }; /* Only used for clearsigned messages. */
2445
2446 mutt_debug(LL_DEBUG2, "Entering handler\n");
2447
2448 /* For clearsigned messages we won't be able to get a character set
2449 * but we know that this may only be text thus we assume Latin-1 here. */
2450 if (!mutt_body_get_charset(m, body_charset, sizeof(body_charset)))
2451 mutt_str_copy(body_charset, "iso-8859-1", sizeof(body_charset));
2452
2453 if (!mutt_file_seek(state->fp_in, m->offset, SEEK_SET))
2454 {
2455 return -1;
2456 }
2457 last_pos = m->offset;
2458
2459 for (bytes = m->length; bytes > 0;)
2460 {
2461 if (!fgets(buf, sizeof(buf), state->fp_in))
2462 break;
2463
2464 LOFF_T offset = ftello(state->fp_in);
2465 bytes -= (offset - last_pos); /* don't rely on mutt_str_len(buf) */
2466 last_pos = offset;
2467
2468 size_t plen = mutt_str_startswith(buf, "-----BEGIN PGP ");
2469 if (plen != 0)
2470 {
2471 clearsign = false;
2472
2473 if (MESSAGE(buf + plen))
2474 {
2475 needpass = 1;
2476 }
2477 else if (SIGNED_MESSAGE(buf + plen))
2478 {
2479 clearsign = true;
2480 needpass = 0;
2481 }
2482 else if (PUBLIC_KEY_BLOCK(buf + plen))
2483 {
2484 needpass = 0;
2485 pgp_keyblock = true;
2486 }
2487 else
2488 {
2489 /* XXX we may wish to recode here */
2490 if (state->prefix)
2491 state_puts(state, state->prefix);
2492 state_puts(state, buf);
2493 continue;
2494 }
2495
2496 have_any_sigs = (have_any_sigs || (clearsign && (state->flags & STATE_VERIFY)));
2497
2498 /* Copy PGP material to an data container */
2499 armored_data = file_to_data_object(state->fp_in, m->offset, m->length);
2500 /* Invoke PGP if needed */
2501 if (pgp_keyblock)
2502 {
2503 pgp_gpgme_extract_keys(armored_data, &fp_out);
2504 }
2505 else if (!clearsign || (state->flags & STATE_VERIFY))
2506 {
2507 gpgme_data_t plaintext = create_gpgme_data();
2508 gpgme_ctx_t ctx = create_gpgme_context(false);
2509
2510 if (clearsign)
2511 {
2512 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2513 }
2514 else
2515 {
2516 err = gpgme_op_decrypt_verify(ctx, armored_data, plaintext);
2517 if (gpg_err_code(err) == GPG_ERR_NO_DATA)
2518 {
2519 /* Decrypt verify can't handle signed only messages. */
2520 gpgme_data_seek(armored_data, 0, SEEK_SET);
2521 /* Must release plaintext so that we supply an uninitialized object. */
2522 gpgme_data_release(plaintext);
2523 plaintext = create_gpgme_data();
2524 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2525 }
2526 }
2527 redraw_if_needed(ctx);
2528
2529 if (err != 0)
2530 {
2531 char errbuf[200] = { 0 };
2532
2533 snprintf(errbuf, sizeof(errbuf) - 1,
2534 _("Error: decryption/verification failed: %s\n"), gpgme_strerror(err));
2535 state_puts(state, errbuf);
2536 }
2537 else
2538 {
2539 /* Decryption/Verification succeeded */
2540
2541 mutt_message(_("PGP message successfully decrypted"));
2542
2543 bool sig_stat = false;
2544 char *tmpfname = NULL;
2545
2546 /* Check whether signatures have been verified. */
2547 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
2548 if (verify_result->signatures)
2549 sig_stat = true;
2550
2551 have_any_sigs = false;
2552 maybe_goodsig = false;
2553 if ((state->flags & STATE_DISPLAY) && sig_stat)
2554 {
2555 int res, idx;
2556 bool anybad = false;
2557
2558 state_attach_puts(state, _("[-- Begin signature information --]\n"));
2559 have_any_sigs = true;
2560 for (idx = 0; (res = show_one_sig_status(ctx, idx, state)) != -1; idx++)
2561 {
2562 if (res == 1)
2563 anybad = true;
2564 }
2565 if (!anybad && idx)
2566 maybe_goodsig = true;
2567
2568 state_attach_puts(state, _("[-- End signature information --]\n\n"));
2569 }
2570
2571 tmpfname = data_object_to_tempfile(plaintext, &fp_out);
2572 if (tmpfname)
2573 {
2574 unlink(tmpfname);
2575 FREE(&tmpfname);
2576 }
2577 else
2578 {
2579 mutt_file_fclose(&fp_out);
2580 state_puts(state, _("Error: copy data failed\n"));
2581 }
2582 }
2583 gpgme_data_release(plaintext);
2584 gpgme_release(ctx);
2585 }
2586
2587 /* Now, copy cleartext to the screen. NOTE - we expect that PGP
2588 * outputs utf-8 cleartext. This may not always be true, but it
2589 * seems to be a reasonable guess. */
2590 if (state->flags & STATE_DISPLAY)
2591 {
2592 if (needpass)
2593 state_attach_puts(state, _("[-- BEGIN PGP MESSAGE --]\n\n"));
2594 else if (pgp_keyblock)
2595 state_attach_puts(state, _("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"));
2596 else
2597 state_attach_puts(state, _("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"));
2598 }
2599
2600 if (clearsign)
2601 {
2602 copy_clearsigned(armored_data, state, body_charset);
2603 }
2604 else if (fp_out)
2605 {
2606 int c;
2607 rewind(fp_out);
2608 struct FgetConv *fc = mutt_ch_fgetconv_open(fp_out, "utf-8", cc_charset(),
2610 while ((c = mutt_ch_fgetconv(fc)) != EOF)
2611 {
2612 state_putc(state, c);
2613 if ((c == '\n') && state->prefix)
2614 state_puts(state, state->prefix);
2615 }
2617 }
2618
2619 if (state->flags & STATE_DISPLAY)
2620 {
2621 state_putc(state, '\n');
2622 if (needpass)
2623 state_attach_puts(state, _("[-- END PGP MESSAGE --]\n"));
2624 else if (pgp_keyblock)
2625 state_attach_puts(state, _("[-- END PGP PUBLIC KEY BLOCK --]\n"));
2626 else
2627 state_attach_puts(state, _("[-- END PGP SIGNED MESSAGE --]\n"));
2628 }
2629
2630 gpgme_data_release(armored_data);
2631 mutt_file_fclose(&fp_out);
2632 }
2633 else
2634 {
2635 /* A traditional PGP part may mix signed and unsigned content */
2636 /* XXX we may wish to recode here */
2637 if (state->prefix)
2638 state_puts(state, state->prefix);
2639 state_puts(state, buf);
2640 }
2641 }
2642
2643 m->goodsig = (maybe_goodsig && have_any_sigs);
2644
2645 if (needpass == -1)
2646 {
2647 state_attach_puts(state, _("[-- Error: could not find beginning of PGP message --]\n\n"));
2648 return 1;
2649 }
2650 mutt_debug(LL_DEBUG2, "Leaving handler\n");
2651
2652 return err;
2653}
const char * cc_charset(void)
Get the cached value of $charset.
Definition: cache.c:106
static gpgme_data_t create_gpgme_data(void)
Create a new GPGME data object.
Definition: crypt_gpgme.c:398
gpgme_ctx_t create_gpgme_context(bool for_smime)
Create a new GPGME context.
Definition: crypt_gpgme.c:359
#define SIGNED_MESSAGE(_y)
Definition: crypt_gpgme.c:100
static gpgme_data_t file_to_data_object(FILE *fp, long offset, size_t length)
Create GPGME data object from file.
Definition: crypt_gpgme.c:491
#define PUBLIC_KEY_BLOCK(_y)
Definition: crypt_gpgme.c:101
static char * data_object_to_tempfile(gpgme_data_t data, FILE **fp_ret)
Copy a data object to a temporary file.
Definition: crypt_gpgme.c:559
static void redraw_if_needed(gpgme_ctx_t ctx)
Accommodate for a redraw if needed.
Definition: crypt_gpgme.c:119
static int pgp_gpgme_extract_keys(gpgme_data_t keydata, FILE **fp)
Write PGP keys to a file.
Definition: crypt_gpgme.c:2069
static void copy_clearsigned(gpgme_data_t data, struct State *state, char *charset)
Copy a clearsigned message.
Definition: crypt_gpgme.c:2372
static int show_one_sig_status(gpgme_ctx_t ctx, int idx, struct State *state)
Show information about one signature.
Definition: crypt_gpgme.c:1417
#define MESSAGE(_y)
Definition: crypt_gpgme.c:99
char * mutt_body_get_charset(struct Body *b, char *buf, size_t buflen)
Get a body's character set.
Definition: body.c:131
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:150
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
Definition: file.c:708
#define mutt_message(...)
Definition: logging2.h:89
#define mutt_debug(LEVEL,...)
Definition: logging2.h:87
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44
#define FREE(x)
Definition: memory.h:43
void mutt_ch_fgetconv_close(struct FgetConv **fc)
Close an fgetconv handle.
Definition: charset.c:956
int mutt_ch_fgetconv(struct FgetConv *fc)
Convert a file's character set.
Definition: charset.c:974
struct FgetConv * mutt_ch_fgetconv_open(FILE *fp, const char *from, const char *to, uint8_t flags)
Prepare a file for charset conversion.
Definition: charset.c:924
#define MUTT_ICONV_NO_FLAGS
No flags are set.
Definition: charset.h:71
#define _(a)
Definition: message.h:28
void state_attach_puts(struct State *state, const char *t)
Write a string to the state.
Definition: state.c:102
#define state_puts(STATE, STR)
Definition: state.h:57
#define STATE_DISPLAY
Output is displayed to the user.
Definition: state.h:32
#define state_putc(STATE, STR)
Definition: state.h:58
#define STATE_VERIFY
Perform signature verification.
Definition: state.h:33
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:228
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:653
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
bool goodsig
Good cryptographic signature.
Definition: body.h:45
Cursor for converting a file's encoding.
Definition: charset.h:41
StateFlags flags
Flags, e.g. STATE_DISPLAY.
Definition: state.h:51
char * prefix
String to add to the beginning of each output line.
Definition: state.h:50
FILE * fp_in
File to read from.
Definition: state.h:48
+ Here is the call graph for this function:

◆ smime_gpgme_application_handler()

int smime_gpgme_application_handler ( struct Body a,
struct State state 
)

Implements CryptModuleSpecs::application_handler() -.

Definition at line 2752 of file crypt_gpgme.c.

2753{
2754 int is_signed = 0;
2755 int rc = 0;
2756
2757 mutt_debug(LL_DEBUG2, "Entering handler\n");
2758
2759 /* clear out any mime headers before the handler, so they can't be spoofed. */
2761 a->warnsig = false;
2762 FILE *fp_out = mutt_file_mkstemp();
2763 if (!fp_out)
2764 {
2765 mutt_perror(_("Can't create temporary file"));
2766 if (state->flags & STATE_DISPLAY)
2767 {
2768 state_attach_puts(state, _("[-- Error: could not create temporary file --]\n"));
2769 }
2770 return -1;
2771 }
2772
2773 struct Body *tattach = decrypt_part(a, state, fp_out, true, &is_signed);
2774 if (tattach)
2775 {
2776 tattach->goodsig = is_signed > 0;
2777
2778 if (state->flags & STATE_DISPLAY)
2779 {
2780 state_attach_puts(state, is_signed ?
2781 _("[-- The following data is S/MIME signed --]\n\n") :
2782 _("[-- The following data is S/MIME encrypted --]\n\n"));
2783 mutt_protected_headers_handler(tattach, state);
2784 }
2785
2786 /* Store any protected headers in the parent so they can be
2787 * accessed for index updates after the handler recursion is done.
2788 * This is done before the handler to prevent a nested encrypted
2789 * handler from freeing the headers. */
2791 a->mime_headers = tattach->mime_headers;
2792 tattach->mime_headers = NULL;
2793
2794 FILE *fp_save = state->fp_in;
2795 state->fp_in = fp_out;
2796 rc = mutt_body_handler(tattach, state);
2797 state->fp_in = fp_save;
2798
2799 /* Embedded multipart signed protected headers override the
2800 * encrypted headers. We need to do this after the handler so
2801 * they can be printed in the pager. */
2802 if (mutt_is_multipart_signed(tattach) && tattach->parts && tattach->parts->mime_headers)
2803 {
2805 a->mime_headers = tattach->parts->mime_headers;
2806 tattach->parts->mime_headers = NULL;
2807 }
2808
2809 /* if a multipart/signed is the _only_ sub-part of a multipart/encrypted,
2810 * cache signature verification status. */
2811 if (mutt_is_multipart_signed(tattach) && !tattach->next)
2812 {
2813 a->goodsig = tattach->goodsig;
2814 if (!a->goodsig)
2815 a->warnsig = tattach->warnsig;
2816 }
2817 else if (tattach->goodsig)
2818 {
2819 a->goodsig = true;
2820 a->warnsig = tattach->warnsig;
2821 }
2822
2823 if (state->flags & STATE_DISPLAY)
2824 {
2825 state_puts(state, "\n");
2826 state_attach_puts(state, is_signed ? _("[-- End of S/MIME signed data --]\n") :
2827 _("[-- End of S/MIME encrypted data --]\n"));
2828 }
2829
2830 mutt_body_free(&tattach);
2831 }
2832
2833 mutt_file_fclose(&fp_out);
2834 mutt_debug(LL_DEBUG2, "Leaving handler\n");
2835
2836 return rc;
2837}
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
Definition: crypt.c:398
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.
Definition: crypt_gpgme.c:1693
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
void mutt_env_free(struct Envelope **ptr)
Free an Envelope.
Definition: envelope.c:97
int mutt_protected_headers_handler(struct Body *b, struct State *state)
Process a protected header - Implements handler_t -.
Definition: crypt.c:1107
#define mutt_perror(...)
Definition: logging2.h:91
int mutt_body_handler(struct Body *b, struct State *state)
Handler for the Body of an email.
Definition: handler.c:1618
The body of an email.
Definition: body.h:36
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:75
struct Body * next
next attachment in the list
Definition: body.h:71
bool warnsig
Maybe good signature.
Definition: body.h:48
#define mutt_file_mkstemp()
Definition: tmp.h:40
+ Here is the call graph for this function:

◆ pgp_class_application_handler()

int pgp_class_application_handler ( struct Body m,
struct State state 
)

Implements CryptModuleSpecs::application_handler() -.

Definition at line 473 of file pgp.c.

474{
475 bool could_not_decrypt = false;
476 int decrypt_okay_rc = 0;
477 int needpass = -1;
478 bool pgp_keyblock = false;
479 bool clearsign = false;
480 int rc = -1;
481 int c = 1;
482 long bytes;
483 LOFF_T last_pos, offset;
484 char buf[8192] = { 0 };
485 FILE *fp_pgp_out = NULL, *fp_pgp_in = NULL, *fp_pgp_err = NULL;
486 FILE *fp_tmp = NULL;
487 pid_t pid;
488 struct Buffer *tmpfname = buf_pool_get();
489
490 bool maybe_goodsig = true;
491 bool have_any_sigs = false;
492
493 char *gpgcharset = NULL;
494 char body_charset[256] = { 0 };
495 mutt_body_get_charset(m, body_charset, sizeof(body_charset));
496
497 if (!mutt_file_seek(state->fp_in, m->offset, SEEK_SET))
498 {
499 return -1;
500 }
501 last_pos = m->offset;
502
503 for (bytes = m->length; bytes > 0;)
504 {
505 if (!fgets(buf, sizeof(buf), state->fp_in))
506 break;
507
508 offset = ftello(state->fp_in);
509 bytes -= (offset - last_pos); /* don't rely on mutt_str_len(buf) */
510 last_pos = offset;
511
512 size_t plen = mutt_str_startswith(buf, "-----BEGIN PGP ");
513 if (plen != 0)
514 {
515 clearsign = false;
516 could_not_decrypt = false;
517 decrypt_okay_rc = 0;
518
519 if (mutt_str_startswith(buf + plen, "MESSAGE-----\n"))
520 {
521 needpass = 1;
522 }
523 else if (mutt_str_startswith(buf + plen, "SIGNED MESSAGE-----\n"))
524 {
525 clearsign = true;
526 needpass = 0;
527 }
528 else if (mutt_str_startswith(buf + plen, "PUBLIC KEY BLOCK-----\n"))
529 {
530 needpass = 0;
531 pgp_keyblock = true;
532 }
533 else
534 {
535 /* XXX we may wish to recode here */
536 if (state->prefix)
537 state_puts(state, state->prefix);
538 state_puts(state, buf);
539 continue;
540 }
541
542 have_any_sigs = have_any_sigs || (clearsign && (state->flags & STATE_VERIFY));
543
544 /* Copy PGP material to temporary file */
545 buf_mktemp(tmpfname);
546 fp_tmp = mutt_file_fopen(buf_string(tmpfname), "w+");
547 if (!fp_tmp)
548 {
549 mutt_perror(buf_string(tmpfname));
550 FREE(&gpgcharset);
551 goto out;
552 }
553
554 fputs(buf, fp_tmp);
555 while ((bytes > 0) && fgets(buf, sizeof(buf) - 1, state->fp_in))
556 {
557 offset = ftello(state->fp_in);
558 bytes -= (offset - last_pos); /* don't rely on mutt_str_len(buf) */
559 last_pos = offset;
560
561 fputs(buf, fp_tmp);
562
563 if ((needpass && mutt_str_equal("-----END PGP MESSAGE-----\n", buf)) ||
564 (!needpass && (mutt_str_equal("-----END PGP SIGNATURE-----\n", buf) ||
565 mutt_str_equal("-----END PGP PUBLIC KEY BLOCK-----\n", buf))))
566 {
567 break;
568 }
569 /* remember optional Charset: armor header as defined by RFC4880 */
570 if (mutt_str_startswith(buf, "Charset: "))
571 {
572 size_t l = 0;
573 FREE(&gpgcharset);
574 gpgcharset = mutt_str_dup(buf + 9);
575 l = mutt_str_len(gpgcharset);
576 if ((l > 0) && (gpgcharset[l - 1] == '\n'))
577 gpgcharset[l - 1] = 0;
578 if (!mutt_ch_check_charset(gpgcharset, false))
579 mutt_str_replace(&gpgcharset, "UTF-8");
580 }
581 }
582
583 /* leave fp_tmp open in case we still need it - but flush it! */
584 fflush(fp_tmp);
585
586 /* Invoke PGP if needed */
587 if (!clearsign || (state->flags & STATE_VERIFY))
588 {
589 fp_pgp_out = mutt_file_mkstemp();
590 if (!fp_pgp_out)
591 {
592 mutt_perror(_("Can't create temporary file"));
593 goto out;
594 }
595
596 fp_pgp_err = mutt_file_mkstemp();
597 if (!fp_pgp_err)
598 {
599 mutt_perror(_("Can't create temporary file"));
600 goto out;
601 }
602
603 pid = pgp_invoke_decode(&fp_pgp_in, NULL, NULL, -1, fileno(fp_pgp_out),
604 fileno(fp_pgp_err), buf_string(tmpfname),
605 (needpass != 0));
606 if (pid == -1)
607 {
608 mutt_file_fclose(&fp_pgp_out);
609 maybe_goodsig = false;
610 fp_pgp_in = NULL;
611 state_attach_puts(state, _("[-- Error: unable to create PGP subprocess --]\n"));
612 }
613 else /* PGP started successfully */
614 {
615 if (needpass)
616 {
619 if (pgp_use_gpg_agent())
620 *PgpPass = '\0';
621 fprintf(fp_pgp_in, "%s\n", PgpPass);
622 }
623
624 mutt_file_fclose(&fp_pgp_in);
625
626 int wait_filter_rc = filter_wait(pid);
627
628 fflush(fp_pgp_err);
629 /* If we are expecting an encrypted message, verify status fd output.
630 * Note that BEGIN PGP MESSAGE does not guarantee the content is encrypted,
631 * so we need to be more selective about the value of decrypt_okay_rc.
632 *
633 * -3 indicates we actively found a DECRYPTION_FAILED.
634 * -2 and -1 indicate part or all of the content was plaintext. */
635 if (needpass)
636 {
637 rewind(fp_pgp_err);
638 decrypt_okay_rc = pgp_check_decryption_okay(fp_pgp_err);
639 if (decrypt_okay_rc <= -3)
640 mutt_file_fclose(&fp_pgp_out);
641 }
642
643 if (state->flags & STATE_DISPLAY)
644 {
645 rewind(fp_pgp_err);
646 crypt_current_time(state, "PGP");
647 int checksig_rc = pgp_copy_checksig(fp_pgp_err, state->fp_out);
648
649 if (checksig_rc == 0)
650 have_any_sigs = true;
651 /* Sig is bad if
652 * gpg_good_sign-pattern did not match || pgp_decode_command returned not 0
653 * Sig _is_ correct if
654 * gpg_good_sign="" && pgp_decode_command returned 0 */
655 if (checksig_rc == -1 || (wait_filter_rc != 0))
656 maybe_goodsig = false;
657
658 state_attach_puts(state, _("[-- End of PGP output --]\n\n"));
659 }
660 if (pgp_use_gpg_agent())
661 {
663 }
664 }
665
666 /* treat empty result as sign of failure */
667 /* TODO: maybe on failure neomutt should include the original undecoded text. */
668 if (fp_pgp_out)
669 {
670 rewind(fp_pgp_out);
671 c = fgetc(fp_pgp_out);
672 ungetc(c, fp_pgp_out);
673 }
674 if (!clearsign && (!fp_pgp_out || (c == EOF)))
675 {
676 could_not_decrypt = true;
678 }
679
680 if ((could_not_decrypt || (decrypt_okay_rc <= -3)) && !(state->flags & STATE_DISPLAY))
681 {
682 mutt_error(_("Could not decrypt PGP message"));
683 goto out;
684 }
685 }
686
687 /* Now, copy cleartext to the screen. */
688 if (state->flags & STATE_DISPLAY)
689 {
690 if (needpass)
691 state_attach_puts(state, _("[-- BEGIN PGP MESSAGE --]\n\n"));
692 else if (pgp_keyblock)
693 state_attach_puts(state, _("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"));
694 else
695 state_attach_puts(state, _("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"));
696 }
697
698 if (clearsign)
699 {
700 rewind(fp_tmp);
701 pgp_copy_clearsigned(fp_tmp, state, body_charset);
702 }
703 else if (fp_pgp_out)
704 {
705 struct FgetConv *fc = NULL;
706 int ch;
707 char *expected_charset = (gpgcharset && *gpgcharset) ? gpgcharset : "utf-8";
708
709 mutt_debug(LL_DEBUG3, "pgp: recoding inline from [%s] to [%s]\n",
710 expected_charset, cc_charset());
711
712 rewind(fp_pgp_out);
713 state_set_prefix(state);
714 fc = mutt_ch_fgetconv_open(fp_pgp_out, expected_charset, cc_charset(),
716 while ((ch = mutt_ch_fgetconv(fc)) != EOF)
717 state_prefix_putc(state, ch);
719 }
720
721 /* Multiple PGP blocks can exist, so these need to be closed and
722 * unlinked inside the loop. */
723 mutt_file_fclose(&fp_tmp);
724 mutt_file_unlink(buf_string(tmpfname));
725 mutt_file_fclose(&fp_pgp_out);
726 mutt_file_fclose(&fp_pgp_err);
727
728 if (state->flags & STATE_DISPLAY)
729 {
730 state_putc(state, '\n');
731 if (needpass)
732 {
733 state_attach_puts(state, _("[-- END PGP MESSAGE --]\n"));
734 if (could_not_decrypt || (decrypt_okay_rc <= -3))
735 {
736 mutt_error(_("Could not decrypt PGP message"));
737 }
738 else if (decrypt_okay_rc < 0)
739 {
740 /* L10N: You will see this error message if (1) you are decrypting
741 (not encrypting) something and (2) it is a plaintext. So the
742 message does not mean "You failed to encrypt the message." */
743 mutt_error(_("PGP message is not encrypted"));
744 }
745 else
746 {
747 mutt_message(_("PGP message successfully decrypted"));
748 }
749 }
750 else if (pgp_keyblock)
751 {
752 state_attach_puts(state, _("[-- END PGP PUBLIC KEY BLOCK --]\n"));
753 }
754 else
755 {
756 state_attach_puts(state, _("[-- END PGP SIGNED MESSAGE --]\n"));
757 }
758 }
759 }
760 else
761 {
762 /* A traditional PGP part may mix signed and unsigned content */
763 /* XXX we may wish to recode here */
764 if (state->prefix)
765 state_puts(state, state->prefix);
766 state_puts(state, buf);
767 }
768 }
769
770 rc = 0;
771
772out:
773 m->goodsig = (maybe_goodsig && have_any_sigs);
774
775 if (fp_tmp)
776 {
777 mutt_file_fclose(&fp_tmp);
778 mutt_file_unlink(buf_string(tmpfname));
779 }
780 mutt_file_fclose(&fp_pgp_out);
781 mutt_file_fclose(&fp_pgp_err);
782
783 buf_pool_release(&tmpfname);
784
785 FREE(&gpgcharset);
786
787 if (needpass == -1)
788 {
789 state_attach_puts(state, _("[-- Error: could not find beginning of PGP message --]\n\n"));
790 return -1;
791 }
792
793 return rc;
794}
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:90
void crypt_current_time(struct State *state, const char *app_name)
Print the current time.
Definition: crypt.c:69
void mutt_need_hard_redraw(void)
Force a hard refresh.
Definition: curs_lib.c:163
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:634
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:194
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:217
bool pgp_class_valid_passphrase(void)
Implements CryptModuleSpecs::valid_passphrase() -.
Definition: pgp.c:85
void pgp_class_void_passphrase(void)
Implements CryptModuleSpecs::void_passphrase() -.
Definition: pgp.c:76
#define mutt_error(...)
Definition: logging2.h:90
@ LL_DEBUG3
Log at debug level 3.
Definition: logging2.h:45
bool mutt_ch_check_charset(const char *cs, bool strict)
Does iconv understand a character set?
Definition: charset.c:885
#define MUTT_ICONV_HOOK_FROM
apply charset-hooks to fromcode
Definition: charset.h:72
void state_prefix_putc(struct State *state, char c)
Write a prefixed character to the state.
Definition: state.c:163
#define state_set_prefix(state)
Definition: state.h:55
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:251
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:798
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:568
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:327
static char PgpPass[1024]
Cached PGP Passphrase.
Definition: pgp.c:69
static int pgp_copy_checksig(FILE *fp_in, FILE *fp_out)
Copy PGP output and look for signs of a good signature.
Definition: pgp.c:252
static void pgp_copy_clearsigned(FILE *fp_in, struct State *state, char *charset)
Copy a clearsigned message, stripping the signature.
Definition: pgp.c:425
bool pgp_use_gpg_agent(void)
Does the user want to use the gpg agent?
Definition: pgp.c:128
static int pgp_check_decryption_okay(FILE *fp_in)
Check GPG output for status codes.
Definition: pgp.c:358
pid_t pgp_invoke_decode(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, bool need_passphrase)
Use PGP to decode a message.
Definition: pgpinvoke.c:263
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
String manipulation buffer.
Definition: buffer.h:34
FILE * fp_out
File to write to.
Definition: state.h:49
#define buf_mktemp(buf)
Definition: tmp.h:37
+ Here is the call graph for this function:

◆ smime_class_application_handler()

int smime_class_application_handler ( struct Body m,
struct State state 
)

Implements CryptModuleSpecs::application_handler() -.

Definition at line 2171 of file smime.c.

2172{
2173 int rc = -1;
2174
2175 /* clear out any mime headers before the handler, so they can't be spoofed. */
2177
2178 struct Body *tattach = smime_handle_entity(m, state, NULL);
2179 if (tattach)
2180 {
2181 rc = 0;
2182 mutt_body_free(&tattach);
2183 }
2184 return rc;
2185}
static struct Body * smime_handle_entity(struct Body *m, struct State *state, FILE *fp_out_file)
Handle type application/pkcs7-mime.
Definition: smime.c:1870
+ Here is the call graph for this function: