Copyright consolidation 03/10
[openssl.git] / include / openssl / bn.h
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /* ====================================================================
11  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
12  *
13  * Portions of the attached software ("Contribution") are developed by
14  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
15  *
16  * The Contribution is licensed pursuant to the Eric Young open source
17  * license provided above.
18  *
19  * The binary polynomial arithmetic software is originally written by
20  * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.
21  *
22  */
23
24 #ifndef HEADER_BN_H
25 # define HEADER_BN_H
26
27 # include <openssl/e_os2.h>
28 # ifndef OPENSSL_NO_STDIO
29 #  include <stdio.h>
30 # endif
31 # include <openssl/opensslconf.h>
32 # include <openssl/ossl_typ.h>
33 # include <openssl/crypto.h>
34
35 #ifdef  __cplusplus
36 extern "C" {
37 #endif
38
39 /*
40  * 64-bit processor with LP64 ABI
41  */
42 # ifdef SIXTY_FOUR_BIT_LONG
43 #  define BN_ULONG        unsigned long
44 #  define BN_BYTES        8
45 # endif
46
47 /*
48  * 64-bit processor other than LP64 ABI
49  */
50 # ifdef SIXTY_FOUR_BIT
51 #  define BN_ULONG        unsigned long long
52 #  define BN_BYTES        8
53 # endif
54
55 # ifdef THIRTY_TWO_BIT
56 #  define BN_ULONG        unsigned int
57 #  define BN_BYTES        4
58 # endif
59
60 # define BN_BITS2       (BN_BYTES * 8)
61 # define BN_BITS        (BN_BITS2 * 2)
62 # define BN_TBIT        ((BN_ULONG)1 << (BN_BITS2 - 1))
63
64 # define BN_FLG_MALLOCED         0x01
65 # define BN_FLG_STATIC_DATA      0x02
66
67 /*
68  * avoid leaking exponent information through timing,
69  * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime,
70  * BN_div() will call BN_div_no_branch,
71  * BN_mod_inverse() will call BN_mod_inverse_no_branch.
72  */
73 # define BN_FLG_CONSTTIME        0x04
74 # define BN_FLG_SECURE           0x08
75
76 # if OPENSSL_API_COMPAT < 0x00908000L
77 /* deprecated name for the flag */
78 #  define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME
79 #  define BN_FLG_FREE            0x8000 /* used for debuging */
80 # endif
81
82 void BN_set_flags(BIGNUM *b, int n);
83 int BN_get_flags(const BIGNUM *b, int n);
84
85 /*
86  * get a clone of a BIGNUM with changed flags, for *temporary* use only (the
87  * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The
88  * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that
89  * has not been otherwise initialised or used.
90  */
91 void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags);
92
93 /* Wrapper function to make using BN_GENCB easier,  */
94 int BN_GENCB_call(BN_GENCB *cb, int a, int b);
95
96 BN_GENCB *BN_GENCB_new(void);
97 void BN_GENCB_free(BN_GENCB *cb);
98
99 /* Populate a BN_GENCB structure with an "old"-style callback */
100 void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *),
101                       void *cb_arg);
102
103 /* Populate a BN_GENCB structure with a "new"-style callback */
104 void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *),
105                   void *cb_arg);
106
107 void *BN_GENCB_get_arg(BN_GENCB *cb);
108
109 # define BN_prime_checks 0      /* default: select number of iterations based
110                                  * on the size of the number */
111
112 /*
113  * number of Miller-Rabin iterations for an error rate of less than 2^-80 for
114  * random 'b'-bit input, b >= 100 (taken from table 4.4 in the Handbook of
115  * Applied Cryptography [Menezes, van Oorschot, Vanstone; CRC Press 1996];
116  * original paper: Damgaard, Landrock, Pomerance: Average case error
117  * estimates for the strong probable prime test. -- Math. Comp. 61 (1993)
118  * 177-194)
119  */
120 # define BN_prime_checks_for_size(b) ((b) >= 1300 ?  2 : \
121                                 (b) >=  850 ?  3 : \
122                                 (b) >=  650 ?  4 : \
123                                 (b) >=  550 ?  5 : \
124                                 (b) >=  450 ?  6 : \
125                                 (b) >=  400 ?  7 : \
126                                 (b) >=  350 ?  8 : \
127                                 (b) >=  300 ?  9 : \
128                                 (b) >=  250 ? 12 : \
129                                 (b) >=  200 ? 15 : \
130                                 (b) >=  150 ? 18 : \
131                                 /* b >= 100 */ 27)
132
133 # define BN_num_bytes(a) ((BN_num_bits(a)+7)/8)
134
135 int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w);
136 int BN_is_zero(const BIGNUM *a);
137 int BN_is_one(const BIGNUM *a);
138 int BN_is_word(const BIGNUM *a, const BN_ULONG w);
139 int BN_is_odd(const BIGNUM *a);
140
141 # define BN_one(a)       (BN_set_word((a),1))
142
143 void BN_zero_ex(BIGNUM *a);
144
145 # if OPENSSL_API_COMPAT >= 0x00908000L
146 #  define BN_zero(a)      BN_zero_ex(a)
147 # else
148 #  define BN_zero(a)      (BN_set_word((a),0))
149 # endif
150
151 const BIGNUM *BN_value_one(void);
152 char *BN_options(void);
153 BN_CTX *BN_CTX_new(void);
154 BN_CTX *BN_CTX_secure_new(void);
155 void BN_CTX_free(BN_CTX *c);
156 void BN_CTX_start(BN_CTX *ctx);
157 BIGNUM *BN_CTX_get(BN_CTX *ctx);
158 void BN_CTX_end(BN_CTX *ctx);
159 int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
160 int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
161 int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
162 int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
163 int BN_num_bits(const BIGNUM *a);
164 int BN_num_bits_word(BN_ULONG l);
165 int BN_security_bits(int L, int N);
166 BIGNUM *BN_new(void);
167 BIGNUM *BN_secure_new(void);
168 void BN_clear_free(BIGNUM *a);
169 BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
170 void BN_swap(BIGNUM *a, BIGNUM *b);
171 BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
172 int BN_bn2bin(const BIGNUM *a, unsigned char *to);
173 int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
174 BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
175 int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
176 BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
177 int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
178 int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
179 int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
180 int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
181 int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
182 int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
183 int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
184 /** BN_set_negative sets sign of a BIGNUM
185  * \param  b  pointer to the BIGNUM object
186  * \param  n  0 if the BIGNUM b should be positive and a value != 0 otherwise
187  */
188 void BN_set_negative(BIGNUM *b, int n);
189 /** BN_is_negative returns 1 if the BIGNUM is negative
190  * \param  a  pointer to the BIGNUM object
191  * \return 1 if a < 0 and 0 otherwise
192  */
193 int BN_is_negative(const BIGNUM *b);
194
195 int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
196            BN_CTX *ctx);
197 # define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx))
198 int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
199 int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
200                BN_CTX *ctx);
201 int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
202                      const BIGNUM *m);
203 int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
204                BN_CTX *ctx);
205 int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
206                      const BIGNUM *m);
207 int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
208                BN_CTX *ctx);
209 int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
210 int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
211 int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
212 int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
213                   BN_CTX *ctx);
214 int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);
215
216 BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
217 BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
218 int BN_mul_word(BIGNUM *a, BN_ULONG w);
219 int BN_add_word(BIGNUM *a, BN_ULONG w);
220 int BN_sub_word(BIGNUM *a, BN_ULONG w);
221 int BN_set_word(BIGNUM *a, BN_ULONG w);
222 BN_ULONG BN_get_word(const BIGNUM *a);
223
224 int BN_cmp(const BIGNUM *a, const BIGNUM *b);
225 void BN_free(BIGNUM *a);
226 int BN_is_bit_set(const BIGNUM *a, int n);
227 int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
228 int BN_lshift1(BIGNUM *r, const BIGNUM *a);
229 int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
230
231 int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
232                const BIGNUM *m, BN_CTX *ctx);
233 int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
234                     const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
235 int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
236                               const BIGNUM *m, BN_CTX *ctx,
237                               BN_MONT_CTX *in_mont);
238 int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p,
239                          const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
240 int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
241                      const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
242                      BN_CTX *ctx, BN_MONT_CTX *m_ctx);
243 int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
244                       const BIGNUM *m, BN_CTX *ctx);
245
246 int BN_mask_bits(BIGNUM *a, int n);
247 # ifndef OPENSSL_NO_STDIO
248 int BN_print_fp(FILE *fp, const BIGNUM *a);
249 # endif
250 int BN_print(BIO *bio, const BIGNUM *a);
251 int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
252 int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
253 int BN_rshift1(BIGNUM *r, const BIGNUM *a);
254 void BN_clear(BIGNUM *a);
255 BIGNUM *BN_dup(const BIGNUM *a);
256 int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
257 int BN_set_bit(BIGNUM *a, int n);
258 int BN_clear_bit(BIGNUM *a, int n);
259 char *BN_bn2hex(const BIGNUM *a);
260 char *BN_bn2dec(const BIGNUM *a);
261 int BN_hex2bn(BIGNUM **a, const char *str);
262 int BN_dec2bn(BIGNUM **a, const char *str);
263 int BN_asc2bn(BIGNUM **a, const char *str);
264 int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
265 int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns
266                                                                   * -2 for
267                                                                   * error */
268 BIGNUM *BN_mod_inverse(BIGNUM *ret,
269                        const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
270 BIGNUM *BN_mod_sqrt(BIGNUM *ret,
271                     const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
272
273 void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords);
274
275 /* Deprecated versions */
276 DEPRECATEDIN_0_9_8(BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe,
277                                              const BIGNUM *add,
278                                              const BIGNUM *rem,
279                                              void (*callback) (int, int,
280                                                                void *),
281                                              void *cb_arg))
282 DEPRECATEDIN_0_9_8(int
283                    BN_is_prime(const BIGNUM *p, int nchecks,
284                                void (*callback) (int, int, void *),
285                                BN_CTX *ctx, void *cb_arg))
286 DEPRECATEDIN_0_9_8(int
287                    BN_is_prime_fasttest(const BIGNUM *p, int nchecks,
288                                         void (*callback) (int, int, void *),
289                                         BN_CTX *ctx, void *cb_arg,
290                                         int do_trial_division))
291
292 /* Newer versions */
293 int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add,
294                          const BIGNUM *rem, BN_GENCB *cb);
295 int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb);
296 int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx,
297                             int do_trial_division, BN_GENCB *cb);
298
299 int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);
300
301 int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
302                             const BIGNUM *Xp, const BIGNUM *Xp1,
303                             const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,
304                             BN_GENCB *cb);
305 int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1,
306                               BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e,
307                               BN_CTX *ctx, BN_GENCB *cb);
308
309 BN_MONT_CTX *BN_MONT_CTX_new(void);
310 int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
311                           BN_MONT_CTX *mont, BN_CTX *ctx);
312 int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
313                      BN_CTX *ctx);
314 int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
315                        BN_CTX *ctx);
316 void BN_MONT_CTX_free(BN_MONT_CTX *mont);
317 int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx);
318 BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);
319 BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock,
320                                     const BIGNUM *mod, BN_CTX *ctx);
321
322 /* BN_BLINDING flags */
323 # define BN_BLINDING_NO_UPDATE   0x00000001
324 # define BN_BLINDING_NO_RECREATE 0x00000002
325
326 BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
327 void BN_BLINDING_free(BN_BLINDING *b);
328 int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
329 int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
330 int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
331 int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
332 int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
333                           BN_CTX *);
334
335 int BN_BLINDING_is_current_thread(BN_BLINDING *b);
336 void BN_BLINDING_set_current_thread(BN_BLINDING *b);
337 int BN_BLINDING_lock(BN_BLINDING *b);
338 int BN_BLINDING_unlock(BN_BLINDING *b);
339
340 unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
341 void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
342 BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
343                                       const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
344                                       int (*bn_mod_exp) (BIGNUM *r,
345                                                          const BIGNUM *a,
346                                                          const BIGNUM *p,
347                                                          const BIGNUM *m,
348                                                          BN_CTX *ctx,
349                                                          BN_MONT_CTX *m_ctx),
350                                       BN_MONT_CTX *m_ctx);
351
352 DEPRECATEDIN_0_9_8(void BN_set_params(int mul, int high, int low, int mont))
353 DEPRECATEDIN_0_9_8(int BN_get_params(int which)) /* 0, mul, 1 high, 2 low, 3
354                                                   * mont */
355
356 BN_RECP_CTX *BN_RECP_CTX_new(void);
357 void BN_RECP_CTX_free(BN_RECP_CTX *recp);
358 int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx);
359 int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
360                           BN_RECP_CTX *recp, BN_CTX *ctx);
361 int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
362                     const BIGNUM *m, BN_CTX *ctx);
363 int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
364                 BN_RECP_CTX *recp, BN_CTX *ctx);
365
366 # ifndef OPENSSL_NO_EC2M
367
368 /*
369  * Functions for arithmetic over binary polynomials represented by BIGNUMs.
370  * The BIGNUM::neg property of BIGNUMs representing binary polynomials is
371  * ignored. Note that input arguments are not const so that their bit arrays
372  * can be expanded to the appropriate size if needed.
373  */
374
375 /*
376  * r = a + b
377  */
378 int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
379 #  define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b)
380 /*
381  * r=a mod p
382  */
383 int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p);
384 /* r = (a * b) mod p */
385 int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
386                     const BIGNUM *p, BN_CTX *ctx);
387 /* r = (a * a) mod p */
388 int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
389 /* r = (1 / b) mod p */
390 int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx);
391 /* r = (a / b) mod p */
392 int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
393                     const BIGNUM *p, BN_CTX *ctx);
394 /* r = (a ^ b) mod p */
395 int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
396                     const BIGNUM *p, BN_CTX *ctx);
397 /* r = sqrt(a) mod p */
398 int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
399                      BN_CTX *ctx);
400 /* r^2 + r = a mod p */
401 int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
402                            BN_CTX *ctx);
403 #  define BN_GF2m_cmp(a, b) BN_ucmp((a), (b))
404 /*-
405  * Some functions allow for representation of the irreducible polynomials
406  * as an unsigned int[], say p.  The irreducible f(t) is then of the form:
407  *     t^p[0] + t^p[1] + ... + t^p[k]
408  * where m = p[0] > p[1] > ... > p[k] = 0.
409  */
410 /* r = a mod p */
411 int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]);
412 /* r = (a * b) mod p */
413 int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
414                         const int p[], BN_CTX *ctx);
415 /* r = (a * a) mod p */
416 int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[],
417                         BN_CTX *ctx);
418 /* r = (1 / b) mod p */
419 int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[],
420                         BN_CTX *ctx);
421 /* r = (a / b) mod p */
422 int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
423                         const int p[], BN_CTX *ctx);
424 /* r = (a ^ b) mod p */
425 int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
426                         const int p[], BN_CTX *ctx);
427 /* r = sqrt(a) mod p */
428 int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a,
429                          const int p[], BN_CTX *ctx);
430 /* r^2 + r = a mod p */
431 int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a,
432                                const int p[], BN_CTX *ctx);
433 int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max);
434 int BN_GF2m_arr2poly(const int p[], BIGNUM *a);
435
436 # endif
437
438 /*
439  * faster mod functions for the 'NIST primes' 0 <= a < p^2
440  */
441 int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
442 int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
443 int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
444 int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
445 int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
446
447 const BIGNUM *BN_get0_nist_prime_192(void);
448 const BIGNUM *BN_get0_nist_prime_224(void);
449 const BIGNUM *BN_get0_nist_prime_256(void);
450 const BIGNUM *BN_get0_nist_prime_384(void);
451 const BIGNUM *BN_get0_nist_prime_521(void);
452
453 int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a,
454                                           const BIGNUM *field, BN_CTX *ctx);
455
456 int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
457                           const BIGNUM *priv, const unsigned char *message,
458                           size_t message_len, BN_CTX *ctx);
459
460 /* Primes from RFC 2409 */
461 BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn);
462 BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn);
463
464 /* Primes from RFC 3526 */
465 BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn);
466 BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn);
467 BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn);
468 BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn);
469 BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn);
470 BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn);
471
472 # if OPENSSL_API_COMPAT < 0x00101000L
473 #  define get_rfc2409_prime_768 BN_get_rfc2409_prime_768
474 #  define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024
475 #  define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536
476 #  define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048
477 #  define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072
478 #  define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096
479 #  define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144
480 #  define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192
481 # endif
482
483 int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom);
484
485 /* BEGIN ERROR CODES */
486 /*
487  * The following lines are auto generated by the script mkerr.pl. Any changes
488  * made after this point may be overwritten when the script is next run.
489  */
490 void ERR_load_BN_strings(void);
491
492 /* Error codes for the BN functions. */
493
494 /* Function codes. */
495 # define BN_F_BNRAND                                      127
496 # define BN_F_BN_BLINDING_CONVERT_EX                      100
497 # define BN_F_BN_BLINDING_CREATE_PARAM                    128
498 # define BN_F_BN_BLINDING_INVERT_EX                       101
499 # define BN_F_BN_BLINDING_NEW                             102
500 # define BN_F_BN_BLINDING_UPDATE                          103
501 # define BN_F_BN_BN2DEC                                   104
502 # define BN_F_BN_BN2HEX                                   105
503 # define BN_F_BN_COMPUTE_WNAF                             142
504 # define BN_F_BN_CTX_GET                                  116
505 # define BN_F_BN_CTX_NEW                                  106
506 # define BN_F_BN_CTX_START                                129
507 # define BN_F_BN_DIV                                      107
508 # define BN_F_BN_DIV_NO_BRANCH                            138
509 # define BN_F_BN_DIV_RECP                                 130
510 # define BN_F_BN_EXP                                      123
511 # define BN_F_BN_EXPAND2                                  108
512 # define BN_F_BN_EXPAND_INTERNAL                          120
513 # define BN_F_BN_GENCB_NEW                                143
514 # define BN_F_BN_GENERATE_DSA_NONCE                       140
515 # define BN_F_BN_GENERATE_PRIME_EX                        141
516 # define BN_F_BN_GF2M_MOD                                 131
517 # define BN_F_BN_GF2M_MOD_EXP                             132
518 # define BN_F_BN_GF2M_MOD_MUL                             133
519 # define BN_F_BN_GF2M_MOD_SOLVE_QUAD                      134
520 # define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR                  135
521 # define BN_F_BN_GF2M_MOD_SQR                             136
522 # define BN_F_BN_GF2M_MOD_SQRT                            137
523 # define BN_F_BN_LSHIFT                                   145
524 # define BN_F_BN_MOD_EXP2_MONT                            118
525 # define BN_F_BN_MOD_EXP_MONT                             109
526 # define BN_F_BN_MOD_EXP_MONT_CONSTTIME                   124
527 # define BN_F_BN_MOD_EXP_MONT_WORD                        117
528 # define BN_F_BN_MOD_EXP_RECP                             125
529 # define BN_F_BN_MOD_EXP_SIMPLE                           126
530 # define BN_F_BN_MOD_INVERSE                              110
531 # define BN_F_BN_MOD_INVERSE_NO_BRANCH                    139
532 # define BN_F_BN_MOD_LSHIFT_QUICK                         119
533 # define BN_F_BN_MOD_MUL_RECIPROCAL                       111
534 # define BN_F_BN_MOD_SQRT                                 121
535 # define BN_F_BN_MPI2BN                                   112
536 # define BN_F_BN_NEW                                      113
537 # define BN_F_BN_RAND                                     114
538 # define BN_F_BN_RAND_RANGE                               122
539 # define BN_F_BN_RSHIFT                                   146
540 # define BN_F_BN_SET_WORDS                                144
541 # define BN_F_BN_USUB                                     115
542
543 /* Reason codes. */
544 # define BN_R_ARG2_LT_ARG3                                100
545 # define BN_R_BAD_RECIPROCAL                              101
546 # define BN_R_BIGNUM_TOO_LONG                             114
547 # define BN_R_BITS_TOO_SMALL                              118
548 # define BN_R_CALLED_WITH_EVEN_MODULUS                    102
549 # define BN_R_DIV_BY_ZERO                                 103
550 # define BN_R_ENCODING_ERROR                              104
551 # define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA                105
552 # define BN_R_INPUT_NOT_REDUCED                           110
553 # define BN_R_INVALID_LENGTH                              106
554 # define BN_R_INVALID_RANGE                               115
555 # define BN_R_INVALID_SHIFT                               119
556 # define BN_R_NOT_A_SQUARE                                111
557 # define BN_R_NOT_INITIALIZED                             107
558 # define BN_R_NO_INVERSE                                  108
559 # define BN_R_NO_SOLUTION                                 116
560 # define BN_R_PRIVATE_KEY_TOO_LARGE                       117
561 # define BN_R_P_IS_NOT_PRIME                              112
562 # define BN_R_TOO_MANY_ITERATIONS                         113
563 # define BN_R_TOO_MANY_TEMPORARY_VARIABLES                109
564
565 #ifdef  __cplusplus
566 }
567 #endif
568 #endif