/[winpt]/trunk/Include/wptGPG.h
ViewVC logotype

Diff of /trunk/Include/wptGPG.h

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

revision 33 by twoaday, Tue Oct 25 07:46:20 2005 UTC revision 39 by twoaday, Fri Oct 28 06:37:35 2005 UTC
# Line 1  Line 1 
 /* wptGPG.h - GnuPG interface  
  *      Copyright (C) 2000-2005 Timo Schulz  
  *  
  * This file is part of WinPT.  
  *  
  * WinPT is free software; you can redistribute it and/or  
  * modify it under the terms of the GNU General Public License  
  * as published by the Free Software Foundation; either version 2  
  * of the License, or (at your option) any later version.  
  *    
  * WinPT is distributed in the hope that it will be useful,  
  * but WITHOUT ANY WARRANTY; without even the implied warranty of  
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU  
  * 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  
  */  
   
 #ifndef WPT_GPG_H  
 #define WPT_GPG_H  
   
 #include "w32gpgme.h"  
 #include "wptKeyCache.h"  
 #include "wptNLS.h"  
   
   
 #define NO_STRICT 0  
   
 #define key_is_useable(key) (!(key)->revoked && !(key)->expired && !(key)->disabled)  
   
 enum setup_t {  
     SETUP_KEYGEN    = 1,  
     SETUP_IMPORT    = 2,  
     SETUP_EXISTING  = 3  
 };  
   
 enum gpg_cmd_t {  
     GPG_CMD_DECRYPT = 0,  
     GPG_CMD_SIGN    = 1  
 };  
   
 enum keycache_t {  
     KEYCACHE_PRV = 0,  
     KEYCACHE_PUB = 1  
 };  
   
 enum entry_t {  
     ENTRY_OPAQUE = 1,  
     ENTRY_SINGLE = 2,  
     ENTRY_MULTI  = 3,  
     ENTRY_GROUP  = 4,  
 };  
   
 struct gpg_card_s;  
 typedef struct gpg_card_s * gpg_card_t;  
   
 /* GPG file association context. */  
 struct gpg_filetype {      
     const char *descr;  
     const char *ext;  
     int nicon;  
 };  
   
 /* Keycache refresh context. */  
 struct refresh_cache_s {  
     int kr_reload;  
     int kr_update;  
     int tr_update;  
 };  
   
 struct gpg_option_s {  
     struct gpg_option_s * next;  
     char * name;  
     char * val;  
     unsigned int used:1;  
     int type;    
 };  
 typedef struct gpg_option_s * gpg_option_t;  
   
 struct gpg_member_s {  
     struct gpg_member_s * next;  
     char * name;  
     unsigned int used:1;    
 };  
 typedef struct gpg_member_s * gpg_member_t;  
   
 struct gpg_group_s {  
     struct gpg_group_s * next;  
     struct gpg_member_s * list;  
     char * name;  
     unsigned int used:1;    
 };  
 typedef struct gpg_group_s * gpg_group_t;  
   
 struct gpg_optfile_s {  
     struct gpg_option_s * list;  
     struct gpg_group_s * grp;  
 };  
 typedef struct gpg_optfile_s * gpg_optfile_t;  
   
 static gpg_filetype gpg_filetypes[] = {  
     {"GPG Detached Signature", ".sig", 1},  
     {"GPG Encrypted Data",     ".gpg", 2},  
     {"GPG Armored Data",       ".asc", 2},  
     {0}  
 };  
   
 struct passphrase_cb_s {  
     int gpg_cmd;        /* sign or decrypt. */  
     int pwd_init;       /* 1 = passphrase request via dialog. */  
     char *pwd;          /* actual passphrase. */  
     char info[1024];    /* hold up the info message */  
     char *title;        /* dialog title. */  
     char keyid[16+1];   /* keyid of the secret key the pwd can be used for. */  
     HWND hwnd;          /* handle of the dialog window. */  
     int cancel;         /* 1 = user cancelled passphrase request. */  
     unsigned int is_card:1; /* 1 = key stored on a smart card. */  
     unsigned int bad_pwd:1; /* 1 = last passphrase was bad. */  
     gpgme_ctx_t gpg;  
     gpgme_recipient_t recipients;  
     struct {  
         int sym_algo;  
         int s2k_mode;  
         int s2k_hash;  
     } sym;  
 };  
   
   
 static const char * gpg_sigstat[] = {  
     _("Error during verification process."),  
     _("The signature is good."),  
     _("The signature is BAD!"),  
     _("The signature could not be checked due to a missing key."),  
     _("No valid OpenPGP signature."),  
     _("Signature Error"),  
     _("Good Signature (Expired Key)"),  
     _("Good Signature (Revoked Key)"),  
     NULL  
 };  
   
 int sigsum_to_index (gpgme_sigsum_t sum);  
 #define SIGSTAT_MASK 8  
 #define get_gpg_sigstat(sum) gpg_sigstat[sigsum_to_index ((sum)) % SIGSTAT_MASK]  
   
 /* This variable is 1 if IDEA is available. */  
 extern int idea_available;  
   
 /*-- wptGPG.cpp --*/  
 char* get_gnupg_default_key( void );  
 int set_gnupg_default_key( const char *key );  
 char* get_gnupg_config (void);  
 char* get_gnupg_keyring_from_options( const char *fname, int pub );  
 int check_gnupg_config (const char *fname, int *secrings, int *pubrings);  
 char* get_gnupg_path( void );  
 int check_gnupg_prog( void );  
 int gnupg_access_files (void);  
 char* get_gnupg_prog( void );  
 char* get_gnupg_keyring (int pub, int strict);  
 char* get_gnupg_cfgfile (void);  
 int set_gnupg_options( const char *buf, size_t buflen );  
   
 int check_gnupg_options (const char *buf);  
 void init_gnupg_table (void);  
 void free_gnupg_table (void);  
 int keyring_check_last_access (void);  
 const char* gnupg_check_file_ext (const char *fname, int *r_type);  
 int gpg_check_permissions (int showmsg);  
 int gnupg_check_homedir (void);  
 int gnupg_access_keyring (int _pub);  
 void gnupg_backup_options ();  
 void gnupg_backup_keyrings (void);  
 void gnupg_display_error (void);  
 int gnupg_copy_keyrings (void);  
 int check_gnupg_engine (int *r_major, int *r_minor, int *r_patch);  
   
 /*-- wptGPGME.cpp --*/  
 const char * get_signature_status( gpgme_sigsum_t sigstat );  
 void keycache_reload( HWND dlg );  
   
 int get_pubkey (const char *keyid, gpgme_key_t *ret_key);  
 int winpt_get_pubkey (const char *keyid, struct winpt_key_s *k);  
 int get_seckey (const char *keyid, gpgme_key_t *ret_skey);  
 int winpt_get_seckey (const char *keyid, struct winpt_key_s *k);  
   
 void keycache_reload( HWND dlg );  
 void keycache_release (int cleanup);  
 gpgme_error_t keycache_update (int is_sec, const char *keyid);  
 gpgme_error_t keycache_init( const char *pubring, const char * secring );  
 void keycache_set_reload( int yes );  
 int keycache_get_reload( void );  
 gpg_keycache_t keycache_get_ctx( int _pub );  
   
 int count_insecure_elgkeys (void);  
   
 int gpg_encrypt_symmetric (void);  
   
   
 /*-- wptGPGParser.cpp --*/  
 /* find */  
 gpg_group_t find_group( gpg_optfile_t opt, const char *str );  
 gpg_option_t find_option( gpg_optfile_t opt, const char *str );  
 gpg_member_t find_member( gpg_optfile_t opt, const char *grp, const char *str );  
 /* delete */  
 int delete_group( gpg_optfile_t opt, const char *str );  
 int delete_member( gpg_optfile_t opt, const char *grp, const char *str );  
 int delete_option( gpg_optfile_t opt, const char *str );  
 /* add */  
 int modify_entry( gpg_optfile_t opt, int type, const char *name, const char *val );  
 int add_entry( gpg_optfile_t opt, int type, const char *name, const char *val );  
 int add_member( gpg_optfile_t opt, const char *grp, const char *str );  
 int add_group( gpg_optfile_t opt, const char *str );  
 /* high-level */  
 int parse_gpg_options( const char *file, gpg_optfile_t *r_opt );  
 int commit_gpg_options( const char *file, gpg_optfile_t opt );  
 void release_gpg_options( gpg_optfile_t opt );  
 /* memory */  
 void release_group( gpg_group_t grp );  
   
 /*-- wptPassphraseCB.cpp --*/  
 enum passdlg_t {  
     PASSDLG_REPEAT = 0,  
     PASSDLG_INIT = 1,    
     PASSDLG_STRICT = 2  
 };  
   
 void set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,  
                             int cmd, HWND hwnd, const char *title);  
 void release_gpg_passphrase_cb (passphrase_cb_s *cb);  
   
 char * request_passphrase (const char *title, int flags, int *ret_cancel);  
 char * request_passphrase2 (const char *title, int flags, int *ret_cancel);  
 const char * passphrase_cb (void *opaque, const char * desc, void *r_hd);  
 char * get_key_userid (const char *keyid);  
 int check_passwd_quality (const char *pass, int strict);  
   
 /*-- wptGPGUtil.cpp --*/  
 gpgme_error_t gpg_rebuild_cache (char **r_inf);  
 gpgme_error_t gpg_get_version (char **r_inf);  
 void          gpg_set_debug_mode (int val);  
 gpgme_error_t gpg_export_seckey (const char *keyid, const char *outfile);  
 gpgme_error_t gpg_manage_ownertrust (char **data, int export);  
   
 char*  generate_revoc_input (int code, const char *cmt, const char *pass);  
 gpgme_error_t gpg_revoke_key (const char *inp_data,  
                               const char *keyid,  
                               char **r_revcert);  
 gpgme_error_t gpg_decode_c_string (const char *src, char **destp, size_t len);  
 gpgme_error_t gpg_import_key_list (const char *fname, char **r_out);  
 gpgme_error_t get_uat_validity (const char *keyid, gpgme_validity_t *r_valid);  
   
 #endif /* WPT_GPG_H */  
1    /* wptGPG.h - GnuPG interface
2     *      Copyright (C) 2000-2005 Timo Schulz
3     *
4     * This file is part of WinPT.
5     *
6     * WinPT is free software; you can redistribute it and/or
7     * modify it under the terms of the GNU General Public License
8     * as published by the Free Software Foundation; either version 2
9     * of the License, or (at your option) any later version.
10     *  
11     * WinPT is distributed in the hope that it will be useful,
12     * but WITHOUT ANY WARRANTY; without even the implied warranty of
13     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14     * General Public License for more details.
15     *
16     * You should have received a copy of the GNU General Public License
17     * along with WinPT; if not, write to the Free Software Foundation,
18     * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19     */
20    
21    #ifndef WPT_GPG_H
22    #define WPT_GPG_H
23    
24    #include "w32gpgme.h"
25    #include "wptKeyCache.h"
26    #include "wptNLS.h"
27    
28    
29    #define NO_STRICT 0
30    
31    #define key_is_useable(key) (!(key)->revoked && !(key)->expired && !(key)->disabled)
32    
33    enum setup_t {
34        SETUP_KEYGEN    = 1,
35        SETUP_IMPORT    = 2,
36        SETUP_EXISTING  = 3
37    };
38    
39    enum gpg_cmd_t {
40        GPG_CMD_DECRYPT = 0,
41        GPG_CMD_SIGN    = 1
42    };
43    
44    enum keycache_t {
45        KEYCACHE_PRV = 0,
46        KEYCACHE_PUB = 1
47    };
48    
49    enum entry_t {
50        ENTRY_OPAQUE = 1,
51        ENTRY_SINGLE = 2,
52        ENTRY_MULTI  = 3,
53        ENTRY_GROUP  = 4,
54    };
55    
56    struct gpg_card_s;
57    typedef struct gpg_card_s * gpg_card_t;
58    
59    /* GPG file association context. */
60    struct gpg_filetype {    
61        const char *descr;
62        const char *ext;
63        int nicon;
64    };
65    
66    /* Keycache refresh context. */
67    struct refresh_cache_s {
68        int kr_reload;
69        int kr_update;
70        int tr_update;
71    };
72    
73    struct gpg_option_s {
74        struct gpg_option_s * next;
75        char * name;
76        char * val;
77        unsigned int used:1;
78        int type;  
79    };
80    typedef struct gpg_option_s * gpg_option_t;
81    
82    struct gpg_member_s {
83        struct gpg_member_s * next;
84        char * name;
85        unsigned int used:1;  
86    };
87    typedef struct gpg_member_s * gpg_member_t;
88    
89    struct gpg_group_s {
90        struct gpg_group_s * next;
91        struct gpg_member_s * list;
92        char * name;
93        unsigned int used:1;  
94    };
95    typedef struct gpg_group_s * gpg_group_t;
96    
97    struct gpg_optfile_s {
98        struct gpg_option_s * list;
99        struct gpg_group_s * grp;
100    };
101    typedef struct gpg_optfile_s * gpg_optfile_t;
102    
103    static gpg_filetype gpg_filetypes[] = {
104        {"GPG Detached Signature", ".sig", 1},
105        {"GPG Encrypted Data",     ".gpg", 2},
106        {"GPG Armored Data",       ".asc", 2},
107        {0}
108    };
109    
110    struct passphrase_cb_s {
111        int gpg_cmd;        /* sign or decrypt. */
112        int pwd_init;       /* 1 = passphrase request via dialog. */
113        char *pwd;          /* actual passphrase. */
114        char info[1024];    /* hold up the info message */
115        char *title;        /* dialog title. */
116        char keyid[16+1];   /* keyid of the secret key the pwd can be used for. */
117        HWND hwnd;          /* handle of the dialog window. */
118        int cancel;         /* 1 = user cancelled passphrase request. */
119        unsigned int is_card:1; /* 1 = key stored on a smart card. */
120        unsigned int bad_pwd:1; /* 1 = last passphrase was bad. */
121        gpgme_ctx_t gpg;
122        gpgme_recipient_t recipients;
123        struct {
124            int sym_algo;
125            int s2k_mode;
126            int s2k_hash;
127        } sym;
128    };
129    
130    
131    static const char * gpg_sigstat[] = {
132        _("Error during verification process."),
133        _("The signature is good."),
134        _("The signature is BAD!"),
135        _("The signature could not be checked due to a missing key."),
136        _("No valid OpenPGP signature."),
137        _("Signature Error"),
138        _("Good Signature (Expired Key)"),
139        _("Good Signature (Revoked Key)"),
140        NULL
141    };
142    
143    int sigsum_to_index (gpgme_sigsum_t sum);
144    #define SIGSTAT_MASK 8
145    #define get_gpg_sigstat(sum) gpg_sigstat[sigsum_to_index ((sum)) % SIGSTAT_MASK]
146    
147    /* This variable is 1 if IDEA is available. */
148    extern int idea_available;
149    
150    /*-- wptGPG.cpp --*/
151    char* get_gnupg_default_key( void );
152    int set_gnupg_default_key( const char *key );
153    char* get_gnupg_config (void);
154    char* get_gnupg_keyring_from_options( const char *fname, int pub );
155    int check_gnupg_config (const char *fname, int *secrings, int *pubrings);
156    char* get_gnupg_path( void );
157    int check_gnupg_prog( void );
158    int gnupg_access_files (void);
159    char* get_gnupg_prog( void );
160    char* get_gnupg_keyring (int pub, int strict);
161    char* get_gnupg_cfgfile (void);
162    int set_gnupg_options( const char *buf, size_t buflen );
163    int gnupg_load_config (void);
164    
165    int check_gnupg_options (const char *buf);
166    void init_gnupg_table (void);
167    void free_gnupg_table (void);
168    int keyring_check_last_access (void);
169    const char* gnupg_check_file_ext (const char *fname, int *r_type);
170    int gpg_check_permissions (int showmsg);
171    int gnupg_check_homedir (void);
172    int gnupg_access_keyring (int _pub);
173    void gnupg_backup_options ();
174    void gnupg_backup_keyrings (void);
175    void gnupg_display_error (void);
176    int gnupg_copy_keyrings (void);
177    int check_gnupg_engine (int *r_major, int *r_minor, int *r_patch);
178    
179    /*-- wptGPGME.cpp --*/
180    const char * get_signature_status( gpgme_sigsum_t sigstat );
181    void keycache_reload( HWND dlg );
182    
183    int get_pubkey (const char *keyid, gpgme_key_t *ret_key);
184    int winpt_get_pubkey (const char *keyid, struct winpt_key_s *k);
185    int get_seckey (const char *keyid, gpgme_key_t *ret_skey);
186    int winpt_get_seckey (const char *keyid, struct winpt_key_s *k);
187    
188    void keycache_reload( HWND dlg );
189    void keycache_release (int cleanup);
190    gpgme_error_t keycache_update (int is_sec, const char *keyid);
191    gpgme_error_t keycache_init( const char *pubring, const char * secring );
192    void keycache_set_reload( int yes );
193    int keycache_get_reload( void );
194    gpg_keycache_t keycache_get_ctx( int _pub );
195    
196    int count_insecure_elgkeys (void);
197    
198    int gpg_encrypt_symmetric (void);
199    
200    
201    /*-- wptGPGParser.cpp --*/
202    /* find */
203    gpg_group_t find_group( gpg_optfile_t opt, const char *str );
204    gpg_option_t find_option( gpg_optfile_t opt, const char *str );
205    gpg_member_t find_member( gpg_optfile_t opt, const char *grp, const char *str );
206    /* delete */
207    int delete_group( gpg_optfile_t opt, const char *str );
208    int delete_member( gpg_optfile_t opt, const char *grp, const char *str );
209    int delete_option( gpg_optfile_t opt, const char *str );
210    /* add */
211    int modify_entry( gpg_optfile_t opt, int type, const char *name, const char *val );
212    int add_entry( gpg_optfile_t opt, int type, const char *name, const char *val );
213    int add_member( gpg_optfile_t opt, const char *grp, const char *str );
214    int add_group( gpg_optfile_t opt, const char *str );
215    /* high-level */
216    int parse_gpg_options( const char *file, gpg_optfile_t *r_opt );
217    int commit_gpg_options( const char *file, gpg_optfile_t opt );
218    void release_gpg_options( gpg_optfile_t opt );
219    /* memory */
220    void release_group( gpg_group_t grp );
221    
222    /*-- wptPassphraseCB.cpp --*/
223    enum passdlg_t {
224        PASSDLG_REPEAT = 0,
225        PASSDLG_INIT = 1,  
226        PASSDLG_STRICT = 2
227    };
228    
229    void set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,
230                                int cmd, HWND hwnd, const char *title);
231    void release_gpg_passphrase_cb (passphrase_cb_s *cb);
232    
233    char * request_passphrase (const char *title, int flags, int *ret_cancel);
234    char * request_passphrase2 (const char *title, int flags, int *ret_cancel);
235    const char * passphrase_cb (void *opaque, const char * desc, void *r_hd);
236    char * get_key_userid (const char *keyid);
237    int check_passwd_quality (const char *pass, int strict);
238    
239    /*-- wptGPGUtil.cpp --*/
240    gpgme_error_t gpg_rebuild_cache (char **r_inf);
241    gpgme_error_t gpg_get_version (char **r_inf);
242    void          gpg_set_debug_mode (int val);
243    gpgme_error_t gpg_export_seckey (const char *keyid, const char *outfile);
244    gpgme_error_t gpg_manage_ownertrust (char **data, int do_export);
245    
246    char*  generate_revoc_input (int code, const char *cmt, const char *pass);
247    gpgme_error_t gpg_revoke_key (const char *inp_data,
248                                  const char *keyid,
249                                  char **r_revcert);
250    gpgme_error_t gpg_decode_c_string (const char *src, char **destp, size_t len);
251    gpgme_error_t gpg_import_key_list (const char *fname, char **r_out);
252    gpgme_error_t get_uat_validity (const char *keyid, gpgme_validity_t *r_valid);
253    
254    #endif /* WPT_GPG_H */
Legend:
Removed from v.33  
changed lines
  Added in v.39
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26