msldap-ext 0.1.0-dev

Encoder/decoder for MS-ADTS LDAP extension controls (Paged Results, ExtendedDN, SDFlags, ShowDeleted, DirSync, VLV). Pure BER โ€” no transport.
Documentation
//! Minimal BER TLV encoder/decoder for the small subset of ASN.1 used by
//! MS-ADTS LDAP control values (SEQUENCE, INTEGER, OCTET STRING, context tags).
//!
//! Not a general-purpose ASN.1 codec. Hand-rolled to keep the dep graph flat
//! (matches the crate's S-tier posture โ€” see README).

use crate::Error;

pub const TAG_INTEGER: u8 = 0x02;
pub const TAG_OCTET_STRING: u8 = 0x04;
pub const TAG_SEQUENCE: u8 = 0x30;

/// Encode a definite-length length field per X.690 ยง8.1.3.
pub fn write_len(out: &mut Vec<u8>, len: usize) {
    if len < 0x80 {
        out.push(len as u8);
        return;
    }
    // long form
    let mut buf = [0u8; 8];
    let mut n = 0usize;
    let mut l = len;
    while l > 0 {
        buf[n] = (l & 0xff) as u8;
        l >>= 8;
        n += 1;
    }
    out.push(0x80 | (n as u8));
    for i in (0..n).rev() {
        out.push(buf[i]);
    }
}

/// Read a tag + length header. Returns (tag, value_len, header_len_consumed).
pub fn read_header(buf: &[u8]) -> Result<(u8, usize, usize), Error> {
    if buf.is_empty() {
        return Err(Error::Truncated);
    }
    let tag = buf[0];
    if buf.len() < 2 {
        return Err(Error::Truncated);
    }
    let first = buf[1];
    if first & 0x80 == 0 {
        return Ok((tag, first as usize, 2));
    }
    let n = (first & 0x7f) as usize;
    if n == 0 || n > 4 {
        return Err(Error::Malformed("unsupported length form"));
    }
    if buf.len() < 2 + n {
        return Err(Error::Truncated);
    }
    let mut len = 0usize;
    for &b in &buf[2..2 + n] {
        len = (len << 8) | (b as usize);
    }
    Ok((tag, len, 2 + n))
}

/// Encode a non-negative INTEGER (u32 range). AD paged-size / DirSync flags
/// fit here; we do NOT emit two's-complement negatives.
pub fn write_u32(out: &mut Vec<u8>, v: u32) {
    let mut bytes = v.to_be_bytes().to_vec();
    // strip leading zero bytes, keep one leading zero if MSB of retained head is set
    while bytes.len() > 1 && bytes[0] == 0 && (bytes[1] & 0x80) == 0 {
        bytes.remove(0);
    }
    // if MSB is set on a would-be-negative value, prepend 0x00
    if bytes[0] & 0x80 != 0 {
        bytes.insert(0, 0x00);
    }
    out.push(TAG_INTEGER);
    write_len(out, bytes.len());
    out.extend_from_slice(&bytes);
}

/// Decode an INTEGER as u32 (accepts any width up to 5 bytes with a leading 0).
pub fn read_u32(buf: &[u8]) -> Result<(u32, usize), Error> {
    let (tag, len, hdr) = read_header(buf)?;
    if tag != TAG_INTEGER {
        return Err(Error::Malformed("expected INTEGER"));
    }
    if buf.len() < hdr + len {
        return Err(Error::Truncated);
    }
    let bytes = &buf[hdr..hdr + len];
    if bytes.is_empty() || bytes.len() > 5 {
        return Err(Error::Malformed("INTEGER out of u32 range"));
    }
    if bytes.len() == 5 && bytes[0] != 0 {
        return Err(Error::Malformed("INTEGER out of u32 range"));
    }
    let mut v: u64 = 0;
    for &b in bytes {
        v = (v << 8) | b as u64;
    }
    if v > u32::MAX as u64 {
        return Err(Error::Malformed("INTEGER exceeds u32"));
    }
    Ok((v as u32, hdr + len))
}

pub fn write_octet_string(out: &mut Vec<u8>, v: &[u8]) {
    out.push(TAG_OCTET_STRING);
    write_len(out, v.len());
    out.extend_from_slice(v);
}

pub fn read_octet_string(buf: &[u8]) -> Result<(&[u8], usize), Error> {
    let (tag, len, hdr) = read_header(buf)?;
    if tag != TAG_OCTET_STRING {
        return Err(Error::Malformed("expected OCTET STRING"));
    }
    if buf.len() < hdr + len {
        return Err(Error::Truncated);
    }
    Ok((&buf[hdr..hdr + len], hdr + len))
}

/// Wrap `body` in a SEQUENCE header (tag 0x30 + length). Returns the full TLV.
pub fn wrap_sequence(body: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(body.len() + 4);
    out.push(TAG_SEQUENCE);
    write_len(&mut out, body.len());
    out.extend_from_slice(body);
    out
}

/// Read a SEQUENCE and return a slice over its inner content.
pub fn read_sequence(buf: &[u8]) -> Result<(&[u8], usize), Error> {
    let (tag, len, hdr) = read_header(buf)?;
    if tag != TAG_SEQUENCE {
        return Err(Error::Malformed("expected SEQUENCE"));
    }
    if buf.len() < hdr + len {
        return Err(Error::Truncated);
    }
    Ok((&buf[hdr..hdr + len], hdr + len))
}