1 /*
2 * Copyright (c) 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 #ifdef HKS_CONFIG_FILE
17 #include HKS_CONFIG_FILE
18 #else
19 #include "hks_config.h"
20 #endif
21
22 #include <stdint.h>
23
24 #include "hks_ability.h"
25 #include "hks_core_ability.h"
26 #include "hks_openssl_aes.h"
27 #include "hks_openssl_bn.h"
28 #include "hks_openssl_common.h"
29 #include "hks_openssl_curve25519.h"
30 #include "hks_openssl_dh.h"
31 #include "hks_openssl_dsa.h"
32 #include "hks_openssl_ecc.h"
33 #include "hks_openssl_hash.h"
34 #include "hks_openssl_hmac.h"
35 #include "hks_openssl_kdf.h"
36 #include "hks_openssl_rsa.h"
37 #include "hks_openssl_sm2.h"
38 #include "hks_openssl_sm3.h"
39 #include "hks_openssl_sm4.h"
40 #include "hks_type.h"
41
RegisterAbilityGenerateKey(void)42 static void RegisterAbilityGenerateKey(void)
43 {
44 #if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY)
45 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_AES), HksOpensslAesGenerateKey);
46 #endif
47 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
48 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_RSA), HksOpensslRsaGenerateKey);
49 #endif
50 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
51 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_ECC), HksOpensslEccGenerateKey);
52 #endif
53 #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_GENERATE_KEY)
54 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_X25519), HksOpensslCurve25519GenerateKey);
55 #endif
56 #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_GENERATE_KEY)
57 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_ED25519), HksOpensslCurve25519GenerateKey);
58 #endif
59 #if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY)
60 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_HMAC), HksOpensslHmacGenerateKey);
61 #endif
62 #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY)
63 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_DSA), HksOpensslDsaGenerateKey);
64 #endif
65 #if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY)
66 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_DH), HksOpensslDhGenerateKey);
67 #endif
68 #if defined(HKS_SUPPORT_SM2_C) && defined(HKS_SUPPORT_SM2_GENERATE_KEY)
69 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_SM2), HksOpensslSm2GenerateKey);
70 #endif
71 #if defined(HKS_SUPPORT_SM3_C) && defined(HKS_SUPPORT_SM3_GENERATE_KEY)
72 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_SM3), HksOpensslSm3GenerateKey);
73 #endif
74 #if defined(HKS_SUPPORT_SM4_C) && defined(HKS_SUPPORT_SM4_GENERATE_KEY)
75 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GENERATE_KEY(HKS_ALG_SM4), HksOpensslSm4GenerateKey);
76 #endif
77 }
78
RegisterAbilityGetPublicKey(void)79 static void RegisterAbilityGetPublicKey(void)
80 {
81 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GET_PUBLIC_KEY)
82 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_RSA), HksOpensslGetRsaPubKey);
83 #endif
84 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GET_PUBLIC_KEY)
85 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_ECC), HksOpensslGetEccPubKey);
86 #endif
87 #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED2519_GET_PUBLIC_KEY)
88 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_ED25519), HksOpensslGetEd25519PubKey);
89 #endif
90 #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_GET_PUBLIC_KEY)
91 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_X25519), HksOpensslGetEd25519PubKey);
92 #endif
93 #if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY)
94 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_DH), HksOpensslGetDhPubKey);
95 #endif
96 #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GET_PUBLIC_KEY)
97 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_DSA), HksOpensslGetDsaPubKey);
98 #endif
99 #if defined(HKS_SUPPORT_SM2_C) && defined(HKS_SUPPORT_SM2_GET_PUBLIC_KEY)
100 (void)RegisterAbility(HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(HKS_ALG_SM2), HksOpensslGetEccPubKey);
101 #endif
102 }
103
RegisterAbilitySign(void)104 static void RegisterAbilitySign(void)
105 {
106 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY)
107 (void)RegisterAbility(HKS_CRYPTO_ABILITY_SIGN(HKS_ALG_RSA), HksOpensslRsaSign);
108 #endif
109 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY)
110 (void)RegisterAbility(HKS_CRYPTO_ABILITY_SIGN(HKS_ALG_ECC), HksOpensslEcdsaSign);
111 #endif
112 #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_SIGN_VERIFY)
113 (void)RegisterAbility(HKS_CRYPTO_ABILITY_SIGN(HKS_ALG_ED25519), HksOpensslEd25519Sign);
114 #endif
115 #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY)
116 (void)RegisterAbility(HKS_CRYPTO_ABILITY_SIGN(HKS_ALG_DSA), HksOpensslDsaSign);
117 #endif
118 #if defined(HKS_SUPPORT_SM2_C) && defined(HKS_SUPPORT_SM2_SIGN_VERIFY)
119 (void)RegisterAbility(HKS_CRYPTO_ABILITY_SIGN(HKS_ALG_SM2), HksOpensslSm2Sign);
120 #endif
121 }
122
RegisterAbilityVerify(void)123 static void RegisterAbilityVerify(void)
124 {
125 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY)
126 (void)RegisterAbility(HKS_CRYPTO_ABILITY_VERIFY(HKS_ALG_RSA), HksOpensslRsaVerify);
127 #endif
128 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY)
129 (void)RegisterAbility(HKS_CRYPTO_ABILITY_VERIFY(HKS_ALG_ECC), HksOpensslEcdsaVerify);
130 #endif
131 #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_SIGN_VERIFY)
132 (void)RegisterAbility(HKS_CRYPTO_ABILITY_VERIFY(HKS_ALG_ED25519), HksOpensslEd25519Verify);
133 #endif
134 #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY)
135 (void)RegisterAbility(HKS_CRYPTO_ABILITY_VERIFY(HKS_ALG_DSA), HksOpensslDsaVerify);
136 #endif
137 #if defined(HKS_SUPPORT_SM2_C) && defined(HKS_SUPPORT_SM2_SIGN_VERIFY)
138 (void)RegisterAbility(HKS_CRYPTO_ABILITY_VERIFY(HKS_ALG_SM2), HksOpensslSm2Verify);
139 #endif
140 }
141
RegisterAbilityEncrypt(void)142 static void RegisterAbilityEncrypt(void)
143 {
144 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT)
145 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT(HKS_ALG_RSA), HksOpensslRsaEncrypt);
146 #endif
147 #ifdef HKS_SUPPORT_AES_C
148 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT(HKS_ALG_AES), HksOpensslAesEncrypt);
149 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_INIT(HKS_ALG_AES),
150 HksOpensslAesEncryptInit);
151 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_UPDATE(HKS_ALG_AES),
152 HksOpensslAesEncryptUpdate);
153 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FINAL(HKS_ALG_AES),
154 HksOpensslAesEncryptFinal);
155 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FREE_CTX(HKS_ALG_AES),
156 HksOpensslAesHalFreeCtx);
157 #endif
158 #ifdef HKS_SUPPORT_SM4_C
159 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT(HKS_ALG_SM4), HksOpensslSm4Encrypt);
160 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_INIT(HKS_ALG_SM4),
161 HksOpensslSm4EncryptInit);
162 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_UPDATE(HKS_ALG_SM4),
163 HksOpensslSm4EncryptUpdate);
164 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FINAL(HKS_ALG_SM4),
165 HksOpensslSm4EncryptFinal);
166 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT_FREE_CTX(HKS_ALG_SM4),
167 HksOpensslSm4HalFreeCtx);
168 #endif
169 #ifdef HKS_SUPPORT_SM2_ENCRYPT_DECRYPT
170 (void)RegisterAbility(HKS_CRYPTO_ABILITY_ENCRYPT(HKS_ALG_SM2), HksOpensslSm2Encrypt);
171 #endif
172 }
173
RegisterAbilityDecrypt(void)174 static void RegisterAbilityDecrypt(void)
175 {
176 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT)
177 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT(HKS_ALG_RSA), HksOpensslRsaDecrypt);
178 #endif
179 #ifdef HKS_SUPPORT_AES_C
180 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT(HKS_ALG_AES), HksOpensslAesDecrypt);
181 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_INIT(HKS_ALG_AES),
182 HksOpensslAesDecryptInit);
183 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_UPDATE(HKS_ALG_AES),
184 HksOpensslAesDecryptUpdate);
185 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FINAL(HKS_ALG_AES),
186 HksOpensslAesDecryptFinal);
187 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FREE_CTX(HKS_ALG_AES),
188 HksOpensslAesHalFreeCtx);
189 #endif
190 #ifdef HKS_SUPPORT_SM4_C
191 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT(HKS_ALG_SM4), HksOpensslSm4Decrypt);
192 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_INIT(HKS_ALG_SM4),
193 HksOpensslSm4DecryptInit);
194 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_UPDATE(HKS_ALG_SM4),
195 HksOpensslSm4DecryptUpdate);
196 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FINAL(HKS_ALG_SM4),
197 HksOpensslSm4DecryptFinal);
198 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT_FREE_CTX(HKS_ALG_SM4),
199 HksOpensslSm4HalFreeCtx);
200 #endif
201 #ifdef HKS_SUPPORT_SM2_ENCRYPT_DECRYPT
202 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DECRYPT(HKS_ALG_SM2), HksOpensslSm2Decrypt);
203 #endif
204 }
205
RegisterAbilityAgree(void)206 static void RegisterAbilityAgree(void)
207 {
208 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) && defined(HKS_SUPPORT_ECDH_AGREE_KEY)
209 (void)RegisterAbility(HKS_CRYPTO_ABILITY_AGREE_KEY(HKS_ALG_ECDH), HksOpensslEcdhAgreeKey);
210 #endif
211 #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_AGREE_KEY)
212 (void)RegisterAbility(HKS_CRYPTO_ABILITY_AGREE_KEY(HKS_ALG_X25519), HksOpensslX25519AgreeKey);
213 #endif
214 #ifdef HKS_SUPPORT_ED25519_TO_X25519
215 (void)RegisterAbility(HKS_CRYPTO_ABILITY_AGREE_KEY(HKS_ALG_ED25519), HksOpensslEd25519AgreeKey);
216 #endif
217 #if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_AGREE_KEY)
218 (void)RegisterAbility(HKS_CRYPTO_ABILITY_AGREE_KEY(HKS_ALG_DH), HksOpensslDhAgreeKey);
219 #endif
220 }
221
RegisterAbilityDerive(void)222 static void RegisterAbilityDerive(void)
223 {
224 #ifdef HKS_SUPPORT_KDF_HKDF
225 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DERIVE_KEY(HKS_ALG_HKDF), HksOpensslHkdf);
226 #endif
227 #ifdef HKS_SUPPORT_KDF_PBKDF2
228 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DERIVE_KEY(HKS_ALG_PBKDF2), HksOpensslPbkdf2);
229 #endif
230 #ifdef HKS_SUPPORT_SM3_C
231 (void)RegisterAbility(HKS_CRYPTO_ABILITY_DERIVE_KEY(HKS_ALG_GMKDF), HksOpensslSmKdf);
232 #endif
233 }
234
RegisterAbilityHash(void)235 static void RegisterAbilityHash(void)
236 {
237 #ifdef HKS_SUPPORT_HASH_C
238 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH, HksOpensslHash);
239 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH_INIT, HksOpensslHashInit);
240 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH_UPDATE, HksOpensslHashUpdate);
241 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH_FINAL, HksOpensslHashFinal);
242 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HASH_FREE_CTX, HksOpensslHashFreeCtx);
243 #endif
244 }
245
RegisterAbilityHmac(void)246 static void RegisterAbilityHmac(void)
247 {
248 #ifdef HKS_SUPPORT_HMAC_C
249 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC, HksOpensslHmac);
250 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC_INIT, HksOpensslHmacInit);
251 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC_UPDATE, HksOpensslHmacUpdate);
252 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC_FINAL, HksOpensslHmacFinal);
253 (void)RegisterAbility(HKS_CRYPTO_ABILITY_HMAC_FREE_CTX, HksOpensslHmacHalFreeCtx);
254 #endif
255 }
256
RegisterAbilityFillRandom(void)257 static void RegisterAbilityFillRandom(void)
258 {
259 (void)RegisterAbility(HKS_CRYPTO_ABILITY_FILL_RANDOM, HksOpensslFillRandom);
260 (void)RegisterAbility(HKS_CRYPTO_ABILITY_FILL_PRI_RANDOM, HksOpensslFillPrivRandom);
261 }
262
RegisterAbilityBnExpMod(void)263 static void RegisterAbilityBnExpMod(void)
264 {
265 #ifdef HKS_SUPPORT_BN_C
266 (void)RegisterAbility(HKS_CRYPTO_ABILITY_BN_EXP_MOD, HksOpensslBnExpMod);
267 #endif
268 }
269
HksCryptoAbilityInitBase(void)270 int32_t HksCryptoAbilityInitBase(void)
271 {
272 RegisterAbilityGenerateKey();
273 RegisterAbilityGetPublicKey();
274 RegisterAbilitySign();
275 RegisterAbilityVerify();
276 RegisterAbilityEncrypt();
277 RegisterAbilityDecrypt();
278 RegisterAbilityAgree();
279 RegisterAbilityDerive();
280 RegisterAbilityHmac();
281 RegisterAbilityHash();
282 RegisterAbilityFillRandom();
283 RegisterAbilityBnExpMod();
284 return HKS_SUCCESS;
285 }