Asn1Codec.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <memory>
#include <typeinfo>
#include <stdexcept>
#include <sstream>
#include "PointerVector.h"
 
 
namespace pcpp
{
    enum class Asn1TagClass : uint8_t
    {
        Universal = 0,
        Application = 1,
        ContextSpecific = 2,
        Private = 3,
    };
 
    enum class Asn1UniversalTagType : uint8_t
    {
        EndOfContent = 0,
        Boolean = 1,
        Integer = 2,
        BitString = 3,
        OctetString = 4,
        Null = 5,
        ObjectIdentifier = 6,
        ObjectDescriptor = 7,
        External = 8,
        Real = 9,
        Enumerated = 10,
        EmbeddedPDV = 11,
        UTF8String = 12,
        RelativeObjectIdentifier = 13,
        Time = 14,
        Reserved = 15,
        Sequence = 16,
        Set = 17,
        NumericString = 18,
        PrintableString = 19,
        T61String = 20,
        VideotexString = 21,
        IA5String = 22,
        UTCTime = 23,
        GeneralizedTime = 24,
        GraphicString = 25,
        VisibleString = 26,
        GeneralString = 27,
        UniversalString = 28,
        CharacterString = 29,
        BMPString = 30,
        Date = 31,
        TimeOfDay = 32,
        DateTime = 33,
        Duration = 34,
        ObjectIdentifierIRI = 35,
        RelativeObjectIdentifierIRI = 36,
        NotApplicable = 255
    };
 
    class Asn1Record
    {
    public:
        static std::unique_ptr<Asn1Record> decode(const uint8_t* data, size_t dataLen, bool lazy = true);
 
        std::vector<uint8_t> encode();
 
        Asn1TagClass getTagClass() const
        {
            return m_TagClass;
        }
 
        bool isConstructed() const
        {
            return m_IsConstructed;
        }
 
        Asn1UniversalTagType getUniversalTagType() const;
 
        uint8_t getTagType() const
        {
            return m_TagType;
        }
 
        size_t getValueLength() const
        {
            return m_ValueLength;
        }
 
        size_t getTotalLength() const
        {
            return m_TotalLength;
        }
 
        std::string toString();
 
        template <class Asn1RecordType> Asn1RecordType* castAs()
        {
            auto result = dynamic_cast<Asn1RecordType*>(this);
            if (result == nullptr)
            {
                throw std::bad_cast();
            }
            return result;
        }
 
        virtual ~Asn1Record() = default;
 
    protected:
        Asn1TagClass m_TagClass = Asn1TagClass::Universal;
        bool m_IsConstructed = false;
        uint8_t m_TagType = 0;
 
        size_t m_ValueLength = 0;
        size_t m_TotalLength = 0;
 
        uint8_t* m_EncodedValue = nullptr;
 
        Asn1Record() = default;
 
        static Asn1Record* decodeInternal(const uint8_t* data, size_t dataLen, bool lazy);
 
        virtual void decodeValue(uint8_t* data, bool lazy) = 0;
        virtual std::vector<uint8_t> encodeValue() const = 0;
 
        static Asn1Record* decodeTagAndCreateRecord(const uint8_t* data, size_t dataLen, uint8_t& tagLen);
        uint8_t decodeLength(const uint8_t* data, size_t dataLen);
        void decodeValueIfNeeded();
 
        uint8_t encodeTag();
        std::vector<uint8_t> encodeLength() const;
 
        virtual std::vector<std::string> toStringList();
 
        friend class Asn1ConstructedRecord;
    };
 
    class Asn1GenericRecord : public Asn1Record
    {
        friend class Asn1Record;
 
    public:
        Asn1GenericRecord(Asn1TagClass tagClass, bool isConstructed, uint8_t tagType, const uint8_t* value,
                          size_t valueLen);
 
        Asn1GenericRecord(Asn1TagClass tagClass, bool isConstructed, uint8_t tagType, const std::string& value);
 
        ~Asn1GenericRecord() override;
 
        const uint8_t* getValue()
        {
            decodeValueIfNeeded();
            return m_Value;
        }
 
    protected:
        Asn1GenericRecord() = default;
 
        void decodeValue(uint8_t* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
    private:
        uint8_t* m_Value = nullptr;
 
        void init(Asn1TagClass tagClass, bool isConstructed, uint8_t tagType, const uint8_t* value, size_t valueLen);
    };
 
    class Asn1ConstructedRecord : public Asn1Record
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1ConstructedRecord(Asn1TagClass tagClass, uint8_t tagType,
                                       const std::vector<Asn1Record*>& subRecords);
 
        explicit Asn1ConstructedRecord(Asn1TagClass tagClass, uint8_t tagType,
                                       const PointerVector<Asn1Record>& subRecords);
 
        PointerVector<Asn1Record>& getSubRecords()
        {
            decodeValueIfNeeded();
            return m_SubRecords;
        };
 
    protected:
        Asn1ConstructedRecord() = default;
 
        void decodeValue(uint8_t* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
        std::vector<std::string> toStringList() override;
 
        template <typename Iterator> void init(Asn1TagClass tagClass, uint8_t tagType, Iterator begin, Iterator end)
        {
            m_TagType = tagType;
            m_TagClass = tagClass;
            m_IsConstructed = true;
 
            size_t recordValueLength = 0;
            for (Iterator recordIter = begin; recordIter != end; ++recordIter)
            {
                auto encodedRecord = (*recordIter)->encode();
                auto copyRecord = Asn1Record::decode(encodedRecord.data(), encodedRecord.size(), false);
                m_SubRecords.pushBack(std::move(copyRecord));
                recordValueLength += encodedRecord.size();
            }
 
            m_ValueLength = recordValueLength;
            m_TotalLength = recordValueLength + 1 + (m_ValueLength < 128 ? 1 : 2);
        }
 
    private:
        PointerVector<Asn1Record> m_SubRecords;
    };
 
    class Asn1SequenceRecord : public Asn1ConstructedRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1SequenceRecord(const std::vector<Asn1Record*>& subRecords);
 
        explicit Asn1SequenceRecord(const PointerVector<Asn1Record>& subRecords);
 
    private:
        Asn1SequenceRecord() = default;
    };
 
    class Asn1SetRecord : public Asn1ConstructedRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1SetRecord(const std::vector<Asn1Record*>& subRecords);
 
        explicit Asn1SetRecord(const PointerVector<Asn1Record>& subRecords);
 
    private:
        Asn1SetRecord() = default;
    };
 
    class Asn1PrimitiveRecord : public Asn1Record
    {
        friend class Asn1Record;
 
    protected:
        Asn1PrimitiveRecord() = default;
        explicit Asn1PrimitiveRecord(Asn1UniversalTagType tagType);
    };
 
    class Asn1IntegerRecord : public Asn1PrimitiveRecord
    {
        friend class Asn1Record;
 
    public:
        template <typename T>
        using EnableIfUnsignedIntegral =
            std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, int>;
 
        explicit Asn1IntegerRecord(uint64_t value);
 
        explicit Asn1IntegerRecord(const std::string& value);
 
        template <typename T, EnableIfUnsignedIntegral<T> = 0> T getIntValue()
        {
            decodeValueIfNeeded();
            return m_Value.getInt<T>();
        }
 
        PCPP_DEPRECATED("Use getIntValue instead")
        uint32_t getValue()
        {
            return getIntValue<uint32_t>();
        }
 
        std::string getValueAsString()
        {
            decodeValueIfNeeded();
            return m_Value.toString();
        }
 
    protected:
        Asn1IntegerRecord() = default;
 
        void decodeValue(uint8_t* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
        std::vector<std::string> toStringList() override;
 
    private:
        class BigInt
        {
        public:
            BigInt() = default;
 
            template <typename T, EnableIfUnsignedIntegral<T> = 0> explicit BigInt(T value)
            {
                m_Value = initFromInt(value);
            }
 
            explicit BigInt(const std::string& value);
            BigInt(const BigInt& other);
 
            template <typename T, EnableIfUnsignedIntegral<T> = 0> BigInt& operator=(T value)
            {
                m_Value = initFromInt(value);
                return *this;
            }
            BigInt& operator=(const std::string& value);
            size_t size() const;
 
            template <typename T, EnableIfUnsignedIntegral<T> = 0> T getInt() const
            {
                if (!canFit<T>())
                {
                    throw std::overflow_error("Value cannot fit into requested int type");
                }
 
                std::stringstream sstream;
                sstream << std::hex << m_Value;
 
                uint64_t result;
                sstream >> result;
                return static_cast<T>(result);
            }
 
            template <typename T, EnableIfUnsignedIntegral<T> = 0> bool canFit() const
            {
                return sizeof(T) >= (m_Value.size() + 1) / 2;
            }
 
            std::string toString() const;
            std::vector<uint8_t> toBytes() const;
 
        private:
            std::string m_Value;
 
            static std::string initFromString(const std::string& value);
 
            template <typename T, EnableIfUnsignedIntegral<T> = 0> static std::string initFromInt(T value)
            {
                std::stringstream ss;
                ss << std::hex << static_cast<uint64_t>(value);
                return ss.str();
            }
        };
 
        BigInt m_Value;
    };
 
    class Asn1EnumeratedRecord : public Asn1IntegerRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1EnumeratedRecord(uint32_t value);
 
    private:
        Asn1EnumeratedRecord() = default;
    };
 
    class Asn1OctetStringRecord : public Asn1PrimitiveRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1OctetStringRecord(const std::string& value);
 
        explicit Asn1OctetStringRecord(const uint8_t* value, size_t valueLength);
 
        std::string getValue()
        {
            decodeValueIfNeeded();
            return m_Value;
        };
 
    protected:
        void decodeValue(uint8_t* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
        std::vector<std::string> toStringList() override;
 
    private:
        std::string m_Value;
        bool m_IsPrintable = true;
 
        Asn1OctetStringRecord() = default;
    };
 
    class Asn1BooleanRecord : public Asn1PrimitiveRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1BooleanRecord(bool value);
 
        bool getValue()
        {
            decodeValueIfNeeded();
            return m_Value;
        };
 
    protected:
        void decodeValue(uint8_t* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
        std::vector<std::string> toStringList() override;
 
    private:
        Asn1BooleanRecord() = default;
 
        bool m_Value = false;
    };
 
    class Asn1NullRecord : public Asn1PrimitiveRecord
    {
        friend class Asn1Record;
 
    public:
        Asn1NullRecord();
 
    protected:
        void decodeValue(uint8_t* data, bool lazy) override
        {}
        std::vector<uint8_t> encodeValue() const override
        {
            return {};
        }
    };
}  // namespace pcpp