1/*
2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10#include <openssl/crypto.h>
11#include "des_local.h"
12#include "spr.h"
13
14void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc)
15{
16 register DES_LONG l, r, t, u;
17 register DES_LONG *s;
18
19 r = data[0];
20 l = data[1];
21
22 IP(r, l);
23 /*
24 * Things have been modified so that the initial rotate is done outside
25 * the loop. This required the DES_SPtrans values in sp.h to be rotated
26 * 1 bit to the right. One perl script later and things have a 5% speed
27 * up on a sparc2. Thanks to Richard Outerbridge for pointing this out.
28 */
29 /* clear the top bits on machines with 8byte longs */
30 /* shift left by 2 */
31 r = ROTATE(r, 29) & 0xffffffffL;
32 l = ROTATE(l, 29) & 0xffffffffL;
33
34 s = ks->ks->deslong;
35 /*
36 * I don't know if it is worth the effort of loop unrolling the inner
37 * loop
38 */
39 if (enc) {
40 D_ENCRYPT(l, r, 0); /* 1 */
41 D_ENCRYPT(r, l, 2); /* 2 */
42 D_ENCRYPT(l, r, 4); /* 3 */
43 D_ENCRYPT(r, l, 6); /* 4 */
44 D_ENCRYPT(l, r, 8); /* 5 */
45 D_ENCRYPT(r, l, 10); /* 6 */
46 D_ENCRYPT(l, r, 12); /* 7 */
47 D_ENCRYPT(r, l, 14); /* 8 */
48 D_ENCRYPT(l, r, 16); /* 9 */
49 D_ENCRYPT(r, l, 18); /* 10 */
50 D_ENCRYPT(l, r, 20); /* 11 */
51 D_ENCRYPT(r, l, 22); /* 12 */
52 D_ENCRYPT(l, r, 24); /* 13 */
53 D_ENCRYPT(r, l, 26); /* 14 */
54 D_ENCRYPT(l, r, 28); /* 15 */
55 D_ENCRYPT(r, l, 30); /* 16 */
56 } else {
57 D_ENCRYPT(l, r, 30); /* 16 */
58 D_ENCRYPT(r, l, 28); /* 15 */
59 D_ENCRYPT(l, r, 26); /* 14 */
60 D_ENCRYPT(r, l, 24); /* 13 */
61 D_ENCRYPT(l, r, 22); /* 12 */
62 D_ENCRYPT(r, l, 20); /* 11 */
63 D_ENCRYPT(l, r, 18); /* 10 */
64 D_ENCRYPT(r, l, 16); /* 9 */
65 D_ENCRYPT(l, r, 14); /* 8 */
66 D_ENCRYPT(r, l, 12); /* 7 */
67 D_ENCRYPT(l, r, 10); /* 6 */
68 D_ENCRYPT(r, l, 8); /* 5 */
69 D_ENCRYPT(l, r, 6); /* 4 */
70 D_ENCRYPT(r, l, 4); /* 3 */
71 D_ENCRYPT(l, r, 2); /* 2 */
72 D_ENCRYPT(r, l, 0); /* 1 */
73 }
74
75 /* rotate and clear the top bits on machines with 8byte longs */
76 l = ROTATE(l, 3) & 0xffffffffL;
77 r = ROTATE(r, 3) & 0xffffffffL;
78
79 FP(r, l);
80 data[0] = l;
81 data[1] = r;
82 l = r = t = u = 0;
83}
84
85void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc)
86{
87 register DES_LONG l, r, t, u;
88 register DES_LONG *s;
89
90 r = data[0];
91 l = data[1];
92
93 /*
94 * Things have been modified so that the initial rotate is done outside
95 * the loop. This required the DES_SPtrans values in sp.h to be rotated
96 * 1 bit to the right. One perl script later and things have a 5% speed
97 * up on a sparc2. Thanks to Richard Outerbridge for pointing this out.
98 */
99 /* clear the top bits on machines with 8byte longs */
100 r = ROTATE(r, 29) & 0xffffffffL;
101 l = ROTATE(l, 29) & 0xffffffffL;
102
103 s = ks->ks->deslong;
104 /*
105 * I don't know if it is worth the effort of loop unrolling the inner
106 * loop
107 */
108 if (enc) {
109 D_ENCRYPT(l, r, 0); /* 1 */
110 D_ENCRYPT(r, l, 2); /* 2 */
111 D_ENCRYPT(l, r, 4); /* 3 */
112 D_ENCRYPT(r, l, 6); /* 4 */
113 D_ENCRYPT(l, r, 8); /* 5 */
114 D_ENCRYPT(r, l, 10); /* 6 */
115 D_ENCRYPT(l, r, 12); /* 7 */
116 D_ENCRYPT(r, l, 14); /* 8 */
117 D_ENCRYPT(l, r, 16); /* 9 */
118 D_ENCRYPT(r, l, 18); /* 10 */
119 D_ENCRYPT(l, r, 20); /* 11 */
120 D_ENCRYPT(r, l, 22); /* 12 */
121 D_ENCRYPT(l, r, 24); /* 13 */
122 D_ENCRYPT(r, l, 26); /* 14 */
123 D_ENCRYPT(l, r, 28); /* 15 */
124 D_ENCRYPT(r, l, 30); /* 16 */
125 } else {
126 D_ENCRYPT(l, r, 30); /* 16 */
127 D_ENCRYPT(r, l, 28); /* 15 */
128 D_ENCRYPT(l, r, 26); /* 14 */
129 D_ENCRYPT(r, l, 24); /* 13 */
130 D_ENCRYPT(l, r, 22); /* 12 */
131 D_ENCRYPT(r, l, 20); /* 11 */
132 D_ENCRYPT(l, r, 18); /* 10 */
133 D_ENCRYPT(r, l, 16); /* 9 */
134 D_ENCRYPT(l, r, 14); /* 8 */
135 D_ENCRYPT(r, l, 12); /* 7 */
136 D_ENCRYPT(l, r, 10); /* 6 */
137 D_ENCRYPT(r, l, 8); /* 5 */
138 D_ENCRYPT(l, r, 6); /* 4 */
139 D_ENCRYPT(r, l, 4); /* 3 */
140 D_ENCRYPT(l, r, 2); /* 2 */
141 D_ENCRYPT(r, l, 0); /* 1 */
142 }
143 /* rotate and clear the top bits on machines with 8byte longs */
144 data[0] = ROTATE(l, 3) & 0xffffffffL;
145 data[1] = ROTATE(r, 3) & 0xffffffffL;
146 l = r = t = u = 0;
147}
148
149void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1,
150 DES_key_schedule *ks2, DES_key_schedule *ks3)
151{
152 register DES_LONG l, r;
153
154 l = data[0];
155 r = data[1];
156 IP(l, r);
157 data[0] = l;
158 data[1] = r;
159 DES_encrypt2((DES_LONG *)data, ks1, DES_ENCRYPT);
160 DES_encrypt2((DES_LONG *)data, ks2, DES_DECRYPT);
161 DES_encrypt2((DES_LONG *)data, ks3, DES_ENCRYPT);
162 l = data[0];
163 r = data[1];
164 FP(r, l);
165 data[0] = l;
166 data[1] = r;
167}
168
169void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1,
170 DES_key_schedule *ks2, DES_key_schedule *ks3)
171{
172 register DES_LONG l, r;
173
174 l = data[0];
175 r = data[1];
176 IP(l, r);
177 data[0] = l;
178 data[1] = r;
179 DES_encrypt2((DES_LONG *)data, ks3, DES_DECRYPT);
180 DES_encrypt2((DES_LONG *)data, ks2, DES_ENCRYPT);
181 DES_encrypt2((DES_LONG *)data, ks1, DES_DECRYPT);
182 l = data[0];
183 r = data[1];
184 FP(r, l);
185 data[0] = l;
186 data[1] = r;
187}
188
189#ifndef DES_DEFAULT_OPTIONS
190
191# undef CBC_ENC_C__DONT_UPDATE_IV
192# include "ncbc_enc.c" /* DES_ncbc_encrypt */
193
194void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output,
195 long length, DES_key_schedule *ks1,
196 DES_key_schedule *ks2, DES_key_schedule *ks3,
197 DES_cblock *ivec, int enc)
198{
199 register DES_LONG tin0, tin1;
200 register DES_LONG tout0, tout1, xor0, xor1;
201 register const unsigned char *in;
202 unsigned char *out;
203 register long l = length;
204 DES_LONG tin[2];
205 unsigned char *iv;
206
207 in = input;
208 out = output;
209 iv = &(*ivec)[0];
210
211 if (enc) {
212 c2l(iv, tout0);
213 c2l(iv, tout1);
214 for (l -= 8; l >= 0; l -= 8) {
215 c2l(in, tin0);
216 c2l(in, tin1);
217 tin0 ^= tout0;
218 tin1 ^= tout1;
219
220 tin[0] = tin0;
221 tin[1] = tin1;
222 DES_encrypt3((DES_LONG *)tin, ks1, ks2, ks3);
223 tout0 = tin[0];
224 tout1 = tin[1];
225
226 l2c(tout0, out);
227 l2c(tout1, out);
228 }
229 if (l != -8) {
230 c2ln(in, tin0, tin1, l + 8);
231 tin0 ^= tout0;
232 tin1 ^= tout1;
233
234 tin[0] = tin0;
235 tin[1] = tin1;
236 DES_encrypt3((DES_LONG *)tin, ks1, ks2, ks3);
237 tout0 = tin[0];
238 tout1 = tin[1];
239
240 l2c(tout0, out);
241 l2c(tout1, out);
242 }
243 iv = &(*ivec)[0];
244 l2c(tout0, iv);
245 l2c(tout1, iv);
246 } else {
247 register DES_LONG t0, t1;
248
249 c2l(iv, xor0);
250 c2l(iv, xor1);
251 for (l -= 8; l >= 0; l -= 8) {
252 c2l(in, tin0);
253 c2l(in, tin1);
254
255 t0 = tin0;
256 t1 = tin1;
257
258 tin[0] = tin0;
259 tin[1] = tin1;
260 DES_decrypt3((DES_LONG *)tin, ks1, ks2, ks3);
261 tout0 = tin[0];
262 tout1 = tin[1];
263
264 tout0 ^= xor0;
265 tout1 ^= xor1;
266 l2c(tout0, out);
267 l2c(tout1, out);
268 xor0 = t0;
269 xor1 = t1;
270 }
271 if (l != -8) {
272 c2l(in, tin0);
273 c2l(in, tin1);
274
275 t0 = tin0;
276 t1 = tin1;
277
278 tin[0] = tin0;
279 tin[1] = tin1;
280 DES_decrypt3((DES_LONG *)tin, ks1, ks2, ks3);
281 tout0 = tin[0];
282 tout1 = tin[1];
283
284 tout0 ^= xor0;
285 tout1 ^= xor1;
286 l2cn(tout0, tout1, out, l + 8);
287 xor0 = t0;
288 xor1 = t1;
289 }
290
291 iv = &(*ivec)[0];
292 l2c(xor0, iv);
293 l2c(xor1, iv);
294 }
295 tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0;
296 tin[0] = tin[1] = 0;
297}
298
299#endif /* DES_DEFAULT_OPTIONS */
300