1 /*
2 * Cryptographic API.
3 *
4 * Support for s390 cryptographic instructions.
5 *
6 * Copyright IBM Corp. 2003,2007
7 * Author(s): Thomas Spatzier
8 * Jan Glauber (jan.glauber@de.ibm.com)
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option)
13 * any later version.
14 *
15 */
16 #ifndef _CRYPTO_ARCH_S390_CRYPT_S390_H
17 #define _CRYPTO_ARCH_S390_CRYPT_S390_H
18
19 #include <asm/errno.h>
20
21 #define CRYPT_S390_OP_MASK 0xFF00
22 #define CRYPT_S390_FUNC_MASK 0x00FF
23
24 #define CRYPT_S390_PRIORITY 300
25 #define CRYPT_S390_COMPOSITE_PRIORITY 400
26
27 #define CRYPT_S390_MSA 0x1
28 #define CRYPT_S390_MSA3 0x2
29 #define CRYPT_S390_MSA4 0x4
30
31 /* s390 cryptographic operations */
32 enum crypt_s390_operations {
33 CRYPT_S390_KM = 0x0100,
34 CRYPT_S390_KMC = 0x0200,
35 CRYPT_S390_KIMD = 0x0300,
36 CRYPT_S390_KLMD = 0x0400,
37 CRYPT_S390_KMAC = 0x0500,
38 CRYPT_S390_KMCTR = 0x0600
39 };
40
41 /*
42 * function codes for KM (CIPHER MESSAGE) instruction
43 * 0x80 is the decipher modifier bit
44 */
45 enum crypt_s390_km_func {
46 KM_QUERY = CRYPT_S390_KM | 0x0,
47 KM_DEA_ENCRYPT = CRYPT_S390_KM | 0x1,
48 KM_DEA_DECRYPT = CRYPT_S390_KM | 0x1 | 0x80,
49 KM_TDEA_128_ENCRYPT = CRYPT_S390_KM | 0x2,
50 KM_TDEA_128_DECRYPT = CRYPT_S390_KM | 0x2 | 0x80,
51 KM_TDEA_192_ENCRYPT = CRYPT_S390_KM | 0x3,
52 KM_TDEA_192_DECRYPT = CRYPT_S390_KM | 0x3 | 0x80,
53 KM_AES_128_ENCRYPT = CRYPT_S390_KM | 0x12,
54 KM_AES_128_DECRYPT = CRYPT_S390_KM | 0x12 | 0x80,
55 KM_AES_192_ENCRYPT = CRYPT_S390_KM | 0x13,
56 KM_AES_192_DECRYPT = CRYPT_S390_KM | 0x13 | 0x80,
57 KM_AES_256_ENCRYPT = CRYPT_S390_KM | 0x14,
58 KM_AES_256_DECRYPT = CRYPT_S390_KM | 0x14 | 0x80,
59 KM_XTS_128_ENCRYPT = CRYPT_S390_KM | 0x32,
60 KM_XTS_128_DECRYPT = CRYPT_S390_KM | 0x32 | 0x80,
61 KM_XTS_256_ENCRYPT = CRYPT_S390_KM | 0x34,
62 KM_XTS_256_DECRYPT = CRYPT_S390_KM | 0x34 | 0x80,
63 };
64
65 /*
66 * function codes for KMC (CIPHER MESSAGE WITH CHAINING)
67 * instruction
68 */
69 enum crypt_s390_kmc_func {
70 KMC_QUERY = CRYPT_S390_KMC | 0x0,
71 KMC_DEA_ENCRYPT = CRYPT_S390_KMC | 0x1,
72 KMC_DEA_DECRYPT = CRYPT_S390_KMC | 0x1 | 0x80,
73 KMC_TDEA_128_ENCRYPT = CRYPT_S390_KMC | 0x2,
74 KMC_TDEA_128_DECRYPT = CRYPT_S390_KMC | 0x2 | 0x80,
75 KMC_TDEA_192_ENCRYPT = CRYPT_S390_KMC | 0x3,
76 KMC_TDEA_192_DECRYPT = CRYPT_S390_KMC | 0x3 | 0x80,
77 KMC_AES_128_ENCRYPT = CRYPT_S390_KMC | 0x12,
78 KMC_AES_128_DECRYPT = CRYPT_S390_KMC | 0x12 | 0x80,
79 KMC_AES_192_ENCRYPT = CRYPT_S390_KMC | 0x13,
80 KMC_AES_192_DECRYPT = CRYPT_S390_KMC | 0x13 | 0x80,
81 KMC_AES_256_ENCRYPT = CRYPT_S390_KMC | 0x14,
82 KMC_AES_256_DECRYPT = CRYPT_S390_KMC | 0x14 | 0x80,
83 KMC_PRNG = CRYPT_S390_KMC | 0x43,
84 };
85
86 /*
87 * function codes for KMCTR (CIPHER MESSAGE WITH COUNTER)
88 * instruction
89 */
90 enum crypt_s390_kmctr_func {
91 KMCTR_QUERY = CRYPT_S390_KMCTR | 0x0,
92 KMCTR_DEA_ENCRYPT = CRYPT_S390_KMCTR | 0x1,
93 KMCTR_DEA_DECRYPT = CRYPT_S390_KMCTR | 0x1 | 0x80,
94 KMCTR_TDEA_128_ENCRYPT = CRYPT_S390_KMCTR | 0x2,
95 KMCTR_TDEA_128_DECRYPT = CRYPT_S390_KMCTR | 0x2 | 0x80,
96 KMCTR_TDEA_192_ENCRYPT = CRYPT_S390_KMCTR | 0x3,
97 KMCTR_TDEA_192_DECRYPT = CRYPT_S390_KMCTR | 0x3 | 0x80,
98 KMCTR_AES_128_ENCRYPT = CRYPT_S390_KMCTR | 0x12,
99 KMCTR_AES_128_DECRYPT = CRYPT_S390_KMCTR | 0x12 | 0x80,
100 KMCTR_AES_192_ENCRYPT = CRYPT_S390_KMCTR | 0x13,
101 KMCTR_AES_192_DECRYPT = CRYPT_S390_KMCTR | 0x13 | 0x80,
102 KMCTR_AES_256_ENCRYPT = CRYPT_S390_KMCTR | 0x14,
103 KMCTR_AES_256_DECRYPT = CRYPT_S390_KMCTR | 0x14 | 0x80,
104 };
105
106 /*
107 * function codes for KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST)
108 * instruction
109 */
110 enum crypt_s390_kimd_func {
111 KIMD_QUERY = CRYPT_S390_KIMD | 0,
112 KIMD_SHA_1 = CRYPT_S390_KIMD | 1,
113 KIMD_SHA_256 = CRYPT_S390_KIMD | 2,
114 KIMD_SHA_512 = CRYPT_S390_KIMD | 3,
115 KIMD_GHASH = CRYPT_S390_KIMD | 65,
116 };
117
118 /*
119 * function codes for KLMD (COMPUTE LAST MESSAGE DIGEST)
120 * instruction
121 */
122 enum crypt_s390_klmd_func {
123 KLMD_QUERY = CRYPT_S390_KLMD | 0,
124 KLMD_SHA_1 = CRYPT_S390_KLMD | 1,
125 KLMD_SHA_256 = CRYPT_S390_KLMD | 2,
126 KLMD_SHA_512 = CRYPT_S390_KLMD | 3,
127 };
128
129 /*
130 * function codes for KMAC (COMPUTE MESSAGE AUTHENTICATION CODE)
131 * instruction
132 */
133 enum crypt_s390_kmac_func {
134 KMAC_QUERY = CRYPT_S390_KMAC | 0,
135 KMAC_DEA = CRYPT_S390_KMAC | 1,
136 KMAC_TDEA_128 = CRYPT_S390_KMAC | 2,
137 KMAC_TDEA_192 = CRYPT_S390_KMAC | 3
138 };
139
140 /**
141 * crypt_s390_km:
142 * @func: the function code passed to KM; see crypt_s390_km_func
143 * @param: address of parameter block; see POP for details on each func
144 * @dest: address of destination memory area
145 * @src: address of source memory area
146 * @src_len: length of src operand in bytes
147 *
148 * Executes the KM (CIPHER MESSAGE) operation of the CPU.
149 *
150 * Returns -1 for failure, 0 for the query func, number of processed
151 * bytes for encryption/decryption funcs
152 */
crypt_s390_km(long func,void * param,u8 * dest,const u8 * src,long src_len)153 static inline int crypt_s390_km(long func, void *param,
154 u8 *dest, const u8 *src, long src_len)
155 {
156 register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
157 register void *__param asm("1") = param;
158 register const u8 *__src asm("2") = src;
159 register long __src_len asm("3") = src_len;
160 register u8 *__dest asm("4") = dest;
161 int ret;
162
163 asm volatile(
164 "0: .insn rre,0xb92e0000,%3,%1 \n" /* KM opcode */
165 "1: brc 1,0b \n" /* handle partial completion */
166 " la %0,0\n"
167 "2:\n"
168 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
169 : "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
170 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
171 if (ret < 0)
172 return ret;
173 return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
174 }
175
176 /**
177 * crypt_s390_kmc:
178 * @func: the function code passed to KM; see crypt_s390_kmc_func
179 * @param: address of parameter block; see POP for details on each func
180 * @dest: address of destination memory area
181 * @src: address of source memory area
182 * @src_len: length of src operand in bytes
183 *
184 * Executes the KMC (CIPHER MESSAGE WITH CHAINING) operation of the CPU.
185 *
186 * Returns -1 for failure, 0 for the query func, number of processed
187 * bytes for encryption/decryption funcs
188 */
crypt_s390_kmc(long func,void * param,u8 * dest,const u8 * src,long src_len)189 static inline int crypt_s390_kmc(long func, void *param,
190 u8 *dest, const u8 *src, long src_len)
191 {
192 register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
193 register void *__param asm("1") = param;
194 register const u8 *__src asm("2") = src;
195 register long __src_len asm("3") = src_len;
196 register u8 *__dest asm("4") = dest;
197 int ret;
198
199 asm volatile(
200 "0: .insn rre,0xb92f0000,%3,%1 \n" /* KMC opcode */
201 "1: brc 1,0b \n" /* handle partial completion */
202 " la %0,0\n"
203 "2:\n"
204 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
205 : "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
206 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
207 if (ret < 0)
208 return ret;
209 return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
210 }
211
212 /**
213 * crypt_s390_kimd:
214 * @func: the function code passed to KM; see crypt_s390_kimd_func
215 * @param: address of parameter block; see POP for details on each func
216 * @src: address of source memory area
217 * @src_len: length of src operand in bytes
218 *
219 * Executes the KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST) operation
220 * of the CPU.
221 *
222 * Returns -1 for failure, 0 for the query func, number of processed
223 * bytes for digest funcs
224 */
crypt_s390_kimd(long func,void * param,const u8 * src,long src_len)225 static inline int crypt_s390_kimd(long func, void *param,
226 const u8 *src, long src_len)
227 {
228 register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
229 register void *__param asm("1") = param;
230 register const u8 *__src asm("2") = src;
231 register long __src_len asm("3") = src_len;
232 int ret;
233
234 asm volatile(
235 "0: .insn rre,0xb93e0000,%1,%1 \n" /* KIMD opcode */
236 "1: brc 1,0b \n" /* handle partial completion */
237 " la %0,0\n"
238 "2:\n"
239 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
240 : "=d" (ret), "+a" (__src), "+d" (__src_len)
241 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
242 if (ret < 0)
243 return ret;
244 return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
245 }
246
247 /**
248 * crypt_s390_klmd:
249 * @func: the function code passed to KM; see crypt_s390_klmd_func
250 * @param: address of parameter block; see POP for details on each func
251 * @src: address of source memory area
252 * @src_len: length of src operand in bytes
253 *
254 * Executes the KLMD (COMPUTE LAST MESSAGE DIGEST) operation of the CPU.
255 *
256 * Returns -1 for failure, 0 for the query func, number of processed
257 * bytes for digest funcs
258 */
crypt_s390_klmd(long func,void * param,const u8 * src,long src_len)259 static inline int crypt_s390_klmd(long func, void *param,
260 const u8 *src, long src_len)
261 {
262 register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
263 register void *__param asm("1") = param;
264 register const u8 *__src asm("2") = src;
265 register long __src_len asm("3") = src_len;
266 int ret;
267
268 asm volatile(
269 "0: .insn rre,0xb93f0000,%1,%1 \n" /* KLMD opcode */
270 "1: brc 1,0b \n" /* handle partial completion */
271 " la %0,0\n"
272 "2:\n"
273 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
274 : "=d" (ret), "+a" (__src), "+d" (__src_len)
275 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
276 if (ret < 0)
277 return ret;
278 return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
279 }
280
281 /**
282 * crypt_s390_kmac:
283 * @func: the function code passed to KM; see crypt_s390_klmd_func
284 * @param: address of parameter block; see POP for details on each func
285 * @src: address of source memory area
286 * @src_len: length of src operand in bytes
287 *
288 * Executes the KMAC (COMPUTE MESSAGE AUTHENTICATION CODE) operation
289 * of the CPU.
290 *
291 * Returns -1 for failure, 0 for the query func, number of processed
292 * bytes for digest funcs
293 */
crypt_s390_kmac(long func,void * param,const u8 * src,long src_len)294 static inline int crypt_s390_kmac(long func, void *param,
295 const u8 *src, long src_len)
296 {
297 register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
298 register void *__param asm("1") = param;
299 register const u8 *__src asm("2") = src;
300 register long __src_len asm("3") = src_len;
301 int ret;
302
303 asm volatile(
304 "0: .insn rre,0xb91e0000,%1,%1 \n" /* KLAC opcode */
305 "1: brc 1,0b \n" /* handle partial completion */
306 " la %0,0\n"
307 "2:\n"
308 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
309 : "=d" (ret), "+a" (__src), "+d" (__src_len)
310 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
311 if (ret < 0)
312 return ret;
313 return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
314 }
315
316 /**
317 * crypt_s390_kmctr:
318 * @func: the function code passed to KMCTR; see crypt_s390_kmctr_func
319 * @param: address of parameter block; see POP for details on each func
320 * @dest: address of destination memory area
321 * @src: address of source memory area
322 * @src_len: length of src operand in bytes
323 * @counter: address of counter value
324 *
325 * Executes the KMCTR (CIPHER MESSAGE WITH COUNTER) operation of the CPU.
326 *
327 * Returns -1 for failure, 0 for the query func, number of processed
328 * bytes for encryption/decryption funcs
329 */
crypt_s390_kmctr(long func,void * param,u8 * dest,const u8 * src,long src_len,u8 * counter)330 static inline int crypt_s390_kmctr(long func, void *param, u8 *dest,
331 const u8 *src, long src_len, u8 *counter)
332 {
333 register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
334 register void *__param asm("1") = param;
335 register const u8 *__src asm("2") = src;
336 register long __src_len asm("3") = src_len;
337 register u8 *__dest asm("4") = dest;
338 register u8 *__ctr asm("6") = counter;
339 int ret = -1;
340
341 asm volatile(
342 "0: .insn rrf,0xb92d0000,%3,%1,%4,0 \n" /* KMCTR opcode */
343 "1: brc 1,0b \n" /* handle partial completion */
344 " la %0,0\n"
345 "2:\n"
346 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
347 : "+d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest),
348 "+a" (__ctr)
349 : "d" (__func), "a" (__param) : "cc", "memory");
350 if (ret < 0)
351 return ret;
352 return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
353 }
354
355 /**
356 * crypt_s390_func_available:
357 * @func: the function code of the specific function; 0 if op in general
358 *
359 * Tests if a specific crypto function is implemented on the machine.
360 *
361 * Returns 1 if func available; 0 if func or op in general not available
362 */
crypt_s390_func_available(int func,unsigned int facility_mask)363 static inline int crypt_s390_func_available(int func,
364 unsigned int facility_mask)
365 {
366 unsigned char status[16];
367 int ret;
368
369 if (facility_mask & CRYPT_S390_MSA && !test_facility(17))
370 return 0;
371
372 if (facility_mask & CRYPT_S390_MSA3 &&
373 (!test_facility(2) || !test_facility(76)))
374 return 0;
375 if (facility_mask & CRYPT_S390_MSA4 &&
376 (!test_facility(2) || !test_facility(77)))
377 return 0;
378
379 switch (func & CRYPT_S390_OP_MASK) {
380 case CRYPT_S390_KM:
381 ret = crypt_s390_km(KM_QUERY, &status, NULL, NULL, 0);
382 break;
383 case CRYPT_S390_KMC:
384 ret = crypt_s390_kmc(KMC_QUERY, &status, NULL, NULL, 0);
385 break;
386 case CRYPT_S390_KIMD:
387 ret = crypt_s390_kimd(KIMD_QUERY, &status, NULL, 0);
388 break;
389 case CRYPT_S390_KLMD:
390 ret = crypt_s390_klmd(KLMD_QUERY, &status, NULL, 0);
391 break;
392 case CRYPT_S390_KMAC:
393 ret = crypt_s390_kmac(KMAC_QUERY, &status, NULL, 0);
394 break;
395 case CRYPT_S390_KMCTR:
396 ret = crypt_s390_kmctr(KMCTR_QUERY, &status, NULL, NULL, 0,
397 NULL);
398 break;
399 default:
400 return 0;
401 }
402 if (ret < 0)
403 return 0;
404 func &= CRYPT_S390_FUNC_MASK;
405 func &= 0x7f; /* mask modifier bit */
406 return (status[func >> 3] & (0x80 >> (func & 7))) != 0;
407 }
408
409 /**
410 * crypt_s390_pcc:
411 * @func: the function code passed to KM; see crypt_s390_km_func
412 * @param: address of parameter block; see POP for details on each func
413 *
414 * Executes the PCC (PERFORM CRYPTOGRAPHIC COMPUTATION) operation of the CPU.
415 *
416 * Returns -1 for failure, 0 for success.
417 */
crypt_s390_pcc(long func,void * param)418 static inline int crypt_s390_pcc(long func, void *param)
419 {
420 register long __func asm("0") = func & 0x7f; /* encrypt or decrypt */
421 register void *__param asm("1") = param;
422 int ret = -1;
423
424 asm volatile(
425 "0: .insn rre,0xb92c0000,0,0 \n" /* PCC opcode */
426 "1: brc 1,0b \n" /* handle partial completion */
427 " la %0,0\n"
428 "2:\n"
429 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
430 : "+d" (ret)
431 : "d" (__func), "a" (__param) : "cc", "memory");
432 return ret;
433 }
434
435
436 #endif /* _CRYPTO_ARCH_S390_CRYPT_S390_H */
437