CryptoKeyDecoder.h

Go to the documentation of this file.

#pragma once
 
 
#include "CryptoDataReader.h"
#include "Asn1Codec.h"
#include <string>
#include <memory>
#include <utility>
 
namespace pcpp
{
    namespace internal
    {
        class PrivateKeyDataView
        {
        protected:
            explicit PrivateKeyDataView(Asn1SequenceRecord* root, std::string decoderType)
                : m_Root(root), m_DecoderType(std::move(decoderType))
            {}
 
            ~PrivateKeyDataView() = default;
 
            template <class Asn1RecordType>
            Asn1RecordType* castSubRecordAs(int index, const std::string& fieldName) const
            {
                try
                {
                    return m_Root->getSubRecords().at(index)->template castAs<Asn1RecordType>();
                }
                catch (const std::exception&)
                {
                    throw std::runtime_error("Invalid " + m_DecoderType + " data: " + fieldName);
                }
            }
 
        private:
            Asn1SequenceRecord* m_Root;
            std::string m_DecoderType;
        };
 
        class RSAPrivateKeyDataView : public PrivateKeyDataView
        {
        public:
            uint8_t getVersion() const;
 
            std::string getModulus() const;
 
            uint64_t getPublicExponent() const;
 
            std::string getPrivateExponent() const;
 
            std::string getPrime1() const;
 
            std::string getPrime2() const;
 
            std::string getExponent1() const;
 
            std::string getExponent2() const;
 
            std::string getCoefficient() const;
 
        protected:
            explicit RSAPrivateKeyDataView(Asn1SequenceRecord* root, std::string decoderType)
                : PrivateKeyDataView(root, decoderType)
            {}
 
            ~RSAPrivateKeyDataView() = default;
 
        private:
            static constexpr int versionOffset = 0;
            static constexpr int modulusOffset = 1;
            static constexpr int publicExponentOffset = 2;
            static constexpr int privateExponentOffset = 3;
            static constexpr int prime1Offset = 4;
            static constexpr int prime2Offset = 5;
            static constexpr int exponent1Offset = 6;
            static constexpr int exponent2Offset = 7;
            static constexpr int coefficientOffset = 8;
        };
 
        class ECPrivateKeyDataView : public PrivateKeyDataView
        {
        public:
            uint8_t getVersion() const;
 
            std::string getPrivateKey() const;
 
            std::unique_ptr<Asn1ObjectIdentifier> getParameters() const;
 
            std::string getPublicKey() const;
 
        protected:
            explicit ECPrivateKeyDataView(Asn1SequenceRecord* root, std::string decoderType);
 
            ~ECPrivateKeyDataView() = default;
 
        private:
            static constexpr int versionOffset = 0;
            static constexpr int privateKeyOffset = 1;
 
            int m_ParametersOffset = -1;
            int m_PublicKeyOffset = -1;
        };
 
        template <typename CryptoKey> class CryptographicKey
        {
        public:
            std::vector<uint8_t> toDER() const
            {
                return m_Root->encode();
            }
 
            std::string toPEM() const
            {
                return PemCodec::encode(m_Root->encode(), CryptoKey::pemLabel);
            }
 
        protected:
            CryptographicKey(std::unique_ptr<uint8_t[]> derData, size_t derDataLen)
                : m_DerData(std::move(derData)), m_Root(Asn1Record::decode(m_DerData.get(), derDataLen))
            {}
 
            CryptographicKey(uint8_t* derData, size_t derDataLen, bool ownDerData)
            {
                m_Root = Asn1Record::decode(derData, derDataLen);
                if (ownDerData)
                {
                    m_DerData.reset(derData);
                }
            }
 
            ~CryptographicKey() = default;
 
            Asn1SequenceRecord* getRoot() const
            {
                try
                {
                    return m_Root->castAs<Asn1SequenceRecord>();
                }
                catch (const std::bad_cast&)
                {
                    throw std::runtime_error("Invalid " + std::string(CryptoKey::keyType) + " data");
                }
            }
 
            template <class Asn1RecordType>
            Asn1RecordType* castSubRecordAs(int index, const std::string& fieldName) const
            {
                try
                {
                    return getRoot()->getSubRecords().at(index)->template castAs<Asn1RecordType>();
                }
                catch (const std::exception&)
                {
                    throw std::runtime_error("Invalid " + std::string(CryptoKey::keyType) + " data: " + fieldName);
                }
            }
 
        private:
            std::unique_ptr<uint8_t[]> m_DerData;
            std::unique_ptr<Asn1Record> m_Root;
        };
    }  // namespace internal
 
    class CryptographicKeyAlgorithm
    {
    public:
        enum Value : uint8_t
        {
            RSA,
            DSA,
            ECDSA,
            ED25519,
            ED448,
            DiffieHellman,
            X448,
            Unknown,
        };
 
        CryptographicKeyAlgorithm() = default;
 
        // cppcheck-suppress noExplicitConstructor
        constexpr CryptographicKeyAlgorithm(Value value) : m_Value(value)
        {}
 
        std::string toString() const;
 
        std::string getOidValue() const;
 
        static CryptographicKeyAlgorithm fromOidValue(const Asn1ObjectIdentifier& value);
 
        // Allow switch and comparisons.
        constexpr operator Value() const
        {
            return m_Value;
        }
 
        // Prevent usage: if(LdapOperationType)
        explicit operator bool() const = delete;
 
    private:
        Value m_Value = Unknown;
    };
 
    class RSAPrivateKey : public internal::CryptographicKey<RSAPrivateKey>,
                          public internal::CryptoDataReader<RSAPrivateKey>,
                          public internal::RSAPrivateKeyDataView
    {
    protected:
        RSAPrivateKey(std::unique_ptr<uint8_t[]> derData, size_t derDataLen)
            : CryptographicKey(std::move(derData), derDataLen), RSAPrivateKeyDataView(getRoot(), keyType)
        {}
 
        RSAPrivateKey(uint8_t* derData, size_t derDataLen, bool ownDerData)
            : CryptographicKey(derData, derDataLen, ownDerData), RSAPrivateKeyDataView(getRoot(), keyType)
        {}
 
    private:
        static constexpr const char* pemLabel = "RSA PRIVATE KEY";
        static constexpr const char* keyType = "RSA private key";
 
        using CryptographicKey::CryptographicKey;
        friend class internal::CryptographicKey<RSAPrivateKey>;
        friend class internal::CryptoDataReader<RSAPrivateKey>;
    };
 
    class ECPrivateKey : public internal::CryptographicKey<ECPrivateKey>,
                         public internal::CryptoDataReader<ECPrivateKey>,
                         public internal::ECPrivateKeyDataView
    {
    protected:
        ECPrivateKey(std::unique_ptr<uint8_t[]> derData, size_t derDataLen)
            : CryptographicKey(std::move(derData), derDataLen), ECPrivateKeyDataView(getRoot(), keyType)
        {}
 
        ECPrivateKey(uint8_t* derData, size_t derDataLen, bool ownDerData)
            : CryptographicKey(derData, derDataLen, ownDerData), ECPrivateKeyDataView(getRoot(), keyType)
        {}
 
    private:
        static constexpr const char* pemLabel = "EC PRIVATE KEY";
        static constexpr const char* keyType = "EC private key";
 
        using CryptographicKey::CryptographicKey;
        friend class internal::CryptographicKey<ECPrivateKey>;
        friend class internal::CryptoDataReader<ECPrivateKey>;
    };
 
    class PKCS8PrivateKey : public internal::CryptographicKey<PKCS8PrivateKey>,
                            public internal::CryptoDataReader<PKCS8PrivateKey>
    {
    public:
        class PrivateKeyData
        {
        public:
            virtual ~PrivateKeyData() = default;
 
            template <class PrivateKeyDataType> PrivateKeyDataType* castAs()
            {
                auto privateKeyData = dynamic_cast<PrivateKeyDataType*>(this);
                if (privateKeyData == nullptr)
                {
                    throw std::runtime_error("Trying to PKCS#8 private key data to the wrong type");
                }
                return privateKeyData;
            }
 
        protected:
            explicit PrivateKeyData(const std::string& rawData);
 
            Asn1SequenceRecord* getRoot() const
            {
                return m_Root->castAs<Asn1SequenceRecord>();
            }
 
            std::vector<uint8_t> m_DerData;
            std::unique_ptr<Asn1Record> m_Root;
        };
 
        class RSAPrivateKeyData : public PrivateKeyData, public internal::RSAPrivateKeyDataView
        {
            friend class PKCS8PrivateKey;
            explicit RSAPrivateKeyData(const std::string& rawData);
        };
 
        class ECPrivateKeyData : public PrivateKeyData, public internal::ECPrivateKeyDataView
        {
            friend class PKCS8PrivateKey;
            explicit ECPrivateKeyData(const std::string& rawData);
        };
 
        class Ed25519PrivateKeyData : public PrivateKeyData
        {
            friend class PKCS8PrivateKey;
            explicit Ed25519PrivateKeyData(const std::string& rawData);
 
        public:
            std::string getPrivateKey() const;
        };
 
        uint8_t getVersion() const;
 
        CryptographicKeyAlgorithm getPrivateKeyAlgorithm() const;
 
        std::unique_ptr<PrivateKeyData> getPrivateKey() const;
 
        template <typename PrivateKeyDataType> std::unique_ptr<PrivateKeyDataType> getPrivateKeyAs() const
        {
            auto privateKey = getPrivateKey();
            if (privateKey == nullptr)
            {
                return nullptr;
            }
 
            if (auto* specificPrivateKey = dynamic_cast<PrivateKeyDataType*>(privateKey.get()))
            {
                privateKey.release();
                return std::unique_ptr<PrivateKeyDataType>(specificPrivateKey);
            }
 
            return nullptr;
        }
 
    private:
        static constexpr const char* pemLabel = "PRIVATE KEY";
        static constexpr const char* keyType = "PKCS#8 private key";
        static constexpr int versionOffset = 0;
        static constexpr int privateKeyAlgorithmOffset = 1;
        static constexpr int privateKeyOffset = 2;
 
        using CryptographicKey::CryptographicKey;
        friend class internal::CryptographicKey<PKCS8PrivateKey>;
        friend class internal::CryptoDataReader<PKCS8PrivateKey>;
    };
 
    class RSAPublicKey : public internal::CryptographicKey<RSAPublicKey>,
                         public internal::CryptoDataReader<RSAPublicKey>
    {
    public:
        std::string getModulus() const;
 
        uint64_t getPublicExponent() const;
 
    private:
        static constexpr const char* pemLabel = "RSA PUBLIC KEY";
        static constexpr const char* keyType = "RSA public key";
        static constexpr int modulusOffset = 0;
        static constexpr int publicExponentOffset = 1;
 
        using CryptographicKey::CryptographicKey;
        friend class internal::CryptographicKey<RSAPublicKey>;
        friend class internal::CryptoDataReader<RSAPublicKey>;
    };
 
    class SubjectPublicKeyInfo : public internal::CryptographicKey<SubjectPublicKeyInfo>,
                                 public internal::CryptoDataReader<SubjectPublicKeyInfo>
    {
    public:
        CryptographicKeyAlgorithm getAlgorithm() const;
 
        std::string getSubjectPublicKey() const;
 
    private:
        static constexpr const char* pemLabel = "PUBLIC KEY";
        static constexpr const char* keyType = "public key";
        static constexpr int algorithmOffset = 0;
        static constexpr int subjectPublicKeyOffset = 1;
 
        using CryptographicKey::CryptographicKey;
        friend class internal::CryptographicKey<SubjectPublicKeyInfo>;
        friend class internal::CryptoDataReader<SubjectPublicKeyInfo>;
    };
}  // namespace pcpp