Rust 实战练习 - 8. 内存,ASM,外挂 【重磅】

2024-03-25 21:12

本文主要是介绍Rust 实战练习 - 8. 内存,ASM,外挂 【重磅】,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

目标:

  • C写一个Demo版本的游戏
  • 由浅入深,了解外挂原理
  • Linux/Android下实现内存读取
  • ptrace实现内存修改(依赖第三方库)

先准备一个C写的小游戏

#include <stdio.h>
#include <string.h>struct Role
{float pos_x; // 位置xfloat pos_y;float pos_z;int level; // 等级long money; // 金钱
};struct Account
{char name[20]; // 名字long ID; // IDstruct Role *role; // 多个角色信息
};void decMoney(struct Role* r){r->money -= rand()%100;
}void main(){printf("GameBoy tester!\r\n");struct Account ac;strcpy(ac.name, "我是张三啊");ac.ID = 20240318;// rolesstruct Role *rl = (struct Role*)malloc(sizeof(struct Role)*4);ac.role = rl;for(int i=0;i<4;i++){rl[i].level = i*2+10;rl[i].money = 5000;rl[i].pos_x = i*1000;rl[i].pos_y = i*1100;rl[i].pos_z = i*1200;}while (1){printf("\r\nInput [l,m,p,c] to change value:");char input = getchar();switch (input){case 'l':for(int i=0;i<4;i++){rl[i].level += rand()%50/10;}break;case 'm':for(int i=0;i<4;i++){rl[i].money += rand()%20;}break;case 'p':for(int i=0;i<4;i++){rl[i].pos_x += rand()%100 * 0.1;rl[i].pos_y += rand()%20 * 0.2;rl[i].pos_z += rand()%10;}break;case 'c':for(int i=0;i<4;i++){decMoney(&rl[i]);}break;default:break;}// printprintf("\r\nAccount: [%ld] => %s\r\n", ac.ID, ac.name);for(int i=0;i<4;i++){printf("Role[%d] => Level:%d, Money: %ld, Pos:[%.2f,%.2f,%.2f]\r\n", i, rl[i].level, rl[i].money, rl[i].pos_x,rl[i].pos_y,rl[i].pos_z);}printf("Cheat: Account [0x%lX], ID [0x%lX], Name [0x%lX], role [%lX]\r\n", &ac, &(ac.ID), ac.name, &(ac.role));printf("Cheat: Role [0x%lX], pos_x [0x%lX], level [0x%lX], money [%lX]\r\n", rl, &(rl[0].pos_x), &(rl[0].level), &(rl[0].money));printf("Cheat: decMoney [0x%lX], main: {0x%lX}\r\n",decMoney, main); }
}// gcc -o gamebox main.c
// ./gamebox
Input [l,m,p,c] to change value:

只要输入 l/m/p/c 就可以随机改变其中的等级,金钱,位置信息。其中输入c会调用函数,随机减少角色的金钱。

Rust修改gamebox

有个出名的技术叫hook,还有一个技术叫修改内存。这也就是简单的游戏外挂范围的技术。这里我们使用rust去模拟一下,修改上面用C写的gamebox。

在Linux下如何搜索内存找到我们需要的数据,不在这里讨论,我们根据gamebox提供的地址,直接定位。一定要自己找,可以使用 PINCE。(类似CE)

备注:ceserver + wine + CE GUI 可以在Linux下进行搜索。

首先,反推几个重要信息的地址关系: (假设字节对齐)

[BaseAddr+0] => name 首地址, char[20]
[BaseAddr+20] => ID, long
[BaseAddr+20+8] => Role的首地址一个, Role size=3*4+4+8=24Role = [BaseAddr+20+8]
[[BaseAddr+20+8]+24*i +0] => Role.pos_x, float
[[BaseAddr+20+8]+24*i +4] => Role.pos_y, float
[[BaseAddr+20+8]+24*i +8] => Role.pos_z, float
[[BaseAddr+20+8]+24*i +12] => Role.level, int
[[BaseAddr+20+8]+24*i +16] => Role.money, long

虽然这个地址信息每次启动时会变化,但是他们的关系应该是固定的。

实际上,字节没有对齐,和我们上面预期有差异:

BaseAddr = 0x7FFEE5125640
[BaseAddr+0] => name 首地址, char[20] => 0x7FFEE5125640 实际占用是0x18=24
[BaseAddr+24] => ID, long => 0x7FFEE5125658
[BaseAddr+24+8] => Role的首地址一个, Role size=3*4+4+8=24  => 0x7FFEE5125660 Role = [BaseAddr+24+8] = [0x7FFEE5125660] = 0x5585F6BFE6B0
[[BaseAddr+24+8]+24*i +0] => Role.pos_x, float => 0x5585F6BFE6B0
[[BaseAddr+24+8]+24*i +4] => Role.pos_y, float
[[BaseAddr+24+8]+24*i +8] => Role.pos_z, float
[[BaseAddr+24+8]+24*i +12] => Role.level, int  => 0x5585F6BFE6BC
[[BaseAddr+24+8]+24*i +16] => Role.money, long => 0x5585F6BFE6C0

准备

https://blog.csdn.net/guojin08/article/details/9454467

https://blog.csdn.net/hhhlizhao/article/details/77930009

https://zhuanlan.zhihu.com/p/348171413

https://zhuanlan.zhihu.com/p/674139021

https://www.52pojie.cn/thread-1355860-1-1.html

Linux上一切皆文件,只要有权限,读写其他程序的内存很简单。

  1. sudo权限,强制读写/proc/ID/mem
  2. 自身为内核空间,直接读写mem
  3. 能获取到proc的mem的物理地址,读写物理内存
  4. dbg相关函数

如果想要注入,修改代码,需要使用ptrace一类的方式。

https://www.52pojie.cn/thread-1568457-1-1.html

Linux和Android的方法都是类似的.

简易内存修改

1.直接读取内存固定位置

读文件方式实现

andy@andy-pc:/proc/22093$ cat maps
5593869d4000-5593869d5000 r--p 00000000 08:12 6160449                    /home/andy/Work/rs_prj/d8/C/gamebox
5593869d5000-5593869d6000 r-xp 00001000 08:12 6160449                    /home/andy/Work/rs_prj/d8/C/gamebox
5593869d6000-5593869d7000 r--p 00002000 08:12 6160449                    /home/andy/Work/rs_prj/d8/C/gamebox
5593869d7000-5593869d8000 r--p 00002000 08:12 6160449                    /home/andy/Work/rs_prj/d8/C/gamebox
5593869d8000-5593869d9000 rw-p 00003000 08:12 6160449                    /home/andy/Work/rs_prj/d8/C/gamebox
559386d8f000-559386db0000 rw-p 00000000 00:00 0                          [heap]
7f914db19000-7f914db1c000 rw-p 00000000 00:00 0 
7f914db1c000-7f914db44000 r--p 00000000 08:12 12848718                   /usr/lib/x86_64-linux-gnu/libc.so.6
7f914db44000-7f914dcd9000 r-xp 00028000 08:12 12848718                   /usr/lib/x86_64-linux-gnu/libc.so.6
7f914dcd9000-7f914dd31000 r--p 001bd000 08:12 12848718                   /usr/lib/x86_64-linux-gnu/libc.so.6
7f914dd31000-7f914dd32000 ---p 00215000 08:12 12848718                   /usr/lib/x86_64-linux-gnu/libc.so.6
7f914dd32000-7f914dd36000 r--p 00215000 08:12 12848718                   /usr/lib/x86_64-linux-gnu/libc.so.6
7f914dd36000-7f914dd38000 rw-p 00219000 08:12 12848718                   /usr/lib/x86_64-linux-gnu/libc.so.6
7f914dd38000-7f914dd45000 rw-p 00000000 00:00 0 
7f914dd5e000-7f914dd60000 rw-p 00000000 00:00 0 
7f914dd60000-7f914dd62000 r--p 00000000 08:12 12848709                   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
7f914dd62000-7f914dd8c000 r-xp 00002000 08:12 12848709                   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
7f914dd8c000-7f914dd97000 r--p 0002c000 08:12 12848709                   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
7f914dd98000-7f914dd9a000 r--p 00037000 08:12 12848709                   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
7f914dd9a000-7f914dd9c000 rw-p 00039000 08:12 12848709                   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
7ffed5856000-7ffed5877000 rw-p 00000000 00:00 0                          [stack]
7ffed596e000-7ffed5972000 r--p 00000000 00:00 0                          [vvar]
7ffed5972000-7ffed5974000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0                  [vsyscall]# gamebox
Account: [20240318] => 我是张三啊
Role[0] => Level:14, Money: 4926, Pos:[9.00,3.80,3.00]
Role[1] => Level:15, Money: 4915, Pos:[1002.60,1100.00,1206.00]
Role[2] => Level:17, Money: 4925, Pos:[2007.20,2203.20,2401.00]
Role[3] => Level:20, Money: 4992, Pos:[3006.80,3301.40,3609.00]
Cheat: Account [0x7FFF90D18540], ID [0x7FFF90D18558], Name [0x7FFF90D18540], role [7FFF90D18560]
Cheat: Role [0x558CE6B4F6B0], pos_x [0x558CE6B4F6B0], level [0x558CE6B4F6BC], money [558CE6B4F6C0]
Cheat: decMoney [0x558CE63E11C9]

根据地址信息,数据主要存在 heap和stack上,函数存在代码段。

use std::{ffi::{CStr, OsString},fs::File,io::Read,os::unix::fs::FileExt,path, u8,
};// 64 bit program
fn main() {let pid = find_id_by_name("gamebox");println!("gamebox pid: {:?}", pid);if pid.len() > 0 {let memf = format!("/proc/{}/mem", pid.first().unwrap());println!("gamebox mem: {}", memf);// 需要root权限if let Ok(f) = &File::open(memf) {let base_addr:u64 = 0x7FFF90D18540;// accountlet id = read_at_mem(f, base_addr + 24, 8);let name = read_at_mem(f, base_addr + 0, 20);let role_addr = read_at_mem(f, base_addr + 24 + 8, 8);let name2 = unsafe { CStr::from_ptr(name.as_ptr() as *const i8) };let role_addr2 = u64::from_le_bytes(role_addr.try_into().unwrap());println!("Account => ID: {}, Name: {}, role addr: 0x{:#X}",u64::from_le_bytes(id.try_into().unwrap()),name2.to_str().unwrap(),role_addr2,);// rolefor i in 0..4 {let level = read_at_mem(f, role_addr2 + 24*i + 12, 4);let money = read_at_mem(f, role_addr2 + 24*i + 16, 8);let pos_x = read_at_mem(f, role_addr2 + 24*i + 0, 4);let pos_y = read_at_mem(f, role_addr2 + 24*i + 4, 4);let pos_z = read_at_mem(f, role_addr2 + 24*i + 8, 4);println!("  Role[{}] => Level: {}, Money: {}, Pos: [{:.2}, {:.2}, {:.2}]",i,u32::from_le_bytes(level.try_into().unwrap()),u64::from_le_bytes(money.try_into().unwrap()),f32::from_le_bytes(pos_x.try_into().unwrap()),f32::from_le_bytes(pos_y.try_into().unwrap()),f32::from_le_bytes(pos_z.try_into().unwrap()),);}} else {println!("need root permission!");}}
}// 读取指定大小的内存数据
fn read_at_mem(f: &File, addr: u64, sz: usize) -> Vec<u8> {let mut buf = Vec::new();buf.resize(sz, 0);f.read_at(&mut buf, addr).unwrap();return buf;
}// 忽略大小写进行进程查找
fn find_id_by_name(name: &str) -> Vec<String> {// 遍历和读取 /proc/xxx/commlet root = path::Path::new("/proc/");let mut pids: Vec<_> = Vec::new();for sub in root.read_dir().unwrap() {if let Ok(id_dir) = sub {let fp = id_dir.path();if fp.is_dir() {let comm = fp.join("comm");if comm.exists() {let txt = file_read_content(comm.to_str().unwrap());// println!("try file: {:?}, {}", comm, txt);if txt.to_ascii_lowercase() == name.to_ascii_lowercase() {let pid = OsString::from(fp.file_name().unwrap()).into_string().unwrap();pids.push(pid);}}}}}pids
}fn file_read_content(filepath: &str) -> String {let mut txt = String::new();if let Ok(mut f) = File::open(filepath) {f.read_to_string(&mut txt).unwrap();}// 默认内容有换行txt = txt.trim().to_string();return txt;
}

2.寻找基地址,真正外挂

基地址的本质是全局变量,所以我们原本的代码无法实现。

修改一下, 重新编译:

struct Account ac;void main(){printf("GameBoy tester!\r\n");   // struct Account ac; // 移动这个到全局变量strcpy(ac.name, "我是张三啊");ac.ID = 20240318;...
}

另外,程序每次加载到内存中并不一定是固定地址的。

  • 在Windows系统中,xp,win7时代是这样,每次固定加载在固定的地址上,所以每次程序运行的地址都是固定的。
  • 到了后来,windows系统和Linux都使用了动态基地址的flag, 每次的初始地址不固定,所以寻找基地址变得麻烦。

思路:

  • 程序加载到内存时,有导出表或者maps信息,可以看到code的初始地址。
  • main函数相对程序初始地址一般是固定的,与第一步地址一起计算可以得到main的动态地址。
  • 程序全局变量等的地址,相对main是固定的,所以就可以动态计算出来当前变量的地址。(即动态的基地址)

Linux上的获取基地址方法:

  1. 启动gamebox得到全局变量偏移信息
Account: [20240318] => 我是张三啊
Role[0] => Level:10, Money: 5000, Pos:[0.00,0.00,0.00]
Role[1] => Level:12, Money: 5000, Pos:[1000.00,1100.00,1200.00]
Role[2] => Level:14, Money: 5000, Pos:[2000.00,2200.00,2400.00]
Role[3] => Level:16, Money: 5000, Pos:[3000.00,3300.00,3600.00]
Cheat: Account [0x55AF86AE7040], ID [0x55AF86AE7058], Name [0x55AF86AE7040], role [55AF86AE7060]
Cheat: Role [0x55AF87D676B0], pos_x [0x55AF87D676B0], level [0x55AF87D676BC], money [55AF87D676C0]
Cheat: decMoney [0x55AF86AE41C9], main: {0x55AF86AE421E}

所以,Account Offset = Account[0x55AF86AE7040] - main[0x55AF86AE421E] = 0x2E22

  1. 通过gamebox进程maps信息获取main偏移
55af86ae3000-55af86ae4000 r--p 00000000 08:12 6160449               /home/andy/Work/rs_prj/d8/C/gamebox
55af86ae4000-55af86ae5000 r-xp 00001000 08:12 6160449               /home/andy/Work/rs_prj/d8/C/gamebox
55af86ae5000-55af86ae6000 r--p 00002000 08:12 6160449               /home/andy/Work/rs_prj/d8/C/gamebox
55af86ae6000-55af86ae7000 r--p 00002000 08:12 6160449               /home/andy/Work/rs_prj/d8/C/gamebox
55af86ae7000-55af86ae8000 rw-p 00003000 08:12 6160449               /home/andy/Work/rs_prj/d8/C/gamebox
55af87d67000-55af87d88000 rw-p 00000000 00:00 0                     [heap]

所以,main Offset = main[0x55AF86AE421E] - gamebox[0x55af86ae3000] = 0x121E

  1. 计算基地址偏移

BaseAddr = gamebox 基地址 + 0x121E + 0x2E22

  1. Code
use std::{ffi::{CStr, OsString},fs::File,io::{BufRead, BufReader, Cursor, Read},os::unix::fs::FileExt,path, u8,
};// 64 bit program
fn main() {let pids = find_id_by_name("gamebox");println!("gamebox pid: {:?}", pids);if pids.len() > 0 {let pid = pids.first().unwrap();let memf = format!("/proc/{}/mem", pid);let mut base_addr:u64 = process_get_base_addr(pid);if base_addr == 0 {println!("gamebox find base addr failed: {}", pid);return;}base_addr += 0x121E + 0x2E22; // Account ac 全局变量偏移println!("gamebox mem: {}, base addr: {:X}", memf, base_addr);// 需要root权限if let Ok(f) = &File::open(memf) {            // accountlet id = read_at_mem(f, base_addr + 24, 8);let name = read_at_mem(f, base_addr + 0, 20);let role_addr = read_at_mem(f, base_addr + 24 + 8, 8);let name2 = unsafe { CStr::from_ptr(name.as_ptr() as *const i8) };let role_addr2 = u64::from_le_bytes(role_addr.try_into().unwrap());println!("Account => ID: {}, Name: {}, role addr: 0x{:#X}",u64::from_le_bytes(id.try_into().unwrap()),name2.to_str().unwrap(),role_addr2,);// rolefor i in 0..4 {let level = read_at_mem(f, role_addr2 + 24*i + 12, 4);let money = read_at_mem(f, role_addr2 + 24*i + 16, 8);let pos_x = read_at_mem(f, role_addr2 + 24*i + 0, 4);let pos_y = read_at_mem(f, role_addr2 + 24*i + 4, 4);let pos_z = read_at_mem(f, role_addr2 + 24*i + 8, 4);println!("\tRole[{}] => Level: {}, Money: {}, Pos: [{:.2}, {:.2}, {:.2}]",i,u32::from_le_bytes(level.try_into().unwrap()),u64::from_le_bytes(money.try_into().unwrap()),f32::from_le_bytes(pos_x.try_into().unwrap()),f32::from_le_bytes(pos_y.try_into().unwrap()),f32::from_le_bytes(pos_z.try_into().unwrap()),);}} else {println!("need root permission!");}}
}fn read_at_mem(f: &File, addr: u64, sz: usize) -> Vec<u8> {let mut buf = Vec::new();buf.resize(sz, 0);f.read_at(&mut buf, addr).unwrap();return buf;
}// 忽略大小写进行进程查找
fn find_id_by_name(name: &str) -> Vec<String> {// 遍历和读取 /proc/xxx/commlet root = path::Path::new("/proc/");let mut pids: Vec<_> = Vec::new();for sub in root.read_dir().unwrap() {if let Ok(id_dir) = sub {let fp = id_dir.path();if fp.is_dir() {let comm = fp.join("comm");if comm.exists() {let txt = file_read_content(comm.to_str().unwrap());// println!("try file: {:?}, {}", comm, txt);if txt.to_ascii_lowercase() == name.to_ascii_lowercase() {let pid = OsString::from(fp.file_name().unwrap()).into_string().unwrap();pids.push(pid);}}}}}pids
}fn file_read_content(filepath: &str) -> String {let mut txt = String::new();if let Ok(mut f) = File::open(filepath) {f.read_to_string(&mut txt).unwrap();}// 默认内容有换行txt = txt.trim().to_string();return txt;
}// 通过 /proc/pid/maps 查找 program 地址
fn process_get_base_addr(pid:&str) -> u64{let mut addr = 0u64;if let Ok(f) = File::open(format!("/proc/{}/maps", pid)){let mut txt = String::new();let mut br = BufReader::new(f);br.read_line(&mut txt).unwrap();//55af86ae3000-55af86ae4000 r--p 00000000 08:12 6160449      /xx/gamebox        if let Some(pos) = txt.find('-') {addr = u64::from_str_radix(&txt[..pos], 16).unwrap();}}return addr;
}
cargo build
sudo ./target/debug/d8gamebox pid: ["7586"]
gamebox mem: /proc/7586/mem, base addr: 55AF86AE7040
Account => ID: 20240318, Name: 我是张三啊, role addr: 0x0x55AF87D676B0Role[0] => Level: 10, Money: 5000, Pos: [0.00, 0.00, 0.00]Role[1] => Level: 12, Money: 5000, Pos: [1000.00, 1100.00, 1200.00]Role[2] => Level: 14, Money: 5000, Pos: [2000.00, 2200.00, 2400.00]Role[3] => Level: 16, Money: 5000, Pos: [3000.00, 3300.00, 3600.00]

然后,尝试关闭gamebox,然后再重启,继续使用程序读取一下,依然有效。

到此,一个只读取gamebox的外挂做好了。

3.修改程序调用逻辑

如果,我们想把代码中decMoney函数的减少钱的逻辑,改成增加钱的逻辑怎么办?

  • root权限,强制改写 decMoney 函数的汇编代码,可以实现简单功能
  • root权限,在内存中新写一个 函数, 替代decMoney,实现任意功能。这个难度很高。

我们做一个简单的版本:

// decMoney 函数汇编代码
.text:00000000000011C9                               public decMoney
.text:00000000000011C9                               decMoney proc near            ; CODE XREF: main+4E3↓p
.text:00000000000011C9                                                             ; DATA XREF: main+68E↓o
.text:00000000000011C9
.text:00000000000011C9                               var_8= qword ptr -8
.text:00000000000011C9
.text:00000000000011C9                               ; __unwind {
.text:00000000000011C9 F3 0F 1E FA                   endbr64
.text:00000000000011CD 55                            push    rbp
.text:00000000000011CE 48 89 E5                      mov     rbp, rsp
.text:00000000000011D1 48 83 EC 10                   sub     rsp, 10h
.text:00000000000011D5 48 89 7D F8                   mov     [rbp+var_8], rdi
.text:00000000000011D9 B8 00 00 00 00                mov     eax, 0
.text:00000000000011DE E8 ED FE FF FF                call    _rand
.text:00000000000011DE
.text:00000000000011E3 48 63 D0                      movsxd  rdx, eax
.text:00000000000011E6 48 69 D2 1F 85 EB 51          imul    rdx, 51EB851Fh
.text:00000000000011ED 48 C1 EA 20                   shr     rdx, 20h
.text:00000000000011F1 C1 FA 05                      sar     edx, 5
.text:00000000000011F4 89 C1                         mov     ecx, eax
.text:00000000000011F6 C1 F9 1F                      sar     ecx, 1Fh
.text:00000000000011F9 29 CA                         sub     edx, ecx
.text:00000000000011FB 6B CA 64                      imul    ecx, edx, 64h ; 'd'
.text:00000000000011FE 29 C8                         sub     eax, ecx 
.text:0000000000001200 89 C2                         mov     edx, eax
.text:0000000000001202 48 8B 45 F8                   mov     rax, [rbp+var_8]
.text:0000000000001206 48 8B 40 10                   mov     rax, [rax+10h]
.text:000000000000120A 48 63 CA                      movsxd  rcx, edx
.text:000000000000120D 48 29 C8                      sub     rax, rcx ; 核心是这里减法处理 
.text:0000000000001210 48 89 C2                      mov     rdx, rax ; v1
.text:0000000000001213 48 8B 45 F8                   mov     rax, [rbp+var_8]
.text:0000000000001217 48 89 50 10                   mov     [rax+10h], rdx ; 最终v1赋值
.text:000000000000121B 90                            nop
.text:000000000000121C C9                            leave
.text:000000000000121D C3                            retn
.text:000000000000121D                               ; } // starts at 11C9
.text:000000000000121D
.text:000000000000121D                               decMoney endp// 反汇编的C代码
__int64 __fastcall decMoney(__int64 a1)
{__int64 v1; // rdx__int64 result; // raxv1 = *(_QWORD *)(a1 + 16) - rand() % 100;  // 需要修改这里的减法操作result = a1;*(_QWORD *)(a1 + 16) = v1;return result;
}

函数 DecMoney 的偏移为 00000000000011C9,sub rax, rcx的偏移为 000000000000120D。offset=0x44.

; https://shell-storm.org/online/Online-Assembler-and-Disassembler/
sub rax, rcx  ; 48 29 c8
add rax, rcx  ; 48 01 c8

所以,修改 函数地址加偏移 0x44 + 1 的值, 从 29 改为 01 就可以啦。

fn_ofset = 0x55AF86AE41C9 − 0x55AF86AE421E = -0x55

说明函数地址在main函数地址之前。

fn_addr = program + 0x121E - 0x55

理论代码如下:

use std::{ffi::{CStr, OsString},fs::File,io::{self, BufRead, BufReader, Cursor, Read},os::unix::fs::FileExt,path, u8,
};// 64 bit program
fn main() {let pids = find_id_by_name("gamebox");println!("gamebox pid: {:?}", pids);if pids.len() > 0 {let pid = pids.first().unwrap();let memf = format!("/proc/{}/mem", pid);let mut fn_addr = 0u64;let mut base_addr:u64 = process_get_base_addr(pid);if base_addr == 0 {println!("gamebox find base addr failed: {}", pid);return;}fn_addr = base_addr + 0x121E - 0x55;  // decMoney 地址base_addr += 0x121E + 0x2E22; // Account ac 全局变量偏移println!("gamebox mem: {}, base addr: {:X}", memf, base_addr);// 需要root权限if let Ok(f) = &File::options().write(true).open(memf) {            // accountlet id = read_at_mem(f, base_addr + 24, 8);let name = read_at_mem(f, base_addr + 0, 20);let role_addr = read_at_mem(f, base_addr + 24 + 8, 8);let name2 = unsafe { CStr::from_ptr(name.as_ptr() as *const i8) };let role_addr2 = u64::from_le_bytes(role_addr.try_into().unwrap());println!("Account => ID: {}, Name: {}, role addr: 0x{:#X}",u64::from_le_bytes(id.try_into().unwrap()),name2.to_str().unwrap(),role_addr2,);// rolefor i in 0..4 {let level = read_at_mem(f, role_addr2 + 24*i + 12, 4);let money = read_at_mem(f, role_addr2 + 24*i + 16, 8);let pos_x = read_at_mem(f, role_addr2 + 24*i + 0, 4);let pos_y = read_at_mem(f, role_addr2 + 24*i + 4, 4);let pos_z = read_at_mem(f, role_addr2 + 24*i + 8, 4);println!("\tRole[{}] => Level: {}, Money: {}, Pos: [{:.2}, {:.2}, {:.2}]",i,u32::from_le_bytes(level.try_into().unwrap()),u64::from_le_bytes(money.try_into().unwrap()),f32::from_le_bytes(pos_x.try_into().unwrap()),f32::from_le_bytes(pos_y.try_into().unwrap()),f32::from_le_bytes(pos_z.try_into().unwrap()),);}let mut buf = String::new();print!("Input any key to modify decMoney function ....");io::stdin().read_line(&mut buf).unwrap();// modify function decMoneylet asm_addr = fn_addr + 0x45; // sub rax, rcx => add rax, rcxlet asm = [0x01u8,];f.write_at(&asm, asm_addr).unwrap();} else {println!("need root permission!");}}
}fn read_at_mem(f: &File, addr: u64, sz: usize) -> Vec<u8> {let mut buf = Vec::new();buf.resize(sz, 0);f.read_at(&mut buf, addr).unwrap();return buf;
}// 忽略大小写进行进程查找
fn find_id_by_name(name: &str) -> Vec<String> {// 遍历和读取 /proc/xxx/commlet root = path::Path::new("/proc/");let mut pids: Vec<_> = Vec::new();for sub in root.read_dir().unwrap() {if let Ok(id_dir) = sub {let fp = id_dir.path();if fp.is_dir() {let comm = fp.join("comm");if comm.exists() {let txt = file_read_content(comm.to_str().unwrap());// println!("try file: {:?}, {}", comm, txt);if txt.to_ascii_lowercase() == name.to_ascii_lowercase() {let pid = OsString::from(fp.file_name().unwrap()).into_string().unwrap();pids.push(pid);}}}}}pids
}fn file_read_content(filepath: &str) -> String {let mut txt = String::new();if let Ok(mut f) = File::open(filepath) {f.read_to_string(&mut txt).unwrap();}// 默认内容有换行txt = txt.trim().to_string();return txt;
}// 通过 /proc/pid/maps 查找 program 地址
fn process_get_base_addr(pid:&str) -> u64{let mut addr = 0u64;if let Ok(f) = File::open(format!("/proc/{}/maps", pid)){let mut txt = String::new();let mut br = BufReader::new(f);br.read_line(&mut txt).unwrap();//55af86ae3000-55af86ae4000 r--p 00000000 08:12 6160449      /xx/gamebox        if let Some(pos) = txt.find('-') {addr = u64::from_str_radix(&txt[..pos], 16).unwrap();}}return addr;
}

看起来似乎可行,实际执行发现,即便是root权限也无法直接修改其他进程的内存信息。

其他思路有:

  • ptrace 接口,dbg方式修改
  • 内核空间修改
  • 能找到对应的物理内存地址,修改物理内存

上面几种方法,只有第一种难度最低,后续研究这种。

4.ptrace 版本

ptrace 提供了一种机制使得父进程可以观察和控制子进程的执行过程,ptrace 还可以检查和修改子进程的可执行文件在内存中的image及子进程所使用的寄存器中的值。通常来说,主要用于实现对进程插入断点和跟踪子进程的系统调用。

我们在/proc/xxx/mem 可以root读取,但是写入失败。但是ptrace可以实现这个写入功能。

long ptrace(enum __ptrace_request request,pid_t pid,void *addr,void *data);
/*
PTRACE_TRACEME,   本进程被其父进程所跟踪。其父进程应该希望跟踪子进程
PTRACE_PEEKTEXT,  从内存地址中读取一个LONG长度数据,内存地址由addr给出
PTRACE_PEEKDATA,  同上
PTRACE_PEEKUSER,  可以检查用户态内存区域(USER area),从USER区域中读取一个字节,偏移量为addr
PTRACE_POKETEXT,  往内存地址中写入一个LONG长度数据。内存地址由addr给出
PTRACE_POKEDATA,  往内存地址中写入一个LONG长度数据。内存地址由addr给出
PTRACE_POKEUSER,  往USER区域中写入一个LONG长度数据,偏移量为addr
PTRACE_GETREGS,    读取寄存器
PTRACE_GETFPREGS,  读取浮点寄存器
PTRACE_SETREGS,  设置寄存器
PTRACE_SETFPREGS,  设置浮点寄存器
PTRACE_CONT,    重新运行
PTRACE_SYSCALL,  重新运行
PTRACE_SINGLESTEP,  设置单步执行标志
PTRACE_ATTACH,追踪指定pid的进程
PTRACE_DETACH,  结束追踪
*/// ptrace Demo 
#include <stdio.h>
#include <stdlib.h>
#include <sys/ptrace.h>
int main(int argc, char* argv[])
{pid_t attack_pid = -1;long  val        = 66;if (argc < 2 || argv[1] <= 0){printf("usage: ./main pid(pid > 0)\n");return 0;}attack_pid = strtoul(argv[1], 0, 10);if (ptrace(PTRACE_ATTACH, attack_pid, NULL, NULL) < 0){printf("attach failed\n");return 0;}//读取数据printf("global1 %d\n", ptrace(PTRACE_PEEKDATA , attack_pid, (void*)0x804a028, NULL));printf("stack_var %d\n", ptrace(PTRACE_PEEKDATA , attack_pid, (void*)0xbfa4195c, NULL));//修改数据ptrace(PTRACE_POKEDATA , attack_pid, (void*)0x804a028, val);ptrace(PTRACE_POKEDATA , attack_pid, (void*)0xbfa4195c, val);ptrace (PTRACE_DETACH, attack_pid, NULL, NULL);waitpid(attack_pid, NULL, WUNTRACED);return 0;
}//main.c被改写的进程
#include <stdio.h>int global1 = 11; // int main(void)
{long stack_var = 10;char c = 'a';while(1){printf("global1 addrss 0x%lx, global1=%d\n", &global1, global1);printf("stack_var addrss 0x%lx, stack_var=%d\n", &stack_var, stack_var);scanf("%c", &c);getchar();if (c != 'c'){break;}}return 0;
}

https://dev59.com/unix/s3VD5IYBdhLWcg3wWaRh

完整的Rust版本的ptrace代码如下:

use std::{ffi::{c_void, CStr, OsString},fs::File,io::{self, BufRead, BufReader, Read, Write},os::unix::fs::FileExt,path, u8,
};use nix::{sys::{ptrace, wait::waitpid}, unistd::Pid};// 64 bit program
fn main() {let pids = find_id_by_name("gamebox");println!("gamebox pid: {:?}", pids);if pids.len() > 0 {let pid = pids.first().unwrap();let mut fn_addr = 0u64;let mut base_addr: u64 = process_get_base_addr(pid);if base_addr == 0 {println!("gamebox find base addr failed: {}", pid);return;}fn_addr = base_addr + 0x121E - 0x55; // decMoney 地址base_addr += 0x121E + 0x2E22; // Account ac 全局变量偏移println!("gamebox base addr: {:#X}, fn addr: {:#X}",base_addr, fn_addr);// 需要root权限let ppid = Pid::from_raw(i32::from_str_radix(pid, 10).unwrap());if let Ok(_) = ptrace::attach(ppid) {waitpid(ppid, None).unwrap();// accountlet id = ptrace_read_at(ppid, base_addr + 24, 8);let name = ptrace_read_at(ppid, base_addr + 0, 20);let role_addr = ptrace_read_at(ppid, base_addr + 24 + 8, 8);let name2 = unsafe { CStr::from_ptr(name.as_ptr() as *const i8) };let role_addr2 = u64::from_le_bytes(role_addr.try_into().unwrap());println!("Account => ID: {}, Name: {:?}, role addr: 0x{:#X}",u64::from_le_bytes(id.try_into().unwrap()),name2.to_str(),role_addr2,);// rolefor i in 0..4 {let level = ptrace_read_at(ppid, role_addr2 + 24 * i + 12, 4);let money = ptrace_read_at(ppid, role_addr2 + 24 * i + 16, 8);let pos_x = ptrace_read_at(ppid, role_addr2 + 24 * i + 0, 4);let pos_y = ptrace_read_at(ppid, role_addr2 + 24 * i + 4, 4);let pos_z = ptrace_read_at(ppid, role_addr2 + 24 * i + 8, 4);println!("\tRole[{}] => Level: {}, Money: {}, Pos: [{:.2}, {:.2}, {:.2}]",i,u32::from_le_bytes(level.try_into().unwrap()),u64::from_le_bytes(money.try_into().unwrap()),f32::from_le_bytes(pos_x.try_into().unwrap()),f32::from_le_bytes(pos_y.try_into().unwrap()),f32::from_le_bytes(pos_z.try_into().unwrap()),);}// modify function decMoneylet asm_addr = fn_addr + 0x44;// ptrace 每次写入也是 8 字节的数据, 所以先读取,然后再写入let mut old_asm = ptrace_read_at(ppid, asm_addr, 8);println!("old_asm: {:?}", old_asm);// 修改 sub rax, rcx => add rax, rcxold_asm[1] = 0x01;let new_val = u64::from_ne_bytes(old_asm.try_into().unwrap());unsafe { ptrace::write(ppid, asm_addr as *mut c_void, new_val as *mut c_void).unwrap();};let old_asm2 = ptrace_read_at(ppid, asm_addr, 8);println!("old_asm2: {:?}", old_asm2);ptrace::detach(ppid, None).unwrap();} else {println!("need root permission!");}}
}fn read_at_mem(f: &File, addr: u64, sz: usize) -> Vec<u8> {let mut buf = Vec::new();buf.resize(sz, 0);f.read_at(&mut buf, addr).unwrap();return buf;
}fn ptrace_read_at(ppid: Pid, addr: u64, sz: usize) -> Vec<u8> {let mut buf = Vec::new();buf.resize(sz, 0);// println!("Begin read {:#X}, sz={}", addr, sz);let mut sz2 = sz/8;if sz%8 != 0 {sz2 += 1;}for i in 0..sz2 {let paddr = (addr + (i*8) as u64) as *mut c_void;// ptrace 每次读取 8 个字节的数据let val = ptrace::read(ppid, paddr).unwrap();//println!("read: [{}] = {:#X}", addr + (i*8) as u64,val);let mut idx = i*8;for b in val.to_ne_bytes(){if idx < sz {buf[idx] = b;idx += 1;}else{break;}            }}return buf;
}// 忽略大小写进行进程查找
fn find_id_by_name(name: &str) -> Vec<String> {// 遍历和读取 /proc/xxx/commlet root = path::Path::new("/proc/");let mut pids: Vec<_> = Vec::new();for sub in root.read_dir().unwrap() {if let Ok(id_dir) = sub {let fp = id_dir.path();if fp.is_dir() {let comm = fp.join("comm");if comm.exists() {let txt = file_read_content(comm.to_str().unwrap());// println!("try file: {:?}, {}", comm, txt);if txt.to_ascii_lowercase() == name.to_ascii_lowercase() {let pid = OsString::from(fp.file_name().unwrap()).into_string().unwrap();pids.push(pid);}}}}}pids
}fn file_read_content(filepath: &str) -> String {let mut txt = String::new();if let Ok(mut f) = File::open(filepath) {f.read_to_string(&mut txt).unwrap();}// 默认内容有换行txt = txt.trim().to_string();return txt;
}// 通过 /proc/pid/maps 查找 program 地址
fn process_get_base_addr(pid: &str) -> u64 {let mut addr = 0u64;if let Ok(f) = File::open(format!("/proc/{}/maps", pid)) {let mut txt = String::new();let mut br = BufReader::new(f);br.read_line(&mut txt).unwrap();//55af86ae3000-55af86ae4000 r--p 00000000 08:12 6160449      /xx/gameboxif let Some(pos) = txt.find('-') {addr = u64::from_str_radix(&txt[..pos], 16).unwrap();}}return addr;
}/*
gamebox pid: ["101595"]
gamebox base addr: 0x55698A849040, fn addr: 0x55698A8461C9
Account => ID: 20240318, Name: Ok("我是张三啊"), role addr: 0x0x55698B1156B0Role[0] => Level: 10, Money: 5000, Pos: [0.00, 0.00, 0.00]Role[1] => Level: 12, Money: 5000, Pos: [1000.00, 1100.00, 1200.00]Role[2] => Level: 14, Money: 5000, Pos: [2000.00, 2200.00, 2400.00]Role[3] => Level: 16, Money: 5000, Pos: [3000.00, 3300.00, 3600.00]
old_asm: [72, 41, 200, 72, 137, 194, 72, 139]
Input any key to modify decMoney function ....
old_asm2: [72, 1, 200, 72, 137, 194, 72, 139]
*/

proc

https://blog.csdn.net/murphy_ma123456/article/details/16117577
https://blog.csdn.net/m0_37315653/article/details/82693108
https://zhuanlan.zhihu.com/p/378388389

这篇关于Rust 实战练习 - 8. 内存,ASM,外挂 【重磅】的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/846265

相关文章

网页解析 lxml 库--实战

lxml库使用流程 lxml 是 Python 的第三方解析库,完全使用 Python 语言编写,它对 XPath表达式提供了良好的支 持,因此能够了高效地解析 HTML/XML 文档。本节讲解如何通过 lxml 库解析 HTML 文档。 pip install lxml lxm| 库提供了一个 etree 模块,该模块专门用来解析 HTML/XML 文档,下面来介绍一下 lxml 库

NameNode内存生产配置

Hadoop2.x 系列,配置 NameNode 内存 NameNode 内存默认 2000m ,如果服务器内存 4G , NameNode 内存可以配置 3g 。在 hadoop-env.sh 文件中配置如下。 HADOOP_NAMENODE_OPTS=-Xmx3072m Hadoop3.x 系列,配置 Nam

性能分析之MySQL索引实战案例

文章目录 一、前言二、准备三、MySQL索引优化四、MySQL 索引知识回顾五、总结 一、前言 在上一讲性能工具之 JProfiler 简单登录案例分析实战中已经发现SQL没有建立索引问题,本文将一起从代码层去分析为什么没有建立索引? 开源ERP项目地址:https://gitee.com/jishenghua/JSH_ERP 二、准备 打开IDEA找到登录请求资源路径位置

C#实战|大乐透选号器[6]:实现实时显示已选择的红蓝球数量

哈喽,你好啊,我是雷工。 关于大乐透选号器在前面已经记录了5篇笔记,这是第6篇; 接下来实现实时显示当前选中红球数量,蓝球数量; 以下为练习笔记。 01 效果演示 当选择和取消选择红球或蓝球时,在对应的位置显示实时已选择的红球、蓝球的数量; 02 标签名称 分别设置Label标签名称为:lblRedCount、lblBlueCount

滚雪球学Java(87):Java事务处理:JDBC的ACID属性与实战技巧!真有两下子!

咦咦咦,各位小可爱,我是你们的好伙伴——bug菌,今天又来给大家普及Java SE啦,别躲起来啊,听我讲干货还不快点赞,赞多了我就有动力讲得更嗨啦!所以呀,养成先点赞后阅读的好习惯,别被干货淹没了哦~ 🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,助你一臂之力,带你早日登顶🚀,欢迎大家关注&&收藏!持续更新中,up!up!up!! 环境说明:Windows 10

RabbitMQ练习(AMQP 0-9-1 Overview)

1、What is AMQP 0-9-1 AMQP 0-9-1(高级消息队列协议)是一种网络协议,它允许遵从该协议的客户端(Publisher或者Consumer)应用程序与遵从该协议的消息中间件代理(Broker,如RabbitMQ)进行通信。 AMQP 0-9-1模型的核心概念包括消息发布者(producers/publisher)、消息(messages)、交换机(exchanges)、

【Rust练习】12.枚举

练习题来自:https://practice-zh.course.rs/compound-types/enum.html 1 // 修复错误enum Number {Zero,One,Two,}enum Number1 {Zero = 0,One,Two,}// C语言风格的枚举定义enum Number2 {Zero = 0.0,One = 1.0,Two = 2.0,}fn m

MySql 事务练习

事务(transaction) -- 事务 transaction-- 事务是一组操作的集合,是一个不可分割的工作单位,事务会将所有的操作作为一个整体一起向系统提交或撤销请求-- 事务的操作要么同时成功,要么同时失败-- MySql的事务默认是自动提交的,当执行一个DML语句,MySql会立即自动隐式提交事务-- 常见案例:银行转账-- 逻辑:A给B转账1000:1.查询

JVM内存调优原则及几种JVM内存调优方法

JVM内存调优原则及几种JVM内存调优方法 1、堆大小设置。 2、回收器选择。   1、在对JVM内存调优的时候不能只看操作系统级别Java进程所占用的内存,这个数值不能准确的反应堆内存的真实占用情况,因为GC过后这个值是不会变化的,因此内存调优的时候要更多地使用JDK提供的内存查看工具,比如JConsole和Java VisualVM。   2、对JVM内存的系统级的调优主要的目的是减少

JVM 常见异常及内存诊断

栈内存溢出 栈内存大小设置:-Xss size 默认除了window以外的所有操作系统默认情况大小为 1MB,window 的默认大小依赖于虚拟机内存。 栈帧过多导致栈内存溢出 下述示例代码,由于递归深度没有限制且没有设置出口,每次方法的调用都会产生一个栈帧导致了创建的栈帧过多,而导致内存溢出(StackOverflowError)。 示例代码: 运行结果: 栈帧过大导致栈内存