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