trunk/Src/wptClipDecryptDlg.cpp

/* wptClipDecryptDlg.cpp - Clipboard decrypt dialog
 *      Copyright (C) 2000-2005 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 "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 secret_key_available (gpgme_recipient_t rset);

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

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


/* 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)
{
    gpgme_error_t err;
    gpgme_ctx_t ctx = NULL;
    gpgme_signature_t sig = NULL;
    gpgme_decrypt_result_t res;
    gpgme_verify_result_t sigres;
    passphrase_cb_s pwd;
    const char *s;
    const char *uid;
    int pgp_type = 0;
    int novalid = 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 && !secret_key_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) {
        winpt_key_s key;
        const char *keyid;

        sig = sigres->signatures;
        if (!sig->fpr)
            BUG (NULL);
        keyid = get_keyid_from_fpr (sig->fpr);
        memset (&key, 0, sizeof (key));
        if (!winpt_get_pubkey (keyid, &key)) {
            if (key.ctx->owner_trust == GPGME_VALIDITY_FULL || 
                key.ctx->owner_trust == GPGME_VALIDITY_ULTIMATE)
                s = _("Signature Status: Created with a fully trusted key");
            else if (key.ctx->owner_trust == GPGME_VALIDITY_MARGINAL)
                s = _("Signature Status: Created with a marginal trusted key");
            else if (key.ctx->owner_trust == GPGME_VALIDITY_NEVER) {
                novalid = 1;
                s =  _("Signature Status: Created with an UNTRUSTED key");
            }
            else
                s = _("Signature Status: Created with an undefined trusted key");
            uid = key.ext->uids->uid;
        }
        else {
            s = "";
            uid = _("user ID not found");
        }
        log_box (_("WinPT Verify"), MB_OK, 
                 _("%s\n"
                   "%s\n"
                   "Signature made: %s\n"
                   "From \"%s\" using key ID 0x%s"
                   "%s %s"),
                   s, get_gpg_sigstat (sig->summary), 
                   strtimestamp (sig->timestamp),
                   uid, keyid, 
                   novalid? "\nPrimary key fingerprint: " : "",
                   novalid? get_key_fpr (key.ctx) : "");
    }
    
leave:
    release_gpg_passphrase_cb (&pwd);
    gpgme_release (ctx);
    return err;
}
1	/* wptClipDecryptDlg.cpp - Clipboard decrypt dialog
2	* Copyright (C) 2000-2005 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	* 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	#ifdef HAVE_CONFIG_H
23	#include <config.h>
24	#endif
25
26	#include <windows.h>
27
28	#include "wptTypes.h"
29	#include "wptW32API.h"
30	#include "wptAgent.h"
31	#include "wptNLS.h"
32	#include "wptGPG.h"
33	#include "wptVersion.h"
34	#include "wptErrors.h"
35	#include "wptCommonCtl.h"
36	#include "wptContext.h"
37	#include "wptDlgs.h"
38	#include "wptKeylist.h"
39	#include "wptUTF8.h"
40	#include "resource.h"
41
42	bool secret_key_available (gpgme_recipient_t rset);
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	char *uid;
51
52	memset (&key, 0, sizeof (key));
53	if (winpt_get_pubkey (keyid, &key))
54	return m_strdup (_("user ID not found"));
55	uid = new char[strlen (key.ext->uids->uid) + 4 + 8];
56	if (!uid)
57	BUG (NULL);
58	sprintf (uid, "\n \"%s\"", key.ext->uids->uid);
59	return uid;
60	}
61
62
63	/* Decrypt the clipboard contents and on success
64	replace the data with the plaintext.
65	Return value: 0 on success. */
66	gpgme_error_t
67	gpgme_op_clip_decrypt (gpgme_ctx_t ctx)
68	{
69	gpgme_error_t err;
70	gpgme_data_t ciph = NULL;
71	gpgme_data_t plain = NULL;
72
73	err = gpg_data_new_from_clipboard (&ciph, 0);
74	if (err)
75	return err;
76
77	err = gpgme_data_new (&plain);
78	if (err) {
79	gpgme_data_release (ciph);
80	return err;
81	}
82
83	err = gpgme_op_decrypt_verify (ctx, ciph, plain);
84
85	gpg_data_release_and_set_clipboard (plain, 0);
86	gpgme_data_release (ciph);
87	return err;
88	}
89
90
91	/* Convenient function to provide clipboard decryption.
92	@hwnd is the parent window used for showing messsages.
93	Return value: 0 on success. */
94	gpgme_error_t
95	clip_decrypt_dlg (HWND hwnd)
96	{
97	gpgme_error_t err;
98	gpgme_ctx_t ctx = NULL;
99	gpgme_signature_t sig = NULL;
100	gpgme_decrypt_result_t res;
101	gpgme_verify_result_t sigres;
102	passphrase_cb_s pwd;
103	const char *s;
104	const char *uid;
105	int pgp_type = 0;
106	int novalid = 0;
107
108	/* allow to verify data generated by 'gpg -a --sign foo' */
109	if (fm_assume_onepass_sig (NULL) == 1) {
110	dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_VERIFY, hwnd,
111	clip_verify_dlg_proc, 0,
112	_("Verify"), IDS_WINPT_VERIFY);
113	return 0;
114	}
115
116	err = gpgme_new (&ctx);
117	if (err)
118	BUG (NULL);
119	set_gpg_passphrase_cb (&pwd, ctx, GPG_CMD_DECRYPT, hwnd, _("Decryption"));
120	gpg_get_recipients (NULL, &pwd.recipients);
121
122	err = gpgme_op_clip_decrypt (ctx);
123	if (pwd.cancel)
124	goto leave;
125	if (gpgme_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
126	agent_del_cache (pwd.keyid);
127
128	res = gpgme_op_decrypt_result (ctx);
129	if (err && res->recipients && !secret_key_available (res->recipients)) {
130	gpgme_recipient_t r = res->recipients;
131	char *u = get_key_userid (r->keyid+8);
132	log_box (_("Decryption"), MB_ERR,
133	_("Encrypted with %s key, ID %s.%s\n"
134	"Decryption failed: secret key not available."),
135	get_key_pubalgo (r->pubkey_algo), r->keyid+8, u);
136	free_if_alloc (u);
137	goto leave;
138	}
139	else if (res->unsupported_algorithm) {
140	log_box (_("Decryption"), MB_ERR, _("Unsupported algorithm: %s"),
141	res->unsupported_algorithm);
142	}
143	else if (err) {
144	gpg_clip_get_pgptype (&pgp_type);
145	if (gpgme_err_code (err) == GPG_ERR_NO_DATA && (pgp_type & PGP_MESSAGE))
146	msg_box (hwnd, _("Broken OpenPGP message (maybe: quoted printable "
147	"character in armor)."), _("Decryption"), MB_INFO);
148	else
149	msg_box (hwnd, gpgme_strerror (err), _("Decryption"), MB_ERR);
150	goto leave;
151	}
152
153	if (0) { /* XXX: Bad MDC */
154	s = _("WARNING: encrypted message has been manipulated!\n"
155	"\n"
156	"Do NOT trust any text or data output from this file!\n"
157	"It is likely, the data was corrupted during the transport\n"
158	"but it might be also possible that this is part of an attack.");
159	msg_box (hwnd, s, _("* IMPORTANT *"), MB_INFO);
160	}
161
162	show_msg (GetDesktopWindow (), 1500, _("GnuPG Status: Finished"));
163
164	sigres = gpgme_op_verify_result (ctx);
165	if (sigres && sigres->signatures) {
166	winpt_key_s key;
167	const char *keyid;
168
169	sig = sigres->signatures;
170	if (!sig->fpr)
171	BUG (NULL);
172	keyid = get_keyid_from_fpr (sig->fpr);
173	memset (&key, 0, sizeof (key));
174	if (!winpt_get_pubkey (keyid, &key)) {
175	if (key.ctx->owner_trust == GPGME_VALIDITY_FULL \|\|
176	key.ctx->owner_trust == GPGME_VALIDITY_ULTIMATE)
177	s = _("Signature Status: Created with a fully trusted key");
178	else if (key.ctx->owner_trust == GPGME_VALIDITY_MARGINAL)
179	s = _("Signature Status: Created with a marginal trusted key");
180	else if (key.ctx->owner_trust == GPGME_VALIDITY_NEVER) {
181	novalid = 1;
182	s = _("Signature Status: Created with an UNTRUSTED key");
183	}
184	else
185	s = _("Signature Status: Created with an undefined trusted key");
186	uid = key.ext->uids->uid;
187	}
188	else {
189	s = "";
190	uid = _("user ID not found");
191	}
192	log_box (_("WinPT Verify"), MB_OK,
193	_("%s\n"
194	"%s\n"
195	"Signature made: %s\n"
196	"From \"%s\" using key ID 0x%s"
197	"%s %s"),
198	s, get_gpg_sigstat (sig->summary),
199	strtimestamp (sig->timestamp),
200	uid, keyid,
201	novalid? "\nPrimary key fingerprint: " : "",
202	novalid? get_key_fpr (key.ctx) : "");
203	}
204
205	leave:
206	release_gpg_passphrase_cb (&pwd);
207	gpgme_release (ctx);
208	return err;
209	}