.. | .. |
---|
| 1 | +// SPDX-License-Identifier: GPL-2.0-or-later |
---|
1 | 2 | /* |
---|
2 | 3 | * Glue Code for assembler optimized version of Camellia |
---|
3 | 4 | * |
---|
.. | .. |
---|
5 | 6 | * |
---|
6 | 7 | * Camellia parts based on code by: |
---|
7 | 8 | * Copyright (C) 2006 NTT (Nippon Telegraph and Telephone Corporation) |
---|
8 | | - * |
---|
9 | | - * This program is free software; you can redistribute it and/or modify |
---|
10 | | - * it under the terms of the GNU General Public License as published by |
---|
11 | | - * the Free Software Foundation; either version 2 of the License, or |
---|
12 | | - * (at your option) any later version. |
---|
13 | | - * |
---|
14 | | - * This program is distributed in the hope that it will be useful, |
---|
15 | | - * but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
16 | | - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
17 | | - * GNU General Public License for more details. |
---|
18 | | - * |
---|
19 | | - * You should have received a copy of the GNU General Public License |
---|
20 | | - * along with this program; if not, write to the Free Software |
---|
21 | | - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 |
---|
22 | | - * USA |
---|
23 | | - * |
---|
24 | 9 | */ |
---|
25 | 10 | |
---|
26 | 11 | #include <asm/unaligned.h> |
---|
.. | .. |
---|
33 | 18 | #include <asm/crypto/glue_helper.h> |
---|
34 | 19 | |
---|
35 | 20 | /* regular block cipher functions */ |
---|
36 | | -asmlinkage void __camellia_enc_blk(struct camellia_ctx *ctx, u8 *dst, |
---|
37 | | - const u8 *src, bool xor); |
---|
| 21 | +asmlinkage void __camellia_enc_blk(const void *ctx, u8 *dst, const u8 *src, |
---|
| 22 | + bool xor); |
---|
38 | 23 | EXPORT_SYMBOL_GPL(__camellia_enc_blk); |
---|
39 | | -asmlinkage void camellia_dec_blk(struct camellia_ctx *ctx, u8 *dst, |
---|
40 | | - const u8 *src); |
---|
| 24 | +asmlinkage void camellia_dec_blk(const void *ctx, u8 *dst, const u8 *src); |
---|
41 | 25 | EXPORT_SYMBOL_GPL(camellia_dec_blk); |
---|
42 | 26 | |
---|
43 | 27 | /* 2-way parallel cipher functions */ |
---|
44 | | -asmlinkage void __camellia_enc_blk_2way(struct camellia_ctx *ctx, u8 *dst, |
---|
45 | | - const u8 *src, bool xor); |
---|
| 28 | +asmlinkage void __camellia_enc_blk_2way(const void *ctx, u8 *dst, const u8 *src, |
---|
| 29 | + bool xor); |
---|
46 | 30 | EXPORT_SYMBOL_GPL(__camellia_enc_blk_2way); |
---|
47 | | -asmlinkage void camellia_dec_blk_2way(struct camellia_ctx *ctx, u8 *dst, |
---|
48 | | - const u8 *src); |
---|
| 31 | +asmlinkage void camellia_dec_blk_2way(const void *ctx, u8 *dst, const u8 *src); |
---|
49 | 32 | EXPORT_SYMBOL_GPL(camellia_dec_blk_2way); |
---|
50 | 33 | |
---|
51 | 34 | static void camellia_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) |
---|
.. | .. |
---|
1244 | 1227 | } |
---|
1245 | 1228 | |
---|
1246 | 1229 | int __camellia_setkey(struct camellia_ctx *cctx, const unsigned char *key, |
---|
1247 | | - unsigned int key_len, u32 *flags) |
---|
| 1230 | + unsigned int key_len) |
---|
1248 | 1231 | { |
---|
1249 | | - if (key_len != 16 && key_len != 24 && key_len != 32) { |
---|
1250 | | - *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN; |
---|
| 1232 | + if (key_len != 16 && key_len != 24 && key_len != 32) |
---|
1251 | 1233 | return -EINVAL; |
---|
1252 | | - } |
---|
1253 | 1234 | |
---|
1254 | 1235 | cctx->key_length = key_len; |
---|
1255 | 1236 | |
---|
.. | .. |
---|
1272 | 1253 | static int camellia_setkey(struct crypto_tfm *tfm, const u8 *key, |
---|
1273 | 1254 | unsigned int key_len) |
---|
1274 | 1255 | { |
---|
1275 | | - return __camellia_setkey(crypto_tfm_ctx(tfm), key, key_len, |
---|
1276 | | - &tfm->crt_flags); |
---|
| 1256 | + return __camellia_setkey(crypto_tfm_ctx(tfm), key, key_len); |
---|
1277 | 1257 | } |
---|
1278 | 1258 | |
---|
1279 | 1259 | static int camellia_setkey_skcipher(struct crypto_skcipher *tfm, const u8 *key, |
---|
.. | .. |
---|
1282 | 1262 | return camellia_setkey(&tfm->base, key, key_len); |
---|
1283 | 1263 | } |
---|
1284 | 1264 | |
---|
1285 | | -void camellia_decrypt_cbc_2way(void *ctx, u128 *dst, const u128 *src) |
---|
| 1265 | +void camellia_decrypt_cbc_2way(const void *ctx, u8 *d, const u8 *s) |
---|
1286 | 1266 | { |
---|
| 1267 | + u128 *dst = (u128 *)d; |
---|
| 1268 | + const u128 *src = (const u128 *)s; |
---|
1287 | 1269 | u128 iv = *src; |
---|
1288 | 1270 | |
---|
1289 | 1271 | camellia_dec_blk_2way(ctx, (u8 *)dst, (u8 *)src); |
---|
.. | .. |
---|
1292 | 1274 | } |
---|
1293 | 1275 | EXPORT_SYMBOL_GPL(camellia_decrypt_cbc_2way); |
---|
1294 | 1276 | |
---|
1295 | | -void camellia_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv) |
---|
| 1277 | +void camellia_crypt_ctr(const void *ctx, u8 *d, const u8 *s, le128 *iv) |
---|
1296 | 1278 | { |
---|
1297 | 1279 | be128 ctrblk; |
---|
| 1280 | + u128 *dst = (u128 *)d; |
---|
| 1281 | + const u128 *src = (const u128 *)s; |
---|
1298 | 1282 | |
---|
1299 | 1283 | if (dst != src) |
---|
1300 | 1284 | *dst = *src; |
---|
.. | .. |
---|
1306 | 1290 | } |
---|
1307 | 1291 | EXPORT_SYMBOL_GPL(camellia_crypt_ctr); |
---|
1308 | 1292 | |
---|
1309 | | -void camellia_crypt_ctr_2way(void *ctx, u128 *dst, const u128 *src, le128 *iv) |
---|
| 1293 | +void camellia_crypt_ctr_2way(const void *ctx, u8 *d, const u8 *s, le128 *iv) |
---|
1310 | 1294 | { |
---|
1311 | 1295 | be128 ctrblks[2]; |
---|
| 1296 | + u128 *dst = (u128 *)d; |
---|
| 1297 | + const u128 *src = (const u128 *)s; |
---|
1312 | 1298 | |
---|
1313 | 1299 | if (dst != src) { |
---|
1314 | 1300 | dst[0] = src[0]; |
---|
.. | .. |
---|
1330 | 1316 | |
---|
1331 | 1317 | .funcs = { { |
---|
1332 | 1318 | .num_blocks = 2, |
---|
1333 | | - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk_2way) } |
---|
| 1319 | + .fn_u = { .ecb = camellia_enc_blk_2way } |
---|
1334 | 1320 | }, { |
---|
1335 | 1321 | .num_blocks = 1, |
---|
1336 | | - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk) } |
---|
| 1322 | + .fn_u = { .ecb = camellia_enc_blk } |
---|
1337 | 1323 | } } |
---|
1338 | 1324 | }; |
---|
1339 | 1325 | |
---|
.. | .. |
---|
1343 | 1329 | |
---|
1344 | 1330 | .funcs = { { |
---|
1345 | 1331 | .num_blocks = 2, |
---|
1346 | | - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr_2way) } |
---|
| 1332 | + .fn_u = { .ctr = camellia_crypt_ctr_2way } |
---|
1347 | 1333 | }, { |
---|
1348 | 1334 | .num_blocks = 1, |
---|
1349 | | - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr) } |
---|
| 1335 | + .fn_u = { .ctr = camellia_crypt_ctr } |
---|
1350 | 1336 | } } |
---|
1351 | 1337 | }; |
---|
1352 | 1338 | |
---|
.. | .. |
---|
1356 | 1342 | |
---|
1357 | 1343 | .funcs = { { |
---|
1358 | 1344 | .num_blocks = 2, |
---|
1359 | | - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk_2way) } |
---|
| 1345 | + .fn_u = { .ecb = camellia_dec_blk_2way } |
---|
1360 | 1346 | }, { |
---|
1361 | 1347 | .num_blocks = 1, |
---|
1362 | | - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk) } |
---|
| 1348 | + .fn_u = { .ecb = camellia_dec_blk } |
---|
1363 | 1349 | } } |
---|
1364 | 1350 | }; |
---|
1365 | 1351 | |
---|
.. | .. |
---|
1369 | 1355 | |
---|
1370 | 1356 | .funcs = { { |
---|
1371 | 1357 | .num_blocks = 2, |
---|
1372 | | - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_decrypt_cbc_2way) } |
---|
| 1358 | + .fn_u = { .cbc = camellia_decrypt_cbc_2way } |
---|
1373 | 1359 | }, { |
---|
1374 | 1360 | .num_blocks = 1, |
---|
1375 | | - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_dec_blk) } |
---|
| 1361 | + .fn_u = { .cbc = camellia_dec_blk } |
---|
1376 | 1362 | } } |
---|
1377 | 1363 | }; |
---|
1378 | 1364 | |
---|
.. | .. |
---|
1388 | 1374 | |
---|
1389 | 1375 | static int cbc_encrypt(struct skcipher_request *req) |
---|
1390 | 1376 | { |
---|
1391 | | - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(camellia_enc_blk), |
---|
1392 | | - req); |
---|
| 1377 | + return glue_cbc_encrypt_req_128bit(camellia_enc_blk, req); |
---|
1393 | 1378 | } |
---|
1394 | 1379 | |
---|
1395 | 1380 | static int cbc_decrypt(struct skcipher_request *req) |
---|