trunk/Src/wptKeygenDlg.cpp

/* wptKeygenDlg.cpp - Key Generation dialog
 *      Copyright (C) 2000-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 "resource.h"
#include "wptTypes.h"
#include "wptNLS.h"
#include "wptGPG.h"
#include "wptCommonCtl.h"
#include "wptContext.h" /* for passphrase_s */
#include "wptDlgs.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptUTF8.h"

/* All valid key generation combination. */
enum gpg_keytype_t {
    GPG_KEYGEN_NONE    = 0,
    GPG_KEYGEN_DSA_ELG = 1,
    GPG_KEYGEN_DSA_RSA = 2,
    GPG_KEYGEN_DSA_SIG = 3,
    GPG_KEYGEN_RSA_SIG = 4,    
    GPG_KEYGEN_RSA     = 5,
    GPG_KEYGEN_RSA_RSA = 6 /*PGP*/
};


static const char key_params[] =
        "<GnupgKeyParms format=\"internal\">\n"
        "Key-Type: %s\n"
        "Key-Usage: sign\n"
        "Key-Length: %d\n"
        "Subkey-Type: %s\n"
        "Subkey-Length: %d\n"
        "Name-Real: %s\n"       
        "Name-Email: %s\n"
        "Expire-Date: %s\n"
        "Passphrase: %s\n"
        "</GnupgKeyParms>\n";

static const char key_params_with_comment[] = 
        "<GnupgKeyParms format=\"internal\">\n"
        "Key-Type: %s\n"
        "Key-Usage: sign\n"
        "Key-Length: %d\n"
        "Subkey-Type: %s\n"
        "Subkey-Length: %d\n"
        "Name-Real: %s\n"
        "Name-Comment: %s\n"
        "Name-Email: %s\n"
        "Expire-Date: %s\n"
        "Passphrase: %s\n"
        "</GnupgKeyParms>\n";

static const char key_params_one[] = 
        "<GnupgKeyParms format=\"internal\">\n"
        "Key-Type: %s\n"
        "Key-Length: %d\n"
        "Key-Usage: %s\n"       
        "Name-Real: %s\n"       
        "Name-Email: %s\n"
        "Expire-Date: %s\n"
        "Passphrase: %s\n"
        "</GnupgKeyParms>\n";

static const char key_params_one_with_comment[] = 
        "<GnupgKeyParms format=\"internal\">\n"
        "Key-Type: %s\n"
        "Key-Length: %d\n"
        "Key-Usage: %s\n"       
        "Name-Real: %s\n"       
        "Name-Comment: %s\n"
        "Name-Email: %s\n"
        "Expire-Date: %s\n"
        "Passphrase: %s\n"
        "</GnupgKeyParms>\n";


/* Generate the GPG specific genkey params with the given information.
   @keytype: See valid combinations.
   @bits: Length in bits.
   @user: user-ID name
   @comment: comment for the user-ID.
   @email: email address.
   @expdata: date of expiration or NULL.
   @passphrase: the actual passphrase.
   Return value: the gen. params. */
static char*
gpg_genkey_params (int keytype, int bits, 
                   const char *user, const char *comment, const char *email,
                   const char *expdate, const char *passphrase)
{
    char *p = NULL;
    int addsize = strlen ("sign encrypt");
    int size = 0;
    
    if (keytype == GPG_KEYGEN_NONE)
        return NULL;
    
    size = strlen (user) + strlen (email) + strlen (passphrase) + addsize + 48;
    if (comment && *comment)
        size += strlen (key_params_with_comment) + strlen (comment);
    else
        size += strlen (key_params);
    if (expdate)
        size += strlen (expdate) + 1;
    p = new char[size+1];
    if (!p)
        BUG (0);
    /* XXX: simply the whole switch-case code. */
    if (comment && *comment) {
        switch( keytype ) {
        case GPG_KEYGEN_DSA_ELG:
            sprintf (p, key_params_with_comment,
                     "DSA", 1024, "ELG-E", bits, user, comment, email,
                     expdate ? expdate : "0", passphrase);
            break;
            
        case GPG_KEYGEN_DSA_RSA:
            sprintf( p, key_params_with_comment, 
                     "DSA", 1024, "RSA", bits, user, comment, email,
                     expdate ? expdate : "0", passphrase );
            break;
            
        case GPG_KEYGEN_DSA_SIG:
            sprintf( p, key_params_one_with_comment, 
                     "DSA", 1024, "sign",
                     user, comment, email,
                     expdate ? expdate : "0", passphrase );
            break;
            
        case GPG_KEYGEN_RSA_SIG:
            sprintf( p, key_params_one_with_comment, 
                     "RSA", bits, "sign",
                     user, comment, email,
                     expdate ? expdate : "0", passphrase );
            break;
            
        case GPG_KEYGEN_RSA:
            sprintf( p, key_params_one_with_comment, 
                    "RSA", bits, "sign encrypt",
                    user, comment, email,
                    expdate ? expdate : "0", passphrase );
            break;

        case GPG_KEYGEN_RSA_RSA:
            sprintf( p, key_params_with_comment,
                     "RSA", bits, "RSA", bits, user, comment, email,
                     expdate? expdate : "0", passphrase );
            break;
            
        default:
            free_if_alloc (p);
            break;
        }
    }
    else {
        switch ( keytype ) {
        case GPG_KEYGEN_DSA_ELG:
            sprintf( p, key_params,
                    "DSA", 1024, "ELG-E", bits, user, email,
                    expdate ? expdate : "0", passphrase );
            break;
            
        case GPG_KEYGEN_DSA_RSA:
            sprintf( p, key_params,
                    "DSA", 1024, "RSA", bits, user, email,
                    expdate ? expdate : "0", passphrase );
            break;
            
        case GPG_KEYGEN_DSA_SIG:
            sprintf( p, key_params_one, 
                    "DSA", 1024, "sign",
                    user, email,
                    expdate ? expdate : "0", passphrase );
            break;
            
        case GPG_KEYGEN_RSA_SIG:
            sprintf( p, key_params_one, 
                    "RSA", bits, "sign",
                    user, email,
                    expdate ? expdate : "0", passphrase );
            break;
            
        case GPG_KEYGEN_RSA:
            sprintf( p, key_params_one, 
                    "RSA", bits, "sign encrypt",
                    user, email,
                    expdate ? expdate : "0", passphrase );
            break;

        case GPG_KEYGEN_RSA_RSA:
            sprintf( p, key_params,
                     "RSA", bits, "RSA", bits, user, email,
                     expdate? expdate : "0", passphrase );
            break;
            
        default:
            free_if_alloc (p);
            break;
        }
    }
    return p;
}


/* Generate a key with the given params @params. @prog_cb is a user defined
   progress callback which is called during the generation.
   @fpr will store the fingerprint of the generated key.
   Return value: 0 on success. */
gpgme_error_t
gpg_genkey (const char *params, gpgme_progress_cb_t prog_cb, char **fpr)
{
    gpgme_error_t err = 0;
    gpgme_ctx_t ctx;
    gpgme_genkey_result_t res;
    
    err = gpgme_new(&ctx);
    if (err)
        return err;
    if (prog_cb)
        gpgme_set_progress_cb (ctx, prog_cb, NULL);
    err = gpgme_op_genkey (ctx, params, NULL, NULL);
    if (!err) {
        res = gpgme_op_genkey_result (ctx);
        *fpr = res->fpr? m_strdup (res->fpr) : NULL;
    }
    gpgme_release (ctx);
    return err;
}


/* Clear all dialog fields. */
static void 
clear_dlg_fields (HWND dlg)
{
    SetDlgItemText (dlg, IDC_KEYGEN_SUBKEYBITS, "");
    SetDlgItemText (dlg, IDC_KEYGEN_NAME, "");
    SetDlgItemText (dlg, IDC_KEYGEN_EMAIL, "");
    SetDlgItemText (dlg, IDC_KEYGEN_COMMENT, "");
    SetDlgItemText (dlg, IDC_KEYGEN_EXPDATE, "");
    SetDlgItemText (dlg, IDC_KEYGEN_PASSPHRASE, "");
    SetDlgItemText (dlg, IDC_KEYGEN_PWDCHECK, "");
}


/* Ask the user if a keyring backup is wanted and if so,
   backup both keyrings to the selected folder. @dlg is
   the handle of the parent window.*/
static void
backup_keyrings (HWND dlg)
{
    const char *name;
    char *path = NULL;
    char *keyring = NULL;
    int id;
    
    path = get_gnupg_path ();
    if (!path)
        BUG (dlg);
    id = msg_box (dlg, 
                 _("It is STRONGLY recommend that you backup your keyrings because they both "
                   "contain VERY important data.\nRemember that your hard disk can crash or the "
                   "files can be deleted by accident; so it is a good\nidea to store them on "
                   "a different mass stoarge like a floppy or CDR!\n\n"
                   "Backup your keyrings now?"),
                 _("WARNING - Important hint" ), MB_YESNO);
    if (id == IDYES) {
        name = get_filesave_dlg (dlg, _("Destination for Public Keyring"), 
                                 NULL, "pubring.gpg");
        if( name ) {
            keyring = make_filename (path, "pubring", "gpg");
            if( !CopyFile (keyring, name, FALSE))
                log_box (_("Key Generation"), MB_ERR,
                         _("Could not copy %s -> %s"), keyring, name);
            free_if_alloc (keyring);
        }
        name = get_filesave_dlg (dlg, _("Destination for Secret Keyring"), 
                                 NULL, "secring.gpg");
        if( name ) {
            keyring = make_filename (path, "secring", "gpg");
            if (!CopyFile (keyring, name, FALSE))
                log_box (_("Key Generation"), MB_ERR,
                         _("Could not copy %s -> %s"), keyring, name);
            free_if_alloc (keyring);
        }
    }
    free_if_alloc (path);
}


/* Fill in all valid GPG algorithms. */
static void
fill_keytype_box (HWND dlg)
{
    HWND cb = GetDlgItem (dlg, IDC_KEYGEN_KEYTYPE);

#define addstr(cb, str) \
    SendMessage ((cb), CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)(str))
    addstr (cb, _("DSA and ELG (default)"));
    addstr (cb, _("DSA and RSA"));
    addstr (cb, _("DSA sign only"));
    addstr (cb, _("RSA sign only"));
    addstr (cb, _("RSA sign and encrypt"));
    addstr (cb, _("RSA and RSA (PGP)") );
    SendMessage (cb, CB_SETCURSEL, 0, 0);
#undef addstr
}


/* Check that the given date lies not in the past.
   Return value: 1 on success. */
int
keygen_check_date (SYSTEMTIME *st)
{       
    SYSTEMTIME t;
        
    GetSystemTime (&t);
    if (st->wYear > t.wYear || st->wMonth > t.wMonth)
        return 1;
    else if (st->wYear < t.wYear || st->wMonth < t.wMonth || st->wDay < t.wDay)
        return 0;
    return 1;
}


/* Dialog box procedure for key generation. */
BOOL CALLBACK
keygen_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static genkey_s *ctx;
    SYSTEMTIME st;
    gpgme_error_t err;
    char name[128] = {0}, email[128] = {0}, comment[128] = {0};
    char *pwd;
    char t[64], *expire = NULL, *fpr=NULL;
    int bits, use_comment, keytype = 0;
    int cancel = 0;
    char *p;
    
    switch ( msg ) {
    case WM_INITDIALOG:
        if (lparam != 0)
            ctx = (genkey_s *)lparam;
        SetWindowText (dlg, _("Key Generation"));
        SetDlgItemText(dlg, IDC_KEYGEN_INFO,
                        _("NOTE: Key generation can be a lengthy process! Please wait until "
                          "you get the message that key generation was finished."));
        SetDlgItemText (dlg, IDC_KEYGEN_SUBKEYINF, _("Subkey size in &bits"));
        SetDlgItemText (dlg, IDC_KEYGEN_NAMEINF, _("&Real name"));
        SetDlgItemText (dlg, IDC_KEYGEN_COMMINF, _("&Comment (optional)"));
        SetDlgItemText (dlg, IDC_KEYGEN_EMAILINF, _("Email &address"));
        SetDlgItemText (dlg, IDC_KEYGEN_EXPINF, _("&Expire date"));
        SetDlgItemText (dlg, IDC_KEYGEN_KEYTYPEINF, _("Key &type"));
        SetDlgItemText (dlg, IDC_KEYGEN_EXPNEVER, _("&Never"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));

        SetDlgItemInt (dlg, IDC_KEYGEN_SUBKEYBITS, DFAULT_KEYSIZE, FALSE);
        CheckDlgButton (dlg, IDC_KEYGEN_HIDEPWD, BST_CHECKED);
        CheckDlgButton (dlg, IDC_KEYGEN_EXPNEVER, BST_CHECKED);
        EnableWindow (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), FALSE);
        fill_keytype_box (dlg);
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);
        return TRUE;
        
    case WM_SYSCOMMAND:
        if (LOWORD (wparam) == SC_CLOSE)
            EndDialog (dlg, TRUE);
        return FALSE;
        
    case WM_COMMAND:
        if (HIWORD (wparam) == BN_CLICKED &&
            LOWORD (wparam) == IDC_KEYGEN_EXPNEVER) {
            int never = IsDlgButtonChecked (dlg, IDC_KEYGEN_EXPNEVER);
            EnableWindow (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), !never);
        }

        switch (LOWORD (wparam)) {
        case IDOK:
            bits = GetDlgItemInt (dlg, IDC_KEYGEN_SUBKEYBITS, NULL, FALSE);
            if (bits < 1024 || bits > 4096) {
                msg_box (dlg, _("Invalid value. Allowed values 1024-4096 bits."), 
                         _("Key Generation"), MB_ERR);
                return FALSE;
            }
            if (bits > DFAULT_KEYSIZE) {
                int id = msg_box (dlg, _("Do you really need such a large key?"),
                                  _("Key Generation"), MB_YESNO);
                if (id == IDNO)
                    bits = DFAULT_KEYSIZE;
            }
            if (!GetDlgItemText (dlg, IDC_KEYGEN_NAME, name, sizeof (name) - 1)) {
                msg_box( dlg, _("Please enter the name."), _("Key Generation"), MB_ERR);
                return FALSE;
            }
            if (strchr (name, '@')) {
                msg_box (dlg, _("Please do not enter the email address in the name field."),
                         _("Key Generation"), MB_INFO);
                return FALSE;
            }
            if (!GetDlgItemText (dlg, IDC_KEYGEN_EMAIL, email, sizeof (email) -1)
                || check_email_address (email)) {
                msg_box (dlg, _("Please enter a valid email address."),
                         _("Key Generation"), MB_ERR);
                return FALSE;
            }
            use_comment = GetDlgItemText(dlg, IDC_KEYGEN_COMMENT, 
                                         comment, sizeof (comment) -1);
            if (use_comment > 0 && strchr (comment, '@')) {
                msg_box (dlg, _("Please do NOT enter the email address in the comment field."),
                         _("Key Generation"), MB_INFO);
                return FALSE;
            }
            keytype = SendDlgItemMessage (dlg, IDC_KEYGEN_KEYTYPE, CB_GETCURSEL, 0, 0) + 1;
            if (IsDlgButtonChecked (dlg, IDC_KEYGEN_EXPNEVER))
                expire = NULL;
            else {
                DateTime_GetSystemtime (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), &st);
                _snprintf (t, DIM (t)-1, "%04d-%02d-%02d", st.wYear, st.wMonth, st.wDay);
                expire = t;
            }

            pwd = request_passphrase2 (_("Key Generation"), PASSDLG_STRICT, &cancel);
            if (cancel) {
                sfree_if_alloc (pwd);
                return FALSE;
            }
            if (!pwd) {
                msg_box (dlg, _("Please enter the passphrase."), 
                         _("Key Generation"), MB_ERR);
                return FALSE;
            }

            if (!use_comment && !strlen (comment)) {
                char *utf8_name;
                utf8_name = native_to_utf8 (name);
                if (!utf8_name)
                    BUG (0);
                p = gpg_genkey_params (keytype, bits, utf8_name, NULL, 
                                       email, expire, pwd);
                free_if_alloc (utf8_name);
            }
            else {
                char *utf8_name, *utf8_comment;
                utf8_name = native_to_utf8 (name);
                utf8_comment = native_to_utf8 (comment);
                if( !utf8_name || !utf8_comment )
                    BUG (0);
                p = gpg_genkey_params (keytype, bits, utf8_name, utf8_comment, 
                                       email, expire, pwd);
                free_if_alloc (utf8_name);
                free_if_alloc (utf8_comment);
            }
            keygen_cb_dlg_create ();
            err = gpg_genkey (p, keygen_cb, &fpr);
            sfree_if_alloc (pwd);
            if (p) {
                wipememory (p, strlen (p));  /* burn the passphrase! */
                free_if_alloc (p);
            }
            keygen_cb_dlg_destroy ();
            keygen_cb (NULL, NULL, 0, 0, 0); /* flush */
            if (err) {
                free_if_alloc (fpr);
                msg_box (dlg, gpgme_strerror (err), _("Key Generation"), MB_ERR);
                return FALSE;
            }
            status_box (dlg, _("Key Generation completed"), _("GnuPG Status"));
            
            keycache_update (0, fpr);
            keycache_update (1, fpr);
            free_if_alloc (fpr);            

            clear_dlg_fields (dlg);
            backup_keyrings (dlg);
            if (ctx)
                ctx->cancel = 0;
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            if (ctx)
                ctx->cancel = 1;
            EndDialog (dlg, FALSE);        
            return FALSE;
        }
        break;
    }
    
    return FALSE;
}


BOOL CALLBACK
keygen_wizard_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static genkey_s *ctx;
    static int pubkey_algo = GPG_KEYGEN_DSA_ELG;
    gpgme_error_t err;
    char name[128], email[128];
    char * utf8_name, * p, *fpr=NULL;
    char * pass = NULL;
    int cancel = 0;
    

    switch( msg ) {
    case WM_INITDIALOG:
        ctx = (genkey_s *)lparam;
        if (!ctx || (ctx && ctx->interactive == 0))
            EnableWindow (GetDlgItem (dlg, IDC_KEYWIZARD_EXPERT), FALSE);
        SetDlgItemText (dlg, IDC_KEYWIZARD_USERSA, _("&Prefer RSA keys"));
        SetDlgItemText (dlg, IDC_KEYWIZARD_NAMEINF, _("Real name:"));
        SetDlgItemText (dlg, IDC_KEYWIZARD_EMAILINF, _("Email address:"));
        SetDlgItemText (dlg, IDC_KEYWIZARD_TITLEINF, _("Name and E-Mail Assignment"));
        SetDlgItemText (dlg, IDC_KEYWIZARD_TEXT1INF, _("Every key pair must have a name associated with it. The name and\nemail address let your correspondents that your public key they are\nusing belongs to us."));
        SetDlgItemText (dlg, IDC_KEYWIZARD_TEXT2INF, _("By accosiating an email address with your key pair, you will enable WinPT to assist your correspondents in selecting the correct public\nkey when communicating with you."));
        SetWindowText (dlg, _("Key Generation Wizard"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
        SetDlgItemText (dlg, IDC_KEYWIZARD_EXPERT, _("E&xpert"));
        SetForegroundWindow (dlg);
        center_window (dlg, NULL);
        break;

    case WM_SYSCOMMAND:
        if( LOWORD( wparam ) == SC_CLOSE )
            EndDialog( dlg, FALSE );

    case WM_COMMAND:
        switch( LOWORD( wparam ) ) {
        case IDC_KEYWIZARD_EXPERT:
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYGEN, dlg,
                            keygen_dlg_proc, 0);
            EndDialog (dlg, TRUE);
            break;

        case IDOK:
            if( !GetDlgItemText( dlg, IDC_KEYWIZARD_NAME, name, sizeof name-1 ) ) {
                msg_box( dlg, _("Please enter the name."), 
                         _("Key Generation Wizard"), MB_ERR );
                return FALSE;
            }
            if (strchr (name, '@')) {
                msg_box (dlg, _("Please do not enter the email address in the name field."),
                         _("Key Generation Wizard"), MB_WARN);
                return FALSE;
            }
            if (!GetDlgItemText(dlg, IDC_KEYWIZARD_EMAIL, email, sizeof email-1 )
                || check_email_address (email)) { 
                msg_box (dlg, _("Please enter a valid email address."), 
                         _("Key Generation Wizard"), MB_ERR);
                return FALSE;
            }
            if (strchr (email, '<') || strchr (email, '>')) {
                msg_box (dlg, _("Please do not add '<' or '>' to the email address."),
                         _("Key Generation Wizard"), MB_WARN);
                return FALSE;
            }
            pass = request_passphrase2 (_("Key Generation"), PASSDLG_STRICT, &cancel);
            if (cancel)
                return FALSE;
            utf8_name = native_to_utf8 (name);
            if (!utf8_name)
                BUG (0);
            if (IsDlgButtonChecked (dlg, IDC_KEYWIZARD_USERSA))
                pubkey_algo = GPG_KEYGEN_DSA_RSA;
            p = gpg_genkey_params (pubkey_algo, DFAULT_KEYSIZE, utf8_name, 
                                     NULL, email, NULL, pass);
            free_if_alloc (utf8_name);
            keygen_cb_dlg_create();
            err = gpg_genkey (p, keygen_cb, &fpr);
            keygen_cb_dlg_destroy();
            keygen_cb (NULL, NULL, 0, 0, 0);
            if (p) {
                wipememory (p, strlen (p));
                free_if_alloc (p);
            }
            sfree_if_alloc (pass);
            if (err) {
                msg_box (dlg, gpgme_strerror( err ), _("Key Generation Wizard"), MB_ERR);
                free_if_alloc (fpr);
                return FALSE;
            }
            status_box( dlg, _("Key Generation completed"), _("GnuPG Status") );
            
            keycache_update (0, fpr);
            keycache_update (1, fpr);
            free_if_alloc (fpr);

            backup_keyrings (dlg);
            if (ctx)
                ctx->cancel = 0;            
            EndDialog (dlg, TRUE);
            break;

        case IDCANCEL:
            if (ctx)
                ctx->cancel = 1;
            EndDialog (dlg, FALSE);
            break;
        }
        break;
    }
    return FALSE;
}
1	werner	36	/* wptKeygenDlg.cpp - Key Generation dialog
2			* Copyright (C) 2000-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			#ifdef HAVE_CONFIG_H
21			#include <config.h>
22			#endif
23
24			#include <windows.h>
25
26	werner	47	#include "resource.h"
27	werner	36	#include "wptTypes.h"
28			#include "wptNLS.h"
29			#include "wptGPG.h"
30			#include "wptCommonCtl.h"
31			#include "wptContext.h" /* for passphrase_s */
32			#include "wptDlgs.h"
33			#include "wptW32API.h"
34			#include "wptVersion.h"
35			#include "wptErrors.h"
36			#include "wptUTF8.h"
37
38			/* All valid key generation combination. */
39			enum gpg_keytype_t {
40			GPG_KEYGEN_NONE = 0,
41			GPG_KEYGEN_DSA_ELG = 1,
42			GPG_KEYGEN_DSA_RSA = 2,
43			GPG_KEYGEN_DSA_SIG = 3,
44			GPG_KEYGEN_RSA_SIG = 4,
45			GPG_KEYGEN_RSA = 5,
46			GPG_KEYGEN_RSA_RSA = 6 /PGP/
47			};
48
49
50			static const char key_params[] =
51			"<GnupgKeyParms format=\"internal\">\n"
52			"Key-Type: %s\n"
53			"Key-Usage: sign\n"
54			"Key-Length: %d\n"
55			"Subkey-Type: %s\n"
56			"Subkey-Length: %d\n"
57			"Name-Real: %s\n"
58			"Name-Email: %s\n"
59			"Expire-Date: %s\n"
60			"Passphrase: %s\n"
61			"</GnupgKeyParms>\n";
62
63			static const char key_params_with_comment[] =
64			"<GnupgKeyParms format=\"internal\">\n"
65			"Key-Type: %s\n"
66			"Key-Usage: sign\n"
67			"Key-Length: %d\n"
68			"Subkey-Type: %s\n"
69			"Subkey-Length: %d\n"
70			"Name-Real: %s\n"
71			"Name-Comment: %s\n"
72			"Name-Email: %s\n"
73			"Expire-Date: %s\n"
74			"Passphrase: %s\n"
75			"</GnupgKeyParms>\n";
76
77			static const char key_params_one[] =
78			"<GnupgKeyParms format=\"internal\">\n"
79			"Key-Type: %s\n"
80			"Key-Length: %d\n"
81			"Key-Usage: %s\n"
82			"Name-Real: %s\n"
83			"Name-Email: %s\n"
84			"Expire-Date: %s\n"
85			"Passphrase: %s\n"
86			"</GnupgKeyParms>\n";
87
88			static const char key_params_one_with_comment[] =
89			"<GnupgKeyParms format=\"internal\">\n"
90			"Key-Type: %s\n"
91			"Key-Length: %d\n"
92			"Key-Usage: %s\n"
93			"Name-Real: %s\n"
94			"Name-Comment: %s\n"
95	twoaday	201	"Name-Email: %s\n"
96	werner	36	"Expire-Date: %s\n"
97			"Passphrase: %s\n"
98			"</GnupgKeyParms>\n";
99
100
101			/* Generate the GPG specific genkey params with the given information.
102			@keytype: See valid combinations.
103			@bits: Length in bits.
104			@user: user-ID name
105			@comment: comment for the user-ID.
106			@email: email address.
107			@expdata: date of expiration or NULL.
108			@passphrase: the actual passphrase.
109			Return value: the gen. params. */
110			static char*
111			gpg_genkey_params (int keytype, int bits,
112			const char user, const char comment, const char *email,
113			const char expdate, const char passphrase)
114			{
115			char *p = NULL;
116			int addsize = strlen ("sign encrypt");
117			int size = 0;
118
119			if (keytype == GPG_KEYGEN_NONE)
120			return NULL;
121
122	twoaday	130	size = strlen (user) + strlen (email) + strlen (passphrase) + addsize + 48;
123			if (comment && *comment)
124			size += strlen (key_params_with_comment) + strlen (comment);
125			else
126			size += strlen (key_params);
127			if (expdate)
128			size += strlen (expdate) + 1;
129	twoaday	201	p = new char[size+1];
130	twoaday	130	if (!p)
131			BUG (0);
132			/* XXX: simply the whole switch-case code. */
133			if (comment && *comment) {
134	werner	36	switch( keytype ) {
135			case GPG_KEYGEN_DSA_ELG:
136			sprintf (p, key_params_with_comment,
137			"DSA", 1024, "ELG-E", bits, user, comment, email,
138			expdate ? expdate : "0", passphrase);
139			break;
140
141			case GPG_KEYGEN_DSA_RSA:
142			sprintf( p, key_params_with_comment,
143			"DSA", 1024, "RSA", bits, user, comment, email,
144			expdate ? expdate : "0", passphrase );
145			break;
146
147			case GPG_KEYGEN_DSA_SIG:
148			sprintf( p, key_params_one_with_comment,
149			"DSA", 1024, "sign",
150			user, comment, email,
151			expdate ? expdate : "0", passphrase );
152			break;
153
154			case GPG_KEYGEN_RSA_SIG:
155			sprintf( p, key_params_one_with_comment,
156			"RSA", bits, "sign",
157			user, comment, email,
158			expdate ? expdate : "0", passphrase );
159			break;
160
161			case GPG_KEYGEN_RSA:
162			sprintf( p, key_params_one_with_comment,
163			"RSA", bits, "sign encrypt",
164			user, comment, email,
165			expdate ? expdate : "0", passphrase );
166			break;
167
168			case GPG_KEYGEN_RSA_RSA:
169			sprintf( p, key_params_with_comment,
170			"RSA", bits, "RSA", bits, user, comment, email,
171			expdate? expdate : "0", passphrase );
172			break;
173
174			default:
175	twoaday	201	free_if_alloc (p);
176	werner	36	break;
177			}
178			}
179			else {
180			switch ( keytype ) {
181			case GPG_KEYGEN_DSA_ELG:
182			sprintf( p, key_params,
183			"DSA", 1024, "ELG-E", bits, user, email,
184			expdate ? expdate : "0", passphrase );
185			break;
186
187			case GPG_KEYGEN_DSA_RSA:
188			sprintf( p, key_params,
189			"DSA", 1024, "RSA", bits, user, email,
190			expdate ? expdate : "0", passphrase );
191			break;
192
193			case GPG_KEYGEN_DSA_SIG:
194			sprintf( p, key_params_one,
195			"DSA", 1024, "sign",
196			user, email,
197			expdate ? expdate : "0", passphrase );
198			break;
199
200			case GPG_KEYGEN_RSA_SIG:
201			sprintf( p, key_params_one,
202			"RSA", bits, "sign",
203			user, email,
204			expdate ? expdate : "0", passphrase );
205			break;
206
207			case GPG_KEYGEN_RSA:
208			sprintf( p, key_params_one,
209			"RSA", bits, "sign encrypt",
210			user, email,
211			expdate ? expdate : "0", passphrase );
212			break;
213
214			case GPG_KEYGEN_RSA_RSA:
215			sprintf( p, key_params,
216			"RSA", bits, "RSA", bits, user, email,
217			expdate? expdate : "0", passphrase );
218			break;
219
220			default:
221	twoaday	201	free_if_alloc (p);
222	werner	36	break;
223			}
224			}
225			return p;
226	twoaday	32	}
227	werner	36
228
229			/* Generate a key with the given params @params. @prog_cb is a user defined
230			progress callback which is called during the generation.
231			@fpr will store the fingerprint of the generated key.
232			Return value: 0 on success. */
233			gpgme_error_t
234			gpg_genkey (const char params, gpgme_progress_cb_t prog_cb, char *fpr)
235			{
236			gpgme_error_t err = 0;
237			gpgme_ctx_t ctx;
238			gpgme_genkey_result_t res;
239
240			err = gpgme_new(&ctx);
241			if (err)
242			return err;
243			if (prog_cb)
244			gpgme_set_progress_cb (ctx, prog_cb, NULL);
245			err = gpgme_op_genkey (ctx, params, NULL, NULL);
246			if (!err) {
247			res = gpgme_op_genkey_result (ctx);
248	twoaday	201	*fpr = res->fpr? m_strdup (res->fpr) : NULL;
249	werner	36	}
250			gpgme_release (ctx);
251			return err;
252			}
253
254
255
256			/* Clear all dialog fields. */
257			static void
258			clear_dlg_fields (HWND dlg)
259			{
260			SetDlgItemText (dlg, IDC_KEYGEN_SUBKEYBITS, "");
261			SetDlgItemText (dlg, IDC_KEYGEN_NAME, "");
262			SetDlgItemText (dlg, IDC_KEYGEN_EMAIL, "");
263			SetDlgItemText (dlg, IDC_KEYGEN_COMMENT, "");
264			SetDlgItemText (dlg, IDC_KEYGEN_EXPDATE, "");
265			SetDlgItemText (dlg, IDC_KEYGEN_PASSPHRASE, "");
266			SetDlgItemText (dlg, IDC_KEYGEN_PWDCHECK, "");
267			}
268
269
270			/* Ask the user if a keyring backup is wanted and if so,
271			backup both keyrings to the selected folder. @dlg is
272			the handle of the parent window.*/
273			static void
274			backup_keyrings (HWND dlg)
275			{
276	twoaday	130	const char *name;
277			char *path = NULL;
278			char *keyring = NULL;
279	werner	36	int id;
280
281			path = get_gnupg_path ();
282			if (!path)
283			BUG (dlg);
284			id = msg_box (dlg,
285			_("It is STRONGLY recommend that you backup your keyrings because they both "
286			"contain VERY important data.\nRemember that your hard disk can crash or the "
287			"files can be deleted by accident; so it is a good\nidea to store them on "
288			"a different mass stoarge like a floppy or CDR!\n\n"
289			"Backup your keyrings now?"),
290			_("WARNING - Important hint" ), MB_YESNO);
291			if (id == IDYES) {
292	twoaday	130	name = get_filesave_dlg (dlg, _("Destination for Public Keyring"),
293			NULL, "pubring.gpg");
294	werner	36	if( name ) {
295	twoaday	130	keyring = make_filename (path, "pubring", "gpg");
296			if( !CopyFile (keyring, name, FALSE))
297			log_box (_("Key Generation"), MB_ERR,
298			_("Could not copy %s -> %s"), keyring, name);
299			free_if_alloc (keyring);
300	werner	36	}
301	twoaday	130	name = get_filesave_dlg (dlg, _("Destination for Secret Keyring"),
302			NULL, "secring.gpg");
303	werner	36	if( name ) {
304	twoaday	130	keyring = make_filename (path, "secring", "gpg");
305			if (!CopyFile (keyring, name, FALSE))
306			log_box (_("Key Generation"), MB_ERR,
307			_("Could not copy %s -> %s"), keyring, name);
308			free_if_alloc (keyring);
309	werner	36	}
310			}
311	twoaday	130	free_if_alloc (path);
312	werner	36	}
313
314
315			/* Fill in all valid GPG algorithms. */
316			static void
317			fill_keytype_box (HWND dlg)
318			{
319	twoaday	130	HWND cb = GetDlgItem (dlg, IDC_KEYGEN_KEYTYPE);
320	werner	36
321	twoaday	130	#define addstr(cb, str) \
322			SendMessage ((cb), CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)(str))
323			addstr (cb, _("DSA and ELG (default)"));
324			addstr (cb, _("DSA and RSA"));
325			addstr (cb, _("DSA sign only"));
326			addstr (cb, _("RSA sign only"));
327			addstr (cb, _("RSA sign and encrypt"));
328			addstr (cb, _("RSA and RSA (PGP)") );
329			SendMessage (cb, CB_SETCURSEL, 0, 0);
330	werner	36	#undef addstr
331			}
332
333
334			/* Check that the given date lies not in the past.
335			Return value: 1 on success. */
336			int
337			keygen_check_date (SYSTEMTIME *st)
338			{
339			SYSTEMTIME t;
340
341			GetSystemTime (&t);
342			if (st->wYear > t.wYear \|\| st->wMonth > t.wMonth)
343			return 1;
344			else if (st->wYear < t.wYear \|\| st->wMonth < t.wMonth \|\| st->wDay < t.wDay)
345	twoaday	130	return 0;
346	werner	36	return 1;
347			}
348
349
350			/* Dialog box procedure for key generation. */
351			BOOL CALLBACK
352			keygen_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
353			{
354			static genkey_s *ctx;
355			SYSTEMTIME st;
356			gpgme_error_t err;
357			char name[128] = {0}, email[128] = {0}, comment[128] = {0};
358	twoaday	130	char *pwd;
359	werner	36	char t[64], expire = NULL, fpr=NULL;
360	twoaday	130	int bits, use_comment, keytype = 0;
361			int cancel = 0;
362			char *p;
363	werner	36
364			switch ( msg ) {
365			case WM_INITDIALOG:
366	twoaday	73	if (lparam != 0)
367	werner	36	ctx = (genkey_s *)lparam;
368	twoaday	130	SetWindowText (dlg, _("Key Generation"));
369			SetDlgItemText(dlg, IDC_KEYGEN_INFO,
370	werner	36	_("NOTE: Key generation can be a lengthy process! Please wait until "
371	twoaday	130	"you get the message that key generation was finished."));
372			SetDlgItemText (dlg, IDC_KEYGEN_SUBKEYINF, _("Subkey size in &bits"));
373			SetDlgItemText (dlg, IDC_KEYGEN_NAMEINF, _("&Real name"));
374			SetDlgItemText (dlg, IDC_KEYGEN_COMMINF, _("&Comment (optional)"));
375			SetDlgItemText (dlg, IDC_KEYGEN_EMAILINF, _("Email &address"));
376			SetDlgItemText (dlg, IDC_KEYGEN_EXPINF, _("&Expire date"));
377			SetDlgItemText (dlg, IDC_KEYGEN_KEYTYPEINF, _("Key &type"));
378	werner	36	SetDlgItemText (dlg, IDC_KEYGEN_EXPNEVER, _("&Never"));
379	twoaday	101	SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
380	werner	36
381	twoaday	130	SetDlgItemInt (dlg, IDC_KEYGEN_SUBKEYBITS, DFAULT_KEYSIZE, FALSE);
382	werner	36	CheckDlgButton (dlg, IDC_KEYGEN_HIDEPWD, BST_CHECKED);
383			CheckDlgButton (dlg, IDC_KEYGEN_EXPNEVER, BST_CHECKED);
384			EnableWindow (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), FALSE);
385			fill_keytype_box (dlg);
386			center_window (dlg, NULL);
387			SetForegroundWindow (dlg);
388			return TRUE;
389
390			case WM_SYSCOMMAND:
391	twoaday	130	if (LOWORD (wparam) == SC_CLOSE)
392	werner	36	EndDialog (dlg, TRUE);
393			return FALSE;
394
395			case WM_COMMAND:
396			if (HIWORD (wparam) == BN_CLICKED &&
397			LOWORD (wparam) == IDC_KEYGEN_EXPNEVER) {
398			int never = IsDlgButtonChecked (dlg, IDC_KEYGEN_EXPNEVER);
399			EnableWindow (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), !never);
400			}
401
402	twoaday	130	switch (LOWORD (wparam)) {
403	werner	36	case IDOK:
404			bits = GetDlgItemInt (dlg, IDC_KEYGEN_SUBKEYBITS, NULL, FALSE);
405			if (bits < 1024 \|\| bits > 4096) {
406			msg_box (dlg, _("Invalid value. Allowed values 1024-4096 bits."),
407			_("Key Generation"), MB_ERR);
408			return FALSE;
409			}
410			if (bits > DFAULT_KEYSIZE) {
411	twoaday	130	int id = msg_box (dlg, _("Do you really need such a large key?"),
412	werner	36	_("Key Generation"), MB_YESNO);
413			if (id == IDNO)
414			bits = DFAULT_KEYSIZE;
415			}
416	twoaday	130	if (!GetDlgItemText (dlg, IDC_KEYGEN_NAME, name, sizeof (name) - 1)) {
417			msg_box( dlg, _("Please enter the name."), _("Key Generation"), MB_ERR);
418	werner	36	return FALSE;
419			}
420			if (strchr (name, '@')) {
421			msg_box (dlg, _("Please do not enter the email address in the name field."),
422			_("Key Generation"), MB_INFO);
423			return FALSE;
424			}
425	twoaday	130	if (!GetDlgItemText (dlg, IDC_KEYGEN_EMAIL, email, sizeof (email) -1)
426	twoaday	190	\|\| check_email_address (email)) {
427	twoaday	130	msg_box (dlg, _("Please enter a valid email address."),
428			_("Key Generation"), MB_ERR);
429	werner	36	return FALSE;
430			}
431	twoaday	130	use_comment = GetDlgItemText(dlg, IDC_KEYGEN_COMMENT,
432			comment, sizeof (comment) -1);
433			if (use_comment > 0 && strchr (comment, '@')) {
434			msg_box (dlg, _("Please do NOT enter the email address in the comment field."),
435			_("Key Generation"), MB_INFO);
436	werner	36	return FALSE;
437			}
438			keytype = SendDlgItemMessage (dlg, IDC_KEYGEN_KEYTYPE, CB_GETCURSEL, 0, 0) + 1;
439			if (IsDlgButtonChecked (dlg, IDC_KEYGEN_EXPNEVER))
440			expire = NULL;
441			else {
442			DateTime_GetSystemtime (GetDlgItem (dlg, IDC_KEYGEN_EXPDATE), &st);
443			_snprintf (t, DIM (t)-1, "%04d-%02d-%02d", st.wYear, st.wMonth, st.wDay);
444			expire = t;
445			}
446	twoaday	130
447			pwd = request_passphrase2 (_("Key Generation"), PASSDLG_STRICT, &cancel);
448			if (cancel) {
449			sfree_if_alloc (pwd);
450			return FALSE;
451			}
452			if (!pwd) {
453			msg_box (dlg, _("Please enter the passphrase."),
454			_("Key Generation"), MB_ERR);
455	werner	36	return FALSE;
456			}
457	twoaday	130
458			if (!use_comment && !strlen (comment)) {
459	werner	36	char *utf8_name;
460	twoaday	187	utf8_name = native_to_utf8 (name);
461	twoaday	130	if (!utf8_name)
462			BUG (0);
463			p = gpg_genkey_params (keytype, bits, utf8_name, NULL,
464			email, expire, pwd);
465	twoaday	201	free_if_alloc (utf8_name);
466	werner	36	}
467			else {
468			char utf8_name, utf8_comment;
469	twoaday	187	utf8_name = native_to_utf8 (name);
470			utf8_comment = native_to_utf8 (comment);
471	twoaday	190	if( !utf8_name \|\| !utf8_comment )
472	twoaday	130	BUG (0);
473			p = gpg_genkey_params (keytype, bits, utf8_name, utf8_comment,
474			email, expire, pwd);
475	twoaday	201	free_if_alloc (utf8_name);
476			free_if_alloc (utf8_comment);
477	werner	36	}
478	twoaday	130	keygen_cb_dlg_create ();
479	werner	36	err = gpg_genkey (p, keygen_cb, &fpr);
480	twoaday	130	sfree_if_alloc (pwd);
481	twoaday	115	if (p) {
482	werner	36	wipememory (p, strlen (p)); /* burn the passphrase! */
483	twoaday	201	free_if_alloc (p);
484	werner	36	}
485			keygen_cb_dlg_destroy ();
486			keygen_cb (NULL, NULL, 0, 0, 0); /* flush */
487	twoaday	115	if (err) {
488	twoaday	201	free_if_alloc (fpr);
489	twoaday	115	msg_box (dlg, gpgme_strerror (err), _("Key Generation"), MB_ERR);
490	werner	36	return FALSE;
491			}
492	twoaday	115	status_box (dlg, _("Key Generation completed"), _("GnuPG Status"));
493	werner	36
494			keycache_update (0, fpr);
495			keycache_update (1, fpr);
496	twoaday	201	free_if_alloc (fpr);
497	werner	36
498			clear_dlg_fields (dlg);
499			backup_keyrings (dlg);
500	twoaday	150	if (ctx)
501			ctx->cancel = 0;
502	werner	36	EndDialog (dlg, TRUE);
503			return TRUE;
504
505			case IDCANCEL:
506	twoaday	150	if (ctx)
507			ctx->cancel = 1;
508			EndDialog (dlg, FALSE);
509	werner	36	return FALSE;
510			}
511			break;
512			}
513
514			return FALSE;
515			}
516
517
518			BOOL CALLBACK
519			keygen_wizard_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
520			{
521			static genkey_s *ctx;
522			static int pubkey_algo = GPG_KEYGEN_DSA_ELG;
523			gpgme_error_t err;
524			char name[128], email[128];
525			char * utf8_name, * p, *fpr=NULL;
526			char * pass = NULL;
527			int cancel = 0;
528
529
530			switch( msg ) {
531			case WM_INITDIALOG:
532			ctx = (genkey_s *)lparam;
533			if (!ctx \|\| (ctx && ctx->interactive == 0))
534			EnableWindow (GetDlgItem (dlg, IDC_KEYWIZARD_EXPERT), FALSE);
535			SetDlgItemText (dlg, IDC_KEYWIZARD_USERSA, _("&Prefer RSA keys"));
536			SetDlgItemText (dlg, IDC_KEYWIZARD_NAMEINF, _("Real name:"));
537			SetDlgItemText (dlg, IDC_KEYWIZARD_EMAILINF, _("Email address:"));
538			SetDlgItemText (dlg, IDC_KEYWIZARD_TITLEINF, _("Name and E-Mail Assignment"));
539			SetDlgItemText (dlg, IDC_KEYWIZARD_TEXT1INF, _("Every key pair must have a name associated with it. The name and\nemail address let your correspondents that your public key they are\nusing belongs to us."));
540			SetDlgItemText (dlg, IDC_KEYWIZARD_TEXT2INF, _("By accosiating an email address with your key pair, you will enable WinPT to assist your correspondents in selecting the correct public\nkey when communicating with you."));
541			SetWindowText (dlg, _("Key Generation Wizard"));
542	twoaday	105	SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
543			SetDlgItemText (dlg, IDC_KEYWIZARD_EXPERT, _("E&xpert"));
544	werner	36	SetForegroundWindow (dlg);
545			center_window (dlg, NULL);
546			break;
547
548			case WM_SYSCOMMAND:
549			if( LOWORD( wparam ) == SC_CLOSE )
550			EndDialog( dlg, FALSE );
551
552			case WM_COMMAND:
553			switch( LOWORD( wparam ) ) {
554			case IDC_KEYWIZARD_EXPERT:
555			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_KEYGEN, dlg,
556	twoaday	73	keygen_dlg_proc, 0);
557	werner	36	EndDialog (dlg, TRUE);
558			break;
559
560			case IDOK:
561			if( !GetDlgItemText( dlg, IDC_KEYWIZARD_NAME, name, sizeof name-1 ) ) {
562			msg_box( dlg, _("Please enter the name."),
563			_("Key Generation Wizard"), MB_ERR );
564			return FALSE;
565			}
566			if (strchr (name, '@')) {
567			msg_box (dlg, _("Please do not enter the email address in the name field."),
568			_("Key Generation Wizard"), MB_WARN);
569			return FALSE;
570			}
571	twoaday	190	if (!GetDlgItemText(dlg, IDC_KEYWIZARD_EMAIL, email, sizeof email-1 )
572			\|\| check_email_address (email)) {
573			msg_box (dlg, _("Please enter a valid email address."),
574			_("Key Generation Wizard"), MB_ERR);
575	werner	36	return FALSE;
576			}
577			if (strchr (email, '<') \|\| strchr (email, '>')) {
578			msg_box (dlg, _("Please do not add '<' or '>' to the email address."),
579			_("Key Generation Wizard"), MB_WARN);
580			return FALSE;
581			}
582			pass = request_passphrase2 (_("Key Generation"), PASSDLG_STRICT, &cancel);
583			if (cancel)
584			return FALSE;
585	twoaday	187	utf8_name = native_to_utf8 (name);
586	twoaday	190	if (!utf8_name)
587			BUG (0);
588	werner	36	if (IsDlgButtonChecked (dlg, IDC_KEYWIZARD_USERSA))
589			pubkey_algo = GPG_KEYGEN_DSA_RSA;
590			p = gpg_genkey_params (pubkey_algo, DFAULT_KEYSIZE, utf8_name,
591			NULL, email, NULL, pass);
592	twoaday	201	free_if_alloc (utf8_name);
593	werner	36	keygen_cb_dlg_create();
594			err = gpg_genkey (p, keygen_cb, &fpr);
595			keygen_cb_dlg_destroy();
596	twoaday	201	keygen_cb (NULL, NULL, 0, 0, 0);
597			if (p) {
598			wipememory (p, strlen (p));
599			free_if_alloc (p);
600	werner	36	}
601			sfree_if_alloc (pass);
602	twoaday	201	if (err) {
603			msg_box (dlg, gpgme_strerror( err ), _("Key Generation Wizard"), MB_ERR);
604			free_if_alloc (fpr);
605	werner	36	return FALSE;
606			}
607			status_box( dlg, _("Key Generation completed"), _("GnuPG Status") );
608
609			keycache_update (0, fpr);
610			keycache_update (1, fpr);
611	twoaday	201	free_if_alloc (fpr);
612	twoaday	150
613	werner	36	backup_keyrings (dlg);
614	twoaday	150	if (ctx)
615			ctx->cancel = 0;
616	werner	36	EndDialog (dlg, TRUE);
617			break;
618
619			case IDCANCEL:
620	twoaday	150	if (ctx)
621			ctx->cancel = 1;
622			EndDialog (dlg, FALSE);
623	werner	36	break;
624			}
625			break;
626			}
627			return FALSE;
628			}