/src/botan/src/lib/asn1/der_enc.cpp

Source (jump to first uncovered line)
/*
* DER Encoder
* (C) 1999-2007,2018 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/der_enc.h>

#include <botan/asn1_obj.h>
#include <botan/bigint.h>
#include <botan/internal/bit_ops.h>
#include <botan/internal/fmt.h>
#include <botan/internal/loadstor.h>
#include <algorithm>

namespace Botan {

namespace {

/*
* DER encode an ASN.1 type tag
*/
void encode_tag(std::vector<uint8_t>& encoded_tag, ASN1_Type type_tag_e, ASN1_Class class_tag_e) {
   const uint32_t type_tag = static_cast<uint32_t>(type_tag_e);
   const uint32_t class_tag = static_cast<uint32_t>(class_tag_e);

   if((class_tag | 0xE0) != 0xE0) {
      throw Encoding_Error(fmt("DER_Encoder: Invalid class tag {}", std::to_string(class_tag)));
   }

   if(type_tag <= 30) {
      encoded_tag.push_back(static_cast<uint8_t>(type_tag | class_tag));
   } else {
      size_t blocks = high_bit(static_cast<uint32_t>(type_tag)) + 6;
      blocks = (blocks - (blocks % 7)) / 7;

      BOTAN_ASSERT_NOMSG(blocks > 0);

      encoded_tag.push_back(static_cast<uint8_t>(class_tag | 0x1F));
      for(size_t i = 0; i != blocks - 1; ++i) {
         encoded_tag.push_back(0x80 | ((type_tag >> 7 * (blocks - i - 1)) & 0x7F));
      }
      encoded_tag.push_back(type_tag & 0x7F);
   }
}

/*
* DER encode an ASN.1 length field
*/
void encode_length(std::vector<uint8_t>& encoded_length, size_t length) {
   if(length <= 127) {
      encoded_length.push_back(static_cast<uint8_t>(length));
   } else {
      const size_t bytes_needed = significant_bytes(length);

      encoded_length.push_back(static_cast<uint8_t>(0x80 | bytes_needed));

      for(size_t i = sizeof(length) - bytes_needed; i < sizeof(length); ++i) {
         encoded_length.push_back(get_byte_var(i, length));
      }
   }
}

}  // namespace

DER_Encoder::DER_Encoder(secure_vector<uint8_t>& vec) {
   m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };
}

DER_Encoder::DER_Encoder(std::vector<uint8_t>& vec) {
   m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };
}

/*
* Push the encoded SEQUENCE/SET to the encoder stream
*/
void DER_Encoder::DER_Sequence::push_contents(DER_Encoder& der) {
   const auto real_class_tag = m_class_tag | ASN1_Class::Constructed;

   if(m_type_tag == ASN1_Type::Set) {
      std::sort(m_set_contents.begin(), m_set_contents.end());
      for(const auto& set_elem : m_set_contents) {
         m_contents += set_elem;
      }
      m_set_contents.clear();
   }

   der.add_object(m_type_tag, real_class_tag, m_contents.data(), m_contents.size());
   m_contents.clear();
}

/*
* Add an encoded value to the SEQUENCE/SET
*/
void DER_Encoder::DER_Sequence::add_bytes(const uint8_t data[], size_t length) {
   if(m_type_tag == ASN1_Type::Set) {
      m_set_contents.push_back(secure_vector<uint8_t>(data, data + length));
   } else {
      m_contents += std::make_pair(data, length);
   }
}

void DER_Encoder::DER_Sequence::add_bytes(const uint8_t hdr[], size_t hdr_len, const uint8_t val[], size_t val_len) {
   if(m_type_tag == ASN1_Type::Set) {
      secure_vector<uint8_t> m;
      m.reserve(hdr_len + val_len);
      m += std::make_pair(hdr, hdr_len);
      m += std::make_pair(val, val_len);
      m_set_contents.push_back(std::move(m));
   } else {
      m_contents += std::make_pair(hdr, hdr_len);
      m_contents += std::make_pair(val, val_len);
   }
}

/*
* Return the type and class taggings
*/
uint32_t DER_Encoder::DER_Sequence::tag_of() const {
   return m_type_tag | m_class_tag;
}

/*
* DER_Sequence Constructor
*/
DER_Encoder::DER_Sequence::DER_Sequence(ASN1_Type t1, ASN1_Class t2) : m_type_tag(t1), m_class_tag(t2) {}

/*
* Return the encoded contents
*/
secure_vector<uint8_t> DER_Encoder::get_contents() {
   if(!m_subsequences.empty()) {
      throw Invalid_State("DER_Encoder: Sequence hasn't been marked done");
   }

   if(m_append_output) {
      throw Invalid_State("DER_Encoder Cannot get contents when using output vector");
   }

   secure_vector<uint8_t> output;
   std::swap(output, m_default_outbuf);
   return output;
}

std::vector<uint8_t> DER_Encoder::get_contents_unlocked() {
   if(!m_subsequences.empty()) {
      throw Invalid_State("DER_Encoder: Sequence hasn't been marked done");
   }

   if(m_append_output) {
      throw Invalid_State("DER_Encoder Cannot get contents when using output vector");
   }

   std::vector<uint8_t> output(m_default_outbuf.begin(), m_default_outbuf.end());
   m_default_outbuf.clear();
   return output;
}

/*
* Start a new ASN.1 SEQUENCE/SET/EXPLICIT
*/
DER_Encoder& DER_Encoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
   m_subsequences.push_back(DER_Sequence(type_tag, class_tag));
   return (*this);
}

/*
* Finish the current ASN.1 SEQUENCE/SET/EXPLICIT
*/
DER_Encoder& DER_Encoder::end_cons() {
   if(m_subsequences.empty()) {
      throw Invalid_State("DER_Encoder::end_cons: No such sequence");
   }

   DER_Sequence last_seq = std::move(m_subsequences[m_subsequences.size() - 1]);
   m_subsequences.pop_back();
   last_seq.push_contents(*this);

   return (*this);
}

/*
* Start a new ASN.1 EXPLICIT encoding
*/
DER_Encoder& DER_Encoder::start_explicit(uint16_t type_no) {
   ASN1_Type type_tag = static_cast<ASN1_Type>(type_no);

   // This would confuse DER_Sequence
   if(type_tag == ASN1_Type::Set) {
      throw Internal_Error("DER_Encoder.start_explicit(SET) not supported");
   }

   return start_cons(type_tag, ASN1_Class::ContextSpecific);
}

/*
* Finish the current ASN.1 EXPLICIT encoding
*/
DER_Encoder& DER_Encoder::end_explicit() {
   return end_cons();
}

/*
* Write raw bytes into the stream
*/
DER_Encoder& DER_Encoder::raw_bytes(const uint8_t bytes[], size_t length) {
   if(!m_subsequences.empty()) {
      m_subsequences[m_subsequences.size() - 1].add_bytes(bytes, length);
   } else if(m_append_output) {
      m_append_output(bytes, length);
   } else {
      m_default_outbuf += std::make_pair(bytes, length);
   }

   return (*this);
}

/*
* Write the encoding of the byte(s)
*/
DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, const uint8_t rep[], size_t length) {
   std::vector<uint8_t> hdr;
   encode_tag(hdr, type_tag, class_tag);
   encode_length(hdr, length);

   if(!m_subsequences.empty()) {
      m_subsequences[m_subsequences.size() - 1].add_bytes(hdr.data(), hdr.size(), rep, length);
   } else if(m_append_output) {
      m_append_output(hdr.data(), hdr.size());
      m_append_output(rep, length);
   } else {
      m_default_outbuf += hdr;
      m_default_outbuf += std::make_pair(rep, length);
   }

   return (*this);
}

/*
* Encode a NULL object
*/
DER_Encoder& DER_Encoder::encode_null() {
   return add_object(ASN1_Type::Null, ASN1_Class::Universal, nullptr, 0);
}

/*
* DER encode a BOOLEAN
*/
DER_Encoder& DER_Encoder::encode(bool is_true) {
   return encode(is_true, ASN1_Type::Boolean, ASN1_Class::Universal);
}

/*
* DER encode a small INTEGER
*/
DER_Encoder& DER_Encoder::encode(size_t n) {
   return encode(BigInt::from_u64(n), ASN1_Type::Integer, ASN1_Class::Universal);
}

/*
* DER encode a small INTEGER
*/
DER_Encoder& DER_Encoder::encode(const BigInt& n) {
   return encode(n, ASN1_Type::Integer, ASN1_Class::Universal);
}

/*
* Encode this object
*/
DER_Encoder& DER_Encoder::encode(const uint8_t bytes[], size_t length, ASN1_Type real_type) {
   return encode(bytes, length, real_type, real_type, ASN1_Class::Universal);
}

/*
* DER encode a BOOLEAN
*/
DER_Encoder& DER_Encoder::encode(bool is_true, ASN1_Type type_tag, ASN1_Class class_tag) {
   uint8_t val = is_true ? 0xFF : 0x00;
   return add_object(type_tag, class_tag, &val, 1);
}

/*
* DER encode a small INTEGER
*/
DER_Encoder& DER_Encoder::encode(size_t n, ASN1_Type type_tag, ASN1_Class class_tag) {
   return encode(BigInt::from_u64(n), type_tag, class_tag);
}

/*
* DER encode an INTEGER
*/
DER_Encoder& DER_Encoder::encode(const BigInt& n, ASN1_Type type_tag, ASN1_Class class_tag) {
   if(n == 0) {
      return add_object(type_tag, class_tag, 0);
   }

   const size_t extra_zero = (n.bits() % 8 == 0) ? 1 : 0;

   auto contents = n.serialize(n.bytes() + extra_zero);
   if(n < 0) {
      for(unsigned char& content : contents) {
         content = ~content;
      }
      for(size_t i = contents.size(); i > 0; --i) {
         if(++contents[i - 1]) {
            break;
         }
      }
   }

   return add_object(type_tag, class_tag, contents);
}

/*
* DER encode an OCTET STRING or BIT STRING
*/
DER_Encoder& DER_Encoder::encode(
   const uint8_t bytes[], size_t length, ASN1_Type real_type, ASN1_Type type_tag, ASN1_Class class_tag) {
   if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
      throw Invalid_Argument("DER_Encoder: Invalid tag for byte/bit string");
   }

   if(real_type == ASN1_Type::BitString) {
      secure_vector<uint8_t> encoded;
      encoded.push_back(0);
      encoded += std::make_pair(bytes, length);
      return add_object(type_tag, class_tag, encoded);
   } else {
      return add_object(type_tag, class_tag, bytes, length);
   }
}

DER_Encoder& DER_Encoder::encode(const ASN1_Object& obj) {
   obj.encode_into(*this);
   return (*this);
}

/*
* Write the encoding of the byte(s)
*/
DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, std::string_view rep_str) {
   const uint8_t* rep = cast_char_ptr_to_uint8(rep_str.data());
   const size_t rep_len = rep_str.size();
   return add_object(type_tag, class_tag, rep, rep_len);
}

/*
* Write the encoding of the byte
*/
DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, uint8_t rep) {
   return add_object(type_tag, class_tag, &rep, 1);
}

}  // namespace Botan

Coverage Report

Created: 2024-11-21 07:03

Line	Count	Source (jump to first uncovered line)
1		/*
2		* DER Encoder
3		* (C) 1999-2007,2018 Jack Lloyd
4		*
5		* Botan is released under the Simplified BSD License (see license.txt)
6		*/
7
8		#include <botan/der_enc.h>
9
10		#include <botan/asn1_obj.h>
11		#include <botan/bigint.h>
12		#include <botan/internal/bit_ops.h>
13		#include <botan/internal/fmt.h>
14		#include <botan/internal/loadstor.h>
15		#include <algorithm>
16
17		namespace Botan {
18
19		namespace {
20
21		/*
22		* DER encode an ASN.1 type tag
23		*/
24	286	void encode_tag(std::vector<uint8_t>& encoded_tag, ASN1_Type type_tag_e, ASN1_Class class_tag_e) {
25	286	const uint32_t type_tag = static_cast<uint32_t>(type_tag_e);
26	286	const uint32_t class_tag = static_cast<uint32_t>(class_tag_e);
27
28	286	if((class_tag \| 0xE0) != 0xE0) {
29	0	throw Encoding_Error(fmt("DER_Encoder: Invalid class tag {}", std::to_string(class_tag)));
30	0	}
31
32	286	if(type_tag <= 30) {
33	286	encoded_tag.push_back(static_cast<uint8_t>(type_tag \| class_tag));
34	286	} else {
35	0	size_t blocks = high_bit(static_cast<uint32_t>(type_tag)) + 6;
36	0	blocks = (blocks - (blocks % 7)) / 7;
37
38	0	BOTAN_ASSERT_NOMSG(blocks > 0);
39
40	0	encoded_tag.push_back(static_cast<uint8_t>(class_tag \| 0x1F));
41	0	for(size_t i = 0; i != blocks - 1; ++i) {
42	0	encoded_tag.push_back(0x80 \| ((type_tag >> 7 * (blocks - i - 1)) & 0x7F));
43	0	}
44	0	encoded_tag.push_back(type_tag & 0x7F);
45	0	}
46	286	}
47
48		/*
49		* DER encode an ASN.1 length field
50		*/
51	286	void encode_length(std::vector<uint8_t>& encoded_length, size_t length) {
52	286	if(length <= 127) {
53	282	encoded_length.push_back(static_cast<uint8_t>(length));
54	282	} else {
55	4	const size_t bytes_needed = significant_bytes(length);
56
57	4	encoded_length.push_back(static_cast<uint8_t>(0x80 \| bytes_needed));
58
59	8	for(size_t i = sizeof(length) - bytes_needed; i < sizeof(length); ++i) {
60	4	encoded_length.push_back(get_byte_var(i, length));
61	4	}
62	4	}
63	286	}
64
65		} // namespace
66
67	0	DER_Encoder::DER_Encoder(secure_vector<uint8_t>& vec) {
68	0	m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };
69	0	}
70
71	206	DER_Encoder::DER_Encoder(std::vector<uint8_t>& vec) {
72	412	m_append_output = [&vec](const uint8_t b[], size_t l) { vec.insert(vec.end(), b, b + l); };
73	206	}
74
75		/*
76		* Push the encoded SEQUENCE/SET to the encoder stream
77		*/
78	40	void DER_Encoder::DER_Sequence::push_contents(DER_Encoder& der) {
79	40	const auto real_class_tag = m_class_tag \| ASN1_Class::Constructed;
80
81	40	if(m_type_tag == ASN1_Type::Set) {
82	0	std::sort(m_set_contents.begin(), m_set_contents.end());
83	0	for(const auto& set_elem : m_set_contents) {
84	0	m_contents += set_elem;
85	0	}
86	0	m_set_contents.clear();
87	0	}
88
89	40	der.add_object(m_type_tag, real_class_tag, m_contents.data(), m_contents.size());
90	40	m_contents.clear();
91	40	}
92
93		/*
94		* Add an encoded value to the SEQUENCE/SET
95		*/
96	0	void DER_Encoder::DER_Sequence::add_bytes(const uint8_t data[], size_t length) {
97	0	if(m_type_tag == ASN1_Type::Set) {
98	0	m_set_contents.push_back(secure_vector<uint8_t>(data, data + length));
99	0	} else {
100	0	m_contents += std::make_pair(data, length);
101	0	}
102	0	}
103
104	80	void DER_Encoder::DER_Sequence::add_bytes(const uint8_t hdr[], size_t hdr_len, const uint8_t val[], size_t val_len) {
105	80	if(m_type_tag == ASN1_Type::Set) {
106	0	secure_vector<uint8_t> m;
107	0	m.reserve(hdr_len + val_len);
108	0	m += std::make_pair(hdr, hdr_len);
109	0	m += std::make_pair(val, val_len);
110	0	m_set_contents.push_back(std::move(m));
111	80	} else {
112	80	m_contents += std::make_pair(hdr, hdr_len);
113	80	m_contents += std::make_pair(val, val_len);
114	80	}
115	80	}
116
117		/*
118		* Return the type and class taggings
119		*/
120	0	uint32_t DER_Encoder::DER_Sequence::tag_of() const {
121	0	return m_type_tag \| m_class_tag;
122	0	}
123
124		/*
125		* DER_Sequence Constructor
126		*/
127	40	DER_Encoder::DER_Sequence::DER_Sequence(ASN1_Type t1, ASN1_Class t2) : m_type_tag(t1), m_class_tag(t2) {}
128
129		/*
130		* Return the encoded contents
131		*/
132	0	secure_vector<uint8_t> DER_Encoder::get_contents() {
133	0	if(!m_subsequences.empty()) {
134	0	throw Invalid_State("DER_Encoder: Sequence hasn't been marked done");
135	0	}
136
137	0	if(m_append_output) {
138	0	throw Invalid_State("DER_Encoder Cannot get contents when using output vector");
139	0	}
140
141	0	secure_vector<uint8_t> output;
142	0	std::swap(output, m_default_outbuf);
143	0	return output;
144	0	}
145
146	0	std::vector<uint8_t> DER_Encoder::get_contents_unlocked() {
147	0	if(!m_subsequences.empty()) {
148	0	throw Invalid_State("DER_Encoder: Sequence hasn't been marked done");
149	0	}
150
151	0	if(m_append_output) {
152	0	throw Invalid_State("DER_Encoder Cannot get contents when using output vector");
153	0	}
154
155	0	std::vector<uint8_t> output(m_default_outbuf.begin(), m_default_outbuf.end());
156	0	m_default_outbuf.clear();
157	0	return output;
158	0	}
159
160		/*
161		* Start a new ASN.1 SEQUENCE/SET/EXPLICIT
162		*/
163	40	DER_Encoder& DER_Encoder::start_cons(ASN1_Type type_tag, ASN1_Class class_tag) {
164	40	m_subsequences.push_back(DER_Sequence(type_tag, class_tag));
165	40	return (*this);
166	40	}
167
168		/*
169		* Finish the current ASN.1 SEQUENCE/SET/EXPLICIT
170		*/
171	40	DER_Encoder& DER_Encoder::end_cons() {
172	40	if(m_subsequences.empty()) {
173	0	throw Invalid_State("DER_Encoder::end_cons: No such sequence");
174	0	}
175
176	40	DER_Sequence last_seq = std::move(m_subsequences[m_subsequences.size() - 1]);
177	40	m_subsequences.pop_back();
178	40	last_seq.push_contents(*this);
179
180	40	return (*this);
181	40	}
182
183		/*
184		* Start a new ASN.1 EXPLICIT encoding
185		*/
186	0	DER_Encoder& DER_Encoder::start_explicit(uint16_t type_no) {
187	0	ASN1_Type type_tag = static_cast<ASN1_Type>(type_no);
188
189		// This would confuse DER_Sequence
190	0	if(type_tag == ASN1_Type::Set) {
191	0	throw Internal_Error("DER_Encoder.start_explicit(SET) not supported");
192	0	}
193
194	0	return start_cons(type_tag, ASN1_Class::ContextSpecific);
195	0	}
196
197		/*
198		* Finish the current ASN.1 EXPLICIT encoding
199		*/
200	0	DER_Encoder& DER_Encoder::end_explicit() {
201	0	return end_cons();
202	0	}
203
204		/*
205		* Write raw bytes into the stream
206		*/
207	0	DER_Encoder& DER_Encoder::raw_bytes(const uint8_t bytes[], size_t length) {
208	0	if(!m_subsequences.empty()) {
209	0	m_subsequences[m_subsequences.size() - 1].add_bytes(bytes, length);
210	0	} else if(m_append_output) {
211	0	m_append_output(bytes, length);
212	0	} else {
213	0	m_default_outbuf += std::make_pair(bytes, length);
214	0	}
215
216	0	return (*this);
217	0	}
218
219		/*
220		* Write the encoding of the byte(s)
221		*/
222	286	DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, const uint8_t rep[], size_t length) {
223	286	std::vector<uint8_t> hdr;
224	286	encode_tag(hdr, type_tag, class_tag);
225	286	encode_length(hdr, length);
226
227	286	if(!m_subsequences.empty()) {
228	80	m_subsequences[m_subsequences.size() - 1].add_bytes(hdr.data(), hdr.size(), rep, length);
229	206	} else if(m_append_output) {
230	206	m_append_output(hdr.data(), hdr.size());
231	206	m_append_output(rep, length);
232	206	} else {
233	0	m_default_outbuf += hdr;
234	0	m_default_outbuf += std::make_pair(rep, length);
235	0	}
236
237	286	return (*this);
238	286	}
239
240		/*
241		* Encode a NULL object
242		*/
243	0	DER_Encoder& DER_Encoder::encode_null() {
244	0	return add_object(ASN1_Type::Null, ASN1_Class::Universal, nullptr, 0);
245	0	}
246
247		/*
248		* DER encode a BOOLEAN
249		*/
250	0	DER_Encoder& DER_Encoder::encode(bool is_true) {
251	0	return encode(is_true, ASN1_Type::Boolean, ASN1_Class::Universal);
252	0	}
253
254		/*
255		* DER encode a small INTEGER
256		*/
257	0	DER_Encoder& DER_Encoder::encode(size_t n) {
258	0	return encode(BigInt::from_u64(n), ASN1_Type::Integer, ASN1_Class::Universal);
259	0	}
260
261		/*
262		* DER encode a small INTEGER
263		*/
264	80	DER_Encoder& DER_Encoder::encode(const BigInt& n) {
265	80	return encode(n, ASN1_Type::Integer, ASN1_Class::Universal);
266	80	}
267
268		/*
269		* Encode this object
270		*/
271	0	DER_Encoder& DER_Encoder::encode(const uint8_t bytes[], size_t length, ASN1_Type real_type) {
272	0	return encode(bytes, length, real_type, real_type, ASN1_Class::Universal);
273	0	}
274
275		/*
276		* DER encode a BOOLEAN
277		*/
278	0	DER_Encoder& DER_Encoder::encode(bool is_true, ASN1_Type type_tag, ASN1_Class class_tag) {
279	0	uint8_t val = is_true ? 0xFF : 0x00;
280	0	return add_object(type_tag, class_tag, &val, 1);
281	0	}
282
283		/*
284		* DER encode a small INTEGER
285		*/
286	0	DER_Encoder& DER_Encoder::encode(size_t n, ASN1_Type type_tag, ASN1_Class class_tag) {
287	0	return encode(BigInt::from_u64(n), type_tag, class_tag);
288	0	}
289
290		/*
291		* DER encode an INTEGER
292		*/
293	80	DER_Encoder& DER_Encoder::encode(const BigInt& n, ASN1_Type type_tag, ASN1_Class class_tag) {
294	80	if(n == 0) {
295	0	return add_object(type_tag, class_tag, 0);
296	0	}
297
298	80	const size_t extra_zero = (n.bits() % 8 == 0) ? 1 : 0;
299
300	80	auto contents = n.serialize(n.bytes() + extra_zero);
301	80	if(n < 0) {
302	0	for(unsigned char& content : contents) {
303	0	content = ~content;
304	0	}
305	0	for(size_t i = contents.size(); i > 0; --i) {
306	0	if(++contents[i - 1]) {
307	0	break;
308	0	}
309	0	}
310	0	}
311
312	80	return add_object(type_tag, class_tag, contents);
313	80	}
314
315		/*
316		* DER encode an OCTET STRING or BIT STRING
317		*/
318		DER_Encoder& DER_Encoder::encode(
319	0	const uint8_t bytes[], size_t length, ASN1_Type real_type, ASN1_Type type_tag, ASN1_Class class_tag) {
320	0	if(real_type != ASN1_Type::OctetString && real_type != ASN1_Type::BitString) {
321	0	throw Invalid_Argument("DER_Encoder: Invalid tag for byte/bit string");
322	0	}
323
324	0	if(real_type == ASN1_Type::BitString) {
325	0	secure_vector<uint8_t> encoded;
326	0	encoded.push_back(0);
327	0	encoded += std::make_pair(bytes, length);
328	0	return add_object(type_tag, class_tag, encoded);
329	0	} else {
330	0	return add_object(type_tag, class_tag, bytes, length);
331	0	}
332	0	}
333
334	166	DER_Encoder& DER_Encoder::encode(const ASN1_Object& obj) {
335	166	obj.encode_into(*this);
336	166	return (*this);
337	166	}
338
339		/*
340		* Write the encoding of the byte(s)
341		*/
342	0	DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, std::string_view rep_str) {
343	0	const uint8_t* rep = cast_char_ptr_to_uint8(rep_str.data());
344	0	const size_t rep_len = rep_str.size();
345	0	return add_object(type_tag, class_tag, rep, rep_len);
346	0	}
347
348		/*
349		* Write the encoding of the byte
350		*/
351	0	DER_Encoder& DER_Encoder::add_object(ASN1_Type type_tag, ASN1_Class class_tag, uint8_t rep) {
352	0	return add_object(type_tag, class_tag, &rep, 1);
353	0	}
354
355		} // namespace Botan