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	twoaday	220	/* wptClipDecryptDlg.cpp - Clipboard decryption
2	twoaday	286	* Copyright (C) 2000-2007 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	werner	42	#ifdef HAVE_CONFIG_H
18			#include <config.h>
19			#endif
20
21	werner	36	#include <windows.h>
22	twoaday	231	#include <assert.h>
23			#include <time.h>
24	werner	36
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	twoaday	129	#include "wptUTF8.h"
37	werner	47	#include "resource.h"
38	twoaday	278	#include "StringBuffer.h"
39	werner	36
40	twoaday	217	bool is_seckey_available (gpgme_recipient_t rset);
41	twoaday	220	char* get_pka_status (gpgme_signature_t sig);
42	werner	36
43	twoaday	220
44	werner	36	/* 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	twoaday	208	winpt_key_s key;
50	twoaday	278	StringBuffer p;
51			const char *userid;
52	twoaday	208	char *uid;
53	werner	36
54	twoaday	278	p = "\n ";
55	twoaday	208	memset (&key, 0, sizeof (key));
56			if (winpt_get_pubkey (keyid, &key))
57	twoaday	256	userid = (_("user ID not found"));
58			else
59			userid = key.ext->uids->uid;
60	twoaday	278	p = p + "\"" + userid + "\"";
61
62	twoaday	217	winpt_release_pubkey (&key);
63	twoaday	278	uid = p.getBufferCopy ();
64	twoaday	208	return uid;
65	werner	36	}
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	twoaday	41	err = gpgme_op_decrypt_verify (ctx, ciph, plain);
89	werner	36
90			gpg_data_release_and_set_clipboard (plain, 0);
91			gpgme_data_release (ciph);
92			return err;
93			}
94
95
96	twoaday	229	/* 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	twoaday	273	if (novalid)
103			novalid = 0; / reset */
104	twoaday	229	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	twoaday	273	if (novalid)
111			*novalid = 1;
112	twoaday	229	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	twoaday	231	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	twoaday	286	const char stat, ot, uid, keyid;
134	twoaday	278	char made[128], ver[128];
135			char *p;
136	twoaday	229
137	twoaday	273	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	twoaday	278	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	twoaday	231	strlen (sig->fpr) + strlen (ot) + strlen (ver) +
153	twoaday	273	strlen (uid) + 1];
154	twoaday	229	if (!p)
155			BUG (0);
156	twoaday	286	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	twoaday	229	*r_header = p;
166			*r_footer = m_strdup (foot);
167			}
168
169
170	twoaday	220	/* 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	twoaday	278	char *pka_info = NULL, timebuf[128];
178	twoaday	220	int novalid = 0;
179
180	twoaday	231	assert (sig->fpr != NULL);
181	twoaday	220
182			memset (&key, 0, sizeof (key));
183	twoaday	286	if (!winpt_get_pubkey (sig->fpr, &key)) {
184	twoaday	229	s = verify_get_key_ownertrust (key.ctx->owner_trust, &novalid);
185	twoaday	220	uid = key.ext->uids->uid;
186	twoaday	231	}
187	twoaday	220	else {
188			s = "";
189			uid = _("user ID not found");
190			}
191
192	twoaday	278	if (!get_locale_timedate (sig->timestamp, timebuf, DIM (timebuf)-1))
193			_snprintf (timebuf, DIM (timebuf)-1, "'unknown time'");
194
195	twoaday	286	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	twoaday	229	pka_info = get_pka_status (sig);
205	twoaday	220	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	twoaday	278	timebuf, uid, keyid,
213	twoaday	220	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	werner	36	/* 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	twoaday	229	clip_decrypt_dlg (HWND hwnd, int use_viewer)
227	werner	36	{
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	twoaday	179	int pgp_type = 0;
234	werner	36
235			/* allow to verify data generated by 'gpg -a --sign foo' */
236	twoaday	214	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	werner	36	}
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	twoaday	179	gpg_get_recipients (NULL, &pwd.recipients);
248
249	werner	36	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	twoaday	217	if (err && res->recipients && !is_seckey_available (res->recipients)) {
257	werner	36	gpgme_recipient_t r = res->recipients;
258	twoaday	208	char *u = get_key_userid (r->keyid+8);
259	werner	36	log_box (_("Decryption"), MB_ERR,
260	twoaday	256	_("Encrypted with %s key, ID 0x%s.%s\n"
261	werner	36	"Decryption failed: secret key not available."),
262	twoaday	208	get_key_pubalgo (r->pubkey_algo), r->keyid+8, u);
263			free_if_alloc (u);
264	werner	36	goto leave;
265			}
266	twoaday	41	else if (res->unsupported_algorithm) {
267			log_box (_("Decryption"), MB_ERR, _("Unsupported algorithm: %s"),
268			res->unsupported_algorithm);
269			}
270	werner	36	else if (err) {
271			gpg_clip_get_pgptype (&pgp_type);
272	twoaday	129	if (gpgme_err_code (err) == GPG_ERR_NO_DATA && (pgp_type & PGP_MESSAGE))
273	werner	36	msg_box (hwnd, _("Broken OpenPGP message (maybe: quoted printable "
274	twoaday	129	"character in armor)."), _("Decryption"), MB_INFO);
275	werner	36	else
276			msg_box (hwnd, gpgme_strerror (err), _("Decryption"), MB_ERR);
277			goto leave;
278			}
279
280	twoaday	236	#if 0
281			if (status_bad_mdc) { /* XXX: Bad MDC */
282			const char *s =
283			_("WARNING: encrypted message has been manipulated!\n"
284	werner	36	"\n"
285			"Do NOT trust any text or data output from this file!\n"
286	twoaday	248	"It is likely that the data was corrupted in transport\n"
287	werner	36	"but it might be also possible that this is part of an attack.");
288			msg_box (hwnd, s, _("* IMPORTANT *"), MB_INFO);
289	twoaday	179	}
290	twoaday	236	#endif
291	werner	36
292			show_msg (GetDesktopWindow (), 1500, _("GnuPG Status: Finished"));
293
294			sigres = gpgme_op_verify_result (ctx);
295	twoaday	229	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	twoaday	236	else if (use_viewer)
304			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CLIPEDIT,
305			hwnd, clip_edit_dlg_proc, 0);
306	twoaday	229
307	werner	36	leave:
308			release_gpg_passphrase_cb (&pwd);
309			gpgme_release (ctx);
310			return err;
311			}