Branch data Line data Source code
1 : : /* crypto/des/des_enc.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 : : #include <openssl/crypto.h>
60 : : #include "des_locl.h"
61 : : #include "spr.h"
62 : :
63 : 7604 : void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc)
64 : : {
65 : : register DES_LONG l,r,t,u;
66 : : #ifdef DES_PTR
67 : : register const unsigned char *des_SP=(const unsigned char *)DES_SPtrans;
68 : : #endif
69 : : #ifndef DES_UNROLL
70 : : register int i;
71 : : #endif
72 : : register DES_LONG *s;
73 : :
74 : 7604 : r=data[0];
75 : 7604 : l=data[1];
76 : :
77 : 7604 : IP(r,l);
78 : : /* Things have been modified so that the initial rotate is
79 : : * done outside the loop. This required the
80 : : * DES_SPtrans values in sp.h to be rotated 1 bit to the right.
81 : : * One perl script later and things have a 5% speed up on a sparc2.
82 : : * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
83 : : * for pointing this out. */
84 : : /* clear the top bits on machines with 8byte longs */
85 : : /* shift left by 2 */
86 : 7604 : r=ROTATE(r,29)&0xffffffffL;
87 : 7604 : l=ROTATE(l,29)&0xffffffffL;
88 : :
89 : 7604 : s=ks->ks->deslong;
90 : : /* I don't know if it is worth the effort of loop unrolling the
91 : : * inner loop */
92 [ + + ]: 7604 : if (enc)
93 : : {
94 : : #ifdef DES_UNROLL
95 : 4487 : D_ENCRYPT(l,r, 0); /* 1 */
96 : 4487 : D_ENCRYPT(r,l, 2); /* 2 */
97 : 4487 : D_ENCRYPT(l,r, 4); /* 3 */
98 : 4487 : D_ENCRYPT(r,l, 6); /* 4 */
99 : 4487 : D_ENCRYPT(l,r, 8); /* 5 */
100 : 4487 : D_ENCRYPT(r,l,10); /* 6 */
101 : 4487 : D_ENCRYPT(l,r,12); /* 7 */
102 : 4487 : D_ENCRYPT(r,l,14); /* 8 */
103 : 4487 : D_ENCRYPT(l,r,16); /* 9 */
104 : 4487 : D_ENCRYPT(r,l,18); /* 10 */
105 : 4487 : D_ENCRYPT(l,r,20); /* 11 */
106 : 4487 : D_ENCRYPT(r,l,22); /* 12 */
107 : 4487 : D_ENCRYPT(l,r,24); /* 13 */
108 : 4487 : D_ENCRYPT(r,l,26); /* 14 */
109 : 4487 : D_ENCRYPT(l,r,28); /* 15 */
110 : 4487 : D_ENCRYPT(r,l,30); /* 16 */
111 : : #else
112 : : for (i=0; i<32; i+=4)
113 : : {
114 : : D_ENCRYPT(l,r,i+0); /* 1 */
115 : : D_ENCRYPT(r,l,i+2); /* 2 */
116 : : }
117 : : #endif
118 : : }
119 : : else
120 : : {
121 : : #ifdef DES_UNROLL
122 : 3117 : D_ENCRYPT(l,r,30); /* 16 */
123 : 3117 : D_ENCRYPT(r,l,28); /* 15 */
124 : 3117 : D_ENCRYPT(l,r,26); /* 14 */
125 : 3117 : D_ENCRYPT(r,l,24); /* 13 */
126 : 3117 : D_ENCRYPT(l,r,22); /* 12 */
127 : 3117 : D_ENCRYPT(r,l,20); /* 11 */
128 : 3117 : D_ENCRYPT(l,r,18); /* 10 */
129 : 3117 : D_ENCRYPT(r,l,16); /* 9 */
130 : 3117 : D_ENCRYPT(l,r,14); /* 8 */
131 : 3117 : D_ENCRYPT(r,l,12); /* 7 */
132 : 3117 : D_ENCRYPT(l,r,10); /* 6 */
133 : 3117 : D_ENCRYPT(r,l, 8); /* 5 */
134 : 3117 : D_ENCRYPT(l,r, 6); /* 4 */
135 : 3117 : D_ENCRYPT(r,l, 4); /* 3 */
136 : 3117 : D_ENCRYPT(l,r, 2); /* 2 */
137 : 3117 : D_ENCRYPT(r,l, 0); /* 1 */
138 : : #else
139 : : for (i=30; i>0; i-=4)
140 : : {
141 : : D_ENCRYPT(l,r,i-0); /* 16 */
142 : : D_ENCRYPT(r,l,i-2); /* 15 */
143 : : }
144 : : #endif
145 : : }
146 : :
147 : : /* rotate and clear the top bits on machines with 8byte longs */
148 : 7604 : l=ROTATE(l,3)&0xffffffffL;
149 : 7604 : r=ROTATE(r,3)&0xffffffffL;
150 : :
151 : 7604 : FP(r,l);
152 : 7604 : data[0]=l;
153 : 7604 : data[1]=r;
154 : 7604 : l=r=t=u=0;
155 : 7604 : }
156 : :
157 : 20796 : void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc)
158 : : {
159 : : register DES_LONG l,r,t,u;
160 : : #ifdef DES_PTR
161 : : register const unsigned char *des_SP=(const unsigned char *)DES_SPtrans;
162 : : #endif
163 : : #ifndef DES_UNROLL
164 : : register int i;
165 : : #endif
166 : : register DES_LONG *s;
167 : :
168 : 20796 : r=data[0];
169 : 20796 : l=data[1];
170 : :
171 : : /* Things have been modified so that the initial rotate is
172 : : * done outside the loop. This required the
173 : : * DES_SPtrans values in sp.h to be rotated 1 bit to the right.
174 : : * One perl script later and things have a 5% speed up on a sparc2.
175 : : * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
176 : : * for pointing this out. */
177 : : /* clear the top bits on machines with 8byte longs */
178 : 20796 : r=ROTATE(r,29)&0xffffffffL;
179 : 20796 : l=ROTATE(l,29)&0xffffffffL;
180 : :
181 : 20796 : s=ks->ks->deslong;
182 : : /* I don't know if it is worth the effort of loop unrolling the
183 : : * inner loop */
184 [ + + ]: 20796 : if (enc)
185 : : {
186 : : #ifdef DES_UNROLL
187 : 11453 : D_ENCRYPT(l,r, 0); /* 1 */
188 : 11453 : D_ENCRYPT(r,l, 2); /* 2 */
189 : 11453 : D_ENCRYPT(l,r, 4); /* 3 */
190 : 11453 : D_ENCRYPT(r,l, 6); /* 4 */
191 : 11453 : D_ENCRYPT(l,r, 8); /* 5 */
192 : 11453 : D_ENCRYPT(r,l,10); /* 6 */
193 : 11453 : D_ENCRYPT(l,r,12); /* 7 */
194 : 11453 : D_ENCRYPT(r,l,14); /* 8 */
195 : 11453 : D_ENCRYPT(l,r,16); /* 9 */
196 : 11453 : D_ENCRYPT(r,l,18); /* 10 */
197 : 11453 : D_ENCRYPT(l,r,20); /* 11 */
198 : 11453 : D_ENCRYPT(r,l,22); /* 12 */
199 : 11453 : D_ENCRYPT(l,r,24); /* 13 */
200 : 11453 : D_ENCRYPT(r,l,26); /* 14 */
201 : 11453 : D_ENCRYPT(l,r,28); /* 15 */
202 : 11453 : D_ENCRYPT(r,l,30); /* 16 */
203 : : #else
204 : : for (i=0; i<32; i+=4)
205 : : {
206 : : D_ENCRYPT(l,r,i+0); /* 1 */
207 : : D_ENCRYPT(r,l,i+2); /* 2 */
208 : : }
209 : : #endif
210 : : }
211 : : else
212 : : {
213 : : #ifdef DES_UNROLL
214 : 9343 : D_ENCRYPT(l,r,30); /* 16 */
215 : 9343 : D_ENCRYPT(r,l,28); /* 15 */
216 : 9343 : D_ENCRYPT(l,r,26); /* 14 */
217 : 9343 : D_ENCRYPT(r,l,24); /* 13 */
218 : 9343 : D_ENCRYPT(l,r,22); /* 12 */
219 : 9343 : D_ENCRYPT(r,l,20); /* 11 */
220 : 9343 : D_ENCRYPT(l,r,18); /* 10 */
221 : 9343 : D_ENCRYPT(r,l,16); /* 9 */
222 : 9343 : D_ENCRYPT(l,r,14); /* 8 */
223 : 9343 : D_ENCRYPT(r,l,12); /* 7 */
224 : 9343 : D_ENCRYPT(l,r,10); /* 6 */
225 : 9343 : D_ENCRYPT(r,l, 8); /* 5 */
226 : 9343 : D_ENCRYPT(l,r, 6); /* 4 */
227 : 9343 : D_ENCRYPT(r,l, 4); /* 3 */
228 : 9343 : D_ENCRYPT(l,r, 2); /* 2 */
229 : 9343 : D_ENCRYPT(r,l, 0); /* 1 */
230 : : #else
231 : : for (i=30; i>0; i-=4)
232 : : {
233 : : D_ENCRYPT(l,r,i-0); /* 16 */
234 : : D_ENCRYPT(r,l,i-2); /* 15 */
235 : : }
236 : : #endif
237 : : }
238 : : /* rotate and clear the top bits on machines with 8byte longs */
239 : 20796 : data[0]=ROTATE(l,3)&0xffffffffL;
240 : 20796 : data[1]=ROTATE(r,3)&0xffffffffL;
241 : 20796 : l=r=t=u=0;
242 : 20796 : }
243 : :
244 : 4521 : void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1,
245 : : DES_key_schedule *ks2, DES_key_schedule *ks3)
246 : : {
247 : : register DES_LONG l,r;
248 : :
249 : 4521 : l=data[0];
250 : 4521 : r=data[1];
251 : 4521 : IP(l,r);
252 : 4521 : data[0]=l;
253 : 4521 : data[1]=r;
254 : 4521 : DES_encrypt2((DES_LONG *)data,ks1,DES_ENCRYPT);
255 : 4521 : DES_encrypt2((DES_LONG *)data,ks2,DES_DECRYPT);
256 : 4521 : DES_encrypt2((DES_LONG *)data,ks3,DES_ENCRYPT);
257 : 4521 : l=data[0];
258 : 4521 : r=data[1];
259 : 4521 : FP(r,l);
260 : 4521 : data[0]=l;
261 : 4521 : data[1]=r;
262 : 4521 : }
263 : :
264 : 2411 : void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1,
265 : : DES_key_schedule *ks2, DES_key_schedule *ks3)
266 : : {
267 : : register DES_LONG l,r;
268 : :
269 : 2411 : l=data[0];
270 : 2411 : r=data[1];
271 : 2411 : IP(l,r);
272 : 2411 : data[0]=l;
273 : 2411 : data[1]=r;
274 : 2411 : DES_encrypt2((DES_LONG *)data,ks3,DES_DECRYPT);
275 : 2411 : DES_encrypt2((DES_LONG *)data,ks2,DES_ENCRYPT);
276 : 2411 : DES_encrypt2((DES_LONG *)data,ks1,DES_DECRYPT);
277 : 2411 : l=data[0];
278 : 2411 : r=data[1];
279 : 2411 : FP(r,l);
280 : 2411 : data[0]=l;
281 : 2411 : data[1]=r;
282 : 2411 : }
283 : :
284 : : #ifndef DES_DEFAULT_OPTIONS
285 : :
286 : : #undef CBC_ENC_C__DONT_UPDATE_IV
287 : : #include "ncbc_enc.c" /* DES_ncbc_encrypt */
288 : :
289 : 388 : void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output,
290 : : long length, DES_key_schedule *ks1,
291 : : DES_key_schedule *ks2, DES_key_schedule *ks3,
292 : : DES_cblock *ivec, int enc)
293 : : {
294 : : register DES_LONG tin0,tin1;
295 : : register DES_LONG tout0,tout1,xor0,xor1;
296 : : register const unsigned char *in;
297 : : unsigned char *out;
298 : 388 : register long l=length;
299 : : DES_LONG tin[2];
300 : : unsigned char *iv;
301 : :
302 : 388 : in=input;
303 : 388 : out=output;
304 : 388 : iv = &(*ivec)[0];
305 : :
306 [ + + ]: 388 : if (enc)
307 : : {
308 : 223 : c2l(iv,tout0);
309 : 223 : c2l(iv,tout1);
310 [ + + ]: 2155 : for (l-=8; l>=0; l-=8)
311 : : {
312 : 1932 : c2l(in,tin0);
313 : 1932 : c2l(in,tin1);
314 : 1932 : tin0^=tout0;
315 : 1932 : tin1^=tout1;
316 : :
317 : 1932 : tin[0]=tin0;
318 : 1932 : tin[1]=tin1;
319 : 1932 : DES_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
320 : 1932 : tout0=tin[0];
321 : 1932 : tout1=tin[1];
322 : :
323 : 1932 : l2c(tout0,out);
324 : 1932 : l2c(tout1,out);
325 : : }
326 [ + + ]: 223 : if (l != -8)
327 : : {
328 [ - - - + : 1 : c2ln(in,tin0,tin1,l+8);
- - - -
- ]
329 : 1 : tin0^=tout0;
330 : 1 : tin1^=tout1;
331 : :
332 : 1 : tin[0]=tin0;
333 : 1 : tin[1]=tin1;
334 : 1 : DES_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
335 : 1 : tout0=tin[0];
336 : 1 : tout1=tin[1];
337 : :
338 : 1 : l2c(tout0,out);
339 : 1 : l2c(tout1,out);
340 : : }
341 : 223 : iv = &(*ivec)[0];
342 : 223 : l2c(tout0,iv);
343 : 223 : l2c(tout1,iv);
344 : : }
345 : : else
346 : : {
347 : : register DES_LONG t0,t1;
348 : :
349 : 165 : c2l(iv,xor0);
350 : 165 : c2l(iv,xor1);
351 [ + + ]: 2031 : for (l-=8; l>=0; l-=8)
352 : : {
353 : 1866 : c2l(in,tin0);
354 : 1866 : c2l(in,tin1);
355 : :
356 : 1866 : t0=tin0;
357 : 1866 : t1=tin1;
358 : :
359 : 1866 : tin[0]=tin0;
360 : 1866 : tin[1]=tin1;
361 : 1866 : DES_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
362 : 1866 : tout0=tin[0];
363 : 1866 : tout1=tin[1];
364 : :
365 : 1866 : tout0^=xor0;
366 : 1866 : tout1^=xor1;
367 : 1866 : l2c(tout0,out);
368 : 1866 : l2c(tout1,out);
369 : 1866 : xor0=t0;
370 : 1866 : xor1=t1;
371 : : }
372 [ + + ]: 165 : if (l != -8)
373 : : {
374 : 1 : c2l(in,tin0);
375 : 1 : c2l(in,tin1);
376 : :
377 : 1 : t0=tin0;
378 : 1 : t1=tin1;
379 : :
380 : 1 : tin[0]=tin0;
381 : 1 : tin[1]=tin1;
382 : 1 : DES_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
383 : 1 : tout0=tin[0];
384 : 1 : tout1=tin[1];
385 : :
386 : 1 : tout0^=xor0;
387 : 1 : tout1^=xor1;
388 [ - - - + : 1 : l2cn(tout0,tout1,out,l+8);
- - - -
- ]
389 : 1 : xor0=t0;
390 : 1 : xor1=t1;
391 : : }
392 : :
393 : 165 : iv = &(*ivec)[0];
394 : 165 : l2c(xor0,iv);
395 : 165 : l2c(xor1,iv);
396 : : }
397 : 388 : tin0=tin1=tout0=tout1=xor0=xor1=0;
398 : : tin[0]=tin[1]=0;
399 : 388 : }
400 : :
401 : : #endif /* DES_DEFAULT_OPTIONS */
|
