/[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 187 by twoaday, Wed Mar 22 11:04:20 2006 UTC revision 333 by twoaday, Tue Oct 13 10:51:21 2009 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-2006, 2009 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.
# Line 13  Line 13 
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.
  *  
  * You should have received a copy of the GNU General Public License  
  * along with WinPT; if not, write to the Free Software Foundation,  
  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA  
16   */   */
   
17  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
18  #include <config.h>  #include <config.h>
19  #endif  #endif
# Line 34  Line 29 
29  #include "wptCommonCtl.h"  #include "wptCommonCtl.h"
30  #include "wptContext.h"  #include "wptContext.h"
31  #include "wptDlgs.h"  #include "wptDlgs.h"
 #include "wptUTF8.h"  
32  #include "wptErrors.h"  #include "wptErrors.h"
33  #include "wptTypes.h"  #include "wptTypes.h"
34  #include "wptKeylist.h"  #include "wptKeylist.h"
35  #include "wptAgent.h"  #include "wptAgent.h"
36  #include "wptRegistry.h"  #include "wptRegistry.h"
37    #include "wptUTF8.h"
38    #include "StringBuffer.h"
39    
 const char* get_symkey_algo (int algo);  
40    
41    /* Return the control ID dependent on the mode (sign or decrypt). */
42  #define item_ctrl_id(cmd) \  #define item_ctrl_id(cmd) \
43      ((cmd) == GPG_CMD_DECRYPT? IDC_DECRYPT_PWD : IDC_DECRYPT_SIGN_PWD)      ((cmd) == GPG_CMD_DECRYPT? IDC_DECRYPT_PWD : IDC_DECRYPT_SIGN_PWD)
44    
45  #define item_ctrl_id2(cmd) \  #define item_ctrl_id2(cmd) \
46      ((cmd) == GPG_CMD_DECRYPT? IDC_DECRYPT_HIDE : IDC_DECRYPT_SIGN_HIDE)      ((cmd) == GPG_CMD_DECRYPT? IDC_DECRYPT_HIDE : IDC_DECRYPT_SIGN_HIDE)
47    
48    const char* get_symkey_algo (int algo);
49    
50    
51  /* Overwrite passphrase and free memory. */  /* Overwrites the passphrase and free the memory.
52       Pointer is also reset to NULL. */
53  static void  static void
54  burn_passphrase (char **pwd)  burn_passphrase (char **pwd)
55  {  {
56      char *pass = *pwd;      char *pass = *pwd;
57    
58      wipememory (pass, strlen (pass));      wipememory (pass, strlen (pass));
59      delete []pass;      delete []pass;
60      *pwd = NULL;      *pwd = NULL;
# Line 68  passphrase_callback_proc (HWND dlg, UINT Line 68  passphrase_callback_proc (HWND dlg, UINT
68      static passphrase_cb_s *c;      static passphrase_cb_s *c;
69      gpgme_decrypt_result_t res=NULL;      gpgme_decrypt_result_t res=NULL;
70      gpgme_sign_result_t res_sig=NULL;      gpgme_sign_result_t res_sig=NULL;
     gpgme_key_t key;  
71      gpgme_recipient_t recip=NULL, r;      gpgme_recipient_t recip=NULL, r;
72        winpt_key_s key;
73      void *item;      void *item;
     const char *id;  
     char *info;  
74      int n;      int n;
75    
76      switch (msg) {      switch (msg) {
77      case WM_ACTIVATE:      case WM_ACTIVATE:
78          safe_edit_control_init (dlg, item_ctrl_id (c->gpg_cmd));          /* Some people complained that it is no longer possible to
79               paste in the passphrase in this dialog. When this option
80               is enabled, the ordinary passphrase control will be used. */
81            if (!reg_prefs.no_safe_pwd_ctrl)
82                safe_edit_control_init (dlg, item_ctrl_id (c->gpg_cmd));
83          break;          break;
84    
85      case WM_DESTROY:      case WM_DESTROY:
86          safe_edit_control_free (dlg, item_ctrl_id (c->gpg_cmd));          if (!reg_prefs.no_safe_pwd_ctrl)
87                safe_edit_control_free (dlg, item_ctrl_id (c->gpg_cmd));
88          break;          break;
89    
90      case WM_INITDIALOG:      case WM_INITDIALOG:
# Line 89  passphrase_callback_proc (HWND dlg, UINT Line 92  passphrase_callback_proc (HWND dlg, UINT
92          if (!c)          if (!c)
93              BUG (0);              BUG (0);
94          SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));          SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
         SetDlgItemText (dlg, IDC_DECRYPT_HIDE, _("&Hide Typing"));  
95          SetWindowText (dlg, c->title);          SetWindowText (dlg, c->title);
96          if (c->gpg_cmd == GPG_CMD_DECRYPT) {          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
97                SetDlgItemText (dlg, IDC_DECRYPT_HIDE, _("&Hide Typing"));
98              SetDlgItemText (dlg, IDC_DECRYPT_LISTINF,              SetDlgItemText (dlg, IDC_DECRYPT_LISTINF,
99                              _("Encrypted with the following public key(s)"));                              _("Encrypted with the following public key(s):"));
100              CheckDlgButton (dlg, IDC_DECRYPT_HIDE, BST_CHECKED);              CheckDlgButton (dlg, IDC_DECRYPT_HIDE, BST_CHECKED);
101          }          }
102          else if (c->gpg_cmd == GPG_CMD_SIGN) {          else if (c->gpg_cmd == GPG_CMD_SIGN) {
# Line 101  passphrase_callback_proc (HWND dlg, UINT Line 104  passphrase_callback_proc (HWND dlg, UINT
104              CheckDlgButton (dlg, IDC_DECRYPT_SIGN_HIDE, BST_CHECKED);              CheckDlgButton (dlg, IDC_DECRYPT_SIGN_HIDE, BST_CHECKED);
105          }          }
106          /* Because it depends on the order the keys are stored in the          /* Because it depends on the order the keys are stored in the
107             keyring whether res->recipients is complete or not, we also             keyring, whether res->recipients is complete or not, we also
108             support that the recipients were externally extracted and then             support that the recipients were externally extracted and then
109             we use this list. */             we use this list. */
110          if (c->recipients)          if (c->recipients) /* recipients were already extracted. */
111              recip = c->recipients; /* recipients were already extracted. */              recip = c->recipients;
112          else {          else if (c->gpg) {
113              res = gpgme_op_decrypt_result (c->gpg);              res = gpgme_op_decrypt_result (c->gpg);
114              if (res && res->recipients)              if (res && res->recipients)
115                  recip = res->recipients;                  recip = res->recipients;
116          }          }
117          if (recip != NULL && c->gpg_cmd == GPG_CMD_DECRYPT) {          if (recip != NULL && c->gpg_cmd == GPG_CMD_DECRYPT) {
118                StringBuffer inf;
119    
120              for (r = recip; r; r = r->next) {              for (r = recip; r; r = r->next) {
121                  get_pubkey (r->keyid, &key);                  memset (&key, 0, sizeof (key));
122                  if (key) {                  if (!winpt_get_pubkey (r->keyid, &key)) {
123                      gpgme_user_id_t u = key->uids;                      gpgme_user_id_t u = key.ctx->uids;
124                      char *uid;                      inf = (u->name? u->name : _("Invalid User ID"));
125                        if (u->email != NULL && strlen (u->email) > 1)
126                      id = u->name;                          inf = inf + " <" + u->email + ">";
127                      if (!id)                      inf = inf + " (" + get_key_pubalgo (r->pubkey_algo);
128                          id = _("Invalid User ID");                      inf = inf + ", 0x" + (r->keyid+8) + ")";
                     uid = utf8_to_native (id);  
                     n = 32+strlen (uid)+1+4+strlen (r->keyid)+1;  
                     if (u->email)  
                         n += strlen (u->email)+1;  
                     info = new char [n+1];  
                     if (!info)  
                         BUG (NULL);  
                     if (!u->email || strlen (u->email) < 1)  
                         sprintf (info, "%s (%s, 0x%s)", uid,  
                                  get_key_pubalgo (r->pubkey_algo), r->keyid+8);  
                     else  
                         sprintf (info, "%s <%s> (%s, 0x%s)", uid, u->email,  
                                  get_key_pubalgo (r->pubkey_algo), r->keyid+8);  
                     free (uid);  
129                  }                  }
130                  else {                  else {
131                      info = new char [32 + strlen (r->keyid)+1 + 4];                      inf = _("Unknown key ID");
132                      if (!info)                      inf = inf + " (" + get_key_pubalgo (r->pubkey_algo);
133                          BUG (NULL);                      inf = inf + ", 0x" + (r->keyid+8) + ")";
                     sprintf (info, _("Unknown key ID (%s, 0x%s)"),  
                              get_key_pubalgo (r->pubkey_algo), r->keyid+8);  
134                  }                  }
135                  listbox_add_string (GetDlgItem (dlg, IDC_DECRYPT_LIST), info);                  ListBox_AddString_utf8 (GetDlgItem (dlg, IDC_DECRYPT_LIST),
136                  free_if_alloc (info);                                          inf.getBuffer ());
137                    winpt_release_pubkey (&key);
138              }              }
139          }          }
140          else if (c->gpg_cmd == GPG_CMD_DECRYPT)          else if (c->gpg_cmd == GPG_CMD_DECRYPT)
141              EnableWindow (GetDlgItem (dlg, IDC_DECRYPT_LIST), FALSE);              EnableWindow (GetDlgItem (dlg, IDC_DECRYPT_LIST), FALSE);
142          SetDlgItemText (dlg, c->gpg_cmd == GPG_CMD_DECRYPT?          SetDlgItemText (dlg, c->gpg_cmd == GPG_CMD_DECRYPT?
143                          IDC_DECRYPT_PWDINFO : IDC_DECRYPT_SIGN_PWDINFO,                          IDC_DECRYPT_PWDINFO : IDC_DECRYPT_SIGN_PWDINFO,
144                          c->bad_pwd? _("Bad passphrase; Enter passphrase again") :                          c->bad_pwd? _("Invalid passphrase; Please enter your passphrase again") :
145                          _("Please enter your passphrase"));                          _("Please enter your passphrase"));
146          if (c->gpg_cmd == GPG_CMD_DECRYPT) {          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
147              SetFocus (GetDlgItem (dlg, IDC_DECRYPT_PWD));              SetFocus (GetDlgItem (dlg, IDC_DECRYPT_PWD));
148              if (res && !res->recipients) {              /* no recipients means symmetric encryption */
149                  const char *s = _("Symmetric encryption.\n"              if (res && !res->recipients) {
150                                    "%s encrypted data.");                  StringBuffer sinf;
151                  const char *alg = get_symkey_algo (c->sym.sym_algo);  
152                  info = new char[strlen (s) + strlen (alg) + 2];                  sinf = _("Symmetric encryption.");
153                  if (!info)                  sinf = sinf + "\n" + get_symkey_algo (c->sym.sym_algo);
154                      BUG (NULL);                  sinf = sinf + " " + _("encrypted data") + ".";
155                  sprintf (info, s, alg);                  SetDlgItemText (dlg, IDC_DECRYPT_MSG, sinf.getBuffer ());
                 SetDlgItemText (dlg, IDC_DECRYPT_MSG, info);  
                 free_if_alloc (info);  
156              }              }
157              else              else
158                  SetDlgItemText (dlg, IDC_DECRYPT_MSG, c->info);                  SetDlgItemText (dlg, IDC_DECRYPT_MSG, c->info);
159          }          }
160          else {          else {
161              SetFocus( GetDlgItem (dlg, IDC_DECRYPT_SIGN_PWD));              SetFocus (GetDlgItem (dlg, IDC_DECRYPT_SIGN_PWD));
162              SetDlgItemText (dlg, IDC_DECRYPT_SIGN_MSG, c->info);              SetDlgItemText (dlg, IDC_DECRYPT_SIGN_MSG, c->info);
163          }          }
164          center_window (dlg, NULL);          center_window (dlg, NULL);
165          SetForegroundWindow (dlg);          SetForegroundWindow (dlg);
166          return FALSE;          return FALSE;
167    
         case WM_SYSCOMMAND:  
             if (LOWORD (wparam) == SC_CLOSE) {  
                 SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "");  
                 c->cancel = 1;  
                 EndDialog (dlg, TRUE);  
             }  
             break;  
   
168          case WM_COMMAND:          case WM_COMMAND:
169              switch (HIWORD (wparam)) {              switch (HIWORD (wparam)) {
170              case BN_CLICKED:              case BN_CLICKED:
171                  if  (LOWORD (wparam) == IDC_DECRYPT_HIDE                  if  (LOWORD (wparam) == IDC_DECRYPT_HIDE ||
172                      || LOWORD (wparam) == IDC_DECRYPT_SIGN_HIDE) {                       LOWORD (wparam) == IDC_DECRYPT_SIGN_HIDE) {
173                      HWND hwnd;                      HWND hwnd;
174                      int hide = IsDlgButtonChecked (dlg, item_ctrl_id2 (c->gpg_cmd));                      int hide;
175                        hide = IsDlgButtonChecked (dlg, item_ctrl_id2 (c->gpg_cmd));
176                      hwnd = GetDlgItem (dlg, item_ctrl_id (c->gpg_cmd));                      hwnd = GetDlgItem (dlg, item_ctrl_id (c->gpg_cmd));
177                      SendMessage (hwnd, EM_SETPASSWORDCHAR, hide? '*' : 0, 0);                      SendMessage (hwnd, EM_SETPASSWORDCHAR, hide? '*' : 0, 0);
178                      SetFocus (hwnd);                      SetFocus (hwnd);
# Line 199  passphrase_callback_proc (HWND dlg, UINT Line 180  passphrase_callback_proc (HWND dlg, UINT
180              }              }
181    
182              switch (LOWORD (wparam)) {              switch (LOWORD (wparam)) {
183              case IDOK:                case IDOK:
184                  /* XXX: the item is even cached when the passphrase is not                  /* XXX: the item is even cached when the passphrase is not
185                          correct, which means that the user needs to delete all                          correct, which means that the user needs to delete all
186                          cached entries to continue. */                          cached entries to continue. */
# Line 208  passphrase_callback_proc (HWND dlg, UINT Line 189  passphrase_callback_proc (HWND dlg, UINT
189                  n = item_get_text_length (dlg, item_ctrl_id (c->gpg_cmd));                  n = item_get_text_length (dlg, item_ctrl_id (c->gpg_cmd));
190                  if (!n) {                  if (!n) {
191                      c->pwd = new char[2];                      c->pwd = new char[2];
                     if (!c->pwd)  
                         BUG (NULL);  
192                      strcpy (c->pwd, "");                      strcpy (c->pwd, "");
193                  }                  }
194                  else {                  else {
195                      c->pwd = new char[n+2];                      char *p = new char[n+2];
196                      if (!c->pwd)                      SafeGetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), p, n+1);
197                          BUG (NULL);                      if (emulate_utf8_bug)
198                      SafeGetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd),                          c->pwd = native_to_utf8 (p);
199                                          c->pwd, n+1);                      else
200                            c->pwd = m_strdup (p);
201                        sfree_if_alloc (p);
202                  }                  }
203                  res = gpgme_op_decrypt_result (c->gpg);                  if (c->gpg != NULL) {
204                  if (!res)                      res = gpgme_op_decrypt_result (c->gpg);
205                      res_sig = gpgme_op_sign_result (c->gpg);                                  if (!res)
206                  if (reg_prefs.cache_time > 0 && !c->is_card &&                          res_sig = gpgme_op_sign_result (c->gpg);
207                      (res || res_sig)) {                      if (!c->is_card && reg_prefs.cache_time > 0 &&
208                      if (agent_get_cache (c->keyid, &item))                                                (res || res_sig)) {
209                          agent_unlock_cache_entry (&item);                          if (agent_get_cache (c->keyid, &item))
210                      else                              agent_unlock_cache_entry (&item);
211                          agent_put_cache (c->keyid, c->pwd, reg_prefs.cache_time);                          else
212                                agent_put_cache (c->keyid, c->pwd,
213                                                 reg_prefs.cache_time);
214                        }
215                  }                  }
216                  c->cancel = 0;                  c->cancel = 0;
217                  EndDialog (dlg, TRUE);                  EndDialog (dlg, TRUE);
# Line 237  passphrase_callback_proc (HWND dlg, UINT Line 221  passphrase_callback_proc (HWND dlg, UINT
221                  SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "");                  SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "");
222                  c->cancel = 1;                  c->cancel = 1;
223                  EndDialog (dlg, FALSE);                  EndDialog (dlg, FALSE);
224                  return FALSE;                  return TRUE;
225              }              }
226              break;              break;
227      }      }
# Line 271  parse_gpg_keyid (const char *pass_info) Line 255  parse_gpg_keyid (const char *pass_info)
255     a input message for the user in @desc. */     a input message for the user in @desc. */
256  static int  static int
257  parse_gpg_description (const char *uid_hint, const char *pass_info,  parse_gpg_description (const char *uid_hint, const char *pass_info,
258                         char *desc, int size)                         char *desc, size_t desc_size)
259  {  {
260      gpgme_pubkey_algo_t algo;      gpgme_pubkey_algo_t algo;
261      char usedkey[16+1];      char usedkey[16+1];
262      char mainkey[16+1];      char mainkey[16+1];
263      char *uid, *p;      char *p, *uid;
264      int n=0;      int n=0;
265    
266      algo = (gpgme_pubkey_algo_t)0;      algo = (gpgme_pubkey_algo_t)0;
# Line 287  parse_gpg_description (const char *uid_h Line 271  parse_gpg_description (const char *uid_h
271          return -1;          return -1;
272      }      }
273    
274      while (p = strsep ((char**)&pass_info, " ")) {      while ((p = strsep ((char**)&pass_info, " "))) {
275          switch (n++) {          switch (n++) {
276          case 0: strncpy (mainkey, p, 16); mainkey[16] = 0; break;          case 0:
277          case 1: strncpy (usedkey, p, 16); usedkey[16] = 0; break;              strncpy (mainkey, p, 16);
278          case 2: algo = (gpgme_pubkey_algo_t)atol (p); break;              mainkey[16] = 0;
279                break;
280    
281            case 1:
282                strncpy (usedkey, p, 16);
283                usedkey[16] = 0;
284                break;
285    
286            case 2:
287                algo = (gpgme_pubkey_algo_t)atol (p);
288                break;
289          }          }
290      }      }
291      uid_hint += 16; /* skip keyid */      uid_hint += 16; /* skip keyid */
292      uid_hint += 1;  /* space */      uid_hint += 1;  /* space */
293    
294        struct winpt_key_s skey;
295        gpgme_subkey_t sk;
296        if (winpt_get_seckey (mainkey, &skey))
297            BUG (0);
298        for (sk = skey.ctx->subkeys; sk; sk = sk->next) {
299            if (memcmp (sk->keyid, usedkey, 8) == 0)
300                break;
301        }
302      uid = utf8_to_native (uid_hint);      uid = utf8_to_native (uid_hint);
   
303      if (strcmp (usedkey, mainkey))      if (strcmp (usedkey, mainkey))
304          _snprintf (desc, size-1,          _snprintf (desc, desc_size-1,
305                     _("You need a passphrase to unlock the secret key for\n"                     _("You need a passphrase to unlock the secret key for user:\n"
306                       "user: \"%s\"\n"                       "\"%s\"\n"
307                       "%s key, ID %s (main key ID %s)\n"),                       "%d-bit %s key, ID 0x%s, created %s (main key ID 0x%s)\n"),
308                     uid, get_key_pubalgo (algo), usedkey+8, mainkey+8);                     uid, sk->length, get_key_pubalgo (algo),
309                       usedkey+8, get_key_created (sk->timestamp), mainkey+8);
310      else if (!strcmp (usedkey, mainkey))      else if (!strcmp (usedkey, mainkey))
311          _snprintf (desc, size-1,          _snprintf (desc, desc_size-1,
312                     _("You need a passphrase to unlock the secret key for\n"                     _("You need a passphrase to unlock the secret key for user:\n"
313                       "user: \"%s\"\n"                       "\"%s\"\n"
314                       "%s key, ID %s\n"),                       "%d-bit %s key, created %s, ID 0x%s\n"),
315                       uid, get_key_pubalgo (algo), usedkey+8);                       uid, sk->length, get_key_pubalgo (algo),
316      free (uid);                       get_key_created (sk->timestamp), usedkey+8);
317        safe_free (uid);
318      return 0;      return 0;
319  }  }
320    
# Line 326  extract_serial_no (const char *id) Line 329  extract_serial_no (const char *id)
329      p = strchr (id, '/');      p = strchr (id, '/');
330      if (!p) {      if (!p) {
331          log_debug ("extract_serial_no: error '%s'\r\n", id);          log_debug ("extract_serial_no: error '%s'\r\n", id);
332          return NULL;          return "";
333      }      }
334        memset (buf, 0, sizeof (buf));
335      strncpy (buf, id+(p-id)-6, 6);      strncpy (buf, id+(p-id)-6, 6);
336      return buf;      return buf;
337  }  }
# Line 344  passphrase_cb (void *hook, const char *u Line 348  passphrase_cb (void *hook, const char *u
348      void *item;      void *item;
349      const char *keyid=NULL, *pass;      const char *keyid=NULL, *pass;
350      DWORD n;      DWORD n;
     int rc = 0;  
351    
352      if (!c) {      if (!c) {
353          log_debug ("passphrase_cb: error '!c'\r\n");          log_debug ("passphrase_cb: error no valid callback\r\n");
354          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
355      }      }
356    
357        /* If the last entered passphrase was wrong, we delete a
358           possible cached entry, we reset the passphrase buffer
359           and switch to the initial state. */
360      c->bad_pwd = prev_was_bad? 1 : 0;      c->bad_pwd = prev_was_bad? 1 : 0;
361      if (prev_was_bad && !c->cancel) {      if (prev_was_bad && !c->cancel) {
362          if (c->pwd)          if (c->pwd)
# Line 366  passphrase_cb (void *hook, const char *u Line 373  passphrase_cb (void *hook, const char *u
373              c->sym.sym_algo = atoi (passphrase_info);              c->sym.sym_algo = atoi (passphrase_info);
374              if (c->sym.sym_algo > 9)              if (c->sym.sym_algo > 9)
375                  pos++;                  pos++;
             /* XXX: be more strict. */  
376              c->sym.s2k_mode = atoi (passphrase_info+pos);              c->sym.s2k_mode = atoi (passphrase_info+pos);
377              c->sym.s2k_hash = atoi (passphrase_info+pos+2);              c->sym.s2k_hash = atoi (passphrase_info+pos+2);
378          }          }
# Line 394  passphrase_cb (void *hook, const char *u Line 400  passphrase_cb (void *hook, const char *u
400              const char *s=passphrase_info;              const char *s=passphrase_info;
401              while (s && *s && *s != 'D')              while (s && *s && *s != 'D')
402                  s++;                  s++;
403              _snprintf (c->info, sizeof c->info-1,              _snprintf (c->info, DIM (c->info)-1,
404                         _("Please enter the PIN to unlock your secret card key\n"                         _("Please enter the PIN to unlock your secret card key\n"
405                           "Card: %s"), extract_serial_no (s));                           "Card: %s"), extract_serial_no (s));
406              c->is_card = 1;              c->is_card = 1;
407          }          }
408          else if (uid_hint)          else if (uid_hint)
409              parse_gpg_description (uid_hint, passphrase_info,              parse_gpg_description (uid_hint, passphrase_info,
410                                     c->info, sizeof (c->info) - 1);                                     c->info, DIM (c->info) - 1);
411            int rc = 0;
412          if (c->gpg_cmd == GPG_CMD_DECRYPT) {          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
413              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,
414                                   (HWND)c->hwnd, passphrase_callback_proc,                                   (HWND)c->hwnd, passphrase_callback_proc,
# Line 415  passphrase_cb (void *hook, const char *u Line 422  passphrase_cb (void *hook, const char *u
422          if (rc == -1) {          if (rc == -1) {
423              if (!WriteFile (hd, "\n", 1, &n, NULL))              if (!WriteFile (hd, "\n", 1, &n, NULL))
424                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
425                log_debug ("passphrase_cb: could not create dialog box\n");
426              return 0;              return 0;
427          }          }
428          c->pwd_init = 0;          c->pwd_init = 0;
429      }      }
430      if (c->cancel) {      if (c->cancel || !c->pwd) {
431          if (!WriteFile (hd, "\n", 1, &n, NULL))          if (!WriteFile (hd, "\n", 1, &n, NULL))
432              log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);              log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
433          return 0;          return 0;
# Line 439  passphrase_cb (void *hook, const char *u Line 447  passphrase_cb (void *hook, const char *u
447  void  void
448  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,
449                         int cmd, HWND hwnd, const char *title)                         int cmd, HWND hwnd, const char *title)
450  {  {    
451      memset (cb, 0, sizeof *cb);      memset (cb, 0, sizeof *cb);
452      cb->gpg_cmd = cmd;      cb->gpg_cmd = cmd;
453      cb->bad_pwd = 0;      cb->bad_pwd = 0;
# Line 447  set_gpg_passphrase_cb (passphrase_cb_s * Line 455  set_gpg_passphrase_cb (passphrase_cb_s *
455      cb->cancel = 0;      cb->cancel = 0;
456      cb->hwnd = hwnd;      cb->hwnd = hwnd;
457      cb->pwd_init = 1;      cb->pwd_init = 1;
     free_if_alloc (cb->title);  
458      cb->title = m_strdup (title);      cb->title = m_strdup (title);
     if (!cb->title)  
         BUG (NULL);  
459      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);
460      cb->gpg = ctx;      cb->gpg = ctx;
461  }  }
462    
463    void
464    set_gpg_auto_passphrase_cb (passphrase_cb_s *cb, const char *title)
465    {
466        memset (cb, 0, sizeof *cb);
467        cb->gpg_cmd = GPG_CMD_SIGN;
468        cb->bad_pwd = 0;
469        cb->is_card = 0;
470        cb->cancel = 0;
471        cb->hwnd = GetActiveWindow ();
472        cb->pwd_init = 1;
473        cb->title = m_strdup (title);
474    }
475    
476    
477  /* Release a passphrase callback @ctx. */  /* Release a passphrase callback @ctx. */
478  void  void
479  release_gpg_passphrase_cb (passphrase_cb_s *ctx)  release_gpg_passphrase_cb (passphrase_cb_s *ctx)
480  {  {
     gpgme_recipient_t r, n;  
   
481      if (!ctx)      if (!ctx)
482          return;          return;
483      sfree_if_alloc (ctx->pwd);      sfree_if_alloc (ctx->pwd);
484      free_if_alloc (ctx->title);      free_if_alloc (ctx->title);
485      r = ctx->recipients;      release_gpg_recipients (&ctx->recipients);
486      while (r) {  }
487    
488    
489    /* Release the gpg recipient list. */
490    void
491    release_gpg_recipients (gpgme_recipient_t *recipients)
492    {
493        gpgme_recipient_t r, n;
494    
495        r = *recipients;
496        while (r != NULL) {
497          n = r->next;          n = r->next;
498          safe_free (r->keyid);          safe_free (r->keyid);
499          safe_free (r);          safe_free (r);
500          r = n;          r = n;
501      }      }
502        *recipients = NULL;
503  }  }
504    
505    
506  /* Simple check to measure passphrase (@pass) quality.  /* _Simple_ check to measure passphrase (@pass) quality.
507     Return value: 0 on success. */     Return value: 0 on success. */
508  int  int
509  check_passwd_quality (const char *pass, int strict)  check_passwd_quality (const char *pass, int strict)
510  {  {
511      int i, nd=0, nc=0, n;      int i, nd=0, nc=0, n;
512    
513        /* A good passphrase should be at least 8 characters. */
514      n = strlen (pass);      n = strlen (pass);
515      if (n < 8)      if (n < 8)
516          return -1;          return -1;
517    
518      for (i=0; i < n; i++) {      for (i=0; i < n; i++) {
519          if (isdigit (pass[i]))          if (isdigit (pass[i]))
520              nd++;              nd++;
521          if (isalpha (pass[i]))          if (isalpha (pass[i]))
522              nc++;              nc++;
523      }      }
524    
525      /* check that the passphrase contains letters and numbers. */      /* Check that the passphrase contains letters and numbers. */
526      if (nd == n || nc == n)      if (nd == n || nc == n)
527          return -1;          return -1;
528    
Legend:
Removed from v.187  
changed lines
  Added in v.333
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26