/[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 260 by twoaday, Wed Aug 16 10:01:30 2006 UTC revision 340 by twoaday, Sun Nov 27 13:15:07 2011 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 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 40  Line 35 
35  #include "wptAgent.h"  #include "wptAgent.h"
36  #include "wptRegistry.h"  #include "wptRegistry.h"
37  #include "wptUTF8.h"  #include "wptUTF8.h"
38    #include "StringBuffer.h"
39    
40    
41  /* Return the control ID dependent on the mode (sign or decrypt). */  /* Return the control ID dependent on the mode (sign or decrypt). */
# Line 50  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  {  {
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 74  passphrase_callback_proc (HWND dlg, UINT Line 71  passphrase_callback_proc (HWND dlg, UINT
71      gpgme_recipient_t recip=NULL, r;      gpgme_recipient_t recip=NULL, r;
72      winpt_key_s key;      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 96  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 104  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                  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"));
125                      id = u->name;                      if (u->email != NULL && strlen (u->email) > 1)
126                      if (!id)                          inf = inf + " <" + u->email + ">";
127                          id = _("Invalid User ID");                      inf = inf + " (" + get_key_pubalgo (r->pubkey_algo);
128                      n = 32+strlen (id)+1+4+strlen (r->keyid)+1;                      inf = inf + ", 0x" + (r->keyid+8) + ")";
                     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)", id,  
                                  get_key_pubalgo (r->pubkey_algo), r->keyid+8);  
                     else  
                         sprintf (info, "%s <%s> (%s, 0x%s)", id, u->email,  
                                  get_key_pubalgo (r->pubkey_algo), r->keyid+8);  
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_AddString_utf8 (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);                  winpt_release_pubkey (&key);
138              }              }
139          }          }
# Line 152  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                  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);
# Line 178  passphrase_callback_proc (HWND dlg, UINT Line 165  passphrase_callback_proc (HWND dlg, UINT
165          SetForegroundWindow (dlg);          SetForegroundWindow (dlg);
166          return FALSE;          return FALSE;
167    
         case WM_SYSCOMMAND:  
             if (LOWORD (wparam) == SC_CLOSE) {  
                 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                      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);                      c->pwd = m_strdup (p);
198                      sfree_if_alloc (p);                      sfree_if_alloc (p);
199                  }                  }
200                  res = gpgme_op_decrypt_result (c->gpg);                  if (c->gpg != NULL) {
201                  if (!res)                      res = gpgme_op_decrypt_result (c->gpg);
202                      res_sig = gpgme_op_sign_result (c->gpg);                                  if (!res)
203                  if (!c->is_card && reg_prefs.cache_time > 0 &&                          res_sig = gpgme_op_sign_result (c->gpg);
204                      (res || res_sig)) {                      if (!c->is_card && reg_prefs.cache_time > 0 &&
205                      if (agent_get_cache (c->keyid, &item))                          (res || res_sig)) {
206                          agent_unlock_cache_entry (&item);                          if (agent_get_cache (c->keyid, &item))
207                      else                              agent_unlock_cache_entry (&item);
208                          agent_put_cache (c->keyid, c->pwd, reg_prefs.cache_time);                          else
209                                agent_put_cache (c->keyid, c->pwd,
210                                                 reg_prefs.cache_time);
211                        }
212                  }                  }
213                  c->cancel = 0;                  c->cancel = 0;
214                  EndDialog (dlg, TRUE);                  EndDialog (dlg, TRUE);
# Line 240  passphrase_callback_proc (HWND dlg, UINT Line 218  passphrase_callback_proc (HWND dlg, UINT
218                  SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "");                  SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "");
219                  c->cancel = 1;                  c->cancel = 1;
220                  EndDialog (dlg, FALSE);                  EndDialog (dlg, FALSE);
221                  return FALSE;                  return TRUE;
222              }              }
223              break;              break;
224      }      }
# Line 274  parse_gpg_keyid (const char *pass_info) Line 252  parse_gpg_keyid (const char *pass_info)
252     a input message for the user in @desc. */     a input message for the user in @desc. */
253  static int  static int
254  parse_gpg_description (const char *uid_hint, const char *pass_info,  parse_gpg_description (const char *uid_hint, const char *pass_info,
255                         char *desc, int size)                         char *desc, size_t desc_size)
256  {  {
257      gpgme_pubkey_algo_t algo;      gpgme_pubkey_algo_t algo;
258      char usedkey[16+1];      char usedkey[16+1];
# Line 290  parse_gpg_description (const char *uid_h Line 268  parse_gpg_description (const char *uid_h
268          return -1;          return -1;
269      }      }
270    
271      while (p = strsep ((char**)&pass_info, " ")) {      while ((p = strsep ((char**)&pass_info, " "))) {
272          switch (n++) {          switch (n++) {
273          case 0: strncpy (mainkey, p, 16); mainkey[16] = 0; break;          case 0:
274          case 1: strncpy (usedkey, p, 16); usedkey[16] = 0; break;              strncpy (mainkey, p, 16);
275          case 2: algo = (gpgme_pubkey_algo_t)atol (p); break;              mainkey[16] = 0;
276                break;
277    
278            case 1:
279                strncpy (usedkey, p, 16);
280                usedkey[16] = 0;
281                break;
282    
283            case 2:
284                algo = (gpgme_pubkey_algo_t)atol (p);
285                break;
286          }          }
287      }      }
288      uid_hint += 16; /* skip keyid */      uid_hint += 16; /* skip keyid */
289      uid_hint += 1;  /* space */      uid_hint += 1;  /* space */
290    
291        struct winpt_key_s skey;
292        gpgme_subkey_t sk;
293        if (winpt_get_seckey (mainkey, &skey))
294            BUG (0);
295        for (sk = skey.ctx->subkeys; sk; sk = sk->next) {
296            if (memcmp (sk->keyid, usedkey, 8) == 0)
297                break;
298        }
299      uid = utf8_to_native (uid_hint);      uid = utf8_to_native (uid_hint);
300      if (strcmp (usedkey, mainkey))      if (strcmp (usedkey, mainkey))
301          _snprintf (desc, size-1,          _snprintf (desc, desc_size-1,
302                     _("You need a passphrase to unlock the secret key for user:\n"                     _("You need a passphrase to unlock the secret key for user:\n"
303                       "\"%s\"\n"                       "\"%s\"\n"
304                       "%s key, ID 0x%s (main key ID 0x%s)\n"),                       "%d-bit %s key, ID 0x%s, created %s (main key ID 0x%s)\n"),
305                     uid, get_key_pubalgo (algo), usedkey+8, mainkey+8);                     uid, sk->length, get_key_pubalgo (algo),
306                       usedkey+8, get_key_created (sk->timestamp), mainkey+8);
307      else if (!strcmp (usedkey, mainkey))      else if (!strcmp (usedkey, mainkey))
308          _snprintf (desc, size-1,          _snprintf (desc, desc_size-1,
309                     _("You need a passphrase to unlock the secret key for user:\n"                     _("You need a passphrase to unlock the secret key for user:\n"
310                       "\"%s\"\n"                       "\"%s\"\n"
311                       "%s key, ID 0x%s\n"),                       "%d-bit %s key, created %s, ID 0x%s\n"),
312                       uid, get_key_pubalgo (algo), usedkey+8);                       uid, sk->length, get_key_pubalgo (algo),
313                         get_key_created (sk->timestamp), usedkey+8);
314      safe_free (uid);      safe_free (uid);
315      return 0;      return 0;
316  }  }
# Line 347  passphrase_cb (void *hook, const char *u Line 345  passphrase_cb (void *hook, const char *u
345      void *item;      void *item;
346      const char *keyid=NULL, *pass;      const char *keyid=NULL, *pass;
347      DWORD n;      DWORD n;
     int rc = 0;  
348    
349      if (!c) {      if (!c) {
350          log_debug ("passphrase_cb: error '!c'\r\n");          log_debug ("passphrase_cb: error no valid callback\r\n");
351          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
352      }      }
353    
354        /* If the last entered passphrase was wrong, we delete a
355           possible cached entry, we reset the passphrase buffer
356           and switch to the initial state. */
357      c->bad_pwd = prev_was_bad? 1 : 0;      c->bad_pwd = prev_was_bad? 1 : 0;
358      if (prev_was_bad && !c->cancel) {      if (prev_was_bad && !c->cancel) {
359          if (c->pwd)          if (c->pwd)
# Line 369  passphrase_cb (void *hook, const char *u Line 370  passphrase_cb (void *hook, const char *u
370              c->sym.sym_algo = atoi (passphrase_info);              c->sym.sym_algo = atoi (passphrase_info);
371              if (c->sym.sym_algo > 9)              if (c->sym.sym_algo > 9)
372                  pos++;                  pos++;
             /* XXX: be more strict. */  
373              c->sym.s2k_mode = atoi (passphrase_info+pos);              c->sym.s2k_mode = atoi (passphrase_info+pos);
374              c->sym.s2k_hash = atoi (passphrase_info+pos+2);              c->sym.s2k_hash = atoi (passphrase_info+pos+2);
375          }          }
# Line 397  passphrase_cb (void *hook, const char *u Line 397  passphrase_cb (void *hook, const char *u
397              const char *s=passphrase_info;              const char *s=passphrase_info;
398              while (s && *s && *s != 'D')              while (s && *s && *s != 'D')
399                  s++;                  s++;
400              _snprintf (c->info, sizeof c->info-1,              _snprintf (c->info, DIM (c->info)-1,
401                         _("Please enter the PIN to unlock your secret card key\n"                         _("Please enter the PIN to unlock your secret card key\n"
402                           "Card: %s"), extract_serial_no (s));                           "Card: %s"), extract_serial_no (s));
403              c->is_card = 1;              c->is_card = 1;
404          }          }
405          else if (uid_hint)          else if (uid_hint)
406              parse_gpg_description (uid_hint, passphrase_info,              parse_gpg_description (uid_hint, passphrase_info,
407                                     c->info, sizeof (c->info) - 1);                                     c->info, DIM (c->info) - 1);
408            int rc = 0;
409          if (c->gpg_cmd == GPG_CMD_DECRYPT) {          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
410              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,
411                                   (HWND)c->hwnd, passphrase_callback_proc,                                   (HWND)c->hwnd, passphrase_callback_proc,
# Line 418  passphrase_cb (void *hook, const char *u Line 419  passphrase_cb (void *hook, const char *u
419          if (rc == -1) {          if (rc == -1) {
420              if (!WriteFile (hd, "\n", 1, &n, NULL))              if (!WriteFile (hd, "\n", 1, &n, NULL))
421                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
422                log_debug ("passphrase_cb: could not create dialog box\n");
423              return 0;              return 0;
424          }          }
425          c->pwd_init = 0;          c->pwd_init = 0;
# Line 442  passphrase_cb (void *hook, const char *u Line 444  passphrase_cb (void *hook, const char *u
444  void  void
445  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,
446                         int cmd, HWND hwnd, const char *title)                         int cmd, HWND hwnd, const char *title)
447  {  {    
448      memset (cb, 0, sizeof *cb);      memset (cb, 0, sizeof *cb);
449      cb->gpg_cmd = cmd;      cb->gpg_cmd = cmd;
450      cb->bad_pwd = 0;      cb->bad_pwd = 0;
# Line 450  set_gpg_passphrase_cb (passphrase_cb_s * Line 452  set_gpg_passphrase_cb (passphrase_cb_s *
452      cb->cancel = 0;      cb->cancel = 0;
453      cb->hwnd = hwnd;      cb->hwnd = hwnd;
454      cb->pwd_init = 1;      cb->pwd_init = 1;
     free_if_alloc (cb->title);  
455      cb->title = m_strdup (title);      cb->title = m_strdup (title);
456      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);
457      cb->gpg = ctx;      cb->gpg = ctx;
458  }  }
459    
460    void
461    set_gpg_auto_passphrase_cb (passphrase_cb_s *cb, const char *title)
462    {
463        memset (cb, 0, sizeof *cb);
464        cb->gpg_cmd = GPG_CMD_SIGN;
465        cb->bad_pwd = 0;
466        cb->is_card = 0;
467        cb->cancel = 0;
468        cb->hwnd = GetActiveWindow ();
469        cb->pwd_init = 1;
470        cb->title = m_strdup (title);
471    }
472    
473    
474    /* Release a passphrase callback @ctx. */
475    void
476    release_gpg_passphrase_cb (passphrase_cb_s *ctx)
477    {
478        if (!ctx)
479            return;
480        sfree_if_alloc (ctx->pwd);
481        free_if_alloc (ctx->title);
482        release_gpg_recipients (&ctx->recipients);
483    }
484    
485    
486  /* Release the gpg recipient list. */  /* Release the gpg recipient list. */
487  void  void
# Line 474  release_gpg_recipients (gpgme_recipient_ Line 500  release_gpg_recipients (gpgme_recipient_
500  }  }
501    
502    
503    /* _Simple_ check to measure passphrase (@pass) quality.
 /* 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);  
 }  
   
   
 /* Simple check to measure passphrase (@pass) quality.  
504     Return value: 0 on success. */     Return value: 0 on success. */
505  int  int
506  check_passwd_quality (const char *pass, int strict)  check_passwd_quality (const char *pass, int strict)
507  {  {
508      int i, nd=0, nc=0, n;      int i, nd=0, nc=0, n;
509    
510        /* A good passphrase should be at least 8 characters. */
511      n = strlen (pass);      n = strlen (pass);
512      if (n < 8)      if (n < 8)
513          return -1;          return -1;
514    
515      for (i=0; i < n; i++) {      for (i=0; i < n; i++) {
516          if (isdigit (pass[i]))          if (isdigit (pass[i]))
517              nd++;              nd++;
518          if (isalpha (pass[i]))          if (isalpha (pass[i]))
519              nc++;              nc++;
520      }      }
521    
522      /* check that the passphrase contains letters and numbers. */      /* Check that the passphrase contains letters and numbers. */
523      if (nd == n || nc == n)      if (nd == n || nc == n)
524          return -1;          return -1;
525    
Legend:
Removed from v.260  
changed lines
  Added in v.340
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26