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.
 */
#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;    
    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);
    sprintf (p, head, made, ver, ot, stat, uid, get_keyid_from_fpr (sig->fpr));
    *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);
        
    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");
    }

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

    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-2006 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;
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	sprintf (p, head, made, ver, ot, stat, uid, get_keyid_from_fpr (sig->fpr));
157	*r_header = p;
158	*r_footer = m_strdup (foot);
159	}
160
161
162	/* Show a human readable description of the given signature @sig. */
163	void
164	verify_show_signature_state (gpgme_signature_t sig)
165	{
166	winpt_key_s key;
167	const char keyid, uid;
168	const char *s;
169	char *pka_info = NULL, timebuf[128];
170	int novalid = 0;
171
172	assert (sig->fpr != NULL);
173
174	keyid = get_keyid_from_fpr (sig->fpr);
175	memset (&key, 0, sizeof (key));
176	if (!winpt_get_pubkey (keyid, &key)) {
177	s = verify_get_key_ownertrust (key.ctx->owner_trust, &novalid);
178	uid = key.ext->uids->uid;
179	}
180	else {
181	s = "";
182	uid = _("user ID not found");
183	}
184
185	if (!get_locale_timedate (sig->timestamp, timebuf, DIM (timebuf)-1))
186	_snprintf (timebuf, DIM (timebuf)-1, "'unknown time'");
187
188	pka_info = get_pka_status (sig);
189	log_box (_("Decrypt Verify"), novalid? MB_WARN : MB_OK,
190	_("%s\n"
191	"%s\n"
192	"Signature made: %s\n"
193	"From \"%s\" using key ID 0x%s"
194	"%s %s\n%s"),
195	s, get_gpg_sigstat (sig->summary),
196	timebuf, uid, keyid,
197	novalid? "\nPrimary key fingerprint: " : "",
198	novalid? get_key_fpr (key.ctx) : "",
199	pka_info? pka_info : ""
200	);
201	free_if_alloc (pka_info);
202	winpt_release_pubkey (&key);
203	}
204
205
206	/* Convenient function to provide clipboard decryption.
207	@hwnd is the parent window used for showing messsages.
208	Return value: 0 on success. */
209	gpgme_error_t
210	clip_decrypt_dlg (HWND hwnd, int use_viewer)
211	{
212	gpgme_error_t err;
213	gpgme_ctx_t ctx = NULL;
214	gpgme_decrypt_result_t res;
215	gpgme_verify_result_t sigres;
216	passphrase_cb_s pwd;
217	int pgp_type = 0;
218
219	/* allow to verify data generated by 'gpg -a --sign foo' */
220	if (fm_assume_onepass_sig (NULL) == 1) {
221	dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_VERIFY, hwnd,
222	clip_verify_dlg_proc, 0,
223	_("Verify"), IDS_WINPT_VERIFY);
224	return 0;
225	}
226
227	err = gpgme_new (&ctx);
228	if (err)
229	BUG (NULL);
230	set_gpg_passphrase_cb (&pwd, ctx, GPG_CMD_DECRYPT, hwnd, _("Decryption"));
231	gpg_get_recipients (NULL, &pwd.recipients);
232
233	err = gpgme_op_clip_decrypt (ctx);
234	if (pwd.cancel)
235	goto leave;
236	if (gpgme_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
237	agent_del_cache (pwd.keyid);
238
239	res = gpgme_op_decrypt_result (ctx);
240	if (err && res->recipients && !is_seckey_available (res->recipients)) {
241	gpgme_recipient_t r = res->recipients;
242	char *u = get_key_userid (r->keyid+8);
243	log_box (_("Decryption"), MB_ERR,
244	_("Encrypted with %s key, ID 0x%s.%s\n"
245	"Decryption failed: secret key not available."),
246	get_key_pubalgo (r->pubkey_algo), r->keyid+8, u);
247	free_if_alloc (u);
248	goto leave;
249	}
250	else if (res->unsupported_algorithm) {
251	log_box (_("Decryption"), MB_ERR, _("Unsupported algorithm: %s"),
252	res->unsupported_algorithm);
253	}
254	else if (err) {
255	gpg_clip_get_pgptype (&pgp_type);
256	if (gpgme_err_code (err) == GPG_ERR_NO_DATA && (pgp_type & PGP_MESSAGE))
257	msg_box (hwnd, _("Broken OpenPGP message (maybe: quoted printable "
258	"character in armor)."), _("Decryption"), MB_INFO);
259	else
260	msg_box (hwnd, gpgme_strerror (err), _("Decryption"), MB_ERR);
261	goto leave;
262	}
263
264	#if 0
265	if (status_bad_mdc) { /* XXX: Bad MDC */
266	const char *s =
267	_("WARNING: encrypted message has been manipulated!\n"
268	"\n"
269	"Do NOT trust any text or data output from this file!\n"
270	"It is likely that the data was corrupted in transport\n"
271	"but it might be also possible that this is part of an attack.");
272	msg_box (hwnd, s, _("* IMPORTANT *"), MB_INFO);
273	}
274	#endif
275
276	show_msg (GetDesktopWindow (), 1500, _("GnuPG Status: Finished"));
277
278	sigres = gpgme_op_verify_result (ctx);
279	if (sigres && sigres->signatures) {
280	if (!use_viewer)
281	verify_show_signature_state (sigres->signatures);
282	else
283	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CLIPEDIT,
284	hwnd, clip_edit_dlg_proc,
285	(LPARAM)sigres->signatures);
286	}
287	else if (use_viewer)
288	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CLIPEDIT,
289	hwnd, clip_edit_dlg_proc, 0);
290
291	leave:
292	release_gpg_passphrase_cb (&pwd);
293	gpgme_release (ctx);
294	return err;
295	}