From 4ef190429667e2aad728e7e9d098cac2af84e34b Mon Sep 17 00:00:00 2001 From: sfluhrer Date: Tue, 14 Jun 2022 14:08:44 -0400 Subject: [PATCH 1/3] Rename We're changing the names of the parameter sets: SHA256 -> SHA2 SHAKE256 -> SHAKE --- api.h | 182 ++++++++++++++++++++++---------------------- internal.h | 8 +- sha256_hash.cpp | 22 +++--- sha256_robust.cpp | 22 +++--- sha256_simple.cpp | 8 +- sha512_hash.cpp | 18 ++--- sha512_robust.cpp | 32 ++++---- sha512_simple.cpp | 16 ++-- shake256_hash.cpp | 18 ++--- shake256_robust.cpp | 6 +- shake256_simple.cpp | 6 +- test_keygen.cpp | 48 ++++++------ test_sign.cpp | 48 ++++++------ test_testvector.cpp | 52 ++++++------- test_thread.cpp | 48 ++++++------ test_verify.cpp | 48 ++++++------ 16 files changed, 291 insertions(+), 291 deletions(-) diff --git a/api.h b/api.h index 5f77370..6fc6713 100644 --- a/api.h +++ b/api.h @@ -328,7 +328,7 @@ class key { /// This is the log2 of the number of hashes we can compute in parallel virtual unsigned num_log_track(void) = 0; - // Pointers into the addr structure that we use; SHA-256 + // Pointers into the addr structure that we use; SHA-2 // uses a different (shorter) addr structure unsigned offset_layer, offset_tree, offset_type; unsigned offset_kp_addr1, offset_kp_addr2; @@ -533,8 +533,8 @@ class key { }; /// -/// This abstract class is for SHA256-based parameter sets -class sha256_hash : public key { +/// This abstract class is for SHA2-based parameter sets +class sha2_hash : public key { protected: /// This precomputes the intermediate state of the public seed (so /// we don't have to recompute it everytime we need it). @@ -553,7 +553,7 @@ class sha256_hash : public key { const unsigned char *msg, size_t len_msg ); // These are implementations of the prf_msg/h_msg functions - // that use SHA512 internally. It is used by the SHA256-L3, L5 + // that use SHA512 internally. It is used by the SHA2-L3, L5 // parameter sets, in this class so that child L5 classes // can redirect the virtual functions to these void prf_msg_512( unsigned char *result, @@ -569,16 +569,16 @@ class sha256_hash : public key { virtual unsigned num_track(void); virtual unsigned num_log_track(void); - sha256_hash(void); + sha2_hash(void); public: virtual void set_public_key(const unsigned char *public_key); virtual void set_private_key(const unsigned char *private_key); }; -/// This abstract class is for SHAKE256-based parameter sets -class shake256_hash : public key { +/// This abstract class is for SHAKE2-based parameter sets +class shake_hash : public key { protected: - SHAKE256_PRECOMPUTE pre_pub_seed; //!< The prehashed public seed + SHAKE256_PRECOMPUTE pre_pub_seed; //!< The SHA256 prehashed public seed virtual unsigned num_track(void); virtual unsigned num_log_track(void); @@ -619,8 +619,8 @@ class haraka_hash : public key { virtual void set_private_key(const unsigned char *private_key); }; -/// This abstract class is for SHA256-simple-based parameter sets -class key_sha256_simple : public sha256_hash { +/// This abstract class is for SHA2-simple-based parameter sets +class key_sha2_simple : public sha2_hash { protected: virtual void thash(unsigned char *out, const unsigned char *in, @@ -631,8 +631,8 @@ class key_sha256_simple : public sha256_hash { }; -/// This abstract class is for SHA256-robust-based parameter sets -class key_sha256_robust : public sha256_hash { +/// This abstract class is for SHA2-robust-based parameter sets +class key_sha2_robust : public sha2_hash { protected: virtual void thash(unsigned char *out, const unsigned char *in, @@ -641,8 +641,8 @@ class key_sha256_robust : public sha256_hash { unsigned char **in, unsigned int inblocks, addr_t* addrxn); }; -// And the L3, L5 versions of the SHA256 parameter sets -class key_sha256_L35_simple : public key_sha256_simple { +// And the L3, L5 versions of the SHA2 parameter sets +class key_sha2_L35_simple : public key_sha2_simple { /// The prehashed public seed for SHA-512 uint64_t state_seeded_512[8]; @@ -667,7 +667,7 @@ class key_sha256_L35_simple : public key_sha256_simple { const unsigned char *r, const unsigned char *msg, size_t len_msg ); }; -class key_sha256_L35_robust : public key_sha256_robust { +class key_sha2_L35_robust : public key_sha2_robust { /// The prehashed public seed for SHA-512 uint64_t state_seeded_512[8]; @@ -693,8 +693,8 @@ class key_sha256_L35_robust : public key_sha256_robust { const unsigned char *msg, size_t len_msg ); }; -/// This abstract class is for SHAKE256-simple-based parameter sets -class key_shake256_simple : public shake256_hash { +/// This abstract class is for SHAKE-simple-based parameter sets +class key_shake_simple : public shake_hash { protected: virtual void thash(unsigned char *out, const unsigned char *in, @@ -704,8 +704,8 @@ class key_shake256_simple : public shake256_hash { unsigned int inblocks, addr_t* addrxn); }; -/// This abstract class is for SHAKE256-robust-based parameter sets -class key_shake256_robust : public shake256_hash { +/// This abstract class is for SHAKE-robust-based parameter sets +class key_shake_robust : public shake_hash { protected: virtual void thash(unsigned char *out, const unsigned char *in, @@ -744,148 +744,148 @@ class key_haraka_robust : public haraka_hash { // // And now the individual parameter set classes -/// The class for keys with the SHA256 simple 128F parameter set -class key_sha256_128f_simple : public key_sha256_simple { +/// The class for keys with the SHA2 simple 128F parameter set +class key_sha2_128f_simple : public key_sha2_simple { public: - key_sha256_128f_simple(void) { set_128f(); } + key_sha2_128f_simple(void) { set_128f(); } }; -/// The class for keys with the SHA256 robust 128F parameter set -class key_sha256_128f_robust : public key_sha256_robust { +/// The class for keys with the SHA2 robust 128F parameter set +class key_sha2_128f_robust : public key_sha2_robust { public: - key_sha256_128f_robust(void) { set_128f(); } + key_sha2_128f_robust(void) { set_128f(); } }; -/// The class for keys with the SHA256 simple 128S parameter set -class key_sha256_128s_simple : public key_sha256_simple { +/// The class for keys with the SHA2 simple 128S parameter set +class key_sha2_128s_simple : public key_sha2_simple { public: - key_sha256_128s_simple(void) { set_128s(); } + key_sha2_128s_simple(void) { set_128s(); } }; -/// The class for keys with the SHA256 robust 128S parameter set -class key_sha256_128s_robust : public key_sha256_robust { +/// The class for keys with the SHA2 robust 128S parameter set +class key_sha2_128s_robust : public key_sha2_robust { public: - key_sha256_128s_robust(void) { set_128s(); } + key_sha2_128s_robust(void) { set_128s(); } }; -/// The class for keys with the SHA256 simple 192F parameter set -class key_sha256_192f_simple : public key_sha256_L35_simple { +/// The class for keys with the SHA2 simple 192F parameter set +class key_sha2_192f_simple : public key_sha2_L35_simple { public: - key_sha256_192f_simple(void) { set_192f(); } + key_sha2_192f_simple(void) { set_192f(); } }; -/// The class for keys with the SHA256 robust 192F parameter set -class key_sha256_192f_robust : public key_sha256_L35_robust { +/// The class for keys with the SHA2 robust 192F parameter set +class key_sha2_192f_robust : public key_sha2_L35_robust { public: - key_sha256_192f_robust(void) { set_192f(); } + key_sha2_192f_robust(void) { set_192f(); } }; -/// The class for keys with the SHA256 simple 192S parameter set -class key_sha256_192s_simple : public key_sha256_L35_simple { +/// The class for keys with the SHA2 simple 192S parameter set +class key_sha2_192s_simple : public key_sha2_L35_simple { public: - key_sha256_192s_simple(void) { set_192s(); } + key_sha2_192s_simple(void) { set_192s(); } }; -/// The class for keys with the SHA256 robust 192S parameter set -class key_sha256_192s_robust : public key_sha256_L35_robust { +/// The class for keys with the SHA2 robust 192S parameter set +class key_sha2_192s_robust : public key_sha2_L35_robust { public: - key_sha256_192s_robust(void) { set_192s(); } + key_sha2_192s_robust(void) { set_192s(); } }; -/// The class for keys with the SHA256 simple 256F parameter set -class key_sha256_256f_simple : public key_sha256_L35_simple { +/// The class for keys with the SHA2 simple 256F parameter set +class key_sha2_256f_simple : public key_sha2_L35_simple { public: - key_sha256_256f_simple(void) { set_256f(); } + key_sha2_256f_simple(void) { set_256f(); } }; -/// The class for keys with the SHA256 robust 256F parameter set -class key_sha256_256f_robust : public key_sha256_L35_robust { +/// The class for keys with the SHA2 robust 256F parameter set +class key_sha2_256f_robust : public key_sha2_L35_robust { public: - key_sha256_256f_robust(void) { set_256f(); } + key_sha2_256f_robust(void) { set_256f(); } }; -/// The class for keys with the SHA256 simple 256S parameter set -class key_sha256_256s_simple : public key_sha256_L35_simple { +/// The class for keys with the SHA2 simple 256S parameter set +class key_sha2_256s_simple : public key_sha2_L35_simple { public: - key_sha256_256s_simple(void) { set_256s(); } + key_sha2_256s_simple(void) { set_256s(); } }; -/// The class for keys with the SHA256 robust 256S parameter set -class key_sha256_256s_robust : public key_sha256_L35_robust { +/// The class for keys with the SHA2 robust 256S parameter set +class key_sha2_256s_robust : public key_sha2_L35_robust { public: - key_sha256_256s_robust(void) { set_256s(); } + key_sha2_256s_robust(void) { set_256s(); } }; -/// The class for keys with the SHAKE256 simple 128F parameter set -class key_shake256_128f_simple : public key_shake256_simple { +/// The class for keys with the SHAKE simple 128F parameter set +class key_shake_128f_simple : public key_shake_simple { public: - key_shake256_128f_simple(void) { set_128f(); } + key_shake_128f_simple(void) { set_128f(); } }; -/// The class for keys with the SHAKE256 robust 128F parameter set -class key_shake256_128f_robust : public key_shake256_robust { +/// The class for keys with the SHAKE robust 128F parameter set +class key_shake_128f_robust : public key_shake_robust { public: - key_shake256_128f_robust(void) { set_128f(); } + key_shake_128f_robust(void) { set_128f(); } }; -/// The class for keys with the SHAKE256 simple 128S parameter set -class key_shake256_128s_simple : public key_shake256_simple { +/// The class for keys with the SHAKE simple 128S parameter set +class key_shake_128s_simple : public key_shake_simple { public: - key_shake256_128s_simple(void) { set_128s(); } + key_shake_128s_simple(void) { set_128s(); } }; -/// The class for keys with the SHAKE256 robust 128S parameter set -class key_shake256_128s_robust : public key_shake256_robust { +/// The class for keys with the SHAKE robust 128S parameter set +class key_shake_128s_robust : public key_shake_robust { public: - key_shake256_128s_robust(void) { set_128s(); } + key_shake_128s_robust(void) { set_128s(); } }; -/// The class for keys with the SHAKE256 simple 192F parameter set -class key_shake256_192f_simple : public key_shake256_simple { +/// The class for keys with the SHAKE simple 192F parameter set +class key_shake_192f_simple : public key_shake_simple { public: - key_shake256_192f_simple(void) { set_192f(); } + key_shake_192f_simple(void) { set_192f(); } }; -/// The class for keys with the SHAKE256 robust 192F parameter set -class key_shake256_192f_robust : public key_shake256_robust { +/// The class for keys with the SHAKE robust 192F parameter set +class key_shake_192f_robust : public key_shake_robust { public: - key_shake256_192f_robust(void) { set_192f(); } + key_shake_192f_robust(void) { set_192f(); } }; -/// The class for keys with the SHAKE256 simple 192S parameter set -class key_shake256_192s_simple : public key_shake256_simple { +/// The class for keys with the SHAKE simple 192S parameter set +class key_shake_192s_simple : public key_shake_simple { public: - key_shake256_192s_simple(void) { set_192s(); } + key_shake_192s_simple(void) { set_192s(); } }; -/// The class for keys with the SHAKE256 robust 192S parameter set -class key_shake256_192s_robust : public key_shake256_robust { +/// The class for keys with the SHAKE robust 192S parameter set +class key_shake_192s_robust : public key_shake_robust { public: - key_shake256_192s_robust(void) { set_192s(); } + key_shake_192s_robust(void) { set_192s(); } }; -/// The class for keys with the SHAKE256 simple 256F parameter set -class key_shake256_256f_simple : public key_shake256_simple { +/// The class for keys with the SHAKE simple 256F parameter set +class key_shake_256f_simple : public key_shake_simple { public: - key_shake256_256f_simple(void) { set_256f(); } + key_shake_256f_simple(void) { set_256f(); } }; -/// The class for keys with the SHAKE256 robust 256F parameter set -class key_shake256_256f_robust : public key_shake256_robust { +/// The class for keys with the SHAKE robust 256F parameter set +class key_shake_256f_robust : public key_shake_robust { public: - key_shake256_256f_robust(void) { set_256f(); } + key_shake_256f_robust(void) { set_256f(); } }; -/// The class for keys with the SHAKE256 simple 256S parameter set -class key_shake256_256s_simple : public key_shake256_simple { +/// The class for keys with the SHAKE simple 256S parameter set +class key_shake_256s_simple : public key_shake_simple { public: - key_shake256_256s_simple(void) { set_256s(); } + key_shake_256s_simple(void) { set_256s(); } }; -/// The class for keys with the SHAKE256 robust 256S parameter set -class key_shake256_256s_robust : public key_shake256_robust { +/// The class for keys with the SHAKE robust 256S parameter set +class key_shake_256s_robust : public key_shake_robust { public: - key_shake256_256s_robust(void) { set_256s(); } + key_shake_256s_robust(void) { set_256s(); } }; /// The class for keys with the HARAKA simple 128F parameter set diff --git a/internal.h b/internal.h index cfb920e..348a854 100644 --- a/internal.h +++ b/internal.h @@ -26,16 +26,16 @@ const int max_wots_digits = 67; // bitstream( mgf1_seed, n + sha256_addr_bytes ); + memcpy( &mgf1_seed[n], addr, sha2_addr_bytes ); + mgf1 bitstream( mgf1_seed, n + sha2_addr_bytes ); // Starting at state_seeded, hash the addr structure and the // input blocks xored with the mgf1 stream - ctx.update(addr, sha256_addr_bytes); + ctx.update(addr, sha2_addr_bytes); for (unsigned i = 0; i < inblocks; i++) { unsigned char buffer[max_len_hash]; bitstream.output( buffer, n ); @@ -49,7 +49,7 @@ void key_sha256_robust::thash( unsigned char* out, /** * 8-way parallel version of thash; takes 8x as much input and output */ -void key_sha256_robust::thash_xn(unsigned char **out, +void key_sha2_robust::thash_xn(unsigned char **out, unsigned char **in, unsigned int inblocks, addr_t* addrx8) @@ -68,17 +68,17 @@ void key_sha256_robust::thash_xn(unsigned char **out, &addrx8[5], &addrx8[6], &addrx8[7], - sha256_addr_bytes ); + sha2_addr_bytes ); // Fire up the MGF1 engine unsigned char *ptr_seed[8]; - unsigned char seed[ 8*(max_len_hash + sha256_addr_bytes) ]; + unsigned char seed[ 8*(max_len_hash + sha2_addr_bytes) ]; for (int i=0; i<8; i++) { - ptr_seed[i] = &seed[ i * (max_len_hash+sha256_addr_bytes) ]; + ptr_seed[i] = &seed[ i * (max_len_hash+sha2_addr_bytes) ]; memcpy( ptr_seed[i], get_public_seed(), n ); - memcpy( ptr_seed[i]+n, &addrx8[i], sha256_addr_bytes ); + memcpy( ptr_seed[i]+n, &addrx8[i], sha2_addr_bytes ); } - mgf1_8x bit_stream( ptr_seed, n + sha256_addr_bytes ); + mgf1_8x bit_stream( ptr_seed, n + sha2_addr_bytes ); unsigned char buffer[8][max_len_hash]; unsigned char *ptr_buffer[8]; diff --git a/sha256_simple.cpp b/sha256_simple.cpp index 0c5c9db..38be4bd 100644 --- a/sha256_simple.cpp +++ b/sha256_simple.cpp @@ -12,7 +12,7 @@ namespace sphincs_plus { /** * The simple version of thash */ -void key_sha256_simple::thash( unsigned char *out, +void key_sha2_simple::thash( unsigned char *out, const unsigned char *in, unsigned int inblocks, addr_t addr) { unsigned char outbuf[sha256_output_size]; @@ -23,7 +23,7 @@ void key_sha256_simple::thash( unsigned char *out, // Starting at state_seeded, hash the addr structure and the // input blocks - ctx.update(addr, sha256_addr_bytes); + ctx.update(addr, sha2_addr_bytes); ctx.update(in, inblocks * len_hash() ); ctx.final(outbuf); @@ -33,7 +33,7 @@ void key_sha256_simple::thash( unsigned char *out, /** * 8-way parallel version of thash; takes 8x as much input and output */ -void key_sha256_simple::thash_xn(unsigned char **out, +void key_sha2_simple::thash_xn(unsigned char **out, unsigned char **in, unsigned int inblocks, addr_t* addrx8) @@ -53,7 +53,7 @@ void key_sha256_simple::thash_xn(unsigned char **out, &addrx8[5], &addrx8[6], &addrx8[7], - sha256_addr_bytes ); + sha2_addr_bytes ); sha256_update8x(&ctx, in[0], diff --git a/sha512_hash.cpp b/sha512_hash.cpp index 3b6a0ff..8e9be17 100644 --- a/sha512_hash.cpp +++ b/sha512_hash.cpp @@ -1,5 +1,5 @@ /* - * This file has support for the L3, L5 SHA-256-based parameter sets + * This file has support for the L3, L5 SHA-2-based parameter sets * These parameter sets use SHA-512 to do the initial message hashes */ #include @@ -10,21 +10,21 @@ namespace sphincs_plus { -// For the SHA256-L3, L5 parameter sets, redirect the PRF_msg to the version +// For the SHA2-L3, L5 parameter sets, redirect the PRF_msg to the version // that uses SHA-512 -void key_sha256_L35_simple::prf_msg( unsigned char *result, +void key_sha2_L35_simple::prf_msg( unsigned char *result, const unsigned char *opt, const unsigned char *msg, size_t len_msg ) { prf_msg_512(result, opt, msg, len_msg); } -void key_sha256_L35_robust::prf_msg( unsigned char *result, +void key_sha2_L35_robust::prf_msg( unsigned char *result, const unsigned char *opt, const unsigned char *msg, size_t len_msg ) { prf_msg_512(result, opt, msg, len_msg); } // prf_msg is defined as HMAC( prf, opt_rand || msg ) -void sha256_hash::prf_msg_512( unsigned char *result, +void sha2_hash::prf_msg_512( unsigned char *result, const unsigned char *opt_rand, const unsigned char *msg, size_t len_msg ) { SHA512_CTX ctx; @@ -61,14 +61,14 @@ void sha256_hash::prf_msg_512( unsigned char *result, ctx.zeroize(); } -// For the SHA256-L3, L5 parameter sets, redirect the h_msg to the version +// For the SHA2-L3, L5 parameter sets, redirect the h_msg to the version // that uses SHA-512 -void key_sha256_L35_simple::h_msg( unsigned char *result, size_t len_result, +void key_sha2_L35_simple::h_msg( unsigned char *result, size_t len_result, const unsigned char *r, const unsigned char *msg, size_t len_msg ) { h_msg_512(result, len_result, r, msg, len_msg); } -void key_sha256_L35_robust::h_msg( unsigned char *result, size_t len_result, +void key_sha2_L35_robust::h_msg( unsigned char *result, size_t len_result, const unsigned char *r, const unsigned char *msg, size_t len_msg ) { h_msg_512(result, len_result, r, msg, len_msg); @@ -76,7 +76,7 @@ void key_sha256_L35_robust::h_msg( unsigned char *result, size_t len_result, // Here, len_result is not the size of the buffer (which it is in most // similar contexts); instead, it is the number of output bytes desired -void sha256_hash::h_msg_512( unsigned char *result, size_t len_result, +void sha2_hash::h_msg_512( unsigned char *result, size_t len_result, const unsigned char *r, const unsigned char *msg, size_t len_msg ) { unsigned char msg_hash[ sha512_output_size + 2*max_len_hash ]; diff --git a/sha512_robust.cpp b/sha512_robust.cpp index 5f7bd88..2d72df2 100644 --- a/sha512_robust.cpp +++ b/sha512_robust.cpp @@ -19,7 +19,7 @@ static void xor_mem(unsigned char* dest, const unsigned char* src, unsigned n) { /** * The robust version of thash */ -void key_sha256_L35_robust::thash( unsigned char *out, +void key_sha2_L35_robust::thash( unsigned char *out, const unsigned char *in, unsigned int inblocks, addr_t addr) { // thash is never called with inblocks==1, hence we don't need to @@ -33,14 +33,14 @@ void key_sha256_L35_robust::thash( unsigned char *out, ctx.init_from_intermediate(state_seeded_512, sha512_block_size); // Initialize the seed for the MGF1 engine - unsigned char mgf1_seed[ max_len_hash + sha256_addr_bytes ]; + unsigned char mgf1_seed[ max_len_hash + sha2_addr_bytes ]; memcpy( mgf1_seed, get_public_seed(), n ); - memcpy( &mgf1_seed[n], addr, sha256_addr_bytes ); - mgf1 bitstream( mgf1_seed, n + sha256_addr_bytes ); + memcpy( &mgf1_seed[n], addr, sha2_addr_bytes ); + mgf1 bitstream( mgf1_seed, n + sha2_addr_bytes ); // Starting at state_seeded, hash the addr structure and the // input blocks xored with the mgf1 stream - ctx.update(addr, sha256_addr_bytes); + ctx.update(addr, sha2_addr_bytes); for (unsigned i = 0; i < inblocks; i++) { unsigned char buffer[max_len_hash]; bitstream.output( buffer, n ); @@ -57,7 +57,7 @@ void key_sha256_L35_robust::thash( unsigned char *out, * 8-way parallel version of thash; takes 8x as much input and output * Note that, for inblocks==1, the alternative f_xn function is used */ -void key_sha256_L35_robust::thash_xn(unsigned char **out, +void key_sha2_L35_robust::thash_xn(unsigned char **out, unsigned char **in, unsigned int inblocks, addr_t* addrx8) @@ -65,9 +65,9 @@ void key_sha256_L35_robust::thash_xn(unsigned char **out, sha512ctx4x ctx; int n = len_hash(); unsigned char *mask_seed[4]; - unsigned char seed[ 4*(max_len_hash + sha256_addr_bytes) ]; + unsigned char seed[ 4*(max_len_hash + sha2_addr_bytes) ]; for (int j=0; j<4; j++) { - mask_seed[j] = &seed[ j * (max_len_hash+sha256_addr_bytes) ]; + mask_seed[j] = &seed[ j * (max_len_hash+sha2_addr_bytes) ]; } unsigned char buffer[4][max_len_hash]; unsigned char *ptr_buffer[4]; @@ -88,14 +88,14 @@ void key_sha256_L35_robust::thash_xn(unsigned char **out, &addrx8[i+1], &addrx8[i+2], &addrx8[i+3], - sha256_addr_bytes ); + sha2_addr_bytes ); // Fire up the MGF1 engine that'll generate the masks for (int j=0; j<4; j++) { memcpy( mask_seed[j], get_public_seed(), n ); - memcpy( mask_seed[j]+n, &addrx8[i+j], sha256_addr_bytes ); + memcpy( mask_seed[j]+n, &addrx8[i+j], sha2_addr_bytes ); } - mgf1_sha512_4x bit_stream( mask_seed, n + sha256_addr_bytes ); + mgf1_sha512_4x bit_stream( mask_seed, n + sha2_addr_bytes ); // Stir in the input blocks (including the mask) for (unsigned k=0, block=0; k #include "api.h" @@ -12,7 +12,7 @@ namespace sphincs_plus { /** * The robust version of thash */ -void key_shake256_robust::thash( unsigned char *out, +void key_shake_robust::thash( unsigned char *out, const unsigned char *in, unsigned int inblocks, addr_t addr) { unsigned n = len_hash(); @@ -43,7 +43,7 @@ void key_shake256_robust::thash( unsigned char *out, * Idea of the future: it might be faster to generate a precomputed * mask for both ctx and mask_ctx, and initialize both with it... */ -void key_shake256_robust::thash_xn(unsigned char **out, +void key_shake_robust::thash_xn(unsigned char **out, unsigned char **in, unsigned int inblocks, addr_t* addrx4) diff --git a/shake256_simple.cpp b/shake256_simple.cpp index abeab7b..8ae9027 100644 --- a/shake256_simple.cpp +++ b/shake256_simple.cpp @@ -1,5 +1,5 @@ /* - * This file has support for the low level SHAKE-256-simple routines + * This file has support for the low level SHAKE-simple routines */ #include #include "api.h" @@ -12,7 +12,7 @@ namespace sphincs_plus { /** * The simple version of thash */ -void key_shake256_simple::thash( unsigned char *out, +void key_shake_simple::thash( unsigned char *out, const unsigned char *in, unsigned int inblocks, addr_t addr) { unsigned n = len_hash(); @@ -28,7 +28,7 @@ void key_shake256_simple::thash( unsigned char *out, /** * 4-way parallel version of thash; takes 4x as much input and output */ -void key_shake256_simple::thash_xn(unsigned char **out, +void key_shake_simple::thash_xn(unsigned char **out, unsigned char **in, unsigned int inblocks, addr_t* addrx4) diff --git a/test_keygen.cpp b/test_keygen.cpp index bd35803..31fe783 100644 --- a/test_keygen.cpp +++ b/test_keygen.cpp @@ -170,42 +170,42 @@ bool test_keygen(bool fast_flag, enum noise_level level) { // and selected 'S' parameter sets // L1 parameter sets - RUN_TEST( sha256_128s_simple, true ); - RUN_TEST( sha256_128f_simple, true ); - RUN_TEST( sha256_128s_robust, false ); - RUN_TEST( sha256_128f_robust, true ); - RUN_TEST( shake256_128s_simple, true ); - RUN_TEST( shake256_128f_simple, true ); - RUN_TEST( shake256_128s_robust, false ); - RUN_TEST( shake256_128f_robust, true ); + RUN_TEST( sha2_128s_simple, true ); + RUN_TEST( sha2_128f_simple, true ); + RUN_TEST( sha2_128s_robust, false ); + RUN_TEST( sha2_128f_robust, true ); + RUN_TEST( shake_128s_simple, true ); + RUN_TEST( shake_128f_simple, true ); + RUN_TEST( shake_128s_robust, false ); + RUN_TEST( shake_128f_robust, true ); RUN_TEST( haraka_128s_simple, false ); RUN_TEST( haraka_128f_simple, true ); RUN_TEST( haraka_128s_robust, true ); RUN_TEST( haraka_128f_robust, true ); // L3 parameter sets - RUN_TEST( sha256_192s_simple, false ); - RUN_TEST( sha256_192f_simple, true ); - RUN_TEST( sha256_192s_robust, false ); - RUN_TEST( sha256_192f_robust, true ); - RUN_TEST( shake256_192s_simple, false ); - RUN_TEST( shake256_192f_simple, true ); - RUN_TEST( shake256_192s_robust, false ); - RUN_TEST( shake256_192f_robust, true ); + RUN_TEST( sha2_192s_simple, false ); + RUN_TEST( sha2_192f_simple, true ); + RUN_TEST( sha2_192s_robust, false ); + RUN_TEST( sha2_192f_robust, true ); + RUN_TEST( shake_192s_simple, false ); + RUN_TEST( shake_192f_simple, true ); + RUN_TEST( shake_192s_robust, false ); + RUN_TEST( shake_192f_robust, true ); RUN_TEST( haraka_192s_simple, false ); RUN_TEST( haraka_192f_simple, true ); RUN_TEST( haraka_192s_robust, false ); RUN_TEST( haraka_192f_robust, true ); // L5 parameter sets - RUN_TEST( sha256_256s_simple, false ); - RUN_TEST( sha256_256f_simple, true ); - RUN_TEST( sha256_256s_robust, false ); - RUN_TEST( sha256_256f_robust, true ); - RUN_TEST( shake256_256s_simple, false ); - RUN_TEST( shake256_256f_simple, true ); - RUN_TEST( shake256_256s_robust, false ); - RUN_TEST( shake256_256f_robust, true ); + RUN_TEST( sha2_256s_simple, false ); + RUN_TEST( sha2_256f_simple, true ); + RUN_TEST( sha2_256s_robust, false ); + RUN_TEST( sha2_256f_robust, true ); + RUN_TEST( shake_256s_simple, false ); + RUN_TEST( shake_256f_simple, true ); + RUN_TEST( shake_256s_robust, false ); + RUN_TEST( shake_256f_robust, true ); RUN_TEST( haraka_256s_simple, false ); RUN_TEST( haraka_256f_simple, true ); RUN_TEST( haraka_256s_robust, false ); diff --git a/test_sign.cpp b/test_sign.cpp index a56326a..4e64d82 100644 --- a/test_sign.cpp +++ b/test_sign.cpp @@ -240,42 +240,42 @@ bool test_sign(bool fast_flag, enum noise_level level) { // and selected 'S' parameter sets // L1 parameter sets - RUN_TEST( sha256_128s_simple, false ); - RUN_TEST( sha256_128f_simple, true ); - RUN_TEST( sha256_128s_robust, false ); - RUN_TEST( sha256_128f_robust, true ); - RUN_TEST( shake256_128s_simple, false ); - RUN_TEST( shake256_128f_simple, true ); - RUN_TEST( shake256_128s_robust, false ); - RUN_TEST( shake256_128f_robust, true ); + RUN_TEST( sha2_128s_simple, false ); + RUN_TEST( sha2_128f_simple, true ); + RUN_TEST( sha2_128s_robust, false ); + RUN_TEST( sha2_128f_robust, true ); + RUN_TEST( shake_128s_simple, false ); + RUN_TEST( shake_128f_simple, true ); + RUN_TEST( shake_128s_robust, false ); + RUN_TEST( shake_128f_robust, true ); RUN_TEST( haraka_128s_simple, true ); RUN_TEST( haraka_128f_simple, true ); RUN_TEST( haraka_128s_robust, false ); RUN_TEST( haraka_128f_robust, true ); // L3 parameter sets - RUN_TEST( sha256_192s_simple, false ); - RUN_TEST( sha256_192f_simple, true ); - RUN_TEST( sha256_192s_robust, false ); - RUN_TEST( sha256_192f_robust, true ); - RUN_TEST( shake256_192s_simple, false ); - RUN_TEST( shake256_192f_simple, true ); - RUN_TEST( shake256_192s_robust, false ); - RUN_TEST( shake256_192f_robust, true ); + RUN_TEST( sha2_192s_simple, false ); + RUN_TEST( sha2_192f_simple, true ); + RUN_TEST( sha2_192s_robust, false ); + RUN_TEST( sha2_192f_robust, true ); + RUN_TEST( shake_192s_simple, false ); + RUN_TEST( shake_192f_simple, true ); + RUN_TEST( shake_192s_robust, false ); + RUN_TEST( shake_192f_robust, true ); RUN_TEST( haraka_192s_simple, false ); RUN_TEST( haraka_192f_simple, true ); RUN_TEST( haraka_192s_robust, false ); RUN_TEST( haraka_192f_robust, true ); // L5 parameter sets - RUN_TEST( sha256_256s_simple, false ); - RUN_TEST( sha256_256f_simple, true ); - RUN_TEST( sha256_256s_robust, false ); - RUN_TEST( sha256_256f_robust, true ); - RUN_TEST( shake256_256s_simple, false ); - RUN_TEST( shake256_256f_simple, true ); - RUN_TEST( shake256_256s_robust, false ); - RUN_TEST( shake256_256f_robust, true ); + RUN_TEST( sha2_256s_simple, false ); + RUN_TEST( sha2_256f_simple, true ); + RUN_TEST( sha2_256s_robust, false ); + RUN_TEST( sha2_256f_robust, true ); + RUN_TEST( shake_256s_simple, false ); + RUN_TEST( shake_256f_simple, true ); + RUN_TEST( shake_256s_robust, false ); + RUN_TEST( shake_256f_robust, true ); RUN_TEST( haraka_256s_simple, false ); RUN_TEST( haraka_256f_simple, true ); RUN_TEST( haraka_256s_robust, false ); diff --git a/test_testvector.cpp b/test_testvector.cpp index 434bc08..28b2026 100644 --- a/test_testvector.cpp +++ b/test_testvector.cpp @@ -7,7 +7,7 @@ // // This tests out various test vectors from the reference code // -// We are supposed to do the same transforms as the refence code; +// We are supposed to do the same transforms as the reference code; // that is, the same seed -> private/public key and the same // private key/optrand/message -> signature operation // @@ -26,7 +26,7 @@ // Obvious question: why did we use an obviously nonrandom pattern // for key generation, but a random one for signatures? The answer // is what the reference code allowed to do (without changing that -// code); the refernce code gave us an API (crypto_sign_seed_keypair) +// code); the reference code gave us an API (crypto_sign_seed_keypair) // that allowed us to specify the seed, so we picked a simple one. // In constrast, the reference code always called randombytes() to // get optrand (and didn't give us an option to skip it); however @@ -65,75 +65,75 @@ class optrand_buffer : public sphincs_plus::random { // Given a parameter set name, return a key of that type static sphincs_plus::key* lookup_key( const char *name) { if (0 == strcmp( name, "sha2_128f_simple" )) - return new sphincs_plus::key_sha256_128f_simple; + return new sphincs_plus::key_sha2_128f_simple; if (0 == strcmp( name, "sha2_128f_robust" )) - return new sphincs_plus::key_sha256_128f_robust; + return new sphincs_plus::key_sha2_128f_robust; if (0 == strcmp( name, "shake_128f_simple" )) - return new sphincs_plus::key_shake256_128f_simple; + return new sphincs_plus::key_shake_128f_simple; if (0 == strcmp( name, "shake_128f_robust" )) - return new sphincs_plus::key_shake256_128f_robust; + return new sphincs_plus::key_shake_128f_robust; if (0 == strcmp( name, "haraka_128f_simple" )) return new sphincs_plus::key_haraka_128f_simple; if (0 == strcmp( name, "haraka_128f_robust" )) return new sphincs_plus::key_haraka_128f_robust; if (0 == strcmp( name, "sha2_128s_simple" )) - return new sphincs_plus::key_sha256_128s_simple; + return new sphincs_plus::key_sha2_128s_simple; if (0 == strcmp( name, "sha2_128s_robust" )) - return new sphincs_plus::key_sha256_128s_robust; + return new sphincs_plus::key_sha2_128s_robust; if (0 == strcmp( name, "shake_128s_simple" )) - return new sphincs_plus::key_shake256_128s_simple; + return new sphincs_plus::key_shake_128s_simple; if (0 == strcmp( name, "shake_128s_robust" )) - return new sphincs_plus::key_shake256_128s_robust; + return new sphincs_plus::key_shake_128s_robust; if (0 == strcmp( name, "haraka_128s_simple" )) return new sphincs_plus::key_haraka_128s_simple; if (0 == strcmp( name, "haraka_128s_robust" )) return new sphincs_plus::key_haraka_128s_robust; if (0 == strcmp( name, "sha2_192f_simple" )) - return new sphincs_plus::key_sha256_192f_simple; + return new sphincs_plus::key_sha2_192f_simple; if (0 == strcmp( name, "sha2_192f_robust" )) - return new sphincs_plus::key_sha256_192f_robust; + return new sphincs_plus::key_sha2_192f_robust; if (0 == strcmp( name, "shake_192f_simple" )) - return new sphincs_plus::key_shake256_192f_simple; + return new sphincs_plus::key_shake_192f_simple; if (0 == strcmp( name, "shake_192f_robust" )) - return new sphincs_plus::key_shake256_192f_robust; + return new sphincs_plus::key_shake_192f_robust; if (0 == strcmp( name, "haraka_192f_simple" )) return new sphincs_plus::key_haraka_192f_simple; if (0 == strcmp( name, "haraka_192f_robust" )) return new sphincs_plus::key_haraka_192f_robust; if (0 == strcmp( name, "sha2_192s_simple" )) - return new sphincs_plus::key_sha256_192s_simple; + return new sphincs_plus::key_sha2_192s_simple; if (0 == strcmp( name, "sha2_192s_robust" )) - return new sphincs_plus::key_sha256_192s_robust; + return new sphincs_plus::key_sha2_192s_robust; if (0 == strcmp( name, "shake_192s_simple" )) - return new sphincs_plus::key_shake256_192s_simple; + return new sphincs_plus::key_shake_192s_simple; if (0 == strcmp( name, "shake_192s_robust" )) - return new sphincs_plus::key_shake256_192s_robust; + return new sphincs_plus::key_shake_192s_robust; if (0 == strcmp( name, "haraka_192s_simple" )) return new sphincs_plus::key_haraka_192s_simple; if (0 == strcmp( name, "haraka_192s_robust" )) return new sphincs_plus::key_haraka_192s_robust; if (0 == strcmp( name, "sha2_256f_simple" )) - return new sphincs_plus::key_sha256_256f_simple; + return new sphincs_plus::key_sha2_256f_simple; if (0 == strcmp( name, "sha2_256f_robust" )) - return new sphincs_plus::key_sha256_256f_robust; + return new sphincs_plus::key_sha2_256f_robust; if (0 == strcmp( name, "shake_256f_simple" )) - return new sphincs_plus::key_shake256_256f_simple; + return new sphincs_plus::key_shake_256f_simple; if (0 == strcmp( name, "shake_256f_robust" )) - return new sphincs_plus::key_shake256_256f_robust; + return new sphincs_plus::key_shake_256f_robust; if (0 == strcmp( name, "haraka_256f_simple" )) return new sphincs_plus::key_haraka_256f_simple; if (0 == strcmp( name, "haraka_256f_robust" )) return new sphincs_plus::key_haraka_256f_robust; if (0 == strcmp( name, "sha2_256s_simple" )) - return new sphincs_plus::key_sha256_256s_simple; + return new sphincs_plus::key_sha2_256s_simple; if (0 == strcmp( name, "sha2_256s_robust" )) - return new sphincs_plus::key_sha256_256s_robust; + return new sphincs_plus::key_sha2_256s_robust; if (0 == strcmp( name, "shake_256s_simple" )) - return new sphincs_plus::key_shake256_256s_simple; + return new sphincs_plus::key_shake_256s_simple; if (0 == strcmp( name, "shake_256s_robust" )) - return new sphincs_plus::key_shake256_256s_robust; + return new sphincs_plus::key_shake_256s_robust; if (0 == strcmp( name, "haraka_256s_simple" )) return new sphincs_plus::key_haraka_256s_simple; if (0 == strcmp( name, "haraka_256s_robust" )) diff --git a/test_thread.cpp b/test_thread.cpp index 3ad105f..93dd237 100644 --- a/test_thread.cpp +++ b/test_thread.cpp @@ -93,42 +93,42 @@ bool test_thread(bool fast_flag, enum noise_level level) { // and selected 'S' parameter sets // L1 parameter sets - RUN_TEST( sha256_128s_simple, true ); - RUN_TEST( sha256_128f_simple, true ); - RUN_TEST( sha256_128s_robust, false ); - RUN_TEST( sha256_128f_robust, true ); - RUN_TEST( shake256_128s_simple, false ); - RUN_TEST( shake256_128f_simple, true ); - RUN_TEST( shake256_128s_robust, false ); - RUN_TEST( shake256_128f_robust, true ); + RUN_TEST( sha2_128s_simple, true ); + RUN_TEST( sha2_128f_simple, true ); + RUN_TEST( sha2_128s_robust, false ); + RUN_TEST( sha2_128f_robust, true ); + RUN_TEST( shake_128s_simple, false ); + RUN_TEST( shake_128f_simple, true ); + RUN_TEST( shake_128s_robust, false ); + RUN_TEST( shake_128f_robust, true ); RUN_TEST( haraka_128s_simple, false ); RUN_TEST( haraka_128f_simple, true ); RUN_TEST( haraka_128s_robust, true ); RUN_TEST( haraka_128f_robust, true ); // L3 parameter sets - RUN_TEST( sha256_192s_simple, false ); - RUN_TEST( sha256_192f_simple, true ); - RUN_TEST( sha256_192s_robust, false ); - RUN_TEST( sha256_192f_robust, true ); - RUN_TEST( shake256_192s_simple, false ); - RUN_TEST( shake256_192f_simple, true ); - RUN_TEST( shake256_192s_robust, false ); - RUN_TEST( shake256_192f_robust, true ); + RUN_TEST( sha2_192s_simple, false ); + RUN_TEST( sha2_192f_simple, true ); + RUN_TEST( sha2_192s_robust, false ); + RUN_TEST( sha2_192f_robust, true ); + RUN_TEST( shake_192s_simple, false ); + RUN_TEST( shake_192f_simple, true ); + RUN_TEST( shake_192s_robust, false ); + RUN_TEST( shake_192f_robust, true ); RUN_TEST( haraka_192s_simple, true ); RUN_TEST( haraka_192f_simple, true ); RUN_TEST( haraka_192s_robust, false ); RUN_TEST( haraka_192f_robust, true ); // L5 parameter sets - RUN_TEST( sha256_256s_simple, false ); - RUN_TEST( sha256_256f_simple, true ); - RUN_TEST( sha256_256s_robust, false ); - RUN_TEST( sha256_256f_robust, true ); - RUN_TEST( shake256_256s_simple, false ); - RUN_TEST( shake256_256f_simple, true ); - RUN_TEST( shake256_256s_robust, false ); - RUN_TEST( shake256_256f_robust, true ); + RUN_TEST( sha2_256s_simple, false ); + RUN_TEST( sha2_256f_simple, true ); + RUN_TEST( sha2_256s_robust, false ); + RUN_TEST( sha2_256f_robust, true ); + RUN_TEST( shake_256s_simple, false ); + RUN_TEST( shake_256f_simple, true ); + RUN_TEST( shake_256s_robust, false ); + RUN_TEST( shake_256f_robust, true ); RUN_TEST( haraka_256s_simple, true ); RUN_TEST( haraka_256f_simple, true ); RUN_TEST( haraka_256s_robust, false ); diff --git a/test_verify.cpp b/test_verify.cpp index 0f17bd9..54ef7f5 100644 --- a/test_verify.cpp +++ b/test_verify.cpp @@ -147,42 +147,42 @@ bool test_verify(bool fast_flag, enum noise_level level) { */ // L1 parameter sets - RUN_TEST( sha256_128s_simple, true ); - RUN_TEST( sha256_128f_simple, false ); - RUN_TEST( sha256_128s_robust, true ); - RUN_TEST( sha256_128f_robust, false ); - RUN_TEST( shake256_128s_simple, true ); - RUN_TEST( shake256_128f_simple, false ); - RUN_TEST( shake256_128s_robust, false ); - RUN_TEST( shake256_128f_robust, false ); + RUN_TEST( sha2_128s_simple, true ); + RUN_TEST( sha2_128f_simple, false ); + RUN_TEST( sha2_128s_robust, true ); + RUN_TEST( sha2_128f_robust, false ); + RUN_TEST( shake_128s_simple, true ); + RUN_TEST( shake_128f_simple, false ); + RUN_TEST( shake_128s_robust, false ); + RUN_TEST( shake_128f_robust, false ); RUN_TEST( haraka_128s_simple, false ); RUN_TEST( haraka_128f_simple, true ); RUN_TEST( haraka_128s_robust, true ); RUN_TEST( haraka_128f_robust, false ); // L3 parameter sets - RUN_TEST( sha256_192s_simple, true ); - RUN_TEST( sha256_192f_simple, false ); - RUN_TEST( sha256_192s_robust, false ); - RUN_TEST( sha256_192f_robust, false ); - RUN_TEST( shake256_192s_simple, false ); - RUN_TEST( shake256_192f_simple, false ); - RUN_TEST( shake256_192s_robust, false ); - RUN_TEST( shake256_192f_robust, false ); + RUN_TEST( sha2_192s_simple, true ); + RUN_TEST( sha2_192f_simple, false ); + RUN_TEST( sha2_192s_robust, false ); + RUN_TEST( sha2_192f_robust, false ); + RUN_TEST( shake_192s_simple, false ); + RUN_TEST( shake_192f_simple, false ); + RUN_TEST( shake_192s_robust, false ); + RUN_TEST( shake_192f_robust, false ); RUN_TEST( haraka_192s_simple, true ); RUN_TEST( haraka_192f_simple, false ); RUN_TEST( haraka_192s_robust, false ); RUN_TEST( haraka_192f_robust, false ); // L5 parameter sets - RUN_TEST( sha256_256s_simple, true ); - RUN_TEST( sha256_256f_simple, false ); - RUN_TEST( sha256_256s_robust, false ); - RUN_TEST( sha256_256f_robust, false ); - RUN_TEST( shake256_256s_simple, false ); - RUN_TEST( shake256_256f_simple, false ); - RUN_TEST( shake256_256s_robust, false ); - RUN_TEST( shake256_256f_robust, false ); + RUN_TEST( sha2_256s_simple, true ); + RUN_TEST( sha2_256f_simple, false ); + RUN_TEST( sha2_256s_robust, false ); + RUN_TEST( sha2_256f_robust, false ); + RUN_TEST( shake_256s_simple, false ); + RUN_TEST( shake_256f_simple, false ); + RUN_TEST( shake_256s_robust, false ); + RUN_TEST( shake_256f_robust, false ); RUN_TEST( haraka_256s_simple, true ); RUN_TEST( haraka_256f_simple, false ); RUN_TEST( haraka_256s_robust, false ); From 7b0aa3957a6ae698430af9d3d72f98025ef8db05 Mon Sep 17 00:00:00 2001 From: sfluhrer Date: Tue, 14 Jun 2022 14:12:33 -0400 Subject: [PATCH 2/3] Rename parameter sets --- nist/nist_api.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nist/nist_api.cpp b/nist/nist_api.cpp index 0458572..548801f 100644 --- a/nist/nist_api.cpp +++ b/nist/nist_api.cpp @@ -13,13 +13,13 @@ extern "C" { // The NIST API assumes that the parameter set is compiled in // This is what chooses it #if !defined( SPX_PARAMETER_SET ) -#define SPX_PARAMETER_SET sha256_128f_robust +#define SPX_PARAMETER_SET sha2_128f_robust #endif #define CONCAT(a, b) CONCAT2(a, b) #define CONCAT2(a, b) a ## b typedef sphincs_plus :: CONCAT( key_, SPX_PARAMETER_SET ) KEY_TYPE; - // sphincs_plus::key_sha256_128f_robust in the default case + // sphincs_plus::key_sha2_128f_robust in the default case extern "C" { /* These functions use the C ABI */ From 430c47c69f8d47cd785364ff1fb45702d3418cf5 Mon Sep 17 00:00:00 2001 From: sfluhrer Date: Tue, 14 Jun 2022 17:47:56 -0400 Subject: [PATCH 3/3] Update to reflect changed parameter set names --- read.me | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/read.me b/read.me index d5627a1..71bbde1 100644 --- a/read.me +++ b/read.me @@ -18,8 +18,8 @@ Here is how this package is used: - Step 1: define an object that denotes the key, as in: - sphincs_plus::key_sha256_128s_simple signer; // This says we're using - // the SPHINCS+-SHA-256-128s-simple parameter set + sphincs_plus::key_sha2_128s_simple signer; // This says we're using + // the SPHINCS+-SHA-2-128s-simple parameter set // There are classes for all 36 parameter sets - Step 2: give the signer a key. Here are the possible options: @@ -98,15 +98,15 @@ Here is how this package is used: while generating a signature; passing a 1 signifies that we shouldn't spawn any child threads; it is also subject to a sane maximum. - - All key classes (such as key_sha256_128s_simple) are subclasses of + - All key classes (such as key_sha2_128s_simple) are subclasses of a master sphincs_plus::key class, this logic works as expected: sphincs_key::key* k; if (i_am_in_a_haraka_mood) k = new sphincs_plus::key_haraka_128s_simple; else if (perhaps_sha_would_be_better) - k = new sphincs_plus::key_sha256_128s_simple; + k = new sphincs_plus::key_sha2_128s_simple; else - k = new sphincs_plus::key_shake256_128s_simple; + k = new sphincs_plus::key_shake_128s_simple; k->generate_key_pair();