1use 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
40const ETYPE_AES128: i32 = 17;
44const ETYPE_AES256: i32 = 18;
46
47const KEY_USAGE_TICKET: u32 = 2;
49const KEY_USAGE_AP_REQ_AUTH: u32 = 11;
51
52const AES_BLOCK: usize = 16;
54const HMAC_LEN: usize = 12;
56const CONFOUNDER_LEN: usize = 16;
58
59const SPNEGO_OID_BYTES: &[u8] = &[0x2b, 0x06, 0x01, 0x05, 0x05, 0x02];
61const KRB5_OID_BYTES: &[u8] = &[0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x01, 0x02, 0x02];
63
64#[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 class: u8,
75 constructed: bool,
77 tag_num: u32,
79 value: &'a [u8],
81}
82
83fn 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 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 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
160fn 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
172fn 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
177fn unwrap_explicit<'a>(tlv: &DerTlv<'a>) -> Result<DerTlv<'a>> {
179 let (inner, _) = parse_der(tlv.value)?;
180 Ok(inner)
181}
182
183fn 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
195fn 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
201fn 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
212fn test_bit_flag(flags_data: &[u8], bit_num: usize) -> bool {
215 if flags_data.is_empty() {
216 return false;
217 }
218 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
227fn oid_matches(tlv: &DerTlv<'_>, expected: &[u8]) -> bool {
229 tlv.class == 0 && tlv.tag_num == 6 && tlv.value == expected
230}
231
232struct ParsedEncryptedData<'a> {
236 etype: i32,
237 kvno: Option<u32>,
238 cipher: &'a [u8],
239}
240
241struct ParsedPrincipalName {
243 components: Vec<String>,
244}
245
246impl ParsedPrincipalName {
247 fn to_string_without_realm(&self) -> String {
249 self.components.join("/")
250 }
251}
252
253struct ParsedTicket<'a> {
255 realm: String,
256 sname: ParsedPrincipalName,
257 enc_part: ParsedEncryptedData<'a>,
258}
259
260#[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#[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
288struct 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 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 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 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 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 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 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 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 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 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 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 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 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
435fn parse_ap_options(tlv: &DerTlv<'_>) -> Result<u32> {
437 if tlv.value.len() < 2 {
438 return Ok(0);
439 }
440 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
451fn 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 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 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 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 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 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 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 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 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
527fn 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 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 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 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 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 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
576fn gcd(a: usize, b: usize) -> usize {
580 if b == 0 { a } else { gcd(b, a % b) }
581}
582
583fn lcm(a: usize, b: usize) -> usize {
585 a / gcd(a, b) * b
586}
587
588fn 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 let msbit =
604 ((in_bits - 1) + ((in_bits + 13) * (i / in_bytes)) + ((in_bytes - i % in_bytes) * 8))
605 % in_bits;
606
607 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 byte += out[i % out_bytes] as u32;
614 out[i % out_bytes] = (byte & 0xff) as u8;
615
616 byte >>= 8;
618 }
619
620 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
632fn 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
654fn 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
675fn xor_bytes(a: &[u8], b: &[u8]) -> Vec<u8> {
677 a.iter().zip(b.iter()).map(|(&x, &y)| x ^ y).collect()
678}
679
680fn 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 let nfolded = nfold(&constant, AES_BLOCK);
697
698 let key_size = base_key.len(); 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
712fn 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]; 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
736fn 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 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 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 let prev_cipher = if preceding_len >= AES_BLOCK {
773 &ciphertext[preceding_len - AES_BLOCK..preceding_len]
774 } else {
775 &[0u8; AES_BLOCK][..] };
777
778 let d = aes_ecb_decrypt(key, &c_second_last);
780
781 let p_last = xor_bytes(&d[..partial_len], c_last);
783
784 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 let decrypted_recovered = aes_ecb_decrypt(key, &c_recovered);
791 let p_second_last = xor_bytes(&decrypted_recovered, prev_cipher);
792
793 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
806fn 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
817fn 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 let ke = derive_key_aes(base_key, usage, 0xAA);
851 let ki = derive_key_aes(base_key, usage, 0x55);
852
853 let plaintext_with_confounder = aes_cts_decrypt(&ke, ct_body)?;
855
856 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 Ok(plaintext_with_confounder[CONFOUNDER_LEN..].to_vec())
866}
867
868fn parse_spnego_init_token(data: &[u8]) -> Result<SpnegoToken> {
880 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 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 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 let (neg_init_seq, _) = parse_der(neg_init_wrapper.value)?;
902 let fields = parse_der_contents(neg_init_seq.value)?;
903
904 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 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 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
930fn 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 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#[derive(Debug, Clone)]
958pub struct KerberosConfig {
959 pub service_principal: String,
961
962 pub realm: String,
964
965 pub keytab_path: Option<String>,
967
968 #[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 pub max_clock_skew_secs: u64,
979
980 pub allow_delegation: bool,
982
983 pub replay_cache_max_entries: usize,
985}
986
987#[allow(deprecated)] impl 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 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 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
1058pub struct KerberosConfigBuilder {
1062 config: KerberosConfig,
1063}
1064
1065impl KerberosConfigBuilder {
1066 pub fn keytab_path(mut self, path: impl Into<String>) -> Self {
1068 self.config.keytab_path = Some(path.into());
1069 self
1070 }
1071
1072 #[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 pub fn max_clock_skew_secs(mut self, secs: u64) -> Self {
1086 self.config.max_clock_skew_secs = secs;
1087 self
1088 }
1089
1090 pub fn allow_delegation(mut self, allow: bool) -> Self {
1092 self.config.allow_delegation = allow;
1093 self
1094 }
1095
1096 pub fn replay_cache_max_entries(mut self, max: usize) -> Self {
1098 self.config.replay_cache_max_entries = max;
1099 self
1100 }
1101
1102 pub fn build(self) -> KerberosConfig {
1104 self.config
1105 }
1106}
1107
1108pub mod oid {
1112 pub const SPNEGO: &str = "1.3.6.1.5.5.2";
1114 pub const KERBEROS_V5: &str = "1.2.840.113554.1.2.2";
1116}
1117
1118#[derive(Clone, Serialize, Deserialize)]
1120pub struct KerberosAuthResult {
1121 pub client_principal: String,
1123
1124 pub realm: String,
1126
1127 pub auth_time: u64,
1129
1130 pub end_time: u64,
1132
1133 pub is_delegated: bool,
1135
1136 pub flags: KerberosTicketFlags,
1138
1139 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#[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#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1176pub enum SpnegoState {
1177 Initial,
1179 Continue,
1181 Completed,
1183 Rejected,
1185}
1186
1187#[derive(Clone)]
1189pub struct SpnegoToken {
1190 pub mech_oid: String,
1192 pub mech_token: Vec<u8>,
1194 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#[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
1233pub struct KerberosManager {
1237 config: KerberosConfig,
1238 replay_cache: Arc<RwLock<HashMap<Vec<u8>, u64>>>,
1240 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 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 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 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 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 let result = self.validate_ap_req(&spnego.mech_token).await?;
1315
1316 Ok(result)
1317 }
1318
1319 pub fn generate_challenge(&self) -> String {
1321 "Negotiate".to_string()
1322 }
1323
1324 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 0x60 => parse_spnego_init_token(data),
1333 0xa1 => parse_spnego_resp_token(data),
1335 _ => 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 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 let ap_req = parse_ap_req(ap_req_bytes)?;
1362
1363 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 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 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 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 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 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 self.check_replay_authenticator(
1443 authenticator.ctime,
1444 authenticator.cusec,
1445 &authenticator.cname.to_string_without_realm(),
1446 )
1447 .await?;
1448
1449 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); 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 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 async fn check_replay_authenticator(&self, ctime: u64, cusec: u32, cname: &str) -> Result<()> {
1489 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 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 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
1546fn parse_keytab(data: &[u8]) -> Result<Vec<KeytabEntry>> {
1554 if data.len() < 4 {
1555 return Err(AuthError::config("Keytab file too short"));
1556 }
1557
1558 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 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
1596fn 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
1616fn 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 let num_components = u16::from_be_bytes([data[0], data[1]]) as usize;
1624 let mut pos = 2;
1625
1626 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 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 pos += 8;
1659 if pos >= data.len() {
1660 return Err(AuthError::config("Keytab entry truncated at kvno"));
1661 }
1662
1663 let kvno = data.get(pos).copied().unwrap_or(0) as u32;
1665 pos += 1;
1666
1667 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 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 #[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 mgr.check_replay(token_data).await.unwrap();
1766
1767 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 #[test]
1787 fn test_parse_der_integer() {
1788 let data = [0x02, 0x01, 0x05];
1790 let (tlv, rest) = parse_der(&data).unwrap();
1791 assert!(rest.is_empty());
1792 assert_eq!(tlv.class, 0); assert_eq!(tlv.tag_num, 2); assert_eq!(parse_der_integer(tlv.value).unwrap(), 5);
1795 }
1796
1797 #[test]
1798 fn test_parse_der_sequence() {
1799 let data = [0x30, 0x06, 0x02, 0x01, 0x05, 0x02, 0x01, 0x0e];
1802 let (tlv, _) = parse_der(&data).unwrap();
1803 assert_eq!(tlv.tag_num, 16); 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 let data = [0xa0, 0x03, 0x02, 0x01, 0x05];
1815 let (tlv, _) = parse_der(&data).unwrap();
1816 assert_eq!(tlv.class, 2); 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 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()); assert!(parse_der(&[0x02, 0x05, 0x01]).is_err()); }
1837
1838 #[test]
1841 fn test_nfold_64bit() {
1842 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 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 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 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 #[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 let p0 = [0u8; 16];
1899 let p1 = [0u8; 16];
1900 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 let ciphertext = aes_ecb_encrypt(&key, &plaintext);
1921 let decrypted = aes_cts_decrypt(&key, &ciphertext).unwrap();
1922 assert_eq!(&decrypted[..], &plaintext[..]);
1923 }
1924
1925 #[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 #[test]
2004 fn test_valid_keytab_v2_header() {
2005 let data = [0x05, 0x02, 0x00, 0x00];
2007 let entries = parse_keytab(&data).unwrap();
2008 assert!(entries.is_empty());
2009 }
2010
2011 #[test]
2014 fn test_ticket_flags_parsing() {
2015 let flags = [0x00, 0x40, 0x80, 0x00, 0x00]; assert!(test_bit_flag(&flags, 1)); assert!(!test_bit_flag(&flags, 2)); assert!(test_bit_flag(&flags, 8)); assert!(!test_bit_flag(&flags, 10)); }
2023
2024 #[test]
2027 #[allow(deprecated)] 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 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 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 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 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}