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