1 // Copyright 2022 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/mac/aes_cmac_parameters.h"
18
19 #include <memory>
20 #include <tuple>
21
22 #include "gmock/gmock.h"
23 #include "gtest/gtest.h"
24 #include "tink/util/statusor.h"
25 #include "tink/util/test_matchers.h"
26
27 namespace crypto {
28 namespace tink {
29 namespace {
30
31 using ::crypto::tink::test::IsOk;
32 using ::crypto::tink::test::StatusIs;
33 using ::testing::Combine;
34 using ::testing::Eq;
35 using ::testing::Range;
36 using ::testing::TestWithParam;
37 using ::testing::Values;
38
39 struct CreateTestCase {
40 AesCmacParameters::Variant variant;
41 int key_size;
42 int cryptographic_tag_size;
43 int total_tag_size;
44 bool has_id_requirement;
45 };
46
47 using AesCmacParametersCreateTest = TestWithParam<CreateTestCase>;
48
49 INSTANTIATE_TEST_SUITE_P(
50 AesCmacParametersCreateTestSuite, AesCmacParametersCreateTest,
51 Values(CreateTestCase{AesCmacParameters::Variant::kTink, /*key_size=*/16,
52 /*cryptographic_tag_size=*/10, /*total_tag_size=*/15,
53 /*has_id_requirement=*/true},
54 CreateTestCase{AesCmacParameters::Variant::kCrunchy, /*key_size=*/16,
55 /*cryptographic_tag_size=*/12, /*total_tag_size=*/17,
56 /*has_id_requirement=*/true},
57 CreateTestCase{AesCmacParameters::Variant::kLegacy, /*key_size=*/32,
58 /*cryptographic_tag_size=*/14, /*total_tag_size=*/19,
59 /*has_id_requirement=*/true},
60 CreateTestCase{AesCmacParameters::Variant::kNoPrefix,
61 /*key_size=*/32, /*cryptographic_tag_size=*/16,
62 /*total_tag_size=*/16,
63 /*has_id_requirement=*/false}));
64
TEST_P(AesCmacParametersCreateTest,Create)65 TEST_P(AesCmacParametersCreateTest, Create) {
66 CreateTestCase test_case = GetParam();
67
68 util::StatusOr<AesCmacParameters> parameters = AesCmacParameters::Create(
69 test_case.key_size, test_case.cryptographic_tag_size, test_case.variant);
70 ASSERT_THAT(parameters, IsOk());
71
72 EXPECT_THAT(parameters->GetVariant(), Eq(test_case.variant));
73 EXPECT_THAT(parameters->KeySizeInBytes(), Eq(test_case.key_size));
74 EXPECT_THAT(parameters->CryptographicTagSizeInBytes(),
75 Eq(test_case.cryptographic_tag_size));
76 EXPECT_THAT(parameters->TotalTagSizeInBytes(), Eq(test_case.total_tag_size));
77 EXPECT_THAT(parameters->HasIdRequirement(), Eq(test_case.has_id_requirement));
78 }
79
TEST(AesCmacParametersTest,CreateWithInvalidVariantFails)80 TEST(AesCmacParametersTest, CreateWithInvalidVariantFails) {
81 EXPECT_THAT(AesCmacParameters::Create(
82 /*key_size_in_bytes=*/32,
83 /*cryptographic_tag_size_in_bytes=*/12,
84 AesCmacParameters::Variant::
85 kDoNotUseInsteadUseDefaultWhenWritingSwitchStatements)
86 .status(),
87 StatusIs(absl::StatusCode::kInvalidArgument));
88 }
89
TEST(AesCmacParametersTest,CreateWithInvalidKeySizeFails)90 TEST(AesCmacParametersTest, CreateWithInvalidKeySizeFails) {
91 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/15,
92 /*cryptographic_tag_size_in_bytes=*/16,
93 AesCmacParameters::Variant::kNoPrefix)
94 .status(),
95 StatusIs(absl::StatusCode::kInvalidArgument));
96 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/17,
97 /*cryptographic_tag_size_in_bytes=*/16,
98 AesCmacParameters::Variant::kNoPrefix)
99 .status(),
100 StatusIs(absl::StatusCode::kInvalidArgument));
101 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/31,
102 /*cryptographic_tag_size_in_bytes=*/16,
103 AesCmacParameters::Variant::kNoPrefix)
104 .status(),
105 StatusIs(absl::StatusCode::kInvalidArgument));
106 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/33,
107 /*cryptographic_tag_size_in_bytes=*/16,
108 AesCmacParameters::Variant::kNoPrefix)
109 .status(),
110 StatusIs(absl::StatusCode::kInvalidArgument));
111 }
112
TEST(AesCmacParametersTest,CreateWithInvalidTagSizeFails)113 TEST(AesCmacParametersTest, CreateWithInvalidTagSizeFails) {
114 // Too small.
115 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/32,
116 /*cryptographic_tag_size_in_bytes=*/7,
117 AesCmacParameters::Variant::kNoPrefix)
118 .status(),
119 StatusIs(absl::StatusCode::kInvalidArgument));
120 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/32,
121 /*cryptographic_tag_size_in_bytes=*/8,
122 AesCmacParameters::Variant::kNoPrefix)
123 .status(),
124 StatusIs(absl::StatusCode::kInvalidArgument));
125 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/32,
126 /*cryptographic_tag_size_in_bytes=*/9,
127 AesCmacParameters::Variant::kNoPrefix)
128 .status(),
129 StatusIs(absl::StatusCode::kInvalidArgument));
130 // Too big;
131 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/32,
132 /*cryptographic_tag_size_in_bytes=*/17,
133 AesCmacParameters::Variant::kNoPrefix)
134 .status(),
135 StatusIs(absl::StatusCode::kInvalidArgument));
136 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/32,
137 /*cryptographic_tag_size_in_bytes=*/18,
138 AesCmacParameters::Variant::kNoPrefix)
139 .status(),
140 StatusIs(absl::StatusCode::kInvalidArgument));
141 EXPECT_THAT(AesCmacParameters::Create(/*key_size_in_bytes=*/32,
142 /*cryptographic_tag_size_in_bytes=*/19,
143 AesCmacParameters::Variant::kNoPrefix)
144 .status(),
145 StatusIs(absl::StatusCode::kInvalidArgument));
146 }
147
TEST(AesCmacParametersTest,CopyConstructor)148 TEST(AesCmacParametersTest, CopyConstructor) {
149 util::StatusOr<AesCmacParameters> parameters =
150 AesCmacParameters::Create(/*key_size_in_bytes=*/32,
151 /*cryptographic_tag_size_in_bytes=*/12,
152 AesCmacParameters::Variant::kTink);
153 ASSERT_THAT(parameters, IsOk());
154
155 AesCmacParameters copy(*parameters);
156 EXPECT_THAT(copy.GetVariant(), Eq(parameters->GetVariant()));
157 EXPECT_THAT(copy.CryptographicTagSizeInBytes(),
158 Eq(parameters->CryptographicTagSizeInBytes()));
159 EXPECT_THAT(copy.TotalTagSizeInBytes(),
160 Eq(parameters->TotalTagSizeInBytes()));
161 EXPECT_THAT(copy.HasIdRequirement(), Eq(parameters->HasIdRequirement()));
162 }
163
TEST(AesCmacParametersTest,CopyAssignment)164 TEST(AesCmacParametersTest, CopyAssignment) {
165 util::StatusOr<AesCmacParameters> parameters =
166 AesCmacParameters::Create(/*key_size_in_bytes=*/32,
167 /*cryptographic_tag_size_in_bytes=*/12,
168 AesCmacParameters::Variant::kTink);
169 ASSERT_THAT(parameters, IsOk());
170
171 AesCmacParameters copy = *parameters;
172 EXPECT_THAT(copy.GetVariant(), Eq(parameters->GetVariant()));
173 EXPECT_THAT(copy.CryptographicTagSizeInBytes(),
174 Eq(parameters->CryptographicTagSizeInBytes()));
175 EXPECT_THAT(copy.TotalTagSizeInBytes(),
176 Eq(parameters->TotalTagSizeInBytes()));
177 EXPECT_THAT(copy.HasIdRequirement(), Eq(parameters->HasIdRequirement()));
178 }
179
180 using AesCmacParametersVariantTest =
181 TestWithParam<std::tuple<int, int, AesCmacParameters::Variant>>;
182
183 INSTANTIATE_TEST_SUITE_P(
184 AesCmacParametersVariantTestSuite, AesCmacParametersVariantTest,
185 Combine(Values(16, 32), Range(10, 16),
186 Values(AesCmacParameters::Variant::kTink,
187 AesCmacParameters::Variant::kCrunchy,
188 AesCmacParameters::Variant::kLegacy,
189 AesCmacParameters::Variant::kNoPrefix)));
190
TEST_P(AesCmacParametersVariantTest,ParametersEquals)191 TEST_P(AesCmacParametersVariantTest, ParametersEquals) {
192 int key_size;
193 int cryptographic_tag_size;
194 AesCmacParameters::Variant variant;
195 std::tie(key_size, cryptographic_tag_size, variant) = GetParam();
196
197 util::StatusOr<AesCmacParameters> parameters =
198 AesCmacParameters::Create(key_size, cryptographic_tag_size, variant);
199 ASSERT_THAT(parameters, IsOk());
200
201 util::StatusOr<AesCmacParameters> other_parameters =
202 AesCmacParameters::Create(key_size, cryptographic_tag_size, variant);
203 ASSERT_THAT(other_parameters, IsOk());
204
205 EXPECT_TRUE(*parameters == *other_parameters);
206 EXPECT_TRUE(*other_parameters == *parameters);
207 EXPECT_FALSE(*parameters != *other_parameters);
208 EXPECT_FALSE(*other_parameters != *parameters);
209 }
210
TEST(AesCmacParametersTest,KeySizeNotEqual)211 TEST(AesCmacParametersTest, KeySizeNotEqual) {
212 util::StatusOr<AesCmacParameters> parameters =
213 AesCmacParameters::Create(/*key_size_in_bytes=*/16,
214 /*cryptographic_tag_size_in_bytes=*/10,
215 AesCmacParameters::Variant::kNoPrefix);
216 ASSERT_THAT(parameters, IsOk());
217
218 util::StatusOr<AesCmacParameters> other_parameters =
219 AesCmacParameters::Create(/*key_size_in_bytes=*/32,
220 /*cryptographic_tag_size_in_bytes=*/10,
221 AesCmacParameters::Variant::kNoPrefix);
222 ASSERT_THAT(other_parameters, IsOk());
223
224 EXPECT_TRUE(*parameters != *other_parameters);
225 EXPECT_FALSE(*parameters == *other_parameters);
226 }
227
TEST(AesCmacParametersTest,TagSizeNotEqual)228 TEST(AesCmacParametersTest, TagSizeNotEqual) {
229 util::StatusOr<AesCmacParameters> parameters =
230 AesCmacParameters::Create(/*key_size_in_bytes=*/32,
231 /*cryptographic_tag_size_in_bytes=*/10,
232 AesCmacParameters::Variant::kNoPrefix);
233 ASSERT_THAT(parameters, IsOk());
234
235 util::StatusOr<AesCmacParameters> other_parameters =
236 AesCmacParameters::Create(/*key_size_in_bytes=*/32,
237 /*cryptographic_tag_size_in_bytes=*/11,
238 AesCmacParameters::Variant::kNoPrefix);
239 ASSERT_THAT(other_parameters, IsOk());
240
241 EXPECT_TRUE(*parameters != *other_parameters);
242 EXPECT_FALSE(*parameters == *other_parameters);
243 }
244
TEST(AesCmacParametersTest,VariantNotEqual)245 TEST(AesCmacParametersTest, VariantNotEqual) {
246 util::StatusOr<AesCmacParameters> parameters =
247 AesCmacParameters::Create(/*key_size_in_bytes=*/32,
248 /*cryptographic_tag_size_in_bytes=*/10,
249 AesCmacParameters::Variant::kNoPrefix);
250 ASSERT_THAT(parameters, IsOk());
251
252 util::StatusOr<AesCmacParameters> other_parameters =
253 AesCmacParameters::Create(/*key_size_in_bytes=*/32,
254 /*cryptographic_tag_size_in_bytes=*/10,
255 AesCmacParameters::Variant::kTink);
256 ASSERT_THAT(other_parameters, IsOk());
257
258 EXPECT_TRUE(*parameters != *other_parameters);
259 EXPECT_FALSE(*parameters == *other_parameters);
260 }
261
262 } // namespace
263 } // namespace tink
264 } // namespace crypto
265