1 // Copyright 2018 Google LLC
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/aead/aes_eax_key_manager.h"
18
19 #include <stdint.h>
20
21 #include <memory>
22 #include <string>
23
24 #include "gmock/gmock.h"
25 #include "gtest/gtest.h"
26 #include "tink/aead.h"
27 #include "tink/subtle/aead_test_util.h"
28 #include "tink/subtle/aes_eax_boringssl.h"
29 #include "tink/util/secret_data.h"
30 #include "tink/util/status.h"
31 #include "tink/util/statusor.h"
32 #include "tink/util/test_matchers.h"
33 #include "proto/aes_eax.pb.h"
34 #include "proto/tink.pb.h"
35
36 namespace crypto {
37 namespace tink {
38
39 using ::crypto::tink::test::IsOk;
40 using ::crypto::tink::util::StatusOr;
41 using ::google::crypto::tink::AesEaxKey;
42 using ::google::crypto::tink::AesEaxKeyFormat;
43 using ::testing::Eq;
44 using ::testing::Ne;
45 using ::testing::Not;
46 using ::testing::SizeIs;
47
48 namespace {
49
TEST(AesEaxKeyManagerTest,Basics)50 TEST(AesEaxKeyManagerTest, Basics) {
51 EXPECT_THAT(AesEaxKeyManager().get_version(), Eq(0));
52 EXPECT_THAT(AesEaxKeyManager().get_key_type(),
53 Eq("type.googleapis.com/google.crypto.tink.AesEaxKey"));
54 EXPECT_THAT(AesEaxKeyManager().key_material_type(),
55 Eq(google::crypto::tink::KeyData::SYMMETRIC));
56 }
57
TEST(AesEaxKeyManagerTest,ValidateEmptyKey)58 TEST(AesEaxKeyManagerTest, ValidateEmptyKey) {
59 EXPECT_THAT(AesEaxKeyManager().ValidateKey(AesEaxKey()), Not(IsOk()));
60 }
61
TEST(AesEaxKeyManagerTest,ValidateEmptyKeyFormat)62 TEST(AesEaxKeyManagerTest, ValidateEmptyKeyFormat) {
63 EXPECT_THAT(AesEaxKeyManager().ValidateKeyFormat(AesEaxKeyFormat()),
64 Not(IsOk()));
65 }
66
TEST(AesEaxKeyManagerTest,ValidKeyFormat)67 TEST(AesEaxKeyManagerTest, ValidKeyFormat) {
68 AesEaxKeyFormat format;
69 format.set_key_size(32);
70 format.mutable_params()->set_iv_size(16);
71 EXPECT_THAT(AesEaxKeyManager().ValidateKeyFormat(format), IsOk());
72 }
73
TEST(AesEaxKeyManagerTest,ValidKeyFormatKeySize)74 TEST(AesEaxKeyManagerTest, ValidKeyFormatKeySize) {
75 AesEaxKeyFormat format;
76 format.mutable_params()->set_iv_size(16);
77
78 for (int len = 0; len < 200; ++len) {
79 format.set_key_size(len);
80 if (len == 16 || len == 32) {
81 EXPECT_THAT(AesEaxKeyManager().ValidateKeyFormat(format), IsOk())
82 << "for len = " << len;
83 } else {
84 EXPECT_THAT(AesEaxKeyManager().ValidateKeyFormat(format), Not(IsOk()))
85 << "for len = " << len;
86 }
87 }
88 }
89
TEST(AesEaxKeyManagerTest,ValidKeyFormatIvSize)90 TEST(AesEaxKeyManagerTest, ValidKeyFormatIvSize) {
91 AesEaxKeyFormat format;
92 format.set_key_size(32);
93
94 for (int iv_size = 0; iv_size < 200; ++iv_size) {
95 format.mutable_params()->set_iv_size(iv_size);
96 if (iv_size == 12 || iv_size == 16) {
97 EXPECT_THAT(AesEaxKeyManager().ValidateKeyFormat(format), IsOk())
98 << "for iv_size = " << iv_size;
99 } else {
100 EXPECT_THAT(AesEaxKeyManager().ValidateKeyFormat(format), Not(IsOk()))
101 << "for iv_size = " << iv_size;
102 }
103 }
104 }
105
TEST(AesEaxKeyManagerTest,CreateKey)106 TEST(AesEaxKeyManagerTest, CreateKey) {
107 AesEaxKeyFormat format;
108 format.set_key_size(32);
109 format.mutable_params()->set_iv_size(16);
110 auto key_or = AesEaxKeyManager().CreateKey(format);
111 ASSERT_THAT(key_or, IsOk());
112 EXPECT_THAT(key_or.value().key_value(), SizeIs(format.key_size()));
113 EXPECT_THAT(key_or.value().params().iv_size(), Eq(format.params().iv_size()));
114 }
115
TEST(AesEaxKeyManagerTest,CreateKeyIsValid)116 TEST(AesEaxKeyManagerTest, CreateKeyIsValid) {
117 AesEaxKeyFormat format;
118 format.set_key_size(32);
119 format.mutable_params()->set_iv_size(16);
120 auto key_or = AesEaxKeyManager().CreateKey(format);
121 ASSERT_THAT(key_or, IsOk());
122 EXPECT_THAT(AesEaxKeyManager().ValidateKey(key_or.value()), IsOk());
123 }
124
TEST(AesEaxKeyManagerTest,MultipleCreateCallsCreateDifferentKeys)125 TEST(AesEaxKeyManagerTest, MultipleCreateCallsCreateDifferentKeys) {
126 AesEaxKeyFormat format;
127 AesEaxKeyManager manager;
128 format.set_key_size(32);
129 format.mutable_params()->set_iv_size(16);
130 auto key1_or = manager.CreateKey(format);
131 ASSERT_THAT(key1_or, IsOk());
132 auto key2_or = manager.CreateKey(format);
133 ASSERT_THAT(key2_or, IsOk());
134 EXPECT_THAT(key1_or.value().key_value(), Ne(key2_or.value().key_value()));
135 }
136
TEST(AesEaxKeyManagerTest,ValidKey)137 TEST(AesEaxKeyManagerTest, ValidKey) {
138 AesEaxKey key;
139 key.set_key_value(std::string(32, 'a'));
140 key.mutable_params()->set_iv_size(16);
141 EXPECT_THAT(AesEaxKeyManager().ValidateKey(key), IsOk());
142 }
143
TEST(AesEaxKeyManagerTest,ValidateKeyKeyLength)144 TEST(AesEaxKeyManagerTest, ValidateKeyKeyLength) {
145 AesEaxKey key;
146 key.mutable_params()->set_iv_size(16);
147
148 for (int len = 0; len < 200; ++len) {
149 key.set_key_value(std::string(len, 'a'));
150 if (len == 16 || len == 32) {
151 EXPECT_THAT(AesEaxKeyManager().ValidateKey(key), IsOk())
152 << "for len = " << len;
153 } else {
154 EXPECT_THAT(AesEaxKeyManager().ValidateKey(key), Not(IsOk()))
155 << "for len = " << len;
156 }
157 }
158 }
159
TEST(AesEaxKeyManagerTest,ValidateKeyIvLength)160 TEST(AesEaxKeyManagerTest, ValidateKeyIvLength) {
161 AesEaxKey key;
162 key.set_key_value(std::string(32, 'a'));
163
164 for (int iv_len = 0; iv_len < 200; ++iv_len) {
165 key.mutable_params()->set_iv_size(iv_len);
166 if (iv_len == 12 || iv_len == 16) {
167 EXPECT_THAT(AesEaxKeyManager().ValidateKey(key), IsOk())
168 << "for iv_size = " << iv_len;
169 } else {
170 EXPECT_THAT(AesEaxKeyManager().ValidateKey(key), Not(IsOk()))
171 << "for iv_size = " << iv_len;
172 }
173 }
174 }
175
TEST(AesGcmKeyManagerTest,CreateAead)176 TEST(AesGcmKeyManagerTest, CreateAead) {
177 AesEaxKeyFormat format;
178 format.set_key_size(32);
179 format.mutable_params()->set_iv_size(16);
180 StatusOr<AesEaxKey> key_or = AesEaxKeyManager().CreateKey(format);
181 ASSERT_THAT(key_or, IsOk());
182
183 StatusOr<std::unique_ptr<Aead>> aead_or =
184 AesEaxKeyManager().GetPrimitive<Aead>(key_or.value());
185
186 ASSERT_THAT(aead_or, IsOk());
187
188 StatusOr<std::unique_ptr<Aead>> boring_ssl_aead_or =
189 subtle::AesEaxBoringSsl::New(
190 util::SecretDataFromStringView(key_or.value().key_value()),
191 key_or.value().params().iv_size());
192 ASSERT_THAT(boring_ssl_aead_or, IsOk());
193
194 ASSERT_THAT(EncryptThenDecrypt(*aead_or.value(), *boring_ssl_aead_or.value(),
195 "message", "aad"),
196 IsOk());
197 }
198
199 } // namespace
200 } // namespace tink
201 } // namespace crypto
202