File size: 2,028 Bytes
f9b95c0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (C) 2025 Moew72 <Moew72@proton.me>

use std::ffi::CString;
use std::mem::ManuallyDrop;

mod lib {
    use std::ffi::*;
    type Func = extern "C" fn(*const c_char, *const c_uchar, c_int, c_int, *mut c_uchar);
    unsafe extern "C" {
        pub(super) static mut module_path: *const c_char;
        pub(super) static mut offset: usize;
        pub(super) static mut sign: Func;
        pub(super) fn load_module() -> c_int;
        pub(super) fn unload_module();
    }
}

pub(crate) fn set_module_path(path: String) {
    let path = CString::new(path.as_str()).unwrap();
    unsafe {
        lib::module_path = ManuallyDrop::new(path).as_ptr();
    }
}

pub(crate) fn set_offset(offset: usize) {
    unsafe {
        lib::offset = offset;
    }
}

pub(crate) fn load_module() {
    let ret = unsafe { lib::load_module() };
    if ret != 0 {
        panic!("load module error.");
    }
}

pub(crate) fn unload_module() {
    unsafe { lib::unload_module() }
}

pub(crate) fn sign(cmd: &str, src: &[u8], seq: i32) -> [Vec<u8>; 3] {
    const TOKEN_DATA_OFFSET: usize = 0x000;
    const TOKEN_LEN_OFFSET: usize = 0x0FF;
    const EXTRA_DATA_OFFSET: usize = 0x100;
    const EXTRA_LEN_OFFSET: usize = 0x1FF;
    const SIGN_DATA_OFFSET: usize = 0x200;
    const SIGN_LEN_OFFSET: usize = 0x2FF;

    let c_cmd = CString::new(cmd).unwrap();
    let mut buf = [0u8; 0x300];
    unsafe {
        lib::sign(
            c_cmd.as_ptr(),
            src.as_ptr(),
            src.len() as i32,
            seq,
            buf.as_mut_ptr(),
        )
    };

    let token_len = buf[TOKEN_LEN_OFFSET];
    let token = &buf[TOKEN_DATA_OFFSET..TOKEN_DATA_OFFSET + token_len as usize];
    let extra_len = buf[EXTRA_LEN_OFFSET];
    let extra = &buf[EXTRA_DATA_OFFSET..EXTRA_DATA_OFFSET + extra_len as usize];
    let sign_len = buf[SIGN_LEN_OFFSET];
    let sign = &buf[SIGN_DATA_OFFSET..SIGN_DATA_OFFSET + sign_len as usize];

    [Vec::from(token), Vec::from(extra), Vec::from(sign)]
}