castrum 0.7.0 → 0.9.0

package/rust/cors.rs

@@ -1,263 +0,0 @@
-// rust/cors.rs — CORS engine extracted from ingress.rs
-// Pre-computes method bitmask for O(1) method matching
-
-use crate::headers::HeaderRefs;
-use crate::method::MethodKind;
-use crate::util::trim_ascii_whitespace;
-use napi::{Error, Result, Status};
-use napi_derive::napi;
-
-// ── CORS engine ───────────────────────────────────────────────────
-#[derive(Clone)]
-pub enum CorsMode {
-    Disabled,
-    Wildcard,
-    Allowlist(Vec<Box<[u8]>>),
-}
-
-#[derive(Clone)]
-pub struct CorsEngine {
-    mode: CorsMode,
-    credentials: bool,
-    methods_wildcard: bool,
-    // Bitmask of allowed methods for O(1) lookup
-    method_bits: u16,
-    headers_wildcard: bool,
-    headers: Vec<Box<[u8]>>,
-}
-
-pub struct CorsEvaluation {
-    pub allowed: bool,
-    pub preflight: bool,
-}
-
-impl CorsEngine {
-    pub fn disabled() -> Self {
-        Self {
-            mode: CorsMode::Disabled,
-            credentials: false,
-            methods_wildcard: false,
-            method_bits: 0,
-            headers_wildcard: false,
-            headers: Vec::new(),
-        }
-    }
-
-    pub fn from_options(opts: Option<CorsOptions>) -> Result<Self> {
-        let Some(opts) = opts else {
-            return Ok(Self::disabled());
-        };
-
-        let credentials = opts.allow_credentials.unwrap_or(false);
-
-        let mode = match opts.allow_origin {
-            Some(list) if !list.is_empty() => {
-                if list.iter().any(|o| o == "*") {
-                    if credentials {
-                        return Err(Error::new(
-                            Status::InvalidArg,
-                            "CORS allowCredentials cannot be used with allowOrigin ['*']",
-                        ));
-                    }
-                    CorsMode::Wildcard
-                } else {
-                    CorsMode::Allowlist(
-                        list.iter()
-                            .map(|s| s.as_bytes().to_vec().into_boxed_slice())
-                            .collect(),
-                    )
-                }
-            }
-            _ => {
-                if credentials {
-                    return Err(Error::new(
-                        Status::InvalidArg,
-                        "CORS allowCredentials requires an explicit allowOrigin list",
-                    ));
-                }
-                CorsMode::Wildcard
-            }
-        };
-
-        let (methods_wildcard, method_bits) = parse_allowed_methods_bitset(opts.allow_methods);
-        let (headers_wildcard, headers) = parse_allowed_headers(opts.allow_headers);
-
-        Ok(Self {
-            mode,
-            credentials,
-            methods_wildcard,
-            method_bits,
-            headers_wildcard,
-            headers,
-        })
-    }
-
-    #[inline]
-    pub fn evaluate(&self, method: MethodKind, headers: &HeaderRefs) -> CorsEvaluation {
-        let origin = match headers.origin() {
-            Some(o) => o,
-            None => {
-                return CorsEvaluation {
-                    allowed: false,
-                    preflight: false,
-                }
-            }
-        };
-
-        let preflight = method == MethodKind::Options && headers.has_acrm();
-
-        let mut allowed = match &self.mode {
-            CorsMode::Disabled => false,
-            CorsMode::Wildcard => !self.credentials,
-            CorsMode::Allowlist(list) => {
-                let origin_trim = trim_ascii_whitespace(origin);
-                list.iter().any(|allowed| &**allowed == origin_trim)
-            }
-        };
-
-        if allowed {
-            if preflight {
-                allowed = self.preflight_method_allowed(headers.acrm())
-                    && self.headers_allowed(headers.acrh());
-            } else {
-                allowed = self.method_allowed_kind(method);
-            }
-        }
-
-        CorsEvaluation { allowed, preflight }
-    }
-
-    #[inline(always)]
-    fn method_allowed_kind(&self, kind: MethodKind) -> bool {
-        if self.methods_wildcard {
-            return true;
-        }
-
-        if self.method_bits == 0 {
-            return matches!(kind, MethodKind::Get | MethodKind::Head | MethodKind::Post);
-        }
-
-        (self.method_bits & kind.bit()) != 0
-    }
-
-    #[inline]
-    fn preflight_method_allowed(&self, acrm: Option<&[u8]>) -> bool {
-        let Some(acrm) = acrm else {
-            return false;
-        };
-
-        let trimmed = trim_ascii_whitespace(acrm);
-        if trimmed.is_empty() {
-            return false;
-        }
-
-        let kind = MethodKind::from_bytes_ignore_case(trimmed);
-        self.method_allowed_kind(kind)
-    }
-
-    #[inline]
-    fn headers_allowed(&self, acrh: Option<&[u8]>) -> bool {
-        let Some(acrh) = acrh else {
-            return true;
-        };
-
-        if self.headers_wildcard {
-            return true;
-        }
-
-        for requested in acrh.split(|&b| b == b',') {
-            let name = trim_ascii_whitespace(requested);
-            if name.is_empty() {
-                continue;
-            }
-
-            let lower = name.to_ascii_lowercase();
-
-            if self.headers.is_empty() {
-                if !is_cors_safelisted_request_header(lower.as_slice()) {
-                    return false;
-                }
-            } else if !self
-                .headers
-                .iter()
-                .any(|allowed| allowed.as_ref() == lower.as_slice())
-            {
-                return false;
-            }
-        }
-
-        true
-    }
-}
-
-fn is_cors_safelisted_request_header(name: &[u8]) -> bool {
-    matches!(
-        name,
-        b"accept" | b"accept-language" | b"content-language" | b"content-type"
-    )
-}
-
-fn parse_allowed_methods_bitset(list: Option<Vec<String>>) -> (bool, u16) {
-    let Some(list) = list else {
-        return (false, 0);
-    };
-
-    let mut bits = 0u16;
-
-    for raw in list {
-        let trimmed = raw.trim();
-
-        if trimmed == "*" {
-            return (true, 0);
-        }
-
-        if trimmed.is_empty() {
-            continue;
-        }
-
-        let upper = trimmed.to_ascii_uppercase();
-        let kind = MethodKind::from_str(&upper);
-
-        if kind != MethodKind::Other {
-            bits |= kind.bit();
-        }
-    }
-
-    (false, bits)
-}
-
-fn parse_allowed_headers(list: Option<Vec<String>>) -> (bool, Vec<Box<[u8]>>) {
-    let Some(list) = list else {
-        return (false, Vec::new());
-    };
-
-    let mut headers = Vec::new();
-
-    for raw in list {
-        let trimmed = raw.trim();
-
-        if trimmed == "*" {
-            return (true, Vec::new());
-        }
-
-        if trimmed.is_empty() {
-            continue;
-        }
-
-        headers.push(trimmed.to_ascii_lowercase().into_bytes().into_boxed_slice());
-    }
-
-    (false, headers)
-}
-
-// ── NAPI option struct ───────────────────────────────────────────
-#[napi(object)]
-#[derive(Clone)]
-pub struct CorsOptions {
-    pub allow_origin: Option<Vec<String>>,
-    pub allow_methods: Option<Vec<String>>,
-    pub allow_headers: Option<Vec<String>>,
-    pub expose_headers: Option<Vec<String>>,
-    pub allow_credentials: Option<bool>,
-    pub max_age: Option<u32>,
-}

package/rust/hashing.rs

@@ -1,164 +0,0 @@
-use napi::bindgen_prelude::*;
-use napi_derive::napi;
-
-use crate::util::should_parallelize;
-use xxhash_rust::xxh3::{xxh3_64, xxh3_64_with_seed, Xxh3};
-
-pub const FNV_OFFSET_BASIS: u64 = 0xcbf2_9ce4_8422_2325;
-pub const FNV_PRIME: u64 = 0x0000_0100_0000_01b3;
-
-// ── FNV-1a (byte-by-byte, correct per spec) ──────────────────────
-
-/// FNV-1a in the "continue" style. FNV-1a is inherently byte-serial,
-/// so we process each byte individually (this is the correct algorithm).
-#[inline]
-pub fn fnv1a64_continue(mut hash: u64, input: &[u8]) -> u64 {
-    for &b in input {
-        hash ^= u64::from(b);
-        hash = hash.wrapping_mul(FNV_PRIME);
-    }
-    hash
-}
-
-/// FNV-1a on a full byte slice, with fast path for small inputs.
-#[inline]
-pub fn fnv1a64_bytes(input: &[u8]) -> u64 {
-    fnv1a64_continue(FNV_OFFSET_BASIS, input)
-}
-
-// ── XXHash wrappers ────────────────────────────────────────────────
-
-#[inline]
-pub fn fast_hash_bytes(input: &[u8]) -> u64 {
-    xxh3_64(input)
-}
-
-#[inline]
-pub fn fast_hash_seeded(input: &[u8], seed: u64) -> u64 {
-    xxh3_64_with_seed(input, seed)
-}
-
-/// Compute a composite cache key from method+path+query.
-#[inline]
-pub fn fast_hash_cache_key(method: &[u8], path: &[u8], query: &[u8]) -> u64 {
-    let mut h = Xxh3::with_seed(0x9E37_79B9_7F4A_7C15);
-    h.update(method);
-    h.update(&[0]);
-    h.update(path);
-    h.update(&[0]);
-    h.update(query);
-    h.digest()
-}
-
-// ── Cow helpers for lazy / cached hashing ──────────────────────────
-
-/// A lazy hash value that can be computed once and cached.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub struct LazyHash(u64);
-
-impl LazyHash {
-    #[inline(always)]
-    pub fn new(value: u64) -> Self {
-        Self(value)
-    }
-
-    #[inline(always)]
-    pub fn get(&self) -> u64 {
-        self.0
-    }
-}
-
-// ── Napi exports ───────────────────────────────────────────────────
-
-#[napi]
-pub fn crc32(input: Uint8Array) -> u32 {
-    crc32fast::hash(input.as_ref())
-}
-
-#[napi(js_name = "fnv1a64")]
-pub fn fnv1a64(input: Uint8Array) -> u64 {
-    fnv1a64_bytes(input.as_ref())
-}
-
-/// CRC32 batch — zero-alloc inline iteration (no Vec allocation from unpack).
-#[napi]
-pub fn crc32_batch_packed(input: Uint8Array) -> Result<Buffer> {
-    let data = input.as_ref();
-    if data.len() < 4 {
-        return Err(Error::from_reason("packed buffer: missing count"));
-    }
-
-    let count = u32::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize;
-
-    // Validate count early
-    let max_possible = (data.len() - 4) / 4;
-    if count > max_possible {
-        return Err(Error::from_reason("packed buffer: impossible item count"));
-    }
-
-    let mut out = Vec::with_capacity(4 + count * 4);
-    out.extend_from_slice(&(count as u32).to_le_bytes());
-    out.resize(4 + count * 4, 0);
-
-    let out_slice = &mut out[4..];
-
-    if should_parallelize(count, data.len().saturating_sub(4)) {
-        use rayon::prelude::*;
-
-        // Pre-compute offsets so we can iterate in parallel without allocations
-        let offsets: Vec<(usize, usize)> = {
-            let mut offsets = Vec::with_capacity(count);
-            let mut offset = 4usize;
-            for _ in 0..count {
-                if offset + 4 > data.len() {
-                    return Err(Error::from_reason("packed buffer: truncated length"));
-                }
-                let len = u32::from_le_bytes([
-                    data[offset], data[offset + 1], data[offset + 2], data[offset + 3],
-                ]) as usize;
-                offset += 4;
-                let end = offset + len;
-                if end > data.len() {
-                    return Err(Error::from_reason("packed buffer: truncated item"));
-                }
-                offsets.push((offset, len));
-                offset = end;
-            }
-            offsets
-        };
-
-        const CHUNK_ITEMS: usize = 256;
-
-        out_slice
-            .par_chunks_mut(CHUNK_ITEMS * 4)
-            .enumerate()
-            .for_each(|(ci, chunk)| {
-                let num_items = chunk.len() / 4;
-                let start = ci * CHUNK_ITEMS;
-                for (i, item) in offsets[start..start + num_items].iter().enumerate() {
-                    let crc = crc32fast::hash(&data[item.0..item.0 + item.1]);
-                    chunk[i * 4..(i + 1) * 4].copy_from_slice(&crc.to_le_bytes());
-                }
-            });
-    } else {
-        let mut offset = 4usize;
-        for i in 0..count {
-            if offset + 4 > data.len() {
-                return Err(Error::from_reason("packed buffer: truncated length"));
-            }
-            let len = u32::from_le_bytes([
-                data[offset], data[offset + 1], data[offset + 2], data[offset + 3],
-            ]) as usize;
-            offset += 4;
-            let end = offset + len;
-            if end > data.len() {
-                return Err(Error::from_reason("packed buffer: truncated item"));
-            }
-            let crc = crc32fast::hash(&data[offset..end]);
-            out_slice[i * 4..(i + 1) * 4].copy_from_slice(&crc.to_le_bytes());
-            offset = end;
-        }
-    }
-
-    Ok(Buffer::from(out))
-}

package/rust/headers.rs

@@ -1,234 +0,0 @@
-// rust/headers.rs — HeaderRefs: zero-alloc packed header parser
-// Extracted from ingress.rs for composability
-// Uses u64 word-at-a-time comparison for header name matching
-
-use napi::{Error, Result};
-
-// ── Header presence flags ─────────────────────────────────────────
-const HAS_ORIGIN: u8 = 1 << 0;
-const HAS_COOKIE: u8 = 1 << 1;
-const HAS_XFF: u8 = 1 << 2;
-const HAS_X_REAL_IP: u8 = 1 << 3;
-const HAS_XFP: u8 = 1 << 4;
-const HAS_ACRM: u8 = 1 << 5;
-const HAS_ACRH: u8 = 1 << 6;
-
-/// Zero-alloc reference-based representation of interesting headers.
-#[derive(Clone, Copy)]
-pub struct HeaderRefs<'a> {
-    origin: Option<&'a [u8]>,
-    cookie: Option<&'a [u8]>,
-    xff: Option<&'a [u8]>,
-    x_real_ip: Option<&'a [u8]>,
-    x_forwarded_proto: Option<&'a [u8]>,
-    acrm: Option<&'a [u8]>,
-    acrh: Option<&'a [u8]>,
-    flags: u8,
-}
-
-/// Load a u64 from the first N bytes of a byte slice, zero-padded.
-#[inline(always)]
-fn load_u64_padded(bytes: &[u8]) -> u64 {
-    let mut buf = [0u8; 8];
-    let len = bytes.len().min(8);
-    buf[..len].copy_from_slice(&bytes[..len]);
-    u64::from_le_bytes(buf)
-}
-
-/// Compare two byte slices using u64 word comparison for case-insensitive matching.
-/// Both inputs should be lowercase already (or we compute lowercase u64).
-#[inline(always)]
-fn byte_slice_eq_ignore_case(a: &[u8], b: &[u8]) -> bool {
-    if a.len() != b.len() {
-        return false;
-    }
-    // For short names (up to 8 bytes) use single u64 comparison
-    if a.len() <= 8 {
-        let wa = load_u64_padded(a) | 0x2020_2020_2020_2020;
-        let wb = load_u64_padded(b) | 0x2020_2020_2020_2020;
-        return wa == wb;
-    }
-    // For longer names: compare first 8 bytes, then remaining
-    if a.len() <= 16 {
-        let wa = load_u64_padded(a) | 0x2020_2020_2020_2020;
-        let wb = load_u64_padded(b) | 0x2020_2020_2020_2020;
-        if wa != wb {
-            return false;
-        }
-        let wa2 = load_u64_padded(&a[8..]) | 0x2020_2020_2020_2020;
-        let wb2 = load_u64_padded(&b[8..]) | 0x2020_2020_2020_2020;
-        return wa2 == wb2;
-    }
-    // Fallback
-    a.eq_ignore_ascii_case(b)
-}
-
-impl<'a> HeaderRefs<'a> {
-    #[inline(always)]
-    pub fn empty() -> Self {
-        Self {
-            origin: None,
-            cookie: None,
-            xff: None,
-            x_real_ip: None,
-            x_forwarded_proto: None,
-            acrm: None,
-            acrh: None,
-            flags: 0,
-        }
-    }
-
-    /// Parse packed headers from the input buffer.
-    /// Format: [u16 count] repeated { [u16 name_len] [name] [u32 value_len] [value] }
-    #[inline]
-    pub fn parse(packed: &'a [u8], is_options: bool, max_headers: usize) -> Result<Self> {
-        let mut h = Self::empty();
-
-        if packed.len() < 2 {
-            return Ok(h);
-        }
-
-        let count = u16::from_le_bytes([packed[0], packed[1]]) as usize;
-        if count > max_headers {
-            return Err(Error::from_reason("too many headers"));
-        }
-
-        let mut pos = 2usize;
-
-        for _ in 0..count {
-            if pos + 2 > packed.len() {
-                return Err(Error::from_reason("malformed packed headers"));
-            }
-
-            let name_len = u16::from_le_bytes([packed[pos], packed[pos + 1]]) as usize;
-            pos += 2;
-
-            if pos + name_len > packed.len() {
-                return Err(Error::from_reason("malformed packed header name"));
-            }
-
-            let name = &packed[pos..pos + name_len];
-            pos += name_len;
-
-            if pos + 4 > packed.len() {
-                return Err(Error::from_reason("malformed packed header value length"));
-            }
-
-            let value_len = u32::from_le_bytes([
-                packed[pos],
-                packed[pos + 1],
-                packed[pos + 2],
-                packed[pos + 3],
-            ]) as usize;
-            pos += 4;
-
-            if pos + value_len > packed.len() {
-                return Err(Error::from_reason("malformed packed header value"));
-            }
-
-            let value = &packed[pos..pos + value_len];
-            pos += value_len;
-
-            if name.is_empty() {
-                continue;
-            }
-
-            let first = name[0] | 0x20;
-
-            // Fast path: dispatch based on first character + name length
-            if first == b'o' && name.len() == 6 {
-                if byte_slice_eq_ignore_case(name, b"origin") {
-                    h.flags |= HAS_ORIGIN;
-                    h.origin = Some(value);
-                }
-            } else if first == b'c' && name.len() == 6 {
-                if byte_slice_eq_ignore_case(name, b"cookie") {
-                    h.flags |= HAS_COOKIE;
-                    h.cookie = Some(value);
-                }
-            } else if first == b'x' {
-                let name_len = name.len();
-                if name_len == 15 && byte_slice_eq_ignore_case(name, b"x-forwarded-for") {
-                    h.flags |= HAS_XFF;
-                    h.xff = Some(value);
-                } else if name_len == 9 && byte_slice_eq_ignore_case(name, b"x-real-ip") {
-                    h.flags |= HAS_X_REAL_IP;
-                    h.x_real_ip = Some(value);
-                } else if name_len == 17 && byte_slice_eq_ignore_case(name, b"x-forwarded-proto") {
-                    h.flags |= HAS_XFP;
-                    h.x_forwarded_proto = Some(value);
-                }
-            } else if first == b'a' && is_options {
-                if name.len() == 29 && byte_slice_eq_ignore_case(name, b"access-control-request-method") {
-                    h.flags |= HAS_ACRM;
-                    h.acrm = Some(value);
-                } else if name.len() == 30 && byte_slice_eq_ignore_case(name, b"access-control-request-headers") {
-                    h.flags |= HAS_ACRH;
-                    h.acrh = Some(value);
-                }
-            }
-        }
-
-        Ok(h)
-    }
-
-    #[inline(always)]
-    pub fn origin(&self) -> Option<&[u8]> {
-        self.origin
-    }
-
-    #[inline(always)]
-    pub fn cookie(&self) -> Option<&[u8]> {
-        self.cookie
-    }
-
-    #[inline(always)]
-    pub fn xff(&self) -> Option<&[u8]> {
-        self.xff
-    }
-
-    #[inline(always)]
-    pub fn x_real_ip(&self) -> Option<&[u8]> {
-        self.x_real_ip
-    }
-
-    #[inline(always)]
-    pub fn x_forwarded_proto(&self) -> Option<&[u8]> {
-        self.x_forwarded_proto
-    }
-
-    #[inline(always)]
-    pub fn acrm(&self) -> Option<&[u8]> {
-        self.acrm
-    }
-
-    #[inline(always)]
-    pub fn acrh(&self) -> Option<&[u8]> {
-        self.acrh
-    }
-
-    #[inline(always)]
-    pub fn has_origin(&self) -> bool {
-        (self.flags & HAS_ORIGIN) != 0
-    }
-
-    #[inline(always)]
-    pub fn has_cookie(&self) -> bool {
-        (self.flags & HAS_COOKIE) != 0
-    }
-
-    #[inline(always)]
-    pub fn has_xfp(&self) -> bool {
-        (self.flags & HAS_XFP) != 0
-    }
-
-    #[inline(always)]
-    pub fn has_acrm(&self) -> bool {
-        (self.flags & HAS_ACRM) != 0
-    }
-
-    #[inline(always)]
-    pub fn has_acrh(&self) -> bool {
-        (self.flags & HAS_ACRH) != 0
-    }
-}