use std::io::{Read, Write};
use std::net::TcpStream;
use std::time::Duration;
use num_bigint_dig::BigUint;
use rsa::RsaPrivateKey;
use crate::der_walk::{extract_signed_data_econtent, tlv_split};
use crate::dh::DhKeyPair;
use crate::enveloped;
use crate::error::{Error, Result};
use crate::kdf::{octet_string_to_key, Hash};
use crate::AsRepResult;
const PA_PK_AS_REQ_TYPE: i32 = 16;
const PA_PK_AS_REP_TYPE: i32 = 17;
const PA_PAC_REQUEST_TYPE: i32 = 128;
pub fn tcp_exchange(kdc_addr: &str, as_req_der: &[u8], timeout: Duration) -> Result<Vec<u8>> {
let mut stream = TcpStream::connect_timeout(
&kdc_addr
.to_socket_addrs_first()
.map_err(|e| Error::Io(std::io::Error::new(std::io::ErrorKind::InvalidInput, e)))?,
timeout,
)?;
stream.set_read_timeout(Some(timeout))?;
stream.set_write_timeout(Some(timeout))?;
let mut frame = Vec::with_capacity(4 + as_req_der.len());
frame.extend_from_slice(&(as_req_der.len() as u32).to_be_bytes());
frame.extend_from_slice(as_req_der);
stream.write_all(&frame)?;
let mut len_buf = [0u8; 4];
stream.read_exact(&mut len_buf)?;
let len = u32::from_be_bytes(len_buf) as usize;
if len > 8 * 1024 * 1024 {
return Err(Error::AsRepParse(format!(
"reply length {len} exceeds sanity cap"
)));
}
let mut body = vec![0u8; len];
stream.read_exact(&mut body)?;
Ok(body)
}
trait ToSocketAddrsFirst {
fn to_socket_addrs_first(&self) -> std::io::Result<std::net::SocketAddr>;
}
impl ToSocketAddrsFirst for str {
fn to_socket_addrs_first(&self) -> std::io::Result<std::net::SocketAddr> {
use std::net::ToSocketAddrs;
self.to_socket_addrs()?.next().ok_or_else(|| {
std::io::Error::new(std::io::ErrorKind::InvalidInput, "no addr resolved")
})
}
}
use picky_asn1::bit_string::BitString;
use picky_asn1::restricted_string::Ia5String;
use picky_asn1::wrapper::{
Asn1SequenceOf, BitStringAsn1, ExplicitContextTag0, ExplicitContextTag1, ExplicitContextTag2,
ExplicitContextTag3, ExplicitContextTag4, ExplicitContextTag5, ExplicitContextTag7,
ExplicitContextTag8, GeneralStringAsn1, IntegerAsn1, OctetStringAsn1, Optional,
};
use picky_asn1_der::application_tag::ApplicationTag;
use picky_krb::constants::types::{
AS_REP_MSG_TYPE, AS_REQ_MSG_TYPE, KRB_ERROR_MSG_TYPE, NT_PRINCIPAL,
};
use picky_krb::data_types::{KerberosStringAsn1, KerberosTime, PaData, PrincipalName};
use picky_krb::messages::{AsRep, AsReq, KdcReq, KdcReqBody};
use picky_krb::pkinit::{KdcDhKeyInfo, PaPkAsRep};
#[derive(Debug, Clone)]
pub struct AsReqOpts<'a> {
pub realm: &'a str,
pub cname: &'a [&'a str],
pub sname: &'a [&'a str],
pub pa_pk_as_req_der: &'a [u8],
pub nonce: u32,
pub till: KerberosTime,
pub etypes: &'a [i32],
}
fn make_kdc_req_body(opts: &AsReqOpts<'_>) -> Result<KdcReqBody> {
let cname_names: Asn1SequenceOf<KerberosStringAsn1> = Asn1SequenceOf::from(
opts.cname
.iter()
.map(|p| kerb_string(p))
.collect::<Result<Vec<_>>>()?,
);
let sname_names: Asn1SequenceOf<KerberosStringAsn1> = Asn1SequenceOf::from(
opts.sname
.iter()
.map(|p| kerb_string(p))
.collect::<Result<Vec<_>>>()?,
);
let cname = PrincipalName {
name_type: ExplicitContextTag0::from(IntegerAsn1::from(vec![NT_PRINCIPAL as u8])),
name_string: ExplicitContextTag1::from(cname_names),
};
let sname = PrincipalName {
name_type: ExplicitContextTag0::from(IntegerAsn1::from(vec![NT_PRINCIPAL as u8])),
name_string: ExplicitContextTag1::from(sname_names),
};
let realm = kerb_string(opts.realm)?;
let kdc_options = BitStringAsn1::from(BitString::with_bytes(vec![0x40, 0x80, 0x00, 0x00]));
let etypes: Asn1SequenceOf<IntegerAsn1> = Asn1SequenceOf::from(
opts.etypes
.iter()
.map(|e| IntegerAsn1::from(i32_to_der_bytes(*e)))
.collect::<Vec<_>>(),
);
Ok(KdcReqBody {
kdc_options: ExplicitContextTag0::from(kdc_options),
cname: Optional::from(Some(ExplicitContextTag1::from(cname))),
realm: ExplicitContextTag2::from(realm),
sname: Optional::from(Some(ExplicitContextTag3::from(sname))),
from: Optional::from(None),
till: ExplicitContextTag5::from(opts.till.clone()),
rtime: Optional::from(None),
nonce: ExplicitContextTag7::from(IntegerAsn1::from(u32_to_der_bytes(opts.nonce))),
etype: ExplicitContextTag8::from(etypes),
addresses: Optional::from(None),
enc_authorization_data: Optional::from(None),
additional_tickets: Optional::from(None),
})
}
pub fn compute_as_req_body_checksum(opts: &AsReqOpts<'_>) -> Result<[u8; 20]> {
let body = make_kdc_req_body(opts)?;
let body_der = picky_asn1_der::to_vec(&body)
.map_err(|e| Error::AsRepParse(format!("encode KdcReqBody for checksum: {e}")))?;
use sha1::{Digest, Sha1};
let mut out = [0u8; 20];
out.copy_from_slice(&Sha1::digest(&body_der));
Ok(out)
}
pub fn build_as_req(opts: &AsReqOpts<'_>) -> Result<Vec<u8>> {
let req_body = make_kdc_req_body(opts)?;
let padata = vec![
PaData {
padata_type: ExplicitContextTag1::from(IntegerAsn1::from(i32_to_der_bytes(
PA_PK_AS_REQ_TYPE,
))),
padata_data: ExplicitContextTag2::from(OctetStringAsn1::from(
opts.pa_pk_as_req_der.to_vec(),
)),
},
PaData {
padata_type: ExplicitContextTag1::from(IntegerAsn1::from(i32_to_der_bytes(
PA_PAC_REQUEST_TYPE,
))),
padata_data: ExplicitContextTag2::from(OctetStringAsn1::from(vec![
0x30, 0x05, 0xA0, 0x03, 0x01, 0x01, 0xFF,
])),
},
];
let kdc_req = KdcReq {
pvno: ExplicitContextTag1::from(IntegerAsn1::from(vec![5])),
msg_type: ExplicitContextTag2::from(IntegerAsn1::from(vec![AS_REQ_MSG_TYPE])),
padata: Optional::from(Some(ExplicitContextTag3::from(Asn1SequenceOf::from(
padata,
)))),
req_body: ExplicitContextTag4::from(req_body),
};
let as_req: AsReq = ApplicationTag(kdc_req);
picky_asn1_der::to_vec(&as_req).map_err(|e| Error::AsRepParse(format!("encode AS-REQ: {e}")))
}
fn kerb_string(s: &str) -> Result<KerberosStringAsn1> {
Ia5String::from_string(s.to_owned())
.map(|ia5| GeneralStringAsn1::from(ia5))
.map_err(|e| Error::AsRepParse(format!("kerberos-string {s:?}: {e}")))
}
fn i32_to_der_bytes(v: i32) -> Vec<u8> {
if v == 0 {
return vec![0];
}
let mut buf = v.to_be_bytes().to_vec();
if v > 0 {
while buf.len() > 1 && buf[0] == 0 && (buf[1] & 0x80) == 0 {
buf.remove(0);
}
} else {
while buf.len() > 1 && buf[0] == 0xFF && (buf[1] & 0x80) != 0 {
buf.remove(0);
}
}
buf
}
fn u32_to_der_bytes(v: u32) -> Vec<u8> {
let mut buf = v.to_be_bytes().to_vec();
while buf.len() > 1 && buf[0] == 0 && (buf[1] & 0x80) == 0 {
buf.remove(0);
}
if (buf[0] & 0x80) != 0 {
buf.insert(0, 0);
}
buf
}
pub fn process_as_rep(
as_rep_bytes: &[u8],
client_dh: &DhKeyPair,
client_key: &RsaPrivateKey,
expected_nonce: u32,
kdf_key_bytes: usize,
) -> Result<AsRepResult> {
if let Some(first) = as_rep_bytes.first() {
if *first == 0x60 | 30 || *first == 0x40 | 30 {
let err: ApplicationTag<picky_krb::messages::KrbErrorInner, KRB_ERROR_MSG_TYPE> =
picky_asn1_der::from_bytes(as_rep_bytes)
.map_err(|e| Error::AsRepParse(format!("KRB-ERROR parse: {e}")))?;
return Err(Error::KrbError(format!("code={:?}", err.0.error_code.0)));
}
}
let as_rep: AsRep = picky_asn1_der::from_bytes(as_rep_bytes)
.map_err(|e| Error::AsRepParse(format!("AS-REP: {e}")))?;
let msg_type = as_rep.0.msg_type.0 .0.last().copied().unwrap_or(0);
if msg_type != AS_REP_MSG_TYPE {
return Err(Error::AsRepParse(format!(
"AS-REP msg-type = {msg_type} (expected {AS_REP_MSG_TYPE})"
)));
}
let padata_list = as_rep
.0
.padata
.0
.as_ref()
.map(|p| p.0 .0.as_slice())
.unwrap_or(&[]);
let pk_rep_padata = padata_list
.iter()
.find(|p| padata_type_matches(&p.padata_type.0, PA_PK_AS_REP_TYPE))
.ok_or_else(|| Error::AsRepParse("no PA-PK-AS-REP padata in AS-REP".into()))?;
let pa_pk_as_rep: PaPkAsRep = picky_asn1_der::from_bytes(&pk_rep_padata.padata_data.0 .0)
.map_err(|e| Error::AsRepParse(format!("PA-PK-AS-REP: {e}")))?;
let reply_key = match pa_pk_as_rep {
PaPkAsRep::DhInfo(dh_info) => {
let signed_data = &dh_info.0.dh_signed_data.0 .0;
let dh_key_info_der = extract_signed_data_econtent(signed_data)?;
let kdc_dh_info: KdcDhKeyInfo = picky_asn1_der::from_bytes(&dh_key_info_der)
.map_err(|e| Error::AsRepParse(format!("KdcDhKeyInfo: {e}")))?;
let nonce_matches_ok = integer_matches_u32(&kdc_dh_info.nonce.0, expected_nonce);
if !nonce_matches_ok {
return Err(Error::AsRepParse(format!(
"KdcDhKeyInfo nonce mismatch (expected {expected_nonce})"
)));
}
let peer_y = parse_bit_string_integer(&kdc_dh_info.subject_public_key.0)?;
let zz = client_dh.compute_shared(&peer_y);
octet_string_to_key(Hash::Sha256, &zz, &[], kdf_key_bytes)?
}
PaPkAsRep::EncKeyPack(bytes) => {
let content_info = &bytes.0 .0;
let reply_key = enveloped::decrypt_enc_key_pack(content_info, client_key)?;
if reply_key.len() != kdf_key_bytes {
return Err(Error::AsRepParse(format!(
"encKeyPack reply-key is {} bytes, caller expected {} (etype mismatch?)",
reply_key.len(),
kdf_key_bytes
)));
}
reply_key
}
};
let ticket_bytes = picky_asn1_der::to_vec(&as_rep.0.ticket.0)
.map_err(|e| Error::AsRepParse(format!("ticket encode: {e}")))?;
Ok(AsRepResult {
ticket: ticket_bytes,
session_key: reply_key,
pac_credential_info: None,
debug_as_req_der: Vec::new(),
})
}
fn padata_type_matches(v: &IntegerAsn1, expected: i32) -> bool {
let bytes = &v.0;
let mut acc: i32 = if bytes.first().copied().unwrap_or(0) & 0x80 != 0 {
-1
} else {
0
};
for &b in bytes {
acc = (acc << 8) | (b as i32 & 0xFF);
}
acc == expected
}
fn integer_matches_u32(v: &IntegerAsn1, expected: u32) -> bool {
let mut bytes = v.0.as_slice();
while bytes.len() > 1 && bytes[0] == 0 {
bytes = &bytes[1..];
}
if bytes.len() > 4 {
return false;
}
let mut acc: u32 = 0;
for &b in bytes {
acc = (acc << 8) | b as u32;
}
acc == expected
}
fn parse_bit_string_integer(bs: &BitStringAsn1) -> Result<BigUint> {
let payload = bs.0.payload_view();
if payload.first().copied() != Some(0x02) {
return Err(Error::AsRepParse("subjectPublicKey not INTEGER".into()));
}
let (int_bytes, _rest) = tlv_split(payload)?;
let mut bs = int_bytes;
if bs.len() > 1 && bs[0] == 0 && (bs[1] & 0x80) != 0 {
bs = &bs[1..];
}
Ok(BigUint::from_bytes_be(bs))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn i32_der_boundary_values() {
assert_eq!(i32_to_der_bytes(0), vec![0]);
assert_eq!(i32_to_der_bytes(1), vec![1]);
assert_eq!(i32_to_der_bytes(127), vec![127]);
assert_eq!(i32_to_der_bytes(128), vec![0, 128]); assert_eq!(i32_to_der_bytes(-1), vec![0xFF]);
assert_eq!(i32_to_der_bytes(-128), vec![0x80]);
}
#[test]
fn u32_der_positive_only() {
assert_eq!(u32_to_der_bytes(0), vec![0]);
assert_eq!(
u32_to_der_bytes(0xDEADBEEF),
vec![0, 0xDE, 0xAD, 0xBE, 0xEF]
);
assert_eq!(u32_to_der_bytes(0x7F), vec![0x7F]);
}
#[test]
fn body_checksum_matches_body_actually_in_as_req() {
use picky_asn1::date::GeneralizedTime;
use picky_asn1::wrapper::GeneralizedTimeAsn1;
use sha1::{Digest, Sha1};
let till = GeneralizedTime::new(2038, 1, 1, 0, 0, 0).unwrap();
let etypes = [18i32, 17, 23];
let cname = ["alice"];
let sname = ["krbtgt", "EXAMPLE.COM"];
let opts = AsReqOpts {
realm: "EXAMPLE.COM",
cname: &cname,
sname: &sname,
pa_pk_as_req_der: &[0x30, 0x00], nonce: 0xDEADBEEF,
till: GeneralizedTimeAsn1::from(till),
etypes: &etypes,
};
let checksum = compute_as_req_body_checksum(&opts).expect("checksum");
assert_eq!(checksum.len(), 20, "SHA-1 output is 20 bytes");
let as_req_der = build_as_req(&opts).expect("build_as_req");
let parsed: AsReq = picky_asn1_der::from_bytes(&as_req_der).expect("re-parse AS-REQ");
let body_der = picky_asn1_der::to_vec(&parsed.0.req_body.0).expect("re-encode body");
let mut expected = [0u8; 20];
expected.copy_from_slice(&Sha1::digest(&body_der));
assert_eq!(
checksum, expected,
"compute_as_req_body_checksum must hash the exact KdcReqBody DER emitted by build_as_req"
);
}
#[test]
fn body_checksum_is_deterministic_for_same_opts() {
use picky_asn1::date::GeneralizedTime;
use picky_asn1::wrapper::GeneralizedTimeAsn1;
let till = GeneralizedTime::new(2038, 1, 1, 0, 0, 0).unwrap();
let etypes = [18i32];
let cname = ["bob"];
let sname = ["krbtgt", "REALM"];
let opts = AsReqOpts {
realm: "REALM",
cname: &cname,
sname: &sname,
pa_pk_as_req_der: &[],
nonce: 42,
till: GeneralizedTimeAsn1::from(till),
etypes: &etypes,
};
let a = compute_as_req_body_checksum(&opts).unwrap();
let b = compute_as_req_body_checksum(&opts).unwrap();
assert_eq!(a, b);
}
}