arch/x86/crypto/fpu.c

   1 /*
   2  * FPU: Wrapper for blkcipher touching fpu
   3  *
   4  * Copyright (c) Intel Corp.
   5  *   Author: Huang Ying <ying.huang@intel.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  */
  13
  14 #include <crypto/internal/skcipher.h>
  15 #include <linux/err.h>
  16 #include <linux/init.h>
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/slab.h>
  20 #include <asm/fpu/api.h>
  21
  22 struct crypto_fpu_ctx {
  23         struct crypto_skcipher *child;
  24 };
  25
  26 static int crypto_fpu_setkey(struct crypto_skcipher *parent, const u8 *key,
  27                              unsigned int keylen)
  28 {
  29         struct crypto_fpu_ctx *ctx = crypto_skcipher_ctx(parent);
  30         struct crypto_skcipher *child = ctx->child;
  31         int err;
  32
  33         crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
  34         crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(parent) &
  35                                          CRYPTO_TFM_REQ_MASK);
  36         err = crypto_skcipher_setkey(child, key, keylen);
  37         crypto_skcipher_set_flags(parent, crypto_skcipher_get_flags(child) &
  38                                           CRYPTO_TFM_RES_MASK);
  39         return err;
  40 }
  41
  42 static int crypto_fpu_encrypt(struct skcipher_request *req)
  43 {
  44         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  45         struct crypto_fpu_ctx *ctx = crypto_skcipher_ctx(tfm);
  46         struct crypto_skcipher *child = ctx->child;
  47         SKCIPHER_REQUEST_ON_STACK(subreq, child);
  48         int err;
  49
  50         skcipher_request_set_tfm(subreq, child);
  51         skcipher_request_set_callback(subreq, 0, NULL, NULL);
  52         skcipher_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
  53                                    req->iv);
  54
  55         kernel_fpu_begin();
  56         err = crypto_skcipher_encrypt(subreq);
  57         kernel_fpu_end();
  58
  59         skcipher_request_zero(subreq);
  60         return err;
  61 }
  62
  63 static int crypto_fpu_decrypt(struct skcipher_request *req)
  64 {
  65         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  66         struct crypto_fpu_ctx *ctx = crypto_skcipher_ctx(tfm);
  67         struct crypto_skcipher *child = ctx->child;
  68         SKCIPHER_REQUEST_ON_STACK(subreq, child);
  69         int err;
  70
  71         skcipher_request_set_tfm(subreq, child);
  72         skcipher_request_set_callback(subreq, 0, NULL, NULL);
  73         skcipher_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
  74                                    req->iv);
  75
  76         kernel_fpu_begin();
  77         err = crypto_skcipher_decrypt(subreq);
  78         kernel_fpu_end();
  79
  80         skcipher_request_zero(subreq);
  81         return err;
  82 }
  83
  84 static int crypto_fpu_init_tfm(struct crypto_skcipher *tfm)
  85 {
  86         struct skcipher_instance *inst = skcipher_alg_instance(tfm);
  87         struct crypto_fpu_ctx *ctx = crypto_skcipher_ctx(tfm);
  88         struct crypto_skcipher_spawn *spawn;
  89         struct crypto_skcipher *cipher;
  90
  91         spawn = skcipher_instance_ctx(inst);
  92         cipher = crypto_spawn_skcipher(spawn);
  93         if (IS_ERR(cipher))
  94                 return PTR_ERR(cipher);
  95
  96         ctx->child = cipher;
  97
  98         return 0;
  99 }
 100
 101 static void crypto_fpu_exit_tfm(struct crypto_skcipher *tfm)
 102 {
 103         struct crypto_fpu_ctx *ctx = crypto_skcipher_ctx(tfm);
 104
 105         crypto_free_skcipher(ctx->child);
 106 }
 107
 108 static void crypto_fpu_free(struct skcipher_instance *inst)
 109 {
 110         crypto_drop_skcipher(skcipher_instance_ctx(inst));
 111         kfree(inst);
 112 }
 113
 114 static int crypto_fpu_create(struct crypto_template *tmpl, struct rtattr **tb)
 115 {
 116         struct crypto_skcipher_spawn *spawn;
 117         struct skcipher_instance *inst;
 118         struct crypto_attr_type *algt;
 119         struct skcipher_alg *alg;
 120         const char *cipher_name;
 121         int err;
 122
 123         algt = crypto_get_attr_type(tb);
 124         if (IS_ERR(algt))
 125                 return PTR_ERR(algt);
 126
 127         if ((algt->type ^ (CRYPTO_ALG_INTERNAL | CRYPTO_ALG_TYPE_SKCIPHER)) &
 128             algt->mask)
 129                 return -EINVAL;
 130
 131         if (!(algt->mask & CRYPTO_ALG_INTERNAL))
 132                 return -EINVAL;
 133
 134         cipher_name = crypto_attr_alg_name(tb[1]);
 135         if (IS_ERR(cipher_name))
 136                 return PTR_ERR(cipher_name);
 137
 138         inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
 139         if (!inst)
 140                 return -ENOMEM;
 141
 142         spawn = skcipher_instance_ctx(inst);
 143
 144         crypto_set_skcipher_spawn(spawn, skcipher_crypto_instance(inst));
 145         err = crypto_grab_skcipher(spawn, cipher_name, CRYPTO_ALG_INTERNAL,
 146                                    CRYPTO_ALG_INTERNAL | CRYPTO_ALG_ASYNC);
 147         if (err)
 148                 goto out_free_inst;
 149
 150         alg = crypto_skcipher_spawn_alg(spawn);
 151
 152         err = crypto_inst_setname(skcipher_crypto_instance(inst), "fpu",
 153                                   &alg->base);
 154         if (err)
 155                 goto out_drop_skcipher;
 156
 157         inst->alg.base.cra_flags = CRYPTO_ALG_INTERNAL;
 158         inst->alg.base.cra_priority = alg->base.cra_priority;
 159         inst->alg.base.cra_blocksize = alg->base.cra_blocksize;
 160         inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
 161
 162         inst->alg.ivsize = crypto_skcipher_alg_ivsize(alg);
 163         inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(alg);
 164         inst->alg.max_keysize = crypto_skcipher_alg_max_keysize(alg);
 165
 166         inst->alg.base.cra_ctxsize = sizeof(struct crypto_fpu_ctx);
 167
 168         inst->alg.init = crypto_fpu_init_tfm;
 169         inst->alg.exit = crypto_fpu_exit_tfm;
 170
 171         inst->alg.setkey = crypto_fpu_setkey;
 172         inst->alg.encrypt = crypto_fpu_encrypt;
 173         inst->alg.decrypt = crypto_fpu_decrypt;
 174
 175         inst->free = crypto_fpu_free;
 176
 177         err = skcipher_register_instance(tmpl, inst);
 178         if (err)
 179                 goto out_drop_skcipher;
 180
 181 out:
 182         return err;
 183
 184 out_drop_skcipher:
 185         crypto_drop_skcipher(spawn);
 186 out_free_inst:
 187         kfree(inst);
 188         goto out;
 189 }
 190
 191 static struct crypto_template crypto_fpu_tmpl = {
 192         .name = "fpu",
 193         .create = crypto_fpu_create,
 194         .module = THIS_MODULE,
 195 };
 196
 197 int __init crypto_fpu_init(void)
 198 {
 199         return crypto_register_template(&crypto_fpu_tmpl);
 200 }
 201
 202 void crypto_fpu_exit(void)
 203 {
 204         crypto_unregister_template(&crypto_fpu_tmpl);
 205 }
 206
 207 MODULE_ALIAS_CRYPTO("fpu");