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 #include "hitls_build.h"
16 #ifdef HITLS_CRYPTO_ASM_CHECK
17
18 #ifdef __cplusplus
19 extern "c" {
20 #endif
21
22 #include "crypt_errno.h"
23 #include "crypt_utils.h"
24 #include "bsl_err_internal.h"
25 #include "asmcap_local.h"
26
27 #if defined(HITLS_CRYPTO_CIPHER)
28 #if defined(HITLS_CRYPTO_AES_ASM)
CRYPT_AES_AsmCheck(void)29 int32_t CRYPT_AES_AsmCheck(void)
30 {
31 #if defined(HITLS_CRYPTO_AES_X8664)
32 if (!IsSupportAVX() || !IsOSSupportAVX() ||
33 !IsSupportAES() || !IsSupportSSE2()) {
34 // SetEncryptKey256 uses AVX and SSE2.
35 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
36 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
37 }
38 #elif defined(HITLS_CRYPTO_AES_ARMV8)
39 if (!IsSupportPMULL() || !IsSupportAES()) {
40 // ARMV8 should support the PMULL instruction sets.
41 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
42 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
43 }
44 #endif
45 return CRYPT_SUCCESS;
46 }
47 #endif // HITLS_CRYPTO_AES_ASM
48
49 #if defined(HITLS_CRYPTO_CHACHA20_ASM)
CRYPT_CHACHA20_AsmCheck(void)50 int32_t CRYPT_CHACHA20_AsmCheck(void)
51 {
52 #if defined(HITLS_CRYPTO_CHACHA20_X8664)
53 if (!IsSupportAVX() || !IsOSSupportAVX() || !IsSupportAVX2()) {
54 // The CHACHA20_Update function uses the AVX and AVX2 instruction sets.
55 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
56 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
57 }
58 #endif
59 return CRYPT_SUCCESS;
60 }
61 #endif // HITLS_CRYPTO_CHACHA20
62
63 #if defined(HITLS_CRYPTO_CHACHA20POLY1305_ASM)
CRYPT_POLY1305_AsmCheck(void)64 int32_t CRYPT_POLY1305_AsmCheck(void)
65 {
66 #if defined(HITLS_CRYPTO_CHACHA20POLY1305_X8664)
67 if (!IsSupportAVX() || !IsOSSupportAVX() ||
68 !IsSupportAVX2() || !IsSupportSSE2()) {
69 // The Poly1305BlockAVX2 function uses AVX, AVX2, and SSE2.
70 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
71 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
72 }
73 #endif
74 return CRYPT_SUCCESS;
75 }
76 #endif // HITLS_CRYPTO_CHACHA20POLY1305
77
78 #if defined(HITLS_CRYPTO_SM4_ASM)
CRYPT_SM4_AsmCheck(void)79 int32_t CRYPT_SM4_AsmCheck(void)
80 {
81 #if defined(HITLS_CRYPTO_SM4_X8664)
82 if ((!IsSupportAVX()) || !IsOSSupportAVX() || !IsSupportAVX2() ||
83 (!IsSupportAES()) || (!IsSupportMOVBE())) {
84 // The AES instruction is used for the SBOX assembly in the XTS.
85 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
86 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
87 }
88 #elif (HITLS_CRYPTO_SM4_ARMV8)
89 if (!IsSupportAES()) {
90 // sbox uses the AES instruction.
91 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
92 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
93 }
94 #endif
95 return CRYPT_SUCCESS;
96 }
97 #endif // HITLS_CRYPTO_SM4
98
99 #if defined(HITLS_CRYPTO_GCM_ASM)
CRYPT_GHASH_AsmCheck(void)100 int32_t CRYPT_GHASH_AsmCheck(void)
101 {
102 #if defined(HITLS_CRYPTO_GCM_X8664)
103 if (!IsSupportAVX() || !IsOSSupportAVX()) {
104 // GcmTableGen4bit uses the AVX.
105 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
106 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
107 }
108 #elif defined(HITLS_CRYPTO_GCM_ARMV8)
109 if (!IsSupportPMULL()) {
110 // In ARMV8, GHASH_BLOCK must support the PMULL instruction set.
111 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
112 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
113 }
114 #endif
115 return CRYPT_SUCCESS;
116 }
117 #endif // HITLS_CRYPTO_GCM
118
119 #endif // HITLS_CRYPTO_CIPHER
120
121 #if defined(HITLS_CRYPTO_MD)
122 #if defined(HITLS_CRYPTO_MD5_ASM)
CRYPT_MD5_AsmCheck(void)123 int32_t CRYPT_MD5_AsmCheck(void)
124 {
125 #if defined(HITLS_CRYPTO_MD5_X8664)
126 if (!IsSupportBMI1()) { // MD5_Compress uses the BMI1 instruction set.
127 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
128 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
129 }
130 #endif
131 return CRYPT_SUCCESS;
132 }
133 #endif // HITLS_CRYPTO_MD5
134
135 #if defined(HITLS_CRYPTO_SHA1_ASM)
CRYPT_SHA1_AsmCheck(void)136 int32_t CRYPT_SHA1_AsmCheck(void)
137 {
138 #if defined(HITLS_CRYPTO_SHA1_X8664)
139 if (!IsSupportAVX() || !IsOSSupportAVX() || !IsSupportAVX2() || !IsSupportBMI1() || !IsSupportBMI2()) {
140 // The SHA1_Step function uses the AVX, AVX2, BMI1, and BMI2 instruction sets.
141 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
142 }
143 #endif
144 return CRYPT_SUCCESS;
145 }
146 #endif // HITLS_CRYPTO_SHA1
147
148 #if defined(HITLS_CRYPTO_SHA2_ASM)
CRYPT_SHA2_AsmCheck(void)149 int32_t CRYPT_SHA2_AsmCheck(void)
150 {
151 #if defined(HITLS_CRYPTO_SHA2_X8664)
152 if (!IsSupportAVX() || !IsOSSupportAVX() || !IsSupportAVX2() || !IsSupportBMI1() || !IsSupportBMI2()) {
153 // The SHA*CompressMultiBlocks_Asm function uses the AVX, AVX2, BMI1, and BMI2 instruction sets.
154 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
155 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
156 }
157 #endif
158 return CRYPT_SUCCESS;
159 }
160 #endif // HITLS_CRYPTO_SHA2
161
162 #if defined(HITLS_CRYPTO_SM3_ASM)
CRYPT_SM3_AsmCheck(void)163 int32_t CRYPT_SM3_AsmCheck(void)
164 {
165 #if defined(HITLS_CRYPTO_SM3_X8664)
166 if (!IsSupportMOVBE()) {
167 // MOVBE is used in the SM3_CompressAsm function.
168 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
169 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
170 }
171 #endif
172 return CRYPT_SUCCESS;
173 }
174 #endif // HITLS_CRYPTO_SM3
175 #endif // HITLS_CRYPTO_MD
176
177 #if defined(HITLS_CRYPTO_PKEY)
178 #if defined(HITLS_CRYPTO_BN_ASM)
CRYPT_BN_AsmCheck(void)179 int32_t CRYPT_BN_AsmCheck(void)
180 {
181 return CRYPT_SUCCESS;
182 }
183 #endif // HITLS_CRYPTO_BN
184
185 #if defined(HITLS_CRYPTO_CURVE_NISTP256_ASM)
CRYPT_ECP256_AsmCheck(void)186 int32_t CRYPT_ECP256_AsmCheck(void)
187 {
188 #if defined(HITLS_CRYPTO_ECC_X8664)
189 if (!IsSupportAVX() || !IsOSSupportAVX()) { // ECP256_OrdSqr uses AVX.
190 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
191 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
192 }
193 #endif
194 return CRYPT_SUCCESS;
195 }
196 #endif // HITLS_CRYPTO_ECC
197
198 #endif // HITLS_CRYPTO_PKEY
199
200 #ifdef __cplusplus
201 }
202 #endif
203
204 #endif // HITLS_CRYPTO_ASM_CHECK