summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/des/des_enc.c
diff options
context:
space:
mode:
authorryker <>1998-10-05 20:13:14 +0000
committerryker <>1998-10-05 20:13:14 +0000
commitaeeae06a79815dc190061534d47236cec09f9e32 (patch)
tree851692b9c2f9c04f077666855641900f19fdb217 /src/lib/libcrypto/des/des_enc.c
parenta4f79641824cbf9f60ca9d1168d1fcc46717a82a (diff)
downloadopenbsd-aeeae06a79815dc190061534d47236cec09f9e32.tar.gz
openbsd-aeeae06a79815dc190061534d47236cec09f9e32.tar.bz2
openbsd-aeeae06a79815dc190061534d47236cec09f9e32.zip
Import of SSLeay-0.9.0b with RSA and IDEA stubbed + OpenBSD build
functionality for shared libs. Note that routines such as sslv2_init and friends that use RSA will not work due to lack of RSA in this library. Needs documentation and help from ports for easy upgrade to full functionality where legally possible.
Diffstat (limited to 'src/lib/libcrypto/des/des_enc.c')
-rw-r--r--src/lib/libcrypto/des/des_enc.c502
1 files changed, 502 insertions, 0 deletions
diff --git a/src/lib/libcrypto/des/des_enc.c b/src/lib/libcrypto/des/des_enc.c
new file mode 100644
index 0000000000..e4db09299e
--- /dev/null
+++ b/src/lib/libcrypto/des/des_enc.c
@@ -0,0 +1,502 @@
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 "des_locl.h"
60
61void des_encrypt(data, ks, enc)
62DES_LONG *data;
63des_key_schedule ks;
64int enc;
65 {
66 register DES_LONG l,r,t,u;
67#ifdef DES_PTR
68 register unsigned char *des_SP=(unsigned char *)des_SPtrans;
69#endif
70#ifndef DES_UNROLL
71 register int i;
72#endif
73 register DES_LONG *s;
74
75 r=data[0];
76 l=data[1];
77
78 IP(r,l);
79 /* Things have been modified so that the initial rotate is
80 * done outside the loop. This required the
81 * des_SPtrans values in sp.h to be rotated 1 bit to the right.
82 * One perl script later and things have a 5% speed up on a sparc2.
83 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
84 * for pointing this out. */
85 /* clear the top bits on machines with 8byte longs */
86 /* shift left by 2 */
87 r=ROTATE(r,29)&0xffffffffL;
88 l=ROTATE(l,29)&0xffffffffL;
89
90 s=(DES_LONG *)ks;
91 /* I don't know if it is worth the effort of loop unrolling the
92 * inner loop */
93 if (enc)
94 {
95#ifdef DES_UNROLL
96 D_ENCRYPT(l,r, 0); /* 1 */
97 D_ENCRYPT(r,l, 2); /* 2 */
98 D_ENCRYPT(l,r, 4); /* 3 */
99 D_ENCRYPT(r,l, 6); /* 4 */
100 D_ENCRYPT(l,r, 8); /* 5 */
101 D_ENCRYPT(r,l,10); /* 6 */
102 D_ENCRYPT(l,r,12); /* 7 */
103 D_ENCRYPT(r,l,14); /* 8 */
104 D_ENCRYPT(l,r,16); /* 9 */
105 D_ENCRYPT(r,l,18); /* 10 */
106 D_ENCRYPT(l,r,20); /* 11 */
107 D_ENCRYPT(r,l,22); /* 12 */
108 D_ENCRYPT(l,r,24); /* 13 */
109 D_ENCRYPT(r,l,26); /* 14 */
110 D_ENCRYPT(l,r,28); /* 15 */
111 D_ENCRYPT(r,l,30); /* 16 */
112#else
113 for (i=0; i<32; i+=8)
114 {
115 D_ENCRYPT(l,r,i+0); /* 1 */
116 D_ENCRYPT(r,l,i+2); /* 2 */
117 D_ENCRYPT(l,r,i+4); /* 3 */
118 D_ENCRYPT(r,l,i+6); /* 4 */
119 }
120#endif
121 }
122 else
123 {
124#ifdef DES_UNROLL
125 D_ENCRYPT(l,r,30); /* 16 */
126 D_ENCRYPT(r,l,28); /* 15 */
127 D_ENCRYPT(l,r,26); /* 14 */
128 D_ENCRYPT(r,l,24); /* 13 */
129 D_ENCRYPT(l,r,22); /* 12 */
130 D_ENCRYPT(r,l,20); /* 11 */
131 D_ENCRYPT(l,r,18); /* 10 */
132 D_ENCRYPT(r,l,16); /* 9 */
133 D_ENCRYPT(l,r,14); /* 8 */
134 D_ENCRYPT(r,l,12); /* 7 */
135 D_ENCRYPT(l,r,10); /* 6 */
136 D_ENCRYPT(r,l, 8); /* 5 */
137 D_ENCRYPT(l,r, 6); /* 4 */
138 D_ENCRYPT(r,l, 4); /* 3 */
139 D_ENCRYPT(l,r, 2); /* 2 */
140 D_ENCRYPT(r,l, 0); /* 1 */
141#else
142 for (i=30; i>0; i-=8)
143 {
144 D_ENCRYPT(l,r,i-0); /* 16 */
145 D_ENCRYPT(r,l,i-2); /* 15 */
146 D_ENCRYPT(l,r,i-4); /* 14 */
147 D_ENCRYPT(r,l,i-6); /* 13 */
148 }
149#endif
150 }
151
152 /* rotate and clear the top bits on machines with 8byte longs */
153 l=ROTATE(l,3)&0xffffffffL;
154 r=ROTATE(r,3)&0xffffffffL;
155
156 FP(r,l);
157 data[0]=l;
158 data[1]=r;
159 l=r=t=u=0;
160 }
161
162void des_encrypt2(data, ks, enc)
163DES_LONG *data;
164des_key_schedule ks;
165int enc;
166 {
167 register DES_LONG l,r,t,u;
168#ifdef DES_PTR
169 register unsigned char *des_SP=(unsigned char *)des_SPtrans;
170#endif
171#ifndef DES_UNROLL
172 register int i;
173#endif
174 register DES_LONG *s;
175
176 r=data[0];
177 l=data[1];
178
179 /* Things have been modified so that the initial rotate is
180 * done outside the loop. This required the
181 * des_SPtrans values in sp.h to be rotated 1 bit to the right.
182 * One perl script later and things have a 5% speed up on a sparc2.
183 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
184 * for pointing this out. */
185 /* clear the top bits on machines with 8byte longs */
186 r=ROTATE(r,29)&0xffffffffL;
187 l=ROTATE(l,29)&0xffffffffL;
188
189 s=(DES_LONG *)ks;
190 /* I don't know if it is worth the effort of loop unrolling the
191 * inner loop */
192 if (enc)
193 {
194#ifdef DES_UNROLL
195 D_ENCRYPT(l,r, 0); /* 1 */
196 D_ENCRYPT(r,l, 2); /* 2 */
197 D_ENCRYPT(l,r, 4); /* 3 */
198 D_ENCRYPT(r,l, 6); /* 4 */
199 D_ENCRYPT(l,r, 8); /* 5 */
200 D_ENCRYPT(r,l,10); /* 6 */
201 D_ENCRYPT(l,r,12); /* 7 */
202 D_ENCRYPT(r,l,14); /* 8 */
203 D_ENCRYPT(l,r,16); /* 9 */
204 D_ENCRYPT(r,l,18); /* 10 */
205 D_ENCRYPT(l,r,20); /* 11 */
206 D_ENCRYPT(r,l,22); /* 12 */
207 D_ENCRYPT(l,r,24); /* 13 */
208 D_ENCRYPT(r,l,26); /* 14 */
209 D_ENCRYPT(l,r,28); /* 15 */
210 D_ENCRYPT(r,l,30); /* 16 */
211#else
212 for (i=0; i<32; i+=8)
213 {
214 D_ENCRYPT(l,r,i+0); /* 1 */
215 D_ENCRYPT(r,l,i+2); /* 2 */
216 D_ENCRYPT(l,r,i+4); /* 3 */
217 D_ENCRYPT(r,l,i+6); /* 4 */
218 }
219#endif
220 }
221 else
222 {
223#ifdef DES_UNROLL
224 D_ENCRYPT(l,r,30); /* 16 */
225 D_ENCRYPT(r,l,28); /* 15 */
226 D_ENCRYPT(l,r,26); /* 14 */
227 D_ENCRYPT(r,l,24); /* 13 */
228 D_ENCRYPT(l,r,22); /* 12 */
229 D_ENCRYPT(r,l,20); /* 11 */
230 D_ENCRYPT(l,r,18); /* 10 */
231 D_ENCRYPT(r,l,16); /* 9 */
232 D_ENCRYPT(l,r,14); /* 8 */
233 D_ENCRYPT(r,l,12); /* 7 */
234 D_ENCRYPT(l,r,10); /* 6 */
235 D_ENCRYPT(r,l, 8); /* 5 */
236 D_ENCRYPT(l,r, 6); /* 4 */
237 D_ENCRYPT(r,l, 4); /* 3 */
238 D_ENCRYPT(l,r, 2); /* 2 */
239 D_ENCRYPT(r,l, 0); /* 1 */
240#else
241 for (i=30; i>0; i-=8)
242 {
243 D_ENCRYPT(l,r,i-0); /* 16 */
244 D_ENCRYPT(r,l,i-2); /* 15 */
245 D_ENCRYPT(l,r,i-4); /* 14 */
246 D_ENCRYPT(r,l,i-6); /* 13 */
247 }
248#endif
249 }
250 /* rotate and clear the top bits on machines with 8byte longs */
251 data[0]=ROTATE(l,3)&0xffffffffL;
252 data[1]=ROTATE(r,3)&0xffffffffL;
253 l=r=t=u=0;
254 }
255
256void des_encrypt3(data,ks1,ks2,ks3)
257DES_LONG *data;
258des_key_schedule ks1;
259des_key_schedule ks2;
260des_key_schedule ks3;
261 {
262 register DES_LONG l,r;
263
264 l=data[0];
265 r=data[1];
266 IP(l,r);
267 data[0]=l;
268 data[1]=r;
269 des_encrypt2((DES_LONG *)data,ks1,DES_ENCRYPT);
270 des_encrypt2((DES_LONG *)data,ks2,DES_DECRYPT);
271 des_encrypt2((DES_LONG *)data,ks3,DES_ENCRYPT);
272 l=data[0];
273 r=data[1];
274 FP(r,l);
275 data[0]=l;
276 data[1]=r;
277 }
278
279void des_decrypt3(data,ks1,ks2,ks3)
280DES_LONG *data;
281des_key_schedule ks1;
282des_key_schedule ks2;
283des_key_schedule ks3;
284 {
285 register DES_LONG l,r;
286
287 l=data[0];
288 r=data[1];
289 IP(l,r);
290 data[0]=l;
291 data[1]=r;
292 des_encrypt2((DES_LONG *)data,ks3,DES_DECRYPT);
293 des_encrypt2((DES_LONG *)data,ks2,DES_ENCRYPT);
294 des_encrypt2((DES_LONG *)data,ks1,DES_DECRYPT);
295 l=data[0];
296 r=data[1];
297 FP(r,l);
298 data[0]=l;
299 data[1]=r;
300 }
301
302#ifndef DES_DEFAULT_OPTIONS
303
304void des_ncbc_encrypt(input, output, length, schedule, ivec, enc)
305des_cblock (*input);
306des_cblock (*output);
307long length;
308des_key_schedule schedule;
309des_cblock (*ivec);
310int enc;
311 {
312 register DES_LONG tin0,tin1;
313 register DES_LONG tout0,tout1,xor0,xor1;
314 register unsigned char *in,*out;
315 register long l=length;
316 DES_LONG tin[2];
317 unsigned char *iv;
318
319 in=(unsigned char *)input;
320 out=(unsigned char *)output;
321 iv=(unsigned char *)ivec;
322
323 if (enc)
324 {
325 c2l(iv,tout0);
326 c2l(iv,tout1);
327 for (l-=8; l>=0; l-=8)
328 {
329 c2l(in,tin0);
330 c2l(in,tin1);
331 tin0^=tout0; tin[0]=tin0;
332 tin1^=tout1; tin[1]=tin1;
333 des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
334 tout0=tin[0]; l2c(tout0,out);
335 tout1=tin[1]; l2c(tout1,out);
336 }
337 if (l != -8)
338 {
339 c2ln(in,tin0,tin1,l+8);
340 tin0^=tout0; tin[0]=tin0;
341 tin1^=tout1; tin[1]=tin1;
342 des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
343 tout0=tin[0]; l2c(tout0,out);
344 tout1=tin[1]; l2c(tout1,out);
345 }
346 iv=(unsigned char *)ivec;
347 l2c(tout0,iv);
348 l2c(tout1,iv);
349 }
350 else
351 {
352 c2l(iv,xor0);
353 c2l(iv,xor1);
354 for (l-=8; l>=0; l-=8)
355 {
356 c2l(in,tin0); tin[0]=tin0;
357 c2l(in,tin1); tin[1]=tin1;
358 des_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
359 tout0=tin[0]^xor0;
360 tout1=tin[1]^xor1;
361 l2c(tout0,out);
362 l2c(tout1,out);
363 xor0=tin0;
364 xor1=tin1;
365 }
366 if (l != -8)
367 {
368 c2l(in,tin0); tin[0]=tin0;
369 c2l(in,tin1); tin[1]=tin1;
370 des_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
371 tout0=tin[0]^xor0;
372 tout1=tin[1]^xor1;
373 l2cn(tout0,tout1,out,l+8);
374 xor0=tin0;
375 xor1=tin1;
376 }
377
378 iv=(unsigned char *)ivec;
379 l2c(xor0,iv);
380 l2c(xor1,iv);
381 }
382 tin0=tin1=tout0=tout1=xor0=xor1=0;
383 tin[0]=tin[1]=0;
384 }
385
386void des_ede3_cbc_encrypt(input, output, length, ks1, ks2, ks3, ivec, enc)
387des_cblock (*input);
388des_cblock (*output);
389long length;
390des_key_schedule ks1;
391des_key_schedule ks2;
392des_key_schedule ks3;
393des_cblock (*ivec);
394int enc;
395 {
396 register DES_LONG tin0,tin1;
397 register DES_LONG tout0,tout1,xor0,xor1;
398 register unsigned char *in,*out;
399 register long l=length;
400 DES_LONG tin[2];
401 unsigned char *iv;
402
403 in=(unsigned char *)input;
404 out=(unsigned char *)output;
405 iv=(unsigned char *)ivec;
406
407 if (enc)
408 {
409 c2l(iv,tout0);
410 c2l(iv,tout1);
411 for (l-=8; l>=0; l-=8)
412 {
413 c2l(in,tin0);
414 c2l(in,tin1);
415 tin0^=tout0;
416 tin1^=tout1;
417
418 tin[0]=tin0;
419 tin[1]=tin1;
420 des_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
421 tout0=tin[0];
422 tout1=tin[1];
423
424 l2c(tout0,out);
425 l2c(tout1,out);
426 }
427 if (l != -8)
428 {
429 c2ln(in,tin0,tin1,l+8);
430 tin0^=tout0;
431 tin1^=tout1;
432
433 tin[0]=tin0;
434 tin[1]=tin1;
435 des_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
436 tout0=tin[0];
437 tout1=tin[1];
438
439 l2c(tout0,out);
440 l2c(tout1,out);
441 }
442 iv=(unsigned char *)ivec;
443 l2c(tout0,iv);
444 l2c(tout1,iv);
445 }
446 else
447 {
448 register DES_LONG t0,t1;
449
450 c2l(iv,xor0);
451 c2l(iv,xor1);
452 for (l-=8; l>=0; l-=8)
453 {
454 c2l(in,tin0);
455 c2l(in,tin1);
456
457 t0=tin0;
458 t1=tin1;
459
460 tin[0]=tin0;
461 tin[1]=tin1;
462 des_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
463 tout0=tin[0];
464 tout1=tin[1];
465
466 tout0^=xor0;
467 tout1^=xor1;
468 l2c(tout0,out);
469 l2c(tout1,out);
470 xor0=t0;
471 xor1=t1;
472 }
473 if (l != -8)
474 {
475 c2l(in,tin0);
476 c2l(in,tin1);
477
478 t0=tin0;
479 t1=tin1;
480
481 tin[0]=tin0;
482 tin[1]=tin1;
483 des_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
484 tout0=tin[0];
485 tout1=tin[1];
486
487 tout0^=xor0;
488 tout1^=xor1;
489 l2cn(tout0,tout1,out,l+8);
490 xor0=t0;
491 xor1=t1;
492 }
493
494 iv=(unsigned char *)ivec;
495 l2c(xor0,iv);
496 l2c(xor1,iv);
497 }
498 tin0=tin1=tout0=tout1=xor0=xor1=0;
499 tin[0]=tin[1]=0;
500 }
501
502#endif /* DES_DEFAULT_OPTIONS */