trunk/Src/wptClipDecryptDlg.cpp

/* wptClipDecryptDlg.cpp - Clipboard decryption
 *      Copyright (C) 2000-2006 Timo Schulz
 *      Copyright (C) 2005 g10 Code GmbH
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <assert.h>
#include <time.h>

#include "wptTypes.h"
#include "wptW32API.h"
#include "wptAgent.h"
#include "wptNLS.h"
#include "wptGPG.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptCommonCtl.h"
#include "wptContext.h"
#include "wptDlgs.h"
#include "wptKeylist.h"
#include "wptUTF8.h"
#include "resource.h"

bool is_seckey_available (gpgme_recipient_t rset);
char* get_pka_status (gpgme_signature_t sig);


/* Return the primary user-ID of the key with the keyid @keyid. 
   Caller must free string. */
char*
get_key_userid (const char *keyid)
{
    winpt_key_s key;
    const char *fmt, *userid;
    char *uid;

    fmt = "\n    \"%s\"";
    memset (&key, 0, sizeof (key));
    if (winpt_get_pubkey (keyid, &key))
        userid = (_("user ID not found"));
    else
        userid = key.ext->uids->uid;
    uid = new char[strlen (userid) + strlen (fmt)+ 2];
    if (!uid)
        BUG (NULL);
    sprintf (uid, fmt, userid);
    winpt_release_pubkey (&key);
    return uid;
}


/* Decrypt the clipboard contents and on success
   replace the data with the plaintext.
   Return value: 0 on success. */
gpgme_error_t
gpgme_op_clip_decrypt (gpgme_ctx_t ctx)
{
    gpgme_error_t err;
    gpgme_data_t ciph = NULL;
    gpgme_data_t plain = NULL;
    
    err = gpg_data_new_from_clipboard (&ciph, 0);
    if (err)
        return err;

    err = gpgme_data_new (&plain);
    if (err) {
        gpgme_data_release (ciph);
        return err;
    }

    err = gpgme_op_decrypt_verify (ctx, ciph, plain);

    gpg_data_release_and_set_clipboard (plain, 0);
    gpgme_data_release (ciph);
    return err;
}


/* Return humand readable ownertrust description for verification info. */
const char*
verify_get_key_ownertrust (gpgme_validity_t key_ot, int *novalid)
{
    const char *s;

    if (key_ot == GPGME_VALIDITY_FULL ||
        key_ot == GPGME_VALIDITY_ULTIMATE)
        s = _("Signature status: created with a fully trusted key");    
    else if (key_ot == GPGME_VALIDITY_MARGINAL)    
        s = _("Signature status: created with a marginal trusted key");
    else if (key_ot == GPGME_VALIDITY_NEVER) {
        if (novalid) *novalid = 1;
        s =  _("Signature status: created with an UNTRUSTED key");      
    }
    else
        s = _("Signature status: created with an undefined trusted key");
    return s;
}


/* Return a signature specific header and footer for the clipboard. */
void
verify_get_clip_info (gpgme_signature_t sig, char **r_header, char **r_footer)
{
    struct winpt_key_s pk;
    const char *head = _("*** PGP SIGNATURE VERIFICATION ***\r\n"
                         "*** Signature made:    %s\r\n"
                         "*** Signature verfied: %s\r\n"
                         "*** %s\r\n"
                         "*** Signature result:  %s\r\n"
                         "*** Signer: %s (0x%s)\r\n"
                         "*** BEGIN PGP DECRYPTED TEXT ***\r\n");
    const char *foot = _("\r\n*** END PGP DECRYPTED TEXT ***");
    const char *s, *ver, *ot;
    char *p, *made;

    if (winpt_get_pubkey (sig->fpr, &pk))
        BUG (0);

    ot = verify_get_key_ownertrust (pk.ctx->owner_trust, NULL);
    made = m_strdup (strtimestamp (sig->timestamp));
    ver = strtimestamp (time (NULL));
    s = get_gpg_sigstat (sig->summary);
    p = new char[strlen (head) + strlen (s) + strlen (made) + 
                 strlen (sig->fpr) + strlen (ot) + strlen (ver) +
                 strlen (pk.ext->uids->uid) + 1];
    if (!p)
        BUG (0);
    sprintf (p, head, made, ver, ot, s, 
                pk.ext->uids->uid, get_keyid_from_fpr (sig->fpr));
    *r_header = p;
    *r_footer = m_strdup (foot);
    free_if_alloc (made);
}


/* Show a human readable description of the given signature @sig. */
void
verify_show_signature_state (gpgme_signature_t sig)
{
    winpt_key_s key;
    const char *keyid, *uid;
    const char *s;
    char *pka_info = NULL;
    int novalid = 0;

    assert (sig->fpr != NULL);
        
    keyid = get_keyid_from_fpr (sig->fpr);
    memset (&key, 0, sizeof (key));
    if (!winpt_get_pubkey (keyid, &key)) {
        s = verify_get_key_ownertrust (key.ctx->owner_trust, &novalid);
        uid = key.ext->uids->uid;       
    }
    else {
        s = "";
        uid = _("user ID not found");
    }

    pka_info = get_pka_status (sig);
    log_box (_("Decrypt Verify"), novalid? MB_WARN : MB_OK, 
             _("%s\n"
               "%s\n"
               "Signature made: %s\n"
               "From \"%s\" using key ID 0x%s"
               "%s %s\n%s"),
               s, get_gpg_sigstat (sig->summary),                  
               strtimestamp (sig->timestamp),
               uid, keyid,
               novalid? "\nPrimary key fingerprint: " : "",
               novalid? get_key_fpr (key.ctx) : "",
               pka_info? pka_info : ""
               );
    free_if_alloc (pka_info);
    winpt_release_pubkey (&key);
}


/* Convenient function to provide clipboard decryption.
   @hwnd is the parent window used for showing messsages.
   Return value: 0 on success. */
gpgme_error_t
clip_decrypt_dlg (HWND hwnd, int use_viewer)
{
    gpgme_error_t err;
    gpgme_ctx_t ctx = NULL;
    gpgme_decrypt_result_t res;
    gpgme_verify_result_t sigres;
    passphrase_cb_s pwd;
    int pgp_type = 0;

    /* allow to verify data generated by 'gpg -a --sign foo' */
    if (fm_assume_onepass_sig (NULL) == 1) {
        dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_VERIFY, hwnd,
                          clip_verify_dlg_proc, 0, 
                          _("Verify"), IDS_WINPT_VERIFY);
        return 0;
    }

    err = gpgme_new (&ctx);
    if (err)
        BUG (NULL);
    set_gpg_passphrase_cb (&pwd, ctx, GPG_CMD_DECRYPT, hwnd, _("Decryption"));
    gpg_get_recipients (NULL, &pwd.recipients);

    err = gpgme_op_clip_decrypt (ctx);
    if (pwd.cancel)
        goto leave;
    if (gpgme_err_code (err) ==  GPG_ERR_BAD_PASSPHRASE)
        agent_del_cache (pwd.keyid);

    res = gpgme_op_decrypt_result (ctx);
    if (err && res->recipients && !is_seckey_available (res->recipients)) {
        gpgme_recipient_t r = res->recipients;
        char *u = get_key_userid (r->keyid+8);
        log_box (_("Decryption"), MB_ERR, 
                 _("Encrypted with %s key, ID 0x%s.%s\n"
                   "Decryption failed: secret key not available."), 
                   get_key_pubalgo (r->pubkey_algo), r->keyid+8, u);
        free_if_alloc (u);
        goto leave;
    }
    else if (res->unsupported_algorithm) {
        log_box (_("Decryption"), MB_ERR, _("Unsupported algorithm: %s"), 
                 res->unsupported_algorithm);
    }
    else if (err) {
        gpg_clip_get_pgptype (&pgp_type);
        if (gpgme_err_code (err) == GPG_ERR_NO_DATA && (pgp_type & PGP_MESSAGE))
            msg_box (hwnd, _("Broken OpenPGP message (maybe: quoted printable "
                             "character in armor)."), _("Decryption"), MB_INFO);
        else
            msg_box (hwnd, gpgme_strerror (err), _("Decryption"), MB_ERR);
        goto leave;
    }

    #if 0
    if (status_bad_mdc) { /* XXX: Bad MDC */
        const char *s = 
            _("WARNING: encrypted message has been manipulated!\n"
            "\n"
            "Do *NOT* trust any text or data output from this file!\n"
            "It is likely that the data was corrupted in transport\n"
            "but it might be also possible that this is part of an attack.");
        msg_box (hwnd, s, _("*** IMPORTANT ***"), MB_INFO);
    }
    #endif

    show_msg (GetDesktopWindow (), 1500, _("GnuPG Status: Finished"));

    sigres = gpgme_op_verify_result (ctx);
    if (sigres && sigres->signatures) {
        if (!use_viewer)
            verify_show_signature_state (sigres->signatures);
        else
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CLIPEDIT,
                            hwnd, clip_edit_dlg_proc, 
                            (LPARAM)sigres->signatures);
    }
    else if (use_viewer)
        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CLIPEDIT,
                            hwnd, clip_edit_dlg_proc, 0);

leave:
    release_gpg_passphrase_cb (&pwd);
    gpgme_release (ctx);
    return err;
}
1	twoaday	220	/* wptClipDecryptDlg.cpp - Clipboard decryption
2			* Copyright (C) 2000-2006 Timo Schulz
3	werner	36	* Copyright (C) 2005 g10 Code GmbH
4			*
5			* This file is part of WinPT.
6			*
7			* WinPT is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 2 of the License, or
10			* (at your option) any later version.
11			*
12			* WinPT is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with WinPT; if not, write to the Free Software Foundation,
19			* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20			*/
21
22	werner	42	#ifdef HAVE_CONFIG_H
23			#include <config.h>
24			#endif
25
26	werner	36	#include <windows.h>
27	twoaday	231	#include <assert.h>
28			#include <time.h>
29	werner	36
30			#include "wptTypes.h"
31			#include "wptW32API.h"
32			#include "wptAgent.h"
33			#include "wptNLS.h"
34			#include "wptGPG.h"
35			#include "wptVersion.h"
36			#include "wptErrors.h"
37			#include "wptCommonCtl.h"
38			#include "wptContext.h"
39			#include "wptDlgs.h"
40			#include "wptKeylist.h"
41	twoaday	129	#include "wptUTF8.h"
42	werner	47	#include "resource.h"
43	werner	36
44	twoaday	217	bool is_seckey_available (gpgme_recipient_t rset);
45	twoaday	220	char* get_pka_status (gpgme_signature_t sig);
46	werner	36
47	twoaday	220
48	werner	36	/* Return the primary user-ID of the key with the keyid @keyid.
49			Caller must free string. */
50			char*
51			get_key_userid (const char *keyid)
52			{
53	twoaday	208	winpt_key_s key;
54	twoaday	256	const char fmt, userid;
55	twoaday	208	char *uid;
56	werner	36
57	twoaday	256	fmt = "\n \"%s\"";
58	twoaday	208	memset (&key, 0, sizeof (key));
59			if (winpt_get_pubkey (keyid, &key))
60	twoaday	256	userid = (_("user ID not found"));
61			else
62			userid = key.ext->uids->uid;
63			uid = new char[strlen (userid) + strlen (fmt)+ 2];
64	twoaday	129	if (!uid)
65	werner	36	BUG (NULL);
66	twoaday	256	sprintf (uid, fmt, userid);
67	twoaday	217	winpt_release_pubkey (&key);
68	twoaday	208	return uid;
69	werner	36	}
70
71
72			/* Decrypt the clipboard contents and on success
73			replace the data with the plaintext.
74			Return value: 0 on success. */
75			gpgme_error_t
76			gpgme_op_clip_decrypt (gpgme_ctx_t ctx)
77			{
78			gpgme_error_t err;
79			gpgme_data_t ciph = NULL;
80			gpgme_data_t plain = NULL;
81
82			err = gpg_data_new_from_clipboard (&ciph, 0);
83			if (err)
84			return err;
85
86			err = gpgme_data_new (&plain);
87			if (err) {
88			gpgme_data_release (ciph);
89			return err;
90			}
91
92	twoaday	41	err = gpgme_op_decrypt_verify (ctx, ciph, plain);
93	werner	36
94			gpg_data_release_and_set_clipboard (plain, 0);
95			gpgme_data_release (ciph);
96			return err;
97			}
98
99
100	twoaday	229	/* Return humand readable ownertrust description for verification info. */
101			const char*
102			verify_get_key_ownertrust (gpgme_validity_t key_ot, int *novalid)
103			{
104			const char *s;
105
106			if (key_ot == GPGME_VALIDITY_FULL \|\|
107			key_ot == GPGME_VALIDITY_ULTIMATE)
108			s = _("Signature status: created with a fully trusted key");
109			else if (key_ot == GPGME_VALIDITY_MARGINAL)
110			s = _("Signature status: created with a marginal trusted key");
111			else if (key_ot == GPGME_VALIDITY_NEVER) {
112			if (novalid) *novalid = 1;
113			s = _("Signature status: created with an UNTRUSTED key");
114			}
115			else
116			s = _("Signature status: created with an undefined trusted key");
117			return s;
118			}
119
120
121			/* Return a signature specific header and footer for the clipboard. */
122			void
123			verify_get_clip_info (gpgme_signature_t sig, char r_header, char r_footer)
124			{
125			struct winpt_key_s pk;
126	twoaday	231	const char head = _(" PGP SIGNATURE VERIFICATION *\r\n"
127			"*** Signature made: %s\r\n"
128			"*** Signature verfied: %s\r\n"
129			"*** %s\r\n"
130			"*** Signature result: %s\r\n"
131			"*** Signer: %s (0x%s)\r\n"
132			"* BEGIN PGP DECRYPTED TEXT *\r\n");
133			const char foot = _("\r\n END PGP DECRYPTED TEXT *");
134	twoaday	256	const char s, ver, *ot;
135			char p, made;
136	twoaday	229
137			if (winpt_get_pubkey (sig->fpr, &pk))
138			BUG (0);
139	twoaday	231
140	twoaday	229	ot = verify_get_key_ownertrust (pk.ctx->owner_trust, NULL);
141	twoaday	256	made = m_strdup (strtimestamp (sig->timestamp));
142	twoaday	231	ver = strtimestamp (time (NULL));
143	twoaday	229	s = get_gpg_sigstat (sig->summary);
144			p = new char[strlen (head) + strlen (s) + strlen (made) +
145	twoaday	231	strlen (sig->fpr) + strlen (ot) + strlen (ver) +
146	twoaday	229	strlen (pk.ext->uids->uid) + 1];
147			if (!p)
148			BUG (0);
149	twoaday	231	sprintf (p, head, made, ver, ot, s,
150			pk.ext->uids->uid, get_keyid_from_fpr (sig->fpr));
151	twoaday	229	*r_header = p;
152			*r_footer = m_strdup (foot);
153	twoaday	256	free_if_alloc (made);
154	twoaday	229	}
155
156
157	twoaday	220	/* Show a human readable description of the given signature @sig. */
158			void
159			verify_show_signature_state (gpgme_signature_t sig)
160			{
161			winpt_key_s key;
162			const char keyid, uid;
163			const char *s;
164			char *pka_info = NULL;
165			int novalid = 0;
166
167	twoaday	231	assert (sig->fpr != NULL);
168	twoaday	220
169			keyid = get_keyid_from_fpr (sig->fpr);
170			memset (&key, 0, sizeof (key));
171			if (!winpt_get_pubkey (keyid, &key)) {
172	twoaday	229	s = verify_get_key_ownertrust (key.ctx->owner_trust, &novalid);
173	twoaday	220	uid = key.ext->uids->uid;
174	twoaday	231	}
175	twoaday	220	else {
176			s = "";
177			uid = _("user ID not found");
178			}
179
180	twoaday	229	pka_info = get_pka_status (sig);
181	twoaday	220	log_box (_("Decrypt Verify"), novalid? MB_WARN : MB_OK,
182			_("%s\n"
183			"%s\n"
184			"Signature made: %s\n"
185			"From \"%s\" using key ID 0x%s"
186			"%s %s\n%s"),
187			s, get_gpg_sigstat (sig->summary),
188			strtimestamp (sig->timestamp),
189			uid, keyid,
190			novalid? "\nPrimary key fingerprint: " : "",
191			novalid? get_key_fpr (key.ctx) : "",
192			pka_info? pka_info : ""
193			);
194			free_if_alloc (pka_info);
195			winpt_release_pubkey (&key);
196			}
197
198
199	werner	36	/* Convenient function to provide clipboard decryption.
200			@hwnd is the parent window used for showing messsages.
201			Return value: 0 on success. */
202			gpgme_error_t
203	twoaday	229	clip_decrypt_dlg (HWND hwnd, int use_viewer)
204	werner	36	{
205			gpgme_error_t err;
206			gpgme_ctx_t ctx = NULL;
207			gpgme_decrypt_result_t res;
208			gpgme_verify_result_t sigres;
209			passphrase_cb_s pwd;
210	twoaday	179	int pgp_type = 0;
211	werner	36
212			/* allow to verify data generated by 'gpg -a --sign foo' */
213	twoaday	214	if (fm_assume_onepass_sig (NULL) == 1) {
214			dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_VERIFY, hwnd,
215			clip_verify_dlg_proc, 0,
216			_("Verify"), IDS_WINPT_VERIFY);
217			return 0;
218	werner	36	}
219
220			err = gpgme_new (&ctx);
221			if (err)
222			BUG (NULL);
223			set_gpg_passphrase_cb (&pwd, ctx, GPG_CMD_DECRYPT, hwnd, _("Decryption"));
224	twoaday	179	gpg_get_recipients (NULL, &pwd.recipients);
225
226	werner	36	err = gpgme_op_clip_decrypt (ctx);
227			if (pwd.cancel)
228			goto leave;
229			if (gpgme_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
230			agent_del_cache (pwd.keyid);
231
232			res = gpgme_op_decrypt_result (ctx);
233	twoaday	217	if (err && res->recipients && !is_seckey_available (res->recipients)) {
234	werner	36	gpgme_recipient_t r = res->recipients;
235	twoaday	208	char *u = get_key_userid (r->keyid+8);
236	werner	36	log_box (_("Decryption"), MB_ERR,
237	twoaday	256	_("Encrypted with %s key, ID 0x%s.%s\n"
238	werner	36	"Decryption failed: secret key not available."),
239	twoaday	208	get_key_pubalgo (r->pubkey_algo), r->keyid+8, u);
240			free_if_alloc (u);
241	werner	36	goto leave;
242			}
243	twoaday	41	else if (res->unsupported_algorithm) {
244			log_box (_("Decryption"), MB_ERR, _("Unsupported algorithm: %s"),
245			res->unsupported_algorithm);
246			}
247	werner	36	else if (err) {
248			gpg_clip_get_pgptype (&pgp_type);
249	twoaday	129	if (gpgme_err_code (err) == GPG_ERR_NO_DATA && (pgp_type & PGP_MESSAGE))
250	werner	36	msg_box (hwnd, _("Broken OpenPGP message (maybe: quoted printable "
251	twoaday	129	"character in armor)."), _("Decryption"), MB_INFO);
252	werner	36	else
253			msg_box (hwnd, gpgme_strerror (err), _("Decryption"), MB_ERR);
254			goto leave;
255			}
256
257	twoaday	236	#if 0
258			if (status_bad_mdc) { /* XXX: Bad MDC */
259			const char *s =
260			_("WARNING: encrypted message has been manipulated!\n"
261	werner	36	"\n"
262			"Do NOT trust any text or data output from this file!\n"
263	twoaday	248	"It is likely that the data was corrupted in transport\n"
264	werner	36	"but it might be also possible that this is part of an attack.");
265			msg_box (hwnd, s, _("* IMPORTANT *"), MB_INFO);
266	twoaday	179	}
267	twoaday	236	#endif
268	werner	36
269			show_msg (GetDesktopWindow (), 1500, _("GnuPG Status: Finished"));
270
271			sigres = gpgme_op_verify_result (ctx);
272	twoaday	229	if (sigres && sigres->signatures) {
273			if (!use_viewer)
274			verify_show_signature_state (sigres->signatures);
275			else
276			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CLIPEDIT,
277			hwnd, clip_edit_dlg_proc,
278			(LPARAM)sigres->signatures);
279			}
280	twoaday	236	else if (use_viewer)
281			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CLIPEDIT,
282			hwnd, clip_edit_dlg_proc, 0);
283	twoaday	229
284	werner	36	leave:
285			release_gpg_passphrase_cb (&pwd);
286			gpgme_release (ctx);
287			return err;
288			}