use alloc::vec::Vec;
use crate::error::{Diagnostic, DiagnosticCode, Error, ErrorKind, Result, Strictness};
use crate::il::{FoldedIter, InstructionIter};
use crate::pe::PeImage;
use crate::reader::Reader;
use crate::tables::MethodDefRow;
use crate::token::{TableId, Token};
const CTX: &str = "method body";
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum HeaderKind {
Tiny,
Fat,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct FatFlags(pub u16);
impl FatFlags {
pub const fn more_sects(self) -> bool {
self.0 & 0x0008 != 0
}
pub const fn init_locals(self) -> bool {
self.0 & 0x0010 != 0
}
pub const fn bits(self) -> u16 {
self.0
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum HandlerKind {
Catch(Token),
Filter {
filter_offset: u32,
},
Finally,
Fault,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ExceptionHandler {
pub kind: HandlerKind,
pub try_offset: u32,
pub try_length: u32,
pub handler_offset: u32,
pub handler_length: u32,
pub raw_flags: u32,
}
impl ExceptionHandler {
pub const fn try_end(&self) -> u32 {
self.try_offset.saturating_add(self.try_length)
}
pub const fn handler_end(&self) -> u32 {
self.handler_offset.saturating_add(self.handler_length)
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct RawSection<'a> {
pub kind: u8,
pub data: &'a [u8],
}
#[derive(Clone, Debug)]
pub struct MethodBody<'a> {
pub kind: HeaderKind,
pub flags: FatFlags,
pub max_stack: u16,
pub code: &'a [u8],
pub code_rva: u32,
pub local_var_sig: Option<Token>,
pub exception_handlers: Vec<ExceptionHandler>,
pub unknown_sections: Vec<RawSection<'a>>,
pub header_dwords: u8,
pub total_size: usize,
diagnostics: Vec<Diagnostic>,
}
impl<'a> MethodBody<'a> {
pub fn parse(bytes: &'a [u8], code_rva: u32) -> Result<Self> {
Self::parse_with(bytes, code_rva, Strictness::Permissive)
}
pub fn parse_with(bytes: &'a [u8], code_rva: u32, strictness: Strictness) -> Result<Self> {
let mut diagnostics = Vec::new();
let mut r = Reader::new(bytes, 0, CTX);
let first = r.peek_u8()?;
match first & 0x03 {
0x02 => {
let header = r.u8()?;
let code_size = usize::from(header >> 2);
let code = r.take(code_size)?;
Ok(MethodBody {
kind: HeaderKind::Tiny,
flags: FatFlags(0),
max_stack: 8,
code,
code_rva: code_rva.wrapping_add(1),
local_var_sig: None,
exception_handlers: Vec::new(),
unknown_sections: Vec::new(),
header_dwords: 0,
total_size: 1 + code_size,
diagnostics,
})
}
0x03 => {
let flags_and_size = r.u16()?;
let flags = FatFlags(flags_and_size & 0x0FFF);
let header_dwords = (flags_and_size >> 12) as u8;
let max_stack = r.u16()?;
let code_size = r.u32()? as usize;
let local_var_sig_tok = r.u32()?;
if header_dwords != 3 {
if strictness.is_strict() {
return Err(Error::new(ErrorKind::Malformed, 0, CTX));
}
diagnostics.push(Diagnostic::new(
DiagnosticCode::FatHeaderSize,
0,
u64::from(header_dwords),
));
}
let header_size = usize::from(header_dwords.max(3)) * 4;
r.seek(header_size)?;
let code = r.take(code_size)?;
let local_var_sig = match local_var_sig_tok {
0 => None,
value => Some(Token(value)),
};
if strictness.is_strict()
&& local_var_sig.is_some_and(|t| t.table() != Some(TableId::StandAloneSig))
{
return Err(Error::new(ErrorKind::Malformed, 8, CTX));
}
let mut exception_handlers = Vec::new();
let mut unknown_sections = Vec::new();
if flags.more_sects() {
parse_sections(
&mut r,
strictness,
&mut diagnostics,
&mut exception_handlers,
&mut unknown_sections,
)?;
}
Ok(MethodBody {
kind: HeaderKind::Fat,
flags,
max_stack,
code,
code_rva: code_rva.wrapping_add(header_size as u32),
local_var_sig,
exception_handlers,
unknown_sections,
header_dwords,
total_size: r.position(),
diagnostics,
})
}
_ => Err(Error::new(ErrorKind::Malformed, 0, CTX)),
}
}
pub fn from_image(image: &PeImage<'a>, method: &MethodDefRow) -> Result<Option<Self>> {
if method.has_no_body() {
return Ok(None);
}
let bytes = image.rva_rest(method.rva)?;
Self::parse_with(bytes, method.rva, image.strictness()).map(Some)
}
pub fn diagnostics(&self) -> &[Diagnostic] {
&self.diagnostics
}
pub fn code_size(&self) -> usize {
self.code.len()
}
pub fn validate_handlers(&self) -> Result<()> {
let code_len = self.code.len() as u64;
for (i, h) in self.exception_handlers.iter().enumerate() {
let try_end = u64::from(h.try_offset) + u64::from(h.try_length);
let handler_end = u64::from(h.handler_offset) + u64::from(h.handler_length);
if try_end > code_len || handler_end > code_len {
return Err(Error::new(ErrorKind::OutOfRange, i, "exception handler"));
}
if h.try_length == 0 || h.handler_length == 0 {
return Err(Error::new(ErrorKind::Malformed, i, "exception handler"));
}
if h.handler_offset < h.try_end() && h.handler_end() > h.try_offset {
return Err(Error::new(ErrorKind::Malformed, i, "exception handler"));
}
if let HandlerKind::Filter { filter_offset } = h.kind {
if u64::from(filter_offset) >= code_len {
return Err(Error::new(ErrorKind::OutOfRange, i, "exception filter"));
}
if filter_offset >= h.handler_offset {
return Err(Error::new(ErrorKind::Malformed, i, "exception filter"));
}
}
for (j, other) in self.exception_handlers.iter().enumerate() {
if i == j {
continue;
}
if partially_overlaps(h.try_offset, h.try_end(), other.try_offset, other.try_end())
{
return Err(Error::new(ErrorKind::Malformed, i, "exception handler nesting"));
}
if partially_overlaps(
h.handler_offset,
h.handler_end(),
other.handler_offset,
other.handler_end(),
) {
return Err(Error::new(ErrorKind::Malformed, i, "exception handler nesting"));
}
}
}
Ok(())
}
pub fn instructions(&self) -> InstructionIter<'a> {
InstructionIter::new(self.code)
}
pub fn folded_instructions(&self) -> FoldedIter<'a> {
FoldedIter::new(self.code)
}
pub fn instruction_offsets(&self) -> Vec<u32> {
let mut offsets = Vec::new();
for item in self.instructions() {
match item {
Ok(instruction) => offsets.push(instruction.offset),
Err(_) => break,
}
}
offsets
}
pub fn is_instruction_boundary(&self, offset: u32) -> bool {
for item in self.instructions() {
match item {
Ok(instruction) => {
if instruction.offset == offset {
return true;
}
if instruction.offset > offset {
return false;
}
}
Err(_) => return false,
}
}
false
}
}
fn partially_overlaps(a_start: u32, a_end: u32, b_start: u32, b_end: u32) -> bool {
let overlaps = a_start < b_end && b_start < a_end;
if !overlaps {
return false;
}
let a_in_b = b_start <= a_start && a_end <= b_end;
let b_in_a = a_start <= b_start && b_end <= a_end;
!a_in_b && !b_in_a
}
fn parse_sections<'a>(
r: &mut Reader<'a>,
strictness: Strictness,
diagnostics: &mut Vec<Diagnostic>,
handlers: &mut Vec<ExceptionHandler>,
unknown: &mut Vec<RawSection<'a>>,
) -> Result<()> {
loop {
r.align_to(0, 4)?;
let section_start = r.position();
let kind = r.u8()?;
let fat = kind & 0x40 != 0;
let more = kind & 0x80 != 0;
let data_size = if fat {
let b = r.take(3)?;
u32::from(b[0]) | (u32::from(b[1]) << 8) | (u32::from(b[2]) << 16)
} else {
let size = u32::from(r.u8()?);
let _reserved = r.u16()?;
size
};
let is_eh = kind & 0x01 != 0;
let clause_size: usize = if fat { 24 } else { 12 };
let declared = data_size as usize;
let mut body_size = declared.saturating_sub(4);
if is_eh
&& clause_size > 0
&& body_size % clause_size != 0
&& declared % clause_size == 0
&& declared <= r.remaining()
{
if strictness.is_strict() {
return Err(Error::new(ErrorKind::Malformed, section_start, CTX));
}
diagnostics.push(Diagnostic::new(
DiagnosticCode::EhSectionSize,
section_start,
u64::from(data_size),
));
body_size = declared;
}
let available = r.remaining();
let body_size = if body_size > available {
if strictness.is_strict() {
return Err(Error::new(ErrorKind::Truncated, section_start, CTX));
}
diagnostics.push(Diagnostic::new(
DiagnosticCode::EhSectionSize,
section_start,
u64::from(data_size),
));
available
} else {
body_size
};
let body = r.take(body_size)?;
if is_eh {
if body.len() % clause_size != 0 {
if strictness.is_strict() {
return Err(Error::new(ErrorKind::Malformed, section_start, CTX));
}
diagnostics.push(Diagnostic::new(
DiagnosticCode::EhSectionSize,
section_start,
body.len() as u64,
));
}
let count = body.len() / clause_size;
handlers.reserve(count);
for i in 0..count {
let chunk = &body[i * clause_size..(i + 1) * clause_size];
handlers.push(read_clause(chunk, fat, section_start + 4 + i * clause_size)?);
}
} else {
unknown.push(RawSection { kind, data: body });
}
if !more {
return Ok(());
}
if r.is_empty() {
if strictness.is_strict() {
return Err(Error::new(ErrorKind::Truncated, r.position(), CTX));
}
return Ok(());
}
}
}
fn read_clause(chunk: &[u8], fat: bool, at: usize) -> Result<ExceptionHandler> {
let mut r = Reader::new(chunk, at, "exception clause");
let (raw_flags, try_offset, try_length, handler_offset, handler_length, extra) = if fat {
(r.u32()?, r.u32()?, r.u32()?, r.u32()?, r.u32()?, r.u32()?)
} else {
let flags = u32::from(r.u16()?);
let try_offset = u32::from(r.u16()?);
let try_length = u32::from(r.u8()?);
let handler_offset = u32::from(r.u16()?);
let handler_length = u32::from(r.u8()?);
let extra = r.u32()?;
(flags, try_offset, try_length, handler_offset, handler_length, extra)
};
let kind = match raw_flags & 0x0007 {
0x0000 => HandlerKind::Catch(Token(extra)),
0x0001 => HandlerKind::Filter { filter_offset: extra },
0x0002 => HandlerKind::Finally,
0x0004 => HandlerKind::Fault,
_ => return Err(Error::new(ErrorKind::Malformed, at, "exception clause")),
};
Ok(ExceptionHandler { kind, try_offset, try_length, handler_offset, handler_length, raw_flags })
}
#[cfg(test)]
mod tests {
use super::*;
fn tiny(code: &[u8]) -> Vec<u8> {
let mut out = alloc::vec![((code.len() as u8) << 2) | 0x02];
out.extend_from_slice(code);
out
}
fn fat(code: &[u8], flags: u16, sections: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
out.extend_from_slice(&((3u16 << 12) | flags | 0x0003).to_le_bytes());
out.extend_from_slice(&8u16.to_le_bytes());
out.extend_from_slice(&(code.len() as u32).to_le_bytes());
out.extend_from_slice(&0x1100_0001u32.to_le_bytes());
out.extend_from_slice(code);
while out.len() % 4 != 0 {
out.push(0);
}
out.extend_from_slice(sections);
out
}
#[test]
fn parses_a_tiny_header() {
let body = tiny(&[0x00, 0x2A]);
let parsed = MethodBody::parse(&body, 0x2000).unwrap();
assert_eq!(parsed.kind, HeaderKind::Tiny);
assert_eq!(parsed.max_stack, 8);
assert_eq!(parsed.code, &[0x00, 0x2A]);
assert_eq!(parsed.code_rva, 0x2001);
assert_eq!(parsed.local_var_sig, None);
assert_eq!(parsed.total_size, 3);
assert!(parsed.exception_handlers.is_empty());
}
#[test]
fn a_tiny_body_can_be_the_maximum_63_bytes() {
let code = alloc::vec![0u8; 63];
let body = tiny(&code);
assert_eq!(MethodBody::parse(&body, 0).unwrap().code.len(), 63);
}
#[test]
fn parses_a_fat_header() {
let body = fat(&[0x2A], 0x0010, &[]);
let parsed = MethodBody::parse(&body, 0x2000).unwrap();
assert_eq!(parsed.kind, HeaderKind::Fat);
assert!(parsed.flags.init_locals());
assert!(!parsed.flags.more_sects());
assert_eq!(parsed.code, &[0x2A]);
assert_eq!(parsed.code_rva, 0x200C);
assert_eq!(parsed.local_var_sig, Some(Token(0x1100_0001)));
assert_eq!(parsed.header_dwords, 3);
}
#[test]
fn parses_a_small_exception_section() {
let mut section = alloc::vec![0x01u8, 4 + 12, 0, 0];
section.extend_from_slice(&0x0002u16.to_le_bytes()); section.extend_from_slice(&0u16.to_le_bytes()); section.push(4); section.extend_from_slice(&4u16.to_le_bytes()); section.push(4); section.extend_from_slice(&0u32.to_le_bytes());
let body = fat(&[0x00; 8], 0x0008, §ion);
let parsed = MethodBody::parse(&body, 0).unwrap();
assert_eq!(parsed.exception_handlers.len(), 1);
let h = parsed.exception_handlers[0];
assert_eq!(h.kind, HandlerKind::Finally);
assert_eq!((h.try_offset, h.try_length), (0, 4));
assert_eq!((h.handler_offset, h.handler_length), (4, 4));
parsed.validate_handlers().unwrap();
}
#[test]
fn parses_a_fat_exception_section_and_chained_sections() {
let mut section = alloc::vec![0x41u8 | 0x80]; let size = 4u32 + 24;
section.extend_from_slice(&size.to_le_bytes()[..3]);
section.extend_from_slice(&0x0001u32.to_le_bytes()); section.extend_from_slice(&0u32.to_le_bytes());
section.extend_from_slice(&4u32.to_le_bytes());
section.extend_from_slice(&8u32.to_le_bytes());
section.extend_from_slice(&4u32.to_le_bytes());
section.extend_from_slice(&4u32.to_le_bytes()); section.extend_from_slice(&[0x02, 4 + 4, 0, 0, 0xDE, 0xAD, 0xBE, 0xEF]);
let body = fat(&[0x00; 12], 0x0008, §ion);
let parsed = MethodBody::parse(&body, 0).unwrap();
assert_eq!(parsed.exception_handlers.len(), 1);
assert_eq!(parsed.exception_handlers[0].kind, HandlerKind::Filter { filter_offset: 4 });
assert_eq!(parsed.unknown_sections.len(), 1);
assert_eq!(parsed.unknown_sections[0].data, &[0xDE, 0xAD, 0xBE, 0xEF]);
parsed.validate_handlers().unwrap();
}
#[test]
fn a_section_size_that_omits_its_own_header_is_recovered() {
let mut section = alloc::vec![0x01u8, 24, 0, 0];
for (flags, try_offset, try_length, handler_offset, handler_length) in
[(0x0000u16, 0u16, 8u8, 8u16, 4u8), (0x0002, 0, 12, 12, 4)]
{
section.extend_from_slice(&flags.to_le_bytes());
section.extend_from_slice(&try_offset.to_le_bytes());
section.push(try_length);
section.extend_from_slice(&handler_offset.to_le_bytes());
section.push(handler_length);
section.extend_from_slice(&0u32.to_le_bytes());
}
let body = fat(&[0x00; 16], 0x0008, §ion);
let parsed = MethodBody::parse(&body, 0).unwrap();
assert_eq!(parsed.exception_handlers.len(), 2, "the second clause must survive");
assert_eq!(parsed.exception_handlers[0].kind, HandlerKind::Catch(Token(0)));
assert_eq!(parsed.exception_handlers[1].kind, HandlerKind::Finally);
assert!(parsed.diagnostics().iter().any(|d| d.code == DiagnosticCode::EhSectionSize));
parsed.validate_handlers().unwrap();
assert!(MethodBody::parse_with(&body, 0, Strictness::Strict).is_err());
}
#[test]
fn a_conforming_section_size_is_never_reinterpreted() {
for count in 0..=20u8 {
let declared = 4 + u32::from(count) * 12;
let mut section = alloc::vec![0x01u8, declared as u8, 0, 0];
for _ in 0..count {
section.extend_from_slice(&0x0002u16.to_le_bytes());
section.extend_from_slice(&0u16.to_le_bytes());
section.push(4);
section.extend_from_slice(&4u16.to_le_bytes());
section.push(4);
section.extend_from_slice(&0u32.to_le_bytes());
}
let body = fat(&[0x00; 8], 0x0008, §ion);
let parsed = MethodBody::parse(&body, 0).unwrap();
assert_eq!(parsed.exception_handlers.len(), usize::from(count), "count {count}");
assert!(
parsed.diagnostics().is_empty(),
"a conforming section must not be diagnosed, count {count}"
);
}
}
#[test]
fn validate_rejects_ranges_outside_the_code() {
let mut section = alloc::vec![0x01u8, 4 + 12, 0, 0];
section.extend_from_slice(&0x0002u16.to_le_bytes());
section.extend_from_slice(&0u16.to_le_bytes());
section.push(200); section.extend_from_slice(&4u16.to_le_bytes());
section.push(4);
section.extend_from_slice(&0u32.to_le_bytes());
let body = fat(&[0x00; 8], 0x0008, §ion);
let parsed = MethodBody::parse(&body, 0).unwrap();
assert_eq!(parsed.code.len(), 8);
assert_eq!(parsed.validate_handlers().unwrap_err().kind, ErrorKind::OutOfRange);
}
#[test]
fn validate_rejects_partially_overlapping_try_blocks() {
let mut section = alloc::vec![0x01u8, 4 + 24, 0, 0];
for (try_offset, try_length, handler_offset) in [(0u16, 8u8, 8u16), (4, 8, 12)] {
section.extend_from_slice(&0x0002u16.to_le_bytes());
section.extend_from_slice(&try_offset.to_le_bytes());
section.push(try_length);
section.extend_from_slice(&handler_offset.to_le_bytes());
section.push(4);
section.extend_from_slice(&0u32.to_le_bytes());
}
let body = fat(&[0x00; 16], 0x0008, §ion);
let parsed = MethodBody::parse(&body, 0).unwrap();
assert_eq!(parsed.exception_handlers.len(), 2);
assert!(parsed.validate_handlers().is_err());
}
#[test]
fn a_fat_header_size_other_than_three_is_diagnosed() {
let mut body = fat(&[0x2A], 0, &[]);
body[1] = (body[1] & 0x0F) | 0x40; let parsed = MethodBody::parse(&body, 0);
assert!(parsed.is_err() || parsed.unwrap().header_dwords == 4);
assert!(MethodBody::parse_with(&body, 0, Strictness::Strict).is_err());
}
#[test]
fn an_unknown_header_format_is_rejected() {
assert_eq!(MethodBody::parse(&[0x00], 0).unwrap_err().kind, ErrorKind::Malformed);
assert_eq!(MethodBody::parse(&[0x01], 0).unwrap_err().kind, ErrorKind::Malformed);
assert_eq!(MethodBody::parse(&[], 0).unwrap_err().kind, ErrorKind::Truncated);
}
#[test]
fn every_truncation_of_a_body_errors_cleanly() {
let mut section = alloc::vec![0x01u8, 4 + 12, 0, 0];
section.extend_from_slice(&0x0002u16.to_le_bytes());
section.extend_from_slice(&0u16.to_le_bytes());
section.push(4);
section.extend_from_slice(&4u16.to_le_bytes());
section.push(4);
section.extend_from_slice(&0u32.to_le_bytes());
let body = fat(&[0x00; 8], 0x0008, §ion);
for len in 0..body.len() {
let _ = MethodBody::parse(&body[..len], 0);
let _ = MethodBody::parse_with(&body[..len], 0, Strictness::Strict);
}
}
#[test]
fn overlap_helper_distinguishes_nesting_from_overlap() {
assert!(!partially_overlaps(0, 10, 2, 5)); assert!(!partially_overlaps(2, 5, 0, 10)); assert!(!partially_overlaps(0, 4, 4, 8)); assert!(partially_overlaps(0, 6, 4, 10)); }
}