2 * QEMU Crypto cipher built-in algorithms
4 * Copyright (c) 2015 Red Hat, Inc.
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 of the License, or (at your option) any later version.
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.
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/>.
21 #include "qemu/osdep.h"
22 #include "crypto/aes.h"
23 #include "crypto/desrfb.h"
24 #include "crypto/xts.h"
26 typedef struct QCryptoCipherBuiltinAESContext QCryptoCipherBuiltinAESContext
;
27 struct QCryptoCipherBuiltinAESContext
{
31 typedef struct QCryptoCipherBuiltinAES QCryptoCipherBuiltinAES
;
32 struct QCryptoCipherBuiltinAES
{
33 QCryptoCipherBuiltinAESContext key
;
34 QCryptoCipherBuiltinAESContext key_tweak
;
35 uint8_t iv
[AES_BLOCK_SIZE
];
37 typedef struct QCryptoCipherBuiltinDESRFB QCryptoCipherBuiltinDESRFB
;
38 struct QCryptoCipherBuiltinDESRFB
{
43 typedef struct QCryptoCipherBuiltin QCryptoCipherBuiltin
;
44 struct QCryptoCipherBuiltin
{
46 QCryptoCipherBuiltinAES aes
;
47 QCryptoCipherBuiltinDESRFB desrfb
;
50 void (*free
)(QCryptoCipher
*cipher
);
51 int (*setiv
)(QCryptoCipher
*cipher
,
52 const uint8_t *iv
, size_t niv
,
54 int (*encrypt
)(QCryptoCipher
*cipher
,
59 int (*decrypt
)(QCryptoCipher
*cipher
,
67 static void qcrypto_cipher_free_aes(QCryptoCipher
*cipher
)
69 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
72 cipher
->opaque
= NULL
;
76 static void qcrypto_cipher_aes_ecb_encrypt(AES_KEY
*key
,
81 const uint8_t *inptr
= in
;
82 uint8_t *outptr
= out
;
84 if (len
> AES_BLOCK_SIZE
) {
85 AES_encrypt(inptr
, outptr
, key
);
86 inptr
+= AES_BLOCK_SIZE
;
87 outptr
+= AES_BLOCK_SIZE
;
88 len
-= AES_BLOCK_SIZE
;
90 uint8_t tmp1
[AES_BLOCK_SIZE
], tmp2
[AES_BLOCK_SIZE
];
91 memcpy(tmp1
, inptr
, len
);
92 /* Fill with 0 to avoid valgrind uninitialized reads */
93 memset(tmp1
+ len
, 0, sizeof(tmp1
) - len
);
94 AES_encrypt(tmp1
, tmp2
, key
);
95 memcpy(outptr
, tmp2
, len
);
102 static void qcrypto_cipher_aes_ecb_decrypt(AES_KEY
*key
,
107 const uint8_t *inptr
= in
;
108 uint8_t *outptr
= out
;
110 if (len
> AES_BLOCK_SIZE
) {
111 AES_decrypt(inptr
, outptr
, key
);
112 inptr
+= AES_BLOCK_SIZE
;
113 outptr
+= AES_BLOCK_SIZE
;
114 len
-= AES_BLOCK_SIZE
;
116 uint8_t tmp1
[AES_BLOCK_SIZE
], tmp2
[AES_BLOCK_SIZE
];
117 memcpy(tmp1
, inptr
, len
);
118 /* Fill with 0 to avoid valgrind uninitialized reads */
119 memset(tmp1
+ len
, 0, sizeof(tmp1
) - len
);
120 AES_decrypt(tmp1
, tmp2
, key
);
121 memcpy(outptr
, tmp2
, len
);
128 static void qcrypto_cipher_aes_xts_encrypt(const void *ctx
,
133 const QCryptoCipherBuiltinAESContext
*aesctx
= ctx
;
135 qcrypto_cipher_aes_ecb_encrypt((AES_KEY
*)&aesctx
->enc
,
140 static void qcrypto_cipher_aes_xts_decrypt(const void *ctx
,
145 const QCryptoCipherBuiltinAESContext
*aesctx
= ctx
;
147 qcrypto_cipher_aes_ecb_decrypt((AES_KEY
*)&aesctx
->dec
,
152 static int qcrypto_cipher_encrypt_aes(QCryptoCipher
*cipher
,
158 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
160 switch (cipher
->mode
) {
161 case QCRYPTO_CIPHER_MODE_ECB
:
162 qcrypto_cipher_aes_ecb_encrypt(&ctxt
->state
.aes
.key
.enc
,
165 case QCRYPTO_CIPHER_MODE_CBC
:
166 AES_cbc_encrypt(in
, out
, len
,
167 &ctxt
->state
.aes
.key
.enc
,
168 ctxt
->state
.aes
.iv
, 1);
170 case QCRYPTO_CIPHER_MODE_XTS
:
171 xts_encrypt(&ctxt
->state
.aes
.key
,
172 &ctxt
->state
.aes
.key_tweak
,
173 qcrypto_cipher_aes_xts_encrypt
,
174 qcrypto_cipher_aes_xts_decrypt
,
179 g_assert_not_reached();
186 static int qcrypto_cipher_decrypt_aes(QCryptoCipher
*cipher
,
192 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
194 switch (cipher
->mode
) {
195 case QCRYPTO_CIPHER_MODE_ECB
:
196 qcrypto_cipher_aes_ecb_decrypt(&ctxt
->state
.aes
.key
.dec
,
199 case QCRYPTO_CIPHER_MODE_CBC
:
200 AES_cbc_encrypt(in
, out
, len
,
201 &ctxt
->state
.aes
.key
.dec
,
202 ctxt
->state
.aes
.iv
, 0);
204 case QCRYPTO_CIPHER_MODE_XTS
:
205 xts_decrypt(&ctxt
->state
.aes
.key
,
206 &ctxt
->state
.aes
.key_tweak
,
207 qcrypto_cipher_aes_xts_encrypt
,
208 qcrypto_cipher_aes_xts_decrypt
,
213 g_assert_not_reached();
219 static int qcrypto_cipher_setiv_aes(QCryptoCipher
*cipher
,
220 const uint8_t *iv
, size_t niv
,
223 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
224 if (niv
!= AES_BLOCK_SIZE
) {
225 error_setg(errp
, "IV must be %d bytes not %zu",
226 AES_BLOCK_SIZE
, niv
);
230 memcpy(ctxt
->state
.aes
.iv
, iv
, AES_BLOCK_SIZE
);
238 static QCryptoCipherBuiltin
*
239 qcrypto_cipher_init_aes(QCryptoCipherMode mode
,
240 const uint8_t *key
, size_t nkey
,
243 QCryptoCipherBuiltin
*ctxt
;
245 if (mode
!= QCRYPTO_CIPHER_MODE_CBC
&&
246 mode
!= QCRYPTO_CIPHER_MODE_ECB
&&
247 mode
!= QCRYPTO_CIPHER_MODE_XTS
) {
248 error_setg(errp
, "Unsupported cipher mode %s",
249 QCryptoCipherMode_lookup
[mode
]);
253 ctxt
= g_new0(QCryptoCipherBuiltin
, 1);
255 if (mode
== QCRYPTO_CIPHER_MODE_XTS
) {
256 if (AES_set_encrypt_key(key
, nkey
* 4, &ctxt
->state
.aes
.key
.enc
) != 0) {
257 error_setg(errp
, "Failed to set encryption key");
261 if (AES_set_decrypt_key(key
, nkey
* 4, &ctxt
->state
.aes
.key
.dec
) != 0) {
262 error_setg(errp
, "Failed to set decryption key");
266 if (AES_set_encrypt_key(key
+ (nkey
/ 2), nkey
* 4,
267 &ctxt
->state
.aes
.key_tweak
.enc
) != 0) {
268 error_setg(errp
, "Failed to set encryption key");
272 if (AES_set_decrypt_key(key
+ (nkey
/ 2), nkey
* 4,
273 &ctxt
->state
.aes
.key_tweak
.dec
) != 0) {
274 error_setg(errp
, "Failed to set decryption key");
278 if (AES_set_encrypt_key(key
, nkey
* 8, &ctxt
->state
.aes
.key
.enc
) != 0) {
279 error_setg(errp
, "Failed to set encryption key");
283 if (AES_set_decrypt_key(key
, nkey
* 8, &ctxt
->state
.aes
.key
.dec
) != 0) {
284 error_setg(errp
, "Failed to set decryption key");
289 ctxt
->blocksize
= AES_BLOCK_SIZE
;
290 ctxt
->free
= qcrypto_cipher_free_aes
;
291 ctxt
->setiv
= qcrypto_cipher_setiv_aes
;
292 ctxt
->encrypt
= qcrypto_cipher_encrypt_aes
;
293 ctxt
->decrypt
= qcrypto_cipher_decrypt_aes
;
303 static void qcrypto_cipher_free_des_rfb(QCryptoCipher
*cipher
)
305 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
307 g_free(ctxt
->state
.desrfb
.key
);
309 cipher
->opaque
= NULL
;
313 static int qcrypto_cipher_encrypt_des_rfb(QCryptoCipher
*cipher
,
319 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
323 error_setg(errp
, "Buffer size must be multiple of 8 not %zu",
328 deskey(ctxt
->state
.desrfb
.key
, EN0
);
330 for (i
= 0; i
< len
; i
+= 8) {
331 des((void *)in
+ i
, out
+ i
);
338 static int qcrypto_cipher_decrypt_des_rfb(QCryptoCipher
*cipher
,
344 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
348 error_setg(errp
, "Buffer size must be multiple of 8 not %zu",
353 deskey(ctxt
->state
.desrfb
.key
, DE1
);
355 for (i
= 0; i
< len
; i
+= 8) {
356 des((void *)in
+ i
, out
+ i
);
363 static int qcrypto_cipher_setiv_des_rfb(QCryptoCipher
*cipher
,
364 const uint8_t *iv
, size_t niv
,
367 error_setg(errp
, "Setting IV is not supported");
372 static QCryptoCipherBuiltin
*
373 qcrypto_cipher_init_des_rfb(QCryptoCipherMode mode
,
374 const uint8_t *key
, size_t nkey
,
377 QCryptoCipherBuiltin
*ctxt
;
379 if (mode
!= QCRYPTO_CIPHER_MODE_ECB
) {
380 error_setg(errp
, "Unsupported cipher mode %s",
381 QCryptoCipherMode_lookup
[mode
]);
385 ctxt
= g_new0(QCryptoCipherBuiltin
, 1);
387 ctxt
->state
.desrfb
.key
= g_new0(uint8_t, nkey
);
388 memcpy(ctxt
->state
.desrfb
.key
, key
, nkey
);
389 ctxt
->state
.desrfb
.nkey
= nkey
;
392 ctxt
->free
= qcrypto_cipher_free_des_rfb
;
393 ctxt
->setiv
= qcrypto_cipher_setiv_des_rfb
;
394 ctxt
->encrypt
= qcrypto_cipher_encrypt_des_rfb
;
395 ctxt
->decrypt
= qcrypto_cipher_decrypt_des_rfb
;
401 bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg
,
402 QCryptoCipherMode mode
)
405 case QCRYPTO_CIPHER_ALG_DES_RFB
:
406 case QCRYPTO_CIPHER_ALG_AES_128
:
407 case QCRYPTO_CIPHER_ALG_AES_192
:
408 case QCRYPTO_CIPHER_ALG_AES_256
:
415 case QCRYPTO_CIPHER_MODE_ECB
:
416 case QCRYPTO_CIPHER_MODE_CBC
:
417 case QCRYPTO_CIPHER_MODE_XTS
:
419 case QCRYPTO_CIPHER_MODE_CTR
:
427 static QCryptoCipherBuiltin
*qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg
,
428 QCryptoCipherMode mode
,
433 QCryptoCipherBuiltin
*ctxt
;
436 case QCRYPTO_CIPHER_MODE_ECB
:
437 case QCRYPTO_CIPHER_MODE_CBC
:
438 case QCRYPTO_CIPHER_MODE_XTS
:
441 error_setg(errp
, "Unsupported cipher mode %s",
442 QCryptoCipherMode_lookup
[mode
]);
446 if (!qcrypto_cipher_validate_key_length(alg
, mode
, nkey
, errp
)) {
451 case QCRYPTO_CIPHER_ALG_DES_RFB
:
452 ctxt
= qcrypto_cipher_init_des_rfb(mode
, key
, nkey
, errp
);
454 case QCRYPTO_CIPHER_ALG_AES_128
:
455 case QCRYPTO_CIPHER_ALG_AES_192
:
456 case QCRYPTO_CIPHER_ALG_AES_256
:
457 ctxt
= qcrypto_cipher_init_aes(mode
, key
, nkey
, errp
);
461 "Unsupported cipher algorithm %s",
462 QCryptoCipherAlgorithm_lookup
[alg
]);
469 void qcrypto_cipher_free(QCryptoCipher
*cipher
)
471 QCryptoCipherBuiltin
*ctxt
;
477 ctxt
= cipher
->opaque
;
483 int qcrypto_cipher_encrypt(QCryptoCipher
*cipher
,
489 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
491 if (len
% ctxt
->blocksize
) {
492 error_setg(errp
, "Length %zu must be a multiple of block size %zu",
493 len
, ctxt
->blocksize
);
497 return ctxt
->encrypt(cipher
, in
, out
, len
, errp
);
501 int qcrypto_cipher_decrypt(QCryptoCipher
*cipher
,
507 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
509 if (len
% ctxt
->blocksize
) {
510 error_setg(errp
, "Length %zu must be a multiple of block size %zu",
511 len
, ctxt
->blocksize
);
515 return ctxt
->decrypt(cipher
, in
, out
, len
, errp
);
519 int qcrypto_cipher_setiv(QCryptoCipher
*cipher
,
520 const uint8_t *iv
, size_t niv
,
523 QCryptoCipherBuiltin
*ctxt
= cipher
->opaque
;
525 return ctxt
->setiv(cipher
, iv
, niv
, errp
);
529 QCryptoCipher
*qcrypto_cipher_new(QCryptoCipherAlgorithm alg
,
530 QCryptoCipherMode mode
,
531 const uint8_t *key
, size_t nkey
,
534 QCryptoCipher
*cipher
;
535 QCryptoCipherBuiltin
*ctxt
;
537 ctxt
= qcrypto_cipher_ctx_new(alg
, mode
, key
, nkey
, errp
);
542 cipher
= g_new0(QCryptoCipher
, 1);
545 cipher
->opaque
= ctxt
;