1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * AES CBC routines supporting VMX instructions on the Power 8 4 * 5 * Copyright (C) 2015 International Business Machines Inc. 6 * 7 * Author: Marcelo Henrique Cerri <mhcerri@br.ibm.com> 8 */ 9 10 #include <asm/simd.h> 11 #include <asm/switch_to.h> 12 #include <crypto/aes.h> 13 #include <crypto/internal/simd.h> 14 #include <crypto/internal/skcipher.h> 15 #include <linux/err.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/uaccess.h> 19 20 #include "aesp8-ppc.h" 21 22 struct p8_aes_cbc_ctx { 23 struct crypto_skcipher *fallback; 24 struct aes_key enc_key; 25 struct aes_key dec_key; 26 }; 27 28 static int p8_aes_cbc_init(struct crypto_skcipher *tfm) 29 { 30 struct p8_aes_cbc_ctx *ctx = crypto_skcipher_ctx(tfm); 31 struct crypto_skcipher *fallback; 32 33 fallback = crypto_alloc_skcipher("cbc(aes)", 0, 34 CRYPTO_ALG_NEED_FALLBACK | 35 CRYPTO_ALG_ASYNC); 36 if (IS_ERR(fallback)) { 37 pr_err("Failed to allocate cbc(aes) fallback: %ld\n", 38 PTR_ERR(fallback)); 39 return PTR_ERR(fallback); 40 } 41 42 crypto_skcipher_set_reqsize(tfm, sizeof(struct skcipher_request) + 43 crypto_skcipher_reqsize(fallback)); 44 ctx->fallback = fallback; 45 return 0; 46 } 47 48 static void p8_aes_cbc_exit(struct crypto_skcipher *tfm) 49 { 50 struct p8_aes_cbc_ctx *ctx = crypto_skcipher_ctx(tfm); 51 52 crypto_free_skcipher(ctx->fallback); 53 } 54 55 static int p8_aes_cbc_setkey(struct crypto_skcipher *tfm, const u8 *key, 56 unsigned int keylen) 57 { 58 struct p8_aes_cbc_ctx *ctx = crypto_skcipher_ctx(tfm); 59 int ret; 60 61 preempt_disable(); 62 pagefault_disable(); 63 enable_kernel_vsx(); 64 ret = aes_p8_set_encrypt_key(key, keylen * 8, &ctx->enc_key); 65 ret |= aes_p8_set_decrypt_key(key, keylen * 8, &ctx->dec_key); 66 disable_kernel_vsx(); 67 pagefault_enable(); 68 preempt_enable(); 69 70 ret |= crypto_skcipher_setkey(ctx->fallback, key, keylen); 71 72 return ret ? -EINVAL : 0; 73 } 74 75 static int p8_aes_cbc_crypt(struct skcipher_request *req, int enc) 76 { 77 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 78 const struct p8_aes_cbc_ctx *ctx = crypto_skcipher_ctx(tfm); 79 struct skcipher_walk walk; 80 unsigned int nbytes; 81 int ret; 82 83 if (!crypto_simd_usable()) { 84 struct skcipher_request *subreq = skcipher_request_ctx(req); 85 86 *subreq = *req; 87 skcipher_request_set_tfm(subreq, ctx->fallback); 88 return enc ? crypto_skcipher_encrypt(subreq) : 89 crypto_skcipher_decrypt(subreq); 90 } 91 92 ret = skcipher_walk_virt(&walk, req, false); 93 while ((nbytes = walk.nbytes) != 0) { 94 preempt_disable(); 95 pagefault_disable(); 96 enable_kernel_vsx(); 97 aes_p8_cbc_encrypt(walk.src.virt.addr, 98 walk.dst.virt.addr, 99 round_down(nbytes, AES_BLOCK_SIZE), 100 enc ? &ctx->enc_key : &ctx->dec_key, 101 walk.iv, enc); 102 disable_kernel_vsx(); 103 pagefault_enable(); 104 preempt_enable(); 105 106 ret = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE); 107 } 108 return ret; 109 } 110 111 static int p8_aes_cbc_encrypt(struct skcipher_request *req) 112 { 113 return p8_aes_cbc_crypt(req, 1); 114 } 115 116 static int p8_aes_cbc_decrypt(struct skcipher_request *req) 117 { 118 return p8_aes_cbc_crypt(req, 0); 119 } 120 121 struct skcipher_alg p8_aes_cbc_alg = { 122 .base.cra_name = "cbc(aes)", 123 .base.cra_driver_name = "p8_aes_cbc", 124 .base.cra_module = THIS_MODULE, 125 .base.cra_priority = 2000, 126 .base.cra_flags = CRYPTO_ALG_NEED_FALLBACK, 127 .base.cra_blocksize = AES_BLOCK_SIZE, 128 .base.cra_ctxsize = sizeof(struct p8_aes_cbc_ctx), 129 .setkey = p8_aes_cbc_setkey, 130 .encrypt = p8_aes_cbc_encrypt, 131 .decrypt = p8_aes_cbc_decrypt, 132 .init = p8_aes_cbc_init, 133 .exit = p8_aes_cbc_exit, 134 .min_keysize = AES_MIN_KEY_SIZE, 135 .max_keysize = AES_MAX_KEY_SIZE, 136 .ivsize = AES_BLOCK_SIZE, 137 }; 138