crypto/cipher-builtin.c.inc

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