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 <gtest/gtest.h>
17 #include "crypto_common.h"
18 #include "crypto_asym_key.h"
19 #include "crypto_kdf.h"
20 #include "log.h"
21 #include "memory.h"
22 #include "memory_mock.h"
23
24 using namespace std;
25 using namespace testing::ext;
26
27 namespace {
28 class NativeKdfest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp();
33 void TearDown();
34 };
35
SetUpTestCase()36 void NativeKdfest::SetUpTestCase() {}
TearDownTestCase()37 void NativeKdfest::TearDownTestCase() {}
38
SetUp()39 void NativeKdfest::SetUp() // add init here, this will be called before test.
40 {
41 }
42
TearDown()43 void NativeKdfest::TearDown() // add destroy here, this will be called when test case done.
44 {
45 }
46
47 static const char *g_keyData = "012345678901234567890123456789";
48 static const char *g_infoData = "infostring";
49 static const char *g_saltData = "saltstring";
50 static const char *g_password = "123456";
51
52 constexpr uint32_t KEY_NORMAL_LENGTH = 32;
53
54 HWTEST_F(NativeKdfest, NativeKdfest001, TestSize.Level0)
55 {
56 OH_CryptoKdfParams *params = nullptr;
57 OH_Crypto_ErrCode ret = OH_CryptoKdfParams_Create("HKDF", ¶ms);
58 EXPECT_EQ(ret, CRYPTO_SUCCESS);
59 Crypto_DataBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
60 .len = strlen(g_keyData)};
61 Crypto_DataBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
62 .len = strlen(g_saltData)};
63 Crypto_DataBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
64 .len = strlen(g_infoData)};
65 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_KEY_DATABLOB, &key);
66 EXPECT_EQ(ret, CRYPTO_SUCCESS);
67 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_SALT_DATABLOB, &salt);
68 EXPECT_EQ(ret, CRYPTO_SUCCESS);
69 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_INFO_DATABLOB, &info);
70 EXPECT_EQ(ret, CRYPTO_SUCCESS);
71
72 Crypto_DataBlob out = {0};
73 OH_CryptoKdf *kdfCtx = nullptr;
74 ret = OH_CryptoKdf_Create("HKDF|SHA256|EXTRACT_AND_EXPAND", &kdfCtx);
75 EXPECT_EQ(ret, CRYPTO_SUCCESS);
76 ret = OH_CryptoKdf_Derive(kdfCtx, params, KEY_NORMAL_LENGTH, &out);
77 EXPECT_EQ(ret, CRYPTO_SUCCESS);
78
79 OH_Crypto_FreeDataBlob(&out);
80 OH_CryptoKdf_Destroy(kdfCtx);
81 OH_CryptoKdfParams_Destroy(params);
82 }
83
84 HWTEST_F(NativeKdfest, NativeKdfest002, TestSize.Level0)
85 {
86 OH_CryptoKdfParams *params = nullptr;
87 OH_Crypto_ErrCode ret = OH_CryptoKdfParams_Create("PBKDF2", ¶ms);
88 EXPECT_EQ(ret, CRYPTO_SUCCESS);
89
90 Crypto_DataBlob password = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_password)),
91 .len = strlen(g_password)};
92 Crypto_DataBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
93 .len = strlen(g_saltData)};
94 int iterations = 10000;
95 Crypto_DataBlob iterationsData = {.data = reinterpret_cast<uint8_t *>(&iterations), .len = sizeof(int)};
96
97 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_KEY_DATABLOB, &password);
98 EXPECT_EQ(ret, CRYPTO_SUCCESS);
99 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_SALT_DATABLOB, &salt);
100 EXPECT_EQ(ret, CRYPTO_SUCCESS);
101 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_ITER_COUNT_INT, &iterationsData);
102 EXPECT_EQ(ret, CRYPTO_SUCCESS);
103
104 Crypto_DataBlob out = {0};
105 OH_CryptoKdf *kdfCtx = nullptr;
106 ret = OH_CryptoKdf_Create("PBKDF2|SHA256", &kdfCtx);
107 EXPECT_EQ(ret, CRYPTO_SUCCESS);
108 ret = OH_CryptoKdf_Derive(kdfCtx, params, KEY_NORMAL_LENGTH, &out);
109 EXPECT_EQ(ret, CRYPTO_SUCCESS);
110
111 OH_Crypto_FreeDataBlob(&out);
112 OH_CryptoKdf_Destroy(kdfCtx);
113 OH_CryptoKdfParams_Destroy(params);
114 }
115
116 HWTEST_F(NativeKdfest, NativeKdfest003, TestSize.Level0)
117 {
118 OH_CryptoKdfParams *params = nullptr;
119 OH_Crypto_ErrCode ret = OH_CryptoKdfParams_Create("SCRYPT", ¶ms);
120 EXPECT_EQ(ret, CRYPTO_SUCCESS);
121
122 Crypto_DataBlob password = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_password)),
123 .len = strlen(g_password)};
124 Crypto_DataBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
125 .len = strlen(g_saltData)};
126
127 uint64_t n = 1024;
128 uint64_t p = 16;
129 uint64_t r = 8;
130 uint64_t maxMem = 1067008;
131 Crypto_DataBlob nData = {.data = reinterpret_cast<uint8_t *>(&n), .len = sizeof(uint64_t)};
132 Crypto_DataBlob pData = {.data = reinterpret_cast<uint8_t *>(&p), .len = sizeof(uint64_t)};
133 Crypto_DataBlob rData = {.data = reinterpret_cast<uint8_t *>(&r), .len = sizeof(uint64_t)};
134 Crypto_DataBlob maxMemData = {.data = reinterpret_cast<uint8_t *>(&maxMem), .len = sizeof(uint64_t)};
135 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_KEY_DATABLOB, &password);
136 EXPECT_EQ(ret, CRYPTO_SUCCESS);
137 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_SALT_DATABLOB, &salt);
138 EXPECT_EQ(ret, CRYPTO_SUCCESS);
139 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_SCRYPT_N_UINT64, &nData);
140 EXPECT_EQ(ret, CRYPTO_SUCCESS);
141 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_SCRYPT_P_UINT64, &pData);
142 EXPECT_EQ(ret, CRYPTO_SUCCESS);
143 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_SCRYPT_R_UINT64, &rData);
144 EXPECT_EQ(ret, CRYPTO_SUCCESS);
145 ret = OH_CryptoKdfParams_SetParam(params, CRYPTO_KDF_SCRYPT_MAX_MEM_UINT64, &maxMemData);
146 EXPECT_EQ(ret, CRYPTO_SUCCESS);
147
148 Crypto_DataBlob out = {0};
149 OH_CryptoKdf *kdfCtx = nullptr;
150 ret = OH_CryptoKdf_Create("SCRYPT", &kdfCtx);
151 EXPECT_EQ(ret, CRYPTO_SUCCESS);
152 ret = OH_CryptoKdf_Derive(kdfCtx, params, KEY_NORMAL_LENGTH, &out);
153 EXPECT_EQ(ret, CRYPTO_SUCCESS);
154
155 OH_Crypto_FreeDataBlob(&out);
156 OH_CryptoKdf_Destroy(kdfCtx);
157 OH_CryptoKdfParams_Destroy(params);
158 }
159
160 HWTEST_F(NativeKdfest, NativeKdfest004, TestSize.Level0)
161 {
162 OH_CryptoKdfParams *params = nullptr;
163 OH_Crypto_ErrCode ret = OH_CryptoKdfParams_Create("SCRYPT", nullptr);
164 EXPECT_NE(ret, CRYPTO_SUCCESS);
165 ret = OH_CryptoKdfParams_Create("XXXX", ¶ms);
166 EXPECT_NE(ret, CRYPTO_SUCCESS);
167 }
168
169 HWTEST_F(NativeKdfest, NativeKdfest005, TestSize.Level0)
170 {
171 Crypto_DataBlob out = {0};
172 OH_CryptoKdf *kdfCtx = nullptr;
173 OH_Crypto_ErrCode ret = OH_CryptoKdf_Create("HKDF|SHA256|EXTRACT_AND_EXPAND", &kdfCtx);
174 EXPECT_EQ(ret, CRYPTO_SUCCESS);
175 ret = OH_CryptoKdf_Derive(kdfCtx, nullptr, KEY_NORMAL_LENGTH, &out);
176 EXPECT_NE(ret, CRYPTO_SUCCESS);
177
178 OH_Crypto_FreeDataBlob(&out);
179 OH_CryptoKdf_Destroy(kdfCtx);
180 }
181 }