xref: /freebsd/sys/contrib/openzfs/module/icp/algs/blake3/blake3_generic.c (revision 924226fba12cc9a228c73b956e1b7fa24c60b055)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Based on BLAKE3 v1.3.1, https://github.com/BLAKE3-team/BLAKE3
24  * Copyright (c) 2019-2020 Samuel Neves and Jack O'Connor
25  * Copyright (c) 2021-2022 Tino Reichardt <milky-zfs@mcmilk.de>
26  */
27 
28 #include <sys/zfs_context.h>
29 #include "blake3_impl.h"
30 
31 #define	rotr32(x, n)	(((x) >> (n)) | ((x) << (32 - (n))))
32 static inline void g(uint32_t *state, size_t a, size_t b, size_t c, size_t d,
33     uint32_t x, uint32_t y)
34 {
35 	state[a] = state[a] + state[b] + x;
36 	state[d] = rotr32(state[d] ^ state[a], 16);
37 	state[c] = state[c] + state[d];
38 	state[b] = rotr32(state[b] ^ state[c], 12);
39 	state[a] = state[a] + state[b] + y;
40 	state[d] = rotr32(state[d] ^ state[a], 8);
41 	state[c] = state[c] + state[d];
42 	state[b] = rotr32(state[b] ^ state[c], 7);
43 }
44 
45 static inline void round_fn(uint32_t state[16], const uint32_t *msg,
46     size_t round)
47 {
48 	/* Select the message schedule based on the round. */
49 	const uint8_t *schedule = BLAKE3_MSG_SCHEDULE[round];
50 
51 	/* Mix the columns. */
52 	g(state, 0, 4, 8, 12, msg[schedule[0]], msg[schedule[1]]);
53 	g(state, 1, 5, 9, 13, msg[schedule[2]], msg[schedule[3]]);
54 	g(state, 2, 6, 10, 14, msg[schedule[4]], msg[schedule[5]]);
55 	g(state, 3, 7, 11, 15, msg[schedule[6]], msg[schedule[7]]);
56 
57 	/* Mix the rows. */
58 	g(state, 0, 5, 10, 15, msg[schedule[8]], msg[schedule[9]]);
59 	g(state, 1, 6, 11, 12, msg[schedule[10]], msg[schedule[11]]);
60 	g(state, 2, 7, 8, 13, msg[schedule[12]], msg[schedule[13]]);
61 	g(state, 3, 4, 9, 14, msg[schedule[14]], msg[schedule[15]]);
62 }
63 
64 static inline void compress_pre(uint32_t state[16], const uint32_t cv[8],
65     const uint8_t block[BLAKE3_BLOCK_LEN], uint8_t block_len,
66     uint64_t counter, uint8_t flags)
67 {
68 	uint32_t block_words[16];
69 	block_words[0] = load32(block + 4 * 0);
70 	block_words[1] = load32(block + 4 * 1);
71 	block_words[2] = load32(block + 4 * 2);
72 	block_words[3] = load32(block + 4 * 3);
73 	block_words[4] = load32(block + 4 * 4);
74 	block_words[5] = load32(block + 4 * 5);
75 	block_words[6] = load32(block + 4 * 6);
76 	block_words[7] = load32(block + 4 * 7);
77 	block_words[8] = load32(block + 4 * 8);
78 	block_words[9] = load32(block + 4 * 9);
79 	block_words[10] = load32(block + 4 * 10);
80 	block_words[11] = load32(block + 4 * 11);
81 	block_words[12] = load32(block + 4 * 12);
82 	block_words[13] = load32(block + 4 * 13);
83 	block_words[14] = load32(block + 4 * 14);
84 	block_words[15] = load32(block + 4 * 15);
85 
86 	state[0] = cv[0];
87 	state[1] = cv[1];
88 	state[2] = cv[2];
89 	state[3] = cv[3];
90 	state[4] = cv[4];
91 	state[5] = cv[5];
92 	state[6] = cv[6];
93 	state[7] = cv[7];
94 	state[8] = BLAKE3_IV[0];
95 	state[9] = BLAKE3_IV[1];
96 	state[10] = BLAKE3_IV[2];
97 	state[11] = BLAKE3_IV[3];
98 	state[12] = counter_low(counter);
99 	state[13] = counter_high(counter);
100 	state[14] = (uint32_t)block_len;
101 	state[15] = (uint32_t)flags;
102 
103 	round_fn(state, &block_words[0], 0);
104 	round_fn(state, &block_words[0], 1);
105 	round_fn(state, &block_words[0], 2);
106 	round_fn(state, &block_words[0], 3);
107 	round_fn(state, &block_words[0], 4);
108 	round_fn(state, &block_words[0], 5);
109 	round_fn(state, &block_words[0], 6);
110 }
111 
112 static inline void blake3_compress_in_place_generic(uint32_t cv[8],
113     const uint8_t block[BLAKE3_BLOCK_LEN], uint8_t block_len,
114     uint64_t counter, uint8_t flags)
115 {
116 	uint32_t state[16];
117 	compress_pre(state, cv, block, block_len, counter, flags);
118 	cv[0] = state[0] ^ state[8];
119 	cv[1] = state[1] ^ state[9];
120 	cv[2] = state[2] ^ state[10];
121 	cv[3] = state[3] ^ state[11];
122 	cv[4] = state[4] ^ state[12];
123 	cv[5] = state[5] ^ state[13];
124 	cv[6] = state[6] ^ state[14];
125 	cv[7] = state[7] ^ state[15];
126 }
127 
128 static inline void hash_one_generic(const uint8_t *input, size_t blocks,
129     const uint32_t key[8], uint64_t counter, uint8_t flags,
130     uint8_t flags_start, uint8_t flags_end, uint8_t out[BLAKE3_OUT_LEN])
131 {
132 	uint32_t cv[8];
133 	memcpy(cv, key, BLAKE3_KEY_LEN);
134 	uint8_t block_flags = flags | flags_start;
135 	while (blocks > 0) {
136 		if (blocks == 1) {
137 			block_flags |= flags_end;
138 		}
139 		blake3_compress_in_place_generic(cv, input, BLAKE3_BLOCK_LEN,
140 		    counter, block_flags);
141 		input = &input[BLAKE3_BLOCK_LEN];
142 		blocks -= 1;
143 		block_flags = flags;
144 	}
145 	store_cv_words(out, cv);
146 }
147 
148 static inline void blake3_compress_xof_generic(const uint32_t cv[8],
149     const uint8_t block[BLAKE3_BLOCK_LEN], uint8_t block_len,
150     uint64_t counter, uint8_t flags, uint8_t out[64])
151 {
152 	uint32_t state[16];
153 	compress_pre(state, cv, block, block_len, counter, flags);
154 
155 	store32(&out[0 * 4], state[0] ^ state[8]);
156 	store32(&out[1 * 4], state[1] ^ state[9]);
157 	store32(&out[2 * 4], state[2] ^ state[10]);
158 	store32(&out[3 * 4], state[3] ^ state[11]);
159 	store32(&out[4 * 4], state[4] ^ state[12]);
160 	store32(&out[5 * 4], state[5] ^ state[13]);
161 	store32(&out[6 * 4], state[6] ^ state[14]);
162 	store32(&out[7 * 4], state[7] ^ state[15]);
163 	store32(&out[8 * 4], state[8] ^ cv[0]);
164 	store32(&out[9 * 4], state[9] ^ cv[1]);
165 	store32(&out[10 * 4], state[10] ^ cv[2]);
166 	store32(&out[11 * 4], state[11] ^ cv[3]);
167 	store32(&out[12 * 4], state[12] ^ cv[4]);
168 	store32(&out[13 * 4], state[13] ^ cv[5]);
169 	store32(&out[14 * 4], state[14] ^ cv[6]);
170 	store32(&out[15 * 4], state[15] ^ cv[7]);
171 }
172 
173 static inline void blake3_hash_many_generic(const uint8_t * const *inputs,
174     size_t num_inputs, size_t blocks, const uint32_t key[8], uint64_t counter,
175     boolean_t increment_counter, uint8_t flags, uint8_t flags_start,
176     uint8_t flags_end, uint8_t *out)
177 {
178 	while (num_inputs > 0) {
179 		hash_one_generic(inputs[0], blocks, key, counter, flags,
180 		    flags_start, flags_end, out);
181 		if (increment_counter) {
182 			counter += 1;
183 		}
184 		inputs += 1;
185 		num_inputs -= 1;
186 		out = &out[BLAKE3_OUT_LEN];
187 	}
188 }
189 
190 static inline boolean_t blake3_is_generic_supported(void)
191 {
192 	return (B_TRUE);
193 }
194 
195 const blake3_impl_ops_t blake3_generic_impl = {
196 	.compress_in_place = blake3_compress_in_place_generic,
197 	.compress_xof = blake3_compress_xof_generic,
198 	.hash_many = blake3_hash_many_generic,
199 	.is_supported = blake3_is_generic_supported,
200 	.degree = 4,
201 	.name = "generic"
202 };
203