a53c8fab3f
Remove the file name from the comment at top of many files. In most cases the file name was wrong anyway, so it's rather pointless. Also unify the IBM copyright statement. We did have a lot of sightly different statements and wanted to change them one after another whenever a file gets touched. However that never happened. Instead people start to take the old/"wrong" statements to use as a template for new files. So unify all of them in one go. Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
349 lines
11 KiB
C
349 lines
11 KiB
C
/*
|
|
* zcrypt 2.1.0
|
|
*
|
|
* Copyright IBM Corp. 2001, 2006
|
|
* Author(s): Robert Burroughs
|
|
* Eric Rossman (edrossma@us.ibm.com)
|
|
*
|
|
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
|
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#ifndef _ZCRYPT_CCA_KEY_H_
|
|
#define _ZCRYPT_CCA_KEY_H_
|
|
|
|
struct T6_keyBlock_hdr {
|
|
unsigned short blen;
|
|
unsigned short ulen;
|
|
unsigned short flags;
|
|
};
|
|
|
|
/**
|
|
* mapping for the cca private ME key token.
|
|
* Three parts of interest here: the header, the private section and
|
|
* the public section.
|
|
*
|
|
* mapping for the cca key token header
|
|
*/
|
|
struct cca_token_hdr {
|
|
unsigned char token_identifier;
|
|
unsigned char version;
|
|
unsigned short token_length;
|
|
unsigned char reserved[4];
|
|
} __attribute__((packed));
|
|
|
|
#define CCA_TKN_HDR_ID_EXT 0x1E
|
|
|
|
/**
|
|
* mapping for the cca private ME section
|
|
*/
|
|
struct cca_private_ext_ME_sec {
|
|
unsigned char section_identifier;
|
|
unsigned char version;
|
|
unsigned short section_length;
|
|
unsigned char private_key_hash[20];
|
|
unsigned char reserved1[4];
|
|
unsigned char key_format;
|
|
unsigned char reserved2;
|
|
unsigned char key_name_hash[20];
|
|
unsigned char key_use_flags[4];
|
|
unsigned char reserved3[6];
|
|
unsigned char reserved4[24];
|
|
unsigned char confounder[24];
|
|
unsigned char exponent[128];
|
|
unsigned char modulus[128];
|
|
} __attribute__((packed));
|
|
|
|
#define CCA_PVT_USAGE_ALL 0x80
|
|
|
|
/**
|
|
* mapping for the cca public section
|
|
* In a private key, the modulus doesn't appear in the public
|
|
* section. So, an arbitrary public exponent of 0x010001 will be
|
|
* used, for a section length of 0x0F always.
|
|
*/
|
|
struct cca_public_sec {
|
|
unsigned char section_identifier;
|
|
unsigned char version;
|
|
unsigned short section_length;
|
|
unsigned char reserved[2];
|
|
unsigned short exponent_len;
|
|
unsigned short modulus_bit_len;
|
|
unsigned short modulus_byte_len; /* In a private key, this is 0 */
|
|
} __attribute__((packed));
|
|
|
|
/**
|
|
* mapping for the cca private CRT key 'token'
|
|
* The first three parts (the only parts considered in this release)
|
|
* are: the header, the private section and the public section.
|
|
* The header and public section are the same as for the
|
|
* struct cca_private_ext_ME
|
|
*
|
|
* Following the structure are the quantities p, q, dp, dq, u, pad,
|
|
* and modulus, in that order, where pad_len is the modulo 8
|
|
* complement of the residue modulo 8 of the sum of
|
|
* (p_len + q_len + dp_len + dq_len + u_len).
|
|
*/
|
|
struct cca_pvt_ext_CRT_sec {
|
|
unsigned char section_identifier;
|
|
unsigned char version;
|
|
unsigned short section_length;
|
|
unsigned char private_key_hash[20];
|
|
unsigned char reserved1[4];
|
|
unsigned char key_format;
|
|
unsigned char reserved2;
|
|
unsigned char key_name_hash[20];
|
|
unsigned char key_use_flags[4];
|
|
unsigned short p_len;
|
|
unsigned short q_len;
|
|
unsigned short dp_len;
|
|
unsigned short dq_len;
|
|
unsigned short u_len;
|
|
unsigned short mod_len;
|
|
unsigned char reserved3[4];
|
|
unsigned short pad_len;
|
|
unsigned char reserved4[52];
|
|
unsigned char confounder[8];
|
|
} __attribute__((packed));
|
|
|
|
#define CCA_PVT_EXT_CRT_SEC_ID_PVT 0x08
|
|
#define CCA_PVT_EXT_CRT_SEC_FMT_CL 0x40
|
|
|
|
/**
|
|
* Set up private key fields of a type6 MEX message.
|
|
* Note that all numerics in the key token are big-endian,
|
|
* while the entries in the key block header are little-endian.
|
|
*
|
|
* @mex: pointer to user input data
|
|
* @p: pointer to memory area for the key
|
|
*
|
|
* Returns the size of the key area or -EFAULT
|
|
*/
|
|
static inline int zcrypt_type6_mex_key_de(struct ica_rsa_modexpo *mex,
|
|
void *p, int big_endian)
|
|
{
|
|
static struct cca_token_hdr static_pvt_me_hdr = {
|
|
.token_identifier = 0x1E,
|
|
.token_length = 0x0183,
|
|
};
|
|
static struct cca_private_ext_ME_sec static_pvt_me_sec = {
|
|
.section_identifier = 0x02,
|
|
.section_length = 0x016C,
|
|
.key_use_flags = {0x80,0x00,0x00,0x00},
|
|
};
|
|
static struct cca_public_sec static_pub_me_sec = {
|
|
.section_identifier = 0x04,
|
|
.section_length = 0x000F,
|
|
.exponent_len = 0x0003,
|
|
};
|
|
static char pk_exponent[3] = { 0x01, 0x00, 0x01 };
|
|
struct {
|
|
struct T6_keyBlock_hdr t6_hdr;
|
|
struct cca_token_hdr pvtMeHdr;
|
|
struct cca_private_ext_ME_sec pvtMeSec;
|
|
struct cca_public_sec pubMeSec;
|
|
char exponent[3];
|
|
} __attribute__((packed)) *key = p;
|
|
unsigned char *temp;
|
|
|
|
memset(key, 0, sizeof(*key));
|
|
|
|
if (big_endian) {
|
|
key->t6_hdr.blen = cpu_to_be16(0x189);
|
|
key->t6_hdr.ulen = cpu_to_be16(0x189 - 2);
|
|
} else {
|
|
key->t6_hdr.blen = cpu_to_le16(0x189);
|
|
key->t6_hdr.ulen = cpu_to_le16(0x189 - 2);
|
|
}
|
|
key->pvtMeHdr = static_pvt_me_hdr;
|
|
key->pvtMeSec = static_pvt_me_sec;
|
|
key->pubMeSec = static_pub_me_sec;
|
|
/*
|
|
* In a private key, the modulus doesn't appear in the public
|
|
* section. So, an arbitrary public exponent of 0x010001 will be
|
|
* used.
|
|
*/
|
|
memcpy(key->exponent, pk_exponent, 3);
|
|
|
|
/* key parameter block */
|
|
temp = key->pvtMeSec.exponent +
|
|
sizeof(key->pvtMeSec.exponent) - mex->inputdatalength;
|
|
if (copy_from_user(temp, mex->b_key, mex->inputdatalength))
|
|
return -EFAULT;
|
|
|
|
/* modulus */
|
|
temp = key->pvtMeSec.modulus +
|
|
sizeof(key->pvtMeSec.modulus) - mex->inputdatalength;
|
|
if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength))
|
|
return -EFAULT;
|
|
key->pubMeSec.modulus_bit_len = 8 * mex->inputdatalength;
|
|
return sizeof(*key);
|
|
}
|
|
|
|
/**
|
|
* Set up private key fields of a type6 MEX message. The _pad variant
|
|
* strips leading zeroes from the b_key.
|
|
* Note that all numerics in the key token are big-endian,
|
|
* while the entries in the key block header are little-endian.
|
|
*
|
|
* @mex: pointer to user input data
|
|
* @p: pointer to memory area for the key
|
|
*
|
|
* Returns the size of the key area or -EFAULT
|
|
*/
|
|
static inline int zcrypt_type6_mex_key_en(struct ica_rsa_modexpo *mex,
|
|
void *p, int big_endian)
|
|
{
|
|
static struct cca_token_hdr static_pub_hdr = {
|
|
.token_identifier = 0x1E,
|
|
};
|
|
static struct cca_public_sec static_pub_sec = {
|
|
.section_identifier = 0x04,
|
|
};
|
|
struct {
|
|
struct T6_keyBlock_hdr t6_hdr;
|
|
struct cca_token_hdr pubHdr;
|
|
struct cca_public_sec pubSec;
|
|
char exponent[0];
|
|
} __attribute__((packed)) *key = p;
|
|
unsigned char *temp;
|
|
int i;
|
|
|
|
memset(key, 0, sizeof(*key));
|
|
|
|
key->pubHdr = static_pub_hdr;
|
|
key->pubSec = static_pub_sec;
|
|
|
|
/* key parameter block */
|
|
temp = key->exponent;
|
|
if (copy_from_user(temp, mex->b_key, mex->inputdatalength))
|
|
return -EFAULT;
|
|
/* Strip leading zeroes from b_key. */
|
|
for (i = 0; i < mex->inputdatalength; i++)
|
|
if (temp[i])
|
|
break;
|
|
if (i >= mex->inputdatalength)
|
|
return -EINVAL;
|
|
memmove(temp, temp + i, mex->inputdatalength - i);
|
|
temp += mex->inputdatalength - i;
|
|
/* modulus */
|
|
if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength))
|
|
return -EFAULT;
|
|
|
|
key->pubSec.modulus_bit_len = 8 * mex->inputdatalength;
|
|
key->pubSec.modulus_byte_len = mex->inputdatalength;
|
|
key->pubSec.exponent_len = mex->inputdatalength - i;
|
|
key->pubSec.section_length = sizeof(key->pubSec) +
|
|
2*mex->inputdatalength - i;
|
|
key->pubHdr.token_length =
|
|
key->pubSec.section_length + sizeof(key->pubHdr);
|
|
if (big_endian) {
|
|
key->t6_hdr.ulen = cpu_to_be16(key->pubHdr.token_length + 4);
|
|
key->t6_hdr.blen = cpu_to_be16(key->pubHdr.token_length + 6);
|
|
} else {
|
|
key->t6_hdr.ulen = cpu_to_le16(key->pubHdr.token_length + 4);
|
|
key->t6_hdr.blen = cpu_to_le16(key->pubHdr.token_length + 6);
|
|
}
|
|
return sizeof(*key) + 2*mex->inputdatalength - i;
|
|
}
|
|
|
|
/**
|
|
* Set up private key fields of a type6 CRT message.
|
|
* Note that all numerics in the key token are big-endian,
|
|
* while the entries in the key block header are little-endian.
|
|
*
|
|
* @mex: pointer to user input data
|
|
* @p: pointer to memory area for the key
|
|
*
|
|
* Returns the size of the key area or -EFAULT
|
|
*/
|
|
static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt *crt,
|
|
void *p, int big_endian)
|
|
{
|
|
static struct cca_public_sec static_cca_pub_sec = {
|
|
.section_identifier = 4,
|
|
.section_length = 0x000f,
|
|
.exponent_len = 0x0003,
|
|
};
|
|
static char pk_exponent[3] = { 0x01, 0x00, 0x01 };
|
|
struct {
|
|
struct T6_keyBlock_hdr t6_hdr;
|
|
struct cca_token_hdr token;
|
|
struct cca_pvt_ext_CRT_sec pvt;
|
|
char key_parts[0];
|
|
} __attribute__((packed)) *key = p;
|
|
struct cca_public_sec *pub;
|
|
int short_len, long_len, pad_len, key_len, size;
|
|
|
|
memset(key, 0, sizeof(*key));
|
|
|
|
short_len = crt->inputdatalength / 2;
|
|
long_len = short_len + 8;
|
|
pad_len = -(3*long_len + 2*short_len) & 7;
|
|
key_len = 3*long_len + 2*short_len + pad_len + crt->inputdatalength;
|
|
size = sizeof(*key) + key_len + sizeof(*pub) + 3;
|
|
|
|
/* parameter block.key block */
|
|
if (big_endian) {
|
|
key->t6_hdr.blen = cpu_to_be16(size);
|
|
key->t6_hdr.ulen = cpu_to_be16(size - 2);
|
|
} else {
|
|
key->t6_hdr.blen = cpu_to_le16(size);
|
|
key->t6_hdr.ulen = cpu_to_le16(size - 2);
|
|
}
|
|
|
|
/* key token header */
|
|
key->token.token_identifier = CCA_TKN_HDR_ID_EXT;
|
|
key->token.token_length = size - 6;
|
|
|
|
/* private section */
|
|
key->pvt.section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT;
|
|
key->pvt.section_length = sizeof(key->pvt) + key_len;
|
|
key->pvt.key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL;
|
|
key->pvt.key_use_flags[0] = CCA_PVT_USAGE_ALL;
|
|
key->pvt.p_len = key->pvt.dp_len = key->pvt.u_len = long_len;
|
|
key->pvt.q_len = key->pvt.dq_len = short_len;
|
|
key->pvt.mod_len = crt->inputdatalength;
|
|
key->pvt.pad_len = pad_len;
|
|
|
|
/* key parts */
|
|
if (copy_from_user(key->key_parts, crt->np_prime, long_len) ||
|
|
copy_from_user(key->key_parts + long_len,
|
|
crt->nq_prime, short_len) ||
|
|
copy_from_user(key->key_parts + long_len + short_len,
|
|
crt->bp_key, long_len) ||
|
|
copy_from_user(key->key_parts + 2*long_len + short_len,
|
|
crt->bq_key, short_len) ||
|
|
copy_from_user(key->key_parts + 2*long_len + 2*short_len,
|
|
crt->u_mult_inv, long_len))
|
|
return -EFAULT;
|
|
memset(key->key_parts + 3*long_len + 2*short_len + pad_len,
|
|
0xff, crt->inputdatalength);
|
|
pub = (struct cca_public_sec *)(key->key_parts + key_len);
|
|
*pub = static_cca_pub_sec;
|
|
pub->modulus_bit_len = 8 * crt->inputdatalength;
|
|
/*
|
|
* In a private key, the modulus doesn't appear in the public
|
|
* section. So, an arbitrary public exponent of 0x010001 will be
|
|
* used.
|
|
*/
|
|
memcpy((char *) (pub + 1), pk_exponent, 3);
|
|
return size;
|
|
}
|
|
|
|
#endif /* _ZCRYPT_CCA_KEY_H_ */
|