/[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 23 by twoaday, Fri Sep 30 10:10:16 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  HINSTANCE glob_hinst; /* global instance for the dialogs */  #include "wptCrypto.h"
39  HWND glob_hwnd; /* global window handle for the dialogs */  #include "wptUTF8.h"
40  HWND activ_hwnd;  
41  LOCK mo_file;  void remove_crit_file_attrs (const char *fname, int force);
42  int scard_support = 0;  BOOL user_is_admin (void);
43  int debug = 0;  int  pcsc_available (void);
44  int mobile = 0;  
45  int gpg_read_only = 0;  /* Global variables. */
46  char gpgver[3];  HINSTANCE glob_hinst;   /* global instance for the dialogs */
47    HWND glob_hwnd;         /* global window handle for the dialogs */
48  /* Internal IPC */  int scard_support = 0;
49  int start_keymanager = 0;  int debug = 0;
50    int gpg_read_only = 0;
51  static void  int admin_user = 0;
52  update_keycache (HWND hwnd)  char gpgver[3];
53  {  /* End */
54      refresh_cache_s rcs = {0};  
55      rcs.kr_reload = 0;  
56      rcs.kr_update = 1;  /* Load the key cache and rebuild the signature cache. */
57      rcs.tr_update = 1;  int
58      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,  update_keycache (HWND hwnd)
59                      keycache_dlg_proc, (LPARAM)&rcs);  {
60  } /* update_keycache */      int err;
61        refresh_cache_s rcs;
62    
63  static char *      /* no need to rebuild the sig cache each time. */
64  get_gettext_lang (void)      memset (&rcs, 0, sizeof (rcs));
65  {          rcs.kring_update = 1;
66      char * fname;      err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
67      fname = get_reg_entry_mo ();                      keycache_dlg_proc, (LPARAM)&rcs);
68      if (!fname)      if (err) {
69          return NULL;          char *cfgf = get_gnupg_config ();
70      return fname;          if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
71  } /* get_gettext_lang */              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 void      }
75  load_gettext (void)      return 0;
76  {  }
77      char * nls = NULL;  
78      char * file = NULL;  
79    /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
80      nls = get_gettext_lang ();  void
81      if (nls) {  gpg_set_debug_mode (int val)
82          set_gettext_file ("winpt", nls);  {
83          file = make_filename (nls, "winpt", "mo");      static char buf[256];
84          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {      char tmp[128];
85              msg_box (NULL, _("Could not initizalize file lock.\n"      
86                               "Native Language Support"),      /* XXX: no gpgme.dbg is created. */
87                       _("WinPT Error"), MB_ERR);      if (val > 0) {
88          }          GetTempPath (DIM (tmp)-1, tmp);
89          free_if_alloc (nls);          _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
90          free_if_alloc (file);          putenv (buf);
91      }      }
92  } /* load_gettext */      else
93            putenv ("GPGME_DEBUG=");
94    }
95  /* check if the default key from the gpg.conf file is available in the  
96     keyring. if not, bail out because encryption won't work properly then. */  
97  static int  /* Initialize the gettext sub system. */
98  check_default_key (gpgme_keycache_t kc)  static void
99  {  load_gettext (void)
100      gpgme_key_t key;  {
101      gpgme_error_t err = GPG_ERR_NO_ERROR;      char *nls;
102      char * defkey;  
103        /* Return the name of the gettext language file. */
104      defkey = get_gnupg_default_key ();      nls = get_reg_entry_mo ();
105      if (defkey)      if (nls != NULL) {
106          err = gpgme_keycache_find_key (kc, defkey, 0, &key);          gettext_set_file ("winpt", nls);
107      free_if_alloc (defkey);          free_if_alloc (nls);
108      return err? -1 : 0;      }
109  } /* check_default_key */  }
110    
111    
112  /* Return the WinPT program file name (with full pathname). */  /* Return true if the GPG environment is useable. */
113  static const char *  static bool
114  get_prog_part (const char * fname, int use_cwd)  gpg_prefs_ok (void)
115  {  {
116      static char program[1024];      char *p;
117      char currdir[256], * cmd = NULL;  
118      int j;      p = get_reg_entry_gpg4win ("gpg.exe");
119                if (!p || file_exist_check (p) != 0) {
120      memset (currdir, 0, DIM (currdir));          free_if_alloc (p);
121      memset (program, 0, DIM (program));          p = get_reg_entry_gpg ("gpgProgram");
122                    if (!p || file_exist_check (p) != 0) {
123      if (use_cwd) {              free_if_alloc (p);
124          GetCurrentDirectory (DIM (currdir)-1, currdir);              log_debug ("gpg_prefs_ok: could not locate gpg.exe");
125          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);              return false;
126      }          }
127      else {      }
128          cmd = GetCommandLine ();      free_if_alloc (p);
129          if (cmd == NULL)      p = get_reg_entry_gpg4win (NULL);
130              return NULL;      if (!p || dir_exist_check (p) != 0) {
131          strncpy (currdir, cmd, 255);          free_if_alloc (p);
132          j = strlen (currdir);          p = get_reg_entry_gpg ("HomeDir");
133          while (j--) {          if (!p || dir_exist_check (p) != 0) {
134              if (currdir[j] == '\\')              free_if_alloc (p);
135                  break;                        log_debug ("gpg_prefs_ok: could not determine home directory");
136          }              return false;
137          currdir[j] = 0;          }
138          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);      }
139      }      free_if_alloc (p);
140      return program;      return true;
141  } /* get_prog_part */  }
142    
143    
144  static int  /* Check gpg files if they are read-only and ask the user
145  check_crypto_engine (void)     if this should be corrected. */
146  {  static void
147      int ma=1, mi=4, pa=0; /* GPG 1.4.0 */  check_readonly_attr (const char *homedir)
148      int rc;  {
149        const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
150      rc = check_gnupg_engine (&ma, &mi, &pa);      char *file;
151      if (rc == -1) {      int i;
152          msg_box (NULL, _("Could not read GnuPG version."), _("WinPT Error"), MB_ERR);  
153          return rc;      for (i=0; files[i] != NULL; i++) {
154      }          file = make_filename (homedir, files[i], NULL);
155      else if (rc) {          remove_crit_file_attrs (file, 0);
156          log_box (_("WinPT Error"), MB_ERR,          free_if_alloc (file);
157                   _("Sorry, you need a newer GPG version.\n"      }
158                     "GPG version %d.%d.%d required GPG version 1.4.0"),  }
159                     ma, mi, pa);  
160          return rc;  
161      }  /* Load the GPG environment. On the first start, some
162      /* We enable smartcard support for GPG: 1.9.x or >= 1.4.0 */     checks are performed to find out in what state GPG is.
163      if (ma >= 1 && mi >= 4)     Return value: 0  everything OK.
164          scard_support = 1;                   >0  fatal error.
165                     -1 public keyring is empty or does not exist. */
166      gpgver[0] = ma;  static int
167      gpgver[1] = mi;  load_gpg_env (void)
168      gpgver[2] = pa;  {
169      return rc;      SECURITY_ATTRIBUTES sec_attr;
170  } /* check_crypto_engine */      char *p;
171        char *pkr;
172        int err = 0;
173  static int  
174  load_keyserver_conf (int quiet)      p = get_reg_entry_gpg4win ("gpg.exe");
175  {      if (!p)
176      const char * t;          return (1);
177      int rc;      if (file_exist_check (p)) {
178            free_if_alloc (p);
179      if (reg_prefs.kserv_conf)          return (1);
180          t = reg_prefs.kserv_conf;      }
181      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))      free_if_alloc (p);
182          t = get_prog_part ("keyserver.conf", 0);  
183      else      p = get_reg_entry_gpg ("HomeDir");
184          t = "keyserver.conf";      if (!p || dir_exist_check (p) != 0) {
185      rc = kserver_load_conf (t);          free_if_alloc (p);
186      if (rc && !quiet)          p = multi_gnupg_path (0);
187          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);      }
188      return rc;      if (p && dir_exist_check (p)) {
189  }          memset (&sec_attr, 0, sizeof (sec_attr));
190            sec_attr.nLength = sizeof (sec_attr);
191            if (!CreateDirectory (p, &sec_attr)) {
192  static void              msg_box (NULL, _("Could not create GPG home directory"),
193  enable_mobile_mode (void)                       _("WinPT Error"), MB_ERR);
194  {              free_if_alloc (p);
195      memset (&reg_prefs, 0, sizeof (reg_prefs));              return (2);
196      reg_prefs.always_trust = 0;          }
197      reg_prefs.auto_backup = 0;      }
198      reg_prefs.cache_time = 0;      check_readonly_attr (p);
199      reg_prefs.expert = 0;      pkr = make_filename (p, "pubring", "gpg");
200      reg_prefs.keylist_mode = 1;      free_if_alloc (p);
201      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      if (get_file_size (pkr) == 0)
202      reg_prefs.no_zip_mmedia = 1;          err = -1;
203      reg_prefs.use_tmpfiles = 1;      free_if_alloc (pkr);
204      reg_prefs.word_wrap = 80;      return err;
205      reg_prefs.use_viewer = 0; /* XXX */  }
206  }  
207    
208  char* get_subkey_fingerprint (gpgme_ctx_t ctx, const char *keyid);  /* check if the default key from the gpg.conf file is available in the
209       keyring. if not, bail out because encryption won't work properly then. */
210  int WINAPI  static int
211  #ifndef WINPT_IPC  check_default_key (void)
212  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)  {
213  #else      gpgme_key_t key;
214  win_main (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
215  #endif      gpg_keycache_t kc;
216  {      char *defkey;
217      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};  
218      HACCEL accel_tab;      kc = keycache_get_ctx (0);
219      int rc, ec, created = 0, use_cwd = 0, nfiles = 0;      defkey = get_gnupg_default_key ();
220      int first_start = 0, start_gpgprefs = 0;      if (defkey) {
221      const char * s;          err = gpg_keycache_find_key (kc, defkey, 0, &key);
222      MSG msg;          if (err) {
223      HWND hwnd = NULL;              free_if_alloc (defkey);
224                return -1;
225      glob_hinst = hinst;          }
226            }
227      #ifdef _DEBUG      else {
228      gpgme_set_debug_mode (1);          /* Actually this is just a warning but we still continue. */
229      #endif          msg_box (NULL, _("No useable secret key found."),
230                     _("WinPT Warning"), MB_WARN);
231      s = PTD_get_version ();          free_if_alloc (defkey);
232      if (strcmp (s, "0.8.0")) {          return 0;
233          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,      }
234                   _("Please update your PTD.dll to the newest version, "  
235                     "the version (%s) you use is too old."), s);      /* Because the secret key listing has no information
236          return 0;         about the validity/status, we need to check the public key. */
237      }      kc = keycache_get_ctx (1);
238        if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
239      if (gpg_md_selftest ()) {          (key->revoked || key->expired)) {
240          msg_box (NULL, _("Cryptographic selftest failed."),          msg_box (NULL, _("Default secret key is unuseable"),
241                   _("WinPT Error"), MB_ERR);                   _("WinPT Warning"), MB_ERR);
242          return 0;          free_if_alloc (defkey);
243      }          return -1;
244        }
245      if (cmdline && stristr (cmdline, "--mobile")) {      free_if_alloc (defkey);
246          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",      return 0;
247                   "WinPT", MB_INFO);  }
248          mobile = 1;  
249      }  
250    /* Return the WinPT program file name (with full pathname). */
251      set_default_kserver ();  static const char*
252    get_prog_part (const char *fname, int use_cwd)
253      if (!mobile) {  {
254          regist_inst_gnupg (1);      static char program[2*MAX_PATH+1];
255          regist_inst_winpt (1, &created);      char currdir[MAX_PATH+1];
256      }      char *cmd = NULL;
257      else {      int j;
258          enable_mobile_mode ();          
259          /* XXX: ask for GPG path */      memset (currdir, 0, DIM (currdir));
260          created = 1; /* Disable registry writing */      memset (program, 0, DIM (program));
261      }          
262        if (use_cwd) {
263      if (!created) {          GetCurrentDirectory (DIM (currdir)-1, currdir);
264          memset (&reg_prefs, 0, sizeof (reg_prefs));          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
265          reg_prefs.use_tmpfiles = 1; /* default */      }
266          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */      else {
267          get_reg_winpt_prefs (&reg_prefs);          cmd = GetCommandLine ();
268          if (!reg_prefs.no_hotkeys)          if (!cmd)
269              hotkeys_modify ();              return NULL;
270      }          strncpy (currdir, cmd, DIM (currdir)-1);
271            j = strlen (currdir);
272      rc = gnupg_check_homedir ();          while (j--) {
273      if (rc) {              if (currdir[j] == '\\')
274          log_box (_("WinPT Error"), MB_ERR,                  break;
275                   _("GPG home directory is not set correctly.\n"          }
276                     "Please check the GPG registry settings:\n%s."),          currdir[j] = 0;
277                   winpt_strerror (rc));          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
278          const char * s = get_filename_dlg (GetActiveWindow (), FILE_OPEN,      }
279                                             _("Select GPG Public Keyring"),      return program;
280                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),  }
281                                             NULL);  
282          if (s != NULL) {  
283              size_t n;  /* Check that the underlying crypto engine fullfills the minimal
284              char * p = strrchr (s, '\\');     requirements so all commands work properly. */
285              if (!p)  static bool
286                  BUG (0);  check_crypto_engine (void)
287              n = p - s;  {
288              if (n)      int ma = 0, mi = 0, pa = 0;
289              {      int rc;
290                  char * file = new char[n+1];  
291                  if (!file)      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
292                      BUG (NULL);      if (rc == -1) {
293                  memset (file, 0, n);          msg_box (NULL, _("Could not read GnuPG version."),
294                  memcpy (file, s, n);                   _("WinPT Error"), MB_ERR);
295                  file[n] = '\0';                  return false;
296                  set_reg_entry_gpg ("HomeDir", file);      }
297                  free_if_alloc (file);      else if (rc) {
298                  gnupg_check_homedir (); /* change gpgProgram if needed */          log_box (_("WinPT Error"), MB_ERR,
299              }                   _("A newer GPG version is needed.\n"
300          }                     "Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
301          else {                     ma, mi, pa);
302              msg_box (NULL, _("GPG home directory could not be determited."),          return false;
303                       _("WinPT Error"), MB_ERR);      }
304              goto start;      /* Enable smart card support for GPG 2 or >= 1.4 */
305          }      if ((ma > 1 || pa >= 4) && pcsc_available ())
306      }          scard_support = 1;
307    
308      rc = check_gnupg_prog ();      gpgver[0] = ma;
309      if (rc) {      gpgver[1] = mi;
310          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"      gpgver[2] = pa;
311                               "Do you want to start the GPG preferences to "      return true;
312                               "correct  this problem?"), _("WinPT Error"),  }
313                               MB_INFO|MB_YESNO) == IDYES)  
314              start_gpgprefs = 1;  
315          else  /* Try to load the keyserver config file. If @quiet is 1
316          {     do not show any errors. */
317              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);  static int
318              return 0;  load_keyserver_conf (int quiet)
319          }  {    
320      }      const char *t, *conf;
321        char *buf;
322      rc = gnupg_access_files ();      int rc;
323      if (!start_gpgprefs && rc)  
324      {      #ifdef WINPT_MOBILE
325          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS)      /* In mobile mode we automatically assume the config file
326          {         in the current directory. */
327              ec = msg_box (NULL,      return kserver_load_conf ("keyserver.conf");
328                  _("Could not access and/or find the public and secret keyring.\n"      #endif
329                    "If this is an accident, quit the program and fix it.\n\n"  
330                    "Continue if you want that WinPT offers you more choices.\n"),      /* Create $APPDATA\winpt if needed. */
331                    "WinPT", MB_INFO|MB_YESNO);      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
332              if (ec == IDYES)      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
333                  first_start = 1;          MessageBox (NULL, _("Failed to create WinPT directory"),
334          }                      _("Keyserver"), MB_ERR);
335          if (!first_start)          free_if_alloc (buf);
336          {          return -1;
337              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);      }
338              return 0;      free_if_alloc (buf);
339          }  
340      }      /* Check for $APPDATA\winpt\keyserver.conf */
341        buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
342      if (!first_start)  
343      {      conf = get_prog_part ("keyserver.conf", 0);
344          rc = gpg_check_permissions (1);      if (!file_exist_check (conf))
345          if (rc && rc == 2)          t = conf;
346              gpg_read_only = 1;      else
347          else if (rc)          t = "keyserver.conf";
348              return 0;      if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
349      }          if (!CopyFile (t, buf, FALSE)) {
350                MessageBox (NULL, _("Failed to copy the keyserver.conf"),
351      load_gettext ();                          _("Keyserver"), MB_ERR);
352      init_gnupg_table ();              free_if_alloc (buf);
353                return -1;
354      nfiles = fm_parse_command_line (cmdline);          }
355      if (nfiles > 0)          t = buf;
356          return 0;      }
357        else
358      if (cmdline && stristr (cmdline, "--wipe-freespace")) {          t = buf;
359          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,      
360                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,      rc = kserver_load_conf (t);
361                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);      if (rc && !quiet)
362          free_gnupg_table ();          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_keyserver_conf (cmdline? 1 : 0);      }
367      if (start_keymanager) {      free_if_alloc (buf);
368          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,      return rc;
369                              GetDesktopWindow(), keymanager_dlg_proc, NULL,  }
370                              _("Key Manager"), IDS_WINPT_KEYMISC);  
371          keycache_release ();  
372          free_gnupg_table ();  /* Check if both keyrings are empty. This indicates that
373          return 0;     WinPT should offer to generate a key pair. */
374      }  static bool
375    check_for_empty_keyrings (bool pub_only)
376      if (cmdline && (stristr (cmdline, "--keymanager")  {
377                  || stristr (cmdline, "--cardmanager"))) {      char *p;
378          update_keycache (GetDesktopWindow ());      int n = 0;
379          if (stristr (cmdline, "keymanager"))  
380              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,      p = get_gnupg_keyring (1, 0);
381                              GetDesktopWindow(), keymanager_dlg_proc, NULL,      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
382                              _("Key Manager"), IDS_WINPT_KEYMISC);            n++;
383          else {      free_if_alloc (p);
384              gpg_card_t crd = smartcard_init ();      if (pub_only)
385              if (crd)          return n == 1? true : false;
386                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,      p = get_gnupg_keyring (0, 0);
387                                    GetDesktopWindow(), card_edit_dlg_proc,      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
388                                    (LPARAM)crd, _("Card Manager"),          n++;
389                                    IDS_WINPT_CARD_EDIT);      free_if_alloc (p);
390              gpg_card_release (crd);      return n==2? true : false;
391          }  }
392          keycache_release ();  
393          free_gnupg_table ();  
394          return 0;  #ifdef WINPT_MOBILE
395      }  /* Enable the mobile mode if possible.
396       There are some constraints which must be fullfilled.
397      CreateMutex (NULL, TRUE, PGM_NAME);     Return value: 0 on success. */
398      if (GetLastError () == ERROR_ALREADY_EXISTS) {  static int
399          free_gnupg_table ();  enable_mobile_mode (void)
400          return 0;  {
401      }      static const char *test_fname = "winpt_mobile_test.txt";
402        FILE *fp;
403      if (cmdline) {      char *pubring;
404          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {      ULARGE_INTEGER caller, total;
405              gpg_set_debug_mode (1);      DWORD temp_size;
406              winpt_debug_msg ();  
407              debug = 1;      fp = fopen (test_fname, "wb");
408          }      if (fp == NULL) {
409      }          MessageBox (NULL, "Mobile mode cannot be used without write permission\n"
410                              "for the current directory", "WinPT Error", MB_ERR);
411      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));              
412      rc = RegisterClass (&wc);          return -1;
413      if (rc == FALSE) {      }
414          msg_box (NULL, _("Could not register window class"), _("WinPT Error"), MB_ERR);      fclose (fp);
415          free_gnupg_table ();      DeleteFile (test_fname);
416          return 0;      if (file_exist_check ("gpg.exe")) {
417      }          MessageBox (NULL, "The GnuPG program needs to be in the same directory\n"
418                              "as the WinPT program", "WinPT Error", MB_ERR);
419      hwnd = CreateWindow (PGM_NAME,          return -1;
420                           PGM_NAME,      }
421                           0, 0, 0, 0, 0,      
422                           NULL,      /* Because write operations to the keyring result in a temporary
423                           NULL,         file, we need at least 2 MB plus the size of the keyring for
424                           hinst,         free space. */
425                           NULL);      pubring = get_gnupg_keyring (1);
426      if (hwnd == NULL) {      temp_size = get_file_size (pubring) + 2097152;
427          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);      free_if_alloc (pubring);
428          free_gnupg_table ();  
429          return 0;      if (!GetDiskFreeSpaceEx (NULL, &caller, &total, NULL) ||
430      }          caller.LowPart < temp_size) {
431      glob_hwnd = hwnd;          log_box ("WinPT Error", MB_ERR,
432      UpdateWindow (hwnd);                   "The mobile mode needs at least %lu KB for temporary files",
433                     temp_size/1024);
434      if (!first_start && !start_gpgprefs) {          return -1;
435          gnupg_backup_options ();              }
436          rc = check_crypto_engine ();  
437          if (rc) {      /* XXX: shall we check for 'temp-directory' in the gpg.conf? */
438              DestroyWindow (hwnd);  
439              free_gnupg_table ();      return 0;
440              return 0;  }
441          }  #endif
442      }  
443        
444      if (start_gpgprefs) {  /* Set the default keyserver for this instance. */
445          char *ring;  void
446          size_t size = 0;  set_default_keyserver (void)
447          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,  {
448                          gpgprefs_dlg_proc, NULL);      char *host = get_reg_entry_keyserver ("Default");
449          ring = get_gnupg_keyring (0, !NO_STRICT);      char *str_port = get_reg_entry_keyserver ("Default_Port");
450          if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)      WORD port = HKP_PORT;
451              first_start = 1; /* The keyring is empty! */  
452          free_if_alloc (ring);      if (!host)
453      }          keyserver_set_default (NULL, 0);
454        else {
455      if (first_start) {          if (str_port && *str_port)
456          struct first_start_s fs;              port = atoi (str_port);
457          struct genkey_s c;          keyserver_set_default (host, port);
458          HWND h;      }
459  start:      free_if_alloc (host);
460          h = GetDesktopWindow ();      free_if_alloc (str_port);
461          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,  }
462                              gpgprefs_dlg_proc, NULL);  
463          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,  
464                          first_run_dlg_proc, (LPARAM)&fs);  /* Display info message that WinPT is now in debug mode. */
465          switch (fs.choice) {  void
466          case SETUP_KEYGEN:  winpt_debug_msg (void)
467              c.interactive = 1;  {      
468              c.first_start = 1;      char output[512];
469              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,      char temp[128];
470                                   h, keygen_wizard_dlg_proc, (LPARAM)&c);          
471              if (!rc)      GetTempPath (DIM (temp) -1, temp);
472                  goto start;      _snprintf (output, DIM (output)-1,
473              break;          "The GPGME output file is %sgpgme.dbg\n"
474            "The WinPT output file is %swinpt.log\n", temp, temp);
475          case SETUP_IMPORT:      MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
476              rc = gnupg_copy_keyrings ();  }
477              if (rc) {  
478                  msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);  
479                  goto start;  /* Search for insecure ElGamal keys and return the
480              }     number of founded keys. */
481              break;  static int
482    count_insecure_elgkeys (void)
483          case -1:  {
484              DestroyWindow (hwnd);      gpg_keycache_t pc;
485              free_gnupg_table ();      gpgme_key_t key;
486              return 0;      int n = 0;
487          }  
488          update_keycache (hwnd);      pc = keycache_get_ctx (1);
489          check_crypto_engine ();      while (!gpg_keycache_next_key (pc, 0, &key)) {
490      }          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
491      else {              n++;
492          gpgme_keycache_t c;      }
493          update_keycache (hwnd);      gpg_keycache_rewind (pc);
494          c = keycache_get_ctx (1);      return n;
495          if (!c || !gpgme_keycache_count (c)) {  }
496              gnupg_display_error ();  
497              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"  
498                               "Please check your GPG config (keyrings, pathes...)"),  /* Main entry point. */
499                               _("WinPT Error"), MB_ERR);  int WINAPI
500              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
501                                    "Do you want to start the GPG preferences dialog?"),  {
502                              "WinPT", MB_INFO|MB_YESNO);      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
503              if (ec == IDYES) {      HACCEL accel_tab;
504                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,      MSG msg;
505                                  gpgprefs_dlg_proc, NULL);      HWND hwnd = NULL;
506                  update_keycache (hwnd);      WORD ver[3], ptdver[4];
507              }      const char *s;
508              else {      int rc, ec, created = 0;
509                  DestroyWindow (hwnd);      int first_start = 0, start_gpgprefs = 0;
510                  free_gnupg_table ();      int winpt_inst_found = 0;
511                  return 0;      int start_manager = 0;    
512              }  
513          }  #ifdef WINPT_MOBILE
514          if (check_default_key (c)) {      /* Do not continue in case of problems. */
515              char * p = get_gnupg_default_key ();      if (enable_mobile_mode ())
516              log_box (_("WinPT Error"), MB_ERR,          return 0;
517                       _("Default key from the GPG options file could not be found.\n"  #endif
518                         "Please check your gpg.conf (options) to correct this:\n\n"  
519                         "%s: public key not found."), p? p : "[null]");      glob_hinst = hinst;
520              free_if_alloc (p);      if (cmdline && stristr (cmdline, "--stop")) {
521              DestroyWindow (hwnd);          hwnd = FindWindow ("WinPT", "WinPT");
522              free_gnupg_table ();          if (hwnd != NULL)
523              return 0;              PostMessage (hwnd, WM_DESTROY, 0, 0);
524          }          return 0;
525          if (count_insecure_elgkeys ())      }
526              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,  
527                              elgamal_warn_dlg_proc, NULL);  #ifdef _DEBUG
528      }      gpg_set_debug_mode (1);
529        debug = 1;
530      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);  #endif
531      keyring_check_last_access (); /* init */  
532      while (GetMessage (&msg, hwnd, 0, 0)) {      get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
533          if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],  
534              TranslateMessage (&msg);                                   &ptdver[2], &ptdver[3]);
535              DispatchMessage (&msg);      
536          }      if (!ec && (ptdver[0] != ver[0] ||
537      }                  ptdver[1] != ver[1] ||
538                            ptdver[2] != ver[2])) {
539      return 0;          log_box (_("WinPT Error"), MB_ERR,
540  } /* WinMain */                   _("The PTD.dll file has a different version than WinPT.exe\n"
541                       "Please update the PTD.dll to version %d.%d.%d"),
542                       ver[0], ver[1], ver[2]);
543            return 0;
544        }
545    
546        if (gpg_md_selftest ()) {
547            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.23  
changed lines
  Added in v.278
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26