@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
inc 861 lines 31.2 KB
Raw
1 /*
2 * QEMU Crypto cipher nettle 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 <nettle/nettle-types.h>
22 #include <nettle/aes.h>
23 #include <nettle/des.h>
24 #include <nettle/cbc.h>
25 #include <nettle/cast128.h>
26 #include <nettle/serpent.h>
27 #include <nettle/twofish.h>
28 #include <nettle/ctr.h>
29 #include <nettle/xts.h>
30 #include <nettle/gcm.h>
31 #ifdef CONFIG_CRYPTO_SM4
32 #include <nettle/sm4.h>
33 #endif
34
35 static inline bool qcrypto_length_check(size_t len, size_t blocksize,
36 Error **errp)
37 {
38 if (unlikely(len & (blocksize - 1))) {
39 error_setg(errp, "Length %zu must be a multiple of block size %zu",
40 len, blocksize);
41 return false;
42 }
43 return true;
44 }
45
46
47 static void qcrypto_cipher_ctx_free(QCryptoCipher *ctx)
48 {
49 g_free(ctx);
50 }
51
52 static int qcrypto_cipher_no_setiv(QCryptoCipher *cipher,
53 const uint8_t *iv, size_t niv,
54 Error **errp)
55 {
56 error_setg(errp, "Setting IV is not supported");
57 return -1;
58 }
59
60
61 #define DEFINE_SETIV(NAME, TYPE, BLEN) \
62 static int NAME##_setiv(QCryptoCipher *cipher, const uint8_t *iv, \
63 size_t niv, Error **errp) \
64 { \
65 TYPE *ctx = container_of(cipher, TYPE, base); \
66 if (niv != BLEN) { \
67 error_setg(errp, "Expected IV size %d not %zu", BLEN, niv); \
68 return -1; \
69 } \
70 memcpy(ctx->iv, iv, niv); \
71 return 0; \
72 }
73
74
75 #define DEFINE_ECB(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
76 static int NAME##_encrypt_ecb(QCryptoCipher *cipher, const void *in, \
77 void *out, size_t len, Error **errp) \
78 { \
79 TYPE *ctx = container_of(cipher, TYPE, base); \
80 if (!qcrypto_length_check(len, BLEN, errp)) { \
81 return -1; \
82 } \
83 ENCRYPT(&ctx->key, len, out, in); \
84 return 0; \
85 } \
86 static int NAME##_decrypt_ecb(QCryptoCipher *cipher, const void *in, \
87 void *out, size_t len, Error **errp) \
88 { \
89 TYPE *ctx = container_of(cipher, TYPE, base); \
90 if (!qcrypto_length_check(len, BLEN, errp)) { \
91 return -1; \
92 } \
93 DECRYPT(&ctx->key, len, out, in); \
94 return 0; \
95 } \
96 static const struct QCryptoCipherDriver NAME##_driver_ecb = { \
97 .cipher_encrypt = NAME##_encrypt_ecb, \
98 .cipher_decrypt = NAME##_decrypt_ecb, \
99 .cipher_setiv = qcrypto_cipher_no_setiv, \
100 .cipher_free = qcrypto_cipher_ctx_free, \
101 };
102
103
104 #define DEFINE_CBC(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
105 static int NAME##_encrypt_cbc(QCryptoCipher *cipher, const void *in, \
106 void *out, size_t len, Error **errp) \
107 { \
108 TYPE *ctx = container_of(cipher, TYPE, base); \
109 if (!qcrypto_length_check(len, BLEN, errp)) { \
110 return -1; \
111 } \
112 cbc_encrypt(&ctx->key, ENCRYPT, BLEN, ctx->iv, len, out, in); \
113 return 0; \
114 } \
115 static int NAME##_decrypt_cbc(QCryptoCipher *cipher, const void *in, \
116 void *out, size_t len, Error **errp) \
117 { \
118 TYPE *ctx = container_of(cipher, TYPE, base); \
119 if (!qcrypto_length_check(len, BLEN, errp)) { \
120 return -1; \
121 } \
122 cbc_decrypt(&ctx->key, DECRYPT, BLEN, ctx->iv, len, out, in); \
123 return 0; \
124 } \
125 static const struct QCryptoCipherDriver NAME##_driver_cbc = { \
126 .cipher_encrypt = NAME##_encrypt_cbc, \
127 .cipher_decrypt = NAME##_decrypt_cbc, \
128 .cipher_setiv = NAME##_setiv, \
129 .cipher_free = qcrypto_cipher_ctx_free, \
130 };
131
132
133 #define DEFINE_CTR(NAME, TYPE, BLEN, ENCRYPT) \
134 static int NAME##_encrypt_ctr(QCryptoCipher *cipher, const void *in, \
135 void *out, size_t len, Error **errp) \
136 { \
137 TYPE *ctx = container_of(cipher, TYPE, base); \
138 if (!qcrypto_length_check(len, BLEN, errp)) { \
139 return -1; \
140 } \
141 ctr_crypt(&ctx->key, ENCRYPT, BLEN, ctx->iv, len, out, in); \
142 return 0; \
143 } \
144 static const struct QCryptoCipherDriver NAME##_driver_ctr = { \
145 .cipher_encrypt = NAME##_encrypt_ctr, \
146 .cipher_decrypt = NAME##_encrypt_ctr, \
147 .cipher_setiv = NAME##_setiv, \
148 .cipher_free = qcrypto_cipher_ctx_free, \
149 };
150
151
152 #define DEFINE__XTS(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
153 static int NAME##_encrypt_xts(QCryptoCipher *cipher, const void *in, \
154 void *out, size_t len, Error **errp) \
155 { \
156 TYPE *ctx = container_of(cipher, TYPE, base); \
157 if (!qcrypto_length_check(len, BLEN, errp)) { \
158 return -1; \
159 } \
160 xts_encrypt_message(&ctx->key, &ctx->key_xts, ENCRYPT, \
161 ctx->iv, len, out, in); \
162 return 0; \
163 } \
164 static int NAME##_decrypt_xts(QCryptoCipher *cipher, const void *in, \
165 void *out, size_t len, Error **errp) \
166 { \
167 TYPE *ctx = container_of(cipher, TYPE, base); \
168 if (!qcrypto_length_check(len, BLEN, errp)) { \
169 return -1; \
170 } \
171 xts_decrypt_message(&ctx->key, &ctx->key_xts, DECRYPT, ENCRYPT, \
172 ctx->iv, len, out, in); \
173 return 0; \
174 }
175
176 #define DEFINE_XTS(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
177 QEMU_BUILD_BUG_ON(BLEN != XTS_BLOCK_SIZE); \
178 DEFINE__XTS(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
179 static const struct QCryptoCipherDriver NAME##_driver_xts = { \
180 .cipher_encrypt = NAME##_encrypt_xts, \
181 .cipher_decrypt = NAME##_decrypt_xts, \
182 .cipher_setiv = NAME##_setiv, \
183 .cipher_free = qcrypto_cipher_ctx_free, \
184 };
185
186
187 #define DEFINE_ECB_CBC_CTR(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
188 DEFINE_SETIV(NAME, TYPE, BLEN) \
189 DEFINE_ECB(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
190 DEFINE_CBC(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
191 DEFINE_CTR(NAME, TYPE, BLEN, ENCRYPT)
192
193 #define DEFINE_ECB_CBC_CTR_XTS(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
194 DEFINE_ECB_CBC_CTR(NAME, TYPE, BLEN, ENCRYPT, DECRYPT) \
195 DEFINE_XTS(NAME, TYPE, BLEN, ENCRYPT, DECRYPT)
196
197
198 typedef struct QCryptoNettleDES {
199 QCryptoCipher base;
200 struct des_ctx key;
201 uint8_t iv[DES_BLOCK_SIZE];
202 } QCryptoNettleDES;
203
204 static void des_encrypt_native(const void *ctx, size_t length,
205 uint8_t *dst, const uint8_t *src)
206 {
207 des_encrypt(ctx, length, dst, src);
208 }
209
210 static void des_decrypt_native(const void *ctx, size_t length,
211 uint8_t *dst, const uint8_t *src)
212 {
213 des_decrypt(ctx, length, dst, src);
214 }
215
216 DEFINE_ECB_CBC_CTR(qcrypto_nettle_des, QCryptoNettleDES,
217 DES_BLOCK_SIZE, des_encrypt_native, des_decrypt_native)
218
219
220 typedef struct QCryptoNettleDES3 {
221 QCryptoCipher base;
222 struct des3_ctx key;
223 uint8_t iv[DES3_BLOCK_SIZE];
224 } QCryptoNettleDES3;
225
226 static void des3_encrypt_native(const void *ctx, size_t length,
227 uint8_t *dst, const uint8_t *src)
228 {
229 des3_encrypt(ctx, length, dst, src);
230 }
231
232 static void des3_decrypt_native(const void *ctx, size_t length,
233 uint8_t *dst, const uint8_t *src)
234 {
235 des3_decrypt(ctx, length, dst, src);
236 }
237
238 DEFINE_ECB_CBC_CTR(qcrypto_nettle_des3, QCryptoNettleDES3, DES3_BLOCK_SIZE,
239 des3_encrypt_native, des3_decrypt_native)
240
241
242 typedef struct QCryptoNettleAES128 {
243 QCryptoCipher base;
244 uint8_t iv[AES_BLOCK_SIZE];
245 /* First key from pair is encode, second key is decode. */
246 struct aes128_ctx key[2], key_xts[2];
247 } QCryptoNettleAES128;
248
249 static void aes128_encrypt_native(const void *ctx, size_t length,
250 uint8_t *dst, const uint8_t *src)
251 {
252 const struct aes128_ctx *keys = ctx;
253 aes128_encrypt(&keys[0], length, dst, src);
254 }
255
256 static void aes128_decrypt_native(const void *ctx, size_t length,
257 uint8_t *dst, const uint8_t *src)
258 {
259 const struct aes128_ctx *keys = ctx;
260 aes128_decrypt(&keys[1], length, dst, src);
261 }
262
263 DEFINE_ECB_CBC_CTR_XTS(qcrypto_nettle_aes128,
264 QCryptoNettleAES128, AES_BLOCK_SIZE,
265 aes128_encrypt_native, aes128_decrypt_native)
266
267
268 typedef struct QCryptoNettleAES192 {
269 QCryptoCipher base;
270 uint8_t iv[AES_BLOCK_SIZE];
271 /* First key from pair is encode, second key is decode. */
272 struct aes192_ctx key[2], key_xts[2];
273 } QCryptoNettleAES192;
274
275 static void aes192_encrypt_native(const void *ctx, size_t length,
276 uint8_t *dst, const uint8_t *src)
277 {
278 const struct aes192_ctx *keys = ctx;
279 aes192_encrypt(&keys[0], length, dst, src);
280 }
281
282 static void aes192_decrypt_native(const void *ctx, size_t length,
283 uint8_t *dst, const uint8_t *src)
284 {
285 const struct aes192_ctx *keys = ctx;
286 aes192_decrypt(&keys[1], length, dst, src);
287 }
288
289 DEFINE_ECB_CBC_CTR_XTS(qcrypto_nettle_aes192,
290 QCryptoNettleAES192, AES_BLOCK_SIZE,
291 aes192_encrypt_native, aes192_decrypt_native)
292
293
294 typedef struct QCryptoNettleAES256 {
295 QCryptoCipher base;
296 uint8_t iv[AES_BLOCK_SIZE];
297 /* First key from pair is encode, second key is decode. */
298 struct aes256_ctx key[2], key_xts[2];
299 } QCryptoNettleAES256;
300
301 static void aes256_encrypt_native(const void *ctx, size_t length,
302 uint8_t *dst, const uint8_t *src)
303 {
304 const struct aes256_ctx *keys = ctx;
305 aes256_encrypt(&keys[0], length, dst, src);
306 }
307
308 static void aes256_decrypt_native(const void *ctx, size_t length,
309 uint8_t *dst, const uint8_t *src)
310 {
311 const struct aes256_ctx *keys = ctx;
312 aes256_decrypt(&keys[1], length, dst, src);
313 }
314
315 DEFINE_ECB_CBC_CTR_XTS(qcrypto_nettle_aes256,
316 QCryptoNettleAES256, AES_BLOCK_SIZE,
317 aes256_encrypt_native, aes256_decrypt_native)
318
319
320 typedef struct QCryptoNettleCAST128 {
321 QCryptoCipher base;
322 uint8_t iv[CAST128_BLOCK_SIZE];
323 struct cast128_ctx key, key_xts;
324 } QCryptoNettleCAST128;
325
326 static void cast128_encrypt_native(const void *ctx, size_t length,
327 uint8_t *dst, const uint8_t *src)
328 {
329 cast128_encrypt(ctx, length, dst, src);
330 }
331
332 static void cast128_decrypt_native(const void *ctx, size_t length,
333 uint8_t *dst, const uint8_t *src)
334 {
335 cast128_decrypt(ctx, length, dst, src);
336 }
337
338 DEFINE_ECB_CBC_CTR(qcrypto_nettle_cast128,
339 QCryptoNettleCAST128, CAST128_BLOCK_SIZE,
340 cast128_encrypt_native, cast128_decrypt_native)
341
342
343 typedef struct QCryptoNettleSerpent {
344 QCryptoCipher base;
345 uint8_t iv[SERPENT_BLOCK_SIZE];
346 struct serpent_ctx key, key_xts;
347 } QCryptoNettleSerpent;
348
349
350 static void serpent_encrypt_native(const void *ctx, size_t length,
351 uint8_t *dst, const uint8_t *src)
352 {
353 serpent_encrypt(ctx, length, dst, src);
354 }
355
356 static void serpent_decrypt_native(const void *ctx, size_t length,
357 uint8_t *dst, const uint8_t *src)
358 {
359 serpent_decrypt(ctx, length, dst, src);
360 }
361
362 DEFINE_ECB_CBC_CTR_XTS(qcrypto_nettle_serpent,
363 QCryptoNettleSerpent, SERPENT_BLOCK_SIZE,
364 serpent_encrypt_native, serpent_decrypt_native)
365
366
367 typedef struct QCryptoNettleTwofish {
368 QCryptoCipher base;
369 uint8_t iv[TWOFISH_BLOCK_SIZE];
370 struct twofish_ctx key, key_xts;
371 } QCryptoNettleTwofish;
372
373 static void twofish_encrypt_native(const void *ctx, size_t length,
374 uint8_t *dst, const uint8_t *src)
375 {
376 twofish_encrypt(ctx, length, dst, src);
377 }
378
379 static void twofish_decrypt_native(const void *ctx, size_t length,
380 uint8_t *dst, const uint8_t *src)
381 {
382 twofish_decrypt(ctx, length, dst, src);
383 }
384
385 DEFINE_ECB_CBC_CTR_XTS(qcrypto_nettle_twofish,
386 QCryptoNettleTwofish, TWOFISH_BLOCK_SIZE,
387 twofish_encrypt_native, twofish_decrypt_native)
388
389 #ifdef CONFIG_CRYPTO_SM4
390 typedef struct QCryptoNettleSm4 {
391 QCryptoCipher base;
392 struct sm4_ctx key[2];
393 } QCryptoNettleSm4;
394
395 static void sm4_encrypt_native(void *ctx, size_t length,
396 uint8_t *dst, const uint8_t *src)
397 {
398 struct sm4_ctx *keys = ctx;
399 sm4_crypt(&keys[0], length, dst, src);
400 }
401
402 static void sm4_decrypt_native(void *ctx, size_t length,
403 uint8_t *dst, const uint8_t *src)
404 {
405 struct sm4_ctx *keys = ctx;
406 sm4_crypt(&keys[1], length, dst, src);
407 }
408
409 DEFINE_ECB(qcrypto_nettle_sm4,
410 QCryptoNettleSm4, SM4_BLOCK_SIZE,
411 sm4_encrypt_native, sm4_decrypt_native)
412 #endif
413
414 /*
415 * GCM is an AEAD mode built on AES (128-bit block only). Drive it through the
416 * generic gcm_* interface, using the block cipher's encrypt function for both
417 * directions; associated data is fed with gcm_update() and the authentication
418 * tag is produced by gcm_digest().
419 */
420 typedef struct QCryptoNettleAESGCM {
421 QCryptoCipher base;
422 struct gcm_key gcm_key;
423 struct gcm_ctx gcm_ctx;
424 union {
425 struct aes128_ctx aes128;
426 struct aes192_ctx aes192;
427 struct aes256_ctx aes256;
428 } cipher;
429 nettle_cipher_func *encrypt;
430 } QCryptoNettleAESGCM;
431
432 static int qcrypto_nettle_aes_gcm_setiv(QCryptoCipher *cipher,
433 const uint8_t *iv, size_t niv,
434 Error **errp)
435 {
436 QCryptoNettleAESGCM *ctx = container_of(cipher, QCryptoNettleAESGCM, base);
437
438 gcm_set_iv(&ctx->gcm_ctx, &ctx->gcm_key, niv, iv);
439 return 0;
440 }
441
442 static int qcrypto_nettle_aes_gcm_setaad(QCryptoCipher *cipher,
443 const uint8_t *aad, size_t len,
444 Error **errp)
445 {
446 QCryptoNettleAESGCM *ctx = container_of(cipher, QCryptoNettleAESGCM, base);
447
448 gcm_update(&ctx->gcm_ctx, &ctx->gcm_key, len, aad);
449 return 0;
450 }
451
452 static int qcrypto_nettle_aes_gcm_encrypt(QCryptoCipher *cipher,
453 const void *in, void *out,
454 size_t len, Error **errp)
455 {
456 QCryptoNettleAESGCM *ctx = container_of(cipher, QCryptoNettleAESGCM, base);
457
458 gcm_encrypt(&ctx->gcm_ctx, &ctx->gcm_key, &ctx->cipher, ctx->encrypt,
459 len, out, in);
460 return 0;
461 }
462
463 static int qcrypto_nettle_aes_gcm_decrypt(QCryptoCipher *cipher,
464 const void *in, void *out,
465 size_t len, Error **errp)
466 {
467 QCryptoNettleAESGCM *ctx = container_of(cipher, QCryptoNettleAESGCM, base);
468
469 gcm_decrypt(&ctx->gcm_ctx, &ctx->gcm_key, &ctx->cipher, ctx->encrypt,
470 len, out, in);
471 return 0;
472 }
473
474 static int qcrypto_nettle_aes_gcm_gettag(QCryptoCipher *cipher,
475 uint8_t *tag, size_t len,
476 Error **errp)
477 {
478 QCryptoNettleAESGCM *ctx = container_of(cipher, QCryptoNettleAESGCM, base);
479
480 gcm_digest(&ctx->gcm_ctx, &ctx->gcm_key, &ctx->cipher, ctx->encrypt,
481 len, tag);
482 return 0;
483 }
484
485 static const struct QCryptoCipherDriver qcrypto_nettle_aes_gcm_driver = {
486 .cipher_encrypt = qcrypto_nettle_aes_gcm_encrypt,
487 .cipher_decrypt = qcrypto_nettle_aes_gcm_decrypt,
488 .cipher_setiv = qcrypto_nettle_aes_gcm_setiv,
489 .cipher_setaad = qcrypto_nettle_aes_gcm_setaad,
490 .cipher_gettag = qcrypto_nettle_aes_gcm_gettag,
491 .cipher_free = qcrypto_cipher_ctx_free,
492 };
493
494 static QCryptoCipher *qcrypto_nettle_aes_gcm_ctx_new(QCryptoCipherAlgo alg,
495 const uint8_t *key,
496 size_t nkey,
497 Error **errp)
498 {
499 QCryptoNettleAESGCM *ctx;
500
501 if (!qcrypto_cipher_validate_key_length(alg, QCRYPTO_CIPHER_MODE_GCM,
502 nkey, errp)) {
503 return NULL;
504 }
505
506 ctx = g_new0(QCryptoNettleAESGCM, 1);
507 ctx->base.driver = &qcrypto_nettle_aes_gcm_driver;
508
509 switch (alg) {
510 case QCRYPTO_CIPHER_ALGO_AES_128:
511 aes128_set_encrypt_key(&ctx->cipher.aes128, key);
512 ctx->encrypt = aes128_encrypt_native;
513 break;
514 case QCRYPTO_CIPHER_ALGO_AES_192:
515 aes192_set_encrypt_key(&ctx->cipher.aes192, key);
516 ctx->encrypt = aes192_encrypt_native;
517 break;
518 case QCRYPTO_CIPHER_ALGO_AES_256:
519 aes256_set_encrypt_key(&ctx->cipher.aes256, key);
520 ctx->encrypt = aes256_encrypt_native;
521 break;
522 default:
523 error_setg(errp, "Unsupported cipher algorithm %s with GCM mode",
524 QCryptoCipherAlgo_str(alg));
525 g_free(ctx);
526 return NULL;
527 }
528
529 gcm_set_key(&ctx->gcm_key, &ctx->cipher, ctx->encrypt);
530 return &ctx->base;
531 }
532
533 bool qcrypto_cipher_supports(QCryptoCipherAlgo alg,
534 QCryptoCipherMode mode)
535 {
536 switch (alg) {
537 case QCRYPTO_CIPHER_ALGO_DES:
538 case QCRYPTO_CIPHER_ALGO_3DES:
539 case QCRYPTO_CIPHER_ALGO_AES_128:
540 case QCRYPTO_CIPHER_ALGO_AES_192:
541 case QCRYPTO_CIPHER_ALGO_AES_256:
542 case QCRYPTO_CIPHER_ALGO_CAST5_128:
543 case QCRYPTO_CIPHER_ALGO_SERPENT_128:
544 case QCRYPTO_CIPHER_ALGO_SERPENT_192:
545 case QCRYPTO_CIPHER_ALGO_SERPENT_256:
546 case QCRYPTO_CIPHER_ALGO_TWOFISH_128:
547 case QCRYPTO_CIPHER_ALGO_TWOFISH_192:
548 case QCRYPTO_CIPHER_ALGO_TWOFISH_256:
549 #ifdef CONFIG_CRYPTO_SM4
550 case QCRYPTO_CIPHER_ALGO_SM4:
551 #endif
552 break;
553 default:
554 return false;
555 }
556
557 switch (mode) {
558 case QCRYPTO_CIPHER_MODE_ECB:
559 case QCRYPTO_CIPHER_MODE_CBC:
560 case QCRYPTO_CIPHER_MODE_XTS:
561 case QCRYPTO_CIPHER_MODE_CTR:
562 return true;
563 case QCRYPTO_CIPHER_MODE_GCM:
564 return alg == QCRYPTO_CIPHER_ALGO_AES_128 ||
565 alg == QCRYPTO_CIPHER_ALGO_AES_192 ||
566 alg == QCRYPTO_CIPHER_ALGO_AES_256;
567 default:
568 return false;
569 }
570 }
571
572 static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgo alg,
573 QCryptoCipherMode mode,
574 const uint8_t *key,
575 size_t nkey,
576 Error **errp)
577 {
578 if (mode == QCRYPTO_CIPHER_MODE_GCM) {
579 return qcrypto_nettle_aes_gcm_ctx_new(alg, key, nkey, errp);
580 }
581
582 switch (mode) {
583 case QCRYPTO_CIPHER_MODE_ECB:
584 case QCRYPTO_CIPHER_MODE_CBC:
585 case QCRYPTO_CIPHER_MODE_XTS:
586 case QCRYPTO_CIPHER_MODE_CTR:
587 break;
588 default:
589 goto bad_cipher_mode;
590 }
591
592 if (!qcrypto_cipher_validate_key_length(alg, mode, nkey, errp)) {
593 return NULL;
594 }
595
596 switch (alg) {
597 case QCRYPTO_CIPHER_ALGO_DES:
598 {
599 QCryptoNettleDES *ctx;
600 const QCryptoCipherDriver *drv;
601
602 switch (mode) {
603 case QCRYPTO_CIPHER_MODE_ECB:
604 drv = &qcrypto_nettle_des_driver_ecb;
605 break;
606 case QCRYPTO_CIPHER_MODE_CBC:
607 drv = &qcrypto_nettle_des_driver_cbc;
608 break;
609 case QCRYPTO_CIPHER_MODE_CTR:
610 drv = &qcrypto_nettle_des_driver_ctr;
611 break;
612 case QCRYPTO_CIPHER_MODE_XTS:
613 goto bad_cipher_mode;
614 default:
615 g_assert_not_reached();
616 }
617
618 ctx = g_new0(QCryptoNettleDES, 1);
619 ctx->base.driver = drv;
620 des_set_key(&ctx->key, key);
621
622 return &ctx->base;
623 }
624
625 case QCRYPTO_CIPHER_ALGO_3DES:
626 {
627 QCryptoNettleDES3 *ctx;
628 const QCryptoCipherDriver *drv;
629
630 switch (mode) {
631 case QCRYPTO_CIPHER_MODE_ECB:
632 drv = &qcrypto_nettle_des3_driver_ecb;
633 break;
634 case QCRYPTO_CIPHER_MODE_CBC:
635 drv = &qcrypto_nettle_des3_driver_cbc;
636 break;
637 case QCRYPTO_CIPHER_MODE_CTR:
638 drv = &qcrypto_nettle_des3_driver_ctr;
639 break;
640 case QCRYPTO_CIPHER_MODE_XTS:
641 goto bad_cipher_mode;
642 default:
643 g_assert_not_reached();
644 }
645
646 ctx = g_new0(QCryptoNettleDES3, 1);
647 ctx->base.driver = drv;
648 des3_set_key(&ctx->key, key);
649 return &ctx->base;
650 }
651
652 case QCRYPTO_CIPHER_ALGO_AES_128:
653 {
654 QCryptoNettleAES128 *ctx = g_new0(QCryptoNettleAES128, 1);
655
656 switch (mode) {
657 case QCRYPTO_CIPHER_MODE_ECB:
658 ctx->base.driver = &qcrypto_nettle_aes128_driver_ecb;
659 break;
660 case QCRYPTO_CIPHER_MODE_CBC:
661 ctx->base.driver = &qcrypto_nettle_aes128_driver_cbc;
662 break;
663 case QCRYPTO_CIPHER_MODE_CTR:
664 ctx->base.driver = &qcrypto_nettle_aes128_driver_ctr;
665 break;
666 case QCRYPTO_CIPHER_MODE_XTS:
667 ctx->base.driver = &qcrypto_nettle_aes128_driver_xts;
668 nkey /= 2;
669 aes128_set_encrypt_key(&ctx->key_xts[0], key + nkey);
670 aes128_set_decrypt_key(&ctx->key_xts[1], key + nkey);
671 break;
672 default:
673 g_assert_not_reached();
674 }
675 aes128_set_encrypt_key(&ctx->key[0], key);
676 aes128_set_decrypt_key(&ctx->key[1], key);
677
678 return &ctx->base;
679 }
680
681 case QCRYPTO_CIPHER_ALGO_AES_192:
682 {
683 QCryptoNettleAES192 *ctx = g_new0(QCryptoNettleAES192, 1);
684
685 switch (mode) {
686 case QCRYPTO_CIPHER_MODE_ECB:
687 ctx->base.driver = &qcrypto_nettle_aes192_driver_ecb;
688 break;
689 case QCRYPTO_CIPHER_MODE_CBC:
690 ctx->base.driver = &qcrypto_nettle_aes192_driver_cbc;
691 break;
692 case QCRYPTO_CIPHER_MODE_CTR:
693 ctx->base.driver = &qcrypto_nettle_aes192_driver_ctr;
694 break;
695 case QCRYPTO_CIPHER_MODE_XTS:
696 ctx->base.driver = &qcrypto_nettle_aes192_driver_xts;
697 nkey /= 2;
698 aes192_set_encrypt_key(&ctx->key_xts[0], key + nkey);
699 aes192_set_decrypt_key(&ctx->key_xts[1], key + nkey);
700 break;
701 default:
702 g_assert_not_reached();
703 }
704 aes192_set_encrypt_key(&ctx->key[0], key);
705 aes192_set_decrypt_key(&ctx->key[1], key);
706
707 return &ctx->base;
708 }
709
710 case QCRYPTO_CIPHER_ALGO_AES_256:
711 {
712 QCryptoNettleAES256 *ctx = g_new0(QCryptoNettleAES256, 1);
713
714 switch (mode) {
715 case QCRYPTO_CIPHER_MODE_ECB:
716 ctx->base.driver = &qcrypto_nettle_aes256_driver_ecb;
717 break;
718 case QCRYPTO_CIPHER_MODE_CBC:
719 ctx->base.driver = &qcrypto_nettle_aes256_driver_cbc;
720 break;
721 case QCRYPTO_CIPHER_MODE_CTR:
722 ctx->base.driver = &qcrypto_nettle_aes256_driver_ctr;
723 break;
724 case QCRYPTO_CIPHER_MODE_XTS:
725 ctx->base.driver = &qcrypto_nettle_aes256_driver_xts;
726 nkey /= 2;
727 aes256_set_encrypt_key(&ctx->key_xts[0], key + nkey);
728 aes256_set_decrypt_key(&ctx->key_xts[1], key + nkey);
729 break;
730 default:
731 g_assert_not_reached();
732 }
733 aes256_set_encrypt_key(&ctx->key[0], key);
734 aes256_set_decrypt_key(&ctx->key[1], key);
735
736 return &ctx->base;
737 }
738
739 case QCRYPTO_CIPHER_ALGO_CAST5_128:
740 {
741 QCryptoNettleCAST128 *ctx;
742 const QCryptoCipherDriver *drv;
743
744 switch (mode) {
745 case QCRYPTO_CIPHER_MODE_ECB:
746 drv = &qcrypto_nettle_cast128_driver_ecb;
747 break;
748 case QCRYPTO_CIPHER_MODE_CBC:
749 drv = &qcrypto_nettle_cast128_driver_cbc;
750 break;
751 case QCRYPTO_CIPHER_MODE_CTR:
752 drv = &qcrypto_nettle_cast128_driver_ctr;
753 break;
754 case QCRYPTO_CIPHER_MODE_XTS:
755 goto bad_cipher_mode;
756 default:
757 g_assert_not_reached();
758 }
759
760 ctx = g_new0(QCryptoNettleCAST128, 1);
761 ctx->base.driver = drv;
762 cast5_set_key(&ctx->key, nkey, key);
763
764 return &ctx->base;
765 }
766
767 case QCRYPTO_CIPHER_ALGO_SERPENT_128:
768 case QCRYPTO_CIPHER_ALGO_SERPENT_192:
769 case QCRYPTO_CIPHER_ALGO_SERPENT_256:
770 {
771 QCryptoNettleSerpent *ctx = g_new0(QCryptoNettleSerpent, 1);
772
773 switch (mode) {
774 case QCRYPTO_CIPHER_MODE_ECB:
775 ctx->base.driver = &qcrypto_nettle_serpent_driver_ecb;
776 break;
777 case QCRYPTO_CIPHER_MODE_CBC:
778 ctx->base.driver = &qcrypto_nettle_serpent_driver_cbc;
779 break;
780 case QCRYPTO_CIPHER_MODE_CTR:
781 ctx->base.driver = &qcrypto_nettle_serpent_driver_ctr;
782 break;
783 case QCRYPTO_CIPHER_MODE_XTS:
784 ctx->base.driver = &qcrypto_nettle_serpent_driver_xts;
785 nkey /= 2;
786 serpent_set_key(&ctx->key_xts, nkey, key + nkey);
787 break;
788 default:
789 g_assert_not_reached();
790 }
791 serpent_set_key(&ctx->key, nkey, key);
792
793 return &ctx->base;
794 }
795
796 case QCRYPTO_CIPHER_ALGO_TWOFISH_128:
797 case QCRYPTO_CIPHER_ALGO_TWOFISH_192:
798 case QCRYPTO_CIPHER_ALGO_TWOFISH_256:
799 {
800 QCryptoNettleTwofish *ctx = g_new0(QCryptoNettleTwofish, 1);
801
802 switch (mode) {
803 case QCRYPTO_CIPHER_MODE_ECB:
804 ctx->base.driver = &qcrypto_nettle_twofish_driver_ecb;
805 break;
806 case QCRYPTO_CIPHER_MODE_CBC:
807 ctx->base.driver = &qcrypto_nettle_twofish_driver_cbc;
808 break;
809 case QCRYPTO_CIPHER_MODE_CTR:
810 ctx->base.driver = &qcrypto_nettle_twofish_driver_ctr;
811 break;
812 case QCRYPTO_CIPHER_MODE_XTS:
813 ctx->base.driver = &qcrypto_nettle_twofish_driver_xts;
814 nkey /= 2;
815 twofish_set_key(&ctx->key_xts, nkey, key + nkey);
816 break;
817 default:
818 g_assert_not_reached();
819 }
820 twofish_set_key(&ctx->key, nkey, key);
821
822 return &ctx->base;
823 }
824 #ifdef CONFIG_CRYPTO_SM4
825 case QCRYPTO_CIPHER_ALGO_SM4:
826 {
827 QCryptoNettleSm4 *ctx;
828 const QCryptoCipherDriver *drv;
829
830 switch (mode) {
831 case QCRYPTO_CIPHER_MODE_ECB:
832 drv = &qcrypto_nettle_sm4_driver_ecb;
833 break;
834 case QCRYPTO_CIPHER_MODE_CBC:
835 case QCRYPTO_CIPHER_MODE_CTR:
836 case QCRYPTO_CIPHER_MODE_XTS:
837 goto bad_cipher_mode;
838 default:
839 g_assert_not_reached();
840 }
841
842 ctx = g_new0(QCryptoNettleSm4, 1);
843 ctx->base.driver = drv;
844 sm4_set_encrypt_key(&ctx->key[0], key);
845 sm4_set_decrypt_key(&ctx->key[1], key);
846
847 return &ctx->base;
848 }
849 #endif
850
851 default:
852 error_setg(errp, "Unsupported cipher algorithm %s",
853 QCryptoCipherAlgo_str(alg));
854 return NULL;
855 }
856
857 bad_cipher_mode:
858 error_setg(errp, "Unsupported cipher mode %s",
859 QCryptoCipherMode_str(mode));
860 return NULL;
861 }