Ensure configured module specific and application specific defines are used
[openssl.git] / crypto / des / des_enc.c
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_locl.h"
12 #include "spr.h"
13
14 void 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
85 void 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
149 void 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
169 void 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
194 void 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 */