blob: fce4ff141674e1a37003a24e2c1c9974e5e7d528 [file] [log] [blame]
/*
*
* Copyright (c) 2021-2023 Project CHIP Authors
* All rights reserved.
*
* 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.
*/
/**
* @file
* This file implements the command handler for the 'chip-cert' tool
* that generates attestation certificates.
*
*/
#include "chip-cert.h"
#include <lib/support/SafeInt.h>
#include <openssl/x509.h>
namespace {
using namespace chip;
using namespace chip::ArgParser;
using namespace chip::Credentials;
using namespace chip::ASN1;
#define CMD_NAME "chip-cert gen-att-cert"
bool HandleOption(const char * progName, OptionSet * optSet, int id, const char * name, const char * arg);
// clang-format off
OptionDef gCmdOptionDefs[] =
{
{ "type", kArgumentRequired, 't' },
{ "subject-cn", kArgumentRequired, 'c' },
{ "subject-vid", kArgumentRequired, 'V' },
{ "subject-pid", kArgumentRequired, 'P' },
{ "vid-pid-as-cn", kNoArgument, 'a' },
{ "key", kArgumentRequired, 'k' },
{ "ca-cert", kArgumentRequired, 'C' },
{ "ca-key", kArgumentRequired, 'K' },
{ "out", kArgumentRequired, 'o' },
{ "out-key", kArgumentRequired, 'O' },
{ "valid-from", kArgumentRequired, 'f' },
{ "lifetime", kArgumentRequired, 'l' },
{ "cdp-uri", kArgumentRequired, 'x' },
{ "crl-issuer-cert", kArgumentRequired, 'L' },
#if CHIP_CONFIG_INTERNAL_FLAG_GENERATE_DA_TEST_CASES
{ "ignore-error", kNoArgument, 'I' },
{ "error-type", kArgumentRequired, 'E' },
#endif
{ }
};
const char * const gCmdOptionHelp =
" -t, --type <att-cert-type>\n"
"\n"
" Attestation certificate type to be generated. Valid certificate type values are:\n"
" a - product attestation authority certificate\n"
" i - product attestation intermediate certificate\n"
" d - device attestation certificate\n"
"\n"
" -c, --subject-cn <string>\n"
"\n"
" Subject DN Common Name attribute encoded as UTF8String.\n"
"\n"
" -V, --subject-vid <hex-digits>\n"
"\n"
" Subject DN CHIP VID attribute (in hex).\n"
"\n"
" -P, --subject-pid <hex-digits>\n"
"\n"
" Subject DN CHIP PID attribute (in hex).\n"
"\n"
" -a, --vid-pid-as-cn\n"
"\n"
" Encode Matter VID and PID parameters as Common Name attributes in the Subject DN.\n"
" If not specified then by default the VID and PID fields are encoded using\n"
" Matter specific OIDs.\n"
"\n"
" -C, --ca-cert <file/str>\n"
"\n"
" File or string containing CA certificate to be used to sign the new certificate.\n"
"\n"
" -K, --ca-key <file/str>\n"
"\n"
" File or string containing CA private key to be used to sign the new certificate.\n"
"\n"
" -k, --key <file/str>\n"
"\n"
" File or string containing the public and private keys for the new certificate (in an X.509 PEM format).\n"
" If not specified, a new key pair will be generated.\n"
"\n"
" -o, --out <file/stdout>\n"
"\n"
" File to contain the new certificate (in an X.509 PEM format).\n"
" If specified '-' then output is written to stdout.\n"
"\n"
" -O, --out-key <file/stdout>\n"
"\n"
" File to contain the public/private key for the new certificate (in an X.509 PEM format).\n"
" This option must be specified if the --key option is not.\n"
" If specified '-' then output is written to stdout.\n"
"\n"
" -f, --valid-from <YYYY>-<MM>-<DD> [ <HH>:<MM>:<SS> ]\n"
"\n"
" The start date for the certificate's validity period. If not specified,\n"
" the validity period starts on the current day.\n"
"\n"
" -l, --lifetime <days>\n"
"\n"
" The lifetime for the new certificate, in whole days. Use special value\n"
" 4294967295 to indicate that certificate doesn't have well defined\n"
" expiration date\n"
"\n"
" -x, --cdp-uri <string>\n"
"\n"
" CRL Distribution Points (CDP) extension (NID_crl_distribution_points) extension to be added to the list\n"
" of certificate extensions.\n"
"\n"
" -L, --crl-issuer-cert <file/str>\n"
"\n"
" File or string containing the CRL Issuer certificate (in an X.509 PEM format).\n"
" The Subject name will be extracted from this certificate to be included in the\n"
" cRLIssuer field of the CRL Distribution Point (CDP) extension.\n"
"\n"
#if CHIP_CONFIG_INTERNAL_FLAG_GENERATE_DA_TEST_CASES
" -I, --ignore-error\n"
"\n"
" Ignore some input parameters error.\n"
" WARNING: This option makes it possible to circumvent attestation certificate\n"
" structure requirement. This is required for negative testing of the attestation flow.\n"
" Because of this it SHOULD NEVER BE ENABLED IN PRODUCTION BUILDS.\n"
"\n"
" -E, --error-type <error-type>\n"
"\n"
" When specified injects specific error into the structure of generated attestation certificate.\n"
" Note that 'ignore-error' option MUST be specified for this error injection to take effect.\n"
" Supported error types that can be injected are:\n"
" no-error - No error to inject.\n"
" cert-version - Certificate version will be set to v2 instead of required v3.\n"
" sig-algo - Use ecdsa-with-SHA1 signature algorithm instead of required ecdsa-with-SHA256.\n"
" issuer-vid - TODO\n"
" issuer-pid - TODO\n"
" subject-vid - TODO\n"
" subject-vid-mismatch - The VID value in the subject field won't match VID in the issuer field.\n"
" subject-pid - TODO\n"
" subject-pid-mismatch - The PID value in the subject field won't match PID in the issuer field.\n"
" sig-curve - Use secp256k1 curve to generate certificate signature instead of\n"
" required secp256r1 (aka prime256v1).\n"
" ext-basic-missing - Certificate won't have required Basic Constraint extension.\n"
" ext-basic-critical-missing - Basic Constraint extension won't have critical field.\n"
" ext-basic-critical-wrong - Basic Constraint extension will be marked as non-critical.\n"
" ext-basic-ca-missing - Basic Constraint extension won't have cA field.\n"
" ext-basic-ca-wrong - Basic Constraint extension cA field will be set to TRUE for DAC\n"
" and to FALSE for PAI and PAA.\n"
" ext-basic-pathlen-presence-wrong - Basic Constraint extension will include pathLen field for DAC\n"
" and won't have pathLen field for PAI and PAA.\n"
" ext-basic-pathlen0 - Basic Constraint extension pathLen field will be set to 0.\n"
" ext-basic-pathlen1 - Basic Constraint extension pathLen field will be set to 1.\n"
" ext-basic-pathlen2 - Basic Constraint extension pathLen field will be set to 2.\n"
" ext-key-usage-missing - Certificate won't have required Key Usage extension.\n"
" ext-key-usage-critical-missing - Key Usage extension won't have critical field.\n"
" ext-key-usage-critical-wrong - Key Usage extension will be marked as non-critical.\n"
" ext-key-usage-dig-sig - Key Usage extension digitalSignature flag won't be set for DAC\n"
" and will be set for PAI/PAA.\n"
" ext-key-usage-key-cert-sign - Key Usage extension keyCertSign flag will be set for DAC\n"
" and won't be set for PAI/PAA.\n"
" ext-key-usage-crl-sign - Key Usage extension cRLSign flag will be set for DAC\n"
" and won't set for PAI/PAA.\n"
" ext-akid-missing - Certificate won't have required Authority Key ID extension.\n"
" ext-skid-missing - Certificate won't have required Subject Key ID extension.\n"
" ext-extended-key-usage - Certificate will include optional Extended Key Usage extension.\n"
" ext-authority-info-access - Certificate will include optional Authority Information Access extension.\n"
" ext-subject-alt-name - Certificate will include optional Subject Alternative Name extension.\n"
" ext-cdp-uri-duplicate - Certificate will include additional URI Field in the CDP extension.\n"
" ext-cdp-crl-issuer-duplicate - Certificate will include additional CRL Issuer Field in the CDP extension.\n"
" ext-cdp-dist-point-duplicate - Certificate will include additional CRL Distribution Point Field in the CDP extension.\n"
" ext-cdp-add - Certificate will include additional CDP extension.\n"
"\n"
#endif // CHIP_CONFIG_INTERNAL_FLAG_GENERATE_DA_TEST_CASES
;
OptionSet gCmdOptions =
{
HandleOption,
gCmdOptionDefs,
"COMMAND OPTIONS",
gCmdOptionHelp
};
HelpOptions gHelpOptions(
CMD_NAME,
"Usage: " CMD_NAME " [ <options...> ]\n",
CHIP_VERSION_STRING "\n" COPYRIGHT_STRING,
"Generate a CHIP Attestation certificate"
);
OptionSet *gCmdOptionSets[] =
{
&gCmdOptions,
&gHelpOptions,
nullptr
};
// clang-format on
AttCertType gAttCertType = kAttCertType_NotSpecified;
const char * gSubjectCN = nullptr;
uint16_t gSubjectVID = VendorId::NotSpecified;
uint16_t gSubjectPID = 0;
bool gEncodeVIDandPIDasCN = false;
const char * gCACertFileNameOrStr = nullptr;
const char * gCAKeyFileNameOrStr = nullptr;
const char * gInKeyFileNameOrStr = nullptr;
const char * gOutCertFileName = nullptr;
const char * gOutKeyFileName = nullptr;
uint32_t gValidDays = kCertValidDays_Undefined;
const char * gCDPURI = nullptr;
const char * gCRLIssuerCertFileName = nullptr;
struct tm gValidFrom;
CertStructConfig gCertConfig;
bool HandleOption(const char * progName, OptionSet * optSet, int id, const char * name, const char * arg)
{
switch (id)
{
case 't':
if (strlen(arg) == 1)
{
if (*arg == 'd')
{
gAttCertType = kAttCertType_DAC;
}
else if (*arg == 'i')
{
gAttCertType = kAttCertType_PAI;
}
else if (*arg == 'a')
{
gAttCertType = kAttCertType_PAA;
}
}
if (gAttCertType == kAttCertType_NotSpecified)
{
PrintArgError("%s: Invalid value specified for the attestation certificate type: %s\n", progName, arg);
return false;
}
break;
case 'c':
gSubjectCN = arg;
break;
case 'V':
if (!ParseInt(arg, gSubjectVID, 16))
{
PrintArgError("%s: Invalid value specified for the subject VID attribute: %s\n", progName, arg);
return false;
}
break;
case 'P':
if (!ParseInt(arg, gSubjectPID, 16))
{
PrintArgError("%s: Invalid value specified for the subject PID attribute: %s\n", progName, arg);
return false;
}
break;
case 'a':
gEncodeVIDandPIDasCN = true;
break;
case 'k':
gInKeyFileNameOrStr = arg;
break;
case 'C':
gCACertFileNameOrStr = arg;
break;
case 'K':
gCAKeyFileNameOrStr = arg;
break;
case 'o':
gOutCertFileName = arg;
break;
case 'O':
gOutKeyFileName = arg;
break;
case 'f':
if (!ParseDateTime(arg, gValidFrom))
{
PrintArgError("%s: Invalid value specified for certificate validity date: %s\n", progName, arg);
return false;
}
break;
case 'l':
if (!ParseInt(arg, gValidDays))
{
PrintArgError("%s: Invalid value specified for certificate lifetime: %s\n", progName, arg);
return false;
}
break;
case 'x':
gCDPURI = arg;
break;
case 'L':
gCRLIssuerCertFileName = arg;
break;
#if CHIP_CONFIG_INTERNAL_FLAG_GENERATE_DA_TEST_CASES
case 'I':
gCertConfig.EnableErrorTestCase();
break;
case 'E':
if (strcmp(arg, "cert-version") == 0)
{
gCertConfig.SetCertVersionWrong();
}
else if (strcmp(arg, "sig-algo") == 0)
{
gCertConfig.SetSigAlgoWrong();
}
else if (strcmp(arg, "subject-vid-mismatch") == 0)
{
gCertConfig.SetSubjectVIDMismatch();
}
else if (strcmp(arg, "subject-pid-mismatch") == 0)
{
gCertConfig.SetSubjectPIDMismatch();
}
else if (strcmp(arg, "sig-curve") == 0)
{
gCertConfig.SetSigCurveWrong();
}
else if (strcmp(arg, "ext-basic-missing") == 0)
{
gCertConfig.SetExtensionBasicMissing();
}
else if (strcmp(arg, "ext-basic-critical-missing") == 0)
{
gCertConfig.SetExtensionBasicCriticalMissing();
}
else if (strcmp(arg, "ext-basic-critical-wrong") == 0)
{
gCertConfig.SetExtensionBasicCriticalWrong();
}
else if (strcmp(arg, "ext-basic-ca-missing") == 0)
{
gCertConfig.SetExtensionBasicCAMissing();
}
else if (strcmp(arg, "ext-basic-ca-wrong") == 0)
{
gCertConfig.SetExtensionBasicCAWrong();
}
else if (strcmp(arg, "ext-basic-pathlen-presence-wrong") == 0)
{
gCertConfig.SetExtensionBasicPathLenPresenceWrong();
}
else if (strcmp(arg, "ext-basic-pathlen0") == 0)
{
gCertConfig.SetExtensionBasicPathLen0();
}
else if (strcmp(arg, "ext-basic-pathlen1") == 0)
{
gCertConfig.SetExtensionBasicPathLen1();
}
else if (strcmp(arg, "ext-basic-pathlen2") == 0)
{
gCertConfig.SetExtensionBasicPathLen2();
}
else if (strcmp(arg, "ext-key-usage-missing") == 0)
{
gCertConfig.SetExtensionKeyUsageMissing();
}
else if (strcmp(arg, "ext-key-usage-critical-missing") == 0)
{
gCertConfig.SetExtensionKeyUsageCriticalMissing();
}
else if (strcmp(arg, "ext-key-usage-critical-wrong") == 0)
{
gCertConfig.SetExtensionKeyUsageCriticalWrong();
}
else if (strcmp(arg, "ext-key-usage-dig-sig") == 0)
{
gCertConfig.SetExtensionKeyUsageDigitalSigWrong();
}
else if (strcmp(arg, "ext-key-usage-key-cert-sign") == 0)
{
gCertConfig.SetExtensionKeyUsageKeyCertSignWrong();
}
else if (strcmp(arg, "ext-key-usage-crl-sign") == 0)
{
gCertConfig.SetExtensionKeyUsageCRLSignWrong();
}
else if (strcmp(arg, "ext-akid-missing") == 0)
{
gCertConfig.SetExtensionAKIDMissing();
}
else if (strcmp(arg, "ext-skid-missing") == 0)
{
gCertConfig.SetExtensionSKIDMissing();
}
else if (strcmp(arg, "ext-extended-key-usage") == 0)
{
gCertConfig.SetExtensionExtendedKeyUsagePresent();
}
else if (strcmp(arg, "ext-authority-info-access") == 0)
{
gCertConfig.SetExtensionAuthorityInfoAccessPresent();
}
else if (strcmp(arg, "ext-subject-alt-name") == 0)
{
gCertConfig.SetExtensionSubjectAltNamePresent();
}
else if (strcmp(arg, "ext-cdp-uri-duplicate") == 0)
{
gCertConfig.SetExtensionCDPURIDuplicate();
}
else if (strcmp(arg, "ext-cdp-crl-issuer-duplicate") == 0)
{
gCertConfig.SetExtensionCDPCRLIssuerDuplicate();
}
else if (strcmp(arg, "ext-cdp-dist-point-duplicate") == 0)
{
gCertConfig.SetExtensionCDPDistPointDuplicate();
}
else if (strcmp(arg, "ext-cdp-add") == 0)
{
gCertConfig.SetExtensionCDPPresent();
}
else if (strcmp(arg, "no-error") != 0)
{
PrintArgError("%s: Invalid value specified for the error type: %s\n", progName, arg);
return false;
}
break;
#endif // CHIP_CONFIG_INTERNAL_FLAG_GENERATE_DA_TEST_CASES
default:
PrintArgError("%s: Unhandled option: %s\n", progName, name);
return false;
}
return true;
}
} // namespace
bool Cmd_GenAttCert(int argc, char * argv[])
{
bool res = true;
std::unique_ptr<X509, void (*)(X509 *)> newCert(X509_new(), &X509_free);
std::unique_ptr<EVP_PKEY, void (*)(EVP_PKEY *)> newKey(EVP_PKEY_new(), &EVP_PKEY_free);
// Declarations related to the CRL Distribution Points (CDP) Extention
std::unique_ptr<X509, void (*)(X509 *)> cRLIssuerCert(nullptr, &X509_free);
std::unique_ptr<X509_EXTENSION, void (*)(X509_EXTENSION *)> cdpExtension(nullptr, &X509_EXTENSION_free);
STACK_OF(DIST_POINT) * distPoints = nullptr;
DIST_POINT * distPoint = nullptr;
ASN1_IA5STRING * uri = nullptr;
GENERAL_NAME * distPointName = nullptr;
GENERAL_NAME * crlIssuerName = nullptr;
std::unique_ptr<X509_EXTENSION, void (*)(X509_EXTENSION *)> cdpExtension2(nullptr, &X509_EXTENSION_free);
{
time_t now = time(nullptr);
gValidFrom = *gmtime(&now);
gValidFrom.tm_hour = 0;
gValidFrom.tm_min = 0;
gValidFrom.tm_sec = 0;
}
if (argc == 1)
{
gHelpOptions.PrintBriefUsage(stderr);
return true;
}
res = ParseArgs(CMD_NAME, argc, argv, gCmdOptionSets);
VerifyTrueOrExit(res);
if (gCertConfig.IsErrorTestCaseEnabled())
{
fprintf(stderr,
"WARNING get-att-cert: The ignor-error option is set. This option makes it possible to generate invalid "
"certificates.\n");
}
if (gAttCertType == kAttCertType_NotSpecified)
{
fprintf(stderr, "Please specify attestation certificate type.\n");
return false;
}
if (!gCertConfig.IsErrorTestCaseEnabled())
{
if (gAttCertType == kAttCertType_DAC)
{
if (gSubjectVID == VendorId::NotSpecified || gSubjectPID == 0)
{
fprintf(stderr, "Please specify VID and PID subject DN attributes.\n");
return false;
}
}
if (gAttCertType == kAttCertType_PAI)
{
if (gSubjectVID == VendorId::NotSpecified)
{
fprintf(stderr, "Please specify VID subject DN attributes.\n");
return false;
}
}
if (gAttCertType == kAttCertType_PAA)
{
if (gSubjectPID != 0)
{
fprintf(stderr, "VID & PID SHALL NOT specify subject DN attributes.\n");
return false;
}
}
}
if (gCACertFileNameOrStr == nullptr && gAttCertType != kAttCertType_PAA)
{
fprintf(stderr, "Please specify the CA certificate file name using the --ca-cert option.\n");
return false;
}
if (gCACertFileNameOrStr != nullptr && gAttCertType == kAttCertType_PAA)
{
fprintf(stderr, "Please don't specify --ca-cert option for the self signed certificate. \n");
return false;
}
if (gCACertFileNameOrStr != nullptr && gCAKeyFileNameOrStr == nullptr)
{
fprintf(stderr, "Please specify the CA key file name using the --ca-key option.\n");
return false;
}
if (gOutCertFileName == nullptr)
{
fprintf(stderr, "Please specify the file name for the new certificate using the --out option.\n");
return false;
}
if (gInKeyFileNameOrStr == nullptr && gOutKeyFileName == nullptr)
{
fprintf(stderr, "Please specify the file name for the new public/private key using the --out-key option.\n");
return false;
}
if (gValidDays == kCertValidDays_Undefined)
{
fprintf(stderr, "Please specify the lifetime (in dys) for the new certificate using the --lifetime option.\n");
return false;
}
if (access(gOutCertFileName, R_OK) == 0)
{
fprintf(stderr,
"Output certificate file already exists (%s)\n"
"To replace the file, please remove it and re-run the command.\n",
gOutCertFileName);
return false;
}
if (gOutKeyFileName != nullptr && access(gOutKeyFileName, R_OK) == 0)
{
fprintf(stderr,
"Output key file already exists (%s)\n"
"To replace the file, please remove it and re-run the command.\n",
gOutKeyFileName);
return false;
}
res = InitOpenSSL();
VerifyTrueOrExit(res);
if (gInKeyFileNameOrStr != nullptr)
{
res = ReadKey(gInKeyFileNameOrStr, newKey);
VerifyTrueOrExit(res);
}
else
{
if (gCertConfig.IsSigCurveWrong())
{
res = GenerateKeyPair_Secp256k1(newKey.get());
VerifyTrueOrExit(res);
}
else
{
res = GenerateKeyPair(newKey.get());
VerifyTrueOrExit(res);
}
}
if (gCRLIssuerCertFileName != nullptr || gCDPURI != nullptr)
{
int result;
// Create a DIST_POINT object
distPoint = DIST_POINT_new();
VerifyOrReturnError(distPoint != nullptr, false);
if (gCDPURI != nullptr)
{
// Set the distribution point name
distPoint->distpoint = DIST_POINT_NAME_new();
VerifyOrReturnError(distPoint->distpoint != nullptr, false);
distPoint->distpoint->type = 0; // fullName
distPoint->distpoint->name.fullname = GENERAL_NAMES_new();
VerifyOrReturnError(distPoint->distpoint->name.fullname != nullptr, false);
// Create and set URI string
uri = ASN1_IA5STRING_new();
VerifyOrReturnError(uri != nullptr, false);
result = ASN1_STRING_set(uri, gCDPURI, -1);
VerifyOrReturnError(result != 0, false);
// Set fullName as a URI
distPointName = GENERAL_NAME_new();
VerifyOrReturnError(distPointName != nullptr, false);
distPointName->type = GEN_URI;
distPointName->d.uniformResourceIdentifier = uri;
sk_GENERAL_NAME_push(distPoint->distpoint->name.fullname, distPointName);
if (gCertConfig.IsExtensionCDPURIDuplicate())
{
// Add second instance of CDP URI - invalid configuration
sk_GENERAL_NAME_push(distPoint->distpoint->name.fullname, distPointName);
}
}
if (gCRLIssuerCertFileName != nullptr)
{
// Extract Subject from the CRL Issuer Certificate
res = ReadCert(gCRLIssuerCertFileName, cRLIssuerCert);
VerifyTrueOrExit(res);
crlIssuerName = GENERAL_NAME_new();
VerifyOrReturnError(crlIssuerName != nullptr, false);
crlIssuerName->type = GEN_DIRNAME;
crlIssuerName->d.directoryName = X509_get_subject_name(cRLIssuerCert.get());
distPoint->CRLissuer = GENERAL_NAMES_new();
sk_GENERAL_NAME_push(distPoint->CRLissuer, crlIssuerName);
if (gCertConfig.IsExtensionCDPCRLIssuerDuplicate())
{
// Add second instance of CDP CRL Issuer - invalid configuration
sk_GENERAL_NAME_push(distPoint->CRLissuer, crlIssuerName);
}
}
// Push single DIST_POINT into array of CRL Distribution Points
distPoints = sk_DIST_POINT_new_null();
sk_DIST_POINT_push(distPoints, distPoint);
if (gCertConfig.IsExtensionCDPDistPointDuplicate())
{
// Add second instance of CDP URI - invalid configuration
sk_DIST_POINT_push(distPoints, distPoint);
}
cdpExtension.reset(X509V3_EXT_i2d(NID_crl_distribution_points, 0, distPoints));
VerifyOrReturnError(cdpExtension.get() != nullptr, false);
}
if (gAttCertType == kAttCertType_PAA)
{
res = MakeAttCert(gAttCertType, gSubjectCN, gSubjectVID, gSubjectPID, gEncodeVIDandPIDasCN, newCert.get(), newKey.get(),
gValidFrom, gValidDays, newCert.get(), newKey.get(), gCertConfig, cdpExtension.get());
VerifyTrueOrExit(res);
}
else
{
std::unique_ptr<X509, void (*)(X509 *)> caCert(nullptr, &X509_free);
std::unique_ptr<EVP_PKEY, void (*)(EVP_PKEY *)> caKey(EVP_PKEY_new(), &EVP_PKEY_free);
res = ReadCert(gCACertFileNameOrStr, caCert);
VerifyTrueOrExit(res);
res = ReadKey(gCAKeyFileNameOrStr, caKey, gCertConfig.IsErrorTestCaseEnabled());
VerifyTrueOrExit(res);
res = MakeAttCert(gAttCertType, gSubjectCN, gSubjectVID, gSubjectPID, gEncodeVIDandPIDasCN, caCert.get(), caKey.get(),
gValidFrom, gValidDays, newCert.get(), newKey.get(), gCertConfig, cdpExtension.get());
VerifyTrueOrExit(res);
}
res = WriteCert(gOutCertFileName, newCert.get(), kCertFormat_X509_PEM);
VerifyTrueOrExit(res);
if (gOutKeyFileName != nullptr)
{
res = WriteKey(gOutKeyFileName, newKey.get(), kKeyFormat_X509_PEM);
VerifyTrueOrExit(res);
}
exit:
return res;
}