1 /* 2 * QEMU Crypto hash algorithms 3 * 4 * Copyright (c) 2015 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 "crypto/hash.h" 23 #include "hashpriv.h" 24 25 static size_t qcrypto_hash_alg_size[QCRYPTO_HASH_ALG__MAX] = { 26 [QCRYPTO_HASH_ALG_MD5] = 16, 27 [QCRYPTO_HASH_ALG_SHA1] = 20, 28 [QCRYPTO_HASH_ALG_SHA224] = 28, 29 [QCRYPTO_HASH_ALG_SHA256] = 32, 30 [QCRYPTO_HASH_ALG_SHA384] = 48, 31 [QCRYPTO_HASH_ALG_SHA512] = 64, 32 [QCRYPTO_HASH_ALG_RIPEMD160] = 20, 33 }; 34 35 size_t qcrypto_hash_digest_len(QCryptoHashAlgorithm alg) 36 { 37 assert(alg < G_N_ELEMENTS(qcrypto_hash_alg_size)); 38 return qcrypto_hash_alg_size[alg]; 39 } 40 41 int qcrypto_hash_bytesv(QCryptoHashAlgorithm alg, 42 const struct iovec *iov, 43 size_t niov, 44 uint8_t **result, 45 size_t *resultlen, 46 Error **errp) 47 { 48 #ifdef CONFIG_AF_ALG 49 int ret; 50 /* 51 * TODO: 52 * Maybe we should treat some afalg errors as fatal 53 */ 54 ret = qcrypto_hash_afalg_driver.hash_bytesv(alg, iov, niov, 55 result, resultlen, 56 NULL); 57 if (ret == 0) { 58 return ret; 59 } 60 #endif 61 62 return qcrypto_hash_lib_driver.hash_bytesv(alg, iov, niov, 63 result, resultlen, 64 errp); 65 } 66 67 68 int qcrypto_hash_bytes(QCryptoHashAlgorithm alg, 69 const char *buf, 70 size_t len, 71 uint8_t **result, 72 size_t *resultlen, 73 Error **errp) 74 { 75 struct iovec iov = { .iov_base = (char *)buf, 76 .iov_len = len }; 77 return qcrypto_hash_bytesv(alg, &iov, 1, result, resultlen, errp); 78 } 79 80 static const char hex[] = "0123456789abcdef"; 81 82 int qcrypto_hash_digestv(QCryptoHashAlgorithm alg, 83 const struct iovec *iov, 84 size_t niov, 85 char **digest, 86 Error **errp) 87 { 88 uint8_t *result = NULL; 89 size_t resultlen = 0; 90 size_t i; 91 92 if (qcrypto_hash_bytesv(alg, iov, niov, &result, &resultlen, errp) < 0) { 93 return -1; 94 } 95 96 *digest = g_new0(char, (resultlen * 2) + 1); 97 for (i = 0 ; i < resultlen ; i++) { 98 (*digest)[(i * 2)] = hex[(result[i] >> 4) & 0xf]; 99 (*digest)[(i * 2) + 1] = hex[result[i] & 0xf]; 100 } 101 (*digest)[resultlen * 2] = '\0'; 102 g_free(result); 103 return 0; 104 } 105 106 int qcrypto_hash_digest(QCryptoHashAlgorithm alg, 107 const char *buf, 108 size_t len, 109 char **digest, 110 Error **errp) 111 { 112 struct iovec iov = { .iov_base = (char *)buf, .iov_len = len }; 113 114 return qcrypto_hash_digestv(alg, &iov, 1, digest, errp); 115 } 116 117 int qcrypto_hash_base64v(QCryptoHashAlgorithm alg, 118 const struct iovec *iov, 119 size_t niov, 120 char **base64, 121 Error **errp) 122 { 123 uint8_t *result = NULL; 124 size_t resultlen = 0; 125 126 if (qcrypto_hash_bytesv(alg, iov, niov, &result, &resultlen, errp) < 0) { 127 return -1; 128 } 129 130 *base64 = g_base64_encode(result, resultlen); 131 g_free(result); 132 return 0; 133 } 134 135 int qcrypto_hash_base64(QCryptoHashAlgorithm alg, 136 const char *buf, 137 size_t len, 138 char **base64, 139 Error **errp) 140 { 141 struct iovec iov = { .iov_base = (char *)buf, .iov_len = len }; 142 143 return qcrypto_hash_base64v(alg, &iov, 1, base64, errp); 144 } 145