trunk/Src/wptClipDecryptDlg.cpp

/* wptClipDecryptDlg.cpp - Clipboard decryption
 *      Copyright (C) 2000-2007 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.
 */
#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"
#include "StringBuffer.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;
    StringBuffer p;
    const char *userid;
    char *uid;

    p = "\n    ";   
    memset (&key, 0, sizeof (key));
    if (winpt_get_pubkey (keyid, &key))
        userid = (_("user ID not found"));
    else
        userid = key.ext->uids->uid;
    p = p + "\"" + userid + "\"";

    winpt_release_pubkey (&key);
    uid = p.getBufferCopy ();
    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 (novalid)
        *novalid = 0; /* reset */
    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 *stat, *ot, *uid, *keyid;
    char made[128], ver[128];
    char *p;

    if (winpt_get_pubkey (sig->fpr, &pk)) {
        uid = _("user ID not found");
        ot = verify_get_key_ownertrust (GPGME_VALIDITY_UNDEFINED, NULL);
    }
    else {
        uid = pk.ext->uids->uid;
        ot = verify_get_key_ownertrust (pk.ctx->owner_trust, NULL);
    }
    
    if (!get_locale_timedate (sig->timestamp, made, DIM (made)-1))
        _snprintf (made, DIM (made)-1, "'unknown time'");
    if (!get_locale_timedate (time (NULL), ver, DIM (ver)-1))
        _snprintf (ver, DIM (ver)-1, "'unknown time'");
    stat = get_gpg_sigstat (sig->summary);
    p = new char[strlen (head) + strlen (stat) + strlen (made) + 
                 strlen (sig->fpr) + strlen (ot) + strlen (ver) +
                 strlen (uid) + 1];
    if (!p)
        BUG (0);
    if (strlen (sig->fpr) == 32) { /* RSA:MD5 */
        if (pk.ext != NULL)
            keyid = pk.ext->key->subkeys->keyid+8;
        else
            keyid = sig->fpr; /* show the fingerprint in case of problems. */
    }
    else
        keyid = get_keyid_from_fpr (sig->fpr);
    sprintf (p, head, made, ver, ot, stat, uid, keyid);
    *r_header = p;
    *r_footer = m_strdup (foot);
}


/* 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, timebuf[128];
    int novalid = 0;

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

    if (!get_locale_timedate (sig->timestamp, timebuf, DIM (timebuf)-1))
        _snprintf (timebuf, DIM (timebuf)-1, "'unknown time'");

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