Botan::ASN1 Namespace Reference

Functions
std::vector< uint8_t >	der_sequence_header (size_t contents_len)
std::vector< uint8_t >	integer_contents (const BigInt &n)
BigInt	integer_from_contents (std::span< const uint8_t > contents)
bool	is_der_sequence_header (std::span< const uint8_t > bytes)
bool	is_single_der_object (std::span< const uint8_t > bytes, ASN1_Type expected_type, ASN1_Class expected_class)
bool	maybe_BER (DataSource &source)
std::vector< uint8_t >	put_in_sequence (const std::vector< uint8_t > &contents)
std::vector< uint8_t >	put_in_sequence (const uint8_t bits[], size_t len)
std::string	to_string (const BER_Object &obj)

Function Documentation

der_sequence_header()

std::vector< uint8_t > Botan::ASN1::der_sequence_header

(

size_t

contents_len

)

Return the DER tag and length header of a SEQUENCE with the given contents length

Parameters

contents_len

the length in bytes of the SEQUENCE contents

Definition at line 71 of file der_enc.cpp.

                                                            {
   std::vector<uint8_t> header;
   header.reserve(2 + sizeof(contents_len));
   encode_tag(header, ASN1_Type::Sequence, ASN1_Class::Constructed);
   encode_length(header, contents_len);
   return header;
}

References Botan::Constructed, and Botan::Sequence.

Referenced by put_in_sequence(), Botan::OCSP::Response::verify_signature(), and Botan::X509_Object::verify_signature().

integer_contents()

std::vector< uint8_t > Botan::ASN1::integer_contents

(

const BigInt &

n

)

Return the contents octets of the DER encoding of the INTEGER n: big-endian two's complement, minimal length. Zero encodes as a single 0x00 octet.

Definition at line 356 of file der_enc.cpp.

                                                         {
   if(n == 0) {
      return {0x00};
   }
 
   // Serialize magnitude with one extra leading byte
   auto contents = n.serialize(n.bytes() + 1);
 
   if(n.signum() < 0) {
      // Two's complement: bitwise NOT then increment
      for(auto& byte : contents) {
         byte = ~byte;
      }
      for(size_t i = contents.size(); i > 0; --i) {
         if(++contents[i - 1] != 0) {
            break;
         }
      }
   }
 
   /*
   * DER requires the leading byte be emitted only if it required
   */
   BOTAN_ASSERT_NOMSG(contents.size() >= 2);
   const bool leading_byte_redundant =
      (contents[0] == 0x00 && (contents[1] & 0x80) == 0) || (contents[0] == 0xFF && (contents[1] & 0x80) != 0);
 
   if(leading_byte_redundant) {
      contents.erase(contents.begin());
   }
   return contents;
}

References BOTAN_ASSERT_NOMSG, Botan::BigInt::bytes(), Botan::BigInt::serialize(), and Botan::BigInt::signum().

Referenced by Botan::DER_Encoder::encode().

integer_from_contents()

BigInt Botan::ASN1::integer_from_contents

(

std::span< const uint8_t >

contents

)

Decode the contents octets of a BER INTEGER (big-endian two's complement). Redundant leading octets are accepted; an empty input is rejected.

Definition at line 801 of file ber_dec.cpp.

                                                                  {
   if(contents.empty()) {
      throw BER_Decoding_Error("INTEGER encoding has no content octets");
   }
 
   BigInt out;
 
   const bool negative = (contents[0] & 0x80) == 0x80;
 
   if(negative) {
      secure_vector<uint8_t> vec(contents.begin(), contents.end());
      for(size_t i = vec.size(); i > 0; --i) {
         const bool gt0 = (vec[i - 1] > 0);
         vec[i - 1] -= 1;
         if(gt0) {
            break;
         }
      }
      for(auto& byte : vec) {
         byte = ~byte;
      }
      out._assign_from_bytes(vec);
      out.set_sign(BigInt::Negative);
   } else {
      out._assign_from_bytes(contents);
   }
 
   return out;
}

References Botan::BigInt::_assign_from_bytes(), Botan::BigInt::Negative, and Botan::BigInt::set_sign().

Referenced by Botan::BER_Decoder::decode(), and Botan::X509_Serial_Number::to_bigint().

is_der_sequence_header()

bool Botan::ASN1::is_der_sequence_header

(

std::span< const uint8_t >

bytes

)

Return true if the bytes are exactly one DER-encoded SEQUENCE, that is a SEQUENCE whose tag plus length header plus contents span the entire buffer with no trailing data. The contents themselves are not otherwise validated.

Definition at line 1128 of file ber_dec.cpp.

                                                          {
   return is_single_der_object(bytes, ASN1_Type::Sequence, ASN1_Class::Universal | ASN1_Class::Constructed);
}

References Botan::Constructed, is_single_der_object(), Botan::Sequence, and Botan::Universal.

Referenced by Botan::AlgorithmIdentifier::decode_from().

is_single_der_object()

bool Botan::ASN1::is_single_der_object	(	std::span< const uint8_t >	bytes,
		ASN1_Type	expected_type,
		ASN1_Class	expected_class )

Definition at line 1100 of file ber_dec.cpp.

                                                                                                            {
   if(bytes.empty()) {
      return false;
   }
 
   try {
      DataSource_Span src(bytes);
 
      ASN1_Type type_tag = ASN1_Type::NoObject;
      ASN1_Class class_tag = ASN1_Class::NoObject;
      const size_t tag_bytes = decode_tag(&src, type_tag, class_tag);
 
      if(type_tag != expected_type || class_tag != expected_class) {
         return false;
      }
 
      const auto dl = decode_length(&src, /*allow_indef=*/0, /*der_mode=*/true, is_constructed(expected_class));
 
      const size_t header_bytes = tag_bytes + dl.field_length();
      if(header_bytes > bytes.size()) {
         return false;
      }
      return dl.content_length() == bytes.size() - header_bytes;
   } catch(Decoding_Error&) {
      return false;
   }
}

References Botan::NoObject.

Referenced by Botan::AlgorithmIdentifier::decode_from(), and is_der_sequence_header().

maybe_BER()

bool Botan::ASN1::maybe_BER

(

DataSource &

src

)

Heuristics tests; is this object possibly BER?

Parameters

src	a data source that will be peeked at but not modified

Definition at line 231 of file asn1_obj.cpp.

                                   {
   uint8_t first_u8 = 0;
   if(source.peek_byte(first_u8) == 0) {
      BOTAN_ASSERT_EQUAL(source.read_byte(first_u8), 0, "Expected EOF");
      throw Stream_IO_Error("ASN1::maybe_BER: Source was empty");
   }
 
   const auto cons_seq = static_cast<uint8_t>(ASN1_Class::Constructed) | static_cast<uint8_t>(ASN1_Type::Sequence);
   return first_u8 == cons_seq;
}

References BOTAN_ASSERT_EQUAL, Botan::Constructed, Botan::DataSource::peek_byte(), Botan::DataSource::read_byte(), and Botan::Sequence.

Referenced by Botan::X509_Object::load_data(), and Botan::X509::load_key().

put_in_sequence() [1/2]

std::vector< uint8_t > Botan::ASN1::put_in_sequence

(

const std::vector< uint8_t > &

val

)

Return the contents wrapped in a DER SEQUENCE

Parameters

val	the contents of the SEQUENCE

Definition at line 208 of file asn1_obj.cpp.

                                                                       {
   return ASN1::put_in_sequence(contents.data(), contents.size());
}

References put_in_sequence().

Referenced by Botan::GeneralName::binary_name(), botan_x509_crl_view_binary_values(), put_in_sequence(), and Botan::X509_Object::tbs_data().

put_in_sequence() [2/2]

std::vector< uint8_t > Botan::ASN1::put_in_sequence	(	const uint8_t	bits[],
		size_t	len )

Return the contents wrapped in a DER SEQUENCE

Parameters

bits	the contents of the SEQUENCE
len	the length of bits in bytes

Definition at line 212 of file asn1_obj.cpp.

                                                                     {
   std::vector<uint8_t> output = der_sequence_header(len);
   output.reserve(output.size() + len);
   if(len > 0) {
      output.insert(output.end(), bits, bits + len);
   }
   return output;
}

References der_sequence_header().

to_string()

std::string Botan::ASN1::to_string

(

const BER_Object &

obj

)

Return the contents of a BER object interpreted as a string

Parameters

obj	the object whose contents are converted

Definition at line 224 of file asn1_obj.cpp.

                                           {
   return bytes_to_string(obj.data());
}

References Botan::bytes_to_string(), and Botan::BER_Object::data().

Referenced by Botan::AlternativeName::decode_from(), Botan::ASN1_String::decode_from(), Botan::ASN1_Time::decode_from(), and Botan::GeneralName::decode_from().