2470{
2471 int needpass = -1;
2472 bool pgp_keyblock = false;
2473 bool clearsign = false;
2474 long bytes;
2475 LOFF_T last_pos;
2476 LOFF_T block_begin;
2477 LOFF_T block_end;
2478 char buf[8192] = { 0 };
2479 FILE *fp_out = NULL;
2480
2481 gpgme_error_t err = GPG_ERR_NO_ERROR;
2482 gpgme_data_t armored_data = NULL;
2483
2484 bool maybe_goodsig = true;
2485 bool have_any_sigs = false;
2486
2487 char body_charset[256] = { 0 };
2488 char *gpgcharset = NULL;
2489
2491
2492
2493
2495 mutt_str_copy(body_charset,
"iso-8859-1",
sizeof(body_charset));
2496
2498 {
2499 return -1;
2500 }
2502
2503 for (bytes = b->
length; bytes > 0;)
2504 {
2505
2506 block_begin = last_pos;
2507
2508 if (!fgets(buf,
sizeof(buf), state->
fp_in))
2509 break;
2510
2511 LOFF_T offset = ftello(state->
fp_in);
2512 if (offset < 0)
2513 {
2515 offset = 0;
2516 }
2517 bytes -= (offset - last_pos);
2518 last_pos = offset;
2519
2521 if (plen != 0)
2522 {
2523 needpass = 0;
2524 clearsign = false;
2525 pgp_keyblock = false;
2526
2528 {
2529 needpass = 1;
2530 }
2532 {
2533 clearsign = true;
2534 }
2536 {
2537 pgp_keyblock = true;
2538 }
2539 else
2540 {
2541
2545 continue;
2546 }
2547
2548
2549 while ((bytes > 0) && (fgets(buf,
sizeof(buf) - 1, state->
fp_in) != NULL))
2550 {
2551 offset = ftello(state->
fp_in);
2552 if (offset < 0)
2553 {
2555 offset = 0;
2556 }
2557 bytes -= (offset - last_pos);
2558 last_pos = offset;
2559
2560 if (needpass &&
mutt_str_equal(
"-----END PGP MESSAGE-----\n", buf))
2561 {
2562 break;
2563 }
2564
2565 if (!needpass && (
mutt_str_equal(
"-----END PGP SIGNATURE-----\n", buf) ||
2567 {
2568 break;
2569 }
2570
2571
2573 {
2574 size_t l = 0;
2577 if ((l =
mutt_str_len(gpgcharset)) > 0 && gpgcharset[l - 1] ==
'\n')
2578 gpgcharset[l - 1] = 0;
2581 }
2582 }
2583 block_end = ftello(state->
fp_in);
2584 if (block_end < 0)
2585 {
2587 block_end = 0;
2588 }
2589
2590 have_any_sigs = (have_any_sigs || (clearsign && (state->
flags &
STATE_VERIFY)));
2591
2592
2594 fseeko(state->
fp_in, block_end, 0);
2595
2596
2597 if (pgp_keyblock)
2598 {
2600 }
2602 {
2605
2606 if (clearsign)
2607 {
2608 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2609 }
2610 else
2611 {
2612 err = gpgme_op_decrypt_verify(ctx, armored_data, plaintext);
2613 if (gpg_err_code(err) == GPG_ERR_NO_DATA)
2614 {
2615
2616 gpgme_data_seek(armored_data, 0, SEEK_SET);
2617
2618 gpgme_data_release(plaintext);
2620 err = gpgme_op_verify(ctx, armored_data, NULL, plaintext);
2621 }
2622 }
2624
2625 gpgme_decrypt_result_t result = gpgme_op_decrypt_result(ctx);
2628
2629 if (err != GPG_ERR_NO_ERROR)
2630 {
2631 char errbuf[200] = { 0 };
2632
2633 snprintf(errbuf, sizeof(errbuf) - 1,
2634 _(
"Error: decryption/verification failed: %s\n"), gpgme_strerror(err));
2636 }
2637 else
2638 {
2639
2640
2642
2643 bool sig_stat = false;
2644 char *tmpfname = NULL;
2645
2646
2647 gpgme_verify_result_t verify_result = gpgme_op_verify_result(ctx);
2648 if (verify_result->signatures)
2649 sig_stat = true;
2650
2651 have_any_sigs = false;
2652 maybe_goodsig = false;
2654 {
2655 int res, idx;
2656 bool anybad = false;
2657
2659 have_any_sigs = true;
2661 {
2662 if (res == 1)
2663 anybad = true;
2664 }
2665 if (!anybad && idx)
2666 maybe_goodsig = true;
2667
2669 }
2670
2672 if (tmpfname)
2673 {
2674 unlink(tmpfname);
2676 }
2677 else
2678 {
2680 state_puts(state,
_(
"Error: copy data failed\n"));
2681 }
2682 }
2683 gpgme_data_release(plaintext);
2684 gpgme_release(ctx);
2685 }
2686
2687
2688
2689
2691 {
2692 if (needpass)
2694 else if (pgp_keyblock)
2696 else
2698 }
2699
2700 if (clearsign)
2701 {
2703 }
2704 else if (fp_out)
2705 {
2706 int c;
2707 char *expected_charset = gpgcharset && *gpgcharset ? gpgcharset : "utf-8";
2708 rewind(fp_out);
2712 {
2714 if ((c ==
'\n') && state->
prefix)
2716 }
2718 }
2719
2721 {
2723 if (needpass)
2725 else if (pgp_keyblock)
2727 else
2729 }
2730
2731
2732 gpgme_data_release(armored_data);
2734 }
2735 else
2736 {
2737
2738
2742 }
2743 }
2745
2746 b->
goodsig = (maybe_goodsig && have_any_sigs);
2747
2748 if (needpass == -1)
2749 {
2750 state_attach_puts(state,
_(
"[-- Error: could not find beginning of PGP message --]\n\n"));
2751 return 1;
2752 }
2754
2755 return err;
2756}
const char * cc_charset(void)
Get the cached value of $charset.
static void show_encryption_info(struct State *state, gpgme_decrypt_result_t result)
Show encryption information.
static gpgme_data_t create_gpgme_data(void)
Create a new GPGME data object.
gpgme_ctx_t create_gpgme_context(bool for_smime)
Create a new GPGME context.
#define SIGNED_MESSAGE(_y)
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 char * data_object_to_tempfile(gpgme_data_t data, FILE **fp_ret)
Copy a data object to a temporary file.
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 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.
char * mutt_body_get_charset(struct Body *b, char *buf, size_t buflen)
Get a body's character set.
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
#define mutt_file_fclose(FP)
#define mutt_message(...)
#define mutt_debug(LEVEL,...)
@ LL_DEBUG2
Log at debug level 2.
@ LL_DEBUG1
Log at debug level 1.
bool mutt_ch_check_charset(const char *cs, bool strict)
Does iconv understand a character set?
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.
void mutt_ch_fgetconv_close(struct FgetConv **ptr)
Close an fgetconv handle.
#define MUTT_ICONV_HOOK_FROM
apply charset-hooks to fromcode
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.
char * mutt_str_dup(const char *str)
Copy a string, safely.
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.
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.
LOFF_T offset
offset where the actual data begins
LOFF_T length
length (in bytes) of attachment
bool goodsig
Good cryptographic signature.
Cursor for converting a file's encoding.
StateFlags flags
Flags, e.g. STATE_DISPLAY.
FILE * fp_in
File to read from.
const char * prefix
String to add to the beginning of each output line.