drivers/crypto/ccp/ccp-crypto.h

   1 /*
   2  * AMD Cryptographic Coprocessor (CCP) crypto API support
   3  *
   4  * Copyright (C) 2013 Advanced Micro Devices, Inc.
   5  *
   6  * Author: Tom Lendacky <thomas.lendacky@amd.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #ifndef __CCP_CRYPTO_H__
  14 #define __CCP_CRYPTO_H__
  15
  16 #include <linux/list.h>
  17 #include <linux/wait.h>
  18 #include <linux/pci.h>
  19 #include <linux/ccp.h>
  20 #include <linux/crypto.h>
  21 #include <crypto/algapi.h>
  22 #include <crypto/aes.h>
  23 #include <crypto/ctr.h>
  24 #include <crypto/hash.h>
  25 #include <crypto/sha.h>
  26
  27 #define CCP_CRA_PRIORITY        300
  28
  29 struct ccp_crypto_ablkcipher_alg {
  30         struct list_head entry;
  31
  32         u32 mode;
  33
  34         struct crypto_alg alg;
  35 };
  36
  37 struct ccp_crypto_ahash_alg {
  38         struct list_head entry;
  39
  40         const __be32 *init;
  41         u32 type;
  42         u32 mode;
  43
  44         /* Child algorithm used for HMAC, CMAC, etc */
  45         char child_alg[CRYPTO_MAX_ALG_NAME];
  46
  47         struct ahash_alg alg;
  48 };
  49
  50 static inline struct ccp_crypto_ablkcipher_alg *
  51         ccp_crypto_ablkcipher_alg(struct crypto_tfm *tfm)
  52 {
  53         struct crypto_alg *alg = tfm->__crt_alg;
  54
  55         return container_of(alg, struct ccp_crypto_ablkcipher_alg, alg);
  56 }
  57
  58 static inline struct ccp_crypto_ahash_alg *
  59         ccp_crypto_ahash_alg(struct crypto_tfm *tfm)
  60 {
  61         struct crypto_alg *alg = tfm->__crt_alg;
  62         struct ahash_alg *ahash_alg;
  63
  64         ahash_alg = container_of(alg, struct ahash_alg, halg.base);
  65
  66         return container_of(ahash_alg, struct ccp_crypto_ahash_alg, alg);
  67 }
  68
  69 /***** AES related defines *****/
  70 struct ccp_aes_ctx {
  71         /* Fallback cipher for XTS with unsupported unit sizes */
  72         struct crypto_ablkcipher *tfm_ablkcipher;
  73
  74         /* Cipher used to generate CMAC K1/K2 keys */
  75         struct crypto_cipher *tfm_cipher;
  76
  77         enum ccp_engine engine;
  78         enum ccp_aes_type type;
  79         enum ccp_aes_mode mode;
  80
  81         struct scatterlist key_sg;
  82         unsigned int key_len;
  83         u8 key[AES_MAX_KEY_SIZE];
  84
  85         u8 nonce[CTR_RFC3686_NONCE_SIZE];
  86
  87         /* CMAC key structures */
  88         struct scatterlist k1_sg;
  89         struct scatterlist k2_sg;
  90         unsigned int kn_len;
  91         u8 k1[AES_BLOCK_SIZE];
  92         u8 k2[AES_BLOCK_SIZE];
  93 };
  94
  95 struct ccp_aes_req_ctx {
  96         struct scatterlist iv_sg;
  97         u8 iv[AES_BLOCK_SIZE];
  98
  99         /* Fields used for RFC3686 requests */
 100         u8 *rfc3686_info;
 101         u8 rfc3686_iv[AES_BLOCK_SIZE];
 102
 103         struct ccp_cmd cmd;
 104 };
 105
 106 struct ccp_aes_cmac_req_ctx {
 107         unsigned int null_msg;
 108         unsigned int final;
 109
 110         struct scatterlist *src;
 111         unsigned int nbytes;
 112
 113         u64 hash_cnt;
 114         unsigned int hash_rem;
 115
 116         struct sg_table data_sg;
 117
 118         struct scatterlist iv_sg;
 119         u8 iv[AES_BLOCK_SIZE];
 120
 121         struct scatterlist buf_sg;
 122         unsigned int buf_count;
 123         u8 buf[AES_BLOCK_SIZE];
 124
 125         struct scatterlist pad_sg;
 126         unsigned int pad_count;
 127         u8 pad[AES_BLOCK_SIZE];
 128
 129         struct ccp_cmd cmd;
 130 };
 131
 132 struct ccp_aes_cmac_exp_ctx {
 133         unsigned int null_msg;
 134
 135         u8 iv[AES_BLOCK_SIZE];
 136
 137         unsigned int buf_count;
 138         u8 buf[AES_BLOCK_SIZE];
 139 };
 140
 141 /***** SHA related defines *****/
 142 #define MAX_SHA_CONTEXT_SIZE    SHA256_DIGEST_SIZE
 143 #define MAX_SHA_BLOCK_SIZE      SHA256_BLOCK_SIZE
 144
 145 struct ccp_sha_ctx {
 146         struct scatterlist opad_sg;
 147         unsigned int opad_count;
 148
 149         unsigned int key_len;
 150         u8 key[MAX_SHA_BLOCK_SIZE];
 151         u8 ipad[MAX_SHA_BLOCK_SIZE];
 152         u8 opad[MAX_SHA_BLOCK_SIZE];
 153         struct crypto_shash *hmac_tfm;
 154 };
 155
 156 struct ccp_sha_req_ctx {
 157         enum ccp_sha_type type;
 158
 159         u64 msg_bits;
 160
 161         unsigned int first;
 162         unsigned int final;
 163
 164         struct scatterlist *src;
 165         unsigned int nbytes;
 166
 167         u64 hash_cnt;
 168         unsigned int hash_rem;
 169
 170         struct sg_table data_sg;
 171
 172         struct scatterlist ctx_sg;
 173         u8 ctx[MAX_SHA_CONTEXT_SIZE];
 174
 175         struct scatterlist buf_sg;
 176         unsigned int buf_count;
 177         u8 buf[MAX_SHA_BLOCK_SIZE];
 178
 179         /* CCP driver command */
 180         struct ccp_cmd cmd;
 181 };
 182
 183 struct ccp_sha_exp_ctx {
 184         enum ccp_sha_type type;
 185
 186         u64 msg_bits;
 187
 188         unsigned int first;
 189
 190         u8 ctx[MAX_SHA_CONTEXT_SIZE];
 191
 192         unsigned int buf_count;
 193         u8 buf[MAX_SHA_BLOCK_SIZE];
 194 };
 195
 196 /***** Common Context Structure *****/
 197 struct ccp_ctx {
 198         int (*complete)(struct crypto_async_request *req, int ret);
 199
 200         union {
 201                 struct ccp_aes_ctx aes;
 202                 struct ccp_sha_ctx sha;
 203         } u;
 204 };
 205
 206 int ccp_crypto_enqueue_request(struct crypto_async_request *req,
 207                                struct ccp_cmd *cmd);
 208 struct scatterlist *ccp_crypto_sg_table_add(struct sg_table *table,
 209                                             struct scatterlist *sg_add);
 210
 211 int ccp_register_aes_algs(struct list_head *head);
 212 int ccp_register_aes_cmac_algs(struct list_head *head);
 213 int ccp_register_aes_xts_algs(struct list_head *head);
 214 int ccp_register_sha_algs(struct list_head *head);
 215
 216 #endif