Refactor Bc into BcMeta, not full BcHeader

This commit is contained in:
George Hilliard committed 2020-04-18 17:00:43 -05:00
1 parent b72d93b1f9
commit 1897bf33c4
4 files changed
+134 -74

No files matched your search

+28 -32
View File
@@ -13,17 +13,30 @@ impl Bc {
fn bc_msg(buf: &[u8]) -> IResult<&[u8], Bc> {
let (buf, header) = bc_header(buf)?;
let (buf, msg) = bc_modern_msg(&header, buf)?;
let (buf, body) = bc_body(&header, buf)?;
let bc = Bc {
header,
body: BcBody::ModernMsg(msg),
meta: header.to_meta(),
body,
};
Ok((buf, bc))
}
fn bc_modern_msg<'a, 'b, E: ParseError<&'b [u8]>>(header: &'a BcHeader, buf: &'b [u8]) -> IResult<&'b [u8], ModernMsg, E> {
fn bc_body<'a, 'b>(header: &'a BcHeader, buf: &'b [u8])
-> IResult<&'b [u8], BcBody>
{
if header.is_modern() {
let (buf, body) = bc_modern_msg(header, buf)?;
Ok((buf, BcBody::ModernMsg(body)))
} else {
unimplemented!()
}
}
fn bc_modern_msg<'a, 'b, E: ParseError<&'b [u8]>>(header: &'a BcHeader, buf: &'b [u8])
-> IResult<&'b [u8], ModernMsg, E>
{
let end_of_xml = header.bin_offset.unwrap_or(buf.len() as u32);
let (mut buf, body_buf) = take(end_of_xml)(buf)?;
@@ -56,7 +69,7 @@ fn bc_modern_msg<'a, 'b, E: ParseError<&'b [u8]>>(header: &'a BcHeader, buf: &'b
Ok((buf, msg))
}
fn bc_header<'a, E: ParseError<&'a [u8]>>(buf: &'a [u8]) -> IResult<&[u8], BcHeader, E> {
fn bc_header(buf: &[u8]) -> IResult<&[u8], BcHeader> {
let (buf, _magic) = verify(le_u32, |x| *x == MAGIC_HEADER)(buf)?;
let (buf, msg_id) = le_u32(buf)?;
let (buf, body_len) = le_u32(buf)?;
@@ -84,33 +97,16 @@ fn bc_header<'a, E: ParseError<&'a [u8]>>(buf: &'a [u8]) -> IResult<&[u8], BcHea
fn test_bc_modern_login() {
let sample = include_bytes!("samples/model_sample_modern_login.bin");
let (_, msg) = bc_msg(&sample[..]).unwrap();
assert_eq!(msg.header.msg_id, 1);
assert_eq!(msg.header.body_len, 145);
assert_eq!(msg.header.enc_offset, 0x1000000);
assert_eq!(msg.header.encrypted, true);
assert_eq!(msg.header.class, 0x6614);
match msg.body {
BcBody::ModernMsg(ModernMsg{ xml: Some(xml), binary: None }) => {
assert_eq!(xml.encryption.unwrap().nonce, "9E6D1FCB9E69846D")
}
_ => assert!(false),
}
}
#[test]
fn test_bc_with_binary() {
let sample = include_bytes!("samples/model_sample_modern_login.bin");
let (_, msg) = bc_msg(&sample[..]).unwrap();
assert_eq!(msg.header.msg_id, 1);
assert_eq!(msg.header.body_len, 145);
assert_eq!(msg.header.enc_offset, 0x1000000);
assert_eq!(msg.header.encrypted, true);
assert_eq!(msg.header.class, 0x6614);
match msg.body {
BcBody::ModernMsg(ModernMsg{ xml: Some(xml), binary: None }) => {
assert_eq!(xml.encryption.unwrap().nonce, "9E6D1FCB9E69846D")
let (buf, header) = bc_header(&sample[..]).unwrap();
let (_, body) = bc_body(&header, buf).unwrap();
assert_eq!(header.msg_id, 1);
assert_eq!(header.body_len, 145);
assert_eq!(header.enc_offset, 0x1000000);
assert_eq!(header.encrypted, true);
assert_eq!(header.class, 0x6614);
match body {
BcBody::ModernMsg(ModernMsg{ xml: Some(ref xml), binary: None }) => {
assert_eq!(xml.encryption.as_ref().unwrap().nonce, "9E6D1FCB9E69846D")
}
_ => assert!(false),
}
+48 -10
View File
@@ -2,12 +2,12 @@ use super::xml::Body;
pub(super) const MAGIC_HEADER: u32 = 0xabcdef0;
const MSG_ID_LOGIN: u32 = 1;
const MSG_ID_VIDEO: u32 = 3;
pub const MSG_ID_LOGIN: u32 = 1;
pub const MSG_ID_VIDEO: u32 = 3;
#[derive(Debug, PartialEq, Eq)]
pub struct Bc {
pub(super) header: BcHeader,
pub meta: BcMeta,
pub body: BcBody,
}
@@ -17,7 +17,7 @@ pub enum BcBody {
ModernMsg(ModernMsg),
}
#[derive(Debug, PartialEq, Eq)]
#[derive(Debug, Default, PartialEq, Eq)]
pub struct ModernMsg {
pub xml: Option<Body>,
pub binary: Option<Vec<u8>>,
@@ -33,12 +33,30 @@ pub enum LegacyMsg {
#[derive(Debug, PartialEq, Eq)]
pub(super) struct BcHeader {
pub(super) body_len: u32,
pub(super) msg_id: u32,
pub(super) enc_offset: u32,
pub(super) encrypted: bool,
pub(super) class: u16,
pub(super) bin_offset: Option<u32>,
pub body_len: u32,
pub msg_id: u32,
pub enc_offset: u32,
pub encrypted: bool,
pub class: u16,
pub bin_offset: Option<u32>,
}
/// The components of the Baichuan TLV header that are not
/// descriptions of the Body (the application dictates these)
#[derive(Debug, PartialEq, Eq)]
pub struct BcMeta {
pub msg_id: u32,
pub client_idx: u32,
pub class: u16,
pub encrypted: bool,
}
/// The components of the Baichuan header that must be filled out after the body is serialized, or
/// is needed for the deserialization of the body (strictly part of the wire format of the message)
#[derive(Debug, PartialEq, Eq)]
pub(super) struct BcSendInfo {
pub body_len: u32,
pub bin_offset: Option<u32>,
}
impl BcHeader {
@@ -59,6 +77,26 @@ impl BcHeader {
pub fn is_encrypted(&self) -> bool {
self.encrypted || self.class == 0x6414
}
pub fn to_meta(&self) -> BcMeta {
BcMeta {
msg_id: self.msg_id,
client_idx: self.enc_offset,
class: self.class,
encrypted: self.encrypted,
}
}
pub fn from_meta(meta: &BcMeta, body_len: u32, bin_offset: Option<u32>) -> BcHeader {
BcHeader {
bin_offset,
body_len,
msg_id: meta.msg_id,
enc_offset: meta.client_idx,
class: meta.class,
encrypted: meta.encrypted,
}
}
}
pub(super) fn has_bin_offset(class: u16) -> bool {
+42 -30
View File
@@ -7,39 +7,53 @@ use super::model::*;
use super::xml::Body;
use super::xml_crypto;
pub type Error = GenError;
impl Bc {
pub fn serialize(&self, buf: &mut [u8]) -> Result<(), GenError> {
gen(bc_msg(self), buf).map(|_| ())
pub fn serialize<W: Write>(&self, buf: W) -> Result<W, GenError> {
// Ideally this would be a combinator, but that would be hairy because we have to
// serialize the XML to have the metadata to build the header
let body_buf;
let bin_offset;
match &self.body {
BcBody::ModernMsg(ref modern) => {
let (buf, xml_len) = gen(opt_ref(&modern.xml, |xml| bc_xml(self.meta.client_idx, xml)), vec!())?;
body_buf = buf;
bin_offset = if has_bin_offset(self.meta.class) {
// If we're required to put binary length, put 0 if we have no binary
Some(if modern.binary.is_some() { xml_len as u32 } else { 0 })
} else { None };
}
BcBody::LegacyMsg(..) => {
//bin_offset = None;
unimplemented!()
}
}
// Now have enough info to create the header
let header = BcHeader::from_meta(&self.meta, body_buf.len() as u32, bin_offset);
let (mut buf, _n) = gen(
tuple((
bc_header(&header),
slice(body_buf),
)), buf)?;
// Put the binary part of the body, TODO this is poorly written
if let BcBody::ModernMsg(ModernMsg { binary: Some(ref binary), .. }) = self.body {
let (buf2, _) = gen(slice(binary), buf)?;
buf = buf2
}
Ok(buf)
}
}
fn bc_msg<'a, W: Write + 'a>(msg: &'a Bc) -> impl SerializeFn<W> + 'a {
use BcBody::*;
tuple((
bc_header(&msg.header),
match msg.body {
ModernMsg(ref body) => bc_modern(body),
LegacyMsg(..) => unimplemented!()
}
))
}
fn bc_modern<'a, W: 'a + Write>(body: &'a ModernMsg) -> impl SerializeFn<W> + 'a {
tuple((
opt_ref(&body.xml, |xml| bc_xml(true, 0, xml)),
opt_ref(&body.binary, slice),
))
}
fn bc_xml<W: Write>(encrypted: bool, enc_offset: u32, xml: &Body) -> impl SerializeFn<W>
fn bc_xml<W: Write>(enc_offset: u32, xml: &Body) -> impl SerializeFn<W>
{
let xml_bytes = xml.serialize(vec!()).unwrap();
if encrypted {
let enc_bytes = xml_crypto::crypt(enc_offset, &xml_bytes);
slice(enc_bytes)
} else {
slice(xml_bytes)
}
let enc_bytes = xml_crypto::crypt(enc_offset, &xml_bytes);
slice(enc_bytes)
}
fn bc_header<W: Write>(header: &BcHeader) -> impl SerializeFn<W> {
@@ -94,9 +108,7 @@ fn test_login_roundtrip() {
let msg = Bc::deserialize(&sample[..]).unwrap();
let mut ser_buf = vec![0; sample.len()];
msg.serialize(&mut ser_buf[..]).unwrap();
let ser_buf = msg.serialize(vec!()).unwrap();
let msg2 = Bc::deserialize(ser_buf.as_ref()).unwrap();
assert_eq!(msg, msg2);
}
+16 -2
View File
@@ -52,7 +52,7 @@ pub struct LoginUser {
pub user_ver: u32,
}
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize)]
#[derive(PartialEq, Eq, Debug, YaDeserialize, YaSerialize)]
pub struct LoginNet {
#[yaserde(attribute)]
pub version: String,
@@ -62,6 +62,20 @@ pub struct LoginNet {
pub udp_port: u16,
}
impl Default for LoginNet {
fn default() -> Self {
LoginNet {
version: xml_ver(),
type_: "LAN".to_string(),
udp_port: 0,
}
}
}
pub fn xml_ver() -> String {
"1.1".to_string()
}
#[test]
fn test_encryption_deser() {
let sample = indoc!(r#"
@@ -141,7 +155,7 @@ fn test_login_ser() {
};
let b2 = Body::try_parse(sample.as_bytes()).unwrap();
let b3 = Body::try_parse(yaserde::ser::to_string(&b).unwrap().as_bytes()).unwrap();
let b3 = Body::try_parse(b.serialize(vec!()).unwrap().as_slice()).unwrap();
assert_eq!(b, b2);
assert_eq!(b, b3);