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