/[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 2 by twoaday, Mon Jan 31 11:02:21 2005 UTC revision 175 by twoaday, Tue Feb 7 08:58:04 2006 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 "wptNLS.h"  
 #include "gpgme.h"  
   
 #define NO_STRICT 0  
   
 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_filetype {      
     const char *descr;  
     const char *ext;  
     int nicon;  
 };  
   
 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;  
     gpgme_recipients_t enc_to;  
     int pwd_init;  
     char pwd[256];  
     char info[1024]; /* hold up the info message */  
     char title[256];  
     const char * keyid;  
     HWND hwnd;  
     int cancel;  
     int is_card;  
 };  
   
 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  
 };  
   
 #define SIGSTAT_MASK 8  
   
 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 (int keep);  
 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);  
   
 gpgme_card_t smartcard_init (void);  
   
 /*-- wptGPGME.cpp --*/  
 const char * get_signature_status( gpgme_sigstat_t sigstat );  
 void keycache_reload( HWND dlg );  
   
 int get_pubkey( const char *keyid, gpgme_key_t *ret_key );  
 int get_seckey( const char *keyid, gpgme_key_t *ret_skey );  
   
 void keycache_reload( HWND dlg );  
 void keycache_release( void );  
 gpgme_error_t keycache_init( const char *pubring, const char * secring );  
 void keycache_set_reload( int yes );  
 int keycache_get_reload( void );  
 gpgme_keycache_t keycache_get_ctx( int _pub );  
   
 int count_insecure_elgkeys( void );  
   
 int gpgme_encrypt_symmetric( void );  
   
 #define gpgme_enable_logging( ctx ) \  
     gpgme_control( (ctx), GPGME_CTRL_LOGGING, 1 )  
   
 #define gpgme_show_error( hwnd, rc, ctx, title, mode )          \  
 do {                                                            \  
     if( (rc) == GPGME_Interal_GPG_Problem && ctx ) {            \  
         char * strerr = gpgme_get_logging( (ctx) );             \  
         msg_box( (hwnd), (strerr)? (strerr) :                   \  
         _("No GPG error description available."), title, mode );\  
         safe_free( strerr );                                    \  
     }                                                           \  
     else {                                                      \  
         msg_box( (hwnd), gpgme_strerror( (rc) ),                \  
                   title, mode );                                \  
     }                                                           \  
 } while ( 0 )  
   
 /*-- 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 --*/  
 void set_gpg_passphrase_cb( gpgme_ctx_t c, passphrase_cb_s * ctx, int cmd,  
                             HWND hwnd, const char * title );  
 char * request_passphrase( const char * title, int init, int * ret_cancel );  
 char * request_passphrase2 (const char * title, int * ret_cancel);  
 const char * passphrase_cb( void * opaque, const char * desc, void * r_hd );  
 char * get_key_userid( const char * keyid );  
   
 #endif /* WPT_GPG_H */  
1    /* wptGPG.h - GnuPG interface
2     *      Copyright (C) 2000-2006 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 (const char *need_gpg_ver,
157                            int *r_major, int *r_minor, int *r_patch);
158    
159    /*-- wptGPGME.cpp --*/
160    const char * get_signature_status( gpgme_sigsum_t sigstat );
161    void keycache_reload( HWND dlg );
162    
163    int get_pubkey (const char *keyid, gpgme_key_t *ret_key);
164    int winpt_get_pubkey (const char *keyid, struct winpt_key_s *k);
165    int get_seckey (const char *keyid, gpgme_key_t *ret_skey);
166    int winpt_get_seckey (const char *keyid, struct winpt_key_s *k);
167    
168    void keycache_reload( HWND dlg );
169    void keycache_release (int cleanup);
170    gpgme_error_t keycache_update (int is_sec, const char *keyid);
171    gpgme_error_t keycache_init (const char *pubring, const char * secring);
172    gpg_keycache_t keycache_get_ctx (int _pub);
173    
174    int count_insecure_elgkeys (void);
175    
176    int gpg_encrypt_symmetric (void);
177    const char *get_gpg_sigstat (gpgme_sigsum_t sum);
178    int check_ultimate_trusted_key (void);
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    void          gpg_data_putc (gpgme_data_t hd, int c);
233    
234    /*-- wptGPGUtil.cpp --*/
235    gpgme_error_t gpg_rebuild_cache (char **r_inf);
236    gpgme_error_t gpg_get_version (char **r_inf);
237    void          gpg_set_debug_mode (int val);
238    gpgme_error_t gpg_export_seckey (const char *keyid, const char *outfile);
239    gpgme_error_t gpg_manage_ownertrust (char **data, int do_export);
240    gpgme_error_t gpg_get_photoid_data (const char *keyid, char **r_status_data,
241                                        unsigned char **r_data,
242                                        unsigned long *ndata);
243    char*  generate_revoke_input (int code, const char *cmt, const char *pass);
244    gpgme_error_t gpg_revoke_cert (const char *inp_data,
245                                   const char *keyid,
246                                   char **r_revcert);
247    gpgme_error_t gpg_decode_c_string (const char *src, char **destp, size_t len);
248    gpgme_error_t gpg_import_key_list (const char *fname, char **r_out);
249    gpgme_error_t gpg_extract_keys (const char *keyfile, const char **keys, DWORD nkeys,
250                                    char **new_keyfile);
251    gpgme_error_t get_uat_validity (const char *keyid, gpgme_validity_t *r_valid);
252    
253    #endif /* WPT_GPG_H */
Legend:
Removed from v.2  
changed lines
  Added in v.175
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26