/[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 278 by twoaday, Mon Jan 15 22:02:04 2007 UTC revision 328 by twoaday, Fri Sep 25 16:07:38 2009 UTC
# Line 1  Line 1 
1  /* wptPassphraseCB.cpp - GPGME Passphrase Callback  /* wptPassphraseCB.cpp - GPGME Passphrase Callback
2   *      Copyright (C) 2001, 2002-2006 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 46  Line 46 
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);  const char* get_symkey_algo (int algo);
 void ListBox_AddString_utf8 (HWND lb, const char *txt);  
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  {  {
# Line 75  passphrase_callback_proc (HWND dlg, UINT Line 75  passphrase_callback_proc (HWND dlg, UINT
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 91  passphrase_callback_proc (HWND dlg, UINT Line 96  passphrase_callback_proc (HWND dlg, UINT
96          if (c->gpg_cmd == GPG_CMD_DECRYPT) {          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
97              SetDlgItemText (dlg, IDC_DECRYPT_HIDE, _("&Hide Typing"));              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 99  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;
# Line 116  passphrase_callback_proc (HWND dlg, UINT Line 121  passphrase_callback_proc (HWND dlg, UINT
121                  memset (&key, 0, sizeof (key));                  memset (&key, 0, sizeof (key));
122                  if (!winpt_get_pubkey (r->keyid, &key)) {                  if (!winpt_get_pubkey (r->keyid, &key)) {
123                      gpgme_user_id_t u = key.ctx->uids;                      gpgme_user_id_t u = key.ctx->uids;
                       
124                      inf = (u->name? u->name : _("Invalid User ID"));                      inf = (u->name? u->name : _("Invalid User ID"));
125                      if (u->email != NULL && strlen (u->email) > 1)                      if (u->email != NULL && strlen (u->email) > 1)
126                          inf = inf + " <" + u->email + ">";                          inf = inf + " <" + u->email + ">";
# Line 137  passphrase_callback_proc (HWND dlg, UINT Line 141  passphrase_callback_proc (HWND dlg, UINT
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                if (res && !res->recipients) {
150                  StringBuffer sinf;                  StringBuffer sinf;
151    
152                  sinf = _("Symmetric encryption.");                  sinf = _("Symmetric encryption.");
153                  sinf = sinf + "\n" + get_symkey_algo (c->sym.sym_algo);                  sinf = sinf + "\n" + get_symkey_algo (c->sym.sym_algo);
154                  sinf = sinf + " " + _("encrypted data.");                  sinf = sinf + " " + _("encrypted data") + ".";
155                  SetDlgItemText (dlg, IDC_DECRYPT_MSG, sinf.getBuffer ());                  SetDlgItemText (dlg, IDC_DECRYPT_MSG, sinf.getBuffer ());
156              }              }
157              else              else
# Line 163  passphrase_callback_proc (HWND dlg, UINT Line 168  passphrase_callback_proc (HWND dlg, UINT
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 174  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 183  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                      char *p = new char[n+2];                      char *p = new char[n+2];
                     if (!p)  
                         BUG (NULL);  
                     /* Get the passphrase and convert it utf8.  
                        This does not just the us-ascii charset. */  
196                      SafeGetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), p, n+1);                      SafeGetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), p, n+1);
197                      c->pwd = native_to_utf8 (p);                      if (emulate_utf8_bug)
198                            c->pwd = native_to_utf8 (p);
199                        else
200                            c->pwd = m_strdup (p);
201                      sfree_if_alloc (p);                      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 (!c->is_card && reg_prefs.cache_time > 0 &&                          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 249  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];
# Line 265  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 */
# Line 277  parse_gpg_description (const char *uid_h Line 293  parse_gpg_description (const char *uid_h
293    
294      uid = utf8_to_native (uid_hint);      uid = utf8_to_native (uid_hint);
295      if (strcmp (usedkey, mainkey))      if (strcmp (usedkey, mainkey))
296          _snprintf (desc, size-1,          _snprintf (desc, desc_size-1,
297                     _("You need a passphrase to unlock the secret key for user:\n"                     _("You need a passphrase to unlock the secret key for user:\n"
298                       "\"%s\"\n"                       "\"%s\"\n"
299                       "%s key, ID 0x%s (main key ID 0x%s)\n"),                       "%s key, ID 0x%s (main key ID 0x%s)\n"),
300                     uid, get_key_pubalgo (algo), usedkey+8, mainkey+8);                     uid, get_key_pubalgo (algo), usedkey+8, mainkey+8);
301      else if (!strcmp (usedkey, mainkey))      else if (!strcmp (usedkey, mainkey))
302          _snprintf (desc, size-1,          _snprintf (desc, desc_size-1,
303                     _("You need a passphrase to unlock the secret key for user:\n"                     _("You need a passphrase to unlock the secret key for user:\n"
304                       "\"%s\"\n"                       "\"%s\"\n"
305                       "%s key, ID 0x%s\n"),                       "%s key, ID 0x%s\n"),
# Line 322  passphrase_cb (void *hook, const char *u Line 338  passphrase_cb (void *hook, const char *u
338      void *item;      void *item;
339      const char *keyid=NULL, *pass;      const char *keyid=NULL, *pass;
340      DWORD n;      DWORD n;
     int rc = 0;  
341    
342      if (!c) {      if (!c) {
343          log_debug ("passphrase_cb: error no valid callback\r\n");          log_debug ("passphrase_cb: error no valid callback\r\n");
344          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
345      }      }
346    
347        /* If the last entered passphrase was wrong, we delete a
348           possible cached entry, we reset the passphrase buffer
349           and switch to the initial state. */
350      c->bad_pwd = prev_was_bad? 1 : 0;      c->bad_pwd = prev_was_bad? 1 : 0;
351      if (prev_was_bad && !c->cancel) {      if (prev_was_bad && !c->cancel) {
352          if (c->pwd)          if (c->pwd)
# Line 344  passphrase_cb (void *hook, const char *u Line 363  passphrase_cb (void *hook, const char *u
363              c->sym.sym_algo = atoi (passphrase_info);              c->sym.sym_algo = atoi (passphrase_info);
364              if (c->sym.sym_algo > 9)              if (c->sym.sym_algo > 9)
365                  pos++;                  pos++;
             /* XXX: be more strict. */  
366              c->sym.s2k_mode = atoi (passphrase_info+pos);              c->sym.s2k_mode = atoi (passphrase_info+pos);
367              c->sym.s2k_hash = atoi (passphrase_info+pos+2);              c->sym.s2k_hash = atoi (passphrase_info+pos+2);
368          }          }
# Line 372  passphrase_cb (void *hook, const char *u Line 390  passphrase_cb (void *hook, const char *u
390              const char *s=passphrase_info;              const char *s=passphrase_info;
391              while (s && *s && *s != 'D')              while (s && *s && *s != 'D')
392                  s++;                  s++;
393              _snprintf (c->info, sizeof (c->info)-1,              _snprintf (c->info, DIM (c->info)-1,
394                         _("Please enter the PIN to unlock your secret card key\n"                         _("Please enter the PIN to unlock your secret card key\n"
395                           "Card: %s"), extract_serial_no (s));                           "Card: %s"), extract_serial_no (s));
396              c->is_card = 1;              c->is_card = 1;
397          }          }
398          else if (uid_hint)          else if (uid_hint)
399              parse_gpg_description (uid_hint, passphrase_info,              parse_gpg_description (uid_hint, passphrase_info,
400                                     c->info, sizeof (c->info) - 1);                                     c->info, DIM (c->info) - 1);
401            int rc = 0;
402          if (c->gpg_cmd == GPG_CMD_DECRYPT) {          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
403              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,
404                                   (HWND)c->hwnd, passphrase_callback_proc,                                   (HWND)c->hwnd, passphrase_callback_proc,
# Line 418  passphrase_cb (void *hook, const char *u Line 437  passphrase_cb (void *hook, const char *u
437  void  void
438  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,
439                         int cmd, HWND hwnd, const char *title)                         int cmd, HWND hwnd, const char *title)
440  {  {    
441      memset (cb, 0, sizeof *cb);      memset (cb, 0, sizeof *cb);
442      cb->gpg_cmd = cmd;      cb->gpg_cmd = cmd;
443      cb->bad_pwd = 0;      cb->bad_pwd = 0;
# Line 426  set_gpg_passphrase_cb (passphrase_cb_s * Line 445  set_gpg_passphrase_cb (passphrase_cb_s *
445      cb->cancel = 0;      cb->cancel = 0;
446      cb->hwnd = hwnd;      cb->hwnd = hwnd;
447      cb->pwd_init = 1;      cb->pwd_init = 1;
     free_if_alloc (cb->title);  
448      cb->title = m_strdup (title);      cb->title = m_strdup (title);
449      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);
450      cb->gpg = ctx;      cb->gpg = ctx;
451  }  }
452    
453    void
454    set_gpg_auto_passphrase_cb (passphrase_cb_s *cb, const char *title)
455    {
456        memset (cb, 0, sizeof *cb);
457        cb->gpg_cmd = GPG_CMD_SIGN;
458        cb->bad_pwd = 0;
459        cb->is_card = 0;
460        cb->cancel = 0;
461        cb->hwnd = GetActiveWindow ();
462        cb->pwd_init = 1;
463        cb->title = m_strdup (title);
464    }
465    
466    
467    /* Release a passphrase callback @ctx. */
468    void
469    release_gpg_passphrase_cb (passphrase_cb_s *ctx)
470    {
471        if (!ctx)
472            return;
473        sfree_if_alloc (ctx->pwd);
474        free_if_alloc (ctx->title);
475        release_gpg_recipients (&ctx->recipients);
476    }
477    
478    
479  /* Release the gpg recipient list. */  /* Release the gpg recipient list. */
480  void  void
# Line 450  release_gpg_recipients (gpgme_recipient_ Line 493  release_gpg_recipients (gpgme_recipient_
493  }  }
494    
495    
   
 /* Release a passphrase callback @ctx. */  
 void  
 release_gpg_passphrase_cb (passphrase_cb_s *ctx)  
 {  
     if (!ctx)  
         return;  
     sfree_if_alloc (ctx->pwd);  
     free_if_alloc (ctx->title);  
     release_gpg_recipients (&ctx->recipients);  
 }  
   
   
496  /* _Simple_ check to measure passphrase (@pass) quality.  /* _Simple_ check to measure passphrase (@pass) quality.
497     Return value: 0 on success. */     Return value: 0 on success. */
498  int  int
Legend:
Removed from v.278  
changed lines
  Added in v.328
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26