1 /*
2 * This file is part of the openHiTLS project.
3 *
4 * openHiTLS is licensed under the Mulan PSL v2.
5 * You can use this software according to the terms and conditions of the Mulan PSL v2.
6 * You may obtain a copy of Mulan PSL v2 at:
7 *
8 * http://license.coscl.org.cn/MulanPSL2
9 *
10 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13 * See the Mulan PSL v2 for more details.
14 */
15
16 /* BEGIN_HEADER */
17
18 #include "stub_replace.h"
19 #include "crypt_errno.h"
20 #include "crypt_utils.h"
21 #include "bsl_init.h"
22 #include "bsl_err.h"
23 #include "bsl_err_internal.h"
24 #include "crypt_types.h"
25 #include "crypt_eal_rand.h"
26 #include "crypt_eal_md.h"
27 #include "crypt_eal_pkey.h"
28 #include "crypt_eal_mac.h"
29 #include "crypt_eal_kdf.h"
30 #include "crypt_eal_cipher.h"
31 #include "asmcap_local.h"
32 #include "bsl_params.h"
33 #include "crypt_params_key.h"
34 /* END_HEADER */
35
36 #define DATA_LEN (64)
ResetStatus(void)37 void ResetStatus(void)
38 {
39 CRYPT_EAL_RandDeinit();
40 BSL_GLOBAL_DeInit();
41 }
42
STUB_IsSupportAVX()43 bool STUB_IsSupportAVX()
44 {
45 return false;
46 }
47
STUB_CRYPT_AES_AsmCheck()48 bool STUB_CRYPT_AES_AsmCheck()
49 {
50 return false;
51 }
52
STUB_IsSupportNEON()53 bool STUB_IsSupportNEON()
54 {
55 return false;
56 }
57
STUB_IsSupportBMI1()58 bool STUB_IsSupportBMI1()
59 {
60 return false;
61 }
62
STUB_IsSupportMOVBE()63 bool STUB_IsSupportMOVBE()
64 {
65 return false;
66 }
67
STUB_IsSupportAES()68 bool STUB_IsSupportAES()
69 {
70 return false;
71 }
72
STUB_CRYPT_GHASH_AsmCheck()73 int32_t STUB_CRYPT_GHASH_AsmCheck()
74 {
75 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
76 }
77
STUB_CRYPT_POLY1305_AsmCheck()78 int32_t STUB_CRYPT_POLY1305_AsmCheck()
79 {
80 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
81 }
82
83 #define CRYPT_INIT_ABILITY_CPU_POS 0
84 #define CRYPT_INIT_ABILITY_BSL_POS 1
85 #define CRYPT_INIT_ABILITY_RAND_POS 2
86
87 #define CRYPT_INIT_ABILITY_BITMAP(value, pos) (((value) >> (pos)) & 0x1)
88 #define CRYPT_INIT_SUPPORT_ABILITY(cap, pos) (CRYPT_INIT_ABILITY_BITMAP(cap, pos) != 0)
89
90 #define DRBG_MAX_OUTPUT_SIZE (1 << 16)
91
92
93 /* @
94 * @test SDV_CRYPT_INIT_FUNC_TC001
95 * @spec -
96 * @title CRYPT_EAL_Init functional test as constructor
97 * @precon nan
98 * @brief 1. CRYPT_EAL_Init called as constructor
99 2. check if DRBG is initialized.
100 3、check if BSL is initialized.
101 * @expect 1. DRBG is initialized
102 2、BSL is initialized
103 * @prior Level 1
104 * @auto TRUE
105 @ */
106 /* BEGIN_CASE */
SDV_CRYPT_INIT_FUNC_TC001()107 void SDV_CRYPT_INIT_FUNC_TC001()
108 {
109 #if defined(HITLS_EAL_INIT_OPTS)
110 uint8_t output[DATA_LEN];
111 uint32_t len = DATA_LEN;
112 int32_t ret = CRYPT_SUCCESS;
113 if(CRYPT_INIT_SUPPORT_ABILITY(HITLS_EAL_INIT_OPTS, CRYPT_INIT_ABILITY_RAND_POS)) {
114 ret = CRYPT_EAL_ERR_DRBG_REPEAT_INIT;
115 }
116 ASSERT_TRUE(CRYPT_EAL_RandInit(CRYPT_RAND_AES128_CTR, NULL, NULL, NULL, 0) == ret);
117 ASSERT_TRUE(CRYPT_EAL_Randbytes(output, len) == CRYPT_SUCCESS);
118 EXIT:
119 ResetStatus();
120 #endif
121 }
122 /* END_CASE */
123
124 /**
125 * @test SDV_CRYPTO_CRYPT_EAL_Init_TC002
126 * @title Check if cpu capability is called at entry point.
127 * @precon nan
128 * @brief
129 * 1. STUB function
130 * 1. call CRYPT_EAL_CipherNewCtx
131 * @expect
132 * 1. CRYPT_EAL_CipherNewCtx returns NULL
133 */
134 /* BEGIN_CASE */
SDV_CRYPTO_CRYPT_EAL_Init_TC002()135 void SDV_CRYPTO_CRYPT_EAL_Init_TC002()
136 {
137 FuncStubInfo tmpStubInfo = {0};
138 CRYPT_EAL_CipherCtx *ctx = NULL;
139 STUB_Init();
140 ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
141 ASSERT_TRUE(ctx != NULL);
142 CRYPT_EAL_CipherFreeCtx(ctx);
143 #if defined(HITLS_CRYPTO_ASM_CHECK)
144 #if defined(__x86_64__)
145 #if defined(HITLS_CRYPTO_AES_ASM)
146 STUB_Replace(&tmpStubInfo, IsSupportAVX, STUB_IsSupportAVX);
147 ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
148 ASSERT_TRUE(ctx == NULL);
149 #endif
150 #if defined(HITLS_CRYPTO_SM4_ASM)
151 ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_SM4_CBC);
152 ASSERT_TRUE(ctx == NULL);
153 #endif
154 STUB_Reset(&tmpStubInfo);
155 #elif defined(__aarch64__)
156 #if defined(HITLS_CRYPTO_AES_ASM)
157 STUB_Replace(&tmpStubInfo, IsSupportAES, STUB_IsSupportAES);
158 ctx = CRYPT_EAL_CipherNewCtx(CRYPT_CIPHER_AES128_CBC);
159 ASSERT_TRUE(ctx == NULL);
160 #endif
161 #endif
162 #endif
163 EXIT:
164 STUB_Reset(&tmpStubInfo);
165 ResetStatus();
166 }
167 /* END_CASE */
168
169 /**
170 * @test SDV_CRYPTO_CRYPT_EAL_Init_TC003
171 * @title Check if cpu capability is called at entry point.
172 * @precon nan
173 * @brief
174 * 1. STUB function
175 * 1. call CRYPT_EAL_MdNewCtx
176 * @expect
177 * 1. CRYPT_EAL_CipherNewCtx returns NULL
178 */
179 /* BEGIN_CASE */
SDV_CRYPTO_CRYPT_EAL_Init_TC003()180 void SDV_CRYPTO_CRYPT_EAL_Init_TC003()
181 {
182 CRYPT_EAL_MdCTX *ctx = NULL;
183 ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SHA256);
184 ASSERT_TRUE(ctx != NULL);
185 CRYPT_EAL_MdFreeCtx(ctx);
186 #if defined(HITLS_CRYPTO_ASM_CHECK)
187 #if defined(__x86_64__)
188 #if defined(HITLS_CRYPTO_SM2_ASM)
189 FuncStubInfo tmpStubInfo = {0};
190 STUB_Init();
191 STUB_Replace(&tmpStubInfo, IsSupportMOVBE, STUB_IsSupportMOVBE);
192 ctx = CRYPT_EAL_MdNewCtx(CRYPT_MD_SM3);
193 ASSERT_TRUE(ctx == NULL);
194 STUB_Reset(&tmpStubInfo);
195 #endif
196 #endif
197 #endif
198 EXIT:
199 ResetStatus();
200 }
201 /* END_CASE */
202
203 /**
204 * @test SDV_CRYPTO_CRYPT_EAL_Init_TC004
205 * @title Check if cpu capability is called at entry point.
206 * @precon nan
207 * @brief
208 * 1. STUB function
209 * 1. call CRYPT_EAL_MdNewCtx
210 * @expect
211 * 1. CRYPT_EAL_CipherNewCtx returns NULL
212 */
213 /* BEGIN_CASE */
SDV_CRYPTO_CRYPT_EAL_Init_TC004()214 void SDV_CRYPTO_CRYPT_EAL_Init_TC004()
215 {
216 ResetStatus();
217 FuncStubInfo tmpStubInfo = {0};
218 STUB_Init();
219 uint32_t keyLen = DATA_LEN;
220 uint8_t key[keyLen];
221 uint32_t saltLen = DATA_LEN;
222 uint8_t salt[saltLen];
223 uint32_t it = 1024;
224 uint32_t outLen = DATA_LEN;
225 uint8_t out[outLen];
226
227 CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_KdfNewCtx(CRYPT_KDF_PBKDF2);
228 ASSERT_TRUE(ctx != NULL);
229
230 CRYPT_MAC_AlgId macAlgId = CRYPT_MAC_HMAC_SHA256;
231 BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
232 ASSERT_EQ(BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32,
233 &macAlgId, sizeof(macAlgId)), CRYPT_SUCCESS);
234 ASSERT_EQ(BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS,
235 key, keyLen), CRYPT_SUCCESS);
236 ASSERT_EQ(BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
237 salt, saltLen), CRYPT_SUCCESS);
238 ASSERT_EQ(BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &it,
239 sizeof(it)), CRYPT_SUCCESS);
240 ASSERT_EQ(CRYPT_EAL_KdfSetParam(ctx, params), CRYPT_SUCCESS);
241 ASSERT_EQ(CRYPT_EAL_KdfDerive(ctx, out, outLen), CRYPT_SUCCESS);
242 #if defined(HITLS_CRYPTO_ASM_CHECK)
243 #if defined(__x86_64__)
244 #if defined(HITLS_CRYPTO_SHA2_ASM)
245 STUB_Replace(&tmpStubInfo, IsSupportAVX, STUB_IsSupportAVX);
246 ASSERT_TRUE(CRYPT_EAL_KdfSetParam(ctx, params) != CRYPT_SUCCESS);
247 STUB_Reset(&tmpStubInfo);
248 #endif
249 #if defined(HITLS_CRYPTO_MD5_ASM)
250 STUB_Replace(&tmpStubInfo, IsSupportBMI1, STUB_IsSupportBMI1);
251 macAlgId = CRYPT_MAC_HMAC_MD5;
252 ASSERT_TRUE(CRYPT_EAL_KdfSetParam(ctx, params) != CRYPT_SUCCESS);
253 STUB_Reset(&tmpStubInfo);
254 #endif
255 #if defined(HITLS_CRYPTO_SM3_ASM)
256 STUB_Replace(&tmpStubInfo, IsSupportMOVBE, STUB_IsSupportMOVBE);
257 macAlgId = CRYPT_MAC_HMAC_SM3;
258 ASSERT_TRUE(CRYPT_EAL_KdfSetParam(ctx, params) != CRYPT_SUCCESS);
259 STUB_Reset(&tmpStubInfo);
260 #endif
261 #endif
262 #endif
263 EXIT:
264 CRYPT_EAL_KdfFreeCtx(ctx);
265 STUB_Reset(&tmpStubInfo);
266 ResetStatus();
267 }
268 /* END_CASE */
269
270 /**
271 * @test SDV_CRYPTO_CRYPT_EAL_Init_TC005
272 * @title Check if cpu capability is called at entry point.
273 * @precon nan
274 * @brief
275 * 1. STUB function
276 * 1. call CRYPT_EAL_MdNewCtx
277 * @expect
278 * 1. CRYPT_EAL_CipherNewCtx returns NULL
279 */
280 /* BEGIN_CASE */
SDV_CRYPTO_CRYPT_EAL_Init_TC005()281 void SDV_CRYPTO_CRYPT_EAL_Init_TC005()
282 {
283 ResetStatus();
284 FuncStubInfo tmpStubInfo = {0};
285 CRYPT_EAL_RndCtx *ctx = NULL;
286
287 STUB_Init();
288 ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, NULL, NULL);
289 ASSERT_TRUE(ctx != NULL);
290 ASSERT_TRUE(CRYPT_EAL_DrbgInstantiate(ctx, NULL, 0) == CRYPT_SUCCESS);
291 CRYPT_EAL_DrbgDeinit(ctx);
292 #if defined(HITLS_CRYPTO_ASM_CHECK)
293 #if defined(__x86_64__)
294 STUB_Replace(&tmpStubInfo, IsSupportAVX, STUB_IsSupportAVX);
295 #if defined(HITLS_CRYPTO_SHA1_ASM)
296 ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA1, NULL, NULL);
297 ASSERT_TRUE(ctx == NULL);
298 ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA1, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
299 #endif
300 #if defined(HITLS_CRYPTO_SHA2_ASM)
301 ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_SHA256, NULL, NULL);
302 ASSERT_TRUE(ctx == NULL);
303 ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_SHA256, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
304 #endif
305 #if defined(HITLS_CRYPTO_AES_ASM)
306 ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_AES128_CTR, NULL, NULL);
307 ASSERT_TRUE(ctx == NULL);
308 ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_AES128_CTR, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
309 #endif
310 #elif defined(__aarch64__)
311 #if defined(HITLS_CRYPTO_AES_ASM)
312 STUB_Replace(&tmpStubInfo, IsSupportAES, STUB_IsSupportAES);
313 ctx = CRYPT_EAL_DrbgNew(CRYPT_RAND_AES128_CTR, NULL, NULL);
314 ASSERT_TRUE(ctx == NULL);
315 ASSERT_NE(CRYPT_EAL_RandInit(CRYPT_RAND_AES128_CTR, NULL, NULL, NULL, 0), CRYPT_SUCCESS);
316 #endif
317 #endif
318 #endif
319 EXIT:
320 STUB_Reset(&tmpStubInfo);
321 ResetStatus();
322 }
323 /* END_CASE */
324