1use crate::errors::{AuthError, Result};
30use aes::cipher::{BlockDecrypt, BlockEncrypt, KeyInit};
31use base64::Engine as _;
32use ring::rand::SecureRandom;
33use serde::{Deserialize, Serialize};
34use sha2::Digest;
35use std::collections::HashMap;
36use std::sync::Arc;
37use std::time::{SystemTime, UNIX_EPOCH};
38use subtle::ConstantTimeEq;
39use tokio::sync::RwLock;
40
41const ETYPE_AES128: i32 = 17;
45const ETYPE_AES256: i32 = 18;
47
48const KEY_USAGE_TICKET: u32 = 2;
50const KEY_USAGE_AP_REQ_AUTH: u32 = 11;
52
53const AES_BLOCK: usize = 16;
55const HMAC_LEN: usize = 12;
57const CONFOUNDER_LEN: usize = 16;
59
60const SPNEGO_OID_BYTES: &[u8] = &[0x2b, 0x06, 0x01, 0x05, 0x05, 0x02];
62const KRB5_OID_BYTES: &[u8] = &[0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x01, 0x02, 0x02];
64
65#[allow(dead_code)]
69#[derive(Debug)]
70struct DerTlv<'a> {
71 class: u8,
73 constructed: bool,
75 tag_num: u32,
77 value: &'a [u8],
79}
80
81fn parse_der(data: &[u8]) -> Result<(DerTlv<'_>, &[u8])> {
83 if data.is_empty() {
84 return Err(AuthError::validation("Empty DER data"));
85 }
86
87 let b0 = data[0];
88 let class = b0 >> 6;
89 let constructed = (b0 & 0x20) != 0;
90 let mut pos: usize = 1;
91
92 let tag_num = if (b0 & 0x1f) == 0x1f {
94 let mut t: u32 = 0;
95 loop {
96 if pos >= data.len() {
97 return Err(AuthError::validation("DER tag truncated"));
98 }
99 let b = data[pos];
100 pos += 1;
101 t = t
102 .checked_shl(7)
103 .ok_or_else(|| AuthError::validation("DER tag too large"))?
104 | (b & 0x7f) as u32;
105 if (b & 0x80) == 0 {
106 break;
107 }
108 }
109 t
110 } else {
111 (b0 & 0x1f) as u32
112 };
113
114 if pos >= data.len() {
116 return Err(AuthError::validation("DER length missing"));
117 }
118 let len_byte = data[pos];
119 pos += 1;
120
121 let length = if len_byte < 0x80 {
122 len_byte as usize
123 } else if len_byte == 0x80 {
124 return Err(AuthError::validation(
125 "Indefinite length not supported in DER",
126 ));
127 } else {
128 let num_bytes = (len_byte & 0x7f) as usize;
129 if num_bytes > 4 || pos + num_bytes > data.len() {
130 return Err(AuthError::validation("DER length overflow"));
131 }
132 let mut l: usize = 0;
133 for &b in &data[pos..pos + num_bytes] {
134 l = l
135 .checked_shl(8)
136 .ok_or_else(|| AuthError::validation("DER length too large"))?
137 | b as usize;
138 }
139 pos += num_bytes;
140 l
141 };
142
143 if pos + length > data.len() {
144 return Err(AuthError::validation("DER value truncated"));
145 }
146
147 Ok((
148 DerTlv {
149 class,
150 constructed,
151 tag_num,
152 value: &data[pos..pos + length],
153 },
154 &data[pos + length..],
155 ))
156}
157
158fn parse_der_contents(data: &[u8]) -> Result<Vec<DerTlv<'_>>> {
160 let mut result = Vec::new();
161 let mut remaining = data;
162 while !remaining.is_empty() {
163 let (tlv, rest) = parse_der(remaining)?;
164 result.push(tlv);
165 remaining = rest;
166 }
167 Ok(result)
168}
169
170fn get_ctx_field<'a, 'b>(fields: &'b [DerTlv<'a>], tag: u32) -> Option<&'b DerTlv<'a>> {
172 fields.iter().find(|f| f.class == 2 && f.tag_num == tag)
173}
174
175fn unwrap_explicit<'a>(tlv: &DerTlv<'a>) -> Result<DerTlv<'a>> {
177 let (inner, _) = parse_der(tlv.value)?;
178 Ok(inner)
179}
180
181fn parse_der_integer(data: &[u8]) -> Result<i64> {
183 if data.is_empty() {
184 return Err(AuthError::validation("Empty INTEGER"));
185 }
186 let mut val: i64 = if data[0] & 0x80 != 0 { -1 } else { 0 };
187 for &b in data {
188 val = (val << 8) | b as i64;
189 }
190 Ok(val)
191}
192
193fn parse_der_string(data: &[u8]) -> Result<String> {
195 String::from_utf8(data.to_vec())
196 .map_err(|e| AuthError::validation(format!("Invalid string encoding: {e}")))
197}
198
199fn parse_kerberos_time(data: &[u8]) -> Result<u64> {
201 let s = parse_der_string(data)?;
202 if s.len() < 15 || !s.ends_with('Z') {
203 return Err(AuthError::validation("Invalid KerberosTime format"));
204 }
205 let dt = chrono::NaiveDateTime::parse_from_str(&s[..14], "%Y%m%d%H%M%S")
206 .map_err(|e| AuthError::validation(format!("Invalid KerberosTime: {e}")))?;
207 Ok(dt.and_utc().timestamp() as u64)
208}
209
210fn test_bit_flag(flags_data: &[u8], bit_num: usize) -> bool {
213 if flags_data.is_empty() {
214 return false;
215 }
216 let byte_idx = 1 + bit_num / 8;
218 let bit_idx = 7 - (bit_num % 8);
219 if byte_idx >= flags_data.len() {
220 return false;
221 }
222 (flags_data[byte_idx] >> bit_idx) & 1 == 1
223}
224
225fn oid_matches(tlv: &DerTlv<'_>, expected: &[u8]) -> bool {
227 tlv.class == 0 && tlv.tag_num == 6 && tlv.value == expected
228}
229
230struct ParsedEncryptedData<'a> {
234 etype: i32,
235 kvno: Option<u32>,
236 cipher: &'a [u8],
237}
238
239struct ParsedPrincipalName {
241 components: Vec<String>,
242}
243
244impl ParsedPrincipalName {
245 fn to_string_without_realm(&self) -> String {
247 self.components.join("/")
248 }
249}
250
251struct ParsedTicket<'a> {
253 realm: String,
254 sname: ParsedPrincipalName,
255 enc_part: ParsedEncryptedData<'a>,
256}
257
258#[allow(dead_code)]
260struct ParsedApReq<'a> {
261 ap_options: u32,
262 ticket: ParsedTicket<'a>,
263 authenticator: ParsedEncryptedData<'a>,
264}
265
266#[allow(dead_code)]
268struct DecryptedTicketPart {
269 flags_raw: Vec<u8>,
270 session_key_type: i32,
271 session_key_value: Vec<u8>,
272 crealm: String,
273 cname: ParsedPrincipalName,
274 auth_time: u64,
275 end_time: u64,
276 start_time: Option<u64>,
277 renew_till: Option<u64>,
278}
279
280struct DecryptedAuthenticator {
282 crealm: String,
283 cname: ParsedPrincipalName,
284 cusec: u32,
285 ctime: u64,
286}
287
288fn parse_encrypted_data<'a>(data: &'a [u8]) -> Result<ParsedEncryptedData<'a>> {
289 let (seq, _) = parse_der(data)?;
290 if seq.tag_num != 16 {
291 return Err(AuthError::validation("EncryptedData: expected SEQUENCE"));
292 }
293 let fields = parse_der_contents(seq.value)?;
294
295 let etype_f = get_ctx_field(&fields, 0)
296 .ok_or_else(|| AuthError::validation("EncryptedData missing etype"))?;
297 let etype = parse_der_integer(unwrap_explicit(etype_f)?.value)? as i32;
298
299 let kvno = if let Some(f) = get_ctx_field(&fields, 1) {
300 Some(parse_der_integer(unwrap_explicit(f)?.value)? as u32)
301 } else {
302 None
303 };
304
305 let cipher_f = get_ctx_field(&fields, 2)
306 .ok_or_else(|| AuthError::validation("EncryptedData missing cipher"))?;
307 let cipher_tlv = unwrap_explicit(cipher_f)?;
308
309 Ok(ParsedEncryptedData {
310 etype,
311 kvno,
312 cipher: cipher_tlv.value,
313 })
314}
315
316fn parse_principal_name(data: &[u8]) -> Result<ParsedPrincipalName> {
317 let (seq, _) = parse_der(data)?;
318 let fields = parse_der_contents(seq.value)?;
319
320 let strings_f = get_ctx_field(&fields, 1)
322 .ok_or_else(|| AuthError::validation("PrincipalName missing name-string"))?;
323 let (strings_seq, _) = parse_der(strings_f.value)?;
324 let string_tlvs = parse_der_contents(strings_seq.value)?;
325
326 let mut components = Vec::new();
327 for tlv in &string_tlvs {
328 components.push(parse_der_string(tlv.value)?);
329 }
330
331 Ok(ParsedPrincipalName { components })
332}
333
334fn parse_ticket<'a>(data: &'a [u8]) -> Result<ParsedTicket<'a>> {
335 let (app, _) = parse_der(data)?;
337 if app.class != 1 || app.tag_num != 1 {
338 return Err(AuthError::validation("Expected Ticket (APPLICATION 1)"));
339 }
340 let (seq, _) = parse_der(app.value)?;
341 let fields = parse_der_contents(seq.value)?;
342
343 let vno_f =
345 get_ctx_field(&fields, 0).ok_or_else(|| AuthError::validation("Ticket missing tkt-vno"))?;
346 let vno = parse_der_integer(unwrap_explicit(vno_f)?.value)?;
347 if vno != 5 {
348 return Err(AuthError::validation(format!(
349 "Unsupported ticket version: {vno}"
350 )));
351 }
352
353 let realm_f =
355 get_ctx_field(&fields, 1).ok_or_else(|| AuthError::validation("Ticket missing realm"))?;
356 let realm = parse_der_string(unwrap_explicit(realm_f)?.value)?;
357
358 let sname_f =
360 get_ctx_field(&fields, 2).ok_or_else(|| AuthError::validation("Ticket missing sname"))?;
361 let sname = parse_principal_name(sname_f.value)?;
362
363 let enc_f = get_ctx_field(&fields, 3)
365 .ok_or_else(|| AuthError::validation("Ticket missing enc-part"))?;
366 let enc_part = parse_encrypted_data(enc_f.value)?;
367
368 Ok(ParsedTicket {
369 realm,
370 sname,
371 enc_part,
372 })
373}
374
375fn parse_ap_req<'a>(data: &'a [u8]) -> Result<ParsedApReq<'a>> {
376 let (app, _) = parse_der(data)?;
378 if app.class != 1 || app.tag_num != 14 {
379 return Err(AuthError::validation("Expected AP-REQ (APPLICATION 14)"));
380 }
381 let (seq, _) = parse_der(app.value)?;
382 let fields = parse_der_contents(seq.value)?;
383
384 let pvno_f =
386 get_ctx_field(&fields, 0).ok_or_else(|| AuthError::validation("AP-REQ missing pvno"))?;
387 let pvno = parse_der_integer(unwrap_explicit(pvno_f)?.value)?;
388 if pvno != 5 {
389 return Err(AuthError::validation(format!(
390 "Unsupported Kerberos version: {pvno}"
391 )));
392 }
393
394 let mt_f = get_ctx_field(&fields, 1)
396 .ok_or_else(|| AuthError::validation("AP-REQ missing msg-type"))?;
397 let mt = parse_der_integer(unwrap_explicit(mt_f)?.value)?;
398 if mt != 14 {
399 return Err(AuthError::validation(format!(
400 "Expected AP-REQ msg-type 14, got {mt}"
401 )));
402 }
403
404 let opts_f = get_ctx_field(&fields, 2)
406 .ok_or_else(|| AuthError::validation("AP-REQ missing ap-options"))?;
407 let opts_tlv = unwrap_explicit(opts_f)?;
408 let ap_options = parse_ap_options(&opts_tlv)?;
409
410 let ticket_f =
412 get_ctx_field(&fields, 3).ok_or_else(|| AuthError::validation("AP-REQ missing ticket"))?;
413 let ticket = parse_ticket(ticket_f.value)?;
414
415 let auth_f = get_ctx_field(&fields, 4)
417 .ok_or_else(|| AuthError::validation("AP-REQ missing authenticator"))?;
418 let authenticator = parse_encrypted_data(auth_f.value)?;
419
420 Ok(ParsedApReq {
421 ap_options,
422 ticket,
423 authenticator,
424 })
425}
426
427fn parse_ap_options(tlv: &DerTlv<'_>) -> Result<u32> {
429 if tlv.value.len() < 2 {
430 return Ok(0);
431 }
432 let mut flags: u32 = 0;
434 for (i, &b) in tlv.value[1..].iter().enumerate() {
435 if i >= 4 {
436 break;
437 }
438 flags |= (b as u32) << (24 - i * 8);
439 }
440 Ok(flags)
441}
442
443fn parse_enc_ticket_part(data: &[u8]) -> Result<DecryptedTicketPart> {
445 let (app, _) = parse_der(data)?;
446 if app.class != 1 || app.tag_num != 3 {
447 return Err(AuthError::validation(
448 "Expected EncTicketPart (APPLICATION 3)",
449 ));
450 }
451 let (seq, _) = parse_der(app.value)?;
452 let fields = parse_der_contents(seq.value)?;
453
454 let flags_f = get_ctx_field(&fields, 0)
456 .ok_or_else(|| AuthError::validation("EncTicketPart missing flags"))?;
457 let flags_tlv = unwrap_explicit(flags_f)?;
458 let flags_raw = flags_tlv.value.to_vec();
459
460 let key_f = get_ctx_field(&fields, 1)
462 .ok_or_else(|| AuthError::validation("EncTicketPart missing key"))?;
463 let (key_seq, _) = parse_der(key_f.value)?;
464 let key_fields = parse_der_contents(key_seq.value)?;
465 let key_type_f = get_ctx_field(&key_fields, 0)
466 .ok_or_else(|| AuthError::validation("EncryptionKey missing keytype"))?;
467 let key_type = parse_der_integer(unwrap_explicit(key_type_f)?.value)? as i32;
468 let key_val_f = get_ctx_field(&key_fields, 1)
469 .ok_or_else(|| AuthError::validation("EncryptionKey missing keyvalue"))?;
470 let key_value = unwrap_explicit(key_val_f)?.value.to_vec();
471
472 let crealm_f = get_ctx_field(&fields, 2)
474 .ok_or_else(|| AuthError::validation("EncTicketPart missing crealm"))?;
475 let crealm = parse_der_string(unwrap_explicit(crealm_f)?.value)?;
476
477 let cname_f = get_ctx_field(&fields, 3)
479 .ok_or_else(|| AuthError::validation("EncTicketPart missing cname"))?;
480 let cname = parse_principal_name(cname_f.value)?;
481
482 let authtime_f = get_ctx_field(&fields, 5)
484 .ok_or_else(|| AuthError::validation("EncTicketPart missing authtime"))?;
485 let auth_time = parse_kerberos_time(unwrap_explicit(authtime_f)?.value)?;
486
487 let start_time = if let Some(f) = get_ctx_field(&fields, 6) {
489 Some(parse_kerberos_time(unwrap_explicit(f)?.value)?)
490 } else {
491 None
492 };
493
494 let endtime_f = get_ctx_field(&fields, 7)
496 .ok_or_else(|| AuthError::validation("EncTicketPart missing endtime"))?;
497 let end_time = parse_kerberos_time(unwrap_explicit(endtime_f)?.value)?;
498
499 let renew_till = if let Some(f) = get_ctx_field(&fields, 8) {
501 Some(parse_kerberos_time(unwrap_explicit(f)?.value)?)
502 } else {
503 None
504 };
505
506 Ok(DecryptedTicketPart {
507 flags_raw,
508 session_key_type: key_type,
509 session_key_value: key_value,
510 crealm,
511 cname,
512 auth_time,
513 end_time,
514 start_time,
515 renew_till,
516 })
517}
518
519fn parse_authenticator(data: &[u8]) -> Result<DecryptedAuthenticator> {
521 let (app, _) = parse_der(data)?;
522 if app.class != 1 || app.tag_num != 2 {
523 return Err(AuthError::validation(
524 "Expected Authenticator (APPLICATION 2)",
525 ));
526 }
527 let (seq, _) = parse_der(app.value)?;
528 let fields = parse_der_contents(seq.value)?;
529
530 let vno_f = get_ctx_field(&fields, 0)
532 .ok_or_else(|| AuthError::validation("Authenticator missing vno"))?;
533 let vno = parse_der_integer(unwrap_explicit(vno_f)?.value)?;
534 if vno != 5 {
535 return Err(AuthError::validation(format!(
536 "Unsupported authenticator version: {vno}"
537 )));
538 }
539
540 let crealm_f = get_ctx_field(&fields, 1)
542 .ok_or_else(|| AuthError::validation("Authenticator missing crealm"))?;
543 let crealm = parse_der_string(unwrap_explicit(crealm_f)?.value)?;
544
545 let cname_f = get_ctx_field(&fields, 2)
547 .ok_or_else(|| AuthError::validation("Authenticator missing cname"))?;
548 let cname = parse_principal_name(cname_f.value)?;
549
550 let cusec_f = get_ctx_field(&fields, 3)
552 .ok_or_else(|| AuthError::validation("Authenticator missing cusec"))?;
553 let cusec = parse_der_integer(unwrap_explicit(cusec_f)?.value)? as u32;
554
555 let ctime_f = get_ctx_field(&fields, 4)
557 .ok_or_else(|| AuthError::validation("Authenticator missing ctime"))?;
558 let ctime = parse_kerberos_time(unwrap_explicit(ctime_f)?.value)?;
559
560 Ok(DecryptedAuthenticator {
561 crealm,
562 cname,
563 cusec,
564 ctime,
565 })
566}
567
568fn gcd(a: usize, b: usize) -> usize {
572 if b == 0 { a } else { gcd(b, a % b) }
573}
574
575fn lcm(a: usize, b: usize) -> usize {
577 a / gcd(a, b) * b
578}
579
580fn nfold(input: &[u8], output_len: usize) -> Vec<u8> {
585 let in_bytes = input.len();
586 let out_bytes = output_len;
587 let lcm_val = lcm(in_bytes, out_bytes);
588 let in_bits = in_bytes * 8;
589
590 let mut out = vec![0u8; out_bytes];
591 let mut byte: u32 = 0;
592
593 for i in (0..lcm_val).rev() {
594 let msbit =
596 ((in_bits - 1) + ((in_bits + 13) * (i / in_bytes)) + ((in_bytes - i % in_bytes) * 8))
597 % in_bits;
598
599 let high = input[((in_bytes - 1).wrapping_sub(msbit >> 3)) % in_bytes] as u32;
601 let low = input[(in_bytes.wrapping_sub(msbit >> 3)) % in_bytes] as u32;
602 byte += ((high << 8 | low) >> ((msbit & 7) + 1)) & 0xff;
603
604 byte += out[i % out_bytes] as u32;
606 out[i % out_bytes] = (byte & 0xff) as u8;
607
608 byte >>= 8;
610 }
611
612 if byte != 0 {
614 for i in (0..out_bytes).rev() {
615 byte += out[i] as u32;
616 out[i] = (byte & 0xff) as u8;
617 byte >>= 8;
618 }
619 }
620
621 out
622}
623
624fn aes_ecb_encrypt(key: &[u8], block: &[u8; AES_BLOCK]) -> [u8; AES_BLOCK] {
627 let mut blk = aes::cipher::generic_array::GenericArray::clone_from_slice(block);
628 match key.len() {
629 16 => {
630 let cipher =
631 aes::Aes128::new(aes::cipher::generic_array::GenericArray::from_slice(key));
632 cipher.encrypt_block(&mut blk);
633 }
634 32 => {
635 let cipher =
636 aes::Aes256::new(aes::cipher::generic_array::GenericArray::from_slice(key));
637 cipher.encrypt_block(&mut blk);
638 }
639 _ => unreachable!("aes_ecb_encrypt: unsupported key length"),
640 }
641 let mut out = [0u8; AES_BLOCK];
642 out.copy_from_slice(&blk);
643 out
644}
645
646fn aes_ecb_decrypt(key: &[u8], block: &[u8; AES_BLOCK]) -> [u8; AES_BLOCK] {
648 let mut blk = aes::cipher::generic_array::GenericArray::clone_from_slice(block);
649 match key.len() {
650 16 => {
651 let cipher =
652 aes::Aes128::new(aes::cipher::generic_array::GenericArray::from_slice(key));
653 cipher.decrypt_block(&mut blk);
654 }
655 32 => {
656 let cipher =
657 aes::Aes256::new(aes::cipher::generic_array::GenericArray::from_slice(key));
658 cipher.decrypt_block(&mut blk);
659 }
660 _ => unreachable!("aes_ecb_decrypt: unsupported key length"),
661 }
662 let mut out = [0u8; AES_BLOCK];
663 out.copy_from_slice(&blk);
664 out
665}
666
667fn xor_bytes(a: &[u8], b: &[u8]) -> Vec<u8> {
669 a.iter().zip(b.iter()).map(|(&x, &y)| x ^ y).collect()
670}
671
672fn derive_key_aes(base_key: &[u8], usage: u32, key_type: u8) -> Vec<u8> {
679 let constant = [
680 (usage >> 24) as u8,
681 (usage >> 16) as u8,
682 (usage >> 8) as u8,
683 usage as u8,
684 key_type,
685 ];
686
687 let nfolded = nfold(&constant, AES_BLOCK);
689
690 let key_size = base_key.len(); let mut derived = Vec::with_capacity(key_size);
692
693 let mut input: [u8; AES_BLOCK] = nfolded.try_into().expect("nfold produced wrong size");
694 while derived.len() < key_size {
695 let encrypted = aes_ecb_encrypt(base_key, &input);
696 derived.extend_from_slice(&encrypted);
697 input = encrypted;
698 }
699
700 derived.truncate(key_size);
701 derived
702}
703
704fn aes_cbc_decrypt(key: &[u8], ciphertext: &[u8]) -> Result<Vec<u8>> {
707 if !ciphertext.len().is_multiple_of(AES_BLOCK) || ciphertext.is_empty() {
708 return Err(AuthError::crypto(
709 "AES-CBC ciphertext must be a non-empty multiple of block size",
710 ));
711 }
712
713 let mut plaintext = Vec::with_capacity(ciphertext.len());
714 let mut prev = [0u8; AES_BLOCK]; let (blocks, _remainder) = ciphertext.as_chunks::<AES_BLOCK>();
719 for ct_block in blocks.iter().copied() {
720 let decrypted = aes_ecb_decrypt(key, &ct_block);
721 let pt_block = xor_bytes(&decrypted, &prev);
722 plaintext.extend_from_slice(&pt_block);
723 prev = ct_block;
724 }
725
726 Ok(plaintext)
727}
728
729fn aes_cts_decrypt(key: &[u8], ciphertext: &[u8]) -> Result<Vec<u8>> {
737 let n = ciphertext.len();
738 if n < AES_BLOCK {
739 return Err(AuthError::crypto("AES-CTS ciphertext too short"));
740 }
741
742 if n == AES_BLOCK {
743 let ct: [u8; AES_BLOCK] = ciphertext
745 .try_into()
746 .expect("length was checked to equal AES_BLOCK above");
747 return Ok(aes_ecb_decrypt(key, &ct).to_vec());
748 }
749
750 let partial_len = match n % AES_BLOCK {
754 0 => AES_BLOCK,
755 r => r,
756 };
757 let preceding_len = n - partial_len - AES_BLOCK;
758
759 let c_second_last: [u8; AES_BLOCK] = ciphertext[preceding_len..preceding_len + AES_BLOCK]
760 .try_into()
761 .expect("slice is exactly AES_BLOCK bytes by construction");
762 let c_last = &ciphertext[preceding_len + AES_BLOCK..];
763
764 let prev_cipher = if preceding_len >= AES_BLOCK {
766 &ciphertext[preceding_len - AES_BLOCK..preceding_len]
767 } else {
768 &[0u8; AES_BLOCK][..] };
770
771 let d = aes_ecb_decrypt(key, &c_second_last);
773
774 let p_last = xor_bytes(&d[..partial_len], c_last);
776
777 let mut c_recovered = [0u8; AES_BLOCK];
779 c_recovered[..partial_len].copy_from_slice(c_last);
780 c_recovered[partial_len..].copy_from_slice(&d[partial_len..]);
781
782 let decrypted_recovered = aes_ecb_decrypt(key, &c_recovered);
784 let p_second_last = xor_bytes(&decrypted_recovered, prev_cipher);
785
786 let mut plaintext = if preceding_len > 0 {
788 aes_cbc_decrypt(key, &ciphertext[..preceding_len])?
789 } else {
790 Vec::new()
791 };
792
793 plaintext.extend_from_slice(&p_second_last);
794 plaintext.extend_from_slice(&p_last);
795
796 Ok(plaintext)
797}
798
799fn hmac_sha1(key: &[u8], data: &[u8]) -> Vec<u8> {
801 use hmac::{Hmac, Mac};
802 type HmacSha1 = Hmac<sha1::Sha1>;
803
804 let mut mac = <HmacSha1 as Mac>::new_from_slice(key).expect("HMAC-SHA1 accepts any key length");
805 mac.update(data);
806 mac.finalize().into_bytes().to_vec()
807}
808
809fn decrypt_aes_cts(base_key: &[u8], ciphertext: &[u8], etype: i32, usage: u32) -> Result<Vec<u8>> {
815 let expected_key_len = match etype {
816 ETYPE_AES128 => 16,
817 ETYPE_AES256 => 32,
818 _ => {
819 return Err(AuthError::crypto(format!(
820 "Unsupported encryption type {etype}; only AES etypes 17/18 are supported"
821 )));
822 }
823 };
824
825 if base_key.len() != expected_key_len {
826 return Err(AuthError::crypto(format!(
827 "Key length mismatch: expected {expected_key_len}, got {}",
828 base_key.len()
829 )));
830 }
831
832 if ciphertext.len() < CONFOUNDER_LEN + HMAC_LEN {
833 return Err(AuthError::crypto(
834 "Ciphertext too short for AES-CTS envelope",
835 ));
836 }
837
838 let ct_body = &ciphertext[..ciphertext.len() - HMAC_LEN];
839 let expected_hmac = &ciphertext[ciphertext.len() - HMAC_LEN..];
840
841 let ke = derive_key_aes(base_key, usage, 0xAA);
843 let ki = derive_key_aes(base_key, usage, 0x55);
844
845 let plaintext_with_confounder = aes_cts_decrypt(&ke, ct_body)?;
847
848 let computed_hmac = hmac_sha1(&ki, &plaintext_with_confounder);
850 if computed_hmac[..HMAC_LEN].ct_eq(expected_hmac).unwrap_u8() != 1 {
851 return Err(AuthError::crypto(
852 "Kerberos HMAC verification failed — wrong key or corrupted ticket",
853 ));
854 }
855
856 Ok(plaintext_with_confounder[CONFOUNDER_LEN..].to_vec())
858}
859
860fn parse_spnego_init_token(data: &[u8]) -> Result<SpnegoToken> {
872 let (app, _) = parse_der(data)?;
874 if app.class != 1 || app.tag_num != 0 {
875 return Err(AuthError::validation(
876 "Expected GSS-API InitialContextToken (APPLICATION 0)",
877 ));
878 }
879
880 let (oid_tlv, rest) = parse_der(app.value)?;
882 if !oid_matches(&oid_tlv, SPNEGO_OID_BYTES) {
883 return Err(AuthError::validation("Not an SPNEGO token"));
884 }
885
886 let (neg_init_wrapper, _) = parse_der(rest)?;
888 if neg_init_wrapper.class != 2 || neg_init_wrapper.tag_num != 0 {
889 return Err(AuthError::validation("Expected NegTokenInit ([CONTEXT 0])"));
890 }
891
892 let (neg_init_seq, _) = parse_der(neg_init_wrapper.value)?;
894 let fields = parse_der_contents(neg_init_seq.value)?;
895
896 let mech_types_f = get_ctx_field(&fields, 0)
898 .ok_or_else(|| AuthError::validation("NegTokenInit missing mechTypes"))?;
899 let (mech_seq, _) = parse_der(mech_types_f.value)?;
900 let mech_oids = parse_der_contents(mech_seq.value)?;
901
902 let has_krb5 = mech_oids.iter().any(|o| oid_matches(o, KRB5_OID_BYTES));
904 if !has_krb5 {
905 return Err(AuthError::validation(
906 "SPNEGO NegTokenInit does not offer Kerberos 5",
907 ));
908 }
909
910 let mech_token_f = get_ctx_field(&fields, 2)
912 .ok_or_else(|| AuthError::validation("NegTokenInit missing mechToken"))?;
913 let mech_token_tlv = unwrap_explicit(mech_token_f)?;
914
915 Ok(SpnegoToken {
916 mech_oid: oid::KERBEROS_V5.to_string(),
917 mech_token: mech_token_tlv.value.to_vec(),
918 state: SpnegoState::Initial,
919 })
920}
921
922fn parse_spnego_resp_token(data: &[u8]) -> Result<SpnegoToken> {
924 let (wrapper, _) = parse_der(data)?;
925 if wrapper.class != 2 || wrapper.tag_num != 1 {
926 return Err(AuthError::validation("Expected NegTokenResp ([CONTEXT 1])"));
927 }
928
929 let (seq, _) = parse_der(wrapper.value)?;
930 let fields = parse_der_contents(seq.value)?;
931
932 let mech_token = if let Some(f) = get_ctx_field(&fields, 2) {
934 unwrap_explicit(f)?.value.to_vec()
935 } else {
936 Vec::new()
937 };
938
939 Ok(SpnegoToken {
940 mech_oid: oid::KERBEROS_V5.to_string(),
941 mech_token,
942 state: SpnegoState::Continue,
943 })
944}
945
946#[derive(Debug, Clone)]
950pub struct KerberosConfig {
951 pub service_principal: String,
953
954 pub realm: String,
956
957 pub keytab_path: Option<String>,
959
960 pub kdc_addresses: Vec<String>,
962
963 pub max_clock_skew_secs: u64,
965
966 pub allow_delegation: bool,
968
969 pub replay_cache_max_entries: usize,
971}
972
973impl Default for KerberosConfig {
974 fn default() -> Self {
975 Self {
976 service_principal: String::new(),
977 realm: String::new(),
978 keytab_path: None,
979 kdc_addresses: Vec::new(),
980 max_clock_skew_secs: 300,
981 allow_delegation: false,
982 replay_cache_max_entries: 100_000,
983 }
984 }
985}
986
987impl KerberosConfig {
988 pub fn builder(
1008 service_principal: impl Into<String>,
1009 realm: impl Into<String>,
1010 ) -> KerberosConfigBuilder {
1011 KerberosConfigBuilder {
1012 config: KerberosConfig {
1013 service_principal: service_principal.into(),
1014 realm: realm.into(),
1015 ..Default::default()
1016 },
1017 }
1018 }
1019
1020 pub fn active_directory(
1033 service_principal: impl Into<String>,
1034 realm: impl Into<String>,
1035 ) -> Self {
1036 Self {
1037 service_principal: service_principal.into(),
1038 realm: realm.into(),
1039 allow_delegation: true,
1040 ..Default::default()
1041 }
1042 }
1043}
1044
1045pub struct KerberosConfigBuilder {
1049 config: KerberosConfig,
1050}
1051
1052impl KerberosConfigBuilder {
1053 pub fn keytab_path(mut self, path: impl Into<String>) -> Self {
1055 self.config.keytab_path = Some(path.into());
1056 self
1057 }
1058
1059 pub fn add_kdc(mut self, addr: impl Into<String>) -> Self {
1061 self.config.kdc_addresses.push(addr.into());
1062 self
1063 }
1064
1065 pub fn max_clock_skew_secs(mut self, secs: u64) -> Self {
1067 self.config.max_clock_skew_secs = secs;
1068 self
1069 }
1070
1071 pub fn allow_delegation(mut self, allow: bool) -> Self {
1073 self.config.allow_delegation = allow;
1074 self
1075 }
1076
1077 pub fn replay_cache_max_entries(mut self, max: usize) -> Self {
1079 self.config.replay_cache_max_entries = max;
1080 self
1081 }
1082
1083 pub fn build(self) -> KerberosConfig {
1085 self.config
1086 }
1087}
1088
1089pub mod oid {
1093 pub const SPNEGO: &str = "1.3.6.1.5.5.2";
1095 pub const KERBEROS_V5: &str = "1.2.840.113554.1.2.2";
1097}
1098
1099#[derive(Clone, Serialize, Deserialize)]
1101pub struct KerberosAuthResult {
1102 pub client_principal: String,
1104
1105 pub realm: String,
1107
1108 pub auth_time: u64,
1110
1111 pub end_time: u64,
1113
1114 pub is_delegated: bool,
1116
1117 pub flags: KerberosTicketFlags,
1119
1120 pub response_token: Option<String>,
1122}
1123
1124impl std::fmt::Debug for KerberosAuthResult {
1125 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1126 let mut d = f.debug_struct("KerberosAuthResult");
1127 d.field("client_principal", &self.client_principal);
1128 d.field("realm", &self.realm);
1129 d.field("auth_time", &self.auth_time);
1130 d.field("end_time", &self.end_time);
1131 d.field("is_delegated", &self.is_delegated);
1132 d.field("flags", &self.flags);
1133 d.field(
1134 "response_token",
1135 &crate::utils::redact::redacted(&self.response_token),
1136 );
1137 d.finish()
1138 }
1139}
1140
1141#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1143pub struct KerberosTicketFlags {
1144 pub forwardable: bool,
1145 pub forwarded: bool,
1146 pub proxiable: bool,
1147 pub proxy: bool,
1148 pub may_postdate: bool,
1149 pub postdated: bool,
1150 pub renewable: bool,
1151 pub pre_authent: bool,
1152 pub hw_authent: bool,
1153}
1154
1155#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1157pub enum SpnegoState {
1158 Initial,
1160 Continue,
1162 Completed,
1164 Rejected,
1166}
1167
1168#[derive(Clone)]
1170pub struct SpnegoToken {
1171 pub mech_oid: String,
1173 pub mech_token: Vec<u8>,
1175 pub state: SpnegoState,
1177}
1178
1179impl std::fmt::Debug for SpnegoToken {
1180 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1181 let mut d = f.debug_struct("SpnegoToken");
1182 d.field("mech_oid", &self.mech_oid);
1183 d.field(
1184 "mech_token",
1185 &crate::utils::redact::redacted(&self.mech_token),
1186 );
1187 d.field("state", &self.state);
1188 d.finish()
1189 }
1190}
1191
1192#[derive(Clone)]
1194pub struct KeytabEntry {
1195 pub principal: String,
1196 pub realm: String,
1197 pub kvno: u32,
1198 pub key_type: u32,
1199 pub key_data: Vec<u8>,
1200}
1201
1202impl std::fmt::Debug for KeytabEntry {
1203 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1204 let mut d = f.debug_struct("KeytabEntry");
1205 d.field("principal", &self.principal);
1206 d.field("realm", &self.realm);
1207 d.field("kvno", &self.kvno);
1208 d.field("key_type", &self.key_type);
1209 d.field("key_data", &crate::utils::redact::redacted(&self.key_data));
1210 d.finish()
1211 }
1212}
1213
1214pub struct KerberosManager {
1218 config: KerberosConfig,
1219 replay_cache: Arc<RwLock<HashMap<Vec<u8>, u64>>>,
1221 keytab_entries: Arc<RwLock<Vec<KeytabEntry>>>,
1223}
1224
1225impl std::fmt::Debug for KerberosManager {
1226 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1227 let mut d = f.debug_struct("KerberosManager");
1228 d.field("config", &self.config);
1229 d.field(
1230 "replay_cache",
1231 &crate::utils::redact::redacted(&self.replay_cache),
1232 );
1233 d.field("keytab_entries", &self.keytab_entries);
1234 d.finish()
1235 }
1236}
1237
1238impl KerberosManager {
1239 pub fn new(config: KerberosConfig) -> Result<Self> {
1241 if config.service_principal.is_empty() {
1242 return Err(AuthError::config("Kerberos service principal must be set"));
1243 }
1244 if config.realm.is_empty() {
1245 return Err(AuthError::config("Kerberos realm must be set"));
1246 }
1247
1248 Ok(Self {
1249 config,
1250 replay_cache: Arc::new(RwLock::new(HashMap::new())),
1251 keytab_entries: Arc::new(RwLock::new(Vec::new())),
1252 })
1253 }
1254
1255 pub async fn load_keytab(&self, path: &str) -> Result<usize> {
1257 let data = tokio::fs::read(path)
1258 .await
1259 .map_err(|e| AuthError::config(format!("Failed to read keytab file: {e}")))?;
1260
1261 let entries = parse_keytab(&data)?;
1262 let count = entries.len();
1263
1264 let mut kt = self.keytab_entries.write().await;
1265 *kt = entries;
1266
1267 Ok(count)
1268 }
1269
1270 pub async fn authenticate(&self, negotiate_token: &str) -> Result<KerberosAuthResult> {
1276 let token_bytes = base64::engine::general_purpose::STANDARD
1277 .decode(negotiate_token.trim())
1278 .map_err(|e| AuthError::validation(format!("Invalid Negotiate token encoding: {e}")))?;
1279
1280 if token_bytes.is_empty() {
1281 return Err(AuthError::validation("Empty Negotiate token"));
1282 }
1283
1284 let spnego = self.parse_spnego_token(&token_bytes)?;
1286
1287 if spnego.mech_oid != oid::KERBEROS_V5 {
1288 return Err(AuthError::validation(format!(
1289 "Unsupported SPNEGO mechanism: {}",
1290 spnego.mech_oid
1291 )));
1292 }
1293
1294 let result = self.validate_ap_req(&spnego.mech_token).await?;
1296
1297 Ok(result)
1298 }
1299
1300 pub fn generate_challenge(&self) -> String {
1302 "Negotiate".to_string()
1303 }
1304
1305 fn parse_spnego_token(&self, data: &[u8]) -> Result<SpnegoToken> {
1307 if data.len() < 2 {
1308 return Err(AuthError::validation("SPNEGO token too short"));
1309 }
1310
1311 match data[0] {
1312 0x60 => parse_spnego_init_token(data),
1314 0xa1 => parse_spnego_resp_token(data),
1316 _ => Ok(SpnegoToken {
1318 mech_oid: oid::KERBEROS_V5.to_string(),
1319 mech_token: data.to_vec(),
1320 state: SpnegoState::Initial,
1321 }),
1322 }
1323 }
1324
1325 async fn validate_ap_req(&self, ap_req_bytes: &[u8]) -> Result<KerberosAuthResult> {
1334 let keytab = self.keytab_entries.read().await;
1335 if keytab.is_empty() {
1336 return Err(AuthError::config(
1337 "No keytab loaded — cannot validate Kerberos tickets",
1338 ));
1339 }
1340
1341 let ap_req = parse_ap_req(ap_req_bytes)?;
1343
1344 let ticket_etype = ap_req.ticket.enc_part.etype;
1346 let ticket_kvno = ap_req.ticket.enc_part.kvno;
1347 let ticket_sname = format!(
1348 "{}@{}",
1349 ap_req.ticket.sname.to_string_without_realm(),
1350 ap_req.ticket.realm
1351 );
1352
1353 let entry = keytab
1354 .iter()
1355 .find(|e| {
1356 e.principal == ticket_sname
1357 && e.key_type == ticket_etype as u32
1358 && ticket_kvno.is_none_or(|v| e.kvno == v)
1359 })
1360 .or_else(|| {
1361 keytab
1363 .iter()
1364 .find(|e| e.realm == ap_req.ticket.realm && e.key_type == ticket_etype as u32)
1365 })
1366 .ok_or_else(|| {
1367 AuthError::config(format!(
1368 "No keytab entry for principal={ticket_sname} etype={ticket_etype}"
1369 ))
1370 })?;
1371
1372 let ticket_plaintext = decrypt_aes_cts(
1374 &entry.key_data,
1375 ap_req.ticket.enc_part.cipher,
1376 ticket_etype,
1377 KEY_USAGE_TICKET,
1378 )?;
1379
1380 let ticket_part = parse_enc_ticket_part(&ticket_plaintext)?;
1381
1382 let now = SystemTime::now()
1384 .duration_since(UNIX_EPOCH)
1385 .map_err(|e| AuthError::internal(format!("Clock error: {e}")))?
1386 .as_secs();
1387
1388 if now > ticket_part.end_time + self.config.max_clock_skew_secs {
1389 return Err(AuthError::validation("Kerberos ticket has expired"));
1390 }
1391
1392 if let Some(start) = ticket_part.start_time
1393 && now + self.config.max_clock_skew_secs < start
1394 {
1395 return Err(AuthError::validation("Kerberos ticket is not yet valid"));
1396 }
1397
1398 let auth_etype = ap_req.authenticator.etype;
1400 let auth_plaintext = decrypt_aes_cts(
1401 &ticket_part.session_key_value,
1402 ap_req.authenticator.cipher,
1403 auth_etype,
1404 KEY_USAGE_AP_REQ_AUTH,
1405 )?;
1406
1407 let authenticator = parse_authenticator(&auth_plaintext)?;
1408
1409 if authenticator.crealm != ticket_part.crealm {
1411 return Err(AuthError::validation(
1412 "Authenticator crealm does not match ticket",
1413 ));
1414 }
1415
1416 if authenticator.cname.to_string_without_realm()
1417 != ticket_part.cname.to_string_without_realm()
1418 {
1419 return Err(AuthError::validation(
1420 "Authenticator cname does not match ticket",
1421 ));
1422 }
1423
1424 let time_diff = now.abs_diff(authenticator.ctime);
1426
1427 if time_diff > self.config.max_clock_skew_secs {
1428 return Err(AuthError::validation(format!(
1429 "Authenticator clock skew too large: {time_diff}s (max {}s)",
1430 self.config.max_clock_skew_secs
1431 )));
1432 }
1433
1434 self.check_replay_authenticator(
1436 authenticator.ctime,
1437 authenticator.cusec,
1438 &authenticator.cname.to_string_without_realm(),
1439 )
1440 .await?;
1441
1442 let client_principal = format!(
1444 "{}@{}",
1445 ticket_part.cname.to_string_without_realm(),
1446 ticket_part.crealm
1447 );
1448 let is_delegated = test_bit_flag(&ticket_part.flags_raw, 2); let flags = KerberosTicketFlags {
1451 forwardable: test_bit_flag(&ticket_part.flags_raw, 1),
1452 forwarded: test_bit_flag(&ticket_part.flags_raw, 2),
1453 proxiable: test_bit_flag(&ticket_part.flags_raw, 3),
1454 proxy: test_bit_flag(&ticket_part.flags_raw, 4),
1455 may_postdate: test_bit_flag(&ticket_part.flags_raw, 5),
1456 postdated: test_bit_flag(&ticket_part.flags_raw, 6),
1457 renewable: test_bit_flag(&ticket_part.flags_raw, 8),
1458 pre_authent: test_bit_flag(&ticket_part.flags_raw, 10),
1459 hw_authent: test_bit_flag(&ticket_part.flags_raw, 11),
1460 };
1461
1462 if is_delegated && !self.config.allow_delegation {
1464 return Err(AuthError::validation(
1465 "Delegated (forwarded) tickets are not allowed by policy",
1466 ));
1467 }
1468
1469 Ok(KerberosAuthResult {
1470 client_principal,
1471 realm: ticket_part.crealm,
1472 auth_time: ticket_part.auth_time,
1473 end_time: ticket_part.end_time,
1474 is_delegated,
1475 flags,
1476 response_token: None,
1477 })
1478 }
1479
1480 async fn check_replay_authenticator(&self, ctime: u64, cusec: u32, cname: &str) -> Result<()> {
1482 let mut hasher = sha2::Sha256::new();
1484 hasher.update(ctime.to_be_bytes());
1485 hasher.update(cusec.to_be_bytes());
1486 hasher.update(cname.as_bytes());
1487 let hash = hasher.finalize().to_vec();
1488
1489 let now = SystemTime::now()
1490 .duration_since(UNIX_EPOCH)
1491 .map_err(|e| AuthError::internal(format!("Clock error: {e}")))?
1492 .as_secs();
1493
1494 let mut cache = self.replay_cache.write().await;
1495
1496 let cutoff = now.saturating_sub(self.config.max_clock_skew_secs * 2);
1498 cache.retain(|_, &mut ts| ts > cutoff);
1499
1500 if cache.contains_key(&hash) {
1501 return Err(AuthError::validation("Kerberos replay attack detected"));
1502 }
1503
1504 if cache.len() >= self.config.replay_cache_max_entries {
1505 return Err(AuthError::internal("Kerberos replay cache full"));
1506 }
1507
1508 cache.insert(hash, now);
1509 Ok(())
1510 }
1511
1512 pub async fn check_replay(&self, token_data: &[u8]) -> Result<()> {
1514 let hash = sha2::Sha256::digest(token_data).to_vec();
1515
1516 let now = SystemTime::now()
1517 .duration_since(UNIX_EPOCH)
1518 .map_err(|e| AuthError::internal(format!("Clock error: {e}")))?
1519 .as_secs();
1520
1521 let mut cache = self.replay_cache.write().await;
1522
1523 let cutoff = now.saturating_sub(self.config.max_clock_skew_secs * 2);
1524 cache.retain(|_, &mut ts| ts > cutoff);
1525
1526 if cache.contains_key(&hash) {
1527 return Err(AuthError::validation("Kerberos replay attack detected"));
1528 }
1529
1530 if cache.len() >= self.config.replay_cache_max_entries {
1531 return Err(AuthError::internal("Kerberos replay cache full"));
1532 }
1533
1534 cache.insert(hash, now);
1535 Ok(())
1536 }
1537
1538 #[allow(dead_code)]
1540 fn generate_response_token(&self) -> Result<Option<String>> {
1541 let rng = ring::rand::SystemRandom::new();
1542 let mut nonce = [0u8; 16];
1543 rng.fill(&mut nonce)
1544 .map_err(|_| AuthError::crypto("Failed to generate SPNEGO response nonce"))?;
1545
1546 let encoded = base64::engine::general_purpose::STANDARD.encode(nonce);
1547 Ok(Some(encoded))
1548 }
1549}
1550
1551fn parse_keytab(data: &[u8]) -> Result<Vec<KeytabEntry>> {
1559 if data.len() < 4 {
1560 return Err(AuthError::config("Keytab file too short"));
1561 }
1562
1563 let version = u16::from_be_bytes([data[0], data[1]]);
1565 if version != 0x0502 && version != 0x0501 {
1566 return Err(AuthError::config(format!(
1567 "Unsupported keytab version: 0x{version:04x}"
1568 )));
1569 }
1570
1571 let mut entries = Vec::new();
1572 let mut pos = 2;
1573
1574 while pos + 4 <= data.len() {
1575 let entry_len =
1576 i32::from_be_bytes([data[pos], data[pos + 1], data[pos + 2], data[pos + 3]]);
1577 pos += 4;
1578
1579 if entry_len <= 0 {
1580 pos += entry_len.unsigned_abs() as usize;
1582 continue;
1583 }
1584 let entry_len = entry_len as usize;
1585
1586 if pos + entry_len > data.len() {
1587 break;
1588 }
1589
1590 let entry_data = &data[pos..pos + entry_len];
1591 if let Ok(entry) = parse_keytab_entry(entry_data, version) {
1592 entries.push(entry);
1593 }
1594
1595 pos += entry_len;
1596 }
1597
1598 Ok(entries)
1599}
1600
1601fn parse_keytab_entry(data: &[u8], _version: u16) -> Result<KeytabEntry> {
1603 if data.len() < 8 {
1604 return Err(AuthError::config("Keytab entry too short"));
1605 }
1606
1607 let num_components = u16::from_be_bytes([data[0], data[1]]) as usize;
1609 let mut pos = 2;
1610
1611 if pos + 2 > data.len() {
1613 return Err(AuthError::config("Keytab entry truncated at realm length"));
1614 }
1615 let realm_len = u16::from_be_bytes([data[pos], data[pos + 1]]) as usize;
1616 pos += 2;
1617
1618 if pos + realm_len > data.len() {
1619 return Err(AuthError::config("Keytab entry truncated at realm data"));
1620 }
1621 let realm = String::from_utf8_lossy(&data[pos..pos + realm_len]).to_string();
1622 pos += realm_len;
1623
1624 let mut principal_parts = Vec::new();
1626 for _ in 0..num_components {
1627 if pos + 2 > data.len() {
1628 return Err(AuthError::config("Keytab entry truncated at component"));
1629 }
1630 let comp_len = u16::from_be_bytes([data[pos], data[pos + 1]]) as usize;
1631 pos += 2;
1632 if pos + comp_len > data.len() {
1633 return Err(AuthError::config(
1634 "Keytab entry truncated at component data",
1635 ));
1636 }
1637 principal_parts.push(String::from_utf8_lossy(&data[pos..pos + comp_len]).to_string());
1638 pos += comp_len;
1639 }
1640 let principal = format!("{}@{}", principal_parts.join("/"), realm);
1641
1642 pos += 8;
1644 if pos >= data.len() {
1645 return Err(AuthError::config("Keytab entry truncated at kvno"));
1646 }
1647
1648 let kvno = data.get(pos).copied().unwrap_or(0) as u32;
1650 pos += 1;
1651
1652 if pos + 2 > data.len() {
1654 return Err(AuthError::config("Keytab entry truncated at key type"));
1655 }
1656 let key_type = u16::from_be_bytes([data[pos], data[pos + 1]]) as u32;
1657 pos += 2;
1658
1659 if pos + 2 > data.len() {
1661 return Err(AuthError::config("Keytab entry truncated at key length"));
1662 }
1663 let key_len = u16::from_be_bytes([data[pos], data[pos + 1]]) as usize;
1664 pos += 2;
1665
1666 if pos + key_len > data.len() {
1667 return Err(AuthError::config("Keytab entry truncated at key data"));
1668 }
1669 let key_data = data[pos..pos + key_len].to_vec();
1670
1671 Ok(KeytabEntry {
1672 principal,
1673 realm,
1674 kvno,
1675 key_type,
1676 key_data,
1677 })
1678}
1679
1680#[cfg(test)]
1681mod tests {
1682 use super::*;
1683
1684 #[test]
1685 fn test_config_defaults() {
1686 let config = KerberosConfig::default();
1687 assert_eq!(config.max_clock_skew_secs, 300);
1688 assert!(!config.allow_delegation);
1689 }
1690
1691 #[test]
1692 fn test_manager_requires_principal() {
1693 let config = KerberosConfig::default();
1694 let err = KerberosManager::new(config).unwrap_err();
1695 assert!(err.to_string().contains("service principal"));
1696 }
1697
1698 #[test]
1699 fn test_manager_requires_realm() {
1700 let config = KerberosConfig {
1701 service_principal: "HTTP/server.example.com".into(),
1702 ..Default::default()
1703 };
1704 let err = KerberosManager::new(config).unwrap_err();
1705 assert!(err.to_string().contains("realm"));
1706 }
1707
1708 #[test]
1709 fn test_manager_creation() {
1710 let config = KerberosConfig {
1711 service_principal: "HTTP/server.example.com@EXAMPLE.COM".into(),
1712 realm: "EXAMPLE.COM".into(),
1713 ..Default::default()
1714 };
1715 let mgr = KerberosManager::new(config);
1716 assert!(mgr.is_ok());
1717 }
1718
1719 #[test]
1720 fn test_generate_challenge() {
1721 let config = KerberosConfig {
1722 service_principal: "HTTP/server.example.com@EXAMPLE.COM".into(),
1723 realm: "EXAMPLE.COM".into(),
1724 ..Default::default()
1725 };
1726 let mgr = KerberosManager::new(config).unwrap();
1727 assert_eq!(mgr.generate_challenge(), "Negotiate");
1728 }
1729
1730 #[tokio::test]
1731 async fn test_replay_detection() {
1732 let config = KerberosConfig {
1733 service_principal: "HTTP/server.example.com@EXAMPLE.COM".into(),
1734 realm: "EXAMPLE.COM".into(),
1735 ..Default::default()
1736 };
1737 let mgr = KerberosManager::new(config).unwrap();
1738
1739 let token_data = b"test_token_data";
1740
1741 mgr.check_replay(token_data).await.unwrap();
1743
1744 let err = mgr.check_replay(token_data).await.unwrap_err();
1746 assert!(err.to_string().contains("replay"));
1747 }
1748
1749 #[test]
1750 fn test_invalid_keytab() {
1751 let result = parse_keytab(&[0x00, 0x01]);
1752 assert!(result.is_err());
1753 }
1754
1755 #[test]
1756 fn test_spnego_state_variants() {
1757 assert_eq!(SpnegoState::Initial, SpnegoState::Initial);
1758 assert_ne!(SpnegoState::Initial, SpnegoState::Completed);
1759 }
1760
1761 #[test]
1764 fn test_parse_der_integer() {
1765 let data = [0x02, 0x01, 0x05];
1767 let (tlv, rest) = parse_der(&data).unwrap();
1768 assert!(rest.is_empty());
1769 assert_eq!(tlv.class, 0); assert_eq!(tlv.tag_num, 2); assert_eq!(parse_der_integer(tlv.value).unwrap(), 5);
1772 }
1773
1774 #[test]
1775 fn test_parse_der_sequence() {
1776 let data = [0x30, 0x06, 0x02, 0x01, 0x05, 0x02, 0x01, 0x0e];
1779 let (tlv, _) = parse_der(&data).unwrap();
1780 assert_eq!(tlv.tag_num, 16); assert!(tlv.constructed);
1782 let contents = parse_der_contents(tlv.value).unwrap();
1783 assert_eq!(contents.len(), 2);
1784 assert_eq!(parse_der_integer(contents[0].value).unwrap(), 5);
1785 assert_eq!(parse_der_integer(contents[1].value).unwrap(), 14);
1786 }
1787
1788 #[test]
1789 fn test_parse_der_context_tag() {
1790 let data = [0xa0, 0x03, 0x02, 0x01, 0x05];
1792 let (tlv, _) = parse_der(&data).unwrap();
1793 assert_eq!(tlv.class, 2); assert_eq!(tlv.tag_num, 0);
1795 let inner = unwrap_explicit(&tlv).unwrap();
1796 assert_eq!(parse_der_integer(inner.value).unwrap(), 5);
1797 }
1798
1799 #[test]
1800 fn test_parse_der_oid() {
1801 let data = [0x06, 0x06, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x02];
1803 let (tlv, _) = parse_der(&data).unwrap();
1804 assert!(oid_matches(&tlv, SPNEGO_OID_BYTES));
1805 assert!(!oid_matches(&tlv, KRB5_OID_BYTES));
1806 }
1807
1808 #[test]
1809 fn test_parse_der_truncated_fails() {
1810 assert!(parse_der(&[]).is_err());
1811 assert!(parse_der(&[0x02]).is_err()); assert!(parse_der(&[0x02, 0x05, 0x01]).is_err()); }
1814
1815 #[test]
1818 fn test_nfold_64bit() {
1819 let result = nfold(b"012345", 8);
1821 assert_eq!(result, vec![0xBE, 0x07, 0x26, 0x31, 0x27, 0x6B, 0x19, 0x55]);
1822 }
1823
1824 #[test]
1825 fn test_nfold_56bit() {
1826 let result = nfold(b"password", 7);
1828 assert_eq!(result, vec![0x78, 0xA0, 0x7B, 0x6C, 0xAF, 0x85, 0xFA]);
1829 }
1830
1831 #[test]
1832 fn test_nfold_64bit_long_input() {
1833 let result = nfold(b"Rough Consensus, and Running Code", 8);
1835 assert_eq!(result, vec![0xBB, 0x6E, 0xD3, 0x08, 0x70, 0xB7, 0xF0, 0xE0]);
1836 }
1837
1838 #[test]
1839 fn test_nfold_168bit() {
1840 let result = nfold(b"password", 21);
1842 assert_eq!(
1843 result,
1844 vec![
1845 0x59, 0xE4, 0xA8, 0xCA, 0x7C, 0x03, 0x85, 0xC3, 0xC3, 0x7B, 0x3F, 0x6D, 0x20, 0x00,
1846 0x24, 0x7C, 0xB6, 0xE6, 0xBD, 0x5B, 0x3E,
1847 ]
1848 );
1849 }
1850
1851 #[test]
1854 fn test_aes_ecb_roundtrip() {
1855 let key = [0x42u8; 16];
1856 let block = [0x01u8; 16];
1857 let encrypted = aes_ecb_encrypt(&key, &block);
1858 let decrypted = aes_ecb_decrypt(&key, &encrypted);
1859 assert_eq!(decrypted, block);
1860 }
1861
1862 #[test]
1863 fn test_aes_ecb_256_roundtrip() {
1864 let key = [0x42u8; 32];
1865 let block = [0xABu8; 16];
1866 let encrypted = aes_ecb_encrypt(&key, &block);
1867 let decrypted = aes_ecb_decrypt(&key, &encrypted);
1868 assert_eq!(decrypted, block);
1869 }
1870
1871 #[test]
1872 fn test_aes_cbc_decrypt_two_blocks() {
1873 let key = [0x00u8; 16];
1874 let p0 = [0u8; 16];
1876 let p1 = [0u8; 16];
1877 let c0 = aes_ecb_encrypt(&key, &p0);
1879 let p1_xor_c0: [u8; 16] = xor_bytes(&p1, &c0).try_into().unwrap();
1880 let c1 = aes_ecb_encrypt(&key, &p1_xor_c0);
1881 let mut ciphertext = Vec::new();
1882 ciphertext.extend_from_slice(&c0);
1883 ciphertext.extend_from_slice(&c1);
1884
1885 let plaintext = aes_cbc_decrypt(&key, &ciphertext).unwrap();
1886 let mut expected = Vec::new();
1887 expected.extend_from_slice(&p0);
1888 expected.extend_from_slice(&p1);
1889 assert_eq!(plaintext, expected);
1890 }
1891
1892 #[test]
1893 fn test_aes_cts_decrypt_single_block() {
1894 let key = [0x00u8; 16];
1895 let plaintext = [0x42u8; 16];
1896 let ciphertext = aes_ecb_encrypt(&key, &plaintext);
1898 let decrypted = aes_cts_decrypt(&key, &ciphertext).unwrap();
1899 assert_eq!(&decrypted[..], &plaintext[..]);
1900 }
1901
1902 #[test]
1909 fn aes_cts_decrypt_rfc3962_vectors() {
1910 fn unhex(s: &str) -> Vec<u8> {
1911 (0..s.len())
1912 .step_by(2)
1913 .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
1914 .collect()
1915 }
1916 let key = b"chicken teriyaki";
1917 let input = b"I would like the General Gau's Chicken, please, and wonton soup.";
1918 assert_eq!(input.len(), 64);
1919 let vectors: [(usize, &str); 6] = [
1920 (17, "c6353568f2bf8cb4d8a580362da7ff7f97"),
1921 (
1922 31,
1923 "fc00783e0efdb2c1d445d4c8eff7ed2297687268d6ecccc0c07b25e25ecfe5",
1924 ),
1925 (
1926 32,
1927 "39312523a78662d5be7fcbcc98ebf5a897687268d6ecccc0c07b25e25ecfe584",
1928 ),
1929 (
1930 47,
1931 "97687268d6ecccc0c07b25e25ecfe584b3fffd940c16a18c1b5549d2f838029e39312523a78662d5be7fcbcc98ebf5",
1932 ),
1933 (
1934 48,
1935 "97687268d6ecccc0c07b25e25ecfe5849dad8bbb96c4cdc03bc103e1a194bbd839312523a78662d5be7fcbcc98ebf5a8",
1936 ),
1937 (
1938 64,
1939 "97687268d6ecccc0c07b25e25ecfe58439312523a78662d5be7fcbcc98ebf5a84807efe836ee89a526730dbc2f7bc8409dad8bbb96c4cdc03bc103e1a194bbd8",
1940 ),
1941 ];
1942 let mut wrong = Vec::new();
1943 for (len, ct_hex) in vectors {
1944 let ct = unhex(ct_hex);
1945 assert_eq!(
1946 ct.len(),
1947 len,
1948 "vector {len} transcribed with the wrong length"
1949 );
1950 match aes_cts_decrypt(key, &ct) {
1951 Ok(pt) if pt == input[..len] => {}
1952 _ => wrong.push(len),
1953 }
1954 }
1955 assert!(
1956 wrong.is_empty(),
1957 "RFC 3962 vectors that did not decrypt, by length: {wrong:?}"
1958 );
1959 }
1960
1961 #[test]
1962 fn test_derive_key_produces_correct_length() {
1963 let key_128 = [0x42u8; 16];
1964 let derived = derive_key_aes(&key_128, 2, 0xAA);
1965 assert_eq!(derived.len(), 16);
1966
1967 let key_256 = [0x42u8; 32];
1968 let derived = derive_key_aes(&key_256, 2, 0xAA);
1969 assert_eq!(derived.len(), 32);
1970 }
1971
1972 #[test]
1973 fn test_hmac_sha1_produces_20_bytes() {
1974 let result = hmac_sha1(b"key", b"data");
1975 assert_eq!(result.len(), 20);
1976 }
1977
1978 #[test]
1981 fn test_valid_keytab_v2_header() {
1982 let data = [0x05, 0x02, 0x00, 0x00];
1984 let entries = parse_keytab(&data).unwrap();
1985 assert!(entries.is_empty());
1986 }
1987
1988 #[test]
1991 fn test_ticket_flags_parsing() {
1992 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)); }
2000
2001 #[test]
2004 fn test_kerberos_config_builder() {
2005 let config = KerberosConfig::builder("HTTP/srv@REALM", "REALM")
2006 .keytab_path("/etc/krb5.keytab")
2007 .add_kdc("kdc1:88")
2008 .add_kdc("kdc2:88")
2009 .max_clock_skew_secs(600)
2010 .build();
2011
2012 assert_eq!(config.service_principal, "HTTP/srv@REALM");
2013 assert_eq!(config.realm, "REALM");
2014 assert_eq!(config.keytab_path.as_deref(), Some("/etc/krb5.keytab"));
2015 assert_eq!(config.kdc_addresses, vec!["kdc1:88", "kdc2:88"]);
2016 assert_eq!(config.max_clock_skew_secs, 600);
2017 assert!(!config.allow_delegation);
2018 }
2019
2020 #[test]
2021 fn test_kerberos_config_active_directory() {
2022 let config = KerberosConfig::active_directory("HTTP/srv@AD.COM", "AD.COM");
2023 assert_eq!(config.service_principal, "HTTP/srv@AD.COM");
2024 assert_eq!(config.realm, "AD.COM");
2025 assert!(config.allow_delegation);
2026 let mgr = KerberosManager::new(config);
2028 assert!(mgr.is_ok());
2029 }
2030
2031 #[test]
2032 fn test_kerberos_builder_override() {
2033 let config = KerberosConfig::builder("HTTP/srv@REALM", "REALM")
2034 .allow_delegation(true)
2035 .replay_cache_max_entries(500)
2036 .build();
2037
2038 assert!(config.allow_delegation);
2039 assert_eq!(config.replay_cache_max_entries, 500);
2040 }
2041}