1 // Copyright 2021 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
15 ///////////////////////////////////////////////////////////////////////////////
16
17 #include "tink/experimental/pqcrypto/signature/subtle/sphincs_verify.h"
18
19 #include <memory>
20 #include <string>
21 #include <utility>
22
23 #include "gmock/gmock.h"
24 #include "gtest/gtest.h"
25 #include "absl/status/status.h"
26 #include "absl/strings/str_cat.h"
27 #include "tink/config/tink_fips.h"
28 #include "tink/experimental/pqcrypto/signature/subtle/sphincs_helper_pqclean.h"
29 #include "tink/experimental/pqcrypto/signature/subtle/sphincs_sign.h"
30 #include "tink/public_key_sign.h"
31 #include "tink/public_key_verify.h"
32 #include "tink/util/status.h"
33 #include "tink/util/statusor.h"
34 #include "tink/util/test_matchers.h"
35
36 extern "C" {
37 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
38 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
39 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
40 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
41 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
42 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
43 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
44 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
45 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
46 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
47 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
48 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
49 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
50 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
51 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
52 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
53 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
54 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
55 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
56 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
57 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
58 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
59 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
60 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
61 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
62 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
63 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
64 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
65 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
66 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
67 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
68 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
69 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
70 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
71 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
72 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
73 }
74
75 namespace crypto {
76 namespace tink {
77 namespace subtle {
78
79 namespace {
80
81 struct SphincsTestCase {
82 std::string test_name;
83 SphincsHashType hash_type;
84 SphincsVariant variant;
85 SphincsSignatureType sig_length_type;
86 int32_t private_key_size;
87 int32_t signature_length;
88 };
89
90 using ::crypto::tink::test::IsOk;
91 using ::crypto::tink::test::StatusIs;
92 using crypto::tink::util::Status;
93
94 using SphincsVerifyTest = testing::TestWithParam<SphincsTestCase>;
95
TEST_P(SphincsVerifyTest,BasicSignVerify)96 TEST_P(SphincsVerifyTest, BasicSignVerify) {
97 if (IsFipsModeEnabled()) {
98 GTEST_SKIP() << "Test assumes kOnlyUseFips is false.";
99 }
100
101 const SphincsTestCase& test_case = GetParam();
102
103 SphincsParamsPqclean params = {
104 .hash_type = test_case.hash_type,
105 .variant = test_case.variant,
106 .sig_length_type = test_case.sig_length_type,
107 .private_key_size = test_case.private_key_size,
108 };
109
110 // Generate sphincs key pair.
111 util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
112 ASSERT_THAT(key_pair, IsOk());
113
114 // Create a new signer.
115 util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
116 SphincsSign::New(key_pair->GetPrivateKey());
117 ASSERT_THAT(signer, IsOk());
118
119 // Sign a message.
120 std::string message = "message to be signed";
121 util::StatusOr<std::string> signature = (*signer)->Sign(message);
122 ASSERT_THAT(signature, IsOk());
123
124 // Create a new verifier.
125 absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
126 SphincsVerify::New(key_pair->GetPublicKey());
127 ASSERT_THAT(verifier, IsOk());
128
129 // Verify signature.
130 Status status = (*verifier)->Verify(*signature, message);
131 EXPECT_THAT(status, IsOk());
132 }
133
TEST_P(SphincsVerifyTest,FailsWithWrongSignature)134 TEST_P(SphincsVerifyTest, FailsWithWrongSignature) {
135 if (IsFipsModeEnabled()) {
136 GTEST_SKIP() << "Test assumes kOnlyUseFips is false.";
137 }
138
139 const SphincsTestCase& test_case = GetParam();
140
141 SphincsParamsPqclean params = {
142 .hash_type = test_case.hash_type,
143 .variant = test_case.variant,
144 .sig_length_type = test_case.sig_length_type,
145 .private_key_size = test_case.private_key_size,
146 };
147
148 // Generate sphincs key pair.
149 util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
150 ASSERT_THAT(key_pair, IsOk());
151
152 // Create a new signer.
153 util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
154 SphincsSign::New(key_pair->GetPrivateKey());
155 ASSERT_THAT(signer, IsOk());
156
157 // Sign a message.
158 std::string message = "message to be signed";
159 util::StatusOr<std::string> signature = (*signer)->Sign(message);
160 ASSERT_THAT(signature, IsOk());
161
162 // Create a new verifier.
163 absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
164 SphincsVerify::New(key_pair->GetPublicKey());
165 ASSERT_THAT(verifier, IsOk());
166
167 // Verify signature.
168 Status status =
169 (*verifier)->Verify(*signature + "some trailing data", message);
170 EXPECT_FALSE(status.ok());
171 }
172
TEST_P(SphincsVerifyTest,FailsWithWrongMessage)173 TEST_P(SphincsVerifyTest, FailsWithWrongMessage) {
174 if (IsFipsModeEnabled()) {
175 GTEST_SKIP() << "Test assumes kOnlyUseFips is false.";
176 }
177
178 const SphincsTestCase& test_case = GetParam();
179
180 SphincsParamsPqclean params = {
181 .hash_type = test_case.hash_type,
182 .variant = test_case.variant,
183 .sig_length_type = test_case.sig_length_type,
184 .private_key_size = test_case.private_key_size,
185 };
186
187 // Generate sphincs key pair.
188 util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
189 ASSERT_THAT(key_pair, IsOk());
190
191 // Create a new signer.
192 util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
193 SphincsSign::New(key_pair->GetPrivateKey());
194 ASSERT_THAT(signer, IsOk());
195
196 // Sign a message.
197 std::string message = "message to be signed";
198 util::StatusOr<std::string> signature = (*signer)->Sign(message);
199 ASSERT_THAT(signature, IsOk());
200
201 // Create a new verifier.
202 absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
203 SphincsVerify::New(key_pair->GetPublicKey());
204 ASSERT_THAT(verifier, IsOk());
205
206 // Verify signature.
207 Status status = (*verifier)->Verify(*signature, "some bad message");
208 EXPECT_FALSE(status.ok());
209 }
210
TEST_P(SphincsVerifyTest,FailsWithBytesFlipped)211 TEST_P(SphincsVerifyTest, FailsWithBytesFlipped) {
212 if (IsFipsModeEnabled()) {
213 GTEST_SKIP() << "Test assumes kOnlyUseFips is false.";
214 }
215
216 const SphincsTestCase& test_case = GetParam();
217
218 SphincsParamsPqclean params = {
219 .hash_type = test_case.hash_type,
220 .variant = test_case.variant,
221 .sig_length_type = test_case.sig_length_type,
222 .private_key_size = test_case.private_key_size,
223 };
224
225 // Generate sphincs key pair.
226 util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
227 ASSERT_THAT(key_pair, IsOk());
228
229 // Create a new signer.
230 util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
231 SphincsSign::New(key_pair->GetPrivateKey());
232 ASSERT_THAT(signer, IsOk());
233
234 // Sign a message.
235 std::string message = "message to be signed";
236 util::StatusOr<std::string> signature = (*signer)->Sign(message);
237 ASSERT_THAT(signature, IsOk());
238
239 // Create a new verifier.
240 absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
241 SphincsVerify::New(key_pair->GetPublicKey());
242 ASSERT_THAT(verifier, IsOk());
243
244 // Invalidate one signature byte.
245 (*signature)[0] ^= 1;
246
247 // Verify signature.
248 Status status = (*verifier)->Verify(*signature, message);
249 EXPECT_FALSE(status.ok());
250 }
251
TEST_P(SphincsVerifyTest,FipsMode)252 TEST_P(SphincsVerifyTest, FipsMode) {
253 if (!IsFipsModeEnabled()) {
254 GTEST_SKIP() << "Test assumes kOnlyUseFips.";
255 }
256
257 const SphincsTestCase& test_case = GetParam();
258
259 SphincsParamsPqclean params = {
260 .hash_type = test_case.hash_type,
261 .variant = test_case.variant,
262 .sig_length_type = test_case.sig_length_type,
263 .private_key_size = test_case.private_key_size,
264 };
265
266 // Generate sphincs key pair.
267 util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
268 ASSERT_THAT(key_pair, IsOk());
269
270 // Create a new signer.
271 EXPECT_THAT(SphincsVerify::New(key_pair->GetPublicKey()).status(),
272 StatusIs(absl::StatusCode::kInternal));
273 }
274
275 // TODO(ioannanedelcu): Add test with testvectors.
276
277 INSTANTIATE_TEST_SUITE_P(
278 SphincsVerifyTests, SphincsVerifyTest,
279 testing::ValuesIn<SphincsTestCase>(
280 {{"SPHINCSHARAKA128FROBUST", SphincsHashType::HARAKA,
281 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
282 PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
283 PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_BYTES},
284 {"SPHINCSHARAKA128SROBUST", SphincsHashType::HARAKA,
285 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
286 PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
287 PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_BYTES},
288 {"SPHINCSHARAKA128FSIMPLE", SphincsHashType::HARAKA,
289 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
290 PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
291 PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_BYTES},
292 {"SPHINCSHARAKA128SSIMPLE", SphincsHashType::HARAKA,
293 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
294 PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
295 PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_BYTES},
296
297 {"SPHINCSHARAKA192FROBUST", SphincsHashType::HARAKA,
298 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
299 PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
300 PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_BYTES},
301 {"SPHINCSHARAKA192SROBUST", SphincsHashType::HARAKA,
302 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
303 PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
304 PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_BYTES},
305 {"SPHINCSHARAKA192FSIMPLE", SphincsHashType::HARAKA,
306 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
307 PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
308 PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_BYTES},
309 {"SPHINCSHARAKA192SSIMPLE", SphincsHashType::HARAKA,
310 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
311 PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
312 PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_BYTES},
313
314 {"SPHINCSHARAKA256FROBUST", SphincsHashType::HARAKA,
315 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
316 PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
317 PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_BYTES},
318 {"SPHINCSHARAKA256SROBUST", SphincsHashType::HARAKA,
319 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
320 PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
321 PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_BYTES},
322 {"SPHINCSHARAKA256FSIMPLE", SphincsHashType::HARAKA,
323 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
324 PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
325 PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_BYTES},
326 {"SPHINCSHARAKA256SSIMPLE", SphincsHashType::HARAKA,
327 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
328 PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
329 PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_BYTES},
330
331 {"SPHINCSSHA256128FROBUST", SphincsHashType::SHA256,
332 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
333 PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
334 PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_BYTES},
335 {"SPHINCSSHA256128SROBUST", SphincsHashType::SHA256,
336 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
337 PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
338 PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_BYTES},
339 {"SPHINCSSHA256128FSIMPLE", SphincsHashType::SHA256,
340 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
341 PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
342 PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_BYTES},
343 {"SPHINCSSHA256128SSIMPLE", SphincsHashType::SHA256,
344 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
345 PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
346 PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_BYTES},
347
348 {"SPHINCSSHA256192FROBUST", SphincsHashType::SHA256,
349 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
350 PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
351 PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_BYTES},
352 {"SPHINCSSHA256192SROBUST", SphincsHashType::SHA256,
353 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
354 PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
355 PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_BYTES},
356 {"SPHINCSSHA256192FSIMPLE", SphincsHashType::SHA256,
357 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
358 PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
359 PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_BYTES},
360 {"SPHINCSSHA256192SSIMPLE", SphincsHashType::SHA256,
361 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
362 PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
363 PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_BYTES},
364
365 {"SPHINCSSHA256256FROBUST", SphincsHashType::SHA256,
366 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
367 PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
368 PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_BYTES},
369 {"SPHINCSSHA256256SROBUST", SphincsHashType::SHA256,
370 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
371 PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
372 PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_BYTES},
373 {"SPHINCSSHA256256FSIMPLE", SphincsHashType::SHA256,
374 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
375 PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
376 PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_BYTES},
377 {"SPHINCSSHA256256SSIMPLE", SphincsHashType::SHA256,
378 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
379 PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
380 PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_BYTES},
381
382 {"SPHINCSSHAKE256128FROBUST", SphincsHashType::SHAKE256,
383 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
384 PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
385 PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_BYTES},
386 {"SPHINCSSHAKE256128SROBUST", SphincsHashType::SHAKE256,
387 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
388 PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
389 PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_BYTES},
390 {"SPHINCSSHAKE256128FSIMPLE", SphincsHashType::SHAKE256,
391 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
392 PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
393 PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_BYTES},
394 {"SPHINCSSHAKE256128SSIMPLE", SphincsHashType::SHAKE256,
395 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
396 PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
397 PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_BYTES},
398
399 {"SPHINCSSHAKE256192FROBUST", SphincsHashType::SHAKE256,
400 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
401 PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
402 PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_BYTES},
403 {"SPHINCSSHAKE256192SROBUST", SphincsHashType::SHAKE256,
404 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
405 PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
406 PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_BYTES},
407 {"SPHINCSSHAKE256192FSIMPLE", SphincsHashType::SHAKE256,
408 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
409 PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
410 PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_BYTES},
411 {"SPHINCSSHAKE256192SSIMPLE", SphincsHashType::SHAKE256,
412 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
413 PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
414 PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_BYTES},
415
416 {"SPHINCSSHAKE256256FROBUST", SphincsHashType::SHAKE256,
417 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
418 PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
419 PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_BYTES},
420 {"SPHINCSSHAKE256256SROBUST", SphincsHashType::SHAKE256,
421 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
422 PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
423 PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_BYTES},
424 {"SPHINCSSHAKE256256FSIMPLE", SphincsHashType::SHAKE256,
425 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
426 PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
427 PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_BYTES},
428 {"SPHINCSSHAKE256256SSIMPLE", SphincsHashType::SHAKE256,
429 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
430 PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
431 PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_BYTES}}),
__anon1b034e8d0202(const testing::TestParamInfo<SphincsVerifyTest::ParamType>& info) 432 [](const testing::TestParamInfo<SphincsVerifyTest::ParamType>& info) {
433 return info.param.test_name;
434 });
435
436 } // namespace
437
438 } // namespace subtle
439 } // namespace tink
440 } // namespace crypto
441