| // Copyright 2021 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| #include "tink/experimental/pqcrypto/signature/sphincs_key_template.h" |
| |
| #include "tink/util/constants.h" |
| #include "proto/experimental/pqcrypto/sphincs.pb.h" |
| #include "proto/tink.pb.h" |
| |
| extern "C" { |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h" |
| #include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h" |
| } |
| |
| namespace crypto { |
| namespace tink { |
| namespace { |
| |
| using google::crypto::tink::KeyTemplate; |
| using google::crypto::tink::OutputPrefixType; |
| using ::google::crypto::tink::SphincsHashType; |
| using ::google::crypto::tink::SphincsKeyFormat; |
| using ::google::crypto::tink::SphincsParams; |
| using ::google::crypto::tink::SphincsPrivateKey; |
| using ::google::crypto::tink::SphincsSignatureType; |
| using ::google::crypto::tink::SphincsVariant; |
| |
| KeyTemplate* NewSphincsKeyTemplate(int32_t private_key_size, |
| SphincsHashType hash_type, |
| SphincsVariant variant, |
| SphincsSignatureType type) { |
| KeyTemplate* key_template = new KeyTemplate; |
| key_template->set_type_url( |
| absl::StrCat(kTypeGoogleapisCom, SphincsPrivateKey().GetTypeName())); |
| key_template->set_output_prefix_type(OutputPrefixType::TINK); |
| |
| SphincsKeyFormat key_format; |
| SphincsParams* params = key_format.mutable_params(); |
| params->set_key_size(private_key_size); |
| params->set_hash_type(hash_type); |
| params->set_variant(variant); |
| params->set_sig_length_type(type); |
| key_format.SerializeToString(key_template->mutable_value()); |
| |
| return key_template; |
| } |
| |
| } // anonymous namespace |
| |
| // HARAKA |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_128_F_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::ROBUST, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_128_F_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::SIMPLE, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_128_S_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::ROBUST, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_128_S_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::SIMPLE, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_192_F_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::ROBUST, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_192_F_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::SIMPLE, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_192_S_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::ROBUST, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_192_S_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::SIMPLE, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_256_F_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::ROBUST, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_256_F_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::SIMPLE, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_256_S_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::ROBUST, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Haraka_256_S_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::HARAKA, SphincsVariant::SIMPLE, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| // SHA256 |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_128_F_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::ROBUST, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_128_F_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_128_S_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::ROBUST, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_128_S_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_192_F_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::ROBUST, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_192_F_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_192_S_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::ROBUST, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_192_S_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_256_F_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::ROBUST, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_256_F_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_256_S_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::ROBUST, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Sha256_256_S_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHA256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| // SHAKE256 |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_128_F_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::ROBUST, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_128_F_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_128_S_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::ROBUST, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_128_S_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_192_F_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::ROBUST, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_192_F_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_192_S_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::ROBUST, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_192_S_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_256_F_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::ROBUST, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_256_F_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::FAST_SIGNING); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_256_S_Robust_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::ROBUST, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| const google::crypto::tink::KeyTemplate& |
| Sphincs_Shake256_256_S_Simple_KeyTemplate() { |
| static const KeyTemplate* key_template = NewSphincsKeyTemplate( |
| PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES, |
| SphincsHashType::SHAKE256, SphincsVariant::SIMPLE, |
| SphincsSignatureType::SMALL_SIGNATURE); |
| return *key_template; |
| } |
| |
| } // namespace tink |
| } // namespace crypto |
