#include <ber_dec.h>

Classes
class	Limits

Public Member Functions
	BER_Decoder (BER_Decoder &&other) noexcept
BOTAN_FUTURE_EXPLICIT	BER_Decoder (BER_Object &&obj)
	BER_Decoder (BER_Object &&obj, Limits limits)
	BER_Decoder (const BER_Decoder &other)=delete
BOTAN_FUTURE_EXPLICIT	BER_Decoder (const BER_Object &obj, Limits limits=Limits::BER())
	BER_Decoder (const uint8_t buf[], size_t len, Limits limits=Limits::BER())
	BER_Decoder (DataSource &src, Limits limits=Limits::BER())
	BER_Decoder (std::span< const uint8_t > buf, Limits limits=Limits::BER())
BER_Decoder &	decode (ASN1_Object &obj, ASN1_Type type_tag=ASN1_Type::NoObject, ASN1_Class class_tag=ASN1_Class::NoObject)
BER_Decoder &	decode (BigInt &out)
BER_Decoder &	decode (BigInt &v, ASN1_Type type_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
BER_Decoder &	decode (bool &out)
BER_Decoder &	decode (bool &v, ASN1_Type type_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
BER_Decoder &	decode (secure_vector< uint8_t > &v, ASN1_Type real_type, ASN1_Type type_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
BER_Decoder &	decode (size_t &out)
BER_Decoder &	decode (size_t &v, ASN1_Type type_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
BER_Decoder &	decode (std::vector< uint8_t > &v, ASN1_Type real_type, ASN1_Type type_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
template<typename Alloc>
BER_Decoder &	decode (std::vector< uint8_t, Alloc > &out, ASN1_Type real_type)
template<typename T>
BER_Decoder &	decode_and_check (const T &expected, std::string_view error_msg)
BER_Decoder &	decode_bitstring (ASN1_BitString &out, ASN1_Type type_tag=ASN1_Type::BitString, ASN1_Class class_tag=ASN1_Class::Universal)
uint64_t	decode_constrained_integer (ASN1_Type type_tag, ASN1_Class class_tag, size_t T_bytes)
template<typename T>
BER_Decoder &	decode_default (T &out, ASN1_Type type_tag, ASN1_Class class_tag, const T &default_value)
template<typename T>
BER_Decoder &	decode_implicit (BER_Object obj, T &out, ASN1_Type real_type, ASN1_Class real_class)
template<typename T>
BER_Decoder &	decode_implicit (T &out, ASN1_Type type_tag, ASN1_Class class_tag, ASN1_Type real_type, ASN1_Class real_class)
template<typename T>
BER_Decoder &	decode_integer_type (T &out)
template<typename T>
BER_Decoder &	decode_integer_type (T &out, ASN1_Type type_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
template<typename T>
BER_Decoder &	decode_list (std::vector< T > &vec, ASN1_Type type_tag=ASN1_Type::Sequence, ASN1_Class class_tag=ASN1_Class::Universal)
BER_Decoder &	decode_named_bitstring (uint64_t &bits, size_t width, ASN1_Type type_tag=ASN1_Type::BitString, ASN1_Class class_tag=ASN1_Class::Universal)
BER_Decoder &	decode_null ()
template<typename Alloc>
BER_Decoder &	decode_octet_aligned_bitstring (std::vector< uint8_t, Alloc > &out, ASN1_Type type_tag=ASN1_Type::BitString, ASN1_Class class_tag=ASN1_Class::Universal)
BER_Decoder &	decode_octet_string_bigint (BigInt &b)
template<typename T>
BER_Decoder &	decode_optional (std::optional< T > &optval, ASN1_Type type_tag, ASN1_Class class_tag)
template<typename T>
BER_Decoder &	decode_optional (T &out, ASN1_Type type_tag, ASN1_Class class_tag, const T &default_value=T())
template<typename F>
BER_Decoder &	decode_optional_field (uint32_t tag_no, ASN1_Class class_tag, F &&fn)
template<typename T>
BER_Decoder &	decode_optional_implicit (T &out, ASN1_Type type_tag, ASN1_Class class_tag, ASN1_Type real_type, ASN1_Class real_class, const T &default_value=T())
template<typename T>
bool	decode_optional_list (std::vector< T > &vec, ASN1_Type type_tag=ASN1_Type::Sequence, ASN1_Class class_tag=ASN1_Class::Universal)
template<typename Alloc>
BER_Decoder &	decode_optional_octet_aligned_bitstring (std::vector< uint8_t, Alloc > &out, ASN1_Type expected_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
template<typename Alloc>
BER_Decoder &	decode_optional_octet_aligned_bitstring (std::vector< uint8_t, Alloc > &out, uint32_t expected_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
template<typename Alloc>
BER_Decoder &	decode_optional_string (std::vector< uint8_t, Alloc > &out, ASN1_Type real_type, ASN1_Type expected_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
template<typename Alloc>
BER_Decoder &	decode_optional_string (std::vector< uint8_t, Alloc > &out, ASN1_Type real_type, uint32_t expected_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
BER_Decoder &	discard_remaining ()
BER_Decoder &	end_cons ()
BER_Decoder &	get_next (BER_Object &ber)
BER_Object	get_next_object ()
std::vector< uint8_t >	get_next_octet_string ()
template<typename T> requires std::is_standard_layout_v<T> && std::is_trivial_v<T>
BER_Decoder &	get_next_value (T &out, ASN1_Type type_tag, ASN1_Class class_tag=ASN1_Class::ContextSpecific)
Limits	limits () const
bool	more_items () const
BER_Decoder &	operator= (BER_Decoder &&) noexcept
BER_Decoder &	operator= (const BER_Decoder &)=delete
const BER_Object &	peek_next_object ()
void	push_back (BER_Object &&obj)
void	push_back (const BER_Object &obj)
template<typename Alloc>
BER_Decoder &	raw_bytes (std::vector< uint8_t, Alloc > &out)
BER_Decoder	start_cons (ASN1_Type type_tag, ASN1_Class class_tag)
BER_Decoder	start_context_specific (uint32_t tag)
BER_Decoder	start_explicit_context_specific (uint32_t tag)
BER_Decoder	start_sequence ()
BER_Decoder	start_set ()
BER_Decoder &	verify_end ()
BER_Decoder &	verify_end (std::string_view err_msg)
	~BER_Decoder ()

Detailed Description

BER Decoding Object

Definition at line 27 of file ber_dec.h.

Constructor & Destructor Documentation

◆ BER_Decoder() [1/8]

Botan::BER_Decoder::BER_Decoder	(	const uint8_t	buf[],
		size_t	len,
		Limits	limits = Limits::BER() )

inline

Set up to BER decode the data in buf of length len

Definition at line 150 of file ber_dec.h.

150 :

151 BER_Decoder(std::span{buf, len}, limits) {}

Botan::BER_Decoder::limits

Limits limits() const

Definition ber_dec.h:197

Botan::BER_Decoder::BER_Decoder

BER_Decoder(const uint8_t buf[], size_t len, Limits limits=Limits::BER())

Definition ber_dec.h:150

References BER_Decoder(), and limits().

Referenced by BER_Decoder(), BER_Decoder(), BER_Decoder(), BER_Decoder(), BER_Decoder(), decode(), decode(), decode(), decode(), decode(), decode(), decode(), decode(), decode(), decode(), decode_and_check(), decode_bitstring(), decode_default(), decode_implicit(), decode_implicit(), decode_integer_type(), decode_integer_type(), decode_list(), decode_named_bitstring(), decode_null(), decode_octet_aligned_bitstring(), decode_octet_string_bigint(), decode_optional(), decode_optional(), decode_optional_field(), decode_optional_implicit(), decode_optional_octet_aligned_bitstring(), decode_optional_octet_aligned_bitstring(), decode_optional_string(), decode_optional_string(), discard_remaining(), end_cons(), get_next(), get_next_value(), operator=(), operator=(), raw_bytes(), start_cons(), start_context_specific(), start_explicit_context_specific(), start_sequence(), start_set(), verify_end(), verify_end(), and ~BER_Decoder().

◆ BER_Decoder() [2/8]

Botan::BER_Decoder::BER_Decoder	(	std::span< const uint8_t >	buf,
		Limits	limits = Limits::BER() )

explicit

Set up to BER decode the data in buf

Definition at line 659 of file ber_dec.cpp.

                                                                  : m_limits(limits) {
   m_data_src = std::make_unique<DataSource_Memory>(buf);
   m_source = m_data_src.get();
}

References limits().

◆ BER_Decoder() [3/8]

Botan::BER_Decoder::BER_Decoder	(	DataSource &	src,
		Limits	limits = Limits::BER() )

explicit

Set up to BER decode the data in src

Definition at line 654 of file ber_dec.cpp.

654: m_limits(limits), m_source(&src) {}

References limits().

◆ BER_Decoder() [4/8]

BOTAN_FUTURE_EXPLICIT Botan::BER_Decoder::BER_Decoder	(	const BER_Object &	obj,
		Limits	limits = Limits::BER() )

inline

Set up to BER decode the data in obj

Definition at line 166 of file ber_dec.h.

166 :

167 BER_Decoder(obj.data(), limits) {}

References Botan::BER_Decoder::Limits::BER(), BER_Decoder(), BOTAN_FUTURE_EXPLICIT, and limits().

◆ BER_Decoder() [5/8]

BOTAN_FUTURE_EXPLICIT Botan::BER_Decoder::BER_Decoder ( BER_Object && obj )

inline

Set up to BER decode the data in obj TODO(Botan4) remove this?

Definition at line 173 of file ber_dec.h.

173: BER_Decoder(std::move(obj), nullptr) {}

References BER_Decoder(), and BOTAN_FUTURE_EXPLICIT.

◆ BER_Decoder() [6/8]

Botan::BER_Decoder::BER_Decoder	(	BER_Object &&	obj,
		Limits	limits )

Set up to BER decode the data in obj, taking ownership of its contents

Definition at line 646 of file ber_dec.cpp.

                                                        : m_limits(limits) {
   m_data_src = std::make_unique<DataSource_BERObject>(std::move(obj));
   m_source = m_data_src.get();
}

References limits().

◆ BER_Decoder() [7/8]

Botan::BER_Decoder::BER_Decoder ( const BER_Decoder & other )

delete

References BER_Decoder().

◆ BER_Decoder() [8/8]

Botan::BER_Decoder::BER_Decoder ( BER_Decoder && other )

defaultnoexcept

Move constructor

References BER_Decoder().

◆ ~BER_Decoder()

Botan::BER_Decoder::~BER_Decoder ( )

default

References BER_Decoder(), and get_next_value().

Member Function Documentation

◆ decode() [1/10]

BER_Decoder & Botan::BER_Decoder::decode	(	ASN1_Object &	obj,
		ASN1_Type	type_tag = ASN1_Type::NoObject,
		ASN1_Class	class_tag = ASN1_Class::NoObject )

Request an object decode itself from this stream

Parameters

obj	the object to decode into
type_tag	must be NoObject; implicit tagging is not supported here
class_tag	must be NoObject; implicit tagging is not supported here

Definition at line 671 of file ber_dec.cpp.

                                                                                           {
   // TODO support this case properly
   if(type_tag != ASN1_Type::NoObject || class_tag != ASN1_Class::NoObject) {
      throw Not_Implemented("BER_Decoder::decode(ASN1_Object) does not support implicit tagged decoding");
   }
   obj.decode_from(*this);
   return (*this);
}

References BER_Decoder(), decode(), and Botan::NoObject.

◆ decode() [2/10]

BER_Decoder & Botan::BER_Decoder::decode ( BigInt & out )

inline

Decode a BER encoded INTEGER

Definition at line 368 of file ber_dec.h.

368{ return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }

Botan::BER_Decoder::decode

BER_Decoder & decode(bool &out)

Definition ber_dec.h:358

Botan::ASN1_Class::Universal

@ Universal

Definition asn1_obj.h:33

Botan::ASN1_Type::Integer

@ Integer

Definition asn1_obj.h:50

References BER_Decoder(), decode(), Botan::Integer, and Botan::Universal.

Referenced by decode().

◆ decode() [3/10]

BER_Decoder & Botan::BER_Decoder::decode	(	BigInt &	v,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

Decode an INTEGER with an IMPLICIT tagging

Parameters

v	where the value is written
type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 775 of file ber_dec.cpp.

                                                                                      {
   const BER_Object obj = get_next_object();
   obj.assert_is_a(type_tag, class_tag);
 
   // An INTEGER must have at least one content octet (X.690 section 8.3.1)
   if(obj.length() == 0) {
      throw BER_Decoding_Error("INTEGER encoding has no content octets");
   }
 
   // DER requires minimal INTEGER encoding (X.690 section 8.3.2)
   if(m_limits.require_der_encoding()) {
      if(obj.length() > 1) {
         if(obj.bits()[0] == 0x00 && (obj.bits()[1] & 0x80) == 0) {
            throw BER_Decoding_Error("Detected non-minimal INTEGER encoding in DER structure");
         }
         if(obj.bits()[0] == 0xFF && (obj.bits()[1] & 0x80) != 0) {
            throw BER_Decoding_Error("Detected non-minimal INTEGER encoding in DER structure");
         }
      }
   }
 
   out = ASN1::integer_from_contents(obj.data());
 
   return (*this);
}

References Botan::BER_Object::assert_is_a(), BER_Decoder(), Botan::BER_Object::bits(), Botan::BER_Object::data(), get_next_object(), Botan::ASN1::integer_from_contents(), and Botan::BER_Object::length().

◆ decode() [4/10]

BER_Decoder & Botan::BER_Decoder::decode ( bool & out )

inline

Decode a BER encoded BOOLEAN

Definition at line 358 of file ber_dec.h.

358{ return decode(out, ASN1_Type::Boolean, ASN1_Class::Universal); }

Botan::ASN1_Type::Boolean

@ Boolean

Definition asn1_obj.h:49

References BER_Decoder(), Botan::Boolean, decode(), and Botan::Universal.

◆ decode() [5/10]

BER_Decoder & Botan::BER_Decoder::decode	(	bool &	v,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

Decode a BOOLEAN with an IMPLICIT tagging

Parameters

v	where the value is written
type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 702 of file ber_dec.cpp.

                                                                                    {
   const BER_Object obj = get_next_object();
   obj.assert_is_a(type_tag, class_tag);
 
   if(obj.length() != 1) {
      throw BER_Decoding_Error("BER boolean value had invalid size");
   }
 
   const uint8_t val = obj.bits()[0];
 
   // DER requires boolean values to be exactly 0x00 or 0xFF
   if(m_limits.require_der_encoding() && val != 0x00 && val != 0xFF) {
      throw BER_Decoding_Error("Detected non-canonical boolean encoding in DER structure");
   }
 
   out = (val != 0) ? true : false;
 
   return (*this);
}

References Botan::BER_Object::assert_is_a(), BER_Decoder(), Botan::BER_Object::bits(), get_next_object(), and Botan::BER_Object::length().

◆ decode() [6/10]

BER_Decoder & Botan::BER_Decoder::decode	(	secure_vector< uint8_t > &	v,
		ASN1_Type	real_type,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

Decode a BIT STRING or OCTET STRING with an IMPLICIT tagging

Parameters

v	where the contents are written
real_type	either ASN1_Type::OctetString or ASN1_Type::BitString
type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 1018 of file ber_dec.cpp.

                                                       {
   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
   }
 
   asn1_decode_binary_string(buffer, get_next_object(), real_type, type_tag, class_tag, m_limits);
   return (*this);
}

References BER_Decoder(), Botan::BitString, get_next_object(), and Botan::OctetString.

◆ decode() [7/10]

BER_Decoder & Botan::BER_Decoder::decode ( size_t & out )

inline

Decode a small BER encoded INTEGER

Definition at line 363 of file ber_dec.h.

363{ return decode(out, ASN1_Type::Integer, ASN1_Class::Universal); }

References BER_Decoder(), decode(), Botan::Integer, and Botan::Universal.

Referenced by decode().

◆ decode() [8/10]

BER_Decoder & Botan::BER_Decoder::decode	(	size_t &	v,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

Decode a small INTEGER with an IMPLICIT tagging

Parameters

v	where the value is written
type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 725 of file ber_dec.cpp.

                                                                                      {
   BigInt integer;
   decode(integer, type_tag, class_tag);
 
   if(integer.signum() < 0) {
      throw BER_Decoding_Error("Decoded small integer value was negative");
   }
 
   if(integer.bits() > 32) {
      throw BER_Decoding_Error("Decoded integer value larger than expected");
   }
 
   out = 0;
   for(size_t i = 0; i != 4; ++i) {
      out = (out << 8) | integer.byte_at(3 - i);
   }
 
   return (*this);
}

References BER_Decoder(), Botan::BigInt::bits(), Botan::BigInt::byte_at(), decode(), and Botan::BigInt::signum().

◆ decode() [9/10]

BER_Decoder & Botan::BER_Decoder::decode	(	std::vector< uint8_t > &	v,
		ASN1_Type	real_type,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

Decode a BIT STRING or OCTET STRING with an IMPLICIT tagging

Parameters

v	where the contents are written
real_type	either ASN1_Type::OctetString or ASN1_Type::BitString
type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 1030 of file ber_dec.cpp.

                                                       {
   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
      throw BER_Bad_Tag("Bad tag for {BIT,OCTET} STRING", static_cast<uint32_t>(real_type));
   }
 
   asn1_decode_binary_string(buffer, get_next_object(), real_type, type_tag, class_tag, m_limits);
   return (*this);
}

References BER_Decoder(), Botan::BitString, get_next_object(), and Botan::OctetString.

◆ decode() [10/10]

template<typename Alloc>

BER_Decoder & Botan::BER_Decoder::decode	(	std::vector< uint8_t, Alloc > &	out,
		ASN1_Type	real_type )

inline

BER decode a BIT STRING or OCTET STRING

Parameters

out	where the contents are written
real_type	either ASN1_Type::OctetString or ASN1_Type::BitString

Definition at line 386 of file ber_dec.h.

                                                                               {
         return decode(out, real_type, real_type, ASN1_Class::Universal);
      }

References BER_Decoder(), decode(), and Botan::Universal.

◆ decode_and_check()

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_and_check	(	const T &	expected,
		std::string_view	error_msg )

inline

Decode a value and throw unless it equals the expected value

Parameters

expected	the value the encoding must have
error_msg	the message of the exception thrown on a mismatch

Definition at line 701 of file ber_dec.h.

                                                                                 {
         T actual;
         decode(actual);
 
         if(actual != expected) {
            throw Decoding_Error(error_msg);
         }
 
         return (*this);
      }

References BER_Decoder(), and decode().

Referenced by Botan::EC_PrivateKey::EC_PrivateKey(), Botan::OCSP::Response::Response(), Botan::RSA_PrivateKey::RSA_PrivateKey(), and Botan::TLS::Session::Session().

◆ decode_bitstring()

BER_Decoder & Botan::BER_Decoder::decode_bitstring	(	ASN1_BitString &	out,
		ASN1_Type	type_tag = ASN1_Type::BitString,
		ASN1_Class	class_tag = ASN1_Class::Universal )

Decode a BIT STRING, retaining the count of unused bits

Parameters

out	where the value is written
type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 1042 of file ber_dec.cpp.

                                                                                                        {
   const BER_Object obj = get_next_object();
 
   std::vector<uint8_t> bits;
   uint8_t unused_bits = 0;
 
   if(is_constructed(obj.class_tag())) {
      obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
      if(m_limits.require_der_encoding()) {
         throw BER_Decoding_Error("Detected constructed string encoding in DER structure");
      }
      bits.reserve(obj.length());  // upper possible bound on the output size
      unused_bits = asn1_concat_constructed_bit_string(bits, obj, m_limits, 0);
   } else {
      unused_bits = asn1_bitstring_unused_bits(obj, type_tag, class_tag, m_limits.require_der_encoding());
      bits.assign(obj.bits() + 1, obj.bits() + obj.length());
   }
 
   if(unused_bits > 0 && !bits.empty()) {
      bits.back() &= static_cast<uint8_t>(0xFF << unused_bits);
   }
 
   out = ASN1_BitString(std::move(bits), unused_bits);
   return (*this);
}

References Botan::BER_Object::assert_is_a(), BER_Decoder(), Botan::BER_Object::bits(), Botan::BER_Object::class_tag(), Botan::Constructed, get_next_object(), and Botan::BER_Object::length().

Referenced by Botan::Cert_Extension::IPAddressBlocks::IPAddressOrRange< V >::decode_from(), decode_named_bitstring(), and decode_octet_aligned_bitstring().

◆ decode_constrained_integer()

uint64_t Botan::BER_Decoder::decode_constrained_integer	(	ASN1_Type	type_tag,
		ASN1_Class	class_tag,
		size_t	T_bytes )

Decode a non-negative INTEGER that fits in at most T_bytes bytes

Throws BER_Decoding_Error if the value is negative or too large.

Parameters

type_tag	the expected type tag
class_tag	the expected class tag
T_bytes	the maximum size of the value in bytes, at most 8

Definition at line 748 of file ber_dec.cpp.

                                                                                                         {
   if(T_bytes > 8) {
      throw BER_Decoding_Error("Can't decode small integer over 8 bytes");
   }
 
   BigInt integer;
   decode(integer, type_tag, class_tag);
 
   if(integer.is_negative()) {
      throw BER_Decoding_Error("Decoded small integer value was negative");
   }
 
   if(integer.bits() > 8 * T_bytes) {
      throw BER_Decoding_Error("Decoded integer value larger than expected");
   }
 
   uint64_t out = 0;
   for(size_t i = 0; i != 8; ++i) {
      out = (out << 8) | integer.byte_at(7 - i);
   }
 
   return out;
}

References Botan::BigInt::bits(), Botan::BigInt::byte_at(), decode(), and Botan::BigInt::is_negative().

Referenced by decode_integer_type().

◆ decode_default()

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_default	(	T &	out,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag,
		const T &	default_value )

inline

Decode a field carrying an ASN.1 DEFAULT value: if the field is absent out is set to default_value. Unlike decode_optional this is only for fields with a DEFAULT (not bare OPTIONAL fields): when the decoder is configured with Limits::with_default_value_encoding_rejected() and is in DER mode, a field that is present but equal to default_value is rejected, since DER requires such components to be omitted.

Definition at line 569 of file ber_dec.h.

                                                                                                            {
         std::optional<T> optval;
         this->decode_optional(optval, type_tag, class_tag);
         if(optval.has_value()) {
            if(m_limits.require_der_encoding() && m_limits.reject_default_value_encoding() &&
               *optval == default_value) {
               throw BER_Decoding_Error("DER component encoded with its DEFAULT value");
            }
            out = std::move(*optval);
         } else {
            out = default_value;
         }
         return (*this);
      }

References BER_Decoder(), and decode_optional().

◆ decode_implicit() [1/2]

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_implicit	(	BER_Object	obj,
		T &	out,
		ASN1_Type	real_type,
		ASN1_Class	real_class )

inline

Decode an already-extracted BER_Object as if its tag were real_type/real_class. Used to consume IMPLICIT-tagged values whose body matches a different universal type (e.g. a context-specific [8] body that should be parsed as an OID).

Definition at line 640 of file ber_dec.h.

                                                                                                       {
         obj.set_tagging(real_type, real_class);
         push_back(std::move(obj));
         if constexpr(std::is_base_of_v<ASN1_Object, T>) {
            // The object was re-tagged above; decode_from checks the real tag itself
            return decode(out);
         } else {
            return decode(out, real_type, real_class);
         }
      }

References BER_Decoder(), decode(), and push_back().

Referenced by Botan::AlternativeName::decode_from(), Botan::Cert_Extension::CRL_Distribution_Points::Distribution_Point::decode_from(), Botan::Cert_Extension::DistributionPointName::decode_from(), decode_implicit(), and decode_optional_implicit().

◆ decode_implicit() [2/2]

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_implicit	(	T &	out,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag,
		ASN1_Type	real_type,
		ASN1_Class	real_class )

inline

Read the next object, requiring it be tagged type_tag/class_tag, and decode it as if its tag were real_type/real_class.

Parameters

out	where the value is written
type_tag	the expected type tag
class_tag	the expected class tag
real_type	the type tag the contents should be parsed as
real_class	the class tag the contents should be parsed as

Definition at line 662 of file ber_dec.h.

                                                                                                       {
         BER_Object obj = get_next_object();
         obj.assert_is_a(type_tag, class_tag);
         return decode_implicit(std::move(obj), out, real_type, real_class);
      }

References Botan::BER_Object::assert_is_a(), BER_Decoder(), decode_implicit(), and get_next_object().

◆ decode_integer_type() [1/2]

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_integer_type ( T & out )

inline

Decode an INTEGER into an integral type, throwing if it does not fit

Parameters

out	where the value is written

Definition at line 526 of file ber_dec.h.

                                               {
         return decode_integer_type<T>(out, ASN1_Type::Integer, ASN1_Class::Universal);
      }

References BER_Decoder(), decode_integer_type(), Botan::Integer, and Botan::Universal.

Referenced by decode_integer_type(), and Botan::TLS::Session::Session().

◆ decode_integer_type() [2/2]

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_integer_type	(	T &	out,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

inline

Decode an INTEGER with an IMPLICIT tagging into an integral type, throwing if it does not fit

Parameters

out	where the value is written
type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 539 of file ber_dec.h.

                                                                                                                   {
         out = static_cast<T>(decode_constrained_integer(type_tag, class_tag, sizeof(out)));
         return (*this);
      }

References BER_Decoder(), Botan::ContextSpecific, and decode_constrained_integer().

◆ decode_list()

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_list	(	std::vector< T > &	vec,
		ASN1_Type	type_tag = ASN1_Type::Sequence,
		ASN1_Class	class_tag = ASN1_Class::Universal )

Decode a constructed object containing a list of homogeneously typed values

Parameters

vec	where the values are appended
type_tag	the expected type tag of the constructed object
class_tag	the expected class tag of the constructed object

Decode a list of homogeneously typed values

Definition at line 880 of file ber_dec.h.

                                                                                                 {
   BER_Decoder list = start_cons(type_tag, class_tag);
 
   while(list.more_items()) {
      T value;
      list.decode(value);
      vec.push_back(std::move(value));
   }
 
   list.end_cons();
 
   return (*this);
}

References BER_Decoder(), decode(), end_cons(), more_items(), push_back(), and start_cons().

Referenced by Botan::Cert_Extension::ASBlocks::ASIdentifierChoice::decode_from(), Botan::Cert_Extension::IPAddressBlocks::IPAddressChoice< V >::decode_from(), decode_optional_list(), Botan::OCSP::Response::Response(), and Botan::TLS::Session::Session().

◆ decode_named_bitstring()

BER_Decoder & Botan::BER_Decoder::decode_named_bitstring	(	uint64_t &	bits,
		size_t	width,
		ASN1_Type	type_tag = ASN1_Type::BitString,
		ASN1_Class	class_tag = ASN1_Class::Universal )

Decode a BIT STRING that is actually a bit set, such as X.509 KeyUsage

The first bit of the encoding becomes the most significant of the width bits of bits. Throws if more than width bits are encoded, or in DER mode if the encoding is not minimal (ie the final bit is unset).

Parameters

bits	where the bit set is written
width	the number of named bits, at most 64
type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 1068 of file ber_dec.cpp.

                                                                       {
   if(width > 64) {
      throw Invalid_Argument("BER_Decoder: Named BIT STRING width is too large");
   }
 
   ASN1_BitString bits;
   decode_bitstring(bits, type_tag, class_tag);
 
   if(bits.bit_length() > width) {
      throw BER_Decoding_Error("Named BIT STRING exceeds declared width");
   }
 
   if(m_limits.require_der_encoding() && bits.bit_length() > 0 && !bits.bit_at(bits.bit_length() - 1)) {
      throw BER_Decoding_Error("Named BIT STRING is not minimally encoded");
   }
 
   uint64_t decoded = 0;
   for(size_t bit = 0; bit != bits.bit_length(); ++bit) {
      if(bits.bit_at(bit)) {
         decoded |= uint64_t(1) << (width - 1 - bit);
      }
   }
 
   out = decoded;
   return (*this);
}

References BER_Decoder(), Botan::ASN1_BitString::bit_at(), Botan::ASN1_BitString::bit_length(), and decode_bitstring().

◆ decode_null()

BER_Decoder & Botan::BER_Decoder::decode_null ( )

Decode a BER encoded NULL, throwing if the next object is anything else

Definition at line 683 of file ber_dec.cpp.

                                      {
   const BER_Object obj = get_next_object();
   obj.assert_is_a(ASN1_Type::Null, ASN1_Class::Universal);
   if(obj.length() > 0) {
      throw BER_Decoding_Error("NULL object had nonzero size");
   }
   return (*this);
}

References Botan::BER_Object::assert_is_a(), BER_Decoder(), get_next_object(), Botan::BER_Object::length(), Botan::Null, and Botan::Universal.

Referenced by Botan::Cert_Extension::ASBlocks::ASIdentifierChoice::decode_from(), and Botan::Cert_Extension::IPAddressBlocks::IPAddressChoice< V >::decode_from().

◆ decode_octet_aligned_bitstring()

template<typename Alloc>

BER_Decoder & Botan::BER_Decoder::decode_octet_aligned_bitstring	(	std::vector< uint8_t, Alloc > &	out,
		ASN1_Type	type_tag = ASN1_Type::BitString,
		ASN1_Class	class_tag = ASN1_Class::Universal )

inline

Decode a BIT STRING, throwing unless it has no unused bits

Parameters

out	where the bits are written
type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 462 of file ber_dec.h.

                                                                                            {
         ASN1_BitString bits;
         decode_bitstring(bits, type_tag, class_tag);
 
         if(bits.unused_bits() != 0) {
            throw Decoding_Error("Expected octet-aligned BIT STRING");
         }
 
         out.assign(bits.bytes().begin(), bits.bytes().end());
         return (*this);
      }

References BER_Decoder(), Botan::BitString, Botan::ASN1_BitString::bytes(), decode_bitstring(), Botan::Universal, and Botan::ASN1_BitString::unused_bits().

Referenced by Botan::X509_Object::decode_from(), decode_optional_octet_aligned_bitstring(), Botan::X509::load_key(), and Botan::OCSP::Response::Response().

◆ decode_octet_string_bigint()

BER_Decoder & Botan::BER_Decoder::decode_octet_string_bigint ( BigInt & b )

Decode an integer value which is typed as an octet string

Definition at line 692 of file ber_dec.cpp.

                                                                {
   secure_vector<uint8_t> out_vec;
   decode(out_vec, ASN1_Type::OctetString);
   out = BigInt::from_bytes(out_vec);
   return (*this);
}

References BER_Decoder(), decode(), Botan::BigInt::from_bytes(), and Botan::OctetString.

◆ decode_optional() [1/2]

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_optional	(	std::optional< T > &	optval,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag )

Decode an OPTIONAL field, setting optval to nullopt if absent

Parameters

optval	where the value is written
type_tag	the expected type tag
class_tag	the expected class tag

Decode an OPTIONAL or DEFAULT element

Definition at line 827 of file ber_dec.h.

                                                                                                          {
   BER_Object obj = get_next_object();
 
   if(obj.is_a(type_tag, class_tag)) {
      T out{};
      if(class_tag == ASN1_Class::ExplicitContextSpecific) {
         BER_Decoder(obj, m_limits).decode(out).verify_end();
      } else {
         this->push_back(std::move(obj));
         if constexpr(std::is_base_of_v<ASN1_Object, T>) {
            // Object types check the tag in decode_from; a re-tagging
            // implicit override of an object is not supported here
            this->decode(out);
         } else {
            this->decode(out, type_tag, class_tag);
         }
      }
      optval = std::move(out);
   } else {
      this->push_back(std::move(obj));
      optval = std::nullopt;
   }
 
   return (*this);
}

References BER_Decoder(), decode(), Botan::ExplicitContextSpecific, get_next_object(), Botan::BER_Object::is_a(), and push_back().

◆ decode_optional() [2/2]

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_optional	(	T &	out,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag,
		const T &	default_value = T() )

inline

Decode an OPTIONAL field, setting out to default_value if absent

Parameters

out	where the value is written
type_tag	the expected type tag
class_tag	the expected class tag
default_value	the value used if the field is not present

Definition at line 553 of file ber_dec.h.

                                                                                                                 {
         std::optional<T> optval;
         this->decode_optional(optval, type_tag, class_tag);
         out = optval ? *optval : default_value;
         return (*this);
      }

References BER_Decoder(), and decode_optional().

Referenced by decode_default(), Botan::Extensions::decode_from(), Botan::GeneralSubtree::decode_from(), Botan::OCSP::SingleResponse::decode_from(), decode_optional(), and Botan::OCSP::Response::Response().

◆ decode_optional_field()

template<typename F>

BER_Decoder & Botan::BER_Decoder::decode_optional_field	(	uint32_t	tag_no,
		ASN1_Class	class_tag,
		F &&	fn )

inline

Decode an OPTIONAL field identified by a context-specific tag number.

If the next object is tagged [tag_no] with class class_tag, fn is invoked to decode it (fn must consume exactly that object). Otherwise the stream is left unchanged and fn is not called.

For a SEQUENCE of optional tagged fields that (per DER) appear at most once and in increasing tag order: call this once per field in tag order, then end_cons(), which rejects any unconsumed object (i.e. a duplicate, out-of-order, or unknown-tag field).

Definition at line 626 of file ber_dec.h.

                                                                                        {
         if(peek_next_object().is_a(tag_no, class_tag)) {
            std::forward<F>(fn)(*this);
         }
         return (*this);
      }

References BER_Decoder(), and peek_next_object().

Referenced by Botan::Cert_Extension::CRL_Distribution_Points::Distribution_Point::decode_from().

◆ decode_optional_implicit()

template<typename T>

BER_Decoder & Botan::BER_Decoder::decode_optional_implicit	(	T &	out,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag,
		ASN1_Type	real_type,
		ASN1_Class	real_class,
		const T &	default_value = T() )

Decode an OPTIONAL IMPLICIT tagged field, setting out to default_value if absent

Parameters

out	where the value is written
type_tag	the expected type tag
class_tag	the expected class tag
real_type	the type tag the contents should be parsed as
real_class	the class tag the contents should be parsed as
default_value	the value used if the field is not present

Decode an OPTIONAL or DEFAULT element with an IMPLICIT tagging

Definition at line 857 of file ber_dec.h.

                                                                           {
   BER_Object obj = get_next_object();
 
   if(obj.is_a(type_tag, class_tag)) {
      decode_implicit(std::move(obj), out, real_type, real_class);
   } else {
      // Not what we wanted, push it back on the stream
      out = default_value;
      push_back(std::move(obj));
   }
 
   return (*this);
}

References BER_Decoder(), decode_implicit(), get_next_object(), Botan::BER_Object::is_a(), and push_back().

◆ decode_optional_list()

template<typename T>

bool Botan::BER_Decoder::decode_optional_list	(	std::vector< T > &	vec,
		ASN1_Type	type_tag = ASN1_Type::Sequence,
		ASN1_Class	class_tag = ASN1_Class::Universal )

Decode a list of homogeneously typed values if one is present

Parameters

vec	where the values are appended
type_tag	the expected type tag of the constructed object
class_tag	the expected class tag of the constructed object

Returns: true if the list was present

Decode an optional list of homogeneously typed values

Definition at line 898 of file ber_dec.h.

                                                                                                  {
   if(peek_next_object().is_a(type_tag, class_tag)) {
      decode_list(vec, type_tag, class_tag);
      return true;
   }
 
   return false;
}

References decode_list(), and peek_next_object().

◆ decode_optional_octet_aligned_bitstring() [1/2]

template<typename Alloc>

BER_Decoder & Botan::BER_Decoder::decode_optional_octet_aligned_bitstring	(	std::vector< uint8_t, Alloc > &	out,
		ASN1_Type	expected_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

inline

Decode an OPTIONAL BIT STRING with no unused bits, clearing out if it is absent

Parameters

out	where the bits are written
expected_tag	the expected type tag
class_tag	the expected class tag

Definition at line 800 of file ber_dec.h.

                                                                                                           {
         return decode_optional_octet_aligned_bitstring(out, static_cast<uint32_t>(expected_tag), class_tag);
      }

References BER_Decoder(), Botan::ContextSpecific, and decode_optional_octet_aligned_bitstring().

◆ decode_optional_octet_aligned_bitstring() [2/2]

template<typename Alloc>

BER_Decoder & Botan::BER_Decoder::decode_optional_octet_aligned_bitstring	(	std::vector< uint8_t, Alloc > &	out,
		uint32_t	expected_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

inline

Decode an OPTIONAL BIT STRING with no unused bits, clearing out if it is absent

Parameters

out	where the bits are written
expected_tag	the expected tag number
class_tag	the expected class tag

Definition at line 769 of file ber_dec.h.

                                                                                                           {
         BER_Object obj = get_next_object();
 
         const ASN1_Type type_tag = static_cast<ASN1_Type>(expected_tag);
 
         if(obj.is_a(type_tag, class_tag)) {
            if(class_tag == ASN1_Class::ExplicitContextSpecific) {
               BER_Decoder(obj, m_limits).decode_octet_aligned_bitstring(out).verify_end();
            } else {
               push_back(std::move(obj));
               decode_octet_aligned_bitstring(out, type_tag, class_tag);
            }
         } else {
            out.clear();
            push_back(std::move(obj));
         }
 
         return (*this);
      }

References BER_Decoder(), Botan::ContextSpecific, decode_octet_aligned_bitstring(), Botan::ExplicitContextSpecific, get_next_object(), Botan::BER_Object::is_a(), and push_back().

Referenced by decode_optional_octet_aligned_bitstring().

◆ decode_optional_string() [1/2]

template<typename Alloc>

BER_Decoder & Botan::BER_Decoder::decode_optional_string	(	std::vector< uint8_t, Alloc > &	out,
		ASN1_Type	real_type,
		ASN1_Type	expected_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

inline

Decode an OPTIONAL string type, clearing out if it is absent

Parameters

out	where the contents are written
real_type	the type tag the contents should be parsed as
expected_tag	the expected type tag
class_tag	the expected class tag

Definition at line 753 of file ber_dec.h.

                                                                                          {
         return decode_optional_string(out, real_type, static_cast<uint32_t>(expected_tag), class_tag);
      }

References BER_Decoder(), Botan::ContextSpecific, and decode_optional_string().

◆ decode_optional_string() [2/2]

template<typename Alloc>

BER_Decoder & Botan::BER_Decoder::decode_optional_string	(	std::vector< uint8_t, Alloc > &	out,
		ASN1_Type	real_type,
		uint32_t	expected_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

inline

Decode an OPTIONAL string type, clearing out if it is absent

Parameters

out	where the contents are written
real_type	the type tag the contents should be parsed as
expected_tag	the expected tag number
class_tag	the expected class tag

Definition at line 721 of file ber_dec.h.

                                                                                          {
         BER_Object obj = get_next_object();
 
         const ASN1_Type type_tag = static_cast<ASN1_Type>(expected_tag);
 
         if(obj.is_a(type_tag, class_tag)) {
            if(class_tag == ASN1_Class::ExplicitContextSpecific) {
               BER_Decoder(obj, m_limits).decode(out, real_type).verify_end();
            } else {
               push_back(std::move(obj));
               decode(out, real_type, type_tag, class_tag);
            }
         } else {
            out.clear();
            push_back(std::move(obj));
         }
 
         return (*this);
      }

References BER_Decoder(), Botan::ContextSpecific, decode(), Botan::ExplicitContextSpecific, get_next_object(), Botan::BER_Object::is_a(), and push_back().

Referenced by decode_optional_string(), and Botan::OCSP::Response::Response().

◆ discard_remaining()

BER_Decoder & Botan::BER_Decoder::discard_remaining ( )

Discard any data that remains unread Returns (*this)

Definition at line 488 of file ber_dec.cpp.

                                            {
   m_pushed = BER_Object();
   uint8_t buf = 0;
   while(m_source->read_byte(buf) != 0) {}
   return (*this);
}

References BER_Decoder().

Referenced by Botan::Ed25519_PrivateKey::Ed25519_PrivateKey(), and Botan::X25519_PrivateKey::X25519_PrivateKey().

◆ end_cons()

BER_Decoder & Botan::BER_Decoder::end_cons ( )

Finish decoding a constructed data, throws if any data remains. Returns the parent of *this (ie the object on which start_cons was called).

Definition at line 630 of file ber_dec.cpp.

                                   {
   if(m_parent == nullptr) {
      throw Invalid_State("BER_Decoder::end_cons called with null parent");
   }
   if(!m_source->end_of_data() || m_pushed.is_set()) {
      throw Decoding_Error("BER_Decoder::end_cons called with data left");
   }
   return (*m_parent);
}

References BER_Decoder().

◆ get_next()

BER_Decoder & Botan::BER_Decoder::get_next ( BER_Object & ber )

inline

Get the next object in the data stream, storing it in ber

If EOF, ber is set to an object with type NO_OBJECT.

Definition at line 210 of file ber_dec.h.

                                             {
         ber = get_next_object();
         return (*this);
      }

References BER_Decoder(), and get_next_object().

Referenced by Botan::OCSP::SingleResponse::decode_from().

◆ get_next_object()

BER_Object Botan::BER_Decoder::get_next_object ( )

Get the next object in the data stream. If EOF, returns an object with type NO_OBJECT.

Definition at line 516 of file ber_dec.cpp.

                                        {
   BER_Object next;
 
   if(m_pushed.is_set()) {
      std::swap(next, m_pushed);
      return next;
   }
 
   for(;;) {
      ASN1_Type type_tag = ASN1_Type::NoObject;
      ASN1_Class class_tag = ASN1_Class::NoObject;
      decode_tag(m_source, type_tag, class_tag);
      next.set_tagging(type_tag, class_tag);
      if(next.is_set() == false) {  // no more objects
         return next;
      }
 
      const size_t allow_indef = m_limits.allow_ber_encoding() ? m_limits.max_nested_indefinite_length() : 0;
      const bool der_mode = m_limits.require_der_encoding();
      const auto dl = decode_length(m_source, allow_indef, der_mode, is_constructed(class_tag));
 
      // Per X.690 8.1.5 the only valid EOC encoding is the two-octet
      // sequence 0x00 0x00. Reject any other length encoding on a tag of
      // (Eoc, Universal) before we consume the "content" bytes.
      if(type_tag == ASN1_Type::Eoc && class_tag == ASN1_Class::Universal &&
         (dl.content_length() != 0 || dl.indefinite_length())) {
         throw BER_Decoding_Error("EOC marker with non-zero length");
      }
 
      if(const auto max_size = m_limits.max_object_size(); max_size && dl.content_length() > *max_size) {
         throw BER_Decoding_Error("Encoded object exceeds maximum size");
      }
 
      if(!m_source->check_available(dl.total_length())) {
         throw BER_Decoding_Error("Value truncated");
      }
 
      uint8_t* out = next.mutable_bits(dl.content_length());
      if(m_source->read(out, dl.content_length()) != dl.content_length()) {
         throw BER_Decoding_Error("Value truncated");
      }
 
      if(dl.indefinite_length()) {
         // After reading the data consume the 2-byte EOC
         uint8_t eoc[2] = {0xFF, 0xFF};
         if(m_source->read(eoc, 2) != 2 || eoc[0] != 0x00 || eoc[1] != 0x00) {
            throw BER_Decoding_Error("Missing or malformed EOC marker");
         }
      }
 
      if(next.tagging() == static_cast<uint32_t>(ASN1_Type::Eoc)) {
         if(m_limits.require_der_encoding()) {
            throw BER_Decoding_Error("Detected EOC marker in DER structure");
         }
         // An EOC marker is only valid as an indefinite-length terminator, which
         // is consumed above when reading the indefinite-length object. A
         // standalone EOC is rejected unless the caller opted to tolerate it.
         if(m_limits.allow_standalone_eoc()) {
            continue;
         }
         throw BER_Decoding_Error("Encountered EOC marker outside of indefinite-length encoding");
      }
 
      break;
   }
 
   return next;
}

References Botan::Eoc, Botan::BER_Object::is_set(), Botan::NoObject, Botan::BER_Object::tagging(), and Botan::Universal.

Referenced by decode(), decode(), decode(), decode(), decode_bitstring(), Botan::AlternativeName::decode_from(), Botan::ASN1_String::decode_from(), Botan::ASN1_Time::decode_from(), Botan::Cert_Extension::ASBlocks::ASIdentifiers::decode_from(), Botan::Cert_Extension::TNAuthList::Entry::decode_from(), Botan::GeneralName::decode_from(), Botan::OID::decode_from(), decode_implicit(), decode_null(), decode_optional(), decode_optional_implicit(), decode_optional_octet_aligned_bitstring(), decode_optional_string(), get_next(), peek_next_object(), Botan::OCSP::Response::Response(), and start_cons().

◆ get_next_octet_string()

std::vector< uint8_t > Botan::BER_Decoder::get_next_octet_string ( )

inline

Decode the next object as an OCTET STRING and return its contents

Definition at line 373 of file ber_dec.h.

                                                 {
         std::vector<uint8_t> out_vec;
         decode(out_vec, ASN1_Type::OctetString);
         return out_vec;
      }

References decode(), and Botan::OctetString.

Referenced by Botan::OCSP::Response::Response().

◆ get_next_value()

template<typename T>
requires std::is_standard_layout_v<T> && std::is_trivial_v<T>

BER_Decoder & Botan::BER_Decoder::get_next_value	(	T &	out,
		ASN1_Type	type_tag,
		ASN1_Class	class_tag = ASN1_Class::ContextSpecific )

inline

Get next object and copy value to POD type Asserts value length is equal to POD type sizeof. Asserts Type tag and optional Class tag according to parameters. Copy value to POD type (struct, union, C-style array, std::array, etc.).

Parameters

out	POD type reference where to copy object value
type_tag	ASN1_Type enum to assert type on object read
class_tag	ASN1_Type enum to assert class on object read (default: CONTEXT_SPECIFIC)

Returns: this reference

Definition at line 322 of file ber_dec.h.

      {
         const BER_Object obj = get_next_value(sizeof(T), type_tag, class_tag);
 
         std::memcpy(reinterpret_cast<uint8_t*>(&out), obj.bits(), obj.length());
 
         return (*this);
      }

References BER_Decoder(), Botan::BER_Object::bits(), Botan::ContextSpecific, get_next_value(), and Botan::BER_Object::length().

Referenced by get_next_value(), and ~BER_Decoder().

◆ limits()

Limits Botan::BER_Decoder::limits ( ) const

inline

Returns the limits currently applied to this decoder

Definition at line 197 of file ber_dec.h.

197{ return m_limits; }

References limits().

Referenced by BER_Decoder(), BER_Decoder(), BER_Decoder(), BER_Decoder(), BER_Decoder(), Botan::AlternativeName::decode_from(), Botan::Cert_Extension::ASBlocks::ASIdentifiers::decode_from(), Botan::Cert_Extension::TNAuthList::Entry::decode_from(), Botan::GeneralName::decode_from(), Botan::X509_DN::decode_from(), and limits().

◆ more_items()

bool Botan::BER_Decoder::more_items ( ) const

Return true if there is at least one more item remaining

Definition at line 461 of file ber_dec.cpp.

                                   {
   if(m_source->end_of_data() && !m_pushed.is_set()) {
      return false;
   }
   return true;
}

Referenced by Botan::AlternativeName::decode_from(), Botan::Cert_Extension::TNAuthList::Entry::decode_from(), Botan::CRL_Entry::decode_from(), Botan::Extensions::decode_from(), Botan::X509_DN::decode_from(), decode_list(), Botan::PKCS12::PKCS12(), and Botan::OCSP::Response::Response().

◆ operator=() [1/2]

BER_Decoder & Botan::BER_Decoder::operator= ( BER_Decoder && )

defaultnoexcept

Move assignment

References BER_Decoder().

◆ operator=() [2/2]

BER_Decoder & Botan::BER_Decoder::operator= ( const BER_Decoder & )

delete

References BER_Decoder().

◆ peek_next_object()

const BER_Object & Botan::BER_Decoder::peek_next_object ( )

Peek at the next object without removing it from the stream

If an object has been pushed, then it returns that object. Otherwise it reads the next object and pushes it. Thus, a you call peek_next_object followed by push_back without a subsequent read, it will fail.

Definition at line 505 of file ber_dec.cpp.

                                                {
   if(!m_pushed.is_set()) {
      m_pushed = get_next_object();
   }
 
   return m_pushed;
}

References get_next_object().

Referenced by Botan::Cert_Extension::ASBlocks::ASIdentifierChoice::decode_from(), Botan::Cert_Extension::ASBlocks::ASIdentifiers::decode_from(), Botan::Cert_Extension::ASBlocks::ASIdOrRange::decode_from(), Botan::Cert_Extension::DistributionPointName::decode_from(), Botan::Cert_Extension::IPAddressBlocks::IPAddressChoice< V >::decode_from(), Botan::Cert_Extension::IPAddressBlocks::IPAddressFamily::decode_from(), Botan::Cert_Extension::IPAddressBlocks::IPAddressOrRange< V >::decode_from(), Botan::OCSP::SingleResponse::decode_from(), decode_optional_field(), and decode_optional_list().

◆ push_back() [1/2]

void Botan::BER_Decoder::push_back ( BER_Object && obj )

Push an object back onto the stream. Throws if another object was previously pushed and has not been subsequently read out.

Definition at line 607 of file ber_dec.cpp.

                                            {
   if(m_pushed.is_set()) {
      throw Invalid_State("BER_Decoder: Only one push back is allowed");
   }
   m_pushed = std::move(obj);
}

◆ push_back() [2/2]

void Botan::BER_Decoder::push_back ( const BER_Object & obj )

Push an object back onto the stream. Throws if another object was previously pushed and has not been subsequently read out.

Definition at line 600 of file ber_dec.cpp.

                                                 {
   if(m_pushed.is_set()) {
      throw Invalid_State("BER_Decoder: Only one push back is allowed");
   }
   m_pushed = obj;
}

Referenced by decode_implicit(), decode_list(), decode_optional(), decode_optional_implicit(), decode_optional_octet_aligned_bitstring(), decode_optional_string(), Botan::GOST_3410_PublicKey::GOST_3410_PublicKey(), and Botan::McEliece_PrivateKey::McEliece_PrivateKey().

◆ raw_bytes()

template<typename Alloc>

BER_Decoder & Botan::BER_Decoder::raw_bytes ( std::vector< uint8_t, Alloc > & out )

inline

Save all the bytes remaining in the source

Parameters

out	where the remaining bytes are written

Definition at line 338 of file ber_dec.h.

                                                             {
         out.clear();
         for(;;) {
            if(auto next = this->read_next_byte()) {
               out.push_back(*next);
            } else {
               break;
            }
         }
         return (*this);
      }

References BER_Decoder().

Referenced by Botan::AlgorithmIdentifier::decode_from(), Botan::Attribute::decode_from(), Botan::X509_DN::decode_from(), Botan::X509_Object::decode_from(), and Botan::OCSP::Response::Response().

◆ start_cons()

BER_Decoder Botan::BER_Decoder::start_cons	(	ASN1_Type	type_tag,
		ASN1_Class	class_tag )

Start decoding a constructed object, returning a decoder for its contents. The returned decoder must be closed with end_cons().

Parameters

type_tag	the expected type tag
class_tag	the expected class tag

Definition at line 614 of file ber_dec.cpp.

                                                                            {
   BER_Object obj = get_next_object();
   obj.assert_is_a(type_tag, class_tag | ASN1_Class::Constructed);
 
   // In DER mode the elements of a universal SET must appear in sorted order
   if(m_limits.require_der_encoding() && type_tag == ASN1_Type::Set && class_tag == ASN1_Class::Universal) {
      verify_set_is_sorted(std::span<const uint8_t>{obj.bits(), obj.length()});
   }
 
   BER_Decoder child(std::move(obj), this);
   return child;
}

References Botan::BER_Object::assert_is_a(), BER_Decoder(), Botan::BER_Object::bits(), Botan::Constructed, get_next_object(), Botan::BER_Object::length(), Botan::Set, and Botan::Universal.

Referenced by decode_list(), start_context_specific(), start_explicit_context_specific(), start_sequence(), and start_set().

◆ start_context_specific()

BER_Decoder Botan::BER_Decoder::start_context_specific ( uint32_t tag )

inline

Start decoding an IMPLICIT context specific constructed object, returning a decoder for its contents. The returned decoder must be closed with end_cons().

Parameters

tag	the expected context specific tag number

Definition at line 290 of file ber_dec.h.

                                                       {
         return start_cons(ASN1_Type(tag), ASN1_Class::ContextSpecific);
      }

References BER_Decoder(), Botan::ContextSpecific, and start_cons().

Referenced by Botan::Cert_Extension::CRL_Distribution_Points::Distribution_Point::decode_from(), Botan::OCSP::SingleResponse::decode_from(), Botan::PKCS12::PKCS12(), and Botan::OCSP::Response::Response().

◆ start_explicit_context_specific()

BER_Decoder Botan::BER_Decoder::start_explicit_context_specific ( uint32_t tag )

inline

Start decoding an EXPLICIT context specific constructed object, returning a decoder for its contents. The returned decoder must be closed with end_cons().

Parameters

tag	the expected context specific tag number

Definition at line 301 of file ber_dec.h.

                                                                {
         return start_cons(ASN1_Type(tag), ASN1_Class::ExplicitContextSpecific);
      }

References BER_Decoder(), Botan::ExplicitContextSpecific, and start_cons().

◆ start_sequence()

BER_Decoder Botan::BER_Decoder::start_sequence ( )

inline

Start decoding a SEQUENCE, returning a decoder for its contents. The returned decoder must be closed with end_cons().

Definition at line 275 of file ber_dec.h.

275{ return start_cons(ASN1_Type::Sequence, ASN1_Class::Universal); }

Botan::ASN1_Type::Sequence

@ Sequence

Definition asn1_obj.h:56

References BER_Decoder(), Botan::Sequence, start_cons(), and Botan::Universal.

◆ start_set()

BER_Decoder Botan::BER_Decoder::start_set ( )

inline

Start decoding a SET, returning a decoder for its contents. The returned decoder must be closed with end_cons().

Definition at line 281 of file ber_dec.h.

281{ return start_cons(ASN1_Type::Set, ASN1_Class::Universal); }

References BER_Decoder(), Botan::Set, start_cons(), and Botan::Universal.

Referenced by Botan::Attribute::decode_from(), and Botan::X509_DN::decode_from().

◆ verify_end() [1/2]

BER_Decoder & Botan::BER_Decoder::verify_end ( )

Verify the stream is concluded, throws otherwise. Returns (*this)

Definition at line 471 of file ber_dec.cpp.

                                     {
   return verify_end("BER_Decoder::verify_end called, but data remains");
}

References BER_Decoder(), and verify_end().

Referenced by Botan::AlternativeName::decode_from(), Botan::Cert_Extension::ASBlocks::ASIdentifiers::decode_from(), Botan::Cert_Extension::CRL_Distribution_Points::Distribution_Point::decode_from(), Botan::Cert_Extension::TNAuthList::Entry::decode_from(), Botan::Extensions::decode_from(), Botan::GeneralName::decode_from(), Botan::OCSP::SingleResponse::decode_from(), Botan::Ed448_PrivateKey::Ed448_PrivateKey(), Botan::GOST_3410_PublicKey::GOST_3410_PublicKey(), Botan::X509::load_key(), Botan::McEliece_PrivateKey::McEliece_PrivateKey(), Botan::McEliece_PublicKey::McEliece_PublicKey(), Botan::pbes2_decrypt(), Botan::PKCS12::PKCS12(), Botan::pkcs12_pbe_decrypt(), Botan::PSS_Params::PSS_Params(), Botan::OCSP::Response::Response(), Botan::RSA_PublicKey::RSA_PublicKey(), and verify_end().

◆ verify_end() [2/2]

BER_Decoder & Botan::BER_Decoder::verify_end ( std::string_view err_msg )

Verify the stream is concluded, throws otherwise. Returns (*this)

Definition at line 478 of file ber_dec.cpp.

                                                       {
   if(!m_source->end_of_data() || m_pushed.is_set()) {
      throw Decoding_Error(err);
   }
   return (*this);
}

References BER_Decoder().

The documentation for this class was generated from the following files:

src/lib/asn1/ber_dec.h
src/lib/asn1/ber_dec.cpp

Classes

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ BER_Decoder() [1/8]

◆ BER_Decoder() [2/8]

◆ BER_Decoder() [3/8]

◆ BER_Decoder() [4/8]

◆ BER_Decoder() [5/8]

◆ BER_Decoder() [6/8]

◆ BER_Decoder() [7/8]

◆ BER_Decoder() [8/8]

◆ ~BER_Decoder()

Member Function Documentation

◆ decode() [1/10]

◆ decode() [2/10]

◆ decode() [3/10]

◆ decode() [4/10]

◆ decode() [5/10]

◆ decode() [6/10]

◆ decode() [7/10]

◆ decode() [8/10]

◆ decode() [9/10]

◆ decode() [10/10]

◆ decode_and_check()

◆ decode_bitstring()

◆ decode_constrained_integer()

◆ decode_default()

◆ decode_implicit() [1/2]

◆ decode_implicit() [2/2]

◆ decode_integer_type() [1/2]

◆ decode_integer_type() [2/2]

◆ decode_list()

◆ decode_named_bitstring()

◆ decode_null()

◆ decode_octet_aligned_bitstring()

◆ decode_octet_string_bigint()

◆ decode_optional() [1/2]

◆ decode_optional() [2/2]

◆ decode_optional_field()

◆ decode_optional_implicit()

◆ decode_optional_list()

◆ decode_optional_octet_aligned_bitstring() [1/2]

◆ decode_optional_octet_aligned_bitstring() [2/2]

◆ decode_optional_string() [1/2]

◆ decode_optional_string() [2/2]

◆ discard_remaining()

◆ end_cons()

◆ get_next()

◆ get_next_object()

◆ get_next_octet_string()

◆ get_next_value()

◆ limits()

◆ more_items()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ peek_next_object()

◆ push_back() [1/2]

◆ push_back() [2/2]

◆ raw_bytes()

◆ start_cons()

◆ start_context_specific()

◆ start_explicit_context_specific()

◆ start_sequence()

◆ start_set()

◆ verify_end() [1/2]

◆ verify_end() [2/2]