/[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 22 by twoaday, Wed Aug 10 11:33:35 2005 UTC revision 27 by twoaday, Tue Oct 18 07:57:13 2005 UTC
# Line 1  Line 1 
1  /* wptPassphraseCB.cpp - GPGME Passphrase Callback  /* wptPassphraseCB.cpp - GPGME Passphrase Callback
2   *      Copyright (C) 2001, 2002, 2003 Timo Schulz   *      Copyright (C) 2001, 2002, 2003, 2005 Timo Schulz
3     *      Copyright (C) 2005 g10 Code GmbH
4   *   *
5   * This file is part of WinPT.   * This file is part of WinPT.
6   *   *
# Line 32  Line 33 
33  #include "wptUTF8.h"  #include "wptUTF8.h"
34  #include "wptErrors.h"  #include "wptErrors.h"
35  #include "wptTypes.h"  #include "wptTypes.h"
36    #include "wptKeyList.h"
37  #include "wptAgent.h"  #include "wptAgent.h"
38  #include "wptRegistry.h"  #include "wptRegistry.h"
39    
40    const char* get_symkey_algo (int algo);
41    
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)
# Line 43  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    
49  BOOL CALLBACK  /* Overwrite passphrase and free memory. */
50    static void
51    burn_passphrase (char **pwd)
52    {
53        char *pass = *pwd;  
54        memset (pass, 0, strlen (pass));
55        delete []pass;
56        *pwd = NULL;
57    }
58    
59    
60    /* Dialog procedure for the passphrase callback. */
61    static BOOL CALLBACK
62  passphrase_callback_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  passphrase_callback_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
63  {      {    
64      static passphrase_cb_s * c;      static passphrase_cb_s * c;
65        gpgme_decrypt_result_t res;
66        gpgme_sign_result_t res_sig;
67      gpgme_key_t key;      gpgme_key_t key;
68      const char * s, * id;      void *ctx = NULL, *item;
69      char info[768] = {0};      const char *id;
70      void * ctx = NULL, * item;      char *info;
71      unsigned int pkalgo;      int n;
72    
73      switch( msg )  {      /* XXX: we need a timer to update the 'enc_to' entries. */
74        switch (msg) {
75      case WM_INITDIALOG:      case WM_INITDIALOG:
76          c = (passphrase_cb_s *)lparam;          c = (passphrase_cb_s *)lparam;
77          if (!c)          if (!c)
# Line 64  passphrase_callback_proc (HWND dlg, UINT Line 82  passphrase_callback_proc (HWND dlg, UINT
82                  _("Encrypted with the following public key(s)") );                  _("Encrypted with the following public key(s)") );
83              CheckDlgButton( dlg, IDC_DECRYPT_HIDE, BST_CHECKED );              CheckDlgButton( dlg, IDC_DECRYPT_HIDE, BST_CHECKED );
84          }          }
85          else if( c->gpg_cmd == GPG_CMD_SIGN )          else if (c->gpg_cmd == GPG_CMD_SIGN)
86              CheckDlgButton( dlg, IDC_DECRYPT_SIGN_HIDE, BST_CHECKED );              CheckDlgButton (dlg, IDC_DECRYPT_SIGN_HIDE, BST_CHECKED);
87          if( c->enc_to && c->gpg_cmd == GPG_CMD_DECRYPT ) {          res = gpgme_op_decrypt_result (c->gpg);
88              gpgme_recipients_enum_open( c->enc_to, &ctx );          if (res != NULL && c->gpg_cmd == GPG_CMD_DECRYPT) {
89              while ( (s = gpgme_recipients_enum_read( c->enc_to, &ctx )) ) {              gpgme_recipient_t r;
90                  pkalgo = *s; s++;  
91                  get_pubkey( s, &key );              /* XXX: not all ENCRYPT_TO entries are listed here. */
92                  if( key ) {              for (r = res->recipients; r; r = r->next) {
93                      char * uid = NULL;                  get_pubkey (r->keyid, &key);
94                      id = gpgme_key_get_string_attr( key, GPGME_ATTR_USERID, NULL, 0 );                  if (key) {
95                      if( !id )                      char *uid;
96                        id = key->uids->name;
97                        if (!id)
98                          id = _("Invalid User ID");                          id = _("Invalid User ID");
99                      uid = utf8_to_wincp (id, strlen (id));                                      uid = utf8_to_wincp (id, strlen (id));
100                      _snprintf( info, sizeof info - 1, "%s (%s, 0x%s)", uid,                      info = new char [32+strlen (uid)+1 + 4 + strlen (r->keyid)+1
101                                  gpgme_key_expand_attr( GPGME_ATTR_ALGO, pkalgo ), s+8 );                                       + strlen (key->uids->email)+1];
102                      free( uid );                      if (!info)
103                            BUG (NULL);
104                        sprintf (info, "%s <%s> (%s, 0x%s)", uid, key->uids->email,
105                                 get_key_pubalgo (r->pubkey_algo), r->keyid+8);
106                        free (uid);
107                        
108                  }                  }
109                  else                  else {
110                      _snprintf( info, sizeof info - 1, _("Unknown (key ID 0x%s)"),                      info = new char [32 + strlen (r->keyid)+1 + 4];
111                                 s? s + 8 : "DEADBEEF" );                      if (!info)
112                  listbox_add_string( GetDlgItem( dlg, IDC_DECRYPT_LIST ), info );                          BUG (NULL);
113                        sprintf (info, _("Unknown key ID (%s, 0x%s)"),
114                                 get_key_pubalgo (r->pubkey_algo), r->keyid+8);
115                    }
116                    listbox_add_string (GetDlgItem (dlg, IDC_DECRYPT_LIST), info);
117                    free_if_alloc (info);
118              }              }
             gpgme_recipients_enum_close( c->enc_to, &ctx );  
119          }          }
120          SetDlgItemText( dlg, c->gpg_cmd == GPG_CMD_DECRYPT?          else if (c->gpg_cmd == GPG_CMD_DECRYPT)
121                EnableWindow (GetDlgItem (dlg, IDC_DECRYPT_LIST), FALSE);
122            SetDlgItemText (dlg, c->gpg_cmd == GPG_CMD_DECRYPT?
123                          IDC_DECRYPT_PWDINFO : IDC_DECRYPT_SIGN_PWDINFO,                          IDC_DECRYPT_PWDINFO : IDC_DECRYPT_SIGN_PWDINFO,
124                          _("Please enter your passphrase") );                          c->bad_pwd? _("Bad passphrase; Enter passphrase again") :
125          if( c->gpg_cmd == GPG_CMD_DECRYPT ) {                          _("Please enter your passphrase"));
126              SetFocus( GetDlgItem( dlg, IDC_DECRYPT_PWD ) );          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
127              SetDlgItemText( dlg, IDC_DECRYPT_MSG, c->info );              SetFocus (GetDlgItem (dlg, IDC_DECRYPT_PWD));
128                if (res && !res->recipients) {
129                    const char *s = _("Symmetric encryption.\n"
130                                      "%s encrypted data.");
131                    const char *alg = get_symkey_algo (c->sym.sym_algo);
132                    info = new char[strlen (s) + strlen (alg) + 2];
133                    if (!info)
134                        BUG (NULL);
135                    sprintf (info, s, alg);
136                    SetDlgItemText (dlg, IDC_DECRYPT_MSG, info);
137                    free_if_alloc (info);
138                }
139                else
140                    SetDlgItemText (dlg, IDC_DECRYPT_MSG, c->info);
141          }          }
142          else {          else {
143              SetFocus( GetDlgItem( dlg, IDC_DECRYPT_SIGN_PWD ) );              SetFocus( GetDlgItem (dlg, IDC_DECRYPT_SIGN_PWD));
144              SetDlgItemText( dlg, IDC_DECRYPT_SIGN_MSG, c->info );              SetDlgItemText (dlg, IDC_DECRYPT_SIGN_MSG, c->info);
145          }          }
146          center_window( dlg );          center_window (dlg, NULL);
147          SetForegroundWindow( dlg );          SetForegroundWindow (dlg);
148          set_active_window( dlg );          set_active_window (dlg);
149          return FALSE;          return FALSE;
150    
151          case WM_SYSCOMMAND:          case WM_SYSCOMMAND:
152              if( LOWORD( wparam ) == SC_CLOSE ) {              if (LOWORD (wparam) == SC_CLOSE) {
153                  SetDlgItemText( dlg, item_ctrl_id( c->gpg_cmd ), "" );                  SetDlgItemText (dlg, item_ctrl_id( c->gpg_cmd ), "");
154                  c->cancel = 1;                  c->cancel = 1;
155                  EndDialog( dlg, TRUE );                  EndDialog (dlg, TRUE);
156              }              }
157              return FALSE;              break;
158    
159          case WM_COMMAND:          case WM_COMMAND:
160              switch( HIWORD( wparam ) ) {              switch( HIWORD( wparam ) ) {
# Line 120  passphrase_callback_proc (HWND dlg, UINT Line 164  passphrase_callback_proc (HWND dlg, UINT
164                      HWND hwnd;                      HWND hwnd;
165                      int hide = IsDlgButtonChecked (dlg, item_ctrl_id2 (c->gpg_cmd));                      int hide = IsDlgButtonChecked (dlg, item_ctrl_id2 (c->gpg_cmd));
166                      hwnd = GetDlgItem (dlg, item_ctrl_id (c->gpg_cmd));                      hwnd = GetDlgItem (dlg, item_ctrl_id (c->gpg_cmd));
167                      SendMessage( hwnd, EM_SETPASSWORDCHAR, hide? '*' : 0, 0 );                      SendMessage (hwnd, EM_SETPASSWORDCHAR, hide? '*' : 0, 0);
168                      SetFocus (hwnd);                      SetFocus (hwnd);
169                  }                  }
170              }              }
# Line 130  passphrase_callback_proc (HWND dlg, UINT Line 174  passphrase_callback_proc (HWND dlg, UINT
174                  /* fixme: the item is even cached when the passphrase is not                  /* fixme: the item is even cached when the passphrase is not
175                            correct, which means that the user needs to delete all                            correct, which means that the user needs to delete all
176                            cached entries to continue. */                            cached entries to continue. */
177                  GetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), c->pwd, sizeof (c->pwd) -1);                  if (c->pwd)
178                  if (reg_prefs.cache_time > 0 && !c->is_card && !strstr (c->keyid, "missing")) {                      burn_passphrase (&c->pwd);
179                    n = item_get_text_length (dlg, item_ctrl_id (c->gpg_cmd));
180                    if (!n) {
181                        c->pwd = new char[2];
182                        if (!c->pwd)
183                            BUG (NULL);
184                        strcpy (c->pwd, "");
185                    }
186                    else {
187                        c->pwd = new char[n+2];
188                        if (!c->pwd)
189                            BUG (NULL);
190                        GetDlgItemText (dlg, item_ctrl_id (c->gpg_cmd), c->pwd, n+1);
191                    }
192                    res = gpgme_op_decrypt_result (c->gpg);
193                    if (!res)
194                        res_sig = gpgme_op_sign_result (c->gpg);
195                    if (reg_prefs.cache_time > 0 && !c->is_card &&
196                        ((res && res->recipients) || (res_sig && res_sig->signatures))) {
197                      if (agent_get_cache (c->keyid, &item))                      if (agent_get_cache (c->keyid, &item))
198                          agent_unlock_cache_entry (&item);                          agent_unlock_cache_entry (&item);
199                      else                      else
# Line 150  passphrase_callback_proc (HWND dlg, UINT Line 212  passphrase_callback_proc (HWND dlg, UINT
212      }      }
213            
214      return FALSE;      return FALSE;
215  } /* passphrase_callback_proc */  }
216    
217    
218  static const char *  /* Extract the main keyid from @pass_info.
219  parse_gpg_keyid (const char * desc)     Return value: long main keyid or NULL for an error. */
220    static const char*
221    parse_gpg_keyid (const char *pass_info)
222  {  {
223      static char keyid[16+1];      static char keyid[16+1];
     char * p;  
224            
225      p = strrchr (desc, '\n');      /* XXX: check for leading alpha-chars? */
226      if( !p )      if (strlen (pass_info) < 16)
227          return NULL;          return NULL;
228      /* the format of the desc buffer looks like this:      /* the format of the desc buffer looks like this:
229         request_keyid[16] main_keyid[16] keytype[1] keylength[4]         request_keyid[16] main_keyid[16] keytype[1] keylength[4]
230         we use the main keyid to use only one cache entry. */         we use the main keyid to use only one cache entry. */
231      strncpy (keyid, desc+(p-desc+1+17), 16);      strncpy (keyid, pass_info+17, 16);
232        keyid[16] = 0;
233      return keyid;      return keyid;
234  } /* parse_gpg_keyid */  }
235    
236    
237  static void  /* Parse the information in @uid_hint and @pass_info to generate
238  parse_gpg_description( char * desc, int size )     a input message for the user in @desc. */
239    static int
240    parse_gpg_description (const char *uid_hint, const char *pass_info,
241                           char *desc, int size)
242  {  {
243      char * buffer = NULL, ch, uid[128] = {0}, * uid2 = NULL;      gpgme_pubkey_algo_t algo;
244      char usedkey[16+1] = {0}, mainkey[16+1] = {0};      char usedkey[16+1], mainkey[16+1];
245      const char * buf;      char *uid, *p;
246      int i, algo, try_again = 0;      int n=0;
247    
248      if( stristr( desc, "[User ID hint missing]" )      if (strlen (uid_hint) < 17) {
249          || stristr( desc, "[passphrase info missing]" ) ) {          *desc = 0;
250          _snprintf( desc, size-1,          return -1;
                    _("You need a passphrase to unlock the secret key for\n"  
                      "user: [UserID hint missing]\n"  
                      "      [passphrase info missing]\n") );  
         return;  
251      }      }
252    
253      buffer = new char[size+1];      while (p = strsep ((char**)&pass_info, " ")) {
254      if( !buffer )          switch (n++) {
255          BUG( NULL );          case 0: strncpy (mainkey, p, 16); mainkey[16] = 0; break;
256      strcpy( buffer, desc );          case 1: strncpy (usedkey, p, 16); usedkey[16] = 0; break;
257      buf = buffer;          case 2: algo = (gpgme_pubkey_algo_t)atol (p); break;
     if( strstr( buf, "TRY_AGAIN" ) ) {  
         buf += strlen( "TRY_AGAIN\n" );  
         try_again = 1;  
     }  
     else if( strstr( buf, "ENTER_PASSPHRASE" ) )  
         buf += strlen( "ENTER_PASSPHRASE\n" );  
     else  
         BUG( NULL );  
     buf += 17;  
     for( i = 0; i < sizeof uid-1; i++ ) {  
         ch = *buf++;  
         if( ch == '\n' ) {  
             uid[i] = '\0';  
             break;  
258          }          }
         uid[i] = ch;  
259      }      }
260      memcpy( usedkey, buf, 16 );      uid_hint += 16; /* skip keyid */
261      usedkey[16] = '\0';      uid_hint += 1;  /* space */
     buf += 17;  
     memcpy( mainkey, buf, 16 );  
     mainkey[16] = '\0';  
     buf += 17;  
     if( !buf )  
         BUG( NULL );  
     algo = atol( buf );  
     free_if_alloc( buffer );  
262    
263      uid2 = utf8_to_wincp (uid, strlen (uid));      uid = utf8_to_wincp (uid_hint, strlen (uid_hint));
264    
265      if( strcmp( usedkey, mainkey ) )      if (strcmp (usedkey, mainkey))
266          _snprintf( desc, size-1,          _snprintf (desc, size-1,
267                     _("You need a passphrase to unlock the secret key for\n"                     _("You need a passphrase to unlock the secret key for\n"
268                       "user: \"%s\"\n"                       "user: \"%s\"\n"
269                       "%s key, ID %s (main key ID %s)\n"),                       "%s key, ID %s (main key ID %s)\n"),
270                     uid2, gpgme_key_expand_attr( GPGME_ATTR_ALGO, algo ),                     uid, get_key_pubalgo (algo), usedkey+8, mainkey+8);
271                     usedkey+8, mainkey+8 );      else if (!strcmp (usedkey, mainkey))
272      else if( !strcmp( usedkey, mainkey ) )          _snprintf (desc, size-1,
         _snprintf( desc, size-1,  
273                     _("You need a passphrase to unlock the secret key for\n"                     _("You need a passphrase to unlock the secret key for\n"
274                       "user: \"%s\"\n"                       "user: \"%s\"\n"
275                       "%s key, ID %s\n"),                       "%s key, ID %s\n"),
276                       uid2, gpgme_key_expand_attr( GPGME_ATTR_ALGO, algo ),                       uid, get_key_pubalgo (algo), usedkey+8);
277                       usedkey+8 );      free (uid);
278      free( uid2 );      return 0;
279  } /* parse_gpg_describtion */  }
280    
281    
282    /*
283  static int inline  static int inline
284  is_hexstring( const char * p )  is_hexstring (const char * p)
285  {  {
286      size_t i;      size_t i;
287      for( i=0; i < strlen( p ); i++ ) {  
288          if( !isxdigit( p[i] ) )      for (i=0; i < strlen (p); i++) {
289            if (!isxdigit (p[i]))
290              return -1;              return -1;
291      }      }
292      return 0;      return 0;
293  }  }
294    */
295    
296    /* Passphrase callback with the ability to support caching. */
297    gpgme_error_t
298    passphrase_cb (void *hook, const char *uid_hint,
299                   const char *passphrase_info,
300                   int prev_was_bad, int fd)
301    {
302        passphrase_cb_s *c = (passphrase_cb_s*)hook;
303        HANDLE hd = (HANDLE)fd;
304        void *item;
305        const char *keyid, *pass;
306        DWORD n;
307        int rc;
308    
309        if (!c)
310            return gpg_error (GPG_ERR_INV_ARG);
311        c->bad_pwd = prev_was_bad? 1 : 0;
312        if (prev_was_bad && !c->cancel) {
313            if (c->pwd)
314                burn_passphrase (&c->pwd);
315            agent_del_cache (c->keyid);
316            c->pwd_init = 1;
317        }
318    
319  const char *      if (passphrase_info) {
320  passphrase_cb( void * opaque, const char * desc, void * r_hd )          if (strlen (passphrase_info) < 16 &&
321  {                !strstr (passphrase_info, "OPENPGP")) {/* assume symetric encryption. */
322      passphrase_cb_s * c = (passphrase_cb_s *)opaque;              int n=2;
323      void * item;              c->sym.sym_algo = atoi (passphrase_info);
324      const char * pass, * keyid;              if (c->sym.sym_algo > 9)
325      int rc = 0;                  n++;
326                /* XXX: be more strict. */
327      if( !c )              c->sym.s2k_mode = atoi (passphrase_info+n);
328          return NULL;              c->sym.s2k_hash = atoi (passphrase_info+n+2);
329            }
330    
331      if( desc ) {          keyid = parse_gpg_keyid (passphrase_info);
332          keyid = parse_gpg_keyid (desc);          pass = agent_get_cache (keyid+8, &item);
333          pass = agent_get_cache( keyid, &item );          if (pass) {
334          if( pass ) {              agent_unlock_cache_entry (&item);
             agent_unlock_cache_entry( &item );  
335              c->pwd_init = 0;              c->pwd_init = 0;
336              return pass;              if (!WriteFile (hd, pass, strlen (pass), &n, NULL))
337                    log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
338                if (!WriteFile (hd, "\n", 1, &n, NULL))
339                    log_debug ("passphrase_cb: WriteFile() failed ec=%d\n", w32_errno);
340                return 0;
341          }          }
342      }      }
343    
344      if( c->pwd_init ) {      if (c->pwd_init) {
345          c->keyid = keyid;          if (keyid && strlen (keyid) == 16)
346          /* if the desc has a length of 32 and only hex digits, we assume a              strcpy (c->keyid, keyid+8);
347             smart card has been used. */  
348          /*log_box( "", 0, "%s %d %d", desc,strlen( desc), is_hexstring( desc ) );*/          /* if @passphrase_info contains 'OPENPGP' we assume a smart card
349          if( desc && strlen( desc ) == 32 && !is_hexstring( desc ) ) {              has been used. */
350            if (strstr (passphrase_info, "OPENPGP")) {
351              char buf[16];              char buf[16];
352              memset( buf, 0, sizeof buf );              memset (buf, 0, sizeof buf);
353              strncpy( buf, desc+20, 8 );              strncpy (buf, "??", 2); /* XXX: fixme we need the serial no. */
354              _snprintf( c->info, sizeof c->info-1,              _snprintf (c->info, sizeof c->info-1,
355                      _("Please enter the PIN to unlock your secret card key\n"                         _("Please enter the PIN to unlock your secret card key\n"
356                        "Card: %s"), buf );                           "Card: %s"), buf);
357              c->is_card = 1;              c->is_card = 1;
358          }          }
359          else if(desc) {          else if (uid_hint)
360              strcpy (c->info, desc);              parse_gpg_description (uid_hint, passphrase_info,
361              parse_gpg_description (c->info, sizeof c->info - 1);                                     c->info, sizeof c->info - 1);
362          }          if (c->gpg_cmd == GPG_CMD_DECRYPT) {
363          if( c->gpg_cmd == GPG_CMD_DECRYPT ) {              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,
364              rc = DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT,                                   (HWND)c->hwnd, passphrase_callback_proc,
365                                  (HWND)c->hwnd, passphrase_callback_proc,                                   (LPARAM)c);
366                                  (LPARAM)c );          }
367          }          else if (c->gpg_cmd == GPG_CMD_SIGN) {
368          else if( c->gpg_cmd == GPG_CMD_SIGN ) {              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT_SIGN,
369              rc = DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_DECRYPT_SIGN,                                   (HWND)c->hwnd, passphrase_callback_proc,
370                                  (HWND)c->hwnd, passphrase_callback_proc,                                   (LPARAM)c);
371                                  (LPARAM)c );          }
372            if (rc == -1) {
373                WriteFile (hd, "\n", 1, &n, NULL);
374                return 0;
375          }          }
         if( rc == -1 )  
             return NULL;  
376          c->pwd_init = 0;          c->pwd_init = 0;
377      }      }
378        if (c->cancel) {
379            WriteFile (hd, "\n", 1, &n, NULL);
380            return 0;
381        }
382    
383        WriteFile (hd, c->pwd, strlen (c->pwd), &n, NULL);
384        WriteFile (hd, "\n", 1, &n, NULL);
385        return 0;
386    }
387    
     if( c->cancel )  
         return NULL;  
388    
389      return c->pwd;  /* Initialize the given passphrase callback @cb with the
390  } /* passphrase_cb */     used gpgme context @ctx, the command @cmd and a title
391       @title for the dialog. */
392    void
393    set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,
394                           int cmd, HWND hwnd, const char *title)
395    {
396        memset (cb, 0, sizeof *cb);
397        cb->gpg_cmd = cmd;
398        cb->bad_pwd = 0;
399        cb->is_card = 0;
400        cb->cancel = 0;
401        cb->hwnd = hwnd;
402        cb->pwd_init = 1;
403        free_if_alloc (cb->title);
404        cb->title = m_strdup (title);
405        if (!cb->title)
406            BUG (NULL);
407        gpgme_set_passphrase_cb (ctx, passphrase_cb, cb);
408        cb->gpg = ctx;
409    }
410    
411    
412    /* Release a passphrase callback @ctx. */
413  void  void
414  set_gpg_passphrase_cb (gpgme_ctx_t c, passphrase_cb_s *ctx, int cmd,  release_gpg_passphrase_cb (passphrase_cb_s *ctx)
                        HWND hwnd, const char *title)  
415  {  {
416      ctx->gpg_cmd = cmd;      if (!ctx)
417      ctx->is_card = 0;          return;
418      ctx->cancel = 0;      sfree_if_alloc (ctx->pwd);
419      ctx->hwnd = hwnd;      free_if_alloc (ctx->title);
420      ctx->pwd_init = 1;  }
     if (strlen (title) > 256)  
         BUG (NULL); /* check bounds */  
     strcpy (ctx->title, title);  
     gpgme_set_passphrase_cb (c, passphrase_cb, ctx);  
 } /* set_gpg_passphrase_cb */  
421    
422    
423    /* Simple check to measure passphrase (@pass) quality.
424       Return value: 0 on success. */
425  int  int
426  check_passwd_quality (const char *pass, int strict)  check_passwd_quality (const char *pass, int strict)
427  {  {
Legend:
Removed from v.22  
changed lines
  Added in v.27
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26