crypto/p224_spake_unittest.cc

   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
   5 #include <crypto/p224_spake.h>
   6
   7 #include "base/logging.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 using namespace crypto;
  11
  12 bool RunExchange(P224EncryptedKeyExchange* client,
  13                  P224EncryptedKeyExchange* server) {
  14
  15   for (;;) {
  16     std::string client_message, server_message;
  17     client_message = client->GetMessage();
  18     server_message = server->GetMessage();
  19
  20     P224EncryptedKeyExchange::Result client_result, server_result;
  21     client_result = client->ProcessMessage(server_message);
  22     server_result = server->ProcessMessage(client_message);
  23
  24     // Check that we never hit the case where only one succeeds.
  25     if ((client_result == P224EncryptedKeyExchange::kResultSuccess) ^
  26         (server_result == P224EncryptedKeyExchange::kResultSuccess)) {
  27       CHECK(false) << "Parties differ on whether authentication was successful";
  28     }
  29
  30     if (client_result == P224EncryptedKeyExchange::kResultFailed ||
  31         server_result == P224EncryptedKeyExchange::kResultFailed) {
  32       return false;
  33     }
  34
  35     if (client_result == P224EncryptedKeyExchange::kResultSuccess &&
  36         server_result == P224EncryptedKeyExchange::kResultSuccess) {
  37       return true;
  38     }
  39
  40     CHECK_EQ(P224EncryptedKeyExchange::kResultPending, client_result);
  41     CHECK_EQ(P224EncryptedKeyExchange::kResultPending, server_result);
  42   }
  43 }
  44
  45 static const char kPassword[] = "foo";
  46
  47 TEST(MutualAuth, CorrectAuth) {
  48   P224EncryptedKeyExchange client(
  49       P224EncryptedKeyExchange::kPeerTypeClient, kPassword);
  50   P224EncryptedKeyExchange server(
  51       P224EncryptedKeyExchange::kPeerTypeServer, kPassword);
  52
  53   EXPECT_TRUE(RunExchange(&client, &server));
  54   EXPECT_EQ(client.GetKey(), server.GetKey());
  55 }
  56
  57 TEST(MutualAuth, IncorrectPassword) {
  58   P224EncryptedKeyExchange client(
  59       P224EncryptedKeyExchange::kPeerTypeClient,
  60       kPassword);
  61   P224EncryptedKeyExchange server(
  62       P224EncryptedKeyExchange::kPeerTypeServer,
  63       "wrongpassword");
  64
  65   EXPECT_FALSE(RunExchange(&client, &server));
  66 }
  67
  68 TEST(MutualAuth, Fuzz) {
  69   static const unsigned kIterations = 40;
  70
  71   for (unsigned i = 0; i < kIterations; i++) {
  72     P224EncryptedKeyExchange client(
  73         P224EncryptedKeyExchange::kPeerTypeClient, kPassword);
  74     P224EncryptedKeyExchange server(
  75         P224EncryptedKeyExchange::kPeerTypeServer, kPassword);
  76
  77     // We'll only be testing small values of i, but we don't want that to bias
  78     // the test coverage. So we disperse the value of i by multiplying by the
  79     // FNV, 32-bit prime, producing a poor-man's PRNG.
  80     const uint32 rand = i * 16777619;
  81
  82     for (unsigned round = 0;; round++) {
  83       std::string client_message, server_message;
  84       client_message = client.GetMessage();
  85       server_message = server.GetMessage();
  86
  87       if ((rand & 1) == round) {
  88         const bool server_or_client = rand & 2;
  89         std::string* m = server_or_client ? &server_message : &client_message;
  90         if (rand & 4) {
  91           // Truncate
  92           *m = m->substr(0, (i >> 3) % m->size());
  93         } else {
  94           // Corrupt
  95           const size_t bits = m->size() * 8;
  96           const size_t bit_to_corrupt = (rand >> 3) % bits;
  97           const_cast<char*>(m->data())[bit_to_corrupt / 8] ^=
  98               1 << (bit_to_corrupt % 8);
  99         }
 100       }
 101
 102       P224EncryptedKeyExchange::Result client_result, server_result;
 103       client_result = client.ProcessMessage(server_message);
 104       server_result = server.ProcessMessage(client_message);
 105
 106       // If we have corrupted anything, we expect the authentication to fail,
 107       // although one side can succeed if we happen to corrupt the second round
 108       // message to the other.
 109       ASSERT_FALSE(
 110           client_result == P224EncryptedKeyExchange::kResultSuccess &&
 111           server_result == P224EncryptedKeyExchange::kResultSuccess);
 112
 113       if (client_result == P224EncryptedKeyExchange::kResultFailed ||
 114           server_result == P224EncryptedKeyExchange::kResultFailed) {
 115         break;
 116       }
 117
 118       ASSERT_EQ(P224EncryptedKeyExchange::kResultPending,
 119                 client_result);
 120       ASSERT_EQ(P224EncryptedKeyExchange::kResultPending,
 121                 server_result);
 122     }
 123   }
 124 }