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

Diff of /trunk/Src/wptPassphraseCB.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 47 by werner, Mon Oct 31 14:04:59 2005 UTC
# Line 1  Line 1 
1  /* wptPassphraseCB.cpp - GPGME Passphrase Callback  /* wptPassphraseCB.cpp - GPGME Passphrase Callback
2   *      Copyright (C) 2001, 2002, 2003, 2005 Timo Schulz   *      Copyright (C) 2001, 2002, 2003, 2005 Timo Schulz
3   *      Copyright (C) 2005 g10 Code GmbH   *      Copyright (C) 2005 g10 Code GmbH
4   *   *
5   * This file is part of WinPT.   * This file is part of WinPT.
6   *   *
7   * WinPT is free software; you can redistribute it and/or   * WinPT is free software; you can redistribute it and/or
8   * modify it under the terms of the GNU General Public License   * modify it under the terms of the GNU General Public License
9   * as published by the Free Software Foundation; either version 2   * as published by the Free Software Foundation; either version 2
10   * of the License, or (at your option) any later version.   * of the License, or (at your option) any later version.
11   *     *  
12   * WinPT is distributed in the hope that it will be useful,   * WinPT is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15   * General Public License for more details.   * General Public License for more details.
16   *   *
17   * You should have received a copy of the GNU General Public License   * You should have received a copy of the GNU General Public License
18   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
19   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20   */   */
21    
22  #include <windows.h>  #ifdef HAVE_CONFIG_H
23  #include <ctype.h>  #include <config.h>
24    #endif
25  #include "../resource.h"  
26  #include "wptNLS.h"  #include <windows.h>
27  #include "wptW32API.h"  #include <windows.h>
28  #include "wptVersion.h"  #include <ctype.h>
29  #include "wptGPG.h"  
30  #include "wptCommonCtl.h"  #include "resource.h"
31  #include "wptContext.h"  #include "wptNLS.h"
32  #include "wptDlgs.h"  #include "wptW32API.h"
33  #include "wptUTF8.h"  #include "wptVersion.h"
34  #include "wptErrors.h"  #include "wptGPG.h"
35  #include "wptTypes.h"  #include "wptCommonCtl.h"
36  #include "wptKeyList.h"  #include "wptContext.h"
37  #include "wptAgent.h"  #include "wptDlgs.h"
38  #include "wptRegistry.h"  #include "wptUTF8.h"
39    #include "wptErrors.h"
40  const char* get_symkey_algo (int algo);  #include "wptTypes.h"
41    #include "wptKeyList.h"
42  #define item_ctrl_id( cmd ) \  #include "wptAgent.h"
43      ((cmd) == GPG_CMD_DECRYPT? IDC_DECRYPT_PWD : IDC_DECRYPT_SIGN_PWD)  #include "wptRegistry.h"
44    
45  #define item_ctrl_id2(cmd) \  const char* get_symkey_algo (int algo);
46      ((cmd) == GPG_CMD_DECRYPT? IDC_DECRYPT_HIDE : IDC_DECRYPT_SIGN_HIDE)  
47    #define item_ctrl_id( cmd ) \
48        ((cmd) == GPG_CMD_DECRYPT? IDC_DECRYPT_PWD : IDC_DECRYPT_SIGN_PWD)
49  /* Overwrite passphrase and free memory. */  
50  static void  #define item_ctrl_id2(cmd) \
51  burn_passphrase (char **pwd)      ((cmd) == GPG_CMD_DECRYPT? IDC_DECRYPT_HIDE : IDC_DECRYPT_SIGN_HIDE)
52  {  
53      char *pass = *pwd;    
54      memset (pass, 0, strlen (pass));  /* Overwrite passphrase and free memory. */
55      delete []pass;  static void
56      *pwd = NULL;  burn_passphrase (char **pwd)
57  }  {
58        char *pass = *pwd;
59        wipememory (pass, strlen (pass));
60  /* Dialog procedure for the passphrase callback. */      delete []pass;
61  static BOOL CALLBACK      *pwd = NULL;
62  passphrase_callback_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  }
63  {      
64      static passphrase_cb_s * c;  
65      gpgme_decrypt_result_t res;  /* Dialog procedure for the passphrase callback. */
66      gpgme_sign_result_t res_sig;  static BOOL CALLBACK
67      gpgme_key_t key;  passphrase_callback_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
68      void *ctx = NULL, *item;  {    
69      const char *id;      static passphrase_cb_s * c;
70      char *info;      gpgme_decrypt_result_t res;
71      int n;      gpgme_sign_result_t res_sig;
72        gpgme_key_t key;
73      /* XXX: we need a timer to update the 'enc_to' entries. */      gpgme_recipient_t recip, r;
74      switch (msg) {      void *ctx = NULL, *item;
75      case WM_INITDIALOG:      const char *id;
76          c = (passphrase_cb_s *)lparam;      char *info;
77          if (!c)      int n;
78              BUG (0);  
79          SetWindowText (dlg, c->title);      switch (msg) {
80          if (c->gpg_cmd == GPG_CMD_DECRYPT) {      case WM_INITDIALOG:
81              SetDlgItemText( dlg, IDC_DECRYPT_LISTINF,          c = (passphrase_cb_s *)lparam;
82                  _("Encrypted with the following public key(s)") );          if (!c)
83              CheckDlgButton( dlg, IDC_DECRYPT_HIDE, BST_CHECKED );              BUG (0);
84          }          SetWindowText (dlg, c->title);
85          else if (c->gpg_cmd == GPG_CMD_SIGN)          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
86              CheckDlgButton (dlg, IDC_DECRYPT_SIGN_HIDE, BST_CHECKED);              SetDlgItemText (dlg, IDC_DECRYPT_LISTINF,
87          res = gpgme_op_decrypt_result (c->gpg);                              _("Encrypted with the following public key(s)"));
88          if (res != NULL && c->gpg_cmd == GPG_CMD_DECRYPT) {              CheckDlgButton (dlg, IDC_DECRYPT_HIDE, BST_CHECKED);
89              gpgme_recipient_t r;          }
90            else if (c->gpg_cmd == GPG_CMD_SIGN)
91              /* XXX: not all ENCRYPT_TO entries are listed here. */              CheckDlgButton (dlg, IDC_DECRYPT_SIGN_HIDE, BST_CHECKED);
92              for (r = res->recipients; r; r = r->next) {          if (c->recipients)
93                  get_pubkey (r->keyid, &key);              recip = c->recipients; /* recipients were already extracted. */
94                  if (key) {          else {
95                      char *uid;              /* XXX: not all ENCRYPT_TO entries are listed here. */
96                      id = key->uids->name;              res = gpgme_op_decrypt_result (c->gpg);
97                      if (!id)              if (res && res->recipients)
98                          id = _("Invalid User ID");                  recip = res->recipients;
99                      uid = utf8_to_wincp (id, strlen (id));          }
100                      info = new char [32+strlen (uid)+1 + 4 + strlen (r->keyid)+1          if (recip != NULL && c->gpg_cmd == GPG_CMD_DECRYPT) {
101                                       + strlen (key->uids->email)+1];              for (r = res->recipients; r; r = r->next) {
102                      if (!info)                  get_pubkey (r->keyid, &key);
103                          BUG (NULL);                  if (key) {
104                      sprintf (info, "%s <%s> (%s, 0x%s)", uid, key->uids->email,                      char *uid;
105                               get_key_pubalgo (r->pubkey_algo), r->keyid+8);                      id = key->uids->name;
106                      free (uid);                      if (!id)
107                                                id = _("Invalid User ID");
108                  }                      uid = utf8_to_wincp (id, strlen (id));
109                  else {                      info = new char [32+strlen (uid)+1 + 4 + strlen (r->keyid)+1
110                      info = new char [32 + strlen (r->keyid)+1 + 4];                                       + strlen (key->uids->email)+1];
111                      if (!info)                      if (!info)
112                          BUG (NULL);                          BUG (NULL);
113                      sprintf (info, _("Unknown key ID (%s, 0x%s)"),                      sprintf (info, "%s <%s> (%s, 0x%s)", uid, key->uids->email,
114                               get_key_pubalgo (r->pubkey_algo), r->keyid+8);                               get_key_pubalgo (r->pubkey_algo), r->keyid+8);
115                  }                      free (uid);
116                  listbox_add_string (GetDlgItem (dlg, IDC_DECRYPT_LIST), info);                      
117                  free_if_alloc (info);                  }
118              }                  else {
119          }                      info = new char [32 + strlen (r->keyid)+1 + 4];
120          else if (c->gpg_cmd == GPG_CMD_DECRYPT)                      if (!info)
121              EnableWindow (GetDlgItem (dlg, IDC_DECRYPT_LIST), FALSE);                          BUG (NULL);
122          SetDlgItemText (dlg, c->gpg_cmd == GPG_CMD_DECRYPT?                      sprintf (info, _("Unknown key ID (%s, 0x%s)"),
123                          IDC_DECRYPT_PWDINFO : IDC_DECRYPT_SIGN_PWDINFO,                               get_key_pubalgo (r->pubkey_algo), r->keyid+8);
124                          c->bad_pwd? _("Bad passphrase; Enter passphrase again") :                  }
125                          _("Please enter your passphrase"));                  listbox_add_string (GetDlgItem (dlg, IDC_DECRYPT_LIST), info);
126          if (c->gpg_cmd == GPG_CMD_DECRYPT) {                  free_if_alloc (info);
127              SetFocus (GetDlgItem (dlg, IDC_DECRYPT_PWD));              }
128              if (res && !res->recipients) {          }
129                  const char *s = _("Symmetric encryption.\n"          else if (c->gpg_cmd == GPG_CMD_DECRYPT)
130                                    "%s encrypted data.");              EnableWindow (GetDlgItem (dlg, IDC_DECRYPT_LIST), FALSE);
131                  const char *alg = get_symkey_algo (c->sym.sym_algo);          SetDlgItemText (dlg, c->gpg_cmd == GPG_CMD_DECRYPT?
132                  info = new char[strlen (s) + strlen (alg) + 2];                          IDC_DECRYPT_PWDINFO : IDC_DECRYPT_SIGN_PWDINFO,
133                  if (!info)                          c->bad_pwd? _("Bad passphrase; Enter passphrase again") :
134                      BUG (NULL);                          _("Please enter your passphrase"));
135                  sprintf (info, s, alg);          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
136                  SetDlgItemText (dlg, IDC_DECRYPT_MSG, info);              SetFocus (GetDlgItem (dlg, IDC_DECRYPT_PWD));
137                  free_if_alloc (info);              if (res && !res->recipients) {
138              }                  const char *s = _("Symmetric encryption.\n"
139              else                                    "%s encrypted data.");
140                  SetDlgItemText (dlg, IDC_DECRYPT_MSG, c->info);                  const char *alg = get_symkey_algo (c->sym.sym_algo);
141          }                  info = new char[strlen (s) + strlen (alg) + 2];
142          else {                  if (!info)
143              SetFocus( GetDlgItem (dlg, IDC_DECRYPT_SIGN_PWD));                      BUG (NULL);
144              SetDlgItemText (dlg, IDC_DECRYPT_SIGN_MSG, c->info);                  sprintf (info, s, alg);
145          }                  SetDlgItemText (dlg, IDC_DECRYPT_MSG, info);
146          center_window (dlg, NULL);                  free_if_alloc (info);
147          SetForegroundWindow (dlg);              }
148          set_active_window (dlg);              else
149          return FALSE;                  SetDlgItemText (dlg, IDC_DECRYPT_MSG, c->info);
150            }
151          case WM_SYSCOMMAND:          else {
152              if (LOWORD (wparam) == SC_CLOSE) {              SetFocus( GetDlgItem (dlg, IDC_DECRYPT_SIGN_PWD));
153                  SetDlgItemText (dlg, item_ctrl_id( c->gpg_cmd ), "");              SetDlgItemText (dlg, IDC_DECRYPT_SIGN_MSG, c->info);
154                  c->cancel = 1;          }
155                  EndDialog (dlg, TRUE);          center_window (dlg, NULL);
156              }          SetForegroundWindow (dlg);
157              break;          set_active_window (dlg);
158            return FALSE;
159          case WM_COMMAND:  
160              switch( HIWORD( wparam ) ) {          case WM_SYSCOMMAND:
161              case BN_CLICKED:              if (LOWORD (wparam) == SC_CLOSE) {
162                  if ( LOWORD( wparam ) == IDC_DECRYPT_HIDE                  SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "");
163                      || LOWORD( wparam ) == IDC_DECRYPT_SIGN_HIDE ) {                  c->cancel = 1;
164                      HWND hwnd;                  EndDialog (dlg, TRUE);
165                      int hide = IsDlgButtonChecked (dlg, item_ctrl_id2 (c->gpg_cmd));              }
166                      hwnd = GetDlgItem (dlg, item_ctrl_id (c->gpg_cmd));              break;
167                      SendMessage (hwnd, EM_SETPASSWORDCHAR, hide? '*' : 0, 0);  
168                      SetFocus (hwnd);          case WM_COMMAND:
169                  }              switch (HIWORD (wparam)) {
170              }              case BN_CLICKED:
171                    if  (LOWORD (wparam) == IDC_DECRYPT_HIDE
172              switch (LOWORD (wparam)) {                      || LOWORD (wparam) == IDC_DECRYPT_SIGN_HIDE) {
173              case IDOK:                        HWND hwnd;
174                  /* fixme: the item is even cached when the passphrase is not                      int hide = IsDlgButtonChecked (dlg, item_ctrl_id2 (c->gpg_cmd));
175                            correct, which means that the user needs to delete all                      hwnd = GetDlgItem (dlg, item_ctrl_id (c->gpg_cmd));
176                            cached entries to continue. */                      SendMessage (hwnd, EM_SETPASSWORDCHAR, hide? '*' : 0, 0);
177                  if (c->pwd)                      SetFocus (hwnd);
178                      burn_passphrase (&c->pwd);                  }
179                  n = item_get_text_length (dlg, item_ctrl_id (c->gpg_cmd));              }
180                  if (!n) {  
181                      c->pwd = new char[2];              switch (LOWORD (wparam)) {
182                      if (!c->pwd)              case IDOK:  
183                          BUG (NULL);                  /* XXX: the item is even cached when the passphrase is not
184                      strcpy (c->pwd, "");                          correct, which means that the user needs to delete all
185                  }                          cached entries to continue. */
186                  else {                  if (c->pwd)
187                      c->pwd = new char[n+2];                      burn_passphrase (&c->pwd);
188                      if (!c->pwd)                  n = item_get_text_length (dlg, item_ctrl_id (c->gpg_cmd));
189                          BUG (NULL);                  if (!n) {
190                      GetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), c->pwd, n+1);                      c->pwd = new char[2];
191                  }                      if (!c->pwd)
192                  res = gpgme_op_decrypt_result (c->gpg);                          BUG (NULL);
193                  if (!res)                      strcpy (c->pwd, "");
194                      res_sig = gpgme_op_sign_result (c->gpg);                  }
195                  if (reg_prefs.cache_time > 0 && !c->is_card &&                  else {
196                      ((res && res->recipients) || (res_sig && res_sig->signatures))) {                      c->pwd = new char[n+2];
197                      if (agent_get_cache (c->keyid, &item))                      if (!c->pwd)
198                          agent_unlock_cache_entry (&item);                          BUG (NULL);
199                      else                      GetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), c->pwd, n+1);
200                          agent_put_cache (c->keyid, c->pwd, reg_prefs.cache_time);                  }
201                  }                  res = gpgme_op_decrypt_result (c->gpg);
202                  EndDialog (dlg, TRUE);                  if (!res)
203                  return TRUE;                      res_sig = gpgme_op_sign_result (c->gpg);
204                                    if (reg_prefs.cache_time > 0 && !c->is_card &&
205              case IDCANCEL:                      ((res && res->recipients) || (res_sig && res_sig->signatures))) {
206                  SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "" );                      if (agent_get_cache (c->keyid, &item))
207                  c->cancel = 1;                          agent_unlock_cache_entry (&item);
208                  EndDialog (dlg, FALSE);                      else
209                  return FALSE;                          agent_put_cache (c->keyid, c->pwd, reg_prefs.cache_time);
210              }                  }
211              break;                  c->cancel = 0;
212      }                  EndDialog (dlg, TRUE);
213                        return TRUE;
214      return FALSE;                  
215  }              case IDCANCEL:
216                    SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "");
217                    c->cancel = 1;
218  /* Extract the main keyid from @pass_info.                  EndDialog (dlg, FALSE);
219     Return value: long main keyid or NULL for an error. */                  return FALSE;
220  static const char*              }
221  parse_gpg_keyid (const char *pass_info)              break;
222  {      }
223      static char keyid[16+1];      
224            return FALSE;
225      /* XXX: check for leading alpha-chars? */  }
226      if (strlen (pass_info) < 16)  
227          return NULL;  
228      /* the format of the desc buffer looks like this:  /* Extract the main keyid from @pass_info.
229         request_keyid[16] main_keyid[16] keytype[1] keylength[4]     Return value: long main keyid or NULL for an error. */
230         we use the main keyid to use only one cache entry. */  static const char*
231      strncpy (keyid, pass_info+17, 16);  parse_gpg_keyid (const char *pass_info)
232      keyid[16] = 0;  {
233      return keyid;      static char keyid[16+1];
234  }      
235        /* XXX: check for leading alpha-chars? */
236        if (strlen (pass_info) < 16)
237  /* Parse the information in @uid_hint and @pass_info to generate          return NULL;
238     a input message for the user in @desc. */      /* the format of the desc buffer looks like this:
239  static int         request_keyid[16] main_keyid[16] keytype[1] keylength[4]
240  parse_gpg_description (const char *uid_hint, const char *pass_info,         we use the main keyid to use only one cache entry. */
241                         char *desc, int size)      strncpy (keyid, pass_info+17, 16);
242  {      keyid[16] = 0;
243      gpgme_pubkey_algo_t algo;      return keyid;
244      char usedkey[16+1], mainkey[16+1];  }
245      char *uid, *p;  
246      int n=0;  
247    /* Parse the information in @uid_hint and @pass_info to generate
248      if (strlen (uid_hint) < 17) {     a input message for the user in @desc. */
249          *desc = 0;  static int
250          return -1;  parse_gpg_description (const char *uid_hint, const char *pass_info,
251      }                         char *desc, int size)
252    {
253      while (p = strsep ((char**)&pass_info, " ")) {      gpgme_pubkey_algo_t algo;
254          switch (n++) {      char usedkey[16+1];
255          case 0: strncpy (mainkey, p, 16); mainkey[16] = 0; break;      char mainkey[16+1];
256          case 1: strncpy (usedkey, p, 16); usedkey[16] = 0; break;      char *uid, *p;
257          case 2: algo = (gpgme_pubkey_algo_t)atol (p); break;      int n=0;
258          }  
259      }      /* Each uid_hint contains a long key-ID so it is at least 16 bytes. */
260      uid_hint += 16; /* skip keyid */      if (strlen (uid_hint) < 17) {
261      uid_hint += 1;  /* space */          *desc = 0;
262            return -1;
263      uid = utf8_to_wincp (uid_hint, strlen (uid_hint));      }
264    
265      if (strcmp (usedkey, mainkey))      while (p = strsep ((char**)&pass_info, " ")) {
266          _snprintf (desc, size-1,          switch (n++) {
267                     _("You need a passphrase to unlock the secret key for\n"          case 0: strncpy (mainkey, p, 16); mainkey[16] = 0; break;
268                       "user: \"%s\"\n"          case 1: strncpy (usedkey, p, 16); usedkey[16] = 0; break;
269                       "%s key, ID %s (main key ID %s)\n"),          case 2: algo = (gpgme_pubkey_algo_t)atol (p); break;
270                     uid, get_key_pubalgo (algo), usedkey+8, mainkey+8);          }
271      else if (!strcmp (usedkey, mainkey))      }
272          _snprintf (desc, size-1,      uid_hint += 16; /* skip keyid */
273                     _("You need a passphrase to unlock the secret key for\n"      uid_hint += 1;  /* space */
274                       "user: \"%s\"\n"  
275                       "%s key, ID %s\n"),      uid = utf8_to_wincp (uid_hint, strlen (uid_hint));
276                       uid, get_key_pubalgo (algo), usedkey+8);  
277      free (uid);      if (strcmp (usedkey, mainkey))
278      return 0;          _snprintf (desc, size-1,
279  }                     _("You need a passphrase to unlock the secret key for\n"
280                         "user: \"%s\"\n"
281                         "%s key, ID %s (main key ID %s)\n"),
282  /*                     uid, get_key_pubalgo (algo), usedkey+8, mainkey+8);
283  static int inline      else if (!strcmp (usedkey, mainkey))
284  is_hexstring (const char * p)          _snprintf (desc, size-1,
285  {                     _("You need a passphrase to unlock the secret key for\n"
286      size_t i;                       "user: \"%s\"\n"
287                         "%s key, ID %s\n"),
288      for (i=0; i < strlen (p); i++) {                       uid, get_key_pubalgo (algo), usedkey+8);
289          if (!isxdigit (p[i]))      free (uid);
290              return -1;      return 0;
291      }  }
292      return 0;  
293  }  
294  */  /* Extract the serial number from the card ID @id and return it. */
295    const char*
296    extract_serial_no (const char *id)
297  /* Extract the serial number from the card ID @id and return it. */  {
298  const char*      static char buf[8];
299  extract_serial_no (const char *id)      char *p;
300  {  
301      static char buf[8];      p = strchr (id, '/');
302      char *p;      if (!p)
303            return NULL;
304      p = strchr (id, '/');      strncpy (buf, id+(p-id)-6, 6);
305      if (!p)      return buf;
306          return NULL;  }
307      strncpy (buf, id+(p-id)-6, 6);  
308      return buf;  
309  }  /* Passphrase callback with the ability to support caching. */
310    gpgme_error_t
311    passphrase_cb (void *hook, const char *uid_hint,
312  /* Passphrase callback with the ability to support caching. */                 const char *passphrase_info,
313  gpgme_error_t                 int prev_was_bad, int fd)
314  passphrase_cb (void *hook, const char *uid_hint,  {
315                 const char *passphrase_info,      passphrase_cb_s *c = (passphrase_cb_s*)hook;
316                 int prev_was_bad, int fd)      HANDLE hd = (HANDLE)fd;
317  {      void *item;
318      passphrase_cb_s *c = (passphrase_cb_s*)hook;      const char *keyid, *pass;
319      HANDLE hd = (HANDLE)fd;      DWORD n;
320      void *item;      int rc;
321      const char *keyid, *pass;  
322      DWORD n;      if (!c)
323      int rc;          return gpg_error (GPG_ERR_INV_ARG);
324        c->bad_pwd = prev_was_bad? 1 : 0;
325      if (!c)      if (prev_was_bad && !c->cancel) {
326          return gpg_error (GPG_ERR_INV_ARG);          if (c->pwd)
327      c->bad_pwd = prev_was_bad? 1 : 0;              burn_passphrase (&c->pwd);
328      if (prev_was_bad && !c->cancel) {          agent_del_cache (c->keyid);
329          if (c->pwd)          c->pwd_init = 1;
330              burn_passphrase (&c->pwd);      }
331          agent_del_cache (c->keyid);  
332          c->pwd_init = 1;      if (passphrase_info) {
333      }          if (strlen (passphrase_info) < 16 &&
334                !strstr (passphrase_info, "OPENPGP")) {
335      if (passphrase_info) {              /* assume symetric encryption. */
336          if (strlen (passphrase_info) < 16 &&              int n=2;
337              !strstr (passphrase_info, "OPENPGP")) {/* assume symetric encryption. */              c->sym.sym_algo = atoi (passphrase_info);
338              int n=2;              if (c->sym.sym_algo > 9)
339              c->sym.sym_algo = atoi (passphrase_info);                  n++;
340              if (c->sym.sym_algo > 9)              /* XXX: be more strict. */
341                  n++;              c->sym.s2k_mode = atoi (passphrase_info+n);
342              /* XXX: be more strict. */              c->sym.s2k_hash = atoi (passphrase_info+n+2);
343              c->sym.s2k_mode = atoi (passphrase_info+n);          }
344              c->sym.s2k_hash = atoi (passphrase_info+n+2);  
345          }          keyid = parse_gpg_keyid (passphrase_info);
346            pass = agent_get_cache (keyid+8, &item);
347          keyid = parse_gpg_keyid (passphrase_info);          if (pass) {
348          pass = agent_get_cache (keyid+8, &item);              agent_unlock_cache_entry (&item);
349          if (pass) {              c->pwd_init = 0;
350              agent_unlock_cache_entry (&item);              if (!WriteFile (hd, pass, strlen (pass), &n, NULL))
351              c->pwd_init = 0;                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
352              if (!WriteFile (hd, pass, strlen (pass), &n, NULL))              if (!WriteFile (hd, "\n", 1, &n, NULL))
353                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
354              if (!WriteFile (hd, "\n", 1, &n, NULL))              return 0;
355                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);          }
356              return 0;      }
357          }  
358      }      if (c->pwd_init) {
359            if (keyid && strlen (keyid) == 16)
360      if (c->pwd_init) {              strcpy (c->keyid, keyid+8);
361          if (keyid && strlen (keyid) == 16)  
362              strcpy (c->keyid, keyid+8);          /* if @passphrase_info contains 'OPENPGP' we assume a smart card
363                has been used. */
364          /* if @passphrase_info contains 'OPENPGP' we assume a smart card          if (strstr (passphrase_info, "OPENPGP")) {
365              has been used. */              const char *s=passphrase_info;
366          if (strstr (passphrase_info, "OPENPGP")) {              while (s && *s && *s != 'D')
367              const char *s=passphrase_info;                  s++;
368              while (s && *s && *s != 'D')              _snprintf (c->info, sizeof c->info-1,
369                  s++;                         _("Please enter the PIN to unlock your secret card key\n"
370              _snprintf (c->info, sizeof c->info-1,                           "Card: %s"), extract_serial_no (s));
371                         _("Please enter the PIN to unlock your secret card key\n"              c->is_card = 1;
372                           "Card: %s"), extract_serial_no (s));          }
373              c->is_card = 1;          else if (uid_hint)
374          }              parse_gpg_description (uid_hint, passphrase_info,
375          else if (uid_hint)                                     c->info, sizeof c->info - 1);
376              parse_gpg_description (uid_hint, passphrase_info,          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
377                                     c->info, sizeof c->info - 1);              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,
378          if (c->gpg_cmd == GPG_CMD_DECRYPT) {                                   (HWND)c->hwnd, passphrase_callback_proc,
379              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,                                   (LPARAM)c);
380                                   (HWND)c->hwnd, passphrase_callback_proc,          }
381                                   (LPARAM)c);          else if (c->gpg_cmd == GPG_CMD_SIGN) {
382          }              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT_SIGN,
383          else if (c->gpg_cmd == GPG_CMD_SIGN) {                                   (HWND)c->hwnd, passphrase_callback_proc,
384              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT_SIGN,                                   (LPARAM)c);
385                                   (HWND)c->hwnd, passphrase_callback_proc,          }
386                                   (LPARAM)c);          if (rc == -1) {
387          }              if (!WriteFile (hd, "\n", 1, &n, NULL))
388          if (rc == -1) {                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
389              WriteFile (hd, "\n", 1, &n, NULL);              return 0;
390              return 0;          }
391          }          c->pwd_init = 0;
392          c->pwd_init = 0;      }
393      }      if (c->cancel) {
394      if (c->cancel) {          if (!WriteFile (hd, "\n", 1, &n, NULL))
395          WriteFile (hd, "\n", 1, &n, NULL);              log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
396          return 0;          return 0;
397      }      }
398    
399      WriteFile (hd, c->pwd, strlen (c->pwd), &n, NULL);      WriteFile (hd, c->pwd, strlen (c->pwd), &n, NULL);
400      WriteFile (hd, "\n", 1, &n, NULL);      WriteFile (hd, "\n", 1, &n, NULL);
401      return 0;      return 0;
402  }  }
403    
404    
405  /* Initialize the given passphrase callback @cb with the  /* Initialize the given passphrase callback @cb with the
406     used gpgme context @ctx, the command @cmd and a title     used gpgme context @ctx, the command @cmd and a title
407     @title for the dialog. */     @title for the dialog. */
408  void  void
409  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,
410                         int cmd, HWND hwnd, const char *title)                         int cmd, HWND hwnd, const char *title)
411  {  {
412      memset (cb, 0, sizeof *cb);      memset (cb, 0, sizeof *cb);
413      cb->gpg_cmd = cmd;      cb->gpg_cmd = cmd;
414      cb->bad_pwd = 0;      cb->bad_pwd = 0;
415      cb->is_card = 0;      cb->is_card = 0;
416      cb->cancel = 0;      cb->cancel = 0;
417      cb->hwnd = hwnd;      cb->hwnd = hwnd;
418      cb->pwd_init = 1;      cb->pwd_init = 1;
419      free_if_alloc (cb->title);      free_if_alloc (cb->title);
420      cb->title = m_strdup (title);      cb->title = m_strdup (title);
421      if (!cb->title)      if (!cb->title)
422          BUG (NULL);          BUG (NULL);
423      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);
424      cb->gpg = ctx;      cb->gpg = ctx;
425  }  }
426    
427    
428  /* Release a passphrase callback @ctx. */  /* Release a passphrase callback @ctx. */
429  void  void
430  release_gpg_passphrase_cb (passphrase_cb_s *ctx)  release_gpg_passphrase_cb (passphrase_cb_s *ctx)
431  {  {
432      if (!ctx)      gpgme_recipient_t r, n;
433          return;  
434      sfree_if_alloc (ctx->pwd);      if (!ctx)
435      free_if_alloc (ctx->title);          return;
436  }      sfree_if_alloc (ctx->pwd);
437        free_if_alloc (ctx->title);
438        r = ctx->recipients;
439  /* Simple check to measure passphrase (@pass) quality.      while (r) {
440     Return value: 0 on success. */          n = r->next;
441  int          safe_free (r->keyid);
442  check_passwd_quality (const char *pass, int strict)          safe_free (r);
443  {          r = n;
444      int i, nd=0, nc=0, n;      }
445    }
446      n = strlen (pass);  
447      if (n < 8)  
448          return -1;  /* Simple check to measure passphrase (@pass) quality.
449       Return value: 0 on success. */
450      for (i=0; i < n; i++) {  int
451          if (isdigit (pass[i])) nd++;  check_passwd_quality (const char *pass, int strict)
452          if (isalpha (pass[i])) nc++;  {
453      }      int i, nd=0, nc=0, n;
454    
455      if (nd == n || nc == n)      n = strlen (pass);
456          return -1;      if (n < 8)
457            return -1;
458      return 0;  
459  }      for (i=0; i < n; i++) {
460            if (isdigit (pass[i]))
461                nd++;
462            if (isalpha (pass[i]))
463                nc++;
464        }
465    
466        /* check that the passphrase contains letters and numbers. */
467        if (nd == n || nc == n)
468            return -1;
469    
470        return 0;
471    }
Legend:
Removed from v.28  
changed lines
  Added in v.47
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26