Update QUICHE copybara for Anonymous Tokens library changes. PiperOrigin-RevId: 519880140

diff --git a/build/source_list.bzl b/build/source_list.bzl
index 7303216..3ef9b8b 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl

@@ -1555,6 +1555,9 @@
     "blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.h",
     "blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.h",
     "blind_sign_auth/anonymous_tokens/cpp/crypto/verifier.h",
+    "blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.h",
+    "blind_sign_auth/anonymous_tokens/cpp/shared/status_utils.h",
+    "blind_sign_auth/anonymous_tokens/cpp/testing/utils.h",
     "blind_sign_auth/blind_sign_auth.h",
     "blind_sign_auth/blind_sign_auth_interface.h",
     "blind_sign_auth/blind_sign_http_interface.h",
@@ -1569,6 +1572,8 @@
     "blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer.cc",
     "blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.cc",
     "blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.cc",
+    "blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.cc",
+    "blind_sign_auth/anonymous_tokens/cpp/testing/utils.cc",
     "blind_sign_auth/blind_sign_auth.cc",
     "blind_sign_auth/cached_blind_sign_auth.cc",
 ]
@@ -1581,6 +1586,7 @@
     "blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc",
     "blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc",
     "blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc",
+    "blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils_test.cc",
     "blind_sign_auth/blind_sign_auth_test.cc",
     "blind_sign_auth/cached_blind_sign_auth_test.cc",
 ]

diff --git a/build/source_list.gni b/build/source_list.gni
index 1cc5dce..cd0d0c1 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni

@@ -1555,6 +1555,9 @@
     "src/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.h",
     "src/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.h",
     "src/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/verifier.h",
+    "src/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.h",
+    "src/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/status_utils.h",
+    "src/quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.h",
     "src/quiche/blind_sign_auth/blind_sign_auth.h",
     "src/quiche/blind_sign_auth/blind_sign_auth_interface.h",
     "src/quiche/blind_sign_auth/blind_sign_http_interface.h",
@@ -1569,6 +1572,8 @@
     "src/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer.cc",
     "src/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.cc",
     "src/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.cc",
+    "src/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.cc",
+    "src/quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.cc",
     "src/quiche/blind_sign_auth/blind_sign_auth.cc",
     "src/quiche/blind_sign_auth/cached_blind_sign_auth.cc",
 ]
@@ -1581,6 +1586,7 @@
     "src/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc",
     "src/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc",
     "src/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc",
+    "src/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils_test.cc",
     "src/quiche/blind_sign_auth/blind_sign_auth_test.cc",
     "src/quiche/blind_sign_auth/cached_blind_sign_auth_test.cc",
 ]

diff --git a/build/source_list.json b/build/source_list.json
index b70ed61..561a1d4 100644
--- a/build/source_list.json
+++ b/build/source_list.json

@@ -1554,6 +1554,9 @@
     "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.h",
     "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.h",
     "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/verifier.h",
+    "quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.h",
+    "quiche/blind_sign_auth/anonymous_tokens/cpp/shared/status_utils.h",
+    "quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.h",
     "quiche/blind_sign_auth/blind_sign_auth.h",
     "quiche/blind_sign_auth/blind_sign_auth_interface.h",
     "quiche/blind_sign_auth/blind_sign_http_interface.h",
@@ -1568,6 +1571,8 @@
     "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer.cc",
     "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.cc",
     "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.cc",
+    "quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.cc",
+    "quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.cc",
     "quiche/blind_sign_auth/blind_sign_auth.cc",
     "quiche/blind_sign_auth/cached_blind_sign_auth.cc"
   ],
@@ -1580,6 +1585,7 @@
     "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc",
     "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc",
     "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc",
+    "quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils_test.cc",
     "quiche/blind_sign_auth/blind_sign_auth_test.cc",
     "quiche/blind_sign_auth/cached_blind_sign_auth_test.cc"
   ],

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client.h b/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client.h
index b2eec59..16f66fe 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client.h
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client.h

@@ -26,7 +26,7 @@
 #include "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.h"
 #include "quiche/blind_sign_auth/anonymous_tokens/proto/anonymous_tokens.pb.h"
 #include "openssl/rsa.h"
-// #include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/platform/api/quiche_export.h"
 
 namespace private_membership {
 namespace anonymous_tokens {

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client_test.cc
index e26b382..81986df 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client_test.cc

@@ -52,33 +52,33 @@
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, Success) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto rsa_key, CreateClientTestKey());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto rsa_key, CreateClientTestKey());
   QUICHE_EXPECT_OK(AnonymousTokensRsaBssaClient::Create(rsa_key.second));
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, InvalidUseCase) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto rsa_key,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto rsa_key,
                                    CreateClientTestKey("INVALID_USE_CASE"));
   EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.second),
               StatusIs(absl::StatusCode::kInvalidArgument));
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, NotAUseCase) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto rsa_key,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto rsa_key,
                                    CreateClientTestKey("NOT_A_USE_CASE"));
   EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.second),
               StatusIs(absl::StatusCode::kInvalidArgument));
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, InvalidKeyVersion) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto rsa_key,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto rsa_key,
                                    CreateClientTestKey("TEST_USE_CASE", 0));
   EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.second),
               StatusIs(absl::StatusCode::kInvalidArgument));
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, InvalidMessageMaskType) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto rsa_key,
       CreateClientTestKey("TEST_USE_CASE", 0, AT_MESSAGE_MASK_TYPE_UNDEFINED));
   EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.second),
@@ -86,7 +86,7 @@
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, InvalidMessageMaskSize) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto rsa_key,
       CreateClientTestKey("TEST_USE_CASE", 0, AT_MESSAGE_MASK_CONCAT, 0));
   EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.second),
@@ -96,10 +96,10 @@
 class AnonymousTokensRsaBssaClientTest : public testing::Test {
  protected:
   void SetUp() override {
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto key, CreateClientTestKey());
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto key, CreateClientTestKey());
     rsa_key_ = std::move(key.first);
     public_key_ = std::move(key.second);
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
         client_, AnonymousTokensRsaBssaClient::Create(public_key_));
   }
 
@@ -138,21 +138,21 @@
 };
 
 TEST_F(AnonymousTokensRsaBssaClientTest, SuccessOneMessage) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignRequest request,
       client_->CreateRequest(CreateInput({"message"})));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
                                    CreateResponse(request));
   QUICHE_EXPECT_OK(client_->ProcessResponse(response));
   EXPECT_EQ(response.anonymous_tokens_size(), 1);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, SuccessMultipleMessages) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignRequest request,
       client_->CreateRequest(CreateInput(
           {"message1", "msg2", "anotherMessage", "one_more_message"})));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
                                    CreateResponse(request));
   EXPECT_EQ(response.anonymous_tokens_size(), 4);
   QUICHE_EXPECT_OK(client_->ProcessResponse(response));
@@ -160,12 +160,12 @@
 
 TEST_F(AnonymousTokensRsaBssaClientTest, EnsureRandomTokens) {
   std::string message = "test_same_message";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignRequest request,
       client_->CreateRequest(CreateInput({message, message})));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
                                    CreateResponse(request));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::vector<RSABlindSignatureTokenWithInput> tokens,
       client_->ProcessResponse(response));
   ASSERT_EQ(tokens.size(), 2);
@@ -184,10 +184,10 @@
 TEST_F(AnonymousTokensRsaBssaClientTest, NotYetValidKey) {
   RSABlindSignaturePublicKey not_valid_key = public_key_;
   absl::Time start_time = absl::Now() + absl::Minutes(100);
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       *not_valid_key.mutable_key_validity_start_time(),
       TimeToProto(start_time));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<AnonymousTokensRsaBssaClient> client,
       AnonymousTokensRsaBssaClient::Create(not_valid_key));
   EXPECT_THAT(client->CreateRequest(CreateInput({"message"})),
@@ -197,9 +197,9 @@
 TEST_F(AnonymousTokensRsaBssaClientTest, ExpiredKey) {
   RSABlindSignaturePublicKey expired_key = public_key_;
   absl::Time end_time = absl::Now() - absl::Seconds(1);
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(*expired_key.mutable_expiration_time(),
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(*expired_key.mutable_expiration_time(),
                                    TimeToProto(end_time));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<AnonymousTokensRsaBssaClient> client,
       AnonymousTokensRsaBssaClient::Create(expired_key));
   EXPECT_THAT(client->CreateRequest(CreateInput({"message"})),
@@ -219,7 +219,7 @@
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ProcessEmptyResponse) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignRequest request,
       client_->CreateRequest(CreateInput({"message"})));
   AnonymousTokensSignResponse response;
@@ -228,10 +228,10 @@
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ProcessResponseWithBadUseCase) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignRequest request,
       client_->CreateRequest(CreateInput({"message"})));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
                                    CreateResponse(request));
   response.mutable_anonymous_tokens(0)->set_use_case("TEST_USE_CASE_2");
   EXPECT_THAT(client_->ProcessResponse(response),
@@ -239,10 +239,10 @@
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ProcessResponseWithBadKeyVersion) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignRequest request,
       client_->CreateRequest(CreateInput({"message"})));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
                                    CreateResponse(request));
   response.mutable_anonymous_tokens(0)->set_key_version(2);
   EXPECT_THAT(client_->ProcessResponse(response),
@@ -250,18 +250,18 @@
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ProcessResponseFromDifferentClient) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<AnonymousTokensRsaBssaClient> client2,
       AnonymousTokensRsaBssaClient::Create(public_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignRequest request1,
       client_->CreateRequest(CreateInput({"message"})));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignRequest request2,
       client2->CreateRequest(CreateInput({"message"})));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(AnonymousTokensSignResponse response1,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response1,
                                    CreateResponse(request1));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(AnonymousTokensSignResponse response2,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response2,
                                    CreateResponse(request2));
   EXPECT_THAT(client_->ProcessResponse(response2),
               StatusIs(absl::StatusCode::kInvalidArgument));

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/at_crypto_utils_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/at_crypto_utils_test.cc
index d007d44..e50e490 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/at_crypto_utils_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/at_crypto_utils_test.cc

@@ -38,21 +38,21 @@
 };
 
 TEST(CryptoUtilsTest, BignumToStringAndBack) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(BnCtxPtr ctx, GetAndStartBigNumCtx());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(BnCtxPtr ctx, GetAndStartBigNumCtx());
 
   // Create a new BIGNUM using the context and set it
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> bn_1, NewBigNum());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> bn_1, NewBigNum());
   ASSERT_EQ(BN_set_u64(bn_1.get(), 0x124435435), 1);
   EXPECT_NE(bn_1, nullptr);
   EXPECT_EQ(BN_is_zero(bn_1.get()), 0);
   EXPECT_EQ(BN_is_one(bn_1.get()), 0);
 
   // Convert bn_1 to string from BIGNUM
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const std::string converted_str,
       BignumToString(*bn_1, BN_num_bytes(bn_1.get())));
   // Convert the string version of bn_1 back to BIGNUM
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> bn_2,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> bn_2,
                                    StringToBignum(converted_str));
   // Check whether the conversion back worked
   EXPECT_EQ(BN_cmp(bn_1.get(), bn_2.get()), 0);
@@ -60,11 +60,11 @@
 
 TEST(CryptoUtilsTest, PowerOfTwoAndRsaSqrtTwo) {
   // Compute 2^(10-1/2).
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> sqrt2,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> sqrt2,
                                    GetRsaSqrtTwo(10));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> small_pow2,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> small_pow2,
                                    ComputePowerOfTwo(9));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> large_pow2,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> large_pow2,
                                    ComputePowerOfTwo(10));
   EXPECT_GT(BN_cmp(sqrt2.get(), small_pow2.get()), 0);
   EXPECT_LT(BN_cmp(sqrt2.get(), large_pow2.get()), 0);
@@ -86,18 +86,18 @@
 }
 
 TEST(CryptoUtilsTest, ComputeCarmichaelLcm) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(BnCtxPtr ctx, GetAndStartBigNumCtx());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(BnCtxPtr ctx, GetAndStartBigNumCtx());
 
   // Suppose that N = 1019 * 1187.
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> phi_p, NewBigNum());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> phi_p, NewBigNum());
   ASSERT_TRUE(BN_set_word(phi_p.get(), 1019 - 1));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> phi_q, NewBigNum());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> phi_q, NewBigNum());
   ASSERT_TRUE(BN_set_word(phi_q.get(), 1187 - 1));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> expected_lcm,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> expected_lcm,
                                    NewBigNum());
   ASSERT_TRUE(BN_set_word(expected_lcm.get(), (1019 - 1) * (1187 - 1) / 2));
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> lcm,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> lcm,
                                    ComputeCarmichaelLcm(*phi_p, *phi_q, *ctx));
   EXPECT_EQ(BN_cmp(lcm.get(), expected_lcm.get()), 0);
 }
@@ -146,7 +146,7 @@
   std::string data = absl::HexStringToBytes(params.input_hex);
   std::string expected_digest =
       absl::HexStringToBytes(params.expected_digest_hex);
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto computed_hash,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto computed_hash,
                                    ComputeHash(data, *params.hasher));
   EXPECT_EQ(computed_hash, expected_digest);
 }
@@ -155,24 +155,24 @@
                          testing::ValuesIn(GetComputeHashTestParams()));
 
 TEST(CryptoUtilsInternalTest, PublicMetadataHashWithHKDF) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(BnCtxPtr ctx, GetAndStartBigNumCtx());
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> max_value,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(BnCtxPtr ctx, GetAndStartBigNumCtx());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> max_value,
                                    NewBigNum());
   ASSERT_TRUE(BN_set_word(max_value.get(), 4294967296));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto key_pair, GetStrongRsaKeys2048());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto key_pair, GetStrongRsaKeys2048());
   std::string input1 = "ro1";
   std::string input2 = "ro2";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> output1,
       internal::PublicMetadataHashWithHKDF(input1, key_pair.first.n(),
                                            1 + input1.size()));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> another_output1,
       internal::PublicMetadataHashWithHKDF(input1, key_pair.first.n(),
                                            1 + input1.size()));
   EXPECT_EQ(BN_cmp(output1.get(), another_output1.get()), 0);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> output2,
       internal::PublicMetadataHashWithHKDF(input2, key_pair.first.n(),
                                            1 + input2.size()));
@@ -183,20 +183,20 @@
 }
 
 TEST(CryptoUtilsTest, PublicExponentHashDifferentModulus) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto key_pair_1, GetStrongRsaKeys2048());
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto key_pair_2,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto key_pair_1, GetStrongRsaKeys2048());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto key_pair_2,
                                    GetAnotherStrongRsaKeys2048());
   std::string metadata = "md";
   // Check that same metadata and different modulus result in different
   // hashes.
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> rsa_modulus_1,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> rsa_modulus_1,
                                    StringToBignum(key_pair_1.first.n()));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> exp1,
       PublicMetadataExponent(*rsa_modulus_1.get(), metadata));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto rsa_modulus_2,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto rsa_modulus_2,
                                    StringToBignum(key_pair_2.first.n()));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> exp2,
       PublicMetadataExponent(*rsa_modulus_2.get(), metadata));
   EXPECT_NE(BN_cmp(exp1.get(), exp2.get()), 0);
@@ -246,15 +246,15 @@
       GetIetfNewPublicExponentWithPublicMetadataTestVectors();
   for (const IetfNewPublicExponentWithPublicMetadataTestVector& test_vector :
        test_vectors) {
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
         bssl::UniquePtr<BIGNUM> rsa_modulus,
         StringToBignum(test_vector.public_key.n()));
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
         bssl::UniquePtr<BIGNUM> rsa_e,
         StringToBignum(test_vector.public_key.e()));
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> expected_new_e,
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> expected_new_e,
                                      StringToBignum(test_vector.new_e));
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
         bssl::UniquePtr<BIGNUM> modified_e,
         ComputeFinalExponentUnderPublicMetadata(
             *rsa_modulus.get(), *rsa_e.get(), test_vector.public_metadata));
@@ -270,15 +270,15 @@
     : public testing::TestWithParam<CreateTestKeyPairFunction*> {
  protected:
   void SetUp() override {
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto keys_pair, (*GetParam())());
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto keys_pair, (*GetParam())());
     public_key_ = std::move(keys_pair.first);
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(rsa_modulus_,
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(rsa_modulus_,
                                      StringToBignum(keys_pair.second.n()));
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(rsa_e_,
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(rsa_e_,
                                      StringToBignum(keys_pair.second.e()));
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(rsa_p_,
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(rsa_p_,
                                      StringToBignum(keys_pair.second.p()));
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(rsa_q_,
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(rsa_q_,
                                      StringToBignum(keys_pair.second.q()));
   }
 
@@ -291,14 +291,14 @@
 
 TEST_P(CryptoUtilsTest, PublicExponentCoprime) {
   std::string metadata = "md";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> exp,
       PublicMetadataExponent(*rsa_modulus_.get(), metadata));
   int rsa_mod_size_bits = BN_num_bits(rsa_modulus_.get());
   // Check that exponent is odd.
   EXPECT_EQ(BN_is_odd(exp.get()), 1);
   // Check that exponent is small enough.
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> sqrt2,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> sqrt2,
                                    GetRsaSqrtTwo(rsa_mod_size_bits / 2));
   EXPECT_LT(BN_cmp(exp.get(), sqrt2.get()), 0);
   EXPECT_LT(BN_cmp(exp.get(), rsa_p_.get()), 0);
@@ -309,15 +309,15 @@
   std::string metadata1 = "md1";
   std::string metadata2 = "md2";
   // Check that hash is deterministic.
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> exp1,
       PublicMetadataExponent(*rsa_modulus_.get(), metadata1));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> another_exp1,
       PublicMetadataExponent(*rsa_modulus_.get(), metadata1));
   EXPECT_EQ(BN_cmp(exp1.get(), another_exp1.get()), 0);
   // Check that hashes are distinct for different metadata.
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> exp2,
       PublicMetadataExponent(*rsa_modulus_.get(), metadata2));
   EXPECT_NE(BN_cmp(exp1.get(), exp2.get()), 0);
@@ -325,21 +325,21 @@
 
 TEST_P(CryptoUtilsTest, FinalExponentCoprime) {
   std::string metadata = "md";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> final_exponent,
       ComputeFinalExponentUnderPublicMetadata(*rsa_modulus_.get(),
                                               *rsa_e_.get(), metadata));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(BnCtxPtr ctx, GetAndStartBigNumCtx());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(BnCtxPtr ctx, GetAndStartBigNumCtx());
 
   // Check that exponent is odd.
   EXPECT_EQ(BN_is_odd(final_exponent.get()), 1);
   // Check that exponent is co-prime to factors of the rsa modulus.
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> gcd_p_fe,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> gcd_p_fe,
                                    NewBigNum());
   ASSERT_EQ(
       BN_gcd(gcd_p_fe.get(), rsa_p_.get(), final_exponent.get(), ctx.get()), 1);
   EXPECT_EQ(BN_cmp(gcd_p_fe.get(), BN_value_one()), 0);
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> gcd_q_fe,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> gcd_q_fe,
                                    NewBigNum());
   ASSERT_EQ(
       BN_gcd(gcd_q_fe.get(), rsa_q_.get(), final_exponent.get(), ctx.get()), 1);
@@ -348,11 +348,11 @@
 
 TEST_P(CryptoUtilsTest, DeterministicModificationOfPublicExponentWithMetadata) {
   std::string metadata = "md";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> public_exp_1,
       ComputeFinalExponentUnderPublicMetadata(*rsa_modulus_.get(),
                                               *rsa_e_.get(), metadata));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> public_exp_2,
       ComputeFinalExponentUnderPublicMetadata(*rsa_modulus_.get(),
                                               *rsa_e_.get(), metadata));
@@ -363,11 +363,11 @@
 TEST_P(CryptoUtilsTest, DifferentPublicExponentWithDifferentPublicMetadata) {
   std::string metadata_1 = "md1";
   std::string metadata_2 = "md2";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> public_exp_1,
       ComputeFinalExponentUnderPublicMetadata(*rsa_modulus_.get(),
                                               *rsa_e_.get(), metadata_1));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       bssl::UniquePtr<BIGNUM> public_exp_2,
       ComputeFinalExponentUnderPublicMetadata(*rsa_modulus_.get(),
                                               *rsa_e_.get(), metadata_2));
@@ -378,7 +378,7 @@
 }
 
 TEST_P(CryptoUtilsTest, ModifiedPublicExponentWithEmptyPublicMetadata) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> new_public_exp,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(bssl::UniquePtr<BIGNUM> new_public_exp,
                                    ComputeFinalExponentUnderPublicMetadata(
                                        *rsa_modulus_.get(), *rsa_e_.get(), ""));
 

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/crypto_utils.h b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/crypto_utils.h
index a776e59..1e938f8 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/crypto_utils.h
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/crypto_utils.h

@@ -27,7 +27,7 @@
 #include "openssl/bn.h"
 #include "openssl/evp.h"
 #include "openssl/rsa.h"
-// #include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/platform/api/quiche_export.h"
 
 namespace private_membership {
 namespace anonymous_tokens {

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc
index a15fa30..57d9755 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc

@@ -43,7 +43,7 @@
     : public ::testing::TestWithParam<CreateTestKeyPairFunction *> {
  protected:
   void SetUp() override {
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto keys_pair, (*GetParam())());
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto keys_pair, (*GetParam())());
     public_key_ = std::move(keys_pair.first);
     private_key_ = std::move(keys_pair.second);
     generator_.seed(0);
@@ -69,22 +69,22 @@
 // proven/analyzed.
 TEST_P(RsaBlindSignerTest, SignerWorks) {
   absl::string_view message = "Hello World!";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string encoded_message,
       EncodeMessageForTests(message, public_key_, sig_hash_, mgf1_hash_,
                             salt_length_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::unique_ptr<RsaBlindSigner> signer,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlindSigner> signer,
                                    RsaBlindSigner::New(private_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string potentially_insecure_signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string potentially_insecure_signature,
                                    signer->Sign(encoded_message));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const auto verifier,
       RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_, public_key_));
   QUICHE_EXPECT_OK(verifier->Verify(potentially_insecure_signature, message));
 }
 
 TEST_P(RsaBlindSignerTest, SignerFails) {
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::unique_ptr<RsaBlindSigner> signer,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlindSigner> signer,
                                    RsaBlindSigner::New(private_key_));
   absl::string_view message = "Hello World!";
   EXPECT_THAT(signer->Sign(message),
@@ -94,9 +94,9 @@
 
   int sig_size = public_key_.n().size();
   std::string message2 = RandomString(sig_size, &distr_u8_, &generator_);
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string insecure_sig,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string insecure_sig,
                                    signer->Sign(message2));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const auto verifier,
       RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_, public_key_));
   EXPECT_THAT(
@@ -116,7 +116,7 @@
     : public ::testing::TestWithParam<CreateTestKeyPairFunction *> {
  protected:
   void SetUp() override {
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto keys_pair, (*GetParam())());
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto keys_pair, (*GetParam())());
     public_key_ = std::move(keys_pair.first);
     private_key_ = std::move(keys_pair.second);
     // NOTE: using recommended RsaSsaPssParams
@@ -139,16 +139,16 @@
 TEST_P(RsaBlindSignerTestWithPublicMetadata, SignerWorksWithPublicMetadata) {
   absl::string_view message = "Hello World!";
   absl::string_view public_metadata = "pubmd!";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string encoded_message,
       EncodeMessageForTests(message, public_key_, sig_hash_, mgf1_hash_,
                             salt_length_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<RsaBlindSigner> signer,
       RsaBlindSigner::New(private_key_, public_metadata));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string potentially_insecure_signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string potentially_insecure_signature,
                                    signer->Sign(encoded_message));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata));
   QUICHE_EXPECT_OK(verifier->Verify(potentially_insecure_signature, message));
@@ -159,16 +159,16 @@
   absl::string_view message = "Hello World!";
   absl::string_view public_metadata = "pubmd!";
   absl::string_view public_metadata_2 = "pubmd2";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string encoded_message,
       EncodeMessageForTests(message, public_key_, sig_hash_, mgf1_hash_,
                             salt_length_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<RsaBlindSigner> signer,
       RsaBlindSigner::New(private_key_, public_metadata));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string potentially_insecure_signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string potentially_insecure_signature,
                                    signer->Sign(encoded_message));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata_2));
   EXPECT_THAT(
@@ -182,16 +182,16 @@
   absl::string_view message = "Hello World!";
   absl::string_view public_metadata = "pubmd!";
   absl::string_view public_metadata_2 = "";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string encoded_message,
       EncodeMessageForTests(message, public_key_, sig_hash_, mgf1_hash_,
                             salt_length_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<RsaBlindSigner> signer,
       RsaBlindSigner::New(private_key_, public_metadata));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string potentially_insecure_signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string potentially_insecure_signature,
                                    signer->Sign(encoded_message));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata_2));
   EXPECT_THAT(

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.h b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.h
index 1dd77e6..d6798a7 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.h
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder.h

@@ -26,7 +26,7 @@
 #include "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/blinder.h"
 #include "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/crypto_utils.h"
 #include "quiche/blind_sign_auth/anonymous_tokens/proto/anonymous_tokens.pb.h"
-// #include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/platform/api/quiche_export.h"
 
 namespace private_membership {
 namespace anonymous_tokens {

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc
index d4f44a5..68274aa 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc

@@ -66,7 +66,7 @@
 class RsaBlinderTest : public testing::TestWithParam<CreateTestKeyFunction*> {
  protected:
   void SetUp() override {
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto test_key, (*GetParam())());
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto test_key, (*GetParam())());
     rsa_key_ = std::move(test_key.first);
     public_key_ = std::move(test_key.second);
   }
@@ -78,18 +78,18 @@
 TEST_P(RsaBlinderTest, BlindSignUnblindEnd2EndTest) {
   const absl::string_view message = "Hello World!";
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
                                    RsaBlinder::New(public_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string blinded_message,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string blinded_message,
                                    blinder->Blind(message));
   EXPECT_NE(blinded_message, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string blinded_signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string blinded_signature,
                                    TestSign(blinded_message, rsa_key_.get()));
   EXPECT_NE(blinded_signature, blinded_message);
   EXPECT_NE(blinded_signature, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string signature,
                                    blinder->Unblind(blinded_signature));
   EXPECT_NE(signature, blinded_signature);
   EXPECT_NE(signature, blinded_message);
@@ -100,9 +100,9 @@
 
 TEST_P(RsaBlinderTest, DoubleBlindingFailure) {
   const absl::string_view message = "Hello World2!";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
                                    RsaBlinder::New(public_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const std::string blinded_message,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const std::string blinded_message,
                                    blinder->Blind(message));
   // Blind the blinded_message
   absl::StatusOr<std::string> result = blinder->Blind(blinded_message);
@@ -117,13 +117,13 @@
 
 TEST_P(RsaBlinderTest, DoubleUnblindingFailure) {
   const absl::string_view message = "Hello World2!";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
                                    RsaBlinder::New(public_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const std::string blinded_message,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const std::string blinded_message,
                                    blinder->Blind(message));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const std::string blinded_signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const std::string blinded_signature,
                                    TestSign(blinded_message, rsa_key_.get()));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string signature,
                                    blinder->Unblind(blinded_signature));
   // Unblind the unblinded signature
   absl::StatusOr<std::string> result = blinder->Unblind(signature);
@@ -137,13 +137,13 @@
 
 TEST_P(RsaBlinderTest, InvalidSignature) {
   const absl::string_view message = "Hello World2!";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
                                    RsaBlinder::New(public_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const std::string blinded_message,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const std::string blinded_message,
                                    blinder->Blind(message));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const std::string blinded_signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const std::string blinded_signature,
                                    TestSign(blinded_message, rsa_key_.get()));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string signature,
                                    blinder->Unblind(blinded_signature));
   QUICHE_EXPECT_OK(blinder->Verify(signature, message));
 
@@ -162,17 +162,17 @@
 
 TEST_P(RsaBlinderTest, InvalidVerificationKey) {
   const absl::string_view message = "Hello World4!";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
                                    RsaBlinder::New(public_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const std::string blinded_message,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const std::string blinded_message,
                                    blinder->Blind(message));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const std::string blinded_signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const std::string blinded_signature,
                                    TestSign(blinded_message, rsa_key_.get()));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string signature,
                                    blinder->Unblind(blinded_signature));
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto bad_key, CreateTestKey());
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> bad_blinder,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto bad_key, CreateTestKey());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> bad_blinder,
                                    RsaBlinder::New(bad_key.second));
   EXPECT_THAT(bad_blinder->Verify(signature, message).code(),
               absl::StatusCode::kInvalidArgument);
@@ -192,7 +192,7 @@
     : public testing::TestWithParam<CreateTestKeyPairFunction*> {
  protected:
   void SetUp() override {
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto test_key, (*GetParam())());
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto test_key, (*GetParam())());
     RSABlindSignaturePublicKey public_key;
     public_key.set_sig_hash_type(HashType::AT_HASH_TYPE_SHA384);
     public_key.set_mask_gen_function(AT_MGF_SHA384);
@@ -200,7 +200,7 @@
     public_key.set_serialized_public_key(
         std::move(test_key.first).SerializeAsString());
     public_key_ = std::move(public_key);
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
         rsa_key_, AnonymousTokensRSAPrivateKeyToRSA(test_key.second));
   }
 
@@ -213,20 +213,20 @@
   const absl::string_view message = "Hello World!";
   const absl::string_view public_metadata = "pubmd!";
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<RsaBlinder> blinder,
       RsaBlinder::New(public_key_, public_metadata));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string blinded_message,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string blinded_message,
                                    blinder->Blind(message));
   EXPECT_NE(blinded_message, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string blinded_signature,
       TestSignWithPublicMetadata(blinded_message, public_metadata, *rsa_key_));
   EXPECT_NE(blinded_signature, blinded_message);
   EXPECT_NE(blinded_signature, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string signature,
                                    blinder->Unblind(blinded_signature));
   EXPECT_NE(signature, blinded_signature);
   EXPECT_NE(signature, blinded_message);
@@ -240,21 +240,21 @@
   const absl::string_view public_metadata = "pubmd!";
   const absl::string_view public_metadata_2 = "pubmd2";
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<RsaBlinder> blinder,
       RsaBlinder::New(public_key_, public_metadata));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string blinded_message,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string blinded_message,
                                    blinder->Blind(message));
   EXPECT_NE(blinded_message, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string blinded_signature,
       TestSignWithPublicMetadata(blinded_message, public_metadata_2,
                                  *rsa_key_));
   EXPECT_NE(blinded_signature, blinded_message);
   EXPECT_NE(blinded_signature, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string signature,
                                    blinder->Unblind(blinded_signature));
   EXPECT_NE(signature, blinded_signature);
   EXPECT_NE(signature, blinded_message);
@@ -269,19 +269,19 @@
   const absl::string_view message = "Hello World!";
   const absl::string_view public_metadata = "pubmd!";
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::unique_ptr<RsaBlinder> blinder,
       RsaBlinder::New(public_key_, public_metadata));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string blinded_message,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string blinded_message,
                                    blinder->Blind(message));
   EXPECT_NE(blinded_message, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string blinded_signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string blinded_signature,
                                    TestSign(blinded_message, rsa_key_.get()));
   EXPECT_NE(blinded_signature, blinded_message);
   EXPECT_NE(blinded_signature, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string signature,
                                    blinder->Unblind(blinded_signature));
   EXPECT_NE(signature, blinded_signature);
   EXPECT_NE(signature, blinded_message);
@@ -296,19 +296,19 @@
   const absl::string_view message = "Hello World!";
   const absl::string_view public_metadata = "pubmd!";
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlinder> blinder,
                                    RsaBlinder::New(public_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string blinded_message,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string blinded_message,
                                    blinder->Blind(message));
   EXPECT_NE(blinded_message, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string blinded_signature,
       TestSignWithPublicMetadata(blinded_message, public_metadata, *rsa_key_));
   EXPECT_NE(blinded_signature, blinded_message);
   EXPECT_NE(blinded_signature, message);
 
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(std::string signature,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string signature,
                                    blinder->Unblind(blinded_signature));
   EXPECT_NE(signature, blinded_signature);
   EXPECT_NE(signature, blinded_message);

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.h b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.h
index 34ab1e3..792773c 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.h
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier.h

@@ -25,7 +25,7 @@
 #include "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/crypto_utils.h"
 #include "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/verifier.h"
 #include "quiche/blind_sign_auth/anonymous_tokens/proto/anonymous_tokens.pb.h"
-// #include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/platform/api/quiche_export.h"
 
 namespace private_membership {
 namespace anonymous_tokens {

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc
index 59d9722..a24429e 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc

@@ -38,12 +38,12 @@
 TEST(RsaSsaPssVerifier, SuccessfulVerification) {
   const IetfStandardRsaBlindSignatureTestVector test_vec =
       GetIetfStandardRsaBlindSignatureTestVector();
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const auto test_keys,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const auto test_keys,
                                    GetIetfStandardRsaBlindSignatureTestKeys());
   const EVP_MD *sig_hash = EVP_sha384();   // Owned by BoringSSL
   const EVP_MD *mgf1_hash = EVP_sha384();  // Owned by BoringSSL
   const int salt_length = kSaltLengthInBytes48;
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const auto verifier, RsaSsaPssVerifier::New(salt_length, sig_hash,
                                                   mgf1_hash, test_keys.first));
   QUICHE_EXPECT_OK(verifier->Verify(test_vec.signature, test_vec.message));
@@ -52,12 +52,12 @@
 TEST(RsaSsaPssVerifier, InvalidSignature) {
   const IetfStandardRsaBlindSignatureTestVector test_vec =
       GetIetfStandardRsaBlindSignatureTestVector();
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const auto test_keys,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const auto test_keys,
                                    GetIetfStandardRsaBlindSignatureTestKeys());
   const EVP_MD *sig_hash = EVP_sha384();   // Owned by BoringSSL
   const EVP_MD *mgf1_hash = EVP_sha384();  // Owned by BoringSSL
   const int salt_length = kSaltLengthInBytes48;
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const auto verifier, RsaSsaPssVerifier::New(salt_length, sig_hash,
                                                   mgf1_hash, test_keys.first));
   // corrupt signature
@@ -77,8 +77,8 @@
   const EVP_MD *mgf1_hash = EVP_sha384();  // Owned by BoringSSL
   const int salt_length = kSaltLengthInBytes48;
   // wrong key
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto new_keys_pair, GetStandardRsaKeyPair());
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto new_keys_pair, GetStandardRsaKeyPair());
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const auto verifier,
       RsaSsaPssVerifier::New(salt_length, sig_hash, mgf1_hash,
                              new_keys_pair.first));
@@ -92,12 +92,12 @@
 TEST(RsaSsaPssVerifier, EmptyMessageVerification) {
   const IetfStandardRsaBlindSignatureTestVector test_vec =
       GetIetfStandardRsaBlindSignatureTestVector();
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(const auto test_keys,
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(const auto test_keys,
                                    GetIetfStandardRsaBlindSignatureTestKeys());
   const EVP_MD *sig_hash = EVP_sha384();   // Owned by BoringSSL
   const EVP_MD *mgf1_hash = EVP_sha384();  // Owned by BoringSSL
   const int salt_length = kSaltLengthInBytes48;
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const auto verifier, RsaSsaPssVerifier::New(salt_length, sig_hash,
                                                   mgf1_hash, test_keys.first));
 
@@ -114,9 +114,9 @@
     : public ::testing::TestWithParam<CreateTestKeyPairFunction *> {
  protected:
   void SetUp() override {
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(auto keys_pair, (*GetParam())());
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto keys_pair, (*GetParam())());
     public_key_ = std::move(keys_pair.first);
-    ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+    ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
         private_key_, AnonymousTokensRSAPrivateKeyToRSA(keys_pair.second));
     // NOTE: using recommended RsaSsaPssParams
     sig_hash_ = EVP_sha384();
@@ -139,15 +139,15 @@
        VerifierWorksWithPublicMetadata) {
   absl::string_view message = "Hello World!";
   absl::string_view public_metadata = "pubmd!";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string encoded_message,
       EncodeMessageForTests(message, public_key_, sig_hash_, mgf1_hash_,
                             salt_length_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string potentially_insecure_signature,
       TestSignWithPublicMetadata(encoded_message, public_metadata,
                                  *private_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata));
   QUICHE_EXPECT_OK(verifier->Verify(potentially_insecure_signature, message));
@@ -158,15 +158,15 @@
   absl::string_view message = "Hello World!";
   absl::string_view public_metadata = "pubmd!";
   absl::string_view public_metadata_2 = "pubmd2";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string encoded_message,
       EncodeMessageForTests(message, public_key_, sig_hash_, mgf1_hash_,
                             salt_length_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string potentially_insecure_signature,
       TestSignWithPublicMetadata(encoded_message, public_metadata,
                                  *private_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata_2));
   EXPECT_THAT(
@@ -180,15 +180,15 @@
   absl::string_view message = "Hello World!";
   absl::string_view public_metadata = "pubmd!";
   absl::string_view public_metadata_2 = "";
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string encoded_message,
       EncodeMessageForTests(message, public_key_, sig_hash_, mgf1_hash_,
                             salt_length_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::string potentially_insecure_signature,
       TestSignWithPublicMetadata(encoded_message, public_metadata,
                                  *private_key_));
-  ANON_TOKENS_QUICHE_EXPECT_OK_AND_ASSIGN(
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata_2));
   EXPECT_THAT(

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.cc
new file mode 100644
index 0000000..2b7a759
--- /dev/null
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.cc

@@ -0,0 +1,64 @@
+// Copyright 2023 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
+//
+//    https://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 "quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.h"
+
+namespace private_membership {
+namespace anonymous_tokens {
+
+absl::StatusOr<AnonymousTokensUseCase> ParseUseCase(
+    absl::string_view use_case) {
+  AnonymousTokensUseCase parsed_use_case;
+  if (!AnonymousTokensUseCase_Parse(std::string(use_case), &parsed_use_case) ||
+      parsed_use_case == ANONYMOUS_TOKENS_USE_CASE_UNDEFINED) {
+    return absl::InvalidArgumentError(
+        "Invalid / undefined use case cannot be parsed.");
+  }
+  return parsed_use_case;
+}
+
+absl::StatusOr<absl::Time> TimeFromProto(
+    const quiche::protobuf::Timestamp& proto) {
+  const auto sec = proto.seconds();
+  const auto ns = proto.nanos();
+  // sec must be [0001-01-01T00:00:00Z, 9999-12-31T23:59:59.999999999Z]
+  if (sec < -62135596800 || sec > 253402300799) {
+    return absl::InvalidArgumentError(absl::StrCat("seconds=", sec));
+  }
+  if (ns < 0 || ns > 999999999) {
+    return absl::InvalidArgumentError(absl::StrCat("nanos=", ns));
+  }
+  return absl::FromUnixSeconds(proto.seconds()) +
+         absl::Nanoseconds(proto.nanos());
+}
+
+absl::StatusOr<quiche::protobuf::Timestamp> TimeToProto(absl::Time time) {
+  quiche::protobuf::Timestamp proto;
+  const int64_t seconds = absl::ToUnixSeconds(time);
+  proto.set_seconds(seconds);
+  proto.set_nanos((time - absl::FromUnixSeconds(seconds)) /
+                  absl::Nanoseconds(1));
+  // seconds must be [0001-01-01T00:00:00Z, 9999-12-31T23:59:59.999999999Z]
+  if (seconds < -62135596800 || seconds > 253402300799) {
+    return absl::InvalidArgumentError(absl::StrCat("seconds=", seconds));
+  }
+  const int64_t ns = proto.nanos();
+  if (ns < 0 || ns > 999999999) {
+    return absl::InvalidArgumentError(absl::StrCat("nanos=", ns));
+  }
+  return proto;
+}
+
+}  // namespace anonymous_tokens
+}  // namespace private_membership

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.h b/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.h
new file mode 100644
index 0000000..30fb2de
--- /dev/null
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.h

@@ -0,0 +1,49 @@
+// Copyright 2023 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
+//
+//    https://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.
+
+#ifndef THIRD_PARTY_ANONYMOUS_TOKENS_CPP_SHARED_PROTO_UTILS_H_
+#define THIRD_PARTY_ANONYMOUS_TOKENS_CPP_SHARED_PROTO_UTILS_H_
+
+#include "quiche/blind_sign_auth/proto/timestamp.pb.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+#include "quiche/blind_sign_auth/anonymous_tokens/proto/anonymous_tokens.pb.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace private_membership {
+namespace anonymous_tokens {
+
+// Returns AnonymousTokensUseCase parsed from a string_view.
+absl::StatusOr<AnonymousTokensUseCase> QUICHE_EXPORT ParseUseCase(
+    absl::string_view use_case);
+
+// Takes in quiche::protobuf::Timestamp and converts it to absl::Time.
+//
+// Timestamp is defined here:
+// https://developers.google.com/protocol-buffers/docs/reference/quiche.protobuf#timestamp
+absl::StatusOr<absl::Time> QUICHE_EXPORT TimeFromProto(
+    const quiche::protobuf::Timestamp& proto);
+
+// Takes in absl::Time and converts it to quiche::protobuf::Timestamp.
+//
+// Timestamp is defined here:
+// https://developers.google.com/protocol-buffers/docs/reference/quiche.protobuf#timestamp
+absl::StatusOr<quiche::protobuf::Timestamp> QUICHE_EXPORT TimeToProto(
+    absl::Time time);
+
+}  // namespace anonymous_tokens
+}  // namespace private_membership
+
+#endif  // THIRD_PARTY_ANONYMOUS_TOKENS_CPP_SHARED_PROTO_UTILS_H_

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils_test.cc
new file mode 100644
index 0000000..5c7d845
--- /dev/null
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils_test.cc

@@ -0,0 +1,93 @@
+// Copyright 2023 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
+//
+//    https://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 "quiche/blind_sign_auth/anonymous_tokens/cpp/shared/proto_utils.h"
+
+#include "quiche/blind_sign_auth/proto/timestamp.pb.h"
+#include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/test_tools/quiche_test_utils.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/time/time.h"
+#include "quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.h"
+#include "quiche/blind_sign_auth/anonymous_tokens/proto/anonymous_tokens.pb.h"
+
+namespace private_membership {
+namespace anonymous_tokens {
+namespace {
+
+TEST(ProtoUtilsTest, EmptyUseCase) {
+  EXPECT_THAT(ParseUseCase("").status().code(),
+              absl::StatusCode::kInvalidArgument);
+}
+
+TEST(ProtoUtilsTest, InvalidUseCase) {
+  EXPECT_THAT(ParseUseCase("NOT_A_USE_CASE").status().code(),
+              absl::StatusCode::kInvalidArgument);
+}
+
+TEST(ProtoUtilsTest, UndefinedUseCase) {
+  EXPECT_THAT(
+      ParseUseCase("ANONYMOUS_TOKENS_USE_CASE_UNDEFINED").status().code(),
+      absl::StatusCode::kInvalidArgument);
+}
+
+TEST(ProtoUtilsTest, ValidUseCase) {
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensUseCase use_case,
+                                   ParseUseCase("TEST_USE_CASE"));
+  EXPECT_EQ(use_case, AnonymousTokensUseCase::TEST_USE_CASE);
+}
+
+TEST(ProtoUtilsTest, TimeFromProtoGood) {
+  quiche::protobuf::Timestamp timestamp;
+  timestamp.set_seconds(1234567890);
+  timestamp.set_nanos(12345);
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(absl::Time time, TimeFromProto(timestamp));
+  ASSERT_EQ(time, absl::FromUnixNanos(1234567890000012345));
+}
+
+TEST(ProtoUtilsTest, TimeFromProtoBad) {
+  quiche::protobuf::Timestamp proto;
+  proto.set_nanos(-1);
+  EXPECT_THAT(TimeFromProto(proto).status().code(),
+              absl::StatusCode::kInvalidArgument);
+
+  proto.set_nanos(0);
+  proto.set_seconds(253402300800);
+  EXPECT_THAT(TimeFromProto(proto).status().code(),
+              absl::StatusCode::kInvalidArgument);
+}
+
+TEST(ProtoUtilsTest, TimeToProtoGood) {
+  quiche::protobuf::Timestamp proto;
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
+      proto, TimeToProto(absl::FromUnixSeconds(1596762373)));
+  EXPECT_EQ(proto.seconds(), 1596762373);
+  EXPECT_EQ(proto.nanos(), 0);
+
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
+      proto, TimeToProto(absl::FromUnixMillis(1596762373123L)));
+  EXPECT_EQ(proto.seconds(), 1596762373);
+  EXPECT_EQ(proto.nanos(), 123000000);
+}
+
+TEST(ProtoUtilsTest, TimeToProtoBad) {
+  absl::StatusOr<quiche::protobuf::Timestamp> proto;
+  proto = TimeToProto(absl::FromUnixSeconds(253402300800));
+  EXPECT_THAT(proto.status().code(), absl::StatusCode::kInvalidArgument);
+}
+
+}  // namespace
+}  // namespace anonymous_tokens
+}  // namespace private_membership

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/status_utils.h b/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/status_utils.h
new file mode 100644
index 0000000..bcdddf6
--- /dev/null
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/shared/status_utils.h

@@ -0,0 +1,49 @@
+// Copyright 2023 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
+//
+//    https://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.
+
+#ifndef THIRD_PARTY_ANONYMOUS_TOKENS_CPP_SHARED_STATUS_UTILS_H_
+#define THIRD_PARTY_ANONYMOUS_TOKENS_CPP_SHARED_STATUS_UTILS_H_
+
+#include "absl/base/optimization.h"
+#include "absl/status/status.h"
+
+namespace private_membership {
+namespace anonymous_tokens {
+
+#define _ANON_TOKENS_STATUS_MACROS_CONCAT_NAME(x, y) \
+  _ANON_TOKENS_STATUS_MACROS_CONCAT_IMPL(x, y)
+#define _ANON_TOKENS_STATUS_MACROS_CONCAT_IMPL(x, y) x##y
+
+#define ANON_TOKENS_ASSIGN_OR_RETURN(lhs, rexpr)                             \
+  _ANON_TOKENS_ASSIGN_OR_RETURN_IMPL(                                        \
+      _ANON_TOKENS_STATUS_MACROS_CONCAT_NAME(_status_or_val, __LINE__), lhs, \
+      rexpr)
+
+#define _ANON_TOKENS_ASSIGN_OR_RETURN_IMPL(statusor, lhs, rexpr) \
+  auto statusor = (rexpr);                                       \
+  if (ABSL_PREDICT_FALSE(!statusor.ok())) {                      \
+    return statusor.status();                                    \
+  }                                                              \
+  lhs = *std::move(statusor)
+
+#define ANON_TOKENS_RETURN_IF_ERROR(expr)                  \
+  do {                                                     \
+    auto _status = (expr);                                 \
+    if (ABSL_PREDICT_FALSE(!_status.ok())) return _status; \
+  } while (0)
+
+}  // namespace anonymous_tokens
+}  // namespace private_membership
+
+#endif  // THIRD_PARTY_ANONYMOUS_TOKENS_CPP_SHARED_STATUS_UTILS_H_

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.cc
new file mode 100644
index 0000000..d21d101
--- /dev/null
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.cc

@@ -0,0 +1,560 @@
+// Copyright 2023 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
+//
+//    https://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 "quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <fstream>
+#include <memory>
+#include <random>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/constants.h"
+#include "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/crypto_utils.h"
+#include "quiche/blind_sign_auth/anonymous_tokens/cpp/shared/status_utils.h"
+#include "quiche/blind_sign_auth/anonymous_tokens/proto/anonymous_tokens.pb.h"
+#include "openssl/rsa.h"
+
+namespace private_membership {
+namespace anonymous_tokens {
+
+namespace {
+
+absl::StatusOr<std::string> ReadFileToString(absl::string_view path) {
+  std::ifstream file((std::string(path)));
+  if (!file.is_open()) {
+    return absl::InternalError("Reading file failed.");
+  }
+  std::ostringstream ss;
+  ss << file.rdbuf();
+  return ss.str();
+}
+
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> ParseRsaKeysFromFile(
+    absl::string_view path) {
+  ANON_TOKENS_ASSIGN_OR_RETURN(std::string text_proto, ReadFileToString(path));
+  RSAPrivateKey private_key;
+  if (!private_key.ParseFromString(text_proto)) {
+    return absl::InternalError("Parsing text proto failed.");
+  }
+  RSAPublicKey public_key;
+  public_key.set_n(private_key.n());
+  public_key.set_e(private_key.e());
+  return std::make_pair(std::move(public_key), std::move(private_key));
+}
+
+absl::StatusOr<bssl::UniquePtr<RSA>> GenerateRSAKey(int modulus_bit_size,
+                                                    const BIGNUM& e) {
+  bssl::UniquePtr<RSA> rsa(RSA_new());
+  if (!rsa.get()) {
+    return absl::InternalError(
+        absl::StrCat("RSA_new failed: ", GetSslErrors()));
+  }
+  if (RSA_generate_key_ex(rsa.get(), modulus_bit_size, &e,
+                          /*cb=*/nullptr) != kBsslSuccess) {
+    return absl::InternalError(
+        absl::StrCat("Error generating private key: ", GetSslErrors()));
+  }
+  return rsa;
+}
+
+}  // namespace
+
+absl::StatusOr<std::pair<bssl::UniquePtr<RSA>, RSABlindSignaturePublicKey>>
+CreateTestKey(int key_size, HashType sig_hash, MaskGenFunction mfg1_hash,
+              int salt_length, MessageMaskType message_mask_type,
+              int message_mask_size) {
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> rsa_f4, NewBigNum());
+  BN_set_u64(rsa_f4.get(), RSA_F4);
+
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<RSA> rsa_key,
+                               GenerateRSAKey(key_size * 8, *rsa_f4));
+
+  RSAPublicKey rsa_public_key;
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_public_key.mutable_n(),
+      BignumToString(*RSA_get0_n(rsa_key.get()), key_size));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_public_key.mutable_e(),
+      BignumToString(*RSA_get0_e(rsa_key.get()), key_size));
+
+  RSABlindSignaturePublicKey public_key;
+  public_key.set_serialized_public_key(rsa_public_key.SerializeAsString());
+  public_key.set_sig_hash_type(sig_hash);
+  public_key.set_mask_gen_function(mfg1_hash);
+  public_key.set_salt_length(salt_length);
+  public_key.set_key_size(key_size);
+  public_key.set_message_mask_type(message_mask_type);
+  public_key.set_message_mask_size(message_mask_size);
+
+  return std::make_pair(std::move(rsa_key), std::move(public_key));
+}
+
+absl::StatusOr<std::string> TestSign(const absl::string_view blinded_data,
+                                     RSA* rsa_key) {
+  if (blinded_data.empty()) {
+    return absl::InvalidArgumentError("blinded_data string is empty.");
+  }
+  const size_t mod_size = RSA_size(rsa_key);
+  if (blinded_data.size() != mod_size) {
+    return absl::InternalError(absl::StrCat(
+        "Expected blind data size = ", mod_size,
+        " actual blind data size = ", blinded_data.size(), " bytes."));
+  }
+  // Compute a raw RSA signature.
+  std::string signature(mod_size, 0);
+  size_t out_len;
+  if (RSA_sign_raw(/*rsa=*/rsa_key, /*out_len=*/&out_len,
+                   /*out=*/reinterpret_cast<uint8_t*>(&signature[0]),
+                   /*max_out=*/mod_size,
+                   /*in=*/reinterpret_cast<const uint8_t*>(&blinded_data[0]),
+                   /*in_len=*/mod_size,
+                   /*padding=*/RSA_NO_PADDING) != kBsslSuccess) {
+    return absl::InternalError(
+        "RSA_sign_raw failed when called from RsaBlindSigner::Sign");
+  }
+  if (out_len != mod_size && out_len == signature.size()) {
+    return absl::InternalError(absl::StrCat(
+        "Expected value of out_len = ", mod_size,
+        " bytes, actual value of out_len and signature.size() = ", out_len,
+        " and ", signature.size(), " bytes."));
+  }
+  return signature;
+}
+
+absl::StatusOr<std::string> TestSignWithPublicMetadata(
+    const absl::string_view blinded_data, absl::string_view public_metadata,
+    const RSA& rsa_key) {
+  if (public_metadata.empty()) {
+    return absl::InvalidArgumentError("Public Metadata is empty.");
+  } else if (blinded_data.empty()) {
+    return absl::InvalidArgumentError("blinded_data string is empty.");
+  } else if (blinded_data.size() != RSA_size(&rsa_key)) {
+    return absl::InternalError(absl::StrCat(
+        "Expected blind data size = ", RSA_size(&rsa_key),
+        " actual blind data size = ", blinded_data.size(), " bytes."));
+  }
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      bssl::UniquePtr<BIGNUM> new_e,
+      ComputeFinalExponentUnderPublicMetadata(
+          *RSA_get0_n(&rsa_key), *RSA_get0_e(&rsa_key), public_metadata));
+  // Compute phi(p) = p-1
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> phi_p, NewBigNum());
+  if (BN_sub(phi_p.get(), RSA_get0_p(&rsa_key), BN_value_one()) != 1) {
+    return absl::InternalError(
+        absl::StrCat("Unable to compute phi(p): ", GetSslErrors()));
+  }
+  // Compute phi(q) = q-1
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> phi_q, NewBigNum());
+  if (BN_sub(phi_q.get(), RSA_get0_q(&rsa_key), BN_value_one()) != 1) {
+    return absl::InternalError(
+        absl::StrCat("Unable to compute phi(q): ", GetSslErrors()));
+  }
+  // Compute phi(n) = phi(p)*phi(q)
+  ANON_TOKENS_ASSIGN_OR_RETURN(auto ctx, GetAndStartBigNumCtx());
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> phi_n, NewBigNum());
+  if (BN_mul(phi_n.get(), phi_p.get(), phi_q.get(), ctx.get()) != 1) {
+    return absl::InternalError(
+        absl::StrCat("Unable to compute phi(n): ", GetSslErrors()));
+  }
+  // Compute lcm(phi(p), phi(q)).
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> lcm, NewBigNum());
+  if (BN_rshift1(lcm.get(), phi_n.get()) != 1) {
+    return absl::InternalError(absl::StrCat(
+        "Could not compute LCM(phi(p), phi(q)): ", GetSslErrors()));
+  }
+  // Compute the new private exponent new_d
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> new_d, NewBigNum());
+  if (!BN_mod_inverse(new_d.get(), new_e.get(), lcm.get(), ctx.get())) {
+    return absl::InternalError(
+        absl::StrCat("Could not compute private exponent d: ", GetSslErrors()));
+  }
+
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> input_bn,
+                               StringToBignum(blinded_data));
+  if (BN_ucmp(input_bn.get(), RSA_get0_n(&rsa_key)) >= 0) {
+    return absl::InvalidArgumentError(
+        "RsaSign input size too large for modulus size");
+  }
+
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> result, NewBigNum());
+  if (!BN_mod_exp(result.get(), input_bn.get(), new_d.get(),
+                  RSA_get0_n(&rsa_key), ctx.get())) {
+    return absl::InternalError(
+        "BN_mod_exp failed in TestSignWithPublicMetadata");
+  }
+
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> vrfy, NewBigNum());
+  if (vrfy == nullptr ||
+      !BN_mod_exp(vrfy.get(), result.get(), new_e.get(), RSA_get0_n(&rsa_key),
+                  ctx.get()) ||
+      BN_cmp(vrfy.get(), input_bn.get()) != 0) {
+    return absl::InternalError("Signature verification failed in RsaSign");
+  }
+
+  return BignumToString(*result, BN_num_bytes(RSA_get0_n(&rsa_key)));
+}
+
+absl::StatusOr<std::string> EncodeMessageForTests(absl::string_view message,
+                                                  RSAPublicKey public_key,
+                                                  const EVP_MD* sig_hasher,
+                                                  const EVP_MD* mgf1_hasher,
+                                                  int32_t salt_length) {
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> rsa_modulus,
+                               StringToBignum(public_key.n()));
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> e,
+                               StringToBignum(public_key.e()));
+  // Convert to OpenSSL RSA.
+  bssl::UniquePtr<RSA> rsa_public_key(RSA_new());
+  if (!rsa_public_key.get()) {
+    return absl::InternalError(
+        absl::StrCat("RSA_new failed: ", GetSslErrors()));
+  } else if (RSA_set0_key(rsa_public_key.get(), rsa_modulus.release(),
+                          e.release(), nullptr) != kBsslSuccess) {
+    return absl::InternalError(
+        absl::StrCat("RSA_set0_key failed: ", GetSslErrors()));
+  }
+
+  const int padded_len = RSA_size(rsa_public_key.get());
+  std::vector<uint8_t> padded(padded_len);
+  ANON_TOKENS_ASSIGN_OR_RETURN(std::string digest,
+                               ComputeHash(message, *sig_hasher));
+  if (RSA_padding_add_PKCS1_PSS_mgf1(
+          /*rsa=*/rsa_public_key.get(), /*EM=*/padded.data(),
+          /*mHash=*/reinterpret_cast<uint8_t*>(&digest[0]), /*Hash=*/sig_hasher,
+          /*mgf1Hash=*/mgf1_hasher,
+          /*sLen=*/salt_length) != kBsslSuccess) {
+    return absl::InternalError(
+        "RSA_padding_add_PKCS1_PSS_mgf1 failed when called from "
+        "testing_utils");
+  }
+  std::string encoded_message(padded.begin(), padded.end());
+  return encoded_message;
+}
+
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> GetStandardRsaKeyPair() {
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> rsa_f4, NewBigNum());
+  BN_set_u64(rsa_f4.get(), RSA_F4);
+  int key_size_in_bytes = kRsaModulusSizeInBytes512;
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<RSA> rsa_key,
+                               GenerateRSAKey(key_size_in_bytes * 8, *rsa_f4));
+
+  RSAPublicKey rsa_public_key;
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_public_key.mutable_n(),
+      BignumToString(*RSA_get0_n(rsa_key.get()), key_size_in_bytes));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_public_key.mutable_e(),
+      BignumToString(*RSA_get0_e(rsa_key.get()), key_size_in_bytes));
+
+  RSAPrivateKey rsa_private_key;
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_private_key.mutable_n(),
+      BignumToString(*RSA_get0_n(rsa_key.get()), key_size_in_bytes));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_private_key.mutable_e(),
+      BignumToString(*RSA_get0_e(rsa_key.get()), key_size_in_bytes));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_private_key.mutable_d(),
+      BignumToString(*RSA_get0_d(rsa_key.get()), key_size_in_bytes));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_private_key.mutable_p(),
+      BignumToString(*RSA_get0_p(rsa_key.get()), key_size_in_bytes));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_private_key.mutable_q(),
+      BignumToString(*RSA_get0_q(rsa_key.get()), key_size_in_bytes));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_private_key.mutable_dp(),
+      BignumToString(*RSA_get0_dmp1(rsa_key.get()), key_size_in_bytes));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_private_key.mutable_dq(),
+      BignumToString(*RSA_get0_dmq1(rsa_key.get()), key_size_in_bytes));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      *rsa_private_key.mutable_crt(),
+      BignumToString(*RSA_get0_iqmp(rsa_key.get()), key_size_in_bytes));
+
+  return std::make_pair(std::move(rsa_public_key), std::move(rsa_private_key));
+}
+
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> GetStrongRsaKeys2048() {
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      auto key_pair,
+      ParseRsaKeysFromFile("quiche/blind_sign_auth/anonymous_tokens/testing/data/"
+                           "strong_rsa_modulus2048_example.binarypb"));
+  return std::make_pair(std::move(key_pair.first), std::move(key_pair.second));
+}
+
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>>
+GetAnotherStrongRsaKeys2048() {
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      auto key_pair,
+      ParseRsaKeysFromFile("quiche/blind_sign_auth/anonymous_tokens/testing/data/"
+                           "strong_rsa_modulus2048_example_2.binarypb"));
+  return std::make_pair(std::move(key_pair.first), std::move(key_pair.second));
+}
+
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> GetStrongRsaKeys3072() {
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      auto key_pair,
+      ParseRsaKeysFromFile("quiche/blind_sign_auth/anonymous_tokens/testing/data/"
+                           "strong_rsa_modulus3072_example.binarypb"));
+  return std::make_pair(std::move(key_pair.first), std::move(key_pair.second));
+}
+
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> GetStrongRsaKeys4096() {
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      auto key_pair,
+      ParseRsaKeysFromFile("quiche/blind_sign_auth/anonymous_tokens/testing/data/"
+                           "strong_rsa_modulus4096_example.binarypb"));
+  return std::make_pair(std::move(key_pair.first), std::move(key_pair.second));
+}
+
+IetfStandardRsaBlindSignatureTestVector
+GetIetfStandardRsaBlindSignatureTestVector() {
+  IetfStandardRsaBlindSignatureTestVector test_vector = {
+      // n
+      absl::HexStringToBytes(
+          "aec4d69addc70b990ea66a5e70603b6fee27aafebd08f2d94cbe1250c556e047a9"
+          "28d635c3f45ee9b66d1bc628a03bac9b7c3f416fe20dabea8f3d7b4bbf7f963be3"
+          "35d2328d67e6c13ee4a8f955e05a3283720d3e1f139c38e43e0338ad058a9495c5"
+          "3377fc35be64d208f89b4aa721bf7f7d3fef837be2a80e0f8adf0bcd1eec5bb040"
+          "443a2b2792fdca522a7472aed74f31a1ebe1eebc1f408660a0543dfe2a850f106a"
+          "617ec6685573702eaaa21a5640a5dcaf9b74e397fa3af18a2f1b7c03ba91a63361"
+          "58de420d63188ee143866ee415735d155b7c2d854d795b7bc236cffd71542df342"
+          "34221a0413e142d8c61355cc44d45bda94204974557ac2704cd8b593f035a5724b"
+          "1adf442e78c542cd4414fce6f1298182fb6d8e53cef1adfd2e90e1e4deec52999b"
+          "dc6c29144e8d52a125232c8c6d75c706ea3cc06841c7bda33568c63a6c03817f72"
+          "2b50fcf898237d788a4400869e44d90a3020923dc646388abcc914315215fcd1ba"
+          "e11b1c751fd52443aac8f601087d8d42737c18a3fa11ecd4131ecae017ae0a14ac"
+          "fc4ef85b83c19fed33cfd1cd629da2c4c09e222b398e18d822f77bb378dea3cb36"
+          "0b605e5aa58b20edc29d000a66bd177c682a17e7eb12a63ef7c2e4183e0d898f3d"
+          "6bf567ba8ae84f84f1d23bf8b8e261c3729e2fa6d07b832e07cddd1d14f55325c6"
+          "f924267957121902dc19b3b32948bdead5"),
+      // e
+      absl::HexStringToBytes("010001"),
+      // d
+      absl::HexStringToBytes(
+          "0d43242aefe1fb2c13fbc66e20b678c4336d20b1808c558b6e62ad16a287077180b1"
+          "77e1f01b12f9c6cd6c52630257ccef26a45135a990928773f3bd2fc01a313f1dac97"
+          "a51cec71cb1fd7efc7adffdeb05f1fb04812c924ed7f4a8269925dad88bd7dcfbc4e"
+          "f01020ebfc60cb3e04c54f981fdbd273e69a8a58b8ceb7c2d83fbcbd6f784d052201"
+          "b88a9848186f2a45c0d2826870733e6fd9aa46983e0a6e82e35ca20a439c5ee7b502"
+          "a9062e1066493bdadf8b49eb30d9558ed85abc7afb29b3c9bc644199654a4676681a"
+          "f4babcea4e6f71fe4565c9c1b85d9985b84ec1abf1a820a9bbebee0df1398aae2c85"
+          "ab580a9f13e7743afd3108eb32100b870648fa6bc17e8abac4d3c99246b1f0ea9f7f"
+          "93a5dd5458c56d9f3f81ff2216b3c3680a13591673c43194d8e6fc93fc1e37ce2986"
+          "bd628ac48088bc723d8fbe293861ca7a9f4a73e9fa63b1b6d0074f5dea2a624c5249"
+          "ff3ad811b6255b299d6bc5451ba7477f19c5a0db690c3e6476398b1483d10314afd3"
+          "8bbaf6e2fbdbcd62c3ca9797a420ca6034ec0a83360a3ee2adf4b9d4ba29731d131b"
+          "099a38d6a23cc463db754603211260e99d19affc902c915d7854554aabf608e3ac52"
+          "c19b8aa26ae042249b17b2d29669b5c859103ee53ef9bdc73ba3c6b537d5c34b6d8f"
+          "034671d7f3a8a6966cc4543df223565343154140fd7391c7e7be03e241f4ecfeb877"
+          "a051"),
+      // p
+      absl::HexStringToBytes(
+          "e1f4d7a34802e27c7392a3cea32a262a34dc3691bd87f3f310dc75673488930559c1"
+          "20fd0410194fb8a0da55bd0b81227e843fdca6692ae80e5a5d414116d4803fca7d8c"
+          "30eaaae57e44a1816ebb5c5b0606c536246c7f11985d731684150b63c9a3ad9e41b0"
+          "4c0b5b27cb188a692c84696b742a80d3cd00ab891f2457443dadfeba6d6daf108602"
+          "be26d7071803c67105a5426838e6889d77e8474b29244cefaf418e381b312048b457"
+          "d73419213063c60ee7b0d81820165864fef93523c9635c22210956e53a8d96322493"
+          "ffc58d845368e2416e078e5bcb5d2fd68ae6acfa54f9627c42e84a9d3f2774017e32"
+          "ebca06308a12ecc290c7cd1156dcccfb2311"),
+      // q
+      absl::HexStringToBytes(
+          "c601a9caea66dc3835827b539db9df6f6f5ae77244692780cd334a006ab353c80642"
+          "6b60718c05245650821d39445d3ab591ed10a7339f15d83fe13f6a3dfb20b9452c6a"
+          "9b42eaa62a68c970df3cadb2139f804ad8223d56108dfde30ba7d367e9b0a7a80c4f"
+          "dba2fd9dde6661fc73fc2947569d2029f2870fc02d8325acf28c9afa19ecf962daa7"
+          "916e21afad09eb62fe9f1cf91b77dc879b7974b490d3ebd2e95426057f35d0a3c9f4"
+          "5f79ac727ab81a519a8b9285932d9b2e5ccd347e59f3f32ad9ca359115e7da008ab7"
+          "406707bd0e8e185a5ed8758b5ba266e8828f8d863ae133846304a2936ad7bc7c9803"
+          "879d2fc4a28e69291d73dbd799f8bc238385"),
+      // message
+      absl::HexStringToBytes("8f3dc6fb8c4a02f4d6352edf0907822c1210a"
+                             "9b32f9bdda4c45a698c80023aa6b5"
+                             "9f8cfec5fdbb36331372ebefedae7d"),
+      // salt
+      absl::HexStringToBytes("051722b35f458781397c3a671a7d3bd3096503940e4c4f1aa"
+                             "a269d60300ce449555cd7340100df9d46944c5356825abf"),
+      // inv
+      absl::HexStringToBytes(
+          "80682c48982407b489d53d1261b19ec8627d02b8cda5336750b8cee332ae260de57b"
+          "02d72609c1e0e9f28e2040fc65b6f02d56dbd6aa9af8fde656f70495dfb723ba0117"
+          "3d4707a12fddac628ca29f3e32340bd8f7ddb557cf819f6b01e445ad96f874ba2355"
+          "84ee71f6581f62d4f43bf03f910f6510deb85e8ef06c7f09d9794a008be7ff2529f0"
+          "ebb69decef646387dc767b74939265fec0223aa6d84d2a8a1cc912d5ca25b4e144ab"
+          "8f6ba054b54910176d5737a2cff011da431bd5f2a0d2d66b9e70b39f4b050e45c0d9"
+          "c16f02deda9ddf2d00f3e4b01037d7029cd49c2d46a8e1fc2c0c17520af1f4b5e25b"
+          "a396afc4cd60c494a4c426448b35b49635b337cfb08e7c22a39b256dd032c00addda"
+          "fb51a627f99a0e1704170ac1f1912e49d9db10ec04c19c58f420212973e0cb329524"
+          "223a6aa56c7937c5dffdb5d966b6cd4cbc26f3201dd25c80960a1a111b32947bb789"
+          "73d269fac7f5186530930ed19f68507540eed9e1bab8b00f00d8ca09b3f099aae461"
+          "80e04e3584bd7ca054df18a1504b89d1d1675d0966c4ae1407be325cdf623cf13ff1"
+          "3e4a28b594d59e3eadbadf6136eee7a59d6a444c9eb4e2198e8a974f27a39eb63af2"
+          "c9af3870488b8adaad444674f512133ad80b9220e09158521614f1faadfe8505ef57"
+          "b7df6813048603f0dd04f4280177a11380fbfc861dbcbd7418d62155248dad5fdec0"
+          "991f"),
+      // encoded_message
+      absl::HexStringToBytes(
+          "6e0c464d9c2f9fbc147b43570fc4f238e0d0b38870b3addcf7a4217df912ccef17a7"
+          "f629aa850f63a063925f312d61d6437be954b45025e8282f9c0b1131bc8ff19a8a92"
+          "8d859b37113db1064f92a27f64761c181c1e1f9b251ae5a2f8a4047573b67a270584"
+          "e089beadcb13e7c82337797119712e9b849ff56e04385d144d3ca9d8d92bf78adb20"
+          "b5bbeb3685f17038ec6afade3ef354429c51c687b45a7018ee3a6966b3af15c9ba8f"
+          "40e6461ba0a17ef5a799672ad882bab02b518f9da7c1a962945c2e9b0f02f29b31b9"
+          "cdf3e633f9d9d2a22e96e1de28e25241ca7dd04147112f578973403e0f4fd8086596"
+          "5475d22294f065e17a1c4a201de93bd14223e6b1b999fd548f2f759f52db71964528"
+          "b6f15b9c2d7811f2a0a35d534b8216301c47f4f04f412cae142b48c4cdff78bc54df"
+          "690fd43142d750c671dd8e2e938e6a440b2f825b6dbb3e19f1d7a3c0150428a47948"
+          "037c322365b7fe6fe57ac88d8f80889e9ff38177bad8c8d8d98db42908b389cb5969"
+          "2a58ce275aa15acb032ca951b3e0a3404b7f33f655b7c7d83a2f8d1b6bbff49d5fce"
+          "df2e030e80881aa436db27a5c0dea13f32e7d460dbf01240c2320c2bb5b3225b1714"
+          "5c72d61d47c8f84d1e19417ebd8ce3638a82d395cc6f7050b6209d9283dc7b93fecc"
+          "04f3f9e7f566829ac41568ef799480c733c09759aa9734e2013d7640dc6151018ea9"
+          "02bc"),
+      // blinded_message
+      absl::HexStringToBytes(
+          "10c166c6a711e81c46f45b18e5873cc4f494f003180dd7f115585d871a2893025965"
+          "4fe28a54dab319cc5011204c8373b50a57b0fdc7a678bd74c523259dfe4fd5ea9f52"
+          "f170e19dfa332930ad1609fc8a00902d725cfe50685c95e5b2968c9a2828a21207fc"
+          "f393d15f849769e2af34ac4259d91dfd98c3a707c509e1af55647efaa31290ddf48e"
+          "0133b798562af5eabd327270ac2fb6c594734ce339a14ea4fe1b9a2f81c0bc230ca5"
+          "23bda17ff42a377266bc2778a274c0ae5ec5a8cbbe364fcf0d2403f7ee178d77ff28"
+          "b67a20c7ceec009182dbcaa9bc99b51ebbf13b7d542be337172c6474f2cd3561219f"
+          "e0dfa3fb207cff89632091ab841cf38d8aa88af6891539f263adb8eac6402c41b6eb"
+          "d72984e43666e537f5f5fe27b2b5aa114957e9a580730308a5f5a9c63a1eb599f093"
+          "ab401d0c6003a451931b6d124180305705845060ebba6b0036154fcef3e5e9f9e4b8"
+          "7e8f084542fd1dd67e7782a5585150181c01eb6d90cb95883837384a5b91dbb606f2"
+          "66059ecc51b5acbaa280e45cfd2eec8cc1cdb1b7211c8e14805ba683f9b78824b2eb"
+          "005bc8a7d7179a36c152cb87c8219e5569bba911bb32a1b923ca83de0e03fb10fba7"
+          "5d85c55907dda5a2606bf918b056c3808ba496a4d95532212040a5f44f37e1097f26"
+          "dc27b98a51837daa78f23e532156296b64352669c94a8a855acf30533d8e0594ace7"
+          "c442"),
+      // blinded_signature
+      absl::HexStringToBytes(
+          "364f6a40dbfbc3bbb257943337eeff791a0f290898a6791283bba581d9eac90a6376"
+          "a837241f5f73a78a5c6746e1306ba3adab6067c32ff69115734ce014d354e2f259d4"
+          "cbfb890244fd451a497fe6ecf9aa90d19a2d441162f7eaa7ce3fc4e89fd4e76b7ae5"
+          "85be2a2c0fd6fb246b8ac8d58bcb585634e30c9168a434786fe5e0b74bfe8187b47a"
+          "c091aa571ffea0a864cb906d0e28c77a00e8cd8f6aba4317a8cc7bf32ce566bd1ef8"
+          "0c64de041728abe087bee6cadd0b7062bde5ceef308a23bd1ccc154fd0c3a26110df"
+          "6193464fc0d24ee189aea8979d722170ba945fdcce9b1b4b63349980f3a92dc2e541"
+          "8c54d38a862916926b3f9ca270a8cf40dfb9772bfbdd9a3e0e0892369c18249211ba"
+          "857f35963d0e05d8da98f1aa0c6bba58f47487b8f663e395091275f82941830b050b"
+          "260e4767ce2fa903e75ff8970c98bfb3a08d6db91ab1746c86420ee2e909bf681cac"
+          "173697135983c3594b2def673736220452fde4ddec867d40ff42dd3da36c84e3e525"
+          "08b891a00f50b4f62d112edb3b6b6cc3dbd546ba10f36b03f06c0d82aeec3b25e127"
+          "af545fac28e1613a0517a6095ad18a98ab79f68801e05c175e15bae21f821e80c80a"
+          "b4fdec6fb34ca315e194502b8f3dcf7892b511aee45060e3994cd15e003861bc7220"
+          "a2babd7b40eda03382548a34a7110f9b1779bf3ef6011361611e6bc5c0dc851e1509"
+          "de1a"),
+      // signature
+      absl::HexStringToBytes(
+          "6fef8bf9bc182cd8cf7ce45c7dcf0e6f3e518ae48f06f3c670c649ac737a8b8119"
+          "a34d51641785be151a697ed7825fdfece82865123445eab03eb4bb91cecf4d6951"
+          "738495f8481151b62de869658573df4e50a95c17c31b52e154ae26a04067d5ecdc"
+          "1592c287550bb982a5bb9c30fd53a768cee6baabb3d483e9f1e2da954c7f4cf492"
+          "fe3944d2fe456c1ecaf0840369e33fb4010e6b44bb1d721840513524d8e9a3519f"
+          "40d1b81ae34fb7a31ee6b7ed641cb16c2ac999004c2191de0201457523f5a4700d"
+          "d649267d9286f5c1d193f1454c9f868a57816bf5ff76c838a2eeb616a3fc9976f6"
+          "5d4371deecfbab29362caebdff69c635fe5a2113da4d4d8c24f0b16a0584fa05e8"
+          "0e607c5d9a2f765f1f069f8d4da21f27c2a3b5c984b4ab24899bef46c6d9323df4"
+          "862fe51ce300fca40fb539c3bb7fe2dcc9409e425f2d3b95e70e9c49c5feb6ecc9"
+          "d43442c33d50003ee936845892fb8be475647da9a080f5bc7f8a716590b3745c22"
+          "09fe05b17992830ce15f32c7b22cde755c8a2fe50bd814a0434130b807dc1b7218"
+          "d4e85342d70695a5d7f29306f25623ad1e8aa08ef71b54b8ee447b5f64e73d09bd"
+          "d6c3b7ca224058d7c67cc7551e9241688ada12d859cb7646fbd3ed8b34312f3b49"
+          "d69802f0eaa11bc4211c2f7a29cd5c01ed01a39001c5856fab36228f5ee2f2e111"
+          "0811872fe7c865c42ed59029c706195d52"),
+  };
+  return test_vector;
+}
+
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>>
+GetIetfStandardRsaBlindSignatureTestKeys() {
+  IetfStandardRsaBlindSignatureTestVector test_vector =
+      GetIetfStandardRsaBlindSignatureTestVector();
+  RSAPublicKey public_key;
+  RSAPrivateKey private_key;
+
+  public_key.set_n(test_vector.n);
+  public_key.set_e(test_vector.e);
+
+  private_key.set_n(test_vector.n);
+  private_key.set_e(test_vector.e);
+  private_key.set_d(test_vector.d);
+  private_key.set_p(test_vector.p);
+  private_key.set_q(test_vector.q);
+
+  // Computing CRT parameters
+  ANON_TOKENS_ASSIGN_OR_RETURN(BnCtxPtr bn_ctx, GetAndStartBigNumCtx());
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> dp_bn, NewBigNum());
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> dq_bn, NewBigNum());
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> crt_bn, NewBigNum());
+
+  // p - 1
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> pm1,
+                               StringToBignum(test_vector.p));
+  BN_sub_word(pm1.get(), 1);
+  // q - 1
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> qm1,
+                               StringToBignum(test_vector.q));
+  BN_sub_word(qm1.get(), 1);
+  // d mod p-1
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> d,
+                               StringToBignum(test_vector.d));
+  BN_mod(dp_bn.get(), d.get(), pm1.get(), bn_ctx.get());
+  // d mod q-1
+  BN_mod(dq_bn.get(), d.get(), qm1.get(), bn_ctx.get());
+  // crt q^(-1) mod p
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> q,
+                               StringToBignum(test_vector.q));
+  ANON_TOKENS_ASSIGN_OR_RETURN(bssl::UniquePtr<BIGNUM> p,
+                               StringToBignum(test_vector.p));
+  BN_mod_inverse(crt_bn.get(), q.get(), p.get(), bn_ctx.get());
+
+  // Populating crt params in private key
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      std::string dp_str, BignumToString(*dp_bn, BN_num_bytes(dp_bn.get())));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      std::string dq_str, BignumToString(*dq_bn, BN_num_bytes(dq_bn.get())));
+  ANON_TOKENS_ASSIGN_OR_RETURN(
+      std::string crt_str, BignumToString(*crt_bn, BN_num_bytes(crt_bn.get())));
+  private_key.set_dp(dp_str);
+  private_key.set_dq(dq_str);
+  private_key.set_crt(crt_str);
+
+  return std::make_pair(std::move(public_key), std::move(private_key));
+}
+
+std::string RandomString(int n, std::uniform_int_distribution<int>* distr_u8,
+                         std::mt19937_64* generator) {
+  std::string rand(n, 0);
+  for (int i = 0; i < n; ++i) {
+    rand[i] = static_cast<uint8_t>((*distr_u8)(*generator));
+  }
+  return rand;
+}
+
+}  // namespace anonymous_tokens
+}  // namespace private_membership

diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.h b/quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.h
new file mode 100644
index 0000000..288b0d1
--- /dev/null
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/testing/utils.h

@@ -0,0 +1,134 @@
+// Copyright 2023 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
+//
+//    https://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.
+
+#ifndef THIRD_PARTY_ANONYMOUS_TOKENS_CPP_TESTING_UTILS_H_
+#define THIRD_PARTY_ANONYMOUS_TOKENS_CPP_TESTING_UTILS_H_
+
+#include <stdint.h>
+
+#include <random>
+#include <string>
+#include <utility>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/constants.h"
+#include "quiche/blind_sign_auth/anonymous_tokens/proto/anonymous_tokens.pb.h"
+#include "openssl/base.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace private_membership {
+namespace anonymous_tokens {
+
+struct QUICHE_EXPORT IetfStandardRsaBlindSignatureTestVector {
+  std::string n;
+  std::string e;
+  std::string d;
+  std::string p;
+  std::string q;
+  std::string message;
+  std::string salt;
+  std::string inv;
+  std::string encoded_message;
+  std::string blinded_message;
+  std::string blinded_signature;
+  std::string signature;
+};
+
+// Creates a pair containing a standard RSA Private key and an Anonymous Tokens
+// RSABlindSignaturePublicKey using RSA_F4 (65537) as the public exponent and
+// other input parameters.
+absl::StatusOr<std::pair<bssl::UniquePtr<RSA>,
+                         RSABlindSignaturePublicKey>> QUICHE_EXPORT
+CreateTestKey(int key_size = 512, HashType sig_hash = AT_HASH_TYPE_SHA384,
+              MaskGenFunction mfg1_hash = AT_MGF_SHA384, int salt_length = 48,
+              MessageMaskType message_mask_type = AT_MESSAGE_MASK_CONCAT,
+              int message_mask_size = kRsaMessageMaskSizeInBytes32);
+
+// Prepares message for signing by computing its hash and then applying the PSS
+// padding to the result by executing RSA_padding_add_PKCS1_PSS_mgf1 from the
+// openssl library, using the input parameters.
+//
+// This is a test function and it skips the message blinding part.
+absl::StatusOr<std::string> EncodeMessageForTests(absl::string_view message,
+                                                  RSAPublicKey public_key,
+                                                  const EVP_MD* sig_hasher,
+                                                  const EVP_MD* mgf1_hasher,
+                                                  int32_t salt_length);
+
+// TestSign can be removed once rsa_blind_signer is moved to
+// anonympous_tokens/public/cpp/crypto
+absl::StatusOr<std::string> QUICHE_EXPORT TestSign(
+    absl::string_view blinded_data, RSA* rsa_key);
+
+// TestSignWithPublicMetadata can be removed once rsa_blind_signer is moved to
+// anonympous_tokens/public/cpp/crypto
+absl::StatusOr<std::string> QUICHE_EXPORT TestSignWithPublicMetadata(
+    absl::string_view blinded_data, absl::string_view public_metadata,
+    const RSA& rsa_key);
+
+// This method returns a newly generated RSA key pair, setting the public
+// exponent to be the standard RSA_F4 (65537) and the modulus size to 512 bytes.
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> QUICHE_EXPORT
+GetStandardRsaKeyPair();
+
+// Method returns fixed 2048-bit strong RSA modulus for testing.
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> QUICHE_EXPORT
+GetStrongRsaKeys2048();
+
+// Method returns another fixed 2048-bit strong RSA modulus for testing.
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> QUICHE_EXPORT
+GetAnotherStrongRsaKeys2048();
+
+// Method returns fixed 3072-bit strong RSA modulus for testing.
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> QUICHE_EXPORT
+GetStrongRsaKeys3072();
+
+// Method returns fixed 4096-bit strong RSA modulus for testing.
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> QUICHE_EXPORT
+GetStrongRsaKeys4096();
+
+// Returns the IETF test example from
+// https://datatracker.ietf.org/doc/draft-irtf-cfrg-rsa-blind-signatures/
+IetfStandardRsaBlindSignatureTestVector QUICHE_EXPORT
+GetIetfStandardRsaBlindSignatureTestVector();
+
+// This method returns a RSA key pair as described in the IETF test example
+// above.
+absl::StatusOr<std::pair<RSAPublicKey, RSAPrivateKey>> QUICHE_EXPORT
+GetIetfStandardRsaBlindSignatureTestKeys();
+
+// Outputs a random string of n characters.
+std::string QUICHE_EXPORT RandomString(
+    int n, std::uniform_int_distribution<int>* distr_u8,
+    std::mt19937_64* generator);
+
+#define ANON_TOKENS_ASSERT_OK_AND_ASSIGN(lhs, rexpr)                       \
+  ANON_TOKENS_ASSERT_OK_AND_ASSIGN_IMPL_(                                  \
+      ANON_TOKENS_STATUS_TESTING_IMPL_CONCAT_(_status_or_value, __LINE__), \
+      lhs, rexpr)
+
+#define ANON_TOKENS_ASSERT_OK_AND_ASSIGN_IMPL_(statusor, lhs, rexpr) \
+  auto statusor = (rexpr);                                           \
+  ASSERT_THAT(statusor.ok(), ::testing::Eq(true));                   \
+  lhs = std::move(statusor).value()
+
+#define ANON_TOKENS_STATUS_TESTING_IMPL_CONCAT_INNER_(x, y) x##y
+#define ANON_TOKENS_STATUS_TESTING_IMPL_CONCAT_(x, y) \
+  ANON_TOKENS_STATUS_TESTING_IMPL_CONCAT_INNER_(x, y)
+
+}  // namespace anonymous_tokens
+}  // namespace private_membership
+
+#endif  // THIRD_PARTY_ANONYMOUS_TOKENS_CPP_TESTING_UTILS_H_