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