Coverage Report

Created: 2024-11-21 07:03

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