p224_spake_unittest.cc 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176
  1. // Copyright (c) 2011 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "crypto/p224_spake.h"
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include <string>
  8. #include "base/strings/string_number_conversions.h"
  9. #include "testing/gtest/include/gtest/gtest.h"
  10. namespace crypto {
  11. namespace {
  12. std::string HexEncodeString(const std::string& binary_data) {
  13. return base::HexEncode(binary_data.c_str(), binary_data.size());
  14. }
  15. bool RunExchange(P224EncryptedKeyExchange* client,
  16. P224EncryptedKeyExchange* server,
  17. bool is_password_same) {
  18. for (;;) {
  19. std::string client_message, server_message;
  20. client_message = client->GetNextMessage();
  21. server_message = server->GetNextMessage();
  22. P224EncryptedKeyExchange::Result client_result, server_result;
  23. client_result = client->ProcessMessage(server_message);
  24. server_result = server->ProcessMessage(client_message);
  25. // Check that we never hit the case where only one succeeds.
  26. EXPECT_EQ(client_result == P224EncryptedKeyExchange::kResultSuccess,
  27. server_result == P224EncryptedKeyExchange::kResultSuccess);
  28. if (client_result == P224EncryptedKeyExchange::kResultFailed ||
  29. server_result == P224EncryptedKeyExchange::kResultFailed) {
  30. return false;
  31. }
  32. EXPECT_EQ(is_password_same,
  33. client->GetUnverifiedKey() == server->GetUnverifiedKey());
  34. if (client_result == P224EncryptedKeyExchange::kResultSuccess &&
  35. server_result == P224EncryptedKeyExchange::kResultSuccess) {
  36. return true;
  37. }
  38. EXPECT_EQ(P224EncryptedKeyExchange::kResultPending, client_result);
  39. EXPECT_EQ(P224EncryptedKeyExchange::kResultPending, server_result);
  40. }
  41. }
  42. const char kPassword[] = "foo";
  43. } // namespace
  44. TEST(MutualAuth, CorrectAuth) {
  45. P224EncryptedKeyExchange client(
  46. P224EncryptedKeyExchange::kPeerTypeClient, kPassword);
  47. P224EncryptedKeyExchange server(
  48. P224EncryptedKeyExchange::kPeerTypeServer, kPassword);
  49. EXPECT_TRUE(RunExchange(&client, &server, true));
  50. EXPECT_EQ(client.GetKey(), server.GetKey());
  51. }
  52. TEST(MutualAuth, IncorrectPassword) {
  53. P224EncryptedKeyExchange client(
  54. P224EncryptedKeyExchange::kPeerTypeClient,
  55. kPassword);
  56. P224EncryptedKeyExchange server(
  57. P224EncryptedKeyExchange::kPeerTypeServer,
  58. "wrongpassword");
  59. EXPECT_FALSE(RunExchange(&client, &server, false));
  60. }
  61. TEST(MutualAuth, ExpectedValues) {
  62. P224EncryptedKeyExchange client(P224EncryptedKeyExchange::kPeerTypeClient,
  63. kPassword);
  64. client.SetXForTesting("Client x");
  65. P224EncryptedKeyExchange server(P224EncryptedKeyExchange::kPeerTypeServer,
  66. kPassword);
  67. server.SetXForTesting("Server x");
  68. std::string client_message = client.GetNextMessage();
  69. EXPECT_EQ(
  70. "3508EF7DECC8AB9F9C439FBB0154288BBECC0A82E8448F4CF29554EB"
  71. "BE9D486686226255EAD1D077C635B1A41F46AC91D7F7F32CED9EC3E0",
  72. HexEncodeString(client_message));
  73. std::string server_message = server.GetNextMessage();
  74. EXPECT_EQ(
  75. "A3088C18B75D2C2B107105661AEC85424777475EB29F1DDFB8C14AFB"
  76. "F1603D0DF38413A00F420ACF2059E7997C935F5A957A193D09A2B584",
  77. HexEncodeString(server_message));
  78. EXPECT_EQ(P224EncryptedKeyExchange::kResultPending,
  79. client.ProcessMessage(server_message));
  80. EXPECT_EQ(P224EncryptedKeyExchange::kResultPending,
  81. server.ProcessMessage(client_message));
  82. EXPECT_EQ(client.GetUnverifiedKey(), server.GetUnverifiedKey());
  83. // Must stay the same. External implementations should be able to pair with.
  84. EXPECT_EQ(
  85. "CE7CCFC435CDA4F01EC8826788B1F8B82EF7D550A34696B371096E64"
  86. "C487D4FE193F7D1A6FF6820BC7F807796BA3889E8F999BBDEFC32FFA",
  87. HexEncodeString(server.GetUnverifiedKey()));
  88. EXPECT_TRUE(RunExchange(&client, &server, true));
  89. EXPECT_EQ(client.GetKey(), server.GetKey());
  90. }
  91. TEST(MutualAuth, Fuzz) {
  92. static const unsigned kIterations = 40;
  93. for (unsigned i = 0; i < kIterations; i++) {
  94. P224EncryptedKeyExchange client(
  95. P224EncryptedKeyExchange::kPeerTypeClient, kPassword);
  96. P224EncryptedKeyExchange server(
  97. P224EncryptedKeyExchange::kPeerTypeServer, kPassword);
  98. // We'll only be testing small values of i, but we don't want that to bias
  99. // the test coverage. So we disperse the value of i by multiplying by the
  100. // FNV, 32-bit prime, producing a simplistic PRNG.
  101. const uint32_t rand = i * 16777619;
  102. for (unsigned round = 0;; round++) {
  103. std::string client_message, server_message;
  104. client_message = client.GetNextMessage();
  105. server_message = server.GetNextMessage();
  106. if ((rand & 1) == round) {
  107. const bool server_or_client = rand & 2;
  108. std::string* m = server_or_client ? &server_message : &client_message;
  109. if (rand & 4) {
  110. // Truncate
  111. *m = m->substr(0, (i >> 3) % m->size());
  112. } else {
  113. // Corrupt
  114. const size_t bits = m->size() * 8;
  115. const size_t bit_to_corrupt = (rand >> 3) % bits;
  116. const_cast<char*>(m->data())[bit_to_corrupt / 8] ^=
  117. 1 << (bit_to_corrupt % 8);
  118. }
  119. }
  120. P224EncryptedKeyExchange::Result client_result, server_result;
  121. client_result = client.ProcessMessage(server_message);
  122. server_result = server.ProcessMessage(client_message);
  123. // If we have corrupted anything, we expect the authentication to fail,
  124. // although one side can succeed if we happen to corrupt the second round
  125. // message to the other.
  126. ASSERT_FALSE(
  127. client_result == P224EncryptedKeyExchange::kResultSuccess &&
  128. server_result == P224EncryptedKeyExchange::kResultSuccess);
  129. if (client_result == P224EncryptedKeyExchange::kResultFailed ||
  130. server_result == P224EncryptedKeyExchange::kResultFailed) {
  131. break;
  132. }
  133. ASSERT_EQ(P224EncryptedKeyExchange::kResultPending,
  134. client_result);
  135. ASSERT_EQ(P224EncryptedKeyExchange::kResultPending,
  136. server_result);
  137. }
  138. }
  139. }
  140. } // namespace crypto