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_helper_pqclean.h"
18
19 #include <cstddef>
20 #include <memory>
21 #include <vector>
22
23 #include "absl/memory/memory.h"
24
25 extern "C" {
26 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
27 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
28 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
29 #include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
30 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
31 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
32 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
33 #include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
34 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
35 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
36 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
37 #include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
38 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
39 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
40 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
41 #include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
42 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
43 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
44 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
45 #include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
46 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
47 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
48 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
49 #include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
50 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
51 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
52 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
53 #include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
54 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
55 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
56 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
57 #include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
58 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
59 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
60 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
61 #include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
62 }
63
64 #define NUM_VARIANTS 2
65 #define NUM_KEY_SIZES 3
66 #define NUM_SIG_LENGTHS 2
67
68 namespace crypto {
69 namespace tink {
70 namespace subtle {
71
72 class SphincsHaraka128FRobustPqclean : public SphincsHelperPqclean {
73 public:
SphincsHaraka128FRobustPqclean()74 SphincsHaraka128FRobustPqclean()
75 : SphincsHelperPqclean(
76 PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_PUBLICKEYBYTES,
77 PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_BYTES) {}
78
79 ~SphincsHaraka128FRobustPqclean() override = default;
80
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const81 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
82 const uint8_t *sk) const override {
83 return PQCLEAN_SPHINCSHARAKA128FROBUST_crypto_sign_signature(
84 sig, siglen, m, mlen, sk);
85 }
86
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const87 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
88 const uint8_t *pk) const override {
89 return PQCLEAN_SPHINCSHARAKA128FROBUST_crypto_sign_verify(
90 sig, siglen, m, mlen, pk);
91 }
92
Keygen(uint8_t * pk,uint8_t * sk) const93 int Keygen(uint8_t *pk, uint8_t *sk) const override {
94 return PQCLEAN_SPHINCSHARAKA128FROBUST_crypto_sign_keypair(pk, sk);
95 }
96 };
97
98 class SphincsHaraka128SRobustPqclean : public SphincsHelperPqclean {
99 public:
SphincsHaraka128SRobustPqclean()100 SphincsHaraka128SRobustPqclean()
101 : SphincsHelperPqclean(
102 PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_PUBLICKEYBYTES,
103 PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_BYTES) {}
104
105 ~SphincsHaraka128SRobustPqclean() override = default;
106
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const107 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
108 const uint8_t *sk) const override {
109 return PQCLEAN_SPHINCSHARAKA128SROBUST_crypto_sign_signature(
110 sig, siglen, m, mlen, sk);
111 }
112
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const113 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
114 const uint8_t *pk) const override {
115 return PQCLEAN_SPHINCSHARAKA128SROBUST_crypto_sign_verify(
116 sig, siglen, m, mlen, pk);
117 }
118
Keygen(uint8_t * pk,uint8_t * sk) const119 int Keygen(uint8_t *pk, uint8_t *sk) const override {
120 return PQCLEAN_SPHINCSHARAKA128SROBUST_crypto_sign_keypair(pk, sk);
121 }
122 };
123
124 class SphincsHaraka128FSimplePqclean : public SphincsHelperPqclean {
125 public:
SphincsHaraka128FSimplePqclean()126 SphincsHaraka128FSimplePqclean()
127 : SphincsHelperPqclean(
128 PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_PUBLICKEYBYTES,
129 PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_BYTES) {}
130
131 ~SphincsHaraka128FSimplePqclean() override = default;
132
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const133 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
134 const uint8_t *sk) const override {
135 return PQCLEAN_SPHINCSHARAKA128FSIMPLE_crypto_sign_signature(
136 sig, siglen, m, mlen, sk);
137 }
138
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const139 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
140 const uint8_t *pk) const override {
141 return PQCLEAN_SPHINCSHARAKA128FSIMPLE_crypto_sign_verify(
142 sig, siglen, m, mlen, pk);
143 }
144
Keygen(uint8_t * pk,uint8_t * sk) const145 int Keygen(uint8_t *pk, uint8_t *sk) const override {
146 return PQCLEAN_SPHINCSHARAKA128FSIMPLE_crypto_sign_keypair(pk, sk);
147 }
148 };
149
150 class SphincsHaraka128SSimplePqclean : public SphincsHelperPqclean {
151 public:
SphincsHaraka128SSimplePqclean()152 SphincsHaraka128SSimplePqclean()
153 : SphincsHelperPqclean(
154 PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_PUBLICKEYBYTES,
155 PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_BYTES) {}
156
157 ~SphincsHaraka128SSimplePqclean() override = default;
158
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const159 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
160 const uint8_t *sk) const override {
161 return PQCLEAN_SPHINCSHARAKA128SSIMPLE_crypto_sign_signature(
162 sig, siglen, m, mlen, sk);
163 }
164
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const165 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
166 const uint8_t *pk) const override {
167 return PQCLEAN_SPHINCSHARAKA128SSIMPLE_crypto_sign_verify(
168 sig, siglen, m, mlen, pk);
169 }
170
Keygen(uint8_t * pk,uint8_t * sk) const171 int Keygen(uint8_t *pk, uint8_t *sk) const override {
172 return PQCLEAN_SPHINCSHARAKA128SSIMPLE_crypto_sign_keypair(pk, sk);
173 }
174 };
175
176 class SphincsHaraka192FRobustPqclean : public SphincsHelperPqclean {
177 public:
SphincsHaraka192FRobustPqclean()178 SphincsHaraka192FRobustPqclean()
179 : SphincsHelperPqclean(
180 PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_PUBLICKEYBYTES,
181 PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_BYTES) {}
182
183 ~SphincsHaraka192FRobustPqclean() override = default;
184
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const185 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
186 const uint8_t *sk) const override {
187 return PQCLEAN_SPHINCSHARAKA192FROBUST_crypto_sign_signature(
188 sig, siglen, m, mlen, sk);
189 }
190
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const191 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
192 const uint8_t *pk) const override {
193 return PQCLEAN_SPHINCSHARAKA192FROBUST_crypto_sign_verify(
194 sig, siglen, m, mlen, pk);
195 }
196
Keygen(uint8_t * pk,uint8_t * sk) const197 int Keygen(uint8_t *pk, uint8_t *sk) const override {
198 return PQCLEAN_SPHINCSHARAKA192FROBUST_crypto_sign_keypair(pk, sk);
199 }
200 };
201
202 class SphincsHaraka192SRobustPqclean : public SphincsHelperPqclean {
203 public:
SphincsHaraka192SRobustPqclean()204 SphincsHaraka192SRobustPqclean()
205 : SphincsHelperPqclean(
206 PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_PUBLICKEYBYTES,
207 PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_BYTES) {}
208
209 ~SphincsHaraka192SRobustPqclean() override = default;
210
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const211 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
212 const uint8_t *sk) const override {
213 return PQCLEAN_SPHINCSHARAKA192SROBUST_crypto_sign_signature(
214 sig, siglen, m, mlen, sk);
215 }
216
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const217 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
218 const uint8_t *pk) const override {
219 return PQCLEAN_SPHINCSHARAKA192SROBUST_crypto_sign_verify(
220 sig, siglen, m, mlen, pk);
221 }
222
Keygen(uint8_t * pk,uint8_t * sk) const223 int Keygen(uint8_t *pk, uint8_t *sk) const override {
224 return PQCLEAN_SPHINCSHARAKA192SROBUST_crypto_sign_keypair(pk, sk);
225 }
226 };
227
228 class SphincsHaraka192FSimplePqclean : public SphincsHelperPqclean {
229 public:
SphincsHaraka192FSimplePqclean()230 SphincsHaraka192FSimplePqclean()
231 : SphincsHelperPqclean(
232 PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_PUBLICKEYBYTES,
233 PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_BYTES) {}
234
235 ~SphincsHaraka192FSimplePqclean() override = default;
236
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const237 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
238 const uint8_t *sk) const override {
239 return PQCLEAN_SPHINCSHARAKA192FSIMPLE_crypto_sign_signature(
240 sig, siglen, m, mlen, sk);
241 }
242
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const243 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
244 const uint8_t *pk) const override {
245 return PQCLEAN_SPHINCSHARAKA192FSIMPLE_crypto_sign_verify(
246 sig, siglen, m, mlen, pk);
247 }
248
Keygen(uint8_t * pk,uint8_t * sk) const249 int Keygen(uint8_t *pk, uint8_t *sk) const override {
250 return PQCLEAN_SPHINCSHARAKA192FSIMPLE_crypto_sign_keypair(pk, sk);
251 }
252 };
253
254 class SphincsHaraka192SSimplePqclean : public SphincsHelperPqclean {
255 public:
SphincsHaraka192SSimplePqclean()256 SphincsHaraka192SSimplePqclean()
257 : SphincsHelperPqclean(
258 PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_PUBLICKEYBYTES,
259 PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_BYTES) {}
260
261 ~SphincsHaraka192SSimplePqclean() override = default;
262
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const263 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
264 const uint8_t *sk) const override {
265 return PQCLEAN_SPHINCSHARAKA192SSIMPLE_crypto_sign_signature(
266 sig, siglen, m, mlen, sk);
267 }
268
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const269 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
270 const uint8_t *pk) const override {
271 return PQCLEAN_SPHINCSHARAKA192SSIMPLE_crypto_sign_verify(
272 sig, siglen, m, mlen, pk);
273 }
274
Keygen(uint8_t * pk,uint8_t * sk) const275 int Keygen(uint8_t *pk, uint8_t *sk) const override {
276 return PQCLEAN_SPHINCSHARAKA192SSIMPLE_crypto_sign_keypair(pk, sk);
277 }
278 };
279
280 class SphincsHaraka256FRobustPqclean : public SphincsHelperPqclean {
281 public:
SphincsHaraka256FRobustPqclean()282 SphincsHaraka256FRobustPqclean()
283 : SphincsHelperPqclean(
284 PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_PUBLICKEYBYTES,
285 PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_BYTES) {}
286
287 ~SphincsHaraka256FRobustPqclean() override = default;
288
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const289 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
290 const uint8_t *sk) const override {
291 return PQCLEAN_SPHINCSHARAKA256FROBUST_crypto_sign_signature(
292 sig, siglen, m, mlen, sk);
293 }
294
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const295 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
296 const uint8_t *pk) const override {
297 return PQCLEAN_SPHINCSHARAKA256FROBUST_crypto_sign_verify(
298 sig, siglen, m, mlen, pk);
299 }
300
Keygen(uint8_t * pk,uint8_t * sk) const301 int Keygen(uint8_t *pk, uint8_t *sk) const override {
302 return PQCLEAN_SPHINCSHARAKA256FROBUST_crypto_sign_keypair(pk, sk);
303 }
304 };
305
306 class SphincsHaraka256SRobustPqclean : public SphincsHelperPqclean {
307 public:
SphincsHaraka256SRobustPqclean()308 SphincsHaraka256SRobustPqclean()
309 : SphincsHelperPqclean(
310 PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_PUBLICKEYBYTES,
311 PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_BYTES) {}
312
313 ~SphincsHaraka256SRobustPqclean() override = default;
314
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const315 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
316 const uint8_t *sk) const override {
317 return PQCLEAN_SPHINCSHARAKA256SROBUST_crypto_sign_signature(
318 sig, siglen, m, mlen, sk);
319 }
320
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const321 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
322 const uint8_t *pk) const override {
323 return PQCLEAN_SPHINCSHARAKA256SROBUST_crypto_sign_verify(
324 sig, siglen, m, mlen, pk);
325 }
326
Keygen(uint8_t * pk,uint8_t * sk) const327 int Keygen(uint8_t *pk, uint8_t *sk) const override {
328 return PQCLEAN_SPHINCSHARAKA256SROBUST_crypto_sign_keypair(pk, sk);
329 }
330 };
331
332 class SphincsHaraka256FSimplePqclean : public SphincsHelperPqclean {
333 public:
SphincsHaraka256FSimplePqclean()334 SphincsHaraka256FSimplePqclean()
335 : SphincsHelperPqclean(
336 PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_PUBLICKEYBYTES,
337 PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_BYTES) {}
338
339 ~SphincsHaraka256FSimplePqclean() override = default;
340
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const341 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
342 const uint8_t *sk) const override {
343 return PQCLEAN_SPHINCSHARAKA256FSIMPLE_crypto_sign_signature(
344 sig, siglen, m, mlen, sk);
345 }
346
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const347 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
348 const uint8_t *pk) const override {
349 return PQCLEAN_SPHINCSHARAKA256FSIMPLE_crypto_sign_verify(
350 sig, siglen, m, mlen, pk);
351 }
352
Keygen(uint8_t * pk,uint8_t * sk) const353 int Keygen(uint8_t *pk, uint8_t *sk) const override {
354 return PQCLEAN_SPHINCSHARAKA256FSIMPLE_crypto_sign_keypair(pk, sk);
355 }
356 };
357
358 class SphincsHaraka256SSimplePqclean : public SphincsHelperPqclean {
359 public:
SphincsHaraka256SSimplePqclean()360 SphincsHaraka256SSimplePqclean()
361 : SphincsHelperPqclean(
362 PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_PUBLICKEYBYTES,
363 PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_BYTES) {}
364
365 ~SphincsHaraka256SSimplePqclean() override = default;
366
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const367 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
368 const uint8_t *sk) const override {
369 return PQCLEAN_SPHINCSHARAKA256SSIMPLE_crypto_sign_signature(
370 sig, siglen, m, mlen, sk);
371 }
372
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const373 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
374 const uint8_t *pk) const override {
375 return PQCLEAN_SPHINCSHARAKA256SSIMPLE_crypto_sign_verify(
376 sig, siglen, m, mlen, pk);
377 }
378
Keygen(uint8_t * pk,uint8_t * sk) const379 int Keygen(uint8_t *pk, uint8_t *sk) const override {
380 return PQCLEAN_SPHINCSHARAKA256SSIMPLE_crypto_sign_keypair(pk, sk);
381 }
382 };
383
384 class SphincsSHA256128FRobustPqclean : public SphincsHelperPqclean {
385 public:
SphincsSHA256128FRobustPqclean()386 SphincsSHA256128FRobustPqclean()
387 : SphincsHelperPqclean(
388 PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_PUBLICKEYBYTES,
389 PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_BYTES) {}
390
391 ~SphincsSHA256128FRobustPqclean() override = default;
392
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const393 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
394 const uint8_t *sk) const override {
395 return PQCLEAN_SPHINCSSHA256128FROBUST_crypto_sign_signature(
396 sig, siglen, m, mlen, sk);
397 }
398
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const399 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
400 const uint8_t *pk) const override {
401 return PQCLEAN_SPHINCSSHA256128FROBUST_crypto_sign_verify(sig, siglen,
402 m, mlen, pk);
403 }
404
Keygen(uint8_t * pk,uint8_t * sk) const405 int Keygen(uint8_t *pk, uint8_t *sk) const override {
406 return PQCLEAN_SPHINCSSHA256128FROBUST_crypto_sign_keypair(pk, sk);
407 }
408 };
409
410 class SphincsSHA256128SRobustPqclean : public SphincsHelperPqclean {
411 public:
SphincsSHA256128SRobustPqclean()412 SphincsSHA256128SRobustPqclean()
413 : SphincsHelperPqclean(
414 PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_PUBLICKEYBYTES,
415 PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_BYTES) {}
416
417 ~SphincsSHA256128SRobustPqclean() override = default;
418
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const419 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
420 const uint8_t *sk) const override {
421 return PQCLEAN_SPHINCSSHA256128SROBUST_crypto_sign_signature(
422 sig, siglen, m, mlen, sk);
423 }
424
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const425 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
426 const uint8_t *pk) const override {
427 return PQCLEAN_SPHINCSSHA256128SROBUST_crypto_sign_verify(sig, siglen,
428 m, mlen, pk);
429 }
430
Keygen(uint8_t * pk,uint8_t * sk) const431 int Keygen(uint8_t *pk, uint8_t *sk) const override {
432 return PQCLEAN_SPHINCSSHA256128SROBUST_crypto_sign_keypair(pk, sk);
433 }
434 };
435
436 class SphincsSHA256128FSimplePqclean : public SphincsHelperPqclean {
437 public:
SphincsSHA256128FSimplePqclean()438 SphincsSHA256128FSimplePqclean()
439 : SphincsHelperPqclean(
440 PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_PUBLICKEYBYTES,
441 PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_BYTES) {}
442
443 ~SphincsSHA256128FSimplePqclean() override = default;
444
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const445 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
446 const uint8_t *sk) const override {
447 return PQCLEAN_SPHINCSSHA256128FSIMPLE_crypto_sign_signature(
448 sig, siglen, m, mlen, sk);
449 }
450
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const451 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
452 const uint8_t *pk) const override {
453 return PQCLEAN_SPHINCSSHA256128FSIMPLE_crypto_sign_verify(sig, siglen,
454 m, mlen, pk);
455 }
456
Keygen(uint8_t * pk,uint8_t * sk) const457 int Keygen(uint8_t *pk, uint8_t *sk) const override {
458 return PQCLEAN_SPHINCSSHA256128FSIMPLE_crypto_sign_keypair(pk, sk);
459 }
460 };
461
462 class SphincsSHA256128SSimplePqclean : public SphincsHelperPqclean {
463 public:
SphincsSHA256128SSimplePqclean()464 SphincsSHA256128SSimplePqclean()
465 : SphincsHelperPqclean(
466 PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_PUBLICKEYBYTES,
467 PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_BYTES) {}
468
469 ~SphincsSHA256128SSimplePqclean() override = default;
470
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const471 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
472 const uint8_t *sk) const override {
473 return PQCLEAN_SPHINCSSHA256128SSIMPLE_crypto_sign_signature(
474 sig, siglen, m, mlen, sk);
475 }
476
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const477 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
478 const uint8_t *pk) const override {
479 return PQCLEAN_SPHINCSSHA256128SSIMPLE_crypto_sign_verify(sig, siglen,
480 m, mlen, pk);
481 }
482
Keygen(uint8_t * pk,uint8_t * sk) const483 int Keygen(uint8_t *pk, uint8_t *sk) const override {
484 return PQCLEAN_SPHINCSSHA256128SSIMPLE_crypto_sign_keypair(pk, sk);
485 }
486 };
487
488 class SphincsSHA256192FRobustPqclean : public SphincsHelperPqclean {
489 public:
SphincsSHA256192FRobustPqclean()490 SphincsSHA256192FRobustPqclean()
491 : SphincsHelperPqclean(
492 PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_PUBLICKEYBYTES,
493 PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_BYTES) {}
494
495 ~SphincsSHA256192FRobustPqclean() override = default;
496
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const497 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
498 const uint8_t *sk) const override {
499 return PQCLEAN_SPHINCSSHA256192FROBUST_crypto_sign_signature(
500 sig, siglen, m, mlen, sk);
501 }
502
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const503 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
504 const uint8_t *pk) const override {
505 return PQCLEAN_SPHINCSSHA256192FROBUST_crypto_sign_verify(sig, siglen,
506 m, mlen, pk);
507 }
508
Keygen(uint8_t * pk,uint8_t * sk) const509 int Keygen(uint8_t *pk, uint8_t *sk) const override {
510 return PQCLEAN_SPHINCSSHA256192FROBUST_crypto_sign_keypair(pk, sk);
511 }
512 };
513
514 class SphincsSHA256192SRobustPqclean : public SphincsHelperPqclean {
515 public:
SphincsSHA256192SRobustPqclean()516 SphincsSHA256192SRobustPqclean()
517 : SphincsHelperPqclean(
518 PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_PUBLICKEYBYTES,
519 PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_BYTES) {}
520
521 ~SphincsSHA256192SRobustPqclean() override = default;
522
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const523 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
524 const uint8_t *sk) const override {
525 return PQCLEAN_SPHINCSSHA256192SROBUST_crypto_sign_signature(
526 sig, siglen, m, mlen, sk);
527 }
528
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const529 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
530 const uint8_t *pk) const override {
531 return PQCLEAN_SPHINCSSHA256192SROBUST_crypto_sign_verify(sig, siglen,
532 m, mlen, pk);
533 }
534
Keygen(uint8_t * pk,uint8_t * sk) const535 int Keygen(uint8_t *pk, uint8_t *sk) const override {
536 return PQCLEAN_SPHINCSSHA256192SROBUST_crypto_sign_keypair(pk, sk);
537 }
538 };
539
540 class SphincsSHA256192FSimplePqclean : public SphincsHelperPqclean {
541 public:
SphincsSHA256192FSimplePqclean()542 SphincsSHA256192FSimplePqclean()
543 : SphincsHelperPqclean(
544 PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_PUBLICKEYBYTES,
545 PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_BYTES) {}
546
547 ~SphincsSHA256192FSimplePqclean() override = default;
548
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const549 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
550 const uint8_t *sk) const override {
551 return PQCLEAN_SPHINCSSHA256192FSIMPLE_crypto_sign_signature(
552 sig, siglen, m, mlen, sk);
553 }
554
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const555 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
556 const uint8_t *pk) const override {
557 return PQCLEAN_SPHINCSSHA256192FSIMPLE_crypto_sign_verify(sig, siglen,
558 m, mlen, pk);
559 }
560
Keygen(uint8_t * pk,uint8_t * sk) const561 int Keygen(uint8_t *pk, uint8_t *sk) const override {
562 return PQCLEAN_SPHINCSSHA256192FSIMPLE_crypto_sign_keypair(pk, sk);
563 }
564 };
565
566 class SphincsSHA256192SSimplePqclean : public SphincsHelperPqclean {
567 public:
SphincsSHA256192SSimplePqclean()568 SphincsSHA256192SSimplePqclean()
569 : SphincsHelperPqclean(
570 PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_PUBLICKEYBYTES,
571 PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_BYTES) {}
572
573 ~SphincsSHA256192SSimplePqclean() override = default;
574
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const575 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
576 const uint8_t *sk) const override {
577 return PQCLEAN_SPHINCSSHA256192SSIMPLE_crypto_sign_signature(
578 sig, siglen, m, mlen, sk);
579 }
580
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const581 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
582 const uint8_t *pk) const override {
583 return PQCLEAN_SPHINCSSHA256192SSIMPLE_crypto_sign_verify(sig, siglen,
584 m, mlen, pk);
585 }
586
Keygen(uint8_t * pk,uint8_t * sk) const587 int Keygen(uint8_t *pk, uint8_t *sk) const override {
588 return PQCLEAN_SPHINCSSHA256192SSIMPLE_crypto_sign_keypair(pk, sk);
589 }
590 };
591
592 class SphincsSHA256256FRobustPqclean : public SphincsHelperPqclean {
593 public:
SphincsSHA256256FRobustPqclean()594 SphincsSHA256256FRobustPqclean()
595 : SphincsHelperPqclean(
596 PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_PUBLICKEYBYTES,
597 PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_BYTES) {}
598
599 ~SphincsSHA256256FRobustPqclean() override = default;
600
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const601 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
602 const uint8_t *sk) const override {
603 return PQCLEAN_SPHINCSSHA256256FROBUST_crypto_sign_signature(
604 sig, siglen, m, mlen, sk);
605 }
606
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const607 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
608 const uint8_t *pk) const override {
609 return PQCLEAN_SPHINCSSHA256256FROBUST_crypto_sign_verify(sig, siglen,
610 m, mlen, pk);
611 }
612
Keygen(uint8_t * pk,uint8_t * sk) const613 int Keygen(uint8_t *pk, uint8_t *sk) const override {
614 return PQCLEAN_SPHINCSSHA256256FROBUST_crypto_sign_keypair(pk, sk);
615 }
616 };
617
618 class SphincsSHA256256SRobustPqclean : public SphincsHelperPqclean {
619 public:
SphincsSHA256256SRobustPqclean()620 SphincsSHA256256SRobustPqclean()
621 : SphincsHelperPqclean(
622 PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_PUBLICKEYBYTES,
623 PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_BYTES) {}
624
625 ~SphincsSHA256256SRobustPqclean() override = default;
626
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const627 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
628 const uint8_t *sk) const override {
629 return PQCLEAN_SPHINCSSHA256256SROBUST_crypto_sign_signature(
630 sig, siglen, m, mlen, sk);
631 }
632
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const633 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
634 const uint8_t *pk) const override {
635 return PQCLEAN_SPHINCSSHA256256SROBUST_crypto_sign_verify(sig, siglen,
636 m, mlen, pk);
637 }
638
Keygen(uint8_t * pk,uint8_t * sk) const639 int Keygen(uint8_t *pk, uint8_t *sk) const override {
640 return PQCLEAN_SPHINCSSHA256256SROBUST_crypto_sign_keypair(pk, sk);
641 }
642 };
643
644 class SphincsSHA256256FSimplePqclean : public SphincsHelperPqclean {
645 public:
SphincsSHA256256FSimplePqclean()646 SphincsSHA256256FSimplePqclean()
647 : SphincsHelperPqclean(
648 PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_PUBLICKEYBYTES,
649 PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_BYTES) {}
650
651 ~SphincsSHA256256FSimplePqclean() override = default;
652
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const653 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
654 const uint8_t *sk) const override {
655 return PQCLEAN_SPHINCSSHA256256FSIMPLE_crypto_sign_signature(
656 sig, siglen, m, mlen, sk);
657 }
658
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const659 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
660 const uint8_t *pk) const override {
661 return PQCLEAN_SPHINCSSHA256256FSIMPLE_crypto_sign_verify(sig, siglen,
662 m, mlen, pk);
663 }
664
Keygen(uint8_t * pk,uint8_t * sk) const665 int Keygen(uint8_t *pk, uint8_t *sk) const override {
666 return PQCLEAN_SPHINCSSHA256256FSIMPLE_crypto_sign_keypair(pk, sk);
667 }
668 };
669
670 class SphincsSHA256256SSimplePqclean : public SphincsHelperPqclean {
671 public:
SphincsSHA256256SSimplePqclean()672 SphincsSHA256256SSimplePqclean()
673 : SphincsHelperPqclean(
674 PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_PUBLICKEYBYTES,
675 PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_BYTES) {}
676
677 ~SphincsSHA256256SSimplePqclean() override = default;
678
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const679 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
680 const uint8_t *sk) const override {
681 return PQCLEAN_SPHINCSSHA256256SSIMPLE_crypto_sign_signature(
682 sig, siglen, m, mlen, sk);
683 }
684
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const685 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
686 const uint8_t *pk) const override {
687 return PQCLEAN_SPHINCSSHA256256SSIMPLE_crypto_sign_verify(sig, siglen,
688 m, mlen, pk);
689 }
690
Keygen(uint8_t * pk,uint8_t * sk) const691 int Keygen(uint8_t *pk, uint8_t *sk) const override {
692 return PQCLEAN_SPHINCSSHA256256SSIMPLE_crypto_sign_keypair(pk, sk);
693 }
694 };
695
696 class SphincsSHAKE256128FRobustPqclean : public SphincsHelperPqclean {
697 public:
SphincsSHAKE256128FRobustPqclean()698 SphincsSHAKE256128FRobustPqclean()
699 : SphincsHelperPqclean(
700 PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_PUBLICKEYBYTES,
701 PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_BYTES) {}
702
703 ~SphincsSHAKE256128FRobustPqclean() override = default;
704
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const705 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
706 const uint8_t *sk) const override {
707 return PQCLEAN_SPHINCSSHAKE256128FROBUST_crypto_sign_signature(
708 sig, siglen, m, mlen, sk);
709 }
710
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const711 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
712 const uint8_t *pk) const override {
713 return PQCLEAN_SPHINCSSHAKE256128FROBUST_crypto_sign_verify(
714 sig, siglen, m, mlen, pk);
715 }
716
Keygen(uint8_t * pk,uint8_t * sk) const717 int Keygen(uint8_t *pk, uint8_t *sk) const override {
718 return PQCLEAN_SPHINCSSHAKE256128FROBUST_crypto_sign_keypair(pk, sk);
719 }
720 };
721
722 class SphincsSHAKE256128SRobustPqclean : public SphincsHelperPqclean {
723 public:
SphincsSHAKE256128SRobustPqclean()724 SphincsSHAKE256128SRobustPqclean()
725 : SphincsHelperPqclean(
726 PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_PUBLICKEYBYTES,
727 PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_BYTES) {}
728
729 ~SphincsSHAKE256128SRobustPqclean() override = default;
730
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const731 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
732 const uint8_t *sk) const override {
733 return PQCLEAN_SPHINCSSHAKE256128SROBUST_crypto_sign_signature(
734 sig, siglen, m, mlen, sk);
735 }
736
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const737 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
738 const uint8_t *pk) const override {
739 return PQCLEAN_SPHINCSSHAKE256128SROBUST_crypto_sign_verify(
740 sig, siglen, m, mlen, pk);
741 }
742
Keygen(uint8_t * pk,uint8_t * sk) const743 int Keygen(uint8_t *pk, uint8_t *sk) const override {
744 return PQCLEAN_SPHINCSSHAKE256128SROBUST_crypto_sign_keypair(pk, sk);
745 }
746 };
747
748 class SphincsSHAKE256128FSimplePqclean : public SphincsHelperPqclean {
749 public:
SphincsSHAKE256128FSimplePqclean()750 SphincsSHAKE256128FSimplePqclean()
751 : SphincsHelperPqclean(
752 PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_PUBLICKEYBYTES,
753 PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_BYTES) {}
754
755 ~SphincsSHAKE256128FSimplePqclean() override = default;
756
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const757 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
758 const uint8_t *sk) const override {
759 return PQCLEAN_SPHINCSSHAKE256128FSIMPLE_crypto_sign_signature(
760 sig, siglen, m, mlen, sk);
761 }
762
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const763 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
764 const uint8_t *pk) const override {
765 return PQCLEAN_SPHINCSSHAKE256128FSIMPLE_crypto_sign_verify(
766 sig, siglen, m, mlen, pk);
767 }
768
Keygen(uint8_t * pk,uint8_t * sk) const769 int Keygen(uint8_t *pk, uint8_t *sk) const override {
770 return PQCLEAN_SPHINCSSHAKE256128FSIMPLE_crypto_sign_keypair(pk, sk);
771 }
772 };
773
774 class SphincsSHAKE256128SSimplePqclean : public SphincsHelperPqclean {
775 public:
SphincsSHAKE256128SSimplePqclean()776 SphincsSHAKE256128SSimplePqclean()
777 : SphincsHelperPqclean(
778 PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_PUBLICKEYBYTES,
779 PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_BYTES) {}
780
781 ~SphincsSHAKE256128SSimplePqclean() override = default;
782
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const783 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
784 const uint8_t *sk) const override {
785 return PQCLEAN_SPHINCSSHAKE256128SSIMPLE_crypto_sign_signature(
786 sig, siglen, m, mlen, sk);
787 }
788
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const789 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
790 const uint8_t *pk) const override {
791 return PQCLEAN_SPHINCSSHAKE256128SSIMPLE_crypto_sign_verify(
792 sig, siglen, m, mlen, pk);
793 }
794
Keygen(uint8_t * pk,uint8_t * sk) const795 int Keygen(uint8_t *pk, uint8_t *sk) const override {
796 return PQCLEAN_SPHINCSSHAKE256128SSIMPLE_crypto_sign_keypair(pk, sk);
797 }
798 };
799
800 class SphincsSHAKE256192FRobustPqclean : public SphincsHelperPqclean {
801 public:
SphincsSHAKE256192FRobustPqclean()802 SphincsSHAKE256192FRobustPqclean()
803 : SphincsHelperPqclean(
804 PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_PUBLICKEYBYTES,
805 PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_BYTES) {}
806
807 ~SphincsSHAKE256192FRobustPqclean() override = default;
808
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const809 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
810 const uint8_t *sk) const override {
811 return PQCLEAN_SPHINCSSHAKE256192FROBUST_crypto_sign_signature(
812 sig, siglen, m, mlen, sk);
813 }
814
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const815 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
816 const uint8_t *pk) const override {
817 return PQCLEAN_SPHINCSSHAKE256192FROBUST_crypto_sign_verify(
818 sig, siglen, m, mlen, pk);
819 }
820
Keygen(uint8_t * pk,uint8_t * sk) const821 int Keygen(uint8_t *pk, uint8_t *sk) const override {
822 return PQCLEAN_SPHINCSSHAKE256192FROBUST_crypto_sign_keypair(pk, sk);
823 }
824 };
825
826 class SphincsSHAKE256192SRobustPqclean : public SphincsHelperPqclean {
827 public:
SphincsSHAKE256192SRobustPqclean()828 SphincsSHAKE256192SRobustPqclean()
829 : SphincsHelperPqclean(
830 PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_PUBLICKEYBYTES,
831 PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_BYTES) {}
832
833 ~SphincsSHAKE256192SRobustPqclean() override = default;
834
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const835 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
836 const uint8_t *sk) const override {
837 return PQCLEAN_SPHINCSSHAKE256192SROBUST_crypto_sign_signature(
838 sig, siglen, m, mlen, sk);
839 }
840
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const841 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
842 const uint8_t *pk) const override {
843 return PQCLEAN_SPHINCSSHAKE256192SROBUST_crypto_sign_verify(
844 sig, siglen, m, mlen, pk);
845 }
846
Keygen(uint8_t * pk,uint8_t * sk) const847 int Keygen(uint8_t *pk, uint8_t *sk) const override {
848 return PQCLEAN_SPHINCSSHAKE256192SROBUST_crypto_sign_keypair(pk, sk);
849 }
850 };
851
852 class SphincsSHAKE256192FSimplePqclean : public SphincsHelperPqclean {
853 public:
SphincsSHAKE256192FSimplePqclean()854 SphincsSHAKE256192FSimplePqclean()
855 : SphincsHelperPqclean(
856 PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_PUBLICKEYBYTES,
857 PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_BYTES) {}
858
859 ~SphincsSHAKE256192FSimplePqclean() override = default;
860
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const861 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
862 const uint8_t *sk) const override {
863 return PQCLEAN_SPHINCSSHAKE256192FSIMPLE_crypto_sign_signature(
864 sig, siglen, m, mlen, sk);
865 }
866
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const867 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
868 const uint8_t *pk) const override {
869 return PQCLEAN_SPHINCSSHAKE256192FSIMPLE_crypto_sign_verify(
870 sig, siglen, m, mlen, pk);
871 }
872
Keygen(uint8_t * pk,uint8_t * sk) const873 int Keygen(uint8_t *pk, uint8_t *sk) const override {
874 return PQCLEAN_SPHINCSSHAKE256192FSIMPLE_crypto_sign_keypair(pk, sk);
875 }
876 };
877
878 class SphincsSHAKE256192SSimplePqclean : public SphincsHelperPqclean {
879 public:
SphincsSHAKE256192SSimplePqclean()880 SphincsSHAKE256192SSimplePqclean()
881 : SphincsHelperPqclean(
882 PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_PUBLICKEYBYTES,
883 PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_BYTES) {}
884
885 ~SphincsSHAKE256192SSimplePqclean() override = default;
886
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const887 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
888 const uint8_t *sk) const override {
889 return PQCLEAN_SPHINCSSHAKE256192SSIMPLE_crypto_sign_signature(
890 sig, siglen, m, mlen, sk);
891 }
892
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const893 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
894 const uint8_t *pk) const override {
895 return PQCLEAN_SPHINCSSHAKE256192SSIMPLE_crypto_sign_verify(
896 sig, siglen, m, mlen, pk);
897 }
898
Keygen(uint8_t * pk,uint8_t * sk) const899 int Keygen(uint8_t *pk, uint8_t *sk) const override {
900 return PQCLEAN_SPHINCSSHAKE256192SSIMPLE_crypto_sign_keypair(pk, sk);
901 }
902 };
903
904 class SphincsSHAKE256256FRobustPqclean : public SphincsHelperPqclean {
905 public:
SphincsSHAKE256256FRobustPqclean()906 SphincsSHAKE256256FRobustPqclean()
907 : SphincsHelperPqclean(
908 PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_PUBLICKEYBYTES,
909 PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_BYTES) {}
910
911 ~SphincsSHAKE256256FRobustPqclean() override = default;
912
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const913 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
914 const uint8_t *sk) const override {
915 return PQCLEAN_SPHINCSSHAKE256256FROBUST_crypto_sign_signature(
916 sig, siglen, m, mlen, sk);
917 }
918
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const919 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
920 const uint8_t *pk) const override {
921 return PQCLEAN_SPHINCSSHAKE256256FROBUST_crypto_sign_verify(
922 sig, siglen, m, mlen, pk);
923 }
924
Keygen(uint8_t * pk,uint8_t * sk) const925 int Keygen(uint8_t *pk, uint8_t *sk) const override {
926 return PQCLEAN_SPHINCSSHAKE256256FROBUST_crypto_sign_keypair(pk, sk);
927 }
928 };
929
930 class SphincsSHAKE256256SRobustPqclean : public SphincsHelperPqclean {
931 public:
SphincsSHAKE256256SRobustPqclean()932 SphincsSHAKE256256SRobustPqclean()
933 : SphincsHelperPqclean(
934 PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_PUBLICKEYBYTES,
935 PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_BYTES) {}
936
937 ~SphincsSHAKE256256SRobustPqclean() override = default;
938
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const939 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
940 const uint8_t *sk) const override {
941 return PQCLEAN_SPHINCSSHAKE256256SROBUST_crypto_sign_signature(
942 sig, siglen, m, mlen, sk);
943 }
944
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const945 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
946 const uint8_t *pk) const override {
947 return PQCLEAN_SPHINCSSHAKE256256SROBUST_crypto_sign_verify(
948 sig, siglen, m, mlen, pk);
949 }
950
Keygen(uint8_t * pk,uint8_t * sk) const951 int Keygen(uint8_t *pk, uint8_t *sk) const override {
952 return PQCLEAN_SPHINCSSHAKE256256SROBUST_crypto_sign_keypair(pk, sk);
953 }
954 };
955
956 class SphincsSHAKE256256FSimplePqclean : public SphincsHelperPqclean {
957 public:
SphincsSHAKE256256FSimplePqclean()958 SphincsSHAKE256256FSimplePqclean()
959 : SphincsHelperPqclean(
960 PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_PUBLICKEYBYTES,
961 PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_BYTES) {}
962
963 ~SphincsSHAKE256256FSimplePqclean() override = default;
964
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const965 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
966 const uint8_t *sk) const override {
967 return PQCLEAN_SPHINCSSHAKE256256FSIMPLE_crypto_sign_signature(
968 sig, siglen, m, mlen, sk);
969 }
970
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const971 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
972 const uint8_t *pk) const override {
973 return PQCLEAN_SPHINCSSHAKE256256FSIMPLE_crypto_sign_verify(
974 sig, siglen, m, mlen, pk);
975 }
976
Keygen(uint8_t * pk,uint8_t * sk) const977 int Keygen(uint8_t *pk, uint8_t *sk) const override {
978 return PQCLEAN_SPHINCSSHAKE256256FSIMPLE_crypto_sign_keypair(pk, sk);
979 }
980 };
981
982 class SphincsSHAKE256256SSimplePqclean : public SphincsHelperPqclean {
983 public:
SphincsSHAKE256256SSimplePqclean()984 SphincsSHAKE256256SSimplePqclean()
985 : SphincsHelperPqclean(
986 PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_PUBLICKEYBYTES,
987 PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_BYTES) {}
988
989 ~SphincsSHAKE256256SSimplePqclean() override = default;
990
Sign(uint8_t * sig,size_t * siglen,const uint8_t * m,size_t mlen,const uint8_t * sk) const991 int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
992 const uint8_t *sk) const override {
993 return PQCLEAN_SPHINCSSHAKE256256SSIMPLE_crypto_sign_signature(
994 sig, siglen, m, mlen, sk);
995 }
996
Verify(const uint8_t * sig,size_t siglen,const uint8_t * m,size_t mlen,const uint8_t * pk) const997 int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
998 const uint8_t *pk) const override {
999 return PQCLEAN_SPHINCSSHAKE256256SSIMPLE_crypto_sign_verify(
1000 sig, siglen, m, mlen, pk);
1001 }
1002
Keygen(uint8_t * pk,uint8_t * sk) const1003 int Keygen(uint8_t *pk, uint8_t *sk) const override {
1004 return PQCLEAN_SPHINCSSHAKE256256SSIMPLE_crypto_sign_keypair(pk, sk);
1005 }
1006 };
1007
1008 std::vector<std::unique_ptr<SphincsHelperPqclean>>
GetSphincsPqcleanHelperArray()1009 GetSphincsPqcleanHelperArray() {
1010 std::vector<std::unique_ptr<SphincsHelperPqclean>> sphincs_helper_pqclean;
1011
1012 sphincs_helper_pqclean.push_back(
1013 absl::make_unique<SphincsHaraka128FRobustPqclean>());
1014 sphincs_helper_pqclean.push_back(
1015 absl::make_unique<SphincsHaraka128SRobustPqclean>());
1016 sphincs_helper_pqclean.push_back(
1017 absl::make_unique<SphincsHaraka128FSimplePqclean>());
1018 sphincs_helper_pqclean.push_back(
1019 absl::make_unique<SphincsHaraka128SSimplePqclean>());
1020 sphincs_helper_pqclean.push_back(
1021 absl::make_unique<SphincsHaraka192FRobustPqclean>());
1022 sphincs_helper_pqclean.push_back(
1023 absl::make_unique<SphincsHaraka192SRobustPqclean>());
1024 sphincs_helper_pqclean.push_back(
1025 absl::make_unique<SphincsHaraka192FSimplePqclean>());
1026 sphincs_helper_pqclean.push_back(
1027 absl::make_unique<SphincsHaraka192SSimplePqclean>());
1028 sphincs_helper_pqclean.push_back(
1029 absl::make_unique<SphincsHaraka256FRobustPqclean>());
1030 sphincs_helper_pqclean.push_back(
1031 absl::make_unique<SphincsHaraka256SRobustPqclean>());
1032 sphincs_helper_pqclean.push_back(
1033 absl::make_unique<SphincsHaraka256FSimplePqclean>());
1034 sphincs_helper_pqclean.push_back(
1035 absl::make_unique<SphincsHaraka256SSimplePqclean>());
1036
1037 sphincs_helper_pqclean.push_back(
1038 absl::make_unique<SphincsSHA256128FRobustPqclean>());
1039 sphincs_helper_pqclean.push_back(
1040 absl::make_unique<SphincsSHA256128SRobustPqclean>());
1041 sphincs_helper_pqclean.push_back(
1042 absl::make_unique<SphincsSHA256128FSimplePqclean>());
1043 sphincs_helper_pqclean.push_back(
1044 absl::make_unique<SphincsSHA256128SSimplePqclean>());
1045 sphincs_helper_pqclean.push_back(
1046 absl::make_unique<SphincsSHA256192FRobustPqclean>());
1047 sphincs_helper_pqclean.push_back(
1048 absl::make_unique<SphincsSHA256192SRobustPqclean>());
1049 sphincs_helper_pqclean.push_back(
1050 absl::make_unique<SphincsSHA256192FSimplePqclean>());
1051 sphincs_helper_pqclean.push_back(
1052 absl::make_unique<SphincsSHA256192SSimplePqclean>());
1053 sphincs_helper_pqclean.push_back(
1054 absl::make_unique<SphincsSHA256256FRobustPqclean>());
1055 sphincs_helper_pqclean.push_back(
1056 absl::make_unique<SphincsSHA256256SRobustPqclean>());
1057 sphincs_helper_pqclean.push_back(
1058 absl::make_unique<SphincsSHA256256FSimplePqclean>());
1059 sphincs_helper_pqclean.push_back(
1060 absl::make_unique<SphincsSHA256256SSimplePqclean>());
1061
1062 sphincs_helper_pqclean.push_back(
1063 absl::make_unique<SphincsSHAKE256128FRobustPqclean>());
1064 sphincs_helper_pqclean.push_back(
1065 absl::make_unique<SphincsSHAKE256128SRobustPqclean>());
1066 sphincs_helper_pqclean.push_back(
1067 absl::make_unique<SphincsSHAKE256128FSimplePqclean>());
1068 sphincs_helper_pqclean.push_back(
1069 absl::make_unique<SphincsSHAKE256128SSimplePqclean>());
1070 sphincs_helper_pqclean.push_back(
1071 absl::make_unique<SphincsSHAKE256192FRobustPqclean>());
1072 sphincs_helper_pqclean.push_back(
1073 absl::make_unique<SphincsSHAKE256192SRobustPqclean>());
1074 sphincs_helper_pqclean.push_back(
1075 absl::make_unique<SphincsSHAKE256192FSimplePqclean>());
1076 sphincs_helper_pqclean.push_back(
1077 absl::make_unique<SphincsSHAKE256192SSimplePqclean>());
1078 sphincs_helper_pqclean.push_back(
1079 absl::make_unique<SphincsSHAKE256256FRobustPqclean>());
1080 sphincs_helper_pqclean.push_back(
1081 absl::make_unique<SphincsSHAKE256256SRobustPqclean>());
1082 sphincs_helper_pqclean.push_back(
1083 absl::make_unique<SphincsSHAKE256256FSimplePqclean>());
1084 sphincs_helper_pqclean.push_back(
1085 absl::make_unique<SphincsSHAKE256256SSimplePqclean>());
1086
1087 return sphincs_helper_pqclean;
1088 }
1089
GetSphincsHelperPqclean(int hash_type,int variant,int key_size,int signature_length)1090 const SphincsHelperPqclean &GetSphincsHelperPqclean(int hash_type, int variant,
1091 int key_size,
1092 int signature_length) {
1093 static std::vector<std::unique_ptr<SphincsHelperPqclean>>
1094 *sphincs_helper_pqclean = new std::vector(GetSphincsPqcleanHelperArray());
1095
1096 // Note that we have to adjust the enum values for hash_type, variant and
1097 // signature_length to start at 0. In the proto the 0 entry is for UNSPECIFIED
1098 // values, but here we require the valid enum values to start at index 0.
1099 return *sphincs_helper_pqclean->at(
1100 (hash_type - 1) * NUM_VARIANTS * NUM_KEY_SIZES * NUM_SIG_LENGTHS +
1101 key_size * NUM_VARIANTS * NUM_SIG_LENGTHS +
1102 (variant - 1) * NUM_SIG_LENGTHS + (signature_length - 1));
1103 }
1104
1105 } // namespace subtle
1106 } // namespace tink
1107 } // namespace crypto
1108