2 * Copyright notice from original mutt:
3 * Copyright (C) 1996,1997 Michael R. Elkins <me@mutt.org>
4 * Copyright (C) 1998,1999 Thomas Roessler <roessler@does-not-exist.org>
5 * Copyright (C) 2004 g10 Code GmbH
7 * This file is part of mutt-ng, see http://www.muttng.org/.
8 * It's licensed under the GNU General Public License,
9 * please see the file GPL in the top level source directory.
13 * This file contains all of the PGP routines necessary to sign, encrypt,
14 * verify and decrypt PGP messages in either the new PGP/MIME format, or
15 * in the older Application/Pgp format. It also contains some code to
16 * cache the user's passphrase for repeat use when decrypting or signing
20 #include <lib-lib/lib-lib.h>
22 #ifdef HAVE_SYS_RESOURCE_H
23 # include <sys/resource.h>
26 #include <lib-mime/mime.h>
27 #include <lib-sys/unix.h>
29 #include <lib-ui/curses.h>
30 #include <lib-ui/enter.h>
31 #include <lib-ui/menu.h>
32 #include <lib-mx/mx.h>
42 char PgpPass[LONG_STRING];
43 time_t PgpExptime = 0; /* when does the cached passphrase expire? */
45 void pgp_void_passphrase (void)
47 p_clear(PgpPass, countof(PgpPass));
51 int pgp_valid_passphrase (void)
53 time_t now = time (NULL);
55 if (pgp_use_gpg_agent ()) {
57 return 1; /* handled by gpg-agent */
61 /* Use cached copy. */
64 pgp_void_passphrase ();
66 if (mutt_get_field_unbuffered (_("Enter PGP passphrase:"), PgpPass,
67 sizeof (PgpPass), M_PASS) == 0) {
68 PgpExptime = time (NULL) + PgpTimeout;
77 void pgp_forget_passphrase (void)
79 pgp_void_passphrase ();
80 mutt_message _("PGP passphrase forgotten.");
83 int pgp_use_gpg_agent (void) {
86 if (!option (OPTUSEGPGAGENT) || !getenv ("GPG_AGENT_INFO"))
89 if ((tty = ttyname(0)))
90 setenv ("GPG_TTY", tty, 0);
95 char *pgp_keyid (pgp_key_t k)
97 if ((k->flags & KEYFLAG_SUBKEY) && k->parent && option (OPTPGPIGNORESUB))
100 return _pgp_keyid (k);
103 char *_pgp_keyid (pgp_key_t k)
105 if (option (OPTPGPLONGIDS))
108 return (k->keyid + 8);
111 /* ----------------------------------------------------------------------------
112 * Routines for handing PGP input.
117 /* Copy PGP output messages and look for signs of a good signature */
119 static int pgp_copy_checksig (FILE * fpin, FILE * fpout)
123 if (PgpGoodSign.pattern) {
128 while ((line = mutt_read_line (line, &linelen, fpin, &lineno)) != NULL) {
129 if (regexec (PgpGoodSign.rx, line, 0, NULL, 0) == 0) {
133 if (m_strncmp (line, "[GNUPG:] ", 9) == 0)
141 mutt_copy_stream (fpin, fpout);
149 * Copy a clearsigned message, and strip the signature and PGP's
152 * XXX - charset handling: We assume that it is safe to do
153 * character set decoding first, dash decoding second here, while
154 * we do it the other way around in the main handler.
156 * (Note that we aren't worse than Outlook &c in this, and also
157 * note that we can successfully handle anything produced by any
158 * existing versions of mutt.)
161 static void pgp_copy_clearsigned (FILE * fpin, STATE * s, char *charset)
163 char buf[HUGE_STRING];
164 short complete, armor_header;
170 fc = fgetconv_open (fpin, charset, MCharset.charset, M_ICONV_HOOK_FROM);
172 for (complete = 1, armor_header = 1;
173 fgetconvs (buf, sizeof (buf), fc) != NULL;
174 complete = strchr (buf, '\n') != NULL) {
181 if (m_strcmp(buf, "-----BEGIN PGP SIGNATURE-----\n") == 0)
185 char *p = vskipspaces(buf);
193 state_puts (s->prefix, s);
195 if (buf[0] == '-' && buf[1] == ' ')
196 state_puts (buf + 2, s);
201 fgetconv_close (&fc);
205 /* Support for the Application/PGP Content Type. */
207 int pgp_application_pgp_handler (BODY * m, STATE * s)
209 int could_not_decrypt = 0;
210 int needpass = -1, pgp_keyblock = 0;
212 int clearsign = 0, rv, rc;
215 off_t last_pos, offset;
216 char buf[HUGE_STRING];
217 char outfile[_POSIX_PATH_MAX];
218 char tmpfname[_POSIX_PATH_MAX];
219 FILE *pgpout = NULL, *pgpin = NULL, *pgperr = NULL;
223 short maybe_goodsig = 1;
224 short have_any_sigs = 0;
226 char body_charset[STRING];
228 mutt_get_body_charset (body_charset, sizeof (body_charset), m);
230 rc = 0; /* silence false compiler warning if (s->flags & M_DISPLAY) */
232 fseeko (s->fpin, m->offset, 0);
233 last_pos = m->offset;
235 for (bytes = m->length; bytes > 0;) {
236 if (fgets (buf, sizeof (buf), s->fpin) == NULL)
239 offset = ftello (s->fpin);
240 bytes -= (offset - last_pos); /* don't rely on m_strlen(buf) */
243 if (m_strncmp("-----BEGIN PGP ", buf, 15) == 0) {
245 start_pos = last_pos;
247 if (m_strcmp("MESSAGE-----\n", buf + 15) == 0)
249 else if (m_strcmp("SIGNED MESSAGE-----\n", buf + 15) == 0) {
253 else if (!option (OPTDONTHANDLEPGPKEYS) &&
254 m_strcmp("PUBLIC KEY BLOCK-----\n", buf + 15) == 0) {
259 /* XXX - we may wish to recode here */
261 state_puts (s->prefix, s);
266 have_any_sigs = have_any_sigs || (clearsign && (s->flags & M_VERIFY));
268 /* Copy PGP material to temporary file */
269 tmpfp = m_tempfile(tmpfname, sizeof(tmpfname), NONULL(MCore.tmpdir), NULL);
271 mutt_perror (tmpfname);
276 while (bytes > 0 && fgets (buf, sizeof (buf) - 1, s->fpin) != NULL) {
277 offset = ftello (s->fpin);
278 bytes -= (offset - last_pos); /* don't rely on m_strlen(buf) */
284 && m_strcmp("-----END PGP MESSAGE-----\n", buf) == 0)
286 && (m_strcmp("-----END PGP SIGNATURE-----\n", buf) == 0
287 || m_strcmp("-----END PGP PUBLIC KEY BLOCK-----\n",
292 /* leave tmpfp open in case we still need it - but flush it! */
296 /* Invoke PGP if needed */
297 if (!clearsign || (s->flags & M_VERIFY)) {
298 pgpout = m_tempfile(outfile, sizeof(outfile), NONULL(MCore.tmpdir), NULL);
299 if (pgpout == NULL) {
300 mutt_perror (outfile);
304 if ((thepid = pgp_invoke_decode (&pgpin, NULL, &pgperr, -1,
305 fileno (pgpout), -1, tmpfname,
312 ("[-- Error: unable to create PGP subprocess! --]\n"),
315 else { /* PGP started successfully */
318 if (!pgp_valid_passphrase ())
319 pgp_void_passphrase ();
320 if (pgp_use_gpg_agent ())
322 fprintf (pgpin, "%s\n", PgpPass);
327 if (s->flags & M_DISPLAY) {
328 crypt_current_time (s, "PGP");
329 rc = pgp_copy_checksig (pgperr, s->fpout);
333 rv = mutt_wait_filter (thepid);
335 if (s->flags & M_DISPLAY) {
341 * gpg_good_sign-pattern did not match || pgp_decode_command returned not 0
342 * Sig _is_ correct if
343 * gpg_good_sign="" && pgp_decode_command returned 0
348 state_attach_puts (_("[-- End of PGP output --]\n\n"), s);
352 /* treat empty result as sign of failure */
353 /* TODO: maybe on failure mutt should include the original undecoded text. */
359 if (!clearsign && (!pgpout || c == EOF)) {
360 could_not_decrypt = 1;
361 pgp_void_passphrase ();
364 if (could_not_decrypt && !(s->flags & M_DISPLAY)) {
365 mutt_error _("Could not decrypt PGP message");
373 * Now, copy cleartext to the screen. NOTE - we expect that PGP
374 * outputs utf-8 cleartext. This may not always be true, but it
375 * seems to be a reasonable guess.
378 if (s->flags & M_DISPLAY) {
380 state_attach_puts (_("[-- BEGIN PGP MESSAGE --]\n\n"), s);
381 else if (pgp_keyblock)
382 state_attach_puts (_("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"), s);
384 state_attach_puts (_("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"), s);
390 pgp_copy_clearsigned (tmpfp, s, body_charset);
396 state_set_prefix (s);
397 fc = fgetconv_open (pgpout, "utf-8", MCharset.charset, 0);
398 while ((c = fgetconv (fc)) != EOF)
399 state_prefix_putc (c, s);
400 fgetconv_close (&fc);
403 if (s->flags & M_DISPLAY) {
404 state_putc ('\n', s);
406 state_attach_puts (_("[-- END PGP MESSAGE --]\n"), s);
407 if (could_not_decrypt)
408 mutt_error _("Could not decrypt PGP message.");
410 mutt_message _("PGP message successfully decrypted.");
412 else if (pgp_keyblock)
413 state_attach_puts (_("[-- END PGP PUBLIC KEY BLOCK --]\n"), s);
415 state_attach_puts (_("[-- END PGP SIGNED MESSAGE --]\n"), s);
420 /* XXX - we may wish to recode here */
422 state_puts (s->prefix, s);
430 m->goodsig = (maybe_goodsig && have_any_sigs);
434 mutt_unlink (tmpfname);
438 mutt_unlink (outfile);
441 if (needpass == -1) {
443 ("[-- Error: could not find beginning of PGP message! --]\n\n"),
451 static int pgp_check_traditional_one_body (FILE * fp, BODY * b,
454 char tempfile[_POSIX_PATH_MAX];
455 char buf[HUGE_STRING];
463 if (b->type != TYPETEXT)
466 if (tagged_only && !b->tagged)
469 tempfd = m_tempfd(tempfile, sizeof(tempfile), NONULL(MCore.tmpdir), NULL);
470 if (mutt_decode_save_attachment (fp, b, tempfd, 0) != 0) {
475 if (!(tfp = fopen(tempfile, "r"))) {
480 while (fgets (buf, sizeof (buf), tfp)) {
481 if (m_strncmp("-----BEGIN PGP ", buf, 15) == 0) {
482 if (m_strcmp("MESSAGE-----\n", buf + 15) == 0)
484 else if (m_strcmp("SIGNED MESSAGE-----\n", buf + 15) == 0)
486 else if (m_strcmp("PUBLIC KEY BLOCK-----\n", buf + 15) == 0)
493 if (!enc && !sgn && !key)
496 /* fix the content type */
498 parameter_setval(&b->parameter, "format", "fixed");
500 parameter_setval(&b->parameter, "x-action", "pgp-encrypted");
502 parameter_setval(&b->parameter, "x-action", "pgp-signed");
504 parameter_setval(&b->parameter, "x-action", "pgp-keys");
509 int pgp_check_traditional (FILE * fp, BODY * b, int tagged_only)
514 for (; b; b = b->next) {
515 if (is_multipart (b))
516 rv = pgp_check_traditional (fp, b->parts, tagged_only) || rv;
517 else if (b->type == TYPETEXT) {
518 if ((r = mutt_is_application_pgp (b)))
521 rv = pgp_check_traditional_one_body (fp, b, tagged_only) || rv;
532 int pgp_verify_one (BODY * sigbdy, STATE * s, const char *tempfile)
534 char sigfile[_POSIX_PATH_MAX], pgperrfile[_POSIX_PATH_MAX];
535 FILE *fp, *pgpout, *pgperr;
540 snprintf (sigfile, sizeof (sigfile), "%s.asc", tempfile);
542 if (!(fp = safe_fopen (sigfile, "w"))) {
543 mutt_perror (sigfile);
547 fseeko (s->fpin, sigbdy->offset, 0);
548 mutt_copy_bytes (s->fpin, fp, sigbdy->length);
551 pgperr = m_tempfile(pgperrfile, sizeof(pgperrfile), NONULL(MCore.tmpdir), NULL);
552 if (pgperr == NULL) {
553 mutt_perror (pgperrfile);
558 crypt_current_time (s, "PGP");
560 if ((thepid = pgp_invoke_verify (NULL, &pgpout, NULL,
561 -1, -1, fileno (pgperr),
562 tempfile, sigfile)) != -1) {
563 if (pgp_copy_checksig (pgpout, s->fpout) >= 0)
571 if (pgp_copy_checksig (pgperr, s->fpout) >= 0)
574 if ((rv = mutt_wait_filter (thepid)))
580 state_attach_puts (_("[-- End of PGP output --]\n\n"), s);
582 mutt_unlink (sigfile);
583 mutt_unlink (pgperrfile);
589 /* Extract pgp public keys from messages or attachments */
591 static void pgp_extract_keys_from_attachment (FILE * fp, BODY * top)
595 char tempfname[_POSIX_PATH_MAX];
597 tempfp = m_tempfile(tempfname, sizeof(tempfname), NONULL(MCore.tmpdir), NULL);
598 if (tempfp == NULL) {
599 mutt_perror (_("Can't create temporary file"));
608 mutt_body_handler (top, &s);
612 if (CRYPT_MOD_CALL_CHECK (PGP, pgp_invoke_import)) {
613 (CRYPT_MOD_CALL (PGP, pgp_invoke_import)) (fname);
614 mutt_any_key_to_continue (NULL);
617 mutt_unlink (tempfname);
620 void pgp_extract_keys_from_attachment_list (FILE * fp, int tag, BODY * top)
623 mutt_error _("Internal error. Inform <roessler@does-not-exist.org>.");
629 set_option (OPTDONTHANDLEPGPKEYS);
631 for (; top; top = top->next) {
632 if (!tag || top->tagged)
633 pgp_extract_keys_from_attachment (fp, top);
639 unset_option (OPTDONTHANDLEPGPKEYS);
642 BODY *pgp_decrypt_part (BODY * a, STATE * s, FILE * fpout, BODY * p)
644 char buf[LONG_STRING];
645 FILE *pgpin, *pgpout, *pgperr, *pgptmp;
649 char pgperrfile[_POSIX_PATH_MAX];
650 char pgptmpfile[_POSIX_PATH_MAX];
654 pgperr = m_tempfile(pgperrfile, sizeof(pgperrfile), NONULL(MCore.tmpdir), NULL);
656 mutt_perror (pgperrfile);
661 pgptmp = m_tempfile(pgptmpfile, sizeof(pgptmpfile), NONULL(MCore.tmpdir), NULL);
663 mutt_perror (pgptmpfile);
668 /* Position the stream at the beginning of the body, and send the data to
669 * the temporary file.
672 fseeko (s->fpin, a->offset, 0);
673 mutt_copy_bytes (s->fpin, pgptmp, a->length);
676 if ((thepid = pgp_invoke_decrypt (&pgpin, &pgpout, NULL, -1, -1,
677 fileno (pgperr), pgptmpfile)) == -1) {
680 if (s->flags & M_DISPLAY)
682 ("[-- Error: could not create a PGP subprocess! --]\n\n"),
687 /* send the PGP passphrase to the subprocess. Never do this if the
688 agent is active, because this might lead to a passphrase send as
690 if (!pgp_use_gpg_agent ())
691 fputs (PgpPass, pgpin);
695 /* Read the output from PGP, and make sure to change CRLF to LF, otherwise
696 * read_mime_header has a hard time parsing the message.
698 while (fgets (buf, sizeof (buf) - 1, pgpout) != NULL) {
700 if (len > 1 && buf[len - 2] == '\r')
701 m_strcpy(buf + len - 2, len - 2, "\n");
706 rv = mutt_wait_filter (thepid);
707 mutt_unlink (pgptmpfile);
709 if (s->flags & M_DISPLAY) {
712 if (pgp_copy_checksig (pgperr, s->fpout) == 0 && !rv && p)
716 state_attach_puts (_("[-- End of PGP output --]\n\n"), s);
723 if (fgetc (fpout) == EOF) {
724 mutt_error (_("Decryption failed."));
725 pgp_void_passphrase ();
731 if ((tattach = mutt_read_mime_header (fpout, 0)) != NULL) {
733 * Need to set the length of this body part.
735 fstat (fileno (fpout), &info);
736 tattach->length = info.st_size - tattach->offset;
738 /* See if we need to recurse on this MIME part. */
740 mutt_parse_part (fpout, tattach);
746 int pgp_decrypt_mime (FILE * fpin, FILE ** fpout, BODY * b, BODY ** cur)
748 char tempfile[_POSIX_PATH_MAX];
752 if (!mutt_is_multipart_encrypted (b))
755 if (!b->parts || !b->parts->next)
762 *fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(MCore.tmpdir), NULL);
763 if (*fpout == NULL) {
764 mutt_perror (_("Can't create temporary file"));
769 *cur = pgp_decrypt_part (b, &s, *fpout, p);
779 int pgp_encrypted_handler (BODY * a, STATE * s)
781 char tempfile[_POSIX_PATH_MAX];
788 if (!a || a->type != TYPEAPPLICATION || !a->subtype ||
789 ascii_strcasecmp ("pgp-encrypted", a->subtype) != 0 ||
790 !a->next || a->next->type != TYPEAPPLICATION || !a->next->subtype ||
791 ascii_strcasecmp ("octet-stream", a->next->subtype) != 0) {
792 if (s->flags & M_DISPLAY)
793 state_attach_puts (_("[-- Error: malformed PGP/MIME message! --]\n\n"),
799 * Move forward to the application/pgp-encrypted body.
803 fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(MCore.tmpdir), NULL);
805 if (s->flags & M_DISPLAY)
807 ("[-- Error: could not create temporary file! --]\n"),
812 if (s->flags & M_DISPLAY)
813 crypt_current_time (s, "PGP");
815 if ((tattach = pgp_decrypt_part (a, s, fpout, p)) != NULL) {
816 if (s->flags & M_DISPLAY)
818 ("[-- The following data is PGP/MIME encrypted --]\n\n"),
823 rc = mutt_body_handler (tattach, s);
827 * if a multipart/signed is the _only_ sub-part of a
828 * multipart/encrypted, cache signature verification
833 if (mutt_is_multipart_signed (tattach) && !tattach->next)
834 p->goodsig |= tattach->goodsig;
836 if (s->flags & M_DISPLAY) {
837 state_puts ("\n", s);
838 state_attach_puts (_("[-- End of PGP/MIME encrypted data --]\n"), s);
841 body_list_wipe(&tattach);
842 /* clear 'Invoking...' message, since there's no error */
843 mutt_message _("PGP message successfully decrypted.");
845 mutt_error _("Could not decrypt PGP message");
846 pgp_void_passphrase ();
851 mutt_unlink (tempfile);
856 /* ----------------------------------------------------------------------------
857 * Routines for sending PGP/MIME messages.
861 BODY *pgp_sign_message (BODY * a)
864 char buffer[LONG_STRING];
865 char sigfile[_POSIX_PATH_MAX], signedfile[_POSIX_PATH_MAX];
866 FILE *pgpin, *pgpout, *pgperr, *fp, *sfp;
871 convert_to_7bit (a); /* Signed data _must_ be in 7-bit format. */
873 fp = m_tempfile(sigfile, sizeof(sigfile), NONULL(MCore.tmpdir), NULL);
878 sfp = m_tempfile(signedfile, sizeof(signedfile), NONULL(MCore.tmpdir), NULL);
880 mutt_perror (signedfile);
886 mutt_write_mime_header (a, sfp);
888 mutt_write_mime_body (a, sfp);
891 if ((thepid = pgp_invoke_sign (&pgpin, &pgpout, &pgperr,
892 -1, -1, -1, signedfile)) == -1) {
893 mutt_perror (_("Can't open PGP subprocess!"));
901 if (!pgp_use_gpg_agent ())
902 fputs (PgpPass, pgpin);
907 * Read back the PGP signature. Also, change MESSAGE=>SIGNATURE as
908 * recommended for future releases of PGP.
910 while (fgets (buffer, sizeof (buffer) - 1, pgpout) != NULL) {
911 if (m_strcmp("-----BEGIN PGP MESSAGE-----\n", buffer) == 0)
912 fputs ("-----BEGIN PGP SIGNATURE-----\n", fp);
913 else if (m_strcmp("-----END PGP MESSAGE-----\n", buffer) == 0)
914 fputs ("-----END PGP SIGNATURE-----\n", fp);
917 empty = 0; /* got some output, so we're ok */
920 /* check for errors from PGP */
922 while (fgets (buffer, sizeof (buffer) - 1, pgperr) != NULL) {
924 fputs (buffer, stdout);
927 if (mutt_wait_filter (thepid) && option (OPTPGPCHECKEXIT))
934 if (m_fclose(&fp) != 0) {
935 mutt_perror ("fclose");
941 pgp_void_passphrase ();
942 mutt_any_key_to_continue (NULL);
947 return (NULL); /* fatal error while signing */
951 t->type = TYPEMULTIPART;
952 t->subtype = m_strdup("signed");
953 t->encoding = ENC7BIT;
955 t->disposition = DISPINLINE;
957 parameter_set_boundary(&t->parameter);
958 parameter_setval(&t->parameter, "protocol", "application/pgp-signature");
959 parameter_setval(&t->parameter, "micalg", pgp_micalg (sigfile));
964 t->parts->next = body_new();
966 t->type = TYPEAPPLICATION;
967 t->subtype = m_strdup("pgp-signature");
968 t->filename = m_strdup(sigfile);
970 t->disposition = DISPINLINE;
971 t->encoding = ENC7BIT;
972 t->unlink = 1; /* ok to remove this file after sending. */
977 static short is_numerical_keyid (const char *s)
979 /* or should we require the "0x"? */
980 if (m_strncmp (s, "0x", 2) == 0)
985 if (strchr ("0123456789ABCDEFabcdef", *s++) == NULL)
991 /* This routine attempts to find the keyids of the recipients of a message.
992 * It returns NULL if any of the keys can not be found.
994 char *pgp_findKeys (address_t * to, address_t * cc, address_t * bcc)
996 char *keylist = NULL, *t;
998 size_t keylist_size = 0;
999 size_t keylist_used = 0;
1000 address_t *tmp = NULL, *addr = NULL;
1001 address_t **last = &tmp;
1004 pgp_key_t k_info = NULL, key = NULL;
1006 const char *fqdn = mutt_fqdn (1);
1008 for (i = 0; i < 3; i++) {
1023 *last = address_list_dup (p);
1025 last = &((*last)->next);
1028 rfc822_qualify (tmp, fqdn);
1030 address_list_uniq(tmp);
1032 for (p = tmp; p; p = p->next) {
1033 char buf[LONG_STRING];
1038 if ((keyID = mutt_crypt_hook (p)) != NULL) {
1041 snprintf (buf, sizeof (buf), _("Use keyID = \"%s\" for %s?"), keyID,
1043 if ((r = mutt_yesorno (buf, M_YES)) == M_YES) {
1044 if (is_numerical_keyid (keyID)) {
1045 if (m_strncmp (keyID, "0x", 2) == 0)
1047 goto bypass_selection; /* you don't see this. */
1050 /* check for e-mail address */
1051 if ((t = strchr (keyID, '@')) &&
1052 (addr = rfc822_parse_adrlist (NULL, keyID))) {
1053 rfc822_qualify (addr, fqdn);
1057 k_info = pgp_getkeybystr (keyID, KEYFLAG_CANENCRYPT, PGP_PUBRING);
1061 address_list_wipe(&tmp);
1062 address_list_wipe(&addr);
1068 pgp_invoke_getkeys (q);
1072 pgp_getkeybyaddr (q, KEYFLAG_CANENCRYPT, PGP_PUBRING)) == NULL) {
1073 snprintf (buf, sizeof (buf), _("Enter keyID for %s: "), q->mailbox);
1075 if ((key = pgp_ask_for_key (buf, q->mailbox,
1076 KEYFLAG_CANENCRYPT, PGP_PUBRING)) == NULL) {
1078 address_list_wipe(&tmp);
1079 address_list_wipe(&addr);
1086 keyID = pgp_keyid (key);
1089 keylist_size += m_strlen(keyID) + 4;
1090 p_realloc(&keylist, keylist_size);
1091 sprintf (keylist + keylist_used, "%s0x%s", keylist_used ? " " : "",
1093 keylist_used = m_strlen(keylist);
1095 pgp_free_key (&key);
1096 address_list_wipe(&addr);
1099 address_list_wipe(&tmp);
1103 /* Warning: "a" is no longer freed in this routine, you need
1104 * to free it later. This is necessary for $fcc_attach. */
1106 BODY *pgp_encrypt_message (BODY * a, char *keylist, int sign)
1108 char buf[LONG_STRING];
1109 char tempfile[_POSIX_PATH_MAX], pgperrfile[_POSIX_PATH_MAX];
1110 char pgpinfile[_POSIX_PATH_MAX];
1111 FILE *pgpin, *pgperr, *fpout, *fptmp;
1117 fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(MCore.tmpdir), NULL);
1118 if (fpout == NULL) {
1119 mutt_perror (_("Can't create temporary file"));
1123 pgperr = m_tempfile(pgperrfile, sizeof(pgperrfile), NONULL(MCore.tmpdir), NULL);
1124 if (pgperr == NULL) {
1125 mutt_perror (pgperrfile);
1130 unlink (pgperrfile);
1132 fptmp = m_tempfile(pgpinfile, sizeof(pgpinfile), NONULL(MCore.tmpdir), NULL);
1133 if (fptmp == NULL) {
1134 mutt_perror (pgpinfile);
1138 unlink (pgperrfile);
1143 convert_to_7bit (a);
1145 mutt_write_mime_header (a, fptmp);
1146 fputc ('\n', fptmp);
1147 mutt_write_mime_body (a, fptmp);
1150 if ((thepid = pgp_invoke_encrypt (&pgpin, NULL, NULL, -1,
1151 fileno (fpout), fileno (pgperr),
1152 pgpinfile, keylist, sign)) == -1) {
1159 if (!pgp_use_gpg_agent ())
1160 fputs (PgpPass, pgpin);
1161 fputc ('\n', pgpin);
1165 if (mutt_wait_filter (thepid) && option (OPTPGPCHECKEXIT))
1173 empty = (fgetc (fpout) == EOF);
1178 while (fgets (buf, sizeof (buf) - 1, pgperr) != NULL) {
1180 fputs (buf, stdout);
1184 /* pause if there is any error output from PGP */
1186 mutt_any_key_to_continue (NULL);
1189 /* fatal error while trying to encrypt message */
1191 pgp_void_passphrase (); /* just in case */
1197 t->type = TYPEMULTIPART;
1198 t->subtype = m_strdup("encrypted");
1199 t->encoding = ENC7BIT;
1201 t->disposition = DISPINLINE;
1203 parameter_set_boundary(&t->parameter);
1204 parameter_setval(&t->parameter, "protocol", "application/pgp-encrypted");
1206 t->parts = body_new();
1207 t->parts->type = TYPEAPPLICATION;
1208 t->parts->subtype = m_strdup("pgp-encrypted");
1209 t->parts->encoding = ENC7BIT;
1211 t->parts->next = body_new();
1212 t->parts->next->type = TYPEAPPLICATION;
1213 t->parts->next->subtype = m_strdup("octet-stream");
1214 t->parts->next->encoding = ENC7BIT;
1215 t->parts->next->filename = m_strdup(tempfile);
1216 t->parts->next->use_disp = 1;
1217 t->parts->next->disposition = DISPINLINE;
1218 t->parts->next->unlink = 1; /* delete after sending the message */
1219 t->parts->next->d_filename = m_strdup("msg.asc"); /* non pgp/mime can save */
1224 BODY *pgp_traditional_encryptsign (BODY * a, int flags, char *keylist)
1228 char pgpoutfile[_POSIX_PATH_MAX];
1229 char pgperrfile[_POSIX_PATH_MAX];
1230 char pgpinfile[_POSIX_PATH_MAX];
1232 char body_charset[STRING];
1234 const char *send_charset;
1236 FILE *pgpout = NULL, *pgperr = NULL, *pgpin = NULL;
1246 if (a->type != TYPETEXT)
1248 if (ascii_strcasecmp (a->subtype, "plain"))
1251 if ((fp = fopen (a->filename, "r")) == NULL) {
1252 mutt_perror (a->filename);
1256 pgpin = m_tempfile(pgpinfile, sizeof(pgpinfile), NONULL(MCore.tmpdir), NULL);
1257 if (pgpin == NULL) {
1258 mutt_perror (pgpinfile);
1263 /* The following code is really correct: If noconv is set,
1264 * a's charset parameter contains the on-disk character set, and
1265 * we have to convert from that to utf-8. If noconv is not set,
1266 * we have to convert from $charset to utf-8.
1269 mutt_get_body_charset (body_charset, sizeof (body_charset), a);
1271 from_charset = body_charset;
1273 from_charset = MCharset.charset;
1275 if (!charset_is_us_ascii (body_charset)) {
1279 if (flags & ENCRYPT)
1280 send_charset = "us-ascii";
1282 send_charset = "utf-8";
1284 fc = fgetconv_open (fp, from_charset, "utf-8", M_ICONV_HOOK_FROM);
1285 while ((c = fgetconv (fc)) != EOF)
1288 fgetconv_close (&fc);
1291 send_charset = "us-ascii";
1292 mutt_copy_stream (fp, pgpin);
1297 pgpout = m_tempfile(pgpoutfile, sizeof(pgpoutfile), NONULL(MCore.tmpdir), NULL);
1298 pgperr = m_tempfile(pgperrfile, sizeof(pgperrfile), NONULL(MCore.tmpdir), NULL);
1299 if (pgpout == NULL || pgperr == NULL) {
1300 mutt_perror (pgpout ? pgperrfile : pgpoutfile);
1304 unlink (pgpoutfile);
1310 unlink (pgperrfile);
1312 if ((thepid = pgp_invoke_traditional (&pgpin, NULL, NULL,
1313 -1, fileno (pgpout), fileno (pgperr),
1314 pgpinfile, keylist, flags)) == -1) {
1315 mutt_perror (_("Can't invoke PGP"));
1319 mutt_unlink (pgpinfile);
1320 unlink (pgpoutfile);
1324 if (pgp_use_gpg_agent ())
1327 fprintf (pgpin, "%s\n", PgpPass);
1330 if (mutt_wait_filter (thepid) && option (OPTPGPCHECKEXIT))
1333 mutt_unlink (pgpinfile);
1342 empty = (fgetc (pgpout) == EOF);
1347 while (fgets (buff, sizeof (buff), pgperr)) {
1349 fputs (buff, stdout);
1355 mutt_any_key_to_continue (NULL);
1359 pgp_void_passphrase (); /* just in case */
1360 unlink (pgpoutfile);
1366 b->encoding = ENC7BIT;
1369 b->subtype = m_strdup("plain");
1371 parameter_setval(&b->parameter, "x-action",
1372 flags & ENCRYPT ? "pgp-encrypted" : "pgp-signed");
1373 parameter_setval(&b->parameter, "charset", send_charset);
1375 b->filename = m_strdup(pgpoutfile);
1377 b->disposition = DISPINLINE;
1383 if (!(flags & ENCRYPT))
1384 b->encoding = a->encoding;
1389 int pgp_send_menu (HEADER * msg, int *redraw)
1392 char input_signas[STRING];
1394 char prompt[LONG_STRING];
1396 /* If autoinline and no crypto options set, then set inline. */
1397 if (option (OPTPGPAUTOINLINE) && !((msg->security & APPLICATION_PGP)
1398 && (msg->security & (SIGN | ENCRYPT))))
1399 msg->security |= INLINE;
1401 snprintf (prompt, sizeof (prompt),
1402 _("PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, %s, or (c)lear? "),
1403 (msg->security & INLINE) ? _("PGP/M(i)ME") : _("(i)nline"));
1405 switch (mutt_multi_choice (prompt, _("esabifc"))) {
1406 case 1: /* (e)ncrypt */
1407 msg->security |= ENCRYPT;
1408 msg->security &= ~SIGN;
1411 case 2: /* (s)ign */
1412 msg->security |= SIGN;
1413 msg->security &= ~ENCRYPT;
1416 case 3: /* sign (a)s */
1417 unset_option (OPTPGPCHECKTRUST);
1420 pgp_ask_for_key (_("Sign as: "), NULL, KEYFLAG_CANSIGN,
1422 snprintf (input_signas, sizeof (input_signas), "0x%s", pgp_keyid (p));
1423 m_strreplace(&PgpSignAs, input_signas);
1426 msg->security |= SIGN;
1428 crypt_pgp_void_passphrase (); /* probably need a different passphrase */
1431 *redraw = REDRAW_FULL;
1434 case 4: /* (b)oth */
1435 msg->security |= (ENCRYPT | SIGN);
1438 case 5: /* (i)nline */
1439 if ((msg->security & (ENCRYPT | SIGN)))
1440 msg->security ^= INLINE;
1442 msg->security &= ~INLINE;
1445 case 6: /* (f)orget it */
1446 case 7: /* (c)lear */
1451 if (msg->security) {
1452 if (!(msg->security & (ENCRYPT | SIGN)))
1455 msg->security |= APPLICATION_PGP;
1458 return (msg->security);