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/sphincs_verify_key_manager.h"
18
19 #include <memory>
20 #include <string>
21
22 #include "gmock/gmock.h"
23 #include "gtest/gtest.h"
24 #include "absl/container/flat_hash_set.h"
25 #include "absl/strings/str_cat.h"
26 #include "tink/experimental/pqcrypto/signature/sphincs_sign_key_manager.h"
27 #include "tink/experimental/pqcrypto/signature/subtle/sphincs_sign.h"
28 #include "tink/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils.h"
29 #include "tink/experimental/pqcrypto/signature/subtle/sphincs_verify.h"
30 #include "tink/experimental/pqcrypto/signature/util/enums.h"
31 #include "tink/public_key_verify.h"
32 #include "tink/util/secret_data.h"
33 #include "tink/util/status.h"
34 #include "tink/util/statusor.h"
35 #include "tink/util/test_matchers.h"
36
37 extern "C" {
38 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
39 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
40 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
41 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
42 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
43 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
44 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
45 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
46 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
47 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
48 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
49 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
50 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
51 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
52 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
53 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
54 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
55 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
56 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
57 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
58 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
59 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
60 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
61 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
62 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
63 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
64 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
65 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
66 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
67 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
68 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
69 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
70 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
71 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
72 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
73 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
74 }
75
76 namespace crypto {
77 namespace tink {
78 namespace {
79
80 using ::crypto::tink::test::IsOk;
81 using ::crypto::tink::util::EnumsPqcrypto;
82 using ::crypto::tink::util::StatusOr;
83 using ::google::crypto::tink::KeyData;
84 using ::google::crypto::tink::SphincsHashType;
85 using ::google::crypto::tink::SphincsKeyFormat;
86 using ::google::crypto::tink::SphincsParams;
87 using ::google::crypto::tink::SphincsPrivateKey;
88 using ::google::crypto::tink::SphincsPublicKey;
89 using ::google::crypto::tink::SphincsSignatureType;
90 using ::google::crypto::tink::SphincsVariant;
91 using ::testing::Eq;
92 using ::testing::Not;
93
94 struct SphincsTestCase {
95 std::string test_name;
96 SphincsHashType hash_type;
97 SphincsVariant variant;
98 SphincsSignatureType sig_length_type;
99 int32_t private_key_size;
100 int32_t public_key_size;
101 };
102
103 using SphincsVerifyKeyManagerTest = testing::TestWithParam<SphincsTestCase>;
104
105 // Helper function that returns a valid sphincs private key.
CreateValidPrivateKey(int32_t private_key_size,SphincsHashType hash_type,SphincsVariant variant,SphincsSignatureType type)106 StatusOr<SphincsPrivateKey> CreateValidPrivateKey(int32_t private_key_size,
107 SphincsHashType hash_type,
108 SphincsVariant variant,
109 SphincsSignatureType type) {
110 SphincsKeyFormat key_format;
111 SphincsParams* params = key_format.mutable_params();
112 params->set_key_size(private_key_size);
113 params->set_hash_type(hash_type);
114 params->set_variant(variant);
115 params->set_sig_length_type(type);
116
117 return SphincsSignKeyManager().CreateKey(key_format);
118 }
119
120 // Helper function that returns a valid sphincs public key.
CreateValidPublicKey(int32_t private_key_size,SphincsHashType hash_type,SphincsVariant variant,SphincsSignatureType type)121 StatusOr<SphincsPublicKey> CreateValidPublicKey(int32_t private_key_size,
122 SphincsHashType hash_type,
123 SphincsVariant variant,
124 SphincsSignatureType type) {
125 StatusOr<SphincsPrivateKey> private_key =
126 CreateValidPrivateKey(private_key_size, hash_type, variant, type);
127
128 if (!private_key.ok()) return private_key.status();
129 return SphincsSignKeyManager().GetPublicKey(*private_key);
130 }
131
TEST(SphincsVerifyKeyManagerTest,Basics)132 TEST(SphincsVerifyKeyManagerTest, Basics) {
133 EXPECT_THAT(SphincsVerifyKeyManager().get_version(), Eq(0));
134 EXPECT_THAT(SphincsVerifyKeyManager().key_material_type(),
135 Eq(KeyData::ASYMMETRIC_PUBLIC));
136 EXPECT_THAT(SphincsVerifyKeyManager().get_key_type(),
137 Eq("type.googleapis.com/google.crypto.tink.SphincsPublicKey"));
138 }
139
TEST(SphincsVerifyKeyManagerTest,ValidateEmptyKey)140 TEST(SphincsVerifyKeyManagerTest, ValidateEmptyKey) {
141 EXPECT_THAT(SphincsVerifyKeyManager().ValidateKey(SphincsPublicKey()),
142 Not(IsOk()));
143 }
144
TEST_P(SphincsVerifyKeyManagerTest,InvalidParam)145 TEST_P(SphincsVerifyKeyManagerTest, InvalidParam) {
146 const SphincsTestCase& test_case = GetParam();
147
148 SphincsKeyFormat key_format;
149 SphincsParams* params = key_format.mutable_params();
150 params->set_key_size(test_case.private_key_size);
151 params->set_hash_type(test_case.hash_type);
152 params->set_variant(test_case.variant);
153 params->set_sig_length_type(SphincsSignatureType::SIG_TYPE_UNSPECIFIED);
154
155 EXPECT_THAT(SphincsVerifyKeyManager().ValidateParams(*params), Not(IsOk()));
156 }
157
TEST_P(SphincsVerifyKeyManagerTest,PublicKeyValid)158 TEST_P(SphincsVerifyKeyManagerTest, PublicKeyValid) {
159 const SphincsTestCase& test_case = GetParam();
160
161 StatusOr<SphincsPublicKey> public_key =
162 CreateValidPublicKey(test_case.private_key_size, test_case.hash_type,
163 test_case.variant, test_case.sig_length_type);
164 ASSERT_THAT(public_key, IsOk());
165
166 EXPECT_THAT(SphincsVerifyKeyManager().ValidateKey(*public_key), IsOk());
167 }
168
TEST(SphincsVerifyKeyManagerTest,PublicKeyInvalidParams)169 TEST(SphincsVerifyKeyManagerTest, PublicKeyInvalidParams) {
170 StatusOr<SphincsPublicKey> public_key = CreateValidPublicKey(
171 subtle::kSphincsPrivateKeySize64, SphincsHashType::HASH_TYPE_UNSPECIFIED,
172 SphincsVariant::VARIANT_UNSPECIFIED,
173 SphincsSignatureType::SIG_TYPE_UNSPECIFIED);
174 EXPECT_THAT(public_key, Not(IsOk()));
175 }
176
TEST_P(SphincsVerifyKeyManagerTest,PublicKeyWrongVersion)177 TEST_P(SphincsVerifyKeyManagerTest, PublicKeyWrongVersion) {
178 const SphincsTestCase& test_case = GetParam();
179
180 StatusOr<SphincsPublicKey> public_key =
181 CreateValidPublicKey(test_case.private_key_size, test_case.hash_type,
182 test_case.variant, test_case.sig_length_type);
183 ASSERT_THAT(public_key, IsOk());
184
185 public_key->set_version(1);
186 EXPECT_THAT(SphincsVerifyKeyManager().ValidateKey(*public_key), Not(IsOk()));
187 }
188
TEST_P(SphincsVerifyKeyManagerTest,Create)189 TEST_P(SphincsVerifyKeyManagerTest, Create) {
190 const SphincsTestCase& test_case = GetParam();
191
192 StatusOr<SphincsPrivateKey> private_key =
193 CreateValidPrivateKey(test_case.private_key_size, test_case.hash_type,
194 test_case.variant, test_case.sig_length_type);
195 ASSERT_THAT(private_key, IsOk());
196
197 StatusOr<SphincsPublicKey> public_key =
198 SphincsSignKeyManager().GetPublicKey(*private_key);
199 ASSERT_THAT(public_key, IsOk());
200
201 subtle::SphincsParamsPqclean sphincs_params_pqclean = {
202 .hash_type = EnumsPqcrypto::ProtoToSubtle(test_case.hash_type),
203 .variant = EnumsPqcrypto::ProtoToSubtle(test_case.variant),
204 .sig_length_type =
205 EnumsPqcrypto::ProtoToSubtle(test_case.sig_length_type),
206 .private_key_size = test_case.private_key_size};
207 subtle::SphincsPrivateKeyPqclean sphincs_private_key_pqclean(
208 util::SecretDataFromStringView(private_key->key_value()),
209 sphincs_params_pqclean);
210
211 util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
212 subtle::SphincsSign::New(sphincs_private_key_pqclean);
213 ASSERT_THAT(direct_signer, IsOk());
214
215 util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
216 SphincsVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
217 ASSERT_THAT(verifier, IsOk());
218
219 std::string message = "Some message";
220 util::StatusOr<std::string> signature = (*direct_signer)->Sign(message);
221 ASSERT_THAT(signature, IsOk());
222 EXPECT_THAT((*verifier)->Verify(*signature, message), IsOk());
223 }
224
TEST_P(SphincsVerifyKeyManagerTest,CreateInvalidPublicKey)225 TEST_P(SphincsVerifyKeyManagerTest, CreateInvalidPublicKey) {
226 const SphincsTestCase& test_case = GetParam();
227
228 StatusOr<SphincsPrivateKey> private_key =
229 CreateValidPrivateKey(test_case.private_key_size, test_case.hash_type,
230 test_case.variant, test_case.sig_length_type);
231 ASSERT_THAT(private_key, IsOk());
232
233 StatusOr<SphincsPublicKey> public_key =
234 SphincsSignKeyManager().GetPublicKey(*private_key);
235 ASSERT_THAT(public_key, IsOk());
236
237 std::string bad_public_key_data = "bad_public_key";
238 public_key->set_key_value(bad_public_key_data);
239
240 util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
241 SphincsVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
242 EXPECT_THAT(verifier, Not(IsOk()));
243 }
244
TEST_P(SphincsVerifyKeyManagerTest,CreateDifferentPublicKey)245 TEST_P(SphincsVerifyKeyManagerTest, CreateDifferentPublicKey) {
246 const SphincsTestCase& test_case = GetParam();
247
248 StatusOr<SphincsPrivateKey> private_key =
249 CreateValidPrivateKey(test_case.private_key_size, test_case.hash_type,
250 test_case.variant, test_case.sig_length_type);
251 ASSERT_THAT(private_key, IsOk());
252
253 // Create a new public key derived from a diffferent private key.
254 StatusOr<SphincsPrivateKey> new_private_key =
255 CreateValidPrivateKey(test_case.private_key_size, test_case.hash_type,
256 test_case.variant, test_case.sig_length_type);
257 ASSERT_THAT(new_private_key, IsOk());
258 StatusOr<SphincsPublicKey> public_key =
259 SphincsSignKeyManager().GetPublicKey(*new_private_key);
260 ASSERT_THAT(public_key, IsOk());
261
262 subtle::SphincsParamsPqclean sphincs_params_pqclean = {
263 .hash_type = EnumsPqcrypto::ProtoToSubtle(test_case.hash_type),
264 .variant = EnumsPqcrypto::ProtoToSubtle(test_case.variant),
265 .sig_length_type =
266 EnumsPqcrypto::ProtoToSubtle(test_case.sig_length_type),
267 .private_key_size = test_case.private_key_size};
268 subtle::SphincsPrivateKeyPqclean sphincs_private_key_pqclean(
269 util::SecretDataFromStringView(private_key->key_value()),
270 sphincs_params_pqclean);
271
272 util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
273 subtle::SphincsSign::New(sphincs_private_key_pqclean);
274 ASSERT_THAT(direct_signer, IsOk());
275
276 util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
277 SphincsVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
278 ASSERT_THAT(verifier, IsOk());
279
280 std::string message = "Some message";
281 util::StatusOr<std::string> signature = (*direct_signer)->Sign(message);
282 ASSERT_THAT(signature, IsOk());
283 EXPECT_THAT((*verifier)->Verify(*signature, message), Not(IsOk()));
284 }
285
286 INSTANTIATE_TEST_SUITE_P(
287 SphincsVerifyKeyManagerTests, SphincsVerifyKeyManagerTest,
288 testing::ValuesIn<SphincsTestCase>(
289 {{"SPHINCSHARAKA128FROBUST", SphincsHashType::HARAKA,
290 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
291 PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
292 PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_PUBLICKEYBYTES},
293 {"SPHINCSHARAKA128SROBUST", SphincsHashType::HARAKA,
294 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
295 PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
296 PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_PUBLICKEYBYTES},
297 {"SPHINCSHARAKA128FSIMPLE", SphincsHashType::HARAKA,
298 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
299 PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
300 PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
301 {"SPHINCSHARAKA128SSIMPLE", SphincsHashType::HARAKA,
302 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
303 PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
304 PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
305
306 {"SPHINCSHARAKA192FROBUST", SphincsHashType::HARAKA,
307 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
308 PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
309 PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_PUBLICKEYBYTES},
310 {"SPHINCSHARAKA192SROBUST", SphincsHashType::HARAKA,
311 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
312 PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
313 PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_PUBLICKEYBYTES},
314 {"SPHINCSHARAKA192FSIMPLE", SphincsHashType::HARAKA,
315 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
316 PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
317 PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
318 {"SPHINCSHARAKA192SSIMPLE", SphincsHashType::HARAKA,
319 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
320 PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
321 PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
322
323 {"SPHINCSHARAKA256FROBUST", SphincsHashType::HARAKA,
324 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
325 PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
326 PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_PUBLICKEYBYTES},
327 {"SPHINCSHARAKA256SROBUST", SphincsHashType::HARAKA,
328 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
329 PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
330 PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_PUBLICKEYBYTES},
331 {"SPHINCSHARAKA256FSIMPLE", SphincsHashType::HARAKA,
332 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
333 PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
334 PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
335 {"SPHINCSHARAKA256SSIMPLE", SphincsHashType::HARAKA,
336 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
337 PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
338 PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
339
340 {"SPHINCSSHA256128FROBUST", SphincsHashType::SHA256,
341 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
342 PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
343 PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_PUBLICKEYBYTES},
344 {"SPHINCSSHA256128SROBUST", SphincsHashType::SHA256,
345 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
346 PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
347 PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_PUBLICKEYBYTES},
348 {"SPHINCSSHA256128FSIMPLE", SphincsHashType::SHA256,
349 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
350 PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
351 PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
352 {"SPHINCSSHA256128SSIMPLE", SphincsHashType::SHA256,
353 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
354 PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
355 PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
356
357 {"SPHINCSSHA256192FROBUST", SphincsHashType::SHA256,
358 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
359 PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
360 PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_PUBLICKEYBYTES},
361 {"SPHINCSSHA256192SROBUST", SphincsHashType::SHA256,
362 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
363 PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
364 PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_PUBLICKEYBYTES},
365 {"SPHINCSSHA256192FSIMPLE", SphincsHashType::SHA256,
366 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
367 PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
368 PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
369 {"SPHINCSSHA256192SSIMPLE", SphincsHashType::SHA256,
370 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
371 PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
372 PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
373
374 {"SPHINCSSHA256256FROBUST", SphincsHashType::SHA256,
375 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
376 PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
377 PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_PUBLICKEYBYTES},
378 {"SPHINCSSHA256256SROBUST", SphincsHashType::SHA256,
379 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
380 PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
381 PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_PUBLICKEYBYTES},
382 {"SPHINCSSHA256256FSIMPLE", SphincsHashType::SHA256,
383 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
384 PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
385 PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
386 {"SPHINCSSHA256256SSIMPLE", SphincsHashType::SHA256,
387 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
388 PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
389 PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
390
391 {"SPHINCSSHAKE256128FROBUST", SphincsHashType::SHAKE256,
392 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
393 PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
394 PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_PUBLICKEYBYTES},
395 {"SPHINCSSHAKE256128SROBUST", SphincsHashType::SHAKE256,
396 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
397 PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
398 PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_PUBLICKEYBYTES},
399 {"SPHINCSSHAKE256128FSIMPLE", SphincsHashType::SHAKE256,
400 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
401 PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
402 PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
403 {"SPHINCSSHAKE256128SSIMPLE", SphincsHashType::SHAKE256,
404 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
405 PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
406 PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
407
408 {"SPHINCSSHAKE256192FROBUST", SphincsHashType::SHAKE256,
409 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
410 PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
411 PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_PUBLICKEYBYTES},
412 {"SPHINCSSHAKE256192SROBUST", SphincsHashType::SHAKE256,
413 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
414 PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
415 PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_PUBLICKEYBYTES},
416 {"SPHINCSSHAKE256192FSIMPLE", SphincsHashType::SHAKE256,
417 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
418 PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
419 PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
420 {"SPHINCSSHAKE256192SSIMPLE", SphincsHashType::SHAKE256,
421 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
422 PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
423 PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
424
425 {"SPHINCSSHAKE256256FROBUST", SphincsHashType::SHAKE256,
426 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
427 PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
428 PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_PUBLICKEYBYTES},
429 {"SPHINCSSHAKE256256SROBUST", SphincsHashType::SHAKE256,
430 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
431 PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
432 PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_PUBLICKEYBYTES},
433 {"SPHINCSSHAKE256256FSIMPLE", SphincsHashType::SHAKE256,
434 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
435 PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
436 PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
437 {"SPHINCSSHAKE256256SSIMPLE", SphincsHashType::SHAKE256,
438 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
439 PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
440 PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_PUBLICKEYBYTES}}),
441 [](const testing::TestParamInfo<SphincsVerifyKeyManagerTest::ParamType>&
__anon0ca8ed0f0202(const testing::TestParamInfo<SphincsVerifyKeyManagerTest::ParamType>& info) 442 info) { return info.param.test_name; });
443
444 } // namespace
445
446 } // namespace tink
447 } // namespace crypto
448