238 lines · c
1/* SPDX-License-Identifier: GPL-2.0+ */2/*3 * Copyright IBM Corp. 2001, 20064 * Author(s): Robert Burroughs5 * Eric Rossman (edrossma@us.ibm.com)6 *7 * Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)8 * Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>9 */10 11#ifndef _ZCRYPT_CCA_KEY_H_12#define _ZCRYPT_CCA_KEY_H_13 14struct t6_keyblock_hdr {15 unsigned short blen;16 unsigned short ulen;17 unsigned short flags;18};19 20/**21 * mapping for the cca private ME key token.22 * Three parts of interest here: the header, the private section and23 * the public section.24 *25 * mapping for the cca key token header26 */27struct cca_token_hdr {28 unsigned char token_identifier;29 unsigned char version;30 unsigned short token_length;31 unsigned char reserved[4];32} __packed;33 34#define CCA_TKN_HDR_ID_EXT 0x1E35 36#define CCA_PVT_USAGE_ALL 0x8037 38/**39 * mapping for the cca public section40 * In a private key, the modulus doesn't appear in the public41 * section. So, an arbitrary public exponent of 0x010001 will be42 * used, for a section length of 0x0F always.43 */44struct cca_public_sec {45 unsigned char section_identifier;46 unsigned char version;47 unsigned short section_length;48 unsigned char reserved[2];49 unsigned short exponent_len;50 unsigned short modulus_bit_len;51 unsigned short modulus_byte_len; /* In a private key, this is 0 */52} __packed;53 54/**55 * mapping for the cca private CRT key 'token'56 * The first three parts (the only parts considered in this release)57 * are: the header, the private section and the public section.58 * The header and public section are the same as for the59 * struct cca_private_ext_ME60 *61 * Following the structure are the quantities p, q, dp, dq, u, pad,62 * and modulus, in that order, where pad_len is the modulo 863 * complement of the residue modulo 8 of the sum of64 * (p_len + q_len + dp_len + dq_len + u_len).65 */66struct cca_pvt_ext_crt_sec {67 unsigned char section_identifier;68 unsigned char version;69 unsigned short section_length;70 unsigned char private_key_hash[20];71 unsigned char reserved1[4];72 unsigned char key_format;73 unsigned char reserved2;74 unsigned char key_name_hash[20];75 unsigned char key_use_flags[4];76 unsigned short p_len;77 unsigned short q_len;78 unsigned short dp_len;79 unsigned short dq_len;80 unsigned short u_len;81 unsigned short mod_len;82 unsigned char reserved3[4];83 unsigned short pad_len;84 unsigned char reserved4[52];85 unsigned char confounder[8];86} __packed;87 88#define CCA_PVT_EXT_CRT_SEC_ID_PVT 0x0889#define CCA_PVT_EXT_CRT_SEC_FMT_CL 0x4090 91/**92 * Set up private key fields of a type6 MEX message.93 *94 * @mex: pointer to user input data95 * @p: pointer to memory area for the key96 *97 * Returns the size of the key area or negative errno value.98 */99static inline int zcrypt_type6_mex_key_en(struct ica_rsa_modexpo *mex, void *p)100{101 static struct cca_token_hdr static_pub_hdr = {102 .token_identifier = 0x1E,103 };104 static struct cca_public_sec static_pub_sec = {105 .section_identifier = 0x04,106 };107 struct {108 struct t6_keyblock_hdr t6_hdr;109 struct cca_token_hdr pubhdr;110 struct cca_public_sec pubsec;111 char exponent[];112 } __packed *key = p;113 unsigned char *ptr;114 115 /*116 * The inputdatalength was a selection criteria in the dispatching117 * function zcrypt_rsa_modexpo(). However, do a plausibility check118 * here to make sure the following copy_from_user() can't be utilized119 * to compromise the system.120 */121 if (WARN_ON_ONCE(mex->inputdatalength > 512))122 return -EINVAL;123 124 memset(key, 0, sizeof(*key));125 126 key->pubhdr = static_pub_hdr;127 key->pubsec = static_pub_sec;128 129 /* key parameter block */130 ptr = key->exponent;131 if (copy_from_user(ptr, mex->b_key, mex->inputdatalength))132 return -EFAULT;133 ptr += mex->inputdatalength;134 /* modulus */135 if (copy_from_user(ptr, mex->n_modulus, mex->inputdatalength))136 return -EFAULT;137 138 key->pubsec.modulus_bit_len = 8 * mex->inputdatalength;139 key->pubsec.modulus_byte_len = mex->inputdatalength;140 key->pubsec.exponent_len = mex->inputdatalength;141 key->pubsec.section_length = sizeof(key->pubsec) +142 2 * mex->inputdatalength;143 key->pubhdr.token_length =144 key->pubsec.section_length + sizeof(key->pubhdr);145 key->t6_hdr.ulen = key->pubhdr.token_length + 4;146 key->t6_hdr.blen = key->pubhdr.token_length + 6;147 148 return sizeof(*key) + 2 * mex->inputdatalength;149}150 151/**152 * Set up private key fields of a type6 CRT message.153 *154 * @mex: pointer to user input data155 * @p: pointer to memory area for the key156 *157 * Returns the size of the key area or -EFAULT158 */159static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt *crt, void *p)160{161 static struct cca_public_sec static_cca_pub_sec = {162 .section_identifier = 4,163 .section_length = 0x000f,164 .exponent_len = 0x0003,165 };166 static char pk_exponent[3] = { 0x01, 0x00, 0x01 };167 struct {168 struct t6_keyblock_hdr t6_hdr;169 struct cca_token_hdr token;170 struct cca_pvt_ext_crt_sec pvt;171 char key_parts[];172 } __packed *key = p;173 struct cca_public_sec *pub;174 int short_len, long_len, pad_len, key_len, size;175 176 /*177 * The inputdatalength was a selection criteria in the dispatching178 * function zcrypt_rsa_crt(). However, do a plausibility check179 * here to make sure the following copy_from_user() can't be utilized180 * to compromise the system.181 */182 if (WARN_ON_ONCE(crt->inputdatalength > 512))183 return -EINVAL;184 185 memset(key, 0, sizeof(*key));186 187 short_len = (crt->inputdatalength + 1) / 2;188 long_len = short_len + 8;189 pad_len = -(3 * long_len + 2 * short_len) & 7;190 key_len = 3 * long_len + 2 * short_len + pad_len + crt->inputdatalength;191 size = sizeof(*key) + key_len + sizeof(*pub) + 3;192 193 /* parameter block.key block */194 key->t6_hdr.blen = size;195 key->t6_hdr.ulen = size - 2;196 197 /* key token header */198 key->token.token_identifier = CCA_TKN_HDR_ID_EXT;199 key->token.token_length = size - 6;200 201 /* private section */202 key->pvt.section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT;203 key->pvt.section_length = sizeof(key->pvt) + key_len;204 key->pvt.key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL;205 key->pvt.key_use_flags[0] = CCA_PVT_USAGE_ALL;206 key->pvt.p_len = key->pvt.dp_len = key->pvt.u_len = long_len;207 key->pvt.q_len = key->pvt.dq_len = short_len;208 key->pvt.mod_len = crt->inputdatalength;209 key->pvt.pad_len = pad_len;210 211 /* key parts */212 if (copy_from_user(key->key_parts, crt->np_prime, long_len) ||213 copy_from_user(key->key_parts + long_len,214 crt->nq_prime, short_len) ||215 copy_from_user(key->key_parts + long_len + short_len,216 crt->bp_key, long_len) ||217 copy_from_user(key->key_parts + 2 * long_len + short_len,218 crt->bq_key, short_len) ||219 copy_from_user(key->key_parts + 2 * long_len + 2 * short_len,220 crt->u_mult_inv, long_len))221 return -EFAULT;222 memset(key->key_parts + 3 * long_len + 2 * short_len + pad_len,223 0xff, crt->inputdatalength);224 pub = (struct cca_public_sec *)(key->key_parts + key_len);225 *pub = static_cca_pub_sec;226 pub->modulus_bit_len = 8 * crt->inputdatalength;227 /*228 * In a private key, the modulus doesn't appear in the public229 * section. So, an arbitrary public exponent of 0x010001 will be230 * used.231 */232 memcpy((char *)(pub + 1), pk_exponent, 3);233 234 return size;235}236 237#endif /* _ZCRYPT_CCA_KEY_H_ */238