/[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 47 by werner, Mon Oct 31 14:04:59 2005 UTC revision 344 by twoaday, Sun Nov 27 14:56:52 2011 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, 2011 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
20    
21  #include <windows.h>  #include <windows.h>
 #include <windows.h>  
22  #include <ctype.h>  #include <ctype.h>
23    
24  #include "resource.h"  #include "resource.h"
# Line 35  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  #define item_ctrl_id( cmd ) \  /* Return the control ID dependent on the mode (sign or decrypt). */
42    #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 66  burn_passphrase (char **pwd) Line 65  burn_passphrase (char **pwd)
65  static BOOL CALLBACK  static BOOL CALLBACK
66  passphrase_callback_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  passphrase_callback_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
67  {      {    
68      static passphrase_cb_s * c;      static passphrase_cb_s *c;
69      gpgme_decrypt_result_t res;      gpgme_decrypt_result_t res=NULL;
70      gpgme_sign_result_t res_sig;      gpgme_sign_result_t res_sig=NULL;
71      gpgme_key_t key;      gpgme_recipient_t recip=NULL, r;
72      gpgme_recipient_t recip, r;      winpt_key_s key;
73      void *ctx = NULL, *item;      void *item;
     const char *id;  
     char *info;  
74      int n;      int n;
75    
76      switch (msg) {      switch (msg) {
77        case WM_ACTIVATE:
78            /* 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;
84    
85        case WM_DESTROY:
86            if (!reg_prefs.no_safe_pwd_ctrl)
87                safe_edit_control_free (dlg, item_ctrl_id (c->gpg_cmd));
88            break;
89    
90      case WM_INITDIALOG:      case WM_INITDIALOG:
91          c = (passphrase_cb_s *)lparam;          c = (passphrase_cb_s *)lparam;
92          if (!c)          if (!c)
93              BUG (0);              BUG (0);
94            SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
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) {
103                SetDlgItemText (dlg, IDC_DECRYPT_SIGN_HIDE, _("&Hide Typing"));
104              CheckDlgButton (dlg, IDC_DECRYPT_SIGN_HIDE, BST_CHECKED);              CheckDlgButton (dlg, IDC_DECRYPT_SIGN_HIDE, BST_CHECKED);
105          if (c->recipients)          }
106              recip = c->recipients; /* recipients were already extracted. */          /* Because it depends on the order the keys are stored in the
107          else {             keyring, whether res->recipients is complete or not, we also
108              /* XXX: not all ENCRYPT_TO entries are listed here. */             support that the recipients were externally extracted and then
109               we use this list. */
110            if (c->recipients) /* recipients were already extracted. */
111                recip = c->recipients;
112            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              for (r = res->recipients; r; r = r->next) {              StringBuffer inf;
119                  get_pubkey (r->keyid, &key);  
120                  if (key) {              for (r = recip; r; r = r->next) {
121                      char *uid;                  memset (&key, 0, sizeof (key));
122                      id = key->uids->name;                  if (!winpt_get_pubkey (r->keyid, &key)) {
123                      if (!id)                      gpgme_user_id_t u = key.ctx->uids;
124                          id = _("Invalid User ID");                      inf = (u->name? u->name : _("Invalid User ID"));
125                      uid = utf8_to_wincp (id, strlen (id));                      if (u->email != NULL && strlen (u->email) > 1)
126                      info = new char [32+strlen (uid)+1 + 4 + strlen (r->keyid)+1                          inf = inf + " <" + u->email + ">";
127                                       + strlen (key->uids->email)+1];                      inf = inf + " (" + get_key_pubalgo (r->pubkey_algo);
128                      if (!info)                      inf = inf + ", 0x" + (r->keyid+8) + ")";
                         BUG (NULL);  
                     sprintf (info, "%s <%s> (%s, 0x%s)", uid, key->uids->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);
         set_active_window (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 179  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 188  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);                      c->pwd = m_strdup (p);
198                      GetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), c->pwd, n+1);                      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 (reg_prefs.cache_time > 0 && !c->is_card &&                          res_sig = gpgme_op_sign_result (c->gpg);
204                      ((res && res->recipients) || (res_sig && res_sig->signatures))) {                      if (!c->is_card && reg_prefs.cache_time > 0 && (res || res_sig)) {
205                      if (agent_get_cache (c->keyid, &item))                          if (agent_get_cache (c->keyid, &item))
206                          agent_unlock_cache_entry (&item);                              agent_unlock_cache_entry (&item);
207                      else                          else
208                          agent_put_cache (c->keyid, c->pwd, reg_prefs.cache_time);                              agent_put_cache (c->keyid, c->pwd, reg_prefs.cache_time);
209                        }
210                  }                  }
211                  c->cancel = 0;                  c->cancel = 0;
212                  EndDialog (dlg, TRUE);                  EndDialog (dlg, TRUE);
# Line 216  passphrase_callback_proc (HWND dlg, UINT Line 216  passphrase_callback_proc (HWND dlg, UINT
216                  SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "");                  SetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), "");
217                  c->cancel = 1;                  c->cancel = 1;
218                  EndDialog (dlg, FALSE);                  EndDialog (dlg, FALSE);
219                  return FALSE;                  return TRUE;
220              }              }
221              break;              break;
222      }      }
# Line 233  parse_gpg_keyid (const char *pass_info) Line 233  parse_gpg_keyid (const char *pass_info)
233      static char keyid[16+1];      static char keyid[16+1];
234            
235      /* XXX: check for leading alpha-chars? */      /* XXX: check for leading alpha-chars? */
236      if (strlen (pass_info) < 16)      if (strlen (pass_info) < 16) {
237            log_debug ("parse_gpg_keyid: error '%s'\r\n", pass_info);
238          return NULL;          return NULL;
239        }
240      /* the format of the desc buffer looks like this:      /* the format of the desc buffer looks like this:
241         request_keyid[16] main_keyid[16] keytype[1] keylength[4]         request_keyid[16] main_keyid[16] keytype[1] keylength[4]
242         we use the main keyid to use only one cache entry. */         we use the main keyid to use only one cache entry. */
# Line 248  parse_gpg_keyid (const char *pass_info) Line 250  parse_gpg_keyid (const char *pass_info)
250     a input message for the user in @desc. */     a input message for the user in @desc. */
251  static int  static int
252  parse_gpg_description (const char *uid_hint, const char *pass_info,  parse_gpg_description (const char *uid_hint, const char *pass_info,
253                         char *desc, int size)                         char *desc, size_t desc_size)
254  {  {
255      gpgme_pubkey_algo_t algo;      gpgme_pubkey_algo_t algo;
256      char usedkey[16+1];      char usedkey[16 + 1];
257      char mainkey[16+1];      char mainkey[16 + 1];
258      char *uid, *p;      char *p;
     int n=0;  
259    
260        algo = (gpgme_pubkey_algo_t)0;
261      /* Each uid_hint contains a long key-ID so it is at least 16 bytes. */      /* Each uid_hint contains a long key-ID so it is at least 16 bytes. */
262      if (strlen (uid_hint) < 17) {      if (strlen (uid_hint) < 17) {
263          *desc = 0;          *desc = 0;
264            log_debug ("parse_gpg_description: error '%s'\r\n", uid_hint);
265          return -1;          return -1;
266      }      }
267    
268      while (p = strsep ((char**)&pass_info, " ")) {      int n = 0;
269        while ((p = strsep ((char**)&pass_info, " "))) {
270          switch (n++) {          switch (n++) {
271          case 0: strncpy (mainkey, p, 16); mainkey[16] = 0; break;          case 0:
272          case 1: strncpy (usedkey, p, 16); usedkey[16] = 0; break;              strncpy (mainkey, p, 16);
273          case 2: algo = (gpgme_pubkey_algo_t)atol (p); break;              mainkey[16] = 0;
274                break;
275    
276            case 1:
277                strncpy (usedkey, p, 16);
278                usedkey[16] = 0;
279                break;
280    
281            case 2:
282                algo = (gpgme_pubkey_algo_t)atol (p);
283                break;
284          }          }
285      }      }
286      uid_hint += 16; /* skip keyid */      uid_hint += 16; /* skip keyid */
287      uid_hint += 1;  /* space */      uid_hint += 1;  /* space */
288    
289      uid = utf8_to_wincp (uid_hint, strlen (uid_hint));      struct winpt_key_s skey;
290        gpgme_subkey_t sk;
291        if (winpt_get_seckey (mainkey, &skey))
292            BUG (0);
293        for (sk = skey.ctx->subkeys; sk; sk = sk->next) {
294            if (memcmp (sk->keyid, usedkey, 8) == 0)
295                break;
296        }
297        char *uid = utf8_to_native (uid_hint);
298      if (strcmp (usedkey, mainkey))      if (strcmp (usedkey, mainkey))
299          _snprintf (desc, size-1,          _snprintf (desc, desc_size-1,
300                     _("You need a passphrase to unlock the secret key for\n"                     _("You need a passphrase to unlock the secret key for user:\n"
301                       "user: \"%s\"\n"                       "\"%s\"\n"
302                       "%s key, ID %s (main key ID %s)\n"),                       "%d-bit %s key, ID 0x%s, created %s (main key ID 0x%s)\n"),
303                     uid, get_key_pubalgo (algo), usedkey+8, mainkey+8);                     uid, sk->length, get_key_pubalgo (algo),
304                       usedkey+8, get_key_created (sk->timestamp), mainkey+8);
305      else if (!strcmp (usedkey, mainkey))      else if (!strcmp (usedkey, mainkey))
306          _snprintf (desc, size-1,          _snprintf (desc, desc_size-1,
307                     _("You need a passphrase to unlock the secret key for\n"                     _("You need a passphrase to unlock the secret key for user:\n"
308                       "user: \"%s\"\n"                       "\"%s\"\n"
309                       "%s key, ID %s\n"),                       "%d-bit %s key, created %s, ID 0x%s\n"),
310                       uid, get_key_pubalgo (algo), usedkey+8);                       uid, sk->length, get_key_pubalgo (algo),
311      free (uid);                       get_key_created (sk->timestamp), usedkey+8);
312        safe_free (uid);
313      return 0;      return 0;
314  }  }
315    
# Line 299  extract_serial_no (const char *id) Line 322  extract_serial_no (const char *id)
322      char *p;      char *p;
323    
324      p = strchr (id, '/');      p = strchr (id, '/');
325      if (!p)      if (!p) {
326          return NULL;          log_debug ("extract_serial_no: error '%s'\r\n", id);
327            return "";
328        }
329        memset (buf, 0, sizeof (buf));
330      strncpy (buf, id+(p-id)-6, 6);      strncpy (buf, id+(p-id)-6, 6);
331      return buf;      return buf;
332  }  }
# Line 315  passphrase_cb (void *hook, const char *u Line 341  passphrase_cb (void *hook, const char *u
341      passphrase_cb_s *c = (passphrase_cb_s*)hook;      passphrase_cb_s *c = (passphrase_cb_s*)hook;
342      HANDLE hd = (HANDLE)fd;      HANDLE hd = (HANDLE)fd;
343      void *item;      void *item;
344      const char *keyid, *pass;      const char *keyid=NULL, *pass;
345      DWORD n;      DWORD n;
     int rc;  
346    
347      if (!c)      if (!c) {
348            log_debug ("passphrase_cb: error no valid callback\r\n");
349          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
350        }
351    
352        /* If the last entered passphrase was wrong, we delete a
353           possible cached entry, we reset the passphrase buffer
354           and switch to the initial state. */
355      c->bad_pwd = prev_was_bad? 1 : 0;      c->bad_pwd = prev_was_bad? 1 : 0;
356      if (prev_was_bad && !c->cancel) {      if (prev_was_bad && !c->cancel) {
357          if (c->pwd)          if (c->pwd)
# Line 333  passphrase_cb (void *hook, const char *u Line 364  passphrase_cb (void *hook, const char *u
364          if (strlen (passphrase_info) < 16 &&          if (strlen (passphrase_info) < 16 &&
365              !strstr (passphrase_info, "OPENPGP")) {              !strstr (passphrase_info, "OPENPGP")) {
366              /* assume symetric encryption. */              /* assume symetric encryption. */
367              int n=2;              int pos = 2;
368              c->sym.sym_algo = atoi (passphrase_info);              c->sym.sym_algo = atoi (passphrase_info);
369              if (c->sym.sym_algo > 9)              if (c->sym.sym_algo > 9)
370                  n++;                  pos++;
371              /* XXX: be more strict. */              c->sym.s2k_mode = atoi (passphrase_info+pos);
372              c->sym.s2k_mode = atoi (passphrase_info+n);              c->sym.s2k_hash = atoi (passphrase_info+pos+2);
             c->sym.s2k_hash = atoi (passphrase_info+n+2);  
373          }          }
374    
375          keyid = parse_gpg_keyid (passphrase_info);          keyid = parse_gpg_keyid (passphrase_info);
376          pass = agent_get_cache (keyid+8, &item);          pass = agent_get_cache (keyid+8, &item);        
377          if (pass) {          if (pass) {
378              agent_unlock_cache_entry (&item);              agent_unlock_cache_entry (&item);
379              c->pwd_init = 0;              c->pwd_init = 0;
# Line 365  passphrase_cb (void *hook, const char *u Line 395  passphrase_cb (void *hook, const char *u
395              const char *s=passphrase_info;              const char *s=passphrase_info;
396              while (s && *s && *s != 'D')              while (s && *s && *s != 'D')
397                  s++;                  s++;
398              _snprintf (c->info, sizeof c->info-1,              _snprintf (c->info, DIM (c->info)-1,
399                         _("Please enter the PIN to unlock your secret card key\n"                         _("Please enter the PIN to unlock your secret card key\n"
400                           "Card: %s"), extract_serial_no (s));                           "Card: %s"), extract_serial_no (s));
401              c->is_card = 1;              c->is_card = 1;
402          }          }
403          else if (uid_hint)          else if (uid_hint)
404              parse_gpg_description (uid_hint, passphrase_info,              parse_gpg_description (uid_hint, passphrase_info,
405                                     c->info, sizeof c->info - 1);                                     c->info, DIM (c->info) - 1);
406            int rc = 0;
407          if (c->gpg_cmd == GPG_CMD_DECRYPT) {          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
408              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,
409                                   (HWND)c->hwnd, passphrase_callback_proc,                                   (HWND)c->hwnd, passphrase_callback_proc,
# Line 386  passphrase_cb (void *hook, const char *u Line 417  passphrase_cb (void *hook, const char *u
417          if (rc == -1) {          if (rc == -1) {
418              if (!WriteFile (hd, "\n", 1, &n, NULL))              if (!WriteFile (hd, "\n", 1, &n, NULL))
419                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);                  log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
420                log_debug ("passphrase_cb: could not create dialog box\n");
421              return 0;              return 0;
422          }          }
423          c->pwd_init = 0;          c->pwd_init = 0;
424      }      }
425      if (c->cancel) {      if (c->cancel || !c->pwd) {
426          if (!WriteFile (hd, "\n", 1, &n, NULL))          if (!WriteFile (hd, "\n", 1, &n, NULL))
427              log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);              log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
428          return 0;          return 0;
429      }      }
430    
431      WriteFile (hd, c->pwd, strlen (c->pwd), &n, NULL);      if (!WriteFile (hd, c->pwd, strlen (c->pwd), &n, NULL))
432      WriteFile (hd, "\n", 1, &n, NULL);          log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
433        if (!WriteFile (hd, "\n", 1, &n, NULL))
434            log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
435      return 0;      return 0;
436  }  }
437    
# Line 408  passphrase_cb (void *hook, const char *u Line 442  passphrase_cb (void *hook, const char *u
442  void  void
443  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,  set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,
444                         int cmd, HWND hwnd, const char *title)                         int cmd, HWND hwnd, const char *title)
445  {  {    
446      memset (cb, 0, sizeof *cb);      memset (cb, 0, sizeof *cb);
447      cb->gpg_cmd = cmd;      cb->gpg_cmd = cmd;
448      cb->bad_pwd = 0;      cb->bad_pwd = 0;
# Line 416  set_gpg_passphrase_cb (passphrase_cb_s * Line 450  set_gpg_passphrase_cb (passphrase_cb_s *
450      cb->cancel = 0;      cb->cancel = 0;
451      cb->hwnd = hwnd;      cb->hwnd = hwnd;
452      cb->pwd_init = 1;      cb->pwd_init = 1;
     free_if_alloc (cb->title);  
453      cb->title = m_strdup (title);      cb->title = m_strdup (title);
     if (!cb->title)  
         BUG (NULL);  
454      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);      gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);
455      cb->gpg = ctx;      cb->gpg = ctx;
456  }  }
457    
458    void
459    set_gpg_auto_passphrase_cb (passphrase_cb_s *cb, const char *title)
460    {
461        memset (cb, 0, sizeof *cb);
462        cb->gpg_cmd = GPG_CMD_SIGN;
463        cb->bad_pwd = 0;
464        cb->is_card = 0;
465        cb->cancel = 0;
466        cb->hwnd = GetActiveWindow ();
467        cb->pwd_init = 1;
468        cb->title = m_strdup (title);
469    }
470    
471    
472  /* Release a passphrase callback @ctx. */  /* Release a passphrase callback @ctx. */
473  void  void
474  release_gpg_passphrase_cb (passphrase_cb_s *ctx)  release_gpg_passphrase_cb (passphrase_cb_s *ctx)
475  {  {
     gpgme_recipient_t r, n;  
   
476      if (!ctx)      if (!ctx)
477          return;          return;
478      sfree_if_alloc (ctx->pwd);      sfree_if_alloc (ctx->pwd);
479      free_if_alloc (ctx->title);      free_if_alloc (ctx->title);
480      r = ctx->recipients;      release_gpg_recipients (&ctx->recipients);
481      while (r) {  }
482    
483    
484    /* Release the gpg recipient list. */
485    void
486    release_gpg_recipients (gpgme_recipient_t *recipients)
487    {
488        gpgme_recipient_t r, n;
489    
490        r = *recipients;
491        while (r != NULL) {
492          n = r->next;          n = r->next;
493          safe_free (r->keyid);          safe_free (r->keyid);
494          safe_free (r);          safe_free (r);
495          r = n;          r = n;
496      }      }
497        *recipients = NULL;
498  }  }
499    
500    
501  /* Simple check to measure passphrase (@pass) quality.  /* _Simple_ check to measure passphrase (@pass) quality.
502     Return value: 0 on success. */     Return value: 0 on success. */
503  int  int
504  check_passwd_quality (const char *pass, int strict)  check_passwd_quality (const char *pass, int strict)
505  {  {
506      int i, nd=0, nc=0, n;      size_t i, nd = 0, nc = 0, na = 0, n;
507    
508        /* A good passphrase should be at least 8 characters. */
509      n = strlen (pass);      n = strlen (pass);
510      if (n < 8)      if (n < 8)
511          return -1;          return -1;
512    
513      for (i=0; i < n; i++) {      for (i = 0; i < n; i++) {
514          if (isdigit (pass[i]))          if (isdigit (pass[i]))
515              nd++;              nd++;
516          if (isalpha (pass[i]))          if (isalpha (pass[i]))
517              nc++;              nc++;
518            else
519                na++;
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 || na == n)
524          return -1;          return -1;
525    
526      return 0;      return 0;
Legend:
Removed from v.47  
changed lines
  Added in v.344
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26