1 // Copyright 2023 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/daead/aes_siv_parameters.h"
18
19 #include <tuple>
20
21 #include "gmock/gmock.h"
22 #include "gtest/gtest.h"
23 #include "tink/util/statusor.h"
24 #include "tink/util/test_matchers.h"
25
26 namespace crypto {
27 namespace tink {
28 namespace {
29
30 using ::crypto::tink::test::IsOk;
31 using ::crypto::tink::test::StatusIs;
32 using ::testing::Combine;
33 using ::testing::Eq;
34 using ::testing::IsTrue;
35 using ::testing::TestWithParam;
36 using ::testing::Values;
37
38 struct CreateTestCase {
39 AesSivParameters::Variant variant;
40 int key_size;
41 bool has_id_requirement;
42 };
43
44 using AesSivParametersBuildTest = TestWithParam<CreateTestCase>;
45
46 INSTANTIATE_TEST_SUITE_P(
47 AesSivParametersBuildTestSuite, AesSivParametersBuildTest,
48 Values(CreateTestCase{AesSivParameters::Variant::kTink, /*key_size=*/32,
49 /*has_id_requirement=*/true},
50 CreateTestCase{AesSivParameters::Variant::kCrunchy, /*key_size=*/48,
51 /*has_id_requirement=*/true},
52 CreateTestCase{AesSivParameters::Variant::kNoPrefix, /*key_size=*/64,
53 /*has_id_requirement=*/false}));
54
TEST_P(AesSivParametersBuildTest,Create)55 TEST_P(AesSivParametersBuildTest, Create) {
56 CreateTestCase test_case = GetParam();
57
58 util::StatusOr<AesSivParameters> parameters =
59 AesSivParameters::Create(test_case.key_size, test_case.variant);
60 ASSERT_THAT(parameters, IsOk());
61
62 EXPECT_THAT(parameters->KeySizeInBytes(), Eq(test_case.key_size));
63 EXPECT_THAT(parameters->GetVariant(), Eq(test_case.variant));
64 EXPECT_THAT(parameters->HasIdRequirement(), Eq(test_case.has_id_requirement));
65 }
66
TEST(AesSivParametersTest,CreateWithInvalidVariantFails)67 TEST(AesSivParametersTest, CreateWithInvalidVariantFails) {
68 EXPECT_THAT(AesSivParameters::Create(
69 /*key_size_in_bytes=*/64,
70 AesSivParameters::Variant::
71 kDoNotUseInsteadUseDefaultWhenWritingSwitchStatements)
72 .status(),
73 StatusIs(absl::StatusCode::kInvalidArgument));
74 }
75
TEST(AesSivParametersTest,CreateWithInvalidKeySizeFails)76 TEST(AesSivParametersTest, CreateWithInvalidKeySizeFails) {
77 EXPECT_THAT(AesSivParameters::Create(/*key_size_in_bytes=*/31,
78 AesSivParameters::Variant::kNoPrefix)
79 .status(),
80 StatusIs(absl::StatusCode::kInvalidArgument));
81 EXPECT_THAT(AesSivParameters::Create(/*key_size_in_bytes=*/33,
82 AesSivParameters::Variant::kNoPrefix)
83 .status(),
84 StatusIs(absl::StatusCode::kInvalidArgument));
85 EXPECT_THAT(AesSivParameters::Create(/*key_size_in_bytes=*/47,
86 AesSivParameters::Variant::kNoPrefix)
87 .status(),
88 StatusIs(absl::StatusCode::kInvalidArgument));
89 EXPECT_THAT(AesSivParameters::Create(/*key_size_in_bytes=*/49,
90 AesSivParameters::Variant::kNoPrefix)
91 .status(),
92 StatusIs(absl::StatusCode::kInvalidArgument));
93 EXPECT_THAT(AesSivParameters::Create(/*key_size_in_bytes=*/63,
94 AesSivParameters::Variant::kNoPrefix)
95 .status(),
96 StatusIs(absl::StatusCode::kInvalidArgument));
97 EXPECT_THAT(AesSivParameters::Create(/*key_size_in_bytes=*/65,
98 AesSivParameters::Variant::kNoPrefix)
99 .status(),
100 StatusIs(absl::StatusCode::kInvalidArgument));
101 }
102
TEST(AesSivParametersTest,CopyConstructor)103 TEST(AesSivParametersTest, CopyConstructor) {
104 util::StatusOr<AesSivParameters> parameters = AesSivParameters::Create(
105 /*key_size_in_bytes=*/64, AesSivParameters::Variant::kTink);
106 ASSERT_THAT(parameters, IsOk());
107
108 AesSivParameters copy(*parameters);
109 EXPECT_THAT(copy.KeySizeInBytes(), Eq(64));
110 EXPECT_THAT(copy.GetVariant(), Eq(AesSivParameters::Variant::kTink));
111 EXPECT_THAT(copy.HasIdRequirement(), IsTrue());
112 }
113
TEST(AesSivParametersTest,CopyAssignment)114 TEST(AesSivParametersTest, CopyAssignment) {
115 util::StatusOr<AesSivParameters> parameters = AesSivParameters::Create(
116 /*key_size_in_bytes=*/64, AesSivParameters::Variant::kTink);
117 ASSERT_THAT(parameters, IsOk());
118
119 AesSivParameters copy = *parameters;
120 EXPECT_THAT(copy.KeySizeInBytes(), Eq(64));
121 EXPECT_THAT(copy.GetVariant(), Eq(AesSivParameters::Variant::kTink));
122 EXPECT_THAT(copy.HasIdRequirement(), IsTrue());
123 }
124
125 using AesSivParametersVariantTest =
126 TestWithParam<std::tuple<int, AesSivParameters::Variant>>;
127
128 INSTANTIATE_TEST_SUITE_P(AesSivParametersVariantTestSuite,
129 AesSivParametersVariantTest,
130 Combine(Values(32, 48, 64),
131 Values(AesSivParameters::Variant::kTink,
132 AesSivParameters::Variant::kCrunchy,
133 AesSivParameters::Variant::kNoPrefix)));
134
TEST_P(AesSivParametersVariantTest,ParametersEquals)135 TEST_P(AesSivParametersVariantTest, ParametersEquals) {
136 int key_size;
137 AesSivParameters::Variant variant;
138 std::tie(key_size, variant) = GetParam();
139
140 util::StatusOr<AesSivParameters> parameters =
141 AesSivParameters::Create(key_size, variant);
142 ASSERT_THAT(parameters, IsOk());
143
144 util::StatusOr<AesSivParameters> other_parameters =
145 AesSivParameters::Create(key_size, variant);
146 ASSERT_THAT(other_parameters, IsOk());
147
148 EXPECT_TRUE(*parameters == *other_parameters);
149 EXPECT_TRUE(*other_parameters == *parameters);
150 EXPECT_FALSE(*parameters != *other_parameters);
151 EXPECT_FALSE(*other_parameters != *parameters);
152 }
153
TEST(AesSivParametersTest,KeySizeNotEqual)154 TEST(AesSivParametersTest, KeySizeNotEqual) {
155 util::StatusOr<AesSivParameters> parameters = AesSivParameters::Create(
156 /*key_size_in_bytes=*/48, AesSivParameters::Variant::kTink);
157 ASSERT_THAT(parameters, IsOk());
158
159 util::StatusOr<AesSivParameters> other_parameters = AesSivParameters::Create(
160 /*key_size_in_bytes=*/64, AesSivParameters::Variant::kTink);
161 ASSERT_THAT(other_parameters, IsOk());
162
163 EXPECT_TRUE(*parameters != *other_parameters);
164 EXPECT_FALSE(*parameters == *other_parameters);
165 }
166
TEST(AesSivParametersTest,VariantNotEqual)167 TEST(AesSivParametersTest, VariantNotEqual) {
168 util::StatusOr<AesSivParameters> parameters = AesSivParameters::Create(
169 /*key_size_in_bytes=*/64, AesSivParameters::Variant::kTink);
170 ASSERT_THAT(parameters, IsOk());
171
172 util::StatusOr<AesSivParameters> other_parameters = AesSivParameters::Create(
173 /*key_size_in_bytes=*/64, AesSivParameters::Variant::kNoPrefix);
174 ASSERT_THAT(other_parameters, IsOk());
175
176 EXPECT_TRUE(*parameters != *other_parameters);
177 EXPECT_FALSE(*parameters == *other_parameters);
178 }
179
180 } // namespace
181 } // namespace tink
182 } // namespace crypto
183