1 /*
2 * Copyright (c) 2021-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 <gtest/gtest.h>
17 #include <iostream>
18
19 #include "file_ex.h"
20 #include "hks_ability.h"
21 #include "hks_config.h"
22 #include "hks_crypto_hal.h"
23 #include "hks_crypto_hal_common.h"
24 #include "hks_mem.h"
25
26 using namespace testing::ext;
27 namespace OHOS {
28 namespace Security {
29 namespace Huks {
30 namespace UnitTest {
31 namespace {
32 struct TestCaseParams {
33 HksKeySpec spec = {0};
34
35 HksErrorCode generateKeyResult = HksErrorCode::HKS_SUCCESS;
36 };
37
38 #ifdef HKS_UNTRUSTED_RUNNING_ENV
39 const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_001_PARAMS = {
40 .spec = {
41 .algType = HKS_ALG_ECC,
42 .keyLen = HKS_ECC_KEY_SIZE_224,
43 .algParam = nullptr,
44 },
45 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
46 .generateKeyResult = HKS_SUCCESS,
47 #else
48 .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
49 #endif
50 };
51 #endif
52
53 const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_002_PARAMS = {
54 .spec = {
55 .algType = HKS_ALG_ECC,
56 .keyLen = HKS_ECC_KEY_SIZE_256,
57 .algParam = nullptr,
58 },
59 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
60 .generateKeyResult = HKS_SUCCESS,
61 #else
62 .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
63 #endif
64 };
65
66 const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_003_PARAMS = {
67 .spec = {
68 .algType = HKS_ALG_ECC,
69 .keyLen = HKS_ECC_KEY_SIZE_384,
70 .algParam = nullptr,
71 },
72 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
73 .generateKeyResult = HKS_SUCCESS,
74 #else
75 .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
76 #endif
77 };
78
79 const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_004_PARAMS = {
80 .spec = {
81 .algType = HKS_ALG_ECC,
82 .keyLen = HKS_ECC_KEY_SIZE_521,
83 .algParam = nullptr,
84 },
85 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
86 .generateKeyResult = HKS_SUCCESS,
87 #else
88 .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
89 #endif
90 };
91 } // namespace
92
93 class HksCryptoHalEccKey : public HksCryptoHalCommon, public testing::Test {
94 public:
95 static void SetUpTestCase(void);
96 static void TearDownTestCase(void);
97 void SetUp();
98 void TearDown();
99 protected:
RunTestCase(const TestCaseParams & testCaseParams) const100 void RunTestCase(const TestCaseParams &testCaseParams) const
101 {
102 HksBlob keyTest02 = { .size = 0, .data = nullptr };
103 ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &keyTest02), testCaseParams.generateKeyResult);
104 if (testCaseParams.generateKeyResult == HKS_SUCCESS) {
105 ASSERT_NE((uint32_t)0, keyTest02.size);
106 ASSERT_NE(nullptr, keyTest02.data);
107 HKS_FREE(keyTest02.data);
108 }
109 }
110 };
111
SetUpTestCase(void)112 void HksCryptoHalEccKey::SetUpTestCase(void)
113 {
114 }
115
TearDownTestCase(void)116 void HksCryptoHalEccKey::TearDownTestCase(void)
117 {
118 }
119
SetUp()120 void HksCryptoHalEccKey::SetUp()
121 {
122 EXPECT_EQ(HksCryptoAbilityInit(), 0);
123 }
124
TearDown()125 void HksCryptoHalEccKey::TearDown()
126 {
127 }
128
129 #ifdef HKS_UNTRUSTED_RUNNING_ENV
130 /**
131 * @tc.number : HksCryptoHalEccKey_001
132 * @tc.name : HksCryptoHalEccKey_001
133 * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-224bit key.
134 */
135 HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_001, Function | SmallTest | Level0)
136 {
137 RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_001_PARAMS);
138 }
139 #endif
140
141 /**
142 * @tc.number : HksCryptoHalEccKey_002
143 * @tc.name : HksCryptoHalEccKey_002
144 * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-256bit key.
145 */
146 HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_002, Function | SmallTest | Level0)
147 {
148 RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_002_PARAMS);
149 }
150
151 /**
152 * @tc.number : HksCryptoHalEccKey_003
153 * @tc.name : HksCryptoHalEccKey_003
154 * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-384bit key.
155 */
156 HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_003, Function | SmallTest | Level0)
157 {
158 RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_003_PARAMS);
159 }
160
161 /**
162 * @tc.number : HksCryptoHalEccKey_004
163 * @tc.name : HksCryptoHalEccKey_004
164 * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-521bit key.
165 */
166 HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_004, Function | SmallTest | Level0)
167 {
168 RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_004_PARAMS);
169 }
170
171 /**
172 * @tc.number : HksCryptoHalEccKey_005
173 * @tc.name : HksCryptoHalEccKey_005
174 * @tc.desc : Generate key and export public key with ECC.
175 */
176 HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Level0)
177 {
178 int32_t ret;
179
180 HksKeySpec spec = {
181 .algType = HKS_ALG_ECC,
182 .keyLen = HKS_ECC_KEY_SIZE_384,
183 };
184
185 HksBlob key = { .size = 0, .data = NULL };
186
187 ret = HksCryptoHalGenerateKey(&spec, &key);
188 ASSERT_EQ(ret, HKS_SUCCESS);
189
190 KeyMaterialEcc *keyMaterial = (KeyMaterialEcc *)key.data;
191 ASSERT_NE(keyMaterial, nullptr);
192
193 uint32_t keyOutLen = sizeof(KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize;
194 HksBlob keyOut = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) };
195 ASSERT_NE(keyOut.data, nullptr);
196
197 ret = HksCryptoHalGetPubKey(&key, &keyOut);
198 ASSERT_EQ(ret, HKS_SUCCESS);
199 HKS_FREE_BLOB(key);
200 HKS_FREE_BLOB(keyOut);
201 }
202 } // namespace UnitTest
203 } // namespace Huks
204 } // namespace Security
205 } // namespace OHOS