1 // Copyright 2021 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/experimental/pqcrypto/signature/util/enums.h"
18
19 #include "gtest/gtest.h"
20
21 namespace crypto {
22 namespace tink {
23 namespace {
24
25 namespace pb = google::crypto::tink;
26 using crypto::tink::util::EnumsPqcrypto;
27
28 class EnumsTest : public ::testing::Test {};
29
TEST_F(EnumsTest,DilithiumSeedExpansion)30 TEST_F(EnumsTest, DilithiumSeedExpansion) {
31 EXPECT_EQ(pb::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE,
32 EnumsPqcrypto::SubtleToProto(
33 subtle::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE));
34 EXPECT_EQ(pb::DilithiumSeedExpansion::SEED_EXPANSION_AES,
35 EnumsPqcrypto::SubtleToProto(
36 subtle::DilithiumSeedExpansion::SEED_EXPANSION_AES));
37 EXPECT_EQ(pb::DilithiumSeedExpansion::SEED_EXPANSION_UNKNOWN,
38 EnumsPqcrypto::SubtleToProto(
39 subtle::DilithiumSeedExpansion::SEED_EXPANSION_UNKNOWN));
40
41 EXPECT_EQ(subtle::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE,
42 EnumsPqcrypto::ProtoToSubtle(
43 pb::DilithiumSeedExpansion::SEED_EXPANSION_SHAKE));
44 EXPECT_EQ(subtle::DilithiumSeedExpansion::SEED_EXPANSION_AES,
45 EnumsPqcrypto::ProtoToSubtle(
46 pb::DilithiumSeedExpansion::SEED_EXPANSION_AES));
47 EXPECT_EQ(subtle::DilithiumSeedExpansion::SEED_EXPANSION_UNKNOWN,
48 EnumsPqcrypto::ProtoToSubtle(
49 pb::DilithiumSeedExpansion::SEED_EXPANSION_UNKNOWN));
50
51 // Check that enum conversion covers the entire range of the proto-enum.
52 int count = 0;
53 for (int int_type = static_cast<int>(pb::DilithiumSeedExpansion_MIN);
54 int_type <= static_cast<int>(pb::DilithiumSeedExpansion_MAX);
55 int_type++) {
56 if (pb::DilithiumSeedExpansion_IsValid(int_type)) {
57 pb::DilithiumSeedExpansion type =
58 static_cast<pb::DilithiumSeedExpansion>(int_type);
59 EXPECT_EQ(type, EnumsPqcrypto::SubtleToProto(
60 EnumsPqcrypto::ProtoToSubtle(type)));
61 count++;
62 }
63 }
64 EXPECT_EQ(3, count);
65 }
66
TEST_F(EnumsTest,SphincsHashType)67 TEST_F(EnumsTest, SphincsHashType) {
68 EXPECT_EQ(pb::SphincsHashType::HARAKA,
69 EnumsPqcrypto::SubtleToProto(subtle::SphincsHashType::HARAKA));
70 EXPECT_EQ(pb::SphincsHashType::SHA256,
71 EnumsPqcrypto::SubtleToProto(subtle::SphincsHashType::SHA256));
72 EXPECT_EQ(pb::SphincsHashType::SHAKE256,
73 EnumsPqcrypto::SubtleToProto(subtle::SphincsHashType::SHAKE256));
74 EXPECT_EQ(pb::SphincsHashType::HASH_TYPE_UNSPECIFIED,
75 EnumsPqcrypto::SubtleToProto(
76 subtle::SphincsHashType::HASH_TYPE_UNSPECIFIED));
77
78 EXPECT_EQ(subtle::SphincsHashType::HARAKA,
79 EnumsPqcrypto::ProtoToSubtle(pb::SphincsHashType::HARAKA));
80 EXPECT_EQ(subtle::SphincsHashType::SHA256,
81 EnumsPqcrypto::ProtoToSubtle(pb::SphincsHashType::SHA256));
82 EXPECT_EQ(subtle::SphincsHashType::SHAKE256,
83 EnumsPqcrypto::ProtoToSubtle(pb::SphincsHashType::SHAKE256));
84 EXPECT_EQ(
85 subtle::SphincsHashType::HASH_TYPE_UNSPECIFIED,
86 EnumsPqcrypto::ProtoToSubtle(pb::SphincsHashType::HASH_TYPE_UNSPECIFIED));
87
88 // Check that enum conversion covers the entire range of the proto-enum.
89 int count = 0;
90 for (int int_type = static_cast<int>(pb::SphincsHashType_MIN);
91 int_type <= static_cast<int>(pb::SphincsHashType_MAX); int_type++) {
92 if (pb::SphincsHashType_IsValid(int_type)) {
93 pb::SphincsHashType type = static_cast<pb::SphincsHashType>(int_type);
94 EXPECT_EQ(type, EnumsPqcrypto::SubtleToProto(
95 EnumsPqcrypto::ProtoToSubtle(type)));
96 count++;
97 }
98 }
99 EXPECT_EQ(4, count);
100 }
101
TEST_F(EnumsTest,SphincsVariant)102 TEST_F(EnumsTest, SphincsVariant) {
103 EXPECT_EQ(pb::SphincsVariant::ROBUST,
104 EnumsPqcrypto::SubtleToProto(subtle::SphincsVariant::ROBUST));
105 EXPECT_EQ(pb::SphincsVariant::SIMPLE,
106 EnumsPqcrypto::SubtleToProto(subtle::SphincsVariant::SIMPLE));
107 EXPECT_EQ(pb::SphincsVariant::VARIANT_UNSPECIFIED,
108 EnumsPqcrypto::SubtleToProto(
109 subtle::SphincsVariant::VARIANT_UNSPECIFIED));
110
111 EXPECT_EQ(subtle::SphincsVariant::ROBUST,
112 EnumsPqcrypto::ProtoToSubtle(pb::SphincsVariant::ROBUST));
113 EXPECT_EQ(subtle::SphincsVariant::SIMPLE,
114 EnumsPqcrypto::ProtoToSubtle(pb::SphincsVariant::SIMPLE));
115 EXPECT_EQ(
116 subtle::SphincsVariant::VARIANT_UNSPECIFIED,
117 EnumsPqcrypto::ProtoToSubtle(pb::SphincsVariant::VARIANT_UNSPECIFIED));
118
119 // Check that enum conversion covers the entire range of the proto-enum.
120 int count = 0;
121 for (int int_type = static_cast<int>(pb::SphincsVariant_MIN);
122 int_type <= static_cast<int>(pb::SphincsVariant_MAX); int_type++) {
123 if (pb::SphincsVariant_IsValid(int_type)) {
124 pb::SphincsVariant type = static_cast<pb::SphincsVariant>(int_type);
125 EXPECT_EQ(type, EnumsPqcrypto::SubtleToProto(
126 EnumsPqcrypto::ProtoToSubtle(type)));
127 count++;
128 }
129 }
130 EXPECT_EQ(3, count);
131 }
132
TEST_F(EnumsTest,SphincsSignatureType)133 TEST_F(EnumsTest, SphincsSignatureType) {
134 EXPECT_EQ(
135 pb::SphincsSignatureType::FAST_SIGNING,
136 EnumsPqcrypto::SubtleToProto(subtle::SphincsSignatureType::FAST_SIGNING));
137 EXPECT_EQ(pb::SphincsSignatureType::SMALL_SIGNATURE,
138 EnumsPqcrypto::SubtleToProto(
139 subtle::SphincsSignatureType::SMALL_SIGNATURE));
140 EXPECT_EQ(pb::SphincsSignatureType::SIG_TYPE_UNSPECIFIED,
141 EnumsPqcrypto::SubtleToProto(
142 subtle::SphincsSignatureType::SIG_TYPE_UNSPECIFIED));
143
144 EXPECT_EQ(
145 subtle::SphincsSignatureType::FAST_SIGNING,
146 EnumsPqcrypto::ProtoToSubtle(pb::SphincsSignatureType::FAST_SIGNING));
147 EXPECT_EQ(
148 subtle::SphincsSignatureType::SMALL_SIGNATURE,
149 EnumsPqcrypto::ProtoToSubtle(pb::SphincsSignatureType::SMALL_SIGNATURE));
150 EXPECT_EQ(subtle::SphincsSignatureType::SIG_TYPE_UNSPECIFIED,
151 EnumsPqcrypto::ProtoToSubtle(
152 pb::SphincsSignatureType::SIG_TYPE_UNSPECIFIED));
153
154 // Check that enum conversion covers the entire range of the proto-enum.
155 int count = 0;
156 for (int int_type = static_cast<int>(pb::SphincsSignatureType_MIN);
157 int_type <= static_cast<int>(pb::SphincsSignatureType_MAX); int_type++) {
158 if (pb::SphincsSignatureType_IsValid(int_type)) {
159 pb::SphincsSignatureType type =
160 static_cast<pb::SphincsSignatureType>(int_type);
161 EXPECT_EQ(type, EnumsPqcrypto::SubtleToProto(
162 EnumsPqcrypto::ProtoToSubtle(type)));
163 count++;
164 }
165 }
166 EXPECT_EQ(3, count);
167 }
168
169 } // namespace
170 } // namespace tink
171 } // namespace crypto
172