Commit | Line | Data |
---|---|---|
6684af1a MS |
1 | /* |
2 | * linux/drivers/s390/crypto/zcrypt_cca_key.h | |
3 | * | |
5432114b | 4 | * zcrypt 2.1.0 |
6684af1a MS |
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; | |
1749a81d | 177 | /* |
6684af1a MS |
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; | |
1749a81d | 341 | /* |
6684af1a MS |
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_ */ |