drivers/crypto/nx/nx-aes-ctr.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /**
   3  * AES CTR routines supporting the Power 7+ Nest Accelerators driver
   4  *
   5  * Copyright (C) 2011-2012 International Business Machines Inc.
   6  *
   7  * Author: Kent Yoder <yoder1@us.ibm.com>
   8  */
   9
  10 #include <crypto/aes.h>
  11 #include <crypto/ctr.h>
  12 #include <crypto/algapi.h>
  13 #include <linux/module.h>
  14 #include <linux/types.h>
  15 #include <linux/crypto.h>
  16 #include <asm/vio.h>
  17
  18 #include "nx_csbcpb.h"
  19 #include "nx.h"
  20
  21
  22 static int ctr_aes_nx_set_key(struct crypto_tfm *tfm,
  23                               const u8          *in_key,
  24                               unsigned int       key_len)
  25 {
  26         struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
  27         struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
  28
  29         nx_ctx_init(nx_ctx, HCOP_FC_AES);
  30
  31         switch (key_len) {
  32         case AES_KEYSIZE_128:
  33                 NX_CPB_SET_KEY_SIZE(csbcpb, NX_KS_AES_128);
  34                 nx_ctx->ap = &nx_ctx->props[NX_PROPS_AES_128];
  35                 break;
  36         case AES_KEYSIZE_192:
  37                 NX_CPB_SET_KEY_SIZE(csbcpb, NX_KS_AES_192);
  38                 nx_ctx->ap = &nx_ctx->props[NX_PROPS_AES_192];
  39                 break;
  40         case AES_KEYSIZE_256:
  41                 NX_CPB_SET_KEY_SIZE(csbcpb, NX_KS_AES_256);
  42                 nx_ctx->ap = &nx_ctx->props[NX_PROPS_AES_256];
  43                 break;
  44         default:
  45                 return -EINVAL;
  46         }
  47
  48         csbcpb->cpb.hdr.mode = NX_MODE_AES_CTR;
  49         memcpy(csbcpb->cpb.aes_ctr.key, in_key, key_len);
  50
  51         return 0;
  52 }
  53
  54 static int ctr3686_aes_nx_set_key(struct crypto_tfm *tfm,
  55                                   const u8          *in_key,
  56                                   unsigned int       key_len)
  57 {
  58         struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
  59
  60         if (key_len < CTR_RFC3686_NONCE_SIZE)
  61                 return -EINVAL;
  62
  63         memcpy(nx_ctx->priv.ctr.nonce,
  64                in_key + key_len - CTR_RFC3686_NONCE_SIZE,
  65                CTR_RFC3686_NONCE_SIZE);
  66
  67         key_len -= CTR_RFC3686_NONCE_SIZE;
  68
  69         return ctr_aes_nx_set_key(tfm, in_key, key_len);
  70 }
  71
  72 static int ctr_aes_nx_crypt(struct blkcipher_desc *desc,
  73                             struct scatterlist    *dst,
  74                             struct scatterlist    *src,
  75                             unsigned int           nbytes)
  76 {
  77         struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
  78         struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
  79         unsigned long irq_flags;
  80         unsigned int processed = 0, to_process;
  81         int rc;
  82
  83         spin_lock_irqsave(&nx_ctx->lock, irq_flags);
  84
  85         do {
  86                 to_process = nbytes - processed;
  87
  88                 rc = nx_build_sg_lists(nx_ctx, desc, dst, src, &to_process,
  89                                        processed, csbcpb->cpb.aes_ctr.iv);
  90                 if (rc)
  91                         goto out;
  92
  93                 if (!nx_ctx->op.inlen || !nx_ctx->op.outlen) {
  94                         rc = -EINVAL;
  95                         goto out;
  96                 }
  97
  98                 rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
  99                                    desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
 100                 if (rc)
 101                         goto out;
 102
 103                 memcpy(desc->info, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);
 104
 105                 atomic_inc(&(nx_ctx->stats->aes_ops));
 106                 atomic64_add(csbcpb->csb.processed_byte_count,
 107                              &(nx_ctx->stats->aes_bytes));
 108
 109                 processed += to_process;
 110         } while (processed < nbytes);
 111 out:
 112         spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
 113         return rc;
 114 }
 115
 116 static int ctr3686_aes_nx_crypt(struct blkcipher_desc *desc,
 117                                 struct scatterlist    *dst,
 118                                 struct scatterlist    *src,
 119                                 unsigned int           nbytes)
 120 {
 121         struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
 122         u8 iv[16];
 123
 124         memcpy(iv, nx_ctx->priv.ctr.nonce, CTR_RFC3686_IV_SIZE);
 125         memcpy(iv + CTR_RFC3686_NONCE_SIZE,
 126                desc->info, CTR_RFC3686_IV_SIZE);
 127         iv[12] = iv[13] = iv[14] = 0;
 128         iv[15] = 1;
 129
 130         desc->info = iv;
 131
 132         return ctr_aes_nx_crypt(desc, dst, src, nbytes);
 133 }
 134
 135 struct crypto_alg nx_ctr3686_aes_alg = {
 136         .cra_name        = "rfc3686(ctr(aes))",
 137         .cra_driver_name = "rfc3686-ctr-aes-nx",
 138         .cra_priority    = 300,
 139         .cra_flags       = CRYPTO_ALG_TYPE_BLKCIPHER,
 140         .cra_blocksize   = 1,
 141         .cra_ctxsize     = sizeof(struct nx_crypto_ctx),
 142         .cra_type        = &crypto_blkcipher_type,
 143         .cra_module      = THIS_MODULE,
 144         .cra_init        = nx_crypto_ctx_aes_ctr_init,
 145         .cra_exit        = nx_crypto_ctx_exit,
 146         .cra_blkcipher = {
 147                 .min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
 148                 .max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
 149                 .ivsize      = CTR_RFC3686_IV_SIZE,
 150                 .setkey      = ctr3686_aes_nx_set_key,
 151                 .encrypt     = ctr3686_aes_nx_crypt,
 152                 .decrypt     = ctr3686_aes_nx_crypt,
 153         }
 154 };