futile/gta-tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

use Firewall in game_networking

Browse Source
This commit is contained in:
futile
2025-12-12 03:52:40 -05:00
committed by sapphire
parent e0a5821431
commit 23fd4b12f9
3 changed files with 60 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/features/game_networking.rs
+47 -88
View File
@@ -1,15 +1,11 @@
use crate::{gui::settings::BlockMethod, util::system_info::SystemInfo};
use std::{error::Error, path::PathBuf};
use windows::{
Win32::{
NetworkManagement::WindowsFirewall::{
INetFwPolicy2, INetFwRule, NET_FW_ACTION_BLOCK, NET_FW_IP_PROTOCOL_ANY,
NET_FW_RULE_DIR_OUT, NetFwPolicy2, NetFwRule,
},
System::Com::{CLSCTX_INPROC_SERVER, CoCreateInstance},
use crate::{
gui::settings::BlockMethod,
util::{
firewall::{Firewall, RuleDirection, RuleMode, RuleProtocol},
system_info::SystemInfo,
},
core::BSTR,
};
use std::error::Error;
const FILTER_NAME_EXE: &str = "[GTA Tools] Block outbound traffic for all of GTA V";
const FILTER_NAME_SAVE_SERVER: &str = "[GTA Tools] Block outbound traffic to Rockstar save server";
@@ -21,116 +17,79 @@ pub struct GameNetworking {
impl Default for GameNetworking {
fn default() -> Self {
let firewall = Firewall::default();
Self {
blocked: if Self::is_save_server_blocked().unwrap() {
Self::is_save_server_blocked().unwrap()
blocked: if firewall.is_blocked(FILTER_NAME_SAVE_SERVER).unwrap() {
true
} else {
Self::is_exe_blocked().unwrap()
firewall.is_blocked(FILTER_NAME_EXE).unwrap()
},
}
}
}
enum Mode {
EntireGame(PathBuf),
SaveServer(String),
}
impl GameNetworking {
fn block_generic(mode: Mode) -> Result<(), Box<dyn Error>> {
let policy: INetFwPolicy2 =
unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER) }?;
let rules = unsafe { policy.Rules() }?;
let filter_name = match mode {
Mode::EntireGame(_) => FILTER_NAME_EXE,
Mode::SaveServer(_) => FILTER_NAME_SAVE_SERVER,
};
unsafe { rules.Remove(&BSTR::from(filter_name)) }?;
let rule: INetFwRule = unsafe { CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER) }?;
unsafe { rule.SetName(&BSTR::from(filter_name)) }?;
match mode {
Mode::EntireGame(exe_path) => {
let exe_path = BSTR::from(exe_path.to_string_lossy().to_string());
unsafe { rule.SetApplicationName(&exe_path) }?;
}
Mode::SaveServer(save_server_ip) => {
unsafe { rule.SetRemoteAddresses(&BSTR::from(save_server_ip)) }?;
}
}
unsafe { rule.SetDirection(NET_FW_RULE_DIR_OUT) }?;
unsafe { rule.SetEnabled(true.into()) }?;
unsafe { rule.SetAction(NET_FW_ACTION_BLOCK) }?;
unsafe { rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0) }?;
unsafe { rules.Add(&rule) }?;
Ok(())
}
fn unblock_generic(filter_name: &str) -> Result<(), Box<dyn Error>> {
let policy: INetFwPolicy2 =
unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER) }?;
let rules = unsafe { policy.Rules() }?;
unsafe { rules.Remove(&BSTR::from(filter_name)) }?;
Ok(())
}
fn is_blocked_generic(filter_name: &str) -> Result<bool, Box<dyn Error>> {
let policy: INetFwPolicy2 =
unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER) }?;
let rules = unsafe { policy.Rules() }?;
let rule_exists = unsafe { rules.Item(&BSTR::from(filter_name)) }.is_ok();
Ok(rule_exists)
}
pub fn block_exe(&mut self, system_info: &mut SystemInfo) -> Result<(), Box<dyn Error>> {
pub fn block_exe(
&mut self,
system_info: &mut SystemInfo,
firewall: &Firewall,
) -> Result<(), Box<dyn Error>> {
let Some(exe_path) = system_info.get_game_exe_path() else {
return Ok(());
};
Self::block_generic(Mode::EntireGame(exe_path.to_path_buf()))?;
self.blocked = Self::is_exe_blocked()?;
firewall.add(
FILTER_NAME_EXE,
RuleMode::Executable(exe_path.to_path_buf()),
RuleDirection::Out,
RuleProtocol::Any,
)?;
self.blocked = firewall.is_blocked(FILTER_NAME_EXE)?;
Ok(())
}
pub fn unblock_exe(&mut self) -> Result<(), Box<dyn Error>> {
Self::unblock_generic(FILTER_NAME_EXE)?;
self.blocked = Self::is_exe_blocked()?;
pub fn unblock_exe(&mut self, firewall: &Firewall) -> Result<(), Box<dyn Error>> {
firewall.remove(FILTER_NAME_EXE)?;
self.blocked = firewall.is_blocked(FILTER_NAME_EXE)?;
Ok(())
}
fn is_exe_blocked() -> Result<bool, Box<dyn Error>> {
Self::is_blocked_generic(FILTER_NAME_EXE)
}
pub fn block_save_server(&mut self, save_server_ip: &str) -> Result<(), Box<dyn Error>> {
Self::block_generic(Mode::SaveServer(save_server_ip.to_owned()))?;
self.blocked = Self::is_save_server_blocked()?;
pub fn block_save_server(
&mut self,
save_server_ip: &str,
firewall: &Firewall,
) -> Result<(), Box<dyn Error>> {
firewall.add(
FILTER_NAME_SAVE_SERVER,
RuleMode::Address(save_server_ip.to_owned()),
RuleDirection::Out,
RuleProtocol::Any,
)?;
self.blocked = firewall.is_blocked(FILTER_NAME_SAVE_SERVER)?;
Ok(())
}
pub fn unblock_save_server(&mut self) -> Result<(), Box<dyn Error>> {
Self::unblock_generic(FILTER_NAME_SAVE_SERVER)?;
self.blocked = Self::is_save_server_blocked()?;
pub fn unblock_save_server(&mut self, firewall: &Firewall) -> Result<(), Box<dyn Error>> {
firewall.remove(FILTER_NAME_SAVE_SERVER)?;
self.blocked = firewall.is_blocked(FILTER_NAME_SAVE_SERVER)?;
Ok(())
}
pub fn is_save_server_blocked() -> Result<bool, Box<dyn Error>> {
Self::is_blocked_generic(FILTER_NAME_SAVE_SERVER)
}
pub fn ensure_block_exclusivity(
&mut self,
block_method: BlockMethod,
firewall: &Firewall,
) -> Result<(), Box<dyn Error>> {
match block_method {
BlockMethod::EntireGame => {
if Self::is_save_server_blocked()? {
self.unblock_save_server()?;
self.blocked = Self::is_exe_blocked()?;
if firewall.is_blocked(FILTER_NAME_SAVE_SERVER)? {
self.unblock_save_server(firewall)?;
self.blocked = firewall.is_blocked(FILTER_NAME_EXE)?;
}
}
BlockMethod::SaveServer => {
if Self::is_exe_blocked()? {
self.unblock_exe()?;
self.blocked = Self::is_save_server_blocked()?;
if firewall.is_blocked(FILTER_NAME_EXE)? {
self.unblock_exe(firewall)?;
self.blocked = firewall.is_blocked(FILTER_NAME_SAVE_SERVER)?;
}
}
}