Mercurial > repos > rliterman > csp2
comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/openssl/bn.h @ 69:33d812a61356
planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d
| author | jpayne |
|---|---|
| date | Tue, 18 Mar 2025 17:55:14 -0400 |
| parents | |
| children |
comparison
equal
deleted
inserted
replaced
| 67:0e9998148a16 | 69:33d812a61356 |
|---|---|
| 1 /* | |
| 2 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. | |
| 3 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved | |
| 4 * | |
| 5 * Licensed under the OpenSSL license (the "License"). You may not use | |
| 6 * this file except in compliance with the License. You can obtain a copy | |
| 7 * in the file LICENSE in the source distribution or at | |
| 8 * https://www.openssl.org/source/license.html | |
| 9 */ | |
| 10 | |
| 11 #ifndef HEADER_BN_H | |
| 12 # define HEADER_BN_H | |
| 13 | |
| 14 # include <openssl/e_os2.h> | |
| 15 # ifndef OPENSSL_NO_STDIO | |
| 16 # include <stdio.h> | |
| 17 # endif | |
| 18 # include <openssl/opensslconf.h> | |
| 19 # include <openssl/ossl_typ.h> | |
| 20 # include <openssl/crypto.h> | |
| 21 # include <openssl/bnerr.h> | |
| 22 | |
| 23 #ifdef __cplusplus | |
| 24 extern "C" { | |
| 25 #endif | |
| 26 | |
| 27 /* | |
| 28 * 64-bit processor with LP64 ABI | |
| 29 */ | |
| 30 # ifdef SIXTY_FOUR_BIT_LONG | |
| 31 # define BN_ULONG unsigned long | |
| 32 # define BN_BYTES 8 | |
| 33 # endif | |
| 34 | |
| 35 /* | |
| 36 * 64-bit processor other than LP64 ABI | |
| 37 */ | |
| 38 # ifdef SIXTY_FOUR_BIT | |
| 39 # define BN_ULONG unsigned long long | |
| 40 # define BN_BYTES 8 | |
| 41 # endif | |
| 42 | |
| 43 # ifdef THIRTY_TWO_BIT | |
| 44 # define BN_ULONG unsigned int | |
| 45 # define BN_BYTES 4 | |
| 46 # endif | |
| 47 | |
| 48 # define BN_BITS2 (BN_BYTES * 8) | |
| 49 # define BN_BITS (BN_BITS2 * 2) | |
| 50 # define BN_TBIT ((BN_ULONG)1 << (BN_BITS2 - 1)) | |
| 51 | |
| 52 # define BN_FLG_MALLOCED 0x01 | |
| 53 # define BN_FLG_STATIC_DATA 0x02 | |
| 54 | |
| 55 /* | |
| 56 * avoid leaking exponent information through timing, | |
| 57 * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime, | |
| 58 * BN_div() will call BN_div_no_branch, | |
| 59 * BN_mod_inverse() will call bn_mod_inverse_no_branch. | |
| 60 */ | |
| 61 # define BN_FLG_CONSTTIME 0x04 | |
| 62 # define BN_FLG_SECURE 0x08 | |
| 63 | |
| 64 # if OPENSSL_API_COMPAT < 0x00908000L | |
| 65 /* deprecated name for the flag */ | |
| 66 # define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME | |
| 67 # define BN_FLG_FREE 0x8000 /* used for debugging */ | |
| 68 # endif | |
| 69 | |
| 70 void BN_set_flags(BIGNUM *b, int n); | |
| 71 int BN_get_flags(const BIGNUM *b, int n); | |
| 72 | |
| 73 /* Values for |top| in BN_rand() */ | |
| 74 #define BN_RAND_TOP_ANY -1 | |
| 75 #define BN_RAND_TOP_ONE 0 | |
| 76 #define BN_RAND_TOP_TWO 1 | |
| 77 | |
| 78 /* Values for |bottom| in BN_rand() */ | |
| 79 #define BN_RAND_BOTTOM_ANY 0 | |
| 80 #define BN_RAND_BOTTOM_ODD 1 | |
| 81 | |
| 82 /* | |
| 83 * get a clone of a BIGNUM with changed flags, for *temporary* use only (the | |
| 84 * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The | |
| 85 * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that | |
| 86 * has not been otherwise initialised or used. | |
| 87 */ | |
| 88 void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags); | |
| 89 | |
| 90 /* Wrapper function to make using BN_GENCB easier */ | |
| 91 int BN_GENCB_call(BN_GENCB *cb, int a, int b); | |
| 92 | |
| 93 BN_GENCB *BN_GENCB_new(void); | |
| 94 void BN_GENCB_free(BN_GENCB *cb); | |
| 95 | |
| 96 /* Populate a BN_GENCB structure with an "old"-style callback */ | |
| 97 void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *), | |
| 98 void *cb_arg); | |
| 99 | |
| 100 /* Populate a BN_GENCB structure with a "new"-style callback */ | |
| 101 void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *), | |
| 102 void *cb_arg); | |
| 103 | |
| 104 void *BN_GENCB_get_arg(BN_GENCB *cb); | |
| 105 | |
| 106 # define BN_prime_checks 0 /* default: select number of iterations based | |
| 107 * on the size of the number */ | |
| 108 | |
| 109 /* | |
| 110 * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations | |
| 111 * that will be done for checking that a random number is probably prime. The | |
| 112 * error rate for accepting a composite number as prime depends on the size of | |
| 113 * the prime |b|. The error rates used are for calculating an RSA key with 2 primes, | |
| 114 * and so the level is what you would expect for a key of double the size of the | |
| 115 * prime. | |
| 116 * | |
| 117 * This table is generated using the algorithm of FIPS PUB 186-4 | |
| 118 * Digital Signature Standard (DSS), section F.1, page 117. | |
| 119 * (https://dx.doi.org/10.6028/NIST.FIPS.186-4) | |
| 120 * | |
| 121 * The following magma script was used to generate the output: | |
| 122 * securitybits:=125; | |
| 123 * k:=1024; | |
| 124 * for t:=1 to 65 do | |
| 125 * for M:=3 to Floor(2*Sqrt(k-1)-1) do | |
| 126 * S:=0; | |
| 127 * // Sum over m | |
| 128 * for m:=3 to M do | |
| 129 * s:=0; | |
| 130 * // Sum over j | |
| 131 * for j:=2 to m do | |
| 132 * s+:=(RealField(32)!2)^-(j+(k-1)/j); | |
| 133 * end for; | |
| 134 * S+:=2^(m-(m-1)*t)*s; | |
| 135 * end for; | |
| 136 * A:=2^(k-2-M*t); | |
| 137 * B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S; | |
| 138 * pkt:=2.00743*Log(2)*k*2^-k*(A+B); | |
| 139 * seclevel:=Floor(-Log(2,pkt)); | |
| 140 * if seclevel ge securitybits then | |
| 141 * printf "k: %5o, security: %o bits (t: %o, M: %o)\n",k,seclevel,t,M; | |
| 142 * break; | |
| 143 * end if; | |
| 144 * end for; | |
| 145 * if seclevel ge securitybits then break; end if; | |
| 146 * end for; | |
| 147 * | |
| 148 * It can be run online at: | |
| 149 * http://magma.maths.usyd.edu.au/calc | |
| 150 * | |
| 151 * And will output: | |
| 152 * k: 1024, security: 129 bits (t: 6, M: 23) | |
| 153 * | |
| 154 * k is the number of bits of the prime, securitybits is the level we want to | |
| 155 * reach. | |
| 156 * | |
| 157 * prime length | RSA key size | # MR tests | security level | |
| 158 * -------------+--------------|------------+--------------- | |
| 159 * (b) >= 6394 | >= 12788 | 3 | 256 bit | |
| 160 * (b) >= 3747 | >= 7494 | 3 | 192 bit | |
| 161 * (b) >= 1345 | >= 2690 | 4 | 128 bit | |
| 162 * (b) >= 1080 | >= 2160 | 5 | 128 bit | |
| 163 * (b) >= 852 | >= 1704 | 5 | 112 bit | |
| 164 * (b) >= 476 | >= 952 | 5 | 80 bit | |
| 165 * (b) >= 400 | >= 800 | 6 | 80 bit | |
| 166 * (b) >= 347 | >= 694 | 7 | 80 bit | |
| 167 * (b) >= 308 | >= 616 | 8 | 80 bit | |
| 168 * (b) >= 55 | >= 110 | 27 | 64 bit | |
| 169 * (b) >= 6 | >= 12 | 34 | 64 bit | |
| 170 */ | |
| 171 | |
| 172 # define BN_prime_checks_for_size(b) ((b) >= 3747 ? 3 : \ | |
| 173 (b) >= 1345 ? 4 : \ | |
| 174 (b) >= 476 ? 5 : \ | |
| 175 (b) >= 400 ? 6 : \ | |
| 176 (b) >= 347 ? 7 : \ | |
| 177 (b) >= 308 ? 8 : \ | |
| 178 (b) >= 55 ? 27 : \ | |
| 179 /* b >= 6 */ 34) | |
| 180 | |
| 181 # define BN_num_bytes(a) ((BN_num_bits(a)+7)/8) | |
| 182 | |
| 183 int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w); | |
| 184 int BN_is_zero(const BIGNUM *a); | |
| 185 int BN_is_one(const BIGNUM *a); | |
| 186 int BN_is_word(const BIGNUM *a, const BN_ULONG w); | |
| 187 int BN_is_odd(const BIGNUM *a); | |
| 188 | |
| 189 # define BN_one(a) (BN_set_word((a),1)) | |
| 190 | |
| 191 void BN_zero_ex(BIGNUM *a); | |
| 192 | |
| 193 # if OPENSSL_API_COMPAT >= 0x00908000L | |
| 194 # define BN_zero(a) BN_zero_ex(a) | |
| 195 # else | |
| 196 # define BN_zero(a) (BN_set_word((a),0)) | |
| 197 # endif | |
| 198 | |
| 199 const BIGNUM *BN_value_one(void); | |
| 200 char *BN_options(void); | |
| 201 BN_CTX *BN_CTX_new(void); | |
| 202 BN_CTX *BN_CTX_secure_new(void); | |
| 203 void BN_CTX_free(BN_CTX *c); | |
| 204 void BN_CTX_start(BN_CTX *ctx); | |
| 205 BIGNUM *BN_CTX_get(BN_CTX *ctx); | |
| 206 void BN_CTX_end(BN_CTX *ctx); | |
| 207 int BN_rand(BIGNUM *rnd, int bits, int top, int bottom); | |
| 208 int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom); | |
| 209 int BN_rand_range(BIGNUM *rnd, const BIGNUM *range); | |
| 210 int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range); | |
| 211 int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom); | |
| 212 int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range); | |
| 213 int BN_num_bits(const BIGNUM *a); | |
| 214 int BN_num_bits_word(BN_ULONG l); | |
| 215 int BN_security_bits(int L, int N); | |
| 216 BIGNUM *BN_new(void); | |
| 217 BIGNUM *BN_secure_new(void); | |
| 218 void BN_clear_free(BIGNUM *a); | |
| 219 BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b); | |
| 220 void BN_swap(BIGNUM *a, BIGNUM *b); | |
| 221 BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret); | |
| 222 int BN_bn2bin(const BIGNUM *a, unsigned char *to); | |
| 223 int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen); | |
| 224 BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret); | |
| 225 int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen); | |
| 226 BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret); | |
| 227 int BN_bn2mpi(const BIGNUM *a, unsigned char *to); | |
| 228 int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
| 229 int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
| 230 int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
| 231 int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
| 232 int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); | |
| 233 int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx); | |
| 234 /** BN_set_negative sets sign of a BIGNUM | |
| 235 * \param b pointer to the BIGNUM object | |
| 236 * \param n 0 if the BIGNUM b should be positive and a value != 0 otherwise | |
| 237 */ | |
| 238 void BN_set_negative(BIGNUM *b, int n); | |
| 239 /** BN_is_negative returns 1 if the BIGNUM is negative | |
| 240 * \param b pointer to the BIGNUM object | |
| 241 * \return 1 if a < 0 and 0 otherwise | |
| 242 */ | |
| 243 int BN_is_negative(const BIGNUM *b); | |
| 244 | |
| 245 int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, | |
| 246 BN_CTX *ctx); | |
| 247 # define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx)) | |
| 248 int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx); | |
| 249 int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, | |
| 250 BN_CTX *ctx); | |
| 251 int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
| 252 const BIGNUM *m); | |
| 253 int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, | |
| 254 BN_CTX *ctx); | |
| 255 int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
| 256 const BIGNUM *m); | |
| 257 int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, | |
| 258 BN_CTX *ctx); | |
| 259 int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); | |
| 260 int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); | |
| 261 int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m); | |
| 262 int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m, | |
| 263 BN_CTX *ctx); | |
| 264 int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m); | |
| 265 | |
| 266 BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w); | |
| 267 BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w); | |
| 268 int BN_mul_word(BIGNUM *a, BN_ULONG w); | |
| 269 int BN_add_word(BIGNUM *a, BN_ULONG w); | |
| 270 int BN_sub_word(BIGNUM *a, BN_ULONG w); | |
| 271 int BN_set_word(BIGNUM *a, BN_ULONG w); | |
| 272 BN_ULONG BN_get_word(const BIGNUM *a); | |
| 273 | |
| 274 int BN_cmp(const BIGNUM *a, const BIGNUM *b); | |
| 275 void BN_free(BIGNUM *a); | |
| 276 int BN_is_bit_set(const BIGNUM *a, int n); | |
| 277 int BN_lshift(BIGNUM *r, const BIGNUM *a, int n); | |
| 278 int BN_lshift1(BIGNUM *r, const BIGNUM *a); | |
| 279 int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
| 280 | |
| 281 int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
| 282 const BIGNUM *m, BN_CTX *ctx); | |
| 283 int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
| 284 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |
| 285 int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p, | |
| 286 const BIGNUM *m, BN_CTX *ctx, | |
| 287 BN_MONT_CTX *in_mont); | |
| 288 int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p, | |
| 289 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |
| 290 int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1, | |
| 291 const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m, | |
| 292 BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |
| 293 int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
| 294 const BIGNUM *m, BN_CTX *ctx); | |
| 295 | |
| 296 int BN_mask_bits(BIGNUM *a, int n); | |
| 297 # ifndef OPENSSL_NO_STDIO | |
| 298 int BN_print_fp(FILE *fp, const BIGNUM *a); | |
| 299 # endif | |
| 300 int BN_print(BIO *bio, const BIGNUM *a); | |
| 301 int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx); | |
| 302 int BN_rshift(BIGNUM *r, const BIGNUM *a, int n); | |
| 303 int BN_rshift1(BIGNUM *r, const BIGNUM *a); | |
| 304 void BN_clear(BIGNUM *a); | |
| 305 BIGNUM *BN_dup(const BIGNUM *a); | |
| 306 int BN_ucmp(const BIGNUM *a, const BIGNUM *b); | |
| 307 int BN_set_bit(BIGNUM *a, int n); | |
| 308 int BN_clear_bit(BIGNUM *a, int n); | |
| 309 char *BN_bn2hex(const BIGNUM *a); | |
| 310 char *BN_bn2dec(const BIGNUM *a); | |
| 311 int BN_hex2bn(BIGNUM **a, const char *str); | |
| 312 int BN_dec2bn(BIGNUM **a, const char *str); | |
| 313 int BN_asc2bn(BIGNUM **a, const char *str); | |
| 314 int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); | |
| 315 int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns | |
| 316 * -2 for | |
| 317 * error */ | |
| 318 BIGNUM *BN_mod_inverse(BIGNUM *ret, | |
| 319 const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); | |
| 320 BIGNUM *BN_mod_sqrt(BIGNUM *ret, | |
| 321 const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); | |
| 322 | |
| 323 void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords); | |
| 324 | |
| 325 /* Deprecated versions */ | |
| 326 DEPRECATEDIN_0_9_8(BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe, | |
| 327 const BIGNUM *add, | |
| 328 const BIGNUM *rem, | |
| 329 void (*callback) (int, int, | |
| 330 void *), | |
| 331 void *cb_arg)) | |
| 332 DEPRECATEDIN_0_9_8(int | |
| 333 BN_is_prime(const BIGNUM *p, int nchecks, | |
| 334 void (*callback) (int, int, void *), | |
| 335 BN_CTX *ctx, void *cb_arg)) | |
| 336 DEPRECATEDIN_0_9_8(int | |
| 337 BN_is_prime_fasttest(const BIGNUM *p, int nchecks, | |
| 338 void (*callback) (int, int, void *), | |
| 339 BN_CTX *ctx, void *cb_arg, | |
| 340 int do_trial_division)) | |
| 341 | |
| 342 /* Newer versions */ | |
| 343 int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add, | |
| 344 const BIGNUM *rem, BN_GENCB *cb); | |
| 345 int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb); | |
| 346 int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, | |
| 347 int do_trial_division, BN_GENCB *cb); | |
| 348 | |
| 349 int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx); | |
| 350 | |
| 351 int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | |
| 352 const BIGNUM *Xp, const BIGNUM *Xp1, | |
| 353 const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx, | |
| 354 BN_GENCB *cb); | |
| 355 int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1, | |
| 356 BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e, | |
| 357 BN_CTX *ctx, BN_GENCB *cb); | |
| 358 | |
| 359 BN_MONT_CTX *BN_MONT_CTX_new(void); | |
| 360 int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
| 361 BN_MONT_CTX *mont, BN_CTX *ctx); | |
| 362 int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, | |
| 363 BN_CTX *ctx); | |
| 364 int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, | |
| 365 BN_CTX *ctx); | |
| 366 void BN_MONT_CTX_free(BN_MONT_CTX *mont); | |
| 367 int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx); | |
| 368 BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from); | |
| 369 BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock, | |
| 370 const BIGNUM *mod, BN_CTX *ctx); | |
| 371 | |
| 372 /* BN_BLINDING flags */ | |
| 373 # define BN_BLINDING_NO_UPDATE 0x00000001 | |
| 374 # define BN_BLINDING_NO_RECREATE 0x00000002 | |
| 375 | |
| 376 BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod); | |
| 377 void BN_BLINDING_free(BN_BLINDING *b); | |
| 378 int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx); | |
| 379 int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); | |
| 380 int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); | |
| 381 int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *); | |
| 382 int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, | |
| 383 BN_CTX *); | |
| 384 | |
| 385 int BN_BLINDING_is_current_thread(BN_BLINDING *b); | |
| 386 void BN_BLINDING_set_current_thread(BN_BLINDING *b); | |
| 387 int BN_BLINDING_lock(BN_BLINDING *b); | |
| 388 int BN_BLINDING_unlock(BN_BLINDING *b); | |
| 389 | |
| 390 unsigned long BN_BLINDING_get_flags(const BN_BLINDING *); | |
| 391 void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long); | |
| 392 BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b, | |
| 393 const BIGNUM *e, BIGNUM *m, BN_CTX *ctx, | |
| 394 int (*bn_mod_exp) (BIGNUM *r, | |
| 395 const BIGNUM *a, | |
| 396 const BIGNUM *p, | |
| 397 const BIGNUM *m, | |
| 398 BN_CTX *ctx, | |
| 399 BN_MONT_CTX *m_ctx), | |
| 400 BN_MONT_CTX *m_ctx); | |
| 401 | |
| 402 DEPRECATEDIN_0_9_8(void BN_set_params(int mul, int high, int low, int mont)) | |
| 403 DEPRECATEDIN_0_9_8(int BN_get_params(int which)) /* 0, mul, 1 high, 2 low, 3 | |
| 404 * mont */ | |
| 405 | |
| 406 BN_RECP_CTX *BN_RECP_CTX_new(void); | |
| 407 void BN_RECP_CTX_free(BN_RECP_CTX *recp); | |
| 408 int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx); | |
| 409 int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y, | |
| 410 BN_RECP_CTX *recp, BN_CTX *ctx); | |
| 411 int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
| 412 const BIGNUM *m, BN_CTX *ctx); | |
| 413 int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, | |
| 414 BN_RECP_CTX *recp, BN_CTX *ctx); | |
| 415 | |
| 416 # ifndef OPENSSL_NO_EC2M | |
| 417 | |
| 418 /* | |
| 419 * Functions for arithmetic over binary polynomials represented by BIGNUMs. | |
| 420 * The BIGNUM::neg property of BIGNUMs representing binary polynomials is | |
| 421 * ignored. Note that input arguments are not const so that their bit arrays | |
| 422 * can be expanded to the appropriate size if needed. | |
| 423 */ | |
| 424 | |
| 425 /* | |
| 426 * r = a + b | |
| 427 */ | |
| 428 int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |
| 429 # define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b) | |
| 430 /* | |
| 431 * r=a mod p | |
| 432 */ | |
| 433 int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p); | |
| 434 /* r = (a * b) mod p */ | |
| 435 int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
| 436 const BIGNUM *p, BN_CTX *ctx); | |
| 437 /* r = (a * a) mod p */ | |
| 438 int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
| 439 /* r = (1 / b) mod p */ | |
| 440 int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx); | |
| 441 /* r = (a / b) mod p */ | |
| 442 int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
| 443 const BIGNUM *p, BN_CTX *ctx); | |
| 444 /* r = (a ^ b) mod p */ | |
| 445 int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
| 446 const BIGNUM *p, BN_CTX *ctx); | |
| 447 /* r = sqrt(a) mod p */ | |
| 448 int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
| 449 BN_CTX *ctx); | |
| 450 /* r^2 + r = a mod p */ | |
| 451 int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
| 452 BN_CTX *ctx); | |
| 453 # define BN_GF2m_cmp(a, b) BN_ucmp((a), (b)) | |
| 454 /*- | |
| 455 * Some functions allow for representation of the irreducible polynomials | |
| 456 * as an unsigned int[], say p. The irreducible f(t) is then of the form: | |
| 457 * t^p[0] + t^p[1] + ... + t^p[k] | |
| 458 * where m = p[0] > p[1] > ... > p[k] = 0. | |
| 459 */ | |
| 460 /* r = a mod p */ | |
| 461 int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]); | |
| 462 /* r = (a * b) mod p */ | |
| 463 int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
| 464 const int p[], BN_CTX *ctx); | |
| 465 /* r = (a * a) mod p */ | |
| 466 int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[], | |
| 467 BN_CTX *ctx); | |
| 468 /* r = (1 / b) mod p */ | |
| 469 int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[], | |
| 470 BN_CTX *ctx); | |
| 471 /* r = (a / b) mod p */ | |
| 472 int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
| 473 const int p[], BN_CTX *ctx); | |
| 474 /* r = (a ^ b) mod p */ | |
| 475 int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |
| 476 const int p[], BN_CTX *ctx); | |
| 477 /* r = sqrt(a) mod p */ | |
| 478 int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a, | |
| 479 const int p[], BN_CTX *ctx); | |
| 480 /* r^2 + r = a mod p */ | |
| 481 int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a, | |
| 482 const int p[], BN_CTX *ctx); | |
| 483 int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max); | |
| 484 int BN_GF2m_arr2poly(const int p[], BIGNUM *a); | |
| 485 | |
| 486 # endif | |
| 487 | |
| 488 /* | |
| 489 * faster mod functions for the 'NIST primes' 0 <= a < p^2 | |
| 490 */ | |
| 491 int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
| 492 int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
| 493 int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
| 494 int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
| 495 int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |
| 496 | |
| 497 const BIGNUM *BN_get0_nist_prime_192(void); | |
| 498 const BIGNUM *BN_get0_nist_prime_224(void); | |
| 499 const BIGNUM *BN_get0_nist_prime_256(void); | |
| 500 const BIGNUM *BN_get0_nist_prime_384(void); | |
| 501 const BIGNUM *BN_get0_nist_prime_521(void); | |
| 502 | |
| 503 int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a, | |
| 504 const BIGNUM *field, BN_CTX *ctx); | |
| 505 | |
| 506 int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range, | |
| 507 const BIGNUM *priv, const unsigned char *message, | |
| 508 size_t message_len, BN_CTX *ctx); | |
| 509 | |
| 510 /* Primes from RFC 2409 */ | |
| 511 BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn); | |
| 512 BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn); | |
| 513 | |
| 514 /* Primes from RFC 3526 */ | |
| 515 BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn); | |
| 516 BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn); | |
| 517 BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn); | |
| 518 BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn); | |
| 519 BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn); | |
| 520 BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn); | |
| 521 | |
| 522 # if OPENSSL_API_COMPAT < 0x10100000L | |
| 523 # define get_rfc2409_prime_768 BN_get_rfc2409_prime_768 | |
| 524 # define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024 | |
| 525 # define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536 | |
| 526 # define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048 | |
| 527 # define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072 | |
| 528 # define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096 | |
| 529 # define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144 | |
| 530 # define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192 | |
| 531 # endif | |
| 532 | |
| 533 int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom); | |
| 534 | |
| 535 | |
| 536 # ifdef __cplusplus | |
| 537 } | |
| 538 # endif | |
| 539 #endif |