Make sphincs.proto enum definitions for unspecified values consistent with other proto definitions.

PiperOrigin-RevId: 463050887

7 files changed, 51 insertions, 44 deletions

diff --git a/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc b/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc
index d621f6902..7005f4883 100644
--- a/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc
@@ -139,8 +139,9 @@ TEST_P(SphincsSignKeyManagerTest, ValidKeyFormat) {
 
 TEST(SphincsSignKeyManagerTest, InvalidKeyFormat) {
   StatusOr<SphincsKeyFormat> key_format = CreateValidKeyFormat(
-      subtle::kSphincsPrivateKeySize64, SphincsHashType::UNKNOWN_HASH_TYPE,
-      SphincsVariant::UNKNOWN_VARIANT, SphincsSignatureType::UNKNOWN_SIG_TYPE);
+      subtle::kSphincsPrivateKeySize64, SphincsHashType::HASH_TYPE_UNSPECIFIED,
+      SphincsVariant::VARIANT_UNSPECIFIED,
+      SphincsSignatureType::SIG_TYPE_UNSPECIFIED);
   ASSERT_THAT(key_format, IsOk());
 
   EXPECT_THAT(SphincsSignKeyManager().ValidateKeyFormat(*key_format),
@@ -183,8 +184,9 @@ TEST_P(SphincsSignKeyManagerTest, PrivateKeyWrongVersion) {
 
 TEST(SphincsSignKeyManagerTest, CreateKeyInvalidParams) {
   StatusOr<SphincsKeyFormat> key_format = CreateValidKeyFormat(
-      subtle::kSphincsPrivateKeySize64, SphincsHashType::UNKNOWN_HASH_TYPE,
-      SphincsVariant::UNKNOWN_VARIANT, SphincsSignatureType::UNKNOWN_SIG_TYPE);
+      subtle::kSphincsPrivateKeySize64, SphincsHashType::HASH_TYPE_UNSPECIFIED,
+      SphincsVariant::VARIANT_UNSPECIFIED,
+      SphincsSignatureType::SIG_TYPE_UNSPECIFIED);
   ASSERT_THAT(key_format, IsOk());
 
   StatusOr<SphincsPrivateKey> private_key =
diff --git a/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc b/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc
index 9072c7373..b17f57c40 100644
--- a/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc
@@ -149,7 +149,7 @@ TEST_P(SphincsVerifyKeyManagerTest, InvalidParam) {
   params->set_key_size(test_case.private_key_size);
   params->set_hash_type(test_case.hash_type);
   params->set_variant(test_case.variant);
-  params->set_sig_length_type(SphincsSignatureType::UNKNOWN_SIG_TYPE);
+  params->set_sig_length_type(SphincsSignatureType::SIG_TYPE_UNSPECIFIED);
 
   EXPECT_THAT(SphincsVerifyKeyManager().ValidateParams(*params), Not(IsOk()));
 }
@@ -167,8 +167,9 @@ TEST_P(SphincsVerifyKeyManagerTest, PublicKeyValid) {
 
 TEST(SphincsVerifyKeyManagerTest, PublicKeyInvalidParams) {
   StatusOr<SphincsPublicKey> public_key = CreateValidPublicKey(
-      subtle::kSphincsPrivateKeySize64, SphincsHashType::UNKNOWN_HASH_TYPE,
-      SphincsVariant::UNKNOWN_VARIANT, SphincsSignatureType::UNKNOWN_SIG_TYPE);
+      subtle::kSphincsPrivateKeySize64, SphincsHashType::HASH_TYPE_UNSPECIFIED,
+      SphincsVariant::VARIANT_UNSPECIFIED,
+      SphincsSignatureType::SIG_TYPE_UNSPECIFIED);
   EXPECT_THAT(public_key, Not(IsOk()));
 }
 
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_helper_pqclean.cc b/cc/experimental/pqcrypto/signature/subtle/sphincs_helper_pqclean.cc
index 3809f2f5f..bb7f33274 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_helper_pqclean.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_helper_pqclean.cc
@@ -1093,10 +1093,13 @@ const SphincsHelperPqclean &GetSphincsHelperPqclean(int hash_type, int variant,
   static std::vector<std::unique_ptr<SphincsHelperPqclean>>
       *sphincs_helper_pqclean = new std::vector(GetSphincsPqcleanHelperArray());
 
+  // Note that we have to adjust the enum values for hash_type, variant and
+  // signature_length to start at 0. In the proto the 0 entry is for UNSPECIFIED
+  // values, but here we require the valid enum values to start at index 0.
   return *sphincs_helper_pqclean->at(
-      hash_type * NUM_VARIANTS * NUM_KEY_SIZES * NUM_SIG_LENGTHS +
-      key_size * NUM_VARIANTS * NUM_SIG_LENGTHS + variant * NUM_SIG_LENGTHS +
-      signature_length);
+      (hash_type - 1) * NUM_VARIANTS * NUM_KEY_SIZES * NUM_SIG_LENGTHS +
+      key_size * NUM_VARIANTS * NUM_SIG_LENGTHS +
+      (variant - 1) * NUM_SIG_LENGTHS + (signature_length - 1));
 }
 
 }  // namespace subtle
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils.h b/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils.h
index 62670f948..95fa9e907 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils.h
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils.h
@@ -40,22 +40,22 @@ const int kSphincsPublicKeySize48 = 48;
 const int kSphincsPublicKeySize64 = 64;
 
 enum SphincsHashType {
-  HARAKA = 0,
-  SHA256 = 1,
-  SHAKE256 = 2,
-  UNKNOWN_HASH_TYPE = 3,
+  HASH_TYPE_UNSPECIFIED = 0,
+  HARAKA = 1,
+  SHA256 = 2,
+  SHAKE256 = 3,
 };
 
 enum SphincsVariant {
-  ROBUST = 0,
-  SIMPLE = 1,
-  UNKNOWN_VARIANT = 3,
+  VARIANT_UNSPECIFIED = 0,
+  ROBUST = 1,
+  SIMPLE = 2,
 };
 
 enum SphincsSignatureType {
-  FAST_SIGNING = 0,
-  SMALL_SIGNATURE = 1,
-  UNKNOWN_SIG_TYPE = 3,
+  SIG_TYPE_UNSPECIFIED = 0,
+  FAST_SIGNING = 1,
+  SMALL_SIGNATURE = 2,
 };
 
 struct SphincsParamsPqclean {
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc b/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc
index a2e97c8c0..167a19512 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc
@@ -163,7 +163,7 @@ TEST_P(SphincsUtilsTest, ValidParams) {
 
 TEST(SphincsUtilsTest, InvalidHashType) {
     SphincsParamsPqclean params = {
-      .hash_type = SphincsHashType::UNKNOWN_HASH_TYPE,
+      .hash_type = SphincsHashType::HASH_TYPE_UNSPECIFIED,
       .variant = SphincsVariant::ROBUST,
       .sig_length_type = SphincsSignatureType::FAST_SIGNING,
       .private_key_size = kSphincsPrivateKeySize64,
@@ -175,7 +175,7 @@ TEST(SphincsUtilsTest, InvalidHashType) {
 TEST(SphincsUtilsTest, InvalidVariant) {
     SphincsParamsPqclean params = {
       .hash_type = SphincsHashType::HARAKA,
-      .variant = SphincsVariant::UNKNOWN_VARIANT,
+      .variant = SphincsVariant::VARIANT_UNSPECIFIED,
       .sig_length_type = SphincsSignatureType::FAST_SIGNING,
       .private_key_size = kSphincsPrivateKeySize64,
   };
@@ -187,7 +187,7 @@ TEST(SphincsUtilsTest, InvalidSignatureType) {
     SphincsParamsPqclean params = {
       .hash_type = SphincsHashType::HARAKA,
       .variant = SphincsVariant::ROBUST,
-      .sig_length_type = SphincsSignatureType::UNKNOWN_SIG_TYPE,
+      .sig_length_type = SphincsSignatureType::SIG_TYPE_UNSPECIFIED,
       .private_key_size = kSphincsPrivateKeySize64,
   };
 
diff --git a/cc/experimental/pqcrypto/signature/util/enums.cc b/cc/experimental/pqcrypto/signature/util/enums.cc
index c6593f77b..eeadc09c7 100644
--- a/cc/experimental/pqcrypto/signature/util/enums.cc
+++ b/cc/experimental/pqcrypto/signature/util/enums.cc
@@ -58,7 +58,7 @@ pb::SphincsHashType EnumsPqcrypto::SubtleToProto(subtle::SphincsHashType type) {
     case subtle::SphincsHashType::SHAKE256:
       return pb::SphincsHashType::SHAKE256;
     default:
-      return pb::SphincsHashType::UNKNOWN_HASH_TYPE;
+      return pb::SphincsHashType::HASH_TYPE_UNSPECIFIED;
   }
 }
 
@@ -72,7 +72,7 @@ subtle::SphincsHashType EnumsPqcrypto::ProtoToSubtle(pb::SphincsHashType type) {
     case pb::SphincsHashType::SHAKE256:
       return subtle::SphincsHashType::SHAKE256;
     default:
-      return subtle::SphincsHashType::UNKNOWN_HASH_TYPE;
+      return subtle::SphincsHashType::HASH_TYPE_UNSPECIFIED;
   }
 }
 
@@ -85,7 +85,7 @@ pb::SphincsVariant EnumsPqcrypto::SubtleToProto(
     case subtle::SphincsVariant::SIMPLE:
       return pb::SphincsVariant::SIMPLE;
     default:
-      return pb::SphincsVariant::UNKNOWN_VARIANT;
+      return pb::SphincsVariant::VARIANT_UNSPECIFIED;
   }
 }
 
@@ -98,7 +98,7 @@ subtle::SphincsVariant EnumsPqcrypto::ProtoToSubtle(
     case pb::SphincsVariant::SIMPLE:
       return subtle::SphincsVariant::SIMPLE;
     default:
-      return subtle::SphincsVariant::UNKNOWN_VARIANT;
+      return subtle::SphincsVariant::VARIANT_UNSPECIFIED;
   }
 }
 
@@ -111,7 +111,7 @@ pb::SphincsSignatureType EnumsPqcrypto::SubtleToProto(
     case subtle::SphincsSignatureType::SMALL_SIGNATURE:
       return pb::SphincsSignatureType::SMALL_SIGNATURE;
     default:
-      return pb::SphincsSignatureType::UNKNOWN_SIG_TYPE;
+      return pb::SphincsSignatureType::SIG_TYPE_UNSPECIFIED;
   }
 }
 
@@ -124,7 +124,7 @@ subtle::SphincsSignatureType EnumsPqcrypto::ProtoToSubtle(
     case pb::SphincsSignatureType::SMALL_SIGNATURE:
       return subtle::SphincsSignatureType::SMALL_SIGNATURE;
     default:
-      return subtle::SphincsSignatureType::UNKNOWN_SIG_TYPE;
+      return subtle::SphincsSignatureType::SIG_TYPE_UNSPECIFIED;
   }
 }
 
diff --git a/cc/experimental/pqcrypto/signature/util/enums_test.cc b/cc/experimental/pqcrypto/signature/util/enums_test.cc
index 1327fe834..1be4bb8b5 100644
--- a/cc/experimental/pqcrypto/signature/util/enums_test.cc
+++ b/cc/experimental/pqcrypto/signature/util/enums_test.cc
@@ -71,9 +71,9 @@ TEST_F(EnumsTest, SphincsHashType) {
             EnumsPqcrypto::SubtleToProto(subtle::SphincsHashType::SHA256));
   EXPECT_EQ(pb::SphincsHashType::SHAKE256,
             EnumsPqcrypto::SubtleToProto(subtle::SphincsHashType::SHAKE256));
-  EXPECT_EQ(
-      pb::SphincsHashType::UNKNOWN_HASH_TYPE,
-      EnumsPqcrypto::SubtleToProto(subtle::SphincsHashType::UNKNOWN_HASH_TYPE));
+  EXPECT_EQ(pb::SphincsHashType::HASH_TYPE_UNSPECIFIED,
+            EnumsPqcrypto::SubtleToProto(
+                subtle::SphincsHashType::HASH_TYPE_UNSPECIFIED));
 
   EXPECT_EQ(subtle::SphincsHashType::HARAKA,
             EnumsPqcrypto::ProtoToSubtle(pb::SphincsHashType::HARAKA));
@@ -82,8 +82,8 @@ TEST_F(EnumsTest, SphincsHashType) {
   EXPECT_EQ(subtle::SphincsHashType::SHAKE256,
             EnumsPqcrypto::ProtoToSubtle(pb::SphincsHashType::SHAKE256));
   EXPECT_EQ(
-      subtle::SphincsHashType::UNKNOWN_HASH_TYPE,
-      EnumsPqcrypto::ProtoToSubtle(pb::SphincsHashType::UNKNOWN_HASH_TYPE));
+      subtle::SphincsHashType::HASH_TYPE_UNSPECIFIED,
+      EnumsPqcrypto::ProtoToSubtle(pb::SphincsHashType::HASH_TYPE_UNSPECIFIED));
 
   // Check that enum conversion covers the entire range of the proto-enum.
   int count = 0;
@@ -104,16 +104,17 @@ TEST_F(EnumsTest, SphincsVariant) {
             EnumsPqcrypto::SubtleToProto(subtle::SphincsVariant::ROBUST));
   EXPECT_EQ(pb::SphincsVariant::SIMPLE,
             EnumsPqcrypto::SubtleToProto(subtle::SphincsVariant::SIMPLE));
-  EXPECT_EQ(
-      pb::SphincsVariant::UNKNOWN_VARIANT,
-      EnumsPqcrypto::SubtleToProto(subtle::SphincsVariant::UNKNOWN_VARIANT));
+  EXPECT_EQ(pb::SphincsVariant::VARIANT_UNSPECIFIED,
+            EnumsPqcrypto::SubtleToProto(
+                subtle::SphincsVariant::VARIANT_UNSPECIFIED));
 
   EXPECT_EQ(subtle::SphincsVariant::ROBUST,
             EnumsPqcrypto::ProtoToSubtle(pb::SphincsVariant::ROBUST));
   EXPECT_EQ(subtle::SphincsVariant::SIMPLE,
             EnumsPqcrypto::ProtoToSubtle(pb::SphincsVariant::SIMPLE));
-  EXPECT_EQ(subtle::SphincsVariant::UNKNOWN_VARIANT,
-            EnumsPqcrypto::ProtoToSubtle(pb::SphincsVariant::UNKNOWN_VARIANT));
+  EXPECT_EQ(
+      subtle::SphincsVariant::VARIANT_UNSPECIFIED,
+      EnumsPqcrypto::ProtoToSubtle(pb::SphincsVariant::VARIANT_UNSPECIFIED));
 
   // Check that enum conversion covers the entire range of the proto-enum.
   int count = 0;
@@ -136,9 +137,9 @@ TEST_F(EnumsTest, SphincsSignatureType) {
   EXPECT_EQ(pb::SphincsSignatureType::SMALL_SIGNATURE,
             EnumsPqcrypto::SubtleToProto(
                 subtle::SphincsSignatureType::SMALL_SIGNATURE));
-  EXPECT_EQ(pb::SphincsSignatureType::UNKNOWN_SIG_TYPE,
+  EXPECT_EQ(pb::SphincsSignatureType::SIG_TYPE_UNSPECIFIED,
             EnumsPqcrypto::SubtleToProto(
-                subtle::SphincsSignatureType::UNKNOWN_SIG_TYPE));
+                subtle::SphincsSignatureType::SIG_TYPE_UNSPECIFIED));
 
   EXPECT_EQ(
       subtle::SphincsSignatureType::FAST_SIGNING,
@@ -146,9 +147,9 @@ TEST_F(EnumsTest, SphincsSignatureType) {
   EXPECT_EQ(
       subtle::SphincsSignatureType::SMALL_SIGNATURE,
       EnumsPqcrypto::ProtoToSubtle(pb::SphincsSignatureType::SMALL_SIGNATURE));
-  EXPECT_EQ(
-      subtle::SphincsSignatureType::UNKNOWN_SIG_TYPE,
-      EnumsPqcrypto::ProtoToSubtle(pb::SphincsSignatureType::UNKNOWN_SIG_TYPE));
+  EXPECT_EQ(subtle::SphincsSignatureType::SIG_TYPE_UNSPECIFIED,
+            EnumsPqcrypto::ProtoToSubtle(
+                pb::SphincsSignatureType::SIG_TYPE_UNSPECIFIED));
 
   // Check that enum conversion covers the entire range of the proto-enum.
   int count = 0;