]>
Commit | Line | Data |
---|---|---|
d02b48c6 RE |
1 | /* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) |
2 | * All rights reserved. | |
3 | * | |
4 | * This package is an SSL implementation written | |
5 | * by Eric Young (eay@cryptsoft.com). | |
6 | * The implementation was written so as to conform with Netscapes SSL. | |
0f113f3e | 7 | * |
d02b48c6 RE |
8 | * This library is free for commercial and non-commercial use as long as |
9 | * the following conditions are aheared to. The following conditions | |
10 | * apply to all code found in this distribution, be it the RC4, RSA, | |
11 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | |
12 | * included with this distribution is covered by the same copyright terms | |
13 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | |
0f113f3e | 14 | * |
d02b48c6 RE |
15 | * Copyright remains Eric Young's, and as such any Copyright notices in |
16 | * the code are not to be removed. | |
17 | * If this package is used in a product, Eric Young should be given attribution | |
18 | * as the author of the parts of the library used. | |
19 | * This can be in the form of a textual message at program startup or | |
20 | * in documentation (online or textual) provided with the package. | |
0f113f3e | 21 | * |
d02b48c6 RE |
22 | * Redistribution and use in source and binary forms, with or without |
23 | * modification, are permitted provided that the following conditions | |
24 | * are met: | |
25 | * 1. Redistributions of source code must retain the copyright | |
26 | * notice, this list of conditions and the following disclaimer. | |
27 | * 2. Redistributions in binary form must reproduce the above copyright | |
28 | * notice, this list of conditions and the following disclaimer in the | |
29 | * documentation and/or other materials provided with the distribution. | |
30 | * 3. All advertising materials mentioning features or use of this software | |
31 | * must display the following acknowledgement: | |
32 | * "This product includes cryptographic software written by | |
33 | * Eric Young (eay@cryptsoft.com)" | |
34 | * The word 'cryptographic' can be left out if the rouines from the library | |
35 | * being used are not cryptographic related :-). | |
0f113f3e | 36 | * 4. If you include any Windows specific code (or a derivative thereof) from |
d02b48c6 RE |
37 | * the apps directory (application code) you must include an acknowledgement: |
38 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | |
0f113f3e | 39 | * |
d02b48c6 RE |
40 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
41 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
42 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
43 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | |
44 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
45 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
46 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
48 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
49 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
50 | * SUCH DAMAGE. | |
0f113f3e | 51 | * |
d02b48c6 RE |
52 | * The licence and distribution terms for any publically available version or |
53 | * derivative of this code cannot be changed. i.e. this code cannot simply be | |
54 | * copied and put under another distribution licence | |
55 | * [including the GNU Public Licence.] | |
56 | */ | |
48fc582f BM |
57 | /* ==================================================================== |
58 | * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. | |
59 | * | |
60 | * Redistribution and use in source and binary forms, with or without | |
61 | * modification, are permitted provided that the following conditions | |
62 | * are met: | |
63 | * | |
64 | * 1. Redistributions of source code must retain the above copyright | |
0f113f3e | 65 | * notice, this list of conditions and the following disclaimer. |
48fc582f BM |
66 | * |
67 | * 2. Redistributions in binary form must reproduce the above copyright | |
68 | * notice, this list of conditions and the following disclaimer in | |
69 | * the documentation and/or other materials provided with the | |
70 | * distribution. | |
71 | * | |
72 | * 3. All advertising materials mentioning features or use of this | |
73 | * software must display the following acknowledgment: | |
74 | * "This product includes software developed by the OpenSSL Project | |
75 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | |
76 | * | |
77 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | |
78 | * endorse or promote products derived from this software without | |
79 | * prior written permission. For written permission, please contact | |
80 | * openssl-core@openssl.org. | |
81 | * | |
82 | * 5. Products derived from this software may not be called "OpenSSL" | |
83 | * nor may "OpenSSL" appear in their names without prior written | |
84 | * permission of the OpenSSL Project. | |
85 | * | |
86 | * 6. Redistributions of any form whatsoever must retain the following | |
87 | * acknowledgment: | |
88 | * "This product includes software developed by the OpenSSL Project | |
89 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | |
90 | * | |
91 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | |
92 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
93 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
94 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | |
95 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
96 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
97 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
98 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
99 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
100 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
101 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |
102 | * OF THE POSSIBILITY OF SUCH DAMAGE. | |
103 | * ==================================================================== | |
104 | * | |
105 | * This product includes cryptographic software written by Eric Young | |
106 | * (eay@cryptsoft.com). This product includes software written by Tim | |
107 | * Hudson (tjh@cryptsoft.com). | |
108 | * | |
109 | */ | |
1dc920c8 BM |
110 | /* ==================================================================== |
111 | * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. | |
112 | * | |
0f113f3e | 113 | * Portions of the attached software ("Contribution") are developed by |
1dc920c8 BM |
114 | * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project. |
115 | * | |
116 | * The Contribution is licensed pursuant to the Eric Young open source | |
117 | * license provided above. | |
118 | * | |
0f113f3e | 119 | * The binary polynomial arithmetic software is originally written by |
1dc920c8 BM |
120 | * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories. |
121 | * | |
122 | */ | |
d02b48c6 | 123 | |
d02b48c6 | 124 | #ifndef HEADER_BN_H |
0f113f3e | 125 | # define HEADER_BN_H |
d02b48c6 | 126 | |
0f113f3e MC |
127 | # include <openssl/e_os2.h> |
128 | # ifndef OPENSSL_NO_STDIO | |
3c27208f | 129 | # include <stdio.h> |
0f113f3e | 130 | # endif |
98186eb4 | 131 | # include <openssl/opensslconf.h> |
0f113f3e MC |
132 | # include <openssl/ossl_typ.h> |
133 | # include <openssl/crypto.h> | |
8e10f2b3 | 134 | |
d02b48c6 RE |
135 | #ifdef __cplusplus |
136 | extern "C" { | |
137 | #endif | |
138 | ||
0f113f3e | 139 | /* |
94af0cd7 | 140 | * 64-bit processor with LP64 ABI |
0f113f3e MC |
141 | */ |
142 | # ifdef SIXTY_FOUR_BIT_LONG | |
0f113f3e | 143 | # define BN_ULONG unsigned long |
0f113f3e | 144 | # define BN_BYTES 8 |
0f113f3e | 145 | # endif |
d02b48c6 | 146 | |
0f113f3e | 147 | /* |
94af0cd7 | 148 | * 64-bit processor other than LP64 ABI |
dfeab068 | 149 | */ |
0f113f3e | 150 | # ifdef SIXTY_FOUR_BIT |
0f113f3e | 151 | # define BN_ULONG unsigned long long |
0f113f3e | 152 | # define BN_BYTES 8 |
0f113f3e | 153 | # endif |
d02b48c6 | 154 | |
0f113f3e | 155 | # ifdef THIRTY_TWO_BIT |
0f113f3e | 156 | # define BN_ULONG unsigned int |
0f113f3e | 157 | # define BN_BYTES 4 |
82e8cb40 | 158 | # endif |
d02b48c6 | 159 | |
94af0cd7 RS |
160 | # define BN_BITS2 (BN_BYTES * 8) |
161 | # define BN_BITS (BN_BITS2 * 2) | |
162 | # define BN_TBIT ((BN_ULONG)1 << (BN_BITS2 - 1)) | |
d02b48c6 | 163 | |
0f113f3e MC |
164 | # define BN_FLG_MALLOCED 0x01 |
165 | # define BN_FLG_STATIC_DATA 0x02 | |
dbd87ffc MC |
166 | |
167 | /* | |
168 | * avoid leaking exponent information through timing, | |
169 | * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime, | |
170 | * BN_div() will call BN_div_no_branch, | |
171 | * BN_mod_inverse() will call BN_mod_inverse_no_branch. | |
172 | */ | |
0f113f3e | 173 | # define BN_FLG_CONSTTIME 0x04 |
74924dcb | 174 | # define BN_FLG_SECURE 0x08 |
bd31fb21 | 175 | |
98186eb4 | 176 | # if OPENSSL_API_COMPAT < 0x00908000L |
dbd87ffc | 177 | /* deprecated name for the flag */ |
0f113f3e | 178 | # define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME |
98186eb4 | 179 | # define BN_FLG_FREE 0x8000 /* used for debuging */ |
0f113f3e | 180 | # endif |
85bcf27c MC |
181 | |
182 | void BN_set_flags(BIGNUM *b, int n); | |
183 | int BN_get_flags(const BIGNUM *b, int n); | |
dfeab068 | 184 | |
0f113f3e MC |
185 | /* |
186 | * get a clone of a BIGNUM with changed flags, for *temporary* use only (the | |
e113c9c5 MC |
187 | * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The |
188 | * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that | |
189 | * has not been otherwise initialised or used. | |
0f113f3e | 190 | */ |
e113c9c5 | 191 | void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags); |
85bcf27c | 192 | |
e9224c71 GT |
193 | /* Wrapper function to make using BN_GENCB easier, */ |
194 | int BN_GENCB_call(BN_GENCB *cb, int a, int b); | |
85bcf27c MC |
195 | |
196 | BN_GENCB *BN_GENCB_new(void); | |
197 | void BN_GENCB_free(BN_GENCB *cb); | |
198 | ||
199 | /* Populate a BN_GENCB structure with an "old"-style callback */ | |
0f113f3e MC |
200 | void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *), |
201 | void *cb_arg); | |
85bcf27c MC |
202 | |
203 | /* Populate a BN_GENCB structure with a "new"-style callback */ | |
0f113f3e MC |
204 | void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *), |
205 | void *cb_arg); | |
85bcf27c MC |
206 | |
207 | void *BN_GENCB_get_arg(BN_GENCB *cb); | |
e9224c71 | 208 | |
0f113f3e MC |
209 | # define BN_prime_checks 0 /* default: select number of iterations based |
210 | * on the size of the number */ | |
d02b48c6 | 211 | |
0f113f3e MC |
212 | /* |
213 | * number of Miller-Rabin iterations for an error rate of less than 2^-80 for | |
214 | * random 'b'-bit input, b >= 100 (taken from table 4.4 in the Handbook of | |
215 | * Applied Cryptography [Menezes, van Oorschot, Vanstone; CRC Press 1996]; | |
216 | * original paper: Damgaard, Landrock, Pomerance: Average case error | |
217 | * estimates for the strong probable prime test. -- Math. Comp. 61 (1993) | |
218 | * 177-194) | |
219 | */ | |
220 | # define BN_prime_checks_for_size(b) ((b) >= 1300 ? 2 : \ | |
38e33cef UM |
221 | (b) >= 850 ? 3 : \ |
222 | (b) >= 650 ? 4 : \ | |
223 | (b) >= 550 ? 5 : \ | |
224 | (b) >= 450 ? 6 : \ | |
225 | (b) >= 400 ? 7 : \ | |
226 | (b) >= 350 ? 8 : \ | |
227 | (b) >= 300 ? 9 : \ | |
228 | (b) >= 250 ? 12 : \ | |
229 | (b) >= 200 ? 15 : \ | |
230 | (b) >= 150 ? 18 : \ | |
231 | /* b >= 100 */ 27) | |
232 | ||
0f113f3e | 233 | # define BN_num_bytes(a) ((BN_num_bits(a)+7)/8) |
85bcf27c MC |
234 | |
235 | int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w); | |
236 | int BN_is_zero(const BIGNUM *a); | |
237 | int BN_is_one(const BIGNUM *a); | |
238 | int BN_is_word(const BIGNUM *a, const BN_ULONG w); | |
239 | int BN_is_odd(const BIGNUM *a); | |
240 | ||
0f113f3e | 241 | # define BN_one(a) (BN_set_word((a),1)) |
85bcf27c MC |
242 | |
243 | void BN_zero_ex(BIGNUM *a); | |
244 | ||
98186eb4 | 245 | # if OPENSSL_API_COMPAT >= 0x00908000L |
0f113f3e MC |
246 | # define BN_zero(a) BN_zero_ex(a) |
247 | # else | |
248 | # define BN_zero(a) (BN_set_word((a),0)) | |
249 | # endif | |
d02b48c6 | 250 | |
98499135 | 251 | const BIGNUM *BN_value_one(void); |
0f113f3e | 252 | char *BN_options(void); |
d02b48c6 | 253 | BN_CTX *BN_CTX_new(void); |
74924dcb | 254 | BN_CTX *BN_CTX_secure_new(void); |
0f113f3e MC |
255 | void BN_CTX_free(BN_CTX *c); |
256 | void BN_CTX_start(BN_CTX *ctx); | |
9b141126 | 257 | BIGNUM *BN_CTX_get(BN_CTX *ctx); |
0f113f3e MC |
258 | void BN_CTX_end(BN_CTX *ctx); |
259 | int BN_rand(BIGNUM *rnd, int bits, int top, int bottom); | |
260 | int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom); | |
261 | int BN_rand_range(BIGNUM *rnd, const BIGNUM *range); | |
262 | int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range); | |
263 | int BN_num_bits(const BIGNUM *a); | |
264 | int BN_num_bits_word(BN_ULONG l); | |
265 | int BN_security_bits(int L, int N); | |
d02b48c6 | 266 | BIGNUM *BN_new(void); |
74924dcb | 267 | BIGNUM *BN_secure_new(void); |
0f113f3e | 268 | void BN_clear_free(BIGNUM *a); |
84c15db5 | 269 | BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b); |
0f113f3e MC |
270 | void BN_swap(BIGNUM *a, BIGNUM *b); |
271 | BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret); | |
272 | int BN_bn2bin(const BIGNUM *a, unsigned char *to); | |
85a4807f DSH |
273 | int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen); |
274 | BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret); | |
275 | int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen); | |
0f113f3e MC |
276 | BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret); |
277 | int BN_bn2mpi(const BIGNUM *a, unsigned char *to); | |
278 | int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
279 | int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
280 | int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
281 | int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
282 | int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); | |
283 | int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx); | |
3798cb81 NL |
284 | /** BN_set_negative sets sign of a BIGNUM |
285 | * \param b pointer to the BIGNUM object | |
0f113f3e | 286 | * \param n 0 if the BIGNUM b should be positive and a value != 0 otherwise |
3798cb81 | 287 | */ |
0f113f3e | 288 | void BN_set_negative(BIGNUM *b, int n); |
3798cb81 NL |
289 | /** BN_is_negative returns 1 if the BIGNUM is negative |
290 | * \param a pointer to the BIGNUM object | |
291 | * \return 1 if a < 0 and 0 otherwise | |
292 | */ | |
0f113f3e MC |
293 | int BN_is_negative(const BIGNUM *b); |
294 | ||
295 | int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, | |
296 | BN_CTX *ctx); | |
297 | # define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx)) | |
298 | int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx); | |
299 | int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, | |
300 | BN_CTX *ctx); | |
301 | int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
302 | const BIGNUM *m); | |
303 | int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, | |
304 | BN_CTX *ctx); | |
305 | int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
306 | const BIGNUM *m); | |
307 | int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, | |
308 | BN_CTX *ctx); | |
309 | int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); | |
310 | int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); | |
311 | int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m); | |
312 | int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m, | |
313 | BN_CTX *ctx); | |
314 | int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m); | |
5acaa495 | 315 | |
7999c65c | 316 | BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w); |
dfeab068 | 317 | BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w); |
0f113f3e MC |
318 | int BN_mul_word(BIGNUM *a, BN_ULONG w); |
319 | int BN_add_word(BIGNUM *a, BN_ULONG w); | |
320 | int BN_sub_word(BIGNUM *a, BN_ULONG w); | |
321 | int BN_set_word(BIGNUM *a, BN_ULONG w); | |
020fc820 | 322 | BN_ULONG BN_get_word(const BIGNUM *a); |
5acaa495 | 323 | |
0f113f3e MC |
324 | int BN_cmp(const BIGNUM *a, const BIGNUM *b); |
325 | void BN_free(BIGNUM *a); | |
326 | int BN_is_bit_set(const BIGNUM *a, int n); | |
327 | int BN_lshift(BIGNUM *r, const BIGNUM *a, int n); | |
328 | int BN_lshift1(BIGNUM *r, const BIGNUM *a); | |
329 | int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
330 | ||
331 | int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
332 | const BIGNUM *m, BN_CTX *ctx); | |
333 | int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
334 | const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |
46a64376 | 335 | int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p, |
0f113f3e MC |
336 | const BIGNUM *m, BN_CTX *ctx, |
337 | BN_MONT_CTX *in_mont); | |
338 | int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p, | |
339 | const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |
340 | int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1, | |
341 | const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m, | |
342 | BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |
343 | int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
344 | const BIGNUM *m, BN_CTX *ctx); | |
345 | ||
346 | int BN_mask_bits(BIGNUM *a, int n); | |
347 | # ifndef OPENSSL_NO_STDIO | |
348 | int BN_print_fp(FILE *fp, const BIGNUM *a); | |
349 | # endif | |
94af0cd7 | 350 | int BN_print(BIO *bio, const BIGNUM *a); |
0f113f3e MC |
351 | int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx); |
352 | int BN_rshift(BIGNUM *r, const BIGNUM *a, int n); | |
353 | int BN_rshift1(BIGNUM *r, const BIGNUM *a); | |
354 | void BN_clear(BIGNUM *a); | |
84c15db5 | 355 | BIGNUM *BN_dup(const BIGNUM *a); |
0f113f3e MC |
356 | int BN_ucmp(const BIGNUM *a, const BIGNUM *b); |
357 | int BN_set_bit(BIGNUM *a, int n); | |
358 | int BN_clear_bit(BIGNUM *a, int n); | |
359 | char *BN_bn2hex(const BIGNUM *a); | |
360 | char *BN_bn2dec(const BIGNUM *a); | |
361 | int BN_hex2bn(BIGNUM **a, const char *str); | |
362 | int BN_dec2bn(BIGNUM **a, const char *str); | |
363 | int BN_asc2bn(BIGNUM **a, const char *str); | |
364 | int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); | |
365 | int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns | |
366 | * -2 for | |
367 | * error */ | |
020fc820 | 368 | BIGNUM *BN_mod_inverse(BIGNUM *ret, |
0f113f3e | 369 | const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); |
cd2eebfd | 370 | BIGNUM *BN_mod_sqrt(BIGNUM *ret, |
0f113f3e | 371 | const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); |
e9224c71 | 372 | |
0f113f3e | 373 | void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords); |
f9b6c0ba | 374 | |
e9224c71 | 375 | /* Deprecated versions */ |
98186eb4 | 376 | DEPRECATEDIN_0_9_8(BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe, |
0f113f3e MC |
377 | const BIGNUM *add, |
378 | const BIGNUM *rem, | |
379 | void (*callback) (int, int, | |
380 | void *), | |
98186eb4 VD |
381 | void *cb_arg)) |
382 | DEPRECATEDIN_0_9_8(int | |
0f113f3e MC |
383 | BN_is_prime(const BIGNUM *p, int nchecks, |
384 | void (*callback) (int, int, void *), | |
98186eb4 VD |
385 | BN_CTX *ctx, void *cb_arg)) |
386 | DEPRECATEDIN_0_9_8(int | |
0f113f3e MC |
387 | BN_is_prime_fasttest(const BIGNUM *p, int nchecks, |
388 | void (*callback) (int, int, void *), | |
389 | BN_CTX *ctx, void *cb_arg, | |
98186eb4 | 390 | int do_trial_division)) |
e9224c71 GT |
391 | |
392 | /* Newer versions */ | |
0f113f3e MC |
393 | int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add, |
394 | const BIGNUM *rem, BN_GENCB *cb); | |
395 | int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb); | |
396 | int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, | |
397 | int do_trial_division, BN_GENCB *cb); | |
d02b48c6 | 398 | |
7b1a0451 DSH |
399 | int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx); |
400 | ||
401 | int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | |
0f113f3e MC |
402 | const BIGNUM *Xp, const BIGNUM *Xp1, |
403 | const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx, | |
404 | BN_GENCB *cb); | |
405 | int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1, | |
406 | BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e, | |
407 | BN_CTX *ctx, BN_GENCB *cb); | |
408 | ||
409 | BN_MONT_CTX *BN_MONT_CTX_new(void); | |
410 | int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
411 | BN_MONT_CTX *mont, BN_CTX *ctx); | |
412 | int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, | |
413 | BN_CTX *ctx); | |
414 | int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, | |
415 | BN_CTX *ctx); | |
d02b48c6 | 416 | void BN_MONT_CTX_free(BN_MONT_CTX *mont); |
0f113f3e MC |
417 | int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx); |
418 | BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from); | |
d188a536 | 419 | BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock, |
0f113f3e | 420 | const BIGNUM *mod, BN_CTX *ctx); |
d02b48c6 | 421 | |
800e400d | 422 | /* BN_BLINDING flags */ |
0f113f3e MC |
423 | # define BN_BLINDING_NO_UPDATE 0x00000001 |
424 | # define BN_BLINDING_NO_RECREATE 0x00000002 | |
800e400d NL |
425 | |
426 | BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod); | |
58964a49 | 427 | void BN_BLINDING_free(BN_BLINDING *b); |
0f113f3e | 428 | int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx); |
800e400d | 429 | int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); |
58964a49 | 430 | int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); |
800e400d | 431 | int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *); |
0f113f3e MC |
432 | int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, |
433 | BN_CTX *); | |
0b1a07c8 AG |
434 | |
435 | int BN_BLINDING_is_current_thread(BN_BLINDING *b); | |
436 | void BN_BLINDING_set_current_thread(BN_BLINDING *b); | |
437 | int BN_BLINDING_lock(BN_BLINDING *b); | |
438 | int BN_BLINDING_unlock(BN_BLINDING *b); | |
439 | ||
800e400d NL |
440 | unsigned long BN_BLINDING_get_flags(const BN_BLINDING *); |
441 | void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long); | |
442 | BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b, | |
0f113f3e MC |
443 | const BIGNUM *e, BIGNUM *m, BN_CTX *ctx, |
444 | int (*bn_mod_exp) (BIGNUM *r, | |
445 | const BIGNUM *a, | |
446 | const BIGNUM *p, | |
447 | const BIGNUM *m, | |
448 | BN_CTX *ctx, | |
449 | BN_MONT_CTX *m_ctx), | |
450 | BN_MONT_CTX *m_ctx); | |
451 | ||
98186eb4 VD |
452 | DEPRECATEDIN_0_9_8(void BN_set_params(int mul, int high, int low, int mont)) |
453 | DEPRECATEDIN_0_9_8(int BN_get_params(int which)) /* 0, mul, 1 high, 2 low, 3 | |
454 | * mont */ | |
dfeab068 | 455 | |
dfeab068 | 456 | BN_RECP_CTX *BN_RECP_CTX_new(void); |
0f113f3e MC |
457 | void BN_RECP_CTX_free(BN_RECP_CTX *recp); |
458 | int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx); | |
459 | int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y, | |
460 | BN_RECP_CTX *recp, BN_CTX *ctx); | |
461 | int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
462 | const BIGNUM *m, BN_CTX *ctx); | |
463 | int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, | |
464 | BN_RECP_CTX *recp, BN_CTX *ctx); | |
465 | ||
466 | # ifndef OPENSSL_NO_EC2M | |
467 | ||
468 | /* | |
469 | * Functions for arithmetic over binary polynomials represented by BIGNUMs. | |
b53e44e5 | 470 | * The BIGNUM::neg property of BIGNUMs representing binary polynomials is |
0f113f3e MC |
471 | * ignored. Note that input arguments are not const so that their bit arrays |
472 | * can be expanded to the appropriate size if needed. | |
1dc920c8 | 473 | */ |
b53e44e5 | 474 | |
0f113f3e MC |
475 | /* |
476 | * r = a + b | |
477 | */ | |
478 | int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
479 | # define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b) | |
480 | /* | |
481 | * r=a mod p | |
482 | */ | |
483 | int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p); | |
e636e2ac | 484 | /* r = (a * b) mod p */ |
0f113f3e MC |
485 | int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
486 | const BIGNUM *p, BN_CTX *ctx); | |
e636e2ac | 487 | /* r = (a * a) mod p */ |
0f113f3e | 488 | int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); |
e636e2ac | 489 | /* r = (1 / b) mod p */ |
0f113f3e | 490 | int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx); |
e636e2ac | 491 | /* r = (a / b) mod p */ |
0f113f3e MC |
492 | int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
493 | const BIGNUM *p, BN_CTX *ctx); | |
e636e2ac | 494 | /* r = (a ^ b) mod p */ |
0f113f3e MC |
495 | int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
496 | const BIGNUM *p, BN_CTX *ctx); | |
e636e2ac | 497 | /* r = sqrt(a) mod p */ |
0f113f3e MC |
498 | int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, |
499 | BN_CTX *ctx); | |
e636e2ac | 500 | /* r^2 + r = a mod p */ |
0f113f3e MC |
501 | int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, |
502 | BN_CTX *ctx); | |
503 | # define BN_GF2m_cmp(a, b) BN_ucmp((a), (b)) | |
c80fd6b2 MC |
504 | /*- |
505 | * Some functions allow for representation of the irreducible polynomials | |
1dc920c8 BM |
506 | * as an unsigned int[], say p. The irreducible f(t) is then of the form: |
507 | * t^p[0] + t^p[1] + ... + t^p[k] | |
508 | * where m = p[0] > p[1] > ... > p[k] = 0. | |
509 | */ | |
e636e2ac | 510 | /* r = a mod p */ |
0f113f3e | 511 | int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]); |
e636e2ac | 512 | /* r = (a * b) mod p */ |
0f113f3e MC |
513 | int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
514 | const int p[], BN_CTX *ctx); | |
e636e2ac | 515 | /* r = (a * a) mod p */ |
0f113f3e MC |
516 | int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[], |
517 | BN_CTX *ctx); | |
e636e2ac | 518 | /* r = (1 / b) mod p */ |
0f113f3e MC |
519 | int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[], |
520 | BN_CTX *ctx); | |
e636e2ac | 521 | /* r = (a / b) mod p */ |
0f113f3e MC |
522 | int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
523 | const int p[], BN_CTX *ctx); | |
e636e2ac | 524 | /* r = (a ^ b) mod p */ |
0f113f3e MC |
525 | int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
526 | const int p[], BN_CTX *ctx); | |
e636e2ac | 527 | /* r = sqrt(a) mod p */ |
0f113f3e MC |
528 | int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a, |
529 | const int p[], BN_CTX *ctx); | |
e636e2ac | 530 | /* r^2 + r = a mod p */ |
0f113f3e MC |
531 | int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a, |
532 | const int p[], BN_CTX *ctx); | |
533 | int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max); | |
534 | int BN_GF2m_arr2poly(const int p[], BIGNUM *a); | |
1dc920c8 | 535 | |
0f113f3e | 536 | # endif |
c9a90645 | 537 | |
0f113f3e MC |
538 | /* |
539 | * faster mod functions for the 'NIST primes' 0 <= a < p^2 | |
540 | */ | |
5c6bf031 BM |
541 | int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); |
542 | int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
543 | int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
544 | int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
545 | int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
546 | ||
547 | const BIGNUM *BN_get0_nist_prime_192(void); | |
548 | const BIGNUM *BN_get0_nist_prime_224(void); | |
549 | const BIGNUM *BN_get0_nist_prime_256(void); | |
550 | const BIGNUM *BN_get0_nist_prime_384(void); | |
551 | const BIGNUM *BN_get0_nist_prime_521(void); | |
552 | ||
0f113f3e MC |
553 | int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a, |
554 | const BIGNUM *field, BN_CTX *ctx); | |
8a99cb29 | 555 | |
0f113f3e MC |
556 | int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range, |
557 | const BIGNUM *priv, const unsigned char *message, | |
558 | size_t message_len, BN_CTX *ctx); | |
775c63fc | 559 | |
bf3d6c0c | 560 | /* Primes from RFC 2409 */ |
40a3c123 DSH |
561 | BIGNUM *get_rfc2409_prime_768(BIGNUM *bn); |
562 | BIGNUM *get_rfc2409_prime_1024(BIGNUM *bn); | |
bf3d6c0c BL |
563 | |
564 | /* Primes from RFC 3526 */ | |
40a3c123 DSH |
565 | BIGNUM *get_rfc3526_prime_1536(BIGNUM *bn); |
566 | BIGNUM *get_rfc3526_prime_2048(BIGNUM *bn); | |
567 | BIGNUM *get_rfc3526_prime_3072(BIGNUM *bn); | |
568 | BIGNUM *get_rfc3526_prime_4096(BIGNUM *bn); | |
569 | BIGNUM *get_rfc3526_prime_6144(BIGNUM *bn); | |
570 | BIGNUM *get_rfc3526_prime_8192(BIGNUM *bn); | |
bf3d6c0c | 571 | |
0f113f3e | 572 | int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom); |
85bcf27c | 573 | |
d02b48c6 | 574 | /* BEGIN ERROR CODES */ |
0f113f3e MC |
575 | /* |
576 | * The following lines are auto generated by the script mkerr.pl. Any changes | |
6d311938 DSH |
577 | * made after this point may be overwritten when the script is next run. |
578 | */ | |
b476df64 | 579 | void ERR_load_BN_strings(void); |
6d311938 | 580 | |
d02b48c6 RE |
581 | /* Error codes for the BN functions. */ |
582 | ||
583 | /* Function codes. */ | |
0f113f3e MC |
584 | # define BN_F_BNRAND 127 |
585 | # define BN_F_BN_BLINDING_CONVERT_EX 100 | |
586 | # define BN_F_BN_BLINDING_CREATE_PARAM 128 | |
587 | # define BN_F_BN_BLINDING_INVERT_EX 101 | |
588 | # define BN_F_BN_BLINDING_NEW 102 | |
589 | # define BN_F_BN_BLINDING_UPDATE 103 | |
590 | # define BN_F_BN_BN2DEC 104 | |
591 | # define BN_F_BN_BN2HEX 105 | |
592 | # define BN_F_BN_COMPUTE_WNAF 142 | |
593 | # define BN_F_BN_CTX_GET 116 | |
594 | # define BN_F_BN_CTX_NEW 106 | |
595 | # define BN_F_BN_CTX_START 129 | |
596 | # define BN_F_BN_DIV 107 | |
597 | # define BN_F_BN_DIV_NO_BRANCH 138 | |
598 | # define BN_F_BN_DIV_RECP 130 | |
599 | # define BN_F_BN_EXP 123 | |
600 | # define BN_F_BN_EXPAND2 108 | |
601 | # define BN_F_BN_EXPAND_INTERNAL 120 | |
602 | # define BN_F_BN_GENCB_NEW 143 | |
603 | # define BN_F_BN_GENERATE_DSA_NONCE 140 | |
604 | # define BN_F_BN_GENERATE_PRIME_EX 141 | |
605 | # define BN_F_BN_GF2M_MOD 131 | |
606 | # define BN_F_BN_GF2M_MOD_EXP 132 | |
607 | # define BN_F_BN_GF2M_MOD_MUL 133 | |
608 | # define BN_F_BN_GF2M_MOD_SOLVE_QUAD 134 | |
609 | # define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR 135 | |
610 | # define BN_F_BN_GF2M_MOD_SQR 136 | |
611 | # define BN_F_BN_GF2M_MOD_SQRT 137 | |
7cc18d81 | 612 | # define BN_F_BN_LSHIFT 145 |
0f113f3e MC |
613 | # define BN_F_BN_MOD_EXP2_MONT 118 |
614 | # define BN_F_BN_MOD_EXP_MONT 109 | |
615 | # define BN_F_BN_MOD_EXP_MONT_CONSTTIME 124 | |
616 | # define BN_F_BN_MOD_EXP_MONT_WORD 117 | |
617 | # define BN_F_BN_MOD_EXP_RECP 125 | |
618 | # define BN_F_BN_MOD_EXP_SIMPLE 126 | |
619 | # define BN_F_BN_MOD_INVERSE 110 | |
620 | # define BN_F_BN_MOD_INVERSE_NO_BRANCH 139 | |
621 | # define BN_F_BN_MOD_LSHIFT_QUICK 119 | |
622 | # define BN_F_BN_MOD_MUL_RECIPROCAL 111 | |
623 | # define BN_F_BN_MOD_SQRT 121 | |
624 | # define BN_F_BN_MPI2BN 112 | |
625 | # define BN_F_BN_NEW 113 | |
626 | # define BN_F_BN_RAND 114 | |
627 | # define BN_F_BN_RAND_RANGE 122 | |
7cc18d81 | 628 | # define BN_F_BN_RSHIFT 146 |
e22d2199 | 629 | # define BN_F_BN_SET_WORDS 144 |
0f113f3e | 630 | # define BN_F_BN_USUB 115 |
d02b48c6 RE |
631 | |
632 | /* Reason codes. */ | |
0f113f3e MC |
633 | # define BN_R_ARG2_LT_ARG3 100 |
634 | # define BN_R_BAD_RECIPROCAL 101 | |
635 | # define BN_R_BIGNUM_TOO_LONG 114 | |
636 | # define BN_R_BITS_TOO_SMALL 118 | |
637 | # define BN_R_CALLED_WITH_EVEN_MODULUS 102 | |
638 | # define BN_R_DIV_BY_ZERO 103 | |
639 | # define BN_R_ENCODING_ERROR 104 | |
640 | # define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105 | |
641 | # define BN_R_INPUT_NOT_REDUCED 110 | |
642 | # define BN_R_INVALID_LENGTH 106 | |
643 | # define BN_R_INVALID_RANGE 115 | |
7cc18d81 | 644 | # define BN_R_INVALID_SHIFT 119 |
0f113f3e MC |
645 | # define BN_R_NOT_A_SQUARE 111 |
646 | # define BN_R_NOT_INITIALIZED 107 | |
647 | # define BN_R_NO_INVERSE 108 | |
648 | # define BN_R_NO_SOLUTION 116 | |
649 | # define BN_R_PRIVATE_KEY_TOO_LARGE 117 | |
650 | # define BN_R_P_IS_NOT_PRIME 112 | |
651 | # define BN_R_TOO_MANY_ITERATIONS 113 | |
652 | # define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109 | |
6d311938 | 653 | |
d02b48c6 RE |
654 | #ifdef __cplusplus |
655 | } | |
656 | #endif | |
657 | #endif |