Allow to get key from SPAKE2 after the first round trip.

crypto/p224_spake_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <crypto/p224_spake.h>
 
 #include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace crypto {
 
 namespace {
 
 bool RunExchange(P224EncryptedKeyExchange* client,
-                 P224EncryptedKeyExchange* server) {
+                 P224EncryptedKeyExchange* server,
+                 bool is_password_same) {
   for (;;) {
     std::string client_message, server_message;
     client_message = client->GetMessage();
     server_message = server->GetMessage();
 
     P224EncryptedKeyExchange::Result client_result, server_result;
     client_result = client->ProcessMessage(server_message);
     server_result = server->ProcessMessage(client_message);
 
     // Check that we never hit the case where only one succeeds.
-    if ((client_result == P224EncryptedKeyExchange::kResultSuccess) ^
-        (server_result == P224EncryptedKeyExchange::kResultSuccess)) {
-      CHECK(false) << "Parties differ on whether authentication was successful";
-    }
+    EXPECT_EQ(client_result == P224EncryptedKeyExchange::kResultSuccess,
+              server_result == P224EncryptedKeyExchange::kResultSuccess);
 
     if (client_result == P224EncryptedKeyExchange::kResultFailed ||
         server_result == P224EncryptedKeyExchange::kResultFailed) {
       return false;
     }
 
+    EXPECT_EQ(is_password_same,
+              client->GetUnverifiedKey() == server->GetUnverifiedKey());
+
     if (client_result == P224EncryptedKeyExchange::kResultSuccess &&
         server_result == P224EncryptedKeyExchange::kResultSuccess) {
       return true;
     }
 
-    CHECK_EQ(P224EncryptedKeyExchange::kResultPending, client_result);
-    CHECK_EQ(P224EncryptedKeyExchange::kResultPending, server_result);
+    EXPECT_EQ(P224EncryptedKeyExchange::kResultPending, client_result);
+    EXPECT_EQ(P224EncryptedKeyExchange::kResultPending, server_result);
   }
 }
 
 const char kPassword[] = "foo";
 
 }  // namespace
 
 TEST(MutualAuth, CorrectAuth) {
   P224EncryptedKeyExchange client(
       P224EncryptedKeyExchange::kPeerTypeClient, kPassword);
   P224EncryptedKeyExchange server(
       P224EncryptedKeyExchange::kPeerTypeServer, kPassword);
 
-  EXPECT_TRUE(RunExchange(&client, &server));
+  EXPECT_TRUE(RunExchange(&client, &server, true));
   EXPECT_EQ(client.GetKey(), server.GetKey());
 }
 
 TEST(MutualAuth, IncorrectPassword) {
   P224EncryptedKeyExchange client(
       P224EncryptedKeyExchange::kPeerTypeClient,
       kPassword);
   P224EncryptedKeyExchange server(
       P224EncryptedKeyExchange::kPeerTypeServer,
       "wrongpassword");
 
-  EXPECT_FALSE(RunExchange(&client, &server));
+  EXPECT_FALSE(RunExchange(&client, &server, false));
 }
 
 TEST(MutualAuth, Fuzz) {
   static const unsigned kIterations = 40;
 
   for (unsigned i = 0; i < kIterations; i++) {
     P224EncryptedKeyExchange client(
         P224EncryptedKeyExchange::kPeerTypeClient, kPassword);
     P224EncryptedKeyExchange server(
         P224EncryptedKeyExchange::kPeerTypeServer, kPassword);
@@ skipping 41 matching lines @@
 
       ASSERT_EQ(P224EncryptedKeyExchange::kResultPending,
                 client_result);
       ASSERT_EQ(P224EncryptedKeyExchange::kResultPending,
                 server_result);
     }
   }
 }
 
 }  // namespace crypto