drivers/crypto/ccp/ccp-crypto.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * AMD Cryptographic Coprocessor (CCP) crypto API support
   4  *
   5  * Copyright (C) 2013,2017 Advanced Micro Devices, Inc.
   6  *
   7  * Author: Tom Lendacky <thomas.lendacky@amd.com>
   8  */
   9
  10 #ifndef __CCP_CRYPTO_H__
  11 #define __CCP_CRYPTO_H__
  12
  13 #include <linux/list.h>
  14 #include <linux/wait.h>
  15 #include <linux/ccp.h>
  16 #include <crypto/algapi.h>
  17 #include <crypto/aes.h>
  18 #include <crypto/internal/aead.h>
  19 #include <crypto/aead.h>
  20 #include <crypto/ctr.h>
  21 #include <crypto/hash.h>
  22 #include <crypto/sha.h>
  23 #include <crypto/akcipher.h>
  24 #include <crypto/skcipher.h>
  25 #include <crypto/internal/rsa.h>
  26
  27 /* We want the module name in front of our messages */
  28 #undef pr_fmt
  29 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
  30
  31 #define CCP_LOG_LEVEL   KERN_INFO
  32
  33 #define CCP_CRA_PRIORITY        300
  34
  35 struct ccp_crypto_skcipher_alg {
  36         struct list_head entry;
  37
  38         u32 mode;
  39
  40         struct skcipher_alg alg;
  41 };
  42
  43 struct ccp_crypto_aead {
  44         struct list_head entry;
  45
  46         u32 mode;
  47
  48         struct aead_alg alg;
  49 };
  50
  51 struct ccp_crypto_ahash_alg {
  52         struct list_head entry;
  53
  54         const __be32 *init;
  55         u32 type;
  56         u32 mode;
  57
  58         /* Child algorithm used for HMAC, CMAC, etc */
  59         char child_alg[CRYPTO_MAX_ALG_NAME];
  60
  61         struct ahash_alg alg;
  62 };
  63
  64 struct ccp_crypto_akcipher_alg {
  65         struct list_head entry;
  66
  67         struct akcipher_alg alg;
  68 };
  69
  70 static inline struct ccp_crypto_skcipher_alg *
  71         ccp_crypto_skcipher_alg(struct crypto_skcipher *tfm)
  72 {
  73         struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
  74
  75         return container_of(alg, struct ccp_crypto_skcipher_alg, alg);
  76 }
  77
  78 static inline struct ccp_crypto_ahash_alg *
  79         ccp_crypto_ahash_alg(struct crypto_tfm *tfm)
  80 {
  81         struct crypto_alg *alg = tfm->__crt_alg;
  82         struct ahash_alg *ahash_alg;
  83
  84         ahash_alg = container_of(alg, struct ahash_alg, halg.base);
  85
  86         return container_of(ahash_alg, struct ccp_crypto_ahash_alg, alg);
  87 }
  88
  89 /***** AES related defines *****/
  90 struct ccp_aes_ctx {
  91         /* Fallback cipher for XTS with unsupported unit sizes */
  92         struct crypto_sync_skcipher *tfm_skcipher;
  93
  94         enum ccp_engine engine;
  95         enum ccp_aes_type type;
  96         enum ccp_aes_mode mode;
  97
  98         struct scatterlist key_sg;
  99         unsigned int key_len;
 100         u8 key[AES_MAX_KEY_SIZE * 2];
 101
 102         u8 nonce[CTR_RFC3686_NONCE_SIZE];
 103
 104         /* CMAC key structures */
 105         struct scatterlist k1_sg;
 106         struct scatterlist k2_sg;
 107         unsigned int kn_len;
 108         u8 k1[AES_BLOCK_SIZE];
 109         u8 k2[AES_BLOCK_SIZE];
 110 };
 111
 112 struct ccp_aes_req_ctx {
 113         struct scatterlist iv_sg;
 114         u8 iv[AES_BLOCK_SIZE];
 115
 116         struct scatterlist tag_sg;
 117         u8 tag[AES_BLOCK_SIZE];
 118
 119         /* Fields used for RFC3686 requests */
 120         u8 *rfc3686_info;
 121         u8 rfc3686_iv[AES_BLOCK_SIZE];
 122
 123         struct ccp_cmd cmd;
 124 };
 125
 126 struct ccp_aes_cmac_req_ctx {
 127         unsigned int null_msg;
 128         unsigned int final;
 129
 130         struct scatterlist *src;
 131         unsigned int nbytes;
 132
 133         u64 hash_cnt;
 134         unsigned int hash_rem;
 135
 136         struct sg_table data_sg;
 137
 138         struct scatterlist iv_sg;
 139         u8 iv[AES_BLOCK_SIZE];
 140
 141         struct scatterlist buf_sg;
 142         unsigned int buf_count;
 143         u8 buf[AES_BLOCK_SIZE];
 144
 145         struct scatterlist pad_sg;
 146         unsigned int pad_count;
 147         u8 pad[AES_BLOCK_SIZE];
 148
 149         struct ccp_cmd cmd;
 150 };
 151
 152 struct ccp_aes_cmac_exp_ctx {
 153         unsigned int null_msg;
 154
 155         u8 iv[AES_BLOCK_SIZE];
 156
 157         unsigned int buf_count;
 158         u8 buf[AES_BLOCK_SIZE];
 159 };
 160
 161 /***** 3DES related defines *****/
 162 struct ccp_des3_ctx {
 163         enum ccp_engine engine;
 164         enum ccp_des3_type type;
 165         enum ccp_des3_mode mode;
 166
 167         struct scatterlist key_sg;
 168         unsigned int key_len;
 169         u8 key[AES_MAX_KEY_SIZE];
 170 };
 171
 172 struct ccp_des3_req_ctx {
 173         struct scatterlist iv_sg;
 174         u8 iv[AES_BLOCK_SIZE];
 175
 176         struct ccp_cmd cmd;
 177 };
 178
 179 /* SHA-related defines
 180  * These values must be large enough to accommodate any variant
 181  */
 182 #define MAX_SHA_CONTEXT_SIZE    SHA512_DIGEST_SIZE
 183 #define MAX_SHA_BLOCK_SIZE      SHA512_BLOCK_SIZE
 184
 185 struct ccp_sha_ctx {
 186         struct scatterlist opad_sg;
 187         unsigned int opad_count;
 188
 189         unsigned int key_len;
 190         u8 key[MAX_SHA_BLOCK_SIZE];
 191         u8 ipad[MAX_SHA_BLOCK_SIZE];
 192         u8 opad[MAX_SHA_BLOCK_SIZE];
 193         struct crypto_shash *hmac_tfm;
 194 };
 195
 196 struct ccp_sha_req_ctx {
 197         enum ccp_sha_type type;
 198
 199         u64 msg_bits;
 200
 201         unsigned int first;
 202         unsigned int final;
 203
 204         struct scatterlist *src;
 205         unsigned int nbytes;
 206
 207         u64 hash_cnt;
 208         unsigned int hash_rem;
 209
 210         struct sg_table data_sg;
 211
 212         struct scatterlist ctx_sg;
 213         u8 ctx[MAX_SHA_CONTEXT_SIZE];
 214
 215         struct scatterlist buf_sg;
 216         unsigned int buf_count;
 217         u8 buf[MAX_SHA_BLOCK_SIZE];
 218
 219         /* CCP driver command */
 220         struct ccp_cmd cmd;
 221 };
 222
 223 struct ccp_sha_exp_ctx {
 224         enum ccp_sha_type type;
 225
 226         u64 msg_bits;
 227
 228         unsigned int first;
 229
 230         u8 ctx[MAX_SHA_CONTEXT_SIZE];
 231
 232         unsigned int buf_count;
 233         u8 buf[MAX_SHA_BLOCK_SIZE];
 234 };
 235
 236 /***** RSA related defines *****/
 237
 238 struct ccp_rsa_ctx {
 239         unsigned int key_len; /* in bits */
 240         struct scatterlist e_sg;
 241         u8 *e_buf;
 242         unsigned int e_len;
 243         struct scatterlist n_sg;
 244         u8 *n_buf;
 245         unsigned int n_len;
 246         struct scatterlist d_sg;
 247         u8 *d_buf;
 248         unsigned int d_len;
 249 };
 250
 251 struct ccp_rsa_req_ctx {
 252         struct ccp_cmd cmd;
 253 };
 254
 255 #define CCP_RSA_MAXMOD  (4 * 1024 / 8)
 256 #define CCP5_RSA_MAXMOD (16 * 1024 / 8)
 257
 258 /***** Common Context Structure *****/
 259 struct ccp_ctx {
 260         int (*complete)(struct crypto_async_request *req, int ret);
 261
 262         union {
 263                 struct ccp_aes_ctx aes;
 264                 struct ccp_rsa_ctx rsa;
 265                 struct ccp_sha_ctx sha;
 266                 struct ccp_des3_ctx des3;
 267         } u;
 268 };
 269
 270 int ccp_crypto_enqueue_request(struct crypto_async_request *req,
 271                                struct ccp_cmd *cmd);
 272 struct scatterlist *ccp_crypto_sg_table_add(struct sg_table *table,
 273                                             struct scatterlist *sg_add);
 274
 275 int ccp_register_aes_algs(struct list_head *head);
 276 int ccp_register_aes_cmac_algs(struct list_head *head);
 277 int ccp_register_aes_xts_algs(struct list_head *head);
 278 int ccp_register_aes_aeads(struct list_head *head);
 279 int ccp_register_sha_algs(struct list_head *head);
 280 int ccp_register_des3_algs(struct list_head *head);
 281 int ccp_register_rsa_algs(struct list_head *head);
 282
 283 #endif