trunk/Src/wptKeyPropsDlg.cpp

/* wptKeyPropsDlg.cpp - WinPT key properties dialog
 *      Copyright (C) 2000, 2001, 2002, 2003, 2005, 2006 Timo Schulz
 *
 * 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 "resource.h"
#include "wptErrors.h"
#include "wptGPG.h"
#include "wptCommonCtl.h"
#include "wptContext.h" /* for passphrase_s */
#include "wptNLS.h"
#include "wptDlgs.h" 
#include "wptTypes.h"
#include "wptKeylist.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptKeyEdit.h"


/* Check that the key is not expired or revoked. */
static int
do_check_key (gpgme_key_t key)
{
    int okay = 0;
    okay = key->expired;
    if (!okay)
        okay = key->revoked;
    return okay;
}


/* Convert a trust integer into a string representation. */
static const char*
ownertrust_to_string (int val, bool is_keypair)
{
    const char *inf;
    int id = val;

    switch (id) {
    case 1: inf = _("Don't know");         break;
    case 2: inf = _("I do NOT trust");     break;
    case 3: inf = _("I trust marginally"); break;
    case 4: inf = _("I trust fully");      break;
    case 5:
    case 6: 
        if (is_keypair)
            inf = _("I trust ultimately (implicit)");
        else
            inf = _("I trust ultimately"); break;
    default:inf = _("Unknown");            break;
    }
    
    return inf;
}


/* Generate a unique temp name for the photo which
   depends on the dialog handle and return it. */
static const char*
get_photo_tmpname (HWND dlg)
{
    static char buf[MAX_PATH+128+1];
    char name[64];

    _snprintf (name, sizeof (name)-1, "winpt_photo_%08lX.tmp", (DWORD)dlg);
    get_temp_name (buf, DIM (buf)-1, name);
    return buf;
}


static void
draw_nophoto_img (HWND dlg)
{
    /*..
    n = DrawText (hdc, "No Photo-ID", -1, &r, DT_LEFT);
    ..*/
}


/* Load the photo from the key @key */
static int
keyprops_load_photo (HWND dlg, gpgme_key_t key, gpgme_validity_t *r_valid)
{
    winpt_key_s k;
    FILE *f;
    const BYTE *img;
    DWORD imglen = 0;
    int pos=0;

    if (winpt_get_pubkey (key->subkeys->keyid, &k))
        BUG (0);
    img = k.ext->attrib.d;
    imglen = k.ext->attrib.len;
    if (!k.ext->attrib.validity)
        get_uat_validity (key->subkeys->keyid, &k.ext->attrib.validity);
    *r_valid = k.ext->attrib.validity;

    if (!img || !imglen) {
        draw_nophoto_img (dlg);
        return -1;
    }

    f = fopen (get_photo_tmpname (dlg), "wb");
    if (f) {
        pos += 16;
        fwrite (img + pos, 1, imglen - pos, f);
        fclose (f);
    }
    return 0;
}


/* Display the photo in the image control in the dialog @dlg. */
static int
keyprops_show_photo (HWND dlg)
{
    RECT r;     
    POINT p;
    HWND h;

    h = GetDlgItem (dlg, IDC_KEYPROPS_IMG);
    GetWindowRect (h, &r);
    p.x = r.left + 5;
    p.y = r.top - 2;
    memset (&p, 0, sizeof (p));
    PTD_jpg_show (h, &p, get_photo_tmpname (dlg));
    
    return 0;
}


/* Return string representation of the key validity. @key. */
static const char*
get_validity (gpgme_key_t key)
{
    if (key->expired)
        return _("Expired");    
    if (key->revoked)
        return _("Revoked");
    if (key->disabled)
        return _("Disabled");
    return get_key_trust2 (NULL, key->uids->validity, 0, 0);
}


/* Return the preferred sym. algorithm from @key as a string. */
static const char*
get_pref_cipher (winpt_key_t k)
{
    if (k->is_v3)
        return "IDEA";
    if (!k->ext || !k->ext->sym_prefs)
        return "3DES";
    switch (*k->ext->sym_prefs) {
    case 1: return "IDEA";
    case 2: return "3DES";
    case 3: return "CAST5";
    case 4: return "Blowfish";
    case 7: return "AES128";
    case 8: return "AES192";
    case 9: return "AES256";
    case 10:return "Twofish";
    }
    return "Unknown";
}


/* Return true if the key has designated revokers. */
static bool
check_for_desig_rev (gpgme_key_t key)
{
    winpt_key_s k;
    memset (&k, 0, sizeof (k));
    if (!winpt_get_pubkey (key->subkeys->keyid, &k))
        return k.ext->gloflags.has_desig_rev? true : false;
    return false;
}


/* Print information (name) of the smart card. */
static const char*
get_card_type (winpt_key_t k)
{    
    static char buf[64];

    if (!k->ext || !k->ext->card_type)
        return "";
    _snprintf (buf, sizeof (buf)-1, _("Card-Type: %s\r\n"), k->ext->card_type);
    return buf;
}


/* Return 1 if at least one user-ID is valid. */
static int
key_is_valid (gpgme_key_t k)
{
    gpgme_user_id_t u;

    for (u=k->uids; u; u=u->next) {
        if (u->validity >= GPGME_VALIDITY_MARGINAL)
            return 1;
    }
    return 0;
}


/* Display the key information for key @k.
   Return value: gpgme key on success. */
static void
display_key_info (HWND dlg, winpt_key_t k)
{
    gpgme_key_t key;
    struct winpt_key_s sk;
    char info[512];
    const char *inf;
    DWORD created, expires;

    gpg_keycache_update_attr (k->ext, KC_ATTR_PREFSYM, 0);
    memset (&sk, 0, sizeof (sk));       
    if (k->key_pair && !winpt_get_seckey (k->keyid, &sk))
        k->is_protected = sk.is_protected;
    key = k->ext->key;
    created = key->subkeys->timestamp;
    expires = key->subkeys->expires;
    _snprintf (info, DIM (info)-1,
               _("Type: %s\r\n"
               "Key ID: 0x%s\r\n"
               "Algorithm: %s\r\n"
               "Size: %s bits\r\n"
               "Created: %s\r\n"
               "Expires: %s\r\n"
               "Validity: %s\r\n"
               "Cipher: %s\r\n"
               "%s\r\n"),
               get_key_type (key),
               k->keyid,
               get_key_algo (key, 0),
               get_key_size (key, 0),
               get_key_created (created),
               get_key_expire_date (expires),
               get_validity (key), 
               get_pref_cipher (k),
               get_card_type (&sk));

    SetDlgItemText (dlg, IDC_KEYPROPS_INFO, info);
    SetDlgItemText (dlg, IDC_KEYPROPS_FPR, get_key_fpr (key));  
    inf = ownertrust_to_string (key->owner_trust, k->key_pair);
    SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
}


/* Dialog box procedure to show the key properties. */
BOOL CALLBACK
keyprops_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static winpt_key_t k = NULL;
    gpgme_validity_t valid;
    const char *inf;
    int rc;
    
    /* XXX: static variable (k) prevent that the dialog can 
            be opened twice. */
    switch (msg) {
    case WM_INITDIALOG:
        if (!lparam)
            dlg_fatal_error (dlg, "Could not get dialog param!");
        k = (winpt_key_t)lparam;
        SetWindowText (dlg, _("Key Properties"));
        SetDlgItemText (dlg, IDC_KEYPROPS_OT_CHANGE, _("&Change"));
        SetDlgItemText (dlg, IDC_KEYPROPS_REVOKERS, _("&Revokers"));
        SetDlgItemText (dlg, IDC_KEYPROPS_CHANGE_PWD, _("Change &Password"));
        SetDlgItemText (dlg, IDC_KEYPROPS_OTINF, _("Ownertrust"));
        
        display_key_info (dlg, k);
        if (!keyprops_load_photo (dlg, k->ctx, &valid)) {
            k->has_photo = 1;   
            if (valid < GPGME_VALIDITY_MARGINAL)
                SetDlgItemText (dlg, IDC_KEYPROPS_IMGINF, _("Photo-ID not validated."));
        }
        if (k->key_pair)
            EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_CHANGE_PWD), TRUE);
        if (check_for_desig_rev (k->ctx))
            EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_REVOKERS), TRUE);
        if (k->ctx->revoked || k->ctx->expired)
            EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_OT_CHANGE), FALSE);
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);      
        return TRUE;

    case WM_DESTROY:
        remove (get_photo_tmpname (dlg));
        break;
      
    case WM_PAINT:
        if (k->has_photo)
            keyprops_show_photo (dlg);
        break;

    case WM_SYSCOMMAND:
        if (LOWORD (wparam) == SC_CLOSE)
            EndDialog (dlg, FALSE);
        return FALSE;
        
    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            EndDialog (dlg, TRUE);
            return TRUE;

        case IDCANCEL:
            EndDialog (dlg, FALSE);
            return TRUE;
            
        case IDC_KEYPROPS_OT_CHANGE:
            if (do_check_key (k->ctx)) {
                msg_box (dlg, _("The status of this key is 'revoked' or 'expired'.\n"
                                "You cannot change the ownertrust of such keys."),
                                _("WinPT Warning"), MB_ERR);
                return TRUE;
            }
            if (!k->key_pair && !key_is_valid (k->ctx)) {
                rc = msg_box (dlg, _("This is a non-valid key.\n"
                                     "Modifying the ownertrust has no effect on such keys.\n\n"
                                     "Do you really want to continue?"), 
                                     _("WinPT Warning"), MB_ICONWARNING|MB_YESNO);
                if (rc == IDNO)
                    return TRUE;
            }
            rc = dialog_box_param (glob_hinst, 
                                   (LPCSTR)IDD_WINPT_KEYEDIT_OWNERTRUST,
                                    dlg, keyedit_ownertrust_dlg_proc,
                                   (LPARAM)k, _("Change Ownertrust"),
                                    IDS_WINPT_KEYEDIT_OWNERTRUST);
            if (rc == FALSE) /* Cancel */
                return TRUE;

            inf = ownertrust_to_string (k->callback.new_val, k->key_pair);
            SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
            msg_box (dlg, _("Ownertrust successfully changed."), 
                     _("GnuPG Status"), MB_OK);
            k->update = 1;
            return TRUE;
            
        case IDC_KEYPROPS_CHANGE_PWD:
            keyedit_change_passwd (k, dlg);         
            return TRUE;

        case IDC_KEYPROPS_REVOKERS:
            k->update = dialog_box_param (
                glob_hinst, (LPCTSTR)IDD_WINPT_KEYREVOKERS, dlg,
                key_revokers_dlg_proc, (LPARAM)k, 
                _("Key Revokers"), IDS_WINPT_KEY_REVOKERS);
            break;
        }
    }
    
    return FALSE;
}
1	werner	36	/* wptKeyPropsDlg.cpp - WinPT key properties dialog
2	twoaday	150	* Copyright (C) 2000, 2001, 2002, 2003, 2005, 2006 Timo Schulz
3	werner	36	*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with WinPT; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20	werner	42	#ifdef HAVE_CONFIG_H
21			#include <config.h>
22			#endif
23
24	werner	36	#include <windows.h>
25
26	werner	47	#include "resource.h"
27	werner	36	#include "wptErrors.h"
28			#include "wptGPG.h"
29			#include "wptCommonCtl.h"
30			#include "wptContext.h" /* for passphrase_s */
31			#include "wptNLS.h"
32			#include "wptDlgs.h"
33			#include "wptTypes.h"
34			#include "wptKeylist.h"
35			#include "wptW32API.h"
36			#include "wptVersion.h"
37			#include "wptKeyEdit.h"
38
39
40			/* Check that the key is not expired or revoked. */
41			static int
42			do_check_key (gpgme_key_t key)
43			{
44			int okay = 0;
45			okay = key->expired;
46			if (!okay)
47			okay = key->revoked;
48			return okay;
49			}
50
51
52			/* Convert a trust integer into a string representation. */
53			static const char*
54	twoaday	150	ownertrust_to_string (int val, bool is_keypair)
55	werner	36	{
56	twoaday	41	const char *inf;
57	werner	36	int id = val;
58	twoaday	41
59	werner	36	switch (id) {
60			case 1: inf = _("Don't know"); break;
61			case 2: inf = _("I do NOT trust"); break;
62			case 3: inf = _("I trust marginally"); break;
63			case 4: inf = _("I trust fully"); break;
64			case 5:
65	twoaday	150	case 6:
66			if (is_keypair)
67			inf = _("I trust ultimately (implicit)");
68			else
69			inf = _("I trust ultimately"); break;
70	werner	36	default:inf = _("Unknown"); break;
71			}
72
73			return inf;
74			}
75
76
77			/* Generate a unique temp name for the photo which
78			depends on the dialog handle and return it. */
79			static const char*
80			get_photo_tmpname (HWND dlg)
81			{
82	twoaday	174	static char buf[MAX_PATH+128+1];
83			char name[64];
84	werner	36
85	twoaday	174	_snprintf (name, sizeof (name)-1, "winpt_photo_%08lX.tmp", (DWORD)dlg);
86	twoaday	211	get_temp_name (buf, DIM (buf)-1, name);
87	werner	36	return buf;
88			}
89
90
91	twoaday	129	static void
92			draw_nophoto_img (HWND dlg)
93			{
94			/*..
95			n = DrawText (hdc, "No Photo-ID", -1, &r, DT_LEFT);
96			..*/
97			}
98
99
100	werner	36	/* Load the photo from the key @key */
101			static int
102			keyprops_load_photo (HWND dlg, gpgme_key_t key, gpgme_validity_t *r_valid)
103			{
104			winpt_key_s k;
105			FILE *f;
106			const BYTE *img;
107			DWORD imglen = 0;
108			int pos=0;
109
110	twoaday	211	if (winpt_get_pubkey (key->subkeys->keyid, &k))
111			BUG (0);
112	werner	36	img = k.ext->attrib.d;
113			imglen = k.ext->attrib.len;
114			if (!k.ext->attrib.validity)
115			get_uat_validity (key->subkeys->keyid, &k.ext->attrib.validity);
116			*r_valid = k.ext->attrib.validity;
117
118	twoaday	129	if (!img \|\| !imglen) {
119			draw_nophoto_img (dlg);
120	werner	36	return -1;
121	twoaday	129	}
122	twoaday	133
123	werner	36	f = fopen (get_photo_tmpname (dlg), "wb");
124			if (f) {
125			pos += 16;
126			fwrite (img + pos, 1, imglen - pos, f);
127			fclose (f);
128			}
129			return 0;
130			}
131
132
133			/* Display the photo in the image control in the dialog @dlg. */
134			static int
135			keyprops_show_photo (HWND dlg)
136			{
137			RECT r;
138			POINT p;
139			HWND h;
140
141			h = GetDlgItem (dlg, IDC_KEYPROPS_IMG);
142			GetWindowRect (h, &r);
143			p.x = r.left + 5;
144			p.y = r.top - 2;
145			memset (&p, 0, sizeof (p));
146			PTD_jpg_show (h, &p, get_photo_tmpname (dlg));
147
148			return 0;
149			}
150
151
152			/* Return string representation of the key validity. @key. */
153			static const char*
154			get_validity (gpgme_key_t key)
155			{
156	twoaday	211	if (key->expired)
157	werner	36	return _("Expired");
158	twoaday	211	if (key->revoked)
159	werner	36	return _("Revoked");
160	twoaday	211	if (key->disabled)
161	twoaday	41	return _("Disabled");
162	werner	36	return get_key_trust2 (NULL, key->uids->validity, 0, 0);
163			}
164
165
166			/* Return the preferred sym. algorithm from @key as a string. */
167			static const char*
168			get_pref_cipher (winpt_key_t k)
169			{
170			if (k->is_v3)
171			return "IDEA";
172	twoaday	211	if (!k->ext \|\| !k->ext->sym_prefs)
173	werner	36	return "3DES";
174			switch (*k->ext->sym_prefs) {
175			case 1: return "IDEA";
176			case 2: return "3DES";
177			case 3: return "CAST5";
178			case 4: return "Blowfish";
179	twoaday	211	case 7: return "AES128";
180			case 8: return "AES192";
181			case 9: return "AES256";
182	werner	36	case 10:return "Twofish";
183			}
184			return "Unknown";
185			}
186
187
188			/* Return true if the key has designated revokers. */
189			static bool
190			check_for_desig_rev (gpgme_key_t key)
191			{
192			winpt_key_s k;
193			memset (&k, 0, sizeof (k));
194			if (!winpt_get_pubkey (key->subkeys->keyid, &k))
195			return k.ext->gloflags.has_desig_rev? true : false;
196			return false;
197			}
198
199
200			/* Print information (name) of the smart card. */
201			static const char*
202			get_card_type (winpt_key_t k)
203			{
204			static char buf[64];
205
206	twoaday	181	if (!k->ext \|\| !k->ext->card_type)
207	werner	36	return "";
208			_snprintf (buf, sizeof (buf)-1, _("Card-Type: %s\r\n"), k->ext->card_type);
209			return buf;
210			}
211
212
213	twoaday	211	/* Return 1 if at least one user-ID is valid. */
214			static int
215			key_is_valid (gpgme_key_t k)
216			{
217			gpgme_user_id_t u;
218
219			for (u=k->uids; u; u=u->next) {
220			if (u->validity >= GPGME_VALIDITY_MARGINAL)
221			return 1;
222			}
223			return 0;
224			}
225
226
227
228	werner	36	/* Display the key information for key @k.
229			Return value: gpgme key on success. */
230			static void
231	twoaday	211	display_key_info (HWND dlg, winpt_key_t k)
232	werner	36	{
233	twoaday	181	gpgme_key_t key;
234	twoaday	211	struct winpt_key_s sk;
235	werner	36	char info[512];
236			const char *inf;
237	twoaday	181	DWORD created, expires;
238	werner	36
239	twoaday	211	gpg_keycache_update_attr (k->ext, KC_ATTR_PREFSYM, 0);
240	twoaday	181	memset (&sk, 0, sizeof (sk));
241			if (k->key_pair && !winpt_get_seckey (k->keyid, &sk))
242			k->is_protected = sk.is_protected;
243	twoaday	211	key = k->ext->key;
244	twoaday	181	created = key->subkeys->timestamp;
245			expires = key->subkeys->expires;
246	werner	36	_snprintf (info, DIM (info)-1,
247			_("Type: %s\r\n"
248	twoaday	211	"Key ID: 0x%s\r\n"
249	werner	36	"Algorithm: %s\r\n"
250	twoaday	128	"Size: %s bits\r\n"
251	werner	36	"Created: %s\r\n"
252			"Expires: %s\r\n"
253			"Validity: %s\r\n"
254			"Cipher: %s\r\n"
255			"%s\r\n"),
256			get_key_type (key),
257			k->keyid,
258			get_key_algo (key, 0),
259			get_key_size (key, 0),
260			get_key_created (created),
261			get_key_expire_date (expires),
262			get_validity (key),
263	twoaday	211	get_pref_cipher (k),
264	twoaday	181	get_card_type (&sk));
265	werner	36
266			SetDlgItemText (dlg, IDC_KEYPROPS_INFO, info);
267			SetDlgItemText (dlg, IDC_KEYPROPS_FPR, get_key_fpr (key));
268	twoaday	150	inf = ownertrust_to_string (key->owner_trust, k->key_pair);
269	werner	36	SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
270			}
271
272
273			/* Dialog box procedure to show the key properties. */
274			BOOL CALLBACK
275			keyprops_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
276			{
277	twoaday	212	static winpt_key_t k = NULL;
278	werner	36	gpgme_validity_t valid;
279			const char *inf;
280			int rc;
281
282			/* XXX: static variable (k) prevent that the dialog can
283			be opened twice. */
284			switch (msg) {
285			case WM_INITDIALOG:
286			if (!lparam)
287			dlg_fatal_error (dlg, "Could not get dialog param!");
288			k = (winpt_key_t)lparam;
289			SetWindowText (dlg, _("Key Properties"));
290			SetDlgItemText (dlg, IDC_KEYPROPS_OT_CHANGE, _("&Change"));
291			SetDlgItemText (dlg, IDC_KEYPROPS_REVOKERS, _("&Revokers"));
292	twoaday	150	SetDlgItemText (dlg, IDC_KEYPROPS_CHANGE_PWD, _("Change &Password"));
293	werner	36	SetDlgItemText (dlg, IDC_KEYPROPS_OTINF, _("Ownertrust"));
294	twoaday	181
295	twoaday	211	display_key_info (dlg, k);
296			if (!keyprops_load_photo (dlg, k->ctx, &valid)) {
297	werner	36	k->has_photo = 1;
298			if (valid < GPGME_VALIDITY_MARGINAL)
299			SetDlgItemText (dlg, IDC_KEYPROPS_IMGINF, _("Photo-ID not validated."));
300			}
301			if (k->key_pair)
302			EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_CHANGE_PWD), TRUE);
303	twoaday	211	if (check_for_desig_rev (k->ctx))
304	werner	36	EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_REVOKERS), TRUE);
305	twoaday	211	if (k->ctx->revoked \|\| k->ctx->expired)
306	twoaday	150	EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_OT_CHANGE), FALSE);
307	werner	36	center_window (dlg, NULL);
308			SetForegroundWindow (dlg);
309			return TRUE;
310
311			case WM_DESTROY:
312	werner	47	remove (get_photo_tmpname (dlg));
313	werner	36	break;
314
315			case WM_PAINT:
316			if (k->has_photo)
317			keyprops_show_photo (dlg);
318			break;
319
320			case WM_SYSCOMMAND:
321			if (LOWORD (wparam) == SC_CLOSE)
322	twoaday	170	EndDialog (dlg, FALSE);
323	werner	36	return FALSE;
324
325			case WM_COMMAND:
326			switch (LOWORD (wparam)) {
327			case IDOK:
328			EndDialog (dlg, TRUE);
329			return TRUE;
330	twoaday	170
331			case IDCANCEL:
332			EndDialog (dlg, FALSE);
333			return TRUE;
334	werner	36
335			case IDC_KEYPROPS_OT_CHANGE:
336	twoaday	211	if (do_check_key (k->ctx)) {
337	werner	36	msg_box (dlg, _("The status of this key is 'revoked' or 'expired'.\n"
338			"You cannot change the ownertrust of such keys."),
339			_("WinPT Warning"), MB_ERR);
340			return TRUE;
341			}
342	twoaday	211	if (!k->key_pair && !key_is_valid (k->ctx)) {
343	twoaday	150	rc = msg_box (dlg, _("This is a non-valid key.\n"
344	werner	36	"Modifying the ownertrust has no effect on such keys.\n\n"
345			"Do you really want to continue?"),
346	twoaday	150	_("WinPT Warning"), MB_ICONWARNING\|MB_YESNO);
347	werner	36	if (rc == IDNO)
348			return TRUE;
349			}
350	twoaday	165	rc = dialog_box_param (glob_hinst,
351			(LPCSTR)IDD_WINPT_KEYEDIT_OWNERTRUST,
352			dlg, keyedit_ownertrust_dlg_proc,
353			(LPARAM)k, _("Change Ownertrust"),
354			IDS_WINPT_KEYEDIT_OWNERTRUST);
355			if (rc == FALSE) /* Cancel */
356			return TRUE;
357	werner	36
358	twoaday	150	inf = ownertrust_to_string (k->callback.new_val, k->key_pair);
359	werner	36	SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
360			msg_box (dlg, _("Ownertrust successfully changed."),
361			_("GnuPG Status"), MB_OK);
362	twoaday	165	k->update = 1;
363	werner	36	return TRUE;
364
365			case IDC_KEYPROPS_CHANGE_PWD:
366			keyedit_change_passwd (k, dlg);
367			return TRUE;
368
369			case IDC_KEYPROPS_REVOKERS:
370	twoaday	161	k->update = dialog_box_param (
371			glob_hinst, (LPCTSTR)IDD_WINPT_KEYREVOKERS, dlg,
372	twoaday	208	key_revokers_dlg_proc, (LPARAM)k,
373	twoaday	161	_("Key Revokers"), IDS_WINPT_KEY_REVOKERS);
374	werner	36	break;
375			}
376			}
377
378			return FALSE;
379			}