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_sign_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_verify_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::subtle::SphincsPublicKeyPqclean;
81 using ::crypto::tink::test::IsOk;
82 using ::crypto::tink::util::EnumsPqcrypto;
83 using ::crypto::tink::util::StatusOr;
84 using ::google::crypto::tink::KeyData;
85 using ::google::crypto::tink::SphincsHashType;
86 using ::google::crypto::tink::SphincsKeyFormat;
87 using ::google::crypto::tink::SphincsParams;
88 using ::google::crypto::tink::SphincsPrivateKey;
89 using ::google::crypto::tink::SphincsPublicKey;
90 using ::google::crypto::tink::SphincsSignatureType;
91 using ::google::crypto::tink::SphincsVariant;
92 using ::testing::Eq;
93 using ::testing::Not;
94 using ::testing::SizeIs;
95
96 struct SphincsTestCase {
97 std::string test_name;
98 SphincsHashType hash_type;
99 SphincsVariant variant;
100 SphincsSignatureType sig_length_type;
101 int32_t private_key_size;
102 int32_t public_key_size;
103 };
104
105 using SphincsSignKeyManagerTest = testing::TestWithParam<SphincsTestCase>;
106
107 // Helper function that returns a valid sphincs key format.
CreateValidKeyFormat(int32_t private_key_size,SphincsHashType hash_type,SphincsVariant variant,SphincsSignatureType type)108 StatusOr<SphincsKeyFormat> CreateValidKeyFormat(int32_t private_key_size,
109 SphincsHashType hash_type,
110 SphincsVariant variant,
111 SphincsSignatureType type) {
112 SphincsKeyFormat key_format;
113 SphincsParams* params = key_format.mutable_params();
114 params->set_key_size(private_key_size);
115 params->set_hash_type(hash_type);
116 params->set_variant(variant);
117 params->set_sig_length_type(type);
118
119 return key_format;
120 }
121
TEST(SphincsSignKeyManagerTest,Basic)122 TEST(SphincsSignKeyManagerTest, Basic) {
123 EXPECT_THAT(SphincsSignKeyManager().get_version(), Eq(0));
124 EXPECT_THAT(SphincsSignKeyManager().key_material_type(),
125 Eq(KeyData::ASYMMETRIC_PRIVATE));
126 EXPECT_THAT(SphincsSignKeyManager().get_key_type(),
127 Eq("type.googleapis.com/google.crypto.tink.SphincsPrivateKey"));
128 }
129
TEST_P(SphincsSignKeyManagerTest,ValidKeyFormat)130 TEST_P(SphincsSignKeyManagerTest, ValidKeyFormat) {
131 const SphincsTestCase& test_case = GetParam();
132
133 StatusOr<SphincsKeyFormat> key_format =
134 CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
135 test_case.variant, test_case.sig_length_type);
136 ASSERT_THAT(key_format, IsOk());
137
138 EXPECT_THAT(SphincsSignKeyManager().ValidateKeyFormat(*key_format), IsOk());
139 }
140
TEST(SphincsSignKeyManagerTest,InvalidKeyFormat)141 TEST(SphincsSignKeyManagerTest, InvalidKeyFormat) {
142 StatusOr<SphincsKeyFormat> key_format = CreateValidKeyFormat(
143 subtle::kSphincsPrivateKeySize64, SphincsHashType::HASH_TYPE_UNSPECIFIED,
144 SphincsVariant::VARIANT_UNSPECIFIED,
145 SphincsSignatureType::SIG_TYPE_UNSPECIFIED);
146 ASSERT_THAT(key_format, IsOk());
147
148 EXPECT_THAT(SphincsSignKeyManager().ValidateKeyFormat(*key_format),
149 Not(IsOk()));
150 }
151
TEST_P(SphincsSignKeyManagerTest,CreateKeyValid)152 TEST_P(SphincsSignKeyManagerTest, CreateKeyValid) {
153 const SphincsTestCase& test_case = GetParam();
154
155 StatusOr<SphincsKeyFormat> key_format =
156 CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
157 test_case.variant, test_case.sig_length_type);
158 ASSERT_THAT(key_format, IsOk());
159
160 StatusOr<SphincsPrivateKey> private_key =
161 SphincsSignKeyManager().CreateKey(*key_format);
162 ASSERT_THAT(private_key, IsOk());
163
164 EXPECT_THAT(SphincsSignKeyManager().ValidateKey(*private_key), IsOk());
165 EXPECT_THAT(private_key->version(), Eq(0));
166 EXPECT_THAT(private_key->public_key().version(), Eq(private_key->version()));
167 EXPECT_THAT(private_key->key_value(), SizeIs(test_case.private_key_size));
168 }
169
TEST_P(SphincsSignKeyManagerTest,PrivateKeyWrongVersion)170 TEST_P(SphincsSignKeyManagerTest, PrivateKeyWrongVersion) {
171 const SphincsTestCase& test_case = GetParam();
172
173 StatusOr<SphincsKeyFormat> key_format =
174 CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
175 test_case.variant, test_case.sig_length_type);
176 ASSERT_THAT(key_format, IsOk());
177
178 StatusOr<SphincsPrivateKey> private_key =
179 SphincsSignKeyManager().CreateKey(*key_format);
180 ASSERT_THAT(private_key, IsOk());
181
182 private_key->set_version(1);
183 EXPECT_THAT(SphincsSignKeyManager().ValidateKey(*private_key), Not(IsOk()));
184 }
185
TEST(SphincsSignKeyManagerTest,CreateKeyInvalidParams)186 TEST(SphincsSignKeyManagerTest, CreateKeyInvalidParams) {
187 StatusOr<SphincsKeyFormat> key_format = CreateValidKeyFormat(
188 subtle::kSphincsPrivateKeySize64, SphincsHashType::HASH_TYPE_UNSPECIFIED,
189 SphincsVariant::VARIANT_UNSPECIFIED,
190 SphincsSignatureType::SIG_TYPE_UNSPECIFIED);
191 ASSERT_THAT(key_format, IsOk());
192
193 StatusOr<SphincsPrivateKey> private_key =
194 SphincsSignKeyManager().CreateKey(*key_format);
195 EXPECT_THAT(private_key, Not(IsOk()));
196 }
197
TEST_P(SphincsSignKeyManagerTest,CreateKeyAlwaysNew)198 TEST_P(SphincsSignKeyManagerTest, CreateKeyAlwaysNew) {
199 const SphincsTestCase& test_case = GetParam();
200
201 StatusOr<SphincsKeyFormat> key_format =
202 CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
203 test_case.variant, test_case.sig_length_type);
204 ASSERT_THAT(key_format, IsOk());
205
206 absl::flat_hash_set<std::string> keys;
207 int num_tests = 5;
208 for (int i = 0; i < num_tests; ++i) {
209 StatusOr<SphincsPrivateKey> private_key =
210 SphincsSignKeyManager().CreateKey(*key_format);
211 ASSERT_THAT(private_key, IsOk());
212 keys.insert(private_key->key_value());
213 }
214 EXPECT_THAT(keys, SizeIs(num_tests));
215 }
216
TEST_P(SphincsSignKeyManagerTest,GetPublicKey)217 TEST_P(SphincsSignKeyManagerTest, GetPublicKey) {
218 const SphincsTestCase& test_case = GetParam();
219
220 StatusOr<SphincsKeyFormat> key_format =
221 CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
222 test_case.variant, test_case.sig_length_type);
223 ASSERT_THAT(key_format, IsOk());
224
225 StatusOr<SphincsPrivateKey> private_key =
226 SphincsSignKeyManager().CreateKey(*key_format);
227 ASSERT_THAT(private_key, IsOk());
228
229 StatusOr<SphincsPublicKey> public_key_or =
230 SphincsSignKeyManager().GetPublicKey(*private_key);
231 ASSERT_THAT(public_key_or, IsOk());
232
233 EXPECT_THAT(public_key_or->version(),
234 Eq(private_key->public_key().version()));
235 EXPECT_THAT(public_key_or->key_value(),
236 Eq(private_key->public_key().key_value()));
237 }
238
TEST_P(SphincsSignKeyManagerTest,CreateValid)239 TEST_P(SphincsSignKeyManagerTest, CreateValid) {
240 const SphincsTestCase& test_case = GetParam();
241
242 StatusOr<SphincsKeyFormat> key_format =
243 CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
244 test_case.variant, test_case.sig_length_type);
245 ASSERT_THAT(key_format, IsOk());
246
247 util::StatusOr<SphincsPrivateKey> private_key =
248 SphincsSignKeyManager().CreateKey(*key_format);
249 ASSERT_THAT(private_key, IsOk());
250
251 util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
252 SphincsSignKeyManager().GetPrimitive<PublicKeySign>(*private_key);
253 ASSERT_THAT(signer, IsOk());
254
255 subtle::SphincsParamsPqclean sphincs_params_pqclean = {
256 .hash_type = EnumsPqcrypto::ProtoToSubtle(test_case.hash_type),
257 .variant = EnumsPqcrypto::ProtoToSubtle(test_case.variant),
258 .sig_length_type =
259 EnumsPqcrypto::ProtoToSubtle(test_case.sig_length_type),
260 .private_key_size = test_case.private_key_size};
261
262 SphincsPublicKeyPqclean sphincs_public_key_pqclean(
263 private_key->public_key().key_value(), sphincs_params_pqclean);
264
265 util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
266 subtle::SphincsVerify::New(sphincs_public_key_pqclean);
267 ASSERT_THAT(verifier, IsOk());
268
269 std::string message = "Some message";
270 util::StatusOr<std::string> signature = (*signer)->Sign(message);
271 ASSERT_THAT(signature, IsOk());
272 EXPECT_THAT((*verifier)->Verify(*signature, message), IsOk());
273 }
274
TEST_P(SphincsSignKeyManagerTest,CreateBadPublicKey)275 TEST_P(SphincsSignKeyManagerTest, CreateBadPublicKey) {
276 const SphincsTestCase& test_case = GetParam();
277
278 StatusOr<SphincsKeyFormat> key_format =
279 CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
280 test_case.variant, test_case.sig_length_type);
281 ASSERT_THAT(key_format, IsOk());
282
283 util::StatusOr<SphincsPrivateKey> private_key =
284 SphincsSignKeyManager().CreateKey(*key_format);
285 ASSERT_THAT(private_key, IsOk());
286
287 util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
288 SphincsSignKeyManager().GetPrimitive<PublicKeySign>(*private_key);
289 ASSERT_THAT(signer, IsOk());
290
291 std::string bad_public_key_data(test_case.public_key_size, '@');
292
293 subtle::SphincsParamsPqclean sphincs_params_pqclean = {
294 .hash_type = EnumsPqcrypto::ProtoToSubtle(test_case.hash_type),
295 .variant = EnumsPqcrypto::ProtoToSubtle(test_case.variant),
296 .sig_length_type =
297 EnumsPqcrypto::ProtoToSubtle(test_case.sig_length_type),
298 .private_key_size = test_case.private_key_size};
299
300 SphincsPublicKeyPqclean sphincs_public_key_pqclean(bad_public_key_data,
301 sphincs_params_pqclean);
302 util::StatusOr<std::unique_ptr<PublicKeyVerify>> direct_verifier =
303 subtle::SphincsVerify::New(sphincs_public_key_pqclean);
304 ASSERT_THAT(direct_verifier, IsOk());
305
306 std::string message = "Some message";
307 util::StatusOr<std::string> signature = (*signer)->Sign(message);
308 ASSERT_THAT(signature, IsOk());
309 EXPECT_THAT((*direct_verifier)->Verify(*signature, message), Not(IsOk()));
310 }
311
312 INSTANTIATE_TEST_SUITE_P(
313 SphincsSignKeyManagerTests, SphincsSignKeyManagerTest,
314 testing::ValuesIn<SphincsTestCase>(
315 {{"SPHINCSHARAKA128FROBUST", SphincsHashType::HARAKA,
316 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
317 PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
318 PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_PUBLICKEYBYTES},
319 {"SPHINCSHARAKA128SROBUST", SphincsHashType::HARAKA,
320 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
321 PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
322 PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_PUBLICKEYBYTES},
323 {"SPHINCSHARAKA128FSIMPLE", SphincsHashType::HARAKA,
324 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
325 PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
326 PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
327 {"SPHINCSHARAKA128SSIMPLE", SphincsHashType::HARAKA,
328 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
329 PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
330 PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
331
332 {"SPHINCSHARAKA192FROBUST", SphincsHashType::HARAKA,
333 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
334 PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
335 PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_PUBLICKEYBYTES},
336 {"SPHINCSHARAKA192SROBUST", SphincsHashType::HARAKA,
337 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
338 PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
339 PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_PUBLICKEYBYTES},
340 {"SPHINCSHARAKA192FSIMPLE", SphincsHashType::HARAKA,
341 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
342 PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
343 PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
344 {"SPHINCSHARAKA192SSIMPLE", SphincsHashType::HARAKA,
345 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
346 PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
347 PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
348
349 {"SPHINCSHARAKA256FROBUST", SphincsHashType::HARAKA,
350 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
351 PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
352 PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_PUBLICKEYBYTES},
353 {"SPHINCSHARAKA256SROBUST", SphincsHashType::HARAKA,
354 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
355 PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
356 PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_PUBLICKEYBYTES},
357 {"SPHINCSHARAKA256FSIMPLE", SphincsHashType::HARAKA,
358 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
359 PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
360 PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
361 {"SPHINCSHARAKA256SSIMPLE", SphincsHashType::HARAKA,
362 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
363 PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
364 PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
365
366 {"SPHINCSSHA256128FROBUST", SphincsHashType::SHA256,
367 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
368 PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
369 PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_PUBLICKEYBYTES},
370 {"SPHINCSSHA256128SROBUST", SphincsHashType::SHA256,
371 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
372 PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
373 PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_PUBLICKEYBYTES},
374 {"SPHINCSSHA256128FSIMPLE", SphincsHashType::SHA256,
375 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
376 PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
377 PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
378 {"SPHINCSSHA256128SSIMPLE", SphincsHashType::SHA256,
379 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
380 PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
381 PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
382
383 {"SPHINCSSHA256192FROBUST", SphincsHashType::SHA256,
384 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
385 PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
386 PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_PUBLICKEYBYTES},
387 {"SPHINCSSHA256192SROBUST", SphincsHashType::SHA256,
388 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
389 PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
390 PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_PUBLICKEYBYTES},
391 {"SPHINCSSHA256192FSIMPLE", SphincsHashType::SHA256,
392 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
393 PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
394 PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
395 {"SPHINCSSHA256192SSIMPLE", SphincsHashType::SHA256,
396 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
397 PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
398 PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
399
400 {"SPHINCSSHA256256FROBUST", SphincsHashType::SHA256,
401 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
402 PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
403 PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_PUBLICKEYBYTES},
404 {"SPHINCSSHA256256SROBUST", SphincsHashType::SHA256,
405 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
406 PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
407 PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_PUBLICKEYBYTES},
408 {"SPHINCSSHA256256FSIMPLE", SphincsHashType::SHA256,
409 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
410 PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
411 PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
412 {"SPHINCSSHA256256SSIMPLE", SphincsHashType::SHA256,
413 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
414 PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
415 PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
416
417 {"SPHINCSSHAKE256128FROBUST", SphincsHashType::SHAKE256,
418 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
419 PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
420 PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_PUBLICKEYBYTES},
421 {"SPHINCSSHAKE256128SROBUST", SphincsHashType::SHAKE256,
422 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
423 PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
424 PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_PUBLICKEYBYTES},
425 {"SPHINCSSHAKE256128FSIMPLE", SphincsHashType::SHAKE256,
426 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
427 PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
428 PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
429 {"SPHINCSSHAKE256128SSIMPLE", SphincsHashType::SHAKE256,
430 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
431 PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
432 PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
433
434 {"SPHINCSSHAKE256192FROBUST", SphincsHashType::SHAKE256,
435 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
436 PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
437 PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_PUBLICKEYBYTES},
438 {"SPHINCSSHAKE256192SROBUST", SphincsHashType::SHAKE256,
439 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
440 PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
441 PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_PUBLICKEYBYTES},
442 {"SPHINCSSHAKE256192FSIMPLE", SphincsHashType::SHAKE256,
443 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
444 PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
445 PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
446 {"SPHINCSSHAKE256192SSIMPLE", SphincsHashType::SHAKE256,
447 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
448 PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
449 PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
450
451 {"SPHINCSSHAKE256256FROBUST", SphincsHashType::SHAKE256,
452 SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
453 PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
454 PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_PUBLICKEYBYTES},
455 {"SPHINCSSHAKE256256SROBUST", SphincsHashType::SHAKE256,
456 SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
457 PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
458 PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_PUBLICKEYBYTES},
459 {"SPHINCSSHAKE256256FSIMPLE", SphincsHashType::SHAKE256,
460 SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
461 PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
462 PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
463 {"SPHINCSSHAKE256256SSIMPLE", SphincsHashType::SHAKE256,
464 SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
465 PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
466 PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_PUBLICKEYBYTES}}),
467 [](const testing::TestParamInfo<SphincsSignKeyManagerTest::ParamType>&
__anonf0ebed2b0202(const testing::TestParamInfo<SphincsSignKeyManagerTest::ParamType>& info) 468 info) { return info.param.test_name; });
469
470 } // namespace
471
472 } // namespace tink
473 } // namespace crypto
474