/[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 26 by twoaday, Mon Oct 17 08:49:30 2005 UTC revision 128 by twoaday, Mon Dec 19 13:05:59 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 "wptNLS.h"  
   
   
 #define NO_STRICT 0  
   
 #define key_is_useable(key) (!(key)->revoked && !(key)->expired && !(key)->disabled)  
   
 enum {  
     SETUP_KEYGEN    = 1,  
     SETUP_IMPORT    = 2,  
     SETUP_EXISTING  = 3  
 };  
   
 enum {  
     GPG_CMD_DECRYPT = 0,  
     GPG_CMD_SIGN    = 1  
 };  
   
 enum {  
     KEYCACHE_PRV = 0,  
     KEYCACHE_PUB = 1  
 };  
   
 enum {  
     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;  
     int pwd_init;  
     char *pwd;  
     char info[1024]; /* hold up the info message */  
     char *title;  
     char keyid[16+1];  
     HWND hwnd;  
     int cancel;  
     unsigned int is_card:1;  
     unsigned int bad_pwd:1;  
     gpgme_ctx_t gpg;  
     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 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_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);  
   
 #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 <gpgme.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    
104    struct passphrase_cb_s {
105        int gpg_cmd;        /* sign or decrypt. */
106        int pwd_init;       /* 1 = passphrase request via dialog. */
107        char *pwd;          /* actual passphrase. */
108        char info[1024];    /* hold up the info message */
109        char *title;        /* dialog title. */
110        char keyid[16+1];   /* keyid of the secret key the pwd can be used for. */
111        HWND hwnd;          /* handle of the dialog window. */
112        int cancel;         /* 1 = user cancelled passphrase request. */
113        unsigned int is_card:1; /* 1 = key stored on a smart card. */
114        unsigned int bad_pwd:1; /* 1 = last passphrase was bad. */
115        gpgme_ctx_t gpg;
116        gpgme_recipient_t recipients;
117        struct {
118            int sym_algo;
119            int s2k_mode;
120            int s2k_hash;
121        } sym;
122    };
123    
124    
125    /* This variable is 1 if IDEA is available. */
126    extern int idea_available;
127    
128    /*-- wptGPG.cpp --*/
129    char* get_gnupg_default_key( void );
130    int set_gnupg_default_key( const char *key );
131    char* get_gnupg_config (void);
132    char* get_gnupg_keyring_from_options( const char *fname, int pub );
133    int check_gnupg_config (const char *fname, int *secrings, int *pubrings);
134    char* get_gnupg_path( void );
135    int check_gnupg_prog( void );
136    int gnupg_access_files (void);
137    char* get_gnupg_prog( void );
138    char* get_gnupg_keyring (int pub, int strict);
139    char* get_gnupg_cfgfile (void);
140    int set_gnupg_options( const char *buf, size_t buflen );
141    int gnupg_load_config (void);
142    char* multi_gnupg_path (int strict);
143    
144    int check_gnupg_options (const char *buf);
145    void init_gnupg_table (void);
146    void free_gnupg_table (void);
147    int keyring_check_last_access (void);
148    const char* gnupg_check_file_ext (const char *fname, int *r_type);
149    int gpg_check_permissions (int showmsg);
150    int gnupg_check_homedir (void);
151    int gnupg_access_keyring (int _pub);
152    void gnupg_backup_options ();
153    void gnupg_backup_keyrings (void);
154    void gnupg_display_error (void);
155    int gnupg_copy_keyrings (void);
156    int check_gnupg_engine (int *r_major, int *r_minor, int *r_patch);
157    
158    /*-- wptGPGME.cpp --*/
159    const char * get_signature_status( gpgme_sigsum_t sigstat );
160    void keycache_reload( HWND dlg );
161    
162    int get_pubkey (const char *keyid, gpgme_key_t *ret_key);
163    int winpt_get_pubkey (const char *keyid, struct winpt_key_s *k);
164    int get_seckey (const char *keyid, gpgme_key_t *ret_skey);
165    int winpt_get_seckey (const char *keyid, struct winpt_key_s *k);
166    
167    void keycache_reload( HWND dlg );
168    void keycache_release (int cleanup);
169    gpgme_error_t keycache_update (int is_sec, const char *keyid);
170    gpgme_error_t keycache_init( const char *pubring, const char * secring );
171    void keycache_set_reload( int yes );
172    int keycache_get_reload( void );
173    gpg_keycache_t keycache_get_ctx( int _pub );
174    
175    int count_insecure_elgkeys (void);
176    
177    int gpg_encrypt_symmetric (void);
178    const char *get_gpg_sigstat (gpgme_sigsum_t sum);
179    
180    /*-- wptGPGParser.cpp --*/
181    /* find */
182    gpg_group_t find_group( gpg_optfile_t opt, const char *str );
183    gpg_option_t find_option( gpg_optfile_t opt, const char *str );
184    gpg_member_t find_member( gpg_optfile_t opt, const char *grp, const char *str );
185    /* delete */
186    int delete_group( gpg_optfile_t opt, const char *str );
187    int delete_member( gpg_optfile_t opt, const char *grp, const char *str );
188    int delete_option( gpg_optfile_t opt, const char *str );
189    /* add */
190    int modify_entry( gpg_optfile_t opt, int type, const char *name, const char *val );
191    int add_entry( gpg_optfile_t opt, int type, const char *name, const char *val );
192    int add_member( gpg_optfile_t opt, const char *grp, const char *str );
193    int add_group( gpg_optfile_t opt, const char *str );
194    /* high-level */
195    int parse_gpg_options( const char *file, gpg_optfile_t *r_opt );
196    int commit_gpg_options( const char *file, gpg_optfile_t opt );
197    void release_gpg_options( gpg_optfile_t opt );
198    /* memory */
199    void release_group( gpg_group_t grp );
200    
201    /*-- wptPassphraseCB.cpp --*/
202    enum passdlg_t {
203        PASSDLG_REPEAT = 0,
204        PASSDLG_INIT = 1,  
205        PASSDLG_STRICT = 2
206    };
207    
208    void set_gpg_passphrase_cb (passphrase_cb_s *cb, gpgme_ctx_t ctx,
209                                int cmd, HWND hwnd, const char *title);
210    void release_gpg_passphrase_cb (passphrase_cb_s *cb);
211    
212    char * request_passphrase (const char *title, int flags, int *ret_cancel);
213    char * request_passphrase2 (const char *title, int flags, int *ret_cancel);
214    const char * passphrase_cb (void *opaque, const char * desc, void *r_hd);
215    char * get_key_userid (const char *keyid);
216    int check_passwd_quality (const char *pass, int strict);
217    
218    /*-- wptClipboard.cpp --*/
219    gpgme_error_t gpg_clip_istext_avail (int *r_val);
220    gpgme_error_t gpg_clip_is_secured (int *r_type, int *r_val);
221    gpgme_error_t gpg_clip_get_pgptype (int *r_type);
222    gpgme_error_t gpg_clip_parse_pgpid (const char *data, int *r_type);
223    
224    /* wptGPGMEData.cpp --*/
225    gpgme_error_t gpg_data_new_from_clipboard (gpgme_data_t *r_dh, int wraplen);
226    void         gpg_data_release_and_set_clipboard (gpgme_data_t dh, int chg_ver);
227    size_t       gpg_data_readline (gpgme_data_t dh, char *line, size_t nbytes);
228    
229    gpgme_error_t gpg_data_release_and_set_file (gpgme_data_t dh, const char *fname);
230    gpgme_error_t  gpg_data_mail_quote (gpgme_data_t *r_dh);
231    gpgme_error_t  gpg_data_extract_plaintext (gpgme_data_t sig, gpgme_data_t *r_plain);
232    
233    /*-- wptGPGUtil.cpp --*/
234    gpgme_error_t gpg_rebuild_cache (char **r_inf);
235    gpgme_error_t gpg_get_version (char **r_inf);
236    void          gpg_set_debug_mode (int val);
237    gpgme_error_t gpg_export_seckey (const char *keyid, const char *outfile);
238    gpgme_error_t gpg_manage_ownertrust (char **data, int do_export);
239    
240    char*  generate_revoc_input (int code, const char *cmt, const char *pass);
241    gpgme_error_t gpg_revoke_key (const char *inp_data,
242                                  const char *keyid,
243                                  char **r_revcert);
244    gpgme_error_t gpg_decode_c_string (const char *src, char **destp, size_t len);
245    gpgme_error_t gpg_import_key_list (const char *fname, char **r_out);
246    gpgme_error_t get_uat_validity (const char *keyid, gpgme_validity_t *r_valid);
247    
248    #endif /* WPT_GPG_H */
Legend:
Removed from v.26  
changed lines
  Added in v.128
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26