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