/src/boringssl/crypto/cipher_extra/e_des.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
2 | | * All rights reserved. |
3 | | * |
4 | | * This package is an SSL implementation written |
5 | | * by Eric Young (eay@cryptsoft.com). |
6 | | * The implementation was written so as to conform with Netscapes SSL. |
7 | | * |
8 | | * This library is free for commercial and non-commercial use as long as |
9 | | * the following conditions are aheared to. The following conditions |
10 | | * apply to all code found in this distribution, be it the RC4, RSA, |
11 | | * lhash, DES, etc., code; not just the SSL code. The SSL documentation |
12 | | * included with this distribution is covered by the same copyright terms |
13 | | * except that the holder is Tim Hudson (tjh@cryptsoft.com). |
14 | | * |
15 | | * Copyright remains Eric Young's, and as such any Copyright notices in |
16 | | * the code are not to be removed. |
17 | | * If this package is used in a product, Eric Young should be given attribution |
18 | | * as the author of the parts of the library used. |
19 | | * This can be in the form of a textual message at program startup or |
20 | | * in documentation (online or textual) provided with the package. |
21 | | * |
22 | | * Redistribution and use in source and binary forms, with or without |
23 | | * modification, are permitted provided that the following conditions |
24 | | * are met: |
25 | | * 1. Redistributions of source code must retain the copyright |
26 | | * notice, this list of conditions and the following disclaimer. |
27 | | * 2. Redistributions in binary form must reproduce the above copyright |
28 | | * notice, this list of conditions and the following disclaimer in the |
29 | | * documentation and/or other materials provided with the distribution. |
30 | | * 3. All advertising materials mentioning features or use of this software |
31 | | * must display the following acknowledgement: |
32 | | * "This product includes cryptographic software written by |
33 | | * Eric Young (eay@cryptsoft.com)" |
34 | | * The word 'cryptographic' can be left out if the rouines from the library |
35 | | * being used are not cryptographic related :-). |
36 | | * 4. If you include any Windows specific code (or a derivative thereof) from |
37 | | * the apps directory (application code) you must include an acknowledgement: |
38 | | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
39 | | * |
40 | | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
41 | | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
42 | | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
43 | | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
44 | | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
45 | | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
46 | | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
47 | | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
48 | | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
49 | | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
50 | | * SUCH DAMAGE. |
51 | | * |
52 | | * The licence and distribution terms for any publically available version or |
53 | | * derivative of this code cannot be changed. i.e. this code cannot simply be |
54 | | * copied and put under another distribution licence |
55 | | * [including the GNU Public Licence.] */ |
56 | | |
57 | | #include <openssl/cipher.h> |
58 | | #include <openssl/des.h> |
59 | | #include <openssl/nid.h> |
60 | | |
61 | | #include "../des/internal.h" |
62 | | #include "../fipsmodule/cipher/internal.h" |
63 | | #include "internal.h" |
64 | | |
65 | | |
66 | | typedef struct { |
67 | | union { |
68 | | double align; |
69 | | DES_key_schedule ks; |
70 | | } ks; |
71 | | } EVP_DES_KEY; |
72 | | |
73 | | static int des_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key, |
74 | 1 | const uint8_t *iv, int enc) { |
75 | 1 | EVP_DES_KEY *dat = (EVP_DES_KEY *)ctx->cipher_data; |
76 | 1 | DES_set_key_ex(key, &dat->ks.ks); |
77 | 1 | return 1; |
78 | 1 | } |
79 | | |
80 | | static int des_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in, |
81 | 2 | size_t in_len) { |
82 | 2 | EVP_DES_KEY *dat = (EVP_DES_KEY *)ctx->cipher_data; |
83 | 2 | DES_ncbc_encrypt_ex(in, out, in_len, &dat->ks.ks, ctx->iv, ctx->encrypt); |
84 | 2 | return 1; |
85 | 2 | } |
86 | | |
87 | | static const EVP_CIPHER evp_des_cbc = { |
88 | | .nid = NID_des_cbc, |
89 | | .block_size = 8, |
90 | | .key_len = 8, |
91 | | .iv_len = 8, |
92 | | .ctx_size = sizeof(EVP_DES_KEY), |
93 | | .flags = EVP_CIPH_CBC_MODE, |
94 | | .init = des_init_key, |
95 | | .cipher = des_cbc_cipher, |
96 | | }; |
97 | | |
98 | 69 | const EVP_CIPHER *EVP_des_cbc(void) { return &evp_des_cbc; } |
99 | | |
100 | | static int des_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in, |
101 | 0 | size_t in_len) { |
102 | 0 | if (in_len < ctx->cipher->block_size) { |
103 | 0 | return 1; |
104 | 0 | } |
105 | 0 | in_len -= ctx->cipher->block_size; |
106 | |
|
107 | 0 | EVP_DES_KEY *dat = (EVP_DES_KEY *)ctx->cipher_data; |
108 | 0 | for (size_t i = 0; i <= in_len; i += ctx->cipher->block_size) { |
109 | 0 | DES_ecb_encrypt_ex(in + i, out + i, &dat->ks.ks, ctx->encrypt); |
110 | 0 | } |
111 | 0 | return 1; |
112 | 0 | } |
113 | | |
114 | | static const EVP_CIPHER evp_des_ecb = { |
115 | | .nid = NID_des_ecb, |
116 | | .block_size = 8, |
117 | | .key_len = 8, |
118 | | .iv_len = 0, |
119 | | .ctx_size = sizeof(EVP_DES_KEY), |
120 | | .flags = EVP_CIPH_ECB_MODE, |
121 | | .init = des_init_key, |
122 | | .cipher = des_ecb_cipher, |
123 | | }; |
124 | | |
125 | 10 | const EVP_CIPHER *EVP_des_ecb(void) { return &evp_des_ecb; } |
126 | | |
127 | | typedef struct { |
128 | | union { |
129 | | double align; |
130 | | DES_key_schedule ks[3]; |
131 | | } ks; |
132 | | } DES_EDE_KEY; |
133 | | |
134 | | static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key, |
135 | 16 | const uint8_t *iv, int enc) { |
136 | 16 | DES_EDE_KEY *dat = (DES_EDE_KEY *)ctx->cipher_data; |
137 | 16 | DES_set_key_ex(key, &dat->ks.ks[0]); |
138 | 16 | DES_set_key_ex(key + 8, &dat->ks.ks[1]); |
139 | 16 | DES_set_key_ex(key + 16, &dat->ks.ks[2]); |
140 | 16 | return 1; |
141 | 16 | } |
142 | | |
143 | | static int des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, |
144 | 2.14k | const uint8_t *in, size_t in_len) { |
145 | 2.14k | DES_EDE_KEY *dat = (DES_EDE_KEY *)ctx->cipher_data; |
146 | 2.14k | DES_ede3_cbc_encrypt_ex(in, out, in_len, &dat->ks.ks[0], &dat->ks.ks[1], |
147 | 2.14k | &dat->ks.ks[2], ctx->iv, ctx->encrypt); |
148 | 2.14k | return 1; |
149 | 2.14k | } |
150 | | |
151 | | static const EVP_CIPHER evp_des_ede3_cbc = { |
152 | | .nid = NID_des_ede3_cbc, |
153 | | .block_size = 8, |
154 | | .key_len = 24, |
155 | | .iv_len = 8, |
156 | | .ctx_size = sizeof(DES_EDE_KEY), |
157 | | .flags = EVP_CIPH_CBC_MODE, |
158 | | .init = des_ede3_init_key, |
159 | | .cipher = des_ede3_cbc_cipher, |
160 | | }; |
161 | | |
162 | 105 | const EVP_CIPHER *EVP_des_ede3_cbc(void) { return &evp_des_ede3_cbc; } |
163 | | |
164 | | static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key, |
165 | 94 | const uint8_t *iv, int enc) { |
166 | 94 | DES_EDE_KEY *dat = (DES_EDE_KEY *)ctx->cipher_data; |
167 | | // 2-DES is 3-DES with the first key used twice. |
168 | 94 | DES_set_key_ex(key, &dat->ks.ks[0]); |
169 | 94 | DES_set_key_ex(key + 8, &dat->ks.ks[1]); |
170 | 94 | DES_set_key_ex(key, &dat->ks.ks[2]); |
171 | 94 | return 1; |
172 | 94 | } |
173 | | |
174 | | static const EVP_CIPHER evp_des_ede_cbc = { |
175 | | .nid = NID_des_ede_cbc, |
176 | | .block_size = 8, |
177 | | .key_len = 16, |
178 | | .iv_len = 8, |
179 | | .ctx_size = sizeof(DES_EDE_KEY), |
180 | | .flags = EVP_CIPH_CBC_MODE, |
181 | | .init = des_ede_init_key, |
182 | | .cipher = des_ede3_cbc_cipher, |
183 | | }; |
184 | | |
185 | 203 | const EVP_CIPHER *EVP_des_ede_cbc(void) { return &evp_des_ede_cbc; } |
186 | | |
187 | | static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, |
188 | 0 | const uint8_t *in, size_t in_len) { |
189 | 0 | if (in_len < ctx->cipher->block_size) { |
190 | 0 | return 1; |
191 | 0 | } |
192 | 0 | in_len -= ctx->cipher->block_size; |
193 | |
|
194 | 0 | DES_EDE_KEY *dat = (DES_EDE_KEY *) ctx->cipher_data; |
195 | 0 | for (size_t i = 0; i <= in_len; i += ctx->cipher->block_size) { |
196 | 0 | DES_ecb3_encrypt_ex(in + i, out + i, &dat->ks.ks[0], &dat->ks.ks[1], |
197 | 0 | &dat->ks.ks[2], ctx->encrypt); |
198 | 0 | } |
199 | 0 | return 1; |
200 | 0 | } |
201 | | |
202 | | static const EVP_CIPHER evp_des_ede = { |
203 | | .nid = NID_des_ede_ecb, |
204 | | .block_size = 8, |
205 | | .key_len = 16, |
206 | | .iv_len = 0, |
207 | | .ctx_size = sizeof(DES_EDE_KEY), |
208 | | .flags = EVP_CIPH_ECB_MODE, |
209 | | .init = des_ede_init_key, |
210 | | .cipher = des_ede_ecb_cipher, |
211 | | }; |
212 | | |
213 | 18 | const EVP_CIPHER *EVP_des_ede(void) { return &evp_des_ede; } |
214 | | |
215 | | static const EVP_CIPHER evp_des_ede3 = { |
216 | | .nid = NID_des_ede3_ecb, |
217 | | .block_size = 8, |
218 | | .key_len = 24, |
219 | | .iv_len = 0, |
220 | | .ctx_size = sizeof(DES_EDE_KEY), |
221 | | .flags = EVP_CIPH_ECB_MODE, |
222 | | .init = des_ede3_init_key, |
223 | | .cipher = des_ede_ecb_cipher, |
224 | | }; |
225 | | |
226 | 21 | const EVP_CIPHER *EVP_des_ede3(void) { return &evp_des_ede3; } |
227 | | |
228 | 0 | const EVP_CIPHER *EVP_des_ede3_ecb(void) { return EVP_des_ede3(); } |