~ubuntu-branches/ubuntu/hardy/openssl/hardy-security

« back to all changes in this revision

Viewing changes to crypto/cast/cast_spd.c

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Martin
  • Date: 2004-05-24 17:02:29 UTC
  • Revision ID: james.westby@ubuntu.com-20040524170229-ixlo08bbbly0xied
Tags: upstream-0.9.7d
ImportĀ upstreamĀ versionĀ 0.9.7d

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* crypto/cast/cast_spd.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
/* 11-Sep-92 Andrew Daviel   Support for Silicon Graphics IRIX added */
 
60
/* 06-Apr-92 Luke Brennan    Support for VMS and add extra signal calls */
 
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
 
 
68
#include <openssl/e_os2.h>
 
69
#include OPENSSL_UNISTD_IO
 
70
OPENSSL_DECLARE_EXIT
 
71
 
 
72
#include <signal.h>
 
73
#ifndef _IRIX
 
74
#include <time.h>
 
75
#endif
 
76
#ifdef TIMES
 
77
#include <sys/types.h>
 
78
#include <sys/times.h>
 
79
#endif
 
80
 
 
81
/* Depending on the VMS version, the tms structure is perhaps defined.
 
82
   The __TMS macro will show if it was.  If it wasn't defined, we should
 
83
   undefine TIMES, since that tells the rest of the program how things
 
84
   should be handled.                           -- Richard Levitte */
 
85
#if defined(OPENSSL_SYS_VMS_DECC) && !defined(__TMS)
 
86
#undef TIMES
 
87
#endif
 
88
 
 
89
#ifndef TIMES
 
90
#include <sys/timeb.h>
 
91
#endif
 
92
 
 
93
#if defined(sun) || defined(__ultrix)
 
94
#define _POSIX_SOURCE
 
95
#include <limits.h>
 
96
#include <sys/param.h>
 
97
#endif
 
98
 
 
99
#include <openssl/cast.h>
 
100
 
 
101
/* The following if from times(3) man page.  It may need to be changed */
 
102
#ifndef HZ
 
103
#ifndef CLK_TCK
 
104
#define HZ      100.0
 
105
#else /* CLK_TCK */
 
106
#define HZ ((double)CLK_TCK)
 
107
#endif
 
108
#endif
 
109
 
 
110
#define BUFSIZE ((long)1024)
 
111
long run=0;
 
112
 
 
113
double Time_F(int s);
 
114
#ifdef SIGALRM
 
115
#if defined(__STDC__) || defined(sgi) || defined(_AIX)
 
116
#define SIGRETTYPE void
 
117
#else
 
118
#define SIGRETTYPE int
 
119
#endif
 
120
 
 
121
SIGRETTYPE sig_done(int sig);
 
122
SIGRETTYPE sig_done(int sig)
 
123
        {
 
124
        signal(SIGALRM,sig_done);
 
125
        run=0;
 
126
#ifdef LINT
 
127
        sig=sig;
 
128
#endif
 
129
        }
 
130
#endif
 
131
 
 
132
#define START   0
 
133
#define STOP    1
 
134
 
 
135
double Time_F(int s)
 
136
        {
 
137
        double ret;
 
138
#ifdef TIMES
 
139
        static struct tms tstart,tend;
 
140
 
 
141
        if (s == START)
 
142
                {
 
143
                times(&tstart);
 
144
                return(0);
 
145
                }
 
146
        else
 
147
                {
 
148
                times(&tend);
 
149
                ret=((double)(tend.tms_utime-tstart.tms_utime))/HZ;
 
150
                return((ret == 0.0)?1e-6:ret);
 
151
                }
 
152
#else /* !times() */
 
153
        static struct timeb tstart,tend;
 
154
        long i;
 
155
 
 
156
        if (s == START)
 
157
                {
 
158
                ftime(&tstart);
 
159
                return(0);
 
160
                }
 
161
        else
 
162
                {
 
163
                ftime(&tend);
 
164
                i=(long)tend.millitm-(long)tstart.millitm;
 
165
                ret=((double)(tend.time-tstart.time))+((double)i)/1e3;
 
166
                return((ret == 0.0)?1e-6:ret);
 
167
                }
 
168
#endif
 
169
        }
 
170
 
 
171
int main(int argc, char **argv)
 
172
        {
 
173
        long count;
 
174
        static unsigned char buf[BUFSIZE];
 
175
        static unsigned char key[] ={
 
176
                        0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,
 
177
                        0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10,
 
178
                        };
 
179
        CAST_KEY sch;
 
180
        double a,b,c,d;
 
181
#ifndef SIGALRM
 
182
        long ca,cb,cc;
 
183
#endif
 
184
 
 
185
#ifndef TIMES
 
186
        printf("To get the most accurate results, try to run this\n");
 
187
        printf("program when this computer is idle.\n");
 
188
#endif
 
189
 
 
190
#ifndef SIGALRM
 
191
        printf("First we calculate the approximate speed ...\n");
 
192
        CAST_set_key(&sch,16,key);
 
193
        count=10;
 
194
        do      {
 
195
                long i;
 
196
                CAST_LONG data[2];
 
197
 
 
198
                count*=2;
 
199
                Time_F(START);
 
200
                for (i=count; i; i--)
 
201
                        CAST_encrypt(data,&sch);
 
202
                d=Time_F(STOP);
 
203
                } while (d < 3.0);
 
204
        ca=count/512;
 
205
        cb=count;
 
206
        cc=count*8/BUFSIZE+1;
 
207
        printf("Doing CAST_set_key %ld times\n",ca);
 
208
#define COND(d) (count != (d))
 
209
#define COUNT(d) (d)
 
210
#else
 
211
#define COND(c) (run)
 
212
#define COUNT(d) (count)
 
213
        signal(SIGALRM,sig_done);
 
214
        printf("Doing CAST_set_key for 10 seconds\n");
 
215
        alarm(10);
 
216
#endif
 
217
 
 
218
        Time_F(START);
 
219
        for (count=0,run=1; COND(ca); count+=4)
 
220
                {
 
221
                CAST_set_key(&sch,16,key);
 
222
                CAST_set_key(&sch,16,key);
 
223
                CAST_set_key(&sch,16,key);
 
224
                CAST_set_key(&sch,16,key);
 
225
                }
 
226
        d=Time_F(STOP);
 
227
        printf("%ld cast set_key's in %.2f seconds\n",count,d);
 
228
        a=((double)COUNT(ca))/d;
 
229
 
 
230
#ifdef SIGALRM
 
231
        printf("Doing CAST_encrypt's for 10 seconds\n");
 
232
        alarm(10);
 
233
#else
 
234
        printf("Doing CAST_encrypt %ld times\n",cb);
 
235
#endif
 
236
        Time_F(START);
 
237
        for (count=0,run=1; COND(cb); count+=4)
 
238
                {
 
239
                CAST_LONG data[2];
 
240
 
 
241
                CAST_encrypt(data,&sch);
 
242
                CAST_encrypt(data,&sch);
 
243
                CAST_encrypt(data,&sch);
 
244
                CAST_encrypt(data,&sch);
 
245
                }
 
246
        d=Time_F(STOP);
 
247
        printf("%ld CAST_encrypt's in %.2f second\n",count,d);
 
248
        b=((double)COUNT(cb)*8)/d;
 
249
 
 
250
#ifdef SIGALRM
 
251
        printf("Doing CAST_cbc_encrypt on %ld byte blocks for 10 seconds\n",
 
252
                BUFSIZE);
 
253
        alarm(10);
 
254
#else
 
255
        printf("Doing CAST_cbc_encrypt %ld times on %ld byte blocks\n",cc,
 
256
                BUFSIZE);
 
257
#endif
 
258
        Time_F(START);
 
259
        for (count=0,run=1; COND(cc); count++)
 
260
                CAST_cbc_encrypt(buf,buf,BUFSIZE,&sch,
 
261
                        &(key[0]),CAST_ENCRYPT);
 
262
        d=Time_F(STOP);
 
263
        printf("%ld CAST_cbc_encrypt's of %ld byte blocks in %.2f second\n",
 
264
                count,BUFSIZE,d);
 
265
        c=((double)COUNT(cc)*BUFSIZE)/d;
 
266
 
 
267
        printf("CAST set_key       per sec = %12.2f (%9.3fuS)\n",a,1.0e6/a);
 
268
        printf("CAST raw ecb bytes per sec = %12.2f (%9.3fuS)\n",b,8.0e6/b);
 
269
        printf("CAST cbc     bytes per sec = %12.2f (%9.3fuS)\n",c,8.0e6/c);
 
270
        exit(0);
 
271
#if defined(LINT) || defined(OPENSSL_SYS_MSDOS)
 
272
        return(0);
 
273
#endif
 
274
        }
 
275