BlindSignAuth: Update error messages to return constant strings. Messages now return at Anonymous Tokens-level granularity.

PiperOrigin-RevId: 678345762

quiche/blind_sign_auth/blind_sign_auth.cc

diff --git a/quiche/blind_sign_auth/blind_sign_auth.cc b/quiche/blind_sign_auth/blind_sign_auth.cc
index 2f6c4e1..47031e2 100644
--- a/quiche/blind_sign_auth/blind_sign_auth.cc
+++ b/quiche/blind_sign_auth/blind_sign_auth.cc
@@ -78,7 +78,8 @@
   if (!response.ok()) {
     QUICHE_LOG(WARNING) << "GetInitialDataRequest failed: "
                         << response.status();
-    std::move(callback)(response.status());
+    std::move(callback)(absl::InvalidArgumentError(
+        "GetInitialDataRequest failed: invalid response"));
     return;
   }
   absl::StatusCode code = response->status_code();
@@ -86,7 +87,8 @@
     std::string message =
         absl::StrCat("GetInitialDataRequest failed with code: ", code);
     QUICHE_LOG(WARNING) << message;
-    std::move(callback)(absl::Status(code, message));
+    std::move(callback)(
+        absl::InvalidArgumentError("GetInitialDataRequest failed"));
     return;
   }
   // Parse GetInitialDataResponse.
@@ -133,7 +135,9 @@
       anonymous_tokens::CreatePublicKeyRSA(
           public_key_proto.n(), public_key_proto.e());
   if (!bssl_rsa_key.ok()) {
-    std::move(callback)(bssl_rsa_key.status());
+    QUICHE_LOG(ERROR) << "Failed to create RSA public key: "
+                      << bssl_rsa_key.status();
+    std::move(callback)(absl::InternalError("Failed to create RSA public key"));
     return;
   }
   absl::StatusOr<anonymous_tokens::Extensions> extensions =
@@ -143,7 +147,8 @@
   if (!extensions.ok()) {
     QUICHE_LOG(WARNING) << "Failed to decode extensions: "
                         << extensions.status();
-    std::move(callback)(extensions.status());
+    std::move(callback)(
+        absl::InvalidArgumentError("Failed to decode extensions"));
     return;
   }
   std::vector<uint16_t> kExpectedExtensionTypes = {
@@ -157,7 +162,8 @@
           *extensions, absl::MakeSpan(kExpectedExtensionTypes), absl::Now());
   if (!result.ok()) {
     QUICHE_LOG(WARNING) << "Failed to validate extensions: " << result;
-    std::move(callback)(result);
+    std::move(callback)(
+        absl::InvalidArgumentError("Failed to validate extensions"));
     return;
   }
   absl::StatusOr<anonymous_tokens::ExpirationTimestamp>
@@ -166,7 +172,8 @@
   if (!expiration_timestamp.ok()) {
     QUICHE_LOG(WARNING) << "Failed to parse expiration timestamp: "
                         << expiration_timestamp.status();
-    std::move(callback)(expiration_timestamp.status());
+    std::move(callback)(
+        absl::InvalidArgumentError("Failed to parse expiration timestamp"));
     return;
   }
   absl::Time public_metadata_expiry_time =
@@ -185,7 +192,8 @@
   if (!token_challenge.ok()) {
     QUICHE_LOG(WARNING) << "Failed to marshal token challenge: "
                         << token_challenge.status();
-    std::move(callback)(token_challenge.status());
+    std::move(callback)(
+        absl::InvalidArgumentError("Failed to marshal token challenge"));
     return;
   }
 
@@ -205,7 +213,8 @@
     if (!client.ok()) {
       QUICHE_LOG(WARNING) << "Failed to create Privacy Pass client: "
                           << client.status();
-      std::move(callback)(client.status());
+      std::move(callback)(
+          absl::InternalError("Failed to create Privacy Pass client"));
       return;
     }
 
@@ -222,7 +231,8 @@
     if (!extended_token_request.ok()) {
       QUICHE_LOG(WARNING) << "Failed to create ExtendedTokenRequest: "
                           << extended_token_request.status();
-      std::move(callback)(extended_token_request.status());
+      std::move(callback)(
+          absl::InternalError("Failed to create ExtendedTokenRequest"));
       return;
     }
     privacy_pass_clients.push_back(*std::move(client));
@@ -249,7 +259,7 @@
           initial_data_response.at_public_metadata_public_key().use_case());
   if (!use_case.ok()) {
     QUICHE_LOG(WARNING) << "Failed to parse use case: " << use_case.status();
-    std::move(callback)(use_case.status());
+    std::move(callback)(absl::InvalidArgumentError("Failed to parse use case"));
     return;
   }
 
@@ -277,14 +287,15 @@
   // Validate response.
   if (!response.ok()) {
     QUICHE_LOG(WARNING) << "AuthAndSign failed: " << response.status();
-    std::move(callback)(response.status());
+    std::move(callback)(
+        absl::InvalidArgumentError("AuthAndSign failed: invalid response"));
     return;
   }
   absl::StatusCode code = response->status_code();
   if (code != absl::StatusCode::kOk) {
     std::string message = absl::StrCat("AuthAndSign failed with code: ", code);
     QUICHE_LOG(WARNING) << message;
-    std::move(callback)(absl::Status(code, message));
+    std::move(callback)(absl::InvalidArgumentError("AuthAndSign failed"));
     return;
   }
 
@@ -322,7 +333,7 @@
         privacy_pass_clients[i]->FinalizeToken(unescaped_blinded_sig);
     if (!token.ok()) {
       QUICHE_LOG(WARNING) << "Failed to finalize token: " << token.status();
-      std::move(callback)(token.status());
+      std::move(callback)(absl::InternalError("Failed to finalize token"));
       return;
     }
 
@@ -331,7 +342,7 @@
     if (!marshaled_token.ok()) {
       QUICHE_LOG(WARNING) << "Failed to marshal token: "
                           << marshaled_token.status();
-      std::move(callback)(marshaled_token.status());
+      std::move(callback)(absl::InternalError("Failed to marshal token"));
       return;
     }
 

quiche/blind_sign_auth/blind_sign_auth_test.cc

diff --git a/quiche/blind_sign_auth/blind_sign_auth_test.cc b/quiche/blind_sign_auth/blind_sign_auth_test.cc
index c9ee00d..7c681df 100644
--- a/quiche/blind_sign_auth/blind_sign_auth_test.cc
+++ b/quiche/blind_sign_auth/blind_sign_auth_test.cc
@@ -269,7 +269,7 @@
   QuicheNotification done;
   SignedTokenCallback callback =
       [&done](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
-        EXPECT_THAT(tokens.status().code(), absl::StatusCode::kInternal);
+        EXPECT_THAT(tokens.status().code(), absl::StatusCode::kInvalidArgument);
         done.Notify();
       };
   blind_sign_auth_->GetTokens(oauth_token_, num_tokens, ProxyLayer::kProxyA,