OLD | NEW |
| (Empty) |
1 /* crypto/des/des_opts.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 /* define PART1, PART2, PART3 or PART4 to build only with a few of the options. | |
60 * This is for machines with 64k code segment size restrictions. */ | |
61 | |
62 #if !defined(OPENSSL_SYS_MSDOS) && (!defined(OPENSSL_SYS_VMS) || defined(__DECC)
) && !defined(OPENSSL_SYS_MACOSX) | |
63 #define TIMES | |
64 #endif | |
65 | |
66 #include <stdio.h> | |
67 #ifndef OPENSSL_SYS_MSDOS | |
68 #include <openssl/e_os2.h> | |
69 #include OPENSSL_UNISTD | |
70 #else | |
71 #include <io.h> | |
72 extern void exit(); | |
73 #endif | |
74 | |
75 #ifndef OPENSSL_SYS_NETWARE | |
76 #include <signal.h> | |
77 #endif | |
78 | |
79 #ifndef _IRIX | |
80 #include <time.h> | |
81 #endif | |
82 #ifdef TIMES | |
83 #include <sys/types.h> | |
84 #include <sys/times.h> | |
85 #endif | |
86 | |
87 /* Depending on the VMS version, the tms structure is perhaps defined. | |
88 The __TMS macro will show if it was. If it wasn't defined, we should | |
89 undefine TIMES, since that tells the rest of the program how things | |
90 should be handled. -- Richard Levitte */ | |
91 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__TMS) | |
92 #undef TIMES | |
93 #endif | |
94 | |
95 #ifndef TIMES | |
96 #include <sys/timeb.h> | |
97 #endif | |
98 | |
99 | |
100 #if defined(sun) || defined(__ultrix) | |
101 #define _POSIX_SOURCE | |
102 #include <limits.h> | |
103 #include <sys/param.h> | |
104 #endif | |
105 | |
106 #include <openssl/des.h> | |
107 #include "spr.h" | |
108 | |
109 #define DES_DEFAULT_OPTIONS | |
110 | |
111 #if !defined(PART1) && !defined(PART2) && !defined(PART3) && !defined(PART4) | |
112 #define PART1 | |
113 #define PART2 | |
114 #define PART3 | |
115 #define PART4 | |
116 #endif | |
117 | |
118 #ifdef PART1 | |
119 | |
120 #undef DES_UNROLL | |
121 #undef DES_RISC1 | |
122 #undef DES_RISC2 | |
123 #undef DES_PTR | |
124 #undef D_ENCRYPT | |
125 #define DES_encrypt1 des_encrypt_u4_cisc_idx | |
126 #define DES_encrypt2 des_encrypt2_u4_cisc_idx | |
127 #define DES_encrypt3 des_encrypt3_u4_cisc_idx | |
128 #define DES_decrypt3 des_decrypt3_u4_cisc_idx | |
129 #undef HEADER_DES_LOCL_H | |
130 #include "des_enc.c" | |
131 | |
132 #define DES_UNROLL | |
133 #undef DES_RISC1 | |
134 #undef DES_RISC2 | |
135 #undef DES_PTR | |
136 #undef D_ENCRYPT | |
137 #undef DES_encrypt1 | |
138 #undef DES_encrypt2 | |
139 #undef DES_encrypt3 | |
140 #undef DES_decrypt3 | |
141 #define DES_encrypt1 des_encrypt_u16_cisc_idx | |
142 #define DES_encrypt2 des_encrypt2_u16_cisc_idx | |
143 #define DES_encrypt3 des_encrypt3_u16_cisc_idx | |
144 #define DES_decrypt3 des_decrypt3_u16_cisc_idx | |
145 #undef HEADER_DES_LOCL_H | |
146 #include "des_enc.c" | |
147 | |
148 #undef DES_UNROLL | |
149 #define DES_RISC1 | |
150 #undef DES_RISC2 | |
151 #undef DES_PTR | |
152 #undef D_ENCRYPT | |
153 #undef DES_encrypt1 | |
154 #undef DES_encrypt2 | |
155 #undef DES_encrypt3 | |
156 #undef DES_decrypt3 | |
157 #define DES_encrypt1 des_encrypt_u4_risc1_idx | |
158 #define DES_encrypt2 des_encrypt2_u4_risc1_idx | |
159 #define DES_encrypt3 des_encrypt3_u4_risc1_idx | |
160 #define DES_decrypt3 des_decrypt3_u4_risc1_idx | |
161 #undef HEADER_DES_LOCL_H | |
162 #include "des_enc.c" | |
163 | |
164 #endif | |
165 | |
166 #ifdef PART2 | |
167 | |
168 #undef DES_UNROLL | |
169 #undef DES_RISC1 | |
170 #define DES_RISC2 | |
171 #undef DES_PTR | |
172 #undef D_ENCRYPT | |
173 #undef DES_encrypt1 | |
174 #undef DES_encrypt2 | |
175 #undef DES_encrypt3 | |
176 #undef DES_decrypt3 | |
177 #define DES_encrypt1 des_encrypt_u4_risc2_idx | |
178 #define DES_encrypt2 des_encrypt2_u4_risc2_idx | |
179 #define DES_encrypt3 des_encrypt3_u4_risc2_idx | |
180 #define DES_decrypt3 des_decrypt3_u4_risc2_idx | |
181 #undef HEADER_DES_LOCL_H | |
182 #include "des_enc.c" | |
183 | |
184 #define DES_UNROLL | |
185 #define DES_RISC1 | |
186 #undef DES_RISC2 | |
187 #undef DES_PTR | |
188 #undef D_ENCRYPT | |
189 #undef DES_encrypt1 | |
190 #undef DES_encrypt2 | |
191 #undef DES_encrypt3 | |
192 #undef DES_decrypt3 | |
193 #define DES_encrypt1 des_encrypt_u16_risc1_idx | |
194 #define DES_encrypt2 des_encrypt2_u16_risc1_idx | |
195 #define DES_encrypt3 des_encrypt3_u16_risc1_idx | |
196 #define DES_decrypt3 des_decrypt3_u16_risc1_idx | |
197 #undef HEADER_DES_LOCL_H | |
198 #include "des_enc.c" | |
199 | |
200 #define DES_UNROLL | |
201 #undef DES_RISC1 | |
202 #define DES_RISC2 | |
203 #undef DES_PTR | |
204 #undef D_ENCRYPT | |
205 #undef DES_encrypt1 | |
206 #undef DES_encrypt2 | |
207 #undef DES_encrypt3 | |
208 #undef DES_decrypt3 | |
209 #define DES_encrypt1 des_encrypt_u16_risc2_idx | |
210 #define DES_encrypt2 des_encrypt2_u16_risc2_idx | |
211 #define DES_encrypt3 des_encrypt3_u16_risc2_idx | |
212 #define DES_decrypt3 des_decrypt3_u16_risc2_idx | |
213 #undef HEADER_DES_LOCL_H | |
214 #include "des_enc.c" | |
215 | |
216 #endif | |
217 | |
218 #ifdef PART3 | |
219 | |
220 #undef DES_UNROLL | |
221 #undef DES_RISC1 | |
222 #undef DES_RISC2 | |
223 #define DES_PTR | |
224 #undef D_ENCRYPT | |
225 #undef DES_encrypt1 | |
226 #undef DES_encrypt2 | |
227 #undef DES_encrypt3 | |
228 #undef DES_decrypt3 | |
229 #define DES_encrypt1 des_encrypt_u4_cisc_ptr | |
230 #define DES_encrypt2 des_encrypt2_u4_cisc_ptr | |
231 #define DES_encrypt3 des_encrypt3_u4_cisc_ptr | |
232 #define DES_decrypt3 des_decrypt3_u4_cisc_ptr | |
233 #undef HEADER_DES_LOCL_H | |
234 #include "des_enc.c" | |
235 | |
236 #define DES_UNROLL | |
237 #undef DES_RISC1 | |
238 #undef DES_RISC2 | |
239 #define DES_PTR | |
240 #undef D_ENCRYPT | |
241 #undef DES_encrypt1 | |
242 #undef DES_encrypt2 | |
243 #undef DES_encrypt3 | |
244 #undef DES_decrypt3 | |
245 #define DES_encrypt1 des_encrypt_u16_cisc_ptr | |
246 #define DES_encrypt2 des_encrypt2_u16_cisc_ptr | |
247 #define DES_encrypt3 des_encrypt3_u16_cisc_ptr | |
248 #define DES_decrypt3 des_decrypt3_u16_cisc_ptr | |
249 #undef HEADER_DES_LOCL_H | |
250 #include "des_enc.c" | |
251 | |
252 #undef DES_UNROLL | |
253 #define DES_RISC1 | |
254 #undef DES_RISC2 | |
255 #define DES_PTR | |
256 #undef D_ENCRYPT | |
257 #undef DES_encrypt1 | |
258 #undef DES_encrypt2 | |
259 #undef DES_encrypt3 | |
260 #undef DES_decrypt3 | |
261 #define DES_encrypt1 des_encrypt_u4_risc1_ptr | |
262 #define DES_encrypt2 des_encrypt2_u4_risc1_ptr | |
263 #define DES_encrypt3 des_encrypt3_u4_risc1_ptr | |
264 #define DES_decrypt3 des_decrypt3_u4_risc1_ptr | |
265 #undef HEADER_DES_LOCL_H | |
266 #include "des_enc.c" | |
267 | |
268 #endif | |
269 | |
270 #ifdef PART4 | |
271 | |
272 #undef DES_UNROLL | |
273 #undef DES_RISC1 | |
274 #define DES_RISC2 | |
275 #define DES_PTR | |
276 #undef D_ENCRYPT | |
277 #undef DES_encrypt1 | |
278 #undef DES_encrypt2 | |
279 #undef DES_encrypt3 | |
280 #undef DES_decrypt3 | |
281 #define DES_encrypt1 des_encrypt_u4_risc2_ptr | |
282 #define DES_encrypt2 des_encrypt2_u4_risc2_ptr | |
283 #define DES_encrypt3 des_encrypt3_u4_risc2_ptr | |
284 #define DES_decrypt3 des_decrypt3_u4_risc2_ptr | |
285 #undef HEADER_DES_LOCL_H | |
286 #include "des_enc.c" | |
287 | |
288 #define DES_UNROLL | |
289 #define DES_RISC1 | |
290 #undef DES_RISC2 | |
291 #define DES_PTR | |
292 #undef D_ENCRYPT | |
293 #undef DES_encrypt1 | |
294 #undef DES_encrypt2 | |
295 #undef DES_encrypt3 | |
296 #undef DES_decrypt3 | |
297 #define DES_encrypt1 des_encrypt_u16_risc1_ptr | |
298 #define DES_encrypt2 des_encrypt2_u16_risc1_ptr | |
299 #define DES_encrypt3 des_encrypt3_u16_risc1_ptr | |
300 #define DES_decrypt3 des_decrypt3_u16_risc1_ptr | |
301 #undef HEADER_DES_LOCL_H | |
302 #include "des_enc.c" | |
303 | |
304 #define DES_UNROLL | |
305 #undef DES_RISC1 | |
306 #define DES_RISC2 | |
307 #define DES_PTR | |
308 #undef D_ENCRYPT | |
309 #undef DES_encrypt1 | |
310 #undef DES_encrypt2 | |
311 #undef DES_encrypt3 | |
312 #undef DES_decrypt3 | |
313 #define DES_encrypt1 des_encrypt_u16_risc2_ptr | |
314 #define DES_encrypt2 des_encrypt2_u16_risc2_ptr | |
315 #define DES_encrypt3 des_encrypt3_u16_risc2_ptr | |
316 #define DES_decrypt3 des_decrypt3_u16_risc2_ptr | |
317 #undef HEADER_DES_LOCL_H | |
318 #include "des_enc.c" | |
319 | |
320 #endif | |
321 | |
322 /* The following if from times(3) man page. It may need to be changed */ | |
323 #ifndef HZ | |
324 # ifndef CLK_TCK | |
325 # ifndef _BSD_CLK_TCK_ /* FreeBSD fix */ | |
326 # define HZ 100.0 | |
327 # else /* _BSD_CLK_TCK_ */ | |
328 # define HZ ((double)_BSD_CLK_TCK_) | |
329 # endif | |
330 # else /* CLK_TCK */ | |
331 # define HZ ((double)CLK_TCK) | |
332 # endif | |
333 #endif | |
334 | |
335 #define BUFSIZE ((long)1024) | |
336 long run=0; | |
337 | |
338 double Time_F(int s); | |
339 #ifdef SIGALRM | |
340 #if defined(__STDC__) || defined(sgi) | |
341 #define SIGRETTYPE void | |
342 #else | |
343 #define SIGRETTYPE int | |
344 #endif | |
345 | |
346 SIGRETTYPE sig_done(int sig); | |
347 SIGRETTYPE sig_done(int sig) | |
348 { | |
349 signal(SIGALRM,sig_done); | |
350 run=0; | |
351 #ifdef LINT | |
352 sig=sig; | |
353 #endif | |
354 } | |
355 #endif | |
356 | |
357 #define START 0 | |
358 #define STOP 1 | |
359 | |
360 double Time_F(int s) | |
361 { | |
362 double ret; | |
363 #ifdef TIMES | |
364 static struct tms tstart,tend; | |
365 | |
366 if (s == START) | |
367 { | |
368 times(&tstart); | |
369 return(0); | |
370 } | |
371 else | |
372 { | |
373 times(&tend); | |
374 ret=((double)(tend.tms_utime-tstart.tms_utime))/HZ; | |
375 return((ret == 0.0)?1e-6:ret); | |
376 } | |
377 #else /* !times() */ | |
378 static struct timeb tstart,tend; | |
379 long i; | |
380 | |
381 if (s == START) | |
382 { | |
383 ftime(&tstart); | |
384 return(0); | |
385 } | |
386 else | |
387 { | |
388 ftime(&tend); | |
389 i=(long)tend.millitm-(long)tstart.millitm; | |
390 ret=((double)(tend.time-tstart.time))+((double)i)/1000.0; | |
391 return((ret == 0.0)?1e-6:ret); | |
392 } | |
393 #endif | |
394 } | |
395 | |
396 #ifdef SIGALRM | |
397 #define print_name(name) fprintf(stderr,"Doing %s's for 10 seconds\n",name); ala
rm(10); | |
398 #else | |
399 #define print_name(name) fprintf(stderr,"Doing %s %ld times\n",name,cb); | |
400 #endif | |
401 | |
402 #define time_it(func,name,index) \ | |
403 print_name(name); \ | |
404 Time_F(START); \ | |
405 for (count=0,run=1; COND(cb); count++) \ | |
406 { \ | |
407 unsigned long d[2]; \ | |
408 func(d,&sch,DES_ENCRYPT); \ | |
409 } \ | |
410 tm[index]=Time_F(STOP); \ | |
411 fprintf(stderr,"%ld %s's in %.2f second\n",count,name,tm[index]); \ | |
412 tm[index]=((double)COUNT(cb))/tm[index]; | |
413 | |
414 #define print_it(name,index) \ | |
415 fprintf(stderr,"%s bytes per sec = %12.2f (%5.1fuS)\n",name, \ | |
416 tm[index]*8,1.0e6/tm[index]); | |
417 | |
418 int main(int argc, char **argv) | |
419 { | |
420 long count; | |
421 static unsigned char buf[BUFSIZE]; | |
422 static DES_cblock key ={0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0}; | |
423 static DES_cblock key2={0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12}; | |
424 static DES_cblock key3={0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12,0x34}; | |
425 DES_key_schedule sch,sch2,sch3; | |
426 double d,tm[16],max=0; | |
427 int rank[16]; | |
428 char *str[16]; | |
429 int max_idx=0,i,num=0,j; | |
430 #ifndef SIGALARM | |
431 long ca,cb,cc,cd,ce; | |
432 #endif | |
433 | |
434 for (i=0; i<12; i++) | |
435 { | |
436 tm[i]=0.0; | |
437 rank[i]=0; | |
438 } | |
439 | |
440 #ifndef TIMES | |
441 fprintf(stderr,"To get the most accurate results, try to run this\n"); | |
442 fprintf(stderr,"program when this computer is idle.\n"); | |
443 #endif | |
444 | |
445 DES_set_key_unchecked(&key,&sch); | |
446 DES_set_key_unchecked(&key2,&sch2); | |
447 DES_set_key_unchecked(&key3,&sch3); | |
448 | |
449 #ifndef SIGALRM | |
450 fprintf(stderr,"First we calculate the approximate speed ...\n"); | |
451 DES_set_key_unchecked(&key,sch); | |
452 count=10; | |
453 do { | |
454 long i; | |
455 unsigned long data[2]; | |
456 | |
457 count*=2; | |
458 Time_F(START); | |
459 for (i=count; i; i--) | |
460 DES_encrypt1(data,&(sch[0]),DES_ENCRYPT); | |
461 d=Time_F(STOP); | |
462 } while (d < 3.0); | |
463 ca=count; | |
464 cb=count*3; | |
465 cc=count*3*8/BUFSIZE+1; | |
466 cd=count*8/BUFSIZE+1; | |
467 | |
468 ce=count/20+1; | |
469 #define COND(d) (count != (d)) | |
470 #define COUNT(d) (d) | |
471 #else | |
472 #define COND(c) (run) | |
473 #define COUNT(d) (count) | |
474 signal(SIGALRM,sig_done); | |
475 alarm(10); | |
476 #endif | |
477 | |
478 #ifdef PART1 | |
479 time_it(des_encrypt_u4_cisc_idx, "des_encrypt_u4_cisc_idx ", 0); | |
480 time_it(des_encrypt_u16_cisc_idx, "des_encrypt_u16_cisc_idx ", 1); | |
481 time_it(des_encrypt_u4_risc1_idx, "des_encrypt_u4_risc1_idx ", 2); | |
482 num+=3; | |
483 #endif | |
484 #ifdef PART2 | |
485 time_it(des_encrypt_u16_risc1_idx,"des_encrypt_u16_risc1_idx", 3); | |
486 time_it(des_encrypt_u4_risc2_idx, "des_encrypt_u4_risc2_idx ", 4); | |
487 time_it(des_encrypt_u16_risc2_idx,"des_encrypt_u16_risc2_idx", 5); | |
488 num+=3; | |
489 #endif | |
490 #ifdef PART3 | |
491 time_it(des_encrypt_u4_cisc_ptr, "des_encrypt_u4_cisc_ptr ", 6); | |
492 time_it(des_encrypt_u16_cisc_ptr, "des_encrypt_u16_cisc_ptr ", 7); | |
493 time_it(des_encrypt_u4_risc1_ptr, "des_encrypt_u4_risc1_ptr ", 8); | |
494 num+=3; | |
495 #endif | |
496 #ifdef PART4 | |
497 time_it(des_encrypt_u16_risc1_ptr,"des_encrypt_u16_risc1_ptr", 9); | |
498 time_it(des_encrypt_u4_risc2_ptr, "des_encrypt_u4_risc2_ptr ",10); | |
499 time_it(des_encrypt_u16_risc2_ptr,"des_encrypt_u16_risc2_ptr",11); | |
500 num+=3; | |
501 #endif | |
502 | |
503 #ifdef PART1 | |
504 str[0]=" 4 c i"; | |
505 print_it("des_encrypt_u4_cisc_idx ",0); | |
506 max=tm[0]; | |
507 max_idx=0; | |
508 str[1]="16 c i"; | |
509 print_it("des_encrypt_u16_cisc_idx ",1); | |
510 if (max < tm[1]) { max=tm[1]; max_idx=1; } | |
511 str[2]=" 4 r1 i"; | |
512 print_it("des_encrypt_u4_risc1_idx ",2); | |
513 if (max < tm[2]) { max=tm[2]; max_idx=2; } | |
514 #endif | |
515 #ifdef PART2 | |
516 str[3]="16 r1 i"; | |
517 print_it("des_encrypt_u16_risc1_idx",3); | |
518 if (max < tm[3]) { max=tm[3]; max_idx=3; } | |
519 str[4]=" 4 r2 i"; | |
520 print_it("des_encrypt_u4_risc2_idx ",4); | |
521 if (max < tm[4]) { max=tm[4]; max_idx=4; } | |
522 str[5]="16 r2 i"; | |
523 print_it("des_encrypt_u16_risc2_idx",5); | |
524 if (max < tm[5]) { max=tm[5]; max_idx=5; } | |
525 #endif | |
526 #ifdef PART3 | |
527 str[6]=" 4 c p"; | |
528 print_it("des_encrypt_u4_cisc_ptr ",6); | |
529 if (max < tm[6]) { max=tm[6]; max_idx=6; } | |
530 str[7]="16 c p"; | |
531 print_it("des_encrypt_u16_cisc_ptr ",7); | |
532 if (max < tm[7]) { max=tm[7]; max_idx=7; } | |
533 str[8]=" 4 r1 p"; | |
534 print_it("des_encrypt_u4_risc1_ptr ",8); | |
535 if (max < tm[8]) { max=tm[8]; max_idx=8; } | |
536 #endif | |
537 #ifdef PART4 | |
538 str[9]="16 r1 p"; | |
539 print_it("des_encrypt_u16_risc1_ptr",9); | |
540 if (max < tm[9]) { max=tm[9]; max_idx=9; } | |
541 str[10]=" 4 r2 p"; | |
542 print_it("des_encrypt_u4_risc2_ptr ",10); | |
543 if (max < tm[10]) { max=tm[10]; max_idx=10; } | |
544 str[11]="16 r2 p"; | |
545 print_it("des_encrypt_u16_risc2_ptr",11); | |
546 if (max < tm[11]) { max=tm[11]; max_idx=11; } | |
547 #endif | |
548 printf("options des ecb/s\n"); | |
549 printf("%s %12.2f 100.0%%\n",str[max_idx],tm[max_idx]); | |
550 d=tm[max_idx]; | |
551 tm[max_idx]= -2.0; | |
552 max= -1.0; | |
553 for (;;) | |
554 { | |
555 for (i=0; i<12; i++) | |
556 { | |
557 if (max < tm[i]) { max=tm[i]; j=i; } | |
558 } | |
559 if (max < 0.0) break; | |
560 printf("%s %12.2f %4.1f%%\n",str[j],tm[j],tm[j]/d*100.0); | |
561 tm[j]= -2.0; | |
562 max= -1.0; | |
563 } | |
564 | |
565 switch (max_idx) | |
566 { | |
567 case 0: | |
568 printf("-DDES_DEFAULT_OPTIONS\n"); | |
569 break; | |
570 case 1: | |
571 printf("-DDES_UNROLL\n"); | |
572 break; | |
573 case 2: | |
574 printf("-DDES_RISC1\n"); | |
575 break; | |
576 case 3: | |
577 printf("-DDES_UNROLL -DDES_RISC1\n"); | |
578 break; | |
579 case 4: | |
580 printf("-DDES_RISC2\n"); | |
581 break; | |
582 case 5: | |
583 printf("-DDES_UNROLL -DDES_RISC2\n"); | |
584 break; | |
585 case 6: | |
586 printf("-DDES_PTR\n"); | |
587 break; | |
588 case 7: | |
589 printf("-DDES_UNROLL -DDES_PTR\n"); | |
590 break; | |
591 case 8: | |
592 printf("-DDES_RISC1 -DDES_PTR\n"); | |
593 break; | |
594 case 9: | |
595 printf("-DDES_UNROLL -DDES_RISC1 -DDES_PTR\n"); | |
596 break; | |
597 case 10: | |
598 printf("-DDES_RISC2 -DDES_PTR\n"); | |
599 break; | |
600 case 11: | |
601 printf("-DDES_UNROLL -DDES_RISC2 -DDES_PTR\n"); | |
602 break; | |
603 } | |
604 exit(0); | |
605 #if defined(LINT) || defined(OPENSSL_SYS_MSDOS) | |
606 return(0); | |
607 #endif | |
608 } | |
OLD | NEW |