Change DilithiumSeedExpansion enum value names in accordance with the protocol buffer best practices so that they will match the corresponding protocol buffer enum value names.

I think it is cleaner if they have matching values.

PiperOrigin-RevId: 394426683

11 files changed, 82 insertions, 50 deletions

diff --git a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager.cc b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager.cc
index fc3e92bd0..7579e7faf 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager.cc
@@ -59,7 +59,7 @@ StatusOr<DilithiumPrivateKey> DilithiumSignKeyManager::CreateKey(
       std::pair<DilithiumPrivateKeyPqclean, DilithiumPublicKeyPqclean>>
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           key_format.key_size(),
-          subtle::DilithiumSeedExpansion::SHAKE_SEED_EXPANSION);
+          subtle::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
   if (!key_pair.status().ok()) {
     return key_pair.status();
   }
@@ -79,7 +79,7 @@ DilithiumSignKeyManager::PublicKeySignFactory::Create(
 
   util::StatusOr<DilithiumPrivateKeyPqclean> dilithium_private_key =
       DilithiumPrivateKeyPqclean::NewPrivateKey(
-          sk_data, subtle::DilithiumSeedExpansion::SHAKE_SEED_EXPANSION);
+          sk_data, subtle::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
 
   if (!dilithium_private_key.ok()) return dilithium_private_key.status();
 
diff --git a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc
index c92f26271..05bed14f2 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc
@@ -168,7 +168,7 @@ TEST_P(DilithiumSignKeyManagerTest, Create) {
   util::StatusOr<DilithiumPublicKeyPqclean> dilithium_public_key =
       DilithiumPublicKeyPqclean::NewPublicKey(
           private_key->public_key().key_value(),
-          subtle::DilithiumSeedExpansion::SHAKE_SEED_EXPANSION);
+          subtle::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       subtle::DilithiumAvx2Verify::New(*dilithium_public_key);
@@ -198,7 +198,7 @@ TEST_P(DilithiumSignKeyManagerTest, CreateDifferentKey) {
   util::StatusOr<DilithiumPublicKeyPqclean> dilithium_public_key =
       DilithiumPublicKeyPqclean::NewPublicKey(
           bad_public_key_data,
-          subtle::DilithiumSeedExpansion::SHAKE_SEED_EXPANSION);
+          subtle::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       subtle::DilithiumAvx2Verify::New(*dilithium_public_key);
   ASSERT_THAT(verifier.status(), IsOk());
diff --git a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager.cc b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager.cc
index cfba6ca1b..140eef5ca 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager.cc
@@ -50,7 +50,7 @@ DilithiumVerifyKeyManager::PublicKeyVerifyFactory::Create(
   util::StatusOr<DilithiumPublicKeyPqclean> dilithium_public_key =
       DilithiumPublicKeyPqclean::NewPublicKey(
           public_key.key_value(),
-          subtle::DilithiumSeedExpansion::SHAKE_SEED_EXPANSION);
+          subtle::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
 
   if (!dilithium_public_key.ok()) return dilithium_public_key.status();
 
diff --git a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc
index 8ca697cbc..e5b792a71 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc
@@ -139,7 +139,7 @@ TEST_P(DilithiumVerifyKeyManagerTest, Create) {
   util::StatusOr<DilithiumPrivateKeyPqclean> dilithium_private_key =
       DilithiumPrivateKeyPqclean::NewPrivateKey(
           util::SecretDataFromStringView(private_key->key_value()),
-          subtle::DilithiumSeedExpansion::SHAKE_SEED_EXPANSION);
+          subtle::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
   ASSERT_THAT(dilithium_private_key.status(), IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
@@ -174,7 +174,7 @@ TEST_P(DilithiumVerifyKeyManagerTest, CreateDifferentPublicKey) {
   util::StatusOr<DilithiumPrivateKeyPqclean> dilithium_private_key =
       DilithiumPrivateKeyPqclean::NewPrivateKey(
           util::SecretDataFromStringView(private_key->key_value()),
-          subtle::DilithiumSeedExpansion::SHAKE_SEED_EXPANSION);
+          subtle::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
   ASSERT_THAT(dilithium_private_key.status(), IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign.cc
index 8d01c3160..713bcb6b2 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign.cc
@@ -77,7 +77,7 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
   switch (key_size) {
     case PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES: {
       switch (private_key_.GetSeedExpansion()) {
-        case DilithiumSeedExpansion::AES_SEED_EXPANSION: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
           signature.resize(PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_BYTES, '0');
           result = PQCLEAN_DILITHIUM2AES_AVX2_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
@@ -86,7 +86,7 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
                   private_key_.GetKeyData().data()));
           break;
         }
-        default: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
           signature.resize(PQCLEAN_DILITHIUM2_AVX2_CRYPTO_BYTES, '0');
           result = PQCLEAN_DILITHIUM2_AVX2_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
@@ -96,12 +96,15 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
 
           break;
         }
+        default: {
+          return util::Status(util::error::INTERNAL, "Invalid seed expansion.");
+        }
       }
       break;
     }
     case PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES: {
       switch (private_key_.GetSeedExpansion()) {
-        case DilithiumSeedExpansion::AES_SEED_EXPANSION: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
           signature.resize(PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_BYTES, '0');
           result = PQCLEAN_DILITHIUM3AES_AVX2_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
@@ -110,7 +113,7 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
                   private_key_.GetKeyData().data()));
           break;
         }
-        default: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
           signature.resize(PQCLEAN_DILITHIUM3_AVX2_CRYPTO_BYTES, '0');
           result = PQCLEAN_DILITHIUM3_AVX2_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
@@ -119,12 +122,15 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
                   private_key_.GetKeyData().data()));
           break;
         }
+        default: {
+          return util::Status(util::error::INTERNAL, "Invalid seed expansion.");
+        }
       }
       break;
     }
     case PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES: {
       switch (private_key_.GetSeedExpansion()) {
-        case DilithiumSeedExpansion::AES_SEED_EXPANSION: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
           signature.resize(PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_BYTES, '0');
           result = PQCLEAN_DILITHIUM5AES_AVX2_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
@@ -133,7 +139,7 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
                   private_key_.GetKeyData().data()));
           break;
         }
-        default: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
           signature.resize(PQCLEAN_DILITHIUM5_AVX2_CRYPTO_BYTES, '0');
           result = PQCLEAN_DILITHIUM5_AVX2_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
@@ -142,6 +148,9 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
                   private_key_.GetKeyData().data()));
           break;
         }
+        default: {
+          return util::Status(util::error::INTERNAL, "Invalid seed expansion.");
+        }
       }
       break;
     }
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc
index b79662b6b..03a50bf6b 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc
@@ -77,7 +77,7 @@ TEST(DilithiumAvx2SignTest, InvalidPrivateKeys) {
     EXPECT_FALSE(
         DilithiumAvx2Sign::New(
             *DilithiumPrivateKeyPqclean::NewPrivateKey(
-                key_data, DilithiumSeedExpansion::SHAKE_SEED_EXPANSION))
+                key_data, DilithiumSeedExpansion::SEED_EXPANSION_SHAKE))
             .ok());
   }
 }
@@ -182,22 +182,22 @@ INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn<DilithiumTestCase>({
         {"Dilithium2", PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM2_AVX2_CRYPTO_BYTES,
-         DilithiumSeedExpansion::SHAKE_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
         {"Dilithium3", PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM3_AVX2_CRYPTO_BYTES,
-         DilithiumSeedExpansion::SHAKE_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
         {"Dilithium5", PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM5_AVX2_CRYPTO_BYTES,
-         DilithiumSeedExpansion::SHAKE_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
         {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_BYTES,
-         DilithiumSeedExpansion::AES_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_AES},
         {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM3_AVX2_CRYPTO_BYTES,
-         DilithiumSeedExpansion::AES_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_AES},
         {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_BYTES,
-         DilithiumSeedExpansion::AES_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_AES},
     }),
     [](const testing::TestParamInfo<DilithiumAvx2SignTest::ParamType>& info) {
       return info.param.test_name;
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify.cc
index c98e54f38..25d4c86eb 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify.cc
@@ -73,7 +73,7 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
   switch (key_size) {
     case PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES: {
       switch (public_key_.GetSeedExpansion()) {
-        case DilithiumSeedExpansion::AES_SEED_EXPANSION: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
           result = PQCLEAN_DILITHIUM2AES_AVX2_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
@@ -83,7 +83,7 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
 
           break;
         }
-        default: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
           result = PQCLEAN_DILITHIUM2_AVX2_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
@@ -92,12 +92,15 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
                   public_key_.GetKeyData().data()));
           break;
         }
+        default: {
+          return util::Status(util::error::INTERNAL, "Invalid seed expansion.");
+        }
       }
       break;
     }
     case PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES: {
       switch (public_key_.GetSeedExpansion()) {
-        case DilithiumSeedExpansion::AES_SEED_EXPANSION: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
           result = PQCLEAN_DILITHIUM3AES_AVX2_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
@@ -106,7 +109,7 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
                   public_key_.GetKeyData().data()));
           break;
         }
-        default: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
           result = PQCLEAN_DILITHIUM3_AVX2_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
@@ -115,12 +118,15 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
                   public_key_.GetKeyData().data()));
           break;
         }
+        default: {
+          return util::Status(util::error::INTERNAL, "Invalid seed expansion.");
+        }
       }
       break;
     }
     case PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES: {
       switch (public_key_.GetSeedExpansion()) {
-        case DilithiumSeedExpansion::AES_SEED_EXPANSION: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
           result = PQCLEAN_DILITHIUM5AES_AVX2_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
@@ -129,7 +135,7 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
                   public_key_.GetKeyData().data()));
           break;
         }
-        default: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
           result = PQCLEAN_DILITHIUM5_AVX2_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
@@ -138,6 +144,9 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
                   public_key_.GetKeyData().data()));
           break;
         }
+        default: {
+          return util::Status(util::error::INTERNAL, "Invalid seed expansion.");
+        }
       }
       break;
     }
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc
index 19e416662..2e9cae07a 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc
@@ -70,7 +70,7 @@ TEST(DilithiumAvx2VerifyTest, InvalidPublicKeys) {
   EXPECT_FALSE(
       DilithiumAvx2Verify::New(
           *DilithiumPublicKeyPqclean::NewPublicKey(
-              null_public_key, DilithiumSeedExpansion::SHAKE_SEED_EXPANSION))
+              null_public_key, DilithiumSeedExpansion::SEED_EXPANSION_SHAKE))
           .ok());
 
   for (int keysize = 0; keysize < PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES;
@@ -84,7 +84,7 @@ TEST(DilithiumAvx2VerifyTest, InvalidPublicKeys) {
     std::string key(keysize, 'x');
     EXPECT_FALSE(DilithiumAvx2Verify::New(
                      *DilithiumPublicKeyPqclean::NewPublicKey(
-                         key, DilithiumSeedExpansion::SHAKE_SEED_EXPANSION))
+                         key, DilithiumSeedExpansion::SEED_EXPANSION_SHAKE))
                      .ok());
   }
 }
@@ -862,7 +862,7 @@ TEST(DilithiumAvx2VerifyTest, Vectors) {
     // Create a new verifier.
     absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
         DilithiumAvx2Verify::New(*DilithiumPublicKeyPqclean::NewPublicKey(
-            v.public_key, DilithiumSeedExpansion::SHAKE_SEED_EXPANSION));
+            v.public_key, DilithiumSeedExpansion::SEED_EXPANSION_SHAKE));
     ASSERT_THAT(verifier.status(), IsOk());
 
     // Verify signature.
@@ -1418,7 +1418,7 @@ TEST(DilithiumAvx2VerifyTest, AesVectors) {
     // Create a new verifier.
     absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
         DilithiumAvx2Verify::New(*DilithiumPublicKeyPqclean::NewPublicKey(
-            v.public_key, DilithiumSeedExpansion::AES_SEED_EXPANSION));
+            v.public_key, DilithiumSeedExpansion::SEED_EXPANSION_AES));
     ASSERT_THAT(verifier.status(), IsOk());
 
     // Verify signature.
@@ -1431,17 +1431,17 @@ INSTANTIATE_TEST_SUITE_P(
     DilithiumAvx2VerifyTests, DilithiumAvx2VerifyTest,
     testing::ValuesIn<DilithiumTestCase>({
         {"Dilithium2", PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
-         DilithiumSeedExpansion::SHAKE_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
         {"Dilithium3", PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
-         DilithiumSeedExpansion::SHAKE_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
         {"Dilithium5", PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
-         DilithiumSeedExpansion::SHAKE_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
         {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         DilithiumSeedExpansion::AES_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_AES},
         {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         DilithiumSeedExpansion::AES_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_AES},
         {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         DilithiumSeedExpansion::AES_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_AES},
     }),
     [](const testing::TestParamInfo<DilithiumAvx2VerifyTest::ParamType>& info) {
       return info.param.test_name;
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_key.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_key.cc
index 5b6953ea2..39aec41ad 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_key.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_key.cc
@@ -57,60 +57,72 @@ DilithiumPrivateKeyPqclean::GenerateKeyPair(
     // Dilithium2.
     case PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES: {
       switch (seed_expansion) {
-        case DilithiumSeedExpansion::AES_SEED_EXPANSION: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
           public_key.resize(PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_PUBLICKEYBYTES);
           PQCLEAN_DILITHIUM2AES_AVX2_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
         }
-        default: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
           public_key.resize(PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES);
           PQCLEAN_DILITHIUM2_AVX2_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
         }
+        default: {
+          return util::Status(util::error::INVALID_ARGUMENT,
+                              "Invalid seed expansion");
+        }
       }
       break;
     }
     // Dilithium3.
     case PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES: {
       switch (seed_expansion) {
-        case DilithiumSeedExpansion::AES_SEED_EXPANSION: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
           public_key.resize(PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_PUBLICKEYBYTES);
           PQCLEAN_DILITHIUM3AES_AVX2_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
         }
-        default: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
           public_key.resize(PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES);
           PQCLEAN_DILITHIUM3_AVX2_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
         }
+        default: {
+          return util::Status(util::error::INVALID_ARGUMENT,
+                              "Invalid seed expansion");
+        }
       }
       break;
     }
     // Dilithium5.
     case PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES: {
       switch (seed_expansion) {
-        case DilithiumSeedExpansion::AES_SEED_EXPANSION: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
           public_key.resize(PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_PUBLICKEYBYTES);
           PQCLEAN_DILITHIUM5AES_AVX2_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
         }
-        default: {
+        case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
           public_key.resize(PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES);
           PQCLEAN_DILITHIUM5_AVX2_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
         }
+        default: {
+          return util::Status(util::error::INVALID_ARGUMENT,
+                              "Invalid seed expansion");
+        }
       }
       break;
     }
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_key.h b/cc/experimental/pqcrypto/signature/subtle/dilithium_key.h
index 0723eaef5..cab6f0ef9 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_key.h
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_key.h
@@ -30,10 +30,12 @@ namespace tink {
 namespace subtle {
 
 enum class DilithiumSeedExpansion {
-  SHAKE_SEED_EXPANSION = 0,
-  AES_SEED_EXPANSION = 1,
+  SEED_EXPANSION_UNKNOWN = 0,
+  SEED_EXPANSION_SHAKE = 1,
+  SEED_EXPANSION_AES = 2,
 };
 
+
 // Dilithium public key representation.
 class DilithiumPublicKeyPqclean {
  public:
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc
index 1bf59a408..3bd78ea55 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc
@@ -88,22 +88,22 @@ INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn<DilithiumTestCase>({
         {"Dilithium2", PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES,
-         DilithiumSeedExpansion::SHAKE_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
         {"Dilithium3", PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES,
-         DilithiumSeedExpansion::SHAKE_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
         {"Dilithium5", PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES,
-         DilithiumSeedExpansion::SHAKE_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
         {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_PUBLICKEYBYTES,
-         DilithiumSeedExpansion::AES_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_AES},
         {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_PUBLICKEYBYTES,
-         DilithiumSeedExpansion::AES_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_AES},
         {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
          PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_PUBLICKEYBYTES,
-         DilithiumSeedExpansion::AES_SEED_EXPANSION},
+         DilithiumSeedExpansion::SEED_EXPANSION_AES},
     }),
     [](const testing::TestParamInfo<DilithiumKeyTest::ParamType>& info) {
       return info.param.test_name;