Asn1Codec.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <memory>
#include <typeinfo>
#include <stdexcept>
#include <sstream>
#include <chrono>
#include <bitset>
#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 const* m_EncodedValue = nullptr;
 
        Asn1Record() = default;
 
        static std::unique_ptr<Asn1Record> decodeInternal(const uint8_t* data, size_t dataLen, bool lazy);
 
        virtual void decodeValue(uint8_t const* data, bool lazy) = 0;
        virtual std::vector<uint8_t> encodeValue() const = 0;
 
        static std::unique_ptr<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 = default;
 
        const uint8_t* getValue()
        {
            decodeValueIfNeeded();
            return m_Value.get();
        }
 
    protected:
        Asn1GenericRecord() = default;
 
        void decodeValue(uint8_t const* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
    private:
        std::unique_ptr<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 const* 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 const* 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;
    };
 
    template <Asn1UniversalTagType TagType> class Asn1StringRecord : public Asn1PrimitiveRecord
    {
    public:
        std::string getValue()
        {
            decodeValueIfNeeded();
            return m_Value;
        };
 
    protected:
        Asn1StringRecord() : Asn1PrimitiveRecord(TagType)
        {}
 
        explicit Asn1StringRecord(const std::string& value) : Asn1PrimitiveRecord(TagType), m_Value(value)
        {
            m_ValueLength = value.size();
            m_TotalLength = m_ValueLength + 2;
        }
 
        void decodeValue(uint8_t const* data, bool lazy) override
        {
            m_Value = std::string(reinterpret_cast<char const*>(data), m_ValueLength);
        }
        std::vector<uint8_t> encodeValue() const override
        {
            return { m_Value.begin(), m_Value.end() };
        }
 
        std::vector<std::string> toStringList() override
        {
            return { Asn1Record::toStringList().front() + ", Value: " + getValue() };
        }
 
        std::string m_Value;
    };
 
    class Asn1OctetStringRecord : public Asn1StringRecord<Asn1UniversalTagType::OctetString>
    {
        friend class Asn1Record;
 
    public:
        using Asn1StringRecord::Asn1StringRecord;
 
        explicit Asn1OctetStringRecord(const uint8_t* value, size_t valueLength);
 
        explicit Asn1OctetStringRecord(const std::string& value) : Asn1StringRecord(value)
        {}
 
    protected:
        void decodeValue(uint8_t const* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
    private:
        Asn1OctetStringRecord() = default;
 
        bool m_IsPrintable = true;
    };
 
    class Asn1UTF8StringRecord : public Asn1StringRecord<Asn1UniversalTagType::UTF8String>
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1UTF8StringRecord(const std::string& value) : Asn1StringRecord(value)
        {}
 
    private:
        Asn1UTF8StringRecord() = default;
    };
 
    class Asn1PrintableStringRecord : public Asn1StringRecord<Asn1UniversalTagType::PrintableString>
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1PrintableStringRecord(const std::string& value) : Asn1StringRecord(value)
        {}
 
    private:
        Asn1PrintableStringRecord() = default;
    };
 
    class Asn1IA5StringRecord : public Asn1StringRecord<Asn1UniversalTagType::IA5String>
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1IA5StringRecord(const std::string& value) : Asn1StringRecord(value)
        {}
 
    private:
        Asn1IA5StringRecord() = default;
    };
 
    class Asn1BooleanRecord : public Asn1PrimitiveRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1BooleanRecord(bool value);
 
        bool getValue()
        {
            decodeValueIfNeeded();
            return m_Value;
        };
 
    protected:
        void decodeValue(uint8_t const* 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 const* data, bool lazy) override
        {}
        std::vector<uint8_t> encodeValue() const override
        {
            return {};
        }
    };
 
    class Asn1ObjectIdentifier
    {
        friend class Asn1ObjectIdentifierRecord;
 
    public:
        explicit Asn1ObjectIdentifier(const uint8_t* data, size_t dataLen);
 
        explicit Asn1ObjectIdentifier(const std::string& oidString);
 
        const std::vector<uint32_t>& getComponents() const
        {
            return m_Components;
        }
 
        bool operator==(const Asn1ObjectIdentifier& other) const
        {
            return m_Components == other.m_Components;
        }
 
        bool operator!=(const Asn1ObjectIdentifier& other) const
        {
            return m_Components != other.m_Components;
        }
 
        std::string toString() const;
 
        std::vector<uint8_t> toBytes() const;
 
        friend std::ostream& operator<<(std::ostream& os, const Asn1ObjectIdentifier& oid)
        {
            return os << oid.toString();
        }
 
    protected:
        Asn1ObjectIdentifier() = default;
 
    private:
        std::vector<uint32_t> m_Components;
    };
 
    class Asn1ObjectIdentifierRecord : public Asn1PrimitiveRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1ObjectIdentifierRecord(const Asn1ObjectIdentifier& value);
 
        const Asn1ObjectIdentifier& getValue()
        {
            decodeValueIfNeeded();
            return m_Value;
        }
 
    protected:
        void decodeValue(uint8_t const* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
        std::vector<std::string> toStringList() override;
 
    private:
        Asn1ObjectIdentifier m_Value;
 
        Asn1ObjectIdentifierRecord() = default;
    };
 
    class Asn1TimeRecord : public Asn1PrimitiveRecord
    {
    public:
        std::chrono::system_clock::time_point getValue(const std::string& timezone = "Z")
        {
            decodeValueIfNeeded();
            return adjustTimezones(m_Value, "Z", timezone);
        };
 
        std::string getValueAsString(const std::string& format = "%Y-%m-%d %H:%M:%S", const std::string& timezone = "Z",
                                     bool includeMilliseconds = false);
 
    protected:
        Asn1TimeRecord() = default;
        explicit Asn1TimeRecord(Asn1UniversalTagType tagType, const std::chrono::system_clock::time_point& value,
                                const std::string& timezone);
 
        std::chrono::system_clock::time_point m_Value;
 
        std::vector<std::string> toStringList() override;
 
        static void validateTimezone(const std::string& timezone);
        static std::chrono::system_clock::time_point adjustTimezones(const std::chrono::system_clock::time_point& value,
                                                                     const std::string& fromTimezone,
                                                                     const std::string& toTimezone);
    };
 
    class Asn1UtcTimeRecord : public Asn1TimeRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1UtcTimeRecord(const std::chrono::system_clock::time_point& value, bool withSeconds = true);
 
    protected:
        void decodeValue(uint8_t const* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
    private:
        Asn1UtcTimeRecord() = default;
        bool m_WithSeconds = true;
    };
 
    class Asn1GeneralizedTimeRecord : public Asn1TimeRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1GeneralizedTimeRecord(const std::chrono::system_clock::time_point& value,
                                           const std::string& timezone = "Z");
 
    protected:
        void decodeValue(uint8_t const* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
    private:
        Asn1GeneralizedTimeRecord() = default;
        std::string m_Timezone;
    };
 
    class Asn1BitStringRecord : public Asn1PrimitiveRecord
    {
        friend class Asn1Record;
 
    public:
        explicit Asn1BitStringRecord(const std::string& value);
 
        std::string getValue()
        {
            decodeValueIfNeeded();
            return m_Value.toString();
        };
 
        std::vector<uint8_t> getVecValue()
        {
            decodeValueIfNeeded();
            return m_Value.toBytes();
        }
 
    protected:
        void decodeValue(uint8_t const* data, bool lazy) override;
        std::vector<uint8_t> encodeValue() const override;
 
        std::vector<std::string> toStringList() override;
 
    private:
        class BitSet
        {
        public:
            BitSet() = default;
            explicit BitSet(const std::string& value);
            BitSet(const uint8_t* data, size_t numBits);
 
            BitSet& operator=(const std::string& value);
 
            size_t sizeInBytes() const;
            std::string toString() const;
            std::vector<uint8_t> toBytes() const;
            size_t getNumBits() const
            {
                return m_NumBits;
            }
 
        private:
            void initFromString(const std::string& value);
 
            std::vector<std::bitset<8>> m_Data;
            size_t m_NumBits = 0;
        };
 
        Asn1BitStringRecord() = default;
 
        BitSet m_Value;
    };
}  // namespace pcpp