Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * x64 SIMD accelerated ChaCha and XChaCha stream ciphers,
4 * including ChaCha20 (RFC7539)
5 *
6 * Copyright (C) 2015 Martin Willi
7 */
8
9#include <crypto/algapi.h>
10#include <crypto/internal/chacha.h>
11#include <crypto/internal/simd.h>
12#include <crypto/internal/skcipher.h>
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/sizes.h>
16#include <asm/simd.h>
17
18asmlinkage void chacha_block_xor_ssse3(u32 *state, u8 *dst, const u8 *src,
19 unsigned int len, int nrounds);
20asmlinkage void chacha_4block_xor_ssse3(u32 *state, u8 *dst, const u8 *src,
21 unsigned int len, int nrounds);
22asmlinkage void hchacha_block_ssse3(const u32 *state, u32 *out, int nrounds);
23
24asmlinkage void chacha_2block_xor_avx2(u32 *state, u8 *dst, const u8 *src,
25 unsigned int len, int nrounds);
26asmlinkage void chacha_4block_xor_avx2(u32 *state, u8 *dst, const u8 *src,
27 unsigned int len, int nrounds);
28asmlinkage void chacha_8block_xor_avx2(u32 *state, u8 *dst, const u8 *src,
29 unsigned int len, int nrounds);
30
31asmlinkage void chacha_2block_xor_avx512vl(u32 *state, u8 *dst, const u8 *src,
32 unsigned int len, int nrounds);
33asmlinkage void chacha_4block_xor_avx512vl(u32 *state, u8 *dst, const u8 *src,
34 unsigned int len, int nrounds);
35asmlinkage void chacha_8block_xor_avx512vl(u32 *state, u8 *dst, const u8 *src,
36 unsigned int len, int nrounds);
37
38static __ro_after_init DEFINE_STATIC_KEY_FALSE(chacha_use_simd);
39static __ro_after_init DEFINE_STATIC_KEY_FALSE(chacha_use_avx2);
40static __ro_after_init DEFINE_STATIC_KEY_FALSE(chacha_use_avx512vl);
41
42static unsigned int chacha_advance(unsigned int len, unsigned int maxblocks)
43{
44 len = min(len, maxblocks * CHACHA_BLOCK_SIZE);
45 return round_up(len, CHACHA_BLOCK_SIZE) / CHACHA_BLOCK_SIZE;
46}
47
48static void chacha_dosimd(u32 *state, u8 *dst, const u8 *src,
49 unsigned int bytes, int nrounds)
50{
51 if (IS_ENABLED(CONFIG_AS_AVX512) &&
52 static_branch_likely(&chacha_use_avx512vl)) {
53 while (bytes >= CHACHA_BLOCK_SIZE * 8) {
54 chacha_8block_xor_avx512vl(state, dst, src, bytes,
55 nrounds);
56 bytes -= CHACHA_BLOCK_SIZE * 8;
57 src += CHACHA_BLOCK_SIZE * 8;
58 dst += CHACHA_BLOCK_SIZE * 8;
59 state[12] += 8;
60 }
61 if (bytes > CHACHA_BLOCK_SIZE * 4) {
62 chacha_8block_xor_avx512vl(state, dst, src, bytes,
63 nrounds);
64 state[12] += chacha_advance(bytes, 8);
65 return;
66 }
67 if (bytes > CHACHA_BLOCK_SIZE * 2) {
68 chacha_4block_xor_avx512vl(state, dst, src, bytes,
69 nrounds);
70 state[12] += chacha_advance(bytes, 4);
71 return;
72 }
73 if (bytes) {
74 chacha_2block_xor_avx512vl(state, dst, src, bytes,
75 nrounds);
76 state[12] += chacha_advance(bytes, 2);
77 return;
78 }
79 }
80
81 if (static_branch_likely(&chacha_use_avx2)) {
82 while (bytes >= CHACHA_BLOCK_SIZE * 8) {
83 chacha_8block_xor_avx2(state, dst, src, bytes, nrounds);
84 bytes -= CHACHA_BLOCK_SIZE * 8;
85 src += CHACHA_BLOCK_SIZE * 8;
86 dst += CHACHA_BLOCK_SIZE * 8;
87 state[12] += 8;
88 }
89 if (bytes > CHACHA_BLOCK_SIZE * 4) {
90 chacha_8block_xor_avx2(state, dst, src, bytes, nrounds);
91 state[12] += chacha_advance(bytes, 8);
92 return;
93 }
94 if (bytes > CHACHA_BLOCK_SIZE * 2) {
95 chacha_4block_xor_avx2(state, dst, src, bytes, nrounds);
96 state[12] += chacha_advance(bytes, 4);
97 return;
98 }
99 if (bytes > CHACHA_BLOCK_SIZE) {
100 chacha_2block_xor_avx2(state, dst, src, bytes, nrounds);
101 state[12] += chacha_advance(bytes, 2);
102 return;
103 }
104 }
105
106 while (bytes >= CHACHA_BLOCK_SIZE * 4) {
107 chacha_4block_xor_ssse3(state, dst, src, bytes, nrounds);
108 bytes -= CHACHA_BLOCK_SIZE * 4;
109 src += CHACHA_BLOCK_SIZE * 4;
110 dst += CHACHA_BLOCK_SIZE * 4;
111 state[12] += 4;
112 }
113 if (bytes > CHACHA_BLOCK_SIZE) {
114 chacha_4block_xor_ssse3(state, dst, src, bytes, nrounds);
115 state[12] += chacha_advance(bytes, 4);
116 return;
117 }
118 if (bytes) {
119 chacha_block_xor_ssse3(state, dst, src, bytes, nrounds);
120 state[12]++;
121 }
122}
123
124void hchacha_block_arch(const u32 *state, u32 *stream, int nrounds)
125{
126 if (!static_branch_likely(&chacha_use_simd) || !crypto_simd_usable()) {
127 hchacha_block_generic(state, stream, nrounds);
128 } else {
129 kernel_fpu_begin();
130 hchacha_block_ssse3(state, stream, nrounds);
131 kernel_fpu_end();
132 }
133}
134EXPORT_SYMBOL(hchacha_block_arch);
135
136void chacha_init_arch(u32 *state, const u32 *key, const u8 *iv)
137{
138 chacha_init_generic(state, key, iv);
139}
140EXPORT_SYMBOL(chacha_init_arch);
141
142void chacha_crypt_arch(u32 *state, u8 *dst, const u8 *src, unsigned int bytes,
143 int nrounds)
144{
145 if (!static_branch_likely(&chacha_use_simd) || !crypto_simd_usable() ||
146 bytes <= CHACHA_BLOCK_SIZE)
147 return chacha_crypt_generic(state, dst, src, bytes, nrounds);
148
149 do {
150 unsigned int todo = min_t(unsigned int, bytes, SZ_4K);
151
152 kernel_fpu_begin();
153 chacha_dosimd(state, dst, src, todo, nrounds);
154 kernel_fpu_end();
155
156 bytes -= todo;
157 src += todo;
158 dst += todo;
159 } while (bytes);
160}
161EXPORT_SYMBOL(chacha_crypt_arch);
162
163static int chacha_simd_stream_xor(struct skcipher_request *req,
164 const struct chacha_ctx *ctx, const u8 *iv)
165{
166 u32 state[CHACHA_STATE_WORDS] __aligned(8);
167 struct skcipher_walk walk;
168 int err;
169
170 err = skcipher_walk_virt(&walk, req, false);
171
172 chacha_init_generic(state, ctx->key, iv);
173
174 while (walk.nbytes > 0) {
175 unsigned int nbytes = walk.nbytes;
176
177 if (nbytes < walk.total)
178 nbytes = round_down(nbytes, walk.stride);
179
180 if (!static_branch_likely(&chacha_use_simd) ||
181 !crypto_simd_usable()) {
182 chacha_crypt_generic(state, walk.dst.virt.addr,
183 walk.src.virt.addr, nbytes,
184 ctx->nrounds);
185 } else {
186 kernel_fpu_begin();
187 chacha_dosimd(state, walk.dst.virt.addr,
188 walk.src.virt.addr, nbytes,
189 ctx->nrounds);
190 kernel_fpu_end();
191 }
192 err = skcipher_walk_done(&walk, walk.nbytes - nbytes);
193 }
194
195 return err;
196}
197
198static int chacha_simd(struct skcipher_request *req)
199{
200 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
201 struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
202
203 return chacha_simd_stream_xor(req, ctx, req->iv);
204}
205
206static int xchacha_simd(struct skcipher_request *req)
207{
208 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
209 struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
210 u32 state[CHACHA_STATE_WORDS] __aligned(8);
211 struct chacha_ctx subctx;
212 u8 real_iv[16];
213
214 chacha_init_generic(state, ctx->key, req->iv);
215
216 if (req->cryptlen > CHACHA_BLOCK_SIZE && crypto_simd_usable()) {
217 kernel_fpu_begin();
218 hchacha_block_ssse3(state, subctx.key, ctx->nrounds);
219 kernel_fpu_end();
220 } else {
221 hchacha_block_generic(state, subctx.key, ctx->nrounds);
222 }
223 subctx.nrounds = ctx->nrounds;
224
225 memcpy(&real_iv[0], req->iv + 24, 8);
226 memcpy(&real_iv[8], req->iv + 16, 8);
227 return chacha_simd_stream_xor(req, &subctx, real_iv);
228}
229
230static struct skcipher_alg algs[] = {
231 {
232 .base.cra_name = "chacha20",
233 .base.cra_driver_name = "chacha20-simd",
234 .base.cra_priority = 300,
235 .base.cra_blocksize = 1,
236 .base.cra_ctxsize = sizeof(struct chacha_ctx),
237 .base.cra_module = THIS_MODULE,
238
239 .min_keysize = CHACHA_KEY_SIZE,
240 .max_keysize = CHACHA_KEY_SIZE,
241 .ivsize = CHACHA_IV_SIZE,
242 .chunksize = CHACHA_BLOCK_SIZE,
243 .setkey = chacha20_setkey,
244 .encrypt = chacha_simd,
245 .decrypt = chacha_simd,
246 }, {
247 .base.cra_name = "xchacha20",
248 .base.cra_driver_name = "xchacha20-simd",
249 .base.cra_priority = 300,
250 .base.cra_blocksize = 1,
251 .base.cra_ctxsize = sizeof(struct chacha_ctx),
252 .base.cra_module = THIS_MODULE,
253
254 .min_keysize = CHACHA_KEY_SIZE,
255 .max_keysize = CHACHA_KEY_SIZE,
256 .ivsize = XCHACHA_IV_SIZE,
257 .chunksize = CHACHA_BLOCK_SIZE,
258 .setkey = chacha20_setkey,
259 .encrypt = xchacha_simd,
260 .decrypt = xchacha_simd,
261 }, {
262 .base.cra_name = "xchacha12",
263 .base.cra_driver_name = "xchacha12-simd",
264 .base.cra_priority = 300,
265 .base.cra_blocksize = 1,
266 .base.cra_ctxsize = sizeof(struct chacha_ctx),
267 .base.cra_module = THIS_MODULE,
268
269 .min_keysize = CHACHA_KEY_SIZE,
270 .max_keysize = CHACHA_KEY_SIZE,
271 .ivsize = XCHACHA_IV_SIZE,
272 .chunksize = CHACHA_BLOCK_SIZE,
273 .setkey = chacha12_setkey,
274 .encrypt = xchacha_simd,
275 .decrypt = xchacha_simd,
276 },
277};
278
279static int __init chacha_simd_mod_init(void)
280{
281 if (!boot_cpu_has(X86_FEATURE_SSSE3))
282 return 0;
283
284 static_branch_enable(&chacha_use_simd);
285
286 if (boot_cpu_has(X86_FEATURE_AVX) &&
287 boot_cpu_has(X86_FEATURE_AVX2) &&
288 cpu_has_xfeatures(XFEATURE_MASK_SSE | XFEATURE_MASK_YMM, NULL)) {
289 static_branch_enable(&chacha_use_avx2);
290
291 if (IS_ENABLED(CONFIG_AS_AVX512) &&
292 boot_cpu_has(X86_FEATURE_AVX512VL) &&
293 boot_cpu_has(X86_FEATURE_AVX512BW)) /* kmovq */
294 static_branch_enable(&chacha_use_avx512vl);
295 }
296 return IS_REACHABLE(CONFIG_CRYPTO_SKCIPHER) ?
297 crypto_register_skciphers(algs, ARRAY_SIZE(algs)) : 0;
298}
299
300static void __exit chacha_simd_mod_fini(void)
301{
302 if (IS_REACHABLE(CONFIG_CRYPTO_SKCIPHER) && boot_cpu_has(X86_FEATURE_SSSE3))
303 crypto_unregister_skciphers(algs, ARRAY_SIZE(algs));
304}
305
306module_init(chacha_simd_mod_init);
307module_exit(chacha_simd_mod_fini);
308
309MODULE_LICENSE("GPL");
310MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
311MODULE_DESCRIPTION("ChaCha and XChaCha stream ciphers (x64 SIMD accelerated)");
312MODULE_ALIAS_CRYPTO("chacha20");
313MODULE_ALIAS_CRYPTO("chacha20-simd");
314MODULE_ALIAS_CRYPTO("xchacha20");
315MODULE_ALIAS_CRYPTO("xchacha20-simd");
316MODULE_ALIAS_CRYPTO("xchacha12");
317MODULE_ALIAS_CRYPTO("xchacha12-simd");
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * x64 SIMD accelerated ChaCha and XChaCha stream ciphers,
4 * including ChaCha20 (RFC7539)
5 *
6 * Copyright (C) 2015 Martin Willi
7 */
8
9#include <crypto/algapi.h>
10#include <crypto/internal/chacha.h>
11#include <crypto/internal/simd.h>
12#include <crypto/internal/skcipher.h>
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <asm/simd.h>
16
17asmlinkage void chacha_block_xor_ssse3(u32 *state, u8 *dst, const u8 *src,
18 unsigned int len, int nrounds);
19asmlinkage void chacha_4block_xor_ssse3(u32 *state, u8 *dst, const u8 *src,
20 unsigned int len, int nrounds);
21asmlinkage void hchacha_block_ssse3(const u32 *state, u32 *out, int nrounds);
22
23asmlinkage void chacha_2block_xor_avx2(u32 *state, u8 *dst, const u8 *src,
24 unsigned int len, int nrounds);
25asmlinkage void chacha_4block_xor_avx2(u32 *state, u8 *dst, const u8 *src,
26 unsigned int len, int nrounds);
27asmlinkage void chacha_8block_xor_avx2(u32 *state, u8 *dst, const u8 *src,
28 unsigned int len, int nrounds);
29
30asmlinkage void chacha_2block_xor_avx512vl(u32 *state, u8 *dst, const u8 *src,
31 unsigned int len, int nrounds);
32asmlinkage void chacha_4block_xor_avx512vl(u32 *state, u8 *dst, const u8 *src,
33 unsigned int len, int nrounds);
34asmlinkage void chacha_8block_xor_avx512vl(u32 *state, u8 *dst, const u8 *src,
35 unsigned int len, int nrounds);
36
37static __ro_after_init DEFINE_STATIC_KEY_FALSE(chacha_use_simd);
38static __ro_after_init DEFINE_STATIC_KEY_FALSE(chacha_use_avx2);
39static __ro_after_init DEFINE_STATIC_KEY_FALSE(chacha_use_avx512vl);
40
41static unsigned int chacha_advance(unsigned int len, unsigned int maxblocks)
42{
43 len = min(len, maxblocks * CHACHA_BLOCK_SIZE);
44 return round_up(len, CHACHA_BLOCK_SIZE) / CHACHA_BLOCK_SIZE;
45}
46
47static void chacha_dosimd(u32 *state, u8 *dst, const u8 *src,
48 unsigned int bytes, int nrounds)
49{
50 if (IS_ENABLED(CONFIG_AS_AVX512) &&
51 static_branch_likely(&chacha_use_avx512vl)) {
52 while (bytes >= CHACHA_BLOCK_SIZE * 8) {
53 chacha_8block_xor_avx512vl(state, dst, src, bytes,
54 nrounds);
55 bytes -= CHACHA_BLOCK_SIZE * 8;
56 src += CHACHA_BLOCK_SIZE * 8;
57 dst += CHACHA_BLOCK_SIZE * 8;
58 state[12] += 8;
59 }
60 if (bytes > CHACHA_BLOCK_SIZE * 4) {
61 chacha_8block_xor_avx512vl(state, dst, src, bytes,
62 nrounds);
63 state[12] += chacha_advance(bytes, 8);
64 return;
65 }
66 if (bytes > CHACHA_BLOCK_SIZE * 2) {
67 chacha_4block_xor_avx512vl(state, dst, src, bytes,
68 nrounds);
69 state[12] += chacha_advance(bytes, 4);
70 return;
71 }
72 if (bytes) {
73 chacha_2block_xor_avx512vl(state, dst, src, bytes,
74 nrounds);
75 state[12] += chacha_advance(bytes, 2);
76 return;
77 }
78 }
79
80 if (static_branch_likely(&chacha_use_avx2)) {
81 while (bytes >= CHACHA_BLOCK_SIZE * 8) {
82 chacha_8block_xor_avx2(state, dst, src, bytes, nrounds);
83 bytes -= CHACHA_BLOCK_SIZE * 8;
84 src += CHACHA_BLOCK_SIZE * 8;
85 dst += CHACHA_BLOCK_SIZE * 8;
86 state[12] += 8;
87 }
88 if (bytes > CHACHA_BLOCK_SIZE * 4) {
89 chacha_8block_xor_avx2(state, dst, src, bytes, nrounds);
90 state[12] += chacha_advance(bytes, 8);
91 return;
92 }
93 if (bytes > CHACHA_BLOCK_SIZE * 2) {
94 chacha_4block_xor_avx2(state, dst, src, bytes, nrounds);
95 state[12] += chacha_advance(bytes, 4);
96 return;
97 }
98 if (bytes > CHACHA_BLOCK_SIZE) {
99 chacha_2block_xor_avx2(state, dst, src, bytes, nrounds);
100 state[12] += chacha_advance(bytes, 2);
101 return;
102 }
103 }
104
105 while (bytes >= CHACHA_BLOCK_SIZE * 4) {
106 chacha_4block_xor_ssse3(state, dst, src, bytes, nrounds);
107 bytes -= CHACHA_BLOCK_SIZE * 4;
108 src += CHACHA_BLOCK_SIZE * 4;
109 dst += CHACHA_BLOCK_SIZE * 4;
110 state[12] += 4;
111 }
112 if (bytes > CHACHA_BLOCK_SIZE) {
113 chacha_4block_xor_ssse3(state, dst, src, bytes, nrounds);
114 state[12] += chacha_advance(bytes, 4);
115 return;
116 }
117 if (bytes) {
118 chacha_block_xor_ssse3(state, dst, src, bytes, nrounds);
119 state[12]++;
120 }
121}
122
123void hchacha_block_arch(const u32 *state, u32 *stream, int nrounds)
124{
125 if (!static_branch_likely(&chacha_use_simd) || !crypto_simd_usable()) {
126 hchacha_block_generic(state, stream, nrounds);
127 } else {
128 kernel_fpu_begin();
129 hchacha_block_ssse3(state, stream, nrounds);
130 kernel_fpu_end();
131 }
132}
133EXPORT_SYMBOL(hchacha_block_arch);
134
135void chacha_init_arch(u32 *state, const u32 *key, const u8 *iv)
136{
137 chacha_init_generic(state, key, iv);
138}
139EXPORT_SYMBOL(chacha_init_arch);
140
141void chacha_crypt_arch(u32 *state, u8 *dst, const u8 *src, unsigned int bytes,
142 int nrounds)
143{
144 if (!static_branch_likely(&chacha_use_simd) || !crypto_simd_usable() ||
145 bytes <= CHACHA_BLOCK_SIZE)
146 return chacha_crypt_generic(state, dst, src, bytes, nrounds);
147
148 do {
149 unsigned int todo = min_t(unsigned int, bytes, SZ_4K);
150
151 kernel_fpu_begin();
152 chacha_dosimd(state, dst, src, todo, nrounds);
153 kernel_fpu_end();
154
155 bytes -= todo;
156 src += todo;
157 dst += todo;
158 } while (bytes);
159}
160EXPORT_SYMBOL(chacha_crypt_arch);
161
162static int chacha_simd_stream_xor(struct skcipher_request *req,
163 const struct chacha_ctx *ctx, const u8 *iv)
164{
165 u32 state[CHACHA_STATE_WORDS] __aligned(8);
166 struct skcipher_walk walk;
167 int err;
168
169 err = skcipher_walk_virt(&walk, req, false);
170
171 chacha_init_generic(state, ctx->key, iv);
172
173 while (walk.nbytes > 0) {
174 unsigned int nbytes = walk.nbytes;
175
176 if (nbytes < walk.total)
177 nbytes = round_down(nbytes, walk.stride);
178
179 if (!static_branch_likely(&chacha_use_simd) ||
180 !crypto_simd_usable()) {
181 chacha_crypt_generic(state, walk.dst.virt.addr,
182 walk.src.virt.addr, nbytes,
183 ctx->nrounds);
184 } else {
185 kernel_fpu_begin();
186 chacha_dosimd(state, walk.dst.virt.addr,
187 walk.src.virt.addr, nbytes,
188 ctx->nrounds);
189 kernel_fpu_end();
190 }
191 err = skcipher_walk_done(&walk, walk.nbytes - nbytes);
192 }
193
194 return err;
195}
196
197static int chacha_simd(struct skcipher_request *req)
198{
199 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
200 struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
201
202 return chacha_simd_stream_xor(req, ctx, req->iv);
203}
204
205static int xchacha_simd(struct skcipher_request *req)
206{
207 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
208 struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
209 u32 state[CHACHA_STATE_WORDS] __aligned(8);
210 struct chacha_ctx subctx;
211 u8 real_iv[16];
212
213 chacha_init_generic(state, ctx->key, req->iv);
214
215 if (req->cryptlen > CHACHA_BLOCK_SIZE && crypto_simd_usable()) {
216 kernel_fpu_begin();
217 hchacha_block_ssse3(state, subctx.key, ctx->nrounds);
218 kernel_fpu_end();
219 } else {
220 hchacha_block_generic(state, subctx.key, ctx->nrounds);
221 }
222 subctx.nrounds = ctx->nrounds;
223
224 memcpy(&real_iv[0], req->iv + 24, 8);
225 memcpy(&real_iv[8], req->iv + 16, 8);
226 return chacha_simd_stream_xor(req, &subctx, real_iv);
227}
228
229static struct skcipher_alg algs[] = {
230 {
231 .base.cra_name = "chacha20",
232 .base.cra_driver_name = "chacha20-simd",
233 .base.cra_priority = 300,
234 .base.cra_blocksize = 1,
235 .base.cra_ctxsize = sizeof(struct chacha_ctx),
236 .base.cra_module = THIS_MODULE,
237
238 .min_keysize = CHACHA_KEY_SIZE,
239 .max_keysize = CHACHA_KEY_SIZE,
240 .ivsize = CHACHA_IV_SIZE,
241 .chunksize = CHACHA_BLOCK_SIZE,
242 .setkey = chacha20_setkey,
243 .encrypt = chacha_simd,
244 .decrypt = chacha_simd,
245 }, {
246 .base.cra_name = "xchacha20",
247 .base.cra_driver_name = "xchacha20-simd",
248 .base.cra_priority = 300,
249 .base.cra_blocksize = 1,
250 .base.cra_ctxsize = sizeof(struct chacha_ctx),
251 .base.cra_module = THIS_MODULE,
252
253 .min_keysize = CHACHA_KEY_SIZE,
254 .max_keysize = CHACHA_KEY_SIZE,
255 .ivsize = XCHACHA_IV_SIZE,
256 .chunksize = CHACHA_BLOCK_SIZE,
257 .setkey = chacha20_setkey,
258 .encrypt = xchacha_simd,
259 .decrypt = xchacha_simd,
260 }, {
261 .base.cra_name = "xchacha12",
262 .base.cra_driver_name = "xchacha12-simd",
263 .base.cra_priority = 300,
264 .base.cra_blocksize = 1,
265 .base.cra_ctxsize = sizeof(struct chacha_ctx),
266 .base.cra_module = THIS_MODULE,
267
268 .min_keysize = CHACHA_KEY_SIZE,
269 .max_keysize = CHACHA_KEY_SIZE,
270 .ivsize = XCHACHA_IV_SIZE,
271 .chunksize = CHACHA_BLOCK_SIZE,
272 .setkey = chacha12_setkey,
273 .encrypt = xchacha_simd,
274 .decrypt = xchacha_simd,
275 },
276};
277
278static int __init chacha_simd_mod_init(void)
279{
280 if (!boot_cpu_has(X86_FEATURE_SSSE3))
281 return 0;
282
283 static_branch_enable(&chacha_use_simd);
284
285 if (boot_cpu_has(X86_FEATURE_AVX) &&
286 boot_cpu_has(X86_FEATURE_AVX2) &&
287 cpu_has_xfeatures(XFEATURE_MASK_SSE | XFEATURE_MASK_YMM, NULL)) {
288 static_branch_enable(&chacha_use_avx2);
289
290 if (IS_ENABLED(CONFIG_AS_AVX512) &&
291 boot_cpu_has(X86_FEATURE_AVX512VL) &&
292 boot_cpu_has(X86_FEATURE_AVX512BW)) /* kmovq */
293 static_branch_enable(&chacha_use_avx512vl);
294 }
295 return IS_REACHABLE(CONFIG_CRYPTO_SKCIPHER) ?
296 crypto_register_skciphers(algs, ARRAY_SIZE(algs)) : 0;
297}
298
299static void __exit chacha_simd_mod_fini(void)
300{
301 if (IS_REACHABLE(CONFIG_CRYPTO_SKCIPHER) && boot_cpu_has(X86_FEATURE_SSSE3))
302 crypto_unregister_skciphers(algs, ARRAY_SIZE(algs));
303}
304
305module_init(chacha_simd_mod_init);
306module_exit(chacha_simd_mod_fini);
307
308MODULE_LICENSE("GPL");
309MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
310MODULE_DESCRIPTION("ChaCha and XChaCha stream ciphers (x64 SIMD accelerated)");
311MODULE_ALIAS_CRYPTO("chacha20");
312MODULE_ALIAS_CRYPTO("chacha20-simd");
313MODULE_ALIAS_CRYPTO("xchacha20");
314MODULE_ALIAS_CRYPTO("xchacha20-simd");
315MODULE_ALIAS_CRYPTO("xchacha12");
316MODULE_ALIAS_CRYPTO("xchacha12-simd");