|
1 /* crypto/bn/exptest.c */ |
|
2 /* Copyright (C) 1995-1998 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 © Portions copyright (c) 2006 Nokia Corporation. All rights reserved. |
|
60 */ |
|
61 #include <stdio.h> |
|
62 #include <stdlib.h> |
|
63 #include <string.h> |
|
64 #ifndef SYMBIAN |
|
65 #include "../e_os.h" |
|
66 #else |
|
67 #include "e_os.h" |
|
68 #endif |
|
69 |
|
70 #include <openssl/bio.h> |
|
71 #include <openssl/bn.h> |
|
72 #include <openssl/rand.h> |
|
73 #include <openssl/err.h> |
|
74 #ifdef SYMBIAN |
|
75 #ifdef stdin |
|
76 #undef stdin |
|
77 #endif |
|
78 #ifdef stdout |
|
79 #undef stdout |
|
80 #endif |
|
81 #ifdef stderr |
|
82 #undef stderr |
|
83 #endif |
|
84 |
|
85 #define stdin fp_stdin |
|
86 #define stdout fp_stdout |
|
87 #define stderr fp_stderr |
|
88 |
|
89 extern FILE *fp_stdout; |
|
90 extern FILE *fp_stderr; |
|
91 #endif |
|
92 |
|
93 |
|
94 #define NUM_BITS (BN_BITS*2) |
|
95 |
|
96 static const char rnd_seed[] = "string to make the random number generator think it has entropy"; |
|
97 #ifndef SYMBIAN |
|
98 int main(int argc, char *argv[]) |
|
99 #else |
|
100 int exp_main(int argc, char *argv[]) |
|
101 #endif |
|
102 { |
|
103 BN_CTX *ctx; |
|
104 BIO *out=NULL; |
|
105 int i,ret; |
|
106 unsigned char c; |
|
107 BIGNUM *r_mont,*r_mont_const,*r_recp,*r_simple,*a,*b,*m; |
|
108 |
|
109 |
|
110 RAND_seed(rnd_seed, sizeof rnd_seed); /* or BN_rand may fail, and we don't |
|
111 * even check its return value |
|
112 * (which we should) */ |
|
113 if(errno==ENOMEM) |
|
114 { |
|
115 return 1; |
|
116 } |
|
117 |
|
118 ERR_load_BN_strings(); |
|
119 if(errno==ENOMEM) |
|
120 { |
|
121 return 1; |
|
122 } |
|
123 |
|
124 ctx=BN_CTX_new(); |
|
125 if (ctx == NULL) |
|
126 { |
|
127 if(errno==ENOMEM) |
|
128 { |
|
129 return 1; |
|
130 } |
|
131 return 1; |
|
132 } |
|
133 r_mont=BN_new(); |
|
134 if(r_mont==NULL&&errno==ENOMEM) |
|
135 { |
|
136 return 1; |
|
137 } |
|
138 r_mont_const=BN_new(); |
|
139 if(r_mont_const==NULL&&errno==ENOMEM) |
|
140 { |
|
141 return 1; |
|
142 } |
|
143 |
|
144 r_recp=BN_new(); |
|
145 if(r_recp==NULL&&errno==ENOMEM) |
|
146 { |
|
147 return 1; |
|
148 } |
|
149 |
|
150 r_simple=BN_new(); |
|
151 if(r_simple==NULL&&errno==ENOMEM) |
|
152 { |
|
153 return 1; |
|
154 } |
|
155 |
|
156 a=BN_new(); |
|
157 if(a==NULL&&errno==ENOMEM) |
|
158 { |
|
159 return 1; |
|
160 } |
|
161 |
|
162 b=BN_new(); |
|
163 if(b==NULL&&errno==ENOMEM) |
|
164 { |
|
165 return 1; |
|
166 } |
|
167 |
|
168 m=BN_new(); |
|
169 if(m==NULL&&errno==ENOMEM) |
|
170 { |
|
171 return 1; |
|
172 } |
|
173 |
|
174 if ( (r_mont == NULL) || (r_recp == NULL) || |
|
175 (a == NULL) || (b == NULL)) |
|
176 goto err; |
|
177 |
|
178 out=BIO_new(BIO_s_file()); |
|
179 if(out==NULL&&errno==ENOMEM) |
|
180 { |
|
181 return 1; |
|
182 } |
|
183 if (out == NULL) |
|
184 return 1; |
|
185 BIO_set_fp(out,stdout,BIO_NOCLOSE); |
|
186 if(errno==ENOMEM) |
|
187 { |
|
188 return 1; |
|
189 } |
|
190 |
|
191 for (i=0; i<200; i++) |
|
192 { |
|
193 RAND_bytes(&c,1); |
|
194 if(errno==ENOMEM) |
|
195 { |
|
196 return 1; |
|
197 } |
|
198 |
|
199 c=(c%BN_BITS)-BN_BITS2; |
|
200 BN_rand(a,NUM_BITS+c,0,0); |
|
201 if(errno==ENOMEM) |
|
202 { |
|
203 return 1; |
|
204 } |
|
205 RAND_bytes(&c,1); |
|
206 if(errno==ENOMEM) |
|
207 { |
|
208 return 1; |
|
209 } |
|
210 c=(c%BN_BITS)-BN_BITS2; |
|
211 BN_rand(b,NUM_BITS+c,0,0); |
|
212 if(errno==ENOMEM) |
|
213 { |
|
214 return 1; |
|
215 } |
|
216 RAND_bytes(&c,1); |
|
217 if(errno==ENOMEM) |
|
218 { |
|
219 return 1; |
|
220 } |
|
221 |
|
222 c=(c%BN_BITS)-BN_BITS2; |
|
223 BN_rand(m,NUM_BITS+c,0,1); |
|
224 if(errno==ENOMEM) |
|
225 { |
|
226 return 1; |
|
227 } |
|
228 |
|
229 BN_mod(a,a,m,ctx); |
|
230 if(errno==ENOMEM) |
|
231 { |
|
232 return 1; |
|
233 } |
|
234 |
|
235 BN_mod(b,b,m,ctx); |
|
236 if(errno==ENOMEM) |
|
237 { |
|
238 return 1; |
|
239 } |
|
240 |
|
241 ret=BN_mod_exp_mont(r_mont,a,b,m,ctx,NULL); |
|
242 if (ret <= 0) |
|
243 { |
|
244 if(errno==ENOMEM) |
|
245 { |
|
246 return 1; |
|
247 } |
|
248 fprintf(stdout,"BN_mod_exp_mont() problems\n"); |
|
249 ERR_print_errors(out); |
|
250 if(errno==ENOMEM) |
|
251 { |
|
252 return 1; |
|
253 } |
|
254 return 1; |
|
255 } |
|
256 |
|
257 ret=BN_mod_exp_recp(r_recp,a,b,m,ctx); |
|
258 if (ret <= 0) |
|
259 { |
|
260 if(errno==ENOMEM) |
|
261 { |
|
262 return 1; |
|
263 } |
|
264 fprintf(stdout,"BN_mod_exp_recp() problems\n"); |
|
265 ERR_print_errors(out); |
|
266 if(errno==ENOMEM) |
|
267 { |
|
268 return 1; |
|
269 } |
|
270 return 1; |
|
271 } |
|
272 |
|
273 ret=BN_mod_exp_simple(r_simple,a,b,m,ctx); |
|
274 if (ret <= 0) |
|
275 { |
|
276 if(errno==ENOMEM) |
|
277 { |
|
278 return 1; |
|
279 } |
|
280 fprintf(stdout,"BN_mod_exp_simple() problems\n"); |
|
281 ERR_print_errors(out); |
|
282 if(errno==ENOMEM) |
|
283 { |
|
284 return 1; |
|
285 } |
|
286 return 1; |
|
287 } |
|
288 |
|
289 ret=BN_mod_exp_mont_consttime(r_mont_const,a,b,m,ctx,NULL); |
|
290 if (ret <= 0) |
|
291 { |
|
292 if(errno==ENOMEM) |
|
293 { |
|
294 return 1; |
|
295 } |
|
296 fprintf(stdout,"BN_mod_exp_mont_consttime() problems\n"); |
|
297 ERR_print_errors(out); |
|
298 if(errno==ENOMEM) |
|
299 { |
|
300 return 1; |
|
301 } |
|
302 return 1; |
|
303 } |
|
304 |
|
305 if (BN_cmp(r_simple, r_mont) == 0 |
|
306 && BN_cmp(r_simple,r_recp) == 0 |
|
307 && BN_cmp(r_simple,r_mont_const) == 0) |
|
308 { |
|
309 if(errno==ENOMEM) |
|
310 { |
|
311 return 1; |
|
312 } |
|
313 fprintf(stdout,"."); |
|
314 fflush(stdout); |
|
315 } |
|
316 else |
|
317 { |
|
318 if (BN_cmp(r_simple,r_mont) != 0) |
|
319 { |
|
320 if(errno==ENOMEM) |
|
321 { |
|
322 return 1; |
|
323 } |
|
324 fprintf(stdout,"\nsimple and mont results differ\n"); |
|
325 } |
|
326 if (BN_cmp(r_simple,r_mont) != 0) |
|
327 { |
|
328 if(errno==ENOMEM) |
|
329 { |
|
330 return 1; |
|
331 } |
|
332 fprintf(stdout,"\nsimple and mont const time results differ\n"); |
|
333 } |
|
334 if (BN_cmp(r_simple,r_recp) != 0) |
|
335 { |
|
336 if(errno==ENOMEM) |
|
337 { |
|
338 return 1; |
|
339 } |
|
340 fprintf(stdout,"\nsimple and recp results differ\n"); |
|
341 } |
|
342 fprintf(stdout,"a (%3d) = ",BN_num_bits(a)); BN_print(out,a); |
|
343 if(errno==ENOMEM) |
|
344 { |
|
345 return 1; |
|
346 } |
|
347 fprintf(stdout,"\nb (%3d) = ",BN_num_bits(b)); BN_print(out,b); |
|
348 if(errno==ENOMEM) |
|
349 { |
|
350 return 1; |
|
351 } |
|
352 fprintf(stdout,"\nm (%3d) = ",BN_num_bits(m)); BN_print(out,m); |
|
353 if(errno==ENOMEM) |
|
354 { |
|
355 return 1; |
|
356 } |
|
357 fprintf(stdout,"\nsimple ="); BN_print(out,r_simple); |
|
358 if(errno==ENOMEM) |
|
359 { |
|
360 return 1; |
|
361 } |
|
362 fprintf(stdout,"\nrecp ="); BN_print(out,r_recp); |
|
363 if(errno==ENOMEM) |
|
364 { |
|
365 return 1; |
|
366 } |
|
367 fprintf(stdout,"\nmont ="); BN_print(out,r_mont); |
|
368 if(errno==ENOMEM) |
|
369 { |
|
370 return 1; |
|
371 } |
|
372 fprintf(stdout,"\nmont_ct ="); BN_print(out,r_mont_const); |
|
373 if(errno==ENOMEM) |
|
374 { |
|
375 return 1; |
|
376 } |
|
377 fprintf(stdout,"\n"); |
|
378 return 1; |
|
379 } |
|
380 } |
|
381 BN_free(r_mont); |
|
382 BN_free(r_mont_const); |
|
383 BN_free(r_recp); |
|
384 BN_free(r_simple); |
|
385 BN_free(a); |
|
386 BN_free(b); |
|
387 BN_free(m); |
|
388 BN_CTX_free(ctx); |
|
389 ERR_remove_state(0); |
|
390 if(errno==ENOMEM) |
|
391 { |
|
392 return 1; |
|
393 } |
|
394 CRYPTO_mem_leaks(out); |
|
395 if(errno==ENOMEM) |
|
396 { |
|
397 return 1; |
|
398 } |
|
399 BIO_free(out); |
|
400 if(errno==ENOMEM) |
|
401 { |
|
402 return 1; |
|
403 } |
|
404 |
|
405 CRYPTO_cleanup_all_ex_data(); |
|
406 if(errno==ENOMEM) |
|
407 { |
|
408 return 1; |
|
409 } |
|
410 |
|
411 fprintf(stdout," done\n"); |
|
412 fprintf(stdout," Test case passed\n"); |
|
413 return 0; |
|
414 err: |
|
415 ERR_load_crypto_strings(); |
|
416 if(errno==ENOMEM) |
|
417 { |
|
418 return 1; |
|
419 } |
|
420 |
|
421 ERR_print_errors(out); |
|
422 if(errno==ENOMEM) |
|
423 { |
|
424 return 1; |
|
425 } |
|
426 |
|
427 |
|
428 #ifdef OPENSSL_SYS_NETWARE |
|
429 fprintf(stdout,"ERROR\n"); |
|
430 #endif |
|
431 return(1); |
|
432 } |
|
433 |