]>
Commit | Line | Data |
---|---|---|
62867571 | 1 | /* |
3c2bdd7d | 2 | * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. |
d02b48c6 | 3 | * |
4a8b0c55 | 4 | * Licensed under the Apache License 2.0 (the "License"). You may not use |
62867571 RS |
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 | |
d02b48c6 RE |
8 | */ |
9 | ||
c6fec81b P |
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 | ||
d02b48c6 | 16 | #include <stdio.h> |
b39fc560 | 17 | #include "internal/cryptlib.h" |
9e9e8cb6 | 18 | #ifndef OPENSSL_NO_DES |
0f113f3e | 19 | # include <openssl/objects.h> |
25f2138b | 20 | # include "crypto/evp.h" |
4d49b685 | 21 | # include "crypto/sha.h" |
0f113f3e MC |
22 | # include <openssl/des.h> |
23 | # include <openssl/rand.h> | |
706457b7 | 24 | # include "evp_local.h" |
0f113f3e MC |
25 | |
26 | typedef struct { | |
27 | union { | |
39147079 | 28 | OSSL_UNION_ALIGN; |
0f113f3e MC |
29 | DES_key_schedule ks[3]; |
30 | } ks; | |
31 | union { | |
7687f525 AP |
32 | void (*cbc) (const void *, void *, size_t, |
33 | const DES_key_schedule *, unsigned char *); | |
0f113f3e MC |
34 | } stream; |
35 | } DES_EDE_KEY; | |
36 | # define ks1 ks.ks[0] | |
37 | # define ks2 ks.ks[1] | |
38 | # define ks3 ks.ks[2] | |
39 | ||
40 | # if defined(AES_ASM) && (defined(__sparc) || defined(__sparc__)) | |
c5d975a7 AP |
41 | /* ---------^^^ this is not a typo, just a way to detect that |
42 | * assembler support was in general requested... */ | |
52f7e44e | 43 | # include "crypto/sparc_arch.h" |
c5d975a7 | 44 | |
0f113f3e | 45 | # define SPARC_DES_CAPABLE (OPENSSL_sparcv9cap_P[1] & CFR_DES) |
c5d975a7 | 46 | |
0f113f3e MC |
47 | void des_t4_key_expand(const void *key, DES_key_schedule *ks); |
48 | void des_t4_ede3_cbc_encrypt(const void *inp, void *out, size_t len, | |
7687f525 | 49 | const DES_key_schedule ks[3], unsigned char iv[8]); |
0f113f3e | 50 | void des_t4_ede3_cbc_decrypt(const void *inp, void *out, size_t len, |
7687f525 | 51 | const DES_key_schedule ks[3], unsigned char iv[8]); |
0f113f3e | 52 | # endif |
c5d975a7 | 53 | |
1921eaad | 54 | static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, |
0f113f3e | 55 | const unsigned char *iv, int enc); |
57ae2e24 | 56 | |
1921eaad | 57 | static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, |
0f113f3e | 58 | const unsigned char *iv, int enc); |
d02b48c6 | 59 | |
216659eb DSH |
60 | static int des3_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr); |
61 | ||
6435f0f6 | 62 | # define data(ctx) EVP_C_DATA(DES_EDE_KEY,ctx) |
dbad1690 | 63 | |
0f113f3e MC |
64 | /* |
65 | * Because of various casts and different args can't use | |
66 | * IMPLEMENT_BLOCK_CIPHER | |
67 | */ | |
d02b48c6 | 68 | |
1921eaad | 69 | static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
0f113f3e | 70 | const unsigned char *in, size_t inl) |
57ae2e24 | 71 | { |
0f113f3e MC |
72 | BLOCK_CIPHER_ecb_loop() |
73 | DES_ecb3_encrypt((const_DES_cblock *)(in + i), | |
74 | (DES_cblock *)(out + i), | |
75 | &data(ctx)->ks1, &data(ctx)->ks2, | |
ed576acd | 76 | &data(ctx)->ks3, EVP_CIPHER_CTX_is_encrypting(ctx)); |
0f113f3e | 77 | return 1; |
57ae2e24 DSH |
78 | } |
79 | ||
1921eaad | 80 | static int des_ede_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
0f113f3e | 81 | const unsigned char *in, size_t inl) |
57ae2e24 | 82 | { |
0f113f3e | 83 | while (inl >= EVP_MAXCHUNK) { |
ed576acd | 84 | int num = EVP_CIPHER_CTX_get_num(ctx); |
0f113f3e MC |
85 | DES_ede3_ofb64_encrypt(in, out, (long)EVP_MAXCHUNK, |
86 | &data(ctx)->ks1, &data(ctx)->ks2, | |
6435f0f6 | 87 | &data(ctx)->ks3, |
c4d21d2f | 88 | (DES_cblock *)ctx->iv, |
6435f0f6 RL |
89 | &num); |
90 | EVP_CIPHER_CTX_set_num(ctx, num); | |
0f113f3e MC |
91 | inl -= EVP_MAXCHUNK; |
92 | in += EVP_MAXCHUNK; | |
93 | out += EVP_MAXCHUNK; | |
94 | } | |
6435f0f6 | 95 | if (inl) { |
ed576acd | 96 | int num = EVP_CIPHER_CTX_get_num(ctx); |
0f113f3e MC |
97 | DES_ede3_ofb64_encrypt(in, out, (long)inl, |
98 | &data(ctx)->ks1, &data(ctx)->ks2, | |
6435f0f6 | 99 | &data(ctx)->ks3, |
c4d21d2f | 100 | (DES_cblock *)ctx->iv, |
6435f0f6 RL |
101 | &num); |
102 | EVP_CIPHER_CTX_set_num(ctx, num); | |
103 | } | |
0f113f3e | 104 | return 1; |
57ae2e24 DSH |
105 | } |
106 | ||
1921eaad | 107 | static int des_ede_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
0f113f3e | 108 | const unsigned char *in, size_t inl) |
57ae2e24 | 109 | { |
0f113f3e | 110 | DES_EDE_KEY *dat = data(ctx); |
c5d975a7 | 111 | |
7687f525 AP |
112 | if (dat->stream.cbc != NULL) { |
113 | (*dat->stream.cbc) (in, out, inl, dat->ks.ks, | |
c4d21d2f | 114 | ctx->iv); |
0f113f3e MC |
115 | return 1; |
116 | } | |
117 | ||
118 | while (inl >= EVP_MAXCHUNK) { | |
119 | DES_ede3_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, | |
120 | &dat->ks1, &dat->ks2, &dat->ks3, | |
c4d21d2f | 121 | (DES_cblock *)ctx->iv, |
ed576acd | 122 | EVP_CIPHER_CTX_is_encrypting(ctx)); |
0f113f3e MC |
123 | inl -= EVP_MAXCHUNK; |
124 | in += EVP_MAXCHUNK; | |
125 | out += EVP_MAXCHUNK; | |
126 | } | |
127 | if (inl) | |
128 | DES_ede3_cbc_encrypt(in, out, (long)inl, | |
129 | &dat->ks1, &dat->ks2, &dat->ks3, | |
c4d21d2f | 130 | (DES_cblock *)ctx->iv, |
ed576acd | 131 | EVP_CIPHER_CTX_is_encrypting(ctx)); |
0f113f3e | 132 | return 1; |
57ae2e24 DSH |
133 | } |
134 | ||
8c6336b0 | 135 | static int des_ede_cfb64_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
0f113f3e | 136 | const unsigned char *in, size_t inl) |
57ae2e24 | 137 | { |
0f113f3e | 138 | while (inl >= EVP_MAXCHUNK) { |
ed576acd | 139 | int num = EVP_CIPHER_CTX_get_num(ctx); |
0f113f3e MC |
140 | DES_ede3_cfb64_encrypt(in, out, (long)EVP_MAXCHUNK, |
141 | &data(ctx)->ks1, &data(ctx)->ks2, | |
c4d21d2f | 142 | &data(ctx)->ks3, (DES_cblock *)ctx->iv, |
ed576acd | 143 | &num, EVP_CIPHER_CTX_is_encrypting(ctx)); |
6435f0f6 | 144 | EVP_CIPHER_CTX_set_num(ctx, num); |
0f113f3e MC |
145 | inl -= EVP_MAXCHUNK; |
146 | in += EVP_MAXCHUNK; | |
147 | out += EVP_MAXCHUNK; | |
148 | } | |
6435f0f6 | 149 | if (inl) { |
ed576acd | 150 | int num = EVP_CIPHER_CTX_get_num(ctx); |
0f113f3e MC |
151 | DES_ede3_cfb64_encrypt(in, out, (long)inl, |
152 | &data(ctx)->ks1, &data(ctx)->ks2, | |
c4d21d2f | 153 | &data(ctx)->ks3, (DES_cblock *)ctx->iv, |
ed576acd | 154 | &num, EVP_CIPHER_CTX_is_encrypting(ctx)); |
6435f0f6 RL |
155 | EVP_CIPHER_CTX_set_num(ctx, num); |
156 | } | |
0f113f3e | 157 | return 1; |
57ae2e24 DSH |
158 | } |
159 | ||
0f113f3e MC |
160 | /* |
161 | * Although we have a CFB-r implementation for 3-DES, it doesn't pack the | |
162 | * right way, so wrap it here | |
163 | */ | |
8c6336b0 | 164 | static int des_ede3_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
0f113f3e MC |
165 | const unsigned char *in, size_t inl) |
166 | { | |
b444ac3e | 167 | size_t n; |
0f113f3e MC |
168 | unsigned char c[1], d[1]; |
169 | ||
fe2d1491 RS |
170 | if (!EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) |
171 | inl *= 8; | |
0f113f3e MC |
172 | for (n = 0; n < inl; ++n) { |
173 | c[0] = (in[n / 8] & (1 << (7 - n % 8))) ? 0x80 : 0; | |
174 | DES_ede3_cfb_encrypt(c, d, 1, 1, | |
175 | &data(ctx)->ks1, &data(ctx)->ks2, | |
c4d21d2f | 176 | &data(ctx)->ks3, (DES_cblock *)ctx->iv, |
ed576acd | 177 | EVP_CIPHER_CTX_is_encrypting(ctx)); |
0f113f3e MC |
178 | out[n / 8] = (out[n / 8] & ~(0x80 >> (unsigned int)(n % 8))) |
179 | | ((d[0] & 0x80) >> (unsigned int)(n % 8)); | |
180 | } | |
8c6336b0 AP |
181 | |
182 | return 1; | |
0f113f3e | 183 | } |
8c6336b0 AP |
184 | |
185 | static int des_ede3_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
0f113f3e MC |
186 | const unsigned char *in, size_t inl) |
187 | { | |
188 | while (inl >= EVP_MAXCHUNK) { | |
189 | DES_ede3_cfb_encrypt(in, out, 8, (long)EVP_MAXCHUNK, | |
190 | &data(ctx)->ks1, &data(ctx)->ks2, | |
c4d21d2f | 191 | &data(ctx)->ks3, (DES_cblock *)ctx->iv, |
ed576acd | 192 | EVP_CIPHER_CTX_is_encrypting(ctx)); |
0f113f3e MC |
193 | inl -= EVP_MAXCHUNK; |
194 | in += EVP_MAXCHUNK; | |
195 | out += EVP_MAXCHUNK; | |
196 | } | |
b444ac3e | 197 | if (inl) |
0f113f3e MC |
198 | DES_ede3_cfb_encrypt(in, out, 8, (long)inl, |
199 | &data(ctx)->ks1, &data(ctx)->ks2, | |
c4d21d2f | 200 | &data(ctx)->ks3, (DES_cblock *)ctx->iv, |
ed576acd | 201 | EVP_CIPHER_CTX_is_encrypting(ctx)); |
8c6336b0 | 202 | return 1; |
0f113f3e | 203 | } |
8c6336b0 | 204 | |
a6cd8707 | 205 | BLOCK_CIPHER_defs(des_ede, DES_EDE_KEY, NID_des_ede, 8, 16, 8, 64, |
0f113f3e MC |
206 | EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1, |
207 | des_ede_init_key, NULL, NULL, NULL, des3_ctrl) | |
208 | # define des_ede3_cfb64_cipher des_ede_cfb64_cipher | |
209 | # define des_ede3_ofb_cipher des_ede_ofb_cipher | |
210 | # define des_ede3_cbc_cipher des_ede_cbc_cipher | |
211 | # define des_ede3_ecb_cipher des_ede_ecb_cipher | |
212 | BLOCK_CIPHER_defs(des_ede3, DES_EDE_KEY, NID_des_ede3, 8, 24, 8, 64, | |
213 | EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1, | |
214 | des_ede3_init_key, NULL, NULL, NULL, des3_ctrl) | |
215 | ||
216 | BLOCK_CIPHER_def_cfb(des_ede3, DES_EDE_KEY, NID_des_ede3, 24, 8, 1, | |
217 | EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1, | |
218 | des_ede3_init_key, NULL, NULL, NULL, des3_ctrl) | |
219 | ||
220 | BLOCK_CIPHER_def_cfb(des_ede3, DES_EDE_KEY, NID_des_ede3, 24, 8, 8, | |
221 | EVP_CIPH_RAND_KEY | EVP_CIPH_FLAG_DEFAULT_ASN1, | |
222 | des_ede3_init_key, NULL, NULL, NULL, des3_ctrl) | |
8c6336b0 | 223 | |
1921eaad | 224 | static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, |
0f113f3e MC |
225 | const unsigned char *iv, int enc) |
226 | { | |
227 | DES_cblock *deskey = (DES_cblock *)key; | |
228 | DES_EDE_KEY *dat = data(ctx); | |
229 | ||
230 | dat->stream.cbc = NULL; | |
231 | # if defined(SPARC_DES_CAPABLE) | |
232 | if (SPARC_DES_CAPABLE) { | |
ed576acd | 233 | int mode = EVP_CIPHER_CTX_get_mode(ctx); |
0f113f3e MC |
234 | |
235 | if (mode == EVP_CIPH_CBC_MODE) { | |
236 | des_t4_key_expand(&deskey[0], &dat->ks1); | |
237 | des_t4_key_expand(&deskey[1], &dat->ks2); | |
238 | memcpy(&dat->ks3, &dat->ks1, sizeof(dat->ks1)); | |
239 | dat->stream.cbc = enc ? des_t4_ede3_cbc_encrypt : | |
240 | des_t4_ede3_cbc_decrypt; | |
241 | return 1; | |
242 | } | |
243 | } | |
244 | # endif | |
0f113f3e MC |
245 | DES_set_key_unchecked(&deskey[0], &dat->ks1); |
246 | DES_set_key_unchecked(&deskey[1], &dat->ks2); | |
0f113f3e MC |
247 | memcpy(&dat->ks3, &dat->ks1, sizeof(dat->ks1)); |
248 | return 1; | |
249 | } | |
d02b48c6 | 250 | |
1921eaad | 251 | static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, |
0f113f3e MC |
252 | const unsigned char *iv, int enc) |
253 | { | |
254 | DES_cblock *deskey = (DES_cblock *)key; | |
255 | DES_EDE_KEY *dat = data(ctx); | |
c5d975a7 | 256 | |
0f113f3e MC |
257 | dat->stream.cbc = NULL; |
258 | # if defined(SPARC_DES_CAPABLE) | |
259 | if (SPARC_DES_CAPABLE) { | |
ed576acd | 260 | int mode = EVP_CIPHER_CTX_get_mode(ctx); |
0f113f3e MC |
261 | |
262 | if (mode == EVP_CIPH_CBC_MODE) { | |
263 | des_t4_key_expand(&deskey[0], &dat->ks1); | |
264 | des_t4_key_expand(&deskey[1], &dat->ks2); | |
265 | des_t4_key_expand(&deskey[2], &dat->ks3); | |
266 | dat->stream.cbc = enc ? des_t4_ede3_cbc_encrypt : | |
267 | des_t4_ede3_cbc_decrypt; | |
268 | return 1; | |
269 | } | |
270 | } | |
271 | # endif | |
0f113f3e MC |
272 | DES_set_key_unchecked(&deskey[0], &dat->ks1); |
273 | DES_set_key_unchecked(&deskey[1], &dat->ks2); | |
274 | DES_set_key_unchecked(&deskey[2], &dat->ks3); | |
0f113f3e MC |
275 | return 1; |
276 | } | |
57ae2e24 | 277 | |
6435f0f6 | 278 | static int des3_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) |
0f113f3e MC |
279 | { |
280 | ||
281 | DES_cblock *deskey = ptr; | |
6521cb03 | 282 | int kl; |
0f113f3e MC |
283 | |
284 | switch (type) { | |
285 | case EVP_CTRL_RAND_KEY: | |
ed576acd | 286 | kl = EVP_CIPHER_CTX_get_key_length(ctx); |
6521cb03 | 287 | if (kl < 0 || RAND_priv_bytes(ptr, kl) <= 0) |
0f113f3e MC |
288 | return 0; |
289 | DES_set_odd_parity(deskey); | |
6521cb03 | 290 | if (kl >= 16) |
0f113f3e | 291 | DES_set_odd_parity(deskey + 1); |
6521cb03 | 292 | if (kl >= 24) |
0f113f3e MC |
293 | DES_set_odd_parity(deskey + 2); |
294 | return 1; | |
295 | ||
296 | default: | |
297 | return -1; | |
298 | } | |
299 | } | |
216659eb | 300 | |
13588350 | 301 | const EVP_CIPHER *EVP_des_ede(void) |
57ae2e24 | 302 | { |
0f113f3e | 303 | return &des_ede_ecb; |
57ae2e24 DSH |
304 | } |
305 | ||
13588350 | 306 | const EVP_CIPHER *EVP_des_ede3(void) |
57ae2e24 | 307 | { |
0f113f3e | 308 | return &des_ede3_ecb; |
57ae2e24 | 309 | } |
97cf1f6c | 310 | |
97cf1f6c | 311 | |
474e469b | 312 | # include <openssl/sha.h> |
97cf1f6c | 313 | |
0f113f3e MC |
314 | static const unsigned char wrap_iv[8] = |
315 | { 0x4a, 0xdd, 0xa2, 0x2c, 0x79, 0xe8, 0x21, 0x05 }; | |
97cf1f6c DSH |
316 | |
317 | static int des_ede3_unwrap(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
0f113f3e MC |
318 | const unsigned char *in, size_t inl) |
319 | { | |
320 | unsigned char icv[8], iv[8], sha1tmp[SHA_DIGEST_LENGTH]; | |
321 | int rv = -1; | |
322 | if (inl < 24) | |
323 | return -1; | |
7687f525 | 324 | if (out == NULL) |
0f113f3e | 325 | return inl - 16; |
c4d21d2f | 326 | memcpy(ctx->iv, wrap_iv, 8); |
0f113f3e MC |
327 | /* Decrypt first block which will end up as icv */ |
328 | des_ede_cbc_cipher(ctx, icv, in, 8); | |
329 | /* Decrypt central blocks */ | |
330 | /* | |
331 | * If decrypting in place move whole output along a block so the next | |
332 | * des_ede_cbc_cipher is in place. | |
333 | */ | |
334 | if (out == in) { | |
335 | memmove(out, out + 8, inl - 8); | |
336 | in -= 8; | |
337 | } | |
338 | des_ede_cbc_cipher(ctx, out, in + 8, inl - 16); | |
339 | /* Decrypt final block which will be IV */ | |
340 | des_ede_cbc_cipher(ctx, iv, in + inl - 8, 8); | |
341 | /* Reverse order of everything */ | |
342 | BUF_reverse(icv, NULL, 8); | |
343 | BUF_reverse(out, NULL, inl - 16); | |
c4d21d2f | 344 | BUF_reverse(ctx->iv, iv, 8); |
0f113f3e MC |
345 | /* Decrypt again using new IV */ |
346 | des_ede_cbc_cipher(ctx, out, out, inl - 16); | |
347 | des_ede_cbc_cipher(ctx, icv, icv, 8); | |
4d49b685 DDO |
348 | if (ossl_sha1(out, inl - 16, sha1tmp) /* Work out hash of first portion */ |
349 | && CRYPTO_memcmp(sha1tmp, icv, 8) == 0) | |
0f113f3e MC |
350 | rv = inl - 16; |
351 | OPENSSL_cleanse(icv, 8); | |
352 | OPENSSL_cleanse(sha1tmp, SHA_DIGEST_LENGTH); | |
353 | OPENSSL_cleanse(iv, 8); | |
c4d21d2f | 354 | OPENSSL_cleanse(ctx->iv, 8); |
0f113f3e MC |
355 | if (rv == -1) |
356 | OPENSSL_cleanse(out, inl - 16); | |
357 | ||
358 | return rv; | |
359 | } | |
97cf1f6c DSH |
360 | |
361 | static int des_ede3_wrap(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
0f113f3e MC |
362 | const unsigned char *in, size_t inl) |
363 | { | |
364 | unsigned char sha1tmp[SHA_DIGEST_LENGTH]; | |
7687f525 | 365 | if (out == NULL) |
0f113f3e MC |
366 | return inl + 16; |
367 | /* Copy input to output buffer + 8 so we have space for IV */ | |
368 | memmove(out + 8, in, inl); | |
369 | /* Work out ICV */ | |
4d49b685 DDO |
370 | if (!ossl_sha1(in, inl, sha1tmp)) |
371 | return -1; | |
0f113f3e MC |
372 | memcpy(out + inl + 8, sha1tmp, 8); |
373 | OPENSSL_cleanse(sha1tmp, SHA_DIGEST_LENGTH); | |
374 | /* Generate random IV */ | |
c4d21d2f | 375 | if (RAND_bytes(ctx->iv, 8) <= 0) |
266483d2 | 376 | return -1; |
c4d21d2f | 377 | memcpy(out, ctx->iv, 8); |
0f113f3e MC |
378 | /* Encrypt everything after IV in place */ |
379 | des_ede_cbc_cipher(ctx, out + 8, out + 8, inl + 8); | |
380 | BUF_reverse(out, NULL, inl + 16); | |
c4d21d2f | 381 | memcpy(ctx->iv, wrap_iv, 8); |
0f113f3e MC |
382 | des_ede_cbc_cipher(ctx, out, out, inl + 16); |
383 | return inl + 16; | |
384 | } | |
97cf1f6c DSH |
385 | |
386 | static int des_ede3_wrap_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
0f113f3e MC |
387 | const unsigned char *in, size_t inl) |
388 | { | |
389 | /* | |
390 | * Sanity check input length: we typically only wrap keys so EVP_MAXCHUNK | |
391 | * is more than will ever be needed. Also input length must be a multiple | |
392 | * of 8 bits. | |
393 | */ | |
394 | if (inl >= EVP_MAXCHUNK || inl % 8) | |
395 | return -1; | |
7141ba31 | 396 | |
6d777689 | 397 | if (ossl_is_partially_overlapping(out, in, inl)) { |
9311d0c4 | 398 | ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING); |
7141ba31 MC |
399 | return 0; |
400 | } | |
401 | ||
ed576acd | 402 | if (EVP_CIPHER_CTX_is_encrypting(ctx)) |
0f113f3e MC |
403 | return des_ede3_wrap(ctx, out, in, inl); |
404 | else | |
405 | return des_ede3_unwrap(ctx, out, in, inl); | |
406 | } | |
97cf1f6c DSH |
407 | |
408 | static const EVP_CIPHER des3_wrap = { | |
0f113f3e MC |
409 | NID_id_smime_alg_CMS3DESwrap, |
410 | 8, 24, 0, | |
411 | EVP_CIPH_WRAP_MODE | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER | |
412 | | EVP_CIPH_FLAG_DEFAULT_ASN1, | |
f6c95e46 | 413 | EVP_ORIG_GLOBAL, |
0f113f3e MC |
414 | des_ede3_init_key, des_ede3_wrap_cipher, |
415 | NULL, | |
416 | sizeof(DES_EDE_KEY), | |
417 | NULL, NULL, NULL, NULL | |
418 | }; | |
97cf1f6c DSH |
419 | |
420 | const EVP_CIPHER *EVP_des_ede3_wrap(void) | |
0f113f3e MC |
421 | { |
422 | return &des3_wrap; | |
423 | } | |
97cf1f6c | 424 | |
d02f751c | 425 | #endif |