1 // Copyright 2017 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
15 ////////////////////////////////////////////////////////////////////////////////
16
17 #include "tink/mac/hmac_key_manager.h"
18
19 #include <memory>
20 #include <sstream>
21 #include <string>
22
23 #include "gmock/gmock.h"
24 #include "gtest/gtest.h"
25 #include "absl/status/status.h"
26 #include "tink/chunked_mac.h"
27 #include "tink/core/key_manager_impl.h"
28 #include "tink/mac.h"
29 #include "tink/util/istream_input_stream.h"
30 #include "tink/util/secret_data.h"
31 #include "tink/util/status.h"
32 #include "tink/util/statusor.h"
33 #include "tink/util/test_matchers.h"
34 #include "proto/hmac.pb.h"
35
36 namespace crypto {
37 namespace tink {
38
39 using ::crypto::tink::test::IsOk;
40 using ::crypto::tink::test::StatusIs;
41 using ::crypto::tink::util::IstreamInputStream;
42 using ::crypto::tink::util::StatusOr;
43 using ::google::crypto::tink::HashType;
44 using ::google::crypto::tink::HmacKey;
45 using ::google::crypto::tink::HmacKeyFormat;
46 using ::testing::Eq;
47 using ::testing::HasSubstr;
48 using ::testing::Not;
49 using ::testing::SizeIs;
50
51 namespace {
52
TEST(HmacKeyManagerTest,Basics)53 TEST(HmacKeyManagerTest, Basics) {
54 EXPECT_EQ(HmacKeyManager().get_version(), 0);
55 EXPECT_EQ(HmacKeyManager().get_key_type(),
56 "type.googleapis.com/google.crypto.tink.HmacKey");
57 EXPECT_EQ(HmacKeyManager().key_material_type(),
58 google::crypto::tink::KeyData::SYMMETRIC);
59 }
60
TEST(HmacKeyManagerTest,ValidateEmptyKey)61 TEST(HmacKeyManagerTest, ValidateEmptyKey) {
62 EXPECT_THAT(HmacKeyManager().ValidateKey(HmacKey()), Not(IsOk()));
63 }
64
TEST(HmacKeyManagerTest,ValidateEmptyKeyFormat)65 TEST(HmacKeyManagerTest, ValidateEmptyKeyFormat) {
66 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(HmacKeyFormat()), Not(IsOk()));
67 }
68
TEST(HmacKeyManagerTest,ValidKeyFormat)69 TEST(HmacKeyManagerTest, ValidKeyFormat) {
70 HmacKeyFormat key_format;
71 key_format.mutable_params()->set_tag_size(16);
72 key_format.mutable_params()->set_hash(HashType::SHA256);
73 key_format.set_key_size(16);
74 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), IsOk());
75 }
76
TEST(HmacKeyManagerTest,ValidateKeyFormatSmallTagSizes)77 TEST(HmacKeyManagerTest, ValidateKeyFormatSmallTagSizes) {
78 for (int i = 0; i < 10; ++i) {
79 HmacKeyFormat key_format;
80 key_format.mutable_params()->set_tag_size(i);
81 key_format.mutable_params()->set_hash(HashType::SHA256);
82 key_format.set_key_size(16);
83 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), Not(IsOk()))
84 << " for length " << i;
85 }
86 }
87
TEST(HmacKeyManagerTest,ValidateKeyFormatTagSizesSha1)88 TEST(HmacKeyManagerTest, ValidateKeyFormatTagSizesSha1) {
89 HmacKeyFormat key_format;
90 key_format.mutable_params()->set_hash(HashType::SHA1);
91 key_format.set_key_size(16);
92
93 key_format.mutable_params()->set_tag_size(20);
94 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), IsOk());
95 key_format.mutable_params()->set_tag_size(21);
96 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), Not(IsOk()));
97 }
98
TEST(HmacKeyManagerTest,ValidateKeyFormatTagSizesSha224)99 TEST(HmacKeyManagerTest, ValidateKeyFormatTagSizesSha224) {
100 HmacKeyFormat key_format;
101 key_format.mutable_params()->set_hash(HashType::SHA224);
102 key_format.set_key_size(16);
103
104 key_format.mutable_params()->set_tag_size(28);
105 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), IsOk());
106 key_format.mutable_params()->set_tag_size(29);
107 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), Not(IsOk()));
108 }
109
TEST(HmacKeyManagerTest,ValidateKeyFormatTagSizesSha256)110 TEST(HmacKeyManagerTest, ValidateKeyFormatTagSizesSha256) {
111 HmacKeyFormat key_format;
112 key_format.mutable_params()->set_hash(HashType::SHA256);
113 key_format.set_key_size(16);
114
115 key_format.mutable_params()->set_tag_size(32);
116 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), IsOk());
117 key_format.mutable_params()->set_tag_size(33);
118 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), Not(IsOk()));
119 }
120
TEST(HmacKeyManagerTest,ValidateKeyFormatTagSizesSha384)121 TEST(HmacKeyManagerTest, ValidateKeyFormatTagSizesSha384) {
122 HmacKeyFormat key_format;
123 key_format.mutable_params()->set_hash(HashType::SHA384);
124 key_format.set_key_size(16);
125
126 key_format.mutable_params()->set_tag_size(48);
127 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), IsOk());
128 key_format.mutable_params()->set_tag_size(49);
129 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), Not(IsOk()));
130 }
131
TEST(HmacKeyManagerTest,ValidateKeyFormatTagSizesSha512)132 TEST(HmacKeyManagerTest, ValidateKeyFormatTagSizesSha512) {
133 HmacKeyFormat key_format;
134 key_format.mutable_params()->set_hash(HashType::SHA512);
135 key_format.set_key_size(16);
136
137 key_format.mutable_params()->set_tag_size(64);
138 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), IsOk());
139 key_format.mutable_params()->set_tag_size(65);
140 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), Not(IsOk()));
141 }
142
TEST(HmacKeyManagerTest,ValidateKeyFormatKeySizes)143 TEST(HmacKeyManagerTest, ValidateKeyFormatKeySizes) {
144 HmacKeyFormat key_format;
145 key_format.mutable_params()->set_hash(HashType::SHA512);
146 key_format.mutable_params()->set_tag_size(64);
147
148 key_format.set_key_size(15);
149 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), Not(IsOk()));
150
151 key_format.set_key_size(16);
152 EXPECT_THAT(HmacKeyManager().ValidateKeyFormat(key_format), IsOk());
153 }
154
TEST(HmacKeyManagerTest,CreateKey)155 TEST(HmacKeyManagerTest, CreateKey) {
156 HmacKeyFormat key_format;
157 key_format.set_key_size(16);
158 key_format.mutable_params()->set_tag_size(10);
159 key_format.mutable_params()->set_hash(HashType::SHA512);
160 auto hmac_key_or = HmacKeyManager().CreateKey(key_format);
161 ASSERT_THAT(hmac_key_or, IsOk());
162 EXPECT_EQ(hmac_key_or.value().version(), 0);
163 EXPECT_EQ(hmac_key_or.value().params().hash(), key_format.params().hash());
164 EXPECT_EQ(hmac_key_or.value().params().tag_size(),
165 key_format.params().tag_size());
166 EXPECT_THAT(hmac_key_or.value().key_value(), SizeIs(key_format.key_size()));
167
168 EXPECT_THAT(HmacKeyManager().ValidateKey(hmac_key_or.value()), IsOk());
169 }
170
TEST(HmacKeyManagerTest,ValidKey)171 TEST(HmacKeyManagerTest, ValidKey) {
172 HmacKey key;
173 key.set_version(0);
174
175 key.mutable_params()->set_hash(HashType::SHA256);
176 key.mutable_params()->set_tag_size(10);
177 key.set_key_value("0123456789abcdef");
178
179 EXPECT_THAT(HmacKeyManager().ValidateKey(key), IsOk());
180 }
181
TEST(HmacKeyManagerTest,ValidateKeyTagSizesSha1)182 TEST(HmacKeyManagerTest, ValidateKeyTagSizesSha1) {
183 HmacKey key;
184 key.set_version(0);
185 key.mutable_params()->set_hash(HashType::SHA1);
186 key.set_key_value("0123456789abcdef");
187
188 key.mutable_params()->set_tag_size(20);
189 EXPECT_THAT(HmacKeyManager().ValidateKey(key), IsOk());
190 key.mutable_params()->set_tag_size(21);
191 EXPECT_THAT(HmacKeyManager().ValidateKey(key), Not(IsOk()));
192 }
193
TEST(HmacKeyManagerTest,ValidateKeyTagSizesSha224)194 TEST(HmacKeyManagerTest, ValidateKeyTagSizesSha224) {
195 HmacKey key;
196 key.set_version(0);
197 key.mutable_params()->set_hash(HashType::SHA224);
198 key.set_key_value("0123456789abcdef");
199
200 key.mutable_params()->set_tag_size(28);
201 EXPECT_THAT(HmacKeyManager().ValidateKey(key), IsOk());
202 key.mutable_params()->set_tag_size(29);
203 EXPECT_THAT(HmacKeyManager().ValidateKey(key), Not(IsOk()));
204 }
205
TEST(HmacKeyManagerTest,ValidateKeyTagSizesSha256)206 TEST(HmacKeyManagerTest, ValidateKeyTagSizesSha256) {
207 HmacKey key;
208 key.set_version(0);
209 key.mutable_params()->set_hash(HashType::SHA256);
210 key.set_key_value("0123456789abcdef");
211
212 key.mutable_params()->set_tag_size(32);
213 EXPECT_THAT(HmacKeyManager().ValidateKey(key), IsOk());
214 key.mutable_params()->set_tag_size(33);
215 EXPECT_THAT(HmacKeyManager().ValidateKey(key), Not(IsOk()));
216 }
217
TEST(HmacKeyManagerTest,ValidateKeyTagSizesSha384)218 TEST(HmacKeyManagerTest, ValidateKeyTagSizesSha384) {
219 HmacKey key;
220 key.set_version(0);
221 key.mutable_params()->set_hash(HashType::SHA384);
222 key.set_key_value("0123456789abcdef");
223
224 key.mutable_params()->set_tag_size(48);
225 EXPECT_THAT(HmacKeyManager().ValidateKey(key), IsOk());
226 key.mutable_params()->set_tag_size(49);
227 EXPECT_THAT(HmacKeyManager().ValidateKey(key), Not(IsOk()));
228 }
229
TEST(HmacKeyManagerTest,ValidateKeyTagSizesSha512)230 TEST(HmacKeyManagerTest, ValidateKeyTagSizesSha512) {
231 HmacKey key;
232 key.set_version(0);
233 key.mutable_params()->set_hash(HashType::SHA512);
234 key.set_key_value("0123456789abcdef");
235
236 key.mutable_params()->set_tag_size(64);
237 EXPECT_THAT(HmacKeyManager().ValidateKey(key), IsOk());
238 key.mutable_params()->set_tag_size(65);
239 EXPECT_THAT(HmacKeyManager().ValidateKey(key), Not(IsOk()));
240 }
241
TEST(HmacKeyManagerTest,ValidateKeyShortKey)242 TEST(HmacKeyManagerTest, ValidateKeyShortKey) {
243 HmacKey key;
244 key.set_version(0);
245
246 key.mutable_params()->set_hash(HashType::SHA256);
247 key.mutable_params()->set_tag_size(10);
248 key.set_key_value("0123456789abcde");
249
250 EXPECT_THAT(HmacKeyManager().ValidateKey(key), Not(IsOk()));
251 }
252
TEST(HmacKeyManagerTest,DeriveKey)253 TEST(HmacKeyManagerTest, DeriveKey) {
254 HmacKeyFormat format;
255 format.set_key_size(23);
256 format.set_version(0);
257 format.mutable_params()->set_hash(HashType::SHA256);
258 format.mutable_params()->set_tag_size(10);
259
260 IstreamInputStream input_stream{
261 absl::make_unique<std::stringstream>("0123456789abcdefghijklmnop")};
262
263 StatusOr<HmacKey> key_or = HmacKeyManager().DeriveKey(format, &input_stream);
264 ASSERT_THAT(key_or, IsOk());
265 EXPECT_EQ(key_or.value().key_value(), "0123456789abcdefghijklm");
266 EXPECT_EQ(key_or.value().params().hash(), format.params().hash());
267 EXPECT_EQ(key_or.value().params().tag_size(), format.params().tag_size());
268 }
269
TEST(HmacKeyManagerTest,DeriveKeyNotEnoughRandomness)270 TEST(HmacKeyManagerTest, DeriveKeyNotEnoughRandomness) {
271 HmacKeyFormat format;
272 format.set_key_size(17);
273 format.set_version(0);
274 format.mutable_params()->set_hash(HashType::SHA256);
275 format.mutable_params()->set_tag_size(10);
276
277 IstreamInputStream input_stream{
278 absl::make_unique<std::stringstream>("0123456789abcdef")};
279
280 ASSERT_THAT(HmacKeyManager().DeriveKey(format, &input_stream).status(),
281 StatusIs(absl::StatusCode::kInvalidArgument));
282 }
283
TEST(HmacKeyManagerTest,DeriveKeyWrongVersion)284 TEST(HmacKeyManagerTest, DeriveKeyWrongVersion) {
285 HmacKeyFormat format;
286 format.set_key_size(16);
287 format.set_version(1);
288 format.mutable_params()->set_hash(HashType::SHA256);
289 format.mutable_params()->set_tag_size(10);
290
291 IstreamInputStream input_stream{
292 absl::make_unique<std::stringstream>("0123456789abcdef")};
293
294 ASSERT_THAT(
295 HmacKeyManager().DeriveKey(format, &input_stream).status(),
296 StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("version")));
297 }
298
TEST(HmacKeyManagerTest,GetMacPrimitive)299 TEST(HmacKeyManagerTest, GetMacPrimitive) {
300 HmacKeyFormat key_format;
301 key_format.mutable_params()->set_tag_size(16);
302 key_format.mutable_params()->set_hash(HashType::SHA256);
303 key_format.set_key_size(16);
304 HmacKey key = HmacKeyManager().CreateKey(key_format).value();
305 auto manager_mac_or = HmacKeyManager().GetPrimitive<Mac>(key);
306 ASSERT_THAT(manager_mac_or, IsOk());
307 auto mac_value_or = manager_mac_or.value()->ComputeMac("some plaintext");
308 ASSERT_THAT(mac_value_or, IsOk());
309
310 auto direct_mac_or = subtle::HmacBoringSsl::New(
311 util::Enums::ProtoToSubtle(key.params().hash()), key.params().tag_size(),
312 util::SecretDataFromStringView(key.key_value()));
313 ASSERT_THAT(direct_mac_or, IsOk());
314 EXPECT_THAT(
315 direct_mac_or.value()->VerifyMac(mac_value_or.value(), "some plaintext"),
316 IsOk());
317 }
318
TEST(HmacKeyManagerTest,GetChunkedMacPrimitive)319 TEST(HmacKeyManagerTest, GetChunkedMacPrimitive) {
320 HmacKeyFormat key_format;
321 key_format.mutable_params()->set_tag_size(16);
322 key_format.mutable_params()->set_hash(HashType::SHA256);
323 key_format.set_key_size(16);
324 HmacKey key = HmacKeyManager().CreateKey(key_format).value();
325
326 util::StatusOr<std::unique_ptr<ChunkedMac>> chunked_mac =
327 HmacKeyManager().GetPrimitive<ChunkedMac>(key);
328 ASSERT_THAT(chunked_mac, IsOk());
329
330 util::StatusOr<std::unique_ptr<ChunkedMacComputation>> computation =
331 (*chunked_mac)->CreateComputation();
332 ASSERT_THAT(computation, IsOk());
333 ASSERT_THAT((*computation)->Update("abc"), IsOk());
334 ASSERT_THAT((*computation)->Update("xyz"), IsOk());
335 util::StatusOr<std::string> tag = (*computation)->ComputeMac();
336 ASSERT_THAT(tag, IsOk());
337
338 util::StatusOr<std::unique_ptr<ChunkedMacVerification>> verification =
339 (*chunked_mac)->CreateVerification(*tag);
340 ASSERT_THAT(verification, IsOk());
341 ASSERT_THAT((*verification)->Update("abc"), IsOk());
342 ASSERT_THAT((*verification)->Update("xyz"), IsOk());
343 EXPECT_THAT((*verification)->VerifyMac(), IsOk());
344 }
345
TEST(HmacKeyManagerTest,MixPrimitives)346 TEST(HmacKeyManagerTest, MixPrimitives) {
347 HmacKeyFormat key_format;
348 key_format.mutable_params()->set_tag_size(16);
349 key_format.mutable_params()->set_hash(HashType::SHA256);
350 key_format.set_key_size(16);
351 HmacKey key = HmacKeyManager().CreateKey(key_format).value();
352
353 util::StatusOr<std::unique_ptr<Mac>> mac =
354 HmacKeyManager().GetPrimitive<Mac>(key);
355 ASSERT_THAT(mac, IsOk());
356
357 util::StatusOr<std::unique_ptr<ChunkedMac>> chunked_mac =
358 HmacKeyManager().GetPrimitive<ChunkedMac>(key);
359 ASSERT_THAT(chunked_mac, IsOk());
360
361 // Compute tag with Mac.
362 util::StatusOr<std::string> tag = (*mac)->ComputeMac("abcxyz");
363 ASSERT_THAT(tag, IsOk());
364
365 // Compute chunked tag with ChunkedMac.
366 util::StatusOr<std::unique_ptr<ChunkedMacComputation>> computation =
367 (*chunked_mac)->CreateComputation();
368 ASSERT_THAT(computation, IsOk());
369 ASSERT_THAT((*computation)->Update("abc"), IsOk());
370 ASSERT_THAT((*computation)->Update("xyz"), IsOk());
371 util::StatusOr<std::string> chunked_tag = (*computation)->ComputeMac();
372 ASSERT_THAT(chunked_tag, IsOk());
373 ASSERT_THAT(*chunked_tag, Eq(*tag)); // Both primitives generated same tag.
374
375 // Verify chunked tag with Mac.
376 ASSERT_THAT((*mac)->VerifyMac(*chunked_tag, "abcxyz"), IsOk());
377
378 // Verify tag with ChunkedMac.
379 util::StatusOr<std::unique_ptr<ChunkedMacVerification>> verification =
380 (*chunked_mac)->CreateVerification(*tag);
381 ASSERT_THAT(verification, IsOk());
382 ASSERT_THAT((*verification)->Update("abc"), IsOk());
383 ASSERT_THAT((*verification)->Update("xyz"), IsOk());
384 EXPECT_THAT((*verification)->VerifyMac(), IsOk());
385 }
386
387 } // namespace
388 } // namespace tink
389 } // namespace crypto
390