← Back to branch summary

~ubuntu-branches/ubuntu/natty/gnome-keyring/natty

« back to all changes in this revision

Viewing changes to pkcs11/gck/gck-crypto.h

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2010-02-16 19:00:06 UTC
  • mfrom: (1.1.58 upstream)
  • Revision ID: james.westby@ubuntu.com-20100216190006-cqpnic4zxlkmmi0o
Tags: 2.29.90git20100218-0ubuntu1
Updated to a git snapshot version

Show diffs side-by-side

added added

removed removed

Lines of Context:
pkcs11/gck/gck-crypto.h
22
22
#ifndef GCKCRYPTO_H_
23
23
#define GCKCRYPTO_H_
24
24
 
 
25
#include "gck-types.h"
 
26
 
 
27
#include "pkcs11/pkcs11.h"
 
28
 
 
29
#include "egg/egg-padding.h"
 
30
 
25
31
#include <glib.h>
26
32
 
27
33
#include <gcrypt.h>
28
34
 
29
 
#include "pkcs11/pkcs11.h"
30
 
 
31
 
typedef guchar* (*GckCryptoPadding) (guint n_modulus, const guchar* raw, 
32
 
                                     gsize n_raw, gsize *n_padded);
33
 
 
34
 
static const CK_MECHANISM_TYPE GCK_CRYPTO_RSA_MECHANISMS[] = {
35
 
        CKM_RSA_PKCS,
36
 
        CKM_RSA_X_509
37
 
};
38
 
 
39
 
static const CK_MECHANISM_TYPE GCK_CRYPTO_DSA_MECHANISMS[] = {
40
 
        CKM_DSA
41
 
};
42
 
 
43
35
void                     gck_crypto_initialize                         (void);
44
36
 
45
 
CK_RV                    gck_crypto_perform                            (gcry_sexp_t sexp, 
46
 
                                                                        CK_MECHANISM_TYPE mech, 
47
 
                                                                        CK_ATTRIBUTE_TYPE method, 
48
 
                                                                        CK_BYTE_PTR bufone, 
49
 
                                                                        CK_ULONG n_bufone, 
50
 
                                                                        CK_BYTE_PTR buftwo, 
 
37
CK_RV                    gck_crypto_prepare                            (GckSession *session,
 
38
                                                                        CK_MECHANISM_TYPE mech,
 
39
                                                                        GckObject *key);
 
40
 
 
41
CK_RV                    gck_crypto_prepare_xsa                        (GckSession *session,
 
42
                                                                        CK_MECHANISM_TYPE mech,
 
43
                                                                        GckObject *key);
 
44
 
 
45
CK_RV                    gck_crypto_perform                            (GckSession *session,
 
46
                                                                        CK_MECHANISM_TYPE mech,
 
47
                                                                        CK_ATTRIBUTE_TYPE method,
 
48
                                                                        CK_BYTE_PTR bufone,
 
49
                                                                        CK_ULONG n_bufone,
 
50
                                                                        CK_BYTE_PTR buftwo,
51
51
                                                                        CK_ULONG_PTR n_buftwo);
52
52
 
53
 
CK_RV                    gck_crypto_encrypt                            (gcry_sexp_t sexp, 
54
 
                                                                        CK_MECHANISM_TYPE mech, 
55
 
                                                                        CK_BYTE_PTR data, 
56
 
                                                                        CK_ULONG n_data, 
57
 
                                                                        CK_BYTE_PTR encrypted, 
58
 
                                                                        CK_ULONG_PTR n_encrypted);
59
 
 
60
 
CK_RV                    gck_crypto_encrypt_rsa                        (gcry_sexp_t sexp, 
61
 
                                                                        GckCryptoPadding padding, 
62
 
                                                                        CK_BYTE_PTR data, 
63
 
                                                                        CK_ULONG n_data, 
64
 
                                                                        CK_BYTE_PTR encrypted, 
65
 
                                                                        CK_ULONG_PTR n_encrypted);
66
 
 
67
 
 
68
 
CK_RV                    gck_crypto_decrypt                            (gcry_sexp_t sexp, 
69
 
                                                                        CK_MECHANISM_TYPE mech, 
70
 
                                                                        CK_BYTE_PTR encrypted, 
71
 
                                                                        CK_ULONG n_encrypted, 
72
 
                                                                        CK_BYTE_PTR data, 
73
 
                                                                        CK_ULONG_PTR n_data);
74
 
 
75
 
CK_RV                    gck_crypto_decrypt_rsa                        (gcry_sexp_t sexp, 
76
 
                                                                        GckCryptoPadding padding, 
77
 
                                                                        CK_BYTE_PTR encrypted, 
78
 
                                                                        CK_ULONG n_encrypted, 
79
 
                                                                        CK_BYTE_PTR data, 
80
 
                                                                        CK_ULONG_PTR n_data);
81
 
 
82
 
CK_RV                    gck_crypto_sign                               (gcry_sexp_t sexp, 
83
 
                                                                        CK_MECHANISM_TYPE mech, 
84
 
                                                                        CK_BYTE_PTR data, 
85
 
                                                                        CK_ULONG n_data, 
86
 
                                                                        CK_BYTE_PTR signature, 
87
 
                                                                        CK_ULONG_PTR n_signature);
88
 
 
89
 
CK_RV                    gck_crypto_sign_rsa                           (gcry_sexp_t sexp, 
90
 
                                                                        GckCryptoPadding padding, 
91
 
                                                                        CK_BYTE_PTR data, 
92
 
                                                                        CK_ULONG n_data, 
93
 
                                                                        CK_BYTE_PTR signature, 
94
 
                                                                        CK_ULONG_PTR n_signature);
95
 
 
96
 
CK_RV                    gck_crypto_sign_dsa                           (gcry_sexp_t sexp, 
97
 
                                                                        CK_BYTE_PTR data, 
98
 
                                                                        CK_ULONG n_data, 
99
 
                                                                        CK_BYTE_PTR signature, 
100
 
                                                                        CK_ULONG_PTR n_signature);
101
 
 
102
 
CK_RV                    gck_crypto_verify                             (gcry_sexp_t sexp, 
103
 
                                                                        CK_MECHANISM_TYPE mech, 
104
 
                                                                        CK_BYTE_PTR data, 
105
 
                                                                        CK_ULONG n_data, 
106
 
                                                                        CK_BYTE_PTR signature, 
107
 
                                                                        CK_ULONG n_signature);
108
 
 
109
 
CK_RV                    gck_crypto_verify_rsa                         (gcry_sexp_t sexp, 
110
 
                                                                        GckCryptoPadding padding, 
111
 
                                                                        CK_BYTE_PTR data, 
112
 
                                                                        CK_ULONG n_data, 
113
 
                                                                        CK_BYTE_PTR signature, 
114
 
                                                                        CK_ULONG n_signature);
115
 
 
116
 
 
117
 
CK_RV                    gck_crypto_verify_dsa                         (gcry_sexp_t sexp, 
118
 
                                                                        CK_BYTE_PTR data, 
119
 
                                                                        CK_ULONG n_data, 
120
 
                                                                        CK_BYTE_PTR signature, 
121
 
                                                                        CK_ULONG n_signature);
122
 
 
123
 
gboolean                 gck_crypto_sexp_parse_key                     (gcry_sexp_t sexp,
124
 
                                                                        int *algorithm, 
125
 
                                                                        gboolean *is_private, 
126
 
                                                                        gcry_sexp_t *numbers);
127
 
 
128
 
gboolean                 gck_crypto_sexp_key_to_public                 (gcry_sexp_t sexp, 
129
 
                                                                        gcry_sexp_t *pub);
130
 
 
131
 
gboolean                 gck_crypto_sexp_extract_mpi                   (gcry_sexp_t sexp, 
132
 
                                                                        gcry_mpi_t *mpi, 
 
53
CK_RV                    gck_crypto_encrypt                            (GckSession *session,
 
54
                                                                        CK_MECHANISM_TYPE mech,
 
55
                                                                        CK_BYTE_PTR data,
 
56
                                                                        CK_ULONG n_data,
 
57
                                                                        CK_BYTE_PTR encrypted,
 
58
                                                                        CK_ULONG_PTR n_encrypted);
 
59
 
 
60
CK_RV                    gck_crypto_encrypt_xsa                        (gcry_sexp_t sexp,
 
61
                                                                        CK_MECHANISM_TYPE mech,
 
62
                                                                        CK_BYTE_PTR data,
 
63
                                                                        CK_ULONG n_data,
 
64
                                                                        CK_BYTE_PTR encrypted,
 
65
                                                                        CK_ULONG_PTR n_encrypted);
 
66
 
 
67
CK_RV                    gck_crypto_decrypt                            (GckSession *session,
 
68
                                                                        CK_MECHANISM_TYPE mech,
 
69
                                                                        CK_BYTE_PTR encrypted,
 
70
                                                                        CK_ULONG n_encrypted,
 
71
                                                                        CK_BYTE_PTR data,
 
72
                                                                        CK_ULONG_PTR n_data);
 
73
 
 
74
CK_RV                    gck_crypto_decrypt_xsa                        (gcry_sexp_t sexp,
 
75
                                                                        CK_MECHANISM_TYPE mech,
 
76
                                                                        CK_BYTE_PTR encrypted,
 
77
                                                                        CK_ULONG n_encrypted,
 
78
                                                                        CK_BYTE_PTR data,
 
79
                                                                        CK_ULONG_PTR n_data);
 
80
 
 
81
CK_RV                    gck_crypto_sign                               (GckSession *session,
 
82
                                                                        CK_MECHANISM_TYPE mech,
 
83
                                                                        CK_BYTE_PTR data,
 
84
                                                                        CK_ULONG n_data,
 
85
                                                                        CK_BYTE_PTR signature,
 
86
                                                                        CK_ULONG_PTR n_signature);
 
87
 
 
88
CK_RV                    gck_crypto_sign_xsa                           (gcry_sexp_t sexp,
 
89
                                                                        CK_MECHANISM_TYPE mech,
 
90
                                                                        CK_BYTE_PTR data,
 
91
                                                                        CK_ULONG n_data,
 
92
                                                                        CK_BYTE_PTR signature,
 
93
                                                                        CK_ULONG_PTR n_signature);
 
94
 
 
95
CK_RV                    gck_crypto_verify                             (GckSession *session,
 
96
                                                                        CK_MECHANISM_TYPE mech,
 
97
                                                                        CK_BYTE_PTR data,
 
98
                                                                        CK_ULONG n_data,
 
99
                                                                        CK_BYTE_PTR signature,
 
100
                                                                        CK_ULONG n_signature);
 
101
 
 
102
CK_RV                    gck_crypto_verify_xsa                         (gcry_sexp_t sexp,
 
103
                                                                        CK_MECHANISM_TYPE mech,
 
104
                                                                        CK_BYTE_PTR data,
 
105
                                                                        CK_ULONG n_data,
 
106
                                                                        CK_BYTE_PTR signature,
 
107
                                                                        CK_ULONG n_signature);
 
108
 
 
109
CK_RV                    gck_crypto_sexp_to_data                       (gcry_sexp_t sexp,
 
110
                                                                        guint bits,
 
111
                                                                        CK_BYTE_PTR data,
 
112
                                                                        CK_ULONG *n_data,
 
113
                                                                        EggPadding padding,
133
114
                                                                        ...) G_GNUC_NULL_TERMINATED;
134
115
 
135
 
void                     gck_crypto_sexp_dump                          (gcry_sexp_t sexp);
136
 
 
137
 
guchar*                  gck_crypto_rsa_pad_raw                        (guint bits, 
138
 
                                                                        const guchar* raw,
139
 
                                                                        gsize n_raw, 
140
 
                                                                        gsize *n_padded);
141
 
 
142
 
guchar*                  gck_crypto_rsa_pad_one                        (guint bits, 
143
 
                                                                        const guchar* raw, 
144
 
                                                                        gsize n_raw, 
145
 
                                                                        gsize *n_padded);
146
 
 
147
 
guchar*                  gck_crypto_rsa_pad_two                        (guint bits, 
148
 
                                                                        const guchar* raw, 
149
 
                                                                        gsize n_raw, 
150
 
                                                                        gsize *n_padded);
151
 
 
152
 
guchar*                  gck_crypto_rsa_unpad_one                      (guint bits, 
153
 
                                                                        const guchar *padded, 
154
 
                                                                        gsize n_padded, 
155
 
                                                                        gsize *n_raw);
156
 
 
157
 
guchar*                  gck_crypto_rsa_unpad_two                      (guint bits, 
158
 
                                                                        const guchar* padded, 
159
 
                                                                        gsize n_padded, 
160
 
                                                                        gsize *n_raw);
 
116
CK_RV                    gck_crypto_data_to_sexp                       (const gchar *format,
 
117
                                                                        guint nbits,
 
118
                                                                        EggPadding padding,
 
119
                                                                        CK_BYTE_PTR data,
 
120
                                                                        CK_ULONG n_data,
 
121
                                                                        gcry_sexp_t *sexp);
 
122
 
 
123
CK_RV                    gck_crypto_generate_key_pair                  (GckSession *session,
 
124
                                                                        CK_MECHANISM_TYPE mech,
 
125
                                                                        CK_ATTRIBUTE_PTR pub_atts,
 
126
                                                                        CK_ULONG n_pub_atts,
 
127
                                                                        CK_ATTRIBUTE_PTR priv_atts,
 
128
                                                                        CK_ULONG n_priv_atts,
 
129
                                                                        GckObject **pub_key,
 
130
                                                                        GckObject **priv_key);
 
131
 
 
132
CK_RV                    gck_crypto_derive_key                         (GckSession *session,
 
133
                                                                        CK_MECHANISM_PTR mech,
 
134
                                                                        GckObject *base,
 
135
                                                                        CK_ATTRIBUTE_PTR attrs,
 
136
                                                                        CK_ULONG n_attrs,
 
137
                                                                        GckObject **derived);
 
138
 
 
139
CK_RV                    gck_crypto_wrap_key                           (GckSession *session,
 
140
                                                                        CK_MECHANISM_PTR mech,
 
141
                                                                        GckObject *wrapper,
 
142
                                                                        GckObject *wrapped,
 
143
                                                                        CK_BYTE_PTR output,
 
144
                                                                        CK_ULONG_PTR n_output);
 
145
 
 
146
CK_RV                    gck_crypto_unwrap_key                         (GckSession *session,
 
147
                                                                        CK_MECHANISM_PTR mech,
 
148
                                                                        GckObject *wrapper,
 
149
                                                                        CK_VOID_PTR input,
 
150
                                                                        CK_ULONG n_input,
 
151
                                                                        CK_ATTRIBUTE_PTR attrs,
 
152
                                                                        CK_ULONG n_attrs,
 
153
                                                                        GckObject **unwrapped);
 
154
 
 
155
gulong                   gck_crypto_secret_key_length                  (CK_KEY_TYPE type);
161
156
 
162
157
#endif /* GCKCRYPTO_H_ */