1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2011 Pawel Jakub Dawidek <pawel@dawidek.net> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <errno.h> 33 #include <string.h> 34 #include <strings.h> 35 36 #include <hast.h> 37 #include <nv.h> 38 #include <sha256.h> 39 #include <zlib.h> 40 #include <pjdlog.h> 41 42 #include "hast_checksum.h" 43 44 #define MAX_HASH_SIZE SHA256_DIGEST_LENGTH 45 46 static void 47 hast_crc32_checksum(const unsigned char *data, size_t size, 48 unsigned char *hash, size_t *hsizep) 49 { 50 uint32_t crc; 51 52 crc = crc32(0L, Z_NULL, 0); 53 crc = crc32(crc, data, size); 54 55 /* XXXPJD: Do we have to use htole32() on crc first? */ 56 bcopy(&crc, hash, sizeof(crc)); 57 *hsizep = sizeof(crc); 58 } 59 60 static void 61 hast_sha256_checksum(const unsigned char *data, size_t size, 62 unsigned char *hash, size_t *hsizep) 63 { 64 SHA256_CTX ctx; 65 66 SHA256_Init(&ctx); 67 SHA256_Update(&ctx, data, size); 68 SHA256_Final(hash, &ctx); 69 *hsizep = SHA256_DIGEST_LENGTH; 70 } 71 72 const char * 73 checksum_name(int num) 74 { 75 76 switch (num) { 77 case HAST_CHECKSUM_NONE: 78 return ("none"); 79 case HAST_CHECKSUM_CRC32: 80 return ("crc32"); 81 case HAST_CHECKSUM_SHA256: 82 return ("sha256"); 83 } 84 return ("unknown"); 85 } 86 87 int 88 checksum_send(const struct hast_resource *res, struct nv *nv, void **datap, 89 size_t *sizep, bool *freedatap __unused) 90 { 91 unsigned char hash[MAX_HASH_SIZE]; 92 size_t hsize; 93 94 switch (res->hr_checksum) { 95 case HAST_CHECKSUM_NONE: 96 return (0); 97 case HAST_CHECKSUM_CRC32: 98 hast_crc32_checksum(*datap, *sizep, hash, &hsize); 99 break; 100 case HAST_CHECKSUM_SHA256: 101 hast_sha256_checksum(*datap, *sizep, hash, &hsize); 102 break; 103 default: 104 PJDLOG_ABORT("Invalid checksum: %d.", res->hr_checksum); 105 } 106 nv_add_string(nv, checksum_name(res->hr_checksum), "checksum"); 107 nv_add_uint8_array(nv, hash, hsize, "hash"); 108 if (nv_error(nv) != 0) { 109 errno = nv_error(nv); 110 return (-1); 111 } 112 return (0); 113 } 114 115 int 116 checksum_recv(const struct hast_resource *res __unused, struct nv *nv, 117 void **datap, size_t *sizep, bool *freedatap __unused) 118 { 119 unsigned char chash[MAX_HASH_SIZE]; 120 const unsigned char *rhash; 121 size_t chsize, rhsize; 122 const char *algo; 123 124 algo = nv_get_string(nv, "checksum"); 125 if (algo == NULL) 126 return (0); /* No checksum. */ 127 rhash = nv_get_uint8_array(nv, &rhsize, "hash"); 128 if (rhash == NULL) { 129 pjdlog_error("Hash is missing."); 130 return (-1); /* Hash not found. */ 131 } 132 if (strcmp(algo, "crc32") == 0) 133 hast_crc32_checksum(*datap, *sizep, chash, &chsize); 134 else if (strcmp(algo, "sha256") == 0) 135 hast_sha256_checksum(*datap, *sizep, chash, &chsize); 136 else { 137 pjdlog_error("Unknown checksum algorithm '%s'.", algo); 138 return (-1); /* Unknown checksum algorithm. */ 139 } 140 if (rhsize != chsize) { 141 pjdlog_error("Invalid hash size (%zu) for %s, should be %zu.", 142 rhsize, algo, chsize); 143 return (-1); /* Different hash size. */ 144 } 145 if (bcmp(rhash, chash, chsize) != 0) { 146 pjdlog_error("Hash mismatch."); 147 return (-1); /* Hash mismatch. */ 148 } 149 150 return (0); 151 } 152