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 <assert.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 invalid = 0;

    invalid = key->expired;
    if (!invalid)
        invalid = key->revoked;
    return invalid;
}


/* 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 (img && !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 kk;

    memset (&kk, 0, sizeof (kk));
    if (!winpt_get_pubkey (key->subkeys->keyid, &kk))
        return kk.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, DIM (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 key)
{
    gpgme_user_id_t u;

    for (u=key->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);
}


/* Context to store associated data of the dialog. */
struct prop_info_s {
    winpt_key_t key;
};


static void
on_init_dialog (HWND dlg, WPARAM wparam, LPARAM lparam)
{
    gpgme_validity_t valid;

    winpt_key_t 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 (do_check_key (k->ctx))
        EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_OT_CHANGE), FALSE);
    center_window (dlg, NULL);  
    SetForegroundWindow (dlg);
}


/* Dialog box procedure to show the key properties. */
BOOL CALLBACK
keyprops_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    struct prop_info_s *prop = NULL;
    const char *inf;
    int rc;
    
    if (msg != WM_INITDIALOG &&
        (prop = (prop_info_s*)GetWindowLong (dlg, GWL_USERDATA)) == NULL)
        return FALSE;

    switch (msg) {
    case WM_INITDIALOG:
        assert (lparam != NULL);
        prop = new struct prop_info_s;
        prop->key = (winpt_key_t)lparam;
        SetWindowLong (dlg, GWL_USERDATA, (LONG)prop);
        on_init_dialog (dlg, wparam, lparam);
        return TRUE;

    case WM_DESTROY:
        remove (get_photo_tmpname (dlg));
        delete prop;prop=NULL;
        SetWindowLong (dlg, GWL_USERDATA, 0);
        break;
      
    case WM_PAINT:
        if (prop->key->has_photo)
            keyprops_show_photo (dlg);
        break;
        
    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 (prop->key->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 (!prop->key->key_pair && !key_is_valid (prop->key->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)prop->key, _("Change Ownertrust"),
                                    IDS_WINPT_KEYEDIT_OWNERTRUST);
            if (rc == FALSE) /* Cancel */
                return TRUE;

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

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