asahi/exe-parse
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 写了一个派生宏，来简单的序列化一个结构体

Browse Source
This commit is contained in:
381848900@qq.com
2024-12-09 16:26:29 +08:00
parent f837e7cdaf
commit 142a8cd3eb
8 changed files with 199 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files

248
src-tauri/src/commands.rs
View File

@@ -3,8 +3,8 @@ use crate::{
pe_parse::{header::ImageDosHeader, pe::PE},
services::{self, GLOBAL_FILE_DATA},
};
use serde::{ser::SerializeStruct, Serialize, Serializer};
use serde_json::Value;
use serde::Serialize;
#[tauri::command]
pub fn greet(name: &str) -> String {
format!("Hello, {}! You've been greeted from Rust!", name)
@@ -99,250 +99,6 @@ pub struct ResponseDOSHeaderData {
children: Option<Vec<ResponseDOSHeaderData>>,
}
fn serialize_field<S>(
state: &mut S,
name: &'static str,
value: Option<String>,
size: usize,
field_type: &str,
offset: usize,
children: Option<Vec<ResponseDOSHeaderData>>,
) -> Result<(), S::Error>
where
S: serde::ser::SerializeStruct,
{
state.serialize_field(
name,
&ResponseDOSHeaderData {
name: name.to_string(),
value,
size,
field_type: field_type.to_string(),
offset,
children,
},
)
}
impl Serialize for ImageDosHeader {
fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
where
S: serde::Serializer,
{
let mut state = serializer.serialize_struct("ResponseDOSHeaderData", 19)?;
// 序列化每个字段
serialize_field(
&mut state,
"e_magic",
Some(format!("0x{:04X}", self.e_magic)),
std::mem::size_of_val(&self.e_magic),
"u16",
offset_of!(self, e_magic),
None,
)?;
serialize_field(
&mut state,
"e_cblp",
Some(format!("0x{:04X}", self.e_cblp)),
std::mem::size_of_val(&self.e_cblp),
"u16",
offset_of!(self, e_cblp),
None,
)?;
serialize_field(
&mut state,
"e_cp",
Some(format!("0x{:04X}", self.e_cp)),
std::mem::size_of_val(&self.e_cp),
"u16",
offset_of!(self, e_cp),
None,
)?;
serialize_field(
&mut state,
"e_crlc",
Some(format!("0x{:04X}", self.e_crlc)),
std::mem::size_of_val(&self.e_crlc),
"u16",
offset_of!(self, e_crlc),
None,
)?;
serialize_field(
&mut state,
"e_cparhdr",
Some(format!("0x{:04X}", self.e_cparhdr)),
std::mem::size_of_val(&self.e_cparhdr),
"u16",
offset_of!(self, e_cparhdr),
None,
)?;
serialize_field(
&mut state,
"e_minalloc",
Some(format!("0x{:04X}", self.e_minalloc)),
std::mem::size_of_val(&self.e_minalloc),
"u16",
offset_of!(self, e_minalloc),
None,
)?;
serialize_field(
&mut state,
"e_maxalloc",
Some(format!("0x{:04X}", self.e_maxalloc)),
std::mem::size_of_val(&self.e_maxalloc),
"u16",
offset_of!(self, e_maxalloc),
None,
)?;
serialize_field(
&mut state,
"e_ss",
Some(format!("0x{:04X}", self.e_ss)),
std::mem::size_of_val(&self.e_ss),
"u16",
offset_of!(self, e_ss),
None,
)?;
serialize_field(
&mut state,
"e_sp",
Some(format!("0x{:04X}", self.e_sp)),
std::mem::size_of_val(&self.e_sp),
"u16",
offset_of!(self, e_sp),
None,
)?;
serialize_field(
&mut state,
"e_csum",
Some(format!("0x{:04X}", self.e_csum)),
std::mem::size_of_val(&self.e_csum),
"u16",
offset_of!(self, e_csum),
None,
)?;
serialize_field(
&mut state,
"e_ip",
Some(format!("0x{:04X}", self.e_ip)),
std::mem::size_of_val(&self.e_ip),
"u16",
offset_of!(self, e_ip),
None,
)?;
serialize_field(
&mut state,
"e_cs",
Some(format!("0x{:04X}", self.e_cs)),
std::mem::size_of_val(&self.e_cs),
"u16",
offset_of!(self, e_cs),
None,
)?;
serialize_field(
&mut state,
"e_lfarlc",
Some(format!("0x{:04X}", self.e_lfarlc)),
std::mem::size_of_val(&self.e_lfarlc),
"u16",
offset_of!(self, e_lfarlc),
None,
)?;
serialize_field(
&mut state,
"e_ovno",
Some(format!("0x{:04X}", self.e_ovno)),
std::mem::size_of_val(&self.e_ovno),
"u16",
offset_of!(self, e_ovno),
None,
)?;
// e_res 序列化，带 children
let mut e_res_children = Vec::new();
for (index, value) in self.e_res.iter().enumerate() {
e_res_children.push(ResponseDOSHeaderData {
name: format!("e_res[{}]", index),
value: Some(format!("0x{:04X}", value)),
size: std::mem::size_of_val(value),
field_type: "u16".to_string(),
offset: offset_of!(self, e_res) + index * std::mem::size_of::<u16>(),
children: None,
});
}
serialize_field(
&mut state,
"e_res",
None,
std::mem::size_of_val(&self.e_res),
"[u16;4]",
offset_of!(self, e_res),
Some(e_res_children),
)?;
// e_oemid 序列化
serialize_field(
&mut state,
"e_oemid",
Some(format!("0x{:04X}", self.e_oemid)),
std::mem::size_of_val(&self.e_oemid),
"u16",
offset_of!(self, e_oemid),
None,
)?;
// e_oeminfo 序列化
serialize_field(
&mut state,
"e_oeminfo",
Some(format!("0x{:04X}", self.e_oeminfo)),
std::mem::size_of_val(&self.e_oeminfo),
"u16",
offset_of!(self, e_oeminfo),
None,
)?;
// e_res2 序列化
let mut e_res2_children = Vec::new();
for (index, value) in self.e_res2.iter().enumerate() {
e_res2_children.push(ResponseDOSHeaderData {
name: format!("e_res2[{}]", index),
value: Some(format!("0x{:04X}", value)),
size: std::mem::size_of_val(value),
field_type: "u16".to_string(),
offset: offset_of!(self, e_res2) + index * std::mem::size_of::<u16>(),
children: None,
});
}
serialize_field(
&mut state,
"e_res2",
None,
std::mem::size_of_val(&self.e_res2),
"[u16;10]",
offset_of!(self, e_res2),
Some(e_res2_children),
)?;
// e_lfanew 序列化
serialize_field(
&mut state,
"e_lfanew",
Some(format!("0x{:04X}", self.e_lfanew.0)), // 假设 Offset 是简单的 tuple struct
std::mem::size_of_val(&self.e_lfanew),
"Offset",
offset_of!(self, e_lfanew),
None,
)?;
state.end()
}
}
// 命令，获取DOS头数据
#[tauri::command]
pub fn command_get_pe_data_dos_header() -> Result<ImageDosHeader, AppError> {

8
src-tauri/src/pe_parse/header.rs
View File

@@ -1,8 +1,10 @@
use super::types::*;
use bitflags::bitflags;
use serde::Serialize;
use pe_serialize_proc_macro::SerializeEX;
use serde::ser::SerializeStruct;
#[repr(C)]
#[derive(Debug, Clone, Copy)]
#[derive(Debug, Clone, Copy, SerializeEX)]
pub struct ImageDosHeader {
pub e_magic: u16, // Magic number 固定值 0x5A4D
pub e_cblp: u16,
@@ -22,7 +24,7 @@ pub struct ImageDosHeader {
pub e_oemid: u16,
pub e_oeminfo: u16,
pub e_res2: [u16; 10],
pub e_lfanew: Offset, // File address of new exe header nt头的偏移
pub e_lfanew: u32, // File address of new exe header nt头的偏移
}
#[repr(C)]