qemu

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
};
162