Lines
0 %
Functions
Branches
100 %
//! OID encoder with `const` support.
use crate::{
arcs::{ARC_MAX_FIRST, ARC_MAX_SECOND},
Arc, Error, ObjectIdentifier, Result,
};
/// BER/DER encoder
#[derive(Debug)]
pub(crate) struct Encoder {
/// Current state
state: State,
/// Bytes of the OID being encoded in-progress
bytes: [u8; ObjectIdentifier::MAX_SIZE],
/// Current position within the byte buffer
cursor: usize,
}
/// Current state of the encoder
enum State {
/// Initial state - no arcs yet encoded
Initial,
/// First arc parsed
FirstArc(Arc),
/// Encoding base 128 body of the OID
Body,
impl Encoder {
/// Create a new encoder initialized to an empty default state.
pub(crate) const fn new() -> Self {
Self {
state: State::Initial,
bytes: [0u8; ObjectIdentifier::MAX_SIZE],
cursor: 0,
/// Extend an existing OID.
pub(crate) const fn extend(oid: ObjectIdentifier) -> Self {
state: State::Body,
bytes: oid.bytes,
cursor: oid.length as usize,
/// Encode an [`Arc`] as base 128 into the internal buffer.
pub(crate) const fn arc(mut self, arc: Arc) -> Result<Self> {
match self.state {
State::Initial => {
if arc > ARC_MAX_FIRST {
return Err(Error::ArcInvalid { arc });
self.state = State::FirstArc(arc);
Ok(self)
// Ensured not to overflow by `ARC_MAX_SECOND` check
#[allow(clippy::integer_arithmetic)]
State::FirstArc(first_arc) => {
if arc > ARC_MAX_SECOND {
self.state = State::Body;
self.bytes[0] = (first_arc * (ARC_MAX_SECOND + 1)) as u8 + arc as u8;
self.cursor = 1;
// TODO(tarcieri): finer-grained overflow safety / checked arithmetic
State::Body => {
// Total number of bytes in encoded arc - 1
let nbytes = base128_len(arc);
// Shouldn't overflow on any 16-bit+ architectures
if self.cursor + nbytes + 1 >= ObjectIdentifier::MAX_SIZE {
return Err(Error::Length);
let new_cursor = self.cursor + nbytes + 1;
// TODO(tarcieri): use `?` when stable in `const fn`
match self.encode_base128_byte(arc, nbytes, false) {
Ok(mut encoder) => {
encoder.cursor = new_cursor;
Ok(encoder)
Err(err) => Err(err),
/// Finish encoding an OID.
pub(crate) const fn finish(self) -> Result<ObjectIdentifier> {
if self.cursor >= 2 {
Ok(ObjectIdentifier {
bytes: self.bytes,
length: self.cursor as u8,
})
} else {
Err(Error::NotEnoughArcs)
/// Encode a single byte of a Base 128 value.
const fn encode_base128_byte(mut self, mut n: u32, i: usize, continued: bool) -> Result<Self> {
let mask = if continued { 0b10000000 } else { 0 };
// Underflow checked by branch
if n > 0x80 {
self.bytes[checked_add!(self.cursor, i)] = (n & 0b1111111) as u8 | mask;
n >>= 7;
if i > 0 {
self.encode_base128_byte(n, i.saturating_sub(1), true)
Err(Error::Base128)
self.bytes[self.cursor] = n as u8 | mask;
/// Compute the length - 1 of an arc when encoded in base 128.
const fn base128_len(arc: Arc) -> usize {
match arc {
0..=0x7f => 0,
0x80..=0x3fff => 1,
0x4000..=0x1fffff => 2,
0x200000..=0x1fffffff => 3,
_ => 4,
#[cfg(test)]
mod tests {
use super::Encoder;
use hex_literal::hex;
/// OID `1.2.840.10045.2.1` encoded as ASN.1 BER/DER
const EXAMPLE_OID_BER: &[u8] = &hex!("2A8648CE3D0201");
#[test]
fn encode() {
let encoder = Encoder::new();
let encoder = encoder.arc(1).unwrap();
let encoder = encoder.arc(2).unwrap();
let encoder = encoder.arc(840).unwrap();
let encoder = encoder.arc(10045).unwrap();
assert_eq!(&encoder.bytes[..encoder.cursor], EXAMPLE_OID_BER);