qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

hmac-gcrypt.c (3883B)

      1 /*
      2  * QEMU Crypto hmac algorithms (based on libgcrypt)
      3  *
      4  * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
      5  *
      6  * Authors:
      7  *    Longpeng(Mike) <longpeng2@huawei.com>
      8  *
      9  * This work is licensed under the terms of the GNU GPL, version 2 or
     10  * (at your option) any later version.  See the COPYING file in the
     11  * top-level directory.
     12  *
     13  */
     14 
     15 #include "qemu/osdep.h"
     16 #include "qapi/error.h"
     17 #include "crypto/hmac.h"
     18 #include "hmacpriv.h"
     19 #include <gcrypt.h>
     20 
     21 static int qcrypto_hmac_alg_map[QCRYPTO_HASH_ALG__MAX] = {
     22     [QCRYPTO_HASH_ALG_MD5] = GCRY_MAC_HMAC_MD5,
     23     [QCRYPTO_HASH_ALG_SHA1] = GCRY_MAC_HMAC_SHA1,
     24     [QCRYPTO_HASH_ALG_SHA224] = GCRY_MAC_HMAC_SHA224,
     25     [QCRYPTO_HASH_ALG_SHA256] = GCRY_MAC_HMAC_SHA256,
     26     [QCRYPTO_HASH_ALG_SHA384] = GCRY_MAC_HMAC_SHA384,
     27     [QCRYPTO_HASH_ALG_SHA512] = GCRY_MAC_HMAC_SHA512,
     28     [QCRYPTO_HASH_ALG_RIPEMD160] = GCRY_MAC_HMAC_RMD160,
     29 };
     30 
     31 typedef struct QCryptoHmacGcrypt QCryptoHmacGcrypt;
     32 struct QCryptoHmacGcrypt {
     33     gcry_mac_hd_t handle;
     34 };
     35 
     36 bool qcrypto_hmac_supports(QCryptoHashAlgorithm alg)
     37 {
     38     if (alg < G_N_ELEMENTS(qcrypto_hmac_alg_map) &&
     39         qcrypto_hmac_alg_map[alg] != GCRY_MAC_NONE) {
     40         return true;
     41     }
     42 
     43     return false;
     44 }
     45 
     46 void *qcrypto_hmac_ctx_new(QCryptoHashAlgorithm alg,
     47                            const uint8_t *key, size_t nkey,
     48                            Error **errp)
     49 {
     50     QCryptoHmacGcrypt *ctx;
     51     gcry_error_t err;
     52 
     53     if (!qcrypto_hmac_supports(alg)) {
     54         error_setg(errp, "Unsupported hmac algorithm %s",
     55                    QCryptoHashAlgorithm_str(alg));
     56         return NULL;
     57     }
     58 
     59     ctx = g_new0(QCryptoHmacGcrypt, 1);
     60 
     61     err = gcry_mac_open(&ctx->handle, qcrypto_hmac_alg_map[alg],
     62                         GCRY_MAC_FLAG_SECURE, NULL);
     63     if (err != 0) {
     64         error_setg(errp, "Cannot initialize hmac: %s",
     65                    gcry_strerror(err));
     66         goto error;
     67     }
     68 
     69     err = gcry_mac_setkey(ctx->handle, (const void *)key, nkey);
     70     if (err != 0) {
     71         error_setg(errp, "Cannot set key: %s",
     72                    gcry_strerror(err));
     73         gcry_mac_close(ctx->handle);
     74         goto error;
     75     }
     76 
     77     return ctx;
     78 
     79 error:
     80     g_free(ctx);
     81     return NULL;
     82 }
     83 
     84 static void
     85 qcrypto_gcrypt_hmac_ctx_free(QCryptoHmac *hmac)
     86 {
     87     QCryptoHmacGcrypt *ctx;
     88 
     89     ctx = hmac->opaque;
     90     gcry_mac_close(ctx->handle);
     91 
     92     g_free(ctx);
     93 }
     94 
     95 static int
     96 qcrypto_gcrypt_hmac_bytesv(QCryptoHmac *hmac,
     97                            const struct iovec *iov,
     98                            size_t niov,
     99                            uint8_t **result,
    100                            size_t *resultlen,
    101                            Error **errp)
    102 {
    103     QCryptoHmacGcrypt *ctx;
    104     gcry_error_t err;
    105     uint32_t ret;
    106     int i;
    107 
    108     ctx = hmac->opaque;
    109 
    110     for (i = 0; i < niov; i++) {
    111         gcry_mac_write(ctx->handle, iov[i].iov_base, iov[i].iov_len);
    112     }
    113 
    114     ret = gcry_mac_get_algo_maclen(qcrypto_hmac_alg_map[hmac->alg]);
    115     if (ret <= 0) {
    116         error_setg(errp, "Unable to get hmac length: %s",
    117                    gcry_strerror(ret));
    118         return -1;
    119     }
    120 
    121     if (*resultlen == 0) {
    122         *resultlen = ret;
    123         *result = g_new0(uint8_t, *resultlen);
    124     } else if (*resultlen != ret) {
    125         error_setg(errp, "Result buffer size %zu is smaller than hmac %d",
    126                    *resultlen, ret);
    127         return -1;
    128     }
    129 
    130     err = gcry_mac_read(ctx->handle, *result, resultlen);
    131     if (err != 0) {
    132         error_setg(errp, "Cannot get result: %s",
    133                    gcry_strerror(err));
    134         return -1;
    135     }
    136 
    137     err = gcry_mac_reset(ctx->handle);
    138     if (err != 0) {
    139         error_setg(errp, "Cannot reset hmac context: %s",
    140                    gcry_strerror(err));
    141         return -1;
    142     }
    143 
    144     return 0;
    145 }
    146 
    147 QCryptoHmacDriver qcrypto_hmac_lib_driver = {
    148     .hmac_bytesv = qcrypto_gcrypt_hmac_bytesv,
    149     .hmac_free = qcrypto_gcrypt_hmac_ctx_free,
    150 };