Skip to content

Commit bd4099d

Browse files
night1ridernight1rider
committed
Update test.c tests to use global devId instead of INVALID_DEVID
1 parent 28c78b5 commit bd4099d

1 file changed

Lines changed: 46 additions & 46 deletions

File tree

‎wolfcrypt/test/test.c‎

Lines changed: 46 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -9965,11 +9965,11 @@ static wc_test_ret_t EVP_test(const WOLFSSL_EVP_CIPHER* type, const byte* key,
99659965
#ifdef HAVE_AES_DECRYPT
99669966
XMEMSET(dec, 0, sizeof(Aes));
99679967
#endif
9968-
ret = wc_AesInit(enc, HEAP_HINT, INVALID_DEVID);
9968+
ret = wc_AesInit(enc, HEAP_HINT, devId);
99699969
if (ret != 0)
99709970
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
99719971
#ifdef HAVE_AES_DECRYPT
9972-
ret = wc_AesInit(dec, HEAP_HINT, INVALID_DEVID);
9972+
ret = wc_AesInit(dec, HEAP_HINT, devId);
99739973
if (ret != 0)
99749974
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
99759975
#endif
@@ -16478,7 +16478,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t gmac_test(void)
1647816478
#endif
1647916479

1648016480
XMEMSET(gmac, 0, sizeof *gmac); /* clear context */
16481-
(void)wc_AesInit(&gmac->aes, HEAP_HINT, INVALID_DEVID); /* Make sure devId updated */
16481+
(void)wc_AesInit(&gmac->aes, HEAP_HINT, devId); /* Make sure devId updated */
1648216482
XMEMSET(tag, 0, sizeof(tag));
1648316483
wc_GmacSetKey(gmac, k1, sizeof(k1));
1648416484
wc_GmacUpdate(gmac, iv1, sizeof(iv1), a1, sizeof(a1), tag, sizeof(t1));
@@ -17779,7 +17779,7 @@ static int sm4_ecb_test(void)
1777917779
byte dec[SM4_BLOCK_SIZE * 4];
1778017780
int ret;
1778117781

17782-
ret = wc_Sm4Init(&sm4, NULL, INVALID_DEVID);
17782+
ret = wc_Sm4Init(&sm4, NULL, devId);
1778317783
if (ret != 0)
1778417784
return WC_TEST_RET_ENC_EC(ret);
1778517785

@@ -17836,7 +17836,7 @@ static int sm4_cbc_test(void)
1783617836
byte dec[SM4_BLOCK_SIZE * 4];
1783717837
int ret;
1783817838

17839-
ret = wc_Sm4Init(&sm4, NULL, INVALID_DEVID);
17839+
ret = wc_Sm4Init(&sm4, NULL, devId);
1784017840
if (ret != 0)
1784117841
return WC_TEST_RET_ENC_EC(ret);
1784217842

@@ -17933,7 +17933,7 @@ static int sm4_ctr_test(void)
1793317933
int i;
1793417934
int ret;
1793517935

17936-
ret = wc_Sm4Init(&sm4, NULL, INVALID_DEVID);
17936+
ret = wc_Sm4Init(&sm4, NULL, devId);
1793717937
if (ret != 0)
1793817938
return WC_TEST_RET_ENC_EC(ret);
1793917939

@@ -18061,7 +18061,7 @@ static int sm4_gcm_test(void)
1806118061
byte tag[SM4_BLOCK_SIZE];
1806218062
int ret;
1806318063

18064-
ret = wc_Sm4Init(&sm4, NULL, INVALID_DEVID);
18064+
ret = wc_Sm4Init(&sm4, NULL, devId);
1806518065
if (ret != 0)
1806618066
return WC_TEST_RET_ENC_EC(ret);
1806718067

@@ -18188,7 +18188,7 @@ static int sm4_ccm_test(void)
1818818188
byte tag[SM4_BLOCK_SIZE];
1818918189
int ret;
1819018190

18191-
ret = wc_Sm4Init(&sm4, NULL, INVALID_DEVID);
18191+
ret = wc_Sm4Init(&sm4, NULL, devId);
1819218192
if (ret != 0)
1819318193
return WC_TEST_RET_ENC_EC(ret);
1819418194

@@ -28365,7 +28365,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t prf_test(void)
2836528365

2836628366
ret = wc_PRF(dig, (word32)digL, secret, (word32)secL, lablSd,
2836728367
(word32)lblsdL, hash_type,
28368-
HEAP_HINT, INVALID_DEVID);
28368+
HEAP_HINT, devId);
2836928369
if (ret != 0) {
2837028370
printf("Failed w/ code: %d\n", ret);
2837128371
return WC_TEST_RET_ENC_EC(ret);
@@ -28421,7 +28421,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t tls12_kdf_test(void)
2842128421

2842228422
ret = wc_PRF_TLS(result, msSz, pms, pmsSz,
2842328423
(const byte*)label, (word32)XSTRLEN(label), seed, seedSz,
28424-
1, sha256_mac, NULL, INVALID_DEVID);
28424+
1, sha256_mac, NULL, devId);
2842528425
if (ret != 0) {
2842628426
if (ret == WC_NO_ERR_TRACE(FIPS_PRIVATE_KEY_LOCKED_E)) {
2842728427
printf(" wc_PRF_TLSv12: Private key locked.\n");
@@ -40454,7 +40454,7 @@ static wc_test_ret_t mlkem512_kat(void)
4045440454
#endif
4045540455

4045640456
#ifdef WOLFSSL_MLKEM_KYBER
40457-
ret = wc_KyberKey_Init(KYBER512, key, HEAP_HINT, INVALID_DEVID);
40457+
ret = wc_KyberKey_Init(KYBER512, key, HEAP_HINT, devId);
4045840458
if (ret != 0)
4045940459
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
4046040460
else
@@ -40517,7 +40517,7 @@ static wc_test_ret_t mlkem512_kat(void)
4051740517
#endif
4051840518
#endif
4051940519
#ifndef WOLFSSL_NO_ML_KEM
40520-
ret = wc_MlKemKey_Init(key, WC_ML_KEM_512, HEAP_HINT, INVALID_DEVID);
40520+
ret = wc_MlKemKey_Init(key, WC_ML_KEM_512, HEAP_HINT, devId);
4052140521
if (ret != 0)
4052240522
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
4052340523
else
@@ -41893,7 +41893,7 @@ static wc_test_ret_t mlkem768_kat(void)
4189341893
#endif
4189441894

4189541895
#ifdef WOLFSSL_MLKEM_KYBER
41896-
ret = wc_KyberKey_Init(KYBER768, key, HEAP_HINT, INVALID_DEVID);
41896+
ret = wc_KyberKey_Init(KYBER768, key, HEAP_HINT, devId);
4189741897
if (ret != 0)
4189841898
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
4189941899
else
@@ -41956,7 +41956,7 @@ static wc_test_ret_t mlkem768_kat(void)
4195641956
#endif
4195741957
#endif
4195841958
#ifndef WOLFSSL_NO_ML_KEM
41959-
ret = wc_MlKemKey_Init(key, WC_ML_KEM_768, HEAP_HINT, INVALID_DEVID);
41959+
ret = wc_MlKemKey_Init(key, WC_ML_KEM_768, HEAP_HINT, devId);
4196041960
if (ret != 0)
4196141961
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
4196241962
else
@@ -43739,7 +43739,7 @@ static wc_test_ret_t mlkem1024_kat(void)
4373943739
#endif
4374043740

4374143741
#ifdef WOLFSSL_MLKEM_KYBER
43742-
ret = wc_KyberKey_Init(KYBER1024, key, HEAP_HINT, INVALID_DEVID);
43742+
ret = wc_KyberKey_Init(KYBER1024, key, HEAP_HINT, devId);
4374343743
if (ret != 0)
4374443744
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
4374543745
else
@@ -43802,7 +43802,7 @@ static wc_test_ret_t mlkem1024_kat(void)
4380243802
#endif
4380343803
#endif
4380443804
#ifndef WOLFSSL_NO_ML_KEM
43805-
ret = wc_MlKemKey_Init(key, WC_ML_KEM_1024, HEAP_HINT, INVALID_DEVID);
43805+
ret = wc_MlKemKey_Init(key, WC_ML_KEM_1024, HEAP_HINT, devId);
4380643806
if (ret != 0)
4380743807
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
4380843808
else
@@ -44014,7 +44014,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t mlkem_test(void)
4401444014
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
4401544015

4401644016
for (i = 0; i < (int)(sizeof(testData) / sizeof(*testData)); i++) {
44017-
ret = wc_MlKemKey_Init(key, testData[i][0], HEAP_HINT, INVALID_DEVID);
44017+
ret = wc_MlKemKey_Init(key, testData[i][0], HEAP_HINT, devId);
4401844018
if (ret != 0)
4401944019
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
4402044020
else
@@ -44033,7 +44033,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t mlkem_test(void)
4403344033
if (ret != 0)
4403444034
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
4403544035

44036-
ret = wc_MlKemKey_Init(key, testData[i][0], HEAP_HINT, INVALID_DEVID);
44036+
ret = wc_MlKemKey_Init(key, testData[i][0], HEAP_HINT, devId);
4403744037
if (ret != 0)
4403844038
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
4403944039

@@ -44054,7 +44054,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t mlkem_test(void)
4405444054
if (XMEMCMP(pub, pub2, testData[i][2]) != 0)
4405544055
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
4405644056

44057-
ret = wc_MlKemKey_Init(key, testData[i][0], HEAP_HINT, INVALID_DEVID);
44057+
ret = wc_MlKemKey_Init(key, testData[i][0], HEAP_HINT, devId);
4405844058
if (ret != 0)
4405944059
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
4406044060

@@ -44080,7 +44080,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t mlkem_test(void)
4408044080
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
4408144081

4408244082
#if defined(WOLFSSL_WC_MLKEM) && !defined(WOLFSSL_NO_MALLOC)
44083-
tmpKey = wc_MlKemKey_New(testData[i][0], HEAP_HINT, INVALID_DEVID);
44083+
tmpKey = wc_MlKemKey_New(testData[i][0], HEAP_HINT, devId);
4408444084
if (tmpKey == NULL)
4408544085
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
4408644086
ret = wc_MlKemKey_Delete(tmpKey, &tmpKey);
@@ -47370,7 +47370,7 @@ static wc_test_ret_t dilithium_param_test(int param, WC_RNG* rng)
4737047370
#endif
4737147371
#endif
4737247372

47373-
tmpKey = wc_dilithium_new(HEAP_HINT, INVALID_DEVID);
47373+
tmpKey = wc_dilithium_new(HEAP_HINT, devId);
4737447374
if (tmpKey == NULL)
4737547375
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
4737647376

@@ -47762,10 +47762,10 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t xmss_test(void)
4776247762
#endif
4776347763
if (ret != 0) { return WC_TEST_RET_ENC_EC(ret); }
4776447764

47765-
ret = wc_XmssKey_Init(&signingKey, NULL, INVALID_DEVID);
47765+
ret = wc_XmssKey_Init(&signingKey, NULL, devId);
4776647766
if (ret != 0) { ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); }
4776747767

47768-
ret = wc_XmssKey_Init(&verifyKey, NULL, INVALID_DEVID);
47768+
ret = wc_XmssKey_Init(&verifyKey, NULL, devId);
4776947769
if (ret != 0) { ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); }
4777047770

4777147771
/* Set the parameter string to the signing key, and
@@ -48252,7 +48252,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t xmss_test_verify_only(void)
4825248252

4825348253
XMEMSET(pub_raw, 0, sizeof(pub_raw));
4825448254

48255-
ret = wc_XmssKey_Init(&verifyKey, NULL, INVALID_DEVID);
48255+
ret = wc_XmssKey_Init(&verifyKey, NULL, devId);
4825648256
if (ret != 0) { return WC_TEST_RET_ENC_EC(ret); }
4825748257

4825848258
ret = wc_XmssKey_SetParamStr(&verifyKey, param);
@@ -48440,10 +48440,10 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t lms_test(void)
4844048440
* signature length: 8688
4844148441
*/
4844248442

48443-
ret = wc_LmsKey_Init(&signingKey, NULL, INVALID_DEVID);
48443+
ret = wc_LmsKey_Init(&signingKey, NULL, devId);
4844448444
if (ret != 0) { ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); }
4844548445

48446-
ret = wc_LmsKey_Init(&verifyKey, NULL, INVALID_DEVID);
48446+
ret = wc_LmsKey_Init(&verifyKey, NULL, devId);
4844748447
if (ret != 0) { ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); }
4844848448

4844948449
ret = wc_LmsKey_SetParameters(&signingKey, 1, 5, 1);
@@ -48808,7 +48808,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t lms_test_verify_only(void)
4880848808

4880948809
XMEMSET(pub_raw, 0, sizeof(pub_raw));
4881048810

48811-
ret = wc_LmsKey_Init(&verifyKey, NULL, INVALID_DEVID);
48811+
ret = wc_LmsKey_Init(&verifyKey, NULL, devId);
4881248812
if (ret != 0) { return WC_TEST_RET_ENC_EC(ret); }
4881348813

4881448814
ret = wc_LmsKey_SetParameters(&verifyKey, 1, 10, 8);
@@ -48932,24 +48932,24 @@ static wc_test_ret_t eccsi_api_test(WC_RNG* rng, EccsiKey* key, mp_int* ssk,
4893248932
byte sig[257];
4893348933
word32 sigSz;
4893448934

48935-
ret = wc_InitEccsiKey_ex(NULL, 32, ECC_SECP256R1, HEAP_HINT, INVALID_DEVID);
48935+
ret = wc_InitEccsiKey_ex(NULL, 32, ECC_SECP256R1, HEAP_HINT, devId);
4893648936
if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG))
4893748937
return WC_TEST_RET_ENC_EC(ret);
48938-
ret = wc_InitEccsiKey_ex(NULL, 32, ECC_SECP256R1, HEAP_HINT, INVALID_DEVID);
48938+
ret = wc_InitEccsiKey_ex(NULL, 32, ECC_SECP256R1, HEAP_HINT, devId);
4893948939
if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG))
4894048940
return WC_TEST_RET_ENC_EC(ret);
4894148941

48942-
ret = wc_InitEccsiKey(NULL, NULL, INVALID_DEVID);
48942+
ret = wc_InitEccsiKey(NULL, NULL, devId);
4894348943
if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG))
4894448944
return WC_TEST_RET_ENC_EC(ret);
48945-
ret = wc_InitEccsiKey(NULL, HEAP_HINT, INVALID_DEVID);
48945+
ret = wc_InitEccsiKey(NULL, HEAP_HINT, devId);
4894648946
if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG))
4894748947
return WC_TEST_RET_ENC_EC(ret);
4894848948

4894948949
wc_FreeEccsiKey(NULL);
4895048950

4895148951
/* Create a valid key. */
48952-
ret = wc_InitEccsiKey(key, NULL, INVALID_DEVID);
48952+
ret = wc_InitEccsiKey(key, NULL, devId);
4895348953
if (ret != 0)
4895448954
return WC_TEST_RET_ENC_EC(ret);
4895548955

@@ -49884,13 +49884,13 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t eccsi_test(void)
4988449884
}
4988549885

4988649886
if (ret == 0) {
49887-
ret = wc_InitEccsiKey(pub, HEAP_HINT, INVALID_DEVID);
49887+
ret = wc_InitEccsiKey(pub, HEAP_HINT, devId);
4988849888
if (ret != 0)
4988949889
ret = WC_TEST_RET_ENC_EC(ret);
4989049890
}
4989149891

4989249892
if (ret == 0) {
49893-
ret = wc_InitEccsiKey(priv, HEAP_HINT, INVALID_DEVID);
49893+
ret = wc_InitEccsiKey(priv, HEAP_HINT, devId);
4989449894
if (ret != 0)
4989549895
ret = WC_TEST_RET_ENC_EC(ret);
4989649896
}
@@ -49942,10 +49942,10 @@ static wc_test_ret_t sakke_api_test(WC_RNG* rng, SakkeKey* key, ecc_point* rsk)
4994249942
word16 ssvSz;
4994349943
word32 len;
4994449944

49945-
ret = wc_InitSakkeKey_ex(NULL, 128, ECC_SAKKE_1, NULL, INVALID_DEVID);
49945+
ret = wc_InitSakkeKey_ex(NULL, 128, ECC_SAKKE_1, NULL, devId);
4994649946
if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG))
4994749947
return WC_TEST_RET_ENC_EC(ret);
49948-
ret = wc_InitSakkeKey_ex(NULL, 128, ECC_SAKKE_1, HEAP_HINT, INVALID_DEVID);
49948+
ret = wc_InitSakkeKey_ex(NULL, 128, ECC_SAKKE_1, HEAP_HINT, devId);
4994949949
if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG))
4995049950
return WC_TEST_RET_ENC_EC(ret);
4995149951

@@ -49954,7 +49954,7 @@ static wc_test_ret_t sakke_api_test(WC_RNG* rng, SakkeKey* key, ecc_point* rsk)
4995449954
XMEMSET(key, 0, sizeof(*key));
4995549955
wc_FreeSakkeKey(key);
4995649956

49957-
ret = wc_InitSakkeKey_ex(key, 128, ECC_SAKKE_1, HEAP_HINT, INVALID_DEVID);
49957+
ret = wc_InitSakkeKey_ex(key, 128, ECC_SAKKE_1, HEAP_HINT, devId);
4995849958
if (ret != 0)
4995949959
return WC_TEST_RET_ENC_EC(ret);
4996049960

@@ -50724,7 +50724,7 @@ static wc_test_ret_t sakke_make_key_test(SakkeKey* priv, SakkeKey* pub, SakkeKey
5072450724
int valid;
5072550725
ecc_point* pubKey = rsk;
5072650726

50727-
ret = wc_InitSakkeKey_ex(key, 128, ECC_SAKKE_1, NULL, INVALID_DEVID);
50727+
ret = wc_InitSakkeKey_ex(key, 128, ECC_SAKKE_1, NULL, devId);
5072850728
if (ret != 0)
5072950729
return WC_TEST_RET_ENC_EC(ret);
5073050730

@@ -50755,7 +50755,7 @@ static wc_test_ret_t sakke_make_key_test(SakkeKey* priv, SakkeKey* pub, SakkeKey
5075550755
if (ret != 0)
5075650756
return WC_TEST_RET_ENC_EC(ret);
5075750757
wc_FreeSakkeKey(key);
50758-
ret = wc_InitSakkeKey_ex(key, 128, ECC_SAKKE_1, NULL, INVALID_DEVID);
50758+
ret = wc_InitSakkeKey_ex(key, 128, ECC_SAKKE_1, NULL, devId);
5075950759
if (ret != 0)
5076050760
return WC_TEST_RET_ENC_EC(ret);
5076150761

@@ -51028,13 +51028,13 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t sakke_test(void)
5102851028
}
5102951029

5103051030
if (ret == 0) {
51031-
ret = wc_InitSakkeKey(pub, HEAP_HINT, INVALID_DEVID);
51031+
ret = wc_InitSakkeKey(pub, HEAP_HINT, devId);
5103251032
if (ret != 0)
5103351033
ret = WC_TEST_RET_ENC_EC(ret);
5103451034
}
5103551035

5103651036
if (ret == 0) {
51037-
ret = wc_InitSakkeKey(priv, HEAP_HINT, INVALID_DEVID);
51037+
ret = wc_InitSakkeKey(priv, HEAP_HINT, devId);
5103851038
if (ret != 0)
5103951039
ret = WC_TEST_RET_ENC_EC(ret);
5104051040
}
@@ -52553,7 +52553,7 @@ static int myDecryptionFunc(wc_PKCS7* pkcs7, int encryptOID, byte* iv, int ivSz,
5255352553
ERROR_OUT(ALGO_ID_E, out);
5255452554
};
5255552555

52556-
ret = wc_AesInit(aes, HEAP_HINT, INVALID_DEVID);
52556+
ret = wc_AesInit(aes, HEAP_HINT, devId);
5255752557
if (ret == 0) {
5255852558
ret = wc_AesSetKey(aes, key, (word32)keySz, iv, AES_DECRYPTION);
5255952559
if (ret == 0)
@@ -53980,7 +53980,7 @@ static wc_test_ret_t envelopedData_encrypt(byte* in, word32 inSz, byte* out,
5398053980
wc_PKCS7* pkcs7;
5398153981
WOLFSSL_SMALL_STACK_STATIC const byte keyId[] = { 0x00 };
5398253982

53983-
pkcs7 = wc_PKCS7_New(NULL, INVALID_DEVID);
53983+
pkcs7 = wc_PKCS7_New(NULL, devId);
5398453984
if (pkcs7 == NULL)
5398553985
return WC_TEST_RET_ENC_ERRNO;
5398653986

@@ -54067,7 +54067,7 @@ static wc_test_ret_t generateBundle(byte* out, word32 *outSz, const byte* encryp
5406754067
}
5406854068

5406954069
/* init PKCS7 */
54070-
pkcs7 = wc_PKCS7_New(NULL, INVALID_DEVID);
54070+
pkcs7 = wc_PKCS7_New(NULL, devId);
5407154071
if (pkcs7 == NULL)
5407254072
return WC_TEST_RET_ENC_ERRNO;
5407354073

@@ -54162,14 +54162,14 @@ static wc_test_ret_t verifyBundle(byte* derBuf, word32 derSz, int keyHint)
5416254162
goto out;
5416354163
}
5416454164

54165-
pkcs7 = wc_PKCS7_New(HEAP_HINT, INVALID_DEVID);
54165+
pkcs7 = wc_PKCS7_New(HEAP_HINT, devId);
5416654166
if (pkcs7 == NULL) {
5416754167
ret = MEMORY_E;
5416854168
goto out;
5416954169
}
5417054170

5417154171
/* Test verify */
54172-
ret = wc_PKCS7_Init(pkcs7, HEAP_HINT, INVALID_DEVID);
54172+
ret = wc_PKCS7_Init(pkcs7, HEAP_HINT, devId);
5417354173
if (ret != 0)
5417454174
goto out;
5417554175
ret = wc_PKCS7_InitWithCert(pkcs7, NULL, 0);

0 commit comments

Comments
 (0)