drivers/s390/crypto/zcrypt_cca_key.h

   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
  31 struct 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  */
  44 struct 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  */
  56 struct 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  */
  81 struct 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  */
 103 struct 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  */
 138 static 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  */
 210 static 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  */
 276 static 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_ */