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