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/streamingaead/aes_gcm_hkdf_streaming_key_manager.h"
18
19 #include <sstream>
20 #include <string>
21 #include <utility>
22
23 #include "gtest/gtest.h"
24 #include "absl/status/status.h"
25 #include "absl/strings/str_cat.h"
26 #include "absl/strings/string_view.h"
27 #include "tink/streaming_aead.h"
28 #include "tink/subtle/aes_gcm_hkdf_streaming.h"
29 #include "tink/subtle/common_enums.h"
30 #include "tink/subtle/random.h"
31 #include "tink/subtle/streaming_aead_test_util.h"
32 #include "tink/subtle/test_util.h"
33 #include "tink/util/istream_input_stream.h"
34 #include "tink/util/ostream_output_stream.h"
35 #include "tink/util/secret_data.h"
36 #include "tink/util/status.h"
37 #include "tink/util/statusor.h"
38 #include "tink/util/test_matchers.h"
39 #include "proto/aes_eax.pb.h"
40 #include "proto/aes_gcm_hkdf_streaming.pb.h"
41 #include "proto/common.pb.h"
42 #include "proto/tink.pb.h"
43
44 namespace crypto {
45 namespace tink {
46
47 using ::crypto::tink::test::IsOk;
48 using ::crypto::tink::test::StatusIs;
49 using ::crypto::tink::util::IstreamInputStream;
50 using ::crypto::tink::util::StatusOr;
51 using ::google::crypto::tink::AesGcmHkdfStreamingKey;
52 using ::google::crypto::tink::AesGcmHkdfStreamingKeyFormat;
53 using ::google::crypto::tink::HashType;
54 using ::testing::Eq;
55 using ::testing::HasSubstr;
56 using ::testing::Not;
57
58 namespace {
59
TEST(AesGcmHkdfStreamingKeyManagerTest,ValidateKey)60 TEST(AesGcmHkdfStreamingKeyManagerTest, ValidateKey) {
61 AesGcmHkdfStreamingKey key;
62 key.set_version(0);
63 key.set_key_value("0123456789abcdef");
64 key.mutable_params()->set_derived_key_size(16);
65 key.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
66 key.mutable_params()->set_ciphertext_segment_size(1024);
67 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().ValidateKey(key), IsOk());
68 }
69
TEST(AesGcmHkdfStreamingKeyManagerTest,ValidateKeyDerivedKeySizes)70 TEST(AesGcmHkdfStreamingKeyManagerTest, ValidateKeyDerivedKeySizes) {
71 for (int derived_key_size = 0; derived_key_size < 42; derived_key_size++) {
72 SCOPED_TRACE(absl::StrCat(" derived_key_size = ", derived_key_size));
73 AesGcmHkdfStreamingKey key;
74 key.set_version(0);
75 key.set_key_value(std::string(derived_key_size, 'a')); // ikm
76 key.mutable_params()->set_derived_key_size(derived_key_size);
77 key.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
78 key.mutable_params()->set_ciphertext_segment_size(1024);
79 if (derived_key_size == 16 || derived_key_size == 32) {
80 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().ValidateKey(key), IsOk());
81 } else {
82 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().ValidateKey(key),
83 StatusIs(absl::StatusCode::kInvalidArgument));
84 }
85 }
86 }
87
TEST(AesGcmHkdfStreamingKeyManagerTest,ValidateKeyDerivedKeyWrongVersion)88 TEST(AesGcmHkdfStreamingKeyManagerTest, ValidateKeyDerivedKeyWrongVersion) {
89 AesGcmHkdfStreamingKey key;
90 key.set_version(1);
91 key.set_key_value("0123456789abcdef");
92 key.mutable_params()->set_derived_key_size(16);
93 key.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
94 key.mutable_params()->set_ciphertext_segment_size(1024);
95 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().ValidateKey(key),
96 StatusIs(absl::StatusCode::kInvalidArgument));
97 }
98
TEST(AesGcmHkdfStreamingKeyManagerTest,GetPrimitive)99 TEST(AesGcmHkdfStreamingKeyManagerTest, GetPrimitive) {
100 std::string plaintext = "some plaintext";
101 std::string aad = "some aad";
102
103 AesGcmHkdfStreamingKey key;
104 key.set_version(0);
105 key.set_key_value("16 bytes of key ");
106 key.mutable_params()->set_ciphertext_segment_size(1024);
107 key.mutable_params()->set_derived_key_size(16);
108 key.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
109
110 auto streaming_aead_from_manager_result =
111 AesGcmHkdfStreamingKeyManager().GetPrimitive<StreamingAead>(key);
112 EXPECT_THAT(streaming_aead_from_manager_result, IsOk());
113
114 int derived_key_size = 16;
115 int ciphertext_segment_size = 1024;
116 int ciphertext_offset = 0;
117 subtle::AesGcmHkdfStreaming::Params params;
118 params.ikm = util::SecretDataFromStringView("16 bytes of key ");
119 params.hkdf_hash = crypto::tink::subtle::HashType::SHA256;
120 params.derived_key_size = derived_key_size;
121 params.ciphertext_segment_size = ciphertext_segment_size;
122 params.ciphertext_offset = ciphertext_offset;
123 auto streaming_aead_direct_result =
124 subtle::AesGcmHkdfStreaming::New(std::move(params));
125 EXPECT_THAT(streaming_aead_direct_result, IsOk());
126
127 // Check that the two primitives are the same by encrypting with one, and
128 // decrypting with the other.
129 EXPECT_THAT(
130 EncryptThenDecrypt(streaming_aead_from_manager_result.value().get(),
131 streaming_aead_direct_result.value().get(),
132 subtle::Random::GetRandomBytes(10000),
133 "some associated data", ciphertext_offset),
134 IsOk());
135 }
136
TEST(AesGcmHkdfStreamingKeyManagerTest,Version)137 TEST(AesGcmHkdfStreamingKeyManagerTest, Version) {
138 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().get_version(), Eq(0));
139 }
140
TEST(AesGcmHkdfStreamingKeyManagerTest,KeyMaterialType)141 TEST(AesGcmHkdfStreamingKeyManagerTest, KeyMaterialType) {
142 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().key_material_type(),
143 Eq(google::crypto::tink::KeyData::SYMMETRIC));
144 }
145
TEST(AesGcmHkdfStreamingKeyManagerTest,KeyType)146 TEST(AesGcmHkdfStreamingKeyManagerTest, KeyType) {
147 EXPECT_THAT(
148 AesGcmHkdfStreamingKeyManager().get_key_type(),
149 Eq("type.googleapis.com/google.crypto.tink.AesGcmHkdfStreamingKey"));
150 }
151
TEST(AesGcmHkdfStreamingKeyManagerTest,ValidateKeyFormatEmpty)152 TEST(AesGcmHkdfStreamingKeyManagerTest, ValidateKeyFormatEmpty) {
153 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().ValidateKeyFormat(
154 AesGcmHkdfStreamingKeyFormat()),
155 StatusIs(absl::StatusCode::kInvalidArgument));
156 }
157
TEST(AesGcmHkdfStreamingKeyManagerTest,ValidateKeyFormat)158 TEST(AesGcmHkdfStreamingKeyManagerTest, ValidateKeyFormat) {
159 AesGcmHkdfStreamingKeyFormat key_format;
160 key_format.set_key_size(32);
161 key_format.mutable_params()->set_derived_key_size(32);
162 key_format.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
163 key_format.mutable_params()->set_ciphertext_segment_size(1024);
164 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().ValidateKeyFormat(key_format),
165 IsOk());
166 }
167
TEST(AesGcmHkdfStreamingKeyManagerTest,ValidateKeyFormatSmallKey)168 TEST(AesGcmHkdfStreamingKeyManagerTest, ValidateKeyFormatSmallKey) {
169 AesGcmHkdfStreamingKeyFormat key_format;
170 key_format.set_key_size(16);
171 key_format.mutable_params()->set_derived_key_size(32);
172 key_format.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
173 key_format.mutable_params()->set_ciphertext_segment_size(1024);
174 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().ValidateKeyFormat(key_format),
175 StatusIs(absl::StatusCode::kInvalidArgument,
176 HasSubstr("derived_key_size")));
177 }
178
TEST(AesGcmHkdfStreamingKeyManagerTest,ValidateKeyFormatWrongHash)179 TEST(AesGcmHkdfStreamingKeyManagerTest, ValidateKeyFormatWrongHash) {
180 AesGcmHkdfStreamingKeyFormat key_format;
181 key_format.set_key_size(32);
182 key_format.mutable_params()->set_derived_key_size(32);
183 key_format.mutable_params()->set_ciphertext_segment_size(1024);
184 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().ValidateKeyFormat(key_format),
185 StatusIs(absl::StatusCode::kInvalidArgument,
186 HasSubstr("hkdf_hash_type")));
187 }
188
TEST(AesGcmHkdfStreamingKeyManagerTest,ValidateKeyFormatSmallSegment)189 TEST(AesGcmHkdfStreamingKeyManagerTest, ValidateKeyFormatSmallSegment) {
190 AesGcmHkdfStreamingKeyFormat key_format;
191 key_format.set_key_size(32);
192 key_format.mutable_params()->set_derived_key_size(32);
193 key_format.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
194 key_format.mutable_params()->set_ciphertext_segment_size(45);
195 EXPECT_THAT(AesGcmHkdfStreamingKeyManager().ValidateKeyFormat(key_format),
196 StatusIs(absl::StatusCode::kInvalidArgument,
197 HasSubstr("ciphertext_segment_size")));
198 }
199
TEST(AesGcmHkdfStreamingKeyManagerTest,CreateKey)200 TEST(AesGcmHkdfStreamingKeyManagerTest, CreateKey) {
201 AesGcmHkdfStreamingKeyFormat key_format;
202 key_format.set_key_size(32);
203 key_format.mutable_params()->set_derived_key_size(32);
204 key_format.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
205 key_format.mutable_params()->set_ciphertext_segment_size(1024);
206 auto key_or = AesGcmHkdfStreamingKeyManager().CreateKey(key_format);
207 ASSERT_THAT(key_or, IsOk());
208 EXPECT_THAT(key_or.value().version(), Eq(0));
209 EXPECT_THAT(key_or.value().params().ciphertext_segment_size(),
210 Eq(key_format.params().ciphertext_segment_size()));
211 EXPECT_THAT(key_or.value().params().derived_key_size(),
212 Eq(key_format.params().derived_key_size()));
213 EXPECT_THAT(key_or.value().params().hkdf_hash_type(),
214 Eq(key_format.params().hkdf_hash_type()));
215 EXPECT_THAT(key_or.value().key_value().size(), Eq(key_format.key_size()));
216 }
217
TEST(AesGcmHkdfStreamingKeyManagerTest,DeriveKey)218 TEST(AesGcmHkdfStreamingKeyManagerTest, DeriveKey) {
219 AesGcmHkdfStreamingKeyFormat key_format;
220 key_format.set_version(0);
221 key_format.set_key_size(32);
222 key_format.mutable_params()->set_derived_key_size(32);
223 key_format.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
224 key_format.mutable_params()->set_ciphertext_segment_size(1024);
225
226 IstreamInputStream input_stream{
227 absl::make_unique<std::stringstream>("01234567890123456789012345678901")};
228
229 StatusOr<AesGcmHkdfStreamingKey> key_or =
230 AesGcmHkdfStreamingKeyManager().DeriveKey(key_format, &input_stream);
231 ASSERT_THAT(key_or, IsOk());
232 EXPECT_THAT(key_or.value().key_value(),
233 Eq("01234567890123456789012345678901"));
234 EXPECT_THAT(key_or.value().params().derived_key_size(),
235 Eq(key_format.params().derived_key_size()));
236 EXPECT_THAT(key_or.value().params().hkdf_hash_type(),
237 Eq(key_format.params().hkdf_hash_type()));
238 EXPECT_THAT(key_or.value().params().ciphertext_segment_size(),
239 Eq(key_format.params().ciphertext_segment_size()));
240 }
241
TEST(AesGcmHkdfStreamingKeyManagerTest,DeriveKeyNotEnoughRandomness)242 TEST(AesGcmHkdfStreamingKeyManagerTest, DeriveKeyNotEnoughRandomness) {
243 AesGcmHkdfStreamingKeyFormat key_format;
244 key_format.set_version(0);
245 key_format.set_key_size(32);
246 key_format.mutable_params()->set_derived_key_size(32);
247 key_format.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
248 key_format.mutable_params()->set_ciphertext_segment_size(1024);
249
250 IstreamInputStream input_stream{
251 absl::make_unique<std::stringstream>("0123456789012345678901234567890")};
252
253 ASSERT_THAT(AesGcmHkdfStreamingKeyManager()
254 .DeriveKey(key_format, &input_stream)
255 .status(),
256 Not(IsOk()));
257 }
258
TEST(AesGcmHkdfStreamingKeyManagerTest,DeriveKeyWrongVersion)259 TEST(AesGcmHkdfStreamingKeyManagerTest, DeriveKeyWrongVersion) {
260 AesGcmHkdfStreamingKeyFormat key_format;
261 key_format.set_version(1);
262 key_format.set_key_size(32);
263 key_format.mutable_params()->set_derived_key_size(32);
264 key_format.mutable_params()->set_hkdf_hash_type(HashType::SHA256);
265 key_format.mutable_params()->set_ciphertext_segment_size(1024);
266
267 IstreamInputStream input_stream{absl::make_unique<std::stringstream>(
268 "0123456789abcdef")};
269
270 ASSERT_THAT(
271 AesGcmHkdfStreamingKeyManager()
272 .DeriveKey(key_format, &input_stream)
273 .status(),
274 StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("version")));
275 }
276
277 } // namespace
278 } // namespace tink
279 } // namespace crypto
280