/*

 *

 *    Copyright (c) 2021-2022 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 methods for generating CHIP X.509 certificate.

 *

 */

#include <algorithm>

#include <initializer_list>

#include <inttypes.h>

#include <stddef.h>

#include <credentials/CHIPCert_Internal.h>

#include <lib/asn1/ASN1.h>

#include <lib/asn1/ASN1Macros.h>

#include <lib/core/CHIPCore.h>

#include <lib/core/CHIPSafeCasts.h>

#include <lib/support/CodeUtils.h>

#include <lib/support/DLLUtil.h>

#include <protocols/Protocols.h>

namespace chip {

namespace Credentials {

using namespace chip::ASN1;

using namespace chip::Crypto;

using namespace chip::Protocols;

namespace {

enum IsCACert

{

    kCACert,

    kNotCACert,

};

CHIP_ERROR EncodeSubjectPublicKeyInfo(const Crypto::P256PublicKey & pubkey, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1_START_SEQUENCE

    {

        ASN1_START_SEQUENCE

        {

            ASN1_ENCODE_OBJECT_ID(kOID_PubKeyAlgo_ECPublicKey);

            ASN1_ENCODE_OBJECT_ID(kOID_EllipticCurve_prime256v1);

        }

        ASN1_END_SEQUENCE;

        ReturnErrorOnFailure(writer.PutBitString(0, pubkey, static_cast<uint8_t>(pubkey.Length())));

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

CHIP_ERROR EncodeAuthorityKeyIdentifierExtension(const Crypto::P256PublicKey & pubkey, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1_START_SEQUENCE

    {

        ASN1_ENCODE_OBJECT_ID(kOID_Extension_AuthorityKeyIdentifier);

        ASN1_START_OCTET_STRING_ENCAPSULATED

        {

            ASN1_START_SEQUENCE

            {

                uint8_t keyid[kSHA1_Hash_Length];

                ReturnErrorOnFailure(Crypto::Hash_SHA1(pubkey, pubkey.Length(), keyid));

                ReturnErrorOnFailure(

                    writer.PutOctetString(kASN1TagClass_ContextSpecific, 0, keyid, static_cast<uint8_t>(sizeof(keyid))));

            }

            ASN1_END_SEQUENCE;

        }

        ASN1_END_ENCAPSULATED;

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

CHIP_ERROR EncodeSubjectKeyIdentifierExtension(const Crypto::P256PublicKey & pubkey, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1_START_SEQUENCE

    {

        ASN1_ENCODE_OBJECT_ID(kOID_Extension_SubjectKeyIdentifier);

        ASN1_START_OCTET_STRING_ENCAPSULATED

        {

            uint8_t keyid[kSHA1_Hash_Length];

            ReturnErrorOnFailure(Crypto::Hash_SHA1(pubkey, pubkey.Length(), keyid));

            ReturnErrorOnFailure(writer.PutOctetString(keyid, static_cast<uint8_t>(sizeof(keyid))));

        }

        ASN1_END_ENCAPSULATED;

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

CHIP_ERROR EncodeExtKeyUsageExtension(std::initializer_list<OID> keyPurposeOIDs, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1_START_SEQUENCE

    {

        ASN1_ENCODE_OBJECT_ID(kOID_Extension_ExtendedKeyUsage);

        // ExtKeyUsage extension MUST be marked as critical.

        ASN1_ENCODE_BOOLEAN(true);

        ASN1_START_OCTET_STRING_ENCAPSULATED

        {

            ASN1_START_SEQUENCE

            {

                for (auto && oid : keyPurposeOIDs)

                {

                    ASN1_ENCODE_OBJECT_ID(oid);

                }

            }

            ASN1_END_SEQUENCE;

        }

        ASN1_END_ENCAPSULATED;

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

CHIP_ERROR EncodeKeyUsageExtension(BitFlags<KeyUsageFlags> keyUsageFlags, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1_START_SEQUENCE

    {

        ASN1_ENCODE_OBJECT_ID(kOID_Extension_KeyUsage);

        // KeyUsage extension MUST be marked as critical.

        ASN1_ENCODE_BOOLEAN(true);

        ASN1_START_OCTET_STRING_ENCAPSULATED

        {

            ASN1_ENCODE_BIT_STRING(keyUsageFlags.Raw());

        }

        ASN1_END_ENCAPSULATED;

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

CHIP_ERROR EncodeIsCAExtension(IsCACert isCA, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1_START_SEQUENCE

    {

        ASN1_ENCODE_OBJECT_ID(kOID_Extension_BasicConstraints);

        // BasicConstraints extension MUST be marked as critical.

        ASN1_ENCODE_BOOLEAN(true);

        ASN1_START_OCTET_STRING_ENCAPSULATED

        {

            ASN1_START_SEQUENCE

            {

                // cA BOOLEAN

                if (isCA == kCACert)

                {

                    // Encode the boolean only if isCA is true

                    ASN1_ENCODE_BOOLEAN(true);

                }

            }

            ASN1_END_SEQUENCE;

        }

        ASN1_END_ENCAPSULATED;

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

CHIP_ERROR EncodeCASpecificExtensions(ASN1Writer & writer)

{

    ReturnErrorOnFailure(EncodeIsCAExtension(kCACert, writer));

    ReturnErrorOnFailure(

        EncodeKeyUsageExtension(BitFlags<KeyUsageFlags>(KeyUsageFlags::kKeyCertSign, KeyUsageFlags::kCRLSign), writer));

    return CHIP_NO_ERROR;

}

CHIP_ERROR EncodeNOCSpecificExtensions(ASN1Writer & writer)

{

    ReturnErrorOnFailure(EncodeIsCAExtension(kNotCACert, writer));

    ReturnErrorOnFailure(EncodeKeyUsageExtension(KeyUsageFlags::kDigitalSignature, writer));

    ReturnErrorOnFailure(EncodeExtKeyUsageExtension({ kOID_KeyPurpose_ClientAuth, kOID_KeyPurpose_ServerAuth }, writer));

    return CHIP_NO_ERROR;

}

CHIP_ERROR EncodeVendorIdVerificationSignerSpecificExtensions(ASN1Writer & writer)

{

    ReturnErrorOnFailure(EncodeIsCAExtension(kNotCACert, writer));

    ReturnErrorOnFailure(EncodeKeyUsageExtension(KeyUsageFlags::kDigitalSignature, writer));

    return CHIP_NO_ERROR;

}

CHIP_ERROR EncodeFutureExtension(const Optional<FutureExtension> & futureExt, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    VerifyOrReturnError(futureExt.HasValue(), CHIP_NO_ERROR);

    ASN1_START_SEQUENCE

    {

        ReturnErrorOnFailure(writer.PutObjectId(futureExt.Value().OID.data(), static_cast<uint16_t>(futureExt.Value().OID.size())));

        ASN1_START_OCTET_STRING_ENCAPSULATED

        {

            ReturnErrorOnFailure(writer.PutOctetString(futureExt.Value().Extension.data(),

                                                       static_cast<uint16_t>(futureExt.Value().Extension.size())));

        }

        ASN1_END_ENCAPSULATED;

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

CHIP_ERROR EncodeExtensions(CertType certType, const Crypto::P256PublicKey & SKI, const Crypto::P256PublicKey & AKI,

                            const Optional<FutureExtension> & futureExt, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1_START_CONSTRUCTED(kASN1TagClass_ContextSpecific, 3)

    {

        ASN1_START_SEQUENCE

        {

            switch (certType)

            {

            case CertType::kICA:

            case CertType::kRoot: {

                ReturnErrorOnFailure(EncodeCASpecificExtensions(writer));

                break;

            }

            case CertType::kNode: {

                ReturnErrorOnFailure(EncodeNOCSpecificExtensions(writer));

                break;

            }

            case CertType::kVidVerificationSigner: {

                ReturnErrorOnFailure(EncodeVendorIdVerificationSignerSpecificExtensions(writer));

                break;

            }

            case CertType::kFirmwareSigning:

            case CertType::kNetworkIdentity: {

                // Nothing to encode extra for those.

                break;

            }

            default: {

                // Unknown/invalid certificate type should not happen.

                return CHIP_ERROR_INVALID_ARGUMENT;

            }

            }

            ReturnErrorOnFailure(EncodeSubjectKeyIdentifierExtension(SKI, writer));

            ReturnErrorOnFailure(EncodeAuthorityKeyIdentifierExtension(AKI, writer));

            ReturnErrorOnFailure(EncodeFutureExtension(futureExt, writer));

        }

        ASN1_END_SEQUENCE;

    }

    ASN1_END_CONSTRUCTED;

exit:

    return err;

}

CHIP_ERROR EncodeValidity(uint32_t validityStart, uint32_t validityEnd, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1UniversalTime asn1Time;

    ASN1_START_SEQUENCE

    {

        ReturnErrorOnFailure(ChipEpochToASN1Time(validityStart, asn1Time));

        ASN1_ENCODE_TIME(asn1Time);

        ReturnErrorOnFailure(ChipEpochToASN1Time(validityEnd, asn1Time));

        ASN1_ENCODE_TIME(asn1Time);

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

CHIP_ERROR EncodeChipECDSASignature(Crypto::P256ECDSASignature & signature, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1_START_BIT_STRING_ENCAPSULATED

    {

        // Convert RAW signature to DER when generating X509 certs.

        P256ECDSASignatureSpan raw_sig(signature.Bytes());

        ReturnErrorOnFailure(ConvertECDSASignatureRawToDER(raw_sig, writer));

    }

    ASN1_END_ENCAPSULATED;

exit:

    return err;

}

CHIP_ERROR EncodeTBSCert(const X509CertRequestParams & requestParams, const Crypto::P256PublicKey & subjectPubkey,

                         const Crypto::P256PublicKey & issuerPubkey, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    CertType certType;

    VerifyOrReturnError(requestParams.SerialNumber >= 0, CHIP_ERROR_INVALID_ARGUMENT);

    VerifyOrReturnError(requestParams.ValidityEnd == kNullCertTime || requestParams.ValidityEnd >= requestParams.ValidityStart,

                        CHIP_ERROR_INVALID_ARGUMENT);

    ReturnErrorOnFailure(requestParams.SubjectDN.GetCertType(certType));

    ASN1_START_SEQUENCE

    {

        // version [0] EXPLICIT Version DEFAULT v1

        ASN1_START_CONSTRUCTED(kASN1TagClass_ContextSpecific, 0)

        {

            // Version ::= INTEGER { v1(0), v2(1), v3(2) }

            ASN1_ENCODE_INTEGER(2);

        }

        ASN1_END_CONSTRUCTED;

        ReturnErrorOnFailure(writer.PutInteger(requestParams.SerialNumber));

        ASN1_START_SEQUENCE

        {

            ASN1_ENCODE_OBJECT_ID(kOID_SigAlgo_ECDSAWithSHA256);

        }

        ASN1_END_SEQUENCE;

        // issuer Name

        ReturnErrorOnFailure(requestParams.IssuerDN.EncodeToASN1(writer));

        // validity Validity,

        ReturnErrorOnFailure(EncodeValidity(requestParams.ValidityStart, requestParams.ValidityEnd, writer));

        // subject Name

        ReturnErrorOnFailure(requestParams.SubjectDN.EncodeToASN1(writer));

        ReturnErrorOnFailure(EncodeSubjectPublicKeyInfo(subjectPubkey, writer));

        // certificate extensions

        ReturnErrorOnFailure(EncodeExtensions(certType, subjectPubkey, issuerPubkey, requestParams.FutureExt, writer));

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

} // namespace

CHIP_ERROR EncodeNetworkIdentityTBSCert(const P256PublicKey & pubkey, ASN1Writer & writer)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ChipDN issuerAndSubject;

    InitNetworkIdentitySubject(issuerAndSubject);

    ASN1_START_SEQUENCE

    {

        // version [0] EXPLICIT Version DEFAULT v1

        ASN1_START_CONSTRUCTED(kASN1TagClass_ContextSpecific, 0)

        {

            ASN1_ENCODE_INTEGER(2); // Version ::= INTEGER { v1(0), v2(1), v3(2) }

        }

        ASN1_END_CONSTRUCTED;

        ReturnErrorOnFailure(writer.PutInteger(kNetworkIdentitySerialNumber));

        ASN1_START_SEQUENCE

        {

            ASN1_ENCODE_OBJECT_ID(kOID_SigAlgo_ECDSAWithSHA256);

        }

        ASN1_END_SEQUENCE;

        // issuer Name

        ReturnErrorOnFailure(issuerAndSubject.EncodeToASN1(writer));

        // validity Validity,

        ReturnErrorOnFailure(EncodeValidity(kNetworkIdentityNotBeforeTime, kNetworkIdentityNotAfterTime, writer));

        // subject Name

        ReturnErrorOnFailure(issuerAndSubject.EncodeToASN1(writer));

        ReturnErrorOnFailure(EncodeSubjectPublicKeyInfo(pubkey, writer));

        // certificate extensions

        ASN1_START_CONSTRUCTED(kASN1TagClass_ContextSpecific, 3)

        {

            ASN1_START_SEQUENCE

            {

                TEMPORARY_RETURN_IGNORED EncodeIsCAExtension(kNotCACert, writer);

                TEMPORARY_RETURN_IGNORED EncodeKeyUsageExtension(KeyUsageFlags::kDigitalSignature, writer);

                TEMPORARY_RETURN_IGNORED EncodeExtKeyUsageExtension({ kOID_KeyPurpose_ClientAuth, kOID_KeyPurpose_ServerAuth },

                                                                    writer);

            }

            ASN1_END_SEQUENCE;

        }

        ASN1_END_CONSTRUCTED;

    }

    ASN1_END_SEQUENCE;

exit:

    return err;

}

CHIP_ERROR NewChipX509Cert(const X509CertRequestParams & requestParams, const Crypto::P256PublicKey & subjectPubkey,

                           const Crypto::P256Keypair & issuerKeypair, MutableByteSpan & x509Cert)

{

    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1Writer writer;

    writer.Init(x509Cert);

    ReturnErrorOnFailure(EncodeTBSCert(requestParams, subjectPubkey, issuerKeypair.Pubkey(), writer));

    Crypto::P256ECDSASignature signature;

    ReturnErrorOnFailure(issuerKeypair.ECDSA_sign_msg(x509Cert.data(), writer.GetLengthWritten(), signature));

    writer.Init(x509Cert);

    ASN1_START_SEQUENCE

    {

        ReturnErrorOnFailure(EncodeTBSCert(requestParams, subjectPubkey, issuerKeypair.Pubkey(), writer));

        ASN1_START_SEQUENCE

        {

            ASN1_ENCODE_OBJECT_ID(kOID_SigAlgo_ECDSAWithSHA256);

        }

        ASN1_END_SEQUENCE;

        ReturnErrorOnFailure(EncodeChipECDSASignature(signature, writer));

    }

    ASN1_END_SEQUENCE;

    x509Cert.reduce_size(writer.GetLengthWritten());

exit:

    return err;

}

DLL_EXPORT CHIP_ERROR NewRootX509Cert(const X509CertRequestParams & requestParams, const Crypto::P256Keypair & issuerKeypair,

                                      MutableByteSpan & x509Cert)

{

    CertType certType;

    ReturnErrorOnFailure(requestParams.SubjectDN.GetCertType(certType));

    VerifyOrReturnError(certType == CertType::kRoot, CHIP_ERROR_INVALID_ARGUMENT);

    VerifyOrReturnError(requestParams.SubjectDN.IsEqual(requestParams.IssuerDN), CHIP_ERROR_INVALID_ARGUMENT);

    return NewChipX509Cert(requestParams, issuerKeypair.Pubkey(), issuerKeypair, x509Cert);

}

DLL_EXPORT CHIP_ERROR NewICAX509Cert(const X509CertRequestParams & requestParams, const Crypto::P256PublicKey & subjectPubkey,

                                     const Crypto::P256Keypair & issuerKeypair, MutableByteSpan & x509Cert)

{

    CertType certType;

    ReturnErrorOnFailure(requestParams.SubjectDN.GetCertType(certType));

    VerifyOrReturnError(certType == CertType::kICA, CHIP_ERROR_INVALID_ARGUMENT);

    ReturnErrorOnFailure(requestParams.IssuerDN.GetCertType(certType));

    VerifyOrReturnError(certType == CertType::kRoot, CHIP_ERROR_INVALID_ARGUMENT);

    return NewChipX509Cert(requestParams, subjectPubkey, issuerKeypair, x509Cert);

}

CHIP_ERROR NewVidVerificationSignerX509Cert(const X509CertRequestParams & requestParams,

                                            const Crypto::P256PublicKey & subjectPubkey, const Crypto::P256Keypair & issuerKeypair,

                                            MutableByteSpan & x509Cert)

{

    CertType certType;

    ReturnErrorOnFailure(requestParams.SubjectDN.GetCertType(certType));

    VerifyOrReturnError(certType == CertType::kVidVerificationSigner, CHIP_ERROR_INVALID_ARGUMENT);

    ReturnErrorOnFailure(requestParams.IssuerDN.GetCertType(certType));

    VerifyOrReturnError((certType == CertType::kICA) || (certType == CertType::kRoot), CHIP_ERROR_INVALID_ARGUMENT);

    return NewChipX509Cert(requestParams, subjectPubkey, issuerKeypair, x509Cert);

}

DLL_EXPORT CHIP_ERROR NewNodeOperationalX509Cert(const X509CertRequestParams & requestParams,

                                                 const Crypto::P256PublicKey & subjectPubkey,

                                                 const Crypto::P256Keypair & issuerKeypair, MutableByteSpan & x509Cert)

{

    CertType certType;

    ReturnErrorOnFailure(requestParams.SubjectDN.GetCertType(certType));

    VerifyOrReturnError(certType == CertType::kNode, CHIP_ERROR_INVALID_ARGUMENT);

    ReturnErrorOnFailure(requestParams.IssuerDN.GetCertType(certType));

    VerifyOrReturnError(certType == CertType::kICA || certType == CertType::kRoot, CHIP_ERROR_INVALID_ARGUMENT);

    return NewChipX509Cert(requestParams, subjectPubkey, issuerKeypair, x509Cert);

}

} // namespace Credentials

} // namespace chip