pers 0.1.0

Parser for Windows Portable Executable (PE) files that borrows the file data, a Rust port of PeNet
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Accessors for the .NET (CLR) metadata.

use alloc::vec::Vec;

use uuid::Uuid;

use super::PeFile;
use crate::error::Result;
use crate::lazy::{Lazy, cached};
use crate::net::{
    BlobHeap, GuidHeap, MetadataHeader, MetadataTablesHeader, StringsHeap, UserStringsHeap,
    com_type_lib_id, module_version_ids, type_ref_hash,
};

/// Cached .NET structures of a [`PeFile`].
#[derive(Debug, Default)]
pub(super) struct DotNetCache<'a> {
    metadata_header: Lazy<Result<Option<MetadataHeader<'a>>>>,
    tables_header: Lazy<Result<Option<MetadataTablesHeader<'a>>>>,
    type_ref_hash: Lazy<Result<Option<[u8; 32]>>>,
    module_version_ids: Lazy<Result<Option<Vec<Uuid>>>>,
    com_type_lib_id: Lazy<Result<Option<Uuid>>>,
}

impl<'a> PeFile<'a> {
    /// True if the file has a CLI (COM descriptor) header.
    pub fn is_dot_net(&self) -> bool {
        matches!(self.com_descriptor(), Ok(Some(_)))
    }

    /// The metadata root referenced by the CLI header.
    pub fn metadata_header(&self) -> Result<Option<&MetadataHeader<'a>>> {
        cached(&self.cache.dot_net.metadata_header, || {
            let Some(com_descriptor) = self.com_descriptor()? else {
                return Ok(None);
            };
            let rva = com_descriptor.meta_data().virtual_address();
            if rva.get() == 0 {
                return Ok(None);
            }
            let offset = self.section_headers()?.rva_to_offset(rva)?;
            MetadataHeader::parse(self.data, offset.usize()).map(Some)
        })
        .map(Option::as_ref)
    }

    /// The `#Strings` heap.
    pub fn metadata_strings(&self) -> Result<Option<StringsHeap<'a>>> {
        self.parse_stream("#Strings", StringsHeap::parse)
    }

    /// The `#US` (user strings) heap.
    pub fn metadata_user_strings(&self) -> Result<Option<UserStringsHeap<'a>>> {
        self.parse_stream("#US", UserStringsHeap::parse)
    }

    /// The `#GUID` heap.
    pub fn metadata_guids(&self) -> Result<Option<GuidHeap<'a>>> {
        self.parse_stream("#GUID", GuidHeap::parse)
    }

    /// The `#Blob` heap.
    pub fn metadata_blob(&self) -> Result<Option<BlobHeap<'a>>> {
        self.parse_stream("#Blob", BlobHeap::parse)
    }

    /// The header of the `#~` stream with all metadata tables.
    pub fn metadata_tables_header(&self) -> Result<Option<&MetadataTablesHeader<'a>>> {
        cached(&self.cache.dot_net.tables_header, || {
            self.parse_stream("#~", |data, offset, _| {
                MetadataTablesHeader::parse(data, offset)
            })
        })
        .map(Option::as_ref)
    }

    /// The TypeRefHash, `Ok(None)` for files without metadata tables or `#Strings` heap.
    pub fn type_ref_hash(&self) -> Result<Option<[u8; 32]>> {
        cached(&self.cache.dot_net.type_ref_hash, || {
            let (Some(tables_header), Some(strings)) =
                (self.metadata_tables_header()?, self.metadata_strings()?)
            else {
                return Ok(None);
            };
            type_ref_hash(tables_header, &strings).map(Some)
        })
        .copied()
    }

    /// The module version ID of each module, `Ok(None)` for files without metadata tables.
    pub fn clr_module_version_ids(&self) -> Result<Option<&[Uuid]>> {
        cached(&self.cache.dot_net.module_version_ids, || {
            let Some(tables_header) = self.metadata_tables_header()? else {
                return Ok(None);
            };
            Ok(Some(module_version_ids(
                tables_header.tables()?,
                self.metadata_guids()?.as_ref(),
            )))
        })
        .map(Option::as_deref)
    }

    /// The COM TypeLib ID of the assembly, `Ok(None)` if it is not specified.
    pub fn clr_com_type_lib_id(&self) -> Result<Option<Uuid>> {
        cached(&self.cache.dot_net.com_type_lib_id, || {
            let (Some(tables_header), Some(strings), Some(blob)) = (
                self.metadata_tables_header()?,
                self.metadata_strings()?,
                self.metadata_blob()?,
            ) else {
                return Ok(None);
            };
            com_type_lib_id(tables_header.tables()?, &strings, &blob)
        })
        .copied()
    }

    /// Parse the first stream with the given name. The stream offset is relative to the
    /// metadata root.
    fn parse_stream<T>(
        &self,
        name: &str,
        parse: impl FnOnce(&'a [u8], usize, usize) -> Result<T>,
    ) -> Result<Option<T>> {
        let Some(header) = self.metadata_header()? else {
            return Ok(None);
        };
        let Some(stream) = header.stream(name) else {
            return Ok(None);
        };
        let offset = header.offset.usize() + stream.stream_offset as usize;
        parse(self.data, offset, stream.size as usize).map(Some)
    }
}