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/util/enums.h"
18
19 #include "gtest/gtest.h"
20 #include "tink/subtle/common_enums.h"
21 #include "proto/common.pb.h"
22
23 using crypto::tink::util::Enums;
24
25 namespace crypto {
26
27 namespace pb = google::crypto::tink;
28
29 namespace tink {
30 namespace {
31
32 class EnumsTest : public ::testing::Test {};
33
TEST_F(EnumsTest,testEllipticCurveType)34 TEST_F(EnumsTest, testEllipticCurveType) {
35 EXPECT_EQ(pb::EllipticCurveType::NIST_P256,
36 Enums::SubtleToProto(subtle::EllipticCurveType::NIST_P256));
37 EXPECT_EQ(pb::EllipticCurveType::NIST_P384,
38 Enums::SubtleToProto(subtle::EllipticCurveType::NIST_P384));
39 EXPECT_EQ(pb::EllipticCurveType::NIST_P521,
40 Enums::SubtleToProto(subtle::EllipticCurveType::NIST_P521));
41 EXPECT_EQ(pb::EllipticCurveType::CURVE25519,
42 Enums::SubtleToProto(subtle::EllipticCurveType::CURVE25519));
43 EXPECT_EQ(pb::EllipticCurveType::UNKNOWN_CURVE,
44 Enums::SubtleToProto(subtle::EllipticCurveType::UNKNOWN_CURVE));
45 EXPECT_EQ(pb::EllipticCurveType::UNKNOWN_CURVE,
46 Enums::SubtleToProto((subtle::EllipticCurveType)42));
47
48 EXPECT_EQ(subtle::EllipticCurveType::NIST_P256,
49 Enums::ProtoToSubtle(pb::EllipticCurveType::NIST_P256));
50 EXPECT_EQ(subtle::EllipticCurveType::NIST_P384,
51 Enums::ProtoToSubtle(pb::EllipticCurveType::NIST_P384));
52 EXPECT_EQ(subtle::EllipticCurveType::NIST_P521,
53 Enums::ProtoToSubtle(pb::EllipticCurveType::NIST_P521));
54 EXPECT_EQ(subtle::EllipticCurveType::CURVE25519,
55 Enums::ProtoToSubtle(pb::EllipticCurveType::CURVE25519));
56 EXPECT_EQ(subtle::EllipticCurveType::UNKNOWN_CURVE,
57 Enums::ProtoToSubtle(pb::EllipticCurveType::UNKNOWN_CURVE));
58 EXPECT_EQ(subtle::EllipticCurveType::UNKNOWN_CURVE,
59 Enums::ProtoToSubtle((pb::EllipticCurveType)42));
60
61 // Check that enum conversion covers the entire range of the proto-enum.
62 int count = 0;
63 for (int int_type = static_cast<int>(pb::EllipticCurveType_MIN);
64 int_type <= static_cast<int>(pb::EllipticCurveType_MAX); int_type++) {
65 if (pb::EllipticCurveType_IsValid(int_type)) {
66 pb::EllipticCurveType type = static_cast<pb::EllipticCurveType>(int_type);
67 EXPECT_EQ(type, Enums::SubtleToProto(Enums::ProtoToSubtle(type)));
68 count++;
69 }
70 }
71 EXPECT_EQ(5, count);
72 }
73
TEST_F(EnumsTest,testHashType)74 TEST_F(EnumsTest, testHashType) {
75 EXPECT_EQ(pb::HashType::SHA1, Enums::SubtleToProto(subtle::HashType::SHA1));
76 EXPECT_EQ(pb::HashType::SHA224,
77 Enums::SubtleToProto(subtle::HashType::SHA224));
78 EXPECT_EQ(pb::HashType::SHA256,
79 Enums::SubtleToProto(subtle::HashType::SHA256));
80 EXPECT_EQ(pb::HashType::SHA384,
81 Enums::SubtleToProto(subtle::HashType::SHA384));
82 EXPECT_EQ(pb::HashType::SHA512,
83 Enums::SubtleToProto(subtle::HashType::SHA512));
84 EXPECT_EQ(pb::HashType::UNKNOWN_HASH,
85 Enums::SubtleToProto(subtle::HashType::UNKNOWN_HASH));
86 EXPECT_EQ(pb::HashType::UNKNOWN_HASH,
87 Enums::SubtleToProto((subtle::HashType)42));
88
89 EXPECT_EQ(subtle::HashType::SHA1, Enums::ProtoToSubtle(pb::HashType::SHA1));
90 EXPECT_EQ(subtle::HashType::SHA224,
91 Enums::ProtoToSubtle(pb::HashType::SHA224));
92 EXPECT_EQ(subtle::HashType::SHA256,
93 Enums::ProtoToSubtle(pb::HashType::SHA256));
94 EXPECT_EQ(subtle::HashType::SHA384,
95 Enums::ProtoToSubtle(pb::HashType::SHA384));
96 EXPECT_EQ(subtle::HashType::SHA512,
97 Enums::ProtoToSubtle(pb::HashType::SHA512));
98 EXPECT_EQ(subtle::HashType::UNKNOWN_HASH,
99 Enums::ProtoToSubtle(pb::HashType::UNKNOWN_HASH));
100 EXPECT_EQ(subtle::HashType::UNKNOWN_HASH,
101 Enums::ProtoToSubtle((pb::HashType)42));
102
103 // Check that enum conversion covers the entire range of the proto-enum.
104 int count = 0;
105 for (int int_type = static_cast<int>(pb::HashType_MIN);
106 int_type <= static_cast<int>(pb::HashType_MAX); int_type++) {
107 if (pb::HashType_IsValid(int_type)) {
108 pb::HashType type = static_cast<pb::HashType>(int_type);
109 EXPECT_EQ(type, Enums::SubtleToProto(Enums::ProtoToSubtle(type)));
110 count++;
111 }
112 }
113 EXPECT_EQ(6, count);
114 }
115
TEST_F(EnumsTest,testHashSize)116 TEST_F(EnumsTest, testHashSize) {
117 EXPECT_EQ(Enums::HashLength(pb::HashType::SHA256).value(), 32);
118 EXPECT_EQ(Enums::HashLength(pb::HashType::SHA384).value(), 48);
119 EXPECT_EQ(Enums::HashLength(pb::HashType::SHA512).value(), 64);
120 EXPECT_TRUE(!Enums::HashLength(pb::HashType::UNKNOWN_HASH).ok());
121 EXPECT_TRUE(!Enums::HashLength(pb::HashType::SHA1).ok());
122 }
123
TEST_F(EnumsTest,testEcPointFormat)124 TEST_F(EnumsTest, testEcPointFormat) {
125 EXPECT_EQ(pb::EcPointFormat::UNCOMPRESSED,
126 Enums::SubtleToProto(subtle::EcPointFormat::UNCOMPRESSED));
127 EXPECT_EQ(pb::EcPointFormat::DO_NOT_USE_CRUNCHY_UNCOMPRESSED,
128 Enums::SubtleToProto(
129 subtle::EcPointFormat::DO_NOT_USE_CRUNCHY_UNCOMPRESSED));
130 EXPECT_EQ(pb::EcPointFormat::COMPRESSED,
131 Enums::SubtleToProto(subtle::EcPointFormat::COMPRESSED));
132 EXPECT_EQ(pb::EcPointFormat::UNKNOWN_FORMAT,
133 Enums::SubtleToProto(subtle::EcPointFormat::UNKNOWN_FORMAT));
134 EXPECT_EQ(pb::EcPointFormat::UNKNOWN_FORMAT,
135 Enums::SubtleToProto((subtle::EcPointFormat)42));
136
137 EXPECT_EQ(subtle::EcPointFormat::UNCOMPRESSED,
138 Enums::ProtoToSubtle(pb::EcPointFormat::UNCOMPRESSED));
139 EXPECT_EQ(
140 subtle::EcPointFormat::DO_NOT_USE_CRUNCHY_UNCOMPRESSED,
141 Enums::ProtoToSubtle(pb::EcPointFormat::DO_NOT_USE_CRUNCHY_UNCOMPRESSED));
142 EXPECT_EQ(subtle::EcPointFormat::COMPRESSED,
143 Enums::ProtoToSubtle(pb::EcPointFormat::COMPRESSED));
144 EXPECT_EQ(subtle::EcPointFormat::UNKNOWN_FORMAT,
145 Enums::ProtoToSubtle(pb::EcPointFormat::UNKNOWN_FORMAT));
146 EXPECT_EQ(subtle::EcPointFormat::UNKNOWN_FORMAT,
147 Enums::ProtoToSubtle((pb::EcPointFormat)42));
148
149 // Check that enum conversion covers the entire range of the proto-enum.
150 int count = 0;
151 for (int int_format = static_cast<int>(pb::EcPointFormat_MIN);
152 int_format <= static_cast<int>(pb::EcPointFormat_MAX); int_format++) {
153 if (pb::EcPointFormat_IsValid(int_format)) {
154 pb::EcPointFormat format = static_cast<pb::EcPointFormat>(int_format);
155 EXPECT_EQ(format, Enums::SubtleToProto(Enums::ProtoToSubtle(format)));
156 count++;
157 }
158 }
159 EXPECT_EQ(4, count);
160 }
161
TEST_F(EnumsTest,testEcdsaSignatureEncoding)162 TEST_F(EnumsTest, testEcdsaSignatureEncoding) {
163 EXPECT_EQ(
164 pb::EcdsaSignatureEncoding::UNKNOWN_ENCODING,
165 Enums::SubtleToProto(subtle::EcdsaSignatureEncoding::UNKNOWN_ENCODING));
166 EXPECT_EQ(pb::EcdsaSignatureEncoding::IEEE_P1363,
167 Enums::SubtleToProto(subtle::EcdsaSignatureEncoding::IEEE_P1363));
168 EXPECT_EQ(pb::EcdsaSignatureEncoding::DER,
169 Enums::SubtleToProto(subtle::EcdsaSignatureEncoding::DER));
170 EXPECT_EQ(subtle::EcdsaSignatureEncoding::UNKNOWN_ENCODING,
171 Enums::ProtoToSubtle(pb::EcdsaSignatureEncoding::UNKNOWN_ENCODING));
172 EXPECT_EQ(subtle::EcdsaSignatureEncoding::IEEE_P1363,
173 Enums::ProtoToSubtle(pb::EcdsaSignatureEncoding::IEEE_P1363));
174 EXPECT_EQ(subtle::EcdsaSignatureEncoding::DER,
175 Enums::ProtoToSubtle(pb::EcdsaSignatureEncoding::DER));
176 // Check that enum conversion covers the entire range of the proto-enum.
177 int count = 0;
178 for (int int_encoding = static_cast<int>(pb::EcdsaSignatureEncoding_MIN);
179 int_encoding <= static_cast<int>(pb::EcdsaSignatureEncoding_MAX);
180 int_encoding++) {
181 if (pb::EcdsaSignatureEncoding_IsValid(int_encoding)) {
182 pb::EcdsaSignatureEncoding encoding =
183 static_cast<pb::EcdsaSignatureEncoding>(int_encoding);
184 EXPECT_EQ(encoding, Enums::SubtleToProto(Enums::ProtoToSubtle(encoding)));
185 count++;
186 }
187 }
188 EXPECT_EQ(3, count);
189 }
190
TEST_F(EnumsTest,testKeyStatusName)191 TEST_F(EnumsTest, testKeyStatusName) {
192 EXPECT_EQ("ENABLED",
193 std::string(Enums::KeyStatusName(pb::KeyStatusType::ENABLED)));
194 EXPECT_EQ("DISABLED",
195 std::string(Enums::KeyStatusName(pb::KeyStatusType::DISABLED)));
196 EXPECT_EQ("DESTROYED",
197 std::string(Enums::KeyStatusName(pb::KeyStatusType::DESTROYED)));
198 EXPECT_EQ(
199 "UNKNOWN_STATUS",
200 std::string(Enums::KeyStatusName(pb::KeyStatusType::UNKNOWN_STATUS)));
201 EXPECT_EQ("UNKNOWN_STATUS",
202 std::string(Enums::KeyStatusName((pb::KeyStatusType)42)));
203
204 EXPECT_EQ(pb::KeyStatusType::ENABLED, Enums::KeyStatus("ENABLED"));
205 EXPECT_EQ(pb::KeyStatusType::DISABLED, Enums::KeyStatus("DISABLED"));
206 EXPECT_EQ(pb::KeyStatusType::DESTROYED, Enums::KeyStatus("DESTROYED"));
207 EXPECT_EQ(pb::KeyStatusType::UNKNOWN_STATUS,
208 Enums::KeyStatus("Other string"));
209 EXPECT_EQ(pb::KeyStatusType::UNKNOWN_STATUS,
210 Enums::KeyStatus("UNKNOWN_STATUS"));
211
212 // Check that enum conversion covers the entire range of the proto-enum.
213 int count = 0;
214 for (int int_status = static_cast<int>(pb::KeyStatusType_MIN);
215 int_status <= static_cast<int>(pb::KeyStatusType_MAX); int_status++) {
216 if (pb::KeyStatusType_IsValid(int_status)) {
217 pb::KeyStatusType status = static_cast<pb::KeyStatusType>(int_status);
218 EXPECT_EQ(status, Enums::KeyStatus(Enums::KeyStatusName(status)));
219 count++;
220 }
221 }
222 EXPECT_EQ(4, count);
223 }
224
TEST_F(EnumsTest,testHashName)225 TEST_F(EnumsTest, testHashName) {
226 EXPECT_EQ("SHA1", std::string(Enums::HashName(pb::HashType::SHA1)));
227 EXPECT_EQ("SHA256", std::string(Enums::HashName(pb::HashType::SHA256)));
228 EXPECT_EQ("SHA512", std::string(Enums::HashName(pb::HashType::SHA512)));
229 EXPECT_EQ("UNKNOWN_HASH",
230 std::string(Enums::HashName(pb::HashType::UNKNOWN_HASH)));
231 EXPECT_EQ("UNKNOWN_HASH", std::string(Enums::HashName((pb::HashType)42)));
232
233 EXPECT_EQ(pb::HashType::SHA1, Enums::Hash("SHA1"));
234 EXPECT_EQ(pb::HashType::SHA224, Enums::Hash("SHA224"));
235 EXPECT_EQ(pb::HashType::SHA256, Enums::Hash("SHA256"));
236 EXPECT_EQ(pb::HashType::SHA384, Enums::Hash("SHA384"));
237 EXPECT_EQ(pb::HashType::SHA512, Enums::Hash("SHA512"));
238 EXPECT_EQ(pb::HashType::UNKNOWN_HASH, Enums::Hash("Other string"));
239 EXPECT_EQ(pb::HashType::UNKNOWN_HASH, Enums::Hash("UNKNOWN_HASH"));
240
241 // Check that enum conversion covers the entire range of the proto-enum.
242 int count = 0;
243 for (int int_hash = static_cast<int>(pb::HashType_MIN);
244 int_hash <= static_cast<int>(pb::HashType_MAX); int_hash++) {
245 if (pb::HashType_IsValid(int_hash)) {
246 pb::HashType hash = static_cast<pb::HashType>(int_hash);
247 EXPECT_EQ(hash, Enums::Hash(Enums::HashName(hash)));
248 count++;
249 }
250 }
251 EXPECT_EQ(6, count);
252 }
253
TEST_F(EnumsTest,testKeyMaterialName)254 TEST_F(EnumsTest, testKeyMaterialName) {
255 EXPECT_EQ("SYMMETRIC",
256 std::string(Enums::KeyMaterialName(pb::KeyData::SYMMETRIC)));
257 EXPECT_EQ(
258 "ASYMMETRIC_PRIVATE",
259 std::string(Enums::KeyMaterialName(pb::KeyData::ASYMMETRIC_PRIVATE)));
260 EXPECT_EQ(
261 "ASYMMETRIC_PUBLIC",
262 std::string(Enums::KeyMaterialName(pb::KeyData::ASYMMETRIC_PUBLIC)));
263 EXPECT_EQ("REMOTE", std::string(Enums::KeyMaterialName(pb::KeyData::REMOTE)));
264 EXPECT_EQ(
265 "UNKNOWN_KEYMATERIAL",
266 std::string(Enums::KeyMaterialName(pb::KeyData::UNKNOWN_KEYMATERIAL)));
267 EXPECT_EQ(
268 "UNKNOWN_KEYMATERIAL",
269 std::string(Enums::KeyMaterialName((pb::KeyData::KeyMaterialType)42)));
270
271 EXPECT_EQ(pb::KeyData::SYMMETRIC, Enums::KeyMaterial("SYMMETRIC"));
272 EXPECT_EQ(pb::KeyData::ASYMMETRIC_PRIVATE,
273 Enums::KeyMaterial("ASYMMETRIC_PRIVATE"));
274 EXPECT_EQ(pb::KeyData::ASYMMETRIC_PUBLIC,
275 Enums::KeyMaterial("ASYMMETRIC_PUBLIC"));
276 EXPECT_EQ(pb::KeyData::REMOTE, Enums::KeyMaterial("REMOTE"));
277 EXPECT_EQ(pb::KeyData::UNKNOWN_KEYMATERIAL,
278 Enums::KeyMaterial("Other string"));
279 EXPECT_EQ(pb::KeyData::UNKNOWN_KEYMATERIAL,
280 Enums::KeyMaterial("UNKNOWN_KEYMATERIAL"));
281
282 // Check that enum conversion covers the entire range of the proto-enum.
283 int count = 0;
284 for (int int_type = static_cast<int>(pb::KeyData::KeyMaterialType_MIN);
285 int_type <= static_cast<int>(pb::KeyData::KeyMaterialType_MAX);
286 int_type++) {
287 if (pb::KeyData::KeyMaterialType_IsValid(int_type)) {
288 pb::KeyData::KeyMaterialType type =
289 static_cast<pb::KeyData::KeyMaterialType>(int_type);
290 EXPECT_EQ(type, Enums::KeyMaterial(Enums::KeyMaterialName(type)));
291 count++;
292 }
293 }
294 EXPECT_EQ(5, count);
295 }
296
TEST_F(EnumsTest,testOutputPrefixName)297 TEST_F(EnumsTest, testOutputPrefixName) {
298 EXPECT_EQ("TINK",
299 std::string(Enums::OutputPrefixName(pb::OutputPrefixType::TINK)));
300 EXPECT_EQ("LEGACY",
301 std::string(Enums::OutputPrefixName(pb::OutputPrefixType::LEGACY)));
302 EXPECT_EQ("RAW",
303 std::string(Enums::OutputPrefixName(pb::OutputPrefixType::RAW)));
304 EXPECT_EQ(
305 "CRUNCHY",
306 std::string(Enums::OutputPrefixName(pb::OutputPrefixType::CRUNCHY)));
307 EXPECT_EQ("UNKNOWN_PREFIX", std::string(Enums::OutputPrefixName(
308 pb::OutputPrefixType::UNKNOWN_PREFIX)));
309 EXPECT_EQ("UNKNOWN_PREFIX",
310 std::string(Enums::OutputPrefixName((pb::OutputPrefixType)42)));
311
312 EXPECT_EQ(pb::OutputPrefixType::TINK, Enums::OutputPrefix("TINK"));
313 EXPECT_EQ(pb::OutputPrefixType::LEGACY, Enums::OutputPrefix("LEGACY"));
314 EXPECT_EQ(pb::OutputPrefixType::RAW, Enums::OutputPrefix("RAW"));
315 EXPECT_EQ(pb::OutputPrefixType::CRUNCHY, Enums::OutputPrefix("CRUNCHY"));
316 EXPECT_EQ(pb::OutputPrefixType::UNKNOWN_PREFIX,
317 Enums::OutputPrefix("Other string"));
318 EXPECT_EQ(pb::OutputPrefixType::UNKNOWN_PREFIX,
319 Enums::OutputPrefix("UNKNOWN_PREFIX"));
320
321 // Check that enum conversion covers the entire range of the proto-enum.
322 int count = 0;
323 for (int int_type = static_cast<int>(pb::OutputPrefixType_MIN);
324 int_type <= static_cast<int>(pb::OutputPrefixType_MAX); int_type++) {
325 if (pb::OutputPrefixType_IsValid(int_type)) {
326 pb::OutputPrefixType type = static_cast<pb::OutputPrefixType>(int_type);
327 EXPECT_EQ(type, Enums::OutputPrefix(Enums::OutputPrefixName(type)));
328 count++;
329 }
330 }
331 EXPECT_EQ(5, count);
332 }
333
334 } // namespace
335 } // namespace tink
336 } // namespace crypto
337