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