mirror of
https://gitee.com/openharmony/security_certificate_framework
synced 2024-11-23 14:39:44 +00:00
证书算法库v1.0测试代码
Signed-off-by: haixiangw <wanghaixiang@huawei.com>
This commit is contained in:
haixiangw
parent
26e8fdb314
commit
0a03cde890
4
BUILD.gn
4
BUILD.gn
@ -29,8 +29,10 @@ group("certificate_framework_fuzztest") {
|
||||
deps = []
|
||||
if (os_level == "standard") {
|
||||
deps += [
|
||||
"test/fuzztest/cfgetandcheck_fuzzer:fuzztest",
|
||||
"test/fuzztest/cfcreate_fuzzer:fuzztest",
|
||||
"test/fuzztest/cfgetandcheck_fuzzer:fuzztest",
|
||||
"test/fuzztest/v1.0/x509certificate_fuzzer:fuzztest",
|
||||
"test/fuzztest/v1.0/x509crl_fuzzer:fuzztest",
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@ -42,43 +42,39 @@ namespace OHOS {
|
||||
|
||||
static char g_testCrl[] =
|
||||
"-----BEGIN X509 CRL-----\r\n"
|
||||
"MIIB/DCB5QIBATANBgkqhkiG9w0BAQsFADCBjDELMAkGA1UEBhMCQ04xETAPBgNV\r\n"
|
||||
"BAgMCHNoYW5naGFpMQ8wDQYDVQQHDAZodWF3ZWkxFTATBgNVBAoMDHd3dy50ZXN0\r\n"
|
||||
"LmNvbTENMAsGA1UECwwEdGVzdDEVMBMGA1UEAwwMd3d3LnRlc3QuY29tMRwwGgYJ\r\n"
|
||||
"KoZIhvcNAQkBFg10ZXN0QHRlc3QuY29tFw0yMjA4MjkwNzAwMTRaFw0yMjA5Mjgw\r\n"
|
||||
"NzAwMTRaMBQwEgIBARcNMjIwODI5MDY1OTUzWqAOMAwwCgYDVR0UBAMCAQAwDQYJ\r\n"
|
||||
"KoZIhvcNAQELBQADggEBAHpfFhhUR59OAvOSuKDQUC5tKeLEuPbY8bYdmQVI8EFd\r\n"
|
||||
"xDkZTXmT3CX1aDPYKVsG/jH9KPAmCV/ODKEGiJzclb3Z4am7tT+Wy4mpXypNS1od\r\n"
|
||||
"wPDcQGsMrjT6iSp6JImiB0dDDSleBTBcYR/hhtFaiGSncyqJ0mhyaXPxIkNOO6nY\r\n"
|
||||
"v+rcTEPQWavViDRyNDhnTbN868I3fzFVBcidF13CA0sCJ91ZvsE9h/YmPO2+e0YE\r\n"
|
||||
"IUgzn37UOiLGObCVBY12QjGiuvVvCl7ncncsFEJuGfvONOqyFHjyxDHo5W0fqTn2\r\n"
|
||||
"eCtiNcgUr9Kz2bwCmvEXhP7PuF4RMLq4vfzi0YjCG98=\r\n"
|
||||
"MIIB4zCBzAIBATANBgkqhkiG9w0BAQsFADAsMQswCQYDVQQGEwJDTjENMAsGA1UE\r\n"
|
||||
"CgwEdGVzdDEOMAwGA1UEAwwFc3ViY2EXDTIzMDkxMjA2NDc1MFoXDTIzMTAxMjA2\r\n"
|
||||
"NDc1MFowOzATAgID6BcNMjMwOTEyMDY0NzQ5WjAkAhMXXWqf7KkJ1xKySFKmPkj2\r\n"
|
||||
"EpOpFw0yMzA5MTIwNjQyNTRaoC8wLTAfBgNVHSMEGDAWgBQiKxjehNkwTvY939f0\r\n"
|
||||
"Au1EIoQg6DAKBgNVHRQEAwIBAjANBgkqhkiG9w0BAQsFAAOCAQEAQKGCXs5aXY56\r\n"
|
||||
"06A/0HynLmq+frJ7p5Uj9cD2vwbZV4xaP2E5jXogBz7YCjmxp0PB995XC9oi3QKQ\r\n"
|
||||
"gLVKY4Nz21WQRecmmZm1cDweDDPwGJ8/I0d2CwMTJfP7rEgsuhgIBq+JUjFcNNaW\r\n"
|
||||
"dia2Gu/aAuIjlaJ5A4W7vvhGVUx9CDUdN8YF5knA3BoQ1uFc1z7gNckkIpTTccQL\r\n"
|
||||
"zoELFDG8/z+bOnAuSg1lZCyv9fOz9lVafC+qaHo+NW9rdChxV1oC5S6jHTu879CO\r\n"
|
||||
"MQnLr3jEBCszNzDjFI64l6f3JVnLZepp6NU1gdunjQL4gtWQXZFlFV75xR8aahd8\r\n"
|
||||
"seB5oDTPQg==\r\n"
|
||||
"-----END X509 CRL-----\r\n";
|
||||
|
||||
static char g_testCert[] =
|
||||
"-----BEGIN CERTIFICATE-----\r\n"
|
||||
"MIID/jCCAuagAwIBAgIBATANBgkqhkiG9w0BAQsFADCBjDELMAkGA1UEBhMCQ04x\r\n"
|
||||
"ETAPBgNVBAgMCHNoYW5naGFpMQ8wDQYDVQQHDAZodWF3ZWkxFTATBgNVBAoMDHd3\r\n"
|
||||
"dy50ZXN0LmNvbTENMAsGA1UECwwEdGVzdDEVMBMGA1UEAwwMd3d3LnRlc3QuY29t\r\n"
|
||||
"MRwwGgYJKoZIhvcNAQkBFg10ZXN0QHRlc3QuY29tMB4XDTIyMDgyOTA2NTUwM1oX\r\n"
|
||||
"DTIzMDgyOTA2NTUwM1owezELMAkGA1UEBhMCQ04xETAPBgNVBAgMCHNoYW5naGFp\r\n"
|
||||
"MRUwEwYDVQQKDAx3d3cudGVzdC5jb20xDTALBgNVBAsMBHRlc3QxFTATBgNVBAMM\r\n"
|
||||
"DHd3dy50ZXN0LmNvbTEcMBoGCSqGSIb3DQEJARYNdGVzdEB0ZXN0LmNvbTCCASIw\r\n"
|
||||
"DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJmY9T4SzXXwKvfMvnvMWY7TqUJK\r\n"
|
||||
"jnWf2Puv0YUQ2fdvyoKQ2LQXdtzoUL53j587oI+IXelOr7dg020zPyun0cmZHZ4y\r\n"
|
||||
"l/qAcrWbDjZeEGcbbb5UtQtn1WOEnv8pkXluO355mbZQUKK9L3gFWseXJKGbIXw0\r\n"
|
||||
"NRpaJZzqvPor4m3a5pmJKPHOlivUdYfLaKSkNj3DlaFzCWKV82k5ee6gzVyETtG+\r\n"
|
||||
"XN+vq8qLybT+fIFsLNMmAHzRxlqz3NiH7yh+1/p/Knvf8bkkRVR2btH51RyX2RSu\r\n"
|
||||
"DjPM0/VRL8fxDSDeWBq+Gvn/E6AbOVMmkx63tcyWHhklCSaZtyz7kq39TQMCAwEA\r\n"
|
||||
"AaN7MHkwCQYDVR0TBAIwADAsBglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0\r\n"
|
||||
"ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFFiFDysfADQCzRZCOSPupQxFicwzMB8G\r\n"
|
||||
"A1UdIwQYMBaAFNYQRQiPsG8HefOTsmsVhaVjY7IPMA0GCSqGSIb3DQEBCwUAA4IB\r\n"
|
||||
"AQAeppxf6sKQJxJQXKPTT3xHKaskidNwDBbOSIvnVvWXicZXDs+1sF6tUaRgvPxL\r\n"
|
||||
"OL58+P2Jy0tfSwj2WhqQRGe9MvQ5iFHcdelZc0ciW6EQ0VDHIaDAQc2nQzej/79w\r\n"
|
||||
"UE7BJJV3b9n1be2iCsuodKO14pOkMb84WcIxng+8SD+MiFqV5BPO1QyKGdO1PE1b\r\n"
|
||||
"+evjyTpFSTgZf2Mw3fGtu5hfEXyHw1lnsFY2MlSwiRlAym/gm4aXy+4H6LyXKd56\r\n"
|
||||
"UYQ6fituD0ziaw3RI6liyIe7aENHCkZf6bAvMRhk4QiU4xu6emwX8Qt1bT7RthP0\r\n"
|
||||
"1Vsro0IOeXT9WAcqEtQUegsi\r\n"
|
||||
"MIIDTzCCAjegAwIBAgICA+gwDQYJKoZIhvcNAQELBQAwLDELMAkGA1UEBhMCQ04x\r\n"
|
||||
"DTALBgNVBAoMBHRlc3QxDjAMBgNVBAMMBXN1YmNhMB4XDTIzMDkxMjA2NDc0OVoX\r\n"
|
||||
"DTMzMDkwOTA2NDc0OVowLDELMAkGA1UEBhMCQ04xDTALBgNVBAoMBHRlc3QxDjAM\r\n"
|
||||
"BgNVBAMMBWxvY2FsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuEcw\r\n"
|
||||
"tv/K2MnMB+AX2oL2KsTMjKteaQncpr6BPfe/LvSXQImnETvzSSIX2Iy19ZEbEDxn\r\n"
|
||||
"osFXGvmrE8iT1P8lP+LYC8WIjzArbQeBvM6n8gq7QW2jAlfAmVy2/SBeBhRFT1Eq\r\n"
|
||||
"rwqld6qqGa0WTnRTnax7v52FddvpG9XBAexE2gQ6UyScWikAKuDgnSQsivz6SMTQ\r\n"
|
||||
"vbax3ffiy2p2RjxH9ZrQTxpUFDRHqMxJvq57wBDLkAtG4TlhQMDIB86cbOQfHHam\r\n"
|
||||
"VHPVSvyZgmr3V4kb9UlDwB9bjrjSMlRsnNqocGEepZQ57IKgLf5SCWRec5Oww+OO\r\n"
|
||||
"3WJOa7ja10sZ0LDdxwIDAQABo3sweTAJBgNVHRMEAjAAMCwGCWCGSAGG+EIBDQQf\r\n"
|
||||
"Fh1PcGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQURsHdrG4w\r\n"
|
||||
"i4GQKaFbmEpdNyNkvB4wHwYDVR0jBBgwFoAUIisY3oTZME72Pd/X9ALtRCKEIOgw\r\n"
|
||||
"DQYJKoZIhvcNAQELBQADggEBAKVdgTE4Q8Nl5nQUQVL/uZMVCmDRcpXdJHq3cyAH\r\n"
|
||||
"4BtbFW/K3MbVcZl2j1tPl6bgI5pn9Tk4kkc+SfxGUKAPR7FQ01zfgEJipSlsmAxS\r\n"
|
||||
"wOZL+PGUbYUL1jzU8207PZOIZcyD67Sj8LeOV4BCNLiBIo++MjpD++x77GnP3veg\r\n"
|
||||
"bDKHfDSVILdH/qnqyGSAGJ4YGJld00tehnTAqBWzmkXVIgWk0bnPTNE0dn5Tj7ZY\r\n"
|
||||
"7zh6YU5JILHnrkjRGdNGmpz8SXJ+bh7u8ffHc4R9FO1q4c9/1YSsOXQj0KazyDIP\r\n"
|
||||
"IArlydFj8wK8sHvYC9WhPs+hiirrRb9Y2ApFzcYX5aYn46Y=\r\n"
|
||||
"-----END CERTIFICATE-----\r\n";
|
||||
|
||||
static void FreeCrlData()
|
||||
|
||||
@ -17,5 +17,6 @@ group("cf_test") {
|
||||
"cf_adapter_test:cf_adapter_test",
|
||||
"cf_core_test:cf_core_test",
|
||||
"cf_sdk_test:cf_sdk_test",
|
||||
"v1.0:cf_version1_test",
|
||||
]
|
||||
}
|
||||
|
||||
75
test/unittest/v1.0/BUILD.gn
Normal file
75
test/unittest/v1.0/BUILD.gn
Normal file
@ -0,0 +1,75 @@
|
||||
# Copyright (c) 2023 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/test.gni")
|
||||
|
||||
module_output_path = "certificate_framework/certificate_framework_test"
|
||||
|
||||
ohos_unittest("cf_version1_test") {
|
||||
testonly = true
|
||||
module_out_path = module_output_path
|
||||
configs = [
|
||||
"../../../config/build:coverage_flag",
|
||||
"../../../config/build:coverage_flag_cc",
|
||||
]
|
||||
|
||||
include_dirs = [
|
||||
"./include",
|
||||
"../../../interfaces/innerkits/certificate",
|
||||
"../../../interfaces/innerkits/common",
|
||||
"../../../interfaces/innerkits/include",
|
||||
"../../../frameworks/common/v1.0/inc",
|
||||
"../../../frameworks/core/v1.0/spi",
|
||||
"../../../frameworks/adapter/v1.0/inc",
|
||||
"//third_party/openssl/include/",
|
||||
]
|
||||
|
||||
sources = [
|
||||
"src/crypto_x509_cert_chain_validator_test.cpp",
|
||||
"src/crypto_x509_certificate_test.cpp",
|
||||
"src/crypto_x509_crl_test.cpp",
|
||||
]
|
||||
|
||||
sources += [
|
||||
"../../../frameworks/core/v1.0/certificate/cert_chain_validator.c",
|
||||
"../../../frameworks/core/v1.0/certificate/x509_certificate.c",
|
||||
"../../../frameworks/core/v1.0/certificate/x509_crl.c",
|
||||
]
|
||||
sources += [
|
||||
"../../../frameworks/adapter/v1.0/src/certificate_openssl_common.c",
|
||||
"../../../frameworks/adapter/v1.0/src/x509_cert_chain_validator_openssl.c",
|
||||
"../../../frameworks/adapter/v1.0/src/x509_certificate_openssl.c",
|
||||
"../../../frameworks/adapter/v1.0/src/x509_crl_entry_openssl.c",
|
||||
"../../../frameworks/adapter/v1.0/src/x509_crl_openssl.c",
|
||||
]
|
||||
|
||||
sources += [
|
||||
"../../../frameworks/common/v1.0/src/cf_blob.c",
|
||||
"../../../frameworks/common/v1.0/src/cf_log.c",
|
||||
"../../../frameworks/common/v1.0/src/cf_object_base.c",
|
||||
"../../../frameworks/common/v1.0/src/utils.c",
|
||||
"src/memory_mock.c",
|
||||
]
|
||||
cflags = [ "-DHILOG_ENABLE" ]
|
||||
if (target_cpu == "arm") {
|
||||
cflags += [ "-DBINDER_IPC_32BIT" ]
|
||||
}
|
||||
|
||||
deps = [ "//third_party/openssl:libcrypto_shared" ]
|
||||
|
||||
external_deps = [
|
||||
"c_utils:utils",
|
||||
"crypto_framework:crypto_framework_lib",
|
||||
"hilog:libhilog",
|
||||
]
|
||||
}
|
||||
35
test/unittest/v1.0/include/memory_mock.h
Normal file
35
test/unittest/v1.0/include/memory_mock.h
Normal file
@ -0,0 +1,35 @@
|
||||
/*
|
||||
* Copyright (c) 2023 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 MEMORY_MOCK_H
|
||||
#define MEMORY_MOCK_H
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void SetMockFlag(bool flag);
|
||||
void StartRecordMallocNum(void);
|
||||
void EndRecordMallocNum(void);
|
||||
uint32_t GetMallocNum(void);
|
||||
void ResetRecordMallocNum(void);
|
||||
void SetMockMallocIndex(uint32_t index);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
665
test/unittest/v1.0/src/crypto_x509_cert_chain_validator_test.cpp
Normal file
665
test/unittest/v1.0/src/crypto_x509_cert_chain_validator_test.cpp
Normal file
@ -0,0 +1,665 @@
|
||||
/*
|
||||
* Copyright (c) 2023 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 <gtest/gtest.h>
|
||||
#include "securec.h"
|
||||
#include "string"
|
||||
|
||||
#include "cert_chain_validator.h"
|
||||
#include "cf_blob.h"
|
||||
#include "memory_mock.h"
|
||||
#include "cf_object_base.h"
|
||||
#include "cf_result.h"
|
||||
#include "x509_cert_chain_validator_openssl.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace testing::ext;
|
||||
|
||||
namespace {
|
||||
class CryptoX509CertChainValidatorTest : public testing::Test {
|
||||
public:
|
||||
static void SetUpTestCase();
|
||||
static void TearDownTestCase();
|
||||
void SetUp();
|
||||
void TearDown();
|
||||
};
|
||||
|
||||
constexpr int32_t CERT_HEADER_LEN = 2;
|
||||
constexpr int32_t INVALID_MAX_CERT_LEN = 8194;
|
||||
|
||||
static char g_caCert[] =
|
||||
"-----BEGIN CERTIFICATE-----\r\n"
|
||||
"MIIFwTCCA6mgAwIBAgIUBfKGru//yxvdRovc8iW9U9dzgqMwDQYJKoZIhvcNAQEL\r\n"
|
||||
"BQAwbzELMAkGA1UEBhMCQ0kxCzAJBgNVBAgMAmhuMQswCQYDVQQHDAJzaDELMAkG\r\n"
|
||||
"A1UECgwCaGgxCzAJBgNVBAsMAmlpMQswCQYDVQQDDAJhYjEfMB0GCSqGSIb3DQEJ\r\n"
|
||||
"ARYQY3J5cHRvQGhlbGxvLmNvbTAgFw0yMjA4MjAxMjIyMzZaGA8yMDYyMDgyMDEy\r\n"
|
||||
"MjIzNlowbzELMAkGA1UEBhMCQ0kxCzAJBgNVBAgMAmhuMQswCQYDVQQHDAJzaDEL\r\n"
|
||||
"MAkGA1UECgwCaGgxCzAJBgNVBAsMAmlpMQswCQYDVQQDDAJhYjEfMB0GCSqGSIb3\r\n"
|
||||
"DQEJARYQY3J5cHRvQGhlbGxvLmNvbTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCC\r\n"
|
||||
"AgoCggIBAOXkcX7cHglTySl4XmjwMhiyxhMQUSTnZtAyjIiudyJmr9q6Ci8OXGTz\r\n"
|
||||
"yPKmvDejwKcWqwYNpSJstwLUl7o8nFgIJmC9zkQ2ZwdEr5gDNehuR9nNjD55tVKD\r\n"
|
||||
"68svuLGEWbyFI9AL8p578VPTex18KnLYTnJzYu2rVslFNBzQFVNyFPGhbN/ZEcnE\r\n"
|
||||
"ICW4qFovuqNdWH/R9wuyilF08CJjBdXAfFvukooleM3Ip/FNSNb0ygs9N+GnxKuw\r\n"
|
||||
"xybcgC/qZlPHtnl03ebI7/gRgL863E7SZR1lDIMFQ35+Z+TcM4SPqbokNr+nCiUV\r\n"
|
||||
"hmTW56rZJSLDDKvzHzSbon1atd7bjjWWDA/FkUZtvjrP+IVHe+McOS1pDxUOyUv6\r\n"
|
||||
"2YiRD6UkHADAqK0shEo/ejbd92CRbobVLapY9GJ0VOolE061PeNDiy/cMI1ihhbB\r\n"
|
||||
"bq6S5YN/mnjgn0ylDD/6SA4rcc8Pep7ubXSVzhp/mugkJltDvYWoTO8rtZJryqP7\r\n"
|
||||
"hehpJ8lZ1sGjlBE+1H4673wqx+HeGToGpBwrXM+3mKa27KDMtSRt0CvLuycR1SIW\r\n"
|
||||
"FmZXy8n8eVemeA4d9flSYak2Mv5PPXttpSM58rylI2BoSTJgxN/j1tE1Lo8hadwp\r\n"
|
||||
"i5g68H0Fd19HONd+LFxAhpgJ2ZUJb3qoGypEy1J322FCq6djIrIXAgMBAAGjUzBR\r\n"
|
||||
"MB0GA1UdDgQWBBRH2csGuD+kwo6tU03rVbR5dtBhfjAfBgNVHSMEGDAWgBRH2csG\r\n"
|
||||
"uD+kwo6tU03rVbR5dtBhfjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUA\r\n"
|
||||
"A4ICAQCovX+y4fN27gjPZuT1x8Lbm1c6UPcraWOUx5fQq7gpbxGhkWvcNWDEM6FD\r\n"
|
||||
"9bNIT3oA0YiiUqPVOG+2pYiDEwsQJbwgrHZmQIYaufMZevO+a5I4u6FHttj05/ju\r\n"
|
||||
"Z/j5xVECUWIpGFIl+q9U8B5dZ7GbI5zMNZ+k1/KWt+6x5zqRYU1ysxlxITokVfzq\r\n"
|
||||
"Bu/DtMGqsrw36FqGEVUc0kYHGW9gwsNLXmw+YMpQMinAOE8uU0Pw8wtQeX9UcA+b\r\n"
|
||||
"UdP4v9R7YkEtE3rfUCZ1pilEEB5XoklOPn6HYwAhrSB8gb1Ar8gmLUcbO0BT85yS\r\n"
|
||||
"oPLJcw/m8XFC8Dj9ZFU25ux4lhvwmRs9HFFcBUJtYxB13UdfqlFTAlZdtPWi00IQ\r\n"
|
||||
"C7MujV0ijoR6PnntwpBhLHIry1XZxzkrHmuJGQuZO7Taf9FyblrydIprkRyLZRSj\r\n"
|
||||
"r3j1va/amhZZZeKZu1A8KLmTK/VF1IU8f9vMBbmrI6Rx0hgmwOr4kVexDdKyhuZw\r\n"
|
||||
"U0u0HqJMJR1Vin93IFMRE63hjNno3NPL7d0mlhmwjEywrY0MmXYiQ6ag8o0PYAXg\r\n"
|
||||
"Nr8NxOEvBY7ZOkWd2deJIyARDEc9nPcY46MiwowJ6bPMVPCXYGOxSfRpvY5SEjgj\r\n"
|
||||
"llVnK3ULIM3AfVqDe7n3GnD4pHbHZQPLGpq0bQH9JUnCraB60g==\r\n"
|
||||
"-----END CERTIFICATE-----\r\n";
|
||||
|
||||
static char g_secondCaCert[] =
|
||||
"-----BEGIN CERTIFICATE-----\r\n"
|
||||
"MIIFvDCCA6SgAwIBAgIUZDZSgan7tFvmeMmUD80kk+opOZwwDQYJKoZIhvcNAQEL\r\n"
|
||||
"BQAwbzELMAkGA1UEBhMCQ0kxCzAJBgNVBAgMAmhuMQswCQYDVQQHDAJzaDELMAkG\r\n"
|
||||
"A1UECgwCaGgxCzAJBgNVBAsMAmlpMQswCQYDVQQDDAJhYjEfMB0GCSqGSIb3DQEJ\r\n"
|
||||
"ARYQY3J5cHRvQGhlbGxvLmNvbTAeFw0yMjA4MjAxMjI4MDhaFw00MjA4MjAxMjI4\r\n"
|
||||
"MDhaMHwxCzAJBgNVBAYTAkNOMQ4wDAYDVQQIDAVIVU5BTjERMA8GA1UEBwwIU0hB\r\n"
|
||||
"R05IQUkxCzAJBgNVBAoMAmhoMQswCQYDVQQLDAJpaTEPMA0GA1UEAwwGYXV0aG9y\r\n"
|
||||
"MR8wHQYJKoZIhvcNAQkBFhBjcnlwdG9AaGVsbG8uY29tMIICIjANBgkqhkiG9w0B\r\n"
|
||||
"AQEFAAOCAg8AMIICCgKCAgEAuSVyrlsC5nO+64mTYGAVJb1bdRJhz7ATMy2CE2AC\r\n"
|
||||
"yo/RAl2p4Yoz8uJ6U23Ip4F+HmAGqXnIRGezwb+U1XaMkxX6WJQybngbYhdJX0As\r\n"
|
||||
"rElz2CZsh0ZE9bsfAakpMtSrCm7RCucHxDD9R6WDWO2p3ARq8QbmLPk6M0tl9Ibo\r\n"
|
||||
"4y/nJ84rvNfEkjgVNnWh3JLJ8a9OnaPBm+3j/1fPhzcTAo5VAXzEcUomxoV/JZdU\r\n"
|
||||
"Dc0uFjqVeG9svMEx0dbn/xYrPm3OygmNjmbwuWkU9wx1aBDB0k5EwZ2pEagus7Wb\r\n"
|
||||
"Qx37MryvLIMZIlOfqCnygwi478FLD2Ml0+1S/3VQR8S4MptlPrlpfNtkFuh5In/l\r\n"
|
||||
"EgN340I8cdQfv4ZFlZ1BcFhz09MYJFo+toQm62umoZFBdH76wy634FGb1JlhJv6v\r\n"
|
||||
"MguyM8QUTYsF9NBLXKqT5GtuiK4paqwwiNz/mu7ulfxAwKh2u5Jiw0xd+QCNNk3d\r\n"
|
||||
"i3Kchx0ZtomjvmHQh57OZRRfO3lNplnujd9/4oloP+N4xGZ9Uknw9KH+Xx0VZy68\r\n"
|
||||
"1luyaW2BtEKc3K5vcFBAt8FSSAYp9/bJbqfXNIDLPJogQ8EKsccOfs/IiMDP3Wgt\r\n"
|
||||
"T3v1Cr76z+dbBo05fHew3n2Y5STCnxnxxth/jo59bO6IeUhN+kfnnKGA7uxwPppk\r\n"
|
||||
"/CECAwEAAaNDMEEwDAYDVR0TBAUwAwEB/zAxBgNVHR8EKjAoMCagJKAihiBodHRw\r\n"
|
||||
"czovL2NhLnhpZXhpYW5iaW4uY24vY3JsLnBlbTANBgkqhkiG9w0BAQsFAAOCAgEA\r\n"
|
||||
"KVB7IIZ2WHSvRLnkMkaDdIu37l60VMhj79MfOTTI/0CcZ0p8G+fqOKGTCtOTFLfz\r\n"
|
||||
"nXCgDOYH9F5tugLLd9B7FiLys5eBdXRym22BHs/jtzUXFrxSFWBhxvW0cwCwy59g\r\n"
|
||||
"5c/vX3QcvliJfjaLq67CwHIdKlKocogJp1qeROy7HfLQMQJHE/Fc30QZXp5bJcmg\r\n"
|
||||
"KDYGdvrgKGpzgf4zjOYH+OMhwB2G9Nd6en7TCihq3A8HiGj+M3OzrKgWR4qiHmPg\r\n"
|
||||
"3SX7njPLPVerly+o8oh2pSwxSLQMKgPHpbvMHIr5vRIAklGg2TP7WV5+Wc+MC+Ls\r\n"
|
||||
"fZ5M7WSZWD6BV2XIHA2iM3N7wYzvH0lNlgR1Pu8vhflPfSjFouILbEHnsokHPsUd\r\n"
|
||||
"bxnNmOyMpCDCg3cjuZYIyjAIB/OoADAekAHX3cAitBBzzD9MBK/UXRkMded6JVwf\r\n"
|
||||
"bZGq+2LLNzXzqMWQeCcGocRHiV+7uw3klLANfF9NyXvW6FYN50LhnoroGwsuGetY\r\n"
|
||||
"22F/8s1N0oC7Ucn/JmZUA9xjaCDEeoTDoefv8/3zSr2sR6wR7hIHgvC9NNOTzdSS\r\n"
|
||||
"Rqc3AfUz90kdsAoZowql7CrZy7LiqzaJMy1F+2H8jmzfCV6DBaCYgzlBGS/dq/Q7\r\n"
|
||||
"A9kbZrfCeb/yEgz0h0LrWnBWww7r2T+Hk4LQ/jLtC1Q=\r\n"
|
||||
"-----END CERTIFICATE-----\r\n";
|
||||
|
||||
static char g_invalidCaCert[] =
|
||||
"-----BEGIN CERTIFICATE-----\r\n"
|
||||
"MIIFwTCCA6mgAwIBAgIUBQorsmfkw1hrf85bkGSOiJLFCfYwDQYJKoZIhvcNAQEL\r\n"
|
||||
"BQAwezELMAkGA1UEBhMCQ04xETAPBgNVBAgMCFNIQU5HSEFJMREwDwYDVQQHDAhT\r\n"
|
||||
"SEFOR0hBSTELMAkGA1UECgwCQUExCzAJBgNVBAsMAkJCMQswCQYDVQQDDAJDQzEf\r\n"
|
||||
"MB0GCSqGSIb3DQEJARYQc2Vjb25kQGhlbGxvLmNvbTAeFw0yMjA4MjMxMTM4NDNa\r\n"
|
||||
"Fw00MjA4MjMxMTM4NDNaMHoxCzAJBgNVBAYTAkNBMREwDwYDVQQIDAhTSEFOR0hB\r\n"
|
||||
"STERMA8GA1UEBwwIU0hBTkdIQUkxCzAJBgNVBAoMAkFBMQswCQYDVQQLDAJCQjEL\r\n"
|
||||
"MAkGA1UEAwwCQ0MxHjAcBgkqhkiG9w0BCQEWD3RoaXJkQGhlbGxvLmNvbTCCAiIw\r\n"
|
||||
"DQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMoRJDPA4mVDVgO7TGQqFZh4OxbV\r\n"
|
||||
"uGaYmlEIVMwadsjA16l7xKB25bX7WmzHVDgZaJ0zJIyxbXXKvlmELS4mqDVmHUhh\r\n"
|
||||
"sDHM+N00LVjV70F0xjaMRb1s6hOWlQ8Y314iDjW+c1lcHhWFliXqIp2Y7/c2QNKH\r\n"
|
||||
"cRd+cqBzR45a9axHQTxS5ajTmLBSSAuSi3u1uVnA7BE7e0i0WSiISOtWiKoqG/R4\r\n"
|
||||
"o+6llKg68LY0zHdWPyHn6F3aTvP+OJN+NHM+2onovpujDI28sTMRKeT92h/Ubf+s\r\n"
|
||||
"q+kD25ADBZbq5kOXKq2m2jyh3RHSrxoPRyVUCFfWeqJk2ZUyOleHqV+orOCvTM37\r\n"
|
||||
"LfbgIG6vchwMRnZHNBYWIm0BYkyo+O9wFV2+wC9iQwk/k+st9sQYNNwH6C2gzNnQ\r\n"
|
||||
"WHgEYbGRSiUYsyXvkoUjw2gsBZJHjtKBNEqVwUA+yapbVRPsIPnzMr2IcLj9K2LM\r\n"
|
||||
"FxOtpuliUjg/pqb4r5m83ZJQDBT3mvJr3NWbzbFKhqIaZyjjacCWr0vaumRsryEz\r\n"
|
||||
"FwOVUZoPvLz/CgTAOAoouxGPs7qJhXb5CtXLdC15U9IEtsP88SExFa4gvO9nZPHE\r\n"
|
||||
"HW9rc8/kppulsPGEDeZxYonGnk8l55ORqjmxcUQnWxWG1sqz4oTwUifWf9cybwMS\r\n"
|
||||
"PpDQ4piAyncWY2jbAgMBAAGjPjA8MAwGA1UdEwQFMAMBAf8wLAYDVR0fBCUwIzAh\r\n"
|
||||
"oB+gHYYbaHR0cHM6Ly9jYS50aGlyZC5jbi9jcmwucGVtMA0GCSqGSIb3DQEBCwUA\r\n"
|
||||
"A4ICAQA0CP5FEccMxxd83S0IL5uwNCPPBzN3qHGZWm1PJD4dvbzsB5AtWbhDvfvD\r\n"
|
||||
"GQRvfH83t3701U2J7wAUuFgG8UCNVKLSLfSv3Gqo5wKhEnZcoE0KZot56IA+lwVe\r\n"
|
||||
"LfwAYgrzPMOWl1pyQ/BE5BcKthS/7OTH7qdNHc0J59xsanKFU9jnGEjfZv14XSRo\r\n"
|
||||
"/iCM9ZIb4tVETnGFVfjp3Rjgnw2OZjdJcfVLIF/zTlkkGOQLqfyJqoafy0MIuM/k\r\n"
|
||||
"nosPXJHX7tqQs5+ckKhPRkBltGsoLv2HzoIGiiGLvFmulvkyUd9FDq8UwfetAKU6\r\n"
|
||||
"BTO6ZkjeS0S+2SBZ29Hm5F2xMoQjTtzYkmxCxbhFkAF2SWvR+hVXoOsAgG2csU15\r\n"
|
||||
"ef+IgUw1aX7RK2OxYEYvX9BFLaoc8zima+ZzUbScZznVsyPGLZl+7tiOkQVFUSOY\r\n"
|
||||
"F2TJqRXT8Obb0gQ1rHfU+ilDuP3+eUuUFfmzInqXTkGDArDEkwKoHezXgHhsvLTu\r\n"
|
||||
"vBYSV/GOZHduz4WmiPQri3CkntSe4/JWeYoJHD+IWBO/Czvh6nNOciRxZSif917h\r\n"
|
||||
"FQ6og3z/5CyHLd7EWKX/CwUqZ0jmGUdGoaO5i7xTeVzYGpkPzoTTRUv2T/go3roE\r\n"
|
||||
"3hd5yG48AaYNKhJ26auBrOARpJe/ktKZTMuU3zHuPRtv3Wtdiw==\r\n"
|
||||
"-----END CERTIFICATE-----\r\n";
|
||||
|
||||
static uint8_t g_certDerFormat[] = {
|
||||
0x30, 0x82, 0x05, 0xc1, 0x30, 0x82, 0x03, 0xa9, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x05,
|
||||
0xf2, 0x86, 0xae, 0xef, 0xff, 0xcb, 0x1b, 0xdd, 0x46, 0x8b, 0xdc, 0xf2, 0x25, 0xbd, 0x53, 0xd7,
|
||||
0x73, 0x82, 0xa3, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
|
||||
0x05, 0x00, 0x30, 0x6f, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43,
|
||||
0x49, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x02, 0x68, 0x6e, 0x31, 0x0b,
|
||||
0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c, 0x02, 0x73, 0x68, 0x31, 0x0b, 0x30, 0x09, 0x06,
|
||||
0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02, 0x68, 0x68, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
|
||||
0x0b, 0x0c, 0x02, 0x69, 0x69, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x02,
|
||||
0x61, 0x62, 0x31, 0x1f, 0x30, 0x1d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09,
|
||||
0x01, 0x16, 0x10, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x40, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
|
||||
0x63, 0x6f, 0x6d, 0x30, 0x20, 0x17, 0x0d, 0x32, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x32, 0x32,
|
||||
0x32, 0x33, 0x36, 0x5a, 0x18, 0x0f, 0x32, 0x30, 0x36, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x32,
|
||||
0x32, 0x32, 0x33, 0x36, 0x5a, 0x30, 0x6f, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06,
|
||||
0x13, 0x02, 0x43, 0x49, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x02, 0x68,
|
||||
0x6e, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c, 0x02, 0x73, 0x68, 0x31, 0x0b,
|
||||
0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02, 0x68, 0x68, 0x31, 0x0b, 0x30, 0x09, 0x06,
|
||||
0x03, 0x55, 0x04, 0x0b, 0x0c, 0x02, 0x69, 0x69, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
|
||||
0x03, 0x0c, 0x02, 0x61, 0x62, 0x31, 0x1f, 0x30, 0x1d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
|
||||
0x0d, 0x01, 0x09, 0x01, 0x16, 0x10, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x40, 0x68, 0x65, 0x6c,
|
||||
0x6c, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 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, 0xe5, 0xe4, 0x71, 0x7e, 0xdc, 0x1e, 0x09, 0x53, 0xc9,
|
||||
0x29, 0x78, 0x5e, 0x68, 0xf0, 0x32, 0x18, 0xb2, 0xc6, 0x13, 0x10, 0x51, 0x24, 0xe7, 0x66, 0xd0,
|
||||
0x32, 0x8c, 0x88, 0xae, 0x77, 0x22, 0x66, 0xaf, 0xda, 0xba, 0x0a, 0x2f, 0x0e, 0x5c, 0x64, 0xf3,
|
||||
0xc8, 0xf2, 0xa6, 0xbc, 0x37, 0xa3, 0xc0, 0xa7, 0x16, 0xab, 0x06, 0x0d, 0xa5, 0x22, 0x6c, 0xb7,
|
||||
0x02, 0xd4, 0x97, 0xba, 0x3c, 0x9c, 0x58, 0x08, 0x26, 0x60, 0xbd, 0xce, 0x44, 0x36, 0x67, 0x07,
|
||||
0x44, 0xaf, 0x98, 0x03, 0x35, 0xe8, 0x6e, 0x47, 0xd9, 0xcd, 0x8c, 0x3e, 0x79, 0xb5, 0x52, 0x83,
|
||||
0xeb, 0xcb, 0x2f, 0xb8, 0xb1, 0x84, 0x59, 0xbc, 0x85, 0x23, 0xd0, 0x0b, 0xf2, 0x9e, 0x7b, 0xf1,
|
||||
0x53, 0xd3, 0x7b, 0x1d, 0x7c, 0x2a, 0x72, 0xd8, 0x4e, 0x72, 0x73, 0x62, 0xed, 0xab, 0x56, 0xc9,
|
||||
0x45, 0x34, 0x1c, 0xd0, 0x15, 0x53, 0x72, 0x14, 0xf1, 0xa1, 0x6c, 0xdf, 0xd9, 0x11, 0xc9, 0xc4,
|
||||
0x20, 0x25, 0xb8, 0xa8, 0x5a, 0x2f, 0xba, 0xa3, 0x5d, 0x58, 0x7f, 0xd1, 0xf7, 0x0b, 0xb2, 0x8a,
|
||||
0x51, 0x74, 0xf0, 0x22, 0x63, 0x05, 0xd5, 0xc0, 0x7c, 0x5b, 0xee, 0x92, 0x8a, 0x25, 0x78, 0xcd,
|
||||
0xc8, 0xa7, 0xf1, 0x4d, 0x48, 0xd6, 0xf4, 0xca, 0x0b, 0x3d, 0x37, 0xe1, 0xa7, 0xc4, 0xab, 0xb0,
|
||||
0xc7, 0x26, 0xdc, 0x80, 0x2f, 0xea, 0x66, 0x53, 0xc7, 0xb6, 0x79, 0x74, 0xdd, 0xe6, 0xc8, 0xef,
|
||||
0xf8, 0x11, 0x80, 0xbf, 0x3a, 0xdc, 0x4e, 0xd2, 0x65, 0x1d, 0x65, 0x0c, 0x83, 0x05, 0x43, 0x7e,
|
||||
0x7e, 0x67, 0xe4, 0xdc, 0x33, 0x84, 0x8f, 0xa9, 0xba, 0x24, 0x36, 0xbf, 0xa7, 0x0a, 0x25, 0x15,
|
||||
0x86, 0x64, 0xd6, 0xe7, 0xaa, 0xd9, 0x25, 0x22, 0xc3, 0x0c, 0xab, 0xf3, 0x1f, 0x34, 0x9b, 0xa2,
|
||||
0x7d, 0x5a, 0xb5, 0xde, 0xdb, 0x8e, 0x35, 0x96, 0x0c, 0x0f, 0xc5, 0x91, 0x46, 0x6d, 0xbe, 0x3a,
|
||||
0xcf, 0xf8, 0x85, 0x47, 0x7b, 0xe3, 0x1c, 0x39, 0x2d, 0x69, 0x0f, 0x15, 0x0e, 0xc9, 0x4b, 0xfa,
|
||||
0xd9, 0x88, 0x91, 0x0f, 0xa5, 0x24, 0x1c, 0x00, 0xc0, 0xa8, 0xad, 0x2c, 0x84, 0x4a, 0x3f, 0x7a,
|
||||
0x36, 0xdd, 0xf7, 0x60, 0x91, 0x6e, 0x86, 0xd5, 0x2d, 0xaa, 0x58, 0xf4, 0x62, 0x74, 0x54, 0xea,
|
||||
0x25, 0x13, 0x4e, 0xb5, 0x3d, 0xe3, 0x43, 0x8b, 0x2f, 0xdc, 0x30, 0x8d, 0x62, 0x86, 0x16, 0xc1,
|
||||
0x6e, 0xae, 0x92, 0xe5, 0x83, 0x7f, 0x9a, 0x78, 0xe0, 0x9f, 0x4c, 0xa5, 0x0c, 0x3f, 0xfa, 0x48,
|
||||
0x0e, 0x2b, 0x71, 0xcf, 0x0f, 0x7a, 0x9e, 0xee, 0x6d, 0x74, 0x95, 0xce, 0x1a, 0x7f, 0x9a, 0xe8,
|
||||
0x24, 0x26, 0x5b, 0x43, 0xbd, 0x85, 0xa8, 0x4c, 0xef, 0x2b, 0xb5, 0x92, 0x6b, 0xca, 0xa3, 0xfb,
|
||||
0x85, 0xe8, 0x69, 0x27, 0xc9, 0x59, 0xd6, 0xc1, 0xa3, 0x94, 0x11, 0x3e, 0xd4, 0x7e, 0x3a, 0xef,
|
||||
0x7c, 0x2a, 0xc7, 0xe1, 0xde, 0x19, 0x3a, 0x06, 0xa4, 0x1c, 0x2b, 0x5c, 0xcf, 0xb7, 0x98, 0xa6,
|
||||
0xb6, 0xec, 0xa0, 0xcc, 0xb5, 0x24, 0x6d, 0xd0, 0x2b, 0xcb, 0xbb, 0x27, 0x11, 0xd5, 0x22, 0x16,
|
||||
0x16, 0x66, 0x57, 0xcb, 0xc9, 0xfc, 0x79, 0x57, 0xa6, 0x78, 0x0e, 0x1d, 0xf5, 0xf9, 0x52, 0x61,
|
||||
0xa9, 0x36, 0x32, 0xfe, 0x4f, 0x3d, 0x7b, 0x6d, 0xa5, 0x23, 0x39, 0xf2, 0xbc, 0xa5, 0x23, 0x60,
|
||||
0x68, 0x49, 0x32, 0x60, 0xc4, 0xdf, 0xe3, 0xd6, 0xd1, 0x35, 0x2e, 0x8f, 0x21, 0x69, 0xdc, 0x29,
|
||||
0x8b, 0x98, 0x3a, 0xf0, 0x7d, 0x05, 0x77, 0x5f, 0x47, 0x38, 0xd7, 0x7e, 0x2c, 0x5c, 0x40, 0x86,
|
||||
0x98, 0x09, 0xd9, 0x95, 0x09, 0x6f, 0x7a, 0xa8, 0x1b, 0x2a, 0x44, 0xcb, 0x52, 0x77, 0xdb, 0x61,
|
||||
0x42, 0xab, 0xa7, 0x63, 0x22, 0xb2, 0x17, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x53, 0x30, 0x51,
|
||||
0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x47, 0xd9, 0xcb, 0x06, 0xb8,
|
||||
0x3f, 0xa4, 0xc2, 0x8e, 0xad, 0x53, 0x4d, 0xeb, 0x55, 0xb4, 0x79, 0x76, 0xd0, 0x61, 0x7e, 0x30,
|
||||
0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x47, 0xd9, 0xcb, 0x06,
|
||||
0xb8, 0x3f, 0xa4, 0xc2, 0x8e, 0xad, 0x53, 0x4d, 0xeb, 0x55, 0xb4, 0x79, 0x76, 0xd0, 0x61, 0x7e,
|
||||
0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01,
|
||||
0xff, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00,
|
||||
0x03, 0x82, 0x02, 0x01, 0x00, 0xa8, 0xbd, 0x7f, 0xb2, 0xe1, 0xf3, 0x76, 0xee, 0x08, 0xcf, 0x66,
|
||||
0xe4, 0xf5, 0xc7, 0xc2, 0xdb, 0x9b, 0x57, 0x3a, 0x50, 0xf7, 0x2b, 0x69, 0x63, 0x94, 0xc7, 0x97,
|
||||
0xd0, 0xab, 0xb8, 0x29, 0x6f, 0x11, 0xa1, 0x91, 0x6b, 0xdc, 0x35, 0x60, 0xc4, 0x33, 0xa1, 0x43,
|
||||
0xf5, 0xb3, 0x48, 0x4f, 0x7a, 0x00, 0xd1, 0x88, 0xa2, 0x52, 0xa3, 0xd5, 0x38, 0x6f, 0xb6, 0xa5,
|
||||
0x88, 0x83, 0x13, 0x0b, 0x10, 0x25, 0xbc, 0x20, 0xac, 0x76, 0x66, 0x40, 0x86, 0x1a, 0xb9, 0xf3,
|
||||
0x19, 0x7a, 0xf3, 0xbe, 0x6b, 0x92, 0x38, 0xbb, 0xa1, 0x47, 0xb6, 0xd8, 0xf4, 0xe7, 0xf8, 0xee,
|
||||
0x67, 0xf8, 0xf9, 0xc5, 0x51, 0x02, 0x51, 0x62, 0x29, 0x18, 0x52, 0x25, 0xfa, 0xaf, 0x54, 0xf0,
|
||||
0x1e, 0x5d, 0x67, 0xb1, 0x9b, 0x23, 0x9c, 0xcc, 0x35, 0x9f, 0xa4, 0xd7, 0xf2, 0x96, 0xb7, 0xee,
|
||||
0xb1, 0xe7, 0x3a, 0x91, 0x61, 0x4d, 0x72, 0xb3, 0x19, 0x71, 0x21, 0x3a, 0x24, 0x55, 0xfc, 0xea,
|
||||
0x06, 0xef, 0xc3, 0xb4, 0xc1, 0xaa, 0xb2, 0xbc, 0x37, 0xe8, 0x5a, 0x86, 0x11, 0x55, 0x1c, 0xd2,
|
||||
0x46, 0x07, 0x19, 0x6f, 0x60, 0xc2, 0xc3, 0x4b, 0x5e, 0x6c, 0x3e, 0x60, 0xca, 0x50, 0x32, 0x29,
|
||||
0xc0, 0x38, 0x4f, 0x2e, 0x53, 0x43, 0xf0, 0xf3, 0x0b, 0x50, 0x79, 0x7f, 0x54, 0x70, 0x0f, 0x9b,
|
||||
0x51, 0xd3, 0xf8, 0xbf, 0xd4, 0x7b, 0x62, 0x41, 0x2d, 0x13, 0x7a, 0xdf, 0x50, 0x26, 0x75, 0xa6,
|
||||
0x29, 0x44, 0x10, 0x1e, 0x57, 0xa2, 0x49, 0x4e, 0x3e, 0x7e, 0x87, 0x63, 0x00, 0x21, 0xad, 0x20,
|
||||
0x7c, 0x81, 0xbd, 0x40, 0xaf, 0xc8, 0x26, 0x2d, 0x47, 0x1b, 0x3b, 0x40, 0x53, 0xf3, 0x9c, 0x92,
|
||||
0xa0, 0xf2, 0xc9, 0x73, 0x0f, 0xe6, 0xf1, 0x71, 0x42, 0xf0, 0x38, 0xfd, 0x64, 0x55, 0x36, 0xe6,
|
||||
0xec, 0x78, 0x96, 0x1b, 0xf0, 0x99, 0x1b, 0x3d, 0x1c, 0x51, 0x5c, 0x05, 0x42, 0x6d, 0x63, 0x10,
|
||||
0x75, 0xdd, 0x47, 0x5f, 0xaa, 0x51, 0x53, 0x02, 0x56, 0x5d, 0xb4, 0xf5, 0xa2, 0xd3, 0x42, 0x10,
|
||||
0x0b, 0xb3, 0x2e, 0x8d, 0x5d, 0x22, 0x8e, 0x84, 0x7a, 0x3e, 0x79, 0xed, 0xc2, 0x90, 0x61, 0x2c,
|
||||
0x72, 0x2b, 0xcb, 0x55, 0xd9, 0xc7, 0x39, 0x2b, 0x1e, 0x6b, 0x89, 0x19, 0x0b, 0x99, 0x3b, 0xb4,
|
||||
0xda, 0x7f, 0xd1, 0x72, 0x6e, 0x5a, 0xf2, 0x74, 0x8a, 0x6b, 0x91, 0x1c, 0x8b, 0x65, 0x14, 0xa3,
|
||||
0xaf, 0x78, 0xf5, 0xbd, 0xaf, 0xda, 0x9a, 0x16, 0x59, 0x65, 0xe2, 0x99, 0xbb, 0x50, 0x3c, 0x28,
|
||||
0xb9, 0x93, 0x2b, 0xf5, 0x45, 0xd4, 0x85, 0x3c, 0x7f, 0xdb, 0xcc, 0x05, 0xb9, 0xab, 0x23, 0xa4,
|
||||
0x71, 0xd2, 0x18, 0x26, 0xc0, 0xea, 0xf8, 0x91, 0x57, 0xb1, 0x0d, 0xd2, 0xb2, 0x86, 0xe6, 0x70,
|
||||
0x53, 0x4b, 0xb4, 0x1e, 0xa2, 0x4c, 0x25, 0x1d, 0x55, 0x8a, 0x7f, 0x77, 0x20, 0x53, 0x11, 0x13,
|
||||
0xad, 0xe1, 0x8c, 0xd9, 0xe8, 0xdc, 0xd3, 0xcb, 0xed, 0xdd, 0x26, 0x96, 0x19, 0xb0, 0x8c, 0x4c,
|
||||
0xb0, 0xad, 0x8d, 0x0c, 0x99, 0x76, 0x22, 0x43, 0xa6, 0xa0, 0xf2, 0x8d, 0x0f, 0x60, 0x05, 0xe0,
|
||||
0x36, 0xbf, 0x0d, 0xc4, 0xe1, 0x2f, 0x05, 0x8e, 0xd9, 0x3a, 0x45, 0x9d, 0xd9, 0xd7, 0x89, 0x23,
|
||||
0x20, 0x11, 0x0c, 0x47, 0x3d, 0x9c, 0xf7, 0x18, 0xe3, 0xa3, 0x22, 0xc2, 0x8c, 0x09, 0xe9, 0xb3,
|
||||
0xcc, 0x54, 0xf0, 0x97, 0x60, 0x63, 0xb1, 0x49, 0xf4, 0x69, 0xbd, 0x8e, 0x52, 0x12, 0x38, 0x23,
|
||||
0x96, 0x55, 0x67, 0x2b, 0x75, 0x0b, 0x20, 0xcd, 0xc0, 0x7d, 0x5a, 0x83, 0x7b, 0xb9, 0xf7, 0x1a,
|
||||
0x70, 0xf8, 0xa4, 0x76, 0xc7, 0x65, 0x03, 0xcb, 0x1a, 0x9a, 0xb4, 0x6d, 0x01, 0xfd, 0x25, 0x49,
|
||||
0xc2, 0xad, 0xa0, 0x7a, 0xd2
|
||||
};
|
||||
|
||||
static uint8_t g_secCertDerFormat[] = {
|
||||
0x30, 0x82, 0x05, 0xbc, 0x30, 0x82, 0x03, 0xa4, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x64,
|
||||
0x36, 0x52, 0x81, 0xa9, 0xfb, 0xb4, 0x5b, 0xe6, 0x78, 0xc9, 0x94, 0x0f, 0xcd, 0x24, 0x93, 0xea,
|
||||
0x29, 0x39, 0x9c, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
|
||||
0x05, 0x00, 0x30, 0x6f, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43,
|
||||
0x49, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x02, 0x68, 0x6e, 0x31, 0x0b,
|
||||
0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c, 0x02, 0x73, 0x68, 0x31, 0x0b, 0x30, 0x09, 0x06,
|
||||
0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02, 0x68, 0x68, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
|
||||
0x0b, 0x0c, 0x02, 0x69, 0x69, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x02,
|
||||
0x61, 0x62, 0x31, 0x1f, 0x30, 0x1d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09,
|
||||
0x01, 0x16, 0x10, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x40, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
|
||||
0x63, 0x6f, 0x6d, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x32, 0x32,
|
||||
0x38, 0x30, 0x38, 0x5a, 0x17, 0x0d, 0x34, 0x32, 0x30, 0x38, 0x32, 0x30, 0x31, 0x32, 0x32, 0x38,
|
||||
0x30, 0x38, 0x5a, 0x30, 0x7c, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02,
|
||||
0x43, 0x4e, 0x31, 0x0e, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x05, 0x48, 0x55, 0x4e,
|
||||
0x41, 0x4e, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c, 0x08, 0x53, 0x48, 0x41,
|
||||
0x47, 0x4e, 0x48, 0x41, 0x49, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x02,
|
||||
0x68, 0x68, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x02, 0x69, 0x69, 0x31,
|
||||
0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72,
|
||||
0x31, 0x1f, 0x30, 0x1d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16,
|
||||
0x10, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x40, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e, 0x63, 0x6f,
|
||||
0x6d, 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, 0xb9, 0x25, 0x72, 0xae, 0x5b, 0x02, 0xe6, 0x73, 0xbe, 0xeb, 0x89, 0x93, 0x60, 0x60,
|
||||
0x15, 0x25, 0xbd, 0x5b, 0x75, 0x12, 0x61, 0xcf, 0xb0, 0x13, 0x33, 0x2d, 0x82, 0x13, 0x60, 0x02,
|
||||
0xca, 0x8f, 0xd1, 0x02, 0x5d, 0xa9, 0xe1, 0x8a, 0x33, 0xf2, 0xe2, 0x7a, 0x53, 0x6d, 0xc8, 0xa7,
|
||||
0x81, 0x7e, 0x1e, 0x60, 0x06, 0xa9, 0x79, 0xc8, 0x44, 0x67, 0xb3, 0xc1, 0xbf, 0x94, 0xd5, 0x76,
|
||||
0x8c, 0x93, 0x15, 0xfa, 0x58, 0x94, 0x32, 0x6e, 0x78, 0x1b, 0x62, 0x17, 0x49, 0x5f, 0x40, 0x2c,
|
||||
0xac, 0x49, 0x73, 0xd8, 0x26, 0x6c, 0x87, 0x46, 0x44, 0xf5, 0xbb, 0x1f, 0x01, 0xa9, 0x29, 0x32,
|
||||
0xd4, 0xab, 0x0a, 0x6e, 0xd1, 0x0a, 0xe7, 0x07, 0xc4, 0x30, 0xfd, 0x47, 0xa5, 0x83, 0x58, 0xed,
|
||||
0xa9, 0xdc, 0x04, 0x6a, 0xf1, 0x06, 0xe6, 0x2c, 0xf9, 0x3a, 0x33, 0x4b, 0x65, 0xf4, 0x86, 0xe8,
|
||||
0xe3, 0x2f, 0xe7, 0x27, 0xce, 0x2b, 0xbc, 0xd7, 0xc4, 0x92, 0x38, 0x15, 0x36, 0x75, 0xa1, 0xdc,
|
||||
0x92, 0xc9, 0xf1, 0xaf, 0x4e, 0x9d, 0xa3, 0xc1, 0x9b, 0xed, 0xe3, 0xff, 0x57, 0xcf, 0x87, 0x37,
|
||||
0x13, 0x02, 0x8e, 0x55, 0x01, 0x7c, 0xc4, 0x71, 0x4a, 0x26, 0xc6, 0x85, 0x7f, 0x25, 0x97, 0x54,
|
||||
0x0d, 0xcd, 0x2e, 0x16, 0x3a, 0x95, 0x78, 0x6f, 0x6c, 0xbc, 0xc1, 0x31, 0xd1, 0xd6, 0xe7, 0xff,
|
||||
0x16, 0x2b, 0x3e, 0x6d, 0xce, 0xca, 0x09, 0x8d, 0x8e, 0x66, 0xf0, 0xb9, 0x69, 0x14, 0xf7, 0x0c,
|
||||
0x75, 0x68, 0x10, 0xc1, 0xd2, 0x4e, 0x44, 0xc1, 0x9d, 0xa9, 0x11, 0xa8, 0x2e, 0xb3, 0xb5, 0x9b,
|
||||
0x43, 0x1d, 0xfb, 0x32, 0xbc, 0xaf, 0x2c, 0x83, 0x19, 0x22, 0x53, 0x9f, 0xa8, 0x29, 0xf2, 0x83,
|
||||
0x08, 0xb8, 0xef, 0xc1, 0x4b, 0x0f, 0x63, 0x25, 0xd3, 0xed, 0x52, 0xff, 0x75, 0x50, 0x47, 0xc4,
|
||||
0xb8, 0x32, 0x9b, 0x65, 0x3e, 0xb9, 0x69, 0x7c, 0xdb, 0x64, 0x16, 0xe8, 0x79, 0x22, 0x7f, 0xe5,
|
||||
0x12, 0x03, 0x77, 0xe3, 0x42, 0x3c, 0x71, 0xd4, 0x1f, 0xbf, 0x86, 0x45, 0x95, 0x9d, 0x41, 0x70,
|
||||
0x58, 0x73, 0xd3, 0xd3, 0x18, 0x24, 0x5a, 0x3e, 0xb6, 0x84, 0x26, 0xeb, 0x6b, 0xa6, 0xa1, 0x91,
|
||||
0x41, 0x74, 0x7e, 0xfa, 0xc3, 0x2e, 0xb7, 0xe0, 0x51, 0x9b, 0xd4, 0x99, 0x61, 0x26, 0xfe, 0xaf,
|
||||
0x32, 0x0b, 0xb2, 0x33, 0xc4, 0x14, 0x4d, 0x8b, 0x05, 0xf4, 0xd0, 0x4b, 0x5c, 0xaa, 0x93, 0xe4,
|
||||
0x6b, 0x6e, 0x88, 0xae, 0x29, 0x6a, 0xac, 0x30, 0x88, 0xdc, 0xff, 0x9a, 0xee, 0xee, 0x95, 0xfc,
|
||||
0x40, 0xc0, 0xa8, 0x76, 0xbb, 0x92, 0x62, 0xc3, 0x4c, 0x5d, 0xf9, 0x00, 0x8d, 0x36, 0x4d, 0xdd,
|
||||
0x8b, 0x72, 0x9c, 0x87, 0x1d, 0x19, 0xb6, 0x89, 0xa3, 0xbe, 0x61, 0xd0, 0x87, 0x9e, 0xce, 0x65,
|
||||
0x14, 0x5f, 0x3b, 0x79, 0x4d, 0xa6, 0x59, 0xee, 0x8d, 0xdf, 0x7f, 0xe2, 0x89, 0x68, 0x3f, 0xe3,
|
||||
0x78, 0xc4, 0x66, 0x7d, 0x52, 0x49, 0xf0, 0xf4, 0xa1, 0xfe, 0x5f, 0x1d, 0x15, 0x67, 0x2e, 0xbc,
|
||||
0xd6, 0x5b, 0xb2, 0x69, 0x6d, 0x81, 0xb4, 0x42, 0x9c, 0xdc, 0xae, 0x6f, 0x70, 0x50, 0x40, 0xb7,
|
||||
0xc1, 0x52, 0x48, 0x06, 0x29, 0xf7, 0xf6, 0xc9, 0x6e, 0xa7, 0xd7, 0x34, 0x80, 0xcb, 0x3c, 0x9a,
|
||||
0x20, 0x43, 0xc1, 0x0a, 0xb1, 0xc7, 0x0e, 0x7e, 0xcf, 0xc8, 0x88, 0xc0, 0xcf, 0xdd, 0x68, 0x2d,
|
||||
0x4f, 0x7b, 0xf5, 0x0a, 0xbe, 0xfa, 0xcf, 0xe7, 0x5b, 0x06, 0x8d, 0x39, 0x7c, 0x77, 0xb0, 0xde,
|
||||
0x7d, 0x98, 0xe5, 0x24, 0xc2, 0x9f, 0x19, 0xf1, 0xc6, 0xd8, 0x7f, 0x8e, 0x8e, 0x7d, 0x6c, 0xee,
|
||||
0x88, 0x79, 0x48, 0x4d, 0xfa, 0x47, 0xe7, 0x9c, 0xa1, 0x80, 0xee, 0xec, 0x70, 0x3e, 0x9a, 0x64,
|
||||
0xfc, 0x21, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x43, 0x30, 0x41, 0x30, 0x0c, 0x06, 0x03, 0x55,
|
||||
0x1d, 0x13, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x31, 0x06, 0x03, 0x55, 0x1d, 0x1f,
|
||||
0x04, 0x2a, 0x30, 0x28, 0x30, 0x26, 0xa0, 0x24, 0xa0, 0x22, 0x86, 0x20, 0x68, 0x74, 0x74, 0x70,
|
||||
0x73, 0x3a, 0x2f, 0x2f, 0x63, 0x61, 0x2e, 0x78, 0x69, 0x65, 0x78, 0x69, 0x61, 0x6e, 0x62, 0x69,
|
||||
0x6e, 0x2e, 0x63, 0x6e, 0x2f, 0x63, 0x72, 0x6c, 0x2e, 0x70, 0x65, 0x6d, 0x30, 0x0d, 0x06, 0x09,
|
||||
0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x02, 0x01, 0x00,
|
||||
0x29, 0x50, 0x7b, 0x20, 0x86, 0x76, 0x58, 0x74, 0xaf, 0x44, 0xb9, 0xe4, 0x32, 0x46, 0x83, 0x74,
|
||||
0x8b, 0xb7, 0xee, 0x5e, 0xb4, 0x54, 0xc8, 0x63, 0xef, 0xd3, 0x1f, 0x39, 0x34, 0xc8, 0xff, 0x40,
|
||||
0x9c, 0x67, 0x4a, 0x7c, 0x1b, 0xe7, 0xea, 0x38, 0xa1, 0x93, 0x0a, 0xd3, 0x93, 0x14, 0xb7, 0xf3,
|
||||
0x9d, 0x70, 0xa0, 0x0c, 0xe6, 0x07, 0xf4, 0x5e, 0x6d, 0xba, 0x02, 0xcb, 0x77, 0xd0, 0x7b, 0x16,
|
||||
0x22, 0xf2, 0xb3, 0x97, 0x81, 0x75, 0x74, 0x72, 0x9b, 0x6d, 0x81, 0x1e, 0xcf, 0xe3, 0xb7, 0x35,
|
||||
0x17, 0x16, 0xbc, 0x52, 0x15, 0x60, 0x61, 0xc6, 0xf5, 0xb4, 0x73, 0x00, 0xb0, 0xcb, 0x9f, 0x60,
|
||||
0xe5, 0xcf, 0xef, 0x5f, 0x74, 0x1c, 0xbe, 0x58, 0x89, 0x7e, 0x36, 0x8b, 0xab, 0xae, 0xc2, 0xc0,
|
||||
0x72, 0x1d, 0x2a, 0x52, 0xa8, 0x72, 0x88, 0x09, 0xa7, 0x5a, 0x9e, 0x44, 0xec, 0xbb, 0x1d, 0xf2,
|
||||
0xd0, 0x31, 0x02, 0x47, 0x13, 0xf1, 0x5c, 0xdf, 0x44, 0x19, 0x5e, 0x9e, 0x5b, 0x25, 0xc9, 0xa0,
|
||||
0x28, 0x36, 0x06, 0x76, 0xfa, 0xe0, 0x28, 0x6a, 0x73, 0x81, 0xfe, 0x33, 0x8c, 0xe6, 0x07, 0xf8,
|
||||
0xe3, 0x21, 0xc0, 0x1d, 0x86, 0xf4, 0xd7, 0x7a, 0x7a, 0x7e, 0xd3, 0x0a, 0x28, 0x6a, 0xdc, 0x0f,
|
||||
0x07, 0x88, 0x68, 0xfe, 0x33, 0x73, 0xb3, 0xac, 0xa8, 0x16, 0x47, 0x8a, 0xa2, 0x1e, 0x63, 0xe0,
|
||||
0xdd, 0x25, 0xfb, 0x9e, 0x33, 0xcb, 0x3d, 0x57, 0xab, 0x97, 0x2f, 0xa8, 0xf2, 0x88, 0x76, 0xa5,
|
||||
0x2c, 0x31, 0x48, 0xb4, 0x0c, 0x2a, 0x03, 0xc7, 0xa5, 0xbb, 0xcc, 0x1c, 0x8a, 0xf9, 0xbd, 0x12,
|
||||
0x00, 0x92, 0x51, 0xa0, 0xd9, 0x33, 0xfb, 0x59, 0x5e, 0x7e, 0x59, 0xcf, 0x8c, 0x0b, 0xe2, 0xec,
|
||||
0x7d, 0x9e, 0x4c, 0xed, 0x64, 0x99, 0x58, 0x3e, 0x81, 0x57, 0x65, 0xc8, 0x1c, 0x0d, 0xa2, 0x33,
|
||||
0x73, 0x7b, 0xc1, 0x8c, 0xef, 0x1f, 0x49, 0x4d, 0x96, 0x04, 0x75, 0x3e, 0xef, 0x2f, 0x85, 0xf9,
|
||||
0x4f, 0x7d, 0x28, 0xc5, 0xa2, 0xe2, 0x0b, 0x6c, 0x41, 0xe7, 0xb2, 0x89, 0x07, 0x3e, 0xc5, 0x1d,
|
||||
0x6f, 0x19, 0xcd, 0x98, 0xec, 0x8c, 0xa4, 0x20, 0xc2, 0x83, 0x77, 0x23, 0xb9, 0x96, 0x08, 0xca,
|
||||
0x30, 0x08, 0x07, 0xf3, 0xa8, 0x00, 0x30, 0x1e, 0x90, 0x01, 0xd7, 0xdd, 0xc0, 0x22, 0xb4, 0x10,
|
||||
0x73, 0xcc, 0x3f, 0x4c, 0x04, 0xaf, 0xd4, 0x5d, 0x19, 0x0c, 0x75, 0xe7, 0x7a, 0x25, 0x5c, 0x1f,
|
||||
0x6d, 0x91, 0xaa, 0xfb, 0x62, 0xcb, 0x37, 0x35, 0xf3, 0xa8, 0xc5, 0x90, 0x78, 0x27, 0x06, 0xa1,
|
||||
0xc4, 0x47, 0x89, 0x5f, 0xbb, 0xbb, 0x0d, 0xe4, 0x94, 0xb0, 0x0d, 0x7c, 0x5f, 0x4d, 0xc9, 0x7b,
|
||||
0xd6, 0xe8, 0x56, 0x0d, 0xe7, 0x42, 0xe1, 0x9e, 0x8a, 0xe8, 0x1b, 0x0b, 0x2e, 0x19, 0xeb, 0x58,
|
||||
0xdb, 0x61, 0x7f, 0xf2, 0xcd, 0x4d, 0xd2, 0x80, 0xbb, 0x51, 0xc9, 0xff, 0x26, 0x66, 0x54, 0x03,
|
||||
0xdc, 0x63, 0x68, 0x20, 0xc4, 0x7a, 0x84, 0xc3, 0xa1, 0xe7, 0xef, 0xf3, 0xfd, 0xf3, 0x4a, 0xbd,
|
||||
0xac, 0x47, 0xac, 0x11, 0xee, 0x12, 0x07, 0x82, 0xf0, 0xbd, 0x34, 0xd3, 0x93, 0xcd, 0xd4, 0x92,
|
||||
0x46, 0xa7, 0x37, 0x01, 0xf5, 0x33, 0xf7, 0x49, 0x1d, 0xb0, 0x0a, 0x19, 0xa3, 0x0a, 0xa5, 0xec,
|
||||
0x2a, 0xd9, 0xcb, 0xb2, 0xe2, 0xab, 0x36, 0x89, 0x33, 0x2d, 0x45, 0xfb, 0x61, 0xfc, 0x8e, 0x6c,
|
||||
0xdf, 0x09, 0x5e, 0x83, 0x05, 0xa0, 0x98, 0x83, 0x39, 0x41, 0x19, 0x2f, 0xdd, 0xab, 0xf4, 0x3b,
|
||||
0x03, 0xd9, 0x1b, 0x66, 0xb7, 0xc2, 0x79, 0xbf, 0xf2, 0x12, 0x0c, 0xf4, 0x87, 0x42, 0xeb, 0x5a,
|
||||
0x70, 0x56, 0xc3, 0x0e, 0xeb, 0xd9, 0x3f, 0x87, 0x93, 0x82, 0xd0, 0xfe, 0x32, 0xed, 0x0b, 0x54,
|
||||
};
|
||||
|
||||
static uint8_t g_invalidCert0[] = {
|
||||
0x30, 0x82, 0x03, 0xc1, 0x30, 0x82, 0x03, 0xa9, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x05,
|
||||
};
|
||||
|
||||
static HcfCertChainValidator *g_validator = nullptr;
|
||||
|
||||
void CryptoX509CertChainValidatorTest::SetUpTestCase()
|
||||
{
|
||||
(void)HcfCertChainValidatorCreate("PKIX", &g_validator);
|
||||
}
|
||||
void CryptoX509CertChainValidatorTest::TearDownTestCase()
|
||||
{
|
||||
CfObjDestroy(g_validator);
|
||||
}
|
||||
|
||||
void CryptoX509CertChainValidatorTest::SetUp()
|
||||
{
|
||||
}
|
||||
|
||||
void CryptoX509CertChainValidatorTest::TearDown()
|
||||
{
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, GetAlgorithm001, TestSize.Level0)
|
||||
{
|
||||
const char *algo = g_validator->getAlgorithm(g_validator);
|
||||
EXPECT_NE(algo, nullptr);
|
||||
if (algo == nullptr) {
|
||||
CfObjDestroy(g_validator);
|
||||
return;
|
||||
}
|
||||
string st("PKIX");
|
||||
ASSERT_STREQ(algo, st.c_str());
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, GetAlgorithm002, TestSize.Level0)
|
||||
{
|
||||
HcfCertChainValidator *pathValidator = nullptr;
|
||||
CfResult res = HcfCertChainValidatorCreate("invalidPKIX", &pathValidator);
|
||||
EXPECT_EQ(res, CF_NOT_SUPPORT);
|
||||
EXPECT_EQ(pathValidator, nullptr);
|
||||
}
|
||||
|
||||
/* valid cert chain. */
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest001, TestSize.Level0)
|
||||
{
|
||||
CfResult res = CF_SUCCESS;
|
||||
HcfCertChainData certsData = { 0 };
|
||||
certsData.format = CF_FORMAT_PEM;
|
||||
certsData.count = 2; /* level-2 cert chain. */
|
||||
uint32_t caCertLen = strlen(g_caCert) + 1;
|
||||
uint32_t secondCaCertLen = strlen(g_secondCaCert) + 1;
|
||||
certsData.dataLen = CERT_HEADER_LEN + secondCaCertLen + CERT_HEADER_LEN + caCertLen;
|
||||
certsData.data = (uint8_t *)malloc(certsData.dataLen);
|
||||
if (certsData.data == nullptr) {
|
||||
return;
|
||||
}
|
||||
if (memcpy_s(certsData.data, CERT_HEADER_LEN + secondCaCertLen + CERT_HEADER_LEN + caCertLen,
|
||||
&secondCaCertLen, CERT_HEADER_LEN) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
if (memcpy_s(certsData.data + CERT_HEADER_LEN, secondCaCertLen + CERT_HEADER_LEN + caCertLen,
|
||||
g_secondCaCert, secondCaCertLen) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
if (memcpy_s(certsData.data + CERT_HEADER_LEN + secondCaCertLen, CERT_HEADER_LEN + caCertLen,
|
||||
&caCertLen, CERT_HEADER_LEN) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
if (memcpy_s(certsData.data + CERT_HEADER_LEN + secondCaCertLen + CERT_HEADER_LEN, caCertLen,
|
||||
g_caCert, caCertLen) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
|
||||
res = g_validator->validate(g_validator, &certsData);
|
||||
EXPECT_EQ(res, CF_SUCCESS);
|
||||
OUT:
|
||||
free(certsData.data);
|
||||
}
|
||||
|
||||
/* invalid cert chain. */
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest002, TestSize.Level0)
|
||||
{
|
||||
CfResult res = CF_SUCCESS;
|
||||
HcfCertChainData certsData = { 0 };
|
||||
certsData.format = CF_FORMAT_PEM;
|
||||
certsData.count = 3; /* level-3 cert chain. */
|
||||
uint32_t caCertLen = strlen(g_caCert) + 1;
|
||||
uint32_t secondCaCertLen = strlen(g_secondCaCert) + 1;
|
||||
uint32_t thirdCertLen = strlen(g_invalidCaCert) + 1;
|
||||
certsData.dataLen = CERT_HEADER_LEN + thirdCertLen + CERT_HEADER_LEN +
|
||||
secondCaCertLen + CERT_HEADER_LEN + caCertLen;
|
||||
certsData.data = (uint8_t *)malloc(certsData.dataLen);
|
||||
EXPECT_NE(certsData.data, nullptr);
|
||||
if (certsData.data == nullptr) {
|
||||
return;
|
||||
}
|
||||
if (memcpy_s(certsData.data,
|
||||
CERT_HEADER_LEN + thirdCertLen + CERT_HEADER_LEN + secondCaCertLen + CERT_HEADER_LEN + caCertLen,
|
||||
&thirdCertLen, CERT_HEADER_LEN) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
if (memcpy_s(certsData.data + CERT_HEADER_LEN,
|
||||
thirdCertLen + CERT_HEADER_LEN + secondCaCertLen + CERT_HEADER_LEN + caCertLen,
|
||||
g_invalidCaCert, thirdCertLen) != EOK) {
|
||||
return;
|
||||
}
|
||||
if (memcpy_s(certsData.data + CERT_HEADER_LEN + thirdCertLen,
|
||||
CERT_HEADER_LEN + secondCaCertLen + CERT_HEADER_LEN + caCertLen, &secondCaCertLen, CERT_HEADER_LEN) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
if (memcpy_s(certsData.data + CERT_HEADER_LEN + thirdCertLen + CERT_HEADER_LEN,
|
||||
secondCaCertLen + CERT_HEADER_LEN + caCertLen, g_secondCaCert, secondCaCertLen) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
if (memcpy_s(certsData.data + CERT_HEADER_LEN + thirdCertLen + CERT_HEADER_LEN + secondCaCertLen,
|
||||
CERT_HEADER_LEN + caCertLen, &caCertLen, CERT_HEADER_LEN) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
if (memcpy_s(certsData.data + CERT_HEADER_LEN + thirdCertLen + CERT_HEADER_LEN + secondCaCertLen + CERT_HEADER_LEN,
|
||||
caCertLen, g_caCert, caCertLen) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
|
||||
res = g_validator->validate(g_validator, &certsData);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
OUT:
|
||||
free(certsData.data);
|
||||
}
|
||||
|
||||
/* invalid cert chain data len. */
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest003, TestSize.Level0)
|
||||
{
|
||||
HcfCertChainData certsData = { 0 };
|
||||
certsData.format = CF_FORMAT_PEM;
|
||||
certsData.count = 3; /* level-3 cert chain. */
|
||||
certsData.dataLen = INVALID_MAX_CERT_LEN;
|
||||
certsData.data = (uint8_t *)malloc(certsData.dataLen);
|
||||
EXPECT_NE(certsData.data, nullptr);
|
||||
if (certsData.data == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
CfResult res = g_validator->validate(g_validator, &certsData);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
free(certsData.data);
|
||||
}
|
||||
|
||||
/* invalid cert number(1). */
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest004, TestSize.Level0)
|
||||
{
|
||||
CfResult res = CF_SUCCESS;
|
||||
HcfCertChainData certsData = { 0 };
|
||||
certsData.format = CF_FORMAT_PEM;
|
||||
certsData.count = 1; /* level-3 cert chain. */
|
||||
uint32_t caCertLen = strlen(g_caCert) + 1;
|
||||
certsData.dataLen = CERT_HEADER_LEN + caCertLen;
|
||||
certsData.data = (uint8_t *)malloc(certsData.dataLen);
|
||||
EXPECT_NE(certsData.data, nullptr);
|
||||
if (certsData.data == nullptr) {
|
||||
return;
|
||||
}
|
||||
if (memcpy_s(certsData.data,
|
||||
CERT_HEADER_LEN + caCertLen, &caCertLen, CERT_HEADER_LEN) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
if (memcpy_s(certsData.data + CERT_HEADER_LEN,
|
||||
caCertLen, g_caCert, caCertLen) != EOK) {
|
||||
goto OUT;
|
||||
}
|
||||
|
||||
res = g_validator->validate(g_validator, &certsData);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
OUT:
|
||||
free(certsData.data);
|
||||
}
|
||||
|
||||
static int32_t ConstructCertData(HcfCertChainData *certsData, uint8_t *caCert, uint32_t caCertLen,
|
||||
uint8_t *secCaCert, uint32_t secCaCertLen)
|
||||
{
|
||||
uint32_t size = CERT_HEADER_LEN + secCaCertLen + CERT_HEADER_LEN + caCertLen;
|
||||
uint8_t *tmp = (uint8_t *)malloc(size);
|
||||
if (tmp == nullptr) {
|
||||
return CF_ERR_MALLOC;
|
||||
}
|
||||
|
||||
int32_t ret = CF_ERR_COPY;
|
||||
do {
|
||||
uint32_t offset = 0;
|
||||
if (memcpy_s(tmp + offset, size - offset, &secCaCertLen, CERT_HEADER_LEN) != EOK) {
|
||||
break;
|
||||
}
|
||||
offset += CERT_HEADER_LEN;
|
||||
if (memcpy_s(tmp + offset, size - offset, secCaCert, secCaCertLen) != EOK) {
|
||||
break;
|
||||
}
|
||||
offset += secCaCertLen;
|
||||
if (memcpy_s(tmp + offset, size - offset, &caCertLen, CERT_HEADER_LEN) != EOK) {
|
||||
break;
|
||||
}
|
||||
offset += CERT_HEADER_LEN;
|
||||
if (memcpy_s(tmp + offset, size - offset, caCert, caCertLen) != EOK) {
|
||||
break;
|
||||
}
|
||||
certsData->data = tmp;
|
||||
certsData->dataLen = size;
|
||||
return CF_SUCCESS;
|
||||
} while (0);
|
||||
free(tmp);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* valid cert chain der format. */
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest005, TestSize.Level0)
|
||||
{
|
||||
HcfCertChainData certsData = { 0 };
|
||||
certsData.format = CF_FORMAT_DER;
|
||||
certsData.count = 2; /* level-2 cert chain. */
|
||||
|
||||
uint32_t caCertLen = sizeof(g_certDerFormat);
|
||||
uint32_t secondCaCertLen = sizeof(g_secCertDerFormat);
|
||||
int32_t ret = ConstructCertData(&certsData, g_certDerFormat, caCertLen, g_secCertDerFormat, secondCaCertLen);
|
||||
ASSERT_EQ(ret, CF_SUCCESS);
|
||||
|
||||
ret = g_validator->validate(g_validator, &certsData);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
free(certsData.data);
|
||||
}
|
||||
|
||||
/* valid cert chain format. */
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest006, TestSize.Level0)
|
||||
{
|
||||
HcfCertChainData certsData = { 0 };
|
||||
certsData.format = static_cast<enum CfEncodingFormat>(CF_FORMAT_PEM + 1);
|
||||
certsData.count = 2; /* level-2 cert chain. */
|
||||
|
||||
uint32_t caCertLen = sizeof(g_certDerFormat);
|
||||
uint32_t secondCaCertLen = sizeof(g_secCertDerFormat);
|
||||
int32_t ret = ConstructCertData(&certsData, g_certDerFormat, caCertLen, g_secCertDerFormat, secondCaCertLen);
|
||||
ASSERT_EQ(ret, CF_SUCCESS);
|
||||
|
||||
ret = g_validator->validate(g_validator, &certsData);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
free(certsData.data);
|
||||
}
|
||||
|
||||
/* invalid cert 0. */
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest007, TestSize.Level0)
|
||||
{
|
||||
HcfCertChainData certsData = { 0 };
|
||||
certsData.format = CF_FORMAT_DER;
|
||||
certsData.count = 2; /* level-2 cert chain. */
|
||||
|
||||
uint32_t caCertLen = sizeof(g_invalidCert0);
|
||||
uint32_t secondCaCertLen = sizeof(g_secCertDerFormat);
|
||||
int32_t ret = ConstructCertData(&certsData, g_invalidCert0, caCertLen, g_secCertDerFormat, secondCaCertLen);
|
||||
ASSERT_EQ(ret, CF_SUCCESS);
|
||||
|
||||
ret = g_validator->validate(g_validator, &certsData);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
free(certsData.data);
|
||||
}
|
||||
|
||||
static const char *GetInvalidValidatorClass(void)
|
||||
{
|
||||
return "INVALID_VALIDATOR_CLASS";
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, NullInput, TestSize.Level0)
|
||||
{
|
||||
CfResult res = HcfCertChainValidatorCreate("PKIX", nullptr);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
res = g_validator->validate(g_validator, nullptr);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
const char *algo = g_validator->getAlgorithm(nullptr);
|
||||
EXPECT_EQ(algo, nullptr);
|
||||
(void)g_validator->base.destroy(nullptr);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, InvalidClass, TestSize.Level0)
|
||||
{
|
||||
HcfCertChainValidator invalidValidator;
|
||||
invalidValidator.base.getClass = GetInvalidValidatorClass;
|
||||
HcfCertChainData certsData = { 0 };
|
||||
CfResult res = g_validator->validate(&invalidValidator, &certsData);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
const char *algo = g_validator->getAlgorithm(&invalidValidator);
|
||||
EXPECT_EQ(algo, nullptr);
|
||||
(void)g_validator->base.destroy(&(invalidValidator.base));
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, NullSpiInput, TestSize.Level0)
|
||||
{
|
||||
HcfCertChainValidatorSpi *spiObj = nullptr;
|
||||
CfResult res = HcfCertChainValidatorSpiCreate(nullptr);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
res = HcfCertChainValidatorSpiCreate(&spiObj);
|
||||
EXPECT_EQ(res, CF_SUCCESS);
|
||||
res = spiObj->engineValidate(spiObj, nullptr);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
(void)spiObj->base.destroy(nullptr);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, InvalidSpiClass, TestSize.Level0)
|
||||
{
|
||||
HcfCertChainValidatorSpi *spiObj = nullptr;
|
||||
CfResult res = HcfCertChainValidatorSpiCreate(&spiObj);
|
||||
HcfCertChainValidatorSpi invalidSpi;
|
||||
invalidSpi.base.getClass = GetInvalidValidatorClass;
|
||||
CfArray data = { 0 };
|
||||
res = spiObj->engineValidate(&invalidSpi, &data);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
(void)spiObj->base.destroy(&(invalidSpi.base));
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertChainValidatorTest, InvalidMalloc, TestSize.Level0)
|
||||
{
|
||||
SetMockFlag(true);
|
||||
HcfCertChainValidator *pathValidator = nullptr;
|
||||
CfResult res = HcfCertChainValidatorCreate("PKIX", &pathValidator);
|
||||
EXPECT_EQ(res, CF_ERR_MALLOC);
|
||||
HcfCertChainData certsData = { 0 };
|
||||
certsData.dataLen = 1;
|
||||
res = g_validator->validate(g_validator, &certsData);
|
||||
EXPECT_NE(res, CF_SUCCESS);
|
||||
SetMockFlag(false);
|
||||
}
|
||||
}
|
||||
988
test/unittest/v1.0/src/crypto_x509_certificate_test.cpp
Normal file
988
test/unittest/v1.0/src/crypto_x509_certificate_test.cpp
Normal file
@ -0,0 +1,988 @@
|
||||
/*
|
||||
* Copyright (c) 2023 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 <gtest/gtest.h>
|
||||
#include "securec.h"
|
||||
|
||||
#include "x509_certificate.h"
|
||||
#include "cf_blob.h"
|
||||
#include "memory_mock.h"
|
||||
|
||||
#include "certificate_openssl_common.h"
|
||||
#include "x509_certificate_openssl.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace testing::ext;
|
||||
|
||||
namespace {
|
||||
class CryptoX509CertificateTest : public testing::Test {
|
||||
public:
|
||||
static void SetUpTestCase();
|
||||
static void TearDownTestCase();
|
||||
void SetUp();
|
||||
void TearDown();
|
||||
};
|
||||
|
||||
static char g_deviceTestCert[] =
|
||||
"-----BEGIN CERTIFICATE-----\r\n"
|
||||
"MIIBLzCB1QIUO/QDVJwZLIpeJyPjyTvE43xvE5cwCgYIKoZIzj0EAwIwGjEYMBYG\r\n"
|
||||
"A1UEAwwPRXhhbXBsZSBSb290IENBMB4XDTIzMDkwNDExMjAxOVoXDTI2MDUzMDEx\r\n"
|
||||
"MjAxOVowGjEYMBYGA1UEAwwPRXhhbXBsZSBSb290IENBMFkwEwYHKoZIzj0CAQYI\r\n"
|
||||
"KoZIzj0DAQcDQgAEHjG74yMIueO7z3T+dyuEIrhxTg2fqgeNB3SGfsIXlsiUfLTa\r\n"
|
||||
"tUsU0i/sePnrKglj2H8Abbx9PK0tsW/VgqwDIDAKBggqhkjOPQQDAgNJADBGAiEA\r\n"
|
||||
"0ce/fvA4tckNZeB865aOApKXKlBjiRlaiuq5mEEqvNACIQDPD9WyC21MXqPBuRUf\r\n"
|
||||
"BetUokslUfjT6+s/X4ByaxycAA==\r\n"
|
||||
"-----END CERTIFICATE-----";
|
||||
|
||||
static char g_rootCert[] =
|
||||
"-----BEGIN CERTIFICATE-----\r\n"
|
||||
"MIIGQDCCBCigAwIBAgIUKNQFxqguJbKjFXanBmC2ZwUv9dkwDQYJKoZIhvcNAQEL\r\n"
|
||||
"BQAwejELMAkGA1UEBhMCQ04xETAPBgNVBAgMCFNIQU5HSEFJMREwDwYDVQQHDAhT\r\n"
|
||||
"SEFOR0hBSTELMAkGA1UECgwCQUExCzAJBgNVBAsMAkJCMQswCQYDVQQDDAJDQzEe\r\n"
|
||||
"MBwGCSqGSIb3DQEJARYPZmlyc3RAaGVsbG8uY29tMCAXDTIyMDgyMzExMjk0MVoY\r\n"
|
||||
"DzIwNjIwODIzMTEyOTQxWjB6MQswCQYDVQQGEwJDTjERMA8GA1UECAwIU0hBTkdI\r\n"
|
||||
"QUkxETAPBgNVBAcMCFNIQU5HSEFJMQswCQYDVQQKDAJBQTELMAkGA1UECwwCQkIx\r\n"
|
||||
"CzAJBgNVBAMMAkNDMR4wHAYJKoZIhvcNAQkBFg9maXJzdEBoZWxsby5jb20wggIi\r\n"
|
||||
"MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCr4nXrmskgHytDYcp8/BRORk71\r\n"
|
||||
"f2idSs6cxxSOycILA3fbhbCB3qA8Bj4k1bT592j99MsKm+djMFvUOW/mS6iEWcoS\r\n"
|
||||
"sK1HvYX2d7y0GMDnltT9I/KlcYDHiwcq0UgHX4OSbB70EUt9vUmq/opYeUJFIbfq\r\n"
|
||||
"QJvGu57PJw+lxdsq3mZvx8n04fIMxqJdQSXu2foh0fSIePthNIV5JNtO9tTmmKn9\r\n"
|
||||
"b+L9Eb1IfhKnvxNVuq046+eUwRA3Qva4HQOkCplamfU+b2dQGXnpha/NzXfCVuZK\r\n"
|
||||
"R13xhUXjuXADGAIoRl9BgxgONTVpy209xQ7W1UvVEbSVDf8r9OlPDf3olRoavTAv\r\n"
|
||||
"+EaYyqrFoEtTzIRZDiLIhqjoqtpbrl5oVggfH/qn8qDyZ+a6puwa81+9Mad8CLwh\r\n"
|
||||
"Q9sa0uT+AET86gCGgpOBPF31+xYgnznQjd2wRs5a2rrYjy5wqAYyGPNUy9lm2EaU\r\n"
|
||||
"03jMv+JzgeSdyqly8g3oCxBhRENgtGWlMUzzqZoM+Z6/NUn+pebRr53z4lzQWFFV\r\n"
|
||||
"M1M81OHIKnleuud5CTnuRNfX7jVX9O+iu/bHjU2YKKrB3L1+ZY0cf6RXUDsBFSxg\r\n"
|
||||
"dRZXBVvjJ8Ag+PDYOGG4Cbh9NByhvNvoKa7eBDpWXkOcP6VqnlIL33AUNKk9NEZc\r\n"
|
||||
"KpyN1Dbk3eN/c9pIBQIDAQABo4G7MIG4MB0GA1UdDgQWBBRn2V1KId/KpzEztYbH\r\n"
|
||||
"PHbCFqIioTAfBgNVHSMEGDAWgBRn2V1KId/KpzEztYbHPHbCFqIioTASBgNVHRMB\r\n"
|
||||
"Af8ECDAGAQH/AgEDMAsGA1UdDwQEAwIBBjAdBgNVHSUEFjAUBggrBgEFBQcDAQYI\r\n"
|
||||
"KwYBBQUHAwIwGgYDVR0RBBMwEYEPZmlyc3RAaGVsbG8uY29tMBoGA1UdEgQTMBGB\r\n"
|
||||
"D2ZpcnN0QGhlbGxvLmNvbTANBgkqhkiG9w0BAQsFAAOCAgEAqbo9c3pEMfk4pmTL\r\n"
|
||||
"Oays4RGZy9kZtZMOgdNvZ1gLbRow85x3mSOQ7ew8trt4PbjEp48EQzTFy4AxsBj/\r\n"
|
||||
"Kw7p6Y9RAu/fBQMOMwIKzBUW9gayehpOyRTgnt27jDUBBXcq21HDy+WK9FTreqTG\r\n"
|
||||
"R2CH/Yt75pfsHLWulq7Ou3s5sWvLyuYxohVDsIJfJHwgUSGPB33bFGqSxzN4qOMJ\r\n"
|
||||
"4+M1OO0+hHVWzqESmYBaroX7XYoFeVOJsEDdjU9lccIZpfupbZ4ljjdBk3v45WSt\r\n"
|
||||
"gbTS2NYauczjl3wT/p5EU7iGf1a8rSOjUqZS6cmDP7Tq0PL4+1iMCZlF1ZXLvPb4\r\n"
|
||||
"dCAebIPMF7Pn1BLjANsQ94iKWHmPWdl8m6QmdCtSGgt7zNx3W0N6kF/7tRdshUQD\r\n"
|
||||
"mPXFZed3U3vVVCOGPPY/KYnNvU2umJ4EsDSThlRPPafZ8GDuj1cF4OGdxfNx6bSQ\r\n"
|
||||
"E6Zuj4oYR1k5+vAWbVS6F25KV0C6mXkrmL/pl2JQt+fyWIjGxP3pkBcxBYyP+OgQ\r\n"
|
||||
"hX9yv+cUIkDPNa9yytVn2Z+9CFJbz3l/AxIxTqR5a3m9Qlls4otQKco0E9ArA3ce\r\n"
|
||||
"v9YYMHEDo61jQYTd2rz7BvIdvQ+ds4V+GjmgDFa21tMvpNxC6LMy4gS4PmOSAbMu\r\n"
|
||||
"jI6AaoTlr5I7zPhFbR8/XEs7DzI=\r\n"
|
||||
"-----END CERTIFICATE-----\r\n";
|
||||
|
||||
static char g_secondCert[] =
|
||||
"-----BEGIN CERTIFICATE-----\r\n"
|
||||
"MIIFwjCCA6qgAwIBAgIUTUs0/9mQvlKZ67Q3nDR+5bwvyoowDQYJKoZIhvcNAQEL\r\n"
|
||||
"BQAwejELMAkGA1UEBhMCQ04xETAPBgNVBAgMCFNIQU5HSEFJMREwDwYDVQQHDAhT\r\n"
|
||||
"SEFOR0hBSTELMAkGA1UECgwCQUExCzAJBgNVBAsMAkJCMQswCQYDVQQDDAJDQzEe\r\n"
|
||||
"MBwGCSqGSIb3DQEJARYPZmlyc3RAaGVsbG8uY29tMB4XDTIyMDgyMzExMzQwMFoX\r\n"
|
||||
"DTQyMDgyMzExMzQwMFowezELMAkGA1UEBhMCQ04xETAPBgNVBAgMCFNIQU5HSEFJ\r\n"
|
||||
"MREwDwYDVQQHDAhTSEFOR0hBSTELMAkGA1UECgwCQUExCzAJBgNVBAsMAkJCMQsw\r\n"
|
||||
"CQYDVQQDDAJDQzEfMB0GCSqGSIb3DQEJARYQc2Vjb25kQGhlbGxvLmNvbTCCAiIw\r\n"
|
||||
"DQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAJkLbBN8iHBWDHCdoMPpUwIeCSpW\r\n"
|
||||
"nWdqJJ83Hmp3KQvm2sY9l2VOMFE+D9QJr3rRLuzQLYwcGjCcqcq+a7up7jfyB+wm\r\n"
|
||||
"FR+H1d9Mnv3G4n1ljwBuGqYr7QQh/6tZ7OsMaSdj6hAQe6b2eFeB1qpTORA2smX+\r\n"
|
||||
"uQZ6C47kKOVkna/P8ipSgnQZejX5f+O/SsystdCLbtkZCGXOahMhi9mmdbK0jNuy\r\n"
|
||||
"ZhM2sea8NiQONQjSFQm1pC0wpMyvCsZt0Xucxgv9pBvcX/w2BV8DrJ67yD61Lac2\r\n"
|
||||
"4x9u7FgBlJRHqBz8pdMo11dwXaBKLL0RHEJR5eZYivX9krRdWH5/8YUwAFnZ09HH\r\n"
|
||||
"IajVxZMBRSuUcHmFrGFbQcNCEsERx1DnWzb6j2iNo55s6kYWbvuF2vdAdZEJPWWk\r\n"
|
||||
"NKRn+OJYQR1t0micL+RRS0rvktc49AOa25xqHIDK9wV6kXlJA36mRa2x9/ijB2c8\r\n"
|
||||
"ZSn5vKhWRZOYQAQpB9kG5H2cK4xx48EOCNDnQ74RSVsP/xq8yJx6NOHDFkXhOq4M\r\n"
|
||||
"7daCtrY57GjyUgIEhhGi7DIAjfLqrwdihLWvUip1gS32lc9Qy806r+yQYHFzqImI\r\n"
|
||||
"GACoP9i5MfZDq5TUbwx4Z9yDQ0Djraa9GCU+GHmaZc84hiXwh2PsPCswG3mme87G\r\n"
|
||||
"OydzdjYF/KKO9P33AgMBAAGjPzA9MAwGA1UdEwQFMAMBAf8wLQYDVR0fBCYwJDAi\r\n"
|
||||
"oCCgHoYcaHR0cHM6Ly9jYS5zZWNvbmQuY24vY3JsLnBlbTANBgkqhkiG9w0BAQsF\r\n"
|
||||
"AAOCAgEASJmN9D3Nf5YHOSa28gZLKhGziwNG9ykRXK59vLNIeYYDuoR51m+zkqtm\r\n"
|
||||
"I5SuYDb+IfjicJCyMnrMlP/d/Lv/YUi/rEF/BS0YF2YlnX+5JmG8RG1Sh2OSfp28\r\n"
|
||||
"rmh5srMg76EuDXIPN1+qHeQqpbNj11DzKL3Z2Tv+ohj2+/WauJt2KTdRWbRU7AT7\r\n"
|
||||
"xRlgFOofQUFUo78JG+Op1yfQnbDqJNBB04ASwEi4ru9yliBgS6Ves/zn5xAjwe98\r\n"
|
||||
"1tGuGFhEYXEKzP3cPGShefdFgyI53YrsVxXy4+x5OdfyRiq9+ao/jAAezZc6fcBe\r\n"
|
||||
"V6gADyhpt9vSDinTcI3xBRqwLIa+ujTd/HEqSu9Di8xYJ+RbKJ0wFRK1VJqMZXKu\r\n"
|
||||
"HIo7mgfBUwojxFbIk+FSXWWvWBtaOQxy4BZxv5NjAFlYU2k3p0rJOhQ3CCpTd6Sf\r\n"
|
||||
"HVd68XS0xK+RLCYxbTK0ejZ8gGN3DHpdtCWRcVXOo47mR3eCgIWAdkWeRO+xs2LV\r\n"
|
||||
"5afFCeGtpITsNUkqh9YVTvMxLEBwSmNH4SHVzJN5Xj6hgfLg2ZhbI7r1DC8CaTr7\r\n"
|
||||
"H56qZfZmrvZbBc1q9yIhqJNPwwOZ0N0QJnZObBE1E8PX7if3lPlOoGIlbYcyEyu4\r\n"
|
||||
"neNdebXmjLY6R8J9/eLy36xX7vRdjDBT1gva9AIthH0dg0tpPJI=\r\n"
|
||||
"-----END CERTIFICATE-----\r\n";
|
||||
|
||||
static char g_testInvalidCert[] =
|
||||
"-----xxxx CERTIFICATE-----\r\n"
|
||||
"MIIDpzCCAo+gAwIBAgICAQAwDQYJKoZIhvcNAQELBQAwbDELMAkGA1UEBhMCQ04x\r\n"
|
||||
"CzAJBgNVBAgMAkJKMQswCQYDVQQHDAJCSjELMAkGA1UECgwCSEQxDDAKBgNVBAsM\r\n"
|
||||
"A2RldjELMAkGA1UEAwwCY2ExGzAZBgkqhkiG9w0BCQEWDGNhQHdvcmxkLmNvbTAe\r\n"
|
||||
"Fw0yMjA4MTkwNTE2MTVaFw0yMzA4MTkwNTE2MTVaMGwxCzAJBgNVBAYTAkNOMQsw\r\n"
|
||||
"CQYDVQQIDAJCSjELMAkGA1UEBwwCQkoxCzAJBgNVBAoMAkhEMQwwCgYDVQQLDANk\r\n"
|
||||
"ZXYxCzAJBgNVBAMMAmNhMRswGQYJKoZIhvcNAQkBFgxjYUB3b3JsZC5jb20wggEi\r\n"
|
||||
"MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCuvLoVT5em7ApBma8xtgpcFcaU\r\n"
|
||||
"CbXBJSUl2NpFW2sriucbEOvKRdw9KvLa/tSP6CupPZVKIzHAP2oeW88aFBr23miG\r\n"
|
||||
"iR49M52c73Iw3H3EG2ckK8M1mxEzXSqynivqiNZDKG+bA5cFzcfmk6Th1bJan9w9\r\n"
|
||||
"Ci8HPSBvgg7Rc6pqNM4HjTHl3Bb6cf4Xh3/GgpjypTd9jAAEyq+l/+1pnTYVlIJA\r\n"
|
||||
"WGh0Z26RosXfzwfFKH77ysTjoj9ambvGmFsMXvNXEyYmBCeYND6xGj4pa2lylsra\r\n"
|
||||
"kfYmGxcFQ45Lj5oWdNQQVdvrQiYWu3SJOC/WqB5UIAq92PPrq1apznxfjqABAgMB\r\n"
|
||||
"AAGjUzBRMB0GA1UdDgQWBBRI5iWwjBMAOCcgcUjUCYJdsvwEMjAfBgNVHSMEGDAW\r\n"
|
||||
"gBRI5iWwjBMAOCcgcUjUCYJdsvwEMjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3\r\n"
|
||||
"DQEBCwUAA4IBAQABop7EJgS2czHKWVzdEwjbi9m5ZUPy6aOV9paV1e/5IyFNHwun\r\n"
|
||||
"B64iwcg03+FmIWNuynb1mglHHrUoXygXu9GIR8cWfOI3W+Pnn8fDi8MxQMn/e/Jj\r\n"
|
||||
"BuGcnRwKynRhyLdkyWYn1YwqenMuFJu9yzkhfAPltGFEuPYCWDatdhm6zhFdu1PE\r\n"
|
||||
"EMErHpQOT45z5cgC4XqgKlE+n8L4/5RfZnbuUJ3bV+FuI+VApLGXJQlJQAOTqBDg\r\n"
|
||||
"k7DMSgPUUxYYa6AGMFy6vqQ6hcgCMK08ko8LdjVd1MobKzM9Oh480GFZA/ubR3QW\r\n"
|
||||
"lv3OuOhmnIxNGcPUiqpSiWKqR5tf1KUImIR9\r\n"
|
||||
"-----END CERTIFICATE-----\r\n";
|
||||
|
||||
/* g_testSelfSignedCaCert
|
||||
Certificate:
|
||||
Data:
|
||||
Version: 3 (0x2)
|
||||
Serial Number: 272 (0x110)
|
||||
Signature Algorithm: sha256WithRSAEncryption
|
||||
Issuer: C = CN, ST = BJ, L = BJ, O = HD, OU = dev, CN = ca, emailAddress = ca@cryptoframework.com
|
||||
Validity
|
||||
Not Before: Aug 19 12:49:06 2022 GMT
|
||||
Not After : Aug 16 12:49:06 2032 GMT
|
||||
Subject: C = CN, ST = BJ, L = BJ, O = HD, OU = dev, CN = ca, emailAddress = ca@cryptoframework.com
|
||||
Subject Public Key Info:
|
||||
Public Key Algorithm: rsaEncryption
|
||||
RSA Public-Key: (2048 bit)
|
||||
Modulus:
|
||||
00:9f:29:d0:85:84:ed:6c:30:6e:d0:13:83:e0:1b:
|
||||
61:08:f7:dd:63:41:06:4b:54:fb:f0:15:7f:e4:e5:
|
||||
d5:a0:1a:e1:33:9e:5b:6f:d9:01:17:38:b1:dc:0b:
|
||||
55:3c:5d:5c:28:a9:16:c7:ae:88:63:77:d2:1c:17:
|
||||
ad:71:54:1e:b7:0c:7f:4c:36:b0:29:33:9c:95:59:
|
||||
fe:b4:1c:7c:43:b9:29:bd:6f:07:3e:83:10:47:20:
|
||||
21:26:04:86:1a:8e:05:f6:01:8a:de:6a:7e:9a:b9:
|
||||
47:6f:b6:47:f4:e1:ff:26:d5:fa:40:6b:52:5f:86:
|
||||
b2:c5:db:0c:07:ba:a1:90:b2:e7:a9:46:a6:10:ef:
|
||||
98:73:14:3b:b6:b5:de:3f:92:16:64:e1:31:b2:36:
|
||||
c9:ec:ae:6b:52:da:81:2a:1a:04:97:d8:d4:9f:a2:
|
||||
ee:35:8f:9a:61:05:47:47:50:da:9d:04:1a:31:d3:
|
||||
81:01:a1:46:8e:55:bb:00:c7:8a:93:52:bf:45:cf:
|
||||
f0:e5:00:fc:f6:1b:2f:f4:81:8f:51:6a:e0:2d:e0:
|
||||
b5:fb:e3:7a:cc:14:6f:35:5a:32:8a:bf:c0:2b:b2:
|
||||
d6:a7:17:23:cd:19:2d:ed:f0:85:1d:b8:73:47:17:
|
||||
60:53:b4:b8:68:bd:7a:03:e9:db:87:f0:ef:26:06:
|
||||
aa:01
|
||||
Exponent: 65537 (0x10001)
|
||||
X509v3 extensions:
|
||||
X509v3 Subject Key Identifier:
|
||||
8C:A3:3B:42:63:01:B3:4D:51:F6:E4:2D:B5:83:7F:18:39:2F:B7:B5
|
||||
X509v3 Authority Key Identifier:
|
||||
keyid:8C:A3:3B:42:63:01:B3:4D:51:F6:E4:2D:B5:83:7F:18:39:2F:B7:B5
|
||||
|
||||
X509v3 Basic Constraints: critical
|
||||
CA:TRUE, pathlen:2
|
||||
X509v3 Key Usage:
|
||||
Certificate Sign, CRL Sign
|
||||
X509v3 Extended Key Usage:
|
||||
TLS Web Server Authentication, TLS Web Client Authentication
|
||||
X509v3 Subject Alternative Name:
|
||||
email:ca@cryptoframework.com
|
||||
X509v3 Issuer Alternative Name:
|
||||
email:ca@cryptoframework.com
|
||||
Signature Algorithm: sha256WithRSAEncryption
|
||||
87:ee:11:13:a7:09:eb:6f:e0:2d:8b:2c:2e:47:3b:11:28:3b:
|
||||
7b:12:b0:66:59:a2:b0:7c:81:89:cb:b2:ff:e5:da:80:e6:77:
|
||||
71:36:e0:40:d5:e5:42:86:4a:6f:0f:e4:b3:f0:7f:70:89:db:
|
||||
40:66:1b:a4:09:b8:ed:2b:9d:a3:e2:3f:1b:dc:63:d1:7e:e0:
|
||||
40:1f:70:b5:2a:db:4a:d3:ac:e9:28:e7:2e:26:14:d3:11:5c:
|
||||
16:c7:34:8f:a9:36:4a:b9:72:8b:04:50:72:34:b8:3c:e2:a2:
|
||||
51:2d:02:9b:71:77:0c:71:9d:8f:9e:4f:94:19:17:c6:e7:57:
|
||||
0a:ad:95:dc:9d:d5:c0:a7:f6:6d:58:d0:6f:3c:f6:f8:cf:d0:
|
||||
d6:6f:8f:ec:58:41:f8:99:9e:3b:c7:9e:9a:4a:8c:43:4b:45:
|
||||
31:4d:c4:33:8e:35:36:97:a3:0b:98:85:54:01:a0:a3:09:c2:
|
||||
f1:2d:01:f9:fc:47:f5:d0:49:b8:73:3a:be:9c:44:5b:0d:dc:
|
||||
91:91:43:65:0d:64:77:dd:58:46:0a:fb:8d:8f:1f:73:4b:ff:
|
||||
4f:4b:73:1d:66:ce:11:5c:e4:94:42:01:58:bd:66:a2:6a:4b:
|
||||
04:2c:1e:d3:f1:b0:f8:13:ba:d1:b7:e2:d8:ca:09:c3:cb:76:
|
||||
21:c0:75:43
|
||||
*/
|
||||
static char g_testSelfSignedCaCert[] =
|
||||
"-----BEGIN CERTIFICATE-----\r\n"
|
||||
"MIIEMjCCAxqgAwIBAgICARAwDQYJKoZIhvcNAQELBQAwdjELMAkGA1UEBhMCQ04x\r\n"
|
||||
"CzAJBgNVBAgMAkJKMQswCQYDVQQHDAJCSjELMAkGA1UECgwCSEQxDDAKBgNVBAsM\r\n"
|
||||
"A2RldjELMAkGA1UEAwwCY2ExJTAjBgkqhkiG9w0BCQEWFmNhQGNyeXB0b2ZyYW1l\r\n"
|
||||
"d29yay5jb20wHhcNMjIwODE5MTI0OTA2WhcNMzIwODE2MTI0OTA2WjB2MQswCQYD\r\n"
|
||||
"VQQGEwJDTjELMAkGA1UECAwCQkoxCzAJBgNVBAcMAkJKMQswCQYDVQQKDAJIRDEM\r\n"
|
||||
"MAoGA1UECwwDZGV2MQswCQYDVQQDDAJjYTElMCMGCSqGSIb3DQEJARYWY2FAY3J5\r\n"
|
||||
"cHRvZnJhbWV3b3JrLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\r\n"
|
||||
"AJ8p0IWE7WwwbtATg+AbYQj33WNBBktU+/AVf+Tl1aAa4TOeW2/ZARc4sdwLVTxd\r\n"
|
||||
"XCipFseuiGN30hwXrXFUHrcMf0w2sCkznJVZ/rQcfEO5Kb1vBz6DEEcgISYEhhqO\r\n"
|
||||
"BfYBit5qfpq5R2+2R/Th/ybV+kBrUl+GssXbDAe6oZCy56lGphDvmHMUO7a13j+S\r\n"
|
||||
"FmThMbI2yeyua1LagSoaBJfY1J+i7jWPmmEFR0dQ2p0EGjHTgQGhRo5VuwDHipNS\r\n"
|
||||
"v0XP8OUA/PYbL/SBj1Fq4C3gtfvjeswUbzVaMoq/wCuy1qcXI80ZLe3whR24c0cX\r\n"
|
||||
"YFO0uGi9egPp24fw7yYGqgECAwEAAaOByTCBxjAdBgNVHQ4EFgQUjKM7QmMBs01R\r\n"
|
||||
"9uQttYN/GDkvt7UwHwYDVR0jBBgwFoAUjKM7QmMBs01R9uQttYN/GDkvt7UwEgYD\r\n"
|
||||
"VR0TAQH/BAgwBgEB/wIBAjALBgNVHQ8EBAMCAQYwHQYDVR0lBBYwFAYIKwYBBQUH\r\n"
|
||||
"AwEGCCsGAQUFBwMCMCEGA1UdEQQaMBiBFmNhQGNyeXB0b2ZyYW1ld29yay5jb20w\r\n"
|
||||
"IQYDVR0SBBowGIEWY2FAY3J5cHRvZnJhbWV3b3JrLmNvbTANBgkqhkiG9w0BAQsF\r\n"
|
||||
"AAOCAQEAh+4RE6cJ62/gLYssLkc7ESg7exKwZlmisHyBicuy/+XagOZ3cTbgQNXl\r\n"
|
||||
"QoZKbw/ks/B/cInbQGYbpAm47Sudo+I/G9xj0X7gQB9wtSrbStOs6SjnLiYU0xFc\r\n"
|
||||
"Fsc0j6k2SrlyiwRQcjS4POKiUS0Cm3F3DHGdj55PlBkXxudXCq2V3J3VwKf2bVjQ\r\n"
|
||||
"bzz2+M/Q1m+P7FhB+JmeO8eemkqMQ0tFMU3EM441NpejC5iFVAGgownC8S0B+fxH\r\n"
|
||||
"9dBJuHM6vpxEWw3ckZFDZQ1kd91YRgr7jY8fc0v/T0tzHWbOEVzklEIBWL1mompL\r\n"
|
||||
"BCwe0/Gw+BO60bfi2MoJw8t2IcB1Qw==\r\n"
|
||||
"-----END CERTIFICATE-----\r\n";
|
||||
|
||||
constexpr int TEST_CERT_VERSION = 3;
|
||||
constexpr int TEST_CERT_CHAIN_LEN = 2;
|
||||
constexpr int TEST_CERT_SERIAL_NUMBER = 272;
|
||||
|
||||
static HcfX509Certificate *g_x509CertObj = nullptr;
|
||||
|
||||
void CryptoX509CertificateTest::SetUpTestCase()
|
||||
{
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_testSelfSignedCaCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_testSelfSignedCaCert) + 1;
|
||||
(void)HcfX509CertificateCreate(&inStream, &g_x509CertObj);
|
||||
}
|
||||
|
||||
void CryptoX509CertificateTest::TearDownTestCase()
|
||||
{
|
||||
CfObjDestroy(g_x509CertObj);
|
||||
}
|
||||
|
||||
void CryptoX509CertificateTest::SetUp()
|
||||
{
|
||||
}
|
||||
|
||||
void CryptoX509CertificateTest::TearDown()
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: CryptoX509CertificateTest.GenerateCert001
|
||||
* @tc.desc: Generate valid PEM format certificate.
|
||||
* @tc.type: FUNC
|
||||
* @tc.require: I5QDNN
|
||||
*/
|
||||
HWTEST_F(CryptoX509CertificateTest, GenerateCert001, TestSize.Level0)
|
||||
{
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_testSelfSignedCaCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_testSelfSignedCaCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(x509Cert, nullptr);
|
||||
CfObjDestroy(x509Cert);
|
||||
}
|
||||
|
||||
/* Invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GenerateCert002, TestSize.Level0)
|
||||
{
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
EXPECT_EQ(x509Cert, nullptr);
|
||||
CfObjDestroy(x509Cert);
|
||||
}
|
||||
|
||||
/* Invalid PEM format. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GenerateCert003, TestSize.Level0)
|
||||
{
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_testInvalidCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_testInvalidCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
EXPECT_EQ(x509Cert, nullptr);
|
||||
CfObjDestroy(x509Cert);
|
||||
}
|
||||
|
||||
/* Valid DER format. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GenerateCert004, TestSize.Level0)
|
||||
{
|
||||
CfEncodingBlob derBlob = { 0 };
|
||||
CfResult ret = g_x509CertObj->base.getEncoded((HcfCertificate *)g_x509CertObj, &derBlob);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(derBlob.data, nullptr);
|
||||
EXPECT_EQ(derBlob.encodingFormat, CF_FORMAT_DER);
|
||||
HcfX509Certificate *certFromDerData = nullptr;
|
||||
ret = HcfX509CertificateCreate(&derBlob, &certFromDerData);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(certFromDerData, nullptr);
|
||||
|
||||
free(derBlob.data);
|
||||
CfObjDestroy(certFromDerData);
|
||||
}
|
||||
|
||||
/* verify self signed cert. */
|
||||
HWTEST_F(CryptoX509CertificateTest, Verify001, TestSize.Level0)
|
||||
{
|
||||
HcfPubKey *keyOut = nullptr;
|
||||
CfResult ret = g_x509CertObj->base.getPublicKey((HcfCertificate *)g_x509CertObj, &keyOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(keyOut, nullptr);
|
||||
ret = g_x509CertObj->base.verify((HcfCertificate *)g_x509CertObj, keyOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
CfObjDestroy(keyOut);
|
||||
}
|
||||
|
||||
/* use root ca cert's public key to verify next cert. */
|
||||
HWTEST_F(CryptoX509CertificateTest, Verify002, TestSize.Level0)
|
||||
{
|
||||
HcfX509Certificate *rootCert = nullptr;
|
||||
CfEncodingBlob root = { 0 };
|
||||
root.data = (uint8_t *)g_rootCert;
|
||||
root.encodingFormat = CF_FORMAT_PEM;
|
||||
root.len = strlen(g_rootCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&root, &rootCert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(rootCert, nullptr);
|
||||
HcfPubKey *rootkeyOut = nullptr;
|
||||
ret = rootCert->base.getPublicKey((HcfCertificate *)rootCert, &rootkeyOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(rootkeyOut, nullptr);
|
||||
|
||||
HcfX509Certificate *secondCert = nullptr;
|
||||
CfEncodingBlob second = { 0 };
|
||||
second.data = (uint8_t *)g_secondCert;
|
||||
second.encodingFormat = CF_FORMAT_PEM;
|
||||
second.len = strlen(g_secondCert) + 1;
|
||||
ret = HcfX509CertificateCreate(&root, &secondCert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(rootCert, nullptr);
|
||||
ret = secondCert->base.verify((HcfCertificate *)secondCert, rootkeyOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
CfObjDestroy(rootkeyOut);
|
||||
CfObjDestroy(rootCert);
|
||||
CfObjDestroy(secondCert);
|
||||
}
|
||||
|
||||
/* verify cert with wrong pub key. */
|
||||
HWTEST_F(CryptoX509CertificateTest, Verify003, TestSize.Level0)
|
||||
{
|
||||
HcfX509Certificate *rootCert = nullptr;
|
||||
CfEncodingBlob root = { 0 };
|
||||
root.data = (uint8_t *)g_rootCert;
|
||||
root.encodingFormat = CF_FORMAT_PEM;
|
||||
root.len = strlen(g_rootCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&root, &rootCert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(rootCert, nullptr);
|
||||
HcfPubKey *rootkeyOut = nullptr;
|
||||
ret = rootCert->base.getPublicKey((HcfCertificate *)rootCert, &rootkeyOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(rootkeyOut, nullptr);
|
||||
|
||||
ret = g_x509CertObj->base.verify((HcfCertificate *)g_x509CertObj, rootkeyOut);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
CfObjDestroy(rootkeyOut);
|
||||
CfObjDestroy(rootCert);
|
||||
}
|
||||
|
||||
/* verify cert with invalid input pub key. */
|
||||
HWTEST_F(CryptoX509CertificateTest, Verify004, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->base.verify((HcfCertificate *)g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetEncoded001, TestSize.Level0)
|
||||
{
|
||||
CfEncodingBlob encodingBlob = { 0 };
|
||||
CfResult ret = g_x509CertObj->base.getEncoded((HcfCertificate *)g_x509CertObj, &encodingBlob);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(encodingBlob.data, nullptr);
|
||||
EXPECT_EQ(encodingBlob.encodingFormat, CF_FORMAT_DER);
|
||||
CfEncodingBlobDataFree(&encodingBlob);
|
||||
}
|
||||
|
||||
/* Invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetEncoded002, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->base.getEncoded((HcfCertificate *)g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetPublicKey, TestSize.Level0)
|
||||
{
|
||||
HcfPubKey *keyOut = nullptr;
|
||||
CfResult ret = g_x509CertObj->base.getPublicKey((HcfCertificate *)g_x509CertObj, &keyOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(keyOut, nullptr);
|
||||
CfObjDestroy(keyOut);
|
||||
}
|
||||
|
||||
/* Input valid date. YYMMDDHHMMSSZ */
|
||||
HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate001, TestSize.Level0)
|
||||
{
|
||||
const char *date = "231018162433Z";
|
||||
// validatetime :2022/08/19 - 2032/08/16
|
||||
CfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
/* Input valid date. time format: YYYYMMDDHHMMSSZ */
|
||||
HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate002, TestSize.Level0)
|
||||
{
|
||||
const char *date = "20231018162433Z";
|
||||
// validatetime :2022/08/19 - 2032/08/16
|
||||
CfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
/* Input invalid date--expiered. */
|
||||
HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate003, TestSize.Level0)
|
||||
{
|
||||
const char *date = "20991018162433Z";
|
||||
// validatetime :2022/08/19 - 2032/08/16
|
||||
CfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date);
|
||||
EXPECT_EQ(ret, CF_ERR_CERT_HAS_EXPIRED);
|
||||
}
|
||||
|
||||
/* Input invalid date. */
|
||||
HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate004, TestSize.Level0)
|
||||
{
|
||||
const char *date = "20191018162433Z";
|
||||
// validatetime :2022/08/19 - 2032/08/16
|
||||
CfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date);
|
||||
EXPECT_EQ(ret, CF_ERR_CERT_NOT_YET_VALID);
|
||||
}
|
||||
|
||||
/* Input invalid date form. */
|
||||
HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate005, TestSize.Level0)
|
||||
{
|
||||
const char *date = "20191018";
|
||||
// validatetime :2022/08/19 - 2032/08/16
|
||||
CfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetVersion, TestSize.Level0)
|
||||
{
|
||||
long ver = g_x509CertObj->getVersion(g_x509CertObj);
|
||||
EXPECT_EQ(ver, TEST_CERT_VERSION);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSerialNumber, TestSize.Level0)
|
||||
{
|
||||
CfBlob out = { 0, nullptr };
|
||||
CfResult ret = g_x509CertObj->getSerialNumber(g_x509CertObj, &out);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(out.data, nullptr);
|
||||
EXPECT_EQ(out.size, 2); /* out size: 2 bytes */
|
||||
EXPECT_EQ(out.data[0] * 0x100 + out.data[1], TEST_CERT_SERIAL_NUMBER);
|
||||
CfBlobDataClearAndFree(&out);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetIssuerName001, TestSize.Level0)
|
||||
{
|
||||
CfBlob out = { 0 };
|
||||
CfResult ret = g_x509CertObj->getIssuerName(g_x509CertObj, &out);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(out.data, nullptr);
|
||||
CfBlobDataClearAndFree(&out);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetIssuerName002, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->getIssuerName(g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSubjectName001, TestSize.Level0)
|
||||
{
|
||||
CfBlob out = { 0 };
|
||||
CfResult ret = g_x509CertObj->getSubjectName(g_x509CertObj, &out);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(out.data, nullptr);
|
||||
CfBlobDataClearAndFree(&out);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSubjectName002, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->getSubjectName(g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetNotBeforeTime001, TestSize.Level0)
|
||||
{
|
||||
CfBlob out = { 0 };
|
||||
CfResult ret = g_x509CertObj->getNotBeforeTime(g_x509CertObj, &out);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(out.data, nullptr);
|
||||
CfBlobDataClearAndFree(&out);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetNotBeforeTime002, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->getNotBeforeTime(g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetNotAfterTime001, TestSize.Level0)
|
||||
{
|
||||
CfBlob out = { 0 };
|
||||
CfResult ret = g_x509CertObj->getNotAfterTime(g_x509CertObj, &out);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(out.data, nullptr);
|
||||
CfBlobDataClearAndFree(&out);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetNotAfterTime002, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->getNotAfterTime(g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSignature001, TestSize.Level0)
|
||||
{
|
||||
CfBlob sigOut = { 0 };
|
||||
CfResult ret = g_x509CertObj->getSignature(g_x509CertObj, &sigOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(sigOut.data, nullptr);
|
||||
CfBlobDataClearAndFree(&sigOut);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSignature002, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->getSignature(g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgName001, TestSize.Level0)
|
||||
{
|
||||
CfBlob sigAlgName = { 0 };
|
||||
CfResult ret = g_x509CertObj->getSignatureAlgName(g_x509CertObj, &sigAlgName);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(sigAlgName.data, nullptr);
|
||||
CfBlobDataClearAndFree(&sigAlgName);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgName002, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->getSignatureAlgName(g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgOid001, TestSize.Level0)
|
||||
{
|
||||
CfBlob sigAlgOid = { 0 };
|
||||
CfResult ret = g_x509CertObj->getSignatureAlgOid(g_x509CertObj, &sigAlgOid);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(sigAlgOid.data, nullptr);
|
||||
CfBlobDataClearAndFree(&sigAlgOid);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgOid002, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->getSignatureAlgOid(g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgParams001, TestSize.Level0)
|
||||
{
|
||||
CfBlob sigAlgParamsOut = { 0 };
|
||||
CfResult ret = g_x509CertObj->getSignatureAlgParams(g_x509CertObj, &sigAlgParamsOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(sigAlgParamsOut.data, nullptr);
|
||||
CfBlobDataClearAndFree(&sigAlgParamsOut);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgParams002, TestSize.Level0)
|
||||
{
|
||||
CfResult ret = g_x509CertObj->getSignatureAlgParams(g_x509CertObj, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetKeyUsage, TestSize.Level0)
|
||||
{
|
||||
CfBlob out = { 0 };
|
||||
CfResult ret = g_x509CertObj->getKeyUsage(g_x509CertObj, &out);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(out.data, nullptr);
|
||||
CfBlobDataClearAndFree(&out);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetExtKeyUsage001, TestSize.Level0)
|
||||
{
|
||||
CfArray keyUsageOut = { 0 };
|
||||
CfResult ret = g_x509CertObj->getExtKeyUsage(g_x509CertObj, &keyUsageOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(keyUsageOut.data, nullptr);
|
||||
CfArrayDataClearAndFree(&keyUsageOut);
|
||||
}
|
||||
|
||||
/* Cert which has no extended key usage. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetExtKeyUsage002, TestSize.Level0)
|
||||
{
|
||||
CfArray keyUsageOut = { 0 };
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_secondCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_secondCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(x509Cert, nullptr);
|
||||
ret = x509Cert->getExtKeyUsage(x509Cert, &keyUsageOut);
|
||||
EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION);
|
||||
EXPECT_EQ(keyUsageOut.data, nullptr);
|
||||
CfObjDestroy(x509Cert);
|
||||
}
|
||||
|
||||
/* not a CA cert */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetBasicConstraints001, TestSize.Level0)
|
||||
{
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_deviceTestCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_deviceTestCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(x509Cert, nullptr);
|
||||
int32_t pathLen = x509Cert->getBasicConstraints(x509Cert);
|
||||
EXPECT_EQ(pathLen, -1); /* cert path len is only valid for CA. */
|
||||
CfObjDestroy(x509Cert);
|
||||
}
|
||||
|
||||
/* CA cert */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetBasicConstraints002, TestSize.Level0)
|
||||
{
|
||||
int32_t pathLen = g_x509CertObj->getBasicConstraints(g_x509CertObj);
|
||||
EXPECT_EQ(pathLen, TEST_CERT_CHAIN_LEN); /* g_testSelfSignedCaCert is CA and it's path len is 2. */
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetBasicConstraints003, TestSize.Level0)
|
||||
{
|
||||
int32_t pathLen = g_x509CertObj->getBasicConstraints(nullptr);
|
||||
EXPECT_EQ(pathLen, -1);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSubjectAltNames001, TestSize.Level0)
|
||||
{
|
||||
CfArray outName = { 0 };
|
||||
CfResult ret = g_x509CertObj->getSubjectAltNames(g_x509CertObj, &outName);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(outName.data, nullptr);
|
||||
CfArrayDataClearAndFree(&outName);
|
||||
}
|
||||
|
||||
/* cert without subject alternative names. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSubjectAltNames002, TestSize.Level0)
|
||||
{
|
||||
CfArray outName = { 0 };
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_secondCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_secondCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(x509Cert, nullptr);
|
||||
ret = x509Cert->getSubjectAltNames(x509Cert, &outName);
|
||||
EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION);
|
||||
EXPECT_EQ(outName.data, nullptr);
|
||||
CfObjDestroy(x509Cert);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetSubjectAltNames003, TestSize.Level0)
|
||||
{
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_secondCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_secondCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(x509Cert, nullptr);
|
||||
ret = x509Cert->getSubjectAltNames(x509Cert, nullptr);
|
||||
EXPECT_EQ(ret, CF_INVALID_PARAMS);
|
||||
CfObjDestroy(x509Cert);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, GetIssuerAltNames001, TestSize.Level0)
|
||||
{
|
||||
CfArray outName = { 0 };
|
||||
CfResult ret = g_x509CertObj->getIssuerAltNames(g_x509CertObj, &outName);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(outName.data, nullptr);
|
||||
CfArrayDataClearAndFree(&outName);
|
||||
}
|
||||
|
||||
/* cert without issuer alternative names. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetIssuerAltNames002, TestSize.Level0)
|
||||
{
|
||||
CfArray outName = { 0 };
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_secondCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_secondCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(x509Cert, nullptr);
|
||||
ret = x509Cert->getIssuerAltNames(x509Cert, &outName);
|
||||
EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION);
|
||||
EXPECT_EQ(outName.data, nullptr);
|
||||
CfObjDestroy(x509Cert);
|
||||
}
|
||||
|
||||
/* invalid input. */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetIssuerAltNames003, TestSize.Level0)
|
||||
{
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_secondCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_secondCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(x509Cert, nullptr);
|
||||
ret = x509Cert->getIssuerAltNames(x509Cert, nullptr);
|
||||
EXPECT_EQ(ret, CF_INVALID_PARAMS);
|
||||
CfObjDestroy(x509Cert);
|
||||
}
|
||||
|
||||
/* oid is nullptr */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetAlgorithmName001, TestSize.Level0)
|
||||
{
|
||||
const char *str = GetAlgorithmName(nullptr);
|
||||
EXPECT_EQ(str, nullptr);
|
||||
}
|
||||
|
||||
/* oid not found */
|
||||
HWTEST_F(CryptoX509CertificateTest, GetAlgorithmName002, TestSize.Level0)
|
||||
{
|
||||
char oid[] = "1.2.840.113549.1.1.255";
|
||||
const char *str = GetAlgorithmName(oid);
|
||||
EXPECT_EQ(str, nullptr);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, NullInput, TestSize.Level0)
|
||||
{
|
||||
(void)HcfX509CertificateCreate(nullptr, nullptr);
|
||||
HcfPubKey *keyOut = nullptr;
|
||||
CfResult ret = g_x509CertObj->base.getPublicKey((HcfCertificate *)g_x509CertObj, &keyOut);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(keyOut, nullptr);
|
||||
(void)g_x509CertObj->base.base.destroy(nullptr);
|
||||
(void)keyOut->base.getAlgorithm(&(keyOut->base));
|
||||
(void)keyOut->base.getEncoded(&(keyOut->base), nullptr);
|
||||
(void)keyOut->base.getFormat(&(keyOut->base));
|
||||
ret = g_x509CertObj->base.verify(nullptr, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
ret = g_x509CertObj->base.getEncoded(nullptr, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
ret = g_x509CertObj->base.getPublicKey(nullptr, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
(void)g_x509CertObj->checkValidityWithDate(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getVersion(nullptr);
|
||||
(void)g_x509CertObj->getSerialNumber(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getIssuerName(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getSubjectName(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getNotBeforeTime(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getNotAfterTime(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getSignature(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getSignatureAlgName(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getSignatureAlgOid(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getSignatureAlgParams(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getKeyUsage(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getExtKeyUsage(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getBasicConstraints(nullptr);
|
||||
(void)g_x509CertObj->getSubjectAltNames(nullptr, nullptr);
|
||||
(void)g_x509CertObj->getIssuerAltNames(nullptr, nullptr);
|
||||
CfObjDestroy(keyOut);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, NullSpiInput, TestSize.Level0)
|
||||
{
|
||||
HcfX509CertificateSpi *spiObj = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_testSelfSignedCaCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_testSelfSignedCaCert) + 1;
|
||||
(void)OpensslX509CertSpiCreate(nullptr, nullptr);
|
||||
CfResult ret = OpensslX509CertSpiCreate(&inStream, &spiObj);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(spiObj, nullptr);
|
||||
(void)spiObj->base.destroy(nullptr);
|
||||
ret = spiObj->engineVerify(nullptr, nullptr);
|
||||
ret = spiObj->engineGetEncoded(nullptr, nullptr);
|
||||
ret = spiObj->engineGetPublicKey(nullptr, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
ret = spiObj->engineCheckValidityWithDate(nullptr, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
long ver = spiObj->engineGetVersion(nullptr);
|
||||
EXPECT_EQ(ver, -1);
|
||||
ret = spiObj->engineGetSerialNumber(nullptr, nullptr);
|
||||
ret = spiObj->engineGetIssuerName(nullptr, nullptr);
|
||||
ret = spiObj->engineGetSubjectName(nullptr, nullptr);
|
||||
ret = spiObj->engineGetNotBeforeTime(nullptr, nullptr);
|
||||
ret = spiObj->engineGetNotAfterTime(nullptr, nullptr);
|
||||
ret = spiObj->engineGetSignature(nullptr, nullptr);
|
||||
ret = spiObj->engineGetSignatureAlgName(nullptr, nullptr);
|
||||
ret = spiObj->engineGetSignatureAlgOid(nullptr, nullptr);
|
||||
ret = spiObj->engineGetSignatureAlgParams(nullptr, nullptr);
|
||||
ret = spiObj->engineGetKeyUsage(nullptr, nullptr);
|
||||
ret = spiObj->engineGetExtKeyUsage(nullptr, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
long basicLen = spiObj->engineGetBasicConstraints(nullptr);
|
||||
EXPECT_EQ(basicLen, -1);
|
||||
ret = spiObj->engineGetSubjectAltNames(nullptr, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
ret = spiObj->engineGetIssuerAltNames(nullptr, nullptr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
CfObjDestroy(spiObj);
|
||||
}
|
||||
|
||||
static const char *GetInvalidCertClass(void)
|
||||
{
|
||||
return "INVALID_CERT_CLASS";
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, InvalidSpiClass, TestSize.Level0)
|
||||
{
|
||||
HcfX509CertificateSpi *spiObj = nullptr;
|
||||
HcfX509CertificateSpi invalidSpi = { {0} };
|
||||
invalidSpi.base.getClass = GetInvalidCertClass;
|
||||
CfBlob invalidOut = { 0 };
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_testSelfSignedCaCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_testSelfSignedCaCert) + 1;
|
||||
CfResult ret = OpensslX509CertSpiCreate(&inStream, &spiObj);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(spiObj, nullptr);
|
||||
(void)spiObj->base.destroy(&(invalidSpi.base));
|
||||
HcfPubKey pubKey;
|
||||
ret = spiObj->engineVerify(&invalidSpi, &pubKey);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
ret = spiObj->engineGetEncoded(&invalidSpi, &inStream);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
HcfPubKey *pubKeyOut = nullptr;
|
||||
ret = spiObj->engineGetPublicKey(&invalidSpi, &pubKeyOut);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
const char *date = "2020";
|
||||
ret = spiObj->engineCheckValidityWithDate(&invalidSpi, date);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
long ver = spiObj->engineGetVersion(&invalidSpi);
|
||||
EXPECT_EQ(ver, -1);
|
||||
ret = spiObj->engineGetSerialNumber(&invalidSpi, &invalidOut);
|
||||
ret = spiObj->engineGetIssuerName(&invalidSpi, &invalidOut);
|
||||
ret = spiObj->engineGetSubjectName(&invalidSpi, &invalidOut);
|
||||
ret = spiObj->engineGetNotBeforeTime(&invalidSpi, &invalidOut);
|
||||
ret = spiObj->engineGetNotAfterTime(&invalidSpi, &invalidOut);
|
||||
ret = spiObj->engineGetSignature(&invalidSpi, &invalidOut);
|
||||
ret = spiObj->engineGetSignatureAlgName(&invalidSpi, &invalidOut);
|
||||
ret = spiObj->engineGetSignatureAlgOid(&invalidSpi, &invalidOut);
|
||||
ret = spiObj->engineGetSignatureAlgParams(&invalidSpi, &invalidOut);
|
||||
ret = spiObj->engineGetKeyUsage(&invalidSpi, &invalidOut);
|
||||
CfArray invalidArr = { 0 };
|
||||
ret = spiObj->engineGetExtKeyUsage(&invalidSpi, &invalidArr);
|
||||
long basicLen = spiObj->engineGetBasicConstraints(&invalidSpi);
|
||||
EXPECT_EQ(basicLen, -1);
|
||||
ret = spiObj->engineGetSubjectAltNames(&invalidSpi, &invalidArr);
|
||||
ret = spiObj->engineGetIssuerAltNames(&invalidSpi, &invalidArr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
CfObjDestroy(spiObj);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, InvalidCertClass, TestSize.Level0)
|
||||
{
|
||||
HcfX509Certificate invalidCert;
|
||||
invalidCert.base.base.getClass = GetInvalidCertClass;
|
||||
CfBlob invalidOut = { 0 };
|
||||
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
HcfPubKey keyOut;
|
||||
g_x509CertObj->base.base.destroy(&(invalidCert.base.base));
|
||||
CfResult ret = g_x509CertObj->base.verify(&(invalidCert.base), &keyOut);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
ret = g_x509CertObj->base.getEncoded(&(invalidCert.base), &inStream);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
HcfPubKey *pubKeyOut = nullptr;
|
||||
ret = g_x509CertObj->base.getPublicKey(&(invalidCert.base), &pubKeyOut);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
const char *date = "2020";
|
||||
ret = g_x509CertObj->checkValidityWithDate(&invalidCert, date);
|
||||
long ver = g_x509CertObj->getVersion(&invalidCert);
|
||||
EXPECT_EQ(ver, -1);
|
||||
ret = g_x509CertObj->getSerialNumber(&invalidCert, &invalidOut);
|
||||
ret = g_x509CertObj->getIssuerName(&invalidCert, &invalidOut);
|
||||
ret = g_x509CertObj->getSubjectName(&invalidCert, &invalidOut);
|
||||
ret = g_x509CertObj->getNotBeforeTime(&invalidCert, &invalidOut);
|
||||
ret = g_x509CertObj->getNotAfterTime(&invalidCert, &invalidOut);
|
||||
ret = g_x509CertObj->getSignature(&invalidCert, &invalidOut);
|
||||
ret = g_x509CertObj->getSignatureAlgName(&invalidCert, &invalidOut);
|
||||
ret = g_x509CertObj->getSignatureAlgOid(&invalidCert, &invalidOut);
|
||||
ret = g_x509CertObj->getSignatureAlgParams(&invalidCert, &invalidOut);
|
||||
ret = g_x509CertObj->getKeyUsage(&invalidCert, &invalidOut);
|
||||
CfArray invalidArr = { 0 };
|
||||
ret = g_x509CertObj->getExtKeyUsage(&invalidCert, &invalidArr);
|
||||
long basicLen = g_x509CertObj->getBasicConstraints(&invalidCert);
|
||||
EXPECT_EQ(basicLen, -1);
|
||||
ret = g_x509CertObj->getSubjectAltNames(&invalidCert, &invalidArr);
|
||||
ret = g_x509CertObj->getIssuerAltNames(&invalidCert, &invalidArr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
}
|
||||
|
||||
HWTEST_F(CryptoX509CertificateTest, InvalidMalloc, TestSize.Level0)
|
||||
{
|
||||
SetMockFlag(true);
|
||||
HcfX509Certificate *x509Cert = nullptr;
|
||||
CfEncodingBlob inStream = { 0 };
|
||||
inStream.data = (uint8_t *)g_secondCert;
|
||||
inStream.encodingFormat = CF_FORMAT_PEM;
|
||||
inStream.len = strlen(g_secondCert) + 1;
|
||||
CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
CfBlob out = { 0 };
|
||||
CfArray arr = { 0 };
|
||||
ret = g_x509CertObj->base.getEncoded(&(g_x509CertObj->base), &inStream);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
HcfPubKey *pubKeyOut = nullptr;
|
||||
ret = g_x509CertObj->base.getPublicKey(&(g_x509CertObj->base), &pubKeyOut);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
const char *date = "2020";
|
||||
ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date);
|
||||
ret = g_x509CertObj->getIssuerName(g_x509CertObj, &out);
|
||||
ret = g_x509CertObj->getSubjectName(g_x509CertObj, &out);
|
||||
ret = g_x509CertObj->getNotBeforeTime(g_x509CertObj, &out);
|
||||
ret = g_x509CertObj->getNotAfterTime(g_x509CertObj, &out);
|
||||
ret = g_x509CertObj->getSignature(g_x509CertObj, &out);
|
||||
ret = g_x509CertObj->getSignatureAlgName(g_x509CertObj, &out);
|
||||
ret = g_x509CertObj->getSignatureAlgOid(g_x509CertObj, &out);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
ret = g_x509CertObj->getSignatureAlgParams(g_x509CertObj, &out);
|
||||
ret = g_x509CertObj->getKeyUsage(g_x509CertObj, &out);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
ret = g_x509CertObj->getExtKeyUsage(g_x509CertObj, &arr);
|
||||
ret = g_x509CertObj->getSubjectAltNames(g_x509CertObj, &arr);
|
||||
ret = g_x509CertObj->getIssuerAltNames(g_x509CertObj, &arr);
|
||||
EXPECT_NE(ret, CF_SUCCESS);
|
||||
SetMockFlag(false);
|
||||
}
|
||||
}
|
||||
112
test/unittest/v1.0/src/crypto_x509_crl_test.cpp
Normal file
112
test/unittest/v1.0/src/crypto_x509_crl_test.cpp
Normal file
@ -0,0 +1,112 @@
|
||||
/*
|
||||
* Copyright (c) 2023 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 "securec.h"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <openssl/x509.h>
|
||||
|
||||
#include "asy_key_generator.h"
|
||||
#include "cipher.h"
|
||||
#include "key_pair.h"
|
||||
#include "cf_memory.h"
|
||||
#include "memory_mock.h"
|
||||
#include "certificate_openssl_class.h"
|
||||
#include "x509_crl.h"
|
||||
#include "x509_crl_openssl.h"
|
||||
#include "x509_crl_entry_openssl.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace testing::ext;
|
||||
|
||||
namespace {
|
||||
HcfX509Crl *g_x509Crl = nullptr;
|
||||
|
||||
class CryptoX509CrlTest : public testing::Test {
|
||||
public:
|
||||
static void SetUpTestCase();
|
||||
static void TearDownTestCase();
|
||||
void SetUp();
|
||||
void TearDown();
|
||||
};
|
||||
|
||||
static uint8_t g_crlDerData[] = {
|
||||
0x30, 0x82, 0x01, 0xE3, 0x30, 0x81, 0xCC, 0x02, 0x01, 0x01, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86,
|
||||
0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0B, 0x05, 0x00, 0x30, 0x2C, 0x31, 0x0B, 0x30, 0x09, 0x06,
|
||||
0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43, 0x4E, 0x31, 0x0D, 0x30, 0x0B, 0x06, 0x03, 0x55, 0x04,
|
||||
0x0A, 0x0C, 0x04, 0x74, 0x65, 0x73, 0x74, 0x31, 0x0E, 0x30, 0x0C, 0x06, 0x03, 0x55, 0x04, 0x03,
|
||||
0x0C, 0x05, 0x73, 0x75, 0x62, 0x63, 0x61, 0x17, 0x0D, 0x32, 0x33, 0x30, 0x39, 0x31, 0x32, 0x30,
|
||||
0x36, 0x34, 0x37, 0x35, 0x30, 0x5A, 0x17, 0x0D, 0x32, 0x33, 0x31, 0x30, 0x31, 0x32, 0x30, 0x36,
|
||||
0x34, 0x37, 0x35, 0x30, 0x5A, 0x30, 0x3B, 0x30, 0x13, 0x02, 0x02, 0x03, 0xE8, 0x17, 0x0D, 0x32,
|
||||
0x33, 0x30, 0x39, 0x31, 0x32, 0x30, 0x36, 0x34, 0x37, 0x34, 0x39, 0x5A, 0x30, 0x24, 0x02, 0x13,
|
||||
0x17, 0x5D, 0x6A, 0x9F, 0xEC, 0xA9, 0x09, 0xD7, 0x12, 0xB2, 0x48, 0x52, 0xA6, 0x3E, 0x48, 0xF6,
|
||||
0x12, 0x93, 0xA9, 0x17, 0x0D, 0x32, 0x33, 0x30, 0x39, 0x31, 0x32, 0x30, 0x36, 0x34, 0x32, 0x35,
|
||||
0x34, 0x5A, 0xA0, 0x2F, 0x30, 0x2D, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30,
|
||||
0x16, 0x80, 0x14, 0x22, 0x2B, 0x18, 0xDE, 0x84, 0xD9, 0x30, 0x4E, 0xF6, 0x3D, 0xDF, 0xD7, 0xF4,
|
||||
0x02, 0xED, 0x44, 0x22, 0x84, 0x20, 0xE8, 0x30, 0x0A, 0x06, 0x03, 0x55, 0x1D, 0x14, 0x04, 0x03,
|
||||
0x02, 0x01, 0x02, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0B,
|
||||
0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x40, 0xA1, 0x82, 0x5E, 0xCE, 0x5A, 0x5D, 0x8E, 0x7A,
|
||||
0xD3, 0xA0, 0x3F, 0xD0, 0x7C, 0xA7, 0x2E, 0x6A, 0xBE, 0x7E, 0xB2, 0x7B, 0xA7, 0x95, 0x23, 0xF5,
|
||||
0xC0, 0xF6, 0xBF, 0x06, 0xD9, 0x57, 0x8C, 0x5A, 0x3F, 0x61, 0x39, 0x8D, 0x7A, 0x20, 0x07, 0x3E,
|
||||
0xD8, 0x0A, 0x39, 0xB1, 0xA7, 0x43, 0xC1, 0xF7, 0xDE, 0x57, 0x0B, 0xDA, 0x22, 0xDD, 0x02, 0x90,
|
||||
0x80, 0xB5, 0x4A, 0x63, 0x83, 0x73, 0xDB, 0x55, 0x90, 0x45, 0xE7, 0x26, 0x99, 0x99, 0xB5, 0x70,
|
||||
0x3C, 0x1E, 0x0C, 0x33, 0xF0, 0x18, 0x9F, 0x3F, 0x23, 0x47, 0x76, 0x0B, 0x03, 0x13, 0x25, 0xF3,
|
||||
0xFB, 0xAC, 0x48, 0x2C, 0xBA, 0x18, 0x08, 0x06, 0xAF, 0x89, 0x52, 0x31, 0x5C, 0x34, 0xD6, 0x96,
|
||||
0x76, 0x26, 0xB6, 0x1A, 0xEF, 0xDA, 0x02, 0xE2, 0x23, 0x95, 0xA2, 0x79, 0x03, 0x85, 0xBB, 0xBE,
|
||||
0xF8, 0x46, 0x55, 0x4C, 0x7D, 0x08, 0x35, 0x1D, 0x37, 0xC6, 0x05, 0xE6, 0x49, 0xC0, 0xDC, 0x1A,
|
||||
0x10, 0xD6, 0xE1, 0x5C, 0xD7, 0x3E, 0xE0, 0x35, 0xC9, 0x24, 0x22, 0x94, 0xD3, 0x71, 0xC4, 0x0B,
|
||||
0xCE, 0x81, 0x0B, 0x14, 0x31, 0xBC, 0xFF, 0x3F, 0x9B, 0x3A, 0x70, 0x2E, 0x4A, 0x0D, 0x65, 0x64,
|
||||
0x2C, 0xAF, 0xF5, 0xF3, 0xB3, 0xF6, 0x55, 0x5A, 0x7C, 0x2F, 0xAA, 0x68, 0x7A, 0x3E, 0x35, 0x6F,
|
||||
0x6B, 0x74, 0x28, 0x71, 0x57, 0x5A, 0x02, 0xE5, 0x2E, 0xA3, 0x1D, 0x3B, 0xBC, 0xEF, 0xD0, 0x8E,
|
||||
0x31, 0x09, 0xCB, 0xAF, 0x78, 0xC4, 0x04, 0x2B, 0x33, 0x37, 0x30, 0xE3, 0x14, 0x8E, 0xB8, 0x97,
|
||||
0xA7, 0xF7, 0x25, 0x59, 0xCB, 0x65, 0xEA, 0x69, 0xE8, 0xD5, 0x35, 0x81, 0xDB, 0xA7, 0x8D, 0x02,
|
||||
0xF8, 0x82, 0xD5, 0x90, 0x5D, 0x91, 0x65, 0x15, 0x5E, 0xF9, 0xC5, 0x1F, 0x1A, 0x6A, 0x17, 0x7C,
|
||||
0xB1, 0xE0, 0x79, 0xA0, 0x34, 0xCF, 0x42
|
||||
};
|
||||
|
||||
const CfEncodingBlob g_crlDerInStream = {
|
||||
g_crlDerData,
|
||||
sizeof(g_crlDerData),
|
||||
CF_FORMAT_DER
|
||||
};
|
||||
|
||||
void CryptoX509CrlTest::SetUpTestCase()
|
||||
{
|
||||
HcfX509Crl *x509Crl = nullptr;
|
||||
int32_t ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
|
||||
ASSERT_EQ(ret, 0);
|
||||
g_x509Crl = x509Crl;
|
||||
}
|
||||
|
||||
void CryptoX509CrlTest::TearDownTestCase()
|
||||
{
|
||||
if (g_x509Crl != nullptr) {
|
||||
CfObjDestroy(g_x509Crl);
|
||||
g_x509Crl = nullptr;
|
||||
}
|
||||
}
|
||||
void CryptoX509CrlTest::SetUp() {}
|
||||
void CryptoX509CrlTest::TearDown() {}
|
||||
|
||||
// Test crl create DER true
|
||||
HWTEST_F(CryptoX509CrlTest, X509CrlTest002, TestSize.Level0)
|
||||
{
|
||||
HcfX509Crl *x509Crl = nullptr;
|
||||
CfResult ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
|
||||
EXPECT_EQ(ret, CF_SUCCESS);
|
||||
EXPECT_NE(x509Crl, nullptr);
|
||||
CfObjDestroy(x509Crl);
|
||||
}
|
||||
}
|
||||
89
test/unittest/v1.0/src/memory_mock.c
Normal file
89
test/unittest/v1.0/src/memory_mock.c
Normal file
@ -0,0 +1,89 @@
|
||||
/*
|
||||
* Copyright (c) 2023 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 "cf_memory.h"
|
||||
#include "memory_mock.h"
|
||||
|
||||
#include "cf_log.h"
|
||||
#include "securec.h"
|
||||
|
||||
static bool g_isMock = false;
|
||||
static uint32_t g_mallocMockIndex = __INT32_MAX__;
|
||||
static uint32_t g_mallocNum = 0;
|
||||
static bool g_isRecordMallocNum = false;
|
||||
|
||||
void SetMockFlag(bool flag)
|
||||
{
|
||||
g_isMock = flag;
|
||||
}
|
||||
|
||||
void *HcfMalloc(uint32_t size, char val)
|
||||
{
|
||||
if (g_isMock) {
|
||||
return NULL;
|
||||
}
|
||||
if (g_isRecordMallocNum) {
|
||||
if (g_mallocNum == g_mallocMockIndex) {
|
||||
LOGI("mock malloc return NULL.");
|
||||
return NULL;
|
||||
}
|
||||
g_mallocNum++;
|
||||
}
|
||||
void *addr = malloc(size);
|
||||
if (addr != NULL) {
|
||||
(void)memset_s(addr, size, val, size);
|
||||
}
|
||||
return addr;
|
||||
}
|
||||
|
||||
void *CfMalloc(uint32_t size)
|
||||
{
|
||||
return HcfMalloc(size, 0);
|
||||
}
|
||||
|
||||
void CfFree(void *addr)
|
||||
{
|
||||
if (addr != NULL) {
|
||||
free(addr);
|
||||
}
|
||||
}
|
||||
|
||||
void StartRecordMallocNum(void)
|
||||
{
|
||||
ResetRecordMallocNum();
|
||||
g_isRecordMallocNum = true;
|
||||
}
|
||||
|
||||
void EndRecordMallocNum(void)
|
||||
{
|
||||
ResetRecordMallocNum();
|
||||
g_isRecordMallocNum = false;
|
||||
}
|
||||
|
||||
uint32_t GetMallocNum(void)
|
||||
{
|
||||
return g_mallocNum;
|
||||
}
|
||||
|
||||
void ResetRecordMallocNum(void)
|
||||
{
|
||||
g_mallocNum = 0;
|
||||
g_mallocMockIndex = __INT32_MAX__;
|
||||
}
|
||||
|
||||
void SetMockMallocIndex(uint32_t index)
|
||||
{
|
||||
g_mallocMockIndex = index;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user