tests/acceptance: skip s390x_ccw_vrtio_tcg on GitLab
[qemu.git] / crypto / cipher-builtin.c
1 /*
2 * QEMU Crypto cipher built-in algorithms
3 *
4 * Copyright (c) 2015 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "qemu/osdep.h"
22 #include "crypto/aes.h"
23 #include "crypto/desrfb.h"
24 #include "crypto/xts.h"
25 #include "cipherpriv.h"
26
27 typedef struct QCryptoCipherBuiltinAESContext QCryptoCipherBuiltinAESContext;
28 struct QCryptoCipherBuiltinAESContext {
29 AES_KEY enc;
30 AES_KEY dec;
31 };
32 typedef struct QCryptoCipherBuiltinAES QCryptoCipherBuiltinAES;
33 struct QCryptoCipherBuiltinAES {
34 QCryptoCipherBuiltinAESContext key;
35 QCryptoCipherBuiltinAESContext key_tweak;
36 uint8_t iv[AES_BLOCK_SIZE];
37 };
38 typedef struct QCryptoCipherBuiltinDESRFB QCryptoCipherBuiltinDESRFB;
39 struct QCryptoCipherBuiltinDESRFB {
40 uint8_t *key;
41 size_t nkey;
42 };
43
44 typedef struct QCryptoCipherBuiltin QCryptoCipherBuiltin;
45 struct QCryptoCipherBuiltin {
46 union {
47 QCryptoCipherBuiltinAES aes;
48 QCryptoCipherBuiltinDESRFB desrfb;
49 } state;
50 size_t blocksize;
51 void (*free)(QCryptoCipher *cipher);
52 int (*setiv)(QCryptoCipher *cipher,
53 const uint8_t *iv, size_t niv,
54 Error **errp);
55 int (*encrypt)(QCryptoCipher *cipher,
56 const void *in,
57 void *out,
58 size_t len,
59 Error **errp);
60 int (*decrypt)(QCryptoCipher *cipher,
61 const void *in,
62 void *out,
63 size_t len,
64 Error **errp);
65 };
66
67
68 static void qcrypto_cipher_free_aes(QCryptoCipher *cipher)
69 {
70 QCryptoCipherBuiltin *ctxt = cipher->opaque;
71
72 g_free(ctxt);
73 cipher->opaque = NULL;
74 }
75
76
77 static void qcrypto_cipher_aes_ecb_encrypt(const AES_KEY *key,
78 const void *in,
79 void *out,
80 size_t len)
81 {
82 const uint8_t *inptr = in;
83 uint8_t *outptr = out;
84 while (len) {
85 if (len > AES_BLOCK_SIZE) {
86 AES_encrypt(inptr, outptr, key);
87 inptr += AES_BLOCK_SIZE;
88 outptr += AES_BLOCK_SIZE;
89 len -= AES_BLOCK_SIZE;
90 } else {
91 uint8_t tmp1[AES_BLOCK_SIZE], tmp2[AES_BLOCK_SIZE];
92 memcpy(tmp1, inptr, len);
93 /* Fill with 0 to avoid valgrind uninitialized reads */
94 memset(tmp1 + len, 0, sizeof(tmp1) - len);
95 AES_encrypt(tmp1, tmp2, key);
96 memcpy(outptr, tmp2, len);
97 len = 0;
98 }
99 }
100 }
101
102
103 static void qcrypto_cipher_aes_ecb_decrypt(const AES_KEY *key,
104 const void *in,
105 void *out,
106 size_t len)
107 {
108 const uint8_t *inptr = in;
109 uint8_t *outptr = out;
110 while (len) {
111 if (len > AES_BLOCK_SIZE) {
112 AES_decrypt(inptr, outptr, key);
113 inptr += AES_BLOCK_SIZE;
114 outptr += AES_BLOCK_SIZE;
115 len -= AES_BLOCK_SIZE;
116 } else {
117 uint8_t tmp1[AES_BLOCK_SIZE], tmp2[AES_BLOCK_SIZE];
118 memcpy(tmp1, inptr, len);
119 /* Fill with 0 to avoid valgrind uninitialized reads */
120 memset(tmp1 + len, 0, sizeof(tmp1) - len);
121 AES_decrypt(tmp1, tmp2, key);
122 memcpy(outptr, tmp2, len);
123 len = 0;
124 }
125 }
126 }
127
128
129 static void qcrypto_cipher_aes_xts_encrypt(const void *ctx,
130 size_t length,
131 uint8_t *dst,
132 const uint8_t *src)
133 {
134 const QCryptoCipherBuiltinAESContext *aesctx = ctx;
135
136 qcrypto_cipher_aes_ecb_encrypt(&aesctx->enc, src, dst, length);
137 }
138
139
140 static void qcrypto_cipher_aes_xts_decrypt(const void *ctx,
141 size_t length,
142 uint8_t *dst,
143 const uint8_t *src)
144 {
145 const QCryptoCipherBuiltinAESContext *aesctx = ctx;
146
147 qcrypto_cipher_aes_ecb_decrypt(&aesctx->dec, src, dst, length);
148 }
149
150
151 static int qcrypto_cipher_encrypt_aes(QCryptoCipher *cipher,
152 const void *in,
153 void *out,
154 size_t len,
155 Error **errp)
156 {
157 QCryptoCipherBuiltin *ctxt = cipher->opaque;
158
159 switch (cipher->mode) {
160 case QCRYPTO_CIPHER_MODE_ECB:
161 qcrypto_cipher_aes_ecb_encrypt(&ctxt->state.aes.key.enc,
162 in, out, len);
163 break;
164 case QCRYPTO_CIPHER_MODE_CBC:
165 AES_cbc_encrypt(in, out, len,
166 &ctxt->state.aes.key.enc,
167 ctxt->state.aes.iv, 1);
168 break;
169 case QCRYPTO_CIPHER_MODE_XTS:
170 xts_encrypt(&ctxt->state.aes.key,
171 &ctxt->state.aes.key_tweak,
172 qcrypto_cipher_aes_xts_encrypt,
173 qcrypto_cipher_aes_xts_decrypt,
174 ctxt->state.aes.iv,
175 len, out, in);
176 break;
177 default:
178 g_assert_not_reached();
179 }
180
181 return 0;
182 }
183
184
185 static int qcrypto_cipher_decrypt_aes(QCryptoCipher *cipher,
186 const void *in,
187 void *out,
188 size_t len,
189 Error **errp)
190 {
191 QCryptoCipherBuiltin *ctxt = cipher->opaque;
192
193 switch (cipher->mode) {
194 case QCRYPTO_CIPHER_MODE_ECB:
195 qcrypto_cipher_aes_ecb_decrypt(&ctxt->state.aes.key.dec,
196 in, out, len);
197 break;
198 case QCRYPTO_CIPHER_MODE_CBC:
199 AES_cbc_encrypt(in, out, len,
200 &ctxt->state.aes.key.dec,
201 ctxt->state.aes.iv, 0);
202 break;
203 case QCRYPTO_CIPHER_MODE_XTS:
204 xts_decrypt(&ctxt->state.aes.key,
205 &ctxt->state.aes.key_tweak,
206 qcrypto_cipher_aes_xts_encrypt,
207 qcrypto_cipher_aes_xts_decrypt,
208 ctxt->state.aes.iv,
209 len, out, in);
210 break;
211 default:
212 g_assert_not_reached();
213 }
214
215 return 0;
216 }
217
218 static int qcrypto_cipher_setiv_aes(QCryptoCipher *cipher,
219 const uint8_t *iv, size_t niv,
220 Error **errp)
221 {
222 QCryptoCipherBuiltin *ctxt = cipher->opaque;
223 if (niv != AES_BLOCK_SIZE) {
224 error_setg(errp, "IV must be %d bytes not %zu",
225 AES_BLOCK_SIZE, niv);
226 return -1;
227 }
228
229 memcpy(ctxt->state.aes.iv, iv, AES_BLOCK_SIZE);
230
231 return 0;
232 }
233
234
235
236
237 static QCryptoCipherBuiltin *
238 qcrypto_cipher_init_aes(QCryptoCipherMode mode,
239 const uint8_t *key, size_t nkey,
240 Error **errp)
241 {
242 QCryptoCipherBuiltin *ctxt;
243
244 if (mode != QCRYPTO_CIPHER_MODE_CBC &&
245 mode != QCRYPTO_CIPHER_MODE_ECB &&
246 mode != QCRYPTO_CIPHER_MODE_XTS) {
247 error_setg(errp, "Unsupported cipher mode %s",
248 QCryptoCipherMode_str(mode));
249 return NULL;
250 }
251
252 ctxt = g_new0(QCryptoCipherBuiltin, 1);
253
254 if (mode == QCRYPTO_CIPHER_MODE_XTS) {
255 if (AES_set_encrypt_key(key, nkey * 4, &ctxt->state.aes.key.enc) != 0) {
256 error_setg(errp, "Failed to set encryption key");
257 goto error;
258 }
259
260 if (AES_set_decrypt_key(key, nkey * 4, &ctxt->state.aes.key.dec) != 0) {
261 error_setg(errp, "Failed to set decryption key");
262 goto error;
263 }
264
265 if (AES_set_encrypt_key(key + (nkey / 2), nkey * 4,
266 &ctxt->state.aes.key_tweak.enc) != 0) {
267 error_setg(errp, "Failed to set encryption key");
268 goto error;
269 }
270
271 if (AES_set_decrypt_key(key + (nkey / 2), nkey * 4,
272 &ctxt->state.aes.key_tweak.dec) != 0) {
273 error_setg(errp, "Failed to set decryption key");
274 goto error;
275 }
276 } else {
277 if (AES_set_encrypt_key(key, nkey * 8, &ctxt->state.aes.key.enc) != 0) {
278 error_setg(errp, "Failed to set encryption key");
279 goto error;
280 }
281
282 if (AES_set_decrypt_key(key, nkey * 8, &ctxt->state.aes.key.dec) != 0) {
283 error_setg(errp, "Failed to set decryption key");
284 goto error;
285 }
286 }
287
288 ctxt->blocksize = AES_BLOCK_SIZE;
289 ctxt->free = qcrypto_cipher_free_aes;
290 ctxt->setiv = qcrypto_cipher_setiv_aes;
291 ctxt->encrypt = qcrypto_cipher_encrypt_aes;
292 ctxt->decrypt = qcrypto_cipher_decrypt_aes;
293
294 return ctxt;
295
296 error:
297 g_free(ctxt);
298 return NULL;
299 }
300
301
302 static void qcrypto_cipher_free_des_rfb(QCryptoCipher *cipher)
303 {
304 QCryptoCipherBuiltin *ctxt = cipher->opaque;
305
306 g_free(ctxt->state.desrfb.key);
307 g_free(ctxt);
308 cipher->opaque = NULL;
309 }
310
311
312 static int qcrypto_cipher_encrypt_des_rfb(QCryptoCipher *cipher,
313 const void *in,
314 void *out,
315 size_t len,
316 Error **errp)
317 {
318 QCryptoCipherBuiltin *ctxt = cipher->opaque;
319 size_t i;
320
321 if (len % 8) {
322 error_setg(errp, "Buffer size must be multiple of 8 not %zu",
323 len);
324 return -1;
325 }
326
327 deskey(ctxt->state.desrfb.key, EN0);
328
329 for (i = 0; i < len; i += 8) {
330 des((void *)in + i, out + i);
331 }
332
333 return 0;
334 }
335
336
337 static int qcrypto_cipher_decrypt_des_rfb(QCryptoCipher *cipher,
338 const void *in,
339 void *out,
340 size_t len,
341 Error **errp)
342 {
343 QCryptoCipherBuiltin *ctxt = cipher->opaque;
344 size_t i;
345
346 if (len % 8) {
347 error_setg(errp, "Buffer size must be multiple of 8 not %zu",
348 len);
349 return -1;
350 }
351
352 deskey(ctxt->state.desrfb.key, DE1);
353
354 for (i = 0; i < len; i += 8) {
355 des((void *)in + i, out + i);
356 }
357
358 return 0;
359 }
360
361
362 static int qcrypto_cipher_setiv_des_rfb(QCryptoCipher *cipher,
363 const uint8_t *iv, size_t niv,
364 Error **errp)
365 {
366 error_setg(errp, "Setting IV is not supported");
367 return -1;
368 }
369
370
371 static QCryptoCipherBuiltin *
372 qcrypto_cipher_init_des_rfb(QCryptoCipherMode mode,
373 const uint8_t *key, size_t nkey,
374 Error **errp)
375 {
376 QCryptoCipherBuiltin *ctxt;
377
378 if (mode != QCRYPTO_CIPHER_MODE_ECB) {
379 error_setg(errp, "Unsupported cipher mode %s",
380 QCryptoCipherMode_str(mode));
381 return NULL;
382 }
383
384 ctxt = g_new0(QCryptoCipherBuiltin, 1);
385
386 ctxt->state.desrfb.key = g_new0(uint8_t, nkey);
387 memcpy(ctxt->state.desrfb.key, key, nkey);
388 ctxt->state.desrfb.nkey = nkey;
389
390 ctxt->blocksize = 8;
391 ctxt->free = qcrypto_cipher_free_des_rfb;
392 ctxt->setiv = qcrypto_cipher_setiv_des_rfb;
393 ctxt->encrypt = qcrypto_cipher_encrypt_des_rfb;
394 ctxt->decrypt = qcrypto_cipher_decrypt_des_rfb;
395
396 return ctxt;
397 }
398
399
400 bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
401 QCryptoCipherMode mode)
402 {
403 switch (alg) {
404 case QCRYPTO_CIPHER_ALG_DES_RFB:
405 case QCRYPTO_CIPHER_ALG_AES_128:
406 case QCRYPTO_CIPHER_ALG_AES_192:
407 case QCRYPTO_CIPHER_ALG_AES_256:
408 break;
409 default:
410 return false;
411 }
412
413 switch (mode) {
414 case QCRYPTO_CIPHER_MODE_ECB:
415 case QCRYPTO_CIPHER_MODE_CBC:
416 case QCRYPTO_CIPHER_MODE_XTS:
417 return true;
418 case QCRYPTO_CIPHER_MODE_CTR:
419 return false;
420 default:
421 return false;
422 }
423 }
424
425
426 static QCryptoCipherBuiltin *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
427 QCryptoCipherMode mode,
428 const uint8_t *key,
429 size_t nkey,
430 Error **errp)
431 {
432 QCryptoCipherBuiltin *ctxt;
433
434 switch (mode) {
435 case QCRYPTO_CIPHER_MODE_ECB:
436 case QCRYPTO_CIPHER_MODE_CBC:
437 case QCRYPTO_CIPHER_MODE_XTS:
438 break;
439 default:
440 error_setg(errp, "Unsupported cipher mode %s",
441 QCryptoCipherMode_str(mode));
442 return NULL;
443 }
444
445 if (!qcrypto_cipher_validate_key_length(alg, mode, nkey, errp)) {
446 return NULL;
447 }
448
449 switch (alg) {
450 case QCRYPTO_CIPHER_ALG_DES_RFB:
451 ctxt = qcrypto_cipher_init_des_rfb(mode, key, nkey, errp);
452 break;
453 case QCRYPTO_CIPHER_ALG_AES_128:
454 case QCRYPTO_CIPHER_ALG_AES_192:
455 case QCRYPTO_CIPHER_ALG_AES_256:
456 ctxt = qcrypto_cipher_init_aes(mode, key, nkey, errp);
457 break;
458 default:
459 error_setg(errp,
460 "Unsupported cipher algorithm %s",
461 QCryptoCipherAlgorithm_str(alg));
462 return NULL;
463 }
464
465 return ctxt;
466 }
467
468 static void
469 qcrypto_builtin_cipher_ctx_free(QCryptoCipher *cipher)
470 {
471 QCryptoCipherBuiltin *ctxt;
472
473 ctxt = cipher->opaque;
474 ctxt->free(cipher);
475 }
476
477
478 static int
479 qcrypto_builtin_cipher_encrypt(QCryptoCipher *cipher,
480 const void *in,
481 void *out,
482 size_t len,
483 Error **errp)
484 {
485 QCryptoCipherBuiltin *ctxt = cipher->opaque;
486
487 if (len % ctxt->blocksize) {
488 error_setg(errp, "Length %zu must be a multiple of block size %zu",
489 len, ctxt->blocksize);
490 return -1;
491 }
492
493 return ctxt->encrypt(cipher, in, out, len, errp);
494 }
495
496
497 static int
498 qcrypto_builtin_cipher_decrypt(QCryptoCipher *cipher,
499 const void *in,
500 void *out,
501 size_t len,
502 Error **errp)
503 {
504 QCryptoCipherBuiltin *ctxt = cipher->opaque;
505
506 if (len % ctxt->blocksize) {
507 error_setg(errp, "Length %zu must be a multiple of block size %zu",
508 len, ctxt->blocksize);
509 return -1;
510 }
511
512 return ctxt->decrypt(cipher, in, out, len, errp);
513 }
514
515
516 static int
517 qcrypto_builtin_cipher_setiv(QCryptoCipher *cipher,
518 const uint8_t *iv, size_t niv,
519 Error **errp)
520 {
521 QCryptoCipherBuiltin *ctxt = cipher->opaque;
522
523 return ctxt->setiv(cipher, iv, niv, errp);
524 }
525
526
527 static struct QCryptoCipherDriver qcrypto_cipher_lib_driver = {
528 .cipher_encrypt = qcrypto_builtin_cipher_encrypt,
529 .cipher_decrypt = qcrypto_builtin_cipher_decrypt,
530 .cipher_setiv = qcrypto_builtin_cipher_setiv,
531 .cipher_free = qcrypto_builtin_cipher_ctx_free,
532 };