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 "hks_ability.h"
20 #include "hks_config.h"
21 #include "hks_crypto_hal.h"
22 #include "hks_crypto_hal_common.h"
23 #include "hks_mem.h"
24
25 using namespace testing::ext;
26 namespace OHOS {
27 namespace Security {
28 namespace Huks {
29 namespace UnitTest {
30 namespace {
31 struct TestCaseParams {
32 HksKeySpec spec = {0};
33 HksKeySpec specForAgree = {0};
34
35 HksErrorCode generateKeyResult = HksErrorCode::HKS_SUCCESS;
36 HksErrorCode agreeResult = HksErrorCode::HKS_SUCCESS;
37 };
38 const uint32_t ALISE_KEY_SIZE = 256;
39 const uint32_t BOB_KEY_SIZE = 256;
40 const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_001_PARAMS = {
41 .spec = {
42 .algType = HKS_ALG_ECC,
43 .keyLen = HKS_ECC_KEY_SIZE_224,
44 .algParam = nullptr,
45 },
46 .specForAgree = {
47 .algType = HKS_ALG_ECDH,
48 .keyLen = HKS_ECC_KEY_SIZE_224,
49 .algParam = nullptr,
50 },
51 .generateKeyResult = HKS_SUCCESS,
52 .agreeResult = HKS_SUCCESS,
53 };
54
55 const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_002_PARAMS = {
56 .spec = {
57 .algType = HKS_ALG_ECC,
58 .keyLen = HKS_ECC_KEY_SIZE_256,
59 .algParam = nullptr,
60 },
61 .specForAgree = {
62 .algType = HKS_ALG_ECDH,
63 .keyLen = HKS_ECC_KEY_SIZE_256,
64 .algParam = nullptr,
65 },
66 .generateKeyResult = HKS_SUCCESS,
67 .agreeResult = HKS_SUCCESS,
68 };
69
70 const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_003_PARAMS = {
71 .spec = {
72 .algType = HKS_ALG_ECC,
73 .keyLen = HKS_ECC_KEY_SIZE_384,
74 .algParam = nullptr,
75 },
76 .specForAgree = {
77 .algType = HKS_ALG_ECDH,
78 .keyLen = HKS_ECC_KEY_SIZE_384,
79 .algParam = nullptr,
80 },
81 .generateKeyResult = HKS_SUCCESS,
82 .agreeResult = HKS_SUCCESS,
83 };
84
85 const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_004_PARAMS = {
86 .spec = {
87 .algType = HKS_ALG_ECC,
88 .keyLen = HKS_ECC_KEY_SIZE_521,
89 .algParam = nullptr,
90 },
91 .specForAgree = {
92 .algType = HKS_ALG_ECDH,
93 .keyLen = HKS_ECC_KEY_SIZE_521,
94 .algParam = nullptr,
95 },
96 .generateKeyResult = HKS_SUCCESS,
97 .agreeResult = HKS_SUCCESS,
98 };
99 } // namespace
100
101 class HksCryptoHalEcdhAgree : public HksCryptoHalCommon, public testing::Test {
102 public:
103 static void SetUpTestCase(void);
104 static void TearDownTestCase(void);
105 void SetUp();
106 void TearDown();
107 protected:
RunTestCase(const TestCaseParams & testCaseParams) const108 void RunTestCase(const TestCaseParams &testCaseParams) const
109 {
110 HksBlob alise = { .size = 0, .data = nullptr };
111 HksBlob bob = { .size = 0, .data = nullptr };
112
113 EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &alise), testCaseParams.generateKeyResult);
114 EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &bob), testCaseParams.generateKeyResult);
115
116 struct HksBlob pubKeyAlise = { .size = ALISE_KEY_SIZE, .data = (uint8_t *)HksMalloc(ALISE_KEY_SIZE) };
117 ASSERT_NE(pubKeyAlise.data, nullptr);
118 struct HksBlob pubKeyBob = { .size = BOB_KEY_SIZE, .data = (uint8_t *)HksMalloc(BOB_KEY_SIZE) };
119 ASSERT_NE(pubKeyBob.data, nullptr);
120
121 EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
122 EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
123
124 struct HksBlob agreeKeyAlise = { .size = ALISE_KEY_SIZE, .data = (uint8_t *)HksMalloc(ALISE_KEY_SIZE) };
125 ASSERT_NE(agreeKeyAlise.data, nullptr);
126 struct HksBlob agreeKeyBob = { .size = BOB_KEY_SIZE, .data = (uint8_t *)HksMalloc(BOB_KEY_SIZE) };
127 ASSERT_NE(agreeKeyBob.data, nullptr);
128
129 EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &testCaseParams.specForAgree, &agreeKeyAlise),
130 testCaseParams.agreeResult);
131 EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &testCaseParams.specForAgree, &agreeKeyBob),
132 testCaseParams.agreeResult);
133
134 EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
135 EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
136
137 HksFree(alise.data);
138 HksFree(bob.data);
139 HksFree(pubKeyAlise.data);
140 HksFree(pubKeyBob.data);
141 HksFree(agreeKeyAlise.data);
142 HksFree(agreeKeyBob.data);
143 }
144 };
145
SetUpTestCase(void)146 void HksCryptoHalEcdhAgree::SetUpTestCase(void)
147 {
148 }
149
TearDownTestCase(void)150 void HksCryptoHalEcdhAgree::TearDownTestCase(void)
151 {
152 }
153
SetUp()154 void HksCryptoHalEcdhAgree::SetUp()
155 {
156 EXPECT_EQ(HksCryptoAbilityInit(), 0);
157 }
158
TearDown()159 void HksCryptoHalEcdhAgree::TearDown()
160 {
161 }
162
163 /**
164 * @tc.number : HksCryptoHalEcdhAgree_001
165 * @tc.name : HksCryptoHalEcdhAgree_001
166 * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-224 key.
167 */
168 HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_001, Function | SmallTest | Level0)
169 {
170 RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_001_PARAMS);
171 }
172
173 /**
174 * @tc.number : HksCryptoHalEcdhAgree_002
175 * @tc.name : HksCryptoHalEcdhAgree_002
176 * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-256 key.
177 */
178 HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_002, Function | SmallTest | Level0)
179 {
180 RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_002_PARAMS);
181 }
182
183 /**
184 * @tc.number : HksCryptoHalEcdhAgree_003
185 * @tc.name : HksCryptoHalEcdhAgree_003
186 * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-384 key.
187 */
188 HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_003, Function | SmallTest | Level0)
189 {
190 RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_003_PARAMS);
191 }
192
193 /**
194 * @tc.number : HksCryptoHalEcdhAgree_004
195 * @tc.name : HksCryptoHalEcdhAgree_004
196 * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-521 key.
197 */
198 HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_004, Function | SmallTest | Level0)
199 {
200 RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_004_PARAMS);
201 }
202 } // namespace UnitTest
203 } // namespace Huks
204 } // namespace Security
205 } // namespace OHOS