276 lines
12 KiB
Rust
276 lines
12 KiB
Rust
//! Parser for a .dex file.
|
|
|
|
use crate::{
|
|
CallSiteIdItem, ClassDefItem, EndianConstant, Error, FieldIdItem, HeaderItem, MapItemType,
|
|
MapList, MethodHandleItem, MethodIdItem, ProtoIdItem, Result, Serializable, StringIdItem,
|
|
TypeIdItem,
|
|
};
|
|
use std::io::{Cursor, Seek, SeekFrom};
|
|
|
|
pub struct DexFileReader<'a> {
|
|
data: &'a [u8],
|
|
header: HeaderItem,
|
|
string_ids: Vec<StringIdItem>,
|
|
type_ids: Vec<TypeIdItem>,
|
|
proto_ids: Vec<ProtoIdItem>,
|
|
field_ids: Vec<FieldIdItem>,
|
|
method_ids: Vec<MethodIdItem>,
|
|
class_defs: Vec<ClassDefItem>,
|
|
call_site_ids: Vec<CallSiteIdItem>,
|
|
method_handles: Vec<MethodHandleItem>,
|
|
map_list: MapList,
|
|
}
|
|
|
|
impl<'a> DexFileReader<'a> {
|
|
pub fn new(data: &'a [u8]) -> Result<Self> {
|
|
let mut buffer = Cursor::new(data);
|
|
let header = HeaderItem::deserialize(&mut buffer)?;
|
|
let mut tmp_file = Self {
|
|
data,
|
|
header,
|
|
// Default values before population
|
|
string_ids: vec![],
|
|
type_ids: vec![],
|
|
proto_ids: vec![],
|
|
field_ids: vec![],
|
|
method_ids: vec![],
|
|
class_defs: vec![],
|
|
call_site_ids: vec![],
|
|
method_handles: vec![],
|
|
map_list: MapList { list: vec![] },
|
|
};
|
|
tmp_file.map_list = tmp_file.get_struct_at_offset(tmp_file.header.map_off)?;
|
|
tmp_file.string_ids = tmp_file.get_item_list::<StringIdItem>(
|
|
tmp_file.header.string_ids_off,
|
|
tmp_file.header.string_ids_size,
|
|
)?;
|
|
tmp_file.type_ids = tmp_file.get_item_list::<TypeIdItem>(
|
|
tmp_file.header.type_ids_off,
|
|
tmp_file.header.type_ids_size,
|
|
)?;
|
|
tmp_file.proto_ids = tmp_file.get_item_list::<ProtoIdItem>(
|
|
tmp_file.header.proto_ids_off,
|
|
tmp_file.header.proto_ids_size,
|
|
)?;
|
|
tmp_file.field_ids = tmp_file.get_item_list::<FieldIdItem>(
|
|
tmp_file.header.field_ids_off,
|
|
tmp_file.header.field_ids_size,
|
|
)?;
|
|
tmp_file.method_ids = tmp_file.get_item_list::<MethodIdItem>(
|
|
tmp_file.header.method_ids_off,
|
|
tmp_file.header.method_ids_size,
|
|
)?;
|
|
tmp_file.class_defs = tmp_file.get_item_list::<ClassDefItem>(
|
|
tmp_file.header.class_defs_off,
|
|
tmp_file.header.class_defs_size,
|
|
)?;
|
|
if let Some(item) = tmp_file
|
|
.map_list
|
|
.list
|
|
.iter()
|
|
.find(|item| item.type_ == MapItemType::CallSiteIdItem)
|
|
{
|
|
tmp_file.call_site_ids =
|
|
tmp_file.get_item_list::<CallSiteIdItem>(item.offset, item.size)?
|
|
}
|
|
if let Some(item) = tmp_file
|
|
.map_list
|
|
.list
|
|
.iter()
|
|
.find(|item| item.type_ == MapItemType::CallSiteIdItem)
|
|
{
|
|
tmp_file.method_handles =
|
|
tmp_file.get_item_list::<MethodHandleItem>(item.offset, item.size)?
|
|
}
|
|
tmp_file.sanity_check()?;
|
|
Ok(tmp_file)
|
|
}
|
|
|
|
/// Return the file [`HeaderItem`].
|
|
pub fn get_header(&self) -> &HeaderItem {
|
|
&self.header
|
|
}
|
|
|
|
fn sanity_check(&self) -> Result<()> {
|
|
if self.header.magic.version != [0x30, 0x33, 0x39] {
|
|
println!(
|
|
"DEX 039 is the only verion currently supported, found {}",
|
|
std::str::from_utf8(self.header.magic.version.as_slice())
|
|
.unwrap_or(&format!("{:x?}", self.header.magic.version))
|
|
); // TODO: use proper logging
|
|
}
|
|
// TODO: check checksum
|
|
// TODO: check signature
|
|
if self.header.file_size as usize != self.data.len() {
|
|
println!(
|
|
"Unexpected file size found: {}, expected {}",
|
|
self.header.file_size,
|
|
self.data.len()
|
|
); // TODO: use proper logging
|
|
}
|
|
if self.header.header_size != 0x70 {
|
|
println!(
|
|
"Unexpected header size found: 0x{:x}",
|
|
self.header.header_size
|
|
); // TODO: use proper logging
|
|
}
|
|
if self.header.endian_tag != EndianConstant::EndianConstant {
|
|
println!("Wrong endian_tag found: {:x?}", self.header.endian_tag); // TODO: use proper logging
|
|
}
|
|
if self.header.link_off != 0 || self.header.link_size != 0 {
|
|
println!("Found non empty link section"); // TODO: use proper logging
|
|
}
|
|
for item in &self.map_list.list {
|
|
match item.type_ {
|
|
MapItemType::HeaderItem if item.offset != 0 || item.size != 1 => {
|
|
return Err(Error::InconsistantStruct(format!(
|
|
"Inconsistant Header Mapping info found in map_list: {item:x?}"
|
|
)))
|
|
}
|
|
MapItemType::StringIdItem
|
|
if item.offset != self.header.string_ids_off
|
|
|| item.size != self.header.string_ids_size =>
|
|
{
|
|
return Err(Error::InconsistantStruct(format!(
|
|
"Inconsistant MapList Mapping info found in map_list: {item:x?}, \
|
|
header.string_ids_off: 0x{:x}, header.string_ids_size: {}",
|
|
self.header.string_ids_off, self.header.string_ids_size
|
|
)))
|
|
}
|
|
MapItemType::TypeIdItem
|
|
if item.offset != self.header.type_ids_off
|
|
|| item.size != self.header.type_ids_size =>
|
|
{
|
|
return Err(Error::InconsistantStruct(format!(
|
|
"Inconsistant MapList Mapping info found in map_list: {item:x?}, \
|
|
header.type_ids_off: 0x{:x}, header.type_ids_size: {}",
|
|
self.header.type_ids_off, self.header.type_ids_size
|
|
)))
|
|
}
|
|
MapItemType::ProtoIdItem
|
|
if item.offset != self.header.proto_ids_off
|
|
|| item.size != self.header.proto_ids_size =>
|
|
{
|
|
return Err(Error::InconsistantStruct(format!(
|
|
"Inconsistant MapList Mapping info found in map_list: {item:x?}, \
|
|
header.proto_ids_off: 0x{:x}, header.proto_ids_size: {}",
|
|
self.header.proto_ids_off, self.header.proto_ids_size
|
|
)))
|
|
}
|
|
MapItemType::FieldIdItem
|
|
if item.offset != self.header.field_ids_off
|
|
|| item.size != self.header.field_ids_size =>
|
|
{
|
|
return Err(Error::InconsistantStruct(format!(
|
|
"Inconsistant MapList Mapping info found in map_list: {item:x?}, \
|
|
header.field_ids_off: 0x{:x}, header.field_ids_size: {}",
|
|
self.header.field_ids_off, self.header.field_ids_size
|
|
)))
|
|
}
|
|
MapItemType::MethodIdItem
|
|
if item.offset != self.header.method_ids_off
|
|
|| item.size != self.header.method_ids_size =>
|
|
{
|
|
return Err(Error::InconsistantStruct(format!(
|
|
"Inconsistant MapList Mapping info found in map_list: {item:x?}, \
|
|
header.method_ids_off: 0x{:x}, header.method_ids_size: {}",
|
|
self.header.method_ids_off, self.header.method_ids_size
|
|
)))
|
|
}
|
|
MapItemType::ClassDefItem
|
|
if item.offset != self.header.class_defs_off
|
|
|| item.size != self.header.class_defs_size =>
|
|
{
|
|
return Err(Error::InconsistantStruct(format!(
|
|
"Inconsistant MapList Mapping info found in map_list: {item:x?}, \
|
|
header.class_defs_off: 0x{:x}, header.class_defs_size: {}",
|
|
self.header.class_defs_off, self.header.class_defs_size
|
|
)))
|
|
}
|
|
MapItemType::CallSiteIdItem => todo!(),
|
|
MapItemType::MethodHandleItem => todo!(),
|
|
MapItemType::MapList if item.offset != self.header.map_off || item.size != 0 => {
|
|
return Err(Error::InconsistantStruct(format!(
|
|
"Inconsistant MapList Mapping info found in map_list: {item:x?}, \
|
|
header.map_list_off: 0x{:x}",
|
|
self.header.map_off
|
|
)))
|
|
}
|
|
/*
|
|
MapItemType::TypeList => todo!(),
|
|
MapItemType::AnnotationSetRefList => todo!(),
|
|
MapItemType::AnnotationSetItem => todo!(),
|
|
MapItemType::ClassDataItem => todo!(),
|
|
MapItemType::CodeItem => todo!(),
|
|
MapItemType::StringDataItem => todo!(),
|
|
MapItemType::DebugInfoItem => todo!(),
|
|
MapItemType::AnnotationItem => todo!(),
|
|
MapItemType::EncodedArrayItem => todo!(),
|
|
MapItemType::AnnotationsDirectoryItem => todo!(),
|
|
MapItemType::HiddenapiClassDataItem => todo!(),
|
|
*/
|
|
MapItemType::UnkownType(ty) => {
|
|
println!("Unknown Type found in map_list: 0x{ty:04x}"); // TODO: use proper
|
|
// loggin
|
|
}
|
|
_ => (),
|
|
}
|
|
let mut occurences = std::collections::HashMap::new();
|
|
for ty in self.map_list.list.iter().map(|val| val.type_) {
|
|
*occurences.entry(ty).or_insert(0) += 1;
|
|
}
|
|
let mut duplicate = false;
|
|
for (ty, val) in occurences {
|
|
if val > 1 {
|
|
println!("Found multiple {} occurence of {:?} in map_list", val, ty);
|
|
// TODO: use proper loggin
|
|
duplicate = true;
|
|
}
|
|
}
|
|
if duplicate {
|
|
return Err(Error::InconsistantStruct(
|
|
"Found multiple occurence of the same item type in map_list".into(),
|
|
));
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn get_item_list<T: Serializable>(&self, offset: u32, size: u32) -> Result<Vec<T>> {
|
|
let mut buffer = Cursor::new(self.data);
|
|
buffer.seek(SeekFrom::Start(offset as u64)).map_err(|err| {
|
|
Error::DeserializationError(format!("Failed to seek 0x{offset:x} position: {err}"))
|
|
})?;
|
|
let mut list = vec![];
|
|
for _ in 0..size {
|
|
let pos = buffer.stream_position().map_err(|err| {
|
|
Error::DeserializationError(format!("Failled to read buffer position: {err}"))
|
|
})?;
|
|
list.push(T::deserialize(&mut buffer).map_err(|err| {
|
|
Error::DeserializationError(format!(
|
|
"Failed to deserialize {} at 0x{:x}: {err}",
|
|
std::any::type_name::<T>(),
|
|
pos
|
|
))
|
|
})?);
|
|
}
|
|
Ok(list)
|
|
}
|
|
|
|
/// Return the structure `T` located at `offset` in the file.
|
|
///
|
|
/// # Warning
|
|
///
|
|
/// If the offset is invalid, UB.
|
|
pub fn get_struct_at_offset<T: Serializable>(&self, offset: u32) -> Result<T> {
|
|
let mut buffer = Cursor::new(self.data);
|
|
buffer.seek(SeekFrom::Start(offset as u64)).unwrap();
|
|
T::deserialize(&mut buffer).map_err(|err| {
|
|
Error::DeserializationError(format!(
|
|
"Failed to deserialize {} at 0x{:x}: {err}",
|
|
std::any::type_name::<T>(),
|
|
offset
|
|
))
|
|
})
|
|
}
|
|
}
|