1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 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 <crc32.h> 37 #include <hast.h> 38 #include <nv.h> 39 #include <sha256.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(data, size); 53 /* XXXPJD: Do we have to use htole32() on crc first? */ 54 bcopy(&crc, hash, sizeof(crc)); 55 *hsizep = sizeof(crc); 56 } 57 58 static void 59 hast_sha256_checksum(const unsigned char *data, size_t size, 60 unsigned char *hash, size_t *hsizep) 61 { 62 SHA256_CTX ctx; 63 64 SHA256_Init(&ctx); 65 SHA256_Update(&ctx, data, size); 66 SHA256_Final(hash, &ctx); 67 *hsizep = SHA256_DIGEST_LENGTH; 68 } 69 70 const char * 71 checksum_name(int num) 72 { 73 74 switch (num) { 75 case HAST_CHECKSUM_NONE: 76 return ("none"); 77 case HAST_CHECKSUM_CRC32: 78 return ("crc32"); 79 case HAST_CHECKSUM_SHA256: 80 return ("sha256"); 81 } 82 return ("unknown"); 83 } 84 85 int 86 checksum_send(const struct hast_resource *res, struct nv *nv, void **datap, 87 size_t *sizep, bool *freedatap __unused) 88 { 89 unsigned char hash[MAX_HASH_SIZE]; 90 size_t hsize; 91 92 switch (res->hr_checksum) { 93 case HAST_CHECKSUM_NONE: 94 return (0); 95 case HAST_CHECKSUM_CRC32: 96 hast_crc32_checksum(*datap, *sizep, hash, &hsize); 97 break; 98 case HAST_CHECKSUM_SHA256: 99 hast_sha256_checksum(*datap, *sizep, hash, &hsize); 100 break; 101 default: 102 PJDLOG_ABORT("Invalid checksum: %d.", res->hr_checksum); 103 } 104 nv_add_string(nv, checksum_name(res->hr_checksum), "checksum"); 105 nv_add_uint8_array(nv, hash, hsize, "hash"); 106 if (nv_error(nv) != 0) { 107 errno = nv_error(nv); 108 return (-1); 109 } 110 return (0); 111 } 112 113 int 114 checksum_recv(const struct hast_resource *res __unused, struct nv *nv, 115 void **datap, size_t *sizep, bool *freedatap __unused) 116 { 117 unsigned char chash[MAX_HASH_SIZE]; 118 const unsigned char *rhash; 119 size_t chsize, rhsize; 120 const char *algo; 121 122 algo = nv_get_string(nv, "checksum"); 123 if (algo == NULL) 124 return (0); /* No checksum. */ 125 rhash = nv_get_uint8_array(nv, &rhsize, "hash"); 126 if (rhash == NULL) { 127 pjdlog_error("Hash is missing."); 128 return (-1); /* Hash not found. */ 129 } 130 if (strcmp(algo, "crc32") == 0) 131 hast_crc32_checksum(*datap, *sizep, chash, &chsize); 132 else if (strcmp(algo, "sha256") == 0) 133 hast_sha256_checksum(*datap, *sizep, chash, &chsize); 134 else { 135 pjdlog_error("Unknown checksum algorithm '%s'.", algo); 136 return (-1); /* Unknown checksum algorithm. */ 137 } 138 if (rhsize != chsize) { 139 pjdlog_error("Invalid hash size (%zu) for %s, should be %zu.", 140 rhsize, algo, chsize); 141 return (-1); /* Different hash size. */ 142 } 143 if (bcmp(rhash, chash, chsize) != 0) { 144 pjdlog_error("Hash mismatch."); 145 return (-1); /* Hash mismatch. */ 146 } 147 148 return (0); 149 } 150