tuxtrain 0.0.4

An easy-to-use generic trainer for Linux
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

use crate::error::MemError;
use crate::Pattern;
use nix::sys::uio::{process_vm_readv, process_vm_writev};
use nix::sys::uio::{IoVec, RemoteIoVec};
use nix::unistd::Pid;

const CHUNK_SIZE: usize = 1024;

pub fn search(
	pid: &Pid,
	region: &(usize, usize),
	pattern: &Pattern,
) -> Result<(usize, Vec<u8>), MemError> {
	let end = region.1;
	let find = pattern.len();
	let mut chunk_size = CHUNK_SIZE;
	let mut pointer = region.0;
	let mut criteria = pattern.iter();
	let mut found = vec![];
	let mut at = 0;

	loop {
		// Avoid overreach
		if pointer + chunk_size > end {
			chunk_size = end - pointer;
		}

		// Read memory region one chunk at a time
		let chunk = read(pid, pointer, chunk_size)?;

		// Try to find pattern
		for (idx, mbyte) in chunk.iter().enumerate() {
			if let Some(byte) = criteria.next().unwrap() {
				// Found one
				if byte == mbyte {
					found.push(*mbyte);

					// Set "at" on first discovery
					if found.len() == 1 {
						at = pointer + idx;
					}
				} else {
					// Doesn't match, reset
					found.clear();
					criteria = pattern.iter();
				}
			} else {
				// Skip (None) is still considered found
				found.push(*mbyte);
			}

			// Found what there is to find
			if found.len() == find {
				return Ok((at, found));
			}
		}

		// Set next chunk
		pointer += chunk.len();

		// End of region, never found it sadly
		if pointer == end {
			break;
		}
	}

	Err(MemError::Read("Could not find pattern '{pattern}'".into()))?
}

pub fn replace(pid: &Pid, at: usize, this: &Vec<u8>, with: &Pattern) -> Result<Vec<u8>, MemError> {
	if this.len() != with.len() {
		Err(MemError::Write("Replacement differs in length.".into()))?
	}

	// Merge "this" "with"
	// None: Use left
	// Some: Use right
	let mut replace = vec![];
	for (i, b) in this.iter().enumerate() {
		replace.push(with[i].unwrap_or_else(|| *b));
	}

	write(pid, at, &replace)?;

	Ok(replace)
}

pub fn read(pid: &Pid, at: usize, len: usize) -> Result<Vec<u8>, MemError> {
	let mut data = vec![0; len];
	let local = IoVec::<&mut [u8]>::from_mut_slice(&mut data);
	let remote = RemoteIoVec { base: at, len };

	process_vm_readv(*pid, &[local], &[remote]).map_err(|e| MemError::Read(e.to_string()))?;
	Ok(data)
}

pub fn write(pid: &Pid, at: usize, data: &Vec<u8>) -> Result<usize, MemError> {
	let local = IoVec::<&[u8]>::from_slice(data);
	let remote = RemoteIoVec {
		base: at,
		len: data.len(),
	};

	process_vm_writev(*pid, &[local], &[remote]).map_err(|e| MemError::Write(e.to_string()))
}