/[winpt]/trunk/Src/WinPT.cpp
ViewVC logotype

Diff of /trunk/Src/WinPT.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 28 by twoaday, Thu Oct 20 12:35:59 2005 UTC revision 278 by twoaday, Mon Jan 15 22:02:04 2007 UTC
# Line 1  Line 1 
1  /* WinPT.cpp - Windows Privacy Tray (WinPT)  /* WinPT.cpp - Windows Privacy Tray (WinPT)
2   *      Copyright (C) 2000-2005 Timo Schulz   *      Copyright (C) 2000-2006 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
6   * WinPT is free software; you can redistribute it and/or modify   * 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   * 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   * the Free Software Foundation; either version 2 of the License, or
9   * (at your option) any later version.   * (at your option) any later version.
10   *   *
11   * WinPT is distributed in the hope that it will be useful,   * WinPT is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   * GNU General Public License for more details.   * GNU General Public License for more details.
15   *   */
16   * You should have received a copy of the GNU General Public License  #ifdef HAVE_CONFIG_H
17   * along with WinPT; if not, write to the Free Software Foundation,  #include <config.h>
18   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA  #endif
19   */  
20  #include <windows.h>  #include <windows.h>
21    #include <shlobj.h>
22  #include "../resource.h"  
23  #include "wptTypes.h"  #include "resource.h"
24  #include "wptW32API.h"  #include "wptTypes.h"
25  #include "wptVersion.h"  #include "wptW32API.h"
26  #include "wptErrors.h"  #include "wptVersion.h"
27  #include "wptGPG.h"  #include "wptErrors.h"
28  #include "wptRegistry.h"  #include "wptGPG.h"
29  #include "wptCommonCtl.h"  #include "wptRegistry.h"
30  #include "wptDlgs.h"  #include "wptCommonCtl.h"
31  #include "wptNLS.h"  #include "wptDlgs.h"
32  #include "wptKeyserver.h"  #include "wptNLS.h"
33  #include "wptCard.h"  #include "wptKeyserver.h"
34  #include "wptFileManager.h"  #include "wptCard.h"
35  #include "wptContext.h"  #include "wptFileManager.h"
36  #include "wptCardEdit.h"  #include "wptContext.h"
37    #include "wptCardEdit.h"
38  #define MIN_GPG_VER "1.4.3"  #include "wptCrypto.h"
39    #include "wptUTF8.h"
40  HINSTANCE glob_hinst;   /* global instance for the dialogs */  
41  HWND glob_hwnd;         /* global window handle for the dialogs */  void remove_crit_file_attrs (const char *fname, int force);
42  HWND activ_hwnd;  BOOL user_is_admin (void);
43  LOCK mo_file;  int  pcsc_available (void);
44  int scard_support = 0;  
45  int debug = 0;  /* Global variables. */
46  int mobile = 0;  HINSTANCE glob_hinst;   /* global instance for the dialogs */
47  int gpg_read_only = 0;  HWND glob_hwnd;         /* global window handle for the dialogs */
48  char gpgver[3];  int scard_support = 0;
49    int debug = 0;
50    int gpg_read_only = 0;
51  /* Load the key cache and rebuild the signature cache. */  int admin_user = 0;
52  static void  char gpgver[3];
53  update_keycache (HWND hwnd)  /* End */
54  {  
55      refresh_cache_s rcs = {0};  
56      rcs.kr_reload = 0;  /* Load the key cache and rebuild the signature cache. */
57      rcs.kr_update = 1;  int
58      rcs.tr_update = 1;  update_keycache (HWND hwnd)
59      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,  {
60                      keycache_dlg_proc, (LPARAM)&rcs);      int err;
61  }      refresh_cache_s rcs;
62    
63        /* no need to rebuild the sig cache each time. */
64  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */      memset (&rcs, 0, sizeof (rcs));
65  void      rcs.kring_update = 1;
66  gpg_set_debug_mode (int val)      err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
67  {                            keycache_dlg_proc, (LPARAM)&rcs);
68      if (val)      if (err) {
69          putenv ("GPGME_DEBUG=5:gpgme.dbg");          char *cfgf = get_gnupg_config ();
70      else          if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
71          putenv ("GPGME_DEBUG=");              msg_box (NULL, _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
72  }          free_if_alloc (cfgf);
73            return -1;
74  static char *      }
75  get_gettext_lang (void)      return 0;
76  {      }
77      char * fname;  
78      fname = get_reg_entry_mo ();  
79      if (!fname)  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
80          return NULL;  void
81      return fname;  gpg_set_debug_mode (int val)
82  } /* get_gettext_lang */  {
83        static char buf[256];
84        char tmp[128];
85  static void      
86  load_gettext (void)      /* XXX: no gpgme.dbg is created. */
87  {      if (val > 0) {
88      char *nls = NULL;          GetTempPath (DIM (tmp)-1, tmp);
89      char *file = NULL;          _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
90            putenv (buf);
91      nls = get_gettext_lang ();      }
92      if (nls) {      else
93          set_gettext_file ("winpt", nls);          putenv ("GPGME_DEBUG=");
94          file = make_filename (nls, "winpt", "mo");  }
95          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {  
96              msg_box (NULL, _("Could not initizalize file lock.\n"  
97                               "Native Language Support"),  /* Initialize the gettext sub system. */
98                       _("WinPT Error"), MB_ERR);  static void
99          }  load_gettext (void)
100          free_if_alloc (nls);  {
101          free_if_alloc (file);      char *nls;
102      }  
103  } /* load_gettext */      /* Return the name of the gettext language file. */
104        nls = get_reg_entry_mo ();
105        if (nls != NULL) {
106  /* check if the default key from the gpg.conf file is available in the          gettext_set_file ("winpt", nls);
107     keyring. if not, bail out because encryption won't work properly then. */          free_if_alloc (nls);
108  static int      }
109  check_default_key (gpg_keycache_t kc)  }
110  {  
111      gpgme_key_t key;  
112      gpgme_error_t err = GPG_ERR_NO_ERROR;  /* Return true if the GPG environment is useable. */
113      char * defkey;  static bool
114    gpg_prefs_ok (void)
115      defkey = get_gnupg_default_key ();  {
116      if (defkey)      char *p;
117          err = gpg_keycache_find_key (kc, defkey, 0, &key);  
118      free_if_alloc (defkey);      p = get_reg_entry_gpg4win ("gpg.exe");
119      return err? -1 : 0;      if (!p || file_exist_check (p) != 0) {
120  } /* check_default_key */          free_if_alloc (p);
121            p = get_reg_entry_gpg ("gpgProgram");
122            if (!p || file_exist_check (p) != 0) {
123  /* Return the WinPT program file name (with full pathname). */              free_if_alloc (p);
124  static const char *              log_debug ("gpg_prefs_ok: could not locate gpg.exe");
125  get_prog_part (const char * fname, int use_cwd)              return false;
126  {          }
127      static char program[1024];      }
128      char currdir[256], * cmd = NULL;      free_if_alloc (p);
129      int j;      p = get_reg_entry_gpg4win (NULL);
130                if (!p || dir_exist_check (p) != 0) {
131      memset (currdir, 0, DIM (currdir));          free_if_alloc (p);
132      memset (program, 0, DIM (program));          p = get_reg_entry_gpg ("HomeDir");
133                    if (!p || dir_exist_check (p) != 0) {
134      if (use_cwd) {              free_if_alloc (p);
135          GetCurrentDirectory (DIM (currdir)-1, currdir);              log_debug ("gpg_prefs_ok: could not determine home directory");
136          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);              return false;
137      }          }
138      else {      }
139          cmd = GetCommandLine ();      free_if_alloc (p);
140          if (cmd == NULL)      return true;
141              return NULL;  }
142          strncpy (currdir, cmd, 255);  
143          j = strlen (currdir);  
144          while (j--) {  /* Check gpg files if they are read-only and ask the user
145              if (currdir[j] == '\\')     if this should be corrected. */
146                  break;            static void
147          }  check_readonly_attr (const char *homedir)
148          currdir[j] = 0;  {
149          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);      const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
150      }      char *file;
151      return program;      int i;
152  } /* get_prog_part */  
153        for (i=0; files[i] != NULL; i++) {
154            file = make_filename (homedir, files[i], NULL);
155  static int          remove_crit_file_attrs (file, 0);
156  check_crypto_engine (void)          free_if_alloc (file);
157  {      }
158      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */  }
159      int rc;  
160    
161      rc = check_gnupg_engine (&ma, &mi, &pa);  /* Load the GPG environment. On the first start, some
162      if (rc == -1) {     checks are performed to find out in what state GPG is.
163          msg_box (NULL, _("Could not read GnuPG version."), _("WinPT Error"), MB_ERR);     Return value: 0  everything OK.
164          return rc;                   >0  fatal error.
165      }                   -1 public keyring is empty or does not exist. */
166      else if (rc) {  static int
167          log_box (_("WinPT Error"), MB_ERR,  load_gpg_env (void)
168                   _("Sorry, you need a newer GPG version.\n"  {
169                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),      SECURITY_ATTRIBUTES sec_attr;
170                     ma, mi, pa);      char *p;
171          return rc;      char *pkr;
172      }      int err = 0;
173      /* We enable smartcard support for GPG: 1.9.x or >= 1.4.0 */  
174      if (ma >= 1 && mi >= 4)      p = get_reg_entry_gpg4win ("gpg.exe");
175          scard_support = 1;      if (!p)
176            return (1);
177      gpgver[0] = ma;      if (file_exist_check (p)) {
178      gpgver[1] = mi;          free_if_alloc (p);
179      gpgver[2] = pa;          return (1);
180      return rc;      }
181  } /* check_crypto_engine */      free_if_alloc (p);
182    
183        p = get_reg_entry_gpg ("HomeDir");
184  static int      if (!p || dir_exist_check (p) != 0) {
185  load_keyserver_conf (int quiet)          free_if_alloc (p);
186  {          p = multi_gnupg_path (0);
187      const char * t;      }
188      int rc;      if (p && dir_exist_check (p)) {
189            memset (&sec_attr, 0, sizeof (sec_attr));
190      if (reg_prefs.kserv_conf)          sec_attr.nLength = sizeof (sec_attr);
191          t = reg_prefs.kserv_conf;          if (!CreateDirectory (p, &sec_attr)) {
192      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))              msg_box (NULL, _("Could not create GPG home directory"),
193          t = get_prog_part ("keyserver.conf", 0);                       _("WinPT Error"), MB_ERR);
194      else              free_if_alloc (p);
195          t = "keyserver.conf";              return (2);
196      rc = kserver_load_conf (t);          }
197      if (rc && !quiet)      }
198          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);      check_readonly_attr (p);
199      return rc;      pkr = make_filename (p, "pubring", "gpg");
200  }      free_if_alloc (p);
201        if (get_file_size (pkr) == 0)
202            err = -1;
203  static void      free_if_alloc (pkr);
204  enable_mobile_mode (void)      return err;
205  {  }
206      memset (&reg_prefs, 0, sizeof (reg_prefs));  
207      reg_prefs.always_trust = 0;  
208      reg_prefs.auto_backup = 0;  /* check if the default key from the gpg.conf file is available in the
209      reg_prefs.cache_time = 0;     keyring. if not, bail out because encryption won't work properly then. */
210      reg_prefs.expert = 0;  static int
211      reg_prefs.keylist_mode = 1;  check_default_key (void)
212      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");  {
213      reg_prefs.no_zip_mmedia = 1;      gpgme_key_t key;
214      reg_prefs.use_tmpfiles = 1;      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
215      reg_prefs.word_wrap = 80;      gpg_keycache_t kc;
216      reg_prefs.use_viewer = 0; /* XXX */      char *defkey;
217  }  
218        kc = keycache_get_ctx (0);
219  char* get_subkey_fingerprint (gpgme_ctx_t ctx, const char *keyid);      defkey = get_gnupg_default_key ();
220        if (defkey) {
221            err = gpg_keycache_find_key (kc, defkey, 0, &key);
222  int WINAPI          if (err) {
223  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)              free_if_alloc (defkey);
224  {              return -1;
225      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};          }
226      HACCEL accel_tab;      }
227      int rc, ec, created = 0, use_cwd = 0, nfiles = 0;      else {
228      int first_start = 0, start_gpgprefs = 0;          /* Actually this is just a warning but we still continue. */
229      const char * s;          msg_box (NULL, _("No useable secret key found."),
230      MSG msg;                   _("WinPT Warning"), MB_WARN);
231      HWND hwnd = NULL;          free_if_alloc (defkey);
232            return 0;
233      glob_hinst = hinst;      }
234    
235      #ifdef _DEBUG      /* Because the secret key listing has no information
236      gpg_set_debug_mode (1);         about the validity/status, we need to check the public key. */
237      debug = 1;      kc = keycache_get_ctx (1);
238      #endif      if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
239            (key->revoked || key->expired)) {
240      s = PTD_get_version ();          msg_box (NULL, _("Default secret key is unuseable"),
241      if (strcmp (s, "0.8.0")) {                   _("WinPT Warning"), MB_ERR);
242          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,          free_if_alloc (defkey);
243                   _("Please update your PTD.dll to the newest version, "          return -1;
244                     "the version (%s) you use is too old."), s);      }
245          return 0;      free_if_alloc (defkey);
246      }      return 0;
247    }
248      if (gpg_md_selftest ()) {  
249          msg_box (NULL, _("Cryptographic selftest failed."),  
250                   _("WinPT Error"), MB_ERR);  /* Return the WinPT program file name (with full pathname). */
251          return 0;  static const char*
252      }  get_prog_part (const char *fname, int use_cwd)
253    {
254      s = gpgme_check_version ("1.1.0");      static char program[2*MAX_PATH+1];
255      if (!s || !*s) {      char currdir[MAX_PATH+1];
256          msg_box (NULL, _("A newer GPGME version is needed."), "WinPT Error", MB_ERR);      char *cmd = NULL;
257          return 0;      int j;
258      }          
259        memset (currdir, 0, DIM (currdir));
260      if (cmdline && stristr (cmdline, "--mobile")) {      memset (program, 0, DIM (program));
261          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",          
262                   "WinPT", MB_INFO);      if (use_cwd) {
263          mobile = 1;          GetCurrentDirectory (DIM (currdir)-1, currdir);
264      }          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
265        }
266      set_default_kserver ();      else {
267            cmd = GetCommandLine ();
268      if (!mobile) {          if (!cmd)
269          regist_inst_gnupg (1);              return NULL;
270          regist_inst_winpt (1, &created);          strncpy (currdir, cmd, DIM (currdir)-1);
271      }          j = strlen (currdir);
272      else {          while (j--) {
273          enable_mobile_mode ();              if (currdir[j] == '\\')
274          /* XXX: ask for GPG path */                  break;
275          created = 1; /* Disable registry writing */          }
276      }          currdir[j] = 0;
277            _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
278      if (!created) {      }
279          memset (&reg_prefs, 0, sizeof (reg_prefs));      return program;
280          reg_prefs.use_tmpfiles = 1; /* default */  }
281          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */  
282          get_reg_winpt_prefs (&reg_prefs);  
283          if (!reg_prefs.no_hotkeys)  /* Check that the underlying crypto engine fullfills the minimal
284              hotkeys_modify ();     requirements so all commands work properly. */
285      }  static bool
286    check_crypto_engine (void)
287      rc = gnupg_check_homedir ();  {
288      if (rc) {      int ma = 0, mi = 0, pa = 0;
289          log_box (_("WinPT Error"), MB_ERR,      int rc;
290                   _("GPG home directory is not set correctly.\n"  
291                     "Please check the GPG registry settings:\n%s."),      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
292                   winpt_strerror (rc));      if (rc == -1) {
293          const char * s = get_fileopen_dlg (GetActiveWindow (),          msg_box (NULL, _("Could not read GnuPG version."),
294                                             _("Select GPG Public Keyring"),                   _("WinPT Error"), MB_ERR);
295                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),          return false;
296                                             NULL);      }
297          if (s != NULL) {      else if (rc) {
298              size_t n;          log_box (_("WinPT Error"), MB_ERR,
299              char * p = strrchr (s, '\\');                   _("A newer GPG version is needed.\n"
300              if (!p)                     "Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
301                  BUG (0);                     ma, mi, pa);
302              n = p - s;          return false;
303              if (n)      }
304              {      /* Enable smart card support for GPG 2 or >= 1.4 */
305                  char * file = new char[n+1];      if ((ma > 1 || pa >= 4) && pcsc_available ())
306                  if (!file)          scard_support = 1;
307                      BUG (NULL);  
308                  memset (file, 0, n);      gpgver[0] = ma;
309                  memcpy (file, s, n);      gpgver[1] = mi;
310                  file[n] = '\0';              gpgver[2] = pa;
311                  set_reg_entry_gpg ("HomeDir", file);      return true;
312                  free_if_alloc (file);  }
313                  gnupg_check_homedir (); /* change gpgProgram if needed */  
314              }  
315          }  /* Try to load the keyserver config file. If @quiet is 1
316          else {     do not show any errors. */
317              msg_box (NULL, _("GPG home directory could not be determited."),  static int
318                       _("WinPT Error"), MB_ERR);  load_keyserver_conf (int quiet)
319              goto start;  {    
320          }      const char *t, *conf;
321      }      char *buf;
322        int rc;
323      rc = check_gnupg_prog ();  
324      if (rc) {      #ifdef WINPT_MOBILE
325          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"      /* In mobile mode we automatically assume the config file
326                               "Do you want to start the GPG preferences to "         in the current directory. */
327                               "correct  this problem?"), _("WinPT Error"),      return kserver_load_conf ("keyserver.conf");
328                               MB_INFO|MB_YESNO) == IDYES)      #endif
329              start_gpgprefs = 1;  
330          else      /* Create $APPDATA\winpt if needed. */
331          {      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
332              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
333              return 0;          MessageBox (NULL, _("Failed to create WinPT directory"),
334          }                      _("Keyserver"), MB_ERR);
335      }          free_if_alloc (buf);
336            return -1;
337      rc = gnupg_access_files ();      }
338      if (!start_gpgprefs && rc)      free_if_alloc (buf);
339      {  
340          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS)      /* Check for $APPDATA\winpt\keyserver.conf */
341          {      buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
342              ec = msg_box (NULL,  
343                  _("Could not access and/or find the public and secret keyring.\n"      conf = get_prog_part ("keyserver.conf", 0);
344                    "If this is an accident, quit the program and fix it.\n\n"      if (!file_exist_check (conf))
345                    "Continue if you want that WinPT offers you more choices.\n"),          t = conf;
346                    "WinPT", MB_INFO|MB_YESNO);      else
347              if (ec == IDYES)          t = "keyserver.conf";
348                  first_start = 1;      if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
349          }          if (!CopyFile (t, buf, FALSE)) {
350          if (!first_start)              MessageBox (NULL, _("Failed to copy the keyserver.conf"),
351          {                          _("Keyserver"), MB_ERR);
352              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              free_if_alloc (buf);
353              return 0;              return -1;
354          }          }
355      }          t = buf;
356        }
357      if (!first_start)      else
358      {          t = buf;
359          rc = gpg_check_permissions (1);      
360          if (rc && rc == 2)      rc = kserver_load_conf (t);
361              gpg_read_only = 1;      if (rc && !quiet)
362          else if (rc)          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
363              return 0;      else {
364      }          free_if_alloc (reg_prefs.kserv_conf);
365            reg_prefs.kserv_conf = m_strdup (t);
366      load_gettext ();      }
367      init_gnupg_table ();      free_if_alloc (buf);
368        return rc;
369      nfiles = fm_parse_command_line (cmdline);  }
370      if (nfiles > 0)  
371          return 0;  
372    /* Check if both keyrings are empty. This indicates that
373      if (cmdline && stristr (cmdline, "--wipe-freespace")) {     WinPT should offer to generate a key pair. */
374          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,  static bool
375                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,  check_for_empty_keyrings (bool pub_only)
376                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);  {
377          free_gnupg_table ();      char *p;
378          return 0;      int n = 0;
379      }  
380        p = get_gnupg_keyring (1, 0);
381      load_keyserver_conf (cmdline? 1 : 0);      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
382            n++;
383      if (cmdline && (stristr (cmdline, "--keymanager")      free_if_alloc (p);
384                  || stristr (cmdline, "--cardmanager"))) {      if (pub_only)
385          update_keycache (GetDesktopWindow ());          return n == 1? true : false;
386          if (stristr (cmdline, "keymanager"))      p = get_gnupg_keyring (0, 0);
387              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
388                              GetDesktopWindow(), keymanager_dlg_proc, NULL,          n++;
389                              _("Key Manager"), IDS_WINPT_KEYMISC);        free_if_alloc (p);
390          else {      return n==2? true : false;
391              gpg_card_t crd = gpg_card_load ();  }
392              if (crd)  
393                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,  
394                                    GetDesktopWindow(), card_edit_dlg_proc,  #ifdef WINPT_MOBILE
395                                    (LPARAM)crd, _("Card Manager"),  /* Enable the mobile mode if possible.
396                                    IDS_WINPT_CARD_EDIT);     There are some constraints which must be fullfilled.
397              gpg_card_release (crd);     Return value: 0 on success. */
398          }  static int
399          keycache_release (0);  enable_mobile_mode (void)
400          free_gnupg_table ();  {
401          return 0;      static const char *test_fname = "winpt_mobile_test.txt";
402      }      FILE *fp;
403        char *pubring;
404      CreateMutex (NULL, TRUE, PGM_NAME);      ULARGE_INTEGER caller, total;
405      if (GetLastError () == ERROR_ALREADY_EXISTS) {      DWORD temp_size;
406          free_gnupg_table ();  
407          return 0;      fp = fopen (test_fname, "wb");
408      }      if (fp == NULL) {
409            MessageBox (NULL, "Mobile mode cannot be used without write permission\n"
410      if (cmdline) {                            "for the current directory", "WinPT Error", MB_ERR);
411          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {              
412              gpg_set_debug_mode (1);          return -1;
413              winpt_debug_msg ();      }
414              debug = 1;      fclose (fp);
415          }      DeleteFile (test_fname);
416      }      if (file_exist_check ("gpg.exe")) {
417            MessageBox (NULL, "The GnuPG program needs to be in the same directory\n"
418      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));                            "as the WinPT program", "WinPT Error", MB_ERR);
419      rc = RegisterClass (&wc);          return -1;
420      if (rc == FALSE) {      }
421          msg_box (NULL, _("Could not register window class"), _("WinPT Error"), MB_ERR);      
422          free_gnupg_table ();      /* Because write operations to the keyring result in a temporary
423          return 0;         file, we need at least 2 MB plus the size of the keyring for
424      }         free space. */
425        pubring = get_gnupg_keyring (1);
426      hwnd = CreateWindow (PGM_NAME,      temp_size = get_file_size (pubring) + 2097152;
427                           PGM_NAME,      free_if_alloc (pubring);
428                           0, 0, 0, 0, 0,  
429                           NULL,      if (!GetDiskFreeSpaceEx (NULL, &caller, &total, NULL) ||
430                           NULL,          caller.LowPart < temp_size) {
431                           hinst,          log_box ("WinPT Error", MB_ERR,
432                           NULL);                   "The mobile mode needs at least %lu KB for temporary files",
433      if (hwnd == NULL) {                   temp_size/1024);
434          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);          return -1;
435          free_gnupg_table ();      }
436          return 0;  
437      }      /* XXX: shall we check for 'temp-directory' in the gpg.conf? */
438      glob_hwnd = hwnd;  
439      UpdateWindow (hwnd);      return 0;
440    }
441      if (!first_start && !start_gpgprefs) {  #endif
442          gnupg_backup_options ();          
443          rc = check_crypto_engine ();  
444          if (rc) {  /* Set the default keyserver for this instance. */
445              DestroyWindow (hwnd);  void
446              free_gnupg_table ();  set_default_keyserver (void)
447              return 0;  {
448          }      char *host = get_reg_entry_keyserver ("Default");
449      }      char *str_port = get_reg_entry_keyserver ("Default_Port");
450            WORD port = HKP_PORT;
451      if (start_gpgprefs) {  
452          char *ring;      if (!host)
453          size_t size = 0;          keyserver_set_default (NULL, 0);
454          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,      else {
455                          gpgprefs_dlg_proc, NULL);          if (str_port && *str_port)
456          ring = get_gnupg_keyring (0, !NO_STRICT);              port = atoi (str_port);
457          if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)          keyserver_set_default (host, port);
458              first_start = 1; /* The keyring is empty! */      }
459          free_if_alloc (ring);      free_if_alloc (host);
460      }      free_if_alloc (str_port);
461    }
462      if (first_start) {  
463          struct first_start_s fs;  
464          struct genkey_s c;  /* Display info message that WinPT is now in debug mode. */
465          HWND h;  void
466  start:  winpt_debug_msg (void)
467          h = GetDesktopWindow ();  {      
468          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,      char output[512];
469                              gpgprefs_dlg_proc, NULL);      char temp[128];
470          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          
471                          first_run_dlg_proc, (LPARAM)&fs);      GetTempPath (DIM (temp) -1, temp);
472          switch (fs.choice) {      _snprintf (output, DIM (output)-1,
473          case SETUP_KEYGEN:          "The GPGME output file is %sgpgme.dbg\n"
474              c.interactive = 1;          "The WinPT output file is %swinpt.log\n", temp, temp);
475              c.first_start = 1;      MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
476              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,  }
477                                   h, keygen_wizard_dlg_proc, (LPARAM)&c);  
478              if (!rc)  
479                  goto start;  /* Search for insecure ElGamal keys and return the
480              break;     number of founded keys. */
481    static int
482          case SETUP_IMPORT:  count_insecure_elgkeys (void)
483              rc = gnupg_copy_keyrings ();  {
484              if (rc) {      gpg_keycache_t pc;
485                  msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);      gpgme_key_t key;
486                  goto start;      int n = 0;
487              }  
488              break;      pc = keycache_get_ctx (1);
489        while (!gpg_keycache_next_key (pc, 0, &key)) {
490          case -1:          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
491              DestroyWindow (hwnd);              n++;
492              free_gnupg_table ();      }
493              return 0;      gpg_keycache_rewind (pc);
494          }      return n;
495          update_keycache (hwnd);  }
496          check_crypto_engine ();  
497      }  
498      else {  /* Main entry point. */
499          gpg_keycache_t c;  int WINAPI
500          update_keycache (hwnd);  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
501          c = keycache_get_ctx (1);  {
502          if (!c || !gpg_keycache_get_size (c)) {      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
503              gnupg_display_error ();      HACCEL accel_tab;
504              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"      MSG msg;
505                               "Please check your GPG config (keyrings, pathes...)"),      HWND hwnd = NULL;
506                               _("WinPT Error"), MB_ERR);      WORD ver[3], ptdver[4];
507              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"      const char *s;
508                                    "Do you want to start the GPG preferences dialog?"),      int rc, ec, created = 0;
509                              "WinPT", MB_INFO|MB_YESNO);      int first_start = 0, start_gpgprefs = 0;
510              if (ec == IDYES) {      int winpt_inst_found = 0;
511                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,      int start_manager = 0;    
512                                  gpgprefs_dlg_proc, NULL);  
513                  update_keycache (hwnd);  #ifdef WINPT_MOBILE
514              }      /* Do not continue in case of problems. */
515              else {      if (enable_mobile_mode ())
516                  DestroyWindow (hwnd);          return 0;
517                  free_gnupg_table ();  #endif
518                  return 0;  
519              }      glob_hinst = hinst;
520          }      if (cmdline && stristr (cmdline, "--stop")) {
521          if (check_default_key (c)) {          hwnd = FindWindow ("WinPT", "WinPT");
522              char * p = get_gnupg_default_key ();          if (hwnd != NULL)
523              log_box (_("WinPT Error"), MB_ERR,              PostMessage (hwnd, WM_DESTROY, 0, 0);
524                       _("Default key from the GPG options file could not be found.\n"          return 0;
525                         "Please check your gpg.conf (options) to correct this:\n\n"      }
526                         "%s: public key not found."), p? p : "[null]");  
527              free_if_alloc (p);  #ifdef _DEBUG
528              DestroyWindow (hwnd);      gpg_set_debug_mode (1);
529              free_gnupg_table ();      debug = 1;
530              return 0;  #endif
531          }  
532          if (count_insecure_elgkeys ())      get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
533              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],  
534                              elgamal_warn_dlg_proc, NULL);                                   &ptdver[2], &ptdver[3]);
535      }      
536        if (!ec && (ptdver[0] != ver[0] ||
537      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);                  ptdver[1] != ver[1] ||
538      keyring_check_last_access (); /* init */                  ptdver[2] != ver[2])) {
539      while (GetMessage (&msg, hwnd, 0, 0)) {          log_box (_("WinPT Error"), MB_ERR,
540          if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {                   _("The PTD.dll file has a different version than WinPT.exe\n"
541              TranslateMessage (&msg);                     "Please update the PTD.dll to version %d.%d.%d"),
542              DispatchMessage (&msg);                     ver[0], ver[1], ver[2]);
543          }          return 0;
544      }      }
545            
546      return 0;      if (gpg_md_selftest ()) {
547  } /* WinMain */          msg_box (NULL, _("Cryptographic selftest failed."),
548                     _("WinPT Error"), MB_ERR);
549            return 0;
550        }
551    
552        s = gpgme_check_version (NEED_GPGME_VERSION);
553        if (!s || !*s) {
554            msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
555                     _("WinPT Error"), MB_ERR);
556            return 0;
557        }
558    
559        CreateMutex (NULL, TRUE, PGM_NAME);
560        if (GetLastError () == ERROR_ALREADY_EXISTS)
561            winpt_inst_found = 1;
562        
563        set_default_keyserver ();
564        load_gettext ();
565        admin_user = user_is_admin ();
566    
567        regist_inst_gnupg (1);
568        regist_inst_winpt (1, &created);
569    
570        if (!created) {
571            memset (&reg_prefs, 0, sizeof (reg_prefs));
572            get_reg_winpt_prefs (&reg_prefs);
573            reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
574            if (gnupg_load_config () == -2)
575                msg_box (NULL, _("The gpg.conf file contains the 'textmode' option\n"
576                                 "which leads to broken binary output during decryption.\n"
577                                 "If this is on purpose, just continue otherwise the option should be disabled."),
578                                _("WinPT Error"), MB_ERR);
579        }
580    
581        if (is_gpg4win_installed ())
582            load_gpg_env (); /* XXX: check return code. */
583    
584        rc = gnupg_check_homedir ();
585        if (rc) {
586            char *p;
587    
588            log_box (_("WinPT Error"), MB_ERR,
589                     _("GPG home directory is not set correctly.\n"
590                       "Please check the GPG registry settings:\n%s."),
591                     winpt_strerror (rc));
592            s = get_fileopen_dlg (GetActiveWindow (),
593                                  _("Select GPG Public Keyring"),
594                                  "GPG Keyrings (*.gpg)\0*.gpg\0\0",
595                                  NULL);
596            if (s != NULL && (p=strrchr (s, '\\'))) {
597                char *path = substr (s, 0, (p-s));
598    
599                set_reg_entry_gpg ("HomeDir", path);
600                free_if_alloc (path);
601            }
602            else {
603                msg_box (NULL, _("GPG home directory could not be determined."),
604                         _("WinPT Error"), MB_ERR);
605                goto start;
606            }
607        }
608    
609        rc = check_gnupg_prog ();
610        if (rc) {
611            if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
612                                 "Do you want to start the GPG preferences to "
613                                 "correct  this problem?"), _("WinPT Error"),
614                                 MB_INFO|MB_YESNO) == IDYES)
615                start_gpgprefs = 1;
616            else {
617                msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
618                return 0;
619            }
620        }
621    
622        rc = gnupg_access_files ();
623        if (!start_gpgprefs && rc) {
624            if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
625                ec = msg_box (NULL,
626                    _("Could not access and/or find the public and secret keyring.\n"
627                      "If this is an accident, quit the program and fix it.\n\n"
628                      "Continue if you want WinPT to offer you more choices.\n"),
629                      "WinPT", MB_INFO|MB_YESNO);
630                if (ec == IDYES)
631                    first_start = 1;
632            }
633            if (!first_start) {
634                msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
635                return 0;
636            }
637        }
638        if (check_for_empty_keyrings (false))
639            first_start = 1;
640    
641        if (!first_start) {
642            rc = gpg_check_permissions (1);
643            if (rc && rc == 2) /* 2 means read-only mode. */
644                gpg_read_only = 1;
645            else if (rc)
646                return 0;
647        }
648        
649        init_gnupg_table ();
650    
651        if (fm_parse_command_line (cmdline) > 0) {
652            free_gnupg_table ();
653            return 0;
654        }
655    
656        if (cmdline && stristr (cmdline, "--wipe-freespace")) {
657            dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
658                                GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
659                                _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
660            free_gnupg_table ();
661            return 0;
662        }
663    
664        load_keyserver_conf (cmdline? 1 : 0);
665    
666        if (cmdline && (stristr (cmdline, "--keymanager")
667                    || stristr (cmdline, "--cardmanager"))) {
668            /* If an instance of WinPT is running, just send the command
669               to open the key manager. Otherwise start a new instance. */
670            HWND tray = FindWindow ("WinPT", "WinPT");
671            if (stristr (cmdline, "keymanager"))
672                start_manager = ID_WINPT_KEY;
673            else
674                start_manager = ID_WINPT_CARD;
675            if (tray != NULL) {
676                PostMessage (tray, WM_COMMAND, start_manager, 0);
677                free_gnupg_table ();
678                return 0;
679            }
680        }
681    
682        /* If we found another WinPT instance, just quit to avoid it
683           will be executed twice. */
684        if (winpt_inst_found) {
685            log_debug ("%s", "WinMain: WinPT is already running.");
686            free_gnupg_table ();
687            return 0;
688        }
689    
690    #ifndef WINPT_MOBILE
691        if (cmdline && (stristr (cmdline, "--enable-debug") ||
692                        stristr (cmdline, "--debug"))) {
693            gpg_set_debug_mode (1);
694            winpt_debug_msg ();
695            debug = 1;
696        }
697    #endif
698    
699        wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
700        rc = RegisterClass (&wc);
701        if (rc == FALSE) {
702            msg_box (NULL, _("Could not register window class"),
703                     _("WinPT Error"), MB_ERR);
704            free_gnupg_table ();
705            return 0;
706        }
707    
708        hwnd = CreateWindow (PGM_NAME,
709                             PGM_NAME,
710                             0, 0, 0, 0, 0,
711                             NULL,
712                             NULL,
713                             hinst,
714                             NULL);
715        if (hwnd == NULL) {
716            msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
717            free_gnupg_table ();
718            return 0;
719        }
720        glob_hwnd = hwnd;
721        UpdateWindow (hwnd);
722    
723        if (!first_start && !start_gpgprefs) {
724            gnupg_backup_options ();        
725            if (!check_crypto_engine ()) {
726                DestroyWindow (hwnd);
727                free_gnupg_table ();
728                return 0;
729            }
730        }
731        
732        if (start_gpgprefs) {
733            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
734                            gpgprefs_dlg_proc, 0);
735            if (check_for_empty_keyrings (true))
736                first_start = 1; /* The public keyring is empty. */
737        }
738    
739        if (first_start) {
740            struct genkey_s c;
741            int choice;
742            HWND h;
743    start:
744            h = GetDesktopWindow ();
745            if (!gpg_prefs_ok ())
746                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
747                                gpgprefs_dlg_proc, 0);
748            choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
749                                     first_run_dlg_proc, 0);
750            switch (choice) {
751            case SETUP_KEYGEN:
752                c.interactive = 1;
753                c.first_start = 1;
754                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
755                                     h, keygen_wizard_dlg_proc, (LPARAM)&c);
756                if (!rc)
757                    goto start;
758                break;
759    
760            case SETUP_IMPORT:
761                rc = gnupg_copy_keyrings ();
762                if (rc) {
763                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
764                    goto start;
765                }
766                break;
767    
768            case SETUP_CARDGEN:
769                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
770                                     h, card_keygen_dlg_proc, 0);
771                if (!rc)
772                    goto start;
773                break;
774    
775            case 0: /* Cancel/Abort. */
776            default:
777                DestroyWindow (hwnd);
778                free_gnupg_table ();
779                return 0;
780            }
781            update_keycache (hwnd);
782            if (!check_crypto_engine ()) {
783                DestroyWindow (hwnd);
784                free_gnupg_table ();
785                keycache_release (1);
786                return 0;
787            }
788            if (!is_gpg4win_installed ()) {
789                select_language ();
790                load_gettext ();
791            }
792        }
793        else {
794            gpg_keycache_t c;
795            if (update_keycache (hwnd)) {
796                DestroyWindow (hwnd);
797                free_gnupg_table ();
798                keycache_release (1);
799                return 0;
800            }
801            /* XXX: rewrite this part. */
802            c = keycache_get_ctx (1);
803            if (!gpg_keycache_get_size (c)) {
804                msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
805                                 "Please check your GPG config (keyrings, pathes...)"),
806                                 _("WinPT Error"), MB_ERR);
807                ec = msg_box (NULL, _("It seems that GPG is not configured properly.\n"
808                                      "Do you want to start the GPG preferences dialog?"),
809                                "WinPT", MB_INFO|MB_YESNO);
810                if (ec == IDYES) {
811                    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
812                                    gpgprefs_dlg_proc, 0);
813                    update_keycache (hwnd);
814                }
815                else {
816                    DestroyWindow (hwnd);
817                    free_gnupg_table ();
818                    keycache_release (1);
819                    return 0;
820                }
821            }      
822            if (check_default_key ()) {
823                char *p = get_gnupg_default_key ();
824                log_box (_("WinPT Error"), MB_ERR,
825                         _("Default key (from the GPG config file) could not be found or is unuseable.\n"
826                           "The default key will be resetted and can be set later in the Key Manager again.\n\n"
827                           "%s: secret key not found."), p? p : "?");
828                set_gnupg_default_key (NULL);
829                free_if_alloc (p);
830            }
831            if (count_insecure_elgkeys ())
832                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
833                                elgamal_warn_dlg_proc, 0);
834        }
835    
836        if (start_manager)
837            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
838    
839        accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
840        keyring_check_last_access (); /* init */
841        while (GetMessage (&msg, hwnd, 0, 0)) {
842            if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
843                TranslateMessage (&msg);
844                DispatchMessage (&msg);
845            }
846        }
847            
848        return 0;
849    }
Legend:
Removed from v.28  
changed lines
  Added in v.278
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26