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
qcrypto_hash_supports(QCryptoHashAlgorithm alg)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
qcrypto_nettle_hash_bytesv(QCryptoHashAlgorithm alg,const struct iovec * iov,size_t niov,uint8_t ** result,size_t * resultlen,Error ** errp)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 };
162