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