cilium 0.0.0

An experimental Rust library for interfacing with Microsoft's CLI assembly format.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use std::io::{Cursor, ErrorKind, Read};
use std::fmt::{Debug, Formatter};
use std::sync::Arc;

pub use crate::raw::heaps::blob::BlobHeap;
pub use crate::raw::heaps::guid::GuidHeap;
pub use crate::raw::heaps::string::{StringHeap, UserStringHeap};

use crate::raw::heaps::table::TableHeap;
use crate::raw::indices::metadata_token;
use crate::raw::indices::sizes::IndexSizes;
use crate::utilities::{FromByteStream, read_string_from_stream_into};

pub mod table;
pub mod guid;
pub mod string;
pub mod blob;

#[derive(Debug)]
pub enum MetadataHeap<'l> {
	Blob(BlobHeap<'l>),
	Guid(GuidHeap<'l>),
	Table(TableHeap<'l>),
	String(StringHeap<'l>),
	UserString(UserStringHeap<'l>),
}

impl<'l> MetadataHeap<'l> {
	#[cfg_attr(feature = "tracing", tracing::instrument(skip_all))]
	pub fn read(stream: &mut Cursor<&'l [u8]>, data: &'l [u8]) -> std::io::Result<Arc<Self>> {
		if stream.get_ref().as_ptr() != data.as_ptr() {
			return Err(ErrorKind::InvalidInput.into());
		}

		let offset = u32::read(stream, &())? as usize;
		let size = u32::read(stream, &())? as usize;

		let mut name = [0u8; 32];
		let name = read_string_from_stream_into::<4>(stream, name.as_mut_slice())?;
		let data = &data[offset..offset + size];

		match name {
			"#Blob" => Ok(Arc::new(Self::Blob(BlobHeap::from(data)))),
			"#US" => Ok(Arc::new(Self::UserString(UserStringHeap::from(data)))),
			"#~" => Ok(Arc::new(Self::Table(TableHeap::try_from(data)?))),
			"#GUID" => Ok(Arc::new(Self::Guid(GuidHeap::try_from(data)?))),
			"#Strings" => Ok(Arc::new(Self::String(StringHeap::try_from(data)?))),
			_ => unimplemented!("Unimplemented MetadataHeap kind {:?}", name),
		}
	}
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct StringIndex(pub usize);

impl FromByteStream for StringIndex {
	type Deps = IndexSizes;
	fn read(stream: &mut Cursor<&[u8]>, sizes: &Self::Deps) -> std::io::Result<Self> {
		let mut value = 0usize.to_ne_bytes();
		stream.read_exact(&mut value[..sizes.string])?;
		Ok(Self(usize::from_le_bytes(value)))
	}
}

impl From<StringIndex> for metadata_token::String {
	#[inline]
	fn from(value: StringIndex) -> Self {
		Self(value.0)
	}
}

impl From<StringIndex> for metadata_token::MetadataToken {
	#[inline]
	fn from(value: StringIndex) -> Self {
		metadata_token::String(value.0).into()
	}
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct BlobIndex(pub usize);

impl FromByteStream for BlobIndex {
	type Deps = IndexSizes;
	fn read(stream: &mut Cursor<&[u8]>, sizes: &Self::Deps) -> std::io::Result<Self> {
		let mut value = 0usize.to_ne_bytes();
		stream.read_exact(&mut value[..sizes.blob])?;
		Ok(Self(usize::from_le_bytes(value)))
	}
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct GuidIndex(pub usize);

impl FromByteStream for GuidIndex {
	type Deps = IndexSizes;
	fn read(stream: &mut Cursor<&[u8]>, sizes: &Self::Deps) -> std::io::Result<Self> {
		let mut value = 0usize.to_ne_bytes();
		stream.read_exact(&mut value[..sizes.guid])?;
		Ok(Self(usize::from_le_bytes(value)))
	}
}

pub(crate) struct SizeDebugWrapper(usize);
impl Debug for SizeDebugWrapper {
	#[inline]
	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
		f.write_str("[u8; ")?;
		Debug::fmt(&self.0, f)?;
		f.write_str("]")
	}
}