/[winpt]/trunk/Src/wptGPGME.cpp
ViewVC logotype

Diff of /trunk/Src/wptGPGME.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 36 by werner, Thu Oct 27 15:25:13 2005 UTC revision 214 by twoaday, Sun May 14 18:40:36 2006 UTC
# Line 17  Line 17 
17   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
18   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19   */   */
   
20  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
21  #include <config.h>  #include <config.h>
22  #endif  #endif
23    
24  #include <sys/types.h>  #include <sys/types.h>
 #include <sys/types.h>  
25  #include <windows.h>  #include <windows.h>
26    
27  #include "../resource.h"  #include "resource.h"
28  #include "wptNLS.h"  #include "wptNLS.h"
29  #include "wptGPG.h"  #include "wptGPG.h"
30  #include "wptErrors.h"  #include "wptErrors.h"
# Line 43  Line 41 
41  BOOL CALLBACK  keycache_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam);  BOOL CALLBACK  keycache_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam);
42  void progress_cleanup (progress_filter_s * pfx);  void progress_cleanup (progress_filter_s * pfx);
43    
44    /* Global GPG key cache contexts. */
45  static gpg_keycache_t pub = NULL;  static gpg_keycache_t pub = NULL;
46  static gpg_keycache_t sec = NULL;  static gpg_keycache_t sec = NULL;
 static unsigned int reload = 0;  
47  static char *gpg_secring = NULL;  static char *gpg_secring = NULL;
48    
49    
# Line 83  keycache_release (int cleanup) Line 81  keycache_release (int cleanup)
81          gpg_keycache_release (sec);          gpg_keycache_release (sec);
82          sec = NULL;          sec = NULL;
83      }      }
84      if (cleanup) {      if (cleanup)
85          if (gpg_secring)          safe_free (gpg_secring);
             free (gpg_secring);  
         gpg_secring = NULL;  
     }  
86  }  }
87    
88    
# Line 107  keycache_update (int is_sec, const char Line 102  keycache_update (int is_sec, const char
102      return err;      return err;
103  }  }
104    
 /* XXX: cache_keyring_names must be called then the GPG homedir changes! */  
105    
106  /* Initialize both cache contexts. Use @pubring for the public  /* Initialize both cache contexts. Use @pubring for the public
107     keyring and @secring for the secret keyring. */     keyring and @secring for the secret keyring. */
# Line 123  keycache_init (const char *pubring, cons Line 117  keycache_init (const char *pubring, cons
117          free_if_alloc (gpg_secring);          free_if_alloc (gpg_secring);
118          gpg_secring = get_gnupg_keyring (0, NO_STRICT);          gpg_secring = get_gnupg_keyring (0, NO_STRICT);
119      }      }
120        
     if (reload) {  
         keycache_release (0);  
         reload = 0;  
     }  
121      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");
122      if (p && *p != ' ') {      if (p && *p != ' ') {
123          val = atoi (p);          val = atoi (p);
124          free_if_alloc (p);          free_if_alloc (p);      
         memset (&pfx, 0, sizeof (pfx));  
125      }      }
126    
127        memset (&pfx, 0, sizeof (pfx));
128        /* Release old contexts first. */
129        keycache_release (0);
130    
131      err = gpg_keycache_new (&pub);      err = gpg_keycache_new (&pub);
132      if (err)      if (err)
133          return err;          return err;
# Line 144  keycache_init (const char *pubring, cons Line 137  keycache_init (const char *pubring, cons
137      if (!err)      if (!err)
138          err = gpg_keycache_init (pub, NULL, 0);          err = gpg_keycache_init (pub, NULL, 0);
139      if (!err)      if (!err)
140          err = gpg_keycache_init( sec, NULL, 1 );          err = gpg_keycache_init (sec, NULL, 1);
141      if( !err && pubring && *pubring )      if (!err && pubring && *pubring)
142          err = gpg_keycache_prepare( pub, pubring, NULL );          err = gpg_keycache_prepare (pub, pubring, NULL);
143      if( !err && secring && * secring )      if (!err && secring && * secring)
144          err = gpg_keycache_prepare( sec, NULL, secring );          err = gpg_keycache_prepare (sec, NULL, secring);
145      if (!err)      if (!err)
146          gpg_keycache_sync (pub, sec);          gpg_keycache_sync (pub, sec);
147      if (val != 0)      if (val != 0)
# Line 157  keycache_init (const char *pubring, cons Line 150  keycache_init (const char *pubring, cons
150  }  }
151    
152    
 /* If @val = 1 indicate to reload the cache. */  
 void  
 keycache_set_reload (int val)  
 {  
     reload = val;  
 }  
   
   
 /* Return the reload cache flag. */  
 int  
 keycache_get_reload (void)  
 {  
     return reload;  
 }  
   
   
153  /* Return the public cache context if @is_pub is set  /* Return the public cache context if @is_pub is set
154     the secre cache context otherwise. */     the secre cache context otherwise. */
155  gpg_keycache_t  gpg_keycache_t
156  keycache_get_ctx (int is_pub)  keycache_get_ctx (int is_pub)
157  {  {
158      return is_pub? pub : sec;      gpg_keycache_t ctx;
159    
160        ctx = is_pub? pub : sec;
161        if (!ctx)
162            BUG (0);
163        return ctx;
164  }  }
165    
166    
167  /* Get the GPG key with keyid @keyid from the cache. Return it  /* Get the GPG key with keyid @keyid from the cache. Return it
168     in @r_key on success. */     in @r_key on success. */
169  static int  static gpgme_error_t
170  get_key_from_cache (const char *keyid, gpgme_key_t *r_key,  get_key_from_cache (const char *keyid, gpgme_key_t *r_key,
171                      struct keycache_s **c, int secret)                      struct keycache_s **c, int secret)
172  {  {
# Line 193  get_key_from_cache (const char *keyid, g Line 175  get_key_from_cache (const char *keyid, g
175      int mode = secret? KEYCACHE_PRV : KEYCACHE_PUB;      int mode = secret? KEYCACHE_PRV : KEYCACHE_PUB;
176    
177      if (!keyid)      if (!keyid)
178          return WPTERR_GENERAL;          return gpg_error (GPG_ERR_INV_VALUE);
179      if (r_key)      if (r_key)
180          *r_key = NULL;          *r_key = NULL;
181      cache = keycache_get_ctx (mode);      cache = keycache_get_ctx (mode);
     if (!cache)  
         BUG( NULL );  
182      if (!c)      if (!c)
183          err = gpg_keycache_find_key (cache, keyid, 0, r_key);          err = gpg_keycache_find_key (cache, keyid, 0, r_key);
184      else      else
185          err = gpg_keycache_find_key2 (cache, keyid, 0, r_key, c);          err = gpg_keycache_find_key2 (cache, keyid, 0, r_key, c);
186      return err? WPTERR_GENERAL : 0;      return err;
187  }  }
188    
189    
190  /* Get GPG key with keyid @keyid directly from GPG and return  /* Get GPG key with keyid @keyid directly from GPG and return
191     it in @r_key on success. */     it in @r_key on success. */
192  static int  static gpgme_error_t
193  get_key_directly (const char *keyid, gpgme_key_t *r_key, int secret)  get_key_directly (const char *keyid, gpgme_key_t *r_key, int secret)
194  {  {
195      gpgme_ctx_t ctx;      gpgme_ctx_t ctx;
# Line 217  get_key_directly (const char *keyid, gpg Line 197  get_key_directly (const char *keyid, gpg
197    
198      err = gpgme_new (&ctx);      err = gpgme_new (&ctx);
199      if (err)      if (err)
200          return WPTERR_GENERAL;          return err;
201      err = gpgme_get_key (ctx, keyid, r_key, secret);      err = gpgme_get_key (ctx, keyid, r_key, secret);
202      gpgme_release (ctx);      gpgme_release (ctx);
203      return err? WPTERR_GENERAL : 0;      return err;
204  }  }
205    
206    
207  /* Search the public key with @keyid as the keyid in the cache and  /* Search the public key with @keyid as the keyid in the cache and
208     return the item in @k. */     return the item in @k. */
209  int  gpgme_error_t
210  winpt_get_pubkey (const char *keyid, winpt_key_s *k)  winpt_get_pubkey (const char *keyid, winpt_key_s *k)
211  {  {
212      int rc;      gpgme_error_t err;
213            
214      rc = get_key_from_cache (keyid, &k->ctx, &k->ext, 0);      err = get_key_from_cache (keyid, &k->ctx, &k->ext, 0);
215      if (rc)      if (err)
216          return rc;          return err;
217      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA &&      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA &&
218                  strlen (k->ctx->subkeys->fpr) == 32;                  strlen (k->ctx->subkeys->fpr) == 32;
219      k->is_protected = k->ext->gloflags.is_protected;      k->is_protected = k->ext->gloflags.is_protected;
220      k->keyid = k->ctx->subkeys->keyid;      k->keyid = k->ctx->subkeys->keyid+8;
221      k->uid = k->ctx->uids->uid;      k->uid = k->ext->uids->uid;
222      return rc;      return 0;
223  }  }
224    
225    
226  int  gpgme_error_t
227  winpt_get_seckey (const char *keyid, winpt_key_s *k)  winpt_get_seckey (const char *keyid, winpt_key_s *k)
228  {  {
229      int rc;      gpgme_error_t err;
230      rc = get_key_from_cache (keyid, &k->ctx, &k->ext, 1);  
231      if (rc)      err = get_key_from_cache (keyid, &k->ctx, &k->ext, 1);
232          return rc;      if (err)
233            return err;
234      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA &&      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA &&
235                  strlen (k->ctx->subkeys->fpr) == 32;                  strlen (k->ctx->subkeys->fpr) == 32;
236      k->is_protected = k->ext->gloflags.is_protected;      k->is_protected = k->ext->gloflags.is_protected;
237      k->keyid = k->ctx->subkeys->keyid;      k->keyid = k->ctx->subkeys->keyid+8;
238      k->uid = k->ctx->uids->uid;      k->uid = k->ext->uids->uid;
239      return rc;      return 0;
240  }  }
241    
242    
243  int  gpgme_error_t
244  get_pubkey (const char *keyid, gpgme_key_t *ret_key)  get_pubkey (const char *keyid, gpgme_key_t *ret_key)
245  {  {
246      int rc;      gpgme_error_t rc;
247    
248      if (pub && sec)      if (pub && sec)
249          rc = get_key_from_cache (keyid, ret_key, NULL, 0);          rc = get_key_from_cache (keyid, ret_key, NULL, 0);
# Line 272  get_pubkey (const char *keyid, gpgme_key Line 253  get_pubkey (const char *keyid, gpgme_key
253  }  }
254    
255    
256  int  gpgme_error_t
257  get_seckey (const char *keyid, gpgme_key_t *ret_skey)  get_seckey (const char *keyid, gpgme_key_t *ret_skey)
258  {  {
259      int rc;      gpgme_error_t rc;
260    
261      if (pub && sec)      if (pub && sec)
262          rc = get_key_from_cache (keyid, ret_skey, NULL, 1);          rc = get_key_from_cache (keyid, ret_skey, NULL, 1);
# Line 295  count_insecure_elgkeys (void) Line 276  count_insecure_elgkeys (void)
276      int n=0;      int n=0;
277    
278      pc = keycache_get_ctx (1);      pc = keycache_get_ctx (1);
     if (!pc)  
         BUG (0);  
279      while (!gpg_keycache_next_key (pc, 0, &key)) {      while (!gpg_keycache_next_key (pc, 0, &key)) {
280          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
281              n++;              n++;
# Line 304  count_insecure_elgkeys (void) Line 283  count_insecure_elgkeys (void)
283      gpg_keycache_rewind (pc);      gpg_keycache_rewind (pc);
284      return n;      return n;
285  }  }
286    
287    
288    
289    /* Map the signature summary in @sum to signature status table index.
290       Return value: index to table. */
291    static int
292    sigsum_to_index (gpgme_sigsum_t sum)
293    {
294        if ((sum & GPGME_SIGSUM_VALID) && (sum & GPGME_SIGSUM_KEY_REVOKED))
295            return 7;
296        if ((sum & GPGME_SIGSUM_VALID) && (sum & GPGME_SIGSUM_SIG_EXPIRED))
297            return 6;
298        if (sum & GPGME_SIGSUM_GREEN)
299            return 1;
300        else if (sum & GPGME_SIGSUM_RED)
301            return 2;
302        else if (sum & GPGME_SIGSUM_KEY_MISSING)
303            return 3;
304        return 0;
305    }
306    
307    
308    /* Return a humand readable description for the signature status @sum. */
309    const char*
310    get_gpg_sigstat (gpgme_sigsum_t sum)
311    {
312        const char *gpg_sigstat[] = {
313            _("Error during verification process."),
314            _("The signature is good."),
315            _("The signature is BAD!"),
316            _("The signature could not be checked due to a missing key."),
317            _("No valid OpenPGP signature."),
318            _("Signature Error"),
319            _("Good Signature (Expired Key)"),
320            _("Good Signature (Revoked Key)"),
321            NULL
322        };
323        const unsigned int mask = 8;
324    
325        return gpg_sigstat[sigsum_to_index (sum) % mask];
326    }
327    
328    
329    /* Check if the secret keyring contains at least one
330       key with ultimate trust.
331       Return value: 0 on success. */
332    int
333    check_ultimate_trusted_key (void)
334    {
335        struct keycache_s *n;
336        int nkeys = 0;
337    
338        for (n = sec->item; n; n = n->next) {
339            if (n->pubpart &&
340                n->pubpart->key->owner_trust == GPGME_VALIDITY_ULTIMATE)
341            return 0;
342            nkeys++;
343        }
344    
345        /* if we do not have any secret keys, it does not make sense
346           to return an error. */
347        if (nkeys == 0)
348            return 0;
349        return -1;
350    }
351    
352    
353    bool
354    secret_key_available (void)
355    {
356        gpg_keycache_t _sec = keycache_get_ctx (0);
357        if (!_sec || gpg_keycache_get_size (_sec) == 0)
358            return false;
359        return true;
360    }
Legend:
Removed from v.36  
changed lines
  Added in v.214
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26