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 const uint32_t DSA_SIZE_256 = 256;
32 const uint32_t SIGNATURE_SIZE = 1024;
33 const uint32_t PUB_KEY_SIZE = 1024;
34 const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_001_SPEC = {
35 .algType = HKS_ALG_DSA,
36 .mode = HKS_MODE_ECB,
37 .padding = HKS_PADDING_NONE,
38 .digest = HKS_DIGEST_SHA1,
39 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
40 };
41
42 const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_002_SPEC = {
43 .algType = HKS_ALG_DSA,
44 .mode = HKS_MODE_ECB,
45 .padding = HKS_PADDING_NONE,
46 .digest = HKS_DIGEST_SHA224,
47 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
48 };
49
50 const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_003_SPEC = {
51 .algType = HKS_ALG_DSA,
52 .mode = HKS_MODE_ECB,
53 .padding = HKS_PADDING_NONE,
54 .digest = HKS_DIGEST_SHA256,
55 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
56 };
57
58 const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_004_SPEC = {
59 .algType = HKS_ALG_DSA,
60 .mode = HKS_MODE_ECB,
61 .padding = HKS_PADDING_NONE,
62 .digest = HKS_DIGEST_SHA384,
63 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
64 };
65
66 const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_005_SPEC = {
67 .algType = HKS_ALG_DSA,
68 .mode = HKS_MODE_ECB,
69 .padding = HKS_PADDING_NONE,
70 .digest = HKS_DIGEST_SHA512,
71 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
72 };
73 } // namespace
74
75 class HksCryptoHalDsaSign : public HksCryptoHalCommon, public testing::Test {
76 public:
77 static void SetUpTestCase(void);
78 static void TearDownTestCase(void);
79 void SetUp();
80 void TearDown();
81 protected:
RunTestCase(const HksUsageSpec & hksUsageSpec) const82 void RunTestCase(const HksUsageSpec &hksUsageSpec) const
83 {
84 HksKeySpec spec = {
85 .algType = HKS_ALG_DSA,
86 .keyLen = DSA_SIZE_256,
87 .algParam = nullptr,
88 };
89
90 HksBlob key = { .size = 0, .data = nullptr };
91
92 #if defined(_USE_MBEDTLS_)
93 EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED);
94 return;
95 #endif
96 #if defined(_USE_OPENSSL_)
97 EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
98 #endif
99
100 const char *hexData = "00112233445566778899aabbccddeeff";
101 uint32_t dataLen = strlen(hexData) / HKS_COUNT_OF_HALF;
102
103 HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
104 ASSERT_NE(message.data, nullptr);
105 for (uint32_t ii = 0; ii < dataLen; ii++) {
106 message.data[ii] = ReadHex((const uint8_t *)&hexData[HKS_COUNT_OF_HALF * ii]);
107 }
108
109 uint8_t hashData[HKS_HMAC_DIGEST_SHA512_LEN] = {0};
110 struct HksBlob hash = { HKS_HMAC_DIGEST_SHA512_LEN, hashData };
111 EXPECT_EQ(HksCryptoHalHash(hksUsageSpec.digest, &message, &hash), HKS_SUCCESS);
112
113 struct HksBlob signature = { .size = SIGNATURE_SIZE, .data = (uint8_t *)HksMalloc(SIGNATURE_SIZE) };
114 ASSERT_NE(signature.data, nullptr);
115
116 EXPECT_EQ(HksCryptoHalSign(&key, &hksUsageSpec, &hash, &signature), HKS_SUCCESS);
117
118 struct HksBlob pubKey = { .size = PUB_KEY_SIZE, .data = (uint8_t *)HksMalloc(PUB_KEY_SIZE) };
119 ASSERT_NE(pubKey.data, nullptr);
120
121 EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS);
122
123 EXPECT_EQ(HksCryptoHalVerify(&pubKey, &hksUsageSpec, &hash, &signature), HKS_SUCCESS);
124
125 HksFree(key.data);
126 HksFree(message.data);
127 HksFree(signature.data);
128 HksFree(pubKey.data);
129 }
130 };
131
SetUpTestCase(void)132 void HksCryptoHalDsaSign::SetUpTestCase(void)
133 {
134 }
135
TearDownTestCase(void)136 void HksCryptoHalDsaSign::TearDownTestCase(void)
137 {
138 }
139
SetUp()140 void HksCryptoHalDsaSign::SetUp()
141 {
142 EXPECT_EQ(HksCryptoAbilityInit(), 0);
143 }
144
TearDown()145 void HksCryptoHalDsaSign::TearDown()
146 {
147 }
148
149 /**
150 * @tc.number : HksCryptoHalDsaSign_001
151 * @tc.name : HksCryptoHalDsaSign_001
152 * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA1 key.
153 */
154 HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_001, Function | SmallTest | Level0)
155 {
156 RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_001_SPEC);
157 }
158
159 /**
160 * @tc.number : HksCryptoHalDsaSign_002
161 * @tc.name : HksCryptoHalDsaSign_002
162 * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA224 key.
163 */
164 HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_002, Function | SmallTest | Level0)
165 {
166 RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_002_SPEC);
167 }
168
169 /**
170 * @tc.number : HksCryptoHalDsaSign_003
171 * @tc.name : HksCryptoHalDsaSign_003
172 * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA256 key.
173 */
174 HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_003, Function | SmallTest | Level0)
175 {
176 RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_003_SPEC);
177 }
178
179 /**
180 * @tc.number : HksCryptoHalDsaSign_004
181 * @tc.name : HksCryptoHalDsaSign_004
182 * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA384 key.
183 */
184 HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_004, Function | SmallTest | Level0)
185 {
186 RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_004_SPEC);
187 }
188
189 /**
190 * @tc.number : HksCryptoHalDsaSign_005
191 * @tc.name : HksCryptoHalDsaSign_005
192 * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA512 key.
193 */
194 HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_005, Function | SmallTest | Level0)
195 {
196 RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_005_SPEC);
197 }
198 } // namespace UnitTest
199 } // namespace Huks
200 } // namespace Security
201 } // namespace OHOS