1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Glue Code for AVX assembler versions of Serpent Cipher
5 * Copyright (C) 2012 Johannes Goetzfried
6 * <Johannes.Goetzfried@informatik.stud.uni-erlangen.de>
8 * Copyright © 2011-2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
11 #include <linux/module.h>
12 #include <linux/types.h>
13 #include <linux/crypto.h>
14 #include <linux/err.h>
15 #include <crypto/algapi.h>
16 #include <crypto/internal/simd.h>
17 #include <crypto/serpent.h>
18 #include <crypto/xts.h>
19 #include <asm/crypto/glue_helper.h>
20 #include <asm/crypto/serpent-avx.h>
22 /* 8-way parallel cipher functions */
23 asmlinkage void serpent_ecb_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst,
25 EXPORT_SYMBOL_GPL(serpent_ecb_enc_8way_avx);
27 asmlinkage void serpent_ecb_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
29 EXPORT_SYMBOL_GPL(serpent_ecb_dec_8way_avx);
31 asmlinkage void serpent_cbc_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
33 EXPORT_SYMBOL_GPL(serpent_cbc_dec_8way_avx);
35 asmlinkage void serpent_ctr_8way_avx(struct serpent_ctx *ctx, u8 *dst,
36 const u8 *src, le128 *iv);
37 EXPORT_SYMBOL_GPL(serpent_ctr_8way_avx);
39 asmlinkage void serpent_xts_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst,
40 const u8 *src, le128 *iv);
41 EXPORT_SYMBOL_GPL(serpent_xts_enc_8way_avx);
43 asmlinkage void serpent_xts_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
44 const u8 *src, le128 *iv);
45 EXPORT_SYMBOL_GPL(serpent_xts_dec_8way_avx);
47 void __serpent_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
51 le128_to_be128(&ctrblk, iv);
54 __serpent_encrypt(ctx, (u8 *)&ctrblk, (u8 *)&ctrblk);
55 u128_xor(dst, src, (u128 *)&ctrblk);
57 EXPORT_SYMBOL_GPL(__serpent_crypt_ctr);
59 void serpent_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv)
61 glue_xts_crypt_128bit_one(ctx, dst, src, iv,
62 GLUE_FUNC_CAST(__serpent_encrypt));
64 EXPORT_SYMBOL_GPL(serpent_xts_enc);
66 void serpent_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv)
68 glue_xts_crypt_128bit_one(ctx, dst, src, iv,
69 GLUE_FUNC_CAST(__serpent_decrypt));
71 EXPORT_SYMBOL_GPL(serpent_xts_dec);
73 static int serpent_setkey_skcipher(struct crypto_skcipher *tfm,
74 const u8 *key, unsigned int keylen)
76 return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen);
79 int xts_serpent_setkey(struct crypto_skcipher *tfm, const u8 *key,
82 struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
85 err = xts_verify_key(tfm, key, keylen);
89 /* first half of xts-key is for crypt */
90 err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2);
94 /* second half of xts-key is for tweak */
95 return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2);
97 EXPORT_SYMBOL_GPL(xts_serpent_setkey);
99 static const struct common_glue_ctx serpent_enc = {
101 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
104 .num_blocks = SERPENT_PARALLEL_BLOCKS,
105 .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_enc_8way_avx) }
108 .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) }
112 static const struct common_glue_ctx serpent_ctr = {
114 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
117 .num_blocks = SERPENT_PARALLEL_BLOCKS,
118 .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_ctr_8way_avx) }
121 .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(__serpent_crypt_ctr) }
125 static const struct common_glue_ctx serpent_enc_xts = {
127 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
130 .num_blocks = SERPENT_PARALLEL_BLOCKS,
131 .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc_8way_avx) }
134 .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc) }
138 static const struct common_glue_ctx serpent_dec = {
140 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
143 .num_blocks = SERPENT_PARALLEL_BLOCKS,
144 .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_dec_8way_avx) }
147 .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) }
151 static const struct common_glue_ctx serpent_dec_cbc = {
153 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
156 .num_blocks = SERPENT_PARALLEL_BLOCKS,
157 .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_cbc_dec_8way_avx) }
160 .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) }
164 static const struct common_glue_ctx serpent_dec_xts = {
166 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
169 .num_blocks = SERPENT_PARALLEL_BLOCKS,
170 .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec_8way_avx) }
173 .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec) }
177 static int ecb_encrypt(struct skcipher_request *req)
179 return glue_ecb_req_128bit(&serpent_enc, req);
182 static int ecb_decrypt(struct skcipher_request *req)
184 return glue_ecb_req_128bit(&serpent_dec, req);
187 static int cbc_encrypt(struct skcipher_request *req)
189 return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__serpent_encrypt),
193 static int cbc_decrypt(struct skcipher_request *req)
195 return glue_cbc_decrypt_req_128bit(&serpent_dec_cbc, req);
198 static int ctr_crypt(struct skcipher_request *req)
200 return glue_ctr_req_128bit(&serpent_ctr, req);
203 static int xts_encrypt(struct skcipher_request *req)
205 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
206 struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
208 return glue_xts_req_128bit(&serpent_enc_xts, req,
209 XTS_TWEAK_CAST(__serpent_encrypt),
210 &ctx->tweak_ctx, &ctx->crypt_ctx, false);
213 static int xts_decrypt(struct skcipher_request *req)
215 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
216 struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
218 return glue_xts_req_128bit(&serpent_dec_xts, req,
219 XTS_TWEAK_CAST(__serpent_encrypt),
220 &ctx->tweak_ctx, &ctx->crypt_ctx, true);
223 static struct skcipher_alg serpent_algs[] = {
225 .base.cra_name = "__ecb(serpent)",
226 .base.cra_driver_name = "__ecb-serpent-avx",
227 .base.cra_priority = 500,
228 .base.cra_flags = CRYPTO_ALG_INTERNAL,
229 .base.cra_blocksize = SERPENT_BLOCK_SIZE,
230 .base.cra_ctxsize = sizeof(struct serpent_ctx),
231 .base.cra_module = THIS_MODULE,
232 .min_keysize = SERPENT_MIN_KEY_SIZE,
233 .max_keysize = SERPENT_MAX_KEY_SIZE,
234 .setkey = serpent_setkey_skcipher,
235 .encrypt = ecb_encrypt,
236 .decrypt = ecb_decrypt,
238 .base.cra_name = "__cbc(serpent)",
239 .base.cra_driver_name = "__cbc-serpent-avx",
240 .base.cra_priority = 500,
241 .base.cra_flags = CRYPTO_ALG_INTERNAL,
242 .base.cra_blocksize = SERPENT_BLOCK_SIZE,
243 .base.cra_ctxsize = sizeof(struct serpent_ctx),
244 .base.cra_module = THIS_MODULE,
245 .min_keysize = SERPENT_MIN_KEY_SIZE,
246 .max_keysize = SERPENT_MAX_KEY_SIZE,
247 .ivsize = SERPENT_BLOCK_SIZE,
248 .setkey = serpent_setkey_skcipher,
249 .encrypt = cbc_encrypt,
250 .decrypt = cbc_decrypt,
252 .base.cra_name = "__ctr(serpent)",
253 .base.cra_driver_name = "__ctr-serpent-avx",
254 .base.cra_priority = 500,
255 .base.cra_flags = CRYPTO_ALG_INTERNAL,
256 .base.cra_blocksize = 1,
257 .base.cra_ctxsize = sizeof(struct serpent_ctx),
258 .base.cra_module = THIS_MODULE,
259 .min_keysize = SERPENT_MIN_KEY_SIZE,
260 .max_keysize = SERPENT_MAX_KEY_SIZE,
261 .ivsize = SERPENT_BLOCK_SIZE,
262 .chunksize = SERPENT_BLOCK_SIZE,
263 .setkey = serpent_setkey_skcipher,
264 .encrypt = ctr_crypt,
265 .decrypt = ctr_crypt,
267 .base.cra_name = "__xts(serpent)",
268 .base.cra_driver_name = "__xts-serpent-avx",
269 .base.cra_priority = 500,
270 .base.cra_flags = CRYPTO_ALG_INTERNAL,
271 .base.cra_blocksize = SERPENT_BLOCK_SIZE,
272 .base.cra_ctxsize = sizeof(struct serpent_xts_ctx),
273 .base.cra_module = THIS_MODULE,
274 .min_keysize = 2 * SERPENT_MIN_KEY_SIZE,
275 .max_keysize = 2 * SERPENT_MAX_KEY_SIZE,
276 .ivsize = SERPENT_BLOCK_SIZE,
277 .setkey = xts_serpent_setkey,
278 .encrypt = xts_encrypt,
279 .decrypt = xts_decrypt,
283 static struct simd_skcipher_alg *serpent_simd_algs[ARRAY_SIZE(serpent_algs)];
285 static int __init serpent_init(void)
287 const char *feature_name;
289 if (!cpu_has_xfeatures(XFEATURE_MASK_SSE | XFEATURE_MASK_YMM,
291 pr_info("CPU feature '%s' is not supported.\n", feature_name);
295 return simd_register_skciphers_compat(serpent_algs,
296 ARRAY_SIZE(serpent_algs),
300 static void __exit serpent_exit(void)
302 simd_unregister_skciphers(serpent_algs, ARRAY_SIZE(serpent_algs),
306 module_init(serpent_init);
307 module_exit(serpent_exit);
309 MODULE_DESCRIPTION("Serpent Cipher Algorithm, AVX optimized");
310 MODULE_LICENSE("GPL");
311 MODULE_ALIAS_CRYPTO("serpent");