/src/openssl/crypto/des/cfb_enc.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright 1995-2022 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 "internal/e_os.h" |
17 | | #include "des_local.h" |
18 | | #include <assert.h> |
19 | | |
20 | | /* |
21 | | * The input and output are loaded in multiples of 8 bits. What this means is |
22 | | * that if you hame numbits=12 and length=2 the first 12 bits will be |
23 | | * retrieved from the first byte and half the second. The second 12 bits |
24 | | * will come from the 3rd and half the 4th byte. |
25 | | */ |
26 | | /* |
27 | | * Until Aug 1 2003 this function did not correctly implement CFB-r, so it |
28 | | * will not be compatible with any encryption prior to that date. Ben. |
29 | | */ |
30 | | void DES_cfb_encrypt(const unsigned char *in, unsigned char *out, int numbits, |
31 | | long length, DES_key_schedule *schedule, |
32 | | DES_cblock *ivec, int enc) |
33 | 0 | { |
34 | 0 | register DES_LONG d0, d1, v0, v1; |
35 | 0 | register unsigned long l = length; |
36 | 0 | register int num = numbits / 8, n = (numbits + 7) / 8, i, rem = |
37 | 0 | numbits % 8; |
38 | 0 | DES_LONG ti[2]; |
39 | 0 | unsigned char *iv; |
40 | | #ifndef L_ENDIAN |
41 | | unsigned char ovec[16]; |
42 | | #else |
43 | 0 | unsigned int sh[4]; |
44 | 0 | unsigned char *ovec = (unsigned char *)sh; |
45 | | |
46 | | /* I kind of count that compiler optimizes away this assertion, */ |
47 | 0 | assert(sizeof(sh[0]) == 4); /* as this holds true for all, */ |
48 | | /* but 16-bit platforms... */ |
49 | | |
50 | 0 | #endif |
51 | | |
52 | 0 | if (numbits <= 0 || numbits > 64) |
53 | 0 | return; |
54 | 0 | iv = &(*ivec)[0]; |
55 | 0 | c2l(iv, v0); |
56 | 0 | c2l(iv, v1); |
57 | 0 | if (enc) { |
58 | 0 | while (l >= (unsigned long)n) { |
59 | 0 | l -= n; |
60 | 0 | ti[0] = v0; |
61 | 0 | ti[1] = v1; |
62 | 0 | DES_encrypt1((DES_LONG *)ti, schedule, DES_ENCRYPT); |
63 | 0 | c2ln(in, d0, d1, n); |
64 | 0 | in += n; |
65 | 0 | d0 ^= ti[0]; |
66 | 0 | d1 ^= ti[1]; |
67 | 0 | l2cn(d0, d1, out, n); |
68 | 0 | out += n; |
69 | | /* |
70 | | * 30-08-94 - eay - changed because l>>32 and l<<32 are bad under |
71 | | * gcc :-( |
72 | | */ |
73 | 0 | if (numbits == 32) { |
74 | 0 | v0 = v1; |
75 | 0 | v1 = d0; |
76 | 0 | } else if (numbits == 64) { |
77 | 0 | v0 = d0; |
78 | 0 | v1 = d1; |
79 | 0 | } else { |
80 | | #ifndef L_ENDIAN |
81 | | iv = &ovec[0]; |
82 | | l2c(v0, iv); |
83 | | l2c(v1, iv); |
84 | | l2c(d0, iv); |
85 | | l2c(d1, iv); |
86 | | #else |
87 | 0 | sh[0] = v0, sh[1] = v1, sh[2] = d0, sh[3] = d1; |
88 | 0 | #endif |
89 | 0 | if (rem == 0) |
90 | 0 | memmove(ovec, ovec + num, 8); |
91 | 0 | else |
92 | 0 | for (i = 0; i < 8; ++i) |
93 | 0 | ovec[i] = ovec[i + num] << rem | |
94 | 0 | ovec[i + num + 1] >> (8 - rem); |
95 | 0 | #ifdef L_ENDIAN |
96 | 0 | v0 = sh[0], v1 = sh[1]; |
97 | | #else |
98 | | iv = &ovec[0]; |
99 | | c2l(iv, v0); |
100 | | c2l(iv, v1); |
101 | | #endif |
102 | 0 | } |
103 | 0 | } |
104 | 0 | } else { |
105 | 0 | while (l >= (unsigned long)n) { |
106 | 0 | l -= n; |
107 | 0 | ti[0] = v0; |
108 | 0 | ti[1] = v1; |
109 | 0 | DES_encrypt1((DES_LONG *)ti, schedule, DES_ENCRYPT); |
110 | 0 | c2ln(in, d0, d1, n); |
111 | 0 | in += n; |
112 | | /* |
113 | | * 30-08-94 - eay - changed because l>>32 and l<<32 are bad under |
114 | | * gcc :-( |
115 | | */ |
116 | 0 | if (numbits == 32) { |
117 | 0 | v0 = v1; |
118 | 0 | v1 = d0; |
119 | 0 | } else if (numbits == 64) { |
120 | 0 | v0 = d0; |
121 | 0 | v1 = d1; |
122 | 0 | } else { |
123 | | #ifndef L_ENDIAN |
124 | | iv = &ovec[0]; |
125 | | l2c(v0, iv); |
126 | | l2c(v1, iv); |
127 | | l2c(d0, iv); |
128 | | l2c(d1, iv); |
129 | | #else |
130 | 0 | sh[0] = v0, sh[1] = v1, sh[2] = d0, sh[3] = d1; |
131 | 0 | #endif |
132 | 0 | if (rem == 0) |
133 | 0 | memmove(ovec, ovec + num, 8); |
134 | 0 | else |
135 | 0 | for (i = 0; i < 8; ++i) |
136 | 0 | ovec[i] = ovec[i + num] << rem | |
137 | 0 | ovec[i + num + 1] >> (8 - rem); |
138 | 0 | #ifdef L_ENDIAN |
139 | 0 | v0 = sh[0], v1 = sh[1]; |
140 | | #else |
141 | | iv = &ovec[0]; |
142 | | c2l(iv, v0); |
143 | | c2l(iv, v1); |
144 | | #endif |
145 | 0 | } |
146 | 0 | d0 ^= ti[0]; |
147 | 0 | d1 ^= ti[1]; |
148 | 0 | l2cn(d0, d1, out, n); |
149 | 0 | out += n; |
150 | 0 | } |
151 | 0 | } |
152 | 0 | iv = &(*ivec)[0]; |
153 | 0 | l2c(v0, iv); |
154 | 0 | l2c(v1, iv); |
155 | 0 | v0 = v1 = d0 = d1 = ti[0] = ti[1] = 0; |
156 | 0 | } |