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

Diff of /trunk/Src/wptKeyPropsDlg.cpp

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

revision 41 by twoaday, Fri Oct 28 07:15:26 2005 UTC revision 310 by twoaday, Sat Apr 7 11:07:20 2007 UTC
# Line 1  Line 1 
1  /* wptKeyPropsDlg.cpp - WinPT key properties dialog  /* wptKeyPropsDlg.cpp - WinPT key property dialog
2   *      Copyright (C) 2000, 2001, 2002, 2003, 2005 Timo Schulz   *      Copyright (C) 2000, 2001, 2002, 2003, 2005, 2006 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
# 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
21    #include <config.h>
22    #endif
23    
24  #include <windows.h>  #include <windows.h>
25    #include <assert.h>
26    
27  #include "../resource.h"  #include "resource.h"
28  #include "wptErrors.h"  #include "wptErrors.h"
29  #include "wptGPG.h"  #include "wptGPG.h"
30  #include "wptCommonCtl.h"  #include "wptCommonCtl.h"
# Line 38  Line 42 
42  static int  static int
43  do_check_key (gpgme_key_t key)  do_check_key (gpgme_key_t key)
44  {  {
45      int okay = 0;      int invalid;
46      okay = key->expired;  
47      if (!okay)      invalid = key->expired;
48          okay = key->revoked;      if (!invalid)
49      return okay;          invalid = key->revoked;
50        return invalid;
51  }  }
52    
53    
54  /* Convert a trust integer into a string representation. */  /* Convert a trust integer into a string representation. */
55  static const char*  static const char*
56  ownertrust_to_string (int val)  ownertrust_to_string (int val, bool is_keypair)
57  {  {
58      const char *inf;      const char *inf;
59      int id = val;      int id = val;
# Line 59  ownertrust_to_string (int val) Line 64  ownertrust_to_string (int val)
64      case 3: inf = _("I trust marginally"); break;      case 3: inf = _("I trust marginally"); break;
65      case 4: inf = _("I trust fully");      break;      case 4: inf = _("I trust fully");      break;
66      case 5:      case 5:
67      case 6: inf = _("I trust ultimately"); break;      case 6:
68            if (is_keypair)
69                inf = _("I trust ultimately (implicit)");
70            else
71                inf = _("I trust ultimately"); break;
72      default:inf = _("Unknown");            break;      default:inf = _("Unknown");            break;
73      }      }
74            
# Line 69  ownertrust_to_string (int val) Line 78  ownertrust_to_string (int val)
78    
79  /* Generate a unique temp name for the photo which  /* Generate a unique temp name for the photo which
80     depends on the dialog handle and return it. */     depends on the dialog handle and return it. */
81  static const char*  const char*
82  get_photo_tmpname (HWND dlg)  get_photo_tmpname (HWND dlg)
83  {  {
84      static char buf[64];      static char buf[MAX_PATH+128+1];
85        char name[64];
86    
87      _snprintf (buf, sizeof (buf)-1, "winpt_photo_%08lX.tmp", (DWORD)dlg);      _snprintf (name, DIM (name)-1, "winpt_photo_%08lX.tmp", (DWORD)dlg);
88        get_temp_name (buf, DIM (buf)-1, name);
89      return buf;      return buf;
90  }  }
91    
92    
93    static void
94    draw_nophoto_img (HWND dlg)
95    {
96        /*..
97        n = DrawText (hdc, "No Photo-ID", -1, &r, DT_LEFT);
98        ..*/
99    }
100    
101    
102    
103    /* Delete temporary photo file. */
104    void
105    key_unload_photo (HWND dlg)
106    {
107        DeleteFile (get_photo_tmpname (dlg));
108    }
109    
110    
111  /* Load the photo from the key @key */  /* Load the photo from the key @key */
112  static int  int
113  keyprops_load_photo (HWND dlg, gpgme_key_t key, gpgme_validity_t *r_valid)  key_load_photo (HWND dlg, gpgme_key_t key, gpgme_validity_t *r_valid)
114  {  {
115      winpt_key_s k;      winpt_key_s k;
116      FILE *f;      FILE *fp;
117      const BYTE *img;      const BYTE *img;
118      DWORD imglen = 0;      DWORD imglen;
     int pos=0;  
119    
120      winpt_get_pubkey (key->subkeys->keyid, &k);      if (winpt_get_pubkey (key->subkeys->keyid, &k))
121            BUG (0);
122      img = k.ext->attrib.d;      img = k.ext->attrib.d;
123      imglen = k.ext->attrib.len;      imglen = k.ext->attrib.len;
124      if (!k.ext->attrib.validity)      if (img && !k.ext->attrib.validity)
125          get_uat_validity (key->subkeys->keyid, &k.ext->attrib.validity);          get_uat_validity (key->subkeys->keyid, &k.ext->attrib.validity);
126      *r_valid = k.ext->attrib.validity;      if (r_valid)
127            *r_valid = k.ext->attrib.validity;
128    
129      if (!img || !imglen)      if (!img || !imglen) {
130            draw_nophoto_img (dlg);
131          return -1;          return -1;
     f = fopen (get_photo_tmpname (dlg), "wb");  
     if (f) {  
         for (pos = 0; img[pos] != 0x10; pos++)  
                 ;  
         pos += 16;  
         fwrite (img + pos, 1, imglen - pos, f);  
         fwrite (img, 1, imglen, f);  
         fclose (f);  
132      }      }
     return 0;  
 }  
   
133    
134  /* Display the photo in the image control in the dialog @dlg. */      fp = fopen (get_photo_tmpname (dlg), "wb");
135  static int      if (fp) {
136  keyprops_show_photo (HWND dlg)          const int pos = 16;
137  {          fwrite (img + pos, 1, imglen - pos, fp);
138      RECT r;              fclose (fp);
139      POINT p;      }
     HWND h;  
   
     h = GetDlgItem (dlg, IDC_KEYPROPS_IMG);  
     GetWindowRect (h, &r);  
     p.x = r.left + 5;  
     p.y = r.top - 2;  
     memset (&p, 0, sizeof (p));  
     PTD_jpg_show (h, &p, get_photo_tmpname (dlg));  
       
140      return 0;      return 0;
141  }  }
142    
# Line 134  keyprops_show_photo (HWND dlg) Line 145  keyprops_show_photo (HWND dlg)
145  static const char*  static const char*
146  get_validity (gpgme_key_t key)  get_validity (gpgme_key_t key)
147  {  {
148      int val;      if (key->expired)
     val = key->expired;  
     if (val)  
149          return _("Expired");              return _("Expired");    
150      val = key->revoked;      if (key->revoked)
     if (val)  
151          return _("Revoked");          return _("Revoked");
152      val = key->disabled;      if (key->disabled)
     if (val)  
153          return _("Disabled");          return _("Disabled");
154        if (key->invalid)
155            return _("Invalid");
156      return get_key_trust2 (NULL, key->uids->validity, 0, 0);      return get_key_trust2 (NULL, key->uids->validity, 0, 0);
157  }  }
158    
# Line 152  get_validity (gpgme_key_t key) Line 161  get_validity (gpgme_key_t key)
161  static const char*  static const char*
162  get_pref_cipher (winpt_key_t k)  get_pref_cipher (winpt_key_t k)
163  {  {
     const char *sym_prefs=NULL;      
   
164      if (k->is_v3)      if (k->is_v3)
165          return "IDEA";          return "IDEA";
166      if (!k->ext->sym_prefs)      if (!k->ext || !k->ext->sym_prefs)
167          return "3DES";          return "3DES";
168      switch (*k->ext->sym_prefs) {      switch (*k->ext->sym_prefs) {
169      case 1: return "IDEA";      case 1: return "IDEA";
170      case 2: return "3DES";      case 2: return "3DES";
171      case 3: return "CAST5";      case 3: return "CAST5";
172      case 4: return "Blowfish";      case 4: return "Blowfish";
173      case 7:      case 7: return "AES128";
174      case 8:      case 8: return "AES192";
175      case 9: return "AES";      case 9: return "AES256";
176      case 10:return "Twofish";      case 10:return "Twofish";
177        default:break;
178      }      }
179      return "Unknown";      return "Unknown";
180  }  }
# Line 177  static bool Line 185  static bool
185  check_for_desig_rev (gpgme_key_t key)  check_for_desig_rev (gpgme_key_t key)
186  {  {
187      winpt_key_s k;      winpt_key_s k;
188    
189      memset (&k, 0, sizeof (k));      memset (&k, 0, sizeof (k));
190      if (!winpt_get_pubkey (key->subkeys->keyid, &k))      if (!winpt_get_pubkey (key->subkeys->keyid, &k))
191          return k.ext->gloflags.has_desig_rev? true : false;          return k.ext->gloflags.has_desig_rev? true : false;
# Line 190  get_card_type (winpt_key_t k) Line 199  get_card_type (winpt_key_t k)
199  {      {    
200      static char buf[64];      static char buf[64];
201    
202      if (!k->ext->card_type)      if (!k->ext || !k->ext->card_type)
203          return "";          return "";
204      _snprintf (buf, sizeof (buf)-1, _("Card-Type: %s\r\n"), k->ext->card_type);      _snprintf (buf, DIM (buf)-1, _("Card-Type: %s\r\n"), k->ext->card_type);
205      return buf;      return buf;
206  }  }
207    
208    
209    /* Return 1 if at least one user-ID is valid. */
210    static int
211    key_is_valid (gpgme_key_t key)
212    {
213        gpgme_user_id_t u;
214    
215        for (u=key->uids; u; u=u->next) {
216            if (u->validity >= GPGME_VALIDITY_MARGINAL)
217                return 1;
218        }
219        return 0;
220    }
221    
222    
223    /* Return extended algorithm information. */
224    const char*
225    props_get_key_algo (gpgme_key_t key, int idx)
226    {
227        /* PGP calls the old RSAv3 keys 'RSA Legacy' and because this
228           is a good method to differ between OpenPGP v4 cert-only keys
229           and v3 RSA keys, we use the same notation. */
230        if (key->subkeys != NULL && strlen (key->subkeys->fpr) == 32)
231            return "RSA Legacy";
232        return get_key_algo (key, idx);
233    }
234    
235    
236  /* Display the key information for key @k.  /* Display the key information for key @k.
237     Return value: gpgme key on success. */     Return value: gpgme key on success. */
238  static void  static void
239  display_key_info (HWND dlg, winpt_key_t k, gpgme_key_t *r_key)  display_key_info (HWND dlg, winpt_key_t k)
240  {  {
241      struct winpt_key_s k2;      gpgme_key_t key;
242      gpgme_key_t sk, key;      struct winpt_key_s sk;
243      char info[512];      char info[512];
244      const char *inf;      const char *inf;
245      u32 created, expires;          DWORD created, expires;
246    
247      memset (&k2, 0, sizeof (k2));            gpg_keycache_update_attr (k->ext, KC_ATTR_PREFSYM, 0);
248      if (k->key_pair)      memset (&sk, 0, sizeof (sk));
249          winpt_get_seckey (k->keyid, &k2);      if (k->key_pair && !winpt_get_seckey (k->keyid, &sk))
250      else              k->is_protected = sk.is_protected;
251          winpt_get_pubkey (k->keyid, &k2);      key = k->ext->key;
252      sk = k2.ctx;              created = key->subkeys->timestamp;
253      if (sk)      expires = key->subkeys->expires;
         k->is_protected = k2.is_protected;  
     if (get_pubkey (k->keyid, &key))  
         BUG (0);      
     created = key->subkeys->timestamp;    
     expires = key->subkeys->expires;      
254      _snprintf (info, DIM (info)-1,      _snprintf (info, DIM (info)-1,
255                 _("Type: %s\r\n"                 _("Type: %s\r\n"
256                 "Key ID: %s\r\n"                 "Key ID: 0x%s\r\n"
257                 "Algorithm: %s\r\n"                 "Algorithm: %s\r\n"
258                 "Size: %s\r\n"                 "Size: %s bits\r\n"
259                 "Created: %s\r\n"                 "Created: %s\r\n"
260                 "Expires: %s\r\n"                 "Expires: %s\r\n"
261                 "Validity: %s\r\n"                 "Validity: %s\r\n"
# Line 232  display_key_info (HWND dlg, winpt_key_t Line 263  display_key_info (HWND dlg, winpt_key_t
263                 "%s\r\n"),                 "%s\r\n"),
264                 get_key_type (key),                 get_key_type (key),
265                 k->keyid,                 k->keyid,
266                 get_key_algo (key, 0),                 props_get_key_algo (key, 0),
267                 get_key_size (key, 0),                 get_key_size (key, 0),
268                 get_key_created (created),                 get_key_created (created),
269                 get_key_expire_date (expires),                 get_key_expire_date (expires),
270                 get_validity (key),                 get_validity (key),
271                 get_pref_cipher (&k2),                 get_pref_cipher (k),
272                 get_card_type (&k2));                 get_card_type (&sk));
273    
274      SetDlgItemText (dlg, IDC_KEYPROPS_INFO, info);      SetDlgItemText (dlg, IDC_KEYPROPS_INFO, info);
275      SetDlgItemText (dlg, IDC_KEYPROPS_FPR, get_key_fpr (key));        SetDlgItemText (dlg, IDC_KEYPROPS_FPR, get_key_fpr (key));  
276      inf = ownertrust_to_string (key->owner_trust);      inf = ownertrust_to_string (key->owner_trust, k->key_pair);
277      SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);      SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
278    }
279    
280    
281    /* Context to store associated data of the dialog. */
282    struct prop_info_s {
283        winpt_key_t key;
284    };
285    
286    
287    static void
288    on_init_dialog (HWND dlg, WPARAM wparam, LPARAM lparam)
289    {
290        gpgme_validity_t valid;
291    
292      *r_key = key;      winpt_key_t k = (winpt_key_t)lparam;
293        assert (k != NULL);
294        SetWindowText (dlg, _("Key Properties"));
295        SetDlgItemText (dlg, IDC_KEYPROPS_OT_CHANGE, _("&Change"));
296        SetDlgItemText (dlg, IDC_KEYPROPS_REVOKERS, _("&Revokers"));
297        SetDlgItemText (dlg, IDC_KEYPROPS_CHANGE_PWD, _("Change &Password"));
298        SetDlgItemText (dlg, IDC_KEYPROPS_OTINF, _("Ownertrust"));  
299        
300        display_key_info (dlg, k);
301        if (!key_load_photo (dlg, k->ctx, &valid)) {
302            k->has_photo = 1;
303            if (valid < GPGME_VALIDITY_MARGINAL)
304                SetDlgItemText (dlg, IDC_KEYPROPS_IMGINF, _("Photo-ID not validated."));
305        }
306        if (k->key_pair)
307            EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_CHANGE_PWD), TRUE);
308        if (check_for_desig_rev (k->ctx))
309            EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_REVOKERS), TRUE);
310        if (do_check_key (k->ctx))
311            EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_OT_CHANGE), FALSE);
312        center_window (dlg, NULL);  
313        SetForegroundWindow (dlg);
314  }  }
315    
316    
# Line 253  display_key_info (HWND dlg, winpt_key_t Line 318  display_key_info (HWND dlg, winpt_key_t
318  BOOL CALLBACK  BOOL CALLBACK
319  keyprops_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  keyprops_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
320  {  {
321      static winpt_key_t k;      struct prop_info_s *prop = NULL;
     static gpgme_key_t key;  
     gpgme_validity_t valid;  
     refresh_cache_s rcs = {0};  
322      const char *inf;      const char *inf;
     int cancel = 0;  
323      int rc;      int rc;
324            
325      /* XXX: static variable (k) prevent that the dialog can      if (msg != WM_INITDIALOG &&
326              be opened twice. */          (prop = (prop_info_s*)GetWindowLong (dlg, GWL_USERDATA)) == NULL)
327            return FALSE;
328    
329      switch (msg) {      switch (msg) {
330      case WM_INITDIALOG:      case WM_INITDIALOG:
331          if (!lparam)          assert (lparam != 0);
332              dlg_fatal_error (dlg, "Could not get dialog param!");          prop = new struct prop_info_s;
333          k = (winpt_key_t)lparam;          prop->key = (winpt_key_t)lparam;
334          #ifndef LANG_DE          SetWindowLong (dlg, GWL_USERDATA, (LONG)prop);
335          SetWindowText (dlg, _("Key Properties"));          on_init_dialog (dlg, wparam, lparam);
         SetDlgItemText (dlg, IDC_KEYPROPS_OT_CHANGE, _("&Change"));  
         SetDlgItemText (dlg, IDC_KEYPROPS_REVOKERS, _("&Revokers"));  
         SetDlgItemText (dlg, IDC_KEYPROPS_CHANGE_PWD, _("Change &Passwd"));  
         SetDlgItemText (dlg, IDC_KEYPROPS_OTINF, _("Ownertrust"));  
         #endif    
   
         display_key_info (dlg, k, &key);  
         if (!keyprops_load_photo (dlg, key, &valid)) {  
             k->has_photo = 1;    
             if (valid < GPGME_VALIDITY_MARGINAL)  
                 SetDlgItemText (dlg, IDC_KEYPROPS_IMGINF, _("Photo-ID not validated."));  
         }  
         if (k->key_pair)  
             EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_CHANGE_PWD), TRUE);  
         if (check_for_desig_rev (key))  
             EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_REVOKERS), TRUE);  
         center_window (dlg, NULL);  
         SetForegroundWindow (dlg);        
336          return TRUE;          return TRUE;
337    
338      case WM_DESTROY:      case WM_DESTROY:
339          unlink (get_photo_tmpname (dlg));          key_unload_photo (dlg);
340            delete prop;prop = NULL;
341            SetWindowLong (dlg, GWL_USERDATA, 0);
342          break;          break;
343                
344      case WM_PAINT:      case WM_PAINT:
345          if (k->has_photo)          /* Display the photo in the frame of the dialog @dlg.
346              keyprops_show_photo (dlg);             The coordinates are fixed to (0,0). */
347            if (prop->key->has_photo) {
348                POINT p;
349                p.x = p.y = 0;
350                PTD_jpg_show (GetDlgItem (dlg, IDC_KEYPROPS_IMG),
351                              &p, get_photo_tmpname (dlg));
352            }
353          break;          break;
354    
     case WM_SYSCOMMAND:  
         if (LOWORD (wparam) == SC_CLOSE)  
             EndDialog (dlg, TRUE);  
         return FALSE;  
           
355      case WM_COMMAND:      case WM_COMMAND:
356          switch (LOWORD (wparam)) {          switch (LOWORD (wparam)) {
357          case IDOK:          case IDOK:
358              EndDialog (dlg, TRUE);              EndDialog (dlg, TRUE);
359              return TRUE;              return TRUE;
360    
361            case IDCANCEL:
362                EndDialog (dlg, FALSE);
363                return TRUE;
364                            
365          case IDC_KEYPROPS_OT_CHANGE:          case IDC_KEYPROPS_OT_CHANGE:
366              if (do_check_key (key)) {              if (!prop->key->key_pair && !key_is_valid (prop->key->ctx)) {
367                  msg_box (dlg, _("The status of this key is 'revoked' or 'expired'.\n"                  rc = msg_box (dlg, _("This is a non-valid key.\n"
                                 "You cannot change the ownertrust of such keys."),  
                                 _("WinPT Warning"), MB_ERR);  
                 return TRUE;  
             }  
             if( !k->key_pair && key->uids->validity < 3 ) {  
                 rc = msg_box( dlg, _("This is a non-valid key.\n"  
368                                       "Modifying the ownertrust has no effect on such keys.\n\n"                                       "Modifying the ownertrust has no effect on such keys.\n\n"
369                                       "Do you really want to continue?"),                                       "Do you really want to continue?"),
370                                       _("WinPT Warning"), MB_ICONWARNING|MB_YESNO );                                       _("WinPT Warning"), MB_ICONWARNING|MB_YESNO);
371                  if (rc == IDNO)                  if (rc == IDNO)
372                      return TRUE;                      return TRUE;
373              }              }
374              //GetDlgItemText (dlg, IDC_KEYPROPS_OT, info, sizeof info -1);              rc = dialog_box_param (glob_hinst,
375              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYEDIT_OWNERTRUST,                                     (LPCSTR)IDD_WINPT_KEYEDIT_OWNERTRUST,
376                                dlg, (DLGPROC)keyedit_ownertrust_dlg_proc,                                      dlg, keyedit_ownertrust_dlg_proc,
377                                (LPARAM)k, _("Change Ownertrust"),                                     (LPARAM)prop->key, _("Change Ownertrust"),
378                                IDS_WINPT_KEYEDIT_OWNERTRUST);                                      IDS_WINPT_KEYEDIT_OWNERTRUST);
379              if (k->callback.new_val == -1) { /* Cancel */              if (rc == FALSE) /* Cancel */
380                  EndDialog (dlg, FALSE);                  return TRUE;
                 break;  
             }  
381    
382              inf = ownertrust_to_string (k->callback.new_val);              inf = ownertrust_to_string (prop->key->callback.new_val,
383                                            prop->key->key_pair);
384              SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);              SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
385              msg_box (dlg, _("Ownertrust successfully changed."),              msg_box (dlg, _("Ownertrust successfully changed."),
386                       _("GnuPG Status"), MB_OK);                       _("GnuPG Status"), MB_OK);
387                            prop->key->update = 1;
             /* XXX: modified ownertrust values can effect the entire  
                     WoT so we reload the cache. But this is very slow. */  
             memset (&rcs, 0, sizeof (rcs));  
             rcs.kr_reload = 1; rcs.kr_update = 1; /* reload only keylist */  
             DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,  
                             keycache_dlg_proc, (LPARAM)&rcs);  
388              return TRUE;              return TRUE;
389                            
390          case IDC_KEYPROPS_CHANGE_PWD:          case IDC_KEYPROPS_CHANGE_PWD:
391              keyedit_change_passwd (k, dlg);                      keyedit_change_passwd (prop->key, dlg);        
392              return TRUE;              return TRUE;
393    
394          case IDC_KEYPROPS_REVOKERS:          case IDC_KEYPROPS_REVOKERS:
395              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYREVOKERS, dlg,              prop->key->update = dialog_box_param (glob_hinst,
396                                key_revokers_dlg_proc, (LPARAM)key,                                            (LPCTSTR)IDD_WINPT_KEYREVOKERS, dlg,
397                                _("Key Revokers"), IDS_WINPT_KEY_REVOKERS);                                            key_revokers_dlg_proc, (LPARAM)prop->key,
398                                              _("Key Revokers"),
399                                              IDS_WINPT_KEY_REVOKERS);
400                UpdateWindow (dlg);
401              break;              break;
402          }          }
403      }      }
Legend:
Removed from v.41  
changed lines
  Added in v.310
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26