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);
    GetTempPath (sizeof (buf)-128, buf);
    strcat (buf, 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;

    winpt_get_pubkey (key->subkeys->keyid, &k);
    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) {
        //for (pos = 0; img[pos] != 0x10; pos++)
        //      ;
        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)
{
    int val;
    val = key->expired;
    if (val)
        return _("Expired");    
    val = key->revoked;
    if (val)
        return _("Revoked");
    val = key->disabled;
    if (val)
        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->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:
    case 8:
    case 9: return "AES";
    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->card_type)
        return "";
    _snprintf (buf, sizeof (buf)-1, _("Card-Type: %s\r\n"), k->ext->card_type);
    return buf;
}


/* 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 *r_key)
{
    struct winpt_key_s k2;
    gpgme_key_t sk, key;
    char info[512];
    const char *inf;
    u32 created, expires;

    memset (&k2, 0, sizeof (k2));       
    if (k->key_pair)
        winpt_get_seckey (k->keyid, &k2);
    else    
        winpt_get_pubkey (k->keyid, &k2);
    sk = k2.ctx;
    if (sk)
        k->is_protected = k2.is_protected;
    if (get_pubkey (k->keyid, &key))
        BUG (0);    
    created = key->subkeys->timestamp;  
    expires = key->subkeys->expires;    
    _snprintf (info, DIM (info)-1,
               _("Type: %s\r\n"
               "Key ID: %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 (&k2),
               get_card_type (&k2));

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

    *r_key = key;
}


/* 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;
    static gpgme_key_t key;
    gpgme_validity_t valid;
    refresh_cache_s rcs = {0};
    const char *inf;
    int cancel = 0;
    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, &key);
        if (!keyprops_load_photo (dlg, key, &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 (key))
            EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_REVOKERS), TRUE);
        if (key->revoked || key->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 (key)) {
                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->uids->validity < 3) {
                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)key, 
                _("Key Revokers"), IDS_WINPT_KEY_REVOKERS);
            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
26	#include "resource.h"
27	#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	ownertrust_to_string (int val, bool is_keypair)
55	{
56	const char *inf;
57	int id = val;
58
59	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	case 6:
66	if (is_keypair)
67	inf = _("I trust ultimately (implicit)");
68	else
69	inf = _("I trust ultimately"); break;
70	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	static char buf[MAX_PATH+128+1];
83	char name[64];
84
85	_snprintf (name, sizeof (name)-1, "winpt_photo_%08lX.tmp", (DWORD)dlg);
86	GetTempPath (sizeof (buf)-128, buf);
87	strcat (buf, name);
88
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	winpt_get_pubkey (key->subkeys->keyid, &k);
113	img = k.ext->attrib.d;
114	imglen = k.ext->attrib.len;
115	if (!k.ext->attrib.validity)
116	get_uat_validity (key->subkeys->keyid, &k.ext->attrib.validity);
117	*r_valid = k.ext->attrib.validity;
118
119	if (!img \|\| !imglen) {
120	draw_nophoto_img (dlg);
121	return -1;
122	}
123
124	f = fopen (get_photo_tmpname (dlg), "wb");
125	if (f) {
126	//for (pos = 0; img[pos] != 0x10; pos++)
127	// ;
128	pos += 16;
129	fwrite (img + pos, 1, imglen - pos, f);
130	fclose (f);
131	}
132	return 0;
133	}
134
135
136	/* Display the photo in the image control in the dialog @dlg. */
137	static int
138	keyprops_show_photo (HWND dlg)
139	{
140	RECT r;
141	POINT p;
142	HWND h;
143
144	h = GetDlgItem (dlg, IDC_KEYPROPS_IMG);
145	GetWindowRect (h, &r);
146	p.x = r.left + 5;
147	p.y = r.top - 2;
148	memset (&p, 0, sizeof (p));
149	PTD_jpg_show (h, &p, get_photo_tmpname (dlg));
150
151	return 0;
152	}
153
154
155	/* Return string representation of the key validity. @key. */
156	static const char*
157	get_validity (gpgme_key_t key)
158	{
159	int val;
160	val = key->expired;
161	if (val)
162	return _("Expired");
163	val = key->revoked;
164	if (val)
165	return _("Revoked");
166	val = key->disabled;
167	if (val)
168	return _("Disabled");
169	return get_key_trust2 (NULL, key->uids->validity, 0, 0);
170	}
171
172
173	/* Return the preferred sym. algorithm from @key as a string. */
174	static const char*
175	get_pref_cipher (winpt_key_t k)
176	{
177	if (k->is_v3)
178	return "IDEA";
179	if (!k->ext->sym_prefs)
180	return "3DES";
181	switch (*k->ext->sym_prefs) {
182	case 1: return "IDEA";
183	case 2: return "3DES";
184	case 3: return "CAST5";
185	case 4: return "Blowfish";
186	case 7:
187	case 8:
188	case 9: return "AES";
189	case 10:return "Twofish";
190	}
191	return "Unknown";
192	}
193
194
195	/* Return true if the key has designated revokers. */
196	static bool
197	check_for_desig_rev (gpgme_key_t key)
198	{
199	winpt_key_s k;
200	memset (&k, 0, sizeof (k));
201	if (!winpt_get_pubkey (key->subkeys->keyid, &k))
202	return k.ext->gloflags.has_desig_rev? true : false;
203	return false;
204	}
205
206
207	/* Print information (name) of the smart card. */
208	static const char*
209	get_card_type (winpt_key_t k)
210	{
211	static char buf[64];
212
213	if (!k->ext->card_type)
214	return "";
215	_snprintf (buf, sizeof (buf)-1, _("Card-Type: %s\r\n"), k->ext->card_type);
216	return buf;
217	}
218
219
220	/* Display the key information for key @k.
221	Return value: gpgme key on success. */
222	static void
223	display_key_info (HWND dlg, winpt_key_t k, gpgme_key_t *r_key)
224	{
225	struct winpt_key_s k2;
226	gpgme_key_t sk, key;
227	char info[512];
228	const char *inf;
229	u32 created, expires;
230
231	memset (&k2, 0, sizeof (k2));
232	if (k->key_pair)
233	winpt_get_seckey (k->keyid, &k2);
234	else
235	winpt_get_pubkey (k->keyid, &k2);
236	sk = k2.ctx;
237	if (sk)
238	k->is_protected = k2.is_protected;
239	if (get_pubkey (k->keyid, &key))
240	BUG (0);
241	created = key->subkeys->timestamp;
242	expires = key->subkeys->expires;
243	_snprintf (info, DIM (info)-1,
244	_("Type: %s\r\n"
245	"Key ID: %s\r\n"
246	"Algorithm: %s\r\n"
247	"Size: %s bits\r\n"
248	"Created: %s\r\n"
249	"Expires: %s\r\n"
250	"Validity: %s\r\n"
251	"Cipher: %s\r\n"
252	"%s\r\n"),
253	get_key_type (key),
254	k->keyid,
255	get_key_algo (key, 0),
256	get_key_size (key, 0),
257	get_key_created (created),
258	get_key_expire_date (expires),
259	get_validity (key),
260	get_pref_cipher (&k2),
261	get_card_type (&k2));
262
263	SetDlgItemText (dlg, IDC_KEYPROPS_INFO, info);
264	SetDlgItemText (dlg, IDC_KEYPROPS_FPR, get_key_fpr (key));
265	inf = ownertrust_to_string (key->owner_trust, k->key_pair);
266	SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
267
268	*r_key = key;
269	}
270
271
272	/* Dialog box procedure to show the key properties. */
273	BOOL CALLBACK
274	keyprops_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
275	{
276	static winpt_key_t k;
277	static gpgme_key_t key;
278	gpgme_validity_t valid;
279	refresh_cache_s rcs = {0};
280	const char *inf;
281	int cancel = 0;
282	int rc;
283
284	/* XXX: static variable (k) prevent that the dialog can
285	be opened twice. */
286	switch (msg) {
287	case WM_INITDIALOG:
288	if (!lparam)
289	dlg_fatal_error (dlg, "Could not get dialog param!");
290	k = (winpt_key_t)lparam;
291	SetWindowText (dlg, _("Key Properties"));
292	SetDlgItemText (dlg, IDC_KEYPROPS_OT_CHANGE, _("&Change"));
293	SetDlgItemText (dlg, IDC_KEYPROPS_REVOKERS, _("&Revokers"));
294	SetDlgItemText (dlg, IDC_KEYPROPS_CHANGE_PWD, _("Change &Password"));
295	SetDlgItemText (dlg, IDC_KEYPROPS_OTINF, _("Ownertrust"));
296
297	display_key_info (dlg, k, &key);
298	if (!keyprops_load_photo (dlg, key, &valid)) {
299	k->has_photo = 1;
300	if (valid < GPGME_VALIDITY_MARGINAL)
301	SetDlgItemText (dlg, IDC_KEYPROPS_IMGINF, _("Photo-ID not validated."));
302	}
303	if (k->key_pair)
304	EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_CHANGE_PWD), TRUE);
305	if (check_for_desig_rev (key))
306	EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_REVOKERS), TRUE);
307	if (key->revoked \|\| key->expired)
308	EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_OT_CHANGE), FALSE);
309	center_window (dlg, NULL);
310	SetForegroundWindow (dlg);
311	return TRUE;
312
313	case WM_DESTROY:
314	remove (get_photo_tmpname (dlg));
315	break;
316
317	case WM_PAINT:
318	if (k->has_photo)
319	keyprops_show_photo (dlg);
320	break;
321
322	case WM_SYSCOMMAND:
323	if (LOWORD (wparam) == SC_CLOSE)
324	EndDialog (dlg, FALSE);
325	return FALSE;
326
327	case WM_COMMAND:
328	switch (LOWORD (wparam)) {
329	case IDOK:
330	EndDialog (dlg, TRUE);
331	return TRUE;
332
333	case IDCANCEL:
334	EndDialog (dlg, FALSE);
335	return TRUE;
336
337	case IDC_KEYPROPS_OT_CHANGE:
338	if (do_check_key (key)) {
339	msg_box (dlg, _("The status of this key is 'revoked' or 'expired'.\n"
340	"You cannot change the ownertrust of such keys."),
341	_("WinPT Warning"), MB_ERR);
342	return TRUE;
343	}
344	if (!k->key_pair && key->uids->validity < 3) {
345	rc = msg_box (dlg, _("This is a non-valid key.\n"
346	"Modifying the ownertrust has no effect on such keys.\n\n"
347	"Do you really want to continue?"),
348	_("WinPT Warning"), MB_ICONWARNING\|MB_YESNO);
349	if (rc == IDNO)
350	return TRUE;
351	}
352	rc = dialog_box_param (glob_hinst,
353	(LPCSTR)IDD_WINPT_KEYEDIT_OWNERTRUST,
354	dlg, keyedit_ownertrust_dlg_proc,
355	(LPARAM)k, _("Change Ownertrust"),
356	IDS_WINPT_KEYEDIT_OWNERTRUST);
357	if (rc == FALSE) /* Cancel */
358	return TRUE;
359
360	inf = ownertrust_to_string (k->callback.new_val, k->key_pair);
361	SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
362	msg_box (dlg, _("Ownertrust successfully changed."),
363	_("GnuPG Status"), MB_OK);
364	k->update = 1;
365	return TRUE;
366
367	case IDC_KEYPROPS_CHANGE_PWD:
368	keyedit_change_passwd (k, dlg);
369	return TRUE;
370
371	case IDC_KEYPROPS_REVOKERS:
372	k->update = dialog_box_param (
373	glob_hinst, (LPCTSTR)IDD_WINPT_KEYREVOKERS, dlg,
374	key_revokers_dlg_proc, (LPARAM)key,
375	_("Key Revokers"), IDS_WINPT_KEY_REVOKERS);
376	break;
377	}
378	}
379
380	return FALSE;
381	}