|
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); alarm(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 } |