asn.h

Go to the documentation of this file.

// asn.h - originally written and placed in the public domain by Wei Dai
 
 
#ifndef CRYPTOPP_ASN_H
#define CRYPTOPP_ASN_H
 
#include "cryptlib.h"
#include "filters.h"
#include "smartptr.h"
#include "stdcpp.h"
#include "queue.h"
#include "misc.h"
 
#include <iosfwd>
 
// Issue 340
#if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wconversion"
# pragma GCC diagnostic ignored "-Wsign-conversion"
#endif
 
NAMESPACE_BEGIN(CryptoPP)
 
 
enum ASNTag
{
        BOOLEAN                         = 0x01,
        INTEGER                         = 0x02,
        BIT_STRING                      = 0x03,
        OCTET_STRING            = 0x04,
        TAG_NULL                        = 0x05,
        OBJECT_IDENTIFIER       = 0x06,
        OBJECT_DESCRIPTOR       = 0x07,
        EXTERNAL                        = 0x08,
        REAL                            = 0x09,
        ENUMERATED                      = 0x0a,
        UTF8_STRING                     = 0x0c,
        SEQUENCE                        = 0x10,
        SET                             = 0x11,
        NUMERIC_STRING          = 0x12,
        PRINTABLE_STRING        = 0x13,
        T61_STRING                      = 0x14,
        VIDEOTEXT_STRING        = 0x15,
        IA5_STRING                      = 0x16,
        UTC_TIME                        = 0x17,
        GENERALIZED_TIME        = 0x18,
        GRAPHIC_STRING          = 0x19,
        VISIBLE_STRING          = 0x1a,
        GENERAL_STRING          = 0x1b,
        UNIVERSAL_STRING        = 0x1c,
        BMP_STRING              = 0x1e
};
 
enum ASNIdFlag
{
        UNIVERSAL           = 0x00,
        // DATA           = 0x01,
        // HEADER           = 0x02,
        PRIMITIVE           = 0x00,
        CONSTRUCTED         = 0x20,
        APPLICATION         = 0x40,
        CONTEXT_SPECIFIC    = 0x80,
        PRIVATE             = 0xc0
};
 
inline void BERDecodeError() {throw BERDecodeErr();}
 
class CRYPTOPP_DLL UnknownOID : public BERDecodeErr
{
public:
        UnknownOID() : BERDecodeErr("BER decode error: unknown object identifier") {}
        UnknownOID(const char *err) : BERDecodeErr(err) {}
};
 
CRYPTOPP_DLL size_t CRYPTOPP_API DERLengthEncode(BufferedTransformation &bt, lword length);
 
CRYPTOPP_DLL bool CRYPTOPP_API BERLengthDecode(BufferedTransformation &bt, size_t &length);
 
CRYPTOPP_DLL void CRYPTOPP_API DEREncodeNull(BufferedTransformation &bt);
 
CRYPTOPP_DLL void CRYPTOPP_API BERDecodeNull(BufferedTransformation &bt);
 
CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeOctetString(BufferedTransformation &bt, const byte *str, size_t strLen);
 
CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeOctetString(BufferedTransformation &bt, const SecByteBlock &str);
 
CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeOctetString(BufferedTransformation &bt, SecByteBlock &str);
 
CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeOctetString(BufferedTransformation &bt, BufferedTransformation &str);
 
CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeTextString(BufferedTransformation &bt, const byte* str, size_t strLen, byte asnTag);
 
CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeTextString(BufferedTransformation &bt, const SecByteBlock &str, byte asnTag);
 
CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeTextString(BufferedTransformation &bt, const std::string &str, byte asnTag);
 
CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeTextString(BufferedTransformation &bt, SecByteBlock &str, byte asnTag);
 
CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeTextString(BufferedTransformation &bt, std::string &str, byte asnTag);
 
CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeDate(BufferedTransformation &bt, const SecByteBlock &str, byte asnTag);
 
CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeDate(BufferedTransformation &bt, SecByteBlock &str, byte asnTag);
 
CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeBitString(BufferedTransformation &bt, const byte *str, size_t strLen, unsigned int unusedBits=0);
 
CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeBitString(BufferedTransformation &bt, SecByteBlock &str, unsigned int &unusedBits);
 
CRYPTOPP_DLL void CRYPTOPP_API DERReencode(BufferedTransformation &bt, BufferedTransformation &dest);
 
CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodePeekLength(const BufferedTransformation &bt);
 
class CRYPTOPP_DLL OID
{
public:
        virtual ~OID() {}
 
        OID() {}
 
        OID(word32 v) : m_values(1, v) {}
 
        OID(BufferedTransformation &bt) {
                BERDecode(bt);
        }
 
        inline OID & operator+=(word32 rhs) {
                m_values.push_back(rhs); return *this;
        }
 
        void DEREncode(BufferedTransformation &bt) const;
 
        void BERDecode(BufferedTransformation &bt);
 
        void BERDecodeAndCheck(BufferedTransformation &bt) const;
 
        bool Empty() const {
                return m_values.empty();
        }
 
        const std::vector<word32>& GetValues() const {
                return m_values;
        }
 
        std::ostream& Print(std::ostream& out) const;
 
protected:
        friend bool operator==(const OID &lhs, const OID &rhs);
        friend bool operator!=(const OID &lhs, const OID &rhs);
        friend bool operator<(const OID &lhs, const OID &rhs);
        friend bool operator<=(const OID &lhs, const OID &rhs);
        friend bool operator>=(const OID &lhs, const OID &rhs);
 
        std::vector<word32> m_values;
 
private:
        static void EncodeValue(BufferedTransformation &bt, word32 v);
        static size_t DecodeValue(BufferedTransformation &bt, word32 &v);
};
 
class EncodedObjectFilter : public Filter
{
public:
        enum Flag {PUT_OBJECTS=1, PUT_MESSANGE_END_AFTER_EACH_OBJECT=2, PUT_MESSANGE_END_AFTER_ALL_OBJECTS=4, PUT_MESSANGE_SERIES_END_AFTER_ALL_OBJECTS=8};
        enum State {IDENTIFIER, LENGTH, BODY, TAIL, ALL_DONE} m_state;
 
        virtual ~EncodedObjectFilter() {}
 
        EncodedObjectFilter(BufferedTransformation *attachment = NULLPTR, unsigned int nObjects = 1, word32 flags = 0);
 
        void Put(const byte *inString, size_t length);
 
        unsigned int GetNumberOfCompletedObjects() const {return m_nCurrentObject;}
        unsigned long GetPositionOfObject(unsigned int i) const {return m_positions[i];}
 
private:
        BufferedTransformation & CurrentTarget();
 
        ByteQueue m_queue;
        std::vector<unsigned int> m_positions;
        lword m_lengthRemaining;
        word32 m_nObjects, m_nCurrentObject, m_level, m_flags;
        byte m_id;
};
 
class CRYPTOPP_DLL BERGeneralDecoder : public Store
{
public:
        enum {DefaultTag = SEQUENCE | EnumToInt(CONSTRUCTED)};
 
        virtual ~BERGeneralDecoder();
 
        explicit BERGeneralDecoder(BufferedTransformation &inQueue);
 
        explicit BERGeneralDecoder(BufferedTransformation &inQueue, byte asnTag);
 
        explicit BERGeneralDecoder(BERGeneralDecoder &inQueue, byte asnTag);
 
        bool IsDefiniteLength() const {
                return m_definiteLength;
        }
 
        lword RemainingLength() const {
                CRYPTOPP_ASSERT(m_definiteLength);
                return IsDefiniteLength() ? m_length : 0;
        }
 
        bool EndReached() const;
 
        byte PeekByte() const;
 
        void CheckByte(byte b);
 
        size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
 
        size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;
 
        void MessageEnd();
 
protected:
        BufferedTransformation &m_inQueue;
        lword m_length;
        bool m_finished, m_definiteLength;
 
private:
        void Init(byte asnTag);
        void StoreInitialize(const NameValuePairs &parameters)
                {CRYPTOPP_UNUSED(parameters); CRYPTOPP_ASSERT(false);}
        lword ReduceLength(lword delta);
};
 
class CRYPTOPP_DLL DERGeneralEncoder : public ByteQueue
{
public:
        enum {DefaultTag = SEQUENCE | EnumToInt(CONSTRUCTED)};
 
        virtual ~DERGeneralEncoder();
 
        explicit DERGeneralEncoder(BufferedTransformation &outQueue);
 
        explicit DERGeneralEncoder(BufferedTransformation &outQueue, byte asnTag);
 
        explicit DERGeneralEncoder(DERGeneralEncoder &outQueue, byte asnTag);
 
        void MessageEnd();
 
private:
        BufferedTransformation &m_outQueue;
        byte m_asnTag;
        bool m_finished;
};
 
class CRYPTOPP_DLL BERSequenceDecoder : public BERGeneralDecoder
{
public:
        enum {DefaultTag = SEQUENCE | EnumToInt(CONSTRUCTED)};
 
        explicit BERSequenceDecoder(BufferedTransformation &inQueue)
                : BERGeneralDecoder(inQueue, DefaultTag) {}
 
        explicit BERSequenceDecoder(BufferedTransformation &inQueue, byte asnTag)
                : BERGeneralDecoder(inQueue, asnTag) {}
 
        explicit BERSequenceDecoder(BERSequenceDecoder &inQueue)
                : BERGeneralDecoder(inQueue, DefaultTag) {}
 
        explicit BERSequenceDecoder(BERSequenceDecoder &inQueue, byte asnTag)
                : BERGeneralDecoder(inQueue, asnTag) {}
};
 
class CRYPTOPP_DLL DERSequenceEncoder : public DERGeneralEncoder
{
public:
        enum {DefaultTag = SEQUENCE | EnumToInt(CONSTRUCTED)};
 
        explicit DERSequenceEncoder(BufferedTransformation &outQueue)
                : DERGeneralEncoder(outQueue, DefaultTag) {}
 
        explicit DERSequenceEncoder(BufferedTransformation &outQueue, byte asnTag)
                : DERGeneralEncoder(outQueue, asnTag) {}
 
        explicit DERSequenceEncoder(DERSequenceEncoder &outQueue)
                : DERGeneralEncoder(outQueue, DefaultTag) {}
 
        explicit DERSequenceEncoder(DERSequenceEncoder &outQueue, byte asnTag)
                : DERGeneralEncoder(outQueue, asnTag) {}
};
 
class CRYPTOPP_DLL BERSetDecoder : public BERGeneralDecoder
{
public:
        enum {DefaultTag = SET | EnumToInt(CONSTRUCTED)};
 
        explicit BERSetDecoder(BufferedTransformation &inQueue)
                : BERGeneralDecoder(inQueue, DefaultTag) {}
 
        explicit BERSetDecoder(BufferedTransformation &inQueue, byte asnTag)
                : BERGeneralDecoder(inQueue, asnTag) {}
 
        explicit BERSetDecoder(BERSetDecoder &inQueue)
                : BERGeneralDecoder(inQueue, DefaultTag) {}
 
        explicit BERSetDecoder(BERSetDecoder &inQueue, byte asnTag)
                : BERGeneralDecoder(inQueue, asnTag) {}
};
 
class CRYPTOPP_DLL DERSetEncoder : public DERGeneralEncoder
{
public:
        enum {DefaultTag = SET | EnumToInt(CONSTRUCTED)};
 
        explicit DERSetEncoder(BufferedTransformation &outQueue)
                : DERGeneralEncoder(outQueue, DefaultTag) {}
 
        explicit DERSetEncoder(BufferedTransformation &outQueue, byte asnTag)
                : DERGeneralEncoder(outQueue, asnTag) {}
 
        explicit DERSetEncoder(DERSetEncoder &outQueue)
                : DERGeneralEncoder(outQueue, DefaultTag) {}
 
        explicit DERSetEncoder(DERSetEncoder &outQueue, byte asnTag)
                : DERGeneralEncoder(outQueue, asnTag) {}
};
 
template <class T>
class ASNOptional : public member_ptr<T>
{
public:
        void BERDecode(BERSequenceDecoder &seqDecoder, byte tag, byte mask = ~CONSTRUCTED)
        {
                byte b;
                if (seqDecoder.Peek(b) && (b & mask) == tag)
                        reset(new T(seqDecoder));
        }
 
        void DEREncode(BufferedTransformation &out)
        {
                if (this->get() != NULLPTR)
                        this->get()->DEREncode(out);
        }
};
 
template <class BASE>
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ASN1CryptoMaterial : public ASN1Object, public BASE
{
public:
        void Save(BufferedTransformation &bt) const
                {BEREncode(bt);}
 
        void Load(BufferedTransformation &bt)
                {BERDecode(bt);}
};
 
class CRYPTOPP_DLL X509PublicKey : public ASN1CryptoMaterial<PublicKey>
{
public:
        virtual ~X509PublicKey() {}
 
        void BERDecode(BufferedTransformation &bt);
        void DEREncode(BufferedTransformation &bt) const;
 
        virtual OID GetAlgorithmID() const =0;
 
        virtual bool BERDecodeAlgorithmParameters(BufferedTransformation &bt)
                {BERDecodeNull(bt); return false;}
 
        virtual bool DEREncodeAlgorithmParameters(BufferedTransformation &bt) const
                {DEREncodeNull(bt); return false;}
 
        virtual void BERDecodePublicKey(BufferedTransformation &bt, bool parametersPresent, size_t size) =0;
 
        virtual void DEREncodePublicKey(BufferedTransformation &bt) const =0;
};
 
class CRYPTOPP_DLL PKCS8PrivateKey : public ASN1CryptoMaterial<PrivateKey>
{
public:
        virtual ~PKCS8PrivateKey() {}
 
        void BERDecode(BufferedTransformation &bt);
        void DEREncode(BufferedTransformation &bt) const;
 
        virtual OID GetAlgorithmID() const =0;
 
        virtual bool BERDecodeAlgorithmParameters(BufferedTransformation &bt)
                {BERDecodeNull(bt); return false;}
 
        virtual bool DEREncodeAlgorithmParameters(BufferedTransformation &bt) const
                {DEREncodeNull(bt); return false;}
 
        virtual void BERDecodePrivateKey(BufferedTransformation &bt, bool parametersPresent, size_t size) =0;
 
        virtual void DEREncodePrivateKey(BufferedTransformation &bt) const =0;
 
        virtual void BERDecodeOptionalAttributes(BufferedTransformation &bt);
 
        virtual void DEREncodeOptionalAttributes(BufferedTransformation &bt) const;
 
protected:
        ByteQueue m_optionalAttributes;
};
 
// ********************************************************
 
template <class T>
size_t DEREncodeUnsigned(BufferedTransformation &out, T w, byte asnTag = INTEGER)
{
        byte buf[sizeof(w)+1];
        unsigned int bc;
        if (asnTag == BOOLEAN)
        {
                buf[sizeof(w)] = w ? 0xff : 0;
                bc = 1;
        }
        else
        {
                buf[0] = 0;
                for (unsigned int i=0; i<sizeof(w); i++)
                        buf[i+1] = byte(w >> (sizeof(w)-1-i)*8);
                bc = sizeof(w);
                while (bc > 1 && buf[sizeof(w)+1-bc] == 0)
                        --bc;
                if (buf[sizeof(w)+1-bc] & 0x80)
                        ++bc;
        }
        out.Put(asnTag);
        size_t lengthBytes = DERLengthEncode(out, bc);
        out.Put(buf+sizeof(w)+1-bc, bc);
        return 1+lengthBytes+bc;
}
 
template <class T>
void BERDecodeUnsigned(BufferedTransformation &in, T &w, byte asnTag = INTEGER,
                                           T minValue = 0, T maxValue = T(0xffffffff))
{
        byte b;
        if (!in.Get(b) || b != asnTag)
                BERDecodeError();
 
        size_t bc;
        bool definite = BERLengthDecode(in, bc);
        if (!definite)
                BERDecodeError();
        if (bc > in.MaxRetrievable())  // Issue 346
                BERDecodeError();
        if (asnTag == BOOLEAN && bc != 1) // X.690, 8.2.1
                BERDecodeError();
        if ((asnTag == INTEGER || asnTag == ENUMERATED) && bc == 0) // X.690, 8.3.1 and 8.4
                BERDecodeError();
 
        SecByteBlock buf(bc);
 
        if (bc != in.Get(buf, bc))
                BERDecodeError();
 
        // This consumes leading 0 octets. According to X.690, 8.3.2, it could be non-conforming behavior.
        //  X.690, 8.3.2 says "the bits of the first octet and bit 8 of the second octet ... (a) shall
        //  not all be ones and (b) shall not all be zeros ... These rules ensure that an integer value
        //  is always encoded in the smallest possible number of octet".
        // We invented AER (Alternate Encoding Rules), which is more relaxed than BER, CER, and DER.
        const byte *ptr = buf;
        while (bc > sizeof(w) && *ptr == 0)
        {
                bc--;
                ptr++;
        }
        if (bc > sizeof(w))
                BERDecodeError();
 
        w = 0;
        for (unsigned int i=0; i<bc; i++)
                w = (w << 8) | ptr[i];
 
        if (w < minValue || w > maxValue)
                BERDecodeError();
}
 
#ifdef CRYPTOPP_DOXYGEN_PROCESSING
inline bool operator==(const OID &lhs, const OID &rhs);
inline bool operator!=(const OID &lhs, const OID &rhs);
inline bool operator<(const OID &lhs, const OID &rhs);
inline bool operator<=(const OID &lhs, const OID &rhs);
inline bool operator>=(const OID &lhs, const OID &rhs);
inline OID operator+(const OID &lhs, unsigned long rhs);
inline std::ostream& operator<<(std::ostream& out, const OID &oid)
        { return oid.Print(out); }
#else
inline bool operator==(const ::CryptoPP::OID &lhs, const ::CryptoPP::OID &rhs)
        {return lhs.m_values == rhs.m_values;}
inline bool operator!=(const ::CryptoPP::OID &lhs, const ::CryptoPP::OID &rhs)
        {return lhs.m_values != rhs.m_values;}
inline bool operator<(const ::CryptoPP::OID &lhs, const ::CryptoPP::OID &rhs)
        {return std::lexicographical_compare(lhs.m_values.begin(), lhs.m_values.end(), rhs.m_values.begin(), rhs.m_values.end());}
inline bool operator<=(const ::CryptoPP::OID &lhs, const ::CryptoPP::OID &rhs)
        {return lhs<rhs || lhs==rhs;}
inline bool operator>=(const ::CryptoPP::OID &lhs, const ::CryptoPP::OID &rhs)
        {return ! (lhs<rhs);}
inline ::CryptoPP::OID operator+(const ::CryptoPP::OID &lhs, unsigned long rhs)
        {return ::CryptoPP::OID(lhs)+=rhs;}
inline std::ostream& operator<<(std::ostream& out, const OID &oid)
        { return oid.Print(out); }
#endif
 
NAMESPACE_END
 
// Issue 340
#if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
# pragma GCC diagnostic pop
#endif
 
#endif