14840716380

Committed 05 May 2025 01:00PM UTC coverage: 91.119% (-0.2%) from 91.313%

Build # 14840716380

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4851 from randombit/jack/fix-simd-4x32

Fix SIMD_4X32 tests

Run Details

96001 of 105358 relevant lines covered (91.12%)

12918201.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

18.71

/src/lib/hash/sha1/sha1.cpp

1	/*
2	* SHA-1
3	* (C) 1999-2008,2011 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/internal/sha1.h>
9
10	#include <botan/internal/bit_ops.h>
11	#include <botan/internal/loadstor.h>
12	#include <botan/internal/rotate.h>
13	#include <botan/internal/stl_util.h>
14	#include <array>
15
16	#if defined(BOTAN_HAS_CPUID)
17	#include <botan/internal/cpuid.h>
18	#endif
19
20	namespace Botan {
21
22	namespace SHA1_F {
23
24	namespace {
25
26	/*
27	* SHA-1 F1 Function
28	*/
29	inline void F1(uint32_t A, uint32_t& B, uint32_t C, uint32_t D, uint32_t& E, uint32_t msg) {	×
30	E += choose(B, C, D) + msg + 0x5A827999 + rotl<5>(A);	×
31	B = rotl<30>(B);	×
32	}
33
34	/*
35	* SHA-1 F2 Function
36	*/
37	inline void F2(uint32_t A, uint32_t& B, uint32_t C, uint32_t D, uint32_t& E, uint32_t msg) {	×
38	E += (B ^ C ^ D) + msg + 0x6ED9EBA1 + rotl<5>(A);	×
39	B = rotl<30>(B);	×
40	}
41
42	/*
43	* SHA-1 F3 Function
44	*/
45	inline void F3(uint32_t A, uint32_t& B, uint32_t C, uint32_t D, uint32_t& E, uint32_t msg) {	×
46	E += majority(B, C, D) + msg + 0x8F1BBCDC + rotl<5>(A);	×
47	B = rotl<30>(B);	×
48	}
49
50	/*
51	* SHA-1 F4 Function
52	*/
53	inline void F4(uint32_t A, uint32_t& B, uint32_t C, uint32_t D, uint32_t& E, uint32_t msg) {	×
54	E += (B ^ C ^ D) + msg + 0xCA62C1D6 + rotl<5>(A);	×
55	B = rotl<30>(B);	×
56	}
57
58	} // namespace
59
60	} // namespace SHA1_F
61
62	/*
63	* SHA-1 Compression Function
64	*/
65	void SHA_1::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {	9,682,436✔
66	using namespace SHA1_F;	9,682,436✔
67
68	#if defined(BOTAN_HAS_SHA1_X86_SHA_NI)
69	if(CPUID::has(CPUID::Feature::SHA)) {	9,682,436✔
70	return sha1_compress_x86(digest, input, blocks);	9,682,436✔
71	}
72	#endif
73
74	#if defined(BOTAN_HAS_SHA1_ARMV8)
75	if(CPUID::has(CPUID::Feature::SHA1)) {
76	return sha1_armv8_compress_n(digest, input, blocks);
77	}
78	#endif
79
80	#if defined(BOTAN_HAS_SHA1_SIMD_4X32)
81	if(CPUID::has(CPUID::Feature::SIMD_4X32)) {	1,711✔
82	return simd_compress_n(digest, input, blocks);	1,711✔
83	}
84
85	#endif
86
87	uint32_t A = digest[0], B = digest[1], C = digest[2], D = digest[3], E = digest[4];	×
88	std::array<uint32_t, 80> W;	×
89	auto W_in = std::span{W}.first<block_bytes / sizeof(uint32_t)>();	×
90
91	BufferSlicer in(input);	×
92
93	for(size_t i = 0; i != blocks; ++i) {	×
94	load_be(W_in, in.take<block_bytes>());	×
95
96	// clang-format off
97
98	for(size_t j = 16; j != 80; j += 8) {	×
99	W[j + 0] = rotl<1>(W[j - 3] ^ W[j - 8] ^ W[j - 14] ^ W[j - 16]);	×
100	W[j + 1] = rotl<1>(W[j - 2] ^ W[j - 7] ^ W[j - 13] ^ W[j - 15]);	×
101	W[j + 2] = rotl<1>(W[j - 1] ^ W[j - 6] ^ W[j - 12] ^ W[j - 14]);	×
102	W[j + 3] = rotl<1>(W[j ] ^ W[j - 5] ^ W[j - 11] ^ W[j - 13]);	×
103	W[j + 4] = rotl<1>(W[j + 1] ^ W[j - 4] ^ W[j - 10] ^ W[j - 12]);	×
104	W[j + 5] = rotl<1>(W[j + 2] ^ W[j - 3] ^ W[j - 9] ^ W[j - 11]);	×
105	W[j + 6] = rotl<1>(W[j + 3] ^ W[j - 2] ^ W[j - 8] ^ W[j - 10]);	×
106	W[j + 7] = rotl<1>(W[j + 4] ^ W[j - 1] ^ W[j - 7] ^ W[j - 9]);	×
107	}
108
109	// clang-format on
110
111	F1(A, B, C, D, E, W[0]);	×
112	F1(E, A, B, C, D, W[1]);	×
113	F1(D, E, A, B, C, W[2]);	×
114	F1(C, D, E, A, B, W[3]);	×
115	F1(B, C, D, E, A, W[4]);	×
116	F1(A, B, C, D, E, W[5]);	×
117	F1(E, A, B, C, D, W[6]);	×
118	F1(D, E, A, B, C, W[7]);	×
119	F1(C, D, E, A, B, W[8]);	×
120	F1(B, C, D, E, A, W[9]);	×
121	F1(A, B, C, D, E, W[10]);	×
122	F1(E, A, B, C, D, W[11]);	×
123	F1(D, E, A, B, C, W[12]);	×
124	F1(C, D, E, A, B, W[13]);	×
125	F1(B, C, D, E, A, W[14]);	×
126	F1(A, B, C, D, E, W[15]);	×
127	F1(E, A, B, C, D, W[16]);	×
128	F1(D, E, A, B, C, W[17]);	×
129	F1(C, D, E, A, B, W[18]);	×
130	F1(B, C, D, E, A, W[19]);	×
131
132	F2(A, B, C, D, E, W[20]);	×
133	F2(E, A, B, C, D, W[21]);	×
134	F2(D, E, A, B, C, W[22]);	×
135	F2(C, D, E, A, B, W[23]);	×
136	F2(B, C, D, E, A, W[24]);	×
137	F2(A, B, C, D, E, W[25]);	×
138	F2(E, A, B, C, D, W[26]);	×
139	F2(D, E, A, B, C, W[27]);	×
140	F2(C, D, E, A, B, W[28]);	×
141	F2(B, C, D, E, A, W[29]);	×
142	F2(A, B, C, D, E, W[30]);	×
143	F2(E, A, B, C, D, W[31]);	×
144	F2(D, E, A, B, C, W[32]);	×
145	F2(C, D, E, A, B, W[33]);	×
146	F2(B, C, D, E, A, W[34]);	×
147	F2(A, B, C, D, E, W[35]);	×
148	F2(E, A, B, C, D, W[36]);	×
149	F2(D, E, A, B, C, W[37]);	×
150	F2(C, D, E, A, B, W[38]);	×
151	F2(B, C, D, E, A, W[39]);	×
152
153	F3(A, B, C, D, E, W[40]);	×
154	F3(E, A, B, C, D, W[41]);	×
155	F3(D, E, A, B, C, W[42]);	×
156	F3(C, D, E, A, B, W[43]);	×
157	F3(B, C, D, E, A, W[44]);	×
158	F3(A, B, C, D, E, W[45]);	×
159	F3(E, A, B, C, D, W[46]);	×
160	F3(D, E, A, B, C, W[47]);	×
161	F3(C, D, E, A, B, W[48]);	×
162	F3(B, C, D, E, A, W[49]);	×
163	F3(A, B, C, D, E, W[50]);	×
164	F3(E, A, B, C, D, W[51]);	×
165	F3(D, E, A, B, C, W[52]);	×
166	F3(C, D, E, A, B, W[53]);	×
167	F3(B, C, D, E, A, W[54]);	×
168	F3(A, B, C, D, E, W[55]);	×
169	F3(E, A, B, C, D, W[56]);	×
170	F3(D, E, A, B, C, W[57]);	×
171	F3(C, D, E, A, B, W[58]);	×
172	F3(B, C, D, E, A, W[59]);	×
173
174	F4(A, B, C, D, E, W[60]);	×
175	F4(E, A, B, C, D, W[61]);	×
176	F4(D, E, A, B, C, W[62]);	×
177	F4(C, D, E, A, B, W[63]);	×
178	F4(B, C, D, E, A, W[64]);	×
179	F4(A, B, C, D, E, W[65]);	×
180	F4(E, A, B, C, D, W[66]);	×
181	F4(D, E, A, B, C, W[67]);	×
182	F4(C, D, E, A, B, W[68]);	×
183	F4(B, C, D, E, A, W[69]);	×
184	F4(A, B, C, D, E, W[70]);	×
185	F4(E, A, B, C, D, W[71]);	×
186	F4(D, E, A, B, C, W[72]);	×
187	F4(C, D, E, A, B, W[73]);	×
188	F4(B, C, D, E, A, W[74]);	×
189	F4(A, B, C, D, E, W[75]);	×
190	F4(E, A, B, C, D, W[76]);	×
191	F4(D, E, A, B, C, W[77]);	×
192	F4(C, D, E, A, B, W[78]);	×
193	F4(B, C, D, E, A, W[79]);	×
194
195	A = (digest[0] += A);	×
196	B = (digest[1] += B);	×
197	C = (digest[2] += C);	×
198	D = (digest[3] += D);	×
199	E = (digest[4] += E);	×
200	}
201	}
202
203	/*
204	* Clear memory of sensitive data
205	*/
206	void SHA_1::init(digest_type& digest) {	2,242,916✔
207	digest.assign({0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0});	2,242,916✔
208	}	2,242,916✔
209
210	std::string SHA_1::provider() const {	234✔
211	#if defined(BOTAN_HAS_SHA1_X86_SHA_NI)
212	if(auto feat = CPUID::check(CPUID::Feature::SHA)) {	234✔
213	return *feat;	156✔
214	}	78✔
215	#endif
216
217	#if defined(BOTAN_HAS_SHA1_ARMV8)
218	if(auto feat = CPUID::check(CPUID::Feature::SHA1)) {
219	return *feat;
220	}
221	#endif
222
223	#if defined(BOTAN_HAS_SHA1_SIMD_4X32)
224	if(auto feat = CPUID::check(CPUID::Feature::SIMD_4X32)) {	156✔
225	return *feat;	312✔
226	}	156✔
227	#endif
228
229	return "base";	×
230	}
231
232	std::unique_ptr<HashFunction> SHA_1::new_object() const {	631✔
233	return std::make_unique<SHA_1>();	631✔
234	}
235
236	std::unique_ptr<HashFunction> SHA_1::copy_state() const {	214✔
237	return std::make_unique<SHA_1>(*this);	214✔
238	}
239
240	void SHA_1::add_data(std::span<const uint8_t> input) {	12,980,539✔
241	m_md.update(input);	12,980,539✔
242	}	12,980,539✔
243
244	void SHA_1::final_result(std::span<uint8_t> output) {	2,120,989✔
245	m_md.final(output);	2,120,989✔
246	}	2,120,989✔
247
248	} // namespace Botan

randombit / botan / 14840716380

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous