]>
Commit | Line | Data |
---|---|---|
dd030860 BM |
1 | /* ==================================================================== |
2 | * Copyright (c) 2006 The OpenSSL Project. All rights reserved. | |
3 | * | |
4 | * Redistribution and use in source and binary forms, with or without | |
5 | * modification, are permitted provided that the following conditions | |
6 | * are met: | |
7 | * | |
8 | * 1. Redistributions of source code must retain the above copyright | |
0f113f3e | 9 | * notice, this list of conditions and the following disclaimer. |
dd030860 BM |
10 | * |
11 | * 2. Redistributions in binary form must reproduce the above copyright | |
12 | * notice, this list of conditions and the following disclaimer in | |
13 | * the documentation and/or other materials provided with the | |
14 | * distribution. | |
15 | * | |
16 | * 3. All advertising materials mentioning features or use of this | |
17 | * software must display the following acknowledgment: | |
18 | * "This product includes software developed by the OpenSSL Project | |
19 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | |
20 | * | |
21 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | |
22 | * endorse or promote products derived from this software without | |
23 | * prior written permission. For written permission, please contact | |
24 | * openssl-core@openssl.org. | |
25 | * | |
26 | * 5. Products derived from this software may not be called "OpenSSL" | |
27 | * nor may "OpenSSL" appear in their names without prior written | |
28 | * permission of the OpenSSL Project. | |
29 | * | |
30 | * 6. Redistributions of any form whatsoever must retain the following | |
31 | * acknowledgment: | |
32 | * "This product includes software developed by the OpenSSL Project | |
33 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | |
34 | * | |
35 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | |
36 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
37 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
38 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | |
39 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
40 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
41 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
42 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
43 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
44 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
45 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |
46 | * OF THE POSSIBILITY OF SUCH DAMAGE. | |
47 | * ==================================================================== | |
48 | * | |
49 | * This product includes cryptographic software written by Eric Young | |
50 | * (eay@cryptsoft.com). This product includes software written by Tim | |
51 | * Hudson (tjh@cryptsoft.com). | |
52 | * | |
53 | */ | |
54 | ||
55 | #include <openssl/opensslconf.h> | |
56 | #ifndef OPENSSL_NO_CAMELLIA | |
0f113f3e MC |
57 | # include <openssl/evp.h> |
58 | # include <openssl/err.h> | |
59 | # include <string.h> | |
60 | # include <assert.h> | |
61 | # include <openssl/camellia.h> | |
6435f0f6 | 62 | # include "internal/evp_int.h" |
0f113f3e | 63 | # include "modes_lcl.h" |
dd030860 BM |
64 | |
65 | static int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, | |
0f113f3e | 66 | const unsigned char *iv, int enc); |
dd030860 BM |
67 | |
68 | /* Camellia subkey Structure */ | |
0f113f3e MC |
69 | typedef struct { |
70 | CAMELLIA_KEY ks; | |
71 | block128_f block; | |
72 | union { | |
73 | cbc128_f cbc; | |
74 | ctr128_f ctr; | |
75 | } stream; | |
76 | } EVP_CAMELLIA_KEY; | |
77 | ||
78 | # define MAXBITCHUNK ((size_t)1<<(sizeof(size_t)*8-4)) | |
4739ccdb | 79 | |
dd030860 | 80 | /* Attribute operation for Camellia */ |
0f113f3e | 81 | # define data(ctx) EVP_C_DATA(EVP_CAMELLIA_KEY,ctx) |
dd030860 | 82 | |
0f113f3e | 83 | # if defined(AES_ASM) && (defined(__sparc) || defined(__sparc__)) |
4739ccdb AP |
84 | /* ---------^^^ this is not a typo, just a way to detect that |
85 | * assembler support was in general requested... */ | |
0f113f3e | 86 | # include "sparc_arch.h" |
4739ccdb AP |
87 | |
88 | extern unsigned int OPENSSL_sparcv9cap_P[]; | |
89 | ||
0f113f3e MC |
90 | # define SPARC_CMLL_CAPABLE (OPENSSL_sparcv9cap_P[1] & CFR_CAMELLIA) |
91 | ||
92 | void cmll_t4_set_key(const unsigned char *key, int bits, CAMELLIA_KEY *ks); | |
93 | void cmll_t4_encrypt(const unsigned char *in, unsigned char *out, | |
94 | const CAMELLIA_KEY *key); | |
95 | void cmll_t4_decrypt(const unsigned char *in, unsigned char *out, | |
96 | const CAMELLIA_KEY *key); | |
97 | ||
98 | void cmll128_t4_cbc_encrypt(const unsigned char *in, unsigned char *out, | |
99 | size_t len, const CAMELLIA_KEY *key, | |
100 | unsigned char *ivec); | |
101 | void cmll128_t4_cbc_decrypt(const unsigned char *in, unsigned char *out, | |
102 | size_t len, const CAMELLIA_KEY *key, | |
103 | unsigned char *ivec); | |
104 | void cmll256_t4_cbc_encrypt(const unsigned char *in, unsigned char *out, | |
105 | size_t len, const CAMELLIA_KEY *key, | |
106 | unsigned char *ivec); | |
107 | void cmll256_t4_cbc_decrypt(const unsigned char *in, unsigned char *out, | |
108 | size_t len, const CAMELLIA_KEY *key, | |
109 | unsigned char *ivec); | |
110 | void cmll128_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out, | |
111 | size_t blocks, const CAMELLIA_KEY *key, | |
112 | unsigned char *ivec); | |
113 | void cmll256_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out, | |
114 | size_t blocks, const CAMELLIA_KEY *key, | |
115 | unsigned char *ivec); | |
4739ccdb AP |
116 | |
117 | static int cmll_t4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, | |
0f113f3e MC |
118 | const unsigned char *iv, int enc) |
119 | { | |
120 | int ret, mode, bits; | |
0b3a231e | 121 | EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) EVP_CIPHER_CTX_cipher_data(ctx); |
0f113f3e | 122 | |
0b3a231e RS |
123 | mode = EVP_CIPHER_CTX_mode(ctx); |
124 | bits = EVP_CIPHER_CTX_key_length(ctx) * 8; | |
0f113f3e MC |
125 | |
126 | cmll_t4_set_key(key, bits, &dat->ks); | |
127 | ||
128 | if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE) | |
129 | && !enc) { | |
130 | ret = 0; | |
131 | dat->block = (block128_f) cmll_t4_decrypt; | |
132 | switch (bits) { | |
133 | case 128: | |
134 | dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ? | |
135 | (cbc128_f) cmll128_t4_cbc_decrypt : NULL; | |
136 | break; | |
137 | case 192: | |
138 | case 256: | |
139 | dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ? | |
140 | (cbc128_f) cmll256_t4_cbc_decrypt : NULL; | |
141 | break; | |
142 | default: | |
143 | ret = -1; | |
144 | } | |
145 | } else { | |
146 | ret = 0; | |
147 | dat->block = (block128_f) cmll_t4_encrypt; | |
148 | switch (bits) { | |
149 | case 128: | |
150 | if (mode == EVP_CIPH_CBC_MODE) | |
151 | dat->stream.cbc = (cbc128_f) cmll128_t4_cbc_encrypt; | |
152 | else if (mode == EVP_CIPH_CTR_MODE) | |
153 | dat->stream.ctr = (ctr128_f) cmll128_t4_ctr32_encrypt; | |
154 | else | |
155 | dat->stream.cbc = NULL; | |
156 | break; | |
157 | case 192: | |
158 | case 256: | |
159 | if (mode == EVP_CIPH_CBC_MODE) | |
160 | dat->stream.cbc = (cbc128_f) cmll256_t4_cbc_encrypt; | |
161 | else if (mode == EVP_CIPH_CTR_MODE) | |
162 | dat->stream.ctr = (ctr128_f) cmll256_t4_ctr32_encrypt; | |
163 | else | |
164 | dat->stream.cbc = NULL; | |
165 | break; | |
166 | default: | |
167 | ret = -1; | |
168 | } | |
169 | } | |
170 | ||
171 | if (ret < 0) { | |
172 | EVPerr(EVP_F_CMLL_T4_INIT_KEY, EVP_R_CAMELLIA_KEY_SETUP_FAILED); | |
173 | return 0; | |
174 | } | |
175 | ||
176 | return 1; | |
177 | } | |
178 | ||
179 | # define cmll_t4_cbc_cipher camellia_cbc_cipher | |
180 | static int cmll_t4_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
181 | const unsigned char *in, size_t len); | |
182 | ||
183 | # define cmll_t4_ecb_cipher camellia_ecb_cipher | |
184 | static int cmll_t4_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
185 | const unsigned char *in, size_t len); | |
186 | ||
187 | # define cmll_t4_ofb_cipher camellia_ofb_cipher | |
188 | static int cmll_t4_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
189 | const unsigned char *in, size_t len); | |
190 | ||
191 | # define cmll_t4_cfb_cipher camellia_cfb_cipher | |
192 | static int cmll_t4_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
193 | const unsigned char *in, size_t len); | |
194 | ||
195 | # define cmll_t4_cfb8_cipher camellia_cfb8_cipher | |
196 | static int cmll_t4_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
197 | const unsigned char *in, size_t len); | |
198 | ||
199 | # define cmll_t4_cfb1_cipher camellia_cfb1_cipher | |
200 | static int cmll_t4_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | |
201 | const unsigned char *in, size_t len); | |
202 | ||
203 | # define cmll_t4_ctr_cipher camellia_ctr_cipher | |
4739ccdb | 204 | static int cmll_t4_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
0f113f3e | 205 | const unsigned char *in, size_t len); |
4739ccdb | 206 | |
0f113f3e | 207 | # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \ |
4739ccdb | 208 | static const EVP_CIPHER cmll_t4_##keylen##_##mode = { \ |
0f113f3e MC |
209 | nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \ |
210 | flags|EVP_CIPH_##MODE##_MODE, \ | |
211 | cmll_t4_init_key, \ | |
212 | cmll_t4_##mode##_cipher, \ | |
213 | NULL, \ | |
214 | sizeof(EVP_CAMELLIA_KEY), \ | |
215 | NULL,NULL,NULL,NULL }; \ | |
4739ccdb | 216 | static const EVP_CIPHER camellia_##keylen##_##mode = { \ |
0f113f3e MC |
217 | nid##_##keylen##_##nmode,blocksize, \ |
218 | keylen/8,ivlen, \ | |
219 | flags|EVP_CIPH_##MODE##_MODE, \ | |
220 | camellia_init_key, \ | |
221 | camellia_##mode##_cipher, \ | |
222 | NULL, \ | |
223 | sizeof(EVP_CAMELLIA_KEY), \ | |
224 | NULL,NULL,NULL,NULL }; \ | |
4739ccdb AP |
225 | const EVP_CIPHER *EVP_camellia_##keylen##_##mode(void) \ |
226 | { return SPARC_CMLL_CAPABLE?&cmll_t4_##keylen##_##mode:&camellia_##keylen##_##mode; } | |
227 | ||
0f113f3e | 228 | # else |
4739ccdb | 229 | |
0f113f3e | 230 | # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \ |
4739ccdb | 231 | static const EVP_CIPHER camellia_##keylen##_##mode = { \ |
0f113f3e MC |
232 | nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \ |
233 | flags|EVP_CIPH_##MODE##_MODE, \ | |
234 | camellia_init_key, \ | |
235 | camellia_##mode##_cipher, \ | |
236 | NULL, \ | |
237 | sizeof(EVP_CAMELLIA_KEY), \ | |
238 | NULL,NULL,NULL,NULL }; \ | |
4739ccdb AP |
239 | const EVP_CIPHER *EVP_camellia_##keylen##_##mode(void) \ |
240 | { return &camellia_##keylen##_##mode; } | |
241 | ||
0f113f3e | 242 | # endif |
dd030860 | 243 | |
0f113f3e MC |
244 | # define BLOCK_CIPHER_generic_pack(nid,keylen,flags) \ |
245 | BLOCK_CIPHER_generic(nid,keylen,16,16,cbc,cbc,CBC,flags|EVP_CIPH_FLAG_DEFAULT_ASN1) \ | |
246 | BLOCK_CIPHER_generic(nid,keylen,16,0,ecb,ecb,ECB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1) \ | |
247 | BLOCK_CIPHER_generic(nid,keylen,1,16,ofb128,ofb,OFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1) \ | |
248 | BLOCK_CIPHER_generic(nid,keylen,1,16,cfb128,cfb,CFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1) \ | |
249 | BLOCK_CIPHER_generic(nid,keylen,1,16,cfb1,cfb1,CFB,flags) \ | |
dda81999 AP |
250 | BLOCK_CIPHER_generic(nid,keylen,1,16,cfb8,cfb8,CFB,flags) \ |
251 | BLOCK_CIPHER_generic(nid, keylen, 1, 16, ctr, ctr, CTR, flags) | |
252 | ||
0f113f3e | 253 | /* The subkey for Camellia is generated. */ |
dd030860 | 254 | static int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, |
0f113f3e | 255 | const unsigned char *iv, int enc) |
4739ccdb | 256 | { |
0f113f3e | 257 | int ret, mode; |
6435f0f6 | 258 | EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx); |
0f113f3e | 259 | |
6435f0f6 | 260 | ret = Camellia_set_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8, &dat->ks); |
0f113f3e MC |
261 | if (ret < 0) { |
262 | EVPerr(EVP_F_CAMELLIA_INIT_KEY, EVP_R_CAMELLIA_KEY_SETUP_FAILED); | |
263 | return 0; | |
264 | } | |
265 | ||
6435f0f6 | 266 | mode = EVP_CIPHER_CTX_mode(ctx); |
0f113f3e MC |
267 | if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE) |
268 | && !enc) { | |
269 | dat->block = (block128_f) Camellia_decrypt; | |
270 | dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ? | |
271 | (cbc128_f) Camellia_cbc_encrypt : NULL; | |
272 | } else { | |
273 | dat->block = (block128_f) Camellia_encrypt; | |
274 | dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ? | |
275 | (cbc128_f) Camellia_cbc_encrypt : NULL; | |
276 | } | |
277 | ||
278 | return 1; | |
279 | } | |
4739ccdb | 280 | |
0f113f3e MC |
281 | static int camellia_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
282 | const unsigned char *in, size_t len) | |
283 | { | |
6435f0f6 | 284 | EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx); |
0f113f3e MC |
285 | |
286 | if (dat->stream.cbc) | |
6435f0f6 RL |
287 | (*dat->stream.cbc) (in, out, len, &dat->ks, |
288 | EVP_CIPHER_CTX_iv_noconst(ctx), | |
289 | EVP_CIPHER_CTX_encrypting(ctx)); | |
290 | else if (EVP_CIPHER_CTX_encrypting(ctx)) | |
291 | CRYPTO_cbc128_encrypt(in, out, len, &dat->ks, | |
292 | EVP_CIPHER_CTX_iv_noconst(ctx), dat->block); | |
0f113f3e | 293 | else |
6435f0f6 RL |
294 | CRYPTO_cbc128_decrypt(in, out, len, &dat->ks, |
295 | EVP_CIPHER_CTX_iv_noconst(ctx), dat->block); | |
4739ccdb | 296 | |
0f113f3e | 297 | return 1; |
4739ccdb AP |
298 | } |
299 | ||
0f113f3e MC |
300 | static int camellia_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
301 | const unsigned char *in, size_t len) | |
4739ccdb | 302 | { |
6435f0f6 | 303 | size_t bl = EVP_CIPHER_CTX_block_size(ctx); |
0f113f3e | 304 | size_t i; |
6435f0f6 | 305 | EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx); |
4739ccdb | 306 | |
0f113f3e MC |
307 | if (len < bl) |
308 | return 1; | |
4739ccdb | 309 | |
0f113f3e MC |
310 | for (i = 0, len -= bl; i <= len; i += bl) |
311 | (*dat->block) (in + i, out + i, &dat->ks); | |
4739ccdb | 312 | |
0f113f3e | 313 | return 1; |
4739ccdb AP |
314 | } |
315 | ||
0f113f3e MC |
316 | static int camellia_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
317 | const unsigned char *in, size_t len) | |
4739ccdb | 318 | { |
6435f0f6 | 319 | EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx); |
4739ccdb | 320 | |
6435f0f6 | 321 | int num = EVP_CIPHER_CTX_num(ctx); |
0f113f3e | 322 | CRYPTO_ofb128_encrypt(in, out, len, &dat->ks, |
6435f0f6 RL |
323 | EVP_CIPHER_CTX_iv_noconst(ctx), &num, dat->block); |
324 | EVP_CIPHER_CTX_set_num(ctx, num); | |
0f113f3e | 325 | return 1; |
4739ccdb AP |
326 | } |
327 | ||
0f113f3e MC |
328 | static int camellia_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
329 | const unsigned char *in, size_t len) | |
4739ccdb | 330 | { |
6435f0f6 | 331 | EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx); |
4739ccdb | 332 | |
6435f0f6 | 333 | int num = EVP_CIPHER_CTX_num(ctx); |
0f113f3e | 334 | CRYPTO_cfb128_encrypt(in, out, len, &dat->ks, |
6435f0f6 RL |
335 | EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block); |
336 | EVP_CIPHER_CTX_set_num(ctx, num); | |
0f113f3e | 337 | return 1; |
4739ccdb AP |
338 | } |
339 | ||
0f113f3e MC |
340 | static int camellia_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
341 | const unsigned char *in, size_t len) | |
4739ccdb | 342 | { |
6435f0f6 | 343 | EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx); |
4739ccdb | 344 | |
6435f0f6 | 345 | int num = EVP_CIPHER_CTX_num(ctx); |
0f113f3e | 346 | CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks, |
6435f0f6 RL |
347 | EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block); |
348 | EVP_CIPHER_CTX_set_num(ctx, num); | |
0f113f3e | 349 | return 1; |
4739ccdb AP |
350 | } |
351 | ||
0f113f3e MC |
352 | static int camellia_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
353 | const unsigned char *in, size_t len) | |
4739ccdb | 354 | { |
6435f0f6 | 355 | EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx); |
0f113f3e | 356 | |
6435f0f6 RL |
357 | if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) { |
358 | int num = EVP_CIPHER_CTX_num(ctx); | |
0f113f3e | 359 | CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks, |
6435f0f6 RL |
360 | EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block); |
361 | EVP_CIPHER_CTX_set_num(ctx, num); | |
0f113f3e MC |
362 | return 1; |
363 | } | |
364 | ||
365 | while (len >= MAXBITCHUNK) { | |
6435f0f6 | 366 | int num = EVP_CIPHER_CTX_num(ctx); |
0f113f3e | 367 | CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks, |
6435f0f6 | 368 | EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block); |
0f113f3e | 369 | len -= MAXBITCHUNK; |
6435f0f6 | 370 | EVP_CIPHER_CTX_set_num(ctx, num); |
0f113f3e | 371 | } |
6435f0f6 RL |
372 | if (len) { |
373 | int num = EVP_CIPHER_CTX_num(ctx); | |
0f113f3e | 374 | CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks, |
6435f0f6 RL |
375 | EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block); |
376 | EVP_CIPHER_CTX_set_num(ctx, num); | |
377 | } | |
0f113f3e MC |
378 | |
379 | return 1; | |
4739ccdb AP |
380 | } |
381 | ||
0f113f3e MC |
382 | static int camellia_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
383 | const unsigned char *in, size_t len) | |
4739ccdb | 384 | { |
6435f0f6 RL |
385 | unsigned int num = EVP_CIPHER_CTX_num(ctx); |
386 | EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx); | |
0f113f3e MC |
387 | |
388 | if (dat->stream.ctr) | |
389 | CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks, | |
6435f0f6 RL |
390 | EVP_CIPHER_CTX_iv_noconst(ctx), |
391 | EVP_CIPHER_CTX_buf_noconst(ctx), &num, | |
392 | dat->stream.ctr); | |
0f113f3e MC |
393 | else |
394 | CRYPTO_ctr128_encrypt(in, out, len, &dat->ks, | |
6435f0f6 RL |
395 | EVP_CIPHER_CTX_iv_noconst(ctx), |
396 | EVP_CIPHER_CTX_buf_noconst(ctx), &num, | |
397 | dat->block); | |
398 | EVP_CIPHER_CTX_set_num(ctx, num); | |
0f113f3e | 399 | return 1; |
4739ccdb | 400 | } |
4739ccdb | 401 | |
0f113f3e MC |
402 | BLOCK_CIPHER_generic_pack(NID_camellia, 128, 0) |
403 | BLOCK_CIPHER_generic_pack(NID_camellia, 192, 0) | |
404 | BLOCK_CIPHER_generic_pack(NID_camellia, 256, 0) | |
02c9b66a DSH |
405 | #else |
406 | ||
407 | # ifdef PEDANTIC | |
0f113f3e | 408 | static void *dummy = &dummy; |
02c9b66a DSH |
409 | # endif |
410 | ||
dd030860 | 411 | #endif |