trunk/Src/WinPT.cpp

/* WinPT.cpp - Windows Privacy Tray (WinPT)
 *      Copyright (C) 2000-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 <shlobj.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptGPG.h"
#include "wptRegistry.h"
#include "wptCommonCtl.h"
#include "wptDlgs.h"
#include "wptNLS.h"
#include "wptKeyserver.h"
#include "wptCard.h"
#include "wptFileManager.h"
#include "wptContext.h"
#include "wptCardEdit.h"
#include "wptCrypto.h"

void remove_crit_file_attrs (const char *fname, int force);


HINSTANCE glob_hinst;   /* global instance for the dialogs */
HWND glob_hwnd;         /* global window handle for the dialogs */
HWND activ_hwnd;
int scard_support = 0;
int debug = 0;
int mobile = 0;
int gpg_read_only = 0;
char gpgver[3];


/* Load the key cache and rebuild the signature cache. */
static void
update_keycache (HWND hwnd)
{
    refresh_cache_s rcs = {0};
    rcs.kr_reload = 0; 
    rcs.kr_update = 1;
    rcs.tr_update = 1;
    DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
                    keycache_dlg_proc, (LPARAM)&rcs);
}


/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
void
gpg_set_debug_mode (int val)
{       
    if (val)
        putenv ("GPGME_DEBUG=5:gpgme.dbg");
    else
        putenv ("GPGME_DEBUG=");
}


/* Return the name of the gettext language file. */
static char*
get_gettext_lang (void)
{    
    char *fname;
    fname = get_reg_entry_mo ();
    if (!fname)
        return NULL;
    return fname;
}


/* Initialize the gettext sub system. */
static void
load_gettext (int prev_inst)
{
    char *nls = NULL;

    nls = get_gettext_lang ();
    if (nls != NULL) {
        set_gettext_file ("winpt", nls);
        free_if_alloc (nls);
    }
}


/* Return true if the GPG environment is useable. */
static bool
gpg_prefs_ok (void)
{
    char *p;

    p = get_reg_entry_gpg4win ("gpg.exe");
    if (!p || file_exist_check (p) != 0) {
        free_if_alloc (p);
        p = get_reg_entry_gpg ("gpgProgram");
        if (!p || file_exist_check (p) != 0) {
            free_if_alloc (p);
            return false;
        }
    }
    free_if_alloc (p);
    p = get_reg_entry_gpg4win (NULL);    
    if (!p || dir_exist_check (p) != 0) {
        free_if_alloc (p);
        p = get_reg_entry_gpg ("HomeDir");
        if (!p || dir_exist_check (p) != 0) {
            free_if_alloc (p);
            return false;
        }
    }
    free_if_alloc (p);
    return true;
}


/* Check gpg files if they are read-only and ask the user
   if this should be corrected. */
static void
check_readonly_attr (const char *homedir)
{
    const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
    char *file;
    int i;

    for (i=0; files[i] != NULL; i++) {
        file = make_filename (homedir, files[i], NULL);
        remove_crit_file_attrs (file, 0);
        free_if_alloc (file);
    }
}


/* Load the GPG environment. On the first start, some
   checks are performed to find out in what state GPG is.
   Return value: 0  everything OK.
                 >0  fatal error.
                 -1 public keyring is empty or does not exist. */
static int
load_gpg_env (void)
{
    SECURITY_ATTRIBUTES sec_attr;
    char *p;
    char *pkr;

    p = get_reg_entry_gpg4win ("gpg.exe");
    if (!p)
        return (1);
    if (file_exist_check (p)) {
        free_if_alloc (p);
        return (1);
    }
    free_if_alloc (p);

    p = get_reg_entry_gpg ("HomeDir");
    if (!p || dir_exist_check (p) != 0) {
        free_if_alloc (p);
        p = multi_gnupg_path (0);
    }
    if (p && dir_exist_check (p)) {
        memset (&sec_attr, 0, sizeof (sec_attr));
        sec_attr.nLength = sizeof (sec_attr);
        if (!CreateDirectory (p, &sec_attr)) {
            msg_box (NULL, _("Could not create GPG home directory"), 
                     _("WinPT Error"), MB_ERR);
            free_if_alloc (p);
            return (2);
        }
    }
    check_readonly_attr (p);
    pkr = make_filename (p, "pubring", "gpg");
    free_if_alloc (p);
    if (!pkr)
        return -1;
    if (get_file_size (pkr) == 0) {
        free_if_alloc (pkr);
        return -1;
    }
    return 0;
}


/* check if the default key from the gpg.conf file is available in the
   keyring. if not, bail out because encryption won't work properly then. */
static int
check_default_key (gpg_keycache_t kc)
{
    gpgme_key_t key;
    gpgme_error_t err = GPG_ERR_NO_ERROR;
    char *defkey;

    defkey = get_gnupg_default_key ();
    if (defkey)
        err = gpg_keycache_find_key (kc, defkey, 0, &key);
    else
        msg_box (NULL, _("No useable secret key found."), 
                 _("WinPT Error"), MB_ERR);
    free_if_alloc (defkey);
    return err? -1 : 0;
}


/* Return the WinPT program file name (with full pathname). */
static const char*
get_prog_part (const char * fname, int use_cwd)
{
    static char program[512];
    char currdir[256];
    char *cmd = NULL;
    int j;
        
    memset (currdir, 0, DIM (currdir));
    memset (program, 0, DIM (program));
        
    if (use_cwd) {
        GetCurrentDirectory (DIM (currdir)-1, currdir);
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
    } 
    else {
        cmd = GetCommandLine ();
        if (cmd == NULL)
            return NULL;
        strncpy (currdir, cmd, sizeof (currdir)-1);
        j = strlen (currdir);
        while (j--) {
            if (currdir[j] == '\\')
                break;
        }
        currdir[j] = 0;
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
    }
    return program;
}


/* Check that the underlying crypto engine fullfills the minimal
   requirements so all commands work properly. */
static bool
check_crypto_engine (void)
{
    int ma=0, mi=0, pa=0;
    int rc;

    rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
    if (rc == -1) {
        msg_box (NULL, _("Could not read GnuPG version."), 
                 _("WinPT Error"), MB_ERR);
        return false;
    }
    else if (rc) {
        log_box (_("WinPT Error"), MB_ERR,
                 _("Sorry, you need a newer GPG version.\n"
                   "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
                   ma, mi, pa);
        return false;
    }
    /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
    if (ma > 1 || pa >= 3)    
        scard_support = 1;

    gpgver[0] = ma;
    gpgver[1] = mi;
    gpgver[2] = pa;
    return true;
}


/* Try to load the keyserver config file. If @quiet is 1
   do not show any errors. */
static int
load_keyserver_conf (int quiet)
{
    char *buf;
    const char *t;
    int rc;

    /* Create $APPDATA\winpt if needed. */
    buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
    if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
        MessageBox (NULL, _("Failed to create WinPT directory"), 
                    _("Keyserver"), MB_ERR);
        free_if_alloc (buf);
        return -1;
    }
    free_if_alloc (buf);

    /* Check for $APPDATA\winpt\keyserver.conf */
    buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);

    if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
        t = get_prog_part ("keyserver.conf", 0);
    else
        t = "keyserver.conf";
    if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
        //log_box (_("Keyserver"), MB_INFO, 
        //       _("keyserver.conf will be copied to \"%s\"\r\n"), buf);
        if (!CopyFile (t, buf, FALSE)) {
            MessageBox (NULL, _("Failed to copy the keyserver.conf"), 
                        _("Keyserver"), MB_ERR);
            free_if_alloc (buf);
            return -1;
        }
        t = buf;
    }
    else
        t = buf;
    
    rc = kserver_load_conf (t);
    if (rc && !quiet)
        msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
    else {
        free_if_alloc (reg_prefs.kserv_conf);
        reg_prefs.kserv_conf = m_strdup (t);
    }
    free_if_alloc (buf);
    return rc;
}


/* Check if both keyrings are empty. This indicates that
   WinPT should offer to generate a key pair. */
static bool
check_for_empty_keyrings (bool pub_only)
{
    char *p;
    int n = 0;

    p = get_gnupg_keyring (1, 0);
    if (file_exist_check (p) == 0 && get_file_size (p) == 0)
        n++;
    free_if_alloc (p);
    if (pub_only)
        return n == 1? true : false;
    p = get_gnupg_keyring (0, 0);
    if (file_exist_check (p) == 0 && get_file_size (p) == 0)
        n++;
    free_if_alloc (p);
    return n==2? true : false;
}


/* Enable the mobility mode. */
static void
enable_mobile_mode (void)
{
    memset (&reg_prefs, 0, sizeof (reg_prefs));
    reg_prefs.always_trust = 0;
    reg_prefs.auto_backup = 0;
    reg_prefs.cache_time = 0;
    reg_prefs.expert = 0;
    reg_prefs.keylist_mode = 1;
    reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
    reg_prefs.no_zip_mmedia = 1;
    reg_prefs.use_tmpfiles = 1;
    reg_prefs.word_wrap = 80;
    reg_prefs.use_viewer = 0; /* XXX */
}


/* Main entry point. */
int WINAPI
WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
{
    WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
    HACCEL accel_tab;
    MSG msg;
    HWND hwnd = NULL;
    WORD ver[3], ptdver[4];
    int rc, ec, created = 0;
    int first_start = 0, start_gpgprefs = 0;
    int winpt_inst_found = 0;
    int start_manager = 0;
    const char *s;

    glob_hinst = hinst;
    if (cmdline && stristr (cmdline, "--stop")) {
        hwnd = FindWindow ("WinPT", "WinPT");
        if (hwnd != NULL)
            PostMessage (hwnd, WM_DESTROY, 0, 0);
        return 0;
    }

    /*
    OSVERSIONINFO osinf;
    memset (&osinf, 0, sizeof (osinf));
    if (GetVersionEx (&osinf) && 
        osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
        osinf.dwMinorVersion == 0) {
        msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
                 "WinPT Warning", MB_INFO);
    }
    */

    #ifdef _DEBUG
    gpg_set_debug_mode (1);
    debug = 1;
    #endif

    get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
    get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], 
                                 &ptdver[2], &ptdver[3]);
    /* XXX
    if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {
        log_box (_("WinPT Error"), MB_ERR, 
                 _("The PTD.dll file has a different version than WinPT.exe\n"
                   "Please update the PTD.dll to version %d.%d.%d"),
                   ver[0], ver[1], ver[2]);
        return 0;
    }
    */

    if (gpg_md_selftest ()) {
        msg_box (NULL, _("Cryptographic selftest failed."),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    s = gpgme_check_version (NEED_GPGME_VERSION);
    if (!s || !*s) {
        msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    CreateMutex (NULL, TRUE, PGM_NAME);
    if (GetLastError () == ERROR_ALREADY_EXISTS)
        winpt_inst_found = 1;

    if (cmdline && stristr (cmdline, "--mobile")) {
        msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!", 
                 "WinPT", MB_INFO);
        mobile = 1;
    }

    set_default_kserver ();
    load_gettext (winpt_inst_found);

    if (!mobile) {
        regist_inst_gnupg (1);
        regist_inst_winpt (1, &created);
    }
    else {
        enable_mobile_mode ();
        /* XXX: ask for GPG path */
        created = 1; /* Disable registry writing */
    }

    if (!created) {
        memset (&reg_prefs, 0, sizeof (reg_prefs));
        reg_prefs.use_tmpfiles = 1; /* default */
        reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
        get_reg_winpt_prefs (&reg_prefs);
        if (!reg_prefs.no_hotkeys)
            hotkeys_modify ();
        gnupg_load_config ();
    }
    else { /* default settings. */
        reg_prefs.keylist_mode = 1;
    }

    if (is_gpg4win_installed ())
        load_gpg_env (); /* XXX: check return code. */

    rc = gnupg_check_homedir ();
    if (rc) {
        log_box (_("WinPT Error"), MB_ERR, 
                 _("GPG home directory is not set correctly.\n"
                   "Please check the GPG registry settings:\n%s."),
                 winpt_strerror (rc));
        s = get_fileopen_dlg (GetActiveWindow (),
                              _("Select GPG Public Keyring"),
                              "GPG Keyrings (*.gpg)\0*.gpg\0\0",
                              NULL);
        if (s != NULL) {
            size_t n;
            char *p = strrchr (s, '\\');
            if (!p)
                BUG (0);
            n = p - s;
            if (n) {
                char *file = new char[n+1];
                if (!file)
                    BUG (NULL);
                memset (file, 0, n);
                memcpy (file, s, n);
                file[n] = '\0';         
                set_reg_entry_gpg ("HomeDir", file);
                free_if_alloc (file);
                gnupg_check_homedir (); /* change gpgProgram if needed */
            }
        }
        else {
            msg_box (NULL, _("GPG home directory could not be determited."),
                     _("WinPT Error"), MB_ERR);
            goto start;
        }
    }

    rc = check_gnupg_prog ();
    if (rc) {
        if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
                             "Do you want to start the GPG preferences to "
                             "correct  this problem?"), _("WinPT Error"),
                             MB_INFO|MB_YESNO) == IDYES)
            start_gpgprefs = 1;
        else {
            msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
            return 0;
        }
    }

    rc = gnupg_access_files ();
    if (!start_gpgprefs && rc) {
        if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
            ec = msg_box (NULL,
                _("Could not access and/or find the public and secret keyring.\n"
                  "If this is an accident, quit the program and fix it.\n\n"
                  "Continue if you want that WinPT offers you more choices.\n"),
                  "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES)
                first_start = 1;
        }
        if (!first_start) {
            msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
            return 0;
        }
    }
    if (check_for_empty_keyrings (false))
        first_start = 1;

    if (!first_start) {
        rc = gpg_check_permissions (1);
        if (rc && rc == 2)
            gpg_read_only = 1;
        else if (rc)
            return 0;
    }
    
    init_gnupg_table ();

    if (fm_parse_command_line (cmdline) > 0) {
        free_gnupg_table ();
        return 0;
    }

    if (cmdline && stristr (cmdline, "--wipe-freespace")) {
        dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
                            GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
                            _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
        free_gnupg_table ();
        return 0;
    }

    load_keyserver_conf (cmdline? 1 : 0);

    if (cmdline && (stristr (cmdline, "--keymanager")
                || stristr (cmdline, "--cardmanager"))) {
        /* If an instance of WinPT is running, just send the command
           to open the key manager. Otherwise start a new instance.
         */
        HWND tray = FindWindow ("WinPT", "WinPT");
        if (stristr (cmdline, "keymanager"))
            start_manager = ID_WINPT_KEY;
        else
            start_manager = ID_WINPT_CARD;
        if (tray != NULL) {
            PostMessage (tray, WM_COMMAND, start_manager, 0);
            free_gnupg_table ();
            return 0;
        }
    }

    /* If we found another WinPT instance, just quit to avoid it
       will be executed twice. */
    if (winpt_inst_found) {
        log_debug ("%s", "WinMain: WinPT is already running."); 
        free_gnupg_table ();
        return 0;
    }

    if (cmdline) {
        if (stristr (cmdline, "--enable-debug") || 
            stristr (cmdline, "--debug")) {
            gpg_set_debug_mode (1);
            winpt_debug_msg ();
            debug = 1;
        }
    }

    wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
    rc = RegisterClass (&wc);
    if (rc == FALSE) {
        msg_box (NULL, _("Could not register window class"), 
                 _("WinPT Error"), MB_ERR);
        free_gnupg_table ();
        return 0;
    }

    hwnd = CreateWindow (PGM_NAME, 
                         PGM_NAME, 
                         0, 0, 0, 0, 0, 
                         NULL, 
                         NULL, 
                         hinst, 
                         NULL);
    if (hwnd == NULL) {
        msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
        free_gnupg_table ();
        return 0;
    }
    glob_hwnd = hwnd;
    UpdateWindow (hwnd);

    if (!first_start && !start_gpgprefs) {
        gnupg_backup_options ();        
        if (!check_crypto_engine ()) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
    }
    
    if (start_gpgprefs) {
        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                        gpgprefs_dlg_proc, 0);
        if (check_for_empty_keyrings (true))
            first_start = 1; /* The public keyring is empty! */
    }

    if (first_start) {
        struct genkey_s c;
        int choice;
        HWND h;
start:
        h = GetDesktopWindow ();
        if (!gpg_prefs_ok ())
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
                            gpgprefs_dlg_proc, 0);
        choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
                                 first_run_dlg_proc, 0);
        switch (choice) {
        case SETUP_KEYGEN:
            c.interactive = 1;
            c.first_start = 1;
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
                                 h, keygen_wizard_dlg_proc, (LPARAM)&c);
            if (!rc)
                goto start;
            break;

        case SETUP_IMPORT:
            rc = gnupg_copy_keyrings ();
            if (rc) {
                msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
                goto start;
            }
            break;

        case 0: /* Cancel/Abort. */
        default:
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        update_keycache (hwnd);
        if (!check_crypto_engine ()) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
    }
    else {
        gpg_keycache_t c, sec_c;
        update_keycache (hwnd);
        c = keycache_get_ctx (1);
        if (!c || !gpg_keycache_get_size (c)) {
            gnupg_display_error ();
            msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
                             "Please check your GPG config (keyrings, pathes...)"),
                             _("WinPT Error"), MB_ERR);
            ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
                                  "Do you want to start the GPG preferences dialog?"),
                            "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES) {
                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                                gpgprefs_dlg_proc, 0);
                update_keycache (hwnd);
            }
            else {
                DestroyWindow (hwnd);
                free_gnupg_table ();
                return 0;
            }
        }
        sec_c = keycache_get_ctx (0);
        if (check_default_key (sec_c)) {
            char *p = get_gnupg_default_key ();
            log_box (_("WinPT Error"), MB_ERR, 
                     _("Default key (from the GPG config file) could not be found.\n"
                       "Please check your gpg.conf or set a new default key to correct it:\n\n"
                       "%s: public key not found."), p? p : "[null]");
            free_if_alloc (p);
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        if (count_insecure_elgkeys ())
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
                            elgamal_warn_dlg_proc, 0);
    }

    if (start_manager)
        PostMessage (hwnd, WM_COMMAND, start_manager, 0);

    accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
    keyring_check_last_access (); /* init */
    while (GetMessage (&msg, hwnd, 0, 0)) {
        if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
            TranslateMessage (&msg);
            DispatchMessage (&msg);
        }
    }
        
    return 0;
}
1	/* WinPT.cpp - Windows Privacy Tray (WinPT)
2	* Copyright (C) 2000-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 <shlobj.h>
26
27	#include "resource.h"
28	#include "wptTypes.h"
29	#include "wptW32API.h"
30	#include "wptVersion.h"
31	#include "wptErrors.h"
32	#include "wptGPG.h"
33	#include "wptRegistry.h"
34	#include "wptCommonCtl.h"
35	#include "wptDlgs.h"
36	#include "wptNLS.h"
37	#include "wptKeyserver.h"
38	#include "wptCard.h"
39	#include "wptFileManager.h"
40	#include "wptContext.h"
41	#include "wptCardEdit.h"
42	#include "wptCrypto.h"
43
44	void remove_crit_file_attrs (const char *fname, int force);
45
46
47	HINSTANCE glob_hinst; /* global instance for the dialogs */
48	HWND glob_hwnd; /* global window handle for the dialogs */
49	HWND activ_hwnd;
50	int scard_support = 0;
51	int debug = 0;
52	int mobile = 0;
53	int gpg_read_only = 0;
54	char gpgver[3];
55
56
57	/* Load the key cache and rebuild the signature cache. */
58	static void
59	update_keycache (HWND hwnd)
60	{
61	refresh_cache_s rcs = {0};
62	rcs.kr_reload = 0;
63	rcs.kr_update = 1;
64	rcs.tr_update = 1;
65	DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
66	keycache_dlg_proc, (LPARAM)&rcs);
67	}
68
69
70	/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
71	void
72	gpg_set_debug_mode (int val)
73	{
74	if (val)
75	putenv ("GPGME_DEBUG=5:gpgme.dbg");
76	else
77	putenv ("GPGME_DEBUG=");
78	}
79
80
81	/* Return the name of the gettext language file. */
82	static char*
83	get_gettext_lang (void)
84	{
85	char *fname;
86	fname = get_reg_entry_mo ();
87	if (!fname)
88	return NULL;
89	return fname;
90	}
91
92
93	/* Initialize the gettext sub system. */
94	static void
95	load_gettext (int prev_inst)
96	{
97	char *nls = NULL;
98
99	nls = get_gettext_lang ();
100	if (nls != NULL) {
101	set_gettext_file ("winpt", nls);
102	free_if_alloc (nls);
103	}
104	}
105
106
107	/* Return true if the GPG environment is useable. */
108	static bool
109	gpg_prefs_ok (void)
110	{
111	char *p;
112
113	p = get_reg_entry_gpg4win ("gpg.exe");
114	if (!p \|\| file_exist_check (p) != 0) {
115	free_if_alloc (p);
116	p = get_reg_entry_gpg ("gpgProgram");
117	if (!p \|\| file_exist_check (p) != 0) {
118	free_if_alloc (p);
119	return false;
120	}
121	}
122	free_if_alloc (p);
123	p = get_reg_entry_gpg4win (NULL);
124	if (!p \|\| dir_exist_check (p) != 0) {
125	free_if_alloc (p);
126	p = get_reg_entry_gpg ("HomeDir");
127	if (!p \|\| dir_exist_check (p) != 0) {
128	free_if_alloc (p);
129	return false;
130	}
131	}
132	free_if_alloc (p);
133	return true;
134	}
135
136
137	/* Check gpg files if they are read-only and ask the user
138	if this should be corrected. */
139	static void
140	check_readonly_attr (const char *homedir)
141	{
142	const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
143	char *file;
144	int i;
145
146	for (i=0; files[i] != NULL; i++) {
147	file = make_filename (homedir, files[i], NULL);
148	remove_crit_file_attrs (file, 0);
149	free_if_alloc (file);
150	}
151	}
152
153
154	/* Load the GPG environment. On the first start, some
155	checks are performed to find out in what state GPG is.
156	Return value: 0 everything OK.
157	>0 fatal error.
158	-1 public keyring is empty or does not exist. */
159	static int
160	load_gpg_env (void)
161	{
162	SECURITY_ATTRIBUTES sec_attr;
163	char *p;
164	char *pkr;
165
166	p = get_reg_entry_gpg4win ("gpg.exe");
167	if (!p)
168	return (1);
169	if (file_exist_check (p)) {
170	free_if_alloc (p);
171	return (1);
172	}
173	free_if_alloc (p);
174
175	p = get_reg_entry_gpg ("HomeDir");
176	if (!p \|\| dir_exist_check (p) != 0) {
177	free_if_alloc (p);
178	p = multi_gnupg_path (0);
179	}
180	if (p && dir_exist_check (p)) {
181	memset (&sec_attr, 0, sizeof (sec_attr));
182	sec_attr.nLength = sizeof (sec_attr);
183	if (!CreateDirectory (p, &sec_attr)) {
184	msg_box (NULL, _("Could not create GPG home directory"),
185	_("WinPT Error"), MB_ERR);
186	free_if_alloc (p);
187	return (2);
188	}
189	}
190	check_readonly_attr (p);
191	pkr = make_filename (p, "pubring", "gpg");
192	free_if_alloc (p);
193	if (!pkr)
194	return -1;
195	if (get_file_size (pkr) == 0) {
196	free_if_alloc (pkr);
197	return -1;
198	}
199	return 0;
200	}
201
202
203	/* check if the default key from the gpg.conf file is available in the
204	keyring. if not, bail out because encryption won't work properly then. */
205	static int
206	check_default_key (gpg_keycache_t kc)
207	{
208	gpgme_key_t key;
209	gpgme_error_t err = GPG_ERR_NO_ERROR;
210	char *defkey;
211
212	defkey = get_gnupg_default_key ();
213	if (defkey)
214	err = gpg_keycache_find_key (kc, defkey, 0, &key);
215	else
216	msg_box (NULL, _("No useable secret key found."),
217	_("WinPT Error"), MB_ERR);
218	free_if_alloc (defkey);
219	return err? -1 : 0;
220	}
221
222
223	/* Return the WinPT program file name (with full pathname). */
224	static const char*
225	get_prog_part (const char * fname, int use_cwd)
226	{
227	static char program[512];
228	char currdir[256];
229	char *cmd = NULL;
230	int j;
231
232	memset (currdir, 0, DIM (currdir));
233	memset (program, 0, DIM (program));
234
235	if (use_cwd) {
236	GetCurrentDirectory (DIM (currdir)-1, currdir);
237	_snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
238	}
239	else {
240	cmd = GetCommandLine ();
241	if (cmd == NULL)
242	return NULL;
243	strncpy (currdir, cmd, sizeof (currdir)-1);
244	j = strlen (currdir);
245	while (j--) {
246	if (currdir[j] == '\\')
247	break;
248	}
249	currdir[j] = 0;
250	_snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
251	}
252	return program;
253	}
254
255
256	/* Check that the underlying crypto engine fullfills the minimal
257	requirements so all commands work properly. */
258	static bool
259	check_crypto_engine (void)
260	{
261	int ma=0, mi=0, pa=0;
262	int rc;
263
264	rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
265	if (rc == -1) {
266	msg_box (NULL, _("Could not read GnuPG version."),
267	_("WinPT Error"), MB_ERR);
268	return false;
269	}
270	else if (rc) {
271	log_box (_("WinPT Error"), MB_ERR,
272	_("Sorry, you need a newer GPG version.\n"
273	"GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
274	ma, mi, pa);
275	return false;
276	}
277	/* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
278	if (ma > 1 \|\| pa >= 3)
279	scard_support = 1;
280
281	gpgver[0] = ma;
282	gpgver[1] = mi;
283	gpgver[2] = pa;
284	return true;
285	}
286
287
288	/* Try to load the keyserver config file. If @quiet is 1
289	do not show any errors. */
290	static int
291	load_keyserver_conf (int quiet)
292	{
293	char *buf;
294	const char *t;
295	int rc;
296
297	/* Create $APPDATA\winpt if needed. */
298	buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
299	if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
300	MessageBox (NULL, _("Failed to create WinPT directory"),
301	_("Keyserver"), MB_ERR);
302	free_if_alloc (buf);
303	return -1;
304	}
305	free_if_alloc (buf);
306
307	/* Check for $APPDATA\winpt\keyserver.conf */
308	buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
309
310	if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
311	t = get_prog_part ("keyserver.conf", 0);
312	else
313	t = "keyserver.conf";
314	if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
315	//log_box (_("Keyserver"), MB_INFO,
316	// _("keyserver.conf will be copied to \"%s\"\r\n"), buf);
317	if (!CopyFile (t, buf, FALSE)) {
318	MessageBox (NULL, _("Failed to copy the keyserver.conf"),
319	_("Keyserver"), MB_ERR);
320	free_if_alloc (buf);
321	return -1;
322	}
323	t = buf;
324	}
325	else
326	t = buf;
327
328	rc = kserver_load_conf (t);
329	if (rc && !quiet)
330	msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
331	else {
332	free_if_alloc (reg_prefs.kserv_conf);
333	reg_prefs.kserv_conf = m_strdup (t);
334	}
335	free_if_alloc (buf);
336	return rc;
337	}
338
339
340	/* Check if both keyrings are empty. This indicates that
341	WinPT should offer to generate a key pair. */
342	static bool
343	check_for_empty_keyrings (bool pub_only)
344	{
345	char *p;
346	int n = 0;
347
348	p = get_gnupg_keyring (1, 0);
349	if (file_exist_check (p) == 0 && get_file_size (p) == 0)
350	n++;
351	free_if_alloc (p);
352	if (pub_only)
353	return n == 1? true : false;
354	p = get_gnupg_keyring (0, 0);
355	if (file_exist_check (p) == 0 && get_file_size (p) == 0)
356	n++;
357	free_if_alloc (p);
358	return n==2? true : false;
359	}
360
361
362	/* Enable the mobility mode. */
363	static void
364	enable_mobile_mode (void)
365	{
366	memset (&reg_prefs, 0, sizeof (reg_prefs));
367	reg_prefs.always_trust = 0;
368	reg_prefs.auto_backup = 0;
369	reg_prefs.cache_time = 0;
370	reg_prefs.expert = 0;
371	reg_prefs.keylist_mode = 1;
372	reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
373	reg_prefs.no_zip_mmedia = 1;
374	reg_prefs.use_tmpfiles = 1;
375	reg_prefs.word_wrap = 80;
376	reg_prefs.use_viewer = 0; /* XXX */
377	}
378
379
380	/* Main entry point. */
381	int WINAPI
382	WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
383	{
384	WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
385	HACCEL accel_tab;
386	MSG msg;
387	HWND hwnd = NULL;
388	WORD ver[3], ptdver[4];
389	int rc, ec, created = 0;
390	int first_start = 0, start_gpgprefs = 0;
391	int winpt_inst_found = 0;
392	int start_manager = 0;
393	const char *s;
394
395	glob_hinst = hinst;
396	if (cmdline && stristr (cmdline, "--stop")) {
397	hwnd = FindWindow ("WinPT", "WinPT");
398	if (hwnd != NULL)
399	PostMessage (hwnd, WM_DESTROY, 0, 0);
400	return 0;
401	}
402
403	/*
404	OSVERSIONINFO osinf;
405	memset (&osinf, 0, sizeof (osinf));
406	if (GetVersionEx (&osinf) &&
407	osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
408	osinf.dwMinorVersion == 0) {
409	msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
410	"WinPT Warning", MB_INFO);
411	}
412	*/
413
414	#ifdef _DEBUG
415	gpg_set_debug_mode (1);
416	debug = 1;
417	#endif
418
419	get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
420	get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
421	&ptdver[2], &ptdver[3]);
422	/* XXX
423	if (ptdver[0] != ver[0] \|\| ptdver[1] != ver[1]\|\| ptdver[2] != ver[2]) {
424	log_box (_("WinPT Error"), MB_ERR,
425	_("The PTD.dll file has a different version than WinPT.exe\n"
426	"Please update the PTD.dll to version %d.%d.%d"),
427	ver[0], ver[1], ver[2]);
428	return 0;
429	}
430	*/
431
432	if (gpg_md_selftest ()) {
433	msg_box (NULL, _("Cryptographic selftest failed."),
434	_("WinPT Error"), MB_ERR);
435	return 0;
436	}
437
438	s = gpgme_check_version (NEED_GPGME_VERSION);
439	if (!s \|\| !*s) {
440	msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
441	_("WinPT Error"), MB_ERR);
442	return 0;
443	}
444
445	CreateMutex (NULL, TRUE, PGM_NAME);
446	if (GetLastError () == ERROR_ALREADY_EXISTS)
447	winpt_inst_found = 1;
448
449	if (cmdline && stristr (cmdline, "--mobile")) {
450	msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
451	"WinPT", MB_INFO);
452	mobile = 1;
453	}
454
455	set_default_kserver ();
456	load_gettext (winpt_inst_found);
457
458	if (!mobile) {
459	regist_inst_gnupg (1);
460	regist_inst_winpt (1, &created);
461	}
462	else {
463	enable_mobile_mode ();
464	/* XXX: ask for GPG path */
465	created = 1; /* Disable registry writing */
466	}
467
468	if (!created) {
469	memset (&reg_prefs, 0, sizeof (reg_prefs));
470	reg_prefs.use_tmpfiles = 1; /* default */
471	reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
472	get_reg_winpt_prefs (&reg_prefs);
473	if (!reg_prefs.no_hotkeys)
474	hotkeys_modify ();
475	gnupg_load_config ();
476	}
477	else { /* default settings. */
478	reg_prefs.keylist_mode = 1;
479	}
480
481	if (is_gpg4win_installed ())
482	load_gpg_env (); /* XXX: check return code. */
483
484	rc = gnupg_check_homedir ();
485	if (rc) {
486	log_box (_("WinPT Error"), MB_ERR,
487	_("GPG home directory is not set correctly.\n"
488	"Please check the GPG registry settings:\n%s."),
489	winpt_strerror (rc));
490	s = get_fileopen_dlg (GetActiveWindow (),
491	_("Select GPG Public Keyring"),
492	"GPG Keyrings (.gpg)\0.gpg\0\0",
493	NULL);
494	if (s != NULL) {
495	size_t n;
496	char *p = strrchr (s, '\\');
497	if (!p)
498	BUG (0);
499	n = p - s;
500	if (n) {
501	char *file = new char[n+1];
502	if (!file)
503	BUG (NULL);
504	memset (file, 0, n);
505	memcpy (file, s, n);
506	file[n] = '\0';
507	set_reg_entry_gpg ("HomeDir", file);
508	free_if_alloc (file);
509	gnupg_check_homedir (); /* change gpgProgram if needed */
510	}
511	}
512	else {
513	msg_box (NULL, _("GPG home directory could not be determited."),
514	_("WinPT Error"), MB_ERR);
515	goto start;
516	}
517	}
518
519	rc = check_gnupg_prog ();
520	if (rc) {
521	if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
522	"Do you want to start the GPG preferences to "
523	"correct this problem?"), _("WinPT Error"),
524	MB_INFO\|MB_YESNO) == IDYES)
525	start_gpgprefs = 1;
526	else {
527	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
528	return 0;
529	}
530	}
531
532	rc = gnupg_access_files ();
533	if (!start_gpgprefs && rc) {
534	if (rc == WPTERR_GPG_KEYRINGS \|\| rc == WPTERR_GPG_OPT_KEYRINGS) {
535	ec = msg_box (NULL,
536	_("Could not access and/or find the public and secret keyring.\n"
537	"If this is an accident, quit the program and fix it.\n\n"
538	"Continue if you want that WinPT offers you more choices.\n"),
539	"WinPT", MB_INFO\|MB_YESNO);
540	if (ec == IDYES)
541	first_start = 1;
542	}
543	if (!first_start) {
544	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
545	return 0;
546	}
547	}
548	if (check_for_empty_keyrings (false))
549	first_start = 1;
550
551	if (!first_start) {
552	rc = gpg_check_permissions (1);
553	if (rc && rc == 2)
554	gpg_read_only = 1;
555	else if (rc)
556	return 0;
557	}
558
559	init_gnupg_table ();
560
561	if (fm_parse_command_line (cmdline) > 0) {
562	free_gnupg_table ();
563	return 0;
564	}
565
566	if (cmdline && stristr (cmdline, "--wipe-freespace")) {
567	dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
568	GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
569	_("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
570	free_gnupg_table ();
571	return 0;
572	}
573
574	load_keyserver_conf (cmdline? 1 : 0);
575
576	if (cmdline && (stristr (cmdline, "--keymanager")
577	\|\| stristr (cmdline, "--cardmanager"))) {
578	/* If an instance of WinPT is running, just send the command
579	to open the key manager. Otherwise start a new instance.
580	*/
581	HWND tray = FindWindow ("WinPT", "WinPT");
582	if (stristr (cmdline, "keymanager"))
583	start_manager = ID_WINPT_KEY;
584	else
585	start_manager = ID_WINPT_CARD;
586	if (tray != NULL) {
587	PostMessage (tray, WM_COMMAND, start_manager, 0);
588	free_gnupg_table ();
589	return 0;
590	}
591	}
592
593	/* If we found another WinPT instance, just quit to avoid it
594	will be executed twice. */
595	if (winpt_inst_found) {
596	log_debug ("%s", "WinMain: WinPT is already running.");
597	free_gnupg_table ();
598	return 0;
599	}
600
601	if (cmdline) {
602	if (stristr (cmdline, "--enable-debug") \|\|
603	stristr (cmdline, "--debug")) {
604	gpg_set_debug_mode (1);
605	winpt_debug_msg ();
606	debug = 1;
607	}
608	}
609
610	wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
611	rc = RegisterClass (&wc);
612	if (rc == FALSE) {
613	msg_box (NULL, _("Could not register window class"),
614	_("WinPT Error"), MB_ERR);
615	free_gnupg_table ();
616	return 0;
617	}
618
619	hwnd = CreateWindow (PGM_NAME,
620	PGM_NAME,
621	0, 0, 0, 0, 0,
622	NULL,
623	NULL,
624	hinst,
625	NULL);
626	if (hwnd == NULL) {
627	msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
628	free_gnupg_table ();
629	return 0;
630	}
631	glob_hwnd = hwnd;
632	UpdateWindow (hwnd);
633
634	if (!first_start && !start_gpgprefs) {
635	gnupg_backup_options ();
636	if (!check_crypto_engine ()) {
637	DestroyWindow (hwnd);
638	free_gnupg_table ();
639	return 0;
640	}
641	}
642
643	if (start_gpgprefs) {
644	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
645	gpgprefs_dlg_proc, 0);
646	if (check_for_empty_keyrings (true))
647	first_start = 1; /* The public keyring is empty! */
648	}
649
650	if (first_start) {
651	struct genkey_s c;
652	int choice;
653	HWND h;
654	start:
655	h = GetDesktopWindow ();
656	if (!gpg_prefs_ok ())
657	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
658	gpgprefs_dlg_proc, 0);
659	choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
660	first_run_dlg_proc, 0);
661	switch (choice) {
662	case SETUP_KEYGEN:
663	c.interactive = 1;
664	c.first_start = 1;
665	rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
666	h, keygen_wizard_dlg_proc, (LPARAM)&c);
667	if (!rc)
668	goto start;
669	break;
670
671	case SETUP_IMPORT:
672	rc = gnupg_copy_keyrings ();
673	if (rc) {
674	msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
675	goto start;
676	}
677	break;
678
679	case 0: /* Cancel/Abort. */
680	default:
681	DestroyWindow (hwnd);
682	free_gnupg_table ();
683	return 0;
684	}
685	update_keycache (hwnd);
686	if (!check_crypto_engine ()) {
687	DestroyWindow (hwnd);
688	free_gnupg_table ();
689	return 0;
690	}
691	}
692	else {
693	gpg_keycache_t c, sec_c;
694	update_keycache (hwnd);
695	c = keycache_get_ctx (1);
696	if (!c \|\| !gpg_keycache_get_size (c)) {
697	gnupg_display_error ();
698	msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
699	"Please check your GPG config (keyrings, pathes...)"),
700	_("WinPT Error"), MB_ERR);
701	ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
702	"Do you want to start the GPG preferences dialog?"),
703	"WinPT", MB_INFO\|MB_YESNO);
704	if (ec == IDYES) {
705	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
706	gpgprefs_dlg_proc, 0);
707	update_keycache (hwnd);
708	}
709	else {
710	DestroyWindow (hwnd);
711	free_gnupg_table ();
712	return 0;
713	}
714	}
715	sec_c = keycache_get_ctx (0);
716	if (check_default_key (sec_c)) {
717	char *p = get_gnupg_default_key ();
718	log_box (_("WinPT Error"), MB_ERR,
719	_("Default key (from the GPG config file) could not be found.\n"
720	"Please check your gpg.conf or set a new default key to correct it:\n\n"
721	"%s: public key not found."), p? p : "[null]");
722	free_if_alloc (p);
723	DestroyWindow (hwnd);
724	free_gnupg_table ();
725	return 0;
726	}
727	if (count_insecure_elgkeys ())
728	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
729	elgamal_warn_dlg_proc, 0);
730	}
731
732	if (start_manager)
733	PostMessage (hwnd, WM_COMMAND, start_manager, 0);
734
735	accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
736	keyring_check_last_access (); /* init */
737	while (GetMessage (&msg, hwnd, 0, 0)) {
738	if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
739	TranslateMessage (&msg);
740	DispatchMessage (&msg);
741	}
742	}
743
744	return 0;
745	}