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 <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 "wptFileManager.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)
{
    gpgme_key_t key;
    const char *s;
    char *p;

    if (get_pubkey (keyid, &key))
        return m_strdup (_("user ID not found"));
    s = key->uids->uid;
    if (!s)
        s = _("user ID not found");
    p = new char[strlen (s) + 4 + 8];
    if (!p)
        BUG (NULL);
    sprintf (p, "\n    \"%s\"", s);
    return p;
}


/* 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 (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 *created, *s;
    char keyid[16+1] = {0};
    int novalid = 0;

    /* allow to verify data generated by 'gpg -a --sign foo' */
    if (fm_assume_onepass_sig (NULL) == 0) {
        /* XXX: addtitional steps needed? */
    }

    err = gpgme_new (&ctx);
    if (err)
        BUG (NULL);
    set_gpg_passphrase_cb (&pwd, ctx, GPG_CMD_DECRYPT, hwnd, _("Decryption"));
    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 *p = 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, p);
        free_if_alloc (p);
        goto leave;
    }
    else if (err) {
        int pgp_type;
        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;
    }

    /* Too paranoid??
    if (flags & GPGME_OPFLAG_BADMDC) {
        const char *s;
        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) {
        gpgme_key_t key;
        const char * val;
        char keyid[16+1];

        sig = sigres->signatures;
        if (!sig->fpr)
            val = "????????????????";
        else
            val = strlen (sig->fpr) == 40? sig->fpr+32 : sig->fpr + 24;
        _snprintf (keyid, sizeof (keyid)-1, "%s", val+8);

        get_pubkey (keyid, &key);
        if (key->owner_trust == GPGME_VALIDITY_FULL || 
            key->owner_trust == GPGME_VALIDITY_ULTIMATE)
            s = _("Signature Status: Created with a fully trusted key");
        else if (key->owner_trust == GPGME_VALIDITY_MARGINAL)
            s = _("Signature Status: Created with a marginal trusted key");
        else if (key->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");
        created = strtimestamp (sig->timestamp);

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