129 lines
4.4 KiB
Rust
129 lines
4.4 KiB
Rust
use crate::util::consts::game::{EXE_ENHANCED, EXE_LEGACY};
|
|
use std::path::Path;
|
|
use sysinfo::System;
|
|
use windows::{
|
|
Win32::{
|
|
Foundation::E_INVALIDARG,
|
|
NetworkManagement::WindowsFirewall::{
|
|
INetFwPolicy2, INetFwRule, NET_FW_ACTION_BLOCK, NET_FW_IP_PROTOCOL_ANY,
|
|
NET_FW_RULE_DIR_IN, NET_FW_RULE_DIR_OUT, NetFwPolicy2, NetFwRule,
|
|
},
|
|
System::Com::{
|
|
CLSCTX_INPROC_SERVER, COINIT_MULTITHREADED, CoCreateInstance, CoInitializeEx,
|
|
CoUninitialize,
|
|
},
|
|
},
|
|
core::{BSTR, HRESULT},
|
|
};
|
|
|
|
const FILTER_NAME_IN: &str = "[GTA Tools] Block all inbound traffic for GTA V";
|
|
const FILTER_NAME_OUT: &str = "[GTA Tools] Block all outbound traffic for GTA V";
|
|
|
|
#[derive(Debug)]
|
|
pub struct GameNetworking {
|
|
pub is_blocked: bool,
|
|
com_initialized: bool,
|
|
policy: INetFwPolicy2,
|
|
}
|
|
|
|
impl Default for GameNetworking {
|
|
fn default() -> Self {
|
|
let result = unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) };
|
|
let mut gn = Self {
|
|
is_blocked: false,
|
|
com_initialized: result != HRESULT(0x80010106u32 as i32),
|
|
policy: unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER).unwrap() },
|
|
};
|
|
gn.is_blocked = gn.is_blocked();
|
|
gn
|
|
}
|
|
}
|
|
|
|
impl Drop for GameNetworking {
|
|
fn drop(&mut self) {
|
|
unsafe {
|
|
if self.com_initialized {
|
|
CoUninitialize();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl GameNetworking {
|
|
pub fn block_all(&mut self, sysinfo: &mut System) {
|
|
let Some(exe_path) = get_game_exe_path(sysinfo) else {
|
|
return;
|
|
};
|
|
let rules = unsafe { self.policy.Rules().unwrap() };
|
|
let filter_name_in = BSTR::from(FILTER_NAME_IN);
|
|
let filter_name_out = BSTR::from(FILTER_NAME_OUT);
|
|
unsafe {
|
|
let _ = rules.Remove(&filter_name_in);
|
|
let _ = rules.Remove(&filter_name_out);
|
|
}
|
|
let exe_path = BSTR::from(exe_path.to_string_lossy().to_string());
|
|
unsafe {
|
|
let inbound_rule: INetFwRule =
|
|
CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER).unwrap();
|
|
inbound_rule.SetName(&filter_name_in).unwrap();
|
|
inbound_rule.SetApplicationName(&exe_path).unwrap();
|
|
inbound_rule.SetDirection(NET_FW_RULE_DIR_IN).unwrap();
|
|
inbound_rule.SetEnabled(true.into()).unwrap();
|
|
inbound_rule.SetAction(NET_FW_ACTION_BLOCK).unwrap();
|
|
inbound_rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0).unwrap();
|
|
rules.Add(&inbound_rule).unwrap();
|
|
}
|
|
unsafe {
|
|
let outbound_rule: INetFwRule =
|
|
CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER).unwrap();
|
|
outbound_rule.SetName(&filter_name_out).unwrap();
|
|
outbound_rule.SetApplicationName(&exe_path).unwrap();
|
|
outbound_rule.SetDirection(NET_FW_RULE_DIR_OUT).unwrap();
|
|
outbound_rule.SetEnabled(true.into()).unwrap();
|
|
outbound_rule.SetAction(NET_FW_ACTION_BLOCK).unwrap();
|
|
outbound_rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0).unwrap();
|
|
rules.Add(&outbound_rule).unwrap();
|
|
}
|
|
self.is_blocked = self.is_blocked();
|
|
}
|
|
|
|
pub fn unblock_all(&mut self) {
|
|
let rules = unsafe { self.policy.Rules().unwrap() };
|
|
unsafe {
|
|
let result = rules.Remove(&BSTR::from(FILTER_NAME_IN));
|
|
if let Err(ref why) = result {
|
|
if why.code() != E_INVALIDARG {
|
|
result.unwrap();
|
|
}
|
|
}
|
|
let result = rules.Remove(&BSTR::from(FILTER_NAME_OUT));
|
|
if let Err(ref why) = result {
|
|
if why.code() != E_INVALIDARG {
|
|
result.unwrap();
|
|
}
|
|
}
|
|
}
|
|
self.is_blocked = self.is_blocked();
|
|
}
|
|
|
|
fn is_blocked(&self) -> bool {
|
|
let rules = unsafe { self.policy.Rules().unwrap() };
|
|
let in_rule_exists = unsafe { rules.Item(&BSTR::from(FILTER_NAME_IN)).is_ok() };
|
|
let out_rule_exists = unsafe { rules.Item(&BSTR::from(FILTER_NAME_OUT)).is_ok() };
|
|
in_rule_exists || out_rule_exists
|
|
}
|
|
}
|
|
|
|
fn get_game_exe_path(sysinfo: &mut System) -> Option<&Path> {
|
|
sysinfo.refresh_all();
|
|
if let Some((_, process)) = sysinfo
|
|
.processes()
|
|
.iter()
|
|
.find(|(_, p)| p.name() == EXE_ENHANCED || p.name() == EXE_LEGACY)
|
|
{
|
|
process.exe()
|
|
} else {
|
|
None
|
|
}
|
|
}
|