openharmony/security_certificate_manager
1
0
Fork 0
mirror of https://gitee.com/openharmony/security_certificate_manager synced 2024-11-23 23:50:31 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

添加fuzz用例

Browse Source 
Signed-off-by: 陈怡博 <chenyibo6@huawei.com>
This commit is contained in:
陈怡博 2024-05-14 20:04:58 +08:00
parent 0b67fbbd2a
commit 92fff53488
21 changed files with 1331 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager.c
View File

@ -259,6 +259,7 @@ static int32_t CmAppCertGetFilePath(const struct CmContext *context, const uint3
break;
case CM_SYS_CREDENTIAL_STORE:
ret = sprintf_s((char *)path->data, MAX_PATH_LEN, "%s%u", SYS_CREDNTIAL_STORE, context->userId);
break;
default:
break;
}

6
test/fuzz_test/BUILD.gn
View File

@ -66,5 +66,11 @@ group("fuzztest") {
"./cmipcserviceupdate_fuzzer:fuzztest",
"./cmonremoterequest_fuzzer:fuzztest",
]
deps += [
"./cmappcert_fuzzer:fuzztest",
"./cmsystemtrustedstore_fuzzer:fuzztest",
"./cmusertrustedstore_fuzzer:fuzztest",
]
}
}

62
test/fuzz_test/cmappcert_fuzzer/BUILD.gn Normal file
View File

@ -0,0 +1,62 @@
# Copyright (c) 2024 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("//build/config/features.gni")
import("//build/test.gni")
module_output_path = "certificate_manager/certificate_manager"
##############################fuzztest##########################################
ohos_fuzztest("CmAppCertFuzzTest") {
module_out_path = module_output_path
fuzz_config_file = "../../../test/fuzz_test/cmappcert_fuzzer"
include_dirs = [
"../../../frameworks/cert_manager_standard/main/common/include",
"../../../frameworks/cert_manager_standard/main/os_dependency/cm_ipc/include",
"../../../interfaces/innerkits/cert_manager_standard/main/include",
"../../../services/cert_manager_standard/cert_manager_service/main/os_dependency/idl/cm_ipc",
"../../../test/unittest/include",
]
cflags = [
"-g",
"-O0",
"-Wno-unused-variable",
"-fno-omit-frame-pointer",
]
sources = [
"../../../test/unittest/src/cm_test_common.cpp",
"cmappcert_fuzzer.cpp",
]
deps = [
"../../../services/cert_manager_standard:cert_manager_service",
"../../../test/fuzz_test/fuzz_test_common:libcert_manager_fuzz_test_common_static",
]
external_deps = [
"access_token:libaccesstoken_sdk",
"access_token:libnativetoken",
"access_token:libtoken_setproc",
]
}
###############################################################################
group("fuzztest") {
testonly = true
deps = []
deps += [
# deps file
":CmAppCertFuzzTest",
]
}
###############################################################################

177
test/fuzz_test/cmappcert_fuzzer/cmappcert_fuzzer.cpp Normal file
View File

@ -0,0 +1,177 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "cmappcert_fuzzer.h"
#include "cm_fuzz_test_common.h"
#include "cm_test_common.h"
#include "cm_cert_data_part1_rsa.h"
#include "cm_ipc_client_serialization.h"
#include "cm_ipc_service.h"
#include "cm_param.h"
#include "cert_manager_api.h"
using namespace CmFuzzTest;
namespace OHOS {
constexpr uint32_t MIN_DATA_USE_TIME = 4;
static bool InstallAppCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, uint32_t store,
struct CmBlob *keyUri)
{
uint8_t certAliasBuf[] = "keyA";
struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetCmBlobFromBuffer(tmpData, remainSize, offset, keyUri)) {
return false;
}
}
const struct CmBlob appCert = { sizeof(g_rsa2048P12CertInfo), const_cast<uint8_t *>(g_rsa2048P12CertInfo) };
const struct CmBlob appCertPwd = { sizeof(g_certPwd), const_cast<uint8_t *>(g_certPwd) };
struct CmParam params01[] = {
{ .tag = CM_TAG_PARAM0_BUFFER, .blob = appCert },
{ .tag = CM_TAG_PARAM1_BUFFER, .blob = appCertPwd },
{ .tag = CM_TAG_PARAM2_BUFFER, .blob = certAlias },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
{ .tag = CM_TAG_PARAM1_UINT32, .uint32Param = TEST_USERID },
};
struct CmParamSet *paramSet01 = NULL;
int32_t ret = CmParamsToParamSet(params01, CM_ARRAY_SIZE(params01), &paramSet01);
if (ret != CM_SUCCESS) {
return false;
}
struct CmBlob paramSetBlob = { paramSet01->paramSetSize, reinterpret_cast<uint8_t *>(paramSet01) };
(void)CmIpcServiceInstallAppCert(&paramSetBlob, keyUri, nullptr);
CmFreeParamSet(&paramSet01);
return true;
}
static bool GetAllAppCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, uint32_t store)
{
struct CmParam params02[] = { { .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store } };
struct CmParamSet *paramSet02 = NULL;
int32_t ret = CmParamsToParamSet(params02, CM_ARRAY_SIZE(params02), &paramSet02);
if (ret != CM_SUCCESS) {
return false;
}
struct CmBlob paramSetBlob = { paramSet02->paramSetSize, reinterpret_cast<uint8_t *>(paramSet02) };
(void)CmIpcServiceGetAppCertList(&paramSetBlob, nullptr, nullptr);
CmFreeParamSet(&paramSet02);
return true;
}
static bool GetAppCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, uint32_t store,
struct CmBlob *keyUri)
{
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetCmBlobFromBuffer(tmpData, remainSize, offset, keyUri)) {
return false;
}
}
struct CmParam params03[] = {
{ .tag = CM_TAG_PARAM0_BUFFER, .blob = *keyUri },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
};
struct CmParamSet *paramSet03 = NULL;
int32_t ret = CmParamsToParamSet(params03, CM_ARRAY_SIZE(params03), &paramSet03);
if (ret != CM_SUCCESS) {
return false;
}
struct CmBlob paramSetBlob = { paramSet03->paramSetSize, reinterpret_cast<uint8_t *>(paramSet03) };
(void)CmIpcServiceGetAppCert(&paramSetBlob, nullptr, nullptr);
CmFreeParamSet(&paramSet03);
return true;
}
static bool UnInstallAppCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, uint32_t store,
struct CmBlob *keyUri)
{
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetCmBlobFromBuffer(tmpData, remainSize, offset, keyUri)) {
return false;
}
}
struct CmParam params04[] = {
{ .tag = CM_TAG_PARAM0_BUFFER, .blob = *keyUri },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
};
struct CmParamSet *paramSet04 = NULL;
int32_t ret = CmParamsToParamSet(params04, CM_ARRAY_SIZE(params04), &paramSet04);
if (ret != CM_SUCCESS) {
return false;
}
struct CmBlob paramSetBlob = { paramSet04->paramSetSize, reinterpret_cast<uint8_t *>(paramSet04) };
(void)CmIpcServiceUninstallAppCert(&paramSetBlob, nullptr, nullptr);
CmFreeParamSet(&paramSet04);
return true;
}
bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
{
uint8_t *tmpData = nullptr;
if (!CopyMyData(data, size, sizeof(uint32_t) * MIN_DATA_USE_TIME, &tmpData)) {
return false;
}
uint32_t remainSize = static_cast<uint32_t>(size);
uint32_t offset = 0;
CertmanagerTest::SetATPermission();
uint32_t store;
if (!GetUintFromBuffer(tmpData, &remainSize, &offset, &store)) {
CmFree(tmpData);
return false;
}
store %= CM_SYS_CREDENTIAL_STORE + 1;
bool ret = false;
uint8_t uriBuf[MAX_LEN_URI] = {0};
struct CmBlob keyUri = { sizeof(uriBuf), uriBuf };
do {
if (!InstallAppCert(tmpData, &remainSize, &offset, store, &keyUri)) {
break;
}
if (!GetAllAppCert(tmpData, &remainSize, &offset, store)) {
break;
}
if (!GetAppCert(tmpData, &remainSize, &offset, store, &keyUri)) {
break;
}
if (!UnInstallAppCert(tmpData, &remainSize, &offset, store, &keyUri)) {
break;
}
} while (0);
(void)CmIpcServiceUninstallAllAppCert(nullptr, nullptr, nullptr);
CmFree(tmpData);
return ret;
}
}
/* Fuzzer entry point */
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
OHOS::DoSomethingInterestingWithMyAPI(data, size);
return 0;
}

18
test/fuzz_test/cmappcert_fuzzer/cmappcert_fuzzer.h Normal file
View File

@ -0,0 +1,18 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FUZZ_PROJECT_NAME
#define FUZZ_PROJECT_NAME "cmappcert_fuzzer"
#endif

13
test/fuzz_test/cmappcert_fuzzer/corpus/init Normal file
View File

@ -0,0 +1,13 @@
# Copyright (c) 2024 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
FUZZ

25
test/fuzz_test/cmappcert_fuzzer/project.xml Normal file
View File

@ -0,0 +1,25 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (c) 2024 Huawei Device Co., Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<fuzz_config>
<fuzztest>
<!-- maximum length of a test input -->
<max_len>1000</max_len>
<!-- maximum total time in seconds to run the fuzzer -->
<max_total_time>300</max_total_time>
<!-- memory usage limit in Mb -->
<rss_limit_mb>4096</rss_limit_mb>
</fuzztest>
</fuzz_config>

63
test/fuzz_test/cmsystemtrustedstore_fuzzer/BUILD.gn Normal file
View File

@ -0,0 +1,63 @@
# Copyright (c) 2024 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("//build/config/features.gni")
import("//build/test.gni")
module_output_path = "certificate_manager/certificate_manager"
##############################fuzztest##########################################
ohos_fuzztest("CmSystemTrustedStoreFuzzTest") {
module_out_path = module_output_path
fuzz_config_file = "../../../test/fuzz_test/cmsystemtrustedstore_fuzzer"
include_dirs = [
"../../../frameworks/cert_manager_standard/main/common/include",
"../../../frameworks/cert_manager_standard/main/os_dependency/cm_ipc/include",
"../../../interfaces/innerkits/cert_manager_standard/main/include",
"../../../services/cert_manager_standard/cert_manager_service/main/os_dependency/idl/cm_ipc",
"../../../services/cert_manager_standard/cert_manager_engine/main/core/include",
"../../../test/unittest/include",
]
cflags = [
"-g",
"-O0",
"-Wno-unused-variable",
"-fno-omit-frame-pointer",
]
sources = [
"../../../test/unittest/src/cm_test_common.cpp",
"cmsystemtrustedstore_fuzzer.cpp",
]
deps = [
"../../../services/cert_manager_standard:cert_manager_service",
"../../../test/fuzz_test/fuzz_test_common:libcert_manager_fuzz_test_common_static",
]
external_deps = [
"access_token:libaccesstoken_sdk",
"access_token:libnativetoken",
"access_token:libtoken_setproc",
]
}
###############################################################################
group("fuzztest") {
testonly = true
deps = []
deps += [
# deps file
":CmSystemTrustedStoreFuzzTest",
]
}
###############################################################################

172
test/fuzz_test/cmsystemtrustedstore_fuzzer/cmsystemtrustedstore_fuzzer.cpp Normal file
View File

@ -0,0 +1,172 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "cmsystemtrustedstore_fuzzer.h"
#include "cm_fuzz_test_common.h"
#include "cert_manager_api.h"
#include "cm_test_common.h"
#include "cm_ipc_client_serialization.h"
#include "cm_ipc_service.h"
#include "cm_param.h"
#include "cert_manager_status.h"
using namespace CmFuzzTest;
namespace OHOS {
constexpr uint32_t MIN_DATA_USE_TIME = 6;
static bool SetSysCertStatus(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, struct CmBlob *keyUri)
{
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetCmBlobFromBuffer(tmpData, remainSize, offset, keyUri)) {
return false;
}
}
uint32_t store = CM_SYSTEM_TRUSTED_STORE;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &store)) {
return false;
}
}
uint32_t state = CERT_STATUS_ENABLED;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &state)) {
return false;
}
}
struct CmParam params01[] = {
{ .tag = CM_TAG_PARAM0_BUFFER, .blob = *keyUri },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = state },
};
struct CmParamSet *paramSet01 = nullptr;
int32_t ret = CmParamsToParamSet(&params01[0], CM_ARRAY_SIZE(params01), &paramSet01);
if (ret != CM_SUCCESS) {
return false;
}
struct CmBlob paramSetBlob = { paramSet01->paramSetSize, reinterpret_cast<uint8_t*>(paramSet01) };
(void)CmIpcServiceSetCertStatus(&paramSetBlob, nullptr, nullptr);
CmFreeParamSet(&paramSet01);
return true;
}
static bool GetAllSysCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset)
{
uint32_t store = CM_SYSTEM_TRUSTED_STORE;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &store)) {
return false;
}
}
uint8_t *certListBlobData = reinterpret_cast<uint8_t *>(CmMalloc(CERT_LIST_LEN));
if (certListBlobData == nullptr) {
return false;
}
struct CmBlob certListBlob = { CERT_LIST_LEN, certListBlobData };
struct CmParam params02[] = {
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
};
struct CmParamSet *paramSet02 = nullptr;
int32_t ret = CmParamsToParamSet(&params02[0], CM_ARRAY_SIZE(params02), &paramSet02);
if (ret != CM_SUCCESS) {
CmFree(certListBlobData);
return false;
}
struct CmBlob paramSetBlob = { paramSet02->paramSetSize, reinterpret_cast<uint8_t*>(paramSet02) };
(void)CmIpcServiceGetCertificateList(&paramSetBlob, &certListBlob, nullptr);
CmFree(certListBlobData);
CmFreeParamSet(&paramSet02);
return true;
}
static bool GetSysCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, struct CmBlob *keyUri)
{
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetCmBlobFromBuffer(tmpData, remainSize, offset, keyUri)) {
return false;
}
}
uint32_t store = CM_SYSTEM_TRUSTED_STORE;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &store)) {
return false;
}
}
uint8_t *certInfoData = reinterpret_cast<uint8_t *>(CmMalloc(CERT_INFO_LEN));
if (certInfoData == nullptr) {
return false;
}
CmBlob certInfoBlob = { CERT_INFO_LEN, certInfoData };
struct CmParam params03[] = {
{ .tag = CM_TAG_PARAM0_BUFFER, .blob = *keyUri },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
};
struct CmParamSet *paramSet03 = nullptr;
int32_t ret = CmParamsToParamSet(&params03[0], CM_ARRAY_SIZE(params03), &paramSet03);
if (ret != CM_SUCCESS) {
CmFree(certInfoData);
return false;
}
struct CmBlob paramSetBlob = { paramSet03->paramSetSize, reinterpret_cast<uint8_t*>(paramSet03) };
(void)CmIpcServiceGetCertificateInfo(&paramSetBlob, &certInfoBlob, nullptr);
CmFree(certInfoData);
CmFreeParamSet(&paramSet03);
return true;
}
bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
{
uint8_t *tmpData = nullptr;
if (!CopyMyData(data, size, sizeof(uint32_t) * MIN_DATA_USE_TIME, &tmpData)) {
return false;
}
uint32_t remainSize = static_cast<uint32_t>(size);
uint32_t offset = 0;
CertmanagerTest::SetATPermission();
bool ret = false;
uint8_t keyUriData[] = "1d3472b9.0";
struct CmBlob keyUri = { sizeof(keyUriData), &keyUriData[0] };
do {
if (!SetSysCertStatus(tmpData, &remainSize, &offset, &keyUri)) {
break;
}
if (!GetAllSysCert(tmpData, &remainSize, &offset)) {
break;
}
if (!GetSysCert(tmpData, &remainSize, &offset, &keyUri)) {
break;
}
} while (0);
CmFree(tmpData);
return ret;
}
}
/* Fuzzer entry point */
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
OHOS::DoSomethingInterestingWithMyAPI(data, size);
return 0;
}

18
test/fuzz_test/cmsystemtrustedstore_fuzzer/cmsystemtrustedstore_fuzzer.h Normal file
View File

@ -0,0 +1,18 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FUZZ_PROJECT_NAME
#define FUZZ_PROJECT_NAME "cmsystemtrustedstore_fuzzer"
#endif

13
test/fuzz_test/cmsystemtrustedstore_fuzzer/corpus/init Normal file
View File

@ -0,0 +1,13 @@
# Copyright (c) 2024 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
FUZZ

25
test/fuzz_test/cmsystemtrustedstore_fuzzer/project.xml Normal file
View File

@ -0,0 +1,25 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (c) 2024 Huawei Device Co., Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<fuzz_config>
<fuzztest>
<!-- maximum length of a test input -->
<max_len>1000</max_len>
<!-- maximum total time in seconds to run the fuzzer -->
<max_total_time>300</max_total_time>
<!-- memory usage limit in Mb -->
<rss_limit_mb>4096</rss_limit_mb>
</fuzztest>
</fuzz_config>

63
test/fuzz_test/cmusertrustedstore_fuzzer/BUILD.gn Normal file
View File

@ -0,0 +1,63 @@
# Copyright (c) 2024 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("//build/config/features.gni")
import("//build/test.gni")
module_output_path = "certificate_manager/certificate_manager"
##############################fuzztest##########################################
ohos_fuzztest("CmUserTrustedStoreFuzzTest") {
module_out_path = module_output_path
fuzz_config_file = "../../../test/fuzz_test/cmusertrustedstore_fuzzer"
include_dirs = [
"../../../frameworks/cert_manager_standard/main/common/include",
"../../../frameworks/cert_manager_standard/main/os_dependency/cm_ipc/include",
"../../../interfaces/innerkits/cert_manager_standard/main/include",
"../../../services/cert_manager_standard/cert_manager_service/main/os_dependency/idl/cm_ipc",
"../../../services/cert_manager_standard/cert_manager_engine/main/core/include",
"../../../test/unittest/include",
]
cflags = [
"-g",
"-O0",
"-Wno-unused-variable",
"-fno-omit-frame-pointer",
]
sources = [
"../../../test/unittest/src/cm_test_common.cpp",
"cmusertrustedstore_fuzzer.cpp",
]
deps = [
"../../../services/cert_manager_standard:cert_manager_service",
"../../../test/fuzz_test/fuzz_test_common:libcert_manager_fuzz_test_common_static",
]
external_deps = [
"access_token:libaccesstoken_sdk",
"access_token:libnativetoken",
"access_token:libtoken_setproc",
]
}
###############################################################################
group("fuzztest") {
testonly = true
deps = []
deps += [
# deps file
":CmUserTrustedStoreFuzzTest",
]
}
###############################################################################

245
test/fuzz_test/cmusertrustedstore_fuzzer/cmusertrustedstore_fuzzer.cpp Normal file
View File

@ -0,0 +1,245 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "cmusertrustedstore_fuzzer.h"
#include "cm_fuzz_test_common.h"
#include "cert_manager_api.h"
#include "cm_test_common.h"
#include "cm_cert_data_user.h"
#include "cm_ipc_client_serialization.h"
#include "cm_ipc_service.h"
#include "cm_param.h"
#include "cert_manager_status.h"
using namespace CmFuzzTest;
namespace OHOS {
constexpr uint32_t MIN_DATA_USE_TIME = 10;
static bool InstallUserCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, struct CmBlob *keyUri)
{
uint32_t userId = TEST_USERID;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &userId)) {
return false;
}
}
uint32_t status = CERT_STATUS_ENABLED;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &status)) {
return false;
}
}
struct CmBlob userCert = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
static uint8_t certAliasBuf01[] = "40dc992e";
struct CmBlob certAlias = { sizeof(certAliasBuf01), certAliasBuf01 };
struct CmParam params01[] = {
{ .tag = CM_TAG_PARAM0_BUFFER, .blob = userCert },
{ .tag = CM_TAG_PARAM1_BUFFER, .blob = certAlias },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = userId },
{ .tag = CM_TAG_PARAM1_UINT32, .uint32Param = status },
};
struct CmParamSet *paramSet01 = NULL;
int32_t ret = CmParamsToParamSet(params01, CM_ARRAY_SIZE(params01), &paramSet01);
if (ret != CM_SUCCESS) {
return false;
}
struct CmBlob paramSetBlob = { paramSet01->paramSetSize, reinterpret_cast<uint8_t *>(paramSet01) };
(void)CmIpcServiceInstallUserCert(&paramSetBlob, keyUri, nullptr);
CmFreeParamSet(&paramSet01);
return true;
}
static bool SetUserCertStatus(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, struct CmBlob *keyUri)
{
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetCmBlobFromBuffer(tmpData, remainSize, offset, keyUri)) {
return false;
}
}
uint32_t store = CM_USER_TRUSTED_STORE;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &store)) {
return false;
}
}
uint32_t state = CERT_STATUS_ENABLED;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &state)) {
return false;
}
}
struct CmParam params02[] = {
{ .tag = CM_TAG_PARAM0_BUFFER, .blob = *keyUri },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = state },
};
struct CmParamSet *paramSet02 = nullptr;
int32_t ret = CmParamsToParamSet(&params02[0], CM_ARRAY_SIZE(params02), &paramSet02);
if (ret != CM_SUCCESS) {
return false;
}
struct CmBlob paramSetBlob = { paramSet02->paramSetSize, reinterpret_cast<uint8_t*>(paramSet02) };
(void)CmIpcServiceSetUserCertStatus(&paramSetBlob, nullptr, nullptr);
CmFreeParamSet(&paramSet02);
return true;
}
static bool GetAllUserCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset)
{
uint32_t store = CM_USER_TRUSTED_STORE;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &store)) {
return false;
}
}
uint8_t *certListBlobData = reinterpret_cast<uint8_t *>(CmMalloc(CERT_LIST_LEN));
if (certListBlobData == nullptr) {
return false;
}
struct CmBlob certListBlob = { CERT_LIST_LEN, certListBlobData };
struct CmParam params03[] = {
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
};
struct CmParamSet *paramSet03 = nullptr;
int32_t ret = CmParamsToParamSet(&params03[0], CM_ARRAY_SIZE(params03), &paramSet03);
if (ret != CM_SUCCESS) {
CmFree(certListBlobData);
return false;
}
struct CmBlob paramSetBlob = { paramSet03->paramSetSize, reinterpret_cast<uint8_t*>(paramSet03) };
(void)CmIpcServiceGetUserCertList(&paramSetBlob, &certListBlob, nullptr);
CmFree(certListBlobData);
CmFreeParamSet(&paramSet03);
return true;
}
static bool GetUserCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, struct CmBlob *keyUri)
{
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetCmBlobFromBuffer(tmpData, remainSize, offset, keyUri)) {
return false;
}
}
uint32_t store = CM_USER_TRUSTED_STORE;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &store)) {
return false;
}
}
uint8_t *certInfoData = reinterpret_cast<uint8_t *>(CmMalloc(CERT_INFO_LEN));
if (certInfoData == nullptr) {
return false;
}
CmBlob certInfoBlob = { CERT_INFO_LEN, certInfoData };
struct CmParam params04[] = {
{ .tag = CM_TAG_PARAM0_BUFFER, .blob = *keyUri },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
};
struct CmParamSet *paramSet04 = nullptr;
int32_t ret = CmParamsToParamSet(&params04[0], CM_ARRAY_SIZE(params04), &paramSet04);
if (ret != CM_SUCCESS) {
CmFree(certInfoData);
return false;
}
struct CmBlob paramSetBlob = { paramSet04->paramSetSize, reinterpret_cast<uint8_t*>(paramSet04) };
(void)CmIpcServiceGetUserCertInfo(&paramSetBlob, &certInfoBlob, nullptr);
CmFree(certInfoData);
CmFreeParamSet(&paramSet04);
return true;
}
static bool UnInstallUserCert(uint8_t *tmpData, uint32_t *remainSize, uint32_t *offset, struct CmBlob *keyUri)
{
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetCmBlobFromBuffer(tmpData, remainSize, offset, keyUri)) {
return false;
}
}
uint32_t store = CM_USER_TRUSTED_STORE;
if (TenPercentChanceOfBeingTrue(tmpData, remainSize, offset)) {
if (!GetUintFromBuffer(tmpData, remainSize, offset, &store)) {
return false;
}
}
struct CmParam params05[] = {
{ .tag = CM_TAG_PARAM0_BUFFER, .blob = *keyUri },
{ .tag = CM_TAG_PARAM0_UINT32, .uint32Param = store },
};
struct CmParamSet *paramSet05 = NULL;
int32_t ret = CmParamsToParamSet(params05, CM_ARRAY_SIZE(params05), &paramSet05);
if (ret != CM_SUCCESS) {
return false;
}
struct CmBlob paramSetBlob = { paramSet05->paramSetSize, reinterpret_cast<uint8_t *>(paramSet05) };
(void)CmIpcServiceUninstallUserCert(&paramSetBlob, nullptr, nullptr);
CmFreeParamSet(&paramSet05);
return true;
}
bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
{
uint8_t *tmpData = nullptr;
if (!CopyMyData(data, size, sizeof(uint32_t) * MIN_DATA_USE_TIME, &tmpData)) {
return false;
}
uint32_t remainSize = static_cast<uint32_t>(size);
uint32_t offset = 0;
CertmanagerTest::SetATPermission();
bool ret = false;
uint8_t keyUriData[] = "1d3472b9.0";
struct CmBlob keyUri = { sizeof(keyUriData), &keyUriData[0] };
do {
if (!InstallUserCert(tmpData, &remainSize, &offset, &keyUri)) {
break;
}
if (!SetUserCertStatus(tmpData, &remainSize, &offset, &keyUri)) {
break;
}
if (!GetAllUserCert(tmpData, &remainSize, &offset)) {
break;
}
if (!GetUserCert(tmpData, &remainSize, &offset, &keyUri)) {
break;
}
if (!UnInstallUserCert(tmpData, &remainSize, &offset, &keyUri)) {
break;
}
} while (0);
(void)CmIpcServiceUninstallAllUserCert(nullptr, nullptr, nullptr);
CmFree(tmpData);
return ret;
}
}
/* Fuzzer entry point */
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
OHOS::DoSomethingInterestingWithMyAPI(data, size);
return 0;
}

18
test/fuzz_test/cmusertrustedstore_fuzzer/cmusertrustedstore_fuzzer.h Normal file
View File

@ -0,0 +1,18 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FUZZ_PROJECT_NAME
#define FUZZ_PROJECT_NAME "cmusertrustedstore_fuzzer"
#endif

13
test/fuzz_test/cmusertrustedstore_fuzzer/corpus/init Normal file
View File

@ -0,0 +1,13 @@
# Copyright (c) 2024 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
FUZZ

25
test/fuzz_test/cmusertrustedstore_fuzzer/project.xml Normal file
View File

@ -0,0 +1,25 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (c) 2024 Huawei Device Co., Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<fuzz_config>
<fuzztest>
<!-- maximum length of a test input -->
<max_len>1000</max_len>
<!-- maximum total time in seconds to run the fuzzer -->
<max_total_time>300</max_total_time>
<!-- memory usage limit in Mb -->
<rss_limit_mb>4096</rss_limit_mb>
</fuzztest>
</fuzz_config>

10
test/fuzz_test/fuzz_test_common/include/cm_fuzz_test_common.h
View File

@ -23,6 +23,12 @@
#include "securec.h"
namespace CmFuzzTest {
constexpr uint32_t CERT_INFO_LEN = sizeof(uint32_t) + MAX_LEN_CERTIFICATE + sizeof(uint32_t) +
MAX_LEN_CERT_ALIAS + sizeof(uint32_t);
constexpr uint32_t CERT_LIST_LEN = sizeof(uint32_t) + (sizeof(uint32_t) + MAX_LEN_SUBJECT_NAME + sizeof(uint32_t) +
sizeof(uint32_t) + MAX_LEN_URI + sizeof(uint32_t) + MAX_LEN_CERT_ALIAS) * MAX_COUNT_CERTIFICATE;
bool GetUintFromBuffer(uint8_t *srcData, uint32_t *remSize, uint32_t *offset, uint32_t *outVal);
bool GetCmBlobFromBuffer(uint8_t *srcData, uint32_t *remSize, uint32_t *offset, struct CmBlob *outBlob);
@ -31,6 +37,10 @@ bool GetCertListFromBuffer(uint8_t *srcData, uint32_t *remSize, uint32_t *offset
bool GetCertInfoFromBuffer(uint8_t *srcData, uint32_t *remSize, uint32_t *offset, struct CertInfo *outInfo);
bool TenPercentChanceOfBeingTrue(uint8_t *srcData, uint32_t *remSize, uint32_t *offset);
int32_t GetCertListInitOutData(struct CmBlob *outListBlob);
bool CopyMyData(const uint8_t *data, const size_t size, const uint32_t minSize, uint8_t **myData);
bool ConstructParamSet(uint8_t *srcData, uint32_t *remainSize, uint32_t *offset,

29
test/fuzz_test/fuzz_test_common/src/cm_fuzz_test_common.cpp
View File

@ -19,6 +19,8 @@
#include "message_parcel.h"
namespace CmFuzzTest {
constexpr uint32_t NUM_10 = 10;
constexpr uint32_t NUM_9 = 9;
bool GetUintFromBuffer(uint8_t *srcData, uint32_t *remSize, uint32_t *offset, uint32_t *outVal)
{
if (*remSize < sizeof(uint32_t)) {
@ -80,6 +82,33 @@ bool GetCertInfoFromBuffer(uint8_t *srcData, uint32_t *remSize, uint32_t *offset
return true;
}
bool TenPercentChanceOfBeingTrue(uint8_t *srcData, uint32_t *remSize, uint32_t *offset)
{
if (srcData == nullptr || remSize == nullptr || offset == nullptr) {
return false;
}
uint32_t randomNum = 0;
if (!GetUintFromBuffer(srcData, remSize, offset, &randomNum)) {
return false;
}
return (randomNum %= NUM_10) == NUM_9;
}
int32_t GetCertListInitOutData(struct CmBlob *outListBlob)
{
/* buff struct: certCount + MAX_CERT_COUNT * (subjectBlob + status + uriBlob + aliasBlob) */
uint32_t buffSize = sizeof(uint32_t) + (sizeof(uint32_t) + MAX_LEN_SUBJECT_NAME + sizeof(uint32_t) +
sizeof(uint32_t) + MAX_LEN_URI + sizeof(uint32_t) + MAX_LEN_CERT_ALIAS) * MAX_COUNT_CERTIFICATE;
outListBlob->data = (uint8_t *)CmMalloc(buffSize);
if (outListBlob->data == NULL) {
return CMR_ERROR_MALLOC_FAIL;
}
outListBlob->size = buffSize;
return CM_SUCCESS;
}
bool CopyMyData(const uint8_t *data, const size_t size, const uint32_t minSize, uint8_t **myData)
{
if (data == nullptr|| static_cast<uint32_t>(size) < minSize) {

334
test/unittest/include/cm_cert_data_user.h Normal file
View File

@ -0,0 +1,334 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef CM_CERT_DATA_USER_H
#define CM_CERT_DATA_USER_H
static const uint8_t g_certData01[] = { /* 40dc992e.0 */
0x30, 0x82, 0x04, 0x31, 0x30, 0x82, 0x03, 0x19, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x01, 0x00,
0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30,
0x81, 0x95, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x47, 0x52, 0x31,
0x44, 0x30, 0x42, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x3b, 0x48, 0x65, 0x6c, 0x6c, 0x65, 0x6e,
0x69, 0x63, 0x20, 0x41, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x69, 0x63, 0x20, 0x61, 0x6e, 0x64, 0x20,
0x52, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x49, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x43, 0x65, 0x72, 0x74, 0x2e, 0x20, 0x41, 0x75, 0x74, 0x68,
0x6f, 0x72, 0x69, 0x74, 0x79, 0x31, 0x40, 0x30, 0x3e, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x37,
0x48, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x69, 0x63, 0x20, 0x41, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x69,
0x63, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x52, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x49,
0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x52, 0x6f, 0x6f, 0x74,
0x43, 0x41, 0x20, 0x32, 0x30, 0x31, 0x31, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x31, 0x31, 0x32, 0x30,
0x36, 0x31, 0x33, 0x34, 0x39, 0x35, 0x32, 0x5a, 0x17, 0x0d, 0x33, 0x31, 0x31, 0x32, 0x30, 0x31,
0x31, 0x33, 0x34, 0x39, 0x35, 0x32, 0x5a, 0x30, 0x81, 0x95, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x06, 0x13, 0x02, 0x47, 0x52, 0x31, 0x44, 0x30, 0x42, 0x06, 0x03, 0x55, 0x04, 0x0a,
0x13, 0x3b, 0x48, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x69, 0x63, 0x20, 0x41, 0x63, 0x61, 0x64, 0x65,
0x6d, 0x69, 0x63, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x52, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68,
0x20, 0x49, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x43, 0x65,
0x72, 0x74, 0x2e, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x31, 0x40, 0x30,
0x3e, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x37, 0x48, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x69, 0x63,
0x20, 0x41, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x69, 0x63, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x52, 0x65,
0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x49, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x43, 0x41, 0x20, 0x32, 0x30, 0x31, 0x31, 0x30,
0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00,
0xa9, 0x53, 0x00, 0xe3, 0x2e, 0xa6, 0xf6, 0x8e, 0xfa, 0x60, 0xd8, 0x2d, 0x95, 0x3e, 0xf8, 0x2c,
0x2a, 0x54, 0x4e, 0xcd, 0xb9, 0x84, 0x61, 0x94, 0x58, 0x4f, 0x8f, 0x3d, 0x8b, 0xe4, 0x43, 0xf3,
0x75, 0x89, 0x8d, 0x51, 0xe4, 0xc3, 0x37, 0xd2, 0x8a, 0x88, 0x4d, 0x79, 0x1e, 0xb7, 0x12, 0xdd,
0x43, 0x78, 0x4a, 0x8a, 0x92, 0xe6, 0xd7, 0x48, 0xd5, 0x0f, 0xa4, 0x3a, 0x29, 0x44, 0x35, 0xb8,
0x07, 0xf6, 0x68, 0x1d, 0x55, 0xcd, 0x38, 0x51, 0xf0, 0x8c, 0x24, 0x31, 0x85, 0xaf, 0x83, 0xc9,
0x7d, 0xe9, 0x77, 0xaf, 0xed, 0x1a, 0x7b, 0x9d, 0x17, 0xf9, 0xb3, 0x9d, 0x38, 0x50, 0x0f, 0xa6,
0x5a, 0x79, 0x91, 0x80, 0xaf, 0x37, 0xae, 0xa6, 0xd3, 0x31, 0xfb, 0xb5, 0x26, 0x09, 0x9d, 0x3c,
0x5a, 0xef, 0x51, 0xc5, 0x2b, 0xdf, 0x96, 0x5d, 0xeb, 0x32, 0x1e, 0x02, 0xda, 0x70, 0x49, 0xec,
0x6e, 0x0c, 0xc8, 0x9a, 0x37, 0x8d, 0xf7, 0xf1, 0x36, 0x60, 0x4b, 0x26, 0x2c, 0x82, 0x9e, 0xd0,
0x78, 0xf3, 0x0d, 0x0f, 0x63, 0xa4, 0x51, 0x30, 0xe1, 0xf9, 0x2b, 0x27, 0x12, 0x07, 0xd8, 0xea,
0xbd, 0x18, 0x62, 0x98, 0xb0, 0x59, 0x37, 0x7d, 0xbe, 0xee, 0xf3, 0x20, 0x51, 0x42, 0x5a, 0x83,
0xef, 0x93, 0xba, 0x69, 0x15, 0xf1, 0x62, 0x9d, 0x9f, 0x99, 0x39, 0x82, 0xa1, 0xb7, 0x74, 0x2e,
0x8b, 0xd4, 0xc5, 0x0b, 0x7b, 0x2f, 0xf0, 0xc8, 0x0a, 0xda, 0x3d, 0x79, 0x0a, 0x9a, 0x93, 0x1c,
0xa5, 0x28, 0x72, 0x73, 0x91, 0x43, 0x9a, 0xa7, 0xd1, 0x4d, 0x85, 0x84, 0xb9, 0xa9, 0x74, 0x8f,
0x14, 0x40, 0xc7, 0xdc, 0xde, 0xac, 0x41, 0x64, 0x6c, 0xb4, 0x19, 0x9b, 0x02, 0x63, 0x6d, 0x24,
0x64, 0x8f, 0x44, 0xb2, 0x25, 0xea, 0xce, 0x5d, 0x74, 0x0c, 0x63, 0x32, 0x5c, 0x8d, 0x87, 0xe5,
0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x81, 0x89, 0x30, 0x81, 0x86, 0x30, 0x0f, 0x06, 0x03, 0x55,
0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0b, 0x06, 0x03,
0x55, 0x1d, 0x0f, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e,
0x04, 0x16, 0x04, 0x14, 0xa6, 0x91, 0x42, 0xfd, 0x13, 0x61, 0x4a, 0x23, 0x9e, 0x08, 0xa4, 0x29,
0xe5, 0xd8, 0x13, 0x04, 0x23, 0xee, 0x41, 0x25, 0x30, 0x47, 0x06, 0x03, 0x55, 0x1d, 0x1e, 0x04,
0x40, 0x30, 0x3e, 0xa0, 0x3c, 0x30, 0x05, 0x82, 0x03, 0x2e, 0x67, 0x72, 0x30, 0x05, 0x82, 0x03,
0x2e, 0x65, 0x75, 0x30, 0x06, 0x82, 0x04, 0x2e, 0x65, 0x64, 0x75, 0x30, 0x06, 0x82, 0x04, 0x2e,
0x6f, 0x72, 0x67, 0x30, 0x05, 0x81, 0x03, 0x2e, 0x67, 0x72, 0x30, 0x05, 0x81, 0x03, 0x2e, 0x65,
0x75, 0x30, 0x06, 0x81, 0x04, 0x2e, 0x65, 0x64, 0x75, 0x30, 0x06, 0x81, 0x04, 0x2e, 0x6f, 0x72,
0x67, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00,
0x03, 0x82, 0x01, 0x01, 0x00, 0x1f, 0xef, 0x79, 0x41, 0xe1, 0x7b, 0x6e, 0x3f, 0xb2, 0x8c, 0x86,
0x37, 0x42, 0x4a, 0x4e, 0x1c, 0x37, 0x1e, 0x8d, 0x66, 0xba, 0x24, 0x81, 0xc9, 0x4f, 0x12, 0x0f,
0x21, 0xc0, 0x03, 0x97, 0x86, 0x25, 0x6d, 0x5d, 0xd3, 0x22, 0x29, 0xa8, 0x6c, 0xa2, 0x0d, 0xa9,
0xeb, 0x3d, 0x06, 0x5b, 0x99, 0x3a, 0xc7, 0xcc, 0xc3, 0x9a, 0x34, 0x7f, 0xab, 0x0e, 0xc8, 0x4e,
0x1c, 0xe1, 0xfa, 0xe4, 0xdc, 0xcd, 0x0d, 0xbe, 0xbf, 0x24, 0xfe, 0x6c, 0xe7, 0x6b, 0xc2, 0x0d,
0xc8, 0x06, 0x9e, 0x4e, 0x8d, 0x61, 0x28, 0xa6, 0x6a, 0xfd, 0xe5, 0xf6, 0x62, 0xea, 0x18, 0x3c,
0x4e, 0xa0, 0x53, 0x9d, 0xb2, 0x3a, 0x9c, 0xeb, 0xa5, 0x9c, 0x91, 0x16, 0xb6, 0x4d, 0x82, 0xe0,
0x0c, 0x05, 0x48, 0xa9, 0x6c, 0xf5, 0xcc, 0xf8, 0xcb, 0x9d, 0x49, 0xb4, 0xf0, 0x02, 0xa5, 0xfd,
0x70, 0x03, 0xed, 0x8a, 0x21, 0xa5, 0xae, 0x13, 0x86, 0x49, 0xc3, 0x33, 0x73, 0xbe, 0x87, 0x3b,
0x74, 0x8b, 0x17, 0x45, 0x26, 0x4c, 0x16, 0x91, 0x83, 0xfe, 0x67, 0x7d, 0xcd, 0x4d, 0x63, 0x67,
0xfa, 0xf3, 0x03, 0x12, 0x96, 0x78, 0x06, 0x8d, 0xb1, 0x67, 0xed, 0x8e, 0x3f, 0xbe, 0x9f, 0x4f,
0x02, 0xf5, 0xb3, 0x09, 0x2f, 0xf3, 0x4c, 0x87, 0xdf, 0x2a, 0xcb, 0x95, 0x7c, 0x01, 0xcc, 0xac,
0x36, 0x7a, 0xbf, 0xa2, 0x73, 0x7a, 0xf7, 0x8f, 0xc1, 0xb5, 0x9a, 0xa1, 0x14, 0xb2, 0x8f, 0x33,
0x9f, 0x0d, 0xef, 0x22, 0xdc, 0x66, 0x7b, 0x84, 0xbd, 0x45, 0x17, 0x06, 0x3d, 0x3c, 0xca, 0xb9,
0x77, 0x34, 0x8f, 0xca, 0xea, 0xcf, 0x3f, 0x31, 0x3e, 0xe3, 0x88, 0xe3, 0x80, 0x49, 0x25, 0xc8,
0x97, 0xb5, 0x9d, 0x9a, 0x99, 0x4d, 0xb0, 0x3c, 0xf8, 0x4a, 0x00, 0x9b, 0x64, 0xdd, 0x9f, 0x39,
0x4b, 0xd1, 0x27, 0xd7, 0xb8
};
static const uint8_t g_certData02[] = { /* 985c1f52.0 */
0x30, 0x82, 0x05, 0x83, 0x30, 0x82, 0x03, 0x6b, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x0e, 0x45,
0xe6, 0xbb, 0x03, 0x83, 0x33, 0xc3, 0x85, 0x65, 0x48, 0xe6, 0xff, 0x45, 0x51, 0x30, 0x0d, 0x06,
0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0c, 0x05, 0x00, 0x30, 0x4c, 0x31, 0x20,
0x30, 0x1e, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x17, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53,
0x69, 0x67, 0x6e, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41, 0x20, 0x2d, 0x20, 0x52, 0x36,
0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0a, 0x47, 0x6c, 0x6f, 0x62, 0x61,
0x6c, 0x53, 0x69, 0x67, 0x6e, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a,
0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x34,
0x31, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x17, 0x0d, 0x33, 0x34, 0x31,
0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x4c, 0x31, 0x20, 0x30, 0x1e,
0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x17, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x69, 0x67,
0x6e, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41, 0x20, 0x2d, 0x20, 0x52, 0x36, 0x31, 0x13,
0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0a, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53,
0x69, 0x67, 0x6e, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x47, 0x6c,
0x6f, 0x62, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x30, 0x82, 0x02, 0x22, 0x30, 0x0d, 0x06, 0x09,
0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x02, 0x0f, 0x00,
0x30, 0x82, 0x02, 0x0a, 0x02, 0x82, 0x02, 0x01, 0x00, 0x95, 0x07, 0xe8, 0x73, 0xca, 0x66, 0xf9,
0xec, 0x14, 0xca, 0x7b, 0x3c, 0xf7, 0x0d, 0x08, 0xf1, 0xb4, 0x45, 0x0b, 0x2c, 0x82, 0xb4, 0x48,
0xc6, 0xeb, 0x5b, 0x3c, 0xae, 0x83, 0xb8, 0x41, 0x92, 0x33, 0x14, 0xa4, 0x6f, 0x7f, 0xe9, 0x2a,
0xcc, 0xc6, 0xb0, 0x88, 0x6b, 0xc5, 0xb6, 0x89, 0xd1, 0xc6, 0xb2, 0xff, 0x14, 0xce, 0x51, 0x14,
0x21, 0xec, 0x4a, 0xdd, 0x1b, 0x5a, 0xc6, 0xd6, 0x87, 0xee, 0x4d, 0x3a, 0x15, 0x06, 0xed, 0x64,
0x66, 0x0b, 0x92, 0x80, 0xca, 0x44, 0xde, 0x73, 0x94, 0x4e, 0xf3, 0xa7, 0x89, 0x7f, 0x4f, 0x78,
0x63, 0x08, 0xc8, 0x12, 0x50, 0x6d, 0x42, 0x66, 0x2f, 0x4d, 0xb9, 0x79, 0x28, 0x4d, 0x52, 0x1a,
0x8a, 0x1a, 0x80, 0xb7, 0x19, 0x81, 0x0e, 0x7e, 0xc4, 0x8a, 0xbc, 0x64, 0x4c, 0x21, 0x1c, 0x43,
0x68, 0xd7, 0x3d, 0x3c, 0x8a, 0xc5, 0xb2, 0x66, 0xd5, 0x90, 0x9a, 0xb7, 0x31, 0x06, 0xc5, 0xbe,
0xe2, 0x6d, 0x32, 0x06, 0xa6, 0x1e, 0xf9, 0xb9, 0xeb, 0xaa, 0xa3, 0xb8, 0xbf, 0xbe, 0x82, 0x63,
0x50, 0xd0, 0xf0, 0x18, 0x89, 0xdf, 0xe4, 0x0f, 0x79, 0xf5, 0xea, 0xa2, 0x1f, 0x2a, 0xd2, 0x70,
0x2e, 0x7b, 0xe7, 0xbc, 0x93, 0xbb, 0x6d, 0x53, 0xe2, 0x48, 0x7c, 0x8c, 0x10, 0x07, 0x38, 0xff,
0x66, 0xb2, 0x77, 0x61, 0x7e, 0xe0, 0xea, 0x8c, 0x3c, 0xaa, 0xb4, 0xa4, 0xf6, 0xf3, 0x95, 0x4a,
0x12, 0x07, 0x6d, 0xfd, 0x8c, 0xb2, 0x89, 0xcf, 0xd0, 0xa0, 0x61, 0x77, 0xc8, 0x58, 0x74, 0xb0,
0xd4, 0x23, 0x3a, 0xf7, 0x5d, 0x3a, 0xca, 0xa2, 0xdb, 0x9d, 0x09, 0xde, 0x5d, 0x44, 0x2d, 0x90,
0xf1, 0x81, 0xcd, 0x57, 0x92, 0xfa, 0x7e, 0xbc, 0x50, 0x04, 0x63, 0x34, 0xdf, 0x6b, 0x93, 0x18,
0xbe, 0x6b, 0x36, 0xb2, 0x39, 0xe4, 0xac, 0x24, 0x36, 0xb7, 0xf0, 0xef, 0xb6, 0x1c, 0x13, 0x57,
0x93, 0xb6, 0xde, 0xb2, 0xf8, 0xe2, 0x85, 0xb7, 0x73, 0xa2, 0xb8, 0x35, 0xaa, 0x45, 0xf2, 0xe0,
0x9d, 0x36, 0xa1, 0x6f, 0x54, 0x8a, 0xf1, 0x72, 0x56, 0x6e, 0x2e, 0x88, 0xc5, 0x51, 0x42, 0x44,
0x15, 0x94, 0xee, 0xa3, 0xc5, 0x38, 0x96, 0x9b, 0x4e, 0x4e, 0x5a, 0x0b, 0x47, 0xf3, 0x06, 0x36,
0x49, 0x77, 0x30, 0xbc, 0x71, 0x37, 0xe5, 0xa6, 0xec, 0x21, 0x08, 0x75, 0xfc, 0xe6, 0x61, 0x16,
0x3f, 0x77, 0xd5, 0xd9, 0x91, 0x97, 0x84, 0x0a, 0x6c, 0xd4, 0x02, 0x4d, 0x74, 0xc0, 0x14, 0xed,
0xfd, 0x39, 0xfb, 0x83, 0xf2, 0x5e, 0x14, 0xa1, 0x04, 0xb0, 0x0b, 0xe9, 0xfe, 0xee, 0x8f, 0xe1,
0x6e, 0x0b, 0xb2, 0x08, 0xb3, 0x61, 0x66, 0x09, 0x6a, 0xb1, 0x06, 0x3a, 0x65, 0x96, 0x59, 0xc0,
0xf0, 0x35, 0xfd, 0xc9, 0xda, 0x28, 0x8d, 0x1a, 0x11, 0x87, 0x70, 0x81, 0x0a, 0xa8, 0x9a, 0x75,
0x1d, 0x9e, 0x3a, 0x86, 0x05, 0x00, 0x9e, 0xdb, 0x80, 0xd6, 0x25, 0xf9, 0xdc, 0x05, 0x9e, 0x27,
0x59, 0x4c, 0x76, 0x39, 0x5b, 0xea, 0xf9, 0xa5, 0xa1, 0xd8, 0x83, 0x0f, 0xd1, 0xff, 0xdf, 0x30,
0x11, 0xf9, 0x85, 0xcf, 0x33, 0x48, 0xf5, 0xca, 0x6d, 0x64, 0x14, 0x2c, 0x7a, 0x58, 0x4f, 0xd3,
0x4b, 0x08, 0x49, 0xc5, 0x95, 0x64, 0x1a, 0x63, 0x0e, 0x79, 0x3d, 0xf5, 0xb3, 0x8c, 0xca, 0x58,
0xad, 0x9c, 0x42, 0x45, 0x79, 0x6e, 0x0e, 0x87, 0x19, 0x5c, 0x54, 0xb1, 0x65, 0xb6, 0xbf, 0x8c,
0x9b, 0xdc, 0x13, 0xe9, 0x0d, 0x6f, 0xb8, 0x2e, 0xdc, 0x67, 0x6e, 0xc9, 0x8b, 0x11, 0xb5, 0x84,
0x14, 0x8a, 0x00, 0x19, 0x70, 0x83, 0x79, 0x91, 0x97, 0x91, 0xd4, 0x1a, 0x27, 0xbf, 0x37, 0x1e,
0x32, 0x07, 0xd8, 0x14, 0x63, 0x3c, 0x28, 0x4c, 0xaf, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x63,
0x30, 0x61, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02,
0x01, 0x06, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03,
0x01, 0x01, 0xff, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xae, 0x6c,
0x05, 0xa3, 0x93, 0x13, 0xe2, 0xa2, 0xe7, 0xe2, 0xd7, 0x1c, 0xd6, 0xc7, 0xf0, 0x7f, 0xc8, 0x67,
0x53, 0xa0, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xae,
0x6c, 0x05, 0xa3, 0x93, 0x13, 0xe2, 0xa2, 0xe7, 0xe2, 0xd7, 0x1c, 0xd6, 0xc7, 0xf0, 0x7f, 0xc8,
0x67, 0x53, 0xa0, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0c,
0x05, 0x00, 0x03, 0x82, 0x02, 0x01, 0x00, 0x83, 0x25, 0xed, 0xe8, 0xd1, 0xfd, 0x95, 0x52, 0xcd,
0x9e, 0xc0, 0x04, 0xa0, 0x91, 0x69, 0xe6, 0x5c, 0xd0, 0x84, 0xde, 0xdc, 0xad, 0xa2, 0x4f, 0xe8,
0x47, 0x78, 0xd6, 0x65, 0x98, 0xa9, 0x5b, 0xa8, 0x3c, 0x87, 0x7c, 0x02, 0x8a, 0xd1, 0x6e, 0xb7,
0x16, 0x73, 0xe6, 0x5f, 0xc0, 0x54, 0x98, 0xd5, 0x74, 0xbe, 0xc1, 0xcd, 0xe2, 0x11, 0x91, 0xad,
0x23, 0x18, 0x3d, 0xdd, 0xe1, 0x72, 0x44, 0x96, 0xb4, 0x95, 0x5e, 0xc0, 0x7b, 0x8e, 0x99, 0x78,
0x16, 0x43, 0x13, 0x56, 0x57, 0xb3, 0xa2, 0xb3, 0x3b, 0xb5, 0x77, 0xdc, 0x40, 0x72, 0xac, 0xa3,
0xeb, 0x9b, 0x35, 0x3e, 0xb1, 0x08, 0x21, 0xa1, 0xe7, 0xc4, 0x43, 0x37, 0x79, 0x32, 0xbe, 0xb5,
0xe7, 0x9c, 0x2c, 0x4c, 0xbc, 0x43, 0x29, 0x99, 0x8e, 0x30, 0xd3, 0xac, 0x21, 0xe0, 0xe3, 0x1d,
0xfa, 0xd8, 0x07, 0x33, 0x76, 0x54, 0x00, 0x22, 0x2a, 0xb9, 0x4d, 0x20, 0x2e, 0x70, 0x68, 0xda,
0xe5, 0x53, 0xfc, 0x83, 0x5c, 0xd3, 0x9d, 0xf2, 0xff, 0x44, 0x0c, 0x44, 0x66, 0xf2, 0xd2, 0xe3,
0xbd, 0x46, 0x00, 0x1a, 0x6d, 0x02, 0xba, 0x25, 0x5d, 0x8d, 0xa1, 0x31, 0x51, 0xdd, 0x54, 0x46,
0x1c, 0x4d, 0xdb, 0x99, 0x96, 0xef, 0x1a, 0x1c, 0x04, 0x5c, 0xa6, 0x15, 0xef, 0x78, 0xe0, 0x79,
0xfe, 0x5d, 0xdb, 0x3e, 0xaa, 0x4c, 0x55, 0xfd, 0x9a, 0x15, 0xa9, 0x6f, 0xe1, 0xa6, 0xfb, 0xdf,
0x70, 0x30, 0xe9, 0xc3, 0xee, 0x42, 0x46, 0xed, 0xc2, 0x93, 0x05, 0x89, 0xfa, 0x7d, 0x63, 0x7b,
0x3f, 0xd0, 0x71, 0x81, 0x7c, 0x00, 0xe8, 0x98, 0xae, 0x0e, 0x78, 0x34, 0xc3, 0x25, 0xfb, 0xaf,
0x0a, 0x9f, 0x20, 0x6b, 0xdd, 0x3b, 0x13, 0x8f, 0x12, 0x8c, 0xe2, 0x41, 0x1a, 0x48, 0x7a, 0x73,
0xa0, 0x77, 0x69, 0xc7, 0xb6, 0x5c, 0x7f, 0x82, 0xc8, 0x1e, 0xfe, 0x58, 0x1b, 0x28, 0x2b, 0xa8,
0x6c, 0xad, 0x5e, 0x6d, 0xc0, 0x05, 0xd2, 0x7b, 0xb7, 0xeb, 0x80, 0xfe, 0x25, 0x37, 0xfe, 0x02,
0x9b, 0x68, 0xac, 0x42, 0x5d, 0xc3, 0xee, 0xf5, 0xcc, 0xdc, 0xf0, 0x50, 0x75, 0xd2, 0x36, 0x69,
0x9c, 0xe6, 0x7b, 0x04, 0xdf, 0x6e, 0x06, 0x69, 0xb6, 0xde, 0x0a, 0x09, 0x48, 0x59, 0x87, 0xeb,
0x7b, 0x14, 0x60, 0x7a, 0x64, 0xaa, 0x69, 0x43, 0xef, 0x91, 0xc7, 0x4c, 0xec, 0x18, 0xdd, 0x6c,
0xef, 0x53, 0x2d, 0x8c, 0x99, 0xe1, 0x5e, 0xf2, 0x72, 0x3e, 0xcf, 0x54, 0xc8, 0xbd, 0x67, 0xec,
0xa4, 0x0f, 0x4c, 0x45, 0xff, 0xd3, 0xb9, 0x30, 0x23, 0x07, 0x4c, 0x8f, 0x10, 0xbf, 0x86, 0x96,
0xd9, 0x99, 0x5a, 0xb4, 0x99, 0x57, 0x1c, 0xa4, 0xcc, 0xbb, 0x15, 0x89, 0x53, 0xba, 0x2c, 0x05,
0x0f, 0xe4, 0xc4, 0x9e, 0x19, 0xb1, 0x18, 0x34, 0xd5, 0x4c, 0x9d, 0xba, 0xed, 0xf7, 0x1f, 0xaf,
0x24, 0x95, 0x04, 0x78, 0xa8, 0x03, 0xbb, 0xee, 0x81, 0xe5, 0xda, 0x5f, 0x7c, 0x8b, 0x4a, 0xa1,
0x90, 0x74, 0x25, 0xa7, 0xb3, 0x3e, 0x4b, 0xc8, 0x2c, 0x56, 0xbd, 0xc7, 0xc8, 0xef, 0x38, 0xe2,
0x5c, 0x92, 0xf0, 0x79, 0xf7, 0x9c, 0x84, 0xba, 0x74, 0x2d, 0x61, 0x01, 0x20, 0x7e, 0x7e, 0xd1,
0xf2, 0x4f, 0x07, 0x59, 0x5f, 0x8b, 0x2d, 0x43, 0x52, 0xeb, 0x46, 0x0c, 0x94, 0xe1, 0xf5, 0x66,
0x47, 0x79, 0x77, 0xd5, 0x54, 0x5b, 0x1f, 0xad, 0x24, 0x37, 0xcb, 0x45, 0x5a, 0x4e, 0xa0, 0x44,
0x48, 0xc8, 0xd8, 0xb0, 0x99, 0xc5, 0x15, 0x84, 0x09, 0xf6, 0xd6, 0x49, 0x49, 0xc0, 0x65, 0xb8,
0xe6, 0x1a, 0x71, 0x6e, 0xa0, 0xa8, 0xf1, 0x82, 0xe8, 0x45, 0x3e, 0x6c, 0xd6, 0x02, 0xd7, 0x0a,
0x67, 0x83, 0x05, 0x5a, 0xc9, 0xa4, 0x10
};
static const uint8_t g_certData03[] = { /* 1df5a75f.0 */
0x30, 0x82, 0x04, 0x33, 0x30, 0x82, 0x03, 0x1b, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x03, 0x09,
0x83, 0xf3, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05,
0x00, 0x30, 0x4d, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x44, 0x45,
0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0c, 0x44, 0x2d, 0x54, 0x72, 0x75,
0x73, 0x74, 0x20, 0x47, 0x6d, 0x62, 0x48, 0x31, 0x27, 0x30, 0x25, 0x06, 0x03, 0x55, 0x04, 0x03,
0x0c, 0x1e, 0x44, 0x2d, 0x54, 0x52, 0x55, 0x53, 0x54, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43,
0x6c, 0x61, 0x73, 0x73, 0x20, 0x33, 0x20, 0x43, 0x41, 0x20, 0x32, 0x20, 0x32, 0x30, 0x30, 0x39,
0x30, 0x1e, 0x17, 0x0d, 0x30, 0x39, 0x31, 0x31, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x35, 0x38,
0x5a, 0x17, 0x0d, 0x32, 0x39, 0x31, 0x31, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x35, 0x38, 0x5a,
0x30, 0x4d, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x44, 0x45, 0x31,
0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0c, 0x44, 0x2d, 0x54, 0x72, 0x75, 0x73,
0x74, 0x20, 0x47, 0x6d, 0x62, 0x48, 0x31, 0x27, 0x30, 0x25, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c,
0x1e, 0x44, 0x2d, 0x54, 0x52, 0x55, 0x53, 0x54, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x6c,
0x61, 0x73, 0x73, 0x20, 0x33, 0x20, 0x43, 0x41, 0x20, 0x32, 0x20, 0x32, 0x30, 0x30, 0x39, 0x30,
0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00,
0xd3, 0xb2, 0x4a, 0xcf, 0x7a, 0x47, 0xef, 0x75, 0x9b, 0x23, 0xfa, 0x3a, 0x2f, 0xd6, 0x50, 0x45,
0x89, 0x35, 0x3a, 0xc6, 0x6b, 0xdb, 0xfe, 0xdb, 0x00, 0x68, 0xa8, 0xe0, 0x03, 0x11, 0x1d, 0x37,
0x50, 0x08, 0x9f, 0x4d, 0x4a, 0x68, 0x94, 0x35, 0xb3, 0x53, 0xd1, 0x94, 0x63, 0xa7, 0x20, 0x56,
0xaf, 0xde, 0x51, 0x78, 0xec, 0x2a, 0x3d, 0xf3, 0x48, 0x48, 0x50, 0x3e, 0x0a, 0xdf, 0x46, 0x55,
0x8b, 0x27, 0x6d, 0xc3, 0x10, 0x4d, 0x0d, 0x91, 0x52, 0x43, 0xd8, 0x87, 0xe0, 0x5d, 0x4e, 0x36,
0xb5, 0x21, 0xca, 0x5f, 0x39, 0x40, 0x04, 0x5f, 0x5b, 0x7e, 0xcc, 0xa3, 0xc6, 0x2b, 0xa9, 0x40,
0x1e, 0xd9, 0x36, 0x84, 0xd6, 0x48, 0xf3, 0x92, 0x1e, 0x34, 0x46, 0x20, 0x24, 0xc1, 0xa4, 0x51,
0x8e, 0x4a, 0x1a, 0xef, 0x50, 0x3f, 0x69, 0x5d, 0x19, 0x7f, 0x45, 0xc3, 0xc7, 0x01, 0x8f, 0x51,
0xc9, 0x23, 0xe8, 0x72, 0xae, 0xb4, 0xbc, 0x56, 0x09, 0x7f, 0x12, 0xcb, 0x1c, 0xb1, 0xaf, 0x29,
0x90, 0x0a, 0xc9, 0x55, 0xcc, 0x0f, 0xd3, 0xb4, 0x1a, 0xed, 0x47, 0x35, 0x5a, 0x4a, 0xed, 0x9c,
0x73, 0x04, 0x21, 0xd0, 0xaa, 0xbd, 0x0c, 0x13, 0xb5, 0x00, 0xca, 0x26, 0x6c, 0xc4, 0x6b, 0x0c,
0x94, 0x5a, 0x95, 0x94, 0xda, 0x50, 0x9a, 0xf1, 0xff, 0xa5, 0x2b, 0x66, 0x31, 0xa4, 0xc9, 0x38,
0xa0, 0xdf, 0x1d, 0x1f, 0xb8, 0x09, 0x2e, 0xf3, 0xa7, 0xe8, 0x67, 0x52, 0xab, 0x95, 0x1f, 0xe0,
0x46, 0x3e, 0xd8, 0xa4, 0xc3, 0xca, 0x5a, 0xc5, 0x31, 0x80, 0xe8, 0x48, 0x9a, 0x9f, 0x94, 0x69,
0xfe, 0x19, 0xdd, 0xd8, 0x73, 0x7c, 0x81, 0xca, 0x96, 0xde, 0x8e, 0xed, 0xb3, 0x32, 0x05, 0x65,
0x84, 0x34, 0xe6, 0xe6, 0xfd, 0x57, 0x10, 0xb5, 0x5f, 0x76, 0xbf, 0x2f, 0xb0, 0x10, 0x0d, 0xc5,
0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x82, 0x01, 0x1a, 0x30, 0x82, 0x01, 0x16, 0x30, 0x0f, 0x06,
0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x1d,
0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xfd, 0xda, 0x14, 0xc4, 0x9f, 0x30, 0xde,
0x21, 0xbd, 0x1e, 0x42, 0x39, 0xfc, 0xab, 0x63, 0x23, 0x49, 0xe0, 0xf1, 0x84, 0x30, 0x0e, 0x06,
0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x81, 0xd3,
0x06, 0x03, 0x55, 0x1d, 0x1f, 0x04, 0x81, 0xcb, 0x30, 0x81, 0xc8, 0x30, 0x81, 0x80, 0xa0, 0x7e,
0xa0, 0x7c, 0x86, 0x7a, 0x6c, 0x64, 0x61, 0x70, 0x3a, 0x2f, 0x2f, 0x64, 0x69, 0x72, 0x65, 0x63,
0x74, 0x6f, 0x72, 0x79, 0x2e, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x2e, 0x6e, 0x65, 0x74,
0x2f, 0x43, 0x4e, 0x3d, 0x44, 0x2d, 0x54, 0x52, 0x55, 0x53, 0x54, 0x25, 0x32, 0x30, 0x52, 0x6f,
0x6f, 0x74, 0x25, 0x32, 0x30, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x25, 0x32, 0x30, 0x33, 0x25, 0x32,
0x30, 0x43, 0x41, 0x25, 0x32, 0x30, 0x32, 0x25, 0x32, 0x30, 0x32, 0x30, 0x30, 0x39, 0x2c, 0x4f,
0x3d, 0x44, 0x2d, 0x54, 0x72, 0x75, 0x73, 0x74, 0x25, 0x32, 0x30, 0x47, 0x6d, 0x62, 0x48, 0x2c,
0x43, 0x3d, 0x44, 0x45, 0x3f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65,
0x72, 0x65, 0x76, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x43,
0xa0, 0x41, 0xa0, 0x3f, 0x86, 0x3d, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
0x2e, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x63, 0x72, 0x6c,
0x2f, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x63, 0x6c,
0x61, 0x73, 0x73, 0x5f, 0x33, 0x5f, 0x63, 0x61, 0x5f, 0x32, 0x5f, 0x32, 0x30, 0x30, 0x39, 0x2e,
0x63, 0x72, 0x6c, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x7f, 0x97, 0xdb, 0x30, 0xc8, 0xdf, 0xa4, 0x9c, 0x7d,
0x21, 0x7a, 0x80, 0x70, 0xce, 0x14, 0x12, 0x69, 0x88, 0x14, 0x95, 0x60, 0x44, 0x01, 0xac, 0xb2,
0xe9, 0x30, 0x4f, 0x9b, 0x50, 0xc2, 0x66, 0xd8, 0x7e, 0x8d, 0x30, 0xb5, 0x70, 0x31, 0xe9, 0xe2,
0x69, 0xc7, 0xf3, 0x70, 0xdb, 0x20, 0x15, 0x86, 0xd0, 0x0d, 0xf0, 0xbe, 0xac, 0x01, 0x75, 0x84,
0xce, 0x7e, 0x9f, 0x4d, 0xbf, 0xb7, 0x60, 0x3b, 0x9c, 0xf3, 0xca, 0x1d, 0xe2, 0x5e, 0x68, 0xd8,
0xa3, 0x9d, 0x97, 0xe5, 0x40, 0x60, 0xd2, 0x36, 0x21, 0xfe, 0xd0, 0xb4, 0xb8, 0x17, 0xda, 0x74,
0xa3, 0x7f, 0xd4, 0xdf, 0xb0, 0x98, 0x02, 0xac, 0x6f, 0x6b, 0x6b, 0x2c, 0x25, 0x24, 0x72, 0xa1,
0x65, 0xee, 0x25, 0x5a, 0xe5, 0xe6, 0x32, 0xe7, 0xf2, 0xdf, 0xab, 0x49, 0xfa, 0xf3, 0x90, 0x69,
0x23, 0xdb, 0x04, 0xd9, 0xe7, 0x5c, 0x58, 0xfc, 0x65, 0xd4, 0x97, 0xbe, 0xcc, 0xfc, 0x2e, 0x0a,
0xcc, 0x25, 0x2a, 0x35, 0x04, 0xf8, 0x60, 0x91, 0x15, 0x75, 0x3d, 0x41, 0xff, 0x23, 0x1f, 0x19,
0xc8, 0x6c, 0xeb, 0x82, 0x53, 0x04, 0xa6, 0xe4, 0x4c, 0x22, 0x4d, 0x8d, 0x8c, 0xba, 0xce, 0x5b,
0x73, 0xec, 0x64, 0x54, 0x50, 0x6d, 0xd1, 0x9c, 0x55, 0xfb, 0x69, 0xc3, 0x36, 0xc3, 0x8c, 0xbc,
0x3c, 0x85, 0xa6, 0x6b, 0x0a, 0x26, 0x0d, 0xe0, 0x93, 0x98, 0x60, 0xae, 0x7e, 0xc6, 0x24, 0x97,
0x8a, 0x61, 0x5f, 0x91, 0x8e, 0x66, 0x92, 0x09, 0x87, 0x36, 0xcd, 0x8b, 0x9b, 0x2d, 0x3e, 0xf6,
0x51, 0xd4, 0x50, 0xd4, 0x59, 0x28, 0xbd, 0x83, 0xf2, 0xcc, 0x28, 0x7b, 0x53, 0x86, 0x6d, 0xd8,
0x26, 0x88, 0x70, 0xd7, 0xea, 0x91, 0xcd, 0x3e, 0xb9, 0xca, 0xc0, 0x90, 0x6e, 0x5a, 0xc6, 0x5e,
0x74, 0x65, 0xd7, 0x5c, 0xfe, 0xa3, 0xe2
};
static const uint8_t g_certData04[] = { /* invalid data */
0xa0, 0x41, 0xa0, 0x3f, 0x86, 0x3d, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
0x2e, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x63, 0x72, 0x6c,
0x2f, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x63, 0x6c,
0x61, 0x73, 0x73, 0x5f, 0x33, 0x5f, 0x63, 0x61, 0x5f, 0x32, 0x5f, 0x32, 0x30, 0x30, 0x39, 0x2e,
0x63, 0x72, 0x6c, 0x30, 0x0d, 0x06, 0x09, 0x2a
};
static const uint8_t g_certData05[] = { /* 2e0g9ue5 */
0x30, 0x82, 0x02, 0xc1, 0x30, 0x82, 0x01, 0xa9, 0x02, 0x01, 0x01, 0x30, 0x0d, 0x06, 0x09, 0x2a,
0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x1a, 0x31, 0x18, 0x30, 0x16,
0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0f, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x52,
0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x32, 0x31, 0x32, 0x31, 0x36,
0x31, 0x30, 0x33, 0x38, 0x31, 0x39, 0x5a, 0x17, 0x0d, 0x32, 0x35, 0x30, 0x39, 0x31, 0x30, 0x31,
0x30, 0x33, 0x38, 0x31, 0x39, 0x5a, 0x30, 0x33, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04,
0x03, 0x0c, 0x06, 0x54, 0x45, 0x53, 0x54, 0x30, 0x31, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55,
0x04, 0x0b, 0x0c, 0x06, 0x54, 0x45, 0x53, 0x54, 0x30, 0x32, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03,
0x55, 0x04, 0x0a, 0x0c, 0x06, 0x54, 0x45, 0x53, 0x54, 0x30, 0x33, 0x30, 0x82, 0x01, 0x22, 0x30,
0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82,
0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xa3, 0x21, 0x49, 0xd7,
0x60, 0xb9, 0x49, 0xe3, 0x40, 0x4e, 0x02, 0x92, 0x07, 0xa6, 0xfb, 0x4a, 0xef, 0x4d, 0xfa, 0x0b,
0xcc, 0xab, 0x5b, 0x7b, 0x1b, 0x86, 0x4f, 0x99, 0x77, 0xb3, 0x52, 0xd8, 0x79, 0x04, 0x1e, 0x80,
0xff, 0xed, 0xb8, 0xfd, 0x51, 0xfe, 0xdd, 0xed, 0xe3, 0xdd, 0x85, 0x76, 0xb0, 0xe4, 0x0a, 0xd7,
0xbf, 0x9a, 0x08, 0x33, 0xa5, 0x24, 0x37, 0xb1, 0xe6, 0x18, 0x9e, 0x32, 0xb6, 0x49, 0x4c, 0xcf,
0x8c, 0x94, 0x75, 0xd3, 0xf9, 0x44, 0xe2, 0xb5, 0xa4, 0xe2, 0x86, 0x6d, 0x0c, 0xef, 0x89, 0xf2,
0x71, 0x06, 0x8a, 0x3a, 0x08, 0xaf, 0x11, 0x46, 0x08, 0xc5, 0xa6, 0x45, 0x37, 0x2f, 0x69, 0x1a,
0xc6, 0x2d, 0x56, 0xa3, 0x4b, 0x72, 0x98, 0x1f, 0x66, 0x58, 0x66, 0x29, 0x69, 0x1e, 0xb6, 0xdc,
0xe0, 0x50, 0x95, 0xd2, 0x5b, 0xa4, 0xf1, 0x3d, 0xc6, 0xac, 0x82, 0x05, 0x52, 0x3e, 0xef, 0x61,
0x5d, 0xa1, 0x8d, 0x17, 0x6b, 0x8d, 0xff, 0x1f, 0x7f, 0xe7, 0xa9, 0x07, 0x2a, 0x6f, 0x3f, 0xca,
0xaa, 0xfa, 0x4b, 0x4f, 0x0d, 0x2f, 0xf7, 0xa8, 0xae, 0x42, 0x6d, 0x8c, 0x83, 0xb0, 0x2b, 0x42,
0xec, 0x7d, 0x93, 0xd9, 0xb1, 0xbd, 0xbd, 0xa6, 0x59, 0x49, 0xe2, 0x70, 0xe4, 0x5b, 0x45, 0xa9,
0xdf, 0x9d, 0xbd, 0x11, 0xe1, 0xbc, 0xd9, 0x7e, 0x91, 0xc6, 0x4f, 0x40, 0xd7, 0xfb, 0x33, 0x51,
0xc0, 0x9b, 0x4f, 0x94, 0x53, 0xd7, 0x89, 0x26, 0x69, 0x4e, 0x58, 0x79, 0xcd, 0x68, 0x76, 0x64,
0xbe, 0x25, 0xee, 0xce, 0xde, 0x2b, 0xaf, 0x05, 0x93, 0x57, 0xb6, 0x6f, 0x67, 0x09, 0x26, 0x13,
0xb9, 0x5a, 0xbc, 0x6a, 0xc8, 0x4e, 0x37, 0xf1, 0x2c, 0xf9, 0x2d, 0x03, 0x62, 0x35, 0x83, 0x67,
0x5b, 0x56, 0xe4, 0xb2, 0xb5, 0x7e, 0x9e, 0x2a, 0x2a, 0x9e, 0xef, 0x21, 0x02, 0x03, 0x01, 0x00,
0x01, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00,
0x03, 0x82, 0x01, 0x01, 0x00, 0x8f, 0x54, 0xb6, 0x5a, 0x0b, 0x49, 0x1d, 0x9c, 0x3b, 0x26, 0xc9,
0x33, 0x47, 0x83, 0xd2, 0x56, 0x5f, 0xa2, 0x2e, 0x2f, 0x49, 0x40, 0x49, 0x08, 0xf3, 0x9b, 0xfd,
0x4d, 0x7b, 0x00, 0xdb, 0xb5, 0xec, 0xe0, 0x48, 0xc6, 0x2d, 0xcc, 0x7d, 0x98, 0xa0, 0x99, 0x6d,
0x35, 0xf2, 0xcc, 0x92, 0x84, 0xbc, 0xa6, 0xa6, 0x01, 0x8f, 0x29, 0x8d, 0xa4, 0x43, 0x8b, 0x1c,
0xd6, 0x6e, 0x44, 0x25, 0x46, 0x44, 0xe0, 0xa0, 0x91, 0xdc, 0x80, 0xa4, 0xbb, 0x01, 0x04, 0xba,
0x69, 0x00, 0xd9, 0xbd, 0x88, 0xa0, 0x3e, 0x7d, 0xe2, 0xca, 0x88, 0x0e, 0x99, 0x08, 0x5d, 0xd9,
0x4f, 0x6a, 0x22, 0xbf, 0x8d, 0xeb, 0xd5, 0xfa, 0xe0, 0x7f, 0xbd, 0x5e, 0x34, 0x0b, 0xd3, 0xec,
0x0b, 0x0c, 0x83, 0x93, 0xde, 0xd8, 0xf6, 0x4f, 0x7c, 0x66, 0x23, 0x6d, 0xb9, 0x4a, 0xd4, 0xd3,
0xd5, 0x16, 0x99, 0x65, 0x69, 0x7f, 0xd6, 0x29, 0x67, 0x63, 0xd5, 0xcc, 0xfd, 0xe7, 0x1c, 0x7a,
0x96, 0x68, 0x16, 0x1f, 0xc9, 0x24, 0xd6, 0xaf, 0x9f, 0xd0, 0xd3, 0x5d, 0xc6, 0x70, 0xcf, 0x5d,
0x10, 0x47, 0x59, 0x0c, 0x16, 0xae, 0x19, 0x89, 0x35, 0x7b, 0xe4, 0x42, 0xb7, 0x62, 0x67, 0x2d,
0xcc, 0xcd, 0x8d, 0x52, 0x4d, 0xa3, 0xf3, 0x4f, 0x44, 0x47, 0xcf, 0xf3, 0x57, 0x96, 0xab, 0xef,
0xd5, 0xe8, 0x8c, 0xf6, 0xca, 0xed, 0x4b, 0x40, 0xae, 0xad, 0x6a, 0x03, 0xb5, 0x7a, 0xb6, 0xc8,
0x59, 0x7d, 0x32, 0x2f, 0x52, 0x6a, 0x29, 0x01, 0x51, 0xd1, 0x81, 0xe0, 0x8b, 0xb5, 0x1c, 0xaa,
0x09, 0xdb, 0x1c, 0x86, 0xbc, 0xd6, 0x95, 0x7c, 0x18, 0x1e, 0x53, 0x8d, 0x63, 0xf1, 0xc0, 0xae,
0x86, 0x91, 0x12, 0x67, 0xe0, 0x93, 0x78, 0xbf, 0x1a, 0x63, 0x27, 0x0a, 0x14, 0x29, 0x8d, 0x5f,
0x59, 0xae, 0x6b, 0x04, 0x1b
};
static char g_certData06[] =
"-----BEGIN CERTIFICATE-----\r\n"
"MIID6jCCAtKgAwIBAgIIIM2q/TmRoLcwDQYJKoZIhvcNAQELBQAwWjELMAkGA1UE\r\n"
"BhMCRU4xEDAOBgNVBAgTB0VuZ2xhbmQxDzANBgNVBAcTBkxvbmRvbjEMMAoGA1UE\r\n"
"ChMDdHMyMQwwCgYDVQQLEwN0czIxDDAKBgNVBAMTA3RzMjAeFw0yMzEyMDUwNzM5\r\n"
"MDBaFw0yNDEwMzEyMzU5MDBaMGExCzAJBgNVBAYTAkNOMRAwDgYDVQQIEwdKaWFu\r\n"
"Z3N1MRAwDgYDVQQHEwdOYW5qaW5nMQwwCgYDVQQKEwN0czMxDDAKBgNVBAsTA3Rz\r\n"
"MzESMBAGA1UEAxMJMTI3LjAuMC4xMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB\r\n"
"CgKCAQEAtt+2QxUevbolYLp51QGcUpageI4fwGLIqv4fj4aoVnHFOOBqVOVpfCLR\r\n"
"p26LFV/F8ebwPyo8YEBKSwXzMD1573rMSbaH9BalscH5lZYAbetXoio6YRvzlcmc\r\n"
"rVvLBNMeVnxY86xHpo0MTNyP7W024rZsxWO98xFQVdoiaBC+7+midlisx2Y+7u0j\r\n"
"zT9GjeUP6JLdLFUZJKUPSTK3jVzw9v1eZQZKYoNfU6vFMd6ndtwW6qEnwpzmmX/U\r\n"
"T+p5ThAMH593zszlz330nTSXBjIsGkyvOz9gSB0Z0LAuJj06XUNhGL5xKJYKbdI3\r\n"
"8MFQFJKvRHfgTAvVsvAvpBUM2DuBKwIDAQABo4GsMIGpMAkGA1UdEwQCMAAwHQYD\r\n"
"VR0OBBYEFDfsHTMZwoA6eaDFlBUyDpka+sYtMAsGA1UdDwQEAwID+DAnBgNVHSUE\r\n"
"IDAeBggrBgEFBQcDAQYIKwYBBQUHAwIGCCsGAQUFBwMEMBQGA1UdEQQNMAuCCTEy\r\n"
"Ny4wLjAuMTARBglghkgBhvhCAQEEBAMCBkAwHgYJYIZIAYb4QgENBBEWD3hjYSBj\r\n"
"ZXJ0aWZpY2F0ZTANBgkqhkiG9w0BAQsFAAOCAQEAp5vTvXrt8ZpgRJVtzv9ss0lJ\r\n"
"izp1fJf+ft5cDXrs7TSD5oHrSW2vk/ZieIMhexU4LFwhs4OE7jK6pgI48Dseqxx7\r\n"
"B/KktxhVMJUmVXd9Ayjp6f+BtZlIk0cArPuoXToXjsV8caTGBXHRdzxpAk/w9syc\r\n"
"GYrbH9TrdNMuTizOb+k268oKXUageZNxHmd7YvOXkcNgrd29jzwXKDYYiUa1DISz\r\n"
"DnYaJOgPt0B/5izhoWNK7GhJDy9KEuLURcTSWFysbbnljwO9INPT9MmlS83PdAgN\r\n"
"iS8VXF4pce1W9U5jH7d7k0JDVSXybebe1iPFphsZpYM/NE+jap+mPy1nTCbf9g==\r\n"
"-----END CERTIFICATE-----\r\n";
#endif /* CM_CERT_DATA_USER_H */

316
test/unittest/src/cm_user_cert_test.cpp
View File

@ -19,327 +19,13 @@
#include "cert_manager_api.h"
#include "cm_log.h"
#include "cm_mem.h"
#include "cm_cert_data_user.h"
using namespace testing::ext;
using namespace CertmanagerTest;
namespace {
constexpr uint32_t MAX_URI_LEN = 256;
static const uint8_t g_certData01[] = { /* 40dc992e.0 */
0x30, 0x82, 0x04, 0x31, 0x30, 0x82, 0x03, 0x19, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x01, 0x00,
0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30,
0x81, 0x95, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x47, 0x52, 0x31,
0x44, 0x30, 0x42, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x3b, 0x48, 0x65, 0x6c, 0x6c, 0x65, 0x6e,
0x69, 0x63, 0x20, 0x41, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x69, 0x63, 0x20, 0x61, 0x6e, 0x64, 0x20,
0x52, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x49, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x43, 0x65, 0x72, 0x74, 0x2e, 0x20, 0x41, 0x75, 0x74, 0x68,
0x6f, 0x72, 0x69, 0x74, 0x79, 0x31, 0x40, 0x30, 0x3e, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x37,
0x48, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x69, 0x63, 0x20, 0x41, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x69,
0x63, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x52, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x49,
0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x52, 0x6f, 0x6f, 0x74,
0x43, 0x41, 0x20, 0x32, 0x30, 0x31, 0x31, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x31, 0x31, 0x32, 0x30,
0x36, 0x31, 0x33, 0x34, 0x39, 0x35, 0x32, 0x5a, 0x17, 0x0d, 0x33, 0x31, 0x31, 0x32, 0x30, 0x31,
0x31, 0x33, 0x34, 0x39, 0x35, 0x32, 0x5a, 0x30, 0x81, 0x95, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x06, 0x13, 0x02, 0x47, 0x52, 0x31, 0x44, 0x30, 0x42, 0x06, 0x03, 0x55, 0x04, 0x0a,
0x13, 0x3b, 0x48, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x69, 0x63, 0x20, 0x41, 0x63, 0x61, 0x64, 0x65,
0x6d, 0x69, 0x63, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x52, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68,
0x20, 0x49, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x43, 0x65,
0x72, 0x74, 0x2e, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x31, 0x40, 0x30,
0x3e, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x37, 0x48, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x69, 0x63,
0x20, 0x41, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x69, 0x63, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x52, 0x65,
0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x49, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x43, 0x41, 0x20, 0x32, 0x30, 0x31, 0x31, 0x30,
0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00,
0xa9, 0x53, 0x00, 0xe3, 0x2e, 0xa6, 0xf6, 0x8e, 0xfa, 0x60, 0xd8, 0x2d, 0x95, 0x3e, 0xf8, 0x2c,
0x2a, 0x54, 0x4e, 0xcd, 0xb9, 0x84, 0x61, 0x94, 0x58, 0x4f, 0x8f, 0x3d, 0x8b, 0xe4, 0x43, 0xf3,
0x75, 0x89, 0x8d, 0x51, 0xe4, 0xc3, 0x37, 0xd2, 0x8a, 0x88, 0x4d, 0x79, 0x1e, 0xb7, 0x12, 0xdd,
0x43, 0x78, 0x4a, 0x8a, 0x92, 0xe6, 0xd7, 0x48, 0xd5, 0x0f, 0xa4, 0x3a, 0x29, 0x44, 0x35, 0xb8,
0x07, 0xf6, 0x68, 0x1d, 0x55, 0xcd, 0x38, 0x51, 0xf0, 0x8c, 0x24, 0x31, 0x85, 0xaf, 0x83, 0xc9,
0x7d, 0xe9, 0x77, 0xaf, 0xed, 0x1a, 0x7b, 0x9d, 0x17, 0xf9, 0xb3, 0x9d, 0x38, 0x50, 0x0f, 0xa6,
0x5a, 0x79, 0x91, 0x80, 0xaf, 0x37, 0xae, 0xa6, 0xd3, 0x31, 0xfb, 0xb5, 0x26, 0x09, 0x9d, 0x3c,
0x5a, 0xef, 0x51, 0xc5, 0x2b, 0xdf, 0x96, 0x5d, 0xeb, 0x32, 0x1e, 0x02, 0xda, 0x70, 0x49, 0xec,
0x6e, 0x0c, 0xc8, 0x9a, 0x37, 0x8d, 0xf7, 0xf1, 0x36, 0x60, 0x4b, 0x26, 0x2c, 0x82, 0x9e, 0xd0,
0x78, 0xf3, 0x0d, 0x0f, 0x63, 0xa4, 0x51, 0x30, 0xe1, 0xf9, 0x2b, 0x27, 0x12, 0x07, 0xd8, 0xea,
0xbd, 0x18, 0x62, 0x98, 0xb0, 0x59, 0x37, 0x7d, 0xbe, 0xee, 0xf3, 0x20, 0x51, 0x42, 0x5a, 0x83,
0xef, 0x93, 0xba, 0x69, 0x15, 0xf1, 0x62, 0x9d, 0x9f, 0x99, 0x39, 0x82, 0xa1, 0xb7, 0x74, 0x2e,
0x8b, 0xd4, 0xc5, 0x0b, 0x7b, 0x2f, 0xf0, 0xc8, 0x0a, 0xda, 0x3d, 0x79, 0x0a, 0x9a, 0x93, 0x1c,
0xa5, 0x28, 0x72, 0x73, 0x91, 0x43, 0x9a, 0xa7, 0xd1, 0x4d, 0x85, 0x84, 0xb9, 0xa9, 0x74, 0x8f,
0x14, 0x40, 0xc7, 0xdc, 0xde, 0xac, 0x41, 0x64, 0x6c, 0xb4, 0x19, 0x9b, 0x02, 0x63, 0x6d, 0x24,
0x64, 0x8f, 0x44, 0xb2, 0x25, 0xea, 0xce, 0x5d, 0x74, 0x0c, 0x63, 0x32, 0x5c, 0x8d, 0x87, 0xe5,
0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x81, 0x89, 0x30, 0x81, 0x86, 0x30, 0x0f, 0x06, 0x03, 0x55,
0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0b, 0x06, 0x03,
0x55, 0x1d, 0x0f, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e,
0x04, 0x16, 0x04, 0x14, 0xa6, 0x91, 0x42, 0xfd, 0x13, 0x61, 0x4a, 0x23, 0x9e, 0x08, 0xa4, 0x29,
0xe5, 0xd8, 0x13, 0x04, 0x23, 0xee, 0x41, 0x25, 0x30, 0x47, 0x06, 0x03, 0x55, 0x1d, 0x1e, 0x04,
0x40, 0x30, 0x3e, 0xa0, 0x3c, 0x30, 0x05, 0x82, 0x03, 0x2e, 0x67, 0x72, 0x30, 0x05, 0x82, 0x03,
0x2e, 0x65, 0x75, 0x30, 0x06, 0x82, 0x04, 0x2e, 0x65, 0x64, 0x75, 0x30, 0x06, 0x82, 0x04, 0x2e,
0x6f, 0x72, 0x67, 0x30, 0x05, 0x81, 0x03, 0x2e, 0x67, 0x72, 0x30, 0x05, 0x81, 0x03, 0x2e, 0x65,
0x75, 0x30, 0x06, 0x81, 0x04, 0x2e, 0x65, 0x64, 0x75, 0x30, 0x06, 0x81, 0x04, 0x2e, 0x6f, 0x72,
0x67, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00,
0x03, 0x82, 0x01, 0x01, 0x00, 0x1f, 0xef, 0x79, 0x41, 0xe1, 0x7b, 0x6e, 0x3f, 0xb2, 0x8c, 0x86,
0x37, 0x42, 0x4a, 0x4e, 0x1c, 0x37, 0x1e, 0x8d, 0x66, 0xba, 0x24, 0x81, 0xc9, 0x4f, 0x12, 0x0f,
0x21, 0xc0, 0x03, 0x97, 0x86, 0x25, 0x6d, 0x5d, 0xd3, 0x22, 0x29, 0xa8, 0x6c, 0xa2, 0x0d, 0xa9,
0xeb, 0x3d, 0x06, 0x5b, 0x99, 0x3a, 0xc7, 0xcc, 0xc3, 0x9a, 0x34, 0x7f, 0xab, 0x0e, 0xc8, 0x4e,
0x1c, 0xe1, 0xfa, 0xe4, 0xdc, 0xcd, 0x0d, 0xbe, 0xbf, 0x24, 0xfe, 0x6c, 0xe7, 0x6b, 0xc2, 0x0d,
0xc8, 0x06, 0x9e, 0x4e, 0x8d, 0x61, 0x28, 0xa6, 0x6a, 0xfd, 0xe5, 0xf6, 0x62, 0xea, 0x18, 0x3c,
0x4e, 0xa0, 0x53, 0x9d, 0xb2, 0x3a, 0x9c, 0xeb, 0xa5, 0x9c, 0x91, 0x16, 0xb6, 0x4d, 0x82, 0xe0,
0x0c, 0x05, 0x48, 0xa9, 0x6c, 0xf5, 0xcc, 0xf8, 0xcb, 0x9d, 0x49, 0xb4, 0xf0, 0x02, 0xa5, 0xfd,
0x70, 0x03, 0xed, 0x8a, 0x21, 0xa5, 0xae, 0x13, 0x86, 0x49, 0xc3, 0x33, 0x73, 0xbe, 0x87, 0x3b,
0x74, 0x8b, 0x17, 0x45, 0x26, 0x4c, 0x16, 0x91, 0x83, 0xfe, 0x67, 0x7d, 0xcd, 0x4d, 0x63, 0x67,
0xfa, 0xf3, 0x03, 0x12, 0x96, 0x78, 0x06, 0x8d, 0xb1, 0x67, 0xed, 0x8e, 0x3f, 0xbe, 0x9f, 0x4f,
0x02, 0xf5, 0xb3, 0x09, 0x2f, 0xf3, 0x4c, 0x87, 0xdf, 0x2a, 0xcb, 0x95, 0x7c, 0x01, 0xcc, 0xac,
0x36, 0x7a, 0xbf, 0xa2, 0x73, 0x7a, 0xf7, 0x8f, 0xc1, 0xb5, 0x9a, 0xa1, 0x14, 0xb2, 0x8f, 0x33,
0x9f, 0x0d, 0xef, 0x22, 0xdc, 0x66, 0x7b, 0x84, 0xbd, 0x45, 0x17, 0x06, 0x3d, 0x3c, 0xca, 0xb9,
0x77, 0x34, 0x8f, 0xca, 0xea, 0xcf, 0x3f, 0x31, 0x3e, 0xe3, 0x88, 0xe3, 0x80, 0x49, 0x25, 0xc8,
0x97, 0xb5, 0x9d, 0x9a, 0x99, 0x4d, 0xb0, 0x3c, 0xf8, 0x4a, 0x00, 0x9b, 0x64, 0xdd, 0x9f, 0x39,
0x4b, 0xd1, 0x27, 0xd7, 0xb8
};
static const uint8_t g_certData02[] = { /* 985c1f52.0 */
0x30, 0x82, 0x05, 0x83, 0x30, 0x82, 0x03, 0x6b, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x0e, 0x45,
0xe6, 0xbb, 0x03, 0x83, 0x33, 0xc3, 0x85, 0x65, 0x48, 0xe6, 0xff, 0x45, 0x51, 0x30, 0x0d, 0x06,
0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0c, 0x05, 0x00, 0x30, 0x4c, 0x31, 0x20,
0x30, 0x1e, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x17, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53,
0x69, 0x67, 0x6e, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41, 0x20, 0x2d, 0x20, 0x52, 0x36,
0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0a, 0x47, 0x6c, 0x6f, 0x62, 0x61,
0x6c, 0x53, 0x69, 0x67, 0x6e, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a,
0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x34,
0x31, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x17, 0x0d, 0x33, 0x34, 0x31,
0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x4c, 0x31, 0x20, 0x30, 0x1e,
0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x17, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x69, 0x67,
0x6e, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41, 0x20, 0x2d, 0x20, 0x52, 0x36, 0x31, 0x13,
0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0a, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53,
0x69, 0x67, 0x6e, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x47, 0x6c,
0x6f, 0x62, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x30, 0x82, 0x02, 0x22, 0x30, 0x0d, 0x06, 0x09,
0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x02, 0x0f, 0x00,
0x30, 0x82, 0x02, 0x0a, 0x02, 0x82, 0x02, 0x01, 0x00, 0x95, 0x07, 0xe8, 0x73, 0xca, 0x66, 0xf9,
0xec, 0x14, 0xca, 0x7b, 0x3c, 0xf7, 0x0d, 0x08, 0xf1, 0xb4, 0x45, 0x0b, 0x2c, 0x82, 0xb4, 0x48,
0xc6, 0xeb, 0x5b, 0x3c, 0xae, 0x83, 0xb8, 0x41, 0x92, 0x33, 0x14, 0xa4, 0x6f, 0x7f, 0xe9, 0x2a,
0xcc, 0xc6, 0xb0, 0x88, 0x6b, 0xc5, 0xb6, 0x89, 0xd1, 0xc6, 0xb2, 0xff, 0x14, 0xce, 0x51, 0x14,
0x21, 0xec, 0x4a, 0xdd, 0x1b, 0x5a, 0xc6, 0xd6, 0x87, 0xee, 0x4d, 0x3a, 0x15, 0x06, 0xed, 0x64,
0x66, 0x0b, 0x92, 0x80, 0xca, 0x44, 0xde, 0x73, 0x94, 0x4e, 0xf3, 0xa7, 0x89, 0x7f, 0x4f, 0x78,
0x63, 0x08, 0xc8, 0x12, 0x50, 0x6d, 0x42, 0x66, 0x2f, 0x4d, 0xb9, 0x79, 0x28, 0x4d, 0x52, 0x1a,
0x8a, 0x1a, 0x80, 0xb7, 0x19, 0x81, 0x0e, 0x7e, 0xc4, 0x8a, 0xbc, 0x64, 0x4c, 0x21, 0x1c, 0x43,
0x68, 0xd7, 0x3d, 0x3c, 0x8a, 0xc5, 0xb2, 0x66, 0xd5, 0x90, 0x9a, 0xb7, 0x31, 0x06, 0xc5, 0xbe,
0xe2, 0x6d, 0x32, 0x06, 0xa6, 0x1e, 0xf9, 0xb9, 0xeb, 0xaa, 0xa3, 0xb8, 0xbf, 0xbe, 0x82, 0x63,
0x50, 0xd0, 0xf0, 0x18, 0x89, 0xdf, 0xe4, 0x0f, 0x79, 0xf5, 0xea, 0xa2, 0x1f, 0x2a, 0xd2, 0x70,
0x2e, 0x7b, 0xe7, 0xbc, 0x93, 0xbb, 0x6d, 0x53, 0xe2, 0x48, 0x7c, 0x8c, 0x10, 0x07, 0x38, 0xff,
0x66, 0xb2, 0x77, 0x61, 0x7e, 0xe0, 0xea, 0x8c, 0x3c, 0xaa, 0xb4, 0xa4, 0xf6, 0xf3, 0x95, 0x4a,
0x12, 0x07, 0x6d, 0xfd, 0x8c, 0xb2, 0x89, 0xcf, 0xd0, 0xa0, 0x61, 0x77, 0xc8, 0x58, 0x74, 0xb0,
0xd4, 0x23, 0x3a, 0xf7, 0x5d, 0x3a, 0xca, 0xa2, 0xdb, 0x9d, 0x09, 0xde, 0x5d, 0x44, 0x2d, 0x90,
0xf1, 0x81, 0xcd, 0x57, 0x92, 0xfa, 0x7e, 0xbc, 0x50, 0x04, 0x63, 0x34, 0xdf, 0x6b, 0x93, 0x18,
0xbe, 0x6b, 0x36, 0xb2, 0x39, 0xe4, 0xac, 0x24, 0x36, 0xb7, 0xf0, 0xef, 0xb6, 0x1c, 0x13, 0x57,
0x93, 0xb6, 0xde, 0xb2, 0xf8, 0xe2, 0x85, 0xb7, 0x73, 0xa2, 0xb8, 0x35, 0xaa, 0x45, 0xf2, 0xe0,
0x9d, 0x36, 0xa1, 0x6f, 0x54, 0x8a, 0xf1, 0x72, 0x56, 0x6e, 0x2e, 0x88, 0xc5, 0x51, 0x42, 0x44,
0x15, 0x94, 0xee, 0xa3, 0xc5, 0x38, 0x96, 0x9b, 0x4e, 0x4e, 0x5a, 0x0b, 0x47, 0xf3, 0x06, 0x36,
0x49, 0x77, 0x30, 0xbc, 0x71, 0x37, 0xe5, 0xa6, 0xec, 0x21, 0x08, 0x75, 0xfc, 0xe6, 0x61, 0x16,
0x3f, 0x77, 0xd5, 0xd9, 0x91, 0x97, 0x84, 0x0a, 0x6c, 0xd4, 0x02, 0x4d, 0x74, 0xc0, 0x14, 0xed,
0xfd, 0x39, 0xfb, 0x83, 0xf2, 0x5e, 0x14, 0xa1, 0x04, 0xb0, 0x0b, 0xe9, 0xfe, 0xee, 0x8f, 0xe1,
0x6e, 0x0b, 0xb2, 0x08, 0xb3, 0x61, 0x66, 0x09, 0x6a, 0xb1, 0x06, 0x3a, 0x65, 0x96, 0x59, 0xc0,
0xf0, 0x35, 0xfd, 0xc9, 0xda, 0x28, 0x8d, 0x1a, 0x11, 0x87, 0x70, 0x81, 0x0a, 0xa8, 0x9a, 0x75,
0x1d, 0x9e, 0x3a, 0x86, 0x05, 0x00, 0x9e, 0xdb, 0x80, 0xd6, 0x25, 0xf9, 0xdc, 0x05, 0x9e, 0x27,
0x59, 0x4c, 0x76, 0x39, 0x5b, 0xea, 0xf9, 0xa5, 0xa1, 0xd8, 0x83, 0x0f, 0xd1, 0xff, 0xdf, 0x30,
0x11, 0xf9, 0x85, 0xcf, 0x33, 0x48, 0xf5, 0xca, 0x6d, 0x64, 0x14, 0x2c, 0x7a, 0x58, 0x4f, 0xd3,
0x4b, 0x08, 0x49, 0xc5, 0x95, 0x64, 0x1a, 0x63, 0x0e, 0x79, 0x3d, 0xf5, 0xb3, 0x8c, 0xca, 0x58,
0xad, 0x9c, 0x42, 0x45, 0x79, 0x6e, 0x0e, 0x87, 0x19, 0x5c, 0x54, 0xb1, 0x65, 0xb6, 0xbf, 0x8c,
0x9b, 0xdc, 0x13, 0xe9, 0x0d, 0x6f, 0xb8, 0x2e, 0xdc, 0x67, 0x6e, 0xc9, 0x8b, 0x11, 0xb5, 0x84,
0x14, 0x8a, 0x00, 0x19, 0x70, 0x83, 0x79, 0x91, 0x97, 0x91, 0xd4, 0x1a, 0x27, 0xbf, 0x37, 0x1e,
0x32, 0x07, 0xd8, 0x14, 0x63, 0x3c, 0x28, 0x4c, 0xaf, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x63,
0x30, 0x61, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02,
0x01, 0x06, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03,
0x01, 0x01, 0xff, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xae, 0x6c,
0x05, 0xa3, 0x93, 0x13, 0xe2, 0xa2, 0xe7, 0xe2, 0xd7, 0x1c, 0xd6, 0xc7, 0xf0, 0x7f, 0xc8, 0x67,
0x53, 0xa0, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xae,
0x6c, 0x05, 0xa3, 0x93, 0x13, 0xe2, 0xa2, 0xe7, 0xe2, 0xd7, 0x1c, 0xd6, 0xc7, 0xf0, 0x7f, 0xc8,
0x67, 0x53, 0xa0, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0c,
0x05, 0x00, 0x03, 0x82, 0x02, 0x01, 0x00, 0x83, 0x25, 0xed, 0xe8, 0xd1, 0xfd, 0x95, 0x52, 0xcd,
0x9e, 0xc0, 0x04, 0xa0, 0x91, 0x69, 0xe6, 0x5c, 0xd0, 0x84, 0xde, 0xdc, 0xad, 0xa2, 0x4f, 0xe8,
0x47, 0x78, 0xd6, 0x65, 0x98, 0xa9, 0x5b, 0xa8, 0x3c, 0x87, 0x7c, 0x02, 0x8a, 0xd1, 0x6e, 0xb7,
0x16, 0x73, 0xe6, 0x5f, 0xc0, 0x54, 0x98, 0xd5, 0x74, 0xbe, 0xc1, 0xcd, 0xe2, 0x11, 0x91, 0xad,
0x23, 0x18, 0x3d, 0xdd, 0xe1, 0x72, 0x44, 0x96, 0xb4, 0x95, 0x5e, 0xc0, 0x7b, 0x8e, 0x99, 0x78,
0x16, 0x43, 0x13, 0x56, 0x57, 0xb3, 0xa2, 0xb3, 0x3b, 0xb5, 0x77, 0xdc, 0x40, 0x72, 0xac, 0xa3,
0xeb, 0x9b, 0x35, 0x3e, 0xb1, 0x08, 0x21, 0xa1, 0xe7, 0xc4, 0x43, 0x37, 0x79, 0x32, 0xbe, 0xb5,
0xe7, 0x9c, 0x2c, 0x4c, 0xbc, 0x43, 0x29, 0x99, 0x8e, 0x30, 0xd3, 0xac, 0x21, 0xe0, 0xe3, 0x1d,
0xfa, 0xd8, 0x07, 0x33, 0x76, 0x54, 0x00, 0x22, 0x2a, 0xb9, 0x4d, 0x20, 0x2e, 0x70, 0x68, 0xda,
0xe5, 0x53, 0xfc, 0x83, 0x5c, 0xd3, 0x9d, 0xf2, 0xff, 0x44, 0x0c, 0x44, 0x66, 0xf2, 0xd2, 0xe3,
0xbd, 0x46, 0x00, 0x1a, 0x6d, 0x02, 0xba, 0x25, 0x5d, 0x8d, 0xa1, 0x31, 0x51, 0xdd, 0x54, 0x46,
0x1c, 0x4d, 0xdb, 0x99, 0x96, 0xef, 0x1a, 0x1c, 0x04, 0x5c, 0xa6, 0x15, 0xef, 0x78, 0xe0, 0x79,
0xfe, 0x5d, 0xdb, 0x3e, 0xaa, 0x4c, 0x55, 0xfd, 0x9a, 0x15, 0xa9, 0x6f, 0xe1, 0xa6, 0xfb, 0xdf,
0x70, 0x30, 0xe9, 0xc3, 0xee, 0x42, 0x46, 0xed, 0xc2, 0x93, 0x05, 0x89, 0xfa, 0x7d, 0x63, 0x7b,
0x3f, 0xd0, 0x71, 0x81, 0x7c, 0x00, 0xe8, 0x98, 0xae, 0x0e, 0x78, 0x34, 0xc3, 0x25, 0xfb, 0xaf,
0x0a, 0x9f, 0x20, 0x6b, 0xdd, 0x3b, 0x13, 0x8f, 0x12, 0x8c, 0xe2, 0x41, 0x1a, 0x48, 0x7a, 0x73,
0xa0, 0x77, 0x69, 0xc7, 0xb6, 0x5c, 0x7f, 0x82, 0xc8, 0x1e, 0xfe, 0x58, 0x1b, 0x28, 0x2b, 0xa8,
0x6c, 0xad, 0x5e, 0x6d, 0xc0, 0x05, 0xd2, 0x7b, 0xb7, 0xeb, 0x80, 0xfe, 0x25, 0x37, 0xfe, 0x02,
0x9b, 0x68, 0xac, 0x42, 0x5d, 0xc3, 0xee, 0xf5, 0xcc, 0xdc, 0xf0, 0x50, 0x75, 0xd2, 0x36, 0x69,
0x9c, 0xe6, 0x7b, 0x04, 0xdf, 0x6e, 0x06, 0x69, 0xb6, 0xde, 0x0a, 0x09, 0x48, 0x59, 0x87, 0xeb,
0x7b, 0x14, 0x60, 0x7a, 0x64, 0xaa, 0x69, 0x43, 0xef, 0x91, 0xc7, 0x4c, 0xec, 0x18, 0xdd, 0x6c,
0xef, 0x53, 0x2d, 0x8c, 0x99, 0xe1, 0x5e, 0xf2, 0x72, 0x3e, 0xcf, 0x54, 0xc8, 0xbd, 0x67, 0xec,
0xa4, 0x0f, 0x4c, 0x45, 0xff, 0xd3, 0xb9, 0x30, 0x23, 0x07, 0x4c, 0x8f, 0x10, 0xbf, 0x86, 0x96,
0xd9, 0x99, 0x5a, 0xb4, 0x99, 0x57, 0x1c, 0xa4, 0xcc, 0xbb, 0x15, 0x89, 0x53, 0xba, 0x2c, 0x05,
0x0f, 0xe4, 0xc4, 0x9e, 0x19, 0xb1, 0x18, 0x34, 0xd5, 0x4c, 0x9d, 0xba, 0xed, 0xf7, 0x1f, 0xaf,
0x24, 0x95, 0x04, 0x78, 0xa8, 0x03, 0xbb, 0xee, 0x81, 0xe5, 0xda, 0x5f, 0x7c, 0x8b, 0x4a, 0xa1,
0x90, 0x74, 0x25, 0xa7, 0xb3, 0x3e, 0x4b, 0xc8, 0x2c, 0x56, 0xbd, 0xc7, 0xc8, 0xef, 0x38, 0xe2,
0x5c, 0x92, 0xf0, 0x79, 0xf7, 0x9c, 0x84, 0xba, 0x74, 0x2d, 0x61, 0x01, 0x20, 0x7e, 0x7e, 0xd1,
0xf2, 0x4f, 0x07, 0x59, 0x5f, 0x8b, 0x2d, 0x43, 0x52, 0xeb, 0x46, 0x0c, 0x94, 0xe1, 0xf5, 0x66,
0x47, 0x79, 0x77, 0xd5, 0x54, 0x5b, 0x1f, 0xad, 0x24, 0x37, 0xcb, 0x45, 0x5a, 0x4e, 0xa0, 0x44,
0x48, 0xc8, 0xd8, 0xb0, 0x99, 0xc5, 0x15, 0x84, 0x09, 0xf6, 0xd6, 0x49, 0x49, 0xc0, 0x65, 0xb8,
0xe6, 0x1a, 0x71, 0x6e, 0xa0, 0xa8, 0xf1, 0x82, 0xe8, 0x45, 0x3e, 0x6c, 0xd6, 0x02, 0xd7, 0x0a,
0x67, 0x83, 0x05, 0x5a, 0xc9, 0xa4, 0x10
};
static const uint8_t g_certData03[] = { /* 1df5a75f.0 */
0x30, 0x82, 0x04, 0x33, 0x30, 0x82, 0x03, 0x1b, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x03, 0x09,
0x83, 0xf3, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05,
0x00, 0x30, 0x4d, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x44, 0x45,
0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0c, 0x44, 0x2d, 0x54, 0x72, 0x75,
0x73, 0x74, 0x20, 0x47, 0x6d, 0x62, 0x48, 0x31, 0x27, 0x30, 0x25, 0x06, 0x03, 0x55, 0x04, 0x03,
0x0c, 0x1e, 0x44, 0x2d, 0x54, 0x52, 0x55, 0x53, 0x54, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43,
0x6c, 0x61, 0x73, 0x73, 0x20, 0x33, 0x20, 0x43, 0x41, 0x20, 0x32, 0x20, 0x32, 0x30, 0x30, 0x39,
0x30, 0x1e, 0x17, 0x0d, 0x30, 0x39, 0x31, 0x31, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x35, 0x38,
0x5a, 0x17, 0x0d, 0x32, 0x39, 0x31, 0x31, 0x30, 0x35, 0x30, 0x38, 0x33, 0x35, 0x35, 0x38, 0x5a,
0x30, 0x4d, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x44, 0x45, 0x31,
0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0c, 0x44, 0x2d, 0x54, 0x72, 0x75, 0x73,
0x74, 0x20, 0x47, 0x6d, 0x62, 0x48, 0x31, 0x27, 0x30, 0x25, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c,
0x1e, 0x44, 0x2d, 0x54, 0x52, 0x55, 0x53, 0x54, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x6c,
0x61, 0x73, 0x73, 0x20, 0x33, 0x20, 0x43, 0x41, 0x20, 0x32, 0x20, 0x32, 0x30, 0x30, 0x39, 0x30,
0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00,
0xd3, 0xb2, 0x4a, 0xcf, 0x7a, 0x47, 0xef, 0x75, 0x9b, 0x23, 0xfa, 0x3a, 0x2f, 0xd6, 0x50, 0x45,
0x89, 0x35, 0x3a, 0xc6, 0x6b, 0xdb, 0xfe, 0xdb, 0x00, 0x68, 0xa8, 0xe0, 0x03, 0x11, 0x1d, 0x37,
0x50, 0x08, 0x9f, 0x4d, 0x4a, 0x68, 0x94, 0x35, 0xb3, 0x53, 0xd1, 0x94, 0x63, 0xa7, 0x20, 0x56,
0xaf, 0xde, 0x51, 0x78, 0xec, 0x2a, 0x3d, 0xf3, 0x48, 0x48, 0x50, 0x3e, 0x0a, 0xdf, 0x46, 0x55,
0x8b, 0x27, 0x6d, 0xc3, 0x10, 0x4d, 0x0d, 0x91, 0x52, 0x43, 0xd8, 0x87, 0xe0, 0x5d, 0x4e, 0x36,
0xb5, 0x21, 0xca, 0x5f, 0x39, 0x40, 0x04, 0x5f, 0x5b, 0x7e, 0xcc, 0xa3, 0xc6, 0x2b, 0xa9, 0x40,
0x1e, 0xd9, 0x36, 0x84, 0xd6, 0x48, 0xf3, 0x92, 0x1e, 0x34, 0x46, 0x20, 0x24, 0xc1, 0xa4, 0x51,
0x8e, 0x4a, 0x1a, 0xef, 0x50, 0x3f, 0x69, 0x5d, 0x19, 0x7f, 0x45, 0xc3, 0xc7, 0x01, 0x8f, 0x51,
0xc9, 0x23, 0xe8, 0x72, 0xae, 0xb4, 0xbc, 0x56, 0x09, 0x7f, 0x12, 0xcb, 0x1c, 0xb1, 0xaf, 0x29,
0x90, 0x0a, 0xc9, 0x55, 0xcc, 0x0f, 0xd3, 0xb4, 0x1a, 0xed, 0x47, 0x35, 0x5a, 0x4a, 0xed, 0x9c,
0x73, 0x04, 0x21, 0xd0, 0xaa, 0xbd, 0x0c, 0x13, 0xb5, 0x00, 0xca, 0x26, 0x6c, 0xc4, 0x6b, 0x0c,
0x94, 0x5a, 0x95, 0x94, 0xda, 0x50, 0x9a, 0xf1, 0xff, 0xa5, 0x2b, 0x66, 0x31, 0xa4, 0xc9, 0x38,
0xa0, 0xdf, 0x1d, 0x1f, 0xb8, 0x09, 0x2e, 0xf3, 0xa7, 0xe8, 0x67, 0x52, 0xab, 0x95, 0x1f, 0xe0,
0x46, 0x3e, 0xd8, 0xa4, 0xc3, 0xca, 0x5a, 0xc5, 0x31, 0x80, 0xe8, 0x48, 0x9a, 0x9f, 0x94, 0x69,
0xfe, 0x19, 0xdd, 0xd8, 0x73, 0x7c, 0x81, 0xca, 0x96, 0xde, 0x8e, 0xed, 0xb3, 0x32, 0x05, 0x65,
0x84, 0x34, 0xe6, 0xe6, 0xfd, 0x57, 0x10, 0xb5, 0x5f, 0x76, 0xbf, 0x2f, 0xb0, 0x10, 0x0d, 0xc5,
0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x82, 0x01, 0x1a, 0x30, 0x82, 0x01, 0x16, 0x30, 0x0f, 0x06,
0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x1d,
0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xfd, 0xda, 0x14, 0xc4, 0x9f, 0x30, 0xde,
0x21, 0xbd, 0x1e, 0x42, 0x39, 0xfc, 0xab, 0x63, 0x23, 0x49, 0xe0, 0xf1, 0x84, 0x30, 0x0e, 0x06,
0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x81, 0xd3,
0x06, 0x03, 0x55, 0x1d, 0x1f, 0x04, 0x81, 0xcb, 0x30, 0x81, 0xc8, 0x30, 0x81, 0x80, 0xa0, 0x7e,
0xa0, 0x7c, 0x86, 0x7a, 0x6c, 0x64, 0x61, 0x70, 0x3a, 0x2f, 0x2f, 0x64, 0x69, 0x72, 0x65, 0x63,
0x74, 0x6f, 0x72, 0x79, 0x2e, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x2e, 0x6e, 0x65, 0x74,
0x2f, 0x43, 0x4e, 0x3d, 0x44, 0x2d, 0x54, 0x52, 0x55, 0x53, 0x54, 0x25, 0x32, 0x30, 0x52, 0x6f,
0x6f, 0x74, 0x25, 0x32, 0x30, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x25, 0x32, 0x30, 0x33, 0x25, 0x32,
0x30, 0x43, 0x41, 0x25, 0x32, 0x30, 0x32, 0x25, 0x32, 0x30, 0x32, 0x30, 0x30, 0x39, 0x2c, 0x4f,
0x3d, 0x44, 0x2d, 0x54, 0x72, 0x75, 0x73, 0x74, 0x25, 0x32, 0x30, 0x47, 0x6d, 0x62, 0x48, 0x2c,
0x43, 0x3d, 0x44, 0x45, 0x3f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65,
0x72, 0x65, 0x76, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x43,
0xa0, 0x41, 0xa0, 0x3f, 0x86, 0x3d, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
0x2e, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x63, 0x72, 0x6c,
0x2f, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x63, 0x6c,
0x61, 0x73, 0x73, 0x5f, 0x33, 0x5f, 0x63, 0x61, 0x5f, 0x32, 0x5f, 0x32, 0x30, 0x30, 0x39, 0x2e,
0x63, 0x72, 0x6c, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x7f, 0x97, 0xdb, 0x30, 0xc8, 0xdf, 0xa4, 0x9c, 0x7d,
0x21, 0x7a, 0x80, 0x70, 0xce, 0x14, 0x12, 0x69, 0x88, 0x14, 0x95, 0x60, 0x44, 0x01, 0xac, 0xb2,
0xe9, 0x30, 0x4f, 0x9b, 0x50, 0xc2, 0x66, 0xd8, 0x7e, 0x8d, 0x30, 0xb5, 0x70, 0x31, 0xe9, 0xe2,
0x69, 0xc7, 0xf3, 0x70, 0xdb, 0x20, 0x15, 0x86, 0xd0, 0x0d, 0xf0, 0xbe, 0xac, 0x01, 0x75, 0x84,
0xce, 0x7e, 0x9f, 0x4d, 0xbf, 0xb7, 0x60, 0x3b, 0x9c, 0xf3, 0xca, 0x1d, 0xe2, 0x5e, 0x68, 0xd8,
0xa3, 0x9d, 0x97, 0xe5, 0x40, 0x60, 0xd2, 0x36, 0x21, 0xfe, 0xd0, 0xb4, 0xb8, 0x17, 0xda, 0x74,
0xa3, 0x7f, 0xd4, 0xdf, 0xb0, 0x98, 0x02, 0xac, 0x6f, 0x6b, 0x6b, 0x2c, 0x25, 0x24, 0x72, 0xa1,
0x65, 0xee, 0x25, 0x5a, 0xe5, 0xe6, 0x32, 0xe7, 0xf2, 0xdf, 0xab, 0x49, 0xfa, 0xf3, 0x90, 0x69,
0x23, 0xdb, 0x04, 0xd9, 0xe7, 0x5c, 0x58, 0xfc, 0x65, 0xd4, 0x97, 0xbe, 0xcc, 0xfc, 0x2e, 0x0a,
0xcc, 0x25, 0x2a, 0x35, 0x04, 0xf8, 0x60, 0x91, 0x15, 0x75, 0x3d, 0x41, 0xff, 0x23, 0x1f, 0x19,
0xc8, 0x6c, 0xeb, 0x82, 0x53, 0x04, 0xa6, 0xe4, 0x4c, 0x22, 0x4d, 0x8d, 0x8c, 0xba, 0xce, 0x5b,
0x73, 0xec, 0x64, 0x54, 0x50, 0x6d, 0xd1, 0x9c, 0x55, 0xfb, 0x69, 0xc3, 0x36, 0xc3, 0x8c, 0xbc,
0x3c, 0x85, 0xa6, 0x6b, 0x0a, 0x26, 0x0d, 0xe0, 0x93, 0x98, 0x60, 0xae, 0x7e, 0xc6, 0x24, 0x97,
0x8a, 0x61, 0x5f, 0x91, 0x8e, 0x66, 0x92, 0x09, 0x87, 0x36, 0xcd, 0x8b, 0x9b, 0x2d, 0x3e, 0xf6,
0x51, 0xd4, 0x50, 0xd4, 0x59, 0x28, 0xbd, 0x83, 0xf2, 0xcc, 0x28, 0x7b, 0x53, 0x86, 0x6d, 0xd8,
0x26, 0x88, 0x70, 0xd7, 0xea, 0x91, 0xcd, 0x3e, 0xb9, 0xca, 0xc0, 0x90, 0x6e, 0x5a, 0xc6, 0x5e,
0x74, 0x65, 0xd7, 0x5c, 0xfe, 0xa3, 0xe2
};
static const uint8_t g_certData04[] = { /* invalid data */
0xa0, 0x41, 0xa0, 0x3f, 0x86, 0x3d, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
0x2e, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x63, 0x72, 0x6c,
0x2f, 0x64, 0x2d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x63, 0x6c,
0x61, 0x73, 0x73, 0x5f, 0x33, 0x5f, 0x63, 0x61, 0x5f, 0x32, 0x5f, 0x32, 0x30, 0x30, 0x39, 0x2e,
0x63, 0x72, 0x6c, 0x30, 0x0d, 0x06, 0x09, 0x2a
};
static const uint8_t g_certData05[] = { /* 2e0g9ue5 */
0x30, 0x82, 0x02, 0xc1, 0x30, 0x82, 0x01, 0xa9, 0x02, 0x01, 0x01, 0x30, 0x0d, 0x06, 0x09, 0x2a,
0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x1a, 0x31, 0x18, 0x30, 0x16,
0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0f, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x52,
0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x32, 0x31, 0x32, 0x31, 0x36,
0x31, 0x30, 0x33, 0x38, 0x31, 0x39, 0x5a, 0x17, 0x0d, 0x32, 0x35, 0x30, 0x39, 0x31, 0x30, 0x31,
0x30, 0x33, 0x38, 0x31, 0x39, 0x5a, 0x30, 0x33, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04,
0x03, 0x0c, 0x06, 0x54, 0x45, 0x53, 0x54, 0x30, 0x31, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55,
0x04, 0x0b, 0x0c, 0x06, 0x54, 0x45, 0x53, 0x54, 0x30, 0x32, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03,
0x55, 0x04, 0x0a, 0x0c, 0x06, 0x54, 0x45, 0x53, 0x54, 0x30, 0x33, 0x30, 0x82, 0x01, 0x22, 0x30,
0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82,
0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xa3, 0x21, 0x49, 0xd7,
0x60, 0xb9, 0x49, 0xe3, 0x40, 0x4e, 0x02, 0x92, 0x07, 0xa6, 0xfb, 0x4a, 0xef, 0x4d, 0xfa, 0x0b,
0xcc, 0xab, 0x5b, 0x7b, 0x1b, 0x86, 0x4f, 0x99, 0x77, 0xb3, 0x52, 0xd8, 0x79, 0x04, 0x1e, 0x80,
0xff, 0xed, 0xb8, 0xfd, 0x51, 0xfe, 0xdd, 0xed, 0xe3, 0xdd, 0x85, 0x76, 0xb0, 0xe4, 0x0a, 0xd7,
0xbf, 0x9a, 0x08, 0x33, 0xa5, 0x24, 0x37, 0xb1, 0xe6, 0x18, 0x9e, 0x32, 0xb6, 0x49, 0x4c, 0xcf,
0x8c, 0x94, 0x75, 0xd3, 0xf9, 0x44, 0xe2, 0xb5, 0xa4, 0xe2, 0x86, 0x6d, 0x0c, 0xef, 0x89, 0xf2,
0x71, 0x06, 0x8a, 0x3a, 0x08, 0xaf, 0x11, 0x46, 0x08, 0xc5, 0xa6, 0x45, 0x37, 0x2f, 0x69, 0x1a,
0xc6, 0x2d, 0x56, 0xa3, 0x4b, 0x72, 0x98, 0x1f, 0x66, 0x58, 0x66, 0x29, 0x69, 0x1e, 0xb6, 0xdc,
0xe0, 0x50, 0x95, 0xd2, 0x5b, 0xa4, 0xf1, 0x3d, 0xc6, 0xac, 0x82, 0x05, 0x52, 0x3e, 0xef, 0x61,
0x5d, 0xa1, 0x8d, 0x17, 0x6b, 0x8d, 0xff, 0x1f, 0x7f, 0xe7, 0xa9, 0x07, 0x2a, 0x6f, 0x3f, 0xca,
0xaa, 0xfa, 0x4b, 0x4f, 0x0d, 0x2f, 0xf7, 0xa8, 0xae, 0x42, 0x6d, 0x8c, 0x83, 0xb0, 0x2b, 0x42,
0xec, 0x7d, 0x93, 0xd9, 0xb1, 0xbd, 0xbd, 0xa6, 0x59, 0x49, 0xe2, 0x70, 0xe4, 0x5b, 0x45, 0xa9,
0xdf, 0x9d, 0xbd, 0x11, 0xe1, 0xbc, 0xd9, 0x7e, 0x91, 0xc6, 0x4f, 0x40, 0xd7, 0xfb, 0x33, 0x51,
0xc0, 0x9b, 0x4f, 0x94, 0x53, 0xd7, 0x89, 0x26, 0x69, 0x4e, 0x58, 0x79, 0xcd, 0x68, 0x76, 0x64,
0xbe, 0x25, 0xee, 0xce, 0xde, 0x2b, 0xaf, 0x05, 0x93, 0x57, 0xb6, 0x6f, 0x67, 0x09, 0x26, 0x13,
0xb9, 0x5a, 0xbc, 0x6a, 0xc8, 0x4e, 0x37, 0xf1, 0x2c, 0xf9, 0x2d, 0x03, 0x62, 0x35, 0x83, 0x67,
0x5b, 0x56, 0xe4, 0xb2, 0xb5, 0x7e, 0x9e, 0x2a, 0x2a, 0x9e, 0xef, 0x21, 0x02, 0x03, 0x01, 0x00,
0x01, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00,
0x03, 0x82, 0x01, 0x01, 0x00, 0x8f, 0x54, 0xb6, 0x5a, 0x0b, 0x49, 0x1d, 0x9c, 0x3b, 0x26, 0xc9,
0x33, 0x47, 0x83, 0xd2, 0x56, 0x5f, 0xa2, 0x2e, 0x2f, 0x49, 0x40, 0x49, 0x08, 0xf3, 0x9b, 0xfd,
0x4d, 0x7b, 0x00, 0xdb, 0xb5, 0xec, 0xe0, 0x48, 0xc6, 0x2d, 0xcc, 0x7d, 0x98, 0xa0, 0x99, 0x6d,
0x35, 0xf2, 0xcc, 0x92, 0x84, 0xbc, 0xa6, 0xa6, 0x01, 0x8f, 0x29, 0x8d, 0xa4, 0x43, 0x8b, 0x1c,
0xd6, 0x6e, 0x44, 0x25, 0x46, 0x44, 0xe0, 0xa0, 0x91, 0xdc, 0x80, 0xa4, 0xbb, 0x01, 0x04, 0xba,
0x69, 0x00, 0xd9, 0xbd, 0x88, 0xa0, 0x3e, 0x7d, 0xe2, 0xca, 0x88, 0x0e, 0x99, 0x08, 0x5d, 0xd9,
0x4f, 0x6a, 0x22, 0xbf, 0x8d, 0xeb, 0xd5, 0xfa, 0xe0, 0x7f, 0xbd, 0x5e, 0x34, 0x0b, 0xd3, 0xec,
0x0b, 0x0c, 0x83, 0x93, 0xde, 0xd8, 0xf6, 0x4f, 0x7c, 0x66, 0x23, 0x6d, 0xb9, 0x4a, 0xd4, 0xd3,
0xd5, 0x16, 0x99, 0x65, 0x69, 0x7f, 0xd6, 0x29, 0x67, 0x63, 0xd5, 0xcc, 0xfd, 0xe7, 0x1c, 0x7a,
0x96, 0x68, 0x16, 0x1f, 0xc9, 0x24, 0xd6, 0xaf, 0x9f, 0xd0, 0xd3, 0x5d, 0xc6, 0x70, 0xcf, 0x5d,
0x10, 0x47, 0x59, 0x0c, 0x16, 0xae, 0x19, 0x89, 0x35, 0x7b, 0xe4, 0x42, 0xb7, 0x62, 0x67, 0x2d,
0xcc, 0xcd, 0x8d, 0x52, 0x4d, 0xa3, 0xf3, 0x4f, 0x44, 0x47, 0xcf, 0xf3, 0x57, 0x96, 0xab, 0xef,
0xd5, 0xe8, 0x8c, 0xf6, 0xca, 0xed, 0x4b, 0x40, 0xae, 0xad, 0x6a, 0x03, 0xb5, 0x7a, 0xb6, 0xc8,
0x59, 0x7d, 0x32, 0x2f, 0x52, 0x6a, 0x29, 0x01, 0x51, 0xd1, 0x81, 0xe0, 0x8b, 0xb5, 0x1c, 0xaa,
0x09, 0xdb, 0x1c, 0x86, 0xbc, 0xd6, 0x95, 0x7c, 0x18, 0x1e, 0x53, 0x8d, 0x63, 0xf1, 0xc0, 0xae,
0x86, 0x91, 0x12, 0x67, 0xe0, 0x93, 0x78, 0xbf, 0x1a, 0x63, 0x27, 0x0a, 0x14, 0x29, 0x8d, 0x5f,
0x59, 0xae, 0x6b, 0x04, 0x1b
};
static char g_certData06[] =
"-----BEGIN CERTIFICATE-----\r\n"
"MIID6jCCAtKgAwIBAgIIIM2q/TmRoLcwDQYJKoZIhvcNAQELBQAwWjELMAkGA1UE\r\n"
"BhMCRU4xEDAOBgNVBAgTB0VuZ2xhbmQxDzANBgNVBAcTBkxvbmRvbjEMMAoGA1UE\r\n"
"ChMDdHMyMQwwCgYDVQQLEwN0czIxDDAKBgNVBAMTA3RzMjAeFw0yMzEyMDUwNzM5\r\n"
"MDBaFw0yNDEwMzEyMzU5MDBaMGExCzAJBgNVBAYTAkNOMRAwDgYDVQQIEwdKaWFu\r\n"
"Z3N1MRAwDgYDVQQHEwdOYW5qaW5nMQwwCgYDVQQKEwN0czMxDDAKBgNVBAsTA3Rz\r\n"
"MzESMBAGA1UEAxMJMTI3LjAuMC4xMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB\r\n"
"CgKCAQEAtt+2QxUevbolYLp51QGcUpageI4fwGLIqv4fj4aoVnHFOOBqVOVpfCLR\r\n"
"p26LFV/F8ebwPyo8YEBKSwXzMD1573rMSbaH9BalscH5lZYAbetXoio6YRvzlcmc\r\n"
"rVvLBNMeVnxY86xHpo0MTNyP7W024rZsxWO98xFQVdoiaBC+7+midlisx2Y+7u0j\r\n"
"zT9GjeUP6JLdLFUZJKUPSTK3jVzw9v1eZQZKYoNfU6vFMd6ndtwW6qEnwpzmmX/U\r\n"
"T+p5ThAMH593zszlz330nTSXBjIsGkyvOz9gSB0Z0LAuJj06XUNhGL5xKJYKbdI3\r\n"
"8MFQFJKvRHfgTAvVsvAvpBUM2DuBKwIDAQABo4GsMIGpMAkGA1UdEwQCMAAwHQYD\r\n"
"VR0OBBYEFDfsHTMZwoA6eaDFlBUyDpka+sYtMAsGA1UdDwQEAwID+DAnBgNVHSUE\r\n"
"IDAeBggrBgEFBQcDAQYIKwYBBQUHAwIGCCsGAQUFBwMEMBQGA1UdEQQNMAuCCTEy\r\n"
"Ny4wLjAuMTARBglghkgBhvhCAQEEBAMCBkAwHgYJYIZIAYb4QgENBBEWD3hjYSBj\r\n"
"ZXJ0aWZpY2F0ZTANBgkqhkiG9w0BAQsFAAOCAQEAp5vTvXrt8ZpgRJVtzv9ss0lJ\r\n"
"izp1fJf+ft5cDXrs7TSD5oHrSW2vk/ZieIMhexU4LFwhs4OE7jK6pgI48Dseqxx7\r\n"
"B/KktxhVMJUmVXd9Ayjp6f+BtZlIk0cArPuoXToXjsV8caTGBXHRdzxpAk/w9syc\r\n"
"GYrbH9TrdNMuTizOb+k268oKXUageZNxHmd7YvOXkcNgrd29jzwXKDYYiUa1DISz\r\n"
"DnYaJOgPt0B/5izhoWNK7GhJDy9KEuLURcTSWFysbbnljwO9INPT9MmlS83PdAgN\r\n"
"iS8VXF4pce1W9U5jH7d7k0JDVSXybebe1iPFphsZpYM/NE+jap+mPy1nTCbf9g==\r\n"
"-----END CERTIFICATE-----\r\n";
struct UserCertListResult {
struct CertAbstract certAbstract;
bool bExpectResult;