include/openssl/bn.h

0001 /*
0002  * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
0003  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
0004  *
0005  * Licensed under the Apache License 2.0 (the "License").  You may not use
0006  * this file except in compliance with the License.  You can obtain a copy
0007  * in the file LICENSE in the source distribution or at
0008  * https://www.openssl.org/source/license.html
0009  */
0010
0011 #ifndef OPENSSL_BN_H
0012 # define OPENSSL_BN_H
0013 # pragma once
0014
0015 # include <openssl/macros.h>
0016 # ifndef OPENSSL_NO_DEPRECATED_3_0
0017 #  define HEADER_BN_H
0018 # endif
0019
0020 # include <openssl/e_os2.h>
0021 # ifndef OPENSSL_NO_STDIO
0022 #  include <stdio.h>
0023 # endif
0024 # include <openssl/opensslconf.h>
0025 # include <openssl/types.h>
0026 # include <openssl/crypto.h>
0027 # include <openssl/bnerr.h>
0028
0029 #ifdef  __cplusplus
0030 extern "C" {
0031 #endif
0032
0033 /*
0034  * 64-bit processor with LP64 ABI
0035  */
0036 # ifdef SIXTY_FOUR_BIT_LONG
0037 #  define BN_ULONG        unsigned long
0038 #  define BN_BYTES        8
0039 # endif
0040
0041 /*
0042  * 64-bit processor other than LP64 ABI
0043  */
0044 # ifdef SIXTY_FOUR_BIT
0045 #  define BN_ULONG        unsigned long long
0046 #  define BN_BYTES        8
0047 # endif
0048
0049 # ifdef THIRTY_TWO_BIT
0050 #  define BN_ULONG        unsigned int
0051 #  define BN_BYTES        4
0052 # endif
0053
0054 # define BN_BITS2       (BN_BYTES * 8)
0055 # define BN_BITS        (BN_BITS2 * 2)
0056 # define BN_TBIT        ((BN_ULONG)1 << (BN_BITS2 - 1))
0057
0058 # define BN_FLG_MALLOCED         0x01
0059 # define BN_FLG_STATIC_DATA      0x02
0060
0061 /*
0062  * avoid leaking exponent information through timing,
0063  * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime,
0064  * BN_div() will call BN_div_no_branch,
0065  * BN_mod_inverse() will call bn_mod_inverse_no_branch.
0066  */
0067 # define BN_FLG_CONSTTIME        0x04
0068 # define BN_FLG_SECURE           0x08
0069
0070 # ifndef OPENSSL_NO_DEPRECATED_0_9_8
0071 /* deprecated name for the flag */
0072 #  define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME
0073 #  define BN_FLG_FREE            0x8000 /* used for debugging */
0074 # endif
0075
0076 void BN_set_flags(BIGNUM *b, int n);
0077 int BN_get_flags(const BIGNUM *b, int n);
0078
0079 /* Values for |top| in BN_rand() */
0080 #define BN_RAND_TOP_ANY    -1
0081 #define BN_RAND_TOP_ONE     0
0082 #define BN_RAND_TOP_TWO     1
0083
0084 /* Values for |bottom| in BN_rand() */
0085 #define BN_RAND_BOTTOM_ANY  0
0086 #define BN_RAND_BOTTOM_ODD  1
0087
0088 /*
0089  * get a clone of a BIGNUM with changed flags, for *temporary* use only (the
0090  * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The
0091  * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that
0092  * has not been otherwise initialised or used.
0093  */
0094 void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags);
0095
0096 /* Wrapper function to make using BN_GENCB easier */
0097 int BN_GENCB_call(BN_GENCB *cb, int a, int b);
0098
0099 BN_GENCB *BN_GENCB_new(void);
0100 void BN_GENCB_free(BN_GENCB *cb);
0101
0102 /* Populate a BN_GENCB structure with an "old"-style callback */
0103 void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *),
0104                       void *cb_arg);
0105
0106 /* Populate a BN_GENCB structure with a "new"-style callback */
0107 void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *),
0108                   void *cb_arg);
0109
0110 void *BN_GENCB_get_arg(BN_GENCB *cb);
0111
0112 # ifndef OPENSSL_NO_DEPRECATED_3_0
0113 #  define BN_prime_checks 0      /* default: select number of iterations based
0114                                   * on the size of the number */
0115
0116 /*
0117  * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations
0118  * that will be done for checking that a random number is probably prime. The
0119  * error rate for accepting a composite number as prime depends on the size of
0120  * the prime |b|. The error rates used are for calculating an RSA key with 2 primes,
0121  * and so the level is what you would expect for a key of double the size of the
0122  * prime.
0123  *
0124  * This table is generated using the algorithm of FIPS PUB 186-4
0125  * Digital Signature Standard (DSS), section F.1, page 117.
0126  * (https://dx.doi.org/10.6028/NIST.FIPS.186-4)
0127  *
0128  * The following magma script was used to generate the output:
0129  * securitybits:=125;
0130  * k:=1024;
0131  * for t:=1 to 65 do
0132  *   for M:=3 to Floor(2*Sqrt(k-1)-1) do
0133  *     S:=0;
0134  *     // Sum over m
0135  *     for m:=3 to M do
0136  *       s:=0;
0137  *       // Sum over j
0138  *       for j:=2 to m do
0139  *         s+:=(RealField(32)!2)^-(j+(k-1)/j);
0140  *       end for;
0141  *       S+:=2^(m-(m-1)*t)*s;
0142  *     end for;
0143  *     A:=2^(k-2-M*t);
0144  *     B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S;
0145  *     pkt:=2.00743*Log(2)*k*2^-k*(A+B);
0146  *     seclevel:=Floor(-Log(2,pkt));
0147  *     if seclevel ge securitybits then
0148  *       printf "k: %5o, security: %o bits  (t: %o, M: %o)\n",k,seclevel,t,M;
0149  *       break;
0150  *     end if;
0151  *   end for;
0152  *   if seclevel ge securitybits then break; end if;
0153  * end for;
0154  *
0155  * It can be run online at:
0156  * http://magma.maths.usyd.edu.au/calc
0157  *
0158  * And will output:
0159  * k:  1024, security: 129 bits  (t: 6, M: 23)
0160  *
0161  * k is the number of bits of the prime, securitybits is the level we want to
0162  * reach.
0163  *
0164  * prime length | RSA key size | # MR tests | security level
0165  * -------------+--------------|------------+---------------
0166  *  (b) >= 6394 |     >= 12788 |          3 |        256 bit
0167  *  (b) >= 3747 |     >=  7494 |          3 |        192 bit
0168  *  (b) >= 1345 |     >=  2690 |          4 |        128 bit
0169  *  (b) >= 1080 |     >=  2160 |          5 |        128 bit
0170  *  (b) >=  852 |     >=  1704 |          5 |        112 bit
0171  *  (b) >=  476 |     >=   952 |          5 |         80 bit
0172  *  (b) >=  400 |     >=   800 |          6 |         80 bit
0173  *  (b) >=  347 |     >=   694 |          7 |         80 bit
0174  *  (b) >=  308 |     >=   616 |          8 |         80 bit
0175  *  (b) >=   55 |     >=   110 |         27 |         64 bit
0176  *  (b) >=    6 |     >=    12 |         34 |         64 bit
0177  */
0178
0179 #  define BN_prime_checks_for_size(b) ((b) >= 3747 ?  3 : \
0180                                       (b) >=  1345 ?  4 : \
0181                                       (b) >=  476 ?  5 : \
0182                                       (b) >=  400 ?  6 : \
0183                                       (b) >=  347 ?  7 : \
0184                                       (b) >=  308 ?  8 : \
0185                                       (b) >=  55  ? 27 : \
0186                                       /* b >= 6 */ 34)
0187 # endif
0188
0189 # define BN_num_bytes(a) ((BN_num_bits(a)+7)/8)
0190
0191 int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w);
0192 int BN_is_zero(const BIGNUM *a);
0193 int BN_is_one(const BIGNUM *a);
0194 int BN_is_word(const BIGNUM *a, const BN_ULONG w);
0195 int BN_is_odd(const BIGNUM *a);
0196
0197 # define BN_one(a)       (BN_set_word((a),1))
0198
0199 void BN_zero_ex(BIGNUM *a);
0200
0201 # if OPENSSL_API_LEVEL > 908
0202 #  define BN_zero(a)      BN_zero_ex(a)
0203 # else
0204 #  define BN_zero(a)      (BN_set_word((a),0))
0205 # endif
0206
0207 const BIGNUM *BN_value_one(void);
0208 char *BN_options(void);
0209 BN_CTX *BN_CTX_new_ex(OSSL_LIB_CTX *ctx);
0210 BN_CTX *BN_CTX_new(void);
0211 BN_CTX *BN_CTX_secure_new_ex(OSSL_LIB_CTX *ctx);
0212 BN_CTX *BN_CTX_secure_new(void);
0213 void BN_CTX_free(BN_CTX *c);
0214 void BN_CTX_start(BN_CTX *ctx);
0215 BIGNUM *BN_CTX_get(BN_CTX *ctx);
0216 void BN_CTX_end(BN_CTX *ctx);
0217 int BN_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
0218                unsigned int strength, BN_CTX *ctx);
0219 int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
0220 int BN_priv_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
0221                     unsigned int strength, BN_CTX *ctx);
0222 int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom);
0223 int BN_rand_range_ex(BIGNUM *r, const BIGNUM *range, unsigned int strength,
0224                      BN_CTX *ctx);
0225 int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
0226 int BN_priv_rand_range_ex(BIGNUM *r, const BIGNUM *range,
0227                           unsigned int strength, BN_CTX *ctx);
0228 int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range);
0229 # ifndef OPENSSL_NO_DEPRECATED_3_0
0230 OSSL_DEPRECATEDIN_3_0
0231 int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
0232 OSSL_DEPRECATEDIN_3_0
0233 int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
0234 # endif
0235 int BN_num_bits(const BIGNUM *a);
0236 int BN_num_bits_word(BN_ULONG l);
0237 int BN_security_bits(int L, int N);
0238 BIGNUM *BN_new(void);
0239 BIGNUM *BN_secure_new(void);
0240 void BN_clear_free(BIGNUM *a);
0241 BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
0242 void BN_swap(BIGNUM *a, BIGNUM *b);
0243 BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
0244 BIGNUM *BN_signed_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
0245 int BN_bn2bin(const BIGNUM *a, unsigned char *to);
0246 int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
0247 int BN_signed_bn2bin(const BIGNUM *a, unsigned char *to, int tolen);
0248 BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
0249 BIGNUM *BN_signed_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
0250 int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
0251 int BN_signed_bn2lebin(const BIGNUM *a, unsigned char *to, int tolen);
0252 BIGNUM *BN_native2bn(const unsigned char *s, int len, BIGNUM *ret);
0253 BIGNUM *BN_signed_native2bn(const unsigned char *s, int len, BIGNUM *ret);
0254 int BN_bn2nativepad(const BIGNUM *a, unsigned char *to, int tolen);
0255 int BN_signed_bn2native(const BIGNUM *a, unsigned char *to, int tolen);
0256 BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
0257 int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
0258 int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
0259 int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
0260 int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
0261 int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
0262 int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
0263 int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
0264 /** BN_set_negative sets sign of a BIGNUM
0265  * \param  b  pointer to the BIGNUM object
0266  * \param  n  0 if the BIGNUM b should be positive and a value != 0 otherwise
0267  */
0268 void BN_set_negative(BIGNUM *b, int n);
0269 /** BN_is_negative returns 1 if the BIGNUM is negative
0270  * \param  b  pointer to the BIGNUM object
0271  * \return 1 if a < 0 and 0 otherwise
0272  */
0273 int BN_is_negative(const BIGNUM *b);
0274
0275 int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
0276            BN_CTX *ctx);
0277 # define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx))
0278 int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
0279 int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
0280                BN_CTX *ctx);
0281 int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
0282                      const BIGNUM *m);
0283 int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
0284                BN_CTX *ctx);
0285 int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
0286                      const BIGNUM *m);
0287 int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
0288                BN_CTX *ctx);
0289 int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
0290 int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
0291 int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
0292 int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
0293                   BN_CTX *ctx);
0294 int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);
0295
0296 BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
0297 BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
0298 int BN_mul_word(BIGNUM *a, BN_ULONG w);
0299 int BN_add_word(BIGNUM *a, BN_ULONG w);
0300 int BN_sub_word(BIGNUM *a, BN_ULONG w);
0301 int BN_set_word(BIGNUM *a, BN_ULONG w);
0302 BN_ULONG BN_get_word(const BIGNUM *a);
0303
0304 int BN_cmp(const BIGNUM *a, const BIGNUM *b);
0305 void BN_free(BIGNUM *a);
0306 int BN_is_bit_set(const BIGNUM *a, int n);
0307 int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
0308 int BN_lshift1(BIGNUM *r, const BIGNUM *a);
0309 int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
0310
0311 int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
0312                const BIGNUM *m, BN_CTX *ctx);
0313 int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
0314                     const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
0315 int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
0316                               const BIGNUM *m, BN_CTX *ctx,
0317                               BN_MONT_CTX *in_mont);
0318 int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p,
0319                          const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
0320 int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
0321                      const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
0322                      BN_CTX *ctx, BN_MONT_CTX *m_ctx);
0323 int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
0324                       const BIGNUM *m, BN_CTX *ctx);
0325 int BN_mod_exp_mont_consttime_x2(BIGNUM *rr1, const BIGNUM *a1, const BIGNUM *p1,
0326                                  const BIGNUM *m1, BN_MONT_CTX *in_mont1,
0327                                  BIGNUM *rr2, const BIGNUM *a2, const BIGNUM *p2,
0328                                  const BIGNUM *m2, BN_MONT_CTX *in_mont2,
0329                                  BN_CTX *ctx);
0330
0331 int BN_mask_bits(BIGNUM *a, int n);
0332 # ifndef OPENSSL_NO_STDIO
0333 int BN_print_fp(FILE *fp, const BIGNUM *a);
0334 # endif
0335 int BN_print(BIO *bio, const BIGNUM *a);
0336 int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
0337 int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
0338 int BN_rshift1(BIGNUM *r, const BIGNUM *a);
0339 void BN_clear(BIGNUM *a);
0340 BIGNUM *BN_dup(const BIGNUM *a);
0341 int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
0342 int BN_set_bit(BIGNUM *a, int n);
0343 int BN_clear_bit(BIGNUM *a, int n);
0344 char *BN_bn2hex(const BIGNUM *a);
0345 char *BN_bn2dec(const BIGNUM *a);
0346 int BN_hex2bn(BIGNUM **a, const char *str);
0347 int BN_dec2bn(BIGNUM **a, const char *str);
0348 int BN_asc2bn(BIGNUM **a, const char *str);
0349 int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
0350 int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns
0351                                                                   * -2 for
0352                                                                   * error */
0353 int BN_are_coprime(BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
0354 BIGNUM *BN_mod_inverse(BIGNUM *ret,
0355                        const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
0356 BIGNUM *BN_mod_sqrt(BIGNUM *ret,
0357                     const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
0358
0359 void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords);
0360
0361 /* Deprecated versions */
0362 # ifndef OPENSSL_NO_DEPRECATED_0_9_8
0363 OSSL_DEPRECATEDIN_0_9_8
0364 BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe,
0365                           const BIGNUM *add, const BIGNUM *rem,
0366                           void (*callback) (int, int, void *),
0367                           void *cb_arg);
0368 OSSL_DEPRECATEDIN_0_9_8
0369 int BN_is_prime(const BIGNUM *p, int nchecks,
0370                 void (*callback) (int, int, void *),
0371                 BN_CTX *ctx, void *cb_arg);
0372 OSSL_DEPRECATEDIN_0_9_8
0373 int BN_is_prime_fasttest(const BIGNUM *p, int nchecks,
0374                          void (*callback) (int, int, void *),
0375                          BN_CTX *ctx, void *cb_arg,
0376                          int do_trial_division);
0377 # endif
0378 # ifndef OPENSSL_NO_DEPRECATED_3_0
0379 OSSL_DEPRECATEDIN_3_0
0380 int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb);
0381 OSSL_DEPRECATEDIN_3_0
0382 int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx,
0383                             int do_trial_division, BN_GENCB *cb);
0384 # endif
0385 /* Newer versions */
0386 int BN_generate_prime_ex2(BIGNUM *ret, int bits, int safe,
0387                           const BIGNUM *add, const BIGNUM *rem, BN_GENCB *cb,
0388                           BN_CTX *ctx);
0389 int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add,
0390                          const BIGNUM *rem, BN_GENCB *cb);
0391 int BN_check_prime(const BIGNUM *p, BN_CTX *ctx, BN_GENCB *cb);
0392
0393 # ifndef OPENSSL_NO_DEPRECATED_3_0
0394 OSSL_DEPRECATEDIN_3_0
0395 int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);
0396
0397 OSSL_DEPRECATEDIN_3_0
0398 int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
0399                             const BIGNUM *Xp, const BIGNUM *Xp1,
0400                             const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,
0401                             BN_GENCB *cb);
0402 OSSL_DEPRECATEDIN_3_0
0403 int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1,
0404                               BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e,
0405                               BN_CTX *ctx, BN_GENCB *cb);
0406 # endif
0407
0408 BN_MONT_CTX *BN_MONT_CTX_new(void);
0409 int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
0410                           BN_MONT_CTX *mont, BN_CTX *ctx);
0411 int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
0412                      BN_CTX *ctx);
0413 int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
0414                        BN_CTX *ctx);
0415 void BN_MONT_CTX_free(BN_MONT_CTX *mont);
0416 int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx);
0417 BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);
0418 BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock,
0419                                     const BIGNUM *mod, BN_CTX *ctx);
0420
0421 /* BN_BLINDING flags */
0422 # define BN_BLINDING_NO_UPDATE   0x00000001
0423 # define BN_BLINDING_NO_RECREATE 0x00000002
0424
0425 BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
0426 void BN_BLINDING_free(BN_BLINDING *b);
0427 int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
0428 int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
0429 int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
0430 int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
0431 int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
0432                           BN_CTX *);
0433
0434 int BN_BLINDING_is_current_thread(BN_BLINDING *b);
0435 void BN_BLINDING_set_current_thread(BN_BLINDING *b);
0436 int BN_BLINDING_lock(BN_BLINDING *b);
0437 int BN_BLINDING_unlock(BN_BLINDING *b);
0438
0439 unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
0440 void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
0441 BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
0442                                       const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
0443                                       int (*bn_mod_exp) (BIGNUM *r,
0444                                                          const BIGNUM *a,
0445                                                          const BIGNUM *p,
0446                                                          const BIGNUM *m,
0447                                                          BN_CTX *ctx,
0448                                                          BN_MONT_CTX *m_ctx),
0449                                       BN_MONT_CTX *m_ctx);
0450 # ifndef OPENSSL_NO_DEPRECATED_0_9_8
0451 OSSL_DEPRECATEDIN_0_9_8
0452 void BN_set_params(int mul, int high, int low, int mont);
0453 OSSL_DEPRECATEDIN_0_9_8
0454 int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */
0455 # endif
0456
0457 BN_RECP_CTX *BN_RECP_CTX_new(void);
0458 void BN_RECP_CTX_free(BN_RECP_CTX *recp);
0459 int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx);
0460 int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
0461                           BN_RECP_CTX *recp, BN_CTX *ctx);
0462 int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
0463                     const BIGNUM *m, BN_CTX *ctx);
0464 int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
0465                 BN_RECP_CTX *recp, BN_CTX *ctx);
0466
0467 # ifndef OPENSSL_NO_EC2M
0468
0469 /*
0470  * Functions for arithmetic over binary polynomials represented by BIGNUMs.
0471  * The BIGNUM::neg property of BIGNUMs representing binary polynomials is
0472  * ignored. Note that input arguments are not const so that their bit arrays
0473  * can be expanded to the appropriate size if needed.
0474  */
0475
0476 /*
0477  * r = a + b
0478  */
0479 int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
0480 #  define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b)
0481 /*
0482  * r=a mod p
0483  */
0484 int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p);
0485 /* r = (a * b) mod p */
0486 int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
0487                     const BIGNUM *p, BN_CTX *ctx);
0488 /* r = (a * a) mod p */
0489 int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
0490 /* r = (1 / b) mod p */
0491 int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx);
0492 /* r = (a / b) mod p */
0493 int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
0494                     const BIGNUM *p, BN_CTX *ctx);
0495 /* r = (a ^ b) mod p */
0496 int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
0497                     const BIGNUM *p, BN_CTX *ctx);
0498 /* r = sqrt(a) mod p */
0499 int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
0500                      BN_CTX *ctx);
0501 /* r^2 + r = a mod p */
0502 int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
0503                            BN_CTX *ctx);
0504 #  define BN_GF2m_cmp(a, b) BN_ucmp((a), (b))
0505 /*-
0506  * Some functions allow for representation of the irreducible polynomials
0507  * as an unsigned int[], say p.  The irreducible f(t) is then of the form:
0508  *     t^p[0] + t^p[1] + ... + t^p[k]
0509  * where m = p[0] > p[1] > ... > p[k] = 0.
0510  */
0511 /* r = a mod p */
0512 int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]);
0513 /* r = (a * b) mod p */
0514 int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
0515                         const int p[], BN_CTX *ctx);
0516 /* r = (a * a) mod p */
0517 int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[],
0518                         BN_CTX *ctx);
0519 /* r = (1 / b) mod p */
0520 int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[],
0521                         BN_CTX *ctx);
0522 /* r = (a / b) mod p */
0523 int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
0524                         const int p[], BN_CTX *ctx);
0525 /* r = (a ^ b) mod p */
0526 int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
0527                         const int p[], BN_CTX *ctx);
0528 /* r = sqrt(a) mod p */
0529 int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a,
0530                          const int p[], BN_CTX *ctx);
0531 /* r^2 + r = a mod p */
0532 int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a,
0533                                const int p[], BN_CTX *ctx);
0534 int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max);
0535 int BN_GF2m_arr2poly(const int p[], BIGNUM *a);
0536
0537 # endif
0538
0539 /*
0540  * faster mod functions for the 'NIST primes' 0 <= a < p^2
0541  */
0542 int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
0543 int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
0544 int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
0545 int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
0546 int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
0547
0548 const BIGNUM *BN_get0_nist_prime_192(void);
0549 const BIGNUM *BN_get0_nist_prime_224(void);
0550 const BIGNUM *BN_get0_nist_prime_256(void);
0551 const BIGNUM *BN_get0_nist_prime_384(void);
0552 const BIGNUM *BN_get0_nist_prime_521(void);
0553
0554 int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a,
0555                                           const BIGNUM *field, BN_CTX *ctx);
0556
0557 int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
0558                           const BIGNUM *priv, const unsigned char *message,
0559                           size_t message_len, BN_CTX *ctx);
0560
0561 /* Primes from RFC 2409 */
0562 BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn);
0563 BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn);
0564
0565 /* Primes from RFC 3526 */
0566 BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn);
0567 BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn);
0568 BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn);
0569 BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn);
0570 BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn);
0571 BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn);
0572
0573 #  ifndef OPENSSL_NO_DEPRECATED_1_1_0
0574 #   define get_rfc2409_prime_768 BN_get_rfc2409_prime_768
0575 #   define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024
0576 #   define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536
0577 #   define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048
0578 #   define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072
0579 #   define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096
0580 #   define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144
0581 #   define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192
0582 #  endif
0583
0584 int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom);
0585
0586
0587 # ifdef  __cplusplus
0588 }
0589 # endif
0590 #endif