removed gnutls_pubkey_get_verify_algorithm() and unnecessary internal APIs
[gnutls:gnutls.git] / lib / crypto-backend.h
1 /*
2  * Copyright (C) 2011-2012 Free Software Foundation, Inc.
3  *
4  * Author: Nikos Mavrogiannopoulos
5  *
6  * This file is part of GnuTLS.
7  *
8  * The GnuTLS is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public License
10  * as published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
20  *
21  */
22
23 #ifndef GNUTLS_CRYPTO_BACKEND_H
24 #define GNUTLS_CRYPTO_BACKEND_H
25
26 #include <gnutls/crypto.h>
27
28 #define gnutls_crypto_single_cipher_st gnutls_crypto_cipher_st
29 #define gnutls_crypto_single_mac_st gnutls_crypto_mac_st
30 #define gnutls_crypto_single_digest_st gnutls_crypto_digest_st
31
32 typedef struct {
33         int (*init) (gnutls_cipher_algorithm_t, void **ctx, int enc);
34         int (*setkey) (void *ctx, const void *key, size_t keysize);
35         int (*setiv) (void *ctx, const void *iv, size_t ivsize);
36         int (*encrypt) (void *ctx, const void *plain, size_t plainsize,
37                         void *encr, size_t encrsize);
38         int (*decrypt) (void *ctx, const void *encr, size_t encrsize,
39                         void *plain, size_t plainsize);
40         int (*aead_encrypt) (void *ctx,
41                              const void *nonce, size_t noncesize,
42                              const void *auth, size_t authsize,
43                              size_t tag_size,
44                              const void *plain, size_t plainsize,
45                              void *encr, size_t encrsize);
46         int (*aead_decrypt) (void *ctx,
47                              const void *nonce, size_t noncesize,
48                              const void *auth, size_t authsize,
49                              size_t tag_size,
50                              const void *encr, size_t encrsize,
51                              void *plain, size_t plainsize);
52         int (*auth) (void *ctx, const void *data, size_t datasize);
53         void (*tag) (void *ctx, void *tag, size_t tagsize);
54         void (*deinit) (void *ctx);
55
56         /* Not needed for registered on run-time. Only included
57          * should define it. */
58         int (*exists) (gnutls_cipher_algorithm_t);      /* true/false */
59 } gnutls_crypto_cipher_st;
60
61 typedef struct {
62         int (*init) (gnutls_mac_algorithm_t, void **ctx);
63         int (*setkey) (void *ctx, const void *key, size_t keysize);
64         int (*setnonce) (void *ctx, const void *nonce, size_t noncesize);
65         int (*hash) (void *ctx, const void *text, size_t textsize);
66         int (*output) (void *src_ctx, void *digest, size_t digestsize);
67         void (*deinit) (void *ctx);
68         int (*fast) (gnutls_mac_algorithm_t, const void *nonce,
69                      size_t nonce_size, const void *key, size_t keysize,
70                      const void *text, size_t textsize, void *digest);
71
72         /* Not needed for registered on run-time. Only included
73          * should define it. */
74         int (*exists) (gnutls_mac_algorithm_t);
75 } gnutls_crypto_mac_st;
76
77 typedef struct {
78         int (*init) (gnutls_digest_algorithm_t, void **ctx);
79         int (*hash) (void *ctx, const void *src, size_t srcsize);
80         int (*output) (void *src_ctx, void *digest, size_t digestsize);
81         void (*deinit) (void *ctx);
82         int (*fast) (gnutls_digest_algorithm_t, const void *src,
83                      size_t srcsize, void *digest);
84
85         /* Not needed for registered on run-time. Only included
86          * should define it. */
87         int (*exists) (gnutls_digest_algorithm_t);
88 } gnutls_crypto_digest_st;
89
90 typedef struct gnutls_crypto_rnd {
91         int (*init) (void **ctx);
92         int (*check) (void **ctx);
93         int (*rnd) (void *ctx, int level, void *data, size_t datasize);
94         void (*rnd_refresh) (void *ctx);
95         void (*deinit) (void *ctx);
96         int (*self_test) (void);
97 } gnutls_crypto_rnd_st;
98
99 typedef void *bigint_t;
100
101 /**
102  * gnutls_bigint_format_t:
103  * @GNUTLS_MPI_FORMAT_USG: Raw unsigned integer format.
104  * @GNUTLS_MPI_FORMAT_STD: Raw signed integer format, always a leading
105  *   zero when positive.
106  * @GNUTLS_MPI_FORMAT_PGP: The pgp integer format.
107  *
108  * Enumeration of different bignum integer encoding formats.
109  */
110 typedef enum {
111         /* raw unsigned integer format */
112         GNUTLS_MPI_FORMAT_USG = 0,
113         /* raw signed integer format - always a leading zero when positive */
114         GNUTLS_MPI_FORMAT_STD = 1,
115         /* the pgp integer format */
116         GNUTLS_MPI_FORMAT_PGP = 2
117 } gnutls_bigint_format_t;
118
119 /* Multi precision integer arithmetic */
120 typedef struct gnutls_crypto_bigint {
121         int (*bigint_init) (bigint_t*);
122         int (*bigint_init_multi) (bigint_t*, ...);
123         void (*bigint_release) (bigint_t n);
124         void (*bigint_clear) (bigint_t n);      /* zeros the int */
125         /* 0 for equality, > 0 for m1>m2, < 0 for m1<m2 */
126         int (*bigint_cmp) (const bigint_t m1, const bigint_t m2);
127         /* as bigint_cmp */
128         int (*bigint_cmp_ui) (const bigint_t m1, unsigned long m2);
129         /* r = a % b */
130         int (*bigint_modm) (bigint_t r, const bigint_t a, const bigint_t b);
131         /* a = b -> ret == a */
132         int (*bigint_set) (bigint_t a, const bigint_t b);
133         bigint_t (*bigint_copy) (const bigint_t a);
134         /* a = b -> ret == a */
135         int (*bigint_set_ui) (bigint_t a, unsigned long b);
136         unsigned int (*bigint_get_nbits) (const bigint_t a);
137         /* w = b ^ e mod m */
138         int (*bigint_powm) (bigint_t w, const bigint_t b,
139                                  const bigint_t e, const bigint_t m);
140         /* w = a + b mod m */
141         int (*bigint_addm) (bigint_t w, const bigint_t a,
142                                  const bigint_t b, const bigint_t m);
143         /* w = a - b mod m */
144         int (*bigint_subm) (bigint_t w, const bigint_t a,
145                                  const bigint_t b, const bigint_t m);
146         /* w = a * b mod m */
147         int (*bigint_mulm) (bigint_t w, const bigint_t a,
148                                  const bigint_t b, const bigint_t m);
149         /* w = a + b */ int (*bigint_add) (bigint_t w,
150                                                const bigint_t a,
151                                                const bigint_t b);
152         /* w = a - b */ int (*bigint_sub) (bigint_t w,
153                                                const bigint_t a,
154                                                const bigint_t b);
155         /* w = a * b */
156         int (*bigint_mul) (bigint_t w, const bigint_t a,
157                                 const bigint_t b);
158         /* w = a + b */
159         int (*bigint_add_ui) (bigint_t w, const bigint_t a,
160                                    unsigned long b);
161         /* w = a - b */
162         int (*bigint_sub_ui) (bigint_t w, const bigint_t a,
163                                    unsigned long b);
164         /* w = a * b */
165         int (*bigint_mul_ui) (bigint_t w, const bigint_t a,
166                                    unsigned long b);
167         /* q = a / b */
168         int (*bigint_div) (bigint_t q, const bigint_t a,
169                                 const bigint_t b);
170         /* 0 if prime */
171         int (*bigint_prime_check) (const bigint_t pp);
172
173         /* reads a bigint from a buffer */
174         /* stores a bigint into the buffer.  returns
175          * GNUTLS_E_SHORT_MEMORY_BUFFER if buf_size is not sufficient to
176          * store this integer, and updates the buf_size;
177          */
178         int (*bigint_scan) (bigint_t m, const void *buf, size_t buf_size,
179                                  gnutls_bigint_format_t format);
180         int (*bigint_print) (const bigint_t a, void *buf,
181                              size_t * buf_size,
182                              gnutls_bigint_format_t format);
183 } gnutls_crypto_bigint_st;
184
185 #define GNUTLS_MAX_PK_PARAMS 16
186
187 typedef struct {
188         bigint_t params[GNUTLS_MAX_PK_PARAMS];
189         unsigned int params_nr; /* the number of parameters */
190         unsigned int flags;
191         gnutls_pk_algorithm_t algo;
192 } gnutls_pk_params_st;
193
194 /**
195  * gnutls_pk_flag_t:
196  * @GNUTLS_PK_FLAG_NONE: No flag.
197  *
198  * Enumeration of public-key flag.
199  */
200 typedef enum {
201         GNUTLS_PK_FLAG_NONE = 0
202 } gnutls_pk_flag_t;
203
204
205 void gnutls_pk_params_release(gnutls_pk_params_st * p);
206 void gnutls_pk_params_clear(gnutls_pk_params_st * p);
207 void gnutls_pk_params_init(gnutls_pk_params_st * p);
208
209
210 #define MAX_PUBLIC_PARAMS_SIZE 4        /* ok for RSA and DSA */
211
212 /* parameters should not be larger than this limit */
213 #define DSA_PUBLIC_PARAMS 4
214 #define DH_PUBLIC_PARAMS 4
215 #define RSA_PUBLIC_PARAMS 2
216 #define ECC_PUBLIC_PARAMS 2
217
218
219 #define MAX_PRIV_PARAMS_SIZE GNUTLS_MAX_PK_PARAMS       /* ok for RSA and DSA */
220
221 /* parameters should not be larger than this limit */
222 #define DSA_PRIVATE_PARAMS 5
223 #define DH_PRIVATE_PARAMS 5
224 #define RSA_PRIVATE_PARAMS 8
225 #define ECC_PRIVATE_PARAMS 3
226
227 #if MAX_PRIV_PARAMS_SIZE - RSA_PRIVATE_PARAMS < 0
228 #error INCREASE MAX_PRIV_PARAMS
229 #endif
230
231 #if MAX_PRIV_PARAMS_SIZE - ECC_PRIVATE_PARAMS < 0
232 #error INCREASE MAX_PRIV_PARAMS
233 #endif
234
235 #if MAX_PRIV_PARAMS_SIZE - DSA_PRIVATE_PARAMS < 0
236 #error INCREASE MAX_PRIV_PARAMS
237 #endif
238
239
240 /* params are:
241  * RSA:
242  *  [0] is modulus
243  *  [1] is public exponent
244  *  [2] is private exponent (private key only)
245  *  [3] is prime1 (p) (private key only)
246  *  [4] is prime2 (q) (private key only)
247  *  [5] is coefficient (u == inverse of p mod q) (private key only)
248  *  [6] e1 == d mod (p-1)
249  *  [7] e2 == d mod (q-1)
250  *
251  *  note that for libgcrypt that does not use the inverse of q mod p,
252  *  we need to perform conversions using fixup_params().
253  *
254  * DSA:
255  *  [0] is p
256  *  [1] is q
257  *  [2] is g
258  *  [3] is y (public key)
259  *  [4] is x (private key only)
260  *
261  * DH: as DSA
262  *
263  * ECC:
264  *  [0] is prime
265  *  [1] is order
266  *  [2] is A
267  *  [3] is B
268  *  [4] is Gx
269  *  [5] is Gy
270  *  [6] is x
271  *  [7] is y
272  *  [8] is k (private key)
273  */
274
275 #define ECC_X 0
276 #define ECC_Y 1
277 #define ECC_K 2
278
279 #define DSA_P 0
280 #define DSA_Q 1
281 #define DSA_G 2
282 #define DSA_Y 3
283 #define DSA_X 4
284
285 #define DH_P 0
286 #define DH_Q 1
287 #define DH_G 2
288 #define DH_Y 3
289 #define DH_X 4
290
291 #define RSA_MODULUS 0
292 #define RSA_PUB 1
293 #define RSA_PRIV 2
294 #define RSA_PRIME1 3
295 #define RSA_PRIME2 4
296 #define RSA_COEF 5
297 #define RSA_E1 6
298 #define RSA_E2 7
299
300 /**
301  * gnutls_direction_t:
302  * @GNUTLS_IMPORT: Import direction.
303  * @GNUTLS_EXPORT: Export direction.
304  *
305  * Enumeration of different directions.
306  */
307 typedef enum {
308         GNUTLS_IMPORT = 0,
309         GNUTLS_EXPORT = 1
310 } gnutls_direction_t;
311
312 /* Public key algorithms */
313 typedef struct gnutls_crypto_pk {
314         /* The params structure should contain the private or public key
315          * parameters, depending on the operation */
316         int (*encrypt) (gnutls_pk_algorithm_t, gnutls_datum_t * ciphertext,
317                         const gnutls_datum_t * plaintext,
318                         const gnutls_pk_params_st * pub);
319         int (*decrypt) (gnutls_pk_algorithm_t, gnutls_datum_t * plaintext,
320                         const gnutls_datum_t * ciphertext,
321                         const gnutls_pk_params_st * priv);
322
323         int (*sign) (gnutls_pk_algorithm_t, gnutls_datum_t * signature,
324                      const gnutls_datum_t * data,
325                      const gnutls_pk_params_st * priv);
326         int (*verify) (gnutls_pk_algorithm_t, const gnutls_datum_t * data,
327                        const gnutls_datum_t * sig,
328                        const gnutls_pk_params_st * pub);
329         /* sanity checks the public key parameters */
330         int (*verify_priv_params) (gnutls_pk_algorithm_t,
331                               const gnutls_pk_params_st * priv);
332         int (*verify_pub_params) (gnutls_pk_algorithm_t,
333                               const gnutls_pk_params_st * pub);
334         int (*generate_keys) (gnutls_pk_algorithm_t, unsigned int nbits,
335                          gnutls_pk_params_st *);
336         int (*generate_params) (gnutls_pk_algorithm_t, unsigned int nbits,
337                          gnutls_pk_params_st *);
338         /* this function should convert params to ones suitable
339          * for the above functions
340          */
341         int (*pk_fixup_private_params) (gnutls_pk_algorithm_t,
342                                         gnutls_direction_t,
343                                         gnutls_pk_params_st *);
344         int (*derive) (gnutls_pk_algorithm_t, gnutls_datum_t * out,
345                        const gnutls_pk_params_st * priv,
346                        const gnutls_pk_params_st * pub);
347
348         int (*curve_exists) (gnutls_ecc_curve_t);       /* true/false */
349 } gnutls_crypto_pk_st;
350
351 /* priority: infinity for backend algorithms, 90 for kernel
352    algorithms, lowest wins
353  */
354 int gnutls_crypto_single_cipher_register(gnutls_cipher_algorithm_t
355                                          algorithm, int priority,
356                                          const
357                                          gnutls_crypto_single_cipher_st *
358                                          s);
359 int gnutls_crypto_single_mac_register(gnutls_mac_algorithm_t algorithm,
360                                       int priority,
361                                       const gnutls_crypto_single_mac_st *
362                                       s);
363 int gnutls_crypto_single_digest_register(gnutls_digest_algorithm_t
364                                          algorithm, int priority,
365                                          const
366                                          gnutls_crypto_single_digest_st *
367                                          s);
368
369 int gnutls_crypto_cipher_register(int priority,
370                                   const gnutls_crypto_cipher_st * s);
371 int gnutls_crypto_mac_register(int priority,
372                                const gnutls_crypto_mac_st * s);
373 int gnutls_crypto_digest_register(int priority,
374                                   const gnutls_crypto_digest_st * s);
375
376 int gnutls_crypto_rnd_register(int priority,
377                                const gnutls_crypto_rnd_st * s);
378 int gnutls_crypto_pk_register(int priority, const gnutls_crypto_pk_st * s);
379 int gnutls_crypto_bigint_register(int priority,
380                                   const gnutls_crypto_bigint_st * s);
381
382 #endif