Skip to main content

auth_framework/protocols/
kerberos.rs

1//! Kerberos / SPNEGO Authentication Protocol Support
2//!
3//! Implements Kerberos 5 (RFC 4120) ticket validation and SPNEGO (RFC 4178)
4//! negotiation for HTTP-based authentication, enabling seamless SSO with
5//! Active Directory and MIT Kerberos environments.
6//!
7//! # Supported Encryption Types
8//!
9//! - AES256-CTS-HMAC-SHA1-96 (etype 18) — recommended
10//! - AES128-CTS-HMAC-SHA1-96 (etype 17) — fallback
11//!
12//! # Architecture
13//!
14//! This module operates as a **service-side ticket validator**:
15//!
16//! 1. Client sends an `Authorization: Negotiate <token>` header
17//! 2. Server decodes the SPNEGO wrapper and extracts the Kerberos AP-REQ
18//! 3. Server decrypts the ticket using keytab keys (AES-CTS-HMAC-SHA1-96)
19//! 4. Server decrypts and verifies the authenticator using the session key
20//! 5. On success, extracts the client principal and returns an auth result
21//!
22//! # Security Considerations
23//!
24//! - Keytab files must be protected with strict filesystem permissions
25//! - Replay protection uses a time-windowed nonce cache
26//! - Clock skew tolerance is configurable (default: 5 minutes per RFC 4120)
27//! - All cryptographic comparisons use constant-time operations
28
29use crate::errors::{AuthError, Result};
30use aes::cipher::{BlockDecrypt, BlockEncrypt, KeyInit};
31use base64::Engine as _;
32use ring::rand::SecureRandom;
33use serde::{Deserialize, Serialize};
34use sha2::Digest;
35use std::collections::HashMap;
36use std::sync::Arc;
37use std::time::{SystemTime, UNIX_EPOCH};
38use subtle::ConstantTimeEq;
39use tokio::sync::RwLock;
40
41// ─── Constants ───────────────────────────────────────────────────────────────
42
43/// Encryption type: AES128-CTS-HMAC-SHA1-96 (RFC 3962).
44const ETYPE_AES128: i32 = 17;
45/// Encryption type: AES256-CTS-HMAC-SHA1-96 (RFC 3962).
46const ETYPE_AES256: i32 = 18;
47
48/// Key usage for ticket encryption (RFC 4120 §7.5.1).
49const KEY_USAGE_TICKET: u32 = 2;
50/// Key usage for AP-REQ authenticator (RFC 4120 §7.5.1, for AES etypes).
51const KEY_USAGE_AP_REQ_AUTH: u32 = 11;
52
53/// AES block size.
54const AES_BLOCK: usize = 16;
55/// HMAC-SHA1-96 output length (truncated to 96 bits = 12 bytes).
56const HMAC_LEN: usize = 12;
57/// Confounder length (one AES block).
58const CONFOUNDER_LEN: usize = 16;
59
60/// SPNEGO OID bytes (1.3.6.1.5.5.2) as encoded in DER (after tag+length).
61const SPNEGO_OID_BYTES: &[u8] = &[0x2b, 0x06, 0x01, 0x05, 0x05, 0x02];
62/// Kerberos 5 OID bytes (1.2.840.113554.1.2.2) as encoded in DER.
63const KRB5_OID_BYTES: &[u8] = &[0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x01, 0x02, 0x02];
64
65// ─── Minimal DER Parser ──────────────────────────────────────────────────────
66
67/// A parsed DER Tag-Length-Value.
68#[allow(dead_code)]
69#[derive(Debug)]
70struct DerTlv<'a> {
71    /// Tag class: 0=Universal, 1=Application, 2=Context-specific, 3=Private.
72    class: u8,
73    /// Whether this is a constructed encoding.
74    constructed: bool,
75    /// Tag number.
76    tag_num: u32,
77    /// The value bytes (content octets).
78    value: &'a [u8],
79}
80
81/// Parse one DER TLV from the front of `data`. Returns (tlv, remaining_bytes).
82fn parse_der(data: &[u8]) -> Result<(DerTlv<'_>, &[u8])> {
83    if data.is_empty() {
84        return Err(AuthError::validation("Empty DER data"));
85    }
86
87    let b0 = data[0];
88    let class = b0 >> 6;
89    let constructed = (b0 & 0x20) != 0;
90    let mut pos: usize = 1;
91
92    // Tag number
93    let tag_num = if (b0 & 0x1f) == 0x1f {
94        let mut t: u32 = 0;
95        loop {
96            if pos >= data.len() {
97                return Err(AuthError::validation("DER tag truncated"));
98            }
99            let b = data[pos];
100            pos += 1;
101            t = t
102                .checked_shl(7)
103                .ok_or_else(|| AuthError::validation("DER tag too large"))?
104                | (b & 0x7f) as u32;
105            if (b & 0x80) == 0 {
106                break;
107            }
108        }
109        t
110    } else {
111        (b0 & 0x1f) as u32
112    };
113
114    // Length
115    if pos >= data.len() {
116        return Err(AuthError::validation("DER length missing"));
117    }
118    let len_byte = data[pos];
119    pos += 1;
120
121    let length = if len_byte < 0x80 {
122        len_byte as usize
123    } else if len_byte == 0x80 {
124        return Err(AuthError::validation(
125            "Indefinite length not supported in DER",
126        ));
127    } else {
128        let num_bytes = (len_byte & 0x7f) as usize;
129        if num_bytes > 4 || pos + num_bytes > data.len() {
130            return Err(AuthError::validation("DER length overflow"));
131        }
132        let mut l: usize = 0;
133        for &b in &data[pos..pos + num_bytes] {
134            l = l
135                .checked_shl(8)
136                .ok_or_else(|| AuthError::validation("DER length too large"))?
137                | b as usize;
138        }
139        pos += num_bytes;
140        l
141    };
142
143    if pos + length > data.len() {
144        return Err(AuthError::validation("DER value truncated"));
145    }
146
147    Ok((
148        DerTlv {
149            class,
150            constructed,
151            tag_num,
152            value: &data[pos..pos + length],
153        },
154        &data[pos + length..],
155    ))
156}
157
158/// Parse all consecutive TLVs from the content of a constructed DER object.
159fn parse_der_contents(data: &[u8]) -> Result<Vec<DerTlv<'_>>> {
160    let mut result = Vec::new();
161    let mut remaining = data;
162    while !remaining.is_empty() {
163        let (tlv, rest) = parse_der(remaining)?;
164        result.push(tlv);
165        remaining = rest;
166    }
167    Ok(result)
168}
169
170/// Find a context-tagged field ([n] EXPLICIT) in a list of DER TLVs.
171fn get_ctx_field<'a, 'b>(fields: &'b [DerTlv<'a>], tag: u32) -> Option<&'b DerTlv<'a>> {
172    fields.iter().find(|f| f.class == 2 && f.tag_num == tag)
173}
174
175/// Unwrap an explicit context tag: parse the inner TLV from the tag's value.
176fn unwrap_explicit<'a>(tlv: &DerTlv<'a>) -> Result<DerTlv<'a>> {
177    let (inner, _) = parse_der(tlv.value)?;
178    Ok(inner)
179}
180
181/// Parse a DER INTEGER value as i64.
182fn parse_der_integer(data: &[u8]) -> Result<i64> {
183    if data.is_empty() {
184        return Err(AuthError::validation("Empty INTEGER"));
185    }
186    let mut val: i64 = if data[0] & 0x80 != 0 { -1 } else { 0 };
187    for &b in data {
188        val = (val << 8) | b as i64;
189    }
190    Ok(val)
191}
192
193/// Parse a DER GeneralString / GeneralizedTime / IA5String as UTF-8.
194fn parse_der_string(data: &[u8]) -> Result<String> {
195    String::from_utf8(data.to_vec())
196        .map_err(|e| AuthError::validation(format!("Invalid string encoding: {e}")))
197}
198
199/// Parse KerberosTime (GeneralizedTime: "YYYYMMDDHHmmSSZ") to Unix timestamp.
200fn parse_kerberos_time(data: &[u8]) -> Result<u64> {
201    let s = parse_der_string(data)?;
202    if s.len() < 15 || !s.ends_with('Z') {
203        return Err(AuthError::validation("Invalid KerberosTime format"));
204    }
205    let dt = chrono::NaiveDateTime::parse_from_str(&s[..14], "%Y%m%d%H%M%S")
206        .map_err(|e| AuthError::validation(format!("Invalid KerberosTime: {e}")))?;
207    Ok(dt.and_utc().timestamp() as u64)
208}
209
210/// Test a single bit in a BIT STRING value (after the unused-bits byte).
211/// Bit numbering follows ASN.1: bit 0 is the MSB of the first content octet.
212fn test_bit_flag(flags_data: &[u8], bit_num: usize) -> bool {
213    if flags_data.is_empty() {
214        return false;
215    }
216    // First byte is unused-bits count; actual flag bytes start at index 1
217    let byte_idx = 1 + bit_num / 8;
218    let bit_idx = 7 - (bit_num % 8);
219    if byte_idx >= flags_data.len() {
220        return false;
221    }
222    (flags_data[byte_idx] >> bit_idx) & 1 == 1
223}
224
225/// Compare a DER OID's value bytes against a known OID byte pattern.
226fn oid_matches(tlv: &DerTlv<'_>, expected: &[u8]) -> bool {
227    tlv.class == 0 && tlv.tag_num == 6 && tlv.value == expected
228}
229
230// ─── Kerberos ASN.1 Structures ───────────────────────────────────────────────
231
232/// Parsed EncryptedData (RFC 4120 §5.2.9).
233struct ParsedEncryptedData<'a> {
234    etype: i32,
235    kvno: Option<u32>,
236    cipher: &'a [u8],
237}
238
239/// Parsed PrincipalName (RFC 4120 §5.2.2).
240struct ParsedPrincipalName {
241    components: Vec<String>,
242}
243
244impl ParsedPrincipalName {
245    /// Reconstruct as "comp1/comp2/...".
246    fn to_string_without_realm(&self) -> String {
247        self.components.join("/")
248    }
249}
250
251/// Parsed Ticket fields (RFC 4120 §5.3).
252struct ParsedTicket<'a> {
253    realm: String,
254    sname: ParsedPrincipalName,
255    enc_part: ParsedEncryptedData<'a>,
256}
257
258/// Parsed AP-REQ (RFC 4120 §5.5.1).
259#[allow(dead_code)]
260struct ParsedApReq<'a> {
261    ap_options: u32,
262    ticket: ParsedTicket<'a>,
263    authenticator: ParsedEncryptedData<'a>,
264}
265
266/// Decrypted EncTicketPart (RFC 4120 §5.3).
267#[allow(dead_code)]
268struct DecryptedTicketPart {
269    flags_raw: Vec<u8>,
270    session_key_type: i32,
271    session_key_value: Vec<u8>,
272    crealm: String,
273    cname: ParsedPrincipalName,
274    auth_time: u64,
275    end_time: u64,
276    start_time: Option<u64>,
277    renew_till: Option<u64>,
278}
279
280/// Decrypted Authenticator (RFC 4120 §5.5.1).
281struct DecryptedAuthenticator {
282    crealm: String,
283    cname: ParsedPrincipalName,
284    cusec: u32,
285    ctime: u64,
286}
287
288fn parse_encrypted_data<'a>(data: &'a [u8]) -> Result<ParsedEncryptedData<'a>> {
289    let (seq, _) = parse_der(data)?;
290    if seq.tag_num != 16 {
291        return Err(AuthError::validation("EncryptedData: expected SEQUENCE"));
292    }
293    let fields = parse_der_contents(seq.value)?;
294
295    let etype_f = get_ctx_field(&fields, 0)
296        .ok_or_else(|| AuthError::validation("EncryptedData missing etype"))?;
297    let etype = parse_der_integer(unwrap_explicit(etype_f)?.value)? as i32;
298
299    let kvno = if let Some(f) = get_ctx_field(&fields, 1) {
300        Some(parse_der_integer(unwrap_explicit(f)?.value)? as u32)
301    } else {
302        None
303    };
304
305    let cipher_f = get_ctx_field(&fields, 2)
306        .ok_or_else(|| AuthError::validation("EncryptedData missing cipher"))?;
307    let cipher_tlv = unwrap_explicit(cipher_f)?;
308
309    Ok(ParsedEncryptedData {
310        etype,
311        kvno,
312        cipher: cipher_tlv.value,
313    })
314}
315
316fn parse_principal_name(data: &[u8]) -> Result<ParsedPrincipalName> {
317    let (seq, _) = parse_der(data)?;
318    let fields = parse_der_contents(seq.value)?;
319
320    // [1] SEQUENCE OF KerberosString
321    let strings_f = get_ctx_field(&fields, 1)
322        .ok_or_else(|| AuthError::validation("PrincipalName missing name-string"))?;
323    let (strings_seq, _) = parse_der(strings_f.value)?;
324    let string_tlvs = parse_der_contents(strings_seq.value)?;
325
326    let mut components = Vec::new();
327    for tlv in &string_tlvs {
328        components.push(parse_der_string(tlv.value)?);
329    }
330
331    Ok(ParsedPrincipalName { components })
332}
333
334fn parse_ticket<'a>(data: &'a [u8]) -> Result<ParsedTicket<'a>> {
335    // [APPLICATION 1] SEQUENCE
336    let (app, _) = parse_der(data)?;
337    if app.class != 1 || app.tag_num != 1 {
338        return Err(AuthError::validation("Expected Ticket (APPLICATION 1)"));
339    }
340    let (seq, _) = parse_der(app.value)?;
341    let fields = parse_der_contents(seq.value)?;
342
343    // [0] tkt-vno INTEGER
344    let vno_f =
345        get_ctx_field(&fields, 0).ok_or_else(|| AuthError::validation("Ticket missing tkt-vno"))?;
346    let vno = parse_der_integer(unwrap_explicit(vno_f)?.value)?;
347    if vno != 5 {
348        return Err(AuthError::validation(format!(
349            "Unsupported ticket version: {vno}"
350        )));
351    }
352
353    // [1] realm GeneralString
354    let realm_f =
355        get_ctx_field(&fields, 1).ok_or_else(|| AuthError::validation("Ticket missing realm"))?;
356    let realm = parse_der_string(unwrap_explicit(realm_f)?.value)?;
357
358    // [2] sname PrincipalName
359    let sname_f =
360        get_ctx_field(&fields, 2).ok_or_else(|| AuthError::validation("Ticket missing sname"))?;
361    let sname = parse_principal_name(sname_f.value)?;
362
363    // [3] enc-part EncryptedData
364    let enc_f = get_ctx_field(&fields, 3)
365        .ok_or_else(|| AuthError::validation("Ticket missing enc-part"))?;
366    let enc_part = parse_encrypted_data(enc_f.value)?;
367
368    Ok(ParsedTicket {
369        realm,
370        sname,
371        enc_part,
372    })
373}
374
375fn parse_ap_req<'a>(data: &'a [u8]) -> Result<ParsedApReq<'a>> {
376    // [APPLICATION 14] SEQUENCE
377    let (app, _) = parse_der(data)?;
378    if app.class != 1 || app.tag_num != 14 {
379        return Err(AuthError::validation("Expected AP-REQ (APPLICATION 14)"));
380    }
381    let (seq, _) = parse_der(app.value)?;
382    let fields = parse_der_contents(seq.value)?;
383
384    // [0] pvno INTEGER (must be 5)
385    let pvno_f =
386        get_ctx_field(&fields, 0).ok_or_else(|| AuthError::validation("AP-REQ missing pvno"))?;
387    let pvno = parse_der_integer(unwrap_explicit(pvno_f)?.value)?;
388    if pvno != 5 {
389        return Err(AuthError::validation(format!(
390            "Unsupported Kerberos version: {pvno}"
391        )));
392    }
393
394    // [1] msg-type INTEGER (must be 14)
395    let mt_f = get_ctx_field(&fields, 1)
396        .ok_or_else(|| AuthError::validation("AP-REQ missing msg-type"))?;
397    let mt = parse_der_integer(unwrap_explicit(mt_f)?.value)?;
398    if mt != 14 {
399        return Err(AuthError::validation(format!(
400            "Expected AP-REQ msg-type 14, got {mt}"
401        )));
402    }
403
404    // [2] ap-options BIT STRING
405    let opts_f = get_ctx_field(&fields, 2)
406        .ok_or_else(|| AuthError::validation("AP-REQ missing ap-options"))?;
407    let opts_tlv = unwrap_explicit(opts_f)?;
408    let ap_options = parse_ap_options(&opts_tlv)?;
409
410    // [3] ticket Ticket
411    let ticket_f =
412        get_ctx_field(&fields, 3).ok_or_else(|| AuthError::validation("AP-REQ missing ticket"))?;
413    let ticket = parse_ticket(ticket_f.value)?;
414
415    // [4] authenticator EncryptedData
416    let auth_f = get_ctx_field(&fields, 4)
417        .ok_or_else(|| AuthError::validation("AP-REQ missing authenticator"))?;
418    let authenticator = parse_encrypted_data(auth_f.value)?;
419
420    Ok(ParsedApReq {
421        ap_options,
422        ticket,
423        authenticator,
424    })
425}
426
427/// Parse AP-REQ options BIT STRING into a u32 flags word.
428fn parse_ap_options(tlv: &DerTlv<'_>) -> Result<u32> {
429    if tlv.value.len() < 2 {
430        return Ok(0);
431    }
432    // First byte = unused bits count, rest = flag bytes
433    let mut flags: u32 = 0;
434    for (i, &b) in tlv.value[1..].iter().enumerate() {
435        if i >= 4 {
436            break;
437        }
438        flags |= (b as u32) << (24 - i * 8);
439    }
440    Ok(flags)
441}
442
443/// Parse decrypted EncTicketPart ([APPLICATION 3] SEQUENCE).
444fn parse_enc_ticket_part(data: &[u8]) -> Result<DecryptedTicketPart> {
445    let (app, _) = parse_der(data)?;
446    if app.class != 1 || app.tag_num != 3 {
447        return Err(AuthError::validation(
448            "Expected EncTicketPart (APPLICATION 3)",
449        ));
450    }
451    let (seq, _) = parse_der(app.value)?;
452    let fields = parse_der_contents(seq.value)?;
453
454    // [0] flags BIT STRING
455    let flags_f = get_ctx_field(&fields, 0)
456        .ok_or_else(|| AuthError::validation("EncTicketPart missing flags"))?;
457    let flags_tlv = unwrap_explicit(flags_f)?;
458    let flags_raw = flags_tlv.value.to_vec();
459
460    // [1] key EncryptionKey
461    let key_f = get_ctx_field(&fields, 1)
462        .ok_or_else(|| AuthError::validation("EncTicketPart missing key"))?;
463    let (key_seq, _) = parse_der(key_f.value)?;
464    let key_fields = parse_der_contents(key_seq.value)?;
465    let key_type_f = get_ctx_field(&key_fields, 0)
466        .ok_or_else(|| AuthError::validation("EncryptionKey missing keytype"))?;
467    let key_type = parse_der_integer(unwrap_explicit(key_type_f)?.value)? as i32;
468    let key_val_f = get_ctx_field(&key_fields, 1)
469        .ok_or_else(|| AuthError::validation("EncryptionKey missing keyvalue"))?;
470    let key_value = unwrap_explicit(key_val_f)?.value.to_vec();
471
472    // [2] crealm GeneralString
473    let crealm_f = get_ctx_field(&fields, 2)
474        .ok_or_else(|| AuthError::validation("EncTicketPart missing crealm"))?;
475    let crealm = parse_der_string(unwrap_explicit(crealm_f)?.value)?;
476
477    // [3] cname PrincipalName
478    let cname_f = get_ctx_field(&fields, 3)
479        .ok_or_else(|| AuthError::validation("EncTicketPart missing cname"))?;
480    let cname = parse_principal_name(cname_f.value)?;
481
482    // [5] authtime KerberosTime
483    let authtime_f = get_ctx_field(&fields, 5)
484        .ok_or_else(|| AuthError::validation("EncTicketPart missing authtime"))?;
485    let auth_time = parse_kerberos_time(unwrap_explicit(authtime_f)?.value)?;
486
487    // [6] starttime KerberosTime OPTIONAL
488    let start_time = if let Some(f) = get_ctx_field(&fields, 6) {
489        Some(parse_kerberos_time(unwrap_explicit(f)?.value)?)
490    } else {
491        None
492    };
493
494    // [7] endtime KerberosTime
495    let endtime_f = get_ctx_field(&fields, 7)
496        .ok_or_else(|| AuthError::validation("EncTicketPart missing endtime"))?;
497    let end_time = parse_kerberos_time(unwrap_explicit(endtime_f)?.value)?;
498
499    // [8] renew-till KerberosTime OPTIONAL
500    let renew_till = if let Some(f) = get_ctx_field(&fields, 8) {
501        Some(parse_kerberos_time(unwrap_explicit(f)?.value)?)
502    } else {
503        None
504    };
505
506    Ok(DecryptedTicketPart {
507        flags_raw,
508        session_key_type: key_type,
509        session_key_value: key_value,
510        crealm,
511        cname,
512        auth_time,
513        end_time,
514        start_time,
515        renew_till,
516    })
517}
518
519/// Parse decrypted Authenticator ([APPLICATION 2] SEQUENCE).
520fn parse_authenticator(data: &[u8]) -> Result<DecryptedAuthenticator> {
521    let (app, _) = parse_der(data)?;
522    if app.class != 1 || app.tag_num != 2 {
523        return Err(AuthError::validation(
524            "Expected Authenticator (APPLICATION 2)",
525        ));
526    }
527    let (seq, _) = parse_der(app.value)?;
528    let fields = parse_der_contents(seq.value)?;
529
530    // [0] authenticator-vno INTEGER (5)
531    let vno_f = get_ctx_field(&fields, 0)
532        .ok_or_else(|| AuthError::validation("Authenticator missing vno"))?;
533    let vno = parse_der_integer(unwrap_explicit(vno_f)?.value)?;
534    if vno != 5 {
535        return Err(AuthError::validation(format!(
536            "Unsupported authenticator version: {vno}"
537        )));
538    }
539
540    // [1] crealm GeneralString
541    let crealm_f = get_ctx_field(&fields, 1)
542        .ok_or_else(|| AuthError::validation("Authenticator missing crealm"))?;
543    let crealm = parse_der_string(unwrap_explicit(crealm_f)?.value)?;
544
545    // [2] cname PrincipalName
546    let cname_f = get_ctx_field(&fields, 2)
547        .ok_or_else(|| AuthError::validation("Authenticator missing cname"))?;
548    let cname = parse_principal_name(cname_f.value)?;
549
550    // [3] cusec Microseconds (INTEGER)
551    let cusec_f = get_ctx_field(&fields, 3)
552        .ok_or_else(|| AuthError::validation("Authenticator missing cusec"))?;
553    let cusec = parse_der_integer(unwrap_explicit(cusec_f)?.value)? as u32;
554
555    // [4] ctime KerberosTime
556    let ctime_f = get_ctx_field(&fields, 4)
557        .ok_or_else(|| AuthError::validation("Authenticator missing ctime"))?;
558    let ctime = parse_kerberos_time(unwrap_explicit(ctime_f)?.value)?;
559
560    Ok(DecryptedAuthenticator {
561        crealm,
562        cname,
563        cusec,
564        ctime,
565    })
566}
567
568// ─── Kerberos Cryptography ───────────────────────────────────────────────────
569
570/// Greatest common divisor.
571fn gcd(a: usize, b: usize) -> usize {
572    if b == 0 { a } else { gcd(b, a % b) }
573}
574
575/// Least common multiple.
576fn lcm(a: usize, b: usize) -> usize {
577    a / gcd(a, b) * b
578}
579
580/// n-fold algorithm (RFC 3961 §5.1).
581///
582/// Folds an arbitrary-length input to an `output_len`-byte output.
583/// Direct port of the MIT Kerberos reference implementation.
584fn nfold(input: &[u8], output_len: usize) -> Vec<u8> {
585    let in_bytes = input.len();
586    let out_bytes = output_len;
587    let lcm_val = lcm(in_bytes, out_bytes);
588    let in_bits = in_bytes * 8;
589
590    let mut out = vec![0u8; out_bytes];
591    let mut byte: u32 = 0;
592
593    for i in (0..lcm_val).rev() {
594        // Compute the msbit in the input which gets added into this byte
595        let msbit =
596            ((in_bits - 1) + ((in_bits + 13) * (i / in_bytes)) + ((in_bytes - i % in_bytes) * 8))
597                % in_bits;
598
599        // Pull out the byte value from the input at the computed bit position
600        let high = input[((in_bytes - 1).wrapping_sub(msbit >> 3)) % in_bytes] as u32;
601        let low = input[(in_bytes.wrapping_sub(msbit >> 3)) % in_bytes] as u32;
602        byte += ((high << 8 | low) >> ((msbit & 7) + 1)) & 0xff;
603
604        // Do the addition
605        byte += out[i % out_bytes] as u32;
606        out[i % out_bytes] = (byte & 0xff) as u8;
607
608        // Keep around the carry bit
609        byte >>= 8;
610    }
611
612    // If there's a carry bit left over, add it back in
613    if byte != 0 {
614        for i in (0..out_bytes).rev() {
615            byte += out[i] as u32;
616            out[i] = (byte & 0xff) as u8;
617            byte >>= 8;
618        }
619    }
620
621    out
622}
623
624/// AES-ECB encrypt a single 16-byte block. Supports 16-byte (AES-128) or
625/// 32-byte (AES-256) keys.
626fn aes_ecb_encrypt(key: &[u8], block: &[u8; AES_BLOCK]) -> [u8; AES_BLOCK] {
627    let mut blk = aes::cipher::generic_array::GenericArray::clone_from_slice(block);
628    match key.len() {
629        16 => {
630            let cipher =
631                aes::Aes128::new(aes::cipher::generic_array::GenericArray::from_slice(key));
632            cipher.encrypt_block(&mut blk);
633        }
634        32 => {
635            let cipher =
636                aes::Aes256::new(aes::cipher::generic_array::GenericArray::from_slice(key));
637            cipher.encrypt_block(&mut blk);
638        }
639        _ => unreachable!("aes_ecb_encrypt: unsupported key length"),
640    }
641    let mut out = [0u8; AES_BLOCK];
642    out.copy_from_slice(&blk);
643    out
644}
645
646/// AES-ECB decrypt a single 16-byte block.
647fn aes_ecb_decrypt(key: &[u8], block: &[u8; AES_BLOCK]) -> [u8; AES_BLOCK] {
648    let mut blk = aes::cipher::generic_array::GenericArray::clone_from_slice(block);
649    match key.len() {
650        16 => {
651            let cipher =
652                aes::Aes128::new(aes::cipher::generic_array::GenericArray::from_slice(key));
653            cipher.decrypt_block(&mut blk);
654        }
655        32 => {
656            let cipher =
657                aes::Aes256::new(aes::cipher::generic_array::GenericArray::from_slice(key));
658            cipher.decrypt_block(&mut blk);
659        }
660        _ => unreachable!("aes_ecb_decrypt: unsupported key length"),
661    }
662    let mut out = [0u8; AES_BLOCK];
663    out.copy_from_slice(&blk);
664    out
665}
666
667/// XOR two byte slices of the same length.
668fn xor_bytes(a: &[u8], b: &[u8]) -> Vec<u8> {
669    a.iter().zip(b.iter()).map(|(&x, &y)| x ^ y).collect()
670}
671
672/// Derive a Kerberos sub-key from a base key using the RFC 3961 DK function.
673///
674/// `key_type` selects the derivative:
675///   - `0xAA` → Ke (encryption key)
676///   - `0x55` → Ki (integrity / HMAC key)
677///   - `0x99` → Kc (checksum key)
678fn derive_key_aes(base_key: &[u8], usage: u32, key_type: u8) -> Vec<u8> {
679    let constant = [
680        (usage >> 24) as u8,
681        (usage >> 16) as u8,
682        (usage >> 8) as u8,
683        usage as u8,
684        key_type,
685    ];
686
687    // n-fold the constant to the AES block size
688    let nfolded = nfold(&constant, AES_BLOCK);
689
690    let key_size = base_key.len(); // 16 for AES-128, 32 for AES-256
691    let mut derived = Vec::with_capacity(key_size);
692
693    let mut input: [u8; AES_BLOCK] = nfolded.try_into().expect("nfold produced wrong size");
694    while derived.len() < key_size {
695        let encrypted = aes_ecb_encrypt(base_key, &input);
696        derived.extend_from_slice(&encrypted);
697        input = encrypted;
698    }
699
700    derived.truncate(key_size);
701    derived
702}
703
704/// AES-CBC decrypt with a zero IV. Returns the full plaintext (same length as
705/// ciphertext, which must be a multiple of 16).
706fn aes_cbc_decrypt(key: &[u8], ciphertext: &[u8]) -> Result<Vec<u8>> {
707    if !ciphertext.len().is_multiple_of(AES_BLOCK) || ciphertext.is_empty() {
708        return Err(AuthError::crypto(
709            "AES-CBC ciphertext must be a non-empty multiple of block size",
710        ));
711    }
712
713    let mut plaintext = Vec::with_capacity(ciphertext.len());
714    let mut prev = [0u8; AES_BLOCK]; // IV = all zeros for Kerberos
715
716    // The length check above guarantees an exact multiple of AES_BLOCK, so the
717    // remainder returned by `as_chunks` is empty and no input is dropped.
718    let (blocks, _remainder) = ciphertext.as_chunks::<AES_BLOCK>();
719    for ct_block in blocks.iter().copied() {
720        let decrypted = aes_ecb_decrypt(key, &ct_block);
721        let pt_block = xor_bytes(&decrypted, &prev);
722        plaintext.extend_from_slice(&pt_block);
723        prev = ct_block;
724    }
725
726    Ok(plaintext)
727}
728
729/// AES-CTS (Cipher Text Stealing) decryption (RFC 3962 / RFC 3961).
730///
731/// Handles three cases:
732///   - Exactly 1 block: ECB decrypt with zero IV
733///   - Multiple of block size: standard CBC decrypt
734///   - Non-multiple: CBC-CTS with last-two-block swap
735fn aes_cts_decrypt(key: &[u8], ciphertext: &[u8]) -> Result<Vec<u8>> {
736    let n = ciphertext.len();
737    if n < AES_BLOCK {
738        return Err(AuthError::crypto("AES-CTS ciphertext too short"));
739    }
740
741    if n == AES_BLOCK {
742        // Single block: ECB decrypt XOR with zero IV = just ECB decrypt
743        let ct: [u8; AES_BLOCK] = ciphertext
744            .try_into()
745            .expect("length was checked to equal AES_BLOCK above");
746        return Ok(aes_ecb_decrypt(key, &ct).to_vec());
747    }
748
749    if n.is_multiple_of(AES_BLOCK) {
750        // Exact multiple: standard CBC
751        return aes_cbc_decrypt(key, ciphertext);
752    }
753
754    // CTS case: non-multiple of block size
755    let partial_len = n % AES_BLOCK;
756    let num_full_blocks = n / AES_BLOCK; // at least 1
757    let preceding_len = (num_full_blocks - 1) * AES_BLOCK;
758
759    let c_second_last: [u8; AES_BLOCK] = ciphertext[preceding_len..preceding_len + AES_BLOCK]
760        .try_into()
761        .expect("slice is exactly AES_BLOCK bytes by construction");
762    let c_last = &ciphertext[preceding_len + AES_BLOCK..];
763
764    // Determine the CBC IV for the CTS pair
765    let prev_cipher = if preceding_len >= AES_BLOCK {
766        &ciphertext[preceding_len - AES_BLOCK..preceding_len]
767    } else {
768        &[0u8; AES_BLOCK][..] // zero IV
769    };
770
771    // ECB decrypt the second-to-last ciphertext block
772    let d = aes_ecb_decrypt(key, &c_second_last);
773
774    // Recover the partial plaintext (last block)
775    let p_last = xor_bytes(&d[..partial_len], c_last);
776
777    // Recover the full "un-swapped" penultimate ciphertext block
778    let mut c_recovered = [0u8; AES_BLOCK];
779    c_recovered[..partial_len].copy_from_slice(c_last);
780    c_recovered[partial_len..].copy_from_slice(&d[partial_len..]);
781
782    // CBC decrypt the recovered block
783    let decrypted_recovered = aes_ecb_decrypt(key, &c_recovered);
784    let p_second_last = xor_bytes(&decrypted_recovered, prev_cipher);
785
786    // CBC decrypt the preceding blocks (if any)
787    let mut plaintext = if preceding_len > 0 {
788        aes_cbc_decrypt(key, &ciphertext[..preceding_len])?
789    } else {
790        Vec::new()
791    };
792
793    plaintext.extend_from_slice(&p_second_last);
794    plaintext.extend_from_slice(&p_last);
795
796    Ok(plaintext)
797}
798
799/// Compute HMAC-SHA1 over the given data, returning the full 20-byte output.
800fn hmac_sha1(key: &[u8], data: &[u8]) -> Vec<u8> {
801    use hmac::{Hmac, Mac};
802    type HmacSha1 = Hmac<sha1::Sha1>;
803
804    let mut mac = <HmacSha1 as Mac>::new_from_slice(key).expect("HMAC-SHA1 accepts any key length");
805    mac.update(data);
806    mac.finalize().into_bytes().to_vec()
807}
808
809/// Decrypt a Kerberos AES-CTS-HMAC-SHA1-96 ciphertext (RFC 3962).
810///
811/// Layout: `ciphertext_body || hmac_sha1_96` where
812///   - `ciphertext_body` = AES-CTS encrypted `confounder || plaintext`
813///   - `hmac_sha1_96`    = HMAC-SHA1 truncated to 96 bits (12 bytes)
814fn decrypt_aes_cts(base_key: &[u8], ciphertext: &[u8], etype: i32, usage: u32) -> Result<Vec<u8>> {
815    let expected_key_len = match etype {
816        ETYPE_AES128 => 16,
817        ETYPE_AES256 => 32,
818        _ => {
819            return Err(AuthError::crypto(format!(
820                "Unsupported encryption type {etype}; only AES etypes 17/18 are supported"
821            )));
822        }
823    };
824
825    if base_key.len() != expected_key_len {
826        return Err(AuthError::crypto(format!(
827            "Key length mismatch: expected {expected_key_len}, got {}",
828            base_key.len()
829        )));
830    }
831
832    if ciphertext.len() < CONFOUNDER_LEN + HMAC_LEN {
833        return Err(AuthError::crypto(
834            "Ciphertext too short for AES-CTS envelope",
835        ));
836    }
837
838    let ct_body = &ciphertext[..ciphertext.len() - HMAC_LEN];
839    let expected_hmac = &ciphertext[ciphertext.len() - HMAC_LEN..];
840
841    // Derive Ke (encryption) and Ki (integrity) sub-keys
842    let ke = derive_key_aes(base_key, usage, 0xAA);
843    let ki = derive_key_aes(base_key, usage, 0x55);
844
845    // Decrypt
846    let plaintext_with_confounder = aes_cts_decrypt(&ke, ct_body)?;
847
848    // Verify HMAC-SHA1-96 over the decrypted plaintext (including confounder)
849    let computed_hmac = hmac_sha1(&ki, &plaintext_with_confounder);
850    if computed_hmac[..HMAC_LEN].ct_eq(expected_hmac).unwrap_u8() != 1 {
851        return Err(AuthError::crypto(
852            "Kerberos HMAC verification failed — wrong key or corrupted ticket",
853        ));
854    }
855
856    // Strip confounder
857    Ok(plaintext_with_confounder[CONFOUNDER_LEN..].to_vec())
858}
859
860// ─── SPNEGO Parsing ──────────────────────────────────────────────────────────
861
862/// Parse a GSS-API / SPNEGO initial context token.
863///
864/// Structure:
865/// ```text
866/// [APPLICATION 0] SEQUENCE {
867///     thisMech  OID (SPNEGO),
868///     innerToken  NegTokenInit (as [CONTEXT 0])
869/// }
870/// ```
871fn parse_spnego_init_token(data: &[u8]) -> Result<SpnegoToken> {
872    // [APPLICATION 0] wrapper
873    let (app, _) = parse_der(data)?;
874    if app.class != 1 || app.tag_num != 0 {
875        return Err(AuthError::validation(
876            "Expected GSS-API InitialContextToken (APPLICATION 0)",
877        ));
878    }
879
880    // Inner: OID followed by NegTokenInit
881    let (oid_tlv, rest) = parse_der(app.value)?;
882    if !oid_matches(&oid_tlv, SPNEGO_OID_BYTES) {
883        return Err(AuthError::validation("Not an SPNEGO token"));
884    }
885
886    // NegTokenInit is [CONTEXT 0] IMPLICIT SEQUENCE
887    let (neg_init_wrapper, _) = parse_der(rest)?;
888    if neg_init_wrapper.class != 2 || neg_init_wrapper.tag_num != 0 {
889        return Err(AuthError::validation("Expected NegTokenInit ([CONTEXT 0])"));
890    }
891
892    // Inner SEQUENCE
893    let (neg_init_seq, _) = parse_der(neg_init_wrapper.value)?;
894    let fields = parse_der_contents(neg_init_seq.value)?;
895
896    // [0] mechTypes: SEQUENCE OF OID
897    let mech_types_f = get_ctx_field(&fields, 0)
898        .ok_or_else(|| AuthError::validation("NegTokenInit missing mechTypes"))?;
899    let (mech_seq, _) = parse_der(mech_types_f.value)?;
900    let mech_oids = parse_der_contents(mech_seq.value)?;
901
902    // Check if Kerberos 5 is among the offered mechanisms
903    let has_krb5 = mech_oids.iter().any(|o| oid_matches(o, KRB5_OID_BYTES));
904    if !has_krb5 {
905        return Err(AuthError::validation(
906            "SPNEGO NegTokenInit does not offer Kerberos 5",
907        ));
908    }
909
910    // [2] mechToken: OCTET STRING (the AP-REQ)
911    let mech_token_f = get_ctx_field(&fields, 2)
912        .ok_or_else(|| AuthError::validation("NegTokenInit missing mechToken"))?;
913    let mech_token_tlv = unwrap_explicit(mech_token_f)?;
914
915    Ok(SpnegoToken {
916        mech_oid: oid::KERBEROS_V5.to_string(),
917        mech_token: mech_token_tlv.value.to_vec(),
918        state: SpnegoState::Initial,
919    })
920}
921
922/// Parse a SPNEGO NegTokenResp ([CONTEXT 1]).
923fn parse_spnego_resp_token(data: &[u8]) -> Result<SpnegoToken> {
924    let (wrapper, _) = parse_der(data)?;
925    if wrapper.class != 2 || wrapper.tag_num != 1 {
926        return Err(AuthError::validation("Expected NegTokenResp ([CONTEXT 1])"));
927    }
928
929    let (seq, _) = parse_der(wrapper.value)?;
930    let fields = parse_der_contents(seq.value)?;
931
932    // [2] responseToken OCTET STRING OPTIONAL
933    let mech_token = if let Some(f) = get_ctx_field(&fields, 2) {
934        unwrap_explicit(f)?.value.to_vec()
935    } else {
936        Vec::new()
937    };
938
939    Ok(SpnegoToken {
940        mech_oid: oid::KERBEROS_V5.to_string(),
941        mech_token,
942        state: SpnegoState::Continue,
943    })
944}
945
946// ─── Configuration ───────────────────────────────────────────────────────────
947
948/// Kerberos / SPNEGO configuration.
949#[derive(Debug, Clone)]
950pub struct KerberosConfig {
951    /// Service principal name (e.g. `HTTP/server.example.com@REALM`).
952    pub service_principal: String,
953
954    /// Kerberos realm (e.g. `EXAMPLE.COM`).
955    pub realm: String,
956
957    /// Path to the keytab file.
958    pub keytab_path: Option<String>,
959
960    /// KDC addresses for ticket verification.
961    pub kdc_addresses: Vec<String>,
962
963    /// Maximum allowed clock skew (default: 300 seconds / 5 minutes).
964    pub max_clock_skew_secs: u64,
965
966    /// Whether to allow delegation (forwarded tickets).
967    pub allow_delegation: bool,
968
969    /// Maximum replay cache entries before eviction.
970    pub replay_cache_max_entries: usize,
971}
972
973impl Default for KerberosConfig {
974    fn default() -> Self {
975        Self {
976            service_principal: String::new(),
977            realm: String::new(),
978            keytab_path: None,
979            kdc_addresses: Vec::new(),
980            max_clock_skew_secs: 300,
981            allow_delegation: false,
982            replay_cache_max_entries: 100_000,
983        }
984    }
985}
986
987impl KerberosConfig {
988    /// Start building a [`KerberosConfig`] with the two required fields.
989    ///
990    /// All optional fields default to [`KerberosConfig::default()`] values.
991    /// Call [`.build()`](KerberosConfigBuilder::build) to validate and obtain
992    /// the finished config.
993    ///
994    /// # Example
995    /// ```rust,ignore
996    /// use auth_framework::protocols::kerberos::KerberosConfig;
997    ///
998    /// let config = KerberosConfig::builder(
999    ///         "HTTP/server.example.com@EXAMPLE.COM",
1000    ///         "EXAMPLE.COM",
1001    ///     )
1002    ///     .keytab_path("/etc/krb5.keytab")
1003    ///     .add_kdc("kdc1.example.com:88")
1004    ///     .add_kdc("kdc2.example.com:88")
1005    ///     .build();
1006    /// ```
1007    pub fn builder(
1008        service_principal: impl Into<String>,
1009        realm: impl Into<String>,
1010    ) -> KerberosConfigBuilder {
1011        KerberosConfigBuilder {
1012            config: KerberosConfig {
1013                service_principal: service_principal.into(),
1014                realm: realm.into(),
1015                ..Default::default()
1016            },
1017        }
1018    }
1019
1020    /// Shorthand for an Active Directory environment.
1021    ///
1022    /// Sets `allow_delegation` to `true` (common in AD) and leaves the
1023    /// rest at defaults.
1024    ///
1025    /// # Example
1026    /// ```rust,ignore
1027    /// let config = KerberosConfig::active_directory(
1028    ///     "HTTP/server.corp.example.com@CORP.EXAMPLE.COM",
1029    ///     "CORP.EXAMPLE.COM",
1030    /// );
1031    /// ```
1032    pub fn active_directory(
1033        service_principal: impl Into<String>,
1034        realm: impl Into<String>,
1035    ) -> Self {
1036        Self {
1037            service_principal: service_principal.into(),
1038            realm: realm.into(),
1039            allow_delegation: true,
1040            ..Default::default()
1041        }
1042    }
1043}
1044
1045/// Builder for [`KerberosConfig`].
1046///
1047/// Created via [`KerberosConfig::builder()`].
1048pub struct KerberosConfigBuilder {
1049    config: KerberosConfig,
1050}
1051
1052impl KerberosConfigBuilder {
1053    /// Set the path to the keytab file.
1054    pub fn keytab_path(mut self, path: impl Into<String>) -> Self {
1055        self.config.keytab_path = Some(path.into());
1056        self
1057    }
1058
1059    /// Append a KDC address (e.g. `"kdc.example.com:88"`).
1060    pub fn add_kdc(mut self, addr: impl Into<String>) -> Self {
1061        self.config.kdc_addresses.push(addr.into());
1062        self
1063    }
1064
1065    /// Set the maximum allowed clock skew in seconds (default: 300).
1066    pub fn max_clock_skew_secs(mut self, secs: u64) -> Self {
1067        self.config.max_clock_skew_secs = secs;
1068        self
1069    }
1070
1071    /// Enable or disable ticket delegation (default: `false`).
1072    pub fn allow_delegation(mut self, allow: bool) -> Self {
1073        self.config.allow_delegation = allow;
1074        self
1075    }
1076
1077    /// Set the maximum replay-cache size (default: 100 000).
1078    pub fn replay_cache_max_entries(mut self, max: usize) -> Self {
1079        self.config.replay_cache_max_entries = max;
1080        self
1081    }
1082
1083    /// Consume the builder and return the finished [`KerberosConfig`].
1084    pub fn build(self) -> KerberosConfig {
1085        self.config
1086    }
1087}
1088
1089// ─── Data Types ──────────────────────────────────────────────────────────────
1090
1091/// Kerberos authentication token OID constants.
1092pub mod oid {
1093    /// SPNEGO OID: 1.3.6.1.5.5.2
1094    pub const SPNEGO: &str = "1.3.6.1.5.5.2";
1095    /// Kerberos 5 OID: 1.2.840.113554.1.2.2
1096    pub const KERBEROS_V5: &str = "1.2.840.113554.1.2.2";
1097}
1098
1099/// Result of Kerberos authentication.
1100#[derive(Clone, Serialize, Deserialize)]
1101pub struct KerberosAuthResult {
1102    /// Authenticated client principal (e.g. `user@REALM`).
1103    pub client_principal: String,
1104
1105    /// Kerberos realm.
1106    pub realm: String,
1107
1108    /// When the ticket was issued.
1109    pub auth_time: u64,
1110
1111    /// When the ticket expires.
1112    pub end_time: u64,
1113
1114    /// Whether this is a delegated (forwarded) ticket.
1115    pub is_delegated: bool,
1116
1117    /// Session flags extracted from the ticket.
1118    pub flags: KerberosTicketFlags,
1119
1120    /// SPNEGO response token to return to the client (mutual auth).
1121    pub response_token: Option<String>,
1122}
1123
1124impl std::fmt::Debug for KerberosAuthResult {
1125    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1126        let mut d = f.debug_struct("KerberosAuthResult");
1127        d.field("client_principal", &self.client_principal);
1128        d.field("realm", &self.realm);
1129        d.field("auth_time", &self.auth_time);
1130        d.field("end_time", &self.end_time);
1131        d.field("is_delegated", &self.is_delegated);
1132        d.field("flags", &self.flags);
1133        d.field(
1134            "response_token",
1135            &crate::utils::redact::redacted(&self.response_token),
1136        );
1137        d.finish()
1138    }
1139}
1140
1141/// Kerberos ticket flags (RFC 4120 §5.3).
1142#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1143pub struct KerberosTicketFlags {
1144    pub forwardable: bool,
1145    pub forwarded: bool,
1146    pub proxiable: bool,
1147    pub proxy: bool,
1148    pub may_postdate: bool,
1149    pub postdated: bool,
1150    pub renewable: bool,
1151    pub pre_authent: bool,
1152    pub hw_authent: bool,
1153}
1154
1155/// SPNEGO negotiation state.
1156#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1157pub enum SpnegoState {
1158    /// Initial negotiation — expecting NegTokenInit.
1159    Initial,
1160    /// Continuation — expecting NegTokenResp.
1161    Continue,
1162    /// Negotiation complete.
1163    Completed,
1164    /// Negotiation rejected.
1165    Rejected,
1166}
1167
1168/// Parsed SPNEGO token (simplified).
1169#[derive(Clone)]
1170pub struct SpnegoToken {
1171    /// Which mechanism was selected.
1172    pub mech_oid: String,
1173    /// The mechanism-specific token bytes (AP-REQ for Kerberos).
1174    pub mech_token: Vec<u8>,
1175    /// Negotiation state.
1176    pub state: SpnegoState,
1177}
1178
1179impl std::fmt::Debug for SpnegoToken {
1180    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1181        let mut d = f.debug_struct("SpnegoToken");
1182        d.field("mech_oid", &self.mech_oid);
1183        d.field(
1184            "mech_token",
1185            &crate::utils::redact::redacted(&self.mech_token),
1186        );
1187        d.field("state", &self.state);
1188        d.finish()
1189    }
1190}
1191
1192/// Kerberos keytab entry.
1193#[derive(Clone)]
1194pub struct KeytabEntry {
1195    pub principal: String,
1196    pub realm: String,
1197    pub kvno: u32,
1198    pub key_type: u32,
1199    pub key_data: Vec<u8>,
1200}
1201
1202impl std::fmt::Debug for KeytabEntry {
1203    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1204        let mut d = f.debug_struct("KeytabEntry");
1205        d.field("principal", &self.principal);
1206        d.field("realm", &self.realm);
1207        d.field("kvno", &self.kvno);
1208        d.field("key_type", &self.key_type);
1209        d.field("key_data", &crate::utils::redact::redacted(&self.key_data));
1210        d.finish()
1211    }
1212}
1213
1214// ─── Manager ─────────────────────────────────────────────────────────────────
1215
1216/// Kerberos / SPNEGO authentication manager.
1217pub struct KerberosManager {
1218    config: KerberosConfig,
1219    /// Replay cache: authenticator hash → timestamp.
1220    replay_cache: Arc<RwLock<HashMap<Vec<u8>, u64>>>,
1221    /// Loaded keytab entries.
1222    keytab_entries: Arc<RwLock<Vec<KeytabEntry>>>,
1223}
1224
1225impl std::fmt::Debug for KerberosManager {
1226    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1227        let mut d = f.debug_struct("KerberosManager");
1228        d.field("config", &self.config);
1229        d.field(
1230            "replay_cache",
1231            &crate::utils::redact::redacted(&self.replay_cache),
1232        );
1233        d.field("keytab_entries", &self.keytab_entries);
1234        d.finish()
1235    }
1236}
1237
1238impl KerberosManager {
1239    /// Create a new Kerberos manager.
1240    pub fn new(config: KerberosConfig) -> Result<Self> {
1241        if config.service_principal.is_empty() {
1242            return Err(AuthError::config("Kerberos service principal must be set"));
1243        }
1244        if config.realm.is_empty() {
1245            return Err(AuthError::config("Kerberos realm must be set"));
1246        }
1247
1248        Ok(Self {
1249            config,
1250            replay_cache: Arc::new(RwLock::new(HashMap::new())),
1251            keytab_entries: Arc::new(RwLock::new(Vec::new())),
1252        })
1253    }
1254
1255    /// Load keytab entries from file.
1256    pub async fn load_keytab(&self, path: &str) -> Result<usize> {
1257        let data = tokio::fs::read(path)
1258            .await
1259            .map_err(|e| AuthError::config(format!("Failed to read keytab file: {e}")))?;
1260
1261        let entries = parse_keytab(&data)?;
1262        let count = entries.len();
1263
1264        let mut kt = self.keytab_entries.write().await;
1265        *kt = entries;
1266
1267        Ok(count)
1268    }
1269
1270    /// Process an HTTP `Authorization: Negotiate <token>` header.
1271    ///
1272    /// Returns the authentication result on success, or an appropriate error.
1273    /// The caller should return the `response_token` (if any) in a
1274    /// `WWW-Authenticate: Negotiate <token>` response header.
1275    pub async fn authenticate(&self, negotiate_token: &str) -> Result<KerberosAuthResult> {
1276        let token_bytes = base64::engine::general_purpose::STANDARD
1277            .decode(negotiate_token.trim())
1278            .map_err(|e| AuthError::validation(format!("Invalid Negotiate token encoding: {e}")))?;
1279
1280        if token_bytes.is_empty() {
1281            return Err(AuthError::validation("Empty Negotiate token"));
1282        }
1283
1284        // Parse SPNEGO wrapper
1285        let spnego = self.parse_spnego_token(&token_bytes)?;
1286
1287        if spnego.mech_oid != oid::KERBEROS_V5 {
1288            return Err(AuthError::validation(format!(
1289                "Unsupported SPNEGO mechanism: {}",
1290                spnego.mech_oid
1291            )));
1292        }
1293
1294        // Validate the Kerberos AP-REQ
1295        let result = self.validate_ap_req(&spnego.mech_token).await?;
1296
1297        Ok(result)
1298    }
1299
1300    /// Generate a `WWW-Authenticate: Negotiate` challenge header value.
1301    pub fn generate_challenge(&self) -> String {
1302        "Negotiate".to_string()
1303    }
1304
1305    /// Parse an SPNEGO token wrapper using proper ASN.1 DER parsing.
1306    fn parse_spnego_token(&self, data: &[u8]) -> Result<SpnegoToken> {
1307        if data.len() < 2 {
1308            return Err(AuthError::validation("SPNEGO token too short"));
1309        }
1310
1311        match data[0] {
1312            // APPLICATION 0 CONSTRUCTED — GSS-API InitialContextToken
1313            0x60 => parse_spnego_init_token(data),
1314            // CONTEXT 1 — NegTokenResp
1315            0xa1 => parse_spnego_resp_token(data),
1316            // Assume raw Kerberos AP-REQ (no SPNEGO wrapper)
1317            _ => Ok(SpnegoToken {
1318                mech_oid: oid::KERBEROS_V5.to_string(),
1319                mech_token: data.to_vec(),
1320                state: SpnegoState::Initial,
1321            }),
1322        }
1323    }
1324
1325    /// Validate a Kerberos AP-REQ message.
1326    ///
1327    /// Performs full cryptographic validation:
1328    /// 1. Parses the AP-REQ ASN.1 structure
1329    /// 2. Looks up the service key from the keytab
1330    /// 3. Decrypts the ticket using AES-CTS-HMAC-SHA1-96
1331    /// 4. Decrypts the authenticator using the session key
1332    /// 5. Verifies timestamps and checks for replay attacks
1333    async fn validate_ap_req(&self, ap_req_bytes: &[u8]) -> Result<KerberosAuthResult> {
1334        let keytab = self.keytab_entries.read().await;
1335        if keytab.is_empty() {
1336            return Err(AuthError::config(
1337                "No keytab loaded — cannot validate Kerberos tickets",
1338            ));
1339        }
1340
1341        // ── Step 1: Parse AP-REQ ──
1342        let ap_req = parse_ap_req(ap_req_bytes)?;
1343
1344        // ── Step 2: Find matching keytab entry ──
1345        let ticket_etype = ap_req.ticket.enc_part.etype;
1346        let ticket_kvno = ap_req.ticket.enc_part.kvno;
1347        let ticket_sname = format!(
1348            "{}@{}",
1349            ap_req.ticket.sname.to_string_without_realm(),
1350            ap_req.ticket.realm
1351        );
1352
1353        let entry = keytab
1354            .iter()
1355            .find(|e| {
1356                e.principal == ticket_sname
1357                    && e.key_type == ticket_etype as u32
1358                    && ticket_kvno.is_none_or(|v| e.kvno == v)
1359            })
1360            .or_else(|| {
1361                // Fallback: match by realm and key type only
1362                keytab
1363                    .iter()
1364                    .find(|e| e.realm == ap_req.ticket.realm && e.key_type == ticket_etype as u32)
1365            })
1366            .ok_or_else(|| {
1367                AuthError::config(format!(
1368                    "No keytab entry for principal={ticket_sname} etype={ticket_etype}"
1369                ))
1370            })?;
1371
1372        // ── Step 3: Decrypt the ticket ──
1373        let ticket_plaintext = decrypt_aes_cts(
1374            &entry.key_data,
1375            ap_req.ticket.enc_part.cipher,
1376            ticket_etype,
1377            KEY_USAGE_TICKET,
1378        )?;
1379
1380        let ticket_part = parse_enc_ticket_part(&ticket_plaintext)?;
1381
1382        // ── Step 4: Check ticket expiration ──
1383        let now = SystemTime::now()
1384            .duration_since(UNIX_EPOCH)
1385            .map_err(|e| AuthError::internal(format!("Clock error: {e}")))?
1386            .as_secs();
1387
1388        if now > ticket_part.end_time + self.config.max_clock_skew_secs {
1389            return Err(AuthError::validation("Kerberos ticket has expired"));
1390        }
1391
1392        if let Some(start) = ticket_part.start_time
1393            && now + self.config.max_clock_skew_secs < start
1394        {
1395            return Err(AuthError::validation("Kerberos ticket is not yet valid"));
1396        }
1397
1398        // ── Step 5: Decrypt the authenticator using the session key ──
1399        let auth_etype = ap_req.authenticator.etype;
1400        let auth_plaintext = decrypt_aes_cts(
1401            &ticket_part.session_key_value,
1402            ap_req.authenticator.cipher,
1403            auth_etype,
1404            KEY_USAGE_AP_REQ_AUTH,
1405        )?;
1406
1407        let authenticator = parse_authenticator(&auth_plaintext)?;
1408
1409        // ── Step 6: Verify authenticator matches ticket ──
1410        if authenticator.crealm != ticket_part.crealm {
1411            return Err(AuthError::validation(
1412                "Authenticator crealm does not match ticket",
1413            ));
1414        }
1415
1416        if authenticator.cname.to_string_without_realm()
1417            != ticket_part.cname.to_string_without_realm()
1418        {
1419            return Err(AuthError::validation(
1420                "Authenticator cname does not match ticket",
1421            ));
1422        }
1423
1424        // ── Step 7: Check clock skew ──
1425        let time_diff = now.abs_diff(authenticator.ctime);
1426
1427        if time_diff > self.config.max_clock_skew_secs {
1428            return Err(AuthError::validation(format!(
1429                "Authenticator clock skew too large: {time_diff}s (max {}s)",
1430                self.config.max_clock_skew_secs
1431            )));
1432        }
1433
1434        // ── Step 8: Replay detection (ctime + cusec + cname) ──
1435        self.check_replay_authenticator(
1436            authenticator.ctime,
1437            authenticator.cusec,
1438            &authenticator.cname.to_string_without_realm(),
1439        )
1440        .await?;
1441
1442        // ── Build result ──
1443        let client_principal = format!(
1444            "{}@{}",
1445            ticket_part.cname.to_string_without_realm(),
1446            ticket_part.crealm
1447        );
1448        let is_delegated = test_bit_flag(&ticket_part.flags_raw, 2); // bit 2 = forwarded
1449
1450        let flags = KerberosTicketFlags {
1451            forwardable: test_bit_flag(&ticket_part.flags_raw, 1),
1452            forwarded: test_bit_flag(&ticket_part.flags_raw, 2),
1453            proxiable: test_bit_flag(&ticket_part.flags_raw, 3),
1454            proxy: test_bit_flag(&ticket_part.flags_raw, 4),
1455            may_postdate: test_bit_flag(&ticket_part.flags_raw, 5),
1456            postdated: test_bit_flag(&ticket_part.flags_raw, 6),
1457            renewable: test_bit_flag(&ticket_part.flags_raw, 8),
1458            pre_authent: test_bit_flag(&ticket_part.flags_raw, 10),
1459            hw_authent: test_bit_flag(&ticket_part.flags_raw, 11),
1460        };
1461
1462        // Reject delegated tickets if not allowed
1463        if is_delegated && !self.config.allow_delegation {
1464            return Err(AuthError::validation(
1465                "Delegated (forwarded) tickets are not allowed by policy",
1466            ));
1467        }
1468
1469        Ok(KerberosAuthResult {
1470            client_principal,
1471            realm: ticket_part.crealm,
1472            auth_time: ticket_part.auth_time,
1473            end_time: ticket_part.end_time,
1474            is_delegated,
1475            flags,
1476            response_token: None,
1477        })
1478    }
1479
1480    /// Check for authenticator replay using (ctime, cusec, cname) tuple.
1481    async fn check_replay_authenticator(&self, ctime: u64, cusec: u32, cname: &str) -> Result<()> {
1482        // Build a unique key from the authenticator's identifying fields
1483        let mut hasher = sha2::Sha256::new();
1484        hasher.update(ctime.to_be_bytes());
1485        hasher.update(cusec.to_be_bytes());
1486        hasher.update(cname.as_bytes());
1487        let hash = hasher.finalize().to_vec();
1488
1489        let now = SystemTime::now()
1490            .duration_since(UNIX_EPOCH)
1491            .map_err(|e| AuthError::internal(format!("Clock error: {e}")))?
1492            .as_secs();
1493
1494        let mut cache = self.replay_cache.write().await;
1495
1496        // Evict stale entries
1497        let cutoff = now.saturating_sub(self.config.max_clock_skew_secs * 2);
1498        cache.retain(|_, &mut ts| ts > cutoff);
1499
1500        if cache.contains_key(&hash) {
1501            return Err(AuthError::validation("Kerberos replay attack detected"));
1502        }
1503
1504        if cache.len() >= self.config.replay_cache_max_entries {
1505            return Err(AuthError::internal("Kerberos replay cache full"));
1506        }
1507
1508        cache.insert(hash, now);
1509        Ok(())
1510    }
1511
1512    /// Check for replay attacks using a raw token hash (for backwards compat).
1513    pub async fn check_replay(&self, token_data: &[u8]) -> Result<()> {
1514        let hash = sha2::Sha256::digest(token_data).to_vec();
1515
1516        let now = SystemTime::now()
1517            .duration_since(UNIX_EPOCH)
1518            .map_err(|e| AuthError::internal(format!("Clock error: {e}")))?
1519            .as_secs();
1520
1521        let mut cache = self.replay_cache.write().await;
1522
1523        let cutoff = now.saturating_sub(self.config.max_clock_skew_secs * 2);
1524        cache.retain(|_, &mut ts| ts > cutoff);
1525
1526        if cache.contains_key(&hash) {
1527            return Err(AuthError::validation("Kerberos replay attack detected"));
1528        }
1529
1530        if cache.len() >= self.config.replay_cache_max_entries {
1531            return Err(AuthError::internal("Kerberos replay cache full"));
1532        }
1533
1534        cache.insert(hash, now);
1535        Ok(())
1536    }
1537
1538    /// Generate a mutual-authentication response token.
1539    #[allow(dead_code)]
1540    fn generate_response_token(&self) -> Result<Option<String>> {
1541        let rng = ring::rand::SystemRandom::new();
1542        let mut nonce = [0u8; 16];
1543        rng.fill(&mut nonce)
1544            .map_err(|_| AuthError::crypto("Failed to generate SPNEGO response nonce"))?;
1545
1546        let encoded = base64::engine::general_purpose::STANDARD.encode(nonce);
1547        Ok(Some(encoded))
1548    }
1549}
1550
1551// ─── Keytab Parsing ──────────────────────────────────────────────────────────
1552
1553/// Parse a Kerberos keytab file (MIT format).
1554///
1555/// Keytab format:
1556/// - 2 bytes: version (0x0502 for v2)
1557/// - Repeated entries: length-prefixed principal + key data
1558fn parse_keytab(data: &[u8]) -> Result<Vec<KeytabEntry>> {
1559    if data.len() < 4 {
1560        return Err(AuthError::config("Keytab file too short"));
1561    }
1562
1563    // Check magic number
1564    let version = u16::from_be_bytes([data[0], data[1]]);
1565    if version != 0x0502 && version != 0x0501 {
1566        return Err(AuthError::config(format!(
1567            "Unsupported keytab version: 0x{version:04x}"
1568        )));
1569    }
1570
1571    let mut entries = Vec::new();
1572    let mut pos = 2;
1573
1574    while pos + 4 <= data.len() {
1575        let entry_len =
1576            i32::from_be_bytes([data[pos], data[pos + 1], data[pos + 2], data[pos + 3]]);
1577        pos += 4;
1578
1579        if entry_len <= 0 {
1580            // Deleted/empty entry — skip
1581            pos += entry_len.unsigned_abs() as usize;
1582            continue;
1583        }
1584        let entry_len = entry_len as usize;
1585
1586        if pos + entry_len > data.len() {
1587            break;
1588        }
1589
1590        let entry_data = &data[pos..pos + entry_len];
1591        if let Ok(entry) = parse_keytab_entry(entry_data, version) {
1592            entries.push(entry);
1593        }
1594
1595        pos += entry_len;
1596    }
1597
1598    Ok(entries)
1599}
1600
1601/// Parse a single keytab entry.
1602fn parse_keytab_entry(data: &[u8], _version: u16) -> Result<KeytabEntry> {
1603    if data.len() < 8 {
1604        return Err(AuthError::config("Keytab entry too short"));
1605    }
1606
1607    // Read number of principal components
1608    let num_components = u16::from_be_bytes([data[0], data[1]]) as usize;
1609    let mut pos = 2;
1610
1611    // Read realm
1612    if pos + 2 > data.len() {
1613        return Err(AuthError::config("Keytab entry truncated at realm length"));
1614    }
1615    let realm_len = u16::from_be_bytes([data[pos], data[pos + 1]]) as usize;
1616    pos += 2;
1617
1618    if pos + realm_len > data.len() {
1619        return Err(AuthError::config("Keytab entry truncated at realm data"));
1620    }
1621    let realm = String::from_utf8_lossy(&data[pos..pos + realm_len]).to_string();
1622    pos += realm_len;
1623
1624    // Read principal components
1625    let mut principal_parts = Vec::new();
1626    for _ in 0..num_components {
1627        if pos + 2 > data.len() {
1628            return Err(AuthError::config("Keytab entry truncated at component"));
1629        }
1630        let comp_len = u16::from_be_bytes([data[pos], data[pos + 1]]) as usize;
1631        pos += 2;
1632        if pos + comp_len > data.len() {
1633            return Err(AuthError::config(
1634                "Keytab entry truncated at component data",
1635            ));
1636        }
1637        principal_parts.push(String::from_utf8_lossy(&data[pos..pos + comp_len]).to_string());
1638        pos += comp_len;
1639    }
1640    let principal = format!("{}@{}", principal_parts.join("/"), realm);
1641
1642    // Skip name_type (4 bytes), timestamp (4 bytes)
1643    pos += 8;
1644    if pos >= data.len() {
1645        return Err(AuthError::config("Keytab entry truncated at kvno"));
1646    }
1647
1648    // Read kvno (1 byte in v1, may have 4-byte extension at end)
1649    let kvno = data.get(pos).copied().unwrap_or(0) as u32;
1650    pos += 1;
1651
1652    // Read key type
1653    if pos + 2 > data.len() {
1654        return Err(AuthError::config("Keytab entry truncated at key type"));
1655    }
1656    let key_type = u16::from_be_bytes([data[pos], data[pos + 1]]) as u32;
1657    pos += 2;
1658
1659    // Read key data
1660    if pos + 2 > data.len() {
1661        return Err(AuthError::config("Keytab entry truncated at key length"));
1662    }
1663    let key_len = u16::from_be_bytes([data[pos], data[pos + 1]]) as usize;
1664    pos += 2;
1665
1666    if pos + key_len > data.len() {
1667        return Err(AuthError::config("Keytab entry truncated at key data"));
1668    }
1669    let key_data = data[pos..pos + key_len].to_vec();
1670
1671    Ok(KeytabEntry {
1672        principal,
1673        realm,
1674        kvno,
1675        key_type,
1676        key_data,
1677    })
1678}
1679
1680#[cfg(test)]
1681mod tests {
1682    use super::*;
1683
1684    #[test]
1685    fn test_config_defaults() {
1686        let config = KerberosConfig::default();
1687        assert_eq!(config.max_clock_skew_secs, 300);
1688        assert!(!config.allow_delegation);
1689    }
1690
1691    #[test]
1692    fn test_manager_requires_principal() {
1693        let config = KerberosConfig::default();
1694        let err = KerberosManager::new(config).unwrap_err();
1695        assert!(err.to_string().contains("service principal"));
1696    }
1697
1698    #[test]
1699    fn test_manager_requires_realm() {
1700        let config = KerberosConfig {
1701            service_principal: "HTTP/server.example.com".into(),
1702            ..Default::default()
1703        };
1704        let err = KerberosManager::new(config).unwrap_err();
1705        assert!(err.to_string().contains("realm"));
1706    }
1707
1708    #[test]
1709    fn test_manager_creation() {
1710        let config = KerberosConfig {
1711            service_principal: "HTTP/server.example.com@EXAMPLE.COM".into(),
1712            realm: "EXAMPLE.COM".into(),
1713            ..Default::default()
1714        };
1715        let mgr = KerberosManager::new(config);
1716        assert!(mgr.is_ok());
1717    }
1718
1719    #[test]
1720    fn test_generate_challenge() {
1721        let config = KerberosConfig {
1722            service_principal: "HTTP/server.example.com@EXAMPLE.COM".into(),
1723            realm: "EXAMPLE.COM".into(),
1724            ..Default::default()
1725        };
1726        let mgr = KerberosManager::new(config).unwrap();
1727        assert_eq!(mgr.generate_challenge(), "Negotiate");
1728    }
1729
1730    #[tokio::test]
1731    async fn test_replay_detection() {
1732        let config = KerberosConfig {
1733            service_principal: "HTTP/server.example.com@EXAMPLE.COM".into(),
1734            realm: "EXAMPLE.COM".into(),
1735            ..Default::default()
1736        };
1737        let mgr = KerberosManager::new(config).unwrap();
1738
1739        let token_data = b"test_token_data";
1740
1741        // First check should succeed
1742        mgr.check_replay(token_data).await.unwrap();
1743
1744        // Second check with same data should fail (replay)
1745        let err = mgr.check_replay(token_data).await.unwrap_err();
1746        assert!(err.to_string().contains("replay"));
1747    }
1748
1749    #[test]
1750    fn test_invalid_keytab() {
1751        let result = parse_keytab(&[0x00, 0x01]);
1752        assert!(result.is_err());
1753    }
1754
1755    #[test]
1756    fn test_spnego_state_variants() {
1757        assert_eq!(SpnegoState::Initial, SpnegoState::Initial);
1758        assert_ne!(SpnegoState::Initial, SpnegoState::Completed);
1759    }
1760
1761    // ── DER parser tests ─────────────────────────────────────────────────
1762
1763    #[test]
1764    fn test_parse_der_integer() {
1765        // DER INTEGER: 02 01 05 → value = 5
1766        let data = [0x02, 0x01, 0x05];
1767        let (tlv, rest) = parse_der(&data).unwrap();
1768        assert!(rest.is_empty());
1769        assert_eq!(tlv.class, 0); // Universal
1770        assert_eq!(tlv.tag_num, 2); // INTEGER
1771        assert_eq!(parse_der_integer(tlv.value).unwrap(), 5);
1772    }
1773
1774    #[test]
1775    fn test_parse_der_sequence() {
1776        // SEQUENCE { INTEGER 5, INTEGER 14 }
1777        // 30 06 02 01 05 02 01 0e
1778        let data = [0x30, 0x06, 0x02, 0x01, 0x05, 0x02, 0x01, 0x0e];
1779        let (tlv, _) = parse_der(&data).unwrap();
1780        assert_eq!(tlv.tag_num, 16); // SEQUENCE
1781        assert!(tlv.constructed);
1782        let contents = parse_der_contents(tlv.value).unwrap();
1783        assert_eq!(contents.len(), 2);
1784        assert_eq!(parse_der_integer(contents[0].value).unwrap(), 5);
1785        assert_eq!(parse_der_integer(contents[1].value).unwrap(), 14);
1786    }
1787
1788    #[test]
1789    fn test_parse_der_context_tag() {
1790        // [0] EXPLICIT INTEGER 5 → a0 03 02 01 05
1791        let data = [0xa0, 0x03, 0x02, 0x01, 0x05];
1792        let (tlv, _) = parse_der(&data).unwrap();
1793        assert_eq!(tlv.class, 2); // Context-specific
1794        assert_eq!(tlv.tag_num, 0);
1795        let inner = unwrap_explicit(&tlv).unwrap();
1796        assert_eq!(parse_der_integer(inner.value).unwrap(), 5);
1797    }
1798
1799    #[test]
1800    fn test_parse_der_oid() {
1801        // OID 1.3.6.1.5.5.2 (SPNEGO)
1802        let data = [0x06, 0x06, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x02];
1803        let (tlv, _) = parse_der(&data).unwrap();
1804        assert!(oid_matches(&tlv, SPNEGO_OID_BYTES));
1805        assert!(!oid_matches(&tlv, KRB5_OID_BYTES));
1806    }
1807
1808    #[test]
1809    fn test_parse_der_truncated_fails() {
1810        assert!(parse_der(&[]).is_err());
1811        assert!(parse_der(&[0x02]).is_err()); // missing length
1812        assert!(parse_der(&[0x02, 0x05, 0x01]).is_err()); // length says 5, only 1 byte
1813    }
1814
1815    // ── n-fold tests (RFC 3961 test vectors) ─────────────────────────────
1816
1817    #[test]
1818    fn test_nfold_64bit() {
1819        // n-fold("012345", 64) = be072631276b1955 (RFC 3961 §A.1)
1820        let result = nfold(b"012345", 8);
1821        assert_eq!(result, vec![0xBE, 0x07, 0x26, 0x31, 0x27, 0x6B, 0x19, 0x55]);
1822    }
1823
1824    #[test]
1825    fn test_nfold_56bit() {
1826        // n-fold("password", 56) = 78 A0 7B 6C AF 85 FA
1827        let result = nfold(b"password", 7);
1828        assert_eq!(result, vec![0x78, 0xA0, 0x7B, 0x6C, 0xAF, 0x85, 0xFA]);
1829    }
1830
1831    #[test]
1832    fn test_nfold_64bit_long_input() {
1833        // n-fold("Rough Consensus, and Running Code", 64) = bb6ed30870b7f0e0 (RFC 3961 §A.1)
1834        let result = nfold(b"Rough Consensus, and Running Code", 8);
1835        assert_eq!(result, vec![0xBB, 0x6E, 0xD3, 0x08, 0x70, 0xB7, 0xF0, 0xE0]);
1836    }
1837
1838    #[test]
1839    fn test_nfold_168bit() {
1840        // n-fold("password", 168) = 59e4a8ca7c0385c3c37b3f6d2000247cb6e6bd5b3e (RFC 3961 §A.1)
1841        let result = nfold(b"password", 21);
1842        assert_eq!(
1843            result,
1844            vec![
1845                0x59, 0xE4, 0xA8, 0xCA, 0x7C, 0x03, 0x85, 0xC3, 0xC3, 0x7B, 0x3F, 0x6D, 0x20, 0x00,
1846                0x24, 0x7C, 0xB6, 0xE6, 0xBD, 0x5B, 0x3E,
1847            ]
1848        );
1849    }
1850
1851    // ── AES crypto tests ─────────────────────────────────────────────────
1852
1853    #[test]
1854    fn test_aes_ecb_roundtrip() {
1855        let key = [0x42u8; 16];
1856        let block = [0x01u8; 16];
1857        let encrypted = aes_ecb_encrypt(&key, &block);
1858        let decrypted = aes_ecb_decrypt(&key, &encrypted);
1859        assert_eq!(decrypted, block);
1860    }
1861
1862    #[test]
1863    fn test_aes_ecb_256_roundtrip() {
1864        let key = [0x42u8; 32];
1865        let block = [0xABu8; 16];
1866        let encrypted = aes_ecb_encrypt(&key, &block);
1867        let decrypted = aes_ecb_decrypt(&key, &encrypted);
1868        assert_eq!(decrypted, block);
1869    }
1870
1871    #[test]
1872    fn test_aes_cbc_decrypt_two_blocks() {
1873        let key = [0x00u8; 16];
1874        // Encrypt two zero blocks with zero key and zero IV using CBC
1875        let p0 = [0u8; 16];
1876        let p1 = [0u8; 16];
1877        // CBC encrypt: C0 = E(P0 XOR 0) = E(0), C1 = E(P1 XOR C0)
1878        let c0 = aes_ecb_encrypt(&key, &p0);
1879        let p1_xor_c0: [u8; 16] = xor_bytes(&p1, &c0).try_into().unwrap();
1880        let c1 = aes_ecb_encrypt(&key, &p1_xor_c0);
1881        let mut ciphertext = Vec::new();
1882        ciphertext.extend_from_slice(&c0);
1883        ciphertext.extend_from_slice(&c1);
1884
1885        let plaintext = aes_cbc_decrypt(&key, &ciphertext).unwrap();
1886        let mut expected = Vec::new();
1887        expected.extend_from_slice(&p0);
1888        expected.extend_from_slice(&p1);
1889        assert_eq!(plaintext, expected);
1890    }
1891
1892    #[test]
1893    fn test_aes_cts_decrypt_single_block() {
1894        let key = [0x00u8; 16];
1895        let plaintext = [0x42u8; 16];
1896        // Single block: CTS = just ECB
1897        let ciphertext = aes_ecb_encrypt(&key, &plaintext);
1898        let decrypted = aes_cts_decrypt(&key, &ciphertext).unwrap();
1899        assert_eq!(&decrypted[..], &plaintext[..]);
1900    }
1901
1902    #[test]
1903    fn test_derive_key_produces_correct_length() {
1904        let key_128 = [0x42u8; 16];
1905        let derived = derive_key_aes(&key_128, 2, 0xAA);
1906        assert_eq!(derived.len(), 16);
1907
1908        let key_256 = [0x42u8; 32];
1909        let derived = derive_key_aes(&key_256, 2, 0xAA);
1910        assert_eq!(derived.len(), 32);
1911    }
1912
1913    #[test]
1914    fn test_hmac_sha1_produces_20_bytes() {
1915        let result = hmac_sha1(b"key", b"data");
1916        assert_eq!(result.len(), 20);
1917    }
1918
1919    // ── Keytab tests ─────────────────────────────────────────────────────
1920
1921    #[test]
1922    fn test_valid_keytab_v2_header() {
1923        // Minimal valid keytab: version 0x0502, followed by zero-length remaining data
1924        let data = [0x05, 0x02, 0x00, 0x00];
1925        let entries = parse_keytab(&data).unwrap();
1926        assert!(entries.is_empty());
1927    }
1928
1929    // ── Ticket flag tests ────────────────────────────────────────────────
1930
1931    #[test]
1932    fn test_ticket_flags_parsing() {
1933        // Bit 1 = forwardable, bit 8 = renewable
1934        // Bit 1 in byte 0 is position 6 (0x40), bit 8 in byte 1 is position 7 (0x80)
1935        let flags = [0x00, 0x40, 0x80, 0x00, 0x00]; // [unused_bits=0] [byte0] [byte1] ...
1936        assert!(test_bit_flag(&flags, 1)); // forwardable
1937        assert!(!test_bit_flag(&flags, 2)); // forwarded
1938        assert!(test_bit_flag(&flags, 8)); // renewable
1939        assert!(!test_bit_flag(&flags, 10)); // pre_authent
1940    }
1941
1942    // ── Builder & preset tests ───────────────────────────────────────────
1943
1944    #[test]
1945    fn test_kerberos_config_builder() {
1946        let config = KerberosConfig::builder("HTTP/srv@REALM", "REALM")
1947            .keytab_path("/etc/krb5.keytab")
1948            .add_kdc("kdc1:88")
1949            .add_kdc("kdc2:88")
1950            .max_clock_skew_secs(600)
1951            .build();
1952
1953        assert_eq!(config.service_principal, "HTTP/srv@REALM");
1954        assert_eq!(config.realm, "REALM");
1955        assert_eq!(config.keytab_path.as_deref(), Some("/etc/krb5.keytab"));
1956        assert_eq!(config.kdc_addresses, vec!["kdc1:88", "kdc2:88"]);
1957        assert_eq!(config.max_clock_skew_secs, 600);
1958        assert!(!config.allow_delegation);
1959    }
1960
1961    #[test]
1962    fn test_kerberos_config_active_directory() {
1963        let config = KerberosConfig::active_directory("HTTP/srv@AD.COM", "AD.COM");
1964        assert_eq!(config.service_principal, "HTTP/srv@AD.COM");
1965        assert_eq!(config.realm, "AD.COM");
1966        assert!(config.allow_delegation);
1967        // Should produce a valid manager
1968        let mgr = KerberosManager::new(config);
1969        assert!(mgr.is_ok());
1970    }
1971
1972    #[test]
1973    fn test_kerberos_builder_override() {
1974        let config = KerberosConfig::builder("HTTP/srv@REALM", "REALM")
1975            .allow_delegation(true)
1976            .replay_cache_max_entries(500)
1977            .build();
1978
1979        assert!(config.allow_delegation);
1980        assert_eq!(config.replay_cache_max_entries, 500);
1981    }
1982}