]>
Commit | Line | Data |
---|---|---|
d02b48c6 RE |
1 | /* crypto/bn/bn.org */ |
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 | /* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING | |
60 | * | |
61 | * Always modify bn.org since bn.h is automatically generated from | |
62 | * it during SSLeay configuration. | |
63 | * | |
64 | * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING | |
65 | */ | |
66 | ||
67 | #ifndef HEADER_BN_H | |
68 | #define HEADER_BN_H | |
69 | ||
70 | #ifdef __cplusplus | |
71 | extern "C" { | |
72 | #endif | |
73 | ||
74 | #undef BN_LLONG | |
75 | ||
76 | #ifdef WIN32 | |
77 | #define BN_LLONG /* This comment stops Configure mutilating things */ | |
78 | #endif | |
79 | ||
80 | #define RECP_MUL_MOD | |
81 | #define MONT_MUL_MOD | |
82 | ||
83 | /* This next option uses the C libraries (2 word)/(1 word) function. | |
84 | * If it is not defined, I use my C version (which is slower). | |
85 | * The reason for this flag is that when the particular C compiler | |
86 | * library routine is used, and the library is linked with a different | |
87 | * compiler, the library is missing. This mostly happens when the | |
88 | * library is built with gcc and then linked using nornal cc. This would | |
89 | * be a common occurance because gcc normally produces code that is | |
90 | * 2 times faster than system compilers for the big number stuff. | |
91 | * For machines with only one compiler (or shared libraries), this should | |
92 | * be on. Again this in only really a problem on machines | |
93 | * using "long long's", are 32bit, and are not using my assember code. */ | |
94 | #if defined(MSDOS) || defined(WINDOWS) || defined(linux) | |
95 | #define BN_DIV2W | |
96 | #endif | |
97 | ||
98 | /* Only one for the following should be defined */ | |
99 | /* The prime number generation stuff may not work when | |
100 | * EIGHT_BIT but I don't care since I've only used this mode | |
101 | * for debuging the bignum libraries */ | |
102 | #undef SIXTY_FOUR_BIT_LONG | |
103 | #undef SIXTY_FOUR_BIT | |
104 | #define THIRTY_TWO_BIT | |
105 | #undef SIXTEEN_BIT | |
106 | #undef EIGHT_BIT | |
107 | ||
108 | /* assuming long is 64bit - this is the DEC Alpha | |
109 | * unsigned long long is only 64 bits :-(, don't define | |
110 | * BN_LLONG for the DEC Alpha */ | |
111 | #ifdef SIXTY_FOUR_BIT_LONG | |
112 | #define BN_ULLONG unsigned long long | |
113 | #define BN_ULONG unsigned long | |
114 | #define BN_LONG long | |
115 | #define BN_BITS 128 | |
116 | #define BN_BYTES 8 | |
117 | #define BN_BITS2 64 | |
118 | #define BN_BITS4 32 | |
119 | #define BN_MASK2 (0xffffffffffffffffL) | |
120 | #define BN_MASK2l (0xffffffffL) | |
121 | #define BN_MASK2h (0xffffffff00000000L) | |
122 | #define BN_MASK2h1 (0xffffffff80000000L) | |
123 | #define BN_TBIT (0x8000000000000000L) | |
124 | #endif | |
125 | ||
126 | #ifdef SIXTY_FOUR_BIT | |
127 | #undef BN_LLONG | |
128 | /* #define BN_ULLONG unsigned long long */ | |
129 | #define BN_ULONG unsigned long long | |
130 | #define BN_LONG long long | |
131 | #define BN_BITS 128 | |
132 | #define BN_BYTES 8 | |
133 | #define BN_BITS2 64 | |
134 | #define BN_BITS4 32 | |
135 | #define BN_MASK2 (0xffffffffffffffffLL) | |
136 | #define BN_MASK2l (0xffffffffL) | |
137 | #define BN_MASK2h (0xffffffff00000000LL) | |
138 | #define BN_MASK2h1 (0xffffffff80000000LL) | |
139 | #define BN_TBIT (0x8000000000000000LL) | |
140 | #endif | |
141 | ||
142 | #ifdef THIRTY_TWO_BIT | |
143 | #ifdef WIN32 | |
144 | #define BN_ULLONG unsigned _int64 | |
145 | #else | |
146 | #define BN_ULLONG unsigned long long | |
147 | #endif | |
148 | #define BN_ULONG unsigned long | |
149 | #define BN_LONG long | |
150 | #define BN_BITS 64 | |
151 | #define BN_BYTES 4 | |
152 | #define BN_BITS2 32 | |
153 | #define BN_BITS4 16 | |
154 | #define BN_MASK2 (0xffffffffL) | |
155 | #define BN_MASK2l (0xffff) | |
156 | #define BN_MASK2h1 (0xffff8000L) | |
157 | #define BN_MASK2h (0xffff0000L) | |
158 | #define BN_TBIT (0x80000000L) | |
159 | #endif | |
160 | ||
161 | #ifdef SIXTEEN_BIT | |
162 | #ifndef BN_DIV2W | |
163 | #define BN_DIV2W | |
164 | #endif | |
165 | #define BN_ULLONG unsigned long | |
166 | #define BN_ULONG unsigned short | |
167 | #define BN_LONG short | |
168 | #define BN_BITS 32 | |
169 | #define BN_BYTES 2 | |
170 | #define BN_BITS2 16 | |
171 | #define BN_BITS4 8 | |
172 | #define BN_MASK2 (0xffff) | |
173 | #define BN_MASK2l (0xff) | |
174 | #define BN_MASK2h1 (0xff80) | |
175 | #define BN_MASK2h (0xff00) | |
176 | #define BN_TBIT (0x8000) | |
177 | #endif | |
178 | ||
179 | #ifdef EIGHT_BIT | |
180 | #ifndef BN_DIV2W | |
181 | #define BN_DIV2W | |
182 | #endif | |
183 | #define BN_ULLONG unsigned short | |
184 | #define BN_ULONG unsigned char | |
185 | #define BN_LONG char | |
186 | #define BN_BITS 16 | |
187 | #define BN_BYTES 1 | |
188 | #define BN_BITS2 8 | |
189 | #define BN_BITS4 4 | |
190 | #define BN_MASK2 (0xff) | |
191 | #define BN_MASK2l (0xf) | |
192 | #define BN_MASK2h1 (0xf8) | |
193 | #define BN_MASK2h (0xf0) | |
194 | #define BN_TBIT (0x80) | |
195 | #endif | |
196 | ||
197 | #define BN_DEFAULT_BITS 1280 | |
198 | ||
199 | #ifdef BIGNUM | |
200 | #undef BIGNUM | |
201 | #endif | |
202 | ||
203 | typedef struct bignum_st | |
204 | { | |
205 | BN_ULONG *d; /* Pointer to an array of 'BN_BITS2' bit chunks. */ | |
206 | int top; /* Index of last used d +1. */ | |
207 | /* The next are internal book keeping for bn_expand. */ | |
208 | int max; /* Size of the d array. */ | |
209 | int neg; /* one if the number is negative */ | |
210 | } BIGNUM; | |
211 | ||
212 | /* Used for temp variables */ | |
213 | #define BN_CTX_NUM 12 | |
214 | typedef struct bignum_ctx | |
215 | { | |
216 | int tos; | |
217 | BIGNUM *bn[BN_CTX_NUM+1]; | |
218 | } BN_CTX; | |
219 | ||
220 | /* Used for montgomery multiplication */ | |
221 | typedef struct bn_mont_ctx_st | |
222 | { | |
223 | int ri; /* number of bits in R */ | |
224 | BIGNUM *RR; /* used to convert to montgomery form */ | |
225 | BIGNUM *N; /* The modulus */ | |
226 | BIGNUM *Ni; /* The inverse of N */ | |
227 | BN_ULONG n0; /* word form of inverse, normally only one of | |
228 | * Ni or n0 is defined */ | |
229 | } BN_MONT_CTX; | |
230 | ||
231 | #define BN_to_montgomery(r,a,mont,ctx) BN_mod_mul_montgomery(\ | |
232 | r,a,(mont)->RR,(mont),ctx) | |
233 | ||
234 | #define BN_prime_checks (5) | |
235 | ||
236 | #define BN_num_bytes(a) ((BN_num_bits(a)+7)/8) | |
237 | #define BN_is_word(a,w) (((a)->top == 1) && ((a)->d[0] == (BN_ULONG)(w))) | |
238 | #define BN_is_zero(a) (((a)->top <= 1) && ((a)->d[0] == (BN_ULONG)0)) | |
239 | #define BN_is_one(a) (BN_is_word((a),1)) | |
240 | #define BN_is_odd(a) ((a)->d[0] & 1) | |
241 | #define BN_one(a) (BN_set_word((a),1)) | |
242 | #define BN_zero(a) (BN_set_word((a),0)) | |
243 | ||
244 | #define bn_fix_top(a) \ | |
245 | { \ | |
246 | BN_ULONG *fix_top_l; \ | |
247 | for (fix_top_l= &((a)->d[(a)->top-1]); (a)->top > 0; (a)->top--) \ | |
248 | if (*(fix_top_l--)) break; \ | |
249 | } | |
250 | ||
251 | #define bn_expand(n,b) ((((b)/BN_BITS2) <= (n)->max)?(n):bn_expand2((n),(b))) | |
252 | ||
253 | ||
254 | #ifndef NOPROTO | |
255 | BIGNUM *BN_value_one(void); | |
256 | char * BN_options(void); | |
257 | BN_CTX *BN_CTX_new(void); | |
258 | void BN_CTX_free(BN_CTX *c); | |
259 | int BN_rand(BIGNUM *rnd, int bits, int top,int bottom); | |
260 | int BN_num_bits(BIGNUM *a); | |
261 | int BN_num_bits_word(BN_ULONG); | |
262 | BIGNUM *BN_new(void); | |
263 | void BN_clear_free(BIGNUM *a); | |
264 | BIGNUM *BN_copy(BIGNUM *a, BIGNUM *b); | |
265 | BIGNUM *BN_bin2bn(unsigned char *s,int len,BIGNUM *ret); | |
266 | int BN_bn2bin(BIGNUM *a, unsigned char *to); | |
267 | int BN_sub(BIGNUM *r, BIGNUM *a, BIGNUM *b); | |
268 | void bn_qsub(BIGNUM *r, BIGNUM *a, BIGNUM *b); | |
269 | void bn_qadd(BIGNUM *r, BIGNUM *a, BIGNUM *b); | |
270 | int BN_add(BIGNUM *r, BIGNUM *a, BIGNUM *b); | |
271 | int BN_mod(BIGNUM *rem, BIGNUM *m, BIGNUM *d, BN_CTX *ctx); | |
272 | int BN_div(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BIGNUM *d, BN_CTX *ctx); | |
273 | int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b); | |
274 | int BN_sqr(BIGNUM *r, BIGNUM *a,BN_CTX *ctx); | |
275 | BN_ULONG BN_mod_word(BIGNUM *a, unsigned long w); | |
276 | BN_ULONG BN_div_word(BIGNUM *a, unsigned long w); | |
277 | int BN_add_word(BIGNUM *a, unsigned long w); | |
278 | int BN_set_word(BIGNUM *a, unsigned long w); | |
279 | unsigned long BN_get_word(BIGNUM *a); | |
280 | int BN_cmp(BIGNUM *a, BIGNUM *b); | |
281 | void BN_free(BIGNUM *a); | |
282 | int BN_is_bit_set(BIGNUM *a, int n); | |
283 | int BN_lshift(BIGNUM *r, BIGNUM *a, int n); | |
284 | int BN_lshift1(BIGNUM *r, BIGNUM *a); | |
285 | int BN_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,BN_CTX *ctx); | |
286 | int BN_mod_exp_mont(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,BN_CTX *ctx); | |
287 | int BN_mod_exp_recp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,BN_CTX *ctx); | |
288 | int BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p, | |
289 | BIGNUM *m,BN_CTX *ctx); | |
290 | int BN_mask_bits(BIGNUM *a,int n); | |
291 | int BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *x, BIGNUM *y, BIGNUM *m, | |
292 | BIGNUM *i, int nb, BN_CTX *ctx); | |
293 | int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, BIGNUM *m, | |
294 | BN_CTX *ctx); | |
295 | #ifndef WIN16 | |
296 | int BN_print_fp(FILE *fp, BIGNUM *a); | |
297 | #endif | |
298 | #ifdef HEADER_BIO_H | |
299 | int BN_print(BIO *fp, BIGNUM *a); | |
300 | #else | |
301 | int BN_print(char *fp, BIGNUM *a); | |
302 | #endif | |
303 | int BN_reciprocal(BIGNUM *r, BIGNUM *m, BN_CTX *ctx); | |
304 | int BN_rshift(BIGNUM *r, BIGNUM *a, int n); | |
305 | int BN_rshift1(BIGNUM *r, BIGNUM *a); | |
306 | void BN_clear(BIGNUM *a); | |
307 | BIGNUM *bn_expand2(BIGNUM *b, int bits); | |
308 | BIGNUM *BN_dup(BIGNUM *a); | |
309 | int BN_ucmp(BIGNUM *a, BIGNUM *b); | |
310 | int BN_set_bit(BIGNUM *a, int n); | |
311 | int BN_clear_bit(BIGNUM *a, int n); | |
312 | char * BN_bn2ascii(BIGNUM *a); | |
313 | int BN_ascii2bn(BIGNUM **a,char *str); | |
314 | int BN_gcd(BIGNUM *r,BIGNUM *in_a,BIGNUM *in_b,BN_CTX *ctx); | |
315 | BIGNUM *BN_mod_inverse(BIGNUM *a, BIGNUM *n,BN_CTX *ctx); | |
316 | BIGNUM *BN_generate_prime(int bits,int strong,BIGNUM *add, | |
317 | BIGNUM *rem,void (*callback)(int,int)); | |
318 | int BN_is_prime(BIGNUM *p,int nchecks,void (*callback)(int,int), | |
319 | BN_CTX *ctx); | |
320 | void ERR_load_BN_strings(void ); | |
321 | ||
322 | BN_ULONG bn_mul_add_word(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w); | |
323 | BN_ULONG bn_mul_word(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w); | |
324 | void bn_sqr_words(BN_ULONG *rp, BN_ULONG *ap, int num); | |
325 | BN_ULONG bn_div64(BN_ULONG h, BN_ULONG l, BN_ULONG d); | |
326 | ||
327 | BN_MONT_CTX *BN_MONT_CTX_new(void ); | |
328 | int BN_mod_mul_montgomery(BIGNUM *r,BIGNUM *a,BIGNUM *b,BN_MONT_CTX *mont, | |
329 | BN_CTX *ctx); | |
330 | int BN_from_montgomery(BIGNUM *r,BIGNUM *a,BN_MONT_CTX *mont,BN_CTX *ctx); | |
331 | void BN_MONT_CTX_free(BN_MONT_CTX *mont); | |
332 | int BN_MONT_CTX_set(BN_MONT_CTX *mont,BIGNUM *modulus,BN_CTX *ctx); | |
333 | ||
334 | #else | |
335 | ||
336 | BIGNUM *BN_value_one(); | |
337 | char * BN_options(); | |
338 | BN_CTX *BN_CTX_new(); | |
339 | void BN_CTX_free(); | |
340 | int BN_rand(); | |
341 | int BN_num_bits(); | |
342 | int BN_num_bits_word(); | |
343 | BIGNUM *BN_new(); | |
344 | void BN_clear_free(); | |
345 | BIGNUM *BN_copy(); | |
346 | BIGNUM *BN_bin2bn(); | |
347 | int BN_bn2bin(); | |
348 | int BN_sub(); | |
349 | void bn_qsub(); | |
350 | void bn_qadd(); | |
351 | int BN_add(); | |
352 | int BN_mod(); | |
353 | int BN_div(); | |
354 | int BN_mul(); | |
355 | int BN_sqr(); | |
356 | BN_ULONG BN_mod_word(); | |
357 | BN_ULONG BN_div_word(); | |
358 | int BN_add_word(); | |
359 | int BN_set_word(); | |
360 | unsigned long BN_get_word(); | |
361 | int BN_cmp(); | |
362 | void BN_free(); | |
363 | int BN_is_bit_set(); | |
364 | int BN_lshift(); | |
365 | int BN_lshift1(); | |
366 | int BN_mod_exp(); | |
367 | int BN_mod_exp_mont(); | |
368 | int BN_mod_exp_recp(); | |
369 | int BN_mod_exp_simple(); | |
370 | int BN_mask_bits(); | |
371 | int BN_mod_mul_reciprocal(); | |
372 | int BN_mod_mul(); | |
373 | #ifndef WIN16 | |
374 | int BN_print_fp(); | |
375 | #endif | |
376 | int BN_print(); | |
377 | int BN_reciprocal(); | |
378 | int BN_rshift(); | |
379 | int BN_rshift1(); | |
380 | void BN_clear(); | |
381 | BIGNUM *bn_expand2(); | |
382 | BIGNUM *BN_dup(); | |
383 | int BN_ucmp(); | |
384 | int BN_set_bit(); | |
385 | int BN_clear_bit(); | |
386 | char * BN_bn2ascii(); | |
387 | int BN_ascii2bn(); | |
388 | int BN_gcd(); | |
389 | BIGNUM *BN_mod_inverse(); | |
390 | BIGNUM *BN_generate_prime(); | |
391 | int BN_is_prime(); | |
392 | void ERR_load_BN_strings(); | |
393 | ||
394 | BN_ULONG bn_mul_add_word(); | |
395 | BN_ULONG bn_mul_word(); | |
396 | void bn_sqr_words(); | |
397 | BN_ULONG bn_div64(); | |
398 | ||
399 | int BN_mod_mul_montgomery(); | |
400 | int BN_from_montgomery(); | |
401 | BN_MONT_CTX *BN_MONT_CTX_new(); | |
402 | void BN_MONT_CTX_free(); | |
403 | int BN_MONT_CTX_set(); | |
404 | ||
405 | #endif | |
406 | ||
407 | /* BEGIN ERROR CODES */ | |
408 | /* Error codes for the BN functions. */ | |
409 | ||
410 | /* Function codes. */ | |
411 | #define BN_F_BN_BL_CTX_INIT 100 | |
412 | #define BN_F_BN_BL_CTX_NEW 101 | |
413 | #define BN_F_BN_BN2ASCII 102 | |
414 | #define BN_F_BN_CTX_NEW 103 | |
415 | #define BN_F_BN_DIV 104 | |
416 | #define BN_F_BN_EXPAND2 105 | |
417 | #define BN_F_BN_MOD_EXP_MONT 106 | |
418 | #define BN_F_BN_MOD_INVERSE 107 | |
419 | #define BN_F_BN_MOD_MUL_RECIPROCAL 108 | |
420 | #define BN_F_BN_NEW 109 | |
421 | #define BN_F_BN_RAND 110 | |
422 | ||
423 | /* Reason codes. */ | |
424 | #define BN_R_BAD_RECIPROCAL 100 | |
425 | #define BN_R_CALLED_WITH_EVEN_MODULUS 101 | |
426 | #define BN_R_DIV_BY_ZERO 102 | |
427 | #define BN_R_NO_INVERSE 103 | |
428 | ||
429 | #ifdef __cplusplus | |
430 | } | |
431 | #endif | |
432 | #endif | |
433 |