~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/crypto/poly1305_glue.c

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  * Poly1305 authenticator algorithm, RFC7539, SIMD glue code
  4  *
  5  * Copyright (C) 2015 Martin Willi
  6  */
  7 
  8 #include <crypto/algapi.h>
  9 #include <crypto/internal/hash.h>
 10 #include <crypto/internal/simd.h>
 11 #include <crypto/poly1305.h>
 12 #include <linux/crypto.h>
 13 #include <linux/kernel.h>
 14 #include <linux/module.h>
 15 #include <asm/simd.h>
 16 
 17 struct poly1305_simd_desc_ctx {
 18         struct poly1305_desc_ctx base;
 19         /* derived key u set? */
 20         bool uset;
 21 #ifdef CONFIG_AS_AVX2
 22         /* derived keys r^3, r^4 set? */
 23         bool wset;
 24 #endif
 25         /* derived Poly1305 key r^2 */
 26         u32 u[5];
 27         /* ... silently appended r^3 and r^4 when using AVX2 */
 28 };
 29 
 30 asmlinkage void poly1305_block_sse2(u32 *h, const u8 *src,
 31                                     const u32 *r, unsigned int blocks);
 32 asmlinkage void poly1305_2block_sse2(u32 *h, const u8 *src, const u32 *r,
 33                                      unsigned int blocks, const u32 *u);
 34 #ifdef CONFIG_AS_AVX2
 35 asmlinkage void poly1305_4block_avx2(u32 *h, const u8 *src, const u32 *r,
 36                                      unsigned int blocks, const u32 *u);
 37 static bool poly1305_use_avx2;
 38 #endif
 39 
 40 static int poly1305_simd_init(struct shash_desc *desc)
 41 {
 42         struct poly1305_simd_desc_ctx *sctx = shash_desc_ctx(desc);
 43 
 44         sctx->uset = false;
 45 #ifdef CONFIG_AS_AVX2
 46         sctx->wset = false;
 47 #endif
 48 
 49         return crypto_poly1305_init(desc);
 50 }
 51 
 52 static void poly1305_simd_mult(u32 *a, const u32 *b)
 53 {
 54         u8 m[POLY1305_BLOCK_SIZE];
 55 
 56         memset(m, 0, sizeof(m));
 57         /* The poly1305 block function adds a hi-bit to the accumulator which
 58          * we don't need for key multiplication; compensate for it. */
 59         a[4] -= 1 << 24;
 60         poly1305_block_sse2(a, m, b, 1);
 61 }
 62 
 63 static unsigned int poly1305_simd_blocks(struct poly1305_desc_ctx *dctx,
 64                                          const u8 *src, unsigned int srclen)
 65 {
 66         struct poly1305_simd_desc_ctx *sctx;
 67         unsigned int blocks, datalen;
 68 
 69         BUILD_BUG_ON(offsetof(struct poly1305_simd_desc_ctx, base));
 70         sctx = container_of(dctx, struct poly1305_simd_desc_ctx, base);
 71 
 72         if (unlikely(!dctx->sset)) {
 73                 datalen = crypto_poly1305_setdesckey(dctx, src, srclen);
 74                 src += srclen - datalen;
 75                 srclen = datalen;
 76         }
 77 
 78 #ifdef CONFIG_AS_AVX2
 79         if (poly1305_use_avx2 && srclen >= POLY1305_BLOCK_SIZE * 4) {
 80                 if (unlikely(!sctx->wset)) {
 81                         if (!sctx->uset) {
 82                                 memcpy(sctx->u, dctx->r.r, sizeof(sctx->u));
 83                                 poly1305_simd_mult(sctx->u, dctx->r.r);
 84                                 sctx->uset = true;
 85                         }
 86                         memcpy(sctx->u + 5, sctx->u, sizeof(sctx->u));
 87                         poly1305_simd_mult(sctx->u + 5, dctx->r.r);
 88                         memcpy(sctx->u + 10, sctx->u + 5, sizeof(sctx->u));
 89                         poly1305_simd_mult(sctx->u + 10, dctx->r.r);
 90                         sctx->wset = true;
 91                 }
 92                 blocks = srclen / (POLY1305_BLOCK_SIZE * 4);
 93                 poly1305_4block_avx2(dctx->h.h, src, dctx->r.r, blocks,
 94                                      sctx->u);
 95                 src += POLY1305_BLOCK_SIZE * 4 * blocks;
 96                 srclen -= POLY1305_BLOCK_SIZE * 4 * blocks;
 97         }
 98 #endif
 99         if (likely(srclen >= POLY1305_BLOCK_SIZE * 2)) {
100                 if (unlikely(!sctx->uset)) {
101                         memcpy(sctx->u, dctx->r.r, sizeof(sctx->u));
102                         poly1305_simd_mult(sctx->u, dctx->r.r);
103                         sctx->uset = true;
104                 }
105                 blocks = srclen / (POLY1305_BLOCK_SIZE * 2);
106                 poly1305_2block_sse2(dctx->h.h, src, dctx->r.r, blocks,
107                                      sctx->u);
108                 src += POLY1305_BLOCK_SIZE * 2 * blocks;
109                 srclen -= POLY1305_BLOCK_SIZE * 2 * blocks;
110         }
111         if (srclen >= POLY1305_BLOCK_SIZE) {
112                 poly1305_block_sse2(dctx->h.h, src, dctx->r.r, 1);
113                 srclen -= POLY1305_BLOCK_SIZE;
114         }
115         return srclen;
116 }
117 
118 static int poly1305_simd_update(struct shash_desc *desc,
119                                 const u8 *src, unsigned int srclen)
120 {
121         struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);
122         unsigned int bytes;
123 
124         /* kernel_fpu_begin/end is costly, use fallback for small updates */
125         if (srclen <= 288 || !crypto_simd_usable())
126                 return crypto_poly1305_update(desc, src, srclen);
127 
128         kernel_fpu_begin();
129 
130         if (unlikely(dctx->buflen)) {
131                 bytes = min(srclen, POLY1305_BLOCK_SIZE - dctx->buflen);
132                 memcpy(dctx->buf + dctx->buflen, src, bytes);
133                 src += bytes;
134                 srclen -= bytes;
135                 dctx->buflen += bytes;
136 
137                 if (dctx->buflen == POLY1305_BLOCK_SIZE) {
138                         poly1305_simd_blocks(dctx, dctx->buf,
139                                              POLY1305_BLOCK_SIZE);
140                         dctx->buflen = 0;
141                 }
142         }
143 
144         if (likely(srclen >= POLY1305_BLOCK_SIZE)) {
145                 bytes = poly1305_simd_blocks(dctx, src, srclen);
146                 src += srclen - bytes;
147                 srclen = bytes;
148         }
149 
150         kernel_fpu_end();
151 
152         if (unlikely(srclen)) {
153                 dctx->buflen = srclen;
154                 memcpy(dctx->buf, src, srclen);
155         }
156 
157         return 0;
158 }
159 
160 static struct shash_alg alg = {
161         .digestsize     = POLY1305_DIGEST_SIZE,
162         .init           = poly1305_simd_init,
163         .update         = poly1305_simd_update,
164         .final          = crypto_poly1305_final,
165         .descsize       = sizeof(struct poly1305_simd_desc_ctx),
166         .base           = {
167                 .cra_name               = "poly1305",
168                 .cra_driver_name        = "poly1305-simd",
169                 .cra_priority           = 300,
170                 .cra_blocksize          = POLY1305_BLOCK_SIZE,
171                 .cra_module             = THIS_MODULE,
172         },
173 };
174 
175 static int __init poly1305_simd_mod_init(void)
176 {
177         if (!boot_cpu_has(X86_FEATURE_XMM2))
178                 return -ENODEV;
179 
180 #ifdef CONFIG_AS_AVX2
181         poly1305_use_avx2 = boot_cpu_has(X86_FEATURE_AVX) &&
182                             boot_cpu_has(X86_FEATURE_AVX2) &&
183                             cpu_has_xfeatures(XFEATURE_MASK_SSE | XFEATURE_MASK_YMM, NULL);
184         alg.descsize = sizeof(struct poly1305_simd_desc_ctx);
185         if (poly1305_use_avx2)
186                 alg.descsize += 10 * sizeof(u32);
187 #endif
188         return crypto_register_shash(&alg);
189 }
190 
191 static void __exit poly1305_simd_mod_exit(void)
192 {
193         crypto_unregister_shash(&alg);
194 }
195 
196 module_init(poly1305_simd_mod_init);
197 module_exit(poly1305_simd_mod_exit);
198 
199 MODULE_LICENSE("GPL");
200 MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
201 MODULE_DESCRIPTION("Poly1305 authenticator");
202 MODULE_ALIAS_CRYPTO("poly1305");
203 MODULE_ALIAS_CRYPTO("poly1305-simd");
204 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp