1/* 2 * linux/drivers/s390/crypto/zcrypt_cca_key.h 3 * 4 * zcrypt 2.1.0 5 * 6 * Copyright (C) 2001, 2006 IBM Corporation 7 * Author(s): Robert Burroughs 8 * Eric Rossman (edrossma@us.ibm.com) 9 * 10 * Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com) 11 * Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com> 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2, or (at your option) 16 * any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License 24 * along with this program; if not, write to the Free Software 25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 26 */ 27 28#ifndef _ZCRYPT_CCA_KEY_H_ 29#define _ZCRYPT_CCA_KEY_H_ 30 31struct T6_keyBlock_hdr { 32 unsigned short blen; 33 unsigned short ulen; 34 unsigned short flags; 35}; 36 37/** 38 * mapping for the cca private ME key token. 39 * Three parts of interest here: the header, the private section and 40 * the public section. 41 * 42 * mapping for the cca key token header 43 */ 44struct cca_token_hdr { 45 unsigned char token_identifier; 46 unsigned char version; 47 unsigned short token_length; 48 unsigned char reserved[4]; 49} __attribute__((packed)); 50 51#define CCA_TKN_HDR_ID_EXT 0x1E 52 53/** 54 * mapping for the cca private ME section 55 */ 56struct cca_private_ext_ME_sec { 57 unsigned char section_identifier; 58 unsigned char version; 59 unsigned short section_length; 60 unsigned char private_key_hash[20]; 61 unsigned char reserved1[4]; 62 unsigned char key_format; 63 unsigned char reserved2; 64 unsigned char key_name_hash[20]; 65 unsigned char key_use_flags[4]; 66 unsigned char reserved3[6]; 67 unsigned char reserved4[24]; 68 unsigned char confounder[24]; 69 unsigned char exponent[128]; 70 unsigned char modulus[128]; 71} __attribute__((packed)); 72 73#define CCA_PVT_USAGE_ALL 0x80 74 75/** 76 * mapping for the cca public section 77 * In a private key, the modulus doesn't appear in the public 78 * section. So, an arbitrary public exponent of 0x010001 will be 79 * used, for a section length of 0x0F always. 80 */ 81struct cca_public_sec { 82 unsigned char section_identifier; 83 unsigned char version; 84 unsigned short section_length; 85 unsigned char reserved[2]; 86 unsigned short exponent_len; 87 unsigned short modulus_bit_len; 88 unsigned short modulus_byte_len; /* In a private key, this is 0 */ 89} __attribute__((packed)); 90 91/** 92 * mapping for the cca private CRT key 'token' 93 * The first three parts (the only parts considered in this release) 94 * are: the header, the private section and the public section. 95 * The header and public section are the same as for the 96 * struct cca_private_ext_ME 97 * 98 * Following the structure are the quantities p, q, dp, dq, u, pad, 99 * and modulus, in that order, where pad_len is the modulo 8 100 * complement of the residue modulo 8 of the sum of 101 * (p_len + q_len + dp_len + dq_len + u_len). 102 */ 103struct cca_pvt_ext_CRT_sec { 104 unsigned char section_identifier; 105 unsigned char version; 106 unsigned short section_length; 107 unsigned char private_key_hash[20]; 108 unsigned char reserved1[4]; 109 unsigned char key_format; 110 unsigned char reserved2; 111 unsigned char key_name_hash[20]; 112 unsigned char key_use_flags[4]; 113 unsigned short p_len; 114 unsigned short q_len; 115 unsigned short dp_len; 116 unsigned short dq_len; 117 unsigned short u_len; 118 unsigned short mod_len; 119 unsigned char reserved3[4]; 120 unsigned short pad_len; 121 unsigned char reserved4[52]; 122 unsigned char confounder[8]; 123} __attribute__((packed)); 124 125#define CCA_PVT_EXT_CRT_SEC_ID_PVT 0x08 126#define CCA_PVT_EXT_CRT_SEC_FMT_CL 0x40 127 128/** 129 * Set up private key fields of a type6 MEX message. 130 * Note that all numerics in the key token are big-endian, 131 * while the entries in the key block header are little-endian. 132 * 133 * @mex: pointer to user input data 134 * @p: pointer to memory area for the key 135 * 136 * Returns the size of the key area or -EFAULT 137 */ 138static inline int zcrypt_type6_mex_key_de(struct ica_rsa_modexpo *mex, 139 void *p, int big_endian) 140{ 141 static struct cca_token_hdr static_pvt_me_hdr = { 142 .token_identifier = 0x1E, 143 .token_length = 0x0183, 144 }; 145 static struct cca_private_ext_ME_sec static_pvt_me_sec = { 146 .section_identifier = 0x02, 147 .section_length = 0x016C, 148 .key_use_flags = {0x80,0x00,0x00,0x00}, 149 }; 150 static struct cca_public_sec static_pub_me_sec = { 151 .section_identifier = 0x04, 152 .section_length = 0x000F, 153 .exponent_len = 0x0003, 154 }; 155 static char pk_exponent[3] = { 0x01, 0x00, 0x01 }; 156 struct { 157 struct T6_keyBlock_hdr t6_hdr; 158 struct cca_token_hdr pvtMeHdr; 159 struct cca_private_ext_ME_sec pvtMeSec; 160 struct cca_public_sec pubMeSec; 161 char exponent[3]; 162 } __attribute__((packed)) *key = p; 163 unsigned char *temp; 164 165 memset(key, 0, sizeof(*key)); 166 167 if (big_endian) { 168 key->t6_hdr.blen = cpu_to_be16(0x189); 169 key->t6_hdr.ulen = cpu_to_be16(0x189 - 2); 170 } else { 171 key->t6_hdr.blen = cpu_to_le16(0x189); 172 key->t6_hdr.ulen = cpu_to_le16(0x189 - 2); 173 } 174 key->pvtMeHdr = static_pvt_me_hdr; 175 key->pvtMeSec = static_pvt_me_sec; 176 key->pubMeSec = static_pub_me_sec; 177 /** 178 * In a private key, the modulus doesn't appear in the public 179 * section. So, an arbitrary public exponent of 0x010001 will be 180 * used. 181 */ 182 memcpy(key->exponent, pk_exponent, 3); 183 184 /* key parameter block */ 185 temp = key->pvtMeSec.exponent + 186 sizeof(key->pvtMeSec.exponent) - mex->inputdatalength; 187 if (copy_from_user(temp, mex->b_key, mex->inputdatalength)) 188 return -EFAULT; 189 190 /* modulus */ 191 temp = key->pvtMeSec.modulus + 192 sizeof(key->pvtMeSec.modulus) - mex->inputdatalength; 193 if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength)) 194 return -EFAULT; 195 key->pubMeSec.modulus_bit_len = 8 * mex->inputdatalength; 196 return sizeof(*key); 197} 198 199/** 200 * Set up private key fields of a type6 MEX message. The _pad variant 201 * strips leading zeroes from the b_key. 202 * Note that all numerics in the key token are big-endian, 203 * while the entries in the key block header are little-endian. 204 * 205 * @mex: pointer to user input data 206 * @p: pointer to memory area for the key 207 * 208 * Returns the size of the key area or -EFAULT 209 */ 210static inline int zcrypt_type6_mex_key_en(struct ica_rsa_modexpo *mex, 211 void *p, int big_endian) 212{ 213 static struct cca_token_hdr static_pub_hdr = { 214 .token_identifier = 0x1E, 215 }; 216 static struct cca_public_sec static_pub_sec = { 217 .section_identifier = 0x04, 218 }; 219 struct { 220 struct T6_keyBlock_hdr t6_hdr; 221 struct cca_token_hdr pubHdr; 222 struct cca_public_sec pubSec; 223 char exponent[0]; 224 } __attribute__((packed)) *key = p; 225 unsigned char *temp; 226 int i; 227 228 memset(key, 0, sizeof(*key)); 229 230 key->pubHdr = static_pub_hdr; 231 key->pubSec = static_pub_sec; 232 233 /* key parameter block */ 234 temp = key->exponent; 235 if (copy_from_user(temp, mex->b_key, mex->inputdatalength)) 236 return -EFAULT; 237 /* Strip leading zeroes from b_key. */ 238 for (i = 0; i < mex->inputdatalength; i++) 239 if (temp[i]) 240 break; 241 if (i >= mex->inputdatalength) 242 return -EINVAL; 243 memmove(temp, temp + i, mex->inputdatalength - i); 244 temp += mex->inputdatalength - i; 245 /* modulus */ 246 if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength)) 247 return -EFAULT; 248 249 key->pubSec.modulus_bit_len = 8 * mex->inputdatalength; 250 key->pubSec.modulus_byte_len = mex->inputdatalength; 251 key->pubSec.exponent_len = mex->inputdatalength - i; 252 key->pubSec.section_length = sizeof(key->pubSec) + 253 2*mex->inputdatalength - i; 254 key->pubHdr.token_length = 255 key->pubSec.section_length + sizeof(key->pubHdr); 256 if (big_endian) { 257 key->t6_hdr.ulen = cpu_to_be16(key->pubHdr.token_length + 4); 258 key->t6_hdr.blen = cpu_to_be16(key->pubHdr.token_length + 6); 259 } else { 260 key->t6_hdr.ulen = cpu_to_le16(key->pubHdr.token_length + 4); 261 key->t6_hdr.blen = cpu_to_le16(key->pubHdr.token_length + 6); 262 } 263 return sizeof(*key) + 2*mex->inputdatalength - i; 264} 265 266/** 267 * Set up private key fields of a type6 CRT message. 268 * Note that all numerics in the key token are big-endian, 269 * while the entries in the key block header are little-endian. 270 * 271 * @mex: pointer to user input data 272 * @p: pointer to memory area for the key 273 * 274 * Returns the size of the key area or -EFAULT 275 */ 276static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt *crt, 277 void *p, int big_endian) 278{ 279 static struct cca_public_sec static_cca_pub_sec = { 280 .section_identifier = 4, 281 .section_length = 0x000f, 282 .exponent_len = 0x0003, 283 }; 284 static char pk_exponent[3] = { 0x01, 0x00, 0x01 }; 285 struct { 286 struct T6_keyBlock_hdr t6_hdr; 287 struct cca_token_hdr token; 288 struct cca_pvt_ext_CRT_sec pvt; 289 char key_parts[0]; 290 } __attribute__((packed)) *key = p; 291 struct cca_public_sec *pub; 292 int short_len, long_len, pad_len, key_len, size; 293 294 memset(key, 0, sizeof(*key)); 295 296 short_len = crt->inputdatalength / 2; 297 long_len = short_len + 8; 298 pad_len = -(3*long_len + 2*short_len) & 7; 299 key_len = 3*long_len + 2*short_len + pad_len + crt->inputdatalength; 300 size = sizeof(*key) + key_len + sizeof(*pub) + 3; 301 302 /* parameter block.key block */ 303 if (big_endian) { 304 key->t6_hdr.blen = cpu_to_be16(size); 305 key->t6_hdr.ulen = cpu_to_be16(size - 2); 306 } else { 307 key->t6_hdr.blen = cpu_to_le16(size); 308 key->t6_hdr.ulen = cpu_to_le16(size - 2); 309 } 310 311 /* key token header */ 312 key->token.token_identifier = CCA_TKN_HDR_ID_EXT; 313 key->token.token_length = size - 6; 314 315 /* private section */ 316 key->pvt.section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT; 317 key->pvt.section_length = sizeof(key->pvt) + key_len; 318 key->pvt.key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL; 319 key->pvt.key_use_flags[0] = CCA_PVT_USAGE_ALL; 320 key->pvt.p_len = key->pvt.dp_len = key->pvt.u_len = long_len; 321 key->pvt.q_len = key->pvt.dq_len = short_len; 322 key->pvt.mod_len = crt->inputdatalength; 323 key->pvt.pad_len = pad_len; 324 325 /* key parts */ 326 if (copy_from_user(key->key_parts, crt->np_prime, long_len) || 327 copy_from_user(key->key_parts + long_len, 328 crt->nq_prime, short_len) || 329 copy_from_user(key->key_parts + long_len + short_len, 330 crt->bp_key, long_len) || 331 copy_from_user(key->key_parts + 2*long_len + short_len, 332 crt->bq_key, short_len) || 333 copy_from_user(key->key_parts + 2*long_len + 2*short_len, 334 crt->u_mult_inv, long_len)) 335 return -EFAULT; 336 memset(key->key_parts + 3*long_len + 2*short_len + pad_len, 337 0xff, crt->inputdatalength); 338 pub = (struct cca_public_sec *)(key->key_parts + key_len); 339 *pub = static_cca_pub_sec; 340 pub->modulus_bit_len = 8 * crt->inputdatalength; 341 /** 342 * In a private key, the modulus doesn't appear in the public 343 * section. So, an arbitrary public exponent of 0x010001 will be 344 * used. 345 */ 346 memcpy((char *) (pub + 1), pk_exponent, 3); 347 return size; 348} 349 350#endif /* _ZCRYPT_CCA_KEY_H_ */ 351