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;
    char *uid;

    memset (&key, 0, sizeof (key));
    if (winpt_get_pubkey (keyid, &key))
        return m_strdup (_("user ID not found"));
    fmt = "\n    \"%s\"";
    uid = new char[strlen (key.ext->uids->uid) + strlen (fmt)+ 2];
    if (!uid)
        BUG (NULL);
    sprintf (uid, fmt, key.ext->uids->uid);
    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, *made, *ver, *ot;
    char *p;

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

    ot = verify_get_key_ownertrust (pk.ctx->owner_trust, NULL);
    made = 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);
}


/* 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;
    const char *s;    
    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 %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) { /* XXX: Bad MDC */
        s = _("WARNING: encrypted message has been manipulated!\n"
            "\n"
            "Do *NOT* trust any text or data output from this file!\n"
            "It is likely, the data was corrupted during the transport\n"
            "but it might be also possible that this is part of an attack.");
        msg_box (hwnd, s, _("*** IMPORTANT ***"), MB_INFO);
    }

    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);
    }

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	220	const char *fmt;
55	twoaday	208	char *uid;
56	werner	36
57	twoaday	208	memset (&key, 0, sizeof (key));
58			if (winpt_get_pubkey (keyid, &key))
59	werner	36	return m_strdup (_("user ID not found"));
60	twoaday	220	fmt = "\n \"%s\"";
61			uid = new char[strlen (key.ext->uids->uid) + strlen (fmt)+ 2];
62	twoaday	129	if (!uid)
63	werner	36	BUG (NULL);
64	twoaday	220	sprintf (uid, fmt, key.ext->uids->uid);
65	twoaday	217	winpt_release_pubkey (&key);
66	twoaday	208	return uid;
67	werner	36	}
68
69
70			/* Decrypt the clipboard contents and on success
71			replace the data with the plaintext.
72			Return value: 0 on success. */
73			gpgme_error_t
74			gpgme_op_clip_decrypt (gpgme_ctx_t ctx)
75			{
76			gpgme_error_t err;
77			gpgme_data_t ciph = NULL;
78			gpgme_data_t plain = NULL;
79
80			err = gpg_data_new_from_clipboard (&ciph, 0);
81			if (err)
82			return err;
83
84			err = gpgme_data_new (&plain);
85			if (err) {
86			gpgme_data_release (ciph);
87			return err;
88			}
89
90	twoaday	41	err = gpgme_op_decrypt_verify (ctx, ciph, plain);
91	werner	36
92			gpg_data_release_and_set_clipboard (plain, 0);
93			gpgme_data_release (ciph);
94			return err;
95			}
96
97
98	twoaday	229	/* Return humand readable ownertrust description for verification info. */
99			const char*
100			verify_get_key_ownertrust (gpgme_validity_t key_ot, int *novalid)
101			{
102			const char *s;
103
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) *novalid = 1;
111			s = _("Signature status: created with an UNTRUSTED key");
112			}
113			else
114			s = _("Signature status: created with an undefined trusted key");
115			return s;
116			}
117
118
119			/* Return a signature specific header and footer for the clipboard. */
120			void
121			verify_get_clip_info (gpgme_signature_t sig, char r_header, char r_footer)
122			{
123			struct winpt_key_s pk;
124	twoaday	231	const char head = _(" PGP SIGNATURE VERIFICATION *\r\n"
125			"*** Signature made: %s\r\n"
126			"*** Signature verfied: %s\r\n"
127			"*** %s\r\n"
128			"*** Signature result: %s\r\n"
129			"*** Signer: %s (0x%s)\r\n"
130			"* BEGIN PGP DECRYPTED TEXT *\r\n");
131			const char foot = _("\r\n END PGP DECRYPTED TEXT *");
132			const char s, made, ver, ot;
133	twoaday	229	char *p;
134
135			if (winpt_get_pubkey (sig->fpr, &pk))
136			BUG (0);
137	twoaday	231
138	twoaday	229	ot = verify_get_key_ownertrust (pk.ctx->owner_trust, NULL);
139			made = strtimestamp (sig->timestamp);
140	twoaday	231	ver = strtimestamp (time (NULL));
141	twoaday	229	s = get_gpg_sigstat (sig->summary);
142			p = new char[strlen (head) + strlen (s) + strlen (made) +
143	twoaday	231	strlen (sig->fpr) + strlen (ot) + strlen (ver) +
144	twoaday	229	strlen (pk.ext->uids->uid) + 1];
145			if (!p)
146			BUG (0);
147	twoaday	231	sprintf (p, head, made, ver, ot, s,
148			pk.ext->uids->uid, get_keyid_from_fpr (sig->fpr));
149	twoaday	229	*r_header = p;
150			*r_footer = m_strdup (foot);
151			}
152
153
154	twoaday	220	/* Show a human readable description of the given signature @sig. */
155			void
156			verify_show_signature_state (gpgme_signature_t sig)
157			{
158			winpt_key_s key;
159			const char keyid, uid;
160			const char *s;
161			char *pka_info = NULL;
162			int novalid = 0;
163
164	twoaday	231	assert (sig->fpr != NULL);
165	twoaday	220
166			keyid = get_keyid_from_fpr (sig->fpr);
167			memset (&key, 0, sizeof (key));
168			if (!winpt_get_pubkey (keyid, &key)) {
169	twoaday	229	s = verify_get_key_ownertrust (key.ctx->owner_trust, &novalid);
170	twoaday	220	uid = key.ext->uids->uid;
171	twoaday	231	}
172	twoaday	220	else {
173			s = "";
174			uid = _("user ID not found");
175			}
176
177	twoaday	229	pka_info = get_pka_status (sig);
178	twoaday	220	log_box (_("Decrypt Verify"), novalid? MB_WARN : MB_OK,
179			_("%s\n"
180			"%s\n"
181			"Signature made: %s\n"
182			"From \"%s\" using key ID 0x%s"
183			"%s %s\n%s"),
184			s, get_gpg_sigstat (sig->summary),
185			strtimestamp (sig->timestamp),
186			uid, keyid,
187			novalid? "\nPrimary key fingerprint: " : "",
188			novalid? get_key_fpr (key.ctx) : "",
189			pka_info? pka_info : ""
190			);
191			free_if_alloc (pka_info);
192			winpt_release_pubkey (&key);
193			}
194
195
196	werner	36	/* Convenient function to provide clipboard decryption.
197			@hwnd is the parent window used for showing messsages.
198			Return value: 0 on success. */
199			gpgme_error_t
200	twoaday	229	clip_decrypt_dlg (HWND hwnd, int use_viewer)
201	werner	36	{
202			gpgme_error_t err;
203			gpgme_ctx_t ctx = NULL;
204			gpgme_decrypt_result_t res;
205			gpgme_verify_result_t sigres;
206			passphrase_cb_s pwd;
207	twoaday	220	const char *s;
208	twoaday	179	int pgp_type = 0;
209	werner	36
210			/* allow to verify data generated by 'gpg -a --sign foo' */
211	twoaday	214	if (fm_assume_onepass_sig (NULL) == 1) {
212			dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_VERIFY, hwnd,
213			clip_verify_dlg_proc, 0,
214			_("Verify"), IDS_WINPT_VERIFY);
215			return 0;
216	werner	36	}
217
218			err = gpgme_new (&ctx);
219			if (err)
220			BUG (NULL);
221			set_gpg_passphrase_cb (&pwd, ctx, GPG_CMD_DECRYPT, hwnd, _("Decryption"));
222	twoaday	179	gpg_get_recipients (NULL, &pwd.recipients);
223
224	werner	36	err = gpgme_op_clip_decrypt (ctx);
225			if (pwd.cancel)
226			goto leave;
227			if (gpgme_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
228			agent_del_cache (pwd.keyid);
229
230			res = gpgme_op_decrypt_result (ctx);
231	twoaday	217	if (err && res->recipients && !is_seckey_available (res->recipients)) {
232	werner	36	gpgme_recipient_t r = res->recipients;
233	twoaday	208	char *u = get_key_userid (r->keyid+8);
234	werner	36	log_box (_("Decryption"), MB_ERR,
235			_("Encrypted with %s key, ID %s.%s\n"
236			"Decryption failed: secret key not available."),
237	twoaday	208	get_key_pubalgo (r->pubkey_algo), r->keyid+8, u);
238			free_if_alloc (u);
239	werner	36	goto leave;
240			}
241	twoaday	41	else if (res->unsupported_algorithm) {
242			log_box (_("Decryption"), MB_ERR, _("Unsupported algorithm: %s"),
243			res->unsupported_algorithm);
244			}
245	werner	36	else if (err) {
246			gpg_clip_get_pgptype (&pgp_type);
247	twoaday	129	if (gpgme_err_code (err) == GPG_ERR_NO_DATA && (pgp_type & PGP_MESSAGE))
248	werner	36	msg_box (hwnd, _("Broken OpenPGP message (maybe: quoted printable "
249	twoaday	129	"character in armor)."), _("Decryption"), MB_INFO);
250	werner	36	else
251			msg_box (hwnd, gpgme_strerror (err), _("Decryption"), MB_ERR);
252			goto leave;
253			}
254
255	twoaday	179	if (0) { /* XXX: Bad MDC */
256	werner	36	s = _("WARNING: encrypted message has been manipulated!\n"
257			"\n"
258			"Do NOT trust any text or data output from this file!\n"
259			"It is likely, the data was corrupted during the transport\n"
260			"but it might be also possible that this is part of an attack.");
261			msg_box (hwnd, s, _("* IMPORTANT *"), MB_INFO);
262	twoaday	179	}
263	werner	36
264			show_msg (GetDesktopWindow (), 1500, _("GnuPG Status: Finished"));
265
266			sigres = gpgme_op_verify_result (ctx);
267	twoaday	229	if (sigres && sigres->signatures) {
268			if (!use_viewer)
269			verify_show_signature_state (sigres->signatures);
270			else
271			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CLIPEDIT,
272			hwnd, clip_edit_dlg_proc,
273			(LPARAM)sigres->signatures);
274			}
275
276	werner	36	leave:
277			release_gpg_passphrase_cb (&pwd);
278			gpgme_release (ctx);
279			return err;
280			}