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 #define CCA_PVT_USAGE_ALL 0x80
52 
53 /**
54  * mapping for the cca public section
55  * In a private key, the modulus doesn't appear in the public
56  * section. So, an arbitrary public exponent of 0x010001 will be
57  * used, for a section length of 0x0F always.
58  */
59 struct cca_public_sec {
60 	unsigned char  section_identifier;
61 	unsigned char  version;
62 	unsigned short section_length;
63 	unsigned char  reserved[2];
64 	unsigned short exponent_len;
65 	unsigned short modulus_bit_len;
66 	unsigned short modulus_byte_len;    /* In a private key, this is 0 */
67 } __attribute__((packed));
68 
69 /**
70  * mapping for the cca private CRT key 'token'
71  * The first three parts (the only parts considered in this release)
72  * are: the header, the private section and the public section.
73  * The header and public section are the same as for the
74  * struct cca_private_ext_ME
75  *
76  * Following the structure are the quantities p, q, dp, dq, u, pad,
77  * and modulus, in that order, where pad_len is the modulo 8
78  * complement of the residue modulo 8 of the sum of
79  * (p_len + q_len + dp_len + dq_len + u_len).
80  */
81 struct cca_pvt_ext_CRT_sec {
82 	unsigned char  section_identifier;
83 	unsigned char  version;
84 	unsigned short section_length;
85 	unsigned char  private_key_hash[20];
86 	unsigned char  reserved1[4];
87 	unsigned char  key_format;
88 	unsigned char  reserved2;
89 	unsigned char  key_name_hash[20];
90 	unsigned char  key_use_flags[4];
91 	unsigned short p_len;
92 	unsigned short q_len;
93 	unsigned short dp_len;
94 	unsigned short dq_len;
95 	unsigned short u_len;
96 	unsigned short mod_len;
97 	unsigned char  reserved3[4];
98 	unsigned short pad_len;
99 	unsigned char  reserved4[52];
100 	unsigned char  confounder[8];
101 } __attribute__((packed));
102 
103 #define CCA_PVT_EXT_CRT_SEC_ID_PVT 0x08
104 #define CCA_PVT_EXT_CRT_SEC_FMT_CL 0x40
105 
106 /**
107  * Set up private key fields of a type6 MEX message. The _pad variant
108  * strips leading zeroes from the b_key.
109  * Note that all numerics in the key token are big-endian,
110  * while the entries in the key block header are little-endian.
111  *
112  * @mex: pointer to user input data
113  * @p: pointer to memory area for the key
114  *
115  * Returns the size of the key area or -EFAULT
116  */
117 static inline int zcrypt_type6_mex_key_en(struct ica_rsa_modexpo *mex, void *p)
118 {
119 	static struct cca_token_hdr static_pub_hdr = {
120 		.token_identifier	=  0x1E,
121 	};
122 	static struct cca_public_sec static_pub_sec = {
123 		.section_identifier	=  0x04,
124 	};
125 	struct {
126 		struct T6_keyBlock_hdr t6_hdr;
127 		struct cca_token_hdr pubHdr;
128 		struct cca_public_sec pubSec;
129 		char exponent[0];
130 	} __attribute__((packed)) *key = p;
131 	unsigned char *temp;
132 	int i;
133 
134 	memset(key, 0, sizeof(*key));
135 
136 	key->pubHdr = static_pub_hdr;
137 	key->pubSec = static_pub_sec;
138 
139 	/* key parameter block */
140 	temp = key->exponent;
141 	if (copy_from_user(temp, mex->b_key, mex->inputdatalength))
142 		return -EFAULT;
143 	/* Strip leading zeroes from b_key. */
144 	for (i = 0; i < mex->inputdatalength; i++)
145 		if (temp[i])
146 			break;
147 	if (i >= mex->inputdatalength)
148 		return -EINVAL;
149 	memmove(temp, temp + i, mex->inputdatalength - i);
150 	temp += mex->inputdatalength - i;
151 	/* modulus */
152 	if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength))
153 		return -EFAULT;
154 
155 	key->pubSec.modulus_bit_len = 8 * mex->inputdatalength;
156 	key->pubSec.modulus_byte_len = mex->inputdatalength;
157 	key->pubSec.exponent_len = mex->inputdatalength - i;
158 	key->pubSec.section_length = sizeof(key->pubSec) +
159 					2*mex->inputdatalength - i;
160 	key->pubHdr.token_length =
161 		key->pubSec.section_length + sizeof(key->pubHdr);
162 	key->t6_hdr.ulen = key->pubHdr.token_length + 4;
163 	key->t6_hdr.blen = key->pubHdr.token_length + 6;
164 	return sizeof(*key) + 2*mex->inputdatalength - i;
165 }
166 
167 /**
168  * Set up private key fields of a type6 CRT message.
169  * Note that all numerics in the key token are big-endian,
170  * while the entries in the key block header are little-endian.
171  *
172  * @mex: pointer to user input data
173  * @p: pointer to memory area for the key
174  *
175  * Returns the size of the key area or -EFAULT
176  */
177 static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt *crt, void *p)
178 {
179 	static struct cca_public_sec static_cca_pub_sec = {
180 		.section_identifier = 4,
181 		.section_length = 0x000f,
182 		.exponent_len = 0x0003,
183 	};
184 	static char pk_exponent[3] = { 0x01, 0x00, 0x01 };
185 	struct {
186 		struct T6_keyBlock_hdr t6_hdr;
187 		struct cca_token_hdr token;
188 		struct cca_pvt_ext_CRT_sec pvt;
189 		char key_parts[0];
190 	} __attribute__((packed)) *key = p;
191 	struct cca_public_sec *pub;
192 	int short_len, long_len, pad_len, key_len, size;
193 
194 	memset(key, 0, sizeof(*key));
195 
196 	short_len = (crt->inputdatalength + 1) / 2;
197 	long_len = short_len + 8;
198 	pad_len = -(3*long_len + 2*short_len) & 7;
199 	key_len = 3*long_len + 2*short_len + pad_len + crt->inputdatalength;
200 	size = sizeof(*key) + key_len + sizeof(*pub) + 3;
201 
202 	/* parameter block.key block */
203 	key->t6_hdr.blen = size;
204 	key->t6_hdr.ulen = size - 2;
205 
206 	/* key token header */
207 	key->token.token_identifier = CCA_TKN_HDR_ID_EXT;
208 	key->token.token_length = size - 6;
209 
210 	/* private section */
211 	key->pvt.section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT;
212 	key->pvt.section_length = sizeof(key->pvt) + key_len;
213 	key->pvt.key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL;
214 	key->pvt.key_use_flags[0] = CCA_PVT_USAGE_ALL;
215 	key->pvt.p_len = key->pvt.dp_len = key->pvt.u_len = long_len;
216 	key->pvt.q_len = key->pvt.dq_len = short_len;
217 	key->pvt.mod_len = crt->inputdatalength;
218 	key->pvt.pad_len = pad_len;
219 
220 	/* key parts */
221 	if (copy_from_user(key->key_parts, crt->np_prime, long_len) ||
222 	    copy_from_user(key->key_parts + long_len,
223 					crt->nq_prime, short_len) ||
224 	    copy_from_user(key->key_parts + long_len + short_len,
225 					crt->bp_key, long_len) ||
226 	    copy_from_user(key->key_parts + 2*long_len + short_len,
227 					crt->bq_key, short_len) ||
228 	    copy_from_user(key->key_parts + 2*long_len + 2*short_len,
229 					crt->u_mult_inv, long_len))
230 		return -EFAULT;
231 	memset(key->key_parts + 3*long_len + 2*short_len + pad_len,
232 	       0xff, crt->inputdatalength);
233 	pub = (struct cca_public_sec *)(key->key_parts + key_len);
234 	*pub = static_cca_pub_sec;
235 	pub->modulus_bit_len = 8 * crt->inputdatalength;
236 	/*
237 	 * In a private key, the modulus doesn't appear in the public
238 	 * section. So, an arbitrary public exponent of 0x010001 will be
239 	 * used.
240 	 */
241 	memcpy((char *) (pub + 1), pk_exponent, 3);
242 	return size;
243 }
244 
245 #endif /* _ZCRYPT_CCA_KEY_H_ */
246