wdext 0.1.0

A DbgEng wrapper framework
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

// SPDX-FileCopyrightText: 2026 takubokudori
// SPDX-License-Identifier: MIT OR Apache-2.0
#[cfg(test)]
pub mod tests {
    use crate::tests::util::local_debug;
    use wdext::{
        PointerWidth, ReadStringStatus, TObject, TargetContext,
        object::traits::string::{AnsiString, UnicodeString},
    };

    mod x64 {
        pub use wdext::object::win_25h2::x64::*;
    }
    mod x86 {
        pub use wdext::object::win_25h2::x86::*;
    }

    mod util;

    fn assert_strings<AS: AnsiString, US: UnicodeString>(ctx: &TargetContext) {
        let addr_us: US::Ptr =
            ctx.evaluate_pointer("String!us").unwrap().into();
        let addr_as: AS::Ptr =
            ctx.evaluate_pointer("String!as").unwrap().into();
        let tobj_us =
            TObject::read_pointer(addr_us, ctx, ctx.memory()).unwrap();
        let tobj_as =
            TObject::read_pointer(addr_as, ctx, ctx.memory()).unwrap();

        assert_eq!(tobj_us.object().length(), 4);
        assert_eq!(tobj_us.object().maximum_length(), 4);
        assert_eq!(
            tobj_us
                .object()
                .read_string(ctx, ctx.memory(), None)
                .unwrap(),
            ("Te".to_string(), ReadStringStatus::MaxBytesReached)
        );
        assert_eq!(
            tobj_us.object().read_string(ctx, ctx.memory(), 2).unwrap(),
            ("T".to_string(), ReadStringStatus::MaxBytesReached)
        );
        assert_eq!(
            tobj_us
                .object()
                .read_string(ctx, ctx.memory(), 10000)
                .unwrap(),
            (
                "Test UNICODE_STRING".to_string(),
                ReadStringStatus::NulTerminated
            )
        );

        assert_eq!(tobj_as.object().length(), 4);
        assert_eq!(tobj_as.object().maximum_length(), 4);
        assert_eq!(
            tobj_as
                .object()
                .read_string(ctx, ctx.memory(), None, 932)
                .unwrap(),
            ("Test".to_string(), ReadStringStatus::MaxBytesReached)
        );
        assert_eq!(
            tobj_as
                .object()
                .read_string(ctx, ctx.memory(), 2, 932)
                .unwrap(),
            ("Te".to_string(), ReadStringStatus::MaxBytesReached)
        );
        assert_eq!(
            tobj_as
                .object()
                .read_string(ctx, ctx.memory(), 10000, 932)
                .unwrap(),
            (
                "Test ANSI_STRING".to_string(),
                ReadStringStatus::NulTerminated,
            )
        );
    }

    #[test]
    fn test_strings() {
        #[cfg(target_arch = "x86")]
        let exe_path = r#"./tests/bin/x86/String.exe"#;
        #[cfg(target_arch = "x86_64")]
        let exe_path = r#"./tests/bin/x64/String.exe"#;
        let ctx = local_debug(exe_path);
        match ctx.pointer_width() {
            PointerWidth::Ptr32 => {
                assert_strings::<
                    x86::string::_ANSI_STRING,
                    x86::string::_UNICODE_STRING,
                >(&ctx);
            }
            PointerWidth::Ptr64 => {
                assert_strings::<
                    x64::string::_ANSI_STRING,
                    x64::string::_UNICODE_STRING,
                >(&ctx);
            }
        }
    }
}