1 /*
2 * Copyright (C) 2022 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 "adaptor_algorithm_test.h"
17
18 #include <gtest/gtest.h>
19
20 #include "adaptor_algorithm.h"
21
22 namespace OHOS {
23 namespace UserIam {
24 namespace PinAuth {
25 using namespace testing;
26 using namespace testing::ext;
27
SetUpTestCase()28 void AdaptorAlgorithmTest::SetUpTestCase()
29 {
30 }
31
TearDownTestCase()32 void AdaptorAlgorithmTest::TearDownTestCase()
33 {
34 }
35
SetUp()36 void AdaptorAlgorithmTest::SetUp()
37 {
38 }
39
TearDown()40 void AdaptorAlgorithmTest::TearDown()
41 {
42 }
43
44 /**
45 * @tc.name: KeyPair test
46 * @tc.desc: verify KeyPair
47 * @tc.type: FUNC
48 * @tc.require: #I64XCB
49 */
50 HWTEST_F(AdaptorAlgorithmTest, KeyPair_Test, TestSize.Level1)
51 {
52 DestroyKeyPair(nullptr);
53
54 std::vector<uint8_t> dataTest(32, 1);
55 Buffer *data = CreateBufferByData(&dataTest[0], 32);
56 EXPECT_NE(data, nullptr);
57 KeyPair keyPair2 = {};
58 keyPair2.pubKey = nullptr;
59 keyPair2.priKey = CopyBuffer(data);
60 EXPECT_NE(keyPair2.priKey, nullptr);
61 bool result = IsEd25519KeyPairValid(&keyPair2);
62 EXPECT_EQ(result, false);
63 DestroyBuffer(keyPair2.priKey);
64
65 KeyPair keyPair3 = {};
66 keyPair3.priKey = nullptr;
67 keyPair3.pubKey = CopyBuffer(data);
68 EXPECT_NE(keyPair3.pubKey, nullptr);
69 result = IsEd25519KeyPairValid(&keyPair3);
70 EXPECT_EQ(result, false);
71 DestroyBuffer(keyPair3.pubKey);
72 DestroyBuffer(data);
73
74 KeyPair *keyPair4 = GenerateEd25519KeyPair();
75 EXPECT_NE(keyPair4, nullptr);
76 result = IsEd25519KeyPairValid(keyPair4);
77 EXPECT_EQ(result, true);
78 DestroyKeyPair(keyPair4);
79 }
80
81 /**
82 * @tc.name: Ed25519Sign test
83 * @tc.desc: sign Ed25519
84 * @tc.type: FUNC
85 * @tc.require: #I64XCB
86 */
87 HWTEST_F(AdaptorAlgorithmTest, Ed25519Sign_Test, TestSize.Level1)
88 {
89 constexpr uint32_t keyLen = 32;
90 std::vector<uint8_t> dataTest(keyLen, 1);
91 Buffer *data = CreateBufferByData(&dataTest[0], keyLen);
92 EXPECT_NE(data, nullptr);
93 Buffer *signContent = nullptr;
94 KeyPair *keyPair = GenerateEd25519KeyPair();
95 EXPECT_NE(keyPair, nullptr);
96
97 int32_t result = Ed25519Sign(nullptr, data, &signContent);
98 EXPECT_EQ(result, RESULT_BAD_PARAM);
99
100 result = Ed25519Sign(keyPair, nullptr, &signContent);
101 EXPECT_EQ(result, RESULT_BAD_PARAM);
102
103 result = Ed25519Sign(keyPair, data, nullptr);
104 EXPECT_EQ(result, RESULT_BAD_PARAM);
105
106 result = Ed25519Sign(keyPair, data, &signContent);
107 EXPECT_EQ(result, RESULT_SUCCESS);
108
109 DestroyBuffer(signContent);
110 DestroyKeyPair(keyPair);
111 DestroyBuffer(data);
112 }
113
114 /**
115 * @tc.name: Ed25519Verify test
116 * @tc.desc: verify Ed25519
117 * @tc.type: FUNC
118 * @tc.require: #I64XCB
119 */
120 HWTEST_F(AdaptorAlgorithmTest, Ed25519Verify_Test, TestSize.Level1)
121 {
122 constexpr uint32_t constLen = 64;
123 std::vector<uint8_t> dataTest(constLen, 1);
124 Buffer *data = CreateBufferByData(&dataTest[0], constLen);
125 KeyPair *keyPair = GenerateEd25519KeyPair();
126 EXPECT_NE(keyPair, nullptr);
127 Buffer *signContent = nullptr;
128
129 int32_t result = Ed25519Sign(keyPair, data, &signContent);
130 EXPECT_EQ(result, RESULT_SUCCESS);
131
132 result = Ed25519Verify(nullptr, data, signContent);
133 EXPECT_EQ(result, RESULT_BAD_PARAM);
134
135 result = Ed25519Verify(keyPair->pubKey, nullptr, signContent);
136 EXPECT_EQ(result, RESULT_BAD_PARAM);
137
138 result = Ed25519Verify(keyPair->pubKey, data, nullptr);
139 EXPECT_EQ(result, RESULT_BAD_PARAM);
140
141 result = Ed25519Verify(keyPair->priKey, data, signContent);
142 EXPECT_EQ(result, RESULT_GENERAL_ERROR);
143
144 result = Ed25519Verify(keyPair->pubKey, data, signContent);
145 EXPECT_EQ(result, RESULT_SUCCESS);
146
147 DestroyBuffer(signContent);
148 DestroyKeyPair(keyPair);
149 DestroyBuffer(data);
150 }
151
152 /**
153 * @tc.name: ase_encode_null
154 * @tc.desc: verify Aes256GcmEncryptNoPadding
155 * @tc.type: FUNC
156 * @tc.require: issueI5NYCT
157 */
158 HWTEST_F(AdaptorAlgorithmTest, AdaptorAlgorithmAesEnCode1, TestSize.Level1)
159 {
160 int32_t result = AesGcm256Encrypt(nullptr, nullptr, nullptr, nullptr);
161 EXPECT_EQ(result, RESULT_BAD_PARAM);
162 }
163
164 /**
165 * @tc.name: ase_encode_failed
166 * @tc.desc: verify Aes256GcmEncryptNoPadding
167 * @tc.type: FUNC
168 * @tc.require: issueI5NYCT
169 */
170 HWTEST_F(AdaptorAlgorithmTest, AdaptorAlgorithmAesEnCode2, TestSize.Level1)
171 {
172 Buffer *plaintext = CreateBufferBySize(20);
173 ASSERT_NE(plaintext, nullptr);
174 int32_t result = AesGcm256Encrypt(plaintext, nullptr, nullptr, nullptr);
175 EXPECT_EQ(result, RESULT_BAD_PARAM);
176 DestroyBuffer(plaintext);
177 }
178
RandomBuffer(uint32_t size)179 static Buffer *RandomBuffer(uint32_t size)
180 {
181 Buffer *buffer = CreateBufferBySize(size);
182 if (buffer == NULL) {
183 return buffer;
184 }
185 (void)SecureRandom(buffer->buf, buffer->maxSize);
186 buffer->contentSize = buffer->maxSize;
187 return buffer;
188 }
189
190 /**
191 * @tc.name: ase_encode_success
192 * @tc.desc: verify Aes256GcmEncryptNoPadding
193 * @tc.type: FUNC
194 * @tc.require: issueI5NYCT
195 */
196 HWTEST_F(AdaptorAlgorithmTest, AdaptorAlgorithmAesValid, TestSize.Level1)
197 {
198 Buffer *plaintext1 = RandomBuffer(64);
199 ASSERT_NE(plaintext1, nullptr);
200 AesGcmParam param = {};
201 param.key = RandomBuffer(AES_GCM_256_KEY_SIZE);
202 ASSERT_NE(param.key, nullptr);
203 param.iv = RandomBuffer(AES_GCM_256_IV_SIZE);
204 ASSERT_NE(param.iv, nullptr);
205 Buffer *cipherText = NULL;
206 Buffer *tag = NULL;
207 int32_t result = AesGcm256Encrypt(plaintext1, ¶m, &cipherText, &tag);
208 EXPECT_EQ(result, RESULT_SUCCESS);
209
210 Buffer *plaintext2 = NULL;
211 result = AesGcm256Decrypt(cipherText, ¶m, tag, &plaintext2);
212 EXPECT_EQ(result, RESULT_SUCCESS);
213
214 bool isSame = CompareBuffer(plaintext1, plaintext2);
215 EXPECT_EQ(isSame, true);
216
217 DestroyBuffer(plaintext1);
218 DestroyBuffer(param.key);
219 DestroyBuffer(param.iv);
220 DestroyBuffer(cipherText);
221 DestroyBuffer(tag);
222 DestroyBuffer(plaintext2);
223 }
224
225 /**
226 * @tc.name: device_key
227 * @tc.desc: verify DeriveDeviceKey
228 * @tc.type: FUNC
229 * @tc.require: issueI5NYDJ
230 */
231 HWTEST_F(AdaptorAlgorithmTest, AdaptorAlgorithmDeriveDeviceKey, TestSize.Level1)
232 {
233 Buffer *secret = CreateBufferBySize(SECRET_SIZE);
234 ASSERT_NE(secret, nullptr);
235 (void)SecureRandom(secret->buf, secret->maxSize);
236 secret->contentSize = secret->maxSize;
237 constexpr uint32_t pinDataLen = 64;
238 Buffer *pinData = CreateBufferBySize(pinDataLen);
239 ASSERT_NE(pinData, nullptr);
240 (void)SecureRandom(pinData->buf, pinData->maxSize);
241 pinData->contentSize = pinData->maxSize;
242 Buffer *key = DeriveDeviceKey(pinData, secret);
243 ASSERT_NE(key, nullptr);
244 EXPECT_EQ(key->contentSize, SHA256_DIGEST_SIZE);
245 DestroyBuffer(key);
246 DestroyBuffer(pinData);
247 DestroyBuffer(secret);
248 }
249
250 /**
251 * @tc.name: hkdf
252 * @tc.desc: verify Hkdf
253 * @tc.type: FUNC
254 * @tc.require: issueI5NYDJ
255 */
256 HWTEST_F(AdaptorAlgorithmTest, AdaptorAlgorithmHkdf, TestSize.Level1)
257 {
258 Buffer *salt = CreateBufferBySize(HKDF_SALT_SIZE);
259 ASSERT_NE(salt, nullptr);
260 (void)SecureRandom(salt->buf, salt->maxSize);
261 salt->contentSize = salt->maxSize;
262 Buffer *rootKey = CreateBufferBySize(AES_GCM_256_KEY_SIZE);
263 ASSERT_NE(rootKey, nullptr);
264 (void)SecureRandom(rootKey->buf, rootKey->maxSize);
265 rootKey->contentSize = rootKey->maxSize;
266 Buffer *key = Hkdf(salt, rootKey);
267 ASSERT_NE(key, nullptr);
268 EXPECT_EQ(key->contentSize, SHA256_DIGEST_SIZE);
269 DestroyBuffer(salt);
270 DestroyBuffer(rootKey);
271 DestroyBuffer(key);
272 }
273
274 /**
275 * @tc.name: sha256
276 * @tc.desc: verify Sha256Adaptor
277 * @tc.type: FUNC
278 * @tc.require: issueI5NYDJ
279 */
280 HWTEST_F(AdaptorAlgorithmTest, AdaptorAlgorithmSha256, TestSize.Level1)
281 {
282 Buffer *data = CreateBufferBySize(64);
283 ASSERT_NE(data, nullptr);
284 (void)SecureRandom(data->buf, data->maxSize);
285 data->contentSize = data->maxSize;
286 Buffer *key = Sha256Adaptor(data);
287 ASSERT_NE(key, nullptr);
288 EXPECT_EQ(key->contentSize, SHA256_DIGEST_SIZE);
289 DestroyBuffer(data);
290 DestroyBuffer(key);
291 }
292 } // namespace PinAuth
293 } // namespace UserIam
294 } // namespace OHOS
295