trunk/Src/wptKeyPropsDlg.cpp

/* wptKeyPropsDlg.cpp - WinPT key properties dialog
 *      Copyright (C) 2000, 2001, 2002, 2003, 2005 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 <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)
{
    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: 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[64];

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


/* 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)
        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);
        fwrite (img, 1, imglen, 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)
{
    const char *sym_prefs=NULL;    

    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\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);
    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;
        #ifndef LANG_DE
        SetWindowText (dlg, _("Key Properties"));
        SetDlgItemText (dlg, IDC_KEYPROPS_OT_CHANGE, _("&Change"));
        SetDlgItemText (dlg, IDC_KEYPROPS_REVOKERS, _("&Revokers"));
        SetDlgItemText (dlg, IDC_KEYPROPS_CHANGE_PWD, _("Change &Passwd"));
        SetDlgItemText (dlg, IDC_KEYPROPS_OTINF, _("Ownertrust"));
        #endif  

        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);
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);      
        return TRUE;

    case WM_DESTROY:
        unlink (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, TRUE);
        return FALSE;
        
    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            EndDialog (dlg, TRUE);
            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;
            }
            //GetDlgItemText (dlg, IDC_KEYPROPS_OT, info, sizeof info -1);
            dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYEDIT_OWNERTRUST,
                              dlg, (DLGPROC)keyedit_ownertrust_dlg_proc,
                              (LPARAM)k, _("Change Ownertrust"),
                              IDS_WINPT_KEYEDIT_OWNERTRUST);
            if (k->callback.new_val == -1) { /* Cancel */
                EndDialog (dlg, FALSE);
                break;
            }

            inf = ownertrust_to_string (k->callback.new_val);
            SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
            msg_box (dlg, _("Ownertrust successfully changed."), 
                     _("GnuPG Status"), MB_OK);
            
            /* XXX: modified ownertrust values can effect the entire
                    WoT so we reload the cache. But this is very slow. */
            memset (&rcs, 0, sizeof (rcs));
            rcs.kr_reload = 1; rcs.kr_update = 1; /* reload only keylist */
            DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,
                            keycache_dlg_proc, (LPARAM)&rcs);
            return TRUE;
            
        case IDC_KEYPROPS_CHANGE_PWD:
            keyedit_change_passwd (k, dlg);         
            return TRUE;

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