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/subtle/falcon_subtle_utils.h"
18
19 #include <climits>
20 #include <string>
21 #include <utility>
22 #include <vector>
23
24 #include "gmock/gmock.h"
25 #include "gtest/gtest.h"
26 #include "absl/strings/str_cat.h"
27 #include "tink/util/status.h"
28 #include "tink/util/statusor.h"
29 #include "tink/util/test_matchers.h"
30
31 namespace crypto {
32 namespace tink {
33 namespace subtle {
34 namespace {
35
36 using ::crypto::tink::test::IsOk;
37 using ::testing::Not;
38
39 struct FalconTestCase {
40 std::string test_name;
41 int32_t private_key_size;
42 int32_t public_key_size;
43 };
44
45 using FalconUtilsTest = testing::TestWithParam<FalconTestCase>;
46
TEST_P(FalconUtilsTest,FalconKeyGeneration)47 TEST_P(FalconUtilsTest, FalconKeyGeneration) {
48 const FalconTestCase& test_case = GetParam();
49
50 // Generate falcon key pair.
51 util::StatusOr<FalconKeyPair> key_pair =
52 GenerateFalconKeyPair(test_case.private_key_size);
53 ASSERT_THAT(key_pair, IsOk());
54
55 // Check keys size.
56 EXPECT_EQ(key_pair->GetPrivateKey().GetKey().size(),
57 test_case.private_key_size);
58 EXPECT_EQ(key_pair->GetPublicKey().GetKey().size(),
59 test_case.public_key_size);
60 }
61
TEST_P(FalconUtilsTest,DifferentContent)62 TEST_P(FalconUtilsTest, DifferentContent) {
63 const FalconTestCase& test_case = GetParam();
64
65 // Generate falcon key pair.
66 util::StatusOr<FalconKeyPair> key_pair =
67 GenerateFalconKeyPair(test_case.private_key_size);
68 ASSERT_THAT(key_pair, IsOk());
69
70 // Check keys content is different.
71 EXPECT_NE(util::SecretDataAsStringView(key_pair->GetPrivateKey().GetKey()),
72 key_pair->GetPublicKey().GetKey());
73 }
74
TEST(FalconUtilsTest,ValidPrivateKeySize)75 TEST(FalconUtilsTest, ValidPrivateKeySize) {
76 EXPECT_THAT(ValidateFalconPrivateKeySize(kFalcon1024PrivateKeySize), IsOk());
77 EXPECT_THAT(ValidateFalconPrivateKeySize(kFalcon512PrivateKeySize), IsOk());
78 }
79
TEST(FalconUtilsTest,InvalidPrivateKeySize)80 TEST(FalconUtilsTest, InvalidPrivateKeySize) {
81 std::vector<int32_t> invalid_keysizes{0,
82 -1,
83 kFalcon1024PrivateKeySize - 1,
84 kFalcon1024PrivateKeySize + 1,
85 INT_MAX,
86 INT_MIN};
87 for (int i = 0; i < invalid_keysizes.size(); i++) {
88 EXPECT_FALSE(ValidateFalconPrivateKeySize(invalid_keysizes[i]).ok());
89 }
90 }
91
TEST(FalconUtilsTest,ValidPublicKeySize)92 TEST(FalconUtilsTest, ValidPublicKeySize) {
93 EXPECT_THAT(ValidateFalconPublicKeySize(kFalcon1024PublicKeySize), IsOk());
94 EXPECT_THAT(ValidateFalconPublicKeySize(kFalcon512PublicKeySize), IsOk());
95 }
96
TEST(FalconUtilsTest,InvalidPublicKeySize)97 TEST(FalconUtilsTest, InvalidPublicKeySize) {
98 std::vector<int32_t> invalid_keysizes{0,
99 -1,
100 kFalcon1024PublicKeySize - 1,
101 kFalcon1024PublicKeySize + 1,
102 INT_MAX,
103 INT_MIN};
104 for (int i = 0; i < invalid_keysizes.size(); i++) {
105 EXPECT_FALSE(ValidateFalconPublicKeySize(invalid_keysizes[i]).ok());
106 }
107 }
108
TEST(FalconUtilsTest,InvalidPrivateKey)109 TEST(FalconUtilsTest, InvalidPrivateKey) {
110 std::string bad_private_key_data = "bad private key";
111 util::StatusOr<FalconPrivateKeyPqclean> private_key =
112 FalconPrivateKeyPqclean::NewPrivateKey(
113 util::SecretDataFromStringView(bad_private_key_data));
114
115 EXPECT_THAT(private_key.status(), testing::Not(IsOk()));
116 }
117
TEST(FalconUtilsTest,InvalidPubliceKey)118 TEST(FalconUtilsTest, InvalidPubliceKey) {
119 std::string bad_public_key_data = "bad public key";
120 util::StatusOr<FalconPublicKeyPqclean> public_key =
121 FalconPublicKeyPqclean::NewPublicKey(bad_public_key_data);
122
123 EXPECT_THAT(public_key, Not(IsOk()));
124 }
125
126 INSTANTIATE_TEST_SUITE_P(
127 FalconUtilsTests, FalconUtilsTest,
128 testing::ValuesIn<FalconTestCase>(
129 {{"Falcon512", kFalcon512PrivateKeySize, kFalcon512PublicKeySize},
130 {"Falcon1024", kFalcon1024PrivateKeySize, kFalcon1024PublicKeySize}}),
__anonfb120b520202(const testing::TestParamInfo<FalconUtilsTest::ParamType>& info) 131 [](const testing::TestParamInfo<FalconUtilsTest::ParamType>& info) {
132 return info.param.test_name;
133 });
134
135 } // namespace
136 } // namespace subtle
137 } // namespace tink
138 } // namespace crypto
139