1/**
2 * AES CTR routines supporting VMX instructions on the Power 8
3 *
4 * Copyright (C) 2015 International Business Machines Inc.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 only.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 *
19 * Author: Marcelo Henrique Cerri <mhcerri@br.ibm.com>
20 */
21
22#include <linux/types.h>
23#include <linux/err.h>
24#include <linux/crypto.h>
25#include <linux/delay.h>
26#include <linux/hardirq.h>
27#include <asm/switch_to.h>
28#include <crypto/aes.h>
29#include <crypto/scatterwalk.h>
30#include "aesp8-ppc.h"
31
32struct p8_aes_ctr_ctx {
33    struct crypto_blkcipher *fallback;
34    struct aes_key enc_key;
35};
36
37static int p8_aes_ctr_init(struct crypto_tfm *tfm)
38{
39    const char *alg;
40    struct crypto_blkcipher *fallback;
41    struct p8_aes_ctr_ctx *ctx = crypto_tfm_ctx(tfm);
42
43    if (!(alg = crypto_tfm_alg_name(tfm))) {
44        printk(KERN_ERR "Failed to get algorithm name.\n");
45        return -ENOENT;
46    }
47
48    fallback = crypto_alloc_blkcipher(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK);
49    if (IS_ERR(fallback)) {
50        printk(KERN_ERR "Failed to allocate transformation for '%s': %ld\n",
51                alg, PTR_ERR(fallback));
52        return PTR_ERR(fallback);
53    }
54    printk(KERN_INFO "Using '%s' as fallback implementation.\n",
55            crypto_tfm_alg_driver_name((struct crypto_tfm *) fallback));
56
57    crypto_blkcipher_set_flags(fallback,
58            crypto_blkcipher_get_flags((struct crypto_blkcipher *) tfm));
59    ctx->fallback = fallback;
60
61    return 0;
62}
63
64static void p8_aes_ctr_exit(struct crypto_tfm *tfm)
65{
66    struct p8_aes_ctr_ctx *ctx = crypto_tfm_ctx(tfm);
67
68    if (ctx->fallback) {
69        crypto_free_blkcipher(ctx->fallback);
70        ctx->fallback = NULL;
71    }
72}
73
74static int p8_aes_ctr_setkey(struct crypto_tfm *tfm, const u8 *key,
75    unsigned int keylen)
76{
77    int ret;
78    struct p8_aes_ctr_ctx *ctx = crypto_tfm_ctx(tfm);
79
80    pagefault_disable();
81    enable_kernel_altivec();
82    enable_kernel_vsx();
83    ret = aes_p8_set_encrypt_key(key, keylen * 8, &ctx->enc_key);
84    pagefault_enable();
85
86    ret += crypto_blkcipher_setkey(ctx->fallback, key, keylen);
87    return ret;
88}
89
90static void p8_aes_ctr_final(struct p8_aes_ctr_ctx *ctx,
91                struct blkcipher_walk *walk)
92{
93    u8 *ctrblk = walk->iv;
94    u8 keystream[AES_BLOCK_SIZE];
95    u8 *src = walk->src.virt.addr;
96    u8 *dst = walk->dst.virt.addr;
97    unsigned int nbytes = walk->nbytes;
98
99    pagefault_disable();
100    enable_kernel_altivec();
101    enable_kernel_vsx();
102    aes_p8_encrypt(ctrblk, keystream, &ctx->enc_key);
103    pagefault_enable();
104
105    crypto_xor(keystream, src, nbytes);
106    memcpy(dst, keystream, nbytes);
107    crypto_inc(ctrblk, AES_BLOCK_SIZE);
108}
109
110static int p8_aes_ctr_crypt(struct blkcipher_desc *desc,
111    struct scatterlist *dst, struct scatterlist *src,
112    unsigned int nbytes)
113{
114    int ret;
115    struct blkcipher_walk walk;
116    struct p8_aes_ctr_ctx *ctx = crypto_tfm_ctx(
117            crypto_blkcipher_tfm(desc->tfm));
118    struct blkcipher_desc fallback_desc = {
119        .tfm = ctx->fallback,
120        .info = desc->info,
121        .flags = desc->flags
122    };
123
124    if (in_interrupt()) {
125        ret = crypto_blkcipher_encrypt(&fallback_desc, dst, src, nbytes);
126    } else {
127        blkcipher_walk_init(&walk, dst, src, nbytes);
128        ret = blkcipher_walk_virt_block(desc, &walk, AES_BLOCK_SIZE);
129        while ((nbytes = walk.nbytes) >= AES_BLOCK_SIZE) {
130            pagefault_disable();
131            enable_kernel_altivec();
132            enable_kernel_vsx();
133            aes_p8_ctr32_encrypt_blocks(walk.src.virt.addr, walk.dst.virt.addr,
134                (nbytes & AES_BLOCK_MASK)/AES_BLOCK_SIZE, &ctx->enc_key, walk.iv);
135            pagefault_enable();
136
137            crypto_inc(walk.iv, AES_BLOCK_SIZE);
138            nbytes &= AES_BLOCK_SIZE - 1;
139            ret = blkcipher_walk_done(desc, &walk, nbytes);
140        }
141        if (walk.nbytes) {
142            p8_aes_ctr_final(ctx, &walk);
143            ret = blkcipher_walk_done(desc, &walk, 0);
144        }
145    }
146
147    return ret;
148}
149
150struct crypto_alg p8_aes_ctr_alg = {
151    .cra_name = "ctr(aes)",
152    .cra_driver_name = "p8_aes_ctr",
153    .cra_module = THIS_MODULE,
154    .cra_priority = 1000,
155    .cra_type = &crypto_blkcipher_type,
156    .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_NEED_FALLBACK,
157    .cra_alignmask = 0,
158    .cra_blocksize = 1,
159    .cra_ctxsize = sizeof(struct p8_aes_ctr_ctx),
160    .cra_init = p8_aes_ctr_init,
161    .cra_exit = p8_aes_ctr_exit,
162    .cra_blkcipher = {
163        .ivsize = 0,
164        .min_keysize = AES_MIN_KEY_SIZE,
165        .max_keysize = AES_MAX_KEY_SIZE,
166        .setkey = p8_aes_ctr_setkey,
167        .encrypt = p8_aes_ctr_crypt,
168        .decrypt = p8_aes_ctr_crypt,
169    },
170};
171