1 /* crypto/bn/bn.h */

     2 /* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)

     3  * All rights reserved.

     4  *

     5  * This package is an SSL implementation written

     6  * by Eric Young (eay@cryptsoft.com).

     7  * The implementation was written so as to conform with Netscapes SSL.

     8  * 

     9  * This library is free for commercial and non-commercial use as long as

    10  * the following conditions are aheared to.  The following conditions

    11  * apply to all code found in this distribution, be it the RC4, RSA,

    12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

    13  * included with this distribution is covered by the same copyright terms

    14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).

    15  * 

    16  * Copyright remains Eric Young's, and as such any Copyright notices in

    17  * the code are not to be removed.

    18  * If this package is used in a product, Eric Young should be given attribution

    19  * as the author of the parts of the library used.

    20  * This can be in the form of a textual message at program startup or

    21  * in documentation (online or textual) provided with the package.

    22  * 

    23  * Redistribution and use in source and binary forms, with or without

    24  * modification, are permitted provided that the following conditions

    25  * are met:

    26  * 1. Redistributions of source code must retain the copyright

    27  *    notice, this list of conditions and the following disclaimer.

    28  * 2. Redistributions in binary form must reproduce the above copyright

    29  *    notice, this list of conditions and the following disclaimer in the

    30  *    documentation and/or other materials provided with the distribution.

    31  * 3. All advertising materials mentioning features or use of this software

    32  *    must display the following acknowledgement:

    33  *    "This product includes cryptographic software written by

    34  *     Eric Young (eay@cryptsoft.com)"

    35  *    The word 'cryptographic' can be left out if the rouines from the library

    36  *    being used are not cryptographic related :-).

    37  * 4. If you include any Windows specific code (or a derivative thereof) from 

    38  *    the apps directory (application code) you must include an acknowledgement:

    39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

    40  * 

    41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

    42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

    45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

    47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

    48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

    49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

    50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

    51  * SUCH DAMAGE.

    52  * 

    53  * The licence and distribution terms for any publically available version or

    54  * derivative of this code cannot be changed.  i.e. this code cannot simply be

    55  * copied and put under another distribution licence

    56  * [including the GNU Public Licence.]

    57  */

    58 

    59 #ifndef HEADER_BN_H

    60 #define HEADER_BN_H

    61 

    62 #include <openssl/e_os2.h>

    63 #ifndef OPENSSL_NO_FP_API

    64 #include <stdio.h> /* FILE */

    65 #endif

    66 

    67 #ifdef  __cplusplus

    68 extern "C" {

    69 #endif

    70 

    71 #ifdef OPENSSL_SYS_VMS

    72 #undef BN_LLONG /* experimental, so far... */

    73 #endif

    74 

    75 #define BN_MUL_COMBA

    76 #define BN_SQR_COMBA

    77 #define BN_RECURSION

    78 

    79 /* This next option uses the C libraries (2 word)/(1 word) function.

    80  * If it is not defined, I use my C version (which is slower).

    81  * The reason for this flag is that when the particular C compiler

    82  * library routine is used, and the library is linked with a different

    83  * compiler, the library is missing.  This mostly happens when the

    84  * library is built with gcc and then linked using normal cc.  This would

    85  * be a common occurrence because gcc normally produces code that is

    86  * 2 times faster than system compilers for the big number stuff.

    87  * For machines with only one compiler (or shared libraries), this should

    88  * be on.  Again this in only really a problem on machines

    89  * using "long long's", are 32bit, and are not using my assembler code. */

    90 #if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || \

    91     defined(OPENSSL_SYS_WIN32) || defined(linux)

    92 # ifndef BN_DIV2W

    93 #  define BN_DIV2W

    94 # endif

    95 #endif

    96 

    97 /* assuming long is 64bit - this is the DEC Alpha

    98  * unsigned long long is only 64 bits :-(, don't define

    99  * BN_LLONG for the DEC Alpha */

   100 #ifdef SIXTY_FOUR_BIT_LONG

   101 #define BN_ULLONG	unsigned long long

   102 #define BN_ULONG	unsigned long

   103 #define BN_LONG		long

   104 #define BN_BITS		128

   105 #define BN_BYTES	8

   106 #define BN_BITS2	64

   107 #define BN_BITS4	32

   108 #define BN_MASK		(0xffffffffffffffffffffffffffffffffLL)

   109 #define BN_MASK2	(0xffffffffffffffffL)

   110 #define BN_MASK2l	(0xffffffffL)

   111 #define BN_MASK2h	(0xffffffff00000000L)

   112 #define BN_MASK2h1	(0xffffffff80000000L)

   113 #define BN_TBIT		(0x8000000000000000L)

   114 #define BN_DEC_CONV	(10000000000000000000UL)

   115 #define BN_DEC_FMT1	"%lu"

   116 #define BN_DEC_FMT2	"%019lu"

   117 #define BN_DEC_NUM	19

   118 #endif

   119 

   120 /* This is where the long long data type is 64 bits, but long is 32.

   121  * For machines where there are 64bit registers, this is the mode to use.

   122  * IRIX, on R4000 and above should use this mode, along with the relevant

   123  * assembler code :-).  Do NOT define BN_LLONG.

   124  */

   125 #ifdef SIXTY_FOUR_BIT

   126 #undef BN_LLONG

   127 #undef BN_ULLONG

   128 #define BN_ULONG	unsigned long long

   129 #define BN_LONG		long long

   130 #define BN_BITS		128

   131 #define BN_BYTES	8

   132 #define BN_BITS2	64

   133 #define BN_BITS4	32

   134 #define BN_MASK2	(0xffffffffffffffffLL)

   135 #define BN_MASK2l	(0xffffffffL)

   136 #define BN_MASK2h	(0xffffffff00000000LL)

   137 #define BN_MASK2h1	(0xffffffff80000000LL)

   138 #define BN_TBIT		(0x8000000000000000LL)

   139 #define BN_DEC_CONV	(10000000000000000000ULL)

   140 #define BN_DEC_FMT1	"%llu"

   141 #define BN_DEC_FMT2	"%019llu"

   142 #define BN_DEC_NUM	19

   143 #endif

   144 

   145 #ifdef THIRTY_TWO_BIT

   146 #if defined(OPENSSL_SYS_WIN32) && !defined(__GNUC__)

   147 #define BN_ULLONG	unsigned _int64

   148 #else

   149 #define BN_ULLONG	unsigned long long

   150 #endif

   151 #define BN_ULONG	unsigned long

   152 #define BN_LONG		long

   153 #define BN_BITS		64

   154 #define BN_BYTES	4

   155 #define BN_BITS2	32

   156 #define BN_BITS4	16

   157 #ifdef OPENSSL_SYS_WIN32

   158 /* VC++ doesn't like the LL suffix */

   159 #define BN_MASK		(0xffffffffffffffffL)

   160 #else

   161 #define BN_MASK		(0xffffffffffffffffLL)

   162 #endif

   163 #define BN_MASK2	(0xffffffffL)

   164 #define BN_MASK2l	(0xffff)

   165 #define BN_MASK2h1	(0xffff8000L)

   166 #define BN_MASK2h	(0xffff0000L)

   167 #define BN_TBIT		(0x80000000L)

   168 #define BN_DEC_CONV	(1000000000L)

   169 #define BN_DEC_FMT1	"%lu"

   170 #define BN_DEC_FMT2	"%09lu"

   171 #define BN_DEC_NUM	9

   172 #endif

   173 

   174 #ifdef SIXTEEN_BIT

   175 #ifndef BN_DIV2W

   176 #define BN_DIV2W

   177 #endif

   178 #define BN_ULLONG	unsigned long

   179 #define BN_ULONG	unsigned short

   180 #define BN_LONG		short

   181 #define BN_BITS		32

   182 #define BN_BYTES	2

   183 #define BN_BITS2	16

   184 #define BN_BITS4	8

   185 #define BN_MASK		(0xffffffff)

   186 #define BN_MASK2	(0xffff)

   187 #define BN_MASK2l	(0xff)

   188 #define BN_MASK2h1	(0xff80)

   189 #define BN_MASK2h	(0xff00)

   190 #define BN_TBIT		(0x8000)

   191 #define BN_DEC_CONV	(100000)

   192 #define BN_DEC_FMT1	"%u"

   193 #define BN_DEC_FMT2	"%05u"

   194 #define BN_DEC_NUM	5

   195 #endif

   196 

   197 #ifdef EIGHT_BIT

   198 #ifndef BN_DIV2W

   199 #define BN_DIV2W

   200 #endif

   201 #define BN_ULLONG	unsigned short

   202 #define BN_ULONG	unsigned char

   203 #define BN_LONG		char

   204 #define BN_BITS		16

   205 #define BN_BYTES	1

   206 #define BN_BITS2	8

   207 #define BN_BITS4	4

   208 #define BN_MASK		(0xffff)

   209 #define BN_MASK2	(0xff)

   210 #define BN_MASK2l	(0xf)

   211 #define BN_MASK2h1	(0xf8)

   212 #define BN_MASK2h	(0xf0)

   213 #define BN_TBIT		(0x80)

   214 #define BN_DEC_CONV	(100)

   215 #define BN_DEC_FMT1	"%u"

   216 #define BN_DEC_FMT2	"%02u"

   217 #define BN_DEC_NUM	2

   218 #endif

   219 

   220 #define BN_DEFAULT_BITS	1280

   221 

   222 #ifdef BIGNUM

   223 #undef BIGNUM

   224 #endif

   225 

   226 #define BN_FLG_MALLOCED		0x01

   227 #define BN_FLG_STATIC_DATA	0x02

   228 #define BN_FLG_FREE		0x8000	/* used for debuging */

   229 #define BN_set_flags(b,n)	((b)->flags|=(n))

   230 #define BN_get_flags(b,n)	((b)->flags&(n))

   231 

   232 typedef struct bignum_st

   233 	{

   234 	BN_ULONG *d;	/* Pointer to an array of 'BN_BITS2' bit chunks. */

   235 	int top;	/* Index of last used d +1. */

   236 	/* The next are internal book keeping for bn_expand. */

   237 	int dmax;	/* Size of the d array. */

   238 	int neg;	/* one if the number is negative */

   239 	int flags;

   240 	} BIGNUM;

   241 

   242 /* Used for temp variables (declaration hidden in bn_lcl.h) */

   243 typedef struct bignum_ctx BN_CTX;

   244 

   245 typedef struct bn_blinding_st

   246 	{

   247 	int init;

   248 	BIGNUM *A;

   249 	BIGNUM *Ai;

   250 	BIGNUM *mod; /* just a reference */

   251 	unsigned long thread_id; /* added in OpenSSL 0.9.6j and 0.9.7b;

   252 				  * used only by crypto/rsa/rsa_eay.c, rsa_lib.c */

   253 	} BN_BLINDING;

   254 

   255 /* Used for montgomery multiplication */

   256 typedef struct bn_mont_ctx_st

   257 	{

   258 	int ri;        /* number of bits in R */

   259 	BIGNUM RR;     /* used to convert to montgomery form */

   260 	BIGNUM N;      /* The modulus */

   261 	BIGNUM Ni;     /* R*(1/R mod N) - N*Ni = 1

   262 	                * (Ni is only stored for bignum algorithm) */

   263 	BN_ULONG n0;   /* least significant word of Ni */

   264 	int flags;

   265 	} BN_MONT_CTX;

   266 

   267 /* Used for reciprocal division/mod functions

   268  * It cannot be shared between threads

   269  */

   270 typedef struct bn_recp_ctx_st

   271 	{

   272 	BIGNUM N;	/* the divisor */

   273 	BIGNUM Nr;	/* the reciprocal */

   274 	int num_bits;

   275 	int shift;

   276 	int flags;

   277 	} BN_RECP_CTX;

   278 

   279 #define BN_prime_checks 0 /* default: select number of iterations

   280 			     based on the size of the number */

   281 

   282 /* number of Miller-Rabin iterations for an error rate  of less than 2^-80

   283  * for random 'b'-bit input, b >= 100 (taken from table 4.4 in the Handbook

   284  * of Applied Cryptography [Menezes, van Oorschot, Vanstone; CRC Press 1996];

   285  * original paper: Damgaard, Landrock, Pomerance: Average case error estimates

   286  * for the strong probable prime test. -- Math. Comp. 61 (1993) 177-194) */

   287 #define BN_prime_checks_for_size(b) ((b) >= 1300 ?  2 : \

   288                                 (b) >=  850 ?  3 : \

   289                                 (b) >=  650 ?  4 : \

   290                                 (b) >=  550 ?  5 : \

   291                                 (b) >=  450 ?  6 : \

   292                                 (b) >=  400 ?  7 : \

   293                                 (b) >=  350 ?  8 : \

   294                                 (b) >=  300 ?  9 : \

   295                                 (b) >=  250 ? 12 : \

   296                                 (b) >=  200 ? 15 : \

   297                                 (b) >=  150 ? 18 : \

   298                                 /* b >= 100 */ 27)

   299 

   300 #define BN_num_bytes(a)	((BN_num_bits(a)+7)/8)

   301 

   302 /* Note that BN_abs_is_word does not work reliably for w == 0 */

   303 #define BN_abs_is_word(a,w) (((a)->top == 1) && ((a)->d[0] == (BN_ULONG)(w)))

   304 #define BN_is_zero(a)       (((a)->top == 0) || BN_abs_is_word(a,0))

   305 #define BN_is_one(a)        (BN_abs_is_word((a),1) && !(a)->neg)

   306 #define BN_is_word(a,w)     ((w) ? BN_abs_is_word((a),(w)) && !(a)->neg : \

   307                                    BN_is_zero((a)))

   308 #define BN_is_odd(a)	    (((a)->top > 0) && ((a)->d[0] & 1))

   309 

   310 #define BN_one(a)	(BN_set_word((a),1))

   311 #define BN_zero(a)	(BN_set_word((a),0))

   312 

   313 /*#define BN_ascii2bn(a)	BN_hex2bn(a) */

   314 /*#define BN_bn2ascii(a)	BN_bn2hex(a) */

   315 

   316 const BIGNUM *BN_value_one(void);

   317 char *	BN_options(void);

   318 BN_CTX *BN_CTX_new(void);

   319 void	BN_CTX_init(BN_CTX *c);

   320 void	BN_CTX_free(BN_CTX *c);

   321 void	BN_CTX_start(BN_CTX *ctx);

   322 BIGNUM *BN_CTX_get(BN_CTX *ctx);

   323 void	BN_CTX_end(BN_CTX *ctx);

   324 int     BN_rand(BIGNUM *rnd, int bits, int top,int bottom);

   325 int     BN_pseudo_rand(BIGNUM *rnd, int bits, int top,int bottom);

   326 int	BN_rand_range(BIGNUM *rnd, BIGNUM *range);

   327 int	BN_pseudo_rand_range(BIGNUM *rnd, BIGNUM *range);

   328 int	BN_num_bits(const BIGNUM *a);

   329 int	BN_num_bits_word(BN_ULONG);

   330 BIGNUM *BN_new(void);

   331 void	BN_init(BIGNUM *);

   332 void	BN_clear_free(BIGNUM *a);

   333 BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);

   334 void	BN_swap(BIGNUM *a, BIGNUM *b);

   335 BIGNUM *BN_bin2bn(const unsigned char *s,int len,BIGNUM *ret);

   336 int	BN_bn2bin(const BIGNUM *a, unsigned char *to);

   337 BIGNUM *BN_mpi2bn(const unsigned char *s,int len,BIGNUM *ret);

   338 int	BN_bn2mpi(const BIGNUM *a, unsigned char *to);

   339 int	BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);

   340 int	BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);

   341 int	BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);

   342 int	BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);

   343 int	BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);

   344 int	BN_sqr(BIGNUM *r, const BIGNUM *a,BN_CTX *ctx);

   345 

   346 int	BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,

   347 	BN_CTX *ctx);

   348 #define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx))

   349 int	BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);

   350 int	BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx);

   351 int	BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m);

   352 int	BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx);

   353 int	BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m);

   354 int	BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,

   355 	const BIGNUM *m, BN_CTX *ctx);

   356 int	BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);

   357 int	BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);

   358 int	BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);

   359 int	BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m, BN_CTX *ctx);

   360 int	BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);

   361 

   362 BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);

   363 BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);

   364 int	BN_mul_word(BIGNUM *a, BN_ULONG w);

   365 int	BN_add_word(BIGNUM *a, BN_ULONG w);

   366 int	BN_sub_word(BIGNUM *a, BN_ULONG w);

   367 int	BN_set_word(BIGNUM *a, BN_ULONG w);

   368 BN_ULONG BN_get_word(const BIGNUM *a);

   369 

   370 int	BN_cmp(const BIGNUM *a, const BIGNUM *b);

   371 void	BN_free(BIGNUM *a);

   372 int	BN_is_bit_set(const BIGNUM *a, int n);

   373 int	BN_lshift(BIGNUM *r, const BIGNUM *a, int n);

   374 int	BN_lshift1(BIGNUM *r, const BIGNUM *a);

   375 int	BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,BN_CTX *ctx);

   376 

   377 int	BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,

   378 	const BIGNUM *m,BN_CTX *ctx);

   379 int	BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,

   380 	const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);

   381 int	BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p,

   382 	const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);

   383 int	BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,

   384 	const BIGNUM *a2, const BIGNUM *p2,const BIGNUM *m,

   385 	BN_CTX *ctx,BN_MONT_CTX *m_ctx);

   386 int	BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,

   387 	const BIGNUM *m,BN_CTX *ctx);

   388 

   389 int	BN_mask_bits(BIGNUM *a,int n);

   390 #ifndef OPENSSL_NO_FP_API

   391 int	BN_print_fp(FILE *fp, const BIGNUM *a);

   392 #endif

   393 #ifdef HEADER_BIO_H

   394 int	BN_print(BIO *fp, const BIGNUM *a);

   395 #else

   396 int	BN_print(void *fp, const BIGNUM *a);

   397 #endif

   398 int	BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);

   399 int	BN_rshift(BIGNUM *r, const BIGNUM *a, int n);

   400 int	BN_rshift1(BIGNUM *r, const BIGNUM *a);

   401 void	BN_clear(BIGNUM *a);

   402 BIGNUM *BN_dup(const BIGNUM *a);

   403 int	BN_ucmp(const BIGNUM *a, const BIGNUM *b);

   404 int	BN_set_bit(BIGNUM *a, int n);

   405 int	BN_clear_bit(BIGNUM *a, int n);

   406 char *	BN_bn2hex(const BIGNUM *a);

   407 char *	BN_bn2dec(const BIGNUM *a);

   408 int 	BN_hex2bn(BIGNUM **a, const char *str);

   409 int 	BN_dec2bn(BIGNUM **a, const char *str);

   410 int	BN_gcd(BIGNUM *r,const BIGNUM *a,const BIGNUM *b,BN_CTX *ctx);

   411 int	BN_kronecker(const BIGNUM *a,const BIGNUM *b,BN_CTX *ctx); /* returns -2 for error */

   412 BIGNUM *BN_mod_inverse(BIGNUM *ret,

   413 	const BIGNUM *a, const BIGNUM *n,BN_CTX *ctx);

   414 BIGNUM *BN_mod_sqrt(BIGNUM *ret,

   415 	const BIGNUM *a, const BIGNUM *n,BN_CTX *ctx);

   416 BIGNUM *BN_generate_prime(BIGNUM *ret,int bits,int safe,

   417 	const BIGNUM *add, const BIGNUM *rem,

   418 	void (*callback)(int,int,void *),void *cb_arg);

   419 int	BN_is_prime(const BIGNUM *p,int nchecks,

   420 	void (*callback)(int,int,void *),

   421 	BN_CTX *ctx,void *cb_arg);

   422 int	BN_is_prime_fasttest(const BIGNUM *p,int nchecks,

   423 	void (*callback)(int,int,void *),BN_CTX *ctx,void *cb_arg,

   424 	int do_trial_division);

   425 

   426 BN_MONT_CTX *BN_MONT_CTX_new(void );

   427 void BN_MONT_CTX_init(BN_MONT_CTX *ctx);

   428 int BN_mod_mul_montgomery(BIGNUM *r,const BIGNUM *a,const BIGNUM *b,

   429 	BN_MONT_CTX *mont, BN_CTX *ctx);

   430 #define BN_to_montgomery(r,a,mont,ctx)	BN_mod_mul_montgomery(\

   431 	(r),(a),&((mont)->RR),(mont),(ctx))

   432 int BN_from_montgomery(BIGNUM *r,const BIGNUM *a,

   433 	BN_MONT_CTX *mont, BN_CTX *ctx);

   434 void BN_MONT_CTX_free(BN_MONT_CTX *mont);

   435 int BN_MONT_CTX_set(BN_MONT_CTX *mont,const BIGNUM *mod,BN_CTX *ctx);

   436 BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to,BN_MONT_CTX *from);

   437 

   438 BN_BLINDING *BN_BLINDING_new(BIGNUM *A,BIGNUM *Ai,BIGNUM *mod);

   439 void BN_BLINDING_free(BN_BLINDING *b);

   440 int BN_BLINDING_update(BN_BLINDING *b,BN_CTX *ctx);

   441 int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *r, BN_CTX *ctx);

   442 int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);

   443 

   444 void BN_set_params(int mul,int high,int low,int mont);

   445 int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */

   446 

   447 void	BN_RECP_CTX_init(BN_RECP_CTX *recp);

   448 BN_RECP_CTX *BN_RECP_CTX_new(void);

   449 void	BN_RECP_CTX_free(BN_RECP_CTX *recp);

   450 int	BN_RECP_CTX_set(BN_RECP_CTX *recp,const BIGNUM *rdiv,BN_CTX *ctx);

   451 int	BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,

   452 	BN_RECP_CTX *recp,BN_CTX *ctx);

   453 int	BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,

   454 	const BIGNUM *m, BN_CTX *ctx);

   455 int	BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,

   456 	BN_RECP_CTX *recp, BN_CTX *ctx);

   457 

   458 /* library internal functions */

   459 

   460 #define bn_expand(a,bits) ((((((bits+BN_BITS2-1))/BN_BITS2)) <= (a)->dmax)?\

   461 	(a):bn_expand2((a),(bits)/BN_BITS2+1))

   462 #define bn_wexpand(a,words) (((words) <= (a)->dmax)?(a):bn_expand2((a),(words)))

   463 BIGNUM *bn_expand2(BIGNUM *a, int words);

   464 BIGNUM *bn_dup_expand(const BIGNUM *a, int words);

   465 

   466 #define bn_fix_top(a) \

   467         { \

   468         BN_ULONG *ftl; \

   469 	if ((a)->top > 0) \

   470 		{ \

   471 		for (ftl= &((a)->d[(a)->top-1]); (a)->top > 0; (a)->top--) \

   472 		if (*(ftl--)) break; \

   473 		} \

   474 	}

   475 

   476 BN_ULONG bn_mul_add_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w);

   477 BN_ULONG bn_mul_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w);

   478 void     bn_sqr_words(BN_ULONG *rp, const BN_ULONG *ap, int num);

   479 BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d);

   480 BN_ULONG bn_add_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,int num);

   481 BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,int num);

   482 

   483 #ifdef BN_DEBUG

   484 void bn_dump1(FILE *o, const char *a, const BN_ULONG *b,int n);

   485 # define bn_print(a) {fprintf(stderr, #a "="); BN_print_fp(stderr,a); \

   486    fprintf(stderr,"\n");}

   487 # define bn_dump(a,n) bn_dump1(stderr,#a,a,n);

   488 #else

   489 # define bn_print(a)

   490 # define bn_dump(a,b)

   491 #endif

   492 

   493 int BN_bntest_rand(BIGNUM *rnd, int bits, int top,int bottom);

   494 

   495 /* BEGIN ERROR CODES */

   496 /* The following lines are auto generated by the script mkerr.pl. Any changes

   497  * made after this point may be overwritten when the script is next run.

   498  */

   499 void ERR_load_BN_strings(void);

   500 

   501 /* Error codes for the BN functions. */

   502 

   503 /* Function codes. */

   504 #define BN_F_BN_BLINDING_CONVERT			 100

   505 #define BN_F_BN_BLINDING_INVERT				 101

   506 #define BN_F_BN_BLINDING_NEW				 102

   507 #define BN_F_BN_BLINDING_UPDATE				 103

   508 #define BN_F_BN_BN2DEC					 104

   509 #define BN_F_BN_BN2HEX					 105

   510 #define BN_F_BN_CTX_GET					 116

   511 #define BN_F_BN_CTX_NEW					 106

   512 #define BN_F_BN_DIV					 107

   513 #define BN_F_BN_EXPAND2					 108

   514 #define BN_F_BN_EXPAND_INTERNAL				 120

   515 #define BN_F_BN_MOD_EXP2_MONT				 118

   516 #define BN_F_BN_MOD_EXP_MONT				 109

   517 #define BN_F_BN_MOD_EXP_MONT_WORD			 117

   518 #define BN_F_BN_MOD_INVERSE				 110

   519 #define BN_F_BN_MOD_LSHIFT_QUICK			 119

   520 #define BN_F_BN_MOD_MUL_RECIPROCAL			 111

   521 #define BN_F_BN_MOD_SQRT				 121

   522 #define BN_F_BN_MPI2BN					 112

   523 #define BN_F_BN_NEW					 113

   524 #define BN_F_BN_RAND					 114

   525 #define BN_F_BN_RAND_RANGE				 122

   526 #define BN_F_BN_USUB					 115

   527 

   528 /* Reason codes. */

   529 #define BN_R_ARG2_LT_ARG3				 100

   530 #define BN_R_BAD_RECIPROCAL				 101

   531 #define BN_R_BIGNUM_TOO_LONG				 114

   532 #define BN_R_CALLED_WITH_EVEN_MODULUS			 102

   533 #define BN_R_DIV_BY_ZERO				 103

   534 #define BN_R_ENCODING_ERROR				 104

   535 #define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA		 105

   536 #define BN_R_INPUT_NOT_REDUCED				 110

   537 #define BN_R_INVALID_LENGTH				 106

   538 #define BN_R_INVALID_RANGE				 115

   539 #define BN_R_NOT_A_SQUARE				 111

   540 #define BN_R_NOT_INITIALIZED				 107

   541 #define BN_R_NO_INVERSE					 108

   542 #define BN_R_P_IS_NOT_PRIME				 112

   543 #define BN_R_TOO_MANY_ITERATIONS			 113

   544 #define BN_R_TOO_MANY_TEMPORARY_VARIABLES		 109

   545 

   546 #ifdef  __cplusplus

   547 }

   548 #endif

   549 #endif

   550