crypto/hmac.c

   1 /*
   2  * QEMU Crypto hmac algorithms
   3  *
   4  * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or
   7  * (at your option) any later version.  See the COPYING file in the
   8  * top-level directory.
   9  *
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "crypto/hmac.h"
  14 #include "hmacpriv.h"
  15
  16 static const char hex[] = "0123456789abcdef";
  17
  18 int qcrypto_hmac_bytesv(QCryptoHmac *hmac,
  19                         const struct iovec *iov,
  20                         size_t niov,
  21                         uint8_t **result,
  22                         size_t *resultlen,
  23                         Error **errp)
  24 {
  25     QCryptoHmacDriver *drv = hmac->driver;
  26
  27     return drv->hmac_bytesv(hmac, iov, niov, result, resultlen, errp);
  28 }
  29
  30 int qcrypto_hmac_bytes(QCryptoHmac *hmac,
  31                        const char *buf,
  32                        size_t len,
  33                        uint8_t **result,
  34                        size_t *resultlen,
  35                        Error **errp)
  36 {
  37     struct iovec iov = {
  38             .iov_base = (char *)buf,
  39             .iov_len = len
  40     };
  41
  42     return qcrypto_hmac_bytesv(hmac, &iov, 1, result, resultlen, errp);
  43 }
  44
  45 int qcrypto_hmac_digestv(QCryptoHmac *hmac,
  46                          const struct iovec *iov,
  47                          size_t niov,
  48                          char **digest,
  49                          Error **errp)
  50 {
  51     uint8_t *result = NULL;
  52     size_t resultlen = 0;
  53     size_t i;
  54
  55     if (qcrypto_hmac_bytesv(hmac, iov, niov, &result, &resultlen, errp) < 0) {
  56         return -1;
  57     }
  58
  59     *digest = g_new0(char, (resultlen * 2) + 1);
  60
  61     for (i = 0 ; i < resultlen ; i++) {
  62         (*digest)[(i * 2)] = hex[(result[i] >> 4) & 0xf];
  63         (*digest)[(i * 2) + 1] = hex[result[i] & 0xf];
  64     }
  65
  66     (*digest)[resultlen * 2] = '\0';
  67
  68     g_free(result);
  69     return 0;
  70 }
  71
  72 int qcrypto_hmac_digest(QCryptoHmac *hmac,
  73                         const char *buf,
  74                         size_t len,
  75                         char **digest,
  76                         Error **errp)
  77 {
  78     struct iovec iov = {
  79             .iov_base = (char *)buf,
  80             .iov_len = len
  81     };
  82
  83     return qcrypto_hmac_digestv(hmac, &iov, 1, digest, errp);
  84 }
  85
  86 QCryptoHmac *qcrypto_hmac_new(QCryptoHashAlgorithm alg,
  87                               const uint8_t *key, size_t nkey,
  88                               Error **errp)
  89 {
  90     QCryptoHmac *hmac;
  91     void *ctx = NULL;
  92     QCryptoHmacDriver *drv = NULL;
  93
  94 #ifdef CONFIG_AF_ALG
  95     ctx = qcrypto_afalg_hmac_ctx_new(alg, key, nkey, NULL);
  96     if (ctx) {
  97         drv = &qcrypto_hmac_afalg_driver;
  98     }
  99 #endif
 100
 101     if (!ctx) {
 102         ctx = qcrypto_hmac_ctx_new(alg, key, nkey, errp);
 103         if (!ctx) {
 104             return NULL;
 105         }
 106
 107         drv = &qcrypto_hmac_lib_driver;
 108     }
 109
 110     hmac = g_new0(QCryptoHmac, 1);
 111     hmac->alg = alg;
 112     hmac->opaque = ctx;
 113     hmac->driver = (void *)drv;
 114
 115     return hmac;
 116 }
 117
 118 void qcrypto_hmac_free(QCryptoHmac *hmac)
 119 {
 120     QCryptoHmacDriver *drv;
 121
 122     if (hmac) {
 123         drv = hmac->driver;
 124         drv->hmac_free(hmac);
 125         g_free(hmac);
 126     }
 127 }