1 /*
2  * Copyright (C) 2022-2024 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 #include "openssl_adapter.h"
17 #include "openssl_adapter_mock.h"
18 #include <openssl/param_build.h>
19 
20 #include "log.h"
21 #include "result.h"
22 #include <stdbool.h>
23 
24 static uint32_t g_mockIndex = __INT32_MAX__;
25 static uint32_t g_callNum = 0;
26 static bool g_isRecordCallNum = false;
27 static bool g_isNeedSpecialMock = false;
28 static int g_double = 2;
29 
IsNeedMock(void)30 static bool IsNeedMock(void)
31 {
32     if (!g_isRecordCallNum) {
33         return false;
34     }
35     g_callNum++;
36     if (g_callNum == g_mockIndex) {
37         LOGD("mock malloc return NULL.");
38         return true;
39     }
40     return false;
41 }
42 
StartRecordOpensslCallNum(void)43 void StartRecordOpensslCallNum(void)
44 {
45     ResetOpensslCallNum();
46     g_isRecordCallNum = true;
47 }
48 
EndRecordOpensslCallNum(void)49 void EndRecordOpensslCallNum(void)
50 {
51     ResetOpensslCallNum();
52     g_isRecordCallNum = false;
53 }
54 
GetOpensslCallNum(void)55 uint32_t GetOpensslCallNum(void)
56 {
57     return g_callNum;
58 }
59 
ResetOpensslCallNum(void)60 void ResetOpensslCallNum(void)
61 {
62     g_callNum = 0;
63     g_mockIndex = __INT32_MAX__;
64 }
65 
SetOpensslCallMockIndex(uint32_t index)66 void SetOpensslCallMockIndex(uint32_t index)
67 {
68     g_mockIndex = index;
69 }
70 
OpensslBnDup(const BIGNUM * a)71 BIGNUM *OpensslBnDup(const BIGNUM *a)
72 {
73     if (IsNeedMock()) {
74         return NULL;
75     }
76     return BN_dup(a);
77 }
78 
OpensslBnClear(BIGNUM * a)79 void OpensslBnClear(BIGNUM *a)
80 {
81     BN_clear(a);
82 }
83 
OpensslBnClearFree(BIGNUM * a)84 void OpensslBnClearFree(BIGNUM *a)
85 {
86     if (a != NULL) {
87         BN_clear_free(a);
88     }
89 }
90 
OpensslBnFree(BIGNUM * a)91 void OpensslBnFree(BIGNUM *a)
92 {
93     if (a != NULL) {
94         BN_free(a);
95     }
96 }
97 
OpensslBnNew(void)98 BIGNUM *OpensslBnNew(void)
99 {
100     if (IsNeedMock()) {
101         return NULL;
102     }
103     return BN_new();
104 }
105 
OpensslBin2Bn(const unsigned char * s,int len,BIGNUM * ret)106 BIGNUM *OpensslBin2Bn(const unsigned char *s, int len, BIGNUM *ret)
107 {
108     if (IsNeedMock()) {
109         return NULL;
110     }
111     return BN_bin2bn(s, len, ret);
112 }
113 
OpensslLeBin2Bn(const unsigned char * s,int len,BIGNUM * ret)114 BIGNUM *OpensslLeBin2Bn(const unsigned char *s, int len, BIGNUM *ret)
115 {
116     if (IsNeedMock()) {
117         return NULL;
118     }
119     return BN_lebin2bn(s, len, ret);
120 }
121 
OpensslBn2BinPad(const BIGNUM * a,unsigned char * to,int toLen)122 int OpensslBn2BinPad(const BIGNUM *a, unsigned char *to, int toLen)
123 {
124     if (IsNeedMock()) {
125         return -1;
126     }
127     return BN_bn2binpad(a, to, toLen);
128 }
129 
OpensslBn2LeBinPad(const BIGNUM * a,unsigned char * to,int tolen)130 int OpensslBn2LeBinPad(const BIGNUM *a, unsigned char *to, int tolen)
131 {
132     if (IsNeedMock()) {
133         return -1;
134     }
135     return BN_bn2lebinpad(a, to, tolen);
136 }
137 
OpensslBnCtxNew(void)138 BN_CTX *OpensslBnCtxNew(void)
139 {
140     if (IsNeedMock()) {
141         return NULL;
142     }
143     return BN_CTX_new();
144 }
145 
OpensslBnCtxFree(BN_CTX * ctx)146 void OpensslBnCtxFree(BN_CTX *ctx)
147 {
148     if (ctx != NULL) {
149         BN_CTX_free(ctx);
150     }
151 }
152 
OpensslBnNumBytes(const BIGNUM * a)153 int OpensslBnNumBytes(const BIGNUM *a)
154 {
155     if (IsNeedMock()) {
156         return -1;
157     }
158     return BN_num_bytes(a);
159 }
160 
OpensslBnSetWord(BIGNUM * a,unsigned int w)161 int OpensslBnSetWord(BIGNUM *a, unsigned int w)
162 {
163     if (IsNeedMock()) {
164         return -1;
165     }
166     return BN_set_word(a, w);
167 }
168 
OpensslBnGetWord(const BIGNUM * a)169 unsigned int OpensslBnGetWord(const BIGNUM *a)
170 {
171     if (IsNeedMock()) {
172         return 0;
173     }
174     return BN_get_word(a);
175 }
176 
OpensslBnNumBits(const BIGNUM * a)177 int OpensslBnNumBits(const BIGNUM *a)
178 {
179     if (IsNeedMock()) {
180         return -1;
181     }
182     return BN_num_bits(a);
183 }
184 
OpensslHex2Bn(BIGNUM ** a,const char * str)185 int OpensslHex2Bn(BIGNUM **a, const char *str)
186 {
187     if (IsNeedMock()) {
188         return -1;
189     }
190     return BN_hex2bn(a, str);
191 }
192 
OpensslBnCmp(const BIGNUM * a,const BIGNUM * b)193 int OpensslBnCmp(const BIGNUM *a, const BIGNUM *b)
194 {
195     if (IsNeedMock()) {
196         return -1;
197     }
198     return BN_cmp(a, b);
199 }
200 
OpensslEcKeyNewByCurveName(int nid)201 EC_KEY *OpensslEcKeyNewByCurveName(int nid)
202 {
203     if (IsNeedMock()) {
204         return NULL;
205     }
206     return EC_KEY_new_by_curve_name(nid);
207 }
208 
OpensslEcPointDup(const EC_POINT * src,const EC_GROUP * group)209 EC_POINT *OpensslEcPointDup(const EC_POINT *src, const EC_GROUP *group)
210 {
211     if (IsNeedMock()) {
212         return NULL;
213     }
214     return EC_POINT_dup(src, group);
215 }
216 
OpensslEcKeyGenerateKey(EC_KEY * eckey)217 int OpensslEcKeyGenerateKey(EC_KEY *eckey)
218 {
219     if (IsNeedMock()) {
220         return -1;
221     }
222     return EC_KEY_generate_key(eckey);
223 }
224 
OpensslEcKeySetPublicKey(EC_KEY * key,const EC_POINT * pub)225 int OpensslEcKeySetPublicKey(EC_KEY *key, const EC_POINT *pub)
226 {
227     if (IsNeedMock()) {
228         return -1;
229     }
230     return EC_KEY_set_public_key(key, pub);
231 }
232 
OpensslEcKeySetPrivateKey(EC_KEY * key,const BIGNUM * privKey)233 int OpensslEcKeySetPrivateKey(EC_KEY *key, const BIGNUM *privKey)
234 {
235     if (IsNeedMock()) {
236         return -1;
237     }
238     return EC_KEY_set_private_key(key, privKey);
239 }
240 
OpensslEcKeyCheckKey(const EC_KEY * key)241 int OpensslEcKeyCheckKey(const EC_KEY *key)
242 {
243     if (IsNeedMock()) {
244         return -1;
245     }
246     return EC_KEY_check_key(key);
247 }
248 
OpensslEcKeyGet0PublicKey(const EC_KEY * key)249 const EC_POINT *OpensslEcKeyGet0PublicKey(const EC_KEY *key)
250 {
251     if (IsNeedMock()) {
252         return NULL;
253     }
254     return EC_KEY_get0_public_key(key);
255 }
256 
OpensslEcKeyGet0PrivateKey(const EC_KEY * key)257 const BIGNUM *OpensslEcKeyGet0PrivateKey(const EC_KEY *key)
258 {
259     if (IsNeedMock()) {
260         return NULL;
261     }
262     return EC_KEY_get0_private_key(key);
263 }
264 
OpensslEcKeyGet0Group(const EC_KEY * key)265 const EC_GROUP *OpensslEcKeyGet0Group(const EC_KEY *key)
266 {
267     if (IsNeedMock()) {
268         return NULL;
269     }
270     return EC_KEY_get0_group(key);
271 }
272 
OpensslEcGroupDup(const EC_GROUP * a)273 EC_GROUP *OpensslEcGroupDup(const EC_GROUP *a)
274 {
275     if (IsNeedMock()) {
276         return NULL;
277     }
278     return EC_GROUP_dup(a);
279 }
280 
OpensslEcGroupFree(EC_GROUP * group)281 void OpensslEcGroupFree(EC_GROUP *group)
282 {
283     if (group != NULL) {
284         EC_GROUP_free(group);
285     }
286 }
287 
OpensslEcKeyNew(void)288 EC_KEY *OpensslEcKeyNew(void)
289 {
290     if (IsNeedMock()) {
291         return NULL;
292     }
293     return EC_KEY_new();
294 }
295 
OpensslEcKeyDup(const EC_KEY * ecKey)296 EC_KEY *OpensslEcKeyDup(const EC_KEY *ecKey)
297 {
298     if (IsNeedMock()) {
299         return NULL;
300     }
301     return EC_KEY_dup(ecKey);
302 }
303 
OpensslEcKeySetGroup(EC_KEY * key,const EC_GROUP * group)304 int OpensslEcKeySetGroup(EC_KEY *key, const EC_GROUP *group)
305 {
306     if (IsNeedMock()) {
307         return -1;
308     }
309     return EC_KEY_set_group(key, group);
310 }
311 
OpensslEcPointGetAffineCoordinatesGfp(const EC_GROUP * group,const EC_POINT * point,BIGNUM * x,BIGNUM * y,BN_CTX * ctx)312 int OpensslEcPointGetAffineCoordinatesGfp(const EC_GROUP *group, const EC_POINT *point, BIGNUM *x,
313     BIGNUM *y, BN_CTX *ctx)
314 {
315     if (IsNeedMock()) {
316         return -1;
317     }
318     return EC_POINT_get_affine_coordinates_GFp(group, point, x, y, ctx);
319 }
320 
OpensslEcGroupGetDegree(const EC_GROUP * group)321 int OpensslEcGroupGetDegree(const EC_GROUP *group)
322 {
323     if (IsNeedMock()) {
324         return -1;
325     }
326     return EC_GROUP_get_degree(group);
327 }
328 
OpensslEcGroupGetCurveGfp(const EC_GROUP * group,BIGNUM * p,BIGNUM * a,BIGNUM * b,BN_CTX * ctx)329 int OpensslEcGroupGetCurveGfp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
330 {
331     if (IsNeedMock()) {
332         return -1;
333     }
334     return EC_GROUP_get_curve_GFp(group, p, a, b, ctx);
335 }
336 
OpensslEcGroupGet0Generator(const EC_GROUP * group)337 const EC_POINT *OpensslEcGroupGet0Generator(const EC_GROUP *group)
338 {
339     if (IsNeedMock()) {
340         return NULL;
341     }
342     return EC_GROUP_get0_generator(group);
343 }
344 
OpensslEcGroupGetOrder(const EC_GROUP * group,BIGNUM * order,BN_CTX * ctx)345 int OpensslEcGroupGetOrder(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
346 {
347     if (IsNeedMock()) {
348         return -1;
349     }
350     return EC_GROUP_get_order(group, order, ctx);
351 }
352 
OpensslEcGroupGetCofactor(const EC_GROUP * group,BIGNUM * cofactor,BN_CTX * ctx)353 int OpensslEcGroupGetCofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
354 {
355     if (IsNeedMock()) {
356         return -1;
357     }
358     return EC_GROUP_get_cofactor(group, cofactor, ctx);
359 }
360 
OpensslEcGroupNewCurveGfp(const BIGNUM * p,const BIGNUM * a,const BIGNUM * b,BN_CTX * ctx)361 EC_GROUP *OpensslEcGroupNewCurveGfp(const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
362 {
363     if (IsNeedMock()) {
364         return NULL;
365     }
366     return EC_GROUP_new_curve_GFp(p, a, b, ctx);
367 }
368 
OpensslEcPointNew(const EC_GROUP * group)369 EC_POINT *OpensslEcPointNew(const EC_GROUP *group)
370 {
371     if (IsNeedMock()) {
372         return NULL;
373     }
374     return EC_POINT_new(group);
375 }
376 
OpensslEcPointCopy(EC_POINT * dst,const EC_POINT * src)377 int OpensslEcPointCopy(EC_POINT *dst, const EC_POINT *src)
378 {
379     if (IsNeedMock()) {
380         return 0;
381     }
382     return EC_POINT_copy(dst, src);
383 }
384 
OpensslEcPointSetAffineCoordinatesGfp(const EC_GROUP * group,EC_POINT * point,const BIGNUM * x,const BIGNUM * y,BN_CTX * ctx)385 int OpensslEcPointSetAffineCoordinatesGfp(const EC_GROUP *group, EC_POINT *point, const BIGNUM *x,
386     const BIGNUM *y, BN_CTX *ctx)
387 {
388     if (IsNeedMock()) {
389         return -1;
390     }
391     return EC_POINT_set_affine_coordinates_GFp(group, point, x, y, ctx);
392 }
393 
OpensslEcGroupSetGenerator(EC_GROUP * group,const EC_POINT * generator,const BIGNUM * order,const BIGNUM * cofactor)394 int OpensslEcGroupSetGenerator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order,
395     const BIGNUM *cofactor)
396 {
397     if (IsNeedMock()) {
398         return -1;
399     }
400     return EC_GROUP_set_generator(group, generator, order, cofactor);
401 }
402 
OpensslEcGroupSetCurveName(EC_GROUP * group,int nid)403 void OpensslEcGroupSetCurveName(EC_GROUP *group, int nid)
404 {
405     if (IsNeedMock()) {
406         return;
407     }
408     EC_GROUP_set_curve_name(group, nid);
409 }
410 
OpensslEcGroupGetCurveName(const EC_GROUP * group)411 int OpensslEcGroupGetCurveName(const EC_GROUP *group)
412 {
413     if (IsNeedMock()) {
414         return 0;
415     }
416     return EC_GROUP_get_curve_name(group);
417 }
418 
OpensslEcPointMul(const EC_GROUP * group,EC_POINT * r,const BIGNUM * gScalar,const EC_POINT * point,const BIGNUM * pScalar,BN_CTX * ctx)419 int OpensslEcPointMul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *gScalar, const EC_POINT *point,
420     const BIGNUM *pScalar, BN_CTX *ctx)
421 {
422     if (IsNeedMock()) {
423         return -1;
424     }
425     return EC_POINT_mul(group, r, gScalar, point, pScalar, ctx);
426 }
427 
OpensslI2dEcPubKey(EC_KEY * a,unsigned char ** pp)428 int OpensslI2dEcPubKey(EC_KEY *a, unsigned char **pp)
429 {
430     if (IsNeedMock()) {
431         return -1;
432     }
433     return i2d_EC_PUBKEY(a, pp);
434 }
435 
OpensslI2dEcPrivateKey(EC_KEY * key,unsigned char ** out)436 int OpensslI2dEcPrivateKey(EC_KEY *key, unsigned char **out)
437 {
438     if (IsNeedMock()) {
439         return -1;
440     }
441     return i2d_ECPrivateKey(key, out);
442 }
443 
OpensslD2iEcPubKey(EC_KEY ** a,const unsigned char ** pp,long length)444 EC_KEY *OpensslD2iEcPubKey(EC_KEY **a, const unsigned char **pp, long length)
445 {
446     if (IsNeedMock()) {
447         return NULL;
448     }
449     return d2i_EC_PUBKEY(a, pp, length);
450 }
451 
OpensslD2iEcPrivateKey(EC_KEY ** key,const unsigned char ** in,long len)452 EC_KEY *OpensslD2iEcPrivateKey(EC_KEY **key, const unsigned char **in, long len)
453 {
454     if (IsNeedMock()) {
455         return NULL;
456     }
457     return d2i_ECPrivateKey(key, in, len);
458 }
459 
OpensslEcKeySetAsn1Flag(EC_KEY * key,int flag)460 void OpensslEcKeySetAsn1Flag(EC_KEY *key, int flag)
461 {
462     EC_KEY_set_asn1_flag(key, flag);
463 }
464 
OpensslEcKeySetEncFlags(EC_KEY * eckey,unsigned int flags)465 void OpensslEcKeySetEncFlags(EC_KEY *eckey, unsigned int flags)
466 {
467     EC_KEY_set_enc_flags(eckey, flags);
468 }
469 
OpensslEcKeyFree(EC_KEY * key)470 void OpensslEcKeyFree(EC_KEY *key)
471 {
472     if (key != NULL) {
473         EC_KEY_free(key);
474     }
475 }
476 
OpensslEcPointFree(EC_POINT * point)477 void OpensslEcPointFree(EC_POINT *point)
478 {
479     if (point != NULL) {
480         EC_POINT_free(point);
481     }
482 }
483 
OpensslEvpMdCtxNew(void)484 EVP_MD_CTX *OpensslEvpMdCtxNew(void)
485 {
486     if (IsNeedMock()) {
487         return NULL;
488     }
489     return EVP_MD_CTX_new();
490 }
491 
OpensslEvpMdCtxGetPkeyCtx(EVP_MD_CTX * ctx)492 EVP_PKEY_CTX *OpensslEvpMdCtxGetPkeyCtx(EVP_MD_CTX *ctx)
493 {
494     if (IsNeedMock()) {
495         return NULL;
496     }
497     return EVP_MD_CTX_get_pkey_ctx(ctx);
498 }
499 
OpensslEvpMdCtxFree(EVP_MD_CTX * ctx)500 void OpensslEvpMdCtxFree(EVP_MD_CTX *ctx)
501 {
502     if (ctx != NULL) {
503         EVP_MD_CTX_free(ctx);
504     }
505 }
506 
OpensslEvpDigestSignInit(EVP_MD_CTX * ctx,EVP_PKEY_CTX ** pctx,const EVP_MD * type,ENGINE * e,EVP_PKEY * pkey)507 int OpensslEvpDigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey)
508 {
509     if (IsNeedMock()) {
510         return -1;
511     }
512     return EVP_DigestSignInit(ctx, pctx, type, e, pkey);
513 }
514 
OpensslEvpDigestSignUpdate(EVP_MD_CTX * ctx,const void * data,size_t count)515 int OpensslEvpDigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)
516 {
517     if (IsNeedMock()) {
518         return -1;
519     }
520     return EVP_DigestSignUpdate(ctx, data, count);
521 }
522 
OpensslEvpDigestSignFinal(EVP_MD_CTX * ctx,unsigned char * sigret,size_t * siglen)523 int OpensslEvpDigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen)
524 {
525     if (sigret != NULL && g_isNeedSpecialMock) {
526         g_callNum++;
527     }
528     if (IsNeedMock()) {
529         if (sigret == NULL) {
530             return -1;
531         }
532         if (g_isNeedSpecialMock) {
533             int res = EVP_DigestSignFinal(ctx, sigret, siglen);
534             *siglen = *siglen * g_double;
535             g_isNeedSpecialMock = false;
536             return res;
537         }
538         g_isNeedSpecialMock = true;
539         return -1;
540     }
541     if (sigret != NULL) {
542         g_callNum++;
543     }
544     return EVP_DigestSignFinal(ctx, sigret, siglen);
545 }
546 
OpensslEvpDigestSign(EVP_MD_CTX * ctx,unsigned char * sig,size_t * siglen,const unsigned char * tbs,size_t tbslen)547 int OpensslEvpDigestSign(EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen, const unsigned char *tbs, size_t tbslen)
548 {
549     if (sig != NULL && g_isNeedSpecialMock) {
550         g_callNum++;
551     }
552     if (IsNeedMock()) {
553         if (sig == NULL) {
554             return -1;
555         }
556         if (g_isNeedSpecialMock) {
557             int res = EVP_DigestSign(ctx, sig, siglen, tbs, tbslen);
558             *siglen = *siglen * g_double;
559             g_isNeedSpecialMock = false;
560             return res;
561         }
562         g_isNeedSpecialMock = true;
563         return -1;
564     }
565     if (sig != NULL) {
566         g_callNum++;
567     }
568     return EVP_DigestSign(ctx, sig, siglen, tbs, tbslen);
569 }
570 
OpensslEvpDigestVerifyInit(EVP_MD_CTX * ctx,EVP_PKEY_CTX ** pctx,const EVP_MD * type,ENGINE * e,EVP_PKEY * pkey)571 int OpensslEvpDigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey)
572 {
573     if (IsNeedMock()) {
574         return -1;
575     }
576     return EVP_DigestVerifyInit(ctx, pctx, type, e, pkey);
577 }
578 
OpensslEvpDigestVerifyUpdate(EVP_MD_CTX * ctx,const void * data,size_t count)579 int OpensslEvpDigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)
580 {
581     if (IsNeedMock()) {
582         return -1;
583     }
584     return EVP_DigestVerifyUpdate(ctx, data, count);
585 }
586 
OpensslEvpDigestVerifyFinal(EVP_MD_CTX * ctx,const unsigned char * sig,size_t siglen)587 int OpensslEvpDigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, size_t siglen)
588 {
589     if (IsNeedMock()) {
590         return -1;
591     }
592     return EVP_DigestVerifyFinal(ctx, sig, siglen);
593 }
594 
OpensslEvpDigestVerify(EVP_MD_CTX * ctx,unsigned char * sig,size_t siglen,const unsigned char * tbs,size_t tbslen)595 int OpensslEvpDigestVerify(EVP_MD_CTX *ctx, unsigned char *sig, size_t siglen,
596     const unsigned char *tbs, size_t tbslen)
597 {
598     if (IsNeedMock()) {
599         return -1;
600     }
601     return EVP_DigestVerify(ctx, sig, siglen, tbs, tbslen);
602 }
603 
OpensslEvpPkeySignInit(EVP_PKEY_CTX * ctx)604 int OpensslEvpPkeySignInit(EVP_PKEY_CTX *ctx)
605 {
606     if (IsNeedMock()) {
607         return -1;
608     }
609     return EVP_PKEY_sign_init(ctx);
610 }
611 
OpensslEvpPkeySign(EVP_PKEY_CTX * ctx,unsigned char * sig,size_t * siglen,const unsigned char * tbs,size_t tbslen)612 int OpensslEvpPkeySign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen, const unsigned char *tbs,
613     size_t tbslen)
614 {
615     if (IsNeedMock()) {
616         return -1;
617     }
618     return EVP_PKEY_sign(ctx, sig, siglen, tbs, tbslen);
619 }
620 
OpensslEvpPkeyVerifyInit(EVP_PKEY_CTX * ctx)621 int OpensslEvpPkeyVerifyInit(EVP_PKEY_CTX *ctx)
622 {
623     if (IsNeedMock()) {
624         return -1;
625     }
626     return EVP_PKEY_verify_init(ctx);
627 }
628 
OpensslEvpPkeyVerify(EVP_PKEY_CTX * ctx,const unsigned char * sig,size_t siglen,const unsigned char * tbs,size_t tbslen)629 int OpensslEvpPkeyVerify(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen, const unsigned char *tbs,
630     size_t tbslen)
631 {
632     if (IsNeedMock()) {
633         return -1;
634     }
635     return EVP_PKEY_verify(ctx, sig, siglen, tbs, tbslen);
636 }
637 
OpensslEvpPkeyCtxNewFromPkey(OSSL_LIB_CTX * libctx,EVP_PKEY * pkey,const char * propquery)638 EVP_PKEY_CTX *OpensslEvpPkeyCtxNewFromPkey(OSSL_LIB_CTX *libctx,
639     EVP_PKEY *pkey, const char *propquery)
640 {
641     if (IsNeedMock()) {
642         return NULL;
643     }
644     return EVP_PKEY_CTX_new_from_pkey(libctx, pkey, propquery);
645 }
646 
OpensslEvpPkeyNew(void)647 EVP_PKEY *OpensslEvpPkeyNew(void)
648 {
649     if (IsNeedMock()) {
650         return NULL;
651     }
652     return EVP_PKEY_new();
653 }
654 
OpensslEvpPkeyNewRawPublicKey(int type,ENGINE * e,const unsigned char * pub,size_t len)655 EVP_PKEY *OpensslEvpPkeyNewRawPublicKey(int type, ENGINE *e, const unsigned char *pub, size_t len)
656 {
657     if (IsNeedMock()) {
658         return NULL;
659     }
660     return EVP_PKEY_new_raw_public_key(type, e, pub, len);
661 }
662 
OpensslEvpPkeyNewRawPrivateKey(int type,ENGINE * e,const unsigned char * pub,size_t len)663 EVP_PKEY *OpensslEvpPkeyNewRawPrivateKey(int type, ENGINE *e, const unsigned char *pub, size_t len)
664 {
665     if (IsNeedMock()) {
666         return NULL;
667     }
668     return EVP_PKEY_new_raw_private_key(type, e, pub, len);
669 }
670 
OpensslEvpPkeyGetRawPublicKey(const EVP_PKEY * pkey,unsigned char * pub,size_t * len)671 int OpensslEvpPkeyGetRawPublicKey(const EVP_PKEY *pkey, unsigned char *pub, size_t *len)
672 {
673     if (IsNeedMock()) {
674         return -1;
675     }
676     return EVP_PKEY_get_raw_public_key(pkey, pub, len);
677 }
678 
OpensslEvpPkeyGetRawPrivateKey(const EVP_PKEY * pkey,unsigned char * priv,size_t * len)679 int OpensslEvpPkeyGetRawPrivateKey(const EVP_PKEY *pkey, unsigned char *priv, size_t *len)
680 {
681     if (IsNeedMock()) {
682         return -1;
683     }
684     return EVP_PKEY_get_raw_private_key(pkey, priv, len);
685 }
686 
OpensslEvpPkeyAssignEcKey(EVP_PKEY * pkey,EC_KEY * key)687 int OpensslEvpPkeyAssignEcKey(EVP_PKEY *pkey, EC_KEY *key)
688 {
689     if (IsNeedMock()) {
690         return -1;
691     }
692     return EVP_PKEY_assign_EC_KEY(pkey, key);
693 }
694 
OpensslEvpPkeyFree(EVP_PKEY * pkey)695 void OpensslEvpPkeyFree(EVP_PKEY *pkey)
696 {
697     if (pkey != NULL) {
698         EVP_PKEY_free(pkey);
699     }
700 }
701 
OpensslEvpPkeyCtxNew(EVP_PKEY * pkey,ENGINE * e)702 EVP_PKEY_CTX *OpensslEvpPkeyCtxNew(EVP_PKEY *pkey, ENGINE *e)
703 {
704     if (IsNeedMock()) {
705         return NULL;
706     }
707     return EVP_PKEY_CTX_new(pkey, e);
708 }
709 
OpensslEvpPkeyDeriveInit(EVP_PKEY_CTX * ctx)710 int OpensslEvpPkeyDeriveInit(EVP_PKEY_CTX *ctx)
711 {
712     if (IsNeedMock()) {
713         return -1;
714     }
715     return EVP_PKEY_derive_init(ctx);
716 }
717 
OpensslEvpPkeyCtxSet1Id(EVP_PKEY_CTX * ctx,const void * id,int idLen)718 int OpensslEvpPkeyCtxSet1Id(EVP_PKEY_CTX *ctx, const void *id, int idLen)
719 {
720     if (id != NULL && g_isNeedSpecialMock) {
721         g_callNum++;
722     }
723     if (IsNeedMock()) {
724         if (id == NULL) {
725             return -1;
726         }
727         if (g_isNeedSpecialMock) {
728             int res = EVP_PKEY_CTX_set1_id(ctx, id, idLen);
729             g_isNeedSpecialMock = false;
730             return res;
731         }
732         g_isNeedSpecialMock = true;
733         return -1;
734     }
735     if (id  != NULL) {
736         g_callNum++;
737     }
738     return EVP_PKEY_CTX_set1_id(ctx, id, idLen);
739 }
740 
OpensslEvpPkeyDeriveSetPeer(EVP_PKEY_CTX * ctx,EVP_PKEY * peer)741 int OpensslEvpPkeyDeriveSetPeer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
742 {
743     if (IsNeedMock()) {
744         return -1;
745     }
746     return EVP_PKEY_derive_set_peer(ctx, peer);
747 }
748 
OpensslEvpPkeyDerive(EVP_PKEY_CTX * ctx,unsigned char * key,size_t * keylen)749 int OpensslEvpPkeyDerive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
750 {
751     if (key != NULL && g_isNeedSpecialMock) {
752         g_callNum++;
753     }
754     if (IsNeedMock()) {
755         if (key == NULL) {
756             return -1;
757         }
758         if (g_isNeedSpecialMock) {
759             int res = EVP_PKEY_derive(ctx, key, keylen);
760             *keylen = *keylen * g_double;
761             g_isNeedSpecialMock = false;
762             return res;
763         }
764         g_isNeedSpecialMock = true;
765         return -1;
766     }
767     if (key != NULL) {
768         g_callNum++;
769     }
770     return EVP_PKEY_derive(ctx, key, keylen);
771 }
772 
OpensslEvpPkeyEncrypt(EVP_PKEY_CTX * ctx,unsigned char * out,size_t * outlen,const unsigned char * in,size_t inlen)773 int OpensslEvpPkeyEncrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
774     const unsigned char *in, size_t inlen)
775 {
776     return EVP_PKEY_encrypt(ctx, out, outlen, in, inlen);
777 }
778 
OpensslEvpPkeyDecrypt(EVP_PKEY_CTX * ctx,unsigned char * out,size_t * outlen,const unsigned char * in,size_t inlen)779 int OpensslEvpPkeyDecrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
780     const unsigned char *in, size_t inlen)
781 {
782     return EVP_PKEY_decrypt(ctx, out, outlen, in, inlen);
783 }
784 
OpensslEvpPkeyEncryptInit(EVP_PKEY_CTX * ctx)785 int OpensslEvpPkeyEncryptInit(EVP_PKEY_CTX *ctx)
786 {
787     return EVP_PKEY_encrypt_init(ctx);
788 }
789 
OpensslEvpPkeyDecryptInit(EVP_PKEY_CTX * ctx)790 int OpensslEvpPkeyDecryptInit(EVP_PKEY_CTX *ctx)
791 {
792     return EVP_PKEY_decrypt_init(ctx);
793 }
794 
OpensslEvpPkeyCtxFree(EVP_PKEY_CTX * ctx)795 void OpensslEvpPkeyCtxFree(EVP_PKEY_CTX *ctx)
796 {
797     if (ctx != NULL) {
798         EVP_PKEY_CTX_free(ctx);
799     }
800 }
801 
OpensslEvpPkeyCtxNewId(int id,ENGINE * e)802 EVP_PKEY_CTX *OpensslEvpPkeyCtxNewId(int id, ENGINE *e)
803 {
804     if (IsNeedMock()) {
805         return NULL;
806     }
807     return EVP_PKEY_CTX_new_id(id, e);
808 }
809 
OpensslEvpPkeyBaseId(EVP_PKEY * pkey)810 int OpensslEvpPkeyBaseId(EVP_PKEY *pkey)
811 {
812     return EVP_PKEY_base_id(pkey);
813 }
814 
OpensslEvpPkeyCtxNewFromName(OSSL_LIB_CTX * libctx,const char * name,const char * propquery)815 EVP_PKEY_CTX *OpensslEvpPkeyCtxNewFromName(OSSL_LIB_CTX *libctx, const char *name, const char *propquery)
816 {
817     if (IsNeedMock()) {
818         return NULL;
819     }
820     return EVP_PKEY_CTX_new_from_name(libctx, name, propquery);
821 }
822 
OpensslOsslParamConstructUtf8String(const char * key,char * buf,size_t bsize)823 OSSL_PARAM OpensslOsslParamConstructUtf8String(const char *key, char *buf, size_t bsize)
824 {
825     return OSSL_PARAM_construct_utf8_string(key, buf, bsize);
826 }
827 
OpensslOsslParamConstructEnd(void)828 OSSL_PARAM OpensslOsslParamConstructEnd(void)
829 {
830     return OSSL_PARAM_construct_end();
831 }
832 
OpensslEvpPkeyGenerate(EVP_PKEY_CTX * ctx,EVP_PKEY ** ppkey)833 int OpensslEvpPkeyGenerate(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
834 {
835     if (IsNeedMock()) {
836         return -1;
837     }
838     return EVP_PKEY_generate(ctx, ppkey);
839 }
840 
OpensslOsslParamConstructUint(const char * key,unsigned int * buf)841 OSSL_PARAM OpensslOsslParamConstructUint(const char *key, unsigned int *buf)
842 {
843     return OSSL_PARAM_construct_uint(key, buf);
844 }
845 
OpensslOsslParamConstructInt(const char * key,int * buf)846 OSSL_PARAM OpensslOsslParamConstructInt(const char *key, int *buf)
847 {
848     return OSSL_PARAM_construct_int(key, buf);
849 }
850 
OpensslEvpPkeyParamGenInit(EVP_PKEY_CTX * ctx)851 int OpensslEvpPkeyParamGenInit(EVP_PKEY_CTX *ctx)
852 {
853     if (IsNeedMock()) {
854         return -1;
855     }
856     return EVP_PKEY_paramgen_init(ctx);
857 }
858 
OpensslEvpPkeyCtxSetDsaParamgenBits(EVP_PKEY_CTX * ctx,int nbits)859 int OpensslEvpPkeyCtxSetDsaParamgenBits(EVP_PKEY_CTX *ctx, int nbits)
860 {
861     if (IsNeedMock()) {
862         return -1;
863     }
864     return EVP_PKEY_CTX_set_dsa_paramgen_bits(ctx, nbits);
865 }
866 
OpensslEvpPkeyCtxSetParams(EVP_PKEY_CTX * ctx,const OSSL_PARAM * params)867 int OpensslEvpPkeyCtxSetParams(EVP_PKEY_CTX *ctx, const OSSL_PARAM *params)
868 {
869     if (IsNeedMock()) {
870         return -1;
871     }
872     return EVP_PKEY_CTX_set_params(ctx, params);
873 }
874 
OpensslEvpPkeyParamGen(EVP_PKEY_CTX * ctx,EVP_PKEY ** ppkey)875 int OpensslEvpPkeyParamGen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
876 {
877     if (IsNeedMock()) {
878         return -1;
879     }
880     return EVP_PKEY_paramgen(ctx, ppkey);
881 }
882 
OpensslEvpPkeyKeyGenInit(EVP_PKEY_CTX * ctx)883 int OpensslEvpPkeyKeyGenInit(EVP_PKEY_CTX *ctx)
884 {
885     if (IsNeedMock()) {
886         return -1;
887     }
888     return EVP_PKEY_keygen_init(ctx);
889 }
890 
OpensslEvpPkeyKeyGen(EVP_PKEY_CTX * ctx,EVP_PKEY ** ppkey)891 int OpensslEvpPkeyKeyGen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
892 {
893     if (IsNeedMock()) {
894         return -1;
895     }
896     return EVP_PKEY_keygen(ctx, ppkey);
897 }
898 
OpensslEvpPkeySet1Dsa(EVP_PKEY * pkey,DSA * key)899 int OpensslEvpPkeySet1Dsa(EVP_PKEY *pkey, DSA *key)
900 {
901     if (IsNeedMock()) {
902         return -1;
903     }
904     return EVP_PKEY_set1_DSA(pkey, key);
905 }
906 
OpensslEvpPkeyGet1Dsa(EVP_PKEY * pkey)907 DSA *OpensslEvpPkeyGet1Dsa(EVP_PKEY *pkey)
908 {
909     if (IsNeedMock()) {
910         return NULL;
911     }
912     return EVP_PKEY_get1_DSA(pkey);
913 }
914 
OpensslDsaNew(void)915 DSA *OpensslDsaNew(void)
916 {
917     if (IsNeedMock()) {
918         return NULL;
919     }
920     return DSA_new();
921 }
922 
OpensslDsaFree(DSA * dsa)923 void OpensslDsaFree(DSA *dsa)
924 {
925     if (dsa != NULL) {
926         DSA_free(dsa);
927     }
928 }
929 
OpensslDsaUpRef(DSA * dsa)930 int OpensslDsaUpRef(DSA *dsa)
931 {
932     if (IsNeedMock()) {
933         return -1;
934     }
935     return DSA_up_ref(dsa);
936 }
937 
OpensslDsaSet0Pqg(DSA * dsa,BIGNUM * p,BIGNUM * q,BIGNUM * g)938 int OpensslDsaSet0Pqg(DSA *dsa, BIGNUM *p, BIGNUM *q, BIGNUM *g)
939 {
940     if (IsNeedMock()) {
941         return -1;
942     }
943     return DSA_set0_pqg(dsa, p, q, g);
944 }
945 
OpensslDsaSet0Key(DSA * dsa,BIGNUM * pubKey,BIGNUM * priKey)946 int OpensslDsaSet0Key(DSA *dsa, BIGNUM *pubKey, BIGNUM *priKey)
947 {
948     if (IsNeedMock()) {
949         return -1;
950     }
951     return DSA_set0_key(dsa, pubKey, priKey);
952 }
953 
OpensslDsaGet0P(const DSA * dsa)954 const BIGNUM *OpensslDsaGet0P(const DSA *dsa)
955 {
956     if (IsNeedMock()) {
957         return NULL;
958     }
959     return DSA_get0_p(dsa);
960 }
961 
OpensslDsaGet0Q(const DSA * dsa)962 const BIGNUM *OpensslDsaGet0Q(const DSA *dsa)
963 {
964     if (IsNeedMock()) {
965         return NULL;
966     }
967     return DSA_get0_q(dsa);
968 }
969 
OpensslDsaGet0G(const DSA * dsa)970 const BIGNUM *OpensslDsaGet0G(const DSA *dsa)
971 {
972     if (IsNeedMock()) {
973         return NULL;
974     }
975     return DSA_get0_g(dsa);
976 }
977 
OpensslDsaGet0PubKey(const DSA * dsa)978 const BIGNUM *OpensslDsaGet0PubKey(const DSA *dsa)
979 {
980     if (IsNeedMock()) {
981         return NULL;
982     }
983     return DSA_get0_pub_key(dsa);
984 }
985 
OpensslDsaGet0PrivKey(const DSA * dsa)986 const BIGNUM *OpensslDsaGet0PrivKey(const DSA *dsa)
987 {
988     if (IsNeedMock()) {
989         return NULL;
990     }
991     return DSA_get0_priv_key(dsa);
992 }
993 
OpensslDsaGenerateKey(DSA * a)994 int OpensslDsaGenerateKey(DSA *a)
995 {
996     if (IsNeedMock()) {
997         return -1;
998     }
999     return DSA_generate_key(a);
1000 }
1001 
OpensslD2iDsaPubKey(DSA ** dsa,const unsigned char ** ppin,long length)1002 DSA *OpensslD2iDsaPubKey(DSA **dsa, const unsigned char **ppin, long length)
1003 {
1004     if (IsNeedMock()) {
1005         return NULL;
1006     }
1007     return d2i_DSA_PUBKEY(dsa, ppin, length);
1008 }
1009 
OpensslD2iDsaPrivateKey(DSA ** dsa,const unsigned char ** ppin,long length)1010 DSA *OpensslD2iDsaPrivateKey(DSA **dsa, const unsigned char **ppin, long length)
1011 {
1012     if (IsNeedMock()) {
1013         return NULL;
1014     }
1015     return d2i_DSAPrivateKey(dsa, ppin, length);
1016 }
1017 
OpensslI2dDsaPubkey(DSA * dsa,unsigned char ** ppout)1018 int OpensslI2dDsaPubkey(DSA *dsa, unsigned char **ppout)
1019 {
1020     if (IsNeedMock()) {
1021         return -1;
1022     }
1023     return i2d_DSA_PUBKEY(dsa, ppout);
1024 }
1025 
OpensslI2dDsaPrivateKey(DSA * dsa,unsigned char ** ppout)1026 int OpensslI2dDsaPrivateKey(DSA *dsa, unsigned char **ppout)
1027 {
1028     if (IsNeedMock()) {
1029         return -1;
1030     }
1031     return i2d_DSAPrivateKey(dsa, ppout);
1032 }
1033 
OpensslEvpPkeyCheck(EVP_PKEY_CTX * ctx)1034 int OpensslEvpPkeyCheck(EVP_PKEY_CTX *ctx)
1035 {
1036     if (IsNeedMock()) {
1037         return -1;
1038     }
1039     return EVP_PKEY_check(ctx);
1040 }
1041 
OpensslEvpPkeyDup(EVP_PKEY * a)1042 EVP_PKEY *OpensslEvpPkeyDup(EVP_PKEY *a)
1043 {
1044     if (IsNeedMock()) {
1045         return NULL;
1046     }
1047     return EVP_PKEY_dup(a);
1048 }
1049 
OpensslD2iPubKey(EVP_PKEY ** a,const unsigned char ** pp,long length)1050 EVP_PKEY *OpensslD2iPubKey(EVP_PKEY **a, const unsigned char **pp, long length)
1051 {
1052     if (IsNeedMock()) {
1053         return NULL;
1054     }
1055     return d2i_PUBKEY(a, pp, length);
1056 }
1057 
OpensslD2iPrivateKey(int type,EVP_PKEY ** a,const unsigned char ** pp,long length)1058 EVP_PKEY *OpensslD2iPrivateKey(int type, EVP_PKEY **a, const unsigned char **pp, long length)
1059 {
1060     if (IsNeedMock()) {
1061         return NULL;
1062     }
1063     return d2i_PrivateKey(type, a, pp, length);
1064 }
1065 
OpensslI2dPubKey(EVP_PKEY * pkey,unsigned char ** ppout)1066 int OpensslI2dPubKey(EVP_PKEY *pkey, unsigned char **ppout)
1067 {
1068     if (IsNeedMock()) {
1069         return -1;
1070     }
1071     return i2d_PUBKEY(pkey, ppout);
1072 }
1073 
OpensslI2dPrivateKey(EVP_PKEY * pkey,unsigned char ** ppout)1074 int OpensslI2dPrivateKey(EVP_PKEY *pkey, unsigned char **ppout)
1075 {
1076     if (IsNeedMock()) {
1077         return -1;
1078     }
1079     return i2d_PrivateKey(pkey, ppout);
1080 }
1081 
OpensslRsaNew(void)1082 RSA *OpensslRsaNew(void)
1083 {
1084     return RSA_new();
1085 }
1086 
OpensslRsaFree(RSA * rsa)1087 void OpensslRsaFree(RSA *rsa)
1088 {
1089     if (rsa != NULL) {
1090         RSA_free(rsa);
1091     }
1092 }
1093 
OpensslRsaGenerateMultiPrimeKey(RSA * rsa,int bits,int primes,BIGNUM * e,BN_GENCB * cb)1094 int OpensslRsaGenerateMultiPrimeKey(RSA *rsa, int bits, int primes,
1095     BIGNUM *e, BN_GENCB *cb)
1096 {
1097     return RSA_generate_multi_prime_key(rsa, bits, primes, e, cb);
1098 }
1099 
OpensslRsaGenerateKeyEx(RSA * rsa,int bits,BIGNUM * e,BN_GENCB * cb)1100 int OpensslRsaGenerateKeyEx(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb)
1101 {
1102     return RSA_generate_key_ex(rsa, bits, e, cb);
1103 }
1104 
OpensslRsaBits(const RSA * rsa)1105 int OpensslRsaBits(const RSA *rsa)
1106 {
1107     return RSA_bits(rsa);
1108 }
1109 
OpensslRsaSet0Key(RSA * r,BIGNUM * n,BIGNUM * e,BIGNUM * d)1110 int OpensslRsaSet0Key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d)
1111 {
1112     return RSA_set0_key(r, n, e, d);
1113 }
1114 
OpensslRsaGet0Key(const RSA * r,const BIGNUM ** n,const BIGNUM ** e,const BIGNUM ** d)1115 void OpensslRsaGet0Key(const RSA *r, const BIGNUM **n, const BIGNUM **e, const BIGNUM **d)
1116 {
1117     RSA_get0_key(r, n, e, d);
1118 }
1119 
OpensslRsaGet0N(const RSA * d)1120 const BIGNUM *OpensslRsaGet0N(const RSA *d)
1121 {
1122     return RSA_get0_n(d);
1123 }
1124 
OpensslRsaGet0E(const RSA * d)1125 const BIGNUM *OpensslRsaGet0E(const RSA *d)
1126 {
1127     return RSA_get0_e(d);
1128 }
1129 
OpensslRsaGet0D(const RSA * d)1130 const BIGNUM *OpensslRsaGet0D(const RSA *d)
1131 {
1132     return RSA_get0_d(d);
1133 }
1134 
OpensslRsaGet0Factors(const RSA * r,const BIGNUM ** p,const BIGNUM ** q)1135 void OpensslRsaGet0Factors(const RSA *r, const BIGNUM **p, const BIGNUM **q)
1136 {
1137     RSA_get0_factors(r, p, q);
1138 }
1139 
OpensslRsaPublicKeyDup(RSA * rsa)1140 RSA *OpensslRsaPublicKeyDup(RSA *rsa)
1141 {
1142     return RSAPublicKey_dup(rsa);
1143 }
1144 
OpensslRsaPrivateKeyDup(RSA * rsa)1145 RSA *OpensslRsaPrivateKeyDup(RSA *rsa)
1146 {
1147     return RSAPrivateKey_dup(rsa);
1148 }
1149 
OpensslD2iRsaPubKey(RSA ** a,const unsigned char ** pp,long length)1150 RSA *OpensslD2iRsaPubKey(RSA **a, const unsigned char **pp, long length)
1151 {
1152     return d2i_RSA_PUBKEY(a, pp, length);
1153 }
1154 
OpensslI2dRsaPubKey(RSA * a,unsigned char ** pp)1155 int OpensslI2dRsaPubKey(RSA *a, unsigned char **pp)
1156 {
1157     return i2d_RSA_PUBKEY(a, pp);
1158 }
1159 
OpensslEvpPkeyCtxSetRsaPssSaltLen(EVP_PKEY_CTX * ctx,int saltlen)1160 int OpensslEvpPkeyCtxSetRsaPssSaltLen(EVP_PKEY_CTX *ctx, int saltlen)
1161 {
1162     return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen);
1163 }
1164 
OpensslEvpPkeyCtxGetRsaPssSaltLen(EVP_PKEY_CTX * ctx,int * saltlen)1165 int OpensslEvpPkeyCtxGetRsaPssSaltLen(EVP_PKEY_CTX *ctx, int *saltlen)
1166 {
1167     return EVP_PKEY_CTX_get_rsa_pss_saltlen(ctx, saltlen);
1168 }
1169 
OpensslEvpPkeyCtxSetRsaPadding(EVP_PKEY_CTX * ctx,int pad)1170 int OpensslEvpPkeyCtxSetRsaPadding(EVP_PKEY_CTX *ctx, int pad)
1171 {
1172     return EVP_PKEY_CTX_set_rsa_padding(ctx, pad);
1173 }
1174 
OpensslEvpPkeyCtxSetRsaMgf1Md(EVP_PKEY_CTX * ctx,const EVP_MD * md)1175 int OpensslEvpPkeyCtxSetRsaMgf1Md(EVP_PKEY_CTX *ctx, const EVP_MD *md)
1176 {
1177     return EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md);
1178 }
1179 
OpensslEvpPkeyCtxSetRsaOaepMd(EVP_PKEY_CTX * ctx,const EVP_MD * md)1180 int OpensslEvpPkeyCtxSetRsaOaepMd(EVP_PKEY_CTX *ctx, const EVP_MD *md)
1181 {
1182     return EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md);
1183 }
1184 
OpensslEvpPkeyCtxSet0RsaOaepLabel(EVP_PKEY_CTX * ctx,void * label,int len)1185 int OpensslEvpPkeyCtxSet0RsaOaepLabel(EVP_PKEY_CTX *ctx, void *label, int len)
1186 {
1187     return EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, label, len);
1188 }
1189 
OpensslEvpPkeyCtxGet0RsaOaepLabel(EVP_PKEY_CTX * ctx,unsigned char ** label)1190 int OpensslEvpPkeyCtxGet0RsaOaepLabel(EVP_PKEY_CTX *ctx, unsigned char **label)
1191 {
1192     return EVP_PKEY_CTX_get0_rsa_oaep_label(ctx, label);
1193 }
1194 
OpensslD2iAutoPrivateKey(EVP_PKEY ** a,const unsigned char ** pp,long length)1195 EVP_PKEY *OpensslD2iAutoPrivateKey(EVP_PKEY **a, const unsigned char **pp, long length)
1196 {
1197     return d2i_AutoPrivateKey(a, pp, length);
1198 }
1199 
OpensslEvpPkeyGet1Rsa(EVP_PKEY * pkey)1200 struct rsa_st *OpensslEvpPkeyGet1Rsa(EVP_PKEY *pkey)
1201 {
1202     return EVP_PKEY_get1_RSA(pkey);
1203 }
1204 
OpensslEvpPkeySet1Rsa(EVP_PKEY * pkey,struct rsa_st * key)1205 int OpensslEvpPkeySet1Rsa(EVP_PKEY *pkey, struct rsa_st *key)
1206 {
1207     return EVP_PKEY_set1_RSA(pkey, key);
1208 }
1209 
OpensslEvpPkeyAssignRsa(EVP_PKEY * pkey,struct rsa_st * key)1210 int OpensslEvpPkeyAssignRsa(EVP_PKEY *pkey, struct rsa_st *key)
1211 {
1212     return EVP_PKEY_assign_RSA(pkey, key);
1213 }
1214 
OpensslBioNew(const BIO_METHOD * type)1215 BIO *OpensslBioNew(const BIO_METHOD *type)
1216 {
1217     return BIO_new(type);
1218 }
1219 
OpensslBioSMem(void)1220 const BIO_METHOD *OpensslBioSMem(void)
1221 {
1222     return BIO_s_mem();
1223 }
1224 
OpensslBioRead(BIO * b,void * data,int dlen)1225 int OpensslBioRead(BIO *b, void *data, int dlen)
1226 {
1227     return BIO_read(b, data, dlen);
1228 }
1229 
OpensslBioFreeAll(BIO * a)1230 void OpensslBioFreeAll(BIO *a)
1231 {
1232     if (a != NULL) {
1233         return BIO_free_all(a);
1234     }
1235 }
1236 
OpensslRandPrivBytes(unsigned char * buf,int num)1237 int OpensslRandPrivBytes(unsigned char *buf, int num)
1238 {
1239     if (IsNeedMock()) {
1240         return -1;
1241     }
1242     return RAND_priv_bytes(buf, num);
1243 }
1244 
OpensslRandSeed(const void * buf,int num)1245 void OpensslRandSeed(const void *buf, int num)
1246 {
1247     RAND_seed(buf, num);
1248 }
1249 
OpensslEvpSha1(void)1250 const EVP_MD *OpensslEvpSha1(void)
1251 {
1252     if (IsNeedMock()) {
1253         return NULL;
1254     }
1255     return EVP_sha1();
1256 }
1257 
OpensslEvpSha224(void)1258 const EVP_MD *OpensslEvpSha224(void)
1259 {
1260     if (IsNeedMock()) {
1261         return NULL;
1262     }
1263     return EVP_sha224();
1264 }
1265 
OpensslEvpSha256(void)1266 const EVP_MD *OpensslEvpSha256(void)
1267 {
1268     if (IsNeedMock()) {
1269         return NULL;
1270     }
1271     return EVP_sha256();
1272 }
1273 
OpensslEvpSha384(void)1274 const EVP_MD *OpensslEvpSha384(void)
1275 {
1276     if (IsNeedMock()) {
1277         return NULL;
1278     }
1279     return EVP_sha384();
1280 }
1281 
OpensslEvpSha512(void)1282 const EVP_MD *OpensslEvpSha512(void)
1283 {
1284     if (IsNeedMock()) {
1285         return NULL;
1286     }
1287     return EVP_sha512();
1288 }
1289 
OpensslEvpMd5(void)1290 const EVP_MD *OpensslEvpMd5(void)
1291 {
1292     if (IsNeedMock()) {
1293         return NULL;
1294     }
1295     return EVP_md5();
1296 }
1297 
OpensslEvpDigestFinalEx(EVP_MD_CTX * ctx,unsigned char * md,unsigned int * size)1298 int OpensslEvpDigestFinalEx(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
1299 {
1300     if (IsNeedMock()) {
1301         return -1;
1302     }
1303     return EVP_DigestFinal_ex(ctx, md, size);
1304 }
1305 
OpensslEvpMdCtxSize(const EVP_MD_CTX * ctx)1306 int OpensslEvpMdCtxSize(const EVP_MD_CTX *ctx)
1307 {
1308     if (IsNeedMock()) {
1309         return -1;
1310     }
1311     return EVP_MD_CTX_size(ctx);
1312 }
1313 
OpensslEvpDigestInitEx(EVP_MD_CTX * ctx,const EVP_MD * type,ENGINE * impl)1314 int OpensslEvpDigestInitEx(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
1315 {
1316     if (IsNeedMock()) {
1317         return -1;
1318     }
1319     return EVP_DigestInit_ex(ctx, type, impl);
1320 }
1321 
OpensslHmacInitEx(HMAC_CTX * ctx,const void * key,int len,const EVP_MD * md,ENGINE * impl)1322 int OpensslHmacInitEx(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md, ENGINE *impl)
1323 {
1324     if (IsNeedMock()) {
1325         return -1;
1326     }
1327     return HMAC_Init_ex(ctx, key, len, md, impl);
1328 }
1329 
OpensslHmacFinal(HMAC_CTX * ctx,unsigned char * md,unsigned int * len)1330 int OpensslHmacFinal(HMAC_CTX *ctx, unsigned char *md, unsigned int *len)
1331 {
1332     if (IsNeedMock()) {
1333         return -1;
1334     }
1335     return HMAC_Final(ctx, md, len);
1336 }
1337 
OpensslHmacSize(const HMAC_CTX * ctx)1338 size_t OpensslHmacSize(const HMAC_CTX *ctx)
1339 {
1340     if (IsNeedMock()) {
1341         return -1;
1342     }
1343     return HMAC_size(ctx);
1344 }
1345 
OpensslHmacCtxFree(HMAC_CTX * ctx)1346 void OpensslHmacCtxFree(HMAC_CTX *ctx)
1347 {
1348     if (ctx != NULL) {
1349         HMAC_CTX_free(ctx);
1350     }
1351 }
1352 
OpensslHmacCtxNew(void)1353 HMAC_CTX *OpensslHmacCtxNew(void)
1354 {
1355     if (IsNeedMock()) {
1356         return NULL;
1357     }
1358     return HMAC_CTX_new();
1359 }
1360 
OpensslEvpCipherCtxFree(EVP_CIPHER_CTX * ctx)1361 void OpensslEvpCipherCtxFree(EVP_CIPHER_CTX *ctx)
1362 {
1363     if (ctx != NULL) {
1364         EVP_CIPHER_CTX_free(ctx);
1365     }
1366 }
1367 
OpensslEvpAes128Ecb(void)1368 const EVP_CIPHER *OpensslEvpAes128Ecb(void)
1369 {
1370     if (IsNeedMock()) {
1371         return NULL;
1372     }
1373     return EVP_aes_128_ecb();
1374 }
1375 
OpensslEvpAes192Ecb(void)1376 const EVP_CIPHER *OpensslEvpAes192Ecb(void)
1377 {
1378     if (IsNeedMock()) {
1379         return NULL;
1380     }
1381     return EVP_aes_192_ecb();
1382 }
1383 
OpensslEvpAes256Ecb(void)1384 const EVP_CIPHER *OpensslEvpAes256Ecb(void)
1385 {
1386     if (IsNeedMock()) {
1387         return NULL;
1388     }
1389     return EVP_aes_256_ecb();
1390 }
1391 
OpensslEvpAes128Cbc(void)1392 const EVP_CIPHER *OpensslEvpAes128Cbc(void)
1393 {
1394     if (IsNeedMock()) {
1395         return NULL;
1396     }
1397     return EVP_aes_128_cbc();
1398 }
1399 
OpensslEvpAes192Cbc(void)1400 const EVP_CIPHER *OpensslEvpAes192Cbc(void)
1401 {
1402     if (IsNeedMock()) {
1403         return NULL;
1404     }
1405     return EVP_aes_192_cbc();
1406 }
1407 
OpensslEvpAes256Cbc(void)1408 const EVP_CIPHER *OpensslEvpAes256Cbc(void)
1409 {
1410     if (IsNeedMock()) {
1411         return NULL;
1412     }
1413     return EVP_aes_256_cbc();
1414 }
1415 
OpensslEvpAes128Ctr(void)1416 const EVP_CIPHER *OpensslEvpAes128Ctr(void)
1417 {
1418     if (IsNeedMock()) {
1419         return NULL;
1420     }
1421     return EVP_aes_128_ctr();
1422 }
1423 
OpensslEvpAes192Ctr(void)1424 const EVP_CIPHER *OpensslEvpAes192Ctr(void)
1425 {
1426     if (IsNeedMock()) {
1427         return NULL;
1428     }
1429     return EVP_aes_192_ctr();
1430 }
1431 
OpensslEvpAes256Ctr(void)1432 const EVP_CIPHER *OpensslEvpAes256Ctr(void)
1433 {
1434     if (IsNeedMock()) {
1435         return NULL;
1436     }
1437     return EVP_aes_256_ctr();
1438 }
1439 
OpensslEvpAes128Ofb(void)1440 const EVP_CIPHER *OpensslEvpAes128Ofb(void)
1441 {
1442     if (IsNeedMock()) {
1443         return NULL;
1444     }
1445     return EVP_aes_128_ofb();
1446 }
1447 
OpensslEvpAes192Ofb(void)1448 const EVP_CIPHER *OpensslEvpAes192Ofb(void)
1449 {
1450     if (IsNeedMock()) {
1451         return NULL;
1452     }
1453     return EVP_aes_192_ofb();
1454 }
1455 
OpensslEvpAes256Ofb(void)1456 const EVP_CIPHER *OpensslEvpAes256Ofb(void)
1457 {
1458     if (IsNeedMock()) {
1459         return NULL;
1460     }
1461     return EVP_aes_256_ofb();
1462 }
1463 
OpensslEvpAes128Cfb(void)1464 const EVP_CIPHER *OpensslEvpAes128Cfb(void)
1465 {
1466     if (IsNeedMock()) {
1467         return NULL;
1468     }
1469     return EVP_aes_128_cfb();
1470 }
1471 
OpensslEvpAes192Cfb(void)1472 const EVP_CIPHER *OpensslEvpAes192Cfb(void)
1473 {
1474     if (IsNeedMock()) {
1475         return NULL;
1476     }
1477     return EVP_aes_192_cfb();
1478 }
1479 
OpensslEvpAes256Cfb(void)1480 const EVP_CIPHER *OpensslEvpAes256Cfb(void)
1481 {
1482     if (IsNeedMock()) {
1483         return NULL;
1484     }
1485     return EVP_aes_256_cfb();
1486 }
1487 
OpensslEvpAes128Cfb1(void)1488 const EVP_CIPHER *OpensslEvpAes128Cfb1(void)
1489 {
1490     if (IsNeedMock()) {
1491         return NULL;
1492     }
1493     return EVP_aes_128_cfb1();
1494 }
1495 
OpensslEvpAes192Cfb1(void)1496 const EVP_CIPHER *OpensslEvpAes192Cfb1(void)
1497 {
1498     if (IsNeedMock()) {
1499         return NULL;
1500     }
1501     return EVP_aes_192_cfb1();
1502 }
1503 
OpensslEvpAes256Cfb1(void)1504 const EVP_CIPHER *OpensslEvpAes256Cfb1(void)
1505 {
1506     if (IsNeedMock()) {
1507         return NULL;
1508     }
1509     return EVP_aes_256_cfb1();
1510 }
1511 
OpensslEvpAes128Cfb128(void)1512 const EVP_CIPHER *OpensslEvpAes128Cfb128(void)
1513 {
1514     if (IsNeedMock()) {
1515         return NULL;
1516     }
1517     return EVP_aes_128_cfb128();
1518 }
1519 
OpensslEvpAes192Cfb128(void)1520 const EVP_CIPHER *OpensslEvpAes192Cfb128(void)
1521 {
1522     if (IsNeedMock()) {
1523         return NULL;
1524     }
1525     return EVP_aes_192_cfb128();
1526 }
1527 
OpensslEvpAes256Cfb128(void)1528 const EVP_CIPHER *OpensslEvpAes256Cfb128(void)
1529 {
1530     if (IsNeedMock()) {
1531         return NULL;
1532     }
1533     return EVP_aes_256_cfb128();
1534 }
1535 
OpensslEvpAes128Cfb8(void)1536 const EVP_CIPHER *OpensslEvpAes128Cfb8(void)
1537 {
1538     if (IsNeedMock()) {
1539         return NULL;
1540     }
1541     return EVP_aes_128_cfb8();
1542 }
1543 
OpensslEvpAes192Cfb8(void)1544 const EVP_CIPHER *OpensslEvpAes192Cfb8(void)
1545 {
1546     if (IsNeedMock()) {
1547         return NULL;
1548     }
1549     return EVP_aes_192_cfb8();
1550 }
1551 
OpensslEvpAes256Cfb8(void)1552 const EVP_CIPHER *OpensslEvpAes256Cfb8(void)
1553 {
1554     if (IsNeedMock()) {
1555         return NULL;
1556     }
1557     return EVP_aes_256_cfb8();
1558 }
1559 
OpensslEvpAes128Ccm(void)1560 const EVP_CIPHER *OpensslEvpAes128Ccm(void)
1561 {
1562     if (IsNeedMock()) {
1563         return NULL;
1564     }
1565     return EVP_aes_128_ccm();
1566 }
1567 
OpensslEvpAes192Ccm(void)1568 const EVP_CIPHER *OpensslEvpAes192Ccm(void)
1569 {
1570     if (IsNeedMock()) {
1571         return NULL;
1572     }
1573     return EVP_aes_192_ccm();
1574 }
1575 
OpensslEvpAes256Ccm(void)1576 const EVP_CIPHER *OpensslEvpAes256Ccm(void)
1577 {
1578     if (IsNeedMock()) {
1579         return NULL;
1580     }
1581     return EVP_aes_256_ccm();
1582 }
1583 
OpensslEvpAes128Gcm(void)1584 const EVP_CIPHER *OpensslEvpAes128Gcm(void)
1585 {
1586     if (IsNeedMock()) {
1587         return NULL;
1588     }
1589     return EVP_aes_128_gcm();
1590 }
1591 
OpensslEvpAes192Gcm(void)1592 const EVP_CIPHER *OpensslEvpAes192Gcm(void)
1593 {
1594     if (IsNeedMock()) {
1595         return NULL;
1596     }
1597     return EVP_aes_192_gcm();
1598 }
1599 
OpensslEvpAes256Gcm(void)1600 const EVP_CIPHER *OpensslEvpAes256Gcm(void)
1601 {
1602     if (IsNeedMock()) {
1603         return NULL;
1604     }
1605     return EVP_aes_256_gcm();
1606 }
1607 
OpensslEvpCipherCtxNew(void)1608 EVP_CIPHER_CTX *OpensslEvpCipherCtxNew(void)
1609 {
1610     if (IsNeedMock()) {
1611         return NULL;
1612     }
1613     return EVP_CIPHER_CTX_new();
1614 }
1615 
OpensslEvpCipherInit(EVP_CIPHER_CTX * ctx,const EVP_CIPHER * cipher,const unsigned char * key,const unsigned char * iv,int enc)1616 int OpensslEvpCipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
1617                          const unsigned char *key, const unsigned char *iv, int enc)
1618 {
1619     if (IsNeedMock()) {
1620         return -1;
1621     }
1622     return EVP_CipherInit(ctx, cipher, key, iv, enc);
1623 }
1624 
OpensslEvpCipherCtxSetPadding(EVP_CIPHER_CTX * ctx,int pad)1625 int OpensslEvpCipherCtxSetPadding(EVP_CIPHER_CTX *ctx, int pad)
1626 {
1627     if (IsNeedMock()) {
1628         return -1;
1629     }
1630     return EVP_CIPHER_CTX_set_padding(ctx, pad);
1631 }
1632 
OpensslEvpCipherFinalEx(EVP_CIPHER_CTX * ctx,unsigned char * out,int * outl)1633 int OpensslEvpCipherFinalEx(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
1634 {
1635     if (IsNeedMock()) {
1636         return -1;
1637     }
1638     return EVP_CipherFinal_ex(ctx, out, outl);
1639 }
1640 
OpensslEvpCipherUpdate(EVP_CIPHER_CTX * ctx,unsigned char * out,int * outl,const unsigned char * in,int inl)1641 int OpensslEvpCipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, const unsigned char *in, int inl)
1642 {
1643     if (IsNeedMock()) {
1644         return -1;
1645     }
1646     return EVP_CipherUpdate(ctx, out, outl, in, inl);
1647 }
1648 
OpensslEvpDesEde3Ecb(void)1649 const EVP_CIPHER *OpensslEvpDesEde3Ecb(void)
1650 {
1651     if (IsNeedMock()) {
1652         return NULL;
1653     }
1654     return EVP_des_ede3_ecb();
1655 }
1656 
OpensslEvpDesEde3Cbc(void)1657 const EVP_CIPHER *OpensslEvpDesEde3Cbc(void)
1658 {
1659     if (IsNeedMock()) {
1660         return NULL;
1661     }
1662     return EVP_des_ede3_cbc();
1663 }
1664 
OpensslEvpDesEde3Ofb(void)1665 const EVP_CIPHER *OpensslEvpDesEde3Ofb(void)
1666 {
1667     if (IsNeedMock()) {
1668         return NULL;
1669     }
1670     return EVP_des_ede3_ofb();
1671 }
1672 
OpensslEvpDesEde3Cfb64(void)1673 const EVP_CIPHER *OpensslEvpDesEde3Cfb64(void)
1674 {
1675     if (IsNeedMock()) {
1676         return NULL;
1677     }
1678     return EVP_des_ede3_cfb64();
1679 }
1680 
OpensslEvpDesEde3Cfb1(void)1681 const EVP_CIPHER *OpensslEvpDesEde3Cfb1(void)
1682 {
1683     if (IsNeedMock()) {
1684         return NULL;
1685     }
1686     return EVP_des_ede3_cfb1();
1687 }
1688 
OpensslEvpDesEde3Cfb8(void)1689 const EVP_CIPHER *OpensslEvpDesEde3Cfb8(void)
1690 {
1691     if (IsNeedMock()) {
1692         return NULL;
1693     }
1694     return EVP_des_ede3_cfb8();
1695 }
1696 
OpensslPkcs5Pbkdf2Hmac(const char * pass,int passlen,const unsigned char * salt,int saltlen,int iter,const EVP_MD * digest,int keylen,unsigned char * out)1697 int OpensslPkcs5Pbkdf2Hmac(const char *pass, int passlen, const unsigned char *salt,
1698     int saltlen, int iter, const EVP_MD *digest, int keylen, unsigned char *out)
1699 {
1700     if (IsNeedMock()) {
1701         return -1;
1702     }
1703     return PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, digest, keylen, out);
1704 }
1705 
OpensslEvpCipherCtxCtrl(EVP_CIPHER_CTX * ctx,int type,int arg,void * ptr)1706 int OpensslEvpCipherCtxCtrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
1707 {
1708     if (IsNeedMock()) {
1709         return -1;
1710     }
1711     return EVP_CIPHER_CTX_ctrl(ctx, type, arg, ptr);
1712 }
1713 
OpensslDhNew(void)1714 DH *OpensslDhNew(void)
1715 {
1716     if (IsNeedMock()) {
1717         return NULL;
1718     }
1719     return DH_new();
1720 }
1721 
OpensslDhComputeKeyPadded(unsigned char * key,const BIGNUM * pubKey,DH * dh)1722 int OpensslDhComputeKeyPadded(unsigned char *key, const BIGNUM *pubKey, DH *dh)
1723 {
1724     if (IsNeedMock()) {
1725         return -1;
1726     }
1727     return DH_compute_key_padded(key, pubKey, dh);
1728 }
1729 
OpensslDhFree(DH * dh)1730 void OpensslDhFree(DH *dh)
1731 {
1732     if (dh != NULL) {
1733         return DH_free(dh);
1734     }
1735 }
1736 
OpensslDhGenerateKey(DH * dh)1737 int OpensslDhGenerateKey(DH *dh)
1738 {
1739     if (IsNeedMock()) {
1740         return -1;
1741     }
1742     return DH_generate_key(dh);
1743 }
1744 
OpensslDhGet0P(const DH * dh)1745 const BIGNUM *OpensslDhGet0P(const DH *dh)
1746 {
1747     if (IsNeedMock()) {
1748         return NULL;
1749     }
1750     return DH_get0_p(dh);
1751 }
1752 
OpensslDhGet0Q(const DH * dh)1753 const BIGNUM *OpensslDhGet0Q(const DH *dh)
1754 {
1755     if (IsNeedMock()) {
1756         return NULL;
1757     }
1758     return DH_get0_q(dh);
1759 }
1760 
OpensslDhGet0G(const DH * dh)1761 const BIGNUM *OpensslDhGet0G(const DH *dh)
1762 {
1763     if (IsNeedMock()) {
1764         return NULL;
1765     }
1766     return DH_get0_g(dh);
1767 }
1768 
OpensslDhGetLength(const DH * dh)1769 long OpensslDhGetLength(const DH *dh)
1770 {
1771     if (IsNeedMock()) {
1772         return -1;
1773     }
1774     return DH_get_length(dh);
1775 }
1776 
OpensslDhSetLength(DH * dh,long length)1777 int OpensslDhSetLength(DH *dh, long length)
1778 {
1779     if (IsNeedMock()) {
1780         return -1;
1781     }
1782     return DH_set_length(dh, length);
1783 }
1784 
OpensslDhGet0PubKey(const DH * dh)1785 const BIGNUM *OpensslDhGet0PubKey(const DH *dh)
1786 {
1787     if (IsNeedMock()) {
1788         return NULL;
1789     }
1790     return DH_get0_pub_key(dh);
1791 }
1792 
OpensslDhGet0PrivKey(const DH * dh)1793 const BIGNUM *OpensslDhGet0PrivKey(const DH *dh)
1794 {
1795     if (IsNeedMock()) {
1796         return NULL;
1797     }
1798     return DH_get0_priv_key(dh);
1799 }
1800 
OpensslEvpPkeySet1Dh(EVP_PKEY * pkey,DH * key)1801 int OpensslEvpPkeySet1Dh(EVP_PKEY *pkey, DH *key)
1802 {
1803     if (IsNeedMock()) {
1804         return -1;
1805     }
1806     return EVP_PKEY_set1_DH(pkey, key);
1807 }
1808 
OpensslEvpPkeyGet1Dh(EVP_PKEY * pkey)1809 DH *OpensslEvpPkeyGet1Dh(EVP_PKEY *pkey)
1810 {
1811     if (IsNeedMock()) {
1812         return NULL;
1813     }
1814     return EVP_PKEY_get1_DH(pkey);
1815 }
1816 
OpensslEvpPkeyAssignDh(EVP_PKEY * pkey,DH * key)1817 int OpensslEvpPkeyAssignDh(EVP_PKEY *pkey, DH *key)
1818 {
1819     if (IsNeedMock()) {
1820         return -1;
1821     }
1822     return EVP_PKEY_assign_DH(pkey, key);
1823 }
1824 
OpensslEvpPkeyCtxSetDhParamgenPrimeLen(EVP_PKEY_CTX * ctx,int pbits)1825 int OpensslEvpPkeyCtxSetDhParamgenPrimeLen(EVP_PKEY_CTX *ctx, int pbits)
1826 {
1827     if (IsNeedMock()) {
1828         return -1;
1829     }
1830     return EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, pbits);
1831 }
1832 
OpensslEvpPkeyCtxSetSignatureMd(EVP_PKEY_CTX * ctx,const EVP_MD * md)1833 int OpensslEvpPkeyCtxSetSignatureMd(EVP_PKEY_CTX *ctx, const EVP_MD *md)
1834 {
1835     if (IsNeedMock()) {
1836         return -1;
1837     }
1838     return EVP_PKEY_CTX_set_signature_md(ctx, md);
1839 }
1840 
OpensslDhUpRef(DH * r)1841 int OpensslDhUpRef(DH *r)
1842 {
1843     if (IsNeedMock()) {
1844         return -1;
1845     }
1846     return DH_up_ref(r);
1847 }
1848 
OpensslDhSet0Pqg(DH * dh,BIGNUM * p,BIGNUM * q,BIGNUM * g)1849 int OpensslDhSet0Pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g)
1850 {
1851     if (IsNeedMock()) {
1852         return -1;
1853     }
1854     return DH_set0_pqg(dh, p, q, g);
1855 }
1856 
OpensslDhSet0Key(DH * dh,BIGNUM * pubKey,BIGNUM * privKey)1857 int OpensslDhSet0Key(DH *dh, BIGNUM *pubKey, BIGNUM *privKey)
1858 {
1859     if (IsNeedMock()) {
1860         return -1;
1861     }
1862     return DH_set0_key(dh, pubKey, privKey);
1863 }
1864 
OpensslOsslParamBldNew(void)1865 OSSL_PARAM_BLD *OpensslOsslParamBldNew(void)
1866 {
1867     if (IsNeedMock()) {
1868         return NULL;
1869     }
1870     return OSSL_PARAM_BLD_new();
1871 }
1872 
OpensslOsslParamBldFree(OSSL_PARAM_BLD * bld)1873 void OpensslOsslParamBldFree(OSSL_PARAM_BLD *bld)
1874 {
1875     if (bld != NULL) {
1876         OSSL_PARAM_BLD_free(bld);
1877     }
1878 }
1879 
OpensslOsslParamBldToParam(OSSL_PARAM_BLD * bld)1880 OSSL_PARAM *OpensslOsslParamBldToParam(OSSL_PARAM_BLD *bld)
1881 {
1882     if (IsNeedMock()) {
1883         return NULL;
1884     }
1885     return OSSL_PARAM_BLD_to_param(bld);
1886 }
1887 
OpensslOsslParamBldPushUtf8String(OSSL_PARAM_BLD * bld,const char * key,const char * buf,size_t bsize)1888 int OpensslOsslParamBldPushUtf8String(OSSL_PARAM_BLD *bld, const char *key, const char *buf, size_t bsize)
1889 {
1890     if (IsNeedMock()) {
1891         return -1;
1892     }
1893     return OSSL_PARAM_BLD_push_utf8_string(bld, key, buf, bsize);
1894 }
1895 
OpensslOsslParamBldPushOctetString(OSSL_PARAM_BLD * bld,const char * key,const void * buf,size_t bsize)1896 int OpensslOsslParamBldPushOctetString(OSSL_PARAM_BLD *bld, const char *key, const void *buf, size_t bsize)
1897 {
1898     if (IsNeedMock()) {
1899         return -1;
1900     }
1901     return OSSL_PARAM_BLD_push_octet_string(bld, key, buf, bsize);
1902 }
1903 
OpensslEvpPkeyCtxSetEcParamgenCurveNid(EVP_PKEY_CTX * ctx,int nid)1904 int OpensslEvpPkeyCtxSetEcParamgenCurveNid(EVP_PKEY_CTX *ctx, int nid)
1905 {
1906     if (IsNeedMock()) {
1907         return -1;
1908     }
1909     return EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, nid);
1910 }
1911 
OpensslEvpPkeyFromDataInit(EVP_PKEY_CTX * ctx)1912 int OpensslEvpPkeyFromDataInit(EVP_PKEY_CTX *ctx)
1913 {
1914     if (IsNeedMock()) {
1915         return -1;
1916     }
1917     return EVP_PKEY_fromdata_init(ctx);
1918 }
1919 
OpensslEvpPkeyFromData(EVP_PKEY_CTX * ctx,EVP_PKEY ** ppkey,int selection,OSSL_PARAM params[])1920 int OpensslEvpPkeyFromData(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey, int selection, OSSL_PARAM params[])
1921 {
1922     if (IsNeedMock()) {
1923         return -1;
1924     }
1925     return EVP_PKEY_fromdata(ctx, ppkey, selection, params);
1926 }
1927 
OpensslEvpPkeyGet1EcKey(EVP_PKEY * pkey)1928 EC_KEY *OpensslEvpPkeyGet1EcKey(EVP_PKEY *pkey)
1929 {
1930     if (IsNeedMock()) {
1931         return NULL;
1932     }
1933     return EVP_PKEY_get1_EC_KEY(pkey);
1934 }
1935 
OpensslOsslParamFree(OSSL_PARAM * params)1936 void OpensslOsslParamFree(OSSL_PARAM *params)
1937 {
1938     if (params != NULL) {
1939         OSSL_PARAM_free(params);
1940     }
1941 }
1942 
OpensslEcOct2Point(const EC_GROUP * group,EC_POINT * p,const unsigned char * buf,size_t len,BN_CTX * ctx)1943 int OpensslEcOct2Point(const EC_GROUP *group, EC_POINT *p, const unsigned char *buf, size_t len, BN_CTX *ctx)
1944 {
1945     if (IsNeedMock()) {
1946         return -1;
1947     }
1948     return EC_POINT_oct2point(group, p, buf, len, ctx);
1949 }
1950 
OpensslEcPointSetAffineCoordinates(const EC_GROUP * group,EC_POINT * p,const BIGNUM * x,const BIGNUM * y,BN_CTX * ctx)1951 int OpensslEcPointSetAffineCoordinates(const EC_GROUP *group, EC_POINT *p,
1952                                        const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
1953 {
1954     if (IsNeedMock()) {
1955         return -1;
1956     }
1957     return EC_POINT_set_affine_coordinates(group, p, x, y, ctx);
1958 }
1959 
OpensslEcPointGetAffineCoordinates(const EC_GROUP * group,const EC_POINT * p,BIGNUM * x,BIGNUM * y,BN_CTX * ctx)1960 int OpensslEcPointGetAffineCoordinates(const EC_GROUP *group, const EC_POINT *p,
1961                                        BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
1962 {
1963     if (IsNeedMock()) {
1964         return -1;
1965     }
1966     return EC_POINT_get_affine_coordinates(group, p, x, y, ctx);
1967 }