1 /*
2 * Copyright (C) 2025 Huawei Device Co., Ltd.
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 #include "scrypt_openssl.h"
17
18 #include <gtest/gtest.h>
19 #include "securec.h"
20
21 #include "detailed_scrypt_params.h"
22 #include "kdf.h"
23 #include "log.h"
24 #include "memory.h"
25
26 using namespace std;
27 using namespace testing::ext;
28
29 namespace {
30 class CryptoScryptTest : public testing::Test {
31 public:
32 static void SetUpTestCase();
33 static void TearDownTestCase();
34 void SetUp();
35 void TearDown();
36 };
37
SetUpTestCase()38 void CryptoScryptTest::SetUpTestCase() {}
TearDownTestCase()39 void CryptoScryptTest::TearDownTestCase() {}
40
SetUp()41 void CryptoScryptTest::SetUp() // add init here, this will be called before test.
42 {
43 }
44
TearDown()45 void CryptoScryptTest::TearDown() // add destroy here, this will be called when test case done.
46 {
47 }
48
49 constexpr uint32_t OUT_PUT_MAX_LENGTH = 128;
50 constexpr uint32_t OUT_PUT_NORMAL_LENGTH = 32;
51 constexpr uint32_t SALT_NORMAL_LENGTH = 16;
52
53 HWTEST_F(CryptoScryptTest, CryptoScryptTest1, TestSize.Level0)
54 {
55 HcfKdf *generator = nullptr;
56 HcfResult ret = HcfKdfCreate("SCRYPT", &generator);
57 EXPECT_EQ(ret, HCF_SUCCESS);
58 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
59 uint8_t saltData[SALT_NORMAL_LENGTH] = {0};
60 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
61 HcfBlob salt = {.data = saltData, .len = SALT_NORMAL_LENGTH};
62 HcfBlob password = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>("123456")),
63 .len = strlen("123456")};
64 HcfScryptParamsSpec params = {
65 .base = { .algName = "SCRYPT", },
66 .passPhrase = password,
67 .salt = salt,
68 .n = 1024,
69 .p = 16,
70 .r = 8,
71 .maxMem = 1067008,
72 .output = output,
73 };
74 ret = generator->generateSecret(generator, &(params.base));
75 EXPECT_EQ(ret, HCF_SUCCESS);
76 HcfObjDestroy(generator);
77 }
78
79 HWTEST_F(CryptoScryptTest, CryptoScryptErrTest1, TestSize.Level0)
80 {
81 HcfKdf *generator = nullptr;
82 HcfResult ret = HcfKdfCreate("SCRYPT", &generator);
83 EXPECT_EQ(ret, HCF_SUCCESS);
84 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
85 uint8_t saltData[SALT_NORMAL_LENGTH] = {0};
86 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
87 HcfBlob salt = {.data = saltData, .len = SALT_NORMAL_LENGTH};
88 HcfBlob password = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>("123456")),
89 .len = strlen("123456")};
90 HcfScryptParamsSpec params = {
91 .base = { .algName = "SCRYPT", },
92 .passPhrase = password,
93 .salt = salt,
94 .n = 1024,
95 .p = 16,
96 .r = 8,
97 .maxMem = 1067007,
98 .output = output,
99 };
100 ret = generator->generateSecret(generator, &(params.base));
101 EXPECT_NE(ret, HCF_SUCCESS);
102 HcfObjDestroy(generator);
103 }
104
105 HWTEST_F(CryptoScryptTest, CryptoScryptErrTest2, TestSize.Level0)
106 {
107 HcfKdf *generator = nullptr;
108 HcfResult ret = HcfKdfCreate("SCRYPT", &generator);
109 EXPECT_EQ(ret, HCF_SUCCESS);
110 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
111 uint8_t saltData[SALT_NORMAL_LENGTH] = {0};
112 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
113 HcfBlob salt = {.data = saltData, .len = SALT_NORMAL_LENGTH};
114 HcfBlob password = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>("123456")),
115 .len = strlen("123456")};
116 HcfScryptParamsSpec params = {
117 .base = { .algName = "SCRYPT", },
118 .passPhrase = password,
119 .salt = salt,
120 .n = 1024,
121 .p = 16,
122 .r = 8,
123 .maxMem = 1067008,
124 .output = output,
125 };
126 generator->base.destroy(nullptr);
127 ret = generator->generateSecret(nullptr, &(params.base));
128 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
129 HcfObjDestroy(generator);
130 }
131
132 HWTEST_F(CryptoScryptTest, CryptoScryptTest2, TestSize.Level0)
133 {
134 HcfKdf *generator = nullptr;
135 HcfResult ret = HcfKdfCreate("SCRYPT", &generator);
136 EXPECT_EQ(ret, HCF_SUCCESS);
137 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
138 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
139 HcfBlob salt = {.data = nullptr, .len = 0};
140 HcfBlob password = {.data = nullptr, .len = 0};
141 HcfScryptParamsSpec params = {
142 .base = { .algName = "SCRYPT", },
143 .passPhrase = password,
144 .salt = salt,
145 .n = 1024,
146 .p = 16,
147 .r = 8,
148 .maxMem = 768,
149 .output = output,
150 };
151 ret = generator->generateSecret(generator, &(params.base));
152 EXPECT_NE(ret, HCF_SUCCESS);
153 HcfObjDestroy(generator);
154 }
155
156 HWTEST_F(CryptoScryptTest, CryptoScryptTest3, TestSize.Level0)
157 {
158 HcfKdf *generator = nullptr;
159 HcfResult ret = HcfKdfCreate("SCRYPT", &generator);
160 EXPECT_EQ(ret, HCF_SUCCESS);
161 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
162 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
163 HcfBlob salt = {.data = nullptr, .len = 0};
164 HcfBlob password = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>("")),
165 .len = strlen("")};
166 HcfScryptParamsSpec params = {
167 .base = { .algName = "SCRYPT", },
168 .passPhrase = password,
169 .salt = salt,
170 .n = 1024,
171 .p = 16,
172 .r = 8,
173 .maxMem = 1067008,
174 .output = output,
175 };
176 ret = generator->generateSecret(generator, &(params.base));
177 EXPECT_EQ(ret, HCF_SUCCESS);
178 HcfObjDestroy(generator);
179 }
180
181 HWTEST_F(CryptoScryptTest, CryptoScryptTest4, TestSize.Level0)
182 {
183 // long password (long than md length)
184 HcfKdf *generator = nullptr;
185 HcfResult ret = HcfKdfCreate("SCRYPT", &generator);
186 EXPECT_EQ(ret, HCF_SUCCESS);
187 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
188 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
189 uint8_t saltData[SALT_NORMAL_LENGTH] = {0};
190 HcfBlob salt = {.data = saltData, .len = SALT_NORMAL_LENGTH};
191 char longPass[] = "12345678123456781234567812345678123456781234567812345678123456781234567812345678";
192 HcfBlob password = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(longPass)),
193 .len = strlen(longPass)};
194 HcfScryptParamsSpec params = {
195 .base = { .algName = "SCRYPT", },
196 .passPhrase = password,
197 .salt = salt,
198 .n = 1024,
199 .p = 16,
200 .r = 8,
201 .maxMem = 1067008,
202 .output = output,
203 };
204 ret = generator->generateSecret(generator, &(params.base));
205 EXPECT_EQ(ret, HCF_SUCCESS);
206 HcfObjDestroy(generator);
207 }
208
209
210 HWTEST_F(CryptoScryptTest, CryptoScryptTest6, TestSize.Level0)
211 {
212 HcfKdf *generator = nullptr;
213 HcfResult ret = HcfKdfCreate("SCRYPT", &generator);
214 EXPECT_EQ(ret, HCF_SUCCESS);
215 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
216 uint8_t saltData[SALT_NORMAL_LENGTH] = {0};
217 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
218 HcfBlob salt = {.data = saltData, .len = SALT_NORMAL_LENGTH};
219 HcfBlob password = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>("123456")),
220 .len = strlen("123456")};
221 HcfScryptParamsSpec params = {
222 .base = { .algName = "SCRYPT", },
223 .passPhrase = password,
224 .salt = salt,
225 .n = 1024,
226 .p = 16,
227 .r = 8,
228 .maxMem = 1067008,
229 .output = output,
230 };
231 ret = generator->generateSecret(generator, &(params.base));
232 EXPECT_EQ(ret, HCF_SUCCESS);
233 HcfObjDestroy(generator);
234 }
235
236 HWTEST_F(CryptoScryptTest, CryptoScryptTestError8, TestSize.Level1)
237 {
238 // use nullptr params
239 HcfKdf *generator = nullptr;
240 HcfResult ret = HcfKdfCreate("SCRYPT", &generator);
241 EXPECT_EQ(ret, HCF_SUCCESS);
242 ret = generator->generateSecret(generator, nullptr);
243 EXPECT_NE(ret, HCF_SUCCESS);
244 HcfObjDestroy(generator);
245 }
246
247 HWTEST_F(CryptoScryptTest, CryptoScryptTestError9, TestSize.Level1)
248 {
249 HcfKdf *generator = nullptr;
250 HcfResult ret = HcfKdfCreate("SCRYPT|abcd", &generator);
251 EXPECT_NE(ret, HCF_SUCCESS);
252 HcfObjDestroy(generator);
253 }
254
255 HWTEST_F(CryptoScryptTest, CryptoScryptTestError10, TestSize.Level1)
256 {
257 HcfKdf *generator = nullptr;
258 HcfResult ret = HcfKdfCreate("ABCD|SM3", &generator);
259 EXPECT_NE(ret, HCF_SUCCESS);
260 HcfObjDestroy(generator);
261 }
262
263 HWTEST_F(CryptoScryptTest, CryptoScryptTestError11, TestSize.Level1)
264 {
265 HcfKdf *generator = nullptr;
266 HcfResult ret = HcfKdfCreate(nullptr, &generator);
267 EXPECT_NE(ret, HCF_SUCCESS);
268 HcfObjDestroy(generator);
269 }
270
271 HWTEST_F(CryptoScryptTest, CryptoScryptTestError12, TestSize.Level1)
272 {
273 HcfResult ret = HcfKdfCreate(nullptr, nullptr);
274 EXPECT_NE(ret, HCF_SUCCESS);
275 }
276 }
277