crypto/hash-nettle.c

   1 /*
   2  * QEMU Crypto hash algorithms
   3  *
   4  * Copyright (c) 2016 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 "qapi/error.h"
  23 #include "crypto/hash.h"
  24 #include "hashpriv.h"
  25 #include <nettle/md5.h>
  26 #include <nettle/sha.h>
  27 #include <nettle/ripemd160.h>
  28
  29 typedef void (*qcrypto_nettle_init)(void *ctx);
  30 typedef void (*qcrypto_nettle_write)(void *ctx,
  31                                      size_t len,
  32                                      const uint8_t *buf);
  33 typedef void (*qcrypto_nettle_result)(void *ctx,
  34                                       size_t len,
  35                                       uint8_t *buf);
  36
  37 union qcrypto_hash_ctx {
  38     struct md5_ctx md5;
  39     struct sha1_ctx sha1;
  40     struct sha224_ctx sha224;
  41     struct sha256_ctx sha256;
  42     struct sha384_ctx sha384;
  43     struct sha512_ctx sha512;
  44     struct ripemd160_ctx ripemd160;
  45 };
  46
  47 struct qcrypto_hash_alg {
  48     qcrypto_nettle_init init;
  49     qcrypto_nettle_write write;
  50     qcrypto_nettle_result result;
  51     size_t len;
  52 } qcrypto_hash_alg_map[] = {
  53     [QCRYPTO_HASH_ALG_MD5] = {
  54         .init = (qcrypto_nettle_init)md5_init,
  55         .write = (qcrypto_nettle_write)md5_update,
  56         .result = (qcrypto_nettle_result)md5_digest,
  57         .len = MD5_DIGEST_SIZE,
  58     },
  59     [QCRYPTO_HASH_ALG_SHA1] = {
  60         .init = (qcrypto_nettle_init)sha1_init,
  61         .write = (qcrypto_nettle_write)sha1_update,
  62         .result = (qcrypto_nettle_result)sha1_digest,
  63         .len = SHA1_DIGEST_SIZE,
  64     },
  65     [QCRYPTO_HASH_ALG_SHA224] = {
  66         .init = (qcrypto_nettle_init)sha224_init,
  67         .write = (qcrypto_nettle_write)sha224_update,
  68         .result = (qcrypto_nettle_result)sha224_digest,
  69         .len = SHA224_DIGEST_SIZE,
  70     },
  71     [QCRYPTO_HASH_ALG_SHA256] = {
  72         .init = (qcrypto_nettle_init)sha256_init,
  73         .write = (qcrypto_nettle_write)sha256_update,
  74         .result = (qcrypto_nettle_result)sha256_digest,
  75         .len = SHA256_DIGEST_SIZE,
  76     },
  77     [QCRYPTO_HASH_ALG_SHA384] = {
  78         .init = (qcrypto_nettle_init)sha384_init,
  79         .write = (qcrypto_nettle_write)sha384_update,
  80         .result = (qcrypto_nettle_result)sha384_digest,
  81         .len = SHA384_DIGEST_SIZE,
  82     },
  83     [QCRYPTO_HASH_ALG_SHA512] = {
  84         .init = (qcrypto_nettle_init)sha512_init,
  85         .write = (qcrypto_nettle_write)sha512_update,
  86         .result = (qcrypto_nettle_result)sha512_digest,
  87         .len = SHA512_DIGEST_SIZE,
  88     },
  89     [QCRYPTO_HASH_ALG_RIPEMD160] = {
  90         .init = (qcrypto_nettle_init)ripemd160_init,
  91         .write = (qcrypto_nettle_write)ripemd160_update,
  92         .result = (qcrypto_nettle_result)ripemd160_digest,
  93         .len = RIPEMD160_DIGEST_SIZE,
  94     },
  95 };
  96
  97 gboolean qcrypto_hash_supports(QCryptoHashAlgorithm alg)
  98 {
  99     if (alg < G_N_ELEMENTS(qcrypto_hash_alg_map) &&
 100         qcrypto_hash_alg_map[alg].init != NULL) {
 101         return true;
 102     }
 103     return false;
 104 }
 105
 106
 107 static int
 108 qcrypto_nettle_hash_bytesv(QCryptoHashAlgorithm alg,
 109                            const struct iovec *iov,
 110                            size_t niov,
 111                            uint8_t **result,
 112                            size_t *resultlen,
 113                            Error **errp)
 114 {
 115     size_t i;
 116     union qcrypto_hash_ctx ctx;
 117
 118     if (!qcrypto_hash_supports(alg)) {
 119         error_setg(errp,
 120                    "Unknown hash algorithm %d",
 121                    alg);
 122         return -1;
 123     }
 124
 125     qcrypto_hash_alg_map[alg].init(&ctx);
 126
 127     for (i = 0; i < niov; i++) {
 128         /* Some versions of nettle have functions
 129          * declared with 'int' instead of 'size_t'
 130          * so to be safe avoid writing more than
 131          * UINT_MAX bytes at a time
 132          */
 133         size_t len = iov[i].iov_len;
 134         uint8_t *base = iov[i].iov_base;
 135         while (len) {
 136             size_t shortlen = MIN(len, UINT_MAX);
 137             qcrypto_hash_alg_map[alg].write(&ctx, len, base);
 138             len -= shortlen;
 139             base += len;
 140         }
 141     }
 142
 143     if (*resultlen == 0) {
 144         *resultlen = qcrypto_hash_alg_map[alg].len;
 145         *result = g_new0(uint8_t, *resultlen);
 146     } else if (*resultlen != qcrypto_hash_alg_map[alg].len) {
 147         error_setg(errp,
 148                    "Result buffer size %zu is smaller than hash %zu",
 149                    *resultlen, qcrypto_hash_alg_map[alg].len);
 150         return -1;
 151     }
 152
 153     qcrypto_hash_alg_map[alg].result(&ctx, *resultlen, *result);
 154
 155     return 0;
 156 }
 157
 158
 159 QCryptoHashDriver qcrypto_hash_lib_driver = {
 160     .hash_bytesv = qcrypto_nettle_hash_bytesv,
 161 };