[linux-2.6-block.git] / drivers / s390 / crypto / zcrypt_cca_key.h

/*
 *  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_ */
Commit	Line	Data
6684af1a	1	/*
5432114b	2	* zcrypt 2.1.0
6684af1a	3	*
a53c8fab	4	* Copyright IBM Corp. 2001, 2006
6684af1a MS	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;
1749a81d	175	/*
6684af1a MS	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) + 2mex->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 = -(3long_len + 2short_len) & 7;
297	key_len = 3long_len + 2short_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 + 2long_len + 2short_len,
332	crt->u_mult_inv, long_len))
333	return -EFAULT;
334	memset(key->key_parts + 3long_len + 2short_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;
1749a81d	339	/*
6684af1a MS	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_ */