1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * OpenSSL/Cryptogams accelerated Poly1305 transform for arm64 4 * 5 * Copyright (C) 2019 Linaro Ltd. <ard.biesheuvel@linaro.org> 6 */ 7 8 #include <asm/hwcap.h> 9 #include <asm/neon.h> 10 #include <asm/simd.h> 11 #include <asm/unaligned.h> 12 #include <crypto/algapi.h> 13 #include <crypto/internal/hash.h> 14 #include <crypto/internal/poly1305.h> 15 #include <crypto/internal/simd.h> 16 #include <linux/cpufeature.h> 17 #include <linux/crypto.h> 18 #include <linux/jump_label.h> 19 #include <linux/module.h> 20 21 asmlinkage void poly1305_init_arm64(void *state, const u8 *key); 22 asmlinkage void poly1305_blocks(void *state, const u8 *src, u32 len, u32 hibit); 23 asmlinkage void poly1305_blocks_neon(void *state, const u8 *src, u32 len, u32 hibit); 24 asmlinkage void poly1305_emit(void *state, u8 *digest, const u32 *nonce); 25 26 static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_neon); 27 28 void poly1305_init_arch(struct poly1305_desc_ctx *dctx, const u8 key[POLY1305_KEY_SIZE]) 29 { 30 poly1305_init_arm64(&dctx->h, key); 31 dctx->s[0] = get_unaligned_le32(key + 16); 32 dctx->s[1] = get_unaligned_le32(key + 20); 33 dctx->s[2] = get_unaligned_le32(key + 24); 34 dctx->s[3] = get_unaligned_le32(key + 28); 35 dctx->buflen = 0; 36 } 37 EXPORT_SYMBOL(poly1305_init_arch); 38 39 static int neon_poly1305_init(struct shash_desc *desc) 40 { 41 struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc); 42 43 dctx->buflen = 0; 44 dctx->rset = 0; 45 dctx->sset = false; 46 47 return 0; 48 } 49 50 static void neon_poly1305_blocks(struct poly1305_desc_ctx *dctx, const u8 *src, 51 u32 len, u32 hibit, bool do_neon) 52 { 53 if (unlikely(!dctx->sset)) { 54 if (!dctx->rset) { 55 poly1305_init_arm64(&dctx->h, src); 56 src += POLY1305_BLOCK_SIZE; 57 len -= POLY1305_BLOCK_SIZE; 58 dctx->rset = 1; 59 } 60 if (len >= POLY1305_BLOCK_SIZE) { 61 dctx->s[0] = get_unaligned_le32(src + 0); 62 dctx->s[1] = get_unaligned_le32(src + 4); 63 dctx->s[2] = get_unaligned_le32(src + 8); 64 dctx->s[3] = get_unaligned_le32(src + 12); 65 src += POLY1305_BLOCK_SIZE; 66 len -= POLY1305_BLOCK_SIZE; 67 dctx->sset = true; 68 } 69 if (len < POLY1305_BLOCK_SIZE) 70 return; 71 } 72 73 len &= ~(POLY1305_BLOCK_SIZE - 1); 74 75 if (static_branch_likely(&have_neon) && likely(do_neon)) 76 poly1305_blocks_neon(&dctx->h, src, len, hibit); 77 else 78 poly1305_blocks(&dctx->h, src, len, hibit); 79 } 80 81 static void neon_poly1305_do_update(struct poly1305_desc_ctx *dctx, 82 const u8 *src, u32 len, bool do_neon) 83 { 84 if (unlikely(dctx->buflen)) { 85 u32 bytes = min(len, POLY1305_BLOCK_SIZE - dctx->buflen); 86 87 memcpy(dctx->buf + dctx->buflen, src, bytes); 88 src += bytes; 89 len -= bytes; 90 dctx->buflen += bytes; 91 92 if (dctx->buflen == POLY1305_BLOCK_SIZE) { 93 neon_poly1305_blocks(dctx, dctx->buf, 94 POLY1305_BLOCK_SIZE, 1, false); 95 dctx->buflen = 0; 96 } 97 } 98 99 if (likely(len >= POLY1305_BLOCK_SIZE)) { 100 neon_poly1305_blocks(dctx, src, len, 1, do_neon); 101 src += round_down(len, POLY1305_BLOCK_SIZE); 102 len %= POLY1305_BLOCK_SIZE; 103 } 104 105 if (unlikely(len)) { 106 dctx->buflen = len; 107 memcpy(dctx->buf, src, len); 108 } 109 } 110 111 static int neon_poly1305_update(struct shash_desc *desc, 112 const u8 *src, unsigned int srclen) 113 { 114 bool do_neon = crypto_simd_usable() && srclen > 128; 115 struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc); 116 117 if (static_branch_likely(&have_neon) && do_neon) 118 kernel_neon_begin(); 119 neon_poly1305_do_update(dctx, src, srclen, do_neon); 120 if (static_branch_likely(&have_neon) && do_neon) 121 kernel_neon_end(); 122 return 0; 123 } 124 125 void poly1305_update_arch(struct poly1305_desc_ctx *dctx, const u8 *src, 126 unsigned int nbytes) 127 { 128 if (unlikely(dctx->buflen)) { 129 u32 bytes = min(nbytes, POLY1305_BLOCK_SIZE - dctx->buflen); 130 131 memcpy(dctx->buf + dctx->buflen, src, bytes); 132 src += bytes; 133 nbytes -= bytes; 134 dctx->buflen += bytes; 135 136 if (dctx->buflen == POLY1305_BLOCK_SIZE) { 137 poly1305_blocks(&dctx->h, dctx->buf, POLY1305_BLOCK_SIZE, 1); 138 dctx->buflen = 0; 139 } 140 } 141 142 if (likely(nbytes >= POLY1305_BLOCK_SIZE)) { 143 unsigned int len = round_down(nbytes, POLY1305_BLOCK_SIZE); 144 145 if (static_branch_likely(&have_neon) && crypto_simd_usable()) { 146 do { 147 unsigned int todo = min_t(unsigned int, len, SZ_4K); 148 149 kernel_neon_begin(); 150 poly1305_blocks_neon(&dctx->h, src, todo, 1); 151 kernel_neon_end(); 152 153 len -= todo; 154 src += todo; 155 } while (len); 156 } else { 157 poly1305_blocks(&dctx->h, src, len, 1); 158 src += len; 159 } 160 nbytes %= POLY1305_BLOCK_SIZE; 161 } 162 163 if (unlikely(nbytes)) { 164 dctx->buflen = nbytes; 165 memcpy(dctx->buf, src, nbytes); 166 } 167 } 168 EXPORT_SYMBOL(poly1305_update_arch); 169 170 void poly1305_final_arch(struct poly1305_desc_ctx *dctx, u8 *dst) 171 { 172 if (unlikely(dctx->buflen)) { 173 dctx->buf[dctx->buflen++] = 1; 174 memset(dctx->buf + dctx->buflen, 0, 175 POLY1305_BLOCK_SIZE - dctx->buflen); 176 poly1305_blocks(&dctx->h, dctx->buf, POLY1305_BLOCK_SIZE, 0); 177 } 178 179 poly1305_emit(&dctx->h, dst, dctx->s); 180 memzero_explicit(dctx, sizeof(*dctx)); 181 } 182 EXPORT_SYMBOL(poly1305_final_arch); 183 184 static int neon_poly1305_final(struct shash_desc *desc, u8 *dst) 185 { 186 struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc); 187 188 if (unlikely(!dctx->sset)) 189 return -ENOKEY; 190 191 poly1305_final_arch(dctx, dst); 192 return 0; 193 } 194 195 static struct shash_alg neon_poly1305_alg = { 196 .init = neon_poly1305_init, 197 .update = neon_poly1305_update, 198 .final = neon_poly1305_final, 199 .digestsize = POLY1305_DIGEST_SIZE, 200 .descsize = sizeof(struct poly1305_desc_ctx), 201 202 .base.cra_name = "poly1305", 203 .base.cra_driver_name = "poly1305-neon", 204 .base.cra_priority = 200, 205 .base.cra_blocksize = POLY1305_BLOCK_SIZE, 206 .base.cra_module = THIS_MODULE, 207 }; 208 209 static int __init neon_poly1305_mod_init(void) 210 { 211 if (!cpu_have_named_feature(ASIMD)) 212 return 0; 213 214 static_branch_enable(&have_neon); 215 216 return IS_REACHABLE(CONFIG_CRYPTO_HASH) ? 217 crypto_register_shash(&neon_poly1305_alg) : 0; 218 } 219 220 static void __exit neon_poly1305_mod_exit(void) 221 { 222 if (IS_REACHABLE(CONFIG_CRYPTO_HASH) && cpu_have_named_feature(ASIMD)) 223 crypto_unregister_shash(&neon_poly1305_alg); 224 } 225 226 module_init(neon_poly1305_mod_init); 227 module_exit(neon_poly1305_mod_exit); 228 229 MODULE_LICENSE("GPL v2"); 230 MODULE_ALIAS_CRYPTO("poly1305"); 231 MODULE_ALIAS_CRYPTO("poly1305-neon"); 232