feat(desktop): adiciona Raven Service e corrige UAC
- Implementa Windows Service (raven-service) para operacoes privilegiadas - Comunicacao via Named Pipes sem necessidade de UAC adicional - Adiciona single-instance para evitar multiplos icones na bandeja - Corrige todos os warnings do clippy (rustdesk, lib, usb_control, agent) - Remove fallback de elevacao para evitar UAC desnecessario - USB Policy e RustDesk provisioning agora usam o servico quando disponivel 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
esdrasrenan
parent
caa6c53b2b
commit
c4664ab1c7
16 changed files with 4209 additions and 143 deletions
17
apps/desktop/src-tauri/Cargo.lock
generated
17
apps/desktop/src-tauri/Cargo.lock
generated
|
|
@ -80,10 +80,12 @@ dependencies = [
|
|||
"tauri-plugin-notification",
|
||||
"tauri-plugin-opener",
|
||||
"tauri-plugin-process",
|
||||
"tauri-plugin-single-instance",
|
||||
"tauri-plugin-store",
|
||||
"tauri-plugin-updater",
|
||||
"thiserror 1.0.69",
|
||||
"tokio",
|
||||
"uuid",
|
||||
"winreg",
|
||||
]
|
||||
|
||||
|
|
@ -4748,6 +4750,21 @@ dependencies = [
|
|||
"tauri-plugin",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-plugin-single-instance"
|
||||
version = "2.3.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dd707f8c86b4e3004e2c141fa24351f1909ba40ce1b8437e30d5ed5277dd3710"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
"tauri",
|
||||
"thiserror 2.0.17",
|
||||
"tracing",
|
||||
"windows-sys 0.60.2",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-plugin-store"
|
||||
version = "2.4.0"
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ tauri-plugin-updater = "2.9.0"
|
|||
tauri-plugin-process = "2.3.0"
|
||||
tauri-plugin-notification = "2"
|
||||
tauri-plugin-deep-link = "2"
|
||||
tauri-plugin-single-instance = "2"
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
serde_json = "1"
|
||||
sysinfo = { version = "0.31", default-features = false, features = ["multithread", "network", "system", "disk"] }
|
||||
|
|
@ -41,6 +42,7 @@ hostname = "0.4"
|
|||
base64 = "0.22"
|
||||
sha2 = "0.10"
|
||||
convex = "0.10.2"
|
||||
uuid = { version = "1", features = ["v4"] }
|
||||
# SSE usa reqwest com stream, nao precisa de websocket
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
|
|
|
|||
|
|
@ -1,20 +1,97 @@
|
|||
; Hooks customizadas do instalador NSIS (Tauri)
|
||||
;
|
||||
; Objetivo: remover a marca "Nullsoft Install System" exibida no canto inferior esquerdo.
|
||||
; Objetivo:
|
||||
; - Remover a marca "Nullsoft Install System" exibida no canto inferior esquerdo
|
||||
; - Instalar o Raven Service para operacoes privilegiadas sem UAC
|
||||
;
|
||||
; Nota: o bundler do Tauri injeta estes macros no script principal do instalador.
|
||||
|
||||
BrandingText " "
|
||||
|
||||
!macro NSIS_HOOK_PREINSTALL
|
||||
; Para qualquer instancia anterior do servico antes de atualizar
|
||||
DetailPrint "Parando servicos anteriores..."
|
||||
|
||||
; Para o servico
|
||||
nsExec::ExecToLog 'sc stop RavenService'
|
||||
|
||||
; Aguarda o servico parar completamente (ate 10 segundos)
|
||||
nsExec::ExecToLog 'powershell -Command "$$i=0; while((Get-Service RavenService -ErrorAction SilentlyContinue).Status -eq \"Running\" -and $$i -lt 10){Start-Sleep 1;$$i++}"'
|
||||
|
||||
; Forca encerramento de processos remanescentes
|
||||
nsExec::ExecToLog 'taskkill /F /IM raven-service.exe'
|
||||
nsExec::ExecToLog 'taskkill /F /IM appsdesktop.exe'
|
||||
|
||||
; Aguarda liberacao dos arquivos
|
||||
Sleep 2000
|
||||
!macroend
|
||||
|
||||
!macro NSIS_HOOK_POSTINSTALL
|
||||
; =========================================================================
|
||||
; Instala e inicia o Raven Service
|
||||
; =========================================================================
|
||||
|
||||
DetailPrint "Instalando Raven Service..."
|
||||
|
||||
; O servico ja esta em $INSTDIR (copiado como resource pelo Tauri)
|
||||
; Registra o servico Windows
|
||||
nsExec::ExecToLog '"$INSTDIR\raven-service.exe" install'
|
||||
Pop $0
|
||||
|
||||
${If} $0 != 0
|
||||
DetailPrint "Aviso: Falha ao registrar servico (codigo: $0)"
|
||||
; Tenta remover e reinstalar
|
||||
nsExec::ExecToLog '"$INSTDIR\raven-service.exe" uninstall'
|
||||
Sleep 500
|
||||
nsExec::ExecToLog '"$INSTDIR\raven-service.exe" install'
|
||||
Pop $0
|
||||
${EndIf}
|
||||
|
||||
; Inicia o servico
|
||||
DetailPrint "Iniciando Raven Service..."
|
||||
nsExec::ExecToLog 'sc start RavenService'
|
||||
Pop $0
|
||||
|
||||
${If} $0 == 0
|
||||
DetailPrint "Raven Service iniciado com sucesso!"
|
||||
${Else}
|
||||
DetailPrint "Aviso: Servico sera iniciado na proxima reinicializacao"
|
||||
${EndIf}
|
||||
|
||||
; =========================================================================
|
||||
; Verifica se RustDesk esta instalado
|
||||
; Se nao estiver, o Raven Service instalara automaticamente no primeiro uso
|
||||
; =========================================================================
|
||||
|
||||
IfFileExists "$PROGRAMFILES\RustDesk\rustdesk.exe" rustdesk_found rustdesk_not_found
|
||||
|
||||
rustdesk_not_found:
|
||||
DetailPrint "RustDesk sera instalado automaticamente pelo Raven Service."
|
||||
Goto rustdesk_done
|
||||
|
||||
rustdesk_found:
|
||||
DetailPrint "RustDesk ja esta instalado."
|
||||
|
||||
rustdesk_done:
|
||||
!macroend
|
||||
|
||||
!macro NSIS_HOOK_PREUNINSTALL
|
||||
; =========================================================================
|
||||
; Para e remove o Raven Service
|
||||
; =========================================================================
|
||||
|
||||
DetailPrint "Parando Raven Service..."
|
||||
nsExec::ExecToLog 'sc stop RavenService'
|
||||
Sleep 1000
|
||||
|
||||
DetailPrint "Removendo Raven Service..."
|
||||
nsExec::ExecToLog '"$INSTDIR\raven-service.exe" uninstall'
|
||||
|
||||
; Aguarda um pouco para garantir que o servico foi removido
|
||||
Sleep 500
|
||||
!macroend
|
||||
|
||||
!macro NSIS_HOOK_POSTUNINSTALL
|
||||
; Nada adicional necessario
|
||||
!macroend
|
||||
|
||||
|
|
|
|||
|
|
@ -708,7 +708,7 @@ fn collect_windows_extended() -> serde_json::Value {
|
|||
}
|
||||
|
||||
fn decode_utf16_le_to_string(bytes: &[u8]) -> Option<String> {
|
||||
if bytes.len() % 2 != 0 {
|
||||
if !bytes.len().is_multiple_of(2) {
|
||||
return None;
|
||||
}
|
||||
let utf16: Vec<u16> = bytes
|
||||
|
|
@ -1086,7 +1086,7 @@ pub fn collect_profile() -> Result<MachineProfile, AgentError> {
|
|||
let system = collect_system();
|
||||
|
||||
let os_name = System::name()
|
||||
.or_else(|| System::long_os_version())
|
||||
.or_else(System::long_os_version)
|
||||
.unwrap_or_else(|| "desconhecido".to_string());
|
||||
let os_version = System::os_version();
|
||||
let architecture = std::env::consts::ARCH.to_string();
|
||||
|
|
@ -1146,7 +1146,7 @@ async fn post_heartbeat(
|
|||
.into_owned();
|
||||
let os = MachineOs {
|
||||
name: System::name()
|
||||
.or_else(|| System::long_os_version())
|
||||
.or_else(System::long_os_version)
|
||||
.unwrap_or_else(|| "desconhecido".to_string()),
|
||||
version: System::os_version(),
|
||||
architecture: Some(std::env::consts::ARCH.to_string()),
|
||||
|
|
|
|||
|
|
@ -2,6 +2,8 @@ mod agent;
|
|||
mod chat;
|
||||
#[cfg(target_os = "windows")]
|
||||
mod rustdesk;
|
||||
#[cfg(target_os = "windows")]
|
||||
mod service_client;
|
||||
mod usb_control;
|
||||
|
||||
use agent::{collect_inventory_plain, collect_profile, AgentRuntime, MachineProfile};
|
||||
|
|
@ -68,21 +70,21 @@ pub fn log_agent(level: &str, message: &str) {
|
|||
#[macro_export]
|
||||
macro_rules! log_info {
|
||||
($($arg:tt)*) => {
|
||||
$crate::log_agent("INFO", &format!($($arg)*))
|
||||
$crate::log_agent("INFO", format!($($arg)*).as_str())
|
||||
};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! log_error {
|
||||
($($arg:tt)*) => {
|
||||
$crate::log_agent("ERROR", &format!($($arg)*))
|
||||
$crate::log_agent("ERROR", format!($($arg)*).as_str())
|
||||
};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! log_warn {
|
||||
($($arg:tt)*) => {
|
||||
$crate::log_agent("WARN", &format!($($arg)*))
|
||||
$crate::log_agent("WARN", format!($($arg)*).as_str())
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -189,6 +191,32 @@ fn run_rustdesk_ensure(
|
|||
password: Option<String>,
|
||||
machine_id: Option<String>,
|
||||
) -> Result<RustdeskProvisioningResult, String> {
|
||||
// Tenta usar o servico primeiro (sem UAC)
|
||||
if service_client::is_service_available() {
|
||||
log_info!("Usando Raven Service para provisionar RustDesk");
|
||||
match service_client::provision_rustdesk(
|
||||
config_string.as_deref(),
|
||||
password.as_deref(),
|
||||
machine_id.as_deref(),
|
||||
) {
|
||||
Ok(result) => {
|
||||
return Ok(RustdeskProvisioningResult {
|
||||
id: result.id,
|
||||
password: result.password,
|
||||
installed_version: result.installed_version,
|
||||
updated: result.updated,
|
||||
last_provisioned_at: result.last_provisioned_at,
|
||||
});
|
||||
}
|
||||
Err(e) => {
|
||||
log_warn!("Falha ao usar servico para RustDesk: {e}");
|
||||
// Continua para fallback
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback: chamada direta (pode pedir UAC)
|
||||
log_info!("Usando chamada direta para provisionar RustDesk (pode pedir UAC)");
|
||||
rustdesk::ensure_rustdesk(
|
||||
config_string.as_deref(),
|
||||
password.as_deref(),
|
||||
|
|
@ -208,14 +236,50 @@ fn run_rustdesk_ensure(
|
|||
|
||||
#[tauri::command]
|
||||
fn apply_usb_policy(policy: String) -> Result<UsbPolicyResult, String> {
|
||||
let policy_enum = UsbPolicy::from_str(&policy)
|
||||
// Valida a politica primeiro
|
||||
let _policy_enum = UsbPolicy::from_str(&policy)
|
||||
.ok_or_else(|| format!("Politica USB invalida: {}. Use ALLOW, BLOCK_ALL ou READONLY.", policy))?;
|
||||
|
||||
usb_control::apply_usb_policy(policy_enum).map_err(|e| e.to_string())
|
||||
// Tenta usar o servico primeiro (sem UAC)
|
||||
#[cfg(target_os = "windows")]
|
||||
if service_client::is_service_available() {
|
||||
log_info!("Usando Raven Service para aplicar politica USB: {}", policy);
|
||||
match service_client::apply_usb_policy(&policy) {
|
||||
Ok(result) => {
|
||||
return Ok(UsbPolicyResult {
|
||||
success: result.success,
|
||||
policy: result.policy,
|
||||
error: result.error,
|
||||
applied_at: result.applied_at,
|
||||
});
|
||||
}
|
||||
Err(e) => {
|
||||
log_warn!("Falha ao usar servico para USB policy: {e}");
|
||||
// Continua para fallback
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback: chamada direta (pode pedir UAC)
|
||||
log_info!("Usando chamada direta para aplicar politica USB (pode pedir UAC)");
|
||||
usb_control::apply_usb_policy(_policy_enum).map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
fn get_usb_policy() -> Result<String, String> {
|
||||
// Tenta usar o servico primeiro
|
||||
#[cfg(target_os = "windows")]
|
||||
if service_client::is_service_available() {
|
||||
match service_client::get_usb_policy() {
|
||||
Ok(policy) => return Ok(policy),
|
||||
Err(e) => {
|
||||
log_warn!("Falha ao obter USB policy via servico: {e}");
|
||||
// Continua para fallback
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback: leitura direta (nao precisa elevacao para ler)
|
||||
usb_control::get_current_policy()
|
||||
.map(|p| p.as_str().to_string())
|
||||
.map_err(|e| e.to_string())
|
||||
|
|
@ -452,6 +516,14 @@ pub fn run() {
|
|||
.plugin(tauri_plugin_process::init())
|
||||
.plugin(tauri_plugin_notification::init())
|
||||
.plugin(tauri_plugin_deep_link::init())
|
||||
.plugin(tauri_plugin_single_instance::init(|app, _argv, _cwd| {
|
||||
// Quando uma segunda instância tenta iniciar, foca a janela existente
|
||||
if let Some(window) = app.get_webview_window("main") {
|
||||
let _ = window.show();
|
||||
let _ = window.unminimize();
|
||||
let _ = window.set_focus();
|
||||
}
|
||||
}))
|
||||
.on_window_event(|window, event| {
|
||||
if let WindowEvent::CloseRequested { api, .. } = event {
|
||||
api.prevent_close();
|
||||
|
|
@ -481,7 +553,7 @@ pub fn run() {
|
|||
{
|
||||
let start_in_background = std::env::args().any(|arg| arg == "--background");
|
||||
setup_raven_autostart();
|
||||
setup_tray(&app.handle())?;
|
||||
setup_tray(app.handle())?;
|
||||
if start_in_background {
|
||||
if let Some(win) = app.get_webview_window("main") {
|
||||
let _ = win.hide();
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
#![cfg(target_os = "windows")]
|
||||
|
||||
use crate::RustdeskProvisioningResult;
|
||||
use chrono::{Local, Utc};
|
||||
use once_cell::sync::Lazy;
|
||||
|
|
@ -30,7 +28,9 @@ const LOCAL_SERVICE_CONFIG: &str = r"C:\\Windows\\ServiceProfiles\\LocalService\
|
|||
const LOCAL_SYSTEM_CONFIG: &str = r"C:\\Windows\\System32\\config\\systemprofile\\AppData\\Roaming\\RustDesk\\config";
|
||||
const APP_IDENTIFIER: &str = "br.com.esdrasrenan.sistemadechamados";
|
||||
const MACHINE_STORE_FILENAME: &str = "machine-agent.json";
|
||||
#[allow(dead_code)]
|
||||
const ACL_FLAG_FILENAME: &str = "rustdesk_acl_unlocked.flag";
|
||||
#[allow(dead_code)]
|
||||
const RUSTDESK_ACL_STORE_KEY: &str = "rustdeskAclUnlockedAt";
|
||||
const SECURITY_VERIFICATION_VALUE: &str = "use-permanent-password";
|
||||
const SECURITY_APPROVE_MODE_VALUE: &str = "password";
|
||||
|
|
@ -85,11 +85,11 @@ fn define_custom_id_from_machine(exe_path: &Path, machine_id: Option<&str>) -> O
|
|||
}) {
|
||||
match set_custom_id(exe_path, value) {
|
||||
Ok(custom) => {
|
||||
log_event(&format!("ID determinístico definido: {custom}"));
|
||||
log_event(format!("ID determinístico definido: {custom}"));
|
||||
Some(custom)
|
||||
}
|
||||
Err(error) => {
|
||||
log_event(&format!("Falha ao definir ID determinístico: {error}"));
|
||||
log_event(format!("Falha ao definir ID determinístico: {error}"));
|
||||
None
|
||||
}
|
||||
}
|
||||
|
|
@ -107,7 +107,7 @@ pub fn ensure_rustdesk(
|
|||
log_event("Iniciando preparo do RustDesk");
|
||||
|
||||
if let Err(error) = ensure_service_profiles_writable_preflight() {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Aviso: não foi possível preparar ACL dos perfis do serviço ({error}). Continuando mesmo assim; o serviço pode não aplicar a senha."
|
||||
));
|
||||
}
|
||||
|
|
@ -116,7 +116,7 @@ pub fn ensure_rustdesk(
|
|||
// Isso preserva o ID quando o Raven é reinstalado mas o RustDesk permanece
|
||||
let preserved_remote_id = read_remote_id_from_profiles();
|
||||
if let Some(ref id) = preserved_remote_id {
|
||||
log_event(&format!("ID existente preservado antes da limpeza: {}", id));
|
||||
log_event(format!("ID existente preservado antes da limpeza: {}", id));
|
||||
}
|
||||
|
||||
let exe_path = detect_executable_path();
|
||||
|
|
@ -129,7 +129,7 @@ pub fn ensure_rustdesk(
|
|||
|
||||
match stop_rustdesk_processes() {
|
||||
Ok(_) => log_event("Instâncias existentes do RustDesk encerradas"),
|
||||
Err(error) => log_event(&format!(
|
||||
Err(error) => log_event(format!(
|
||||
"Aviso: não foi possível parar completamente o RustDesk antes da reprovisionamento ({error})"
|
||||
)),
|
||||
}
|
||||
|
|
@ -139,7 +139,7 @@ pub fn ensure_rustdesk(
|
|||
if freshly_installed {
|
||||
match purge_existing_rustdesk_profiles() {
|
||||
Ok(_) => log_event("Configurações antigas do RustDesk limpas (instalação fresca)"),
|
||||
Err(error) => log_event(&format!(
|
||||
Err(error) => log_event(format!(
|
||||
"Aviso: não foi possível limpar completamente os perfis existentes do RustDesk ({error})"
|
||||
)),
|
||||
}
|
||||
|
|
@ -152,19 +152,19 @@ pub fn ensure_rustdesk(
|
|||
if trimmed.is_empty() { None } else { Some(trimmed) }
|
||||
}) {
|
||||
if let Err(error) = run_with_args(&exe_path, &["--config", value]) {
|
||||
log_event(&format!("Falha ao aplicar configuração inline: {error}"));
|
||||
log_event(format!("Falha ao aplicar configuração inline: {error}"));
|
||||
} else {
|
||||
log_event("Configuração aplicada via --config");
|
||||
}
|
||||
} else {
|
||||
let config_path = write_config_files()?;
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Arquivo de configuração atualizado em {}",
|
||||
config_path.display()
|
||||
));
|
||||
|
||||
if let Err(error) = apply_config(&exe_path, &config_path) {
|
||||
log_event(&format!("Falha ao aplicar configuração via CLI: {error}"));
|
||||
log_event(format!("Falha ao aplicar configuração via CLI: {error}"));
|
||||
} else {
|
||||
log_event("Configuração aplicada via CLI");
|
||||
}
|
||||
|
|
@ -176,7 +176,7 @@ pub fn ensure_rustdesk(
|
|||
.unwrap_or_else(|| DEFAULT_PASSWORD.to_string());
|
||||
|
||||
if let Err(error) = set_password(&exe_path, &password) {
|
||||
log_event(&format!("Falha ao definir senha padrão: {error}"));
|
||||
log_event(format!("Falha ao definir senha padrão: {error}"));
|
||||
} else {
|
||||
log_event("Senha padrão definida com sucesso");
|
||||
log_event("Aplicando senha nos perfis do RustDesk");
|
||||
|
|
@ -185,21 +185,21 @@ pub fn ensure_rustdesk(
|
|||
log_event("Senha e flags de segurança gravadas em todos os perfis do RustDesk");
|
||||
log_password_replication(&password);
|
||||
}
|
||||
Err(error) => log_event(&format!("Falha ao persistir senha nos perfis: {error}")),
|
||||
Err(error) => log_event(format!("Falha ao persistir senha nos perfis: {error}")),
|
||||
}
|
||||
|
||||
match propagate_password_profile() {
|
||||
Ok(_) => log_event("Perfil base propagado para ProgramData e perfis de serviço"),
|
||||
Err(error) => log_event(&format!("Falha ao copiar perfil de senha: {error}")),
|
||||
Err(error) => log_event(format!("Falha ao copiar perfil de senha: {error}")),
|
||||
}
|
||||
|
||||
match replicate_password_artifacts() {
|
||||
Ok(_) => log_event("Artefatos de senha replicados para o serviço do RustDesk"),
|
||||
Err(error) => log_event(&format!("Falha ao replicar artefatos de senha: {error}")),
|
||||
Err(error) => log_event(format!("Falha ao replicar artefatos de senha: {error}")),
|
||||
}
|
||||
|
||||
if let Err(error) = enforce_security_flags() {
|
||||
log_event(&format!("Falha ao reforçar configuração de senha permanente: {error}"));
|
||||
log_event(format!("Falha ao reforçar configuração de senha permanente: {error}"));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -207,7 +207,7 @@ pub fn ensure_rustdesk(
|
|||
// Isso garante que reinstalar o Raven nao muda o ID do RustDesk
|
||||
let custom_id = if let Some(ref existing_id) = preserved_remote_id {
|
||||
if !freshly_installed {
|
||||
log_event(&format!("Reutilizando ID existente do RustDesk: {}", existing_id));
|
||||
log_event(format!("Reutilizando ID existente do RustDesk: {}", existing_id));
|
||||
Some(existing_id.clone())
|
||||
} else {
|
||||
// Instalacao fresca - define novo ID baseado no machine_id
|
||||
|
|
@ -219,7 +219,7 @@ pub fn ensure_rustdesk(
|
|||
};
|
||||
|
||||
if let Err(error) = ensure_service_running(&exe_path) {
|
||||
log_event(&format!("Falha ao reiniciar serviço do RustDesk: {error}"));
|
||||
log_event(format!("Falha ao reiniciar serviço do RustDesk: {error}"));
|
||||
} else {
|
||||
log_event("Serviço RustDesk reiniciado/run ativo");
|
||||
}
|
||||
|
|
@ -227,10 +227,10 @@ pub fn ensure_rustdesk(
|
|||
let reported_id = match query_id_with_retries(&exe_path, 5) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
log_event(&format!("Falha ao obter ID após múltiplas tentativas: {error}"));
|
||||
log_event(format!("Falha ao obter ID após múltiplas tentativas: {error}"));
|
||||
match read_remote_id_from_profiles().or_else(|| custom_id.clone()) {
|
||||
Some(value) => {
|
||||
log_event(&format!("ID obtido via arquivos de perfil: {value}"));
|
||||
log_event(format!("ID obtido via arquivos de perfil: {value}"));
|
||||
value
|
||||
}
|
||||
None => return Err(error),
|
||||
|
|
@ -242,7 +242,7 @@ pub fn ensure_rustdesk(
|
|||
|
||||
if let Some(expected) = custom_id.as_ref() {
|
||||
if expected != &reported_id {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"ID retornado difere do determinístico ({expected}) -> reaplicando ID determinístico"
|
||||
));
|
||||
|
||||
|
|
@ -252,25 +252,25 @@ pub fn ensure_rustdesk(
|
|||
Ok(_) => match query_id_with_retries(&exe_path, 3) {
|
||||
Ok(rechecked) => {
|
||||
if &rechecked == expected {
|
||||
log_event(&format!("ID determinístico aplicado com sucesso: {rechecked}"));
|
||||
log_event(format!("ID determinístico aplicado com sucesso: {rechecked}"));
|
||||
final_id = rechecked;
|
||||
enforced = true;
|
||||
} else {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"ID ainda difere após reaplicação (esperado {expected}, reportado {rechecked}); usando ID reportado"
|
||||
));
|
||||
final_id = rechecked;
|
||||
}
|
||||
}
|
||||
Err(error) => {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao consultar ID após reaplicação: {error}; usando ID reportado ({reported_id})"
|
||||
));
|
||||
final_id = reported_id.clone();
|
||||
}
|
||||
},
|
||||
Err(error) => {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao reaplicar ID determinístico ({expected}): {error}; usando ID reportado ({reported_id})"
|
||||
));
|
||||
final_id = reported_id.clone();
|
||||
|
|
@ -308,7 +308,7 @@ pub fn ensure_rustdesk(
|
|||
"lastError": serde_json::Value::Null
|
||||
});
|
||||
if let Err(error) = upsert_machine_store_value("rustdesk", rustdesk_data) {
|
||||
log_event(&format!("Aviso: falha ao salvar dados do RustDesk no store: {error}"));
|
||||
log_event(format!("Aviso: falha ao salvar dados do RustDesk no store: {error}"));
|
||||
} else {
|
||||
log_event("Dados do RustDesk salvos no machine-agent.json");
|
||||
}
|
||||
|
|
@ -316,7 +316,7 @@ pub fn ensure_rustdesk(
|
|||
// Sincroniza com o backend imediatamente apos provisionar
|
||||
// O Rust faz o HTTP direto, sem passar pelo CSP do webview
|
||||
if let Err(error) = sync_remote_access_with_backend(&result) {
|
||||
log_event(&format!("Aviso: falha ao sincronizar com backend: {error}"));
|
||||
log_event(format!("Aviso: falha ao sincronizar com backend: {error}"));
|
||||
} else {
|
||||
log_event("Acesso remoto sincronizado com backend");
|
||||
// Atualiza lastSyncedAt no store
|
||||
|
|
@ -330,13 +330,13 @@ pub fn ensure_rustdesk(
|
|||
"lastError": serde_json::Value::Null
|
||||
});
|
||||
if let Err(e) = upsert_machine_store_value("rustdesk", synced_data) {
|
||||
log_event(&format!("Aviso: falha ao atualizar lastSyncedAt: {e}"));
|
||||
log_event(format!("Aviso: falha ao atualizar lastSyncedAt: {e}"));
|
||||
} else {
|
||||
log_event("lastSyncedAt atualizado com sucesso");
|
||||
}
|
||||
}
|
||||
|
||||
log_event(&format!("Provisionamento concluído. ID final: {final_id}. Versão: {:?}", version));
|
||||
log_event(format!("Provisionamento concluído. ID final: {final_id}. Versão: {:?}", version));
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
|
@ -403,7 +403,7 @@ fn write_config_files() -> Result<PathBuf, RustdeskError> {
|
|||
let config_contents = build_config_contents();
|
||||
let main_path = program_data_config_dir().join("RustDesk2.toml");
|
||||
write_file(&main_path, &config_contents)?;
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Config principal gravada em {}",
|
||||
main_path.display()
|
||||
));
|
||||
|
|
@ -412,7 +412,7 @@ fn write_config_files() -> Result<PathBuf, RustdeskError> {
|
|||
for service_dir in service_profile_dirs() {
|
||||
let service_profile = service_dir.join("RustDesk2.toml");
|
||||
if let Err(error) = write_file(&service_profile, &config_contents) {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao gravar config no perfil do serviço ({}): {error}",
|
||||
service_profile.display()
|
||||
));
|
||||
|
|
@ -421,7 +421,7 @@ fn write_config_files() -> Result<PathBuf, RustdeskError> {
|
|||
|
||||
if let Some(appdata_path) = user_appdata_config_path("RustDesk2.toml") {
|
||||
if let Err(error) = write_file(&appdata_path, &config_contents) {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao atualizar config no AppData do usuário: {error}"
|
||||
));
|
||||
}
|
||||
|
|
@ -516,7 +516,7 @@ fn ensure_service_running(exe_path: &Path) -> Result<(), RustdeskError> {
|
|||
ensure_service_installed(exe_path)?;
|
||||
|
||||
if let Err(error) = configure_service_startup() {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Aviso: não foi possível reforçar autostart/recuperação do serviço RustDesk: {error}"
|
||||
));
|
||||
}
|
||||
|
|
@ -553,7 +553,7 @@ fn ensure_service_running(exe_path: &Path) -> Result<(), RustdeskError> {
|
|||
let _ = run_with_args(exe_path, &["--install-service"]);
|
||||
let _ = run_sc(&["config", SERVICE_NAME, &format!("start= {}", "auto")]);
|
||||
if let Err(error) = start_sequence() {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao subir o serviço RustDesk mesmo após reinstalação: {error}"
|
||||
));
|
||||
}
|
||||
|
|
@ -631,8 +631,8 @@ fn remove_rustdesk_autorun_artifacts() {
|
|||
for path in startup_paths {
|
||||
if path.exists() {
|
||||
match fs::remove_file(&path) {
|
||||
Ok(_) => log_event(&format!("Atalho de inicialização do RustDesk removido: {}", path.display())),
|
||||
Err(error) => log_event(&format!(
|
||||
Ok(_) => log_event(format!("Atalho de inicialização do RustDesk removido: {}", path.display())),
|
||||
Err(error) => log_event(format!(
|
||||
"Falha ao remover atalho de inicialização do RustDesk ({}): {}",
|
||||
path.display(),
|
||||
error
|
||||
|
|
@ -650,7 +650,7 @@ fn remove_rustdesk_autorun_artifacts() {
|
|||
.status();
|
||||
if let Ok(code) = status {
|
||||
if code.success() {
|
||||
log_event(&format!("Entrada de auto-run RustDesk removida de {}", reg_path));
|
||||
log_event(format!("Entrada de auto-run RustDesk removida de {}", reg_path));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -658,7 +658,7 @@ fn remove_rustdesk_autorun_artifacts() {
|
|||
|
||||
fn stop_rustdesk_processes() -> Result<(), RustdeskError> {
|
||||
if let Err(error) = try_stop_service() {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Não foi possível parar o serviço RustDesk antes da sincronização: {error}"
|
||||
));
|
||||
}
|
||||
|
|
@ -774,12 +774,12 @@ fn ensure_remote_id_files(id: &str) {
|
|||
for dir in remote_id_directories() {
|
||||
let path = dir.join("RustDesk_local.toml");
|
||||
match write_remote_id_value(&path, id) {
|
||||
Ok(_) => log_event(&format!(
|
||||
Ok(_) => log_event(format!(
|
||||
"remote_id atualizado para {} em {}",
|
||||
id,
|
||||
path.display()
|
||||
)),
|
||||
Err(error) => log_event(&format!(
|
||||
Err(error) => log_event(format!(
|
||||
"Falha ao atualizar remote_id em {}: {error}",
|
||||
path.display()
|
||||
)),
|
||||
|
|
@ -821,7 +821,7 @@ fn ensure_password_files(secret: &str) -> Result<(), String> {
|
|||
if let Err(error) = write_toml_kv(&password_path, "password", secret) {
|
||||
errors.push(format!("{} -> {}", password_path.display(), error));
|
||||
} else {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Senha escrita via fallback em {}",
|
||||
password_path.display()
|
||||
));
|
||||
|
|
@ -829,12 +829,12 @@ fn ensure_password_files(secret: &str) -> Result<(), String> {
|
|||
|
||||
let local_path = dir.join("RustDesk_local.toml");
|
||||
if let Err(error) = write_toml_kv(&local_path, "verification-method", SECURITY_VERIFICATION_VALUE) {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao ajustar verification-method em {}: {error}",
|
||||
local_path.display()
|
||||
));
|
||||
} else {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"verification-method atualizado para {} em {}",
|
||||
SECURITY_VERIFICATION_VALUE,
|
||||
local_path.display()
|
||||
|
|
@ -843,19 +843,19 @@ fn ensure_password_files(secret: &str) -> Result<(), String> {
|
|||
|
||||
let rustdesk2_path = dir.join("RustDesk2.toml");
|
||||
if let Err(error) = enforce_security_in_rustdesk2(&rustdesk2_path) {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao ajustar flags no RustDesk2.toml em {}: {error}",
|
||||
rustdesk2_path.display()
|
||||
));
|
||||
}
|
||||
|
||||
if let Err(error) = write_toml_kv(&local_path, "approve-mode", SECURITY_APPROVE_MODE_VALUE) {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao ajustar approve-mode em {}: {error}",
|
||||
local_path.display()
|
||||
));
|
||||
} else {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"approve-mode atualizado para {} em {}",
|
||||
SECURITY_APPROVE_MODE_VALUE,
|
||||
local_path.display()
|
||||
|
|
@ -877,7 +877,7 @@ fn enforce_security_flags() -> Result<(), String> {
|
|||
if let Err(error) = write_toml_kv(&local_path, "verification-method", SECURITY_VERIFICATION_VALUE) {
|
||||
errors.push(format!("{} -> {}", local_path.display(), error));
|
||||
} else {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"verification-method atualizado para {} em {}",
|
||||
SECURITY_VERIFICATION_VALUE,
|
||||
local_path.display()
|
||||
|
|
@ -887,7 +887,7 @@ fn enforce_security_flags() -> Result<(), String> {
|
|||
if let Err(error) = write_toml_kv(&local_path, "approve-mode", SECURITY_APPROVE_MODE_VALUE) {
|
||||
errors.push(format!("{} -> {}", local_path.display(), error));
|
||||
} else {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"approve-mode atualizado para {} em {}",
|
||||
SECURITY_APPROVE_MODE_VALUE,
|
||||
local_path.display()
|
||||
|
|
@ -921,7 +921,7 @@ fn propagate_password_profile() -> io::Result<bool> {
|
|||
if !src_path.exists() {
|
||||
continue;
|
||||
}
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Copiando {} para ProgramData/serviços",
|
||||
src_path.display()
|
||||
));
|
||||
|
|
@ -929,7 +929,7 @@ fn propagate_password_profile() -> io::Result<bool> {
|
|||
for dest_root in propagation_destinations() {
|
||||
let target_path = dest_root.join(filename);
|
||||
copy_overwrite(&src_path, &target_path)?;
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"{} propagado para {}",
|
||||
filename,
|
||||
target_path.display()
|
||||
|
|
@ -969,7 +969,7 @@ fn replicate_password_artifacts() -> io::Result<()> {
|
|||
|
||||
let target_path = dest.join(name);
|
||||
copy_overwrite(&source_path, &target_path)?;
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Artefato de senha {name} replicado para {}",
|
||||
target_path.display()
|
||||
));
|
||||
|
|
@ -981,13 +981,11 @@ fn replicate_password_artifacts() -> io::Result<()> {
|
|||
|
||||
fn purge_existing_rustdesk_profiles() -> Result<(), String> {
|
||||
let mut errors = Vec::new();
|
||||
let mut cleaned_any = false;
|
||||
|
||||
for dir in remote_id_directories() {
|
||||
match purge_config_dir(&dir) {
|
||||
Ok(true) => {
|
||||
cleaned_any = true;
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Perfis antigos removidos em {}",
|
||||
dir.display()
|
||||
));
|
||||
|
|
@ -997,9 +995,7 @@ fn purge_existing_rustdesk_profiles() -> Result<(), String> {
|
|||
}
|
||||
}
|
||||
|
||||
if cleaned_any {
|
||||
Ok(())
|
||||
} else if errors.is_empty() {
|
||||
if errors.is_empty() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(errors.join(" | "))
|
||||
|
|
@ -1030,6 +1026,7 @@ fn purge_config_dir(dir: &Path) -> Result<bool, io::Error> {
|
|||
Ok(removed)
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn run_powershell_elevated(script: &str) -> Result<(), String> {
|
||||
let temp_dir = env::temp_dir();
|
||||
let payload = temp_dir.join("raven_payload.ps1");
|
||||
|
|
@ -1077,6 +1074,7 @@ exit $process.ExitCode
|
|||
Err(format!("elevated ps exit {:?}", status.code()))
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn fix_profile_acl(target: &Path) -> Result<(), String> {
|
||||
let target_str = target.display().to_string();
|
||||
let transcript = env::temp_dir().join("raven_acl_ps.log");
|
||||
|
|
@ -1111,7 +1109,7 @@ try {{
|
|||
let result = run_powershell_elevated(&script);
|
||||
if result.is_err() {
|
||||
if let Ok(content) = fs::read_to_string(&transcript) {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"ACL transcript para {}:\n{}",
|
||||
target.display(), content
|
||||
));
|
||||
|
|
@ -1122,6 +1120,9 @@ try {{
|
|||
}
|
||||
|
||||
fn ensure_service_profiles_writable_preflight() -> Result<(), String> {
|
||||
// Verificamos se os diretorios de perfil sao graváveis
|
||||
// Se nao forem, apenas logamos aviso - o Raven Service deve lidar com isso
|
||||
// Nao usamos elevacao para evitar UAC adicional
|
||||
let mut blocked_dirs = Vec::new();
|
||||
for dir in service_profile_dirs() {
|
||||
if !can_write_dir(&dir) {
|
||||
|
|
@ -1133,53 +1134,46 @@ fn ensure_service_profiles_writable_preflight() -> Result<(), String> {
|
|||
return Ok(());
|
||||
}
|
||||
|
||||
if has_acl_unlock_flag() {
|
||||
log_event("Perfis do serviço voltaram a bloquear escrita; reaplicando correção de ACL");
|
||||
} else {
|
||||
log_event("Executando ajuste inicial de ACL dos perfis do serviço (requer UAC)");
|
||||
}
|
||||
// Apenas logamos aviso - o serviço RavenService deve lidar com permissões
|
||||
log_event(format!(
|
||||
"Aviso: alguns perfis de serviço não são graváveis: {:?}. O Raven Service deve configurar permissões.",
|
||||
blocked_dirs.iter().map(|d| d.display().to_string()).collect::<Vec<_>>()
|
||||
));
|
||||
|
||||
let mut last_error: Option<String> = None;
|
||||
for dir in blocked_dirs.iter() {
|
||||
log_event(&format!(
|
||||
"Tentando corrigir ACL via UAC (preflight) em {}...",
|
||||
dir.display()
|
||||
));
|
||||
if let Err(error) = fix_profile_acl(dir) {
|
||||
last_error = Some(error);
|
||||
continue;
|
||||
}
|
||||
if can_write_dir(dir) {
|
||||
log_event(&format!(
|
||||
"ACL ajustada com sucesso em {}",
|
||||
dir.display()
|
||||
));
|
||||
} else {
|
||||
last_error = Some(format!(
|
||||
"continua sem permissão para {} mesmo após preflight",
|
||||
dir.display()
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
if blocked_dirs.iter().all(|dir| can_write_dir(dir)) {
|
||||
mark_acl_unlock_flag();
|
||||
Ok(())
|
||||
} else {
|
||||
Err(last_error.unwrap_or_else(|| "nenhum perfil de serviço acessível".into()))
|
||||
}
|
||||
// Retornamos Ok para não bloquear o fluxo
|
||||
// O Raven Service, rodando como LocalSystem, pode gravar nesses diretórios
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn stop_service_elevated() -> Result<(), String> {
|
||||
let script = r#"
|
||||
$ErrorActionPreference='Stop'
|
||||
$service = Get-Service -Name 'RustDesk' -ErrorAction SilentlyContinue
|
||||
if ($service -and $service.Status -ne 'Stopped') {
|
||||
Stop-Service -Name 'RustDesk' -Force -ErrorAction Stop
|
||||
$service.WaitForStatus('Stopped','00:00:10')
|
||||
}
|
||||
"#;
|
||||
run_powershell_elevated(script)
|
||||
// Tentamos parar o serviço RustDesk sem elevação
|
||||
// Se falhar, apenas logamos aviso - o Raven Service pode lidar com isso
|
||||
// Não usamos elevação para evitar UAC adicional
|
||||
let output = Command::new("sc")
|
||||
.args(["stop", "RustDesk"])
|
||||
.output();
|
||||
|
||||
match output {
|
||||
Ok(result) => {
|
||||
if result.status.success() {
|
||||
// Aguarda um pouco para o serviço parar
|
||||
std::thread::sleep(std::time::Duration::from_secs(2));
|
||||
Ok(())
|
||||
} else {
|
||||
let stderr = String::from_utf8_lossy(&result.stderr);
|
||||
log_event(format!(
|
||||
"Aviso: não foi possível parar o serviço RustDesk sem elevação: {}",
|
||||
stderr.trim()
|
||||
));
|
||||
// Retornamos Ok para não bloquear - o serviço pode estar já parado
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
log_event(format!("Aviso: falha ao executar sc stop RustDesk: {e}"));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn can_write_dir(dir: &Path) -> bool {
|
||||
|
|
@ -1339,21 +1333,21 @@ fn log_password_replication(secret: &str) {
|
|||
fn log_password_match(path: &Path, secret: &str) {
|
||||
match read_password_from_file(path) {
|
||||
Some(value) if value == secret => {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Senha confirmada em {} ({})",
|
||||
path.display(),
|
||||
mask_secret(&value)
|
||||
));
|
||||
}
|
||||
Some(value) => {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Aviso: senha divergente ({}) em {}",
|
||||
mask_secret(&value),
|
||||
path.display()
|
||||
));
|
||||
}
|
||||
None => {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Aviso: chave 'password' não encontrada em {}",
|
||||
path.display()
|
||||
));
|
||||
|
|
@ -1469,21 +1463,24 @@ fn write_machine_store_object(map: JsonMap<String, JsonValue>) -> Result<(), Str
|
|||
}
|
||||
|
||||
fn upsert_machine_store_value(key: &str, value: JsonValue) -> Result<(), String> {
|
||||
let mut map = read_machine_store_object().unwrap_or_else(JsonMap::new);
|
||||
let mut map = read_machine_store_object().unwrap_or_default();
|
||||
map.insert(key.to_string(), value);
|
||||
write_machine_store_object(map)
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn machine_store_key_exists(key: &str) -> bool {
|
||||
read_machine_store_object()
|
||||
.map(|map| map.contains_key(key))
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn acl_flag_file_path() -> Option<PathBuf> {
|
||||
raven_appdata_root().map(|dir| dir.join(ACL_FLAG_FILENAME))
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn has_acl_unlock_flag() -> bool {
|
||||
if let Some(flag) = acl_flag_file_path() {
|
||||
if flag.exists() {
|
||||
|
|
@ -1493,6 +1490,7 @@ fn has_acl_unlock_flag() -> bool {
|
|||
machine_store_key_exists(RUSTDESK_ACL_STORE_KEY)
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn mark_acl_unlock_flag() {
|
||||
let timestamp = Utc::now().timestamp_millis();
|
||||
if let Some(flag_path) = acl_flag_file_path() {
|
||||
|
|
@ -1500,7 +1498,7 @@ fn mark_acl_unlock_flag() {
|
|||
let _ = fs::create_dir_all(parent);
|
||||
}
|
||||
if let Err(error) = fs::write(&flag_path, timestamp.to_string()) {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao gravar flag de ACL em {}: {error}",
|
||||
flag_path.display()
|
||||
));
|
||||
|
|
@ -1508,7 +1506,7 @@ fn mark_acl_unlock_flag() {
|
|||
}
|
||||
|
||||
if let Err(error) = upsert_machine_store_value(RUSTDESK_ACL_STORE_KEY, JsonValue::from(timestamp)) {
|
||||
log_event(&format!(
|
||||
log_event(format!(
|
||||
"Falha ao registrar flag de ACL no machine-agent: {error}"
|
||||
));
|
||||
}
|
||||
|
|
@ -1547,7 +1545,7 @@ fn sync_remote_access_with_backend(result: &crate::RustdeskProvisioningResult) -
|
|||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("https://tickets.esdrasrenan.com.br");
|
||||
|
||||
log_event(&format!("Sincronizando com backend: {} (machineId: {})", api_base_url, machine_id));
|
||||
log_event(format!("Sincronizando com backend: {} (machineId: {})", api_base_url, machine_id));
|
||||
|
||||
// Monta payload conforme schema esperado pelo backend
|
||||
// Schema: { machineToken, provider, identifier, password?, url?, username?, notes? }
|
||||
|
|
@ -1575,13 +1573,13 @@ fn sync_remote_access_with_backend(result: &crate::RustdeskProvisioningResult) -
|
|||
.send()?;
|
||||
|
||||
if response.status().is_success() {
|
||||
log_event(&format!("Sync com backend OK: status {}", response.status()));
|
||||
log_event(format!("Sync com backend OK: status {}", response.status()));
|
||||
Ok(())
|
||||
} else {
|
||||
let status = response.status();
|
||||
let body = response.text().unwrap_or_default();
|
||||
let body_preview = if body.len() > 200 { &body[..200] } else { &body };
|
||||
log_event(&format!("Sync com backend falhou: {} - {}", status, body_preview));
|
||||
log_event(format!("Sync com backend falhou: {} - {}", status, body_preview));
|
||||
Err(RustdeskError::CommandFailed {
|
||||
command: "sync_remote_access".to_string(),
|
||||
status: Some(status.as_u16() as i32)
|
||||
|
|
|
|||
244
apps/desktop/src-tauri/src/service_client.rs
Normal file
244
apps/desktop/src-tauri/src/service_client.rs
Normal file
|
|
@ -0,0 +1,244 @@
|
|||
//! Cliente IPC para comunicacao com o Raven Service
|
||||
//!
|
||||
//! Este modulo permite que o app Tauri se comunique com o Raven Service
|
||||
//! via Named Pipes para executar operacoes privilegiadas.
|
||||
|
||||
#![allow(dead_code)]
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::io::{BufRead, BufReader, Write};
|
||||
use std::time::Duration;
|
||||
use thiserror::Error;
|
||||
|
||||
const PIPE_NAME: &str = r"\\.\pipe\RavenService";
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum ServiceClientError {
|
||||
#[error("Servico nao disponivel: {0}")]
|
||||
ServiceUnavailable(String),
|
||||
|
||||
#[error("Erro de comunicacao: {0}")]
|
||||
CommunicationError(String),
|
||||
|
||||
#[error("Erro de serializacao: {0}")]
|
||||
SerializationError(#[from] serde_json::Error),
|
||||
|
||||
#[error("Erro do servico: {message} (code: {code})")]
|
||||
ServiceError { code: i32, message: String },
|
||||
|
||||
#[error("Timeout aguardando resposta")]
|
||||
Timeout,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
struct Request {
|
||||
id: String,
|
||||
method: String,
|
||||
params: serde_json::Value,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct Response {
|
||||
id: String,
|
||||
result: Option<serde_json::Value>,
|
||||
error: Option<ErrorResponse>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct ErrorResponse {
|
||||
code: i32,
|
||||
message: String,
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Tipos de Resultado
|
||||
// =============================================================================
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct UsbPolicyResult {
|
||||
pub success: bool,
|
||||
pub policy: String,
|
||||
pub error: Option<String>,
|
||||
pub applied_at: Option<i64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RustdeskResult {
|
||||
pub id: String,
|
||||
pub password: String,
|
||||
pub installed_version: Option<String>,
|
||||
pub updated: bool,
|
||||
pub last_provisioned_at: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RustdeskStatus {
|
||||
pub installed: bool,
|
||||
pub running: bool,
|
||||
pub id: Option<String>,
|
||||
pub version: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct HealthCheckResult {
|
||||
pub status: String,
|
||||
pub service: String,
|
||||
pub version: String,
|
||||
pub timestamp: i64,
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Cliente
|
||||
// =============================================================================
|
||||
|
||||
/// Verifica se o servico esta disponivel
|
||||
pub fn is_service_available() -> bool {
|
||||
health_check().is_ok()
|
||||
}
|
||||
|
||||
/// Verifica saude do servico
|
||||
pub fn health_check() -> Result<HealthCheckResult, ServiceClientError> {
|
||||
let response = call_service("health_check", serde_json::json!({}))?;
|
||||
serde_json::from_value(response).map_err(|e| e.into())
|
||||
}
|
||||
|
||||
/// Aplica politica de USB
|
||||
pub fn apply_usb_policy(policy: &str) -> Result<UsbPolicyResult, ServiceClientError> {
|
||||
let response = call_service(
|
||||
"apply_usb_policy",
|
||||
serde_json::json!({ "policy": policy }),
|
||||
)?;
|
||||
serde_json::from_value(response).map_err(|e| e.into())
|
||||
}
|
||||
|
||||
/// Obtem politica de USB atual
|
||||
pub fn get_usb_policy() -> Result<String, ServiceClientError> {
|
||||
let response = call_service("get_usb_policy", serde_json::json!({}))?;
|
||||
response
|
||||
.get("policy")
|
||||
.and_then(|p| p.as_str())
|
||||
.map(String::from)
|
||||
.ok_or_else(|| ServiceClientError::CommunicationError("Resposta invalida".into()))
|
||||
}
|
||||
|
||||
/// Provisiona RustDesk
|
||||
pub fn provision_rustdesk(
|
||||
config: Option<&str>,
|
||||
password: Option<&str>,
|
||||
machine_id: Option<&str>,
|
||||
) -> Result<RustdeskResult, ServiceClientError> {
|
||||
let params = serde_json::json!({
|
||||
"config": config,
|
||||
"password": password,
|
||||
"machineId": machine_id,
|
||||
});
|
||||
let response = call_service("provision_rustdesk", params)?;
|
||||
serde_json::from_value(response).map_err(|e| e.into())
|
||||
}
|
||||
|
||||
/// Obtem status do RustDesk
|
||||
pub fn get_rustdesk_status() -> Result<RustdeskStatus, ServiceClientError> {
|
||||
let response = call_service("get_rustdesk_status", serde_json::json!({}))?;
|
||||
serde_json::from_value(response).map_err(|e| e.into())
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Comunicacao IPC
|
||||
// =============================================================================
|
||||
|
||||
fn call_service(
|
||||
method: &str,
|
||||
params: serde_json::Value,
|
||||
) -> Result<serde_json::Value, ServiceClientError> {
|
||||
// Gera ID unico para a requisicao
|
||||
let id = uuid::Uuid::new_v4().to_string();
|
||||
|
||||
let request = Request {
|
||||
id: id.clone(),
|
||||
method: method.to_string(),
|
||||
params,
|
||||
};
|
||||
|
||||
// Serializa requisicao
|
||||
let request_json = serde_json::to_string(&request)?;
|
||||
|
||||
// Conecta ao pipe
|
||||
let mut pipe = connect_to_pipe()?;
|
||||
|
||||
// Envia requisicao
|
||||
writeln!(pipe, "{}", request_json).map_err(|e| {
|
||||
ServiceClientError::CommunicationError(format!("Erro ao enviar requisicao: {}", e))
|
||||
})?;
|
||||
pipe.flush().map_err(|e| {
|
||||
ServiceClientError::CommunicationError(format!("Erro ao flush: {}", e))
|
||||
})?;
|
||||
|
||||
// Le resposta
|
||||
let mut reader = BufReader::new(pipe);
|
||||
let mut response_line = String::new();
|
||||
|
||||
reader.read_line(&mut response_line).map_err(|e| {
|
||||
ServiceClientError::CommunicationError(format!("Erro ao ler resposta: {}", e))
|
||||
})?;
|
||||
|
||||
// Parse da resposta
|
||||
let response: Response = serde_json::from_str(&response_line)?;
|
||||
|
||||
// Verifica se o ID bate
|
||||
if response.id != id {
|
||||
return Err(ServiceClientError::CommunicationError(
|
||||
"ID de resposta nao corresponde".into(),
|
||||
));
|
||||
}
|
||||
|
||||
// Verifica erro
|
||||
if let Some(error) = response.error {
|
||||
return Err(ServiceClientError::ServiceError {
|
||||
code: error.code,
|
||||
message: error.message,
|
||||
});
|
||||
}
|
||||
|
||||
// Retorna resultado
|
||||
response
|
||||
.result
|
||||
.ok_or_else(|| ServiceClientError::CommunicationError("Resposta sem resultado".into()))
|
||||
}
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
fn connect_to_pipe() -> Result<std::fs::File, ServiceClientError> {
|
||||
// Tenta conectar ao pipe com retry
|
||||
let mut attempts = 0;
|
||||
let max_attempts = 3;
|
||||
|
||||
loop {
|
||||
match std::fs::OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.open(PIPE_NAME)
|
||||
{
|
||||
Ok(file) => return Ok(file),
|
||||
Err(e) => {
|
||||
attempts += 1;
|
||||
if attempts >= max_attempts {
|
||||
return Err(ServiceClientError::ServiceUnavailable(format!(
|
||||
"Nao foi possivel conectar ao servico apos {} tentativas: {}",
|
||||
max_attempts, e
|
||||
)));
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(500));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
fn connect_to_pipe() -> Result<std::fs::File, ServiceClientError> {
|
||||
Err(ServiceClientError::ServiceUnavailable(
|
||||
"Named Pipes so estao disponiveis no Windows".into(),
|
||||
))
|
||||
}
|
||||
|
|
@ -93,22 +93,10 @@ mod windows_impl {
|
|||
applied_at: Some(now),
|
||||
}),
|
||||
Err(err) => {
|
||||
// Tenta elevação se faltou permissão
|
||||
// Se faltou permissão, retorna erro - o serviço deve ser usado
|
||||
// Não fazemos elevação aqui para evitar UAC adicional
|
||||
if is_permission_error(&err) {
|
||||
if let Err(elevated_err) = apply_policy_with_elevation(policy) {
|
||||
return Err(elevated_err);
|
||||
}
|
||||
// Revalida a policy após elevação
|
||||
let current = get_current_policy()?;
|
||||
if current != policy {
|
||||
return Err(UsbControlError::PermissionDenied);
|
||||
}
|
||||
return Ok(UsbPolicyResult {
|
||||
success: true,
|
||||
policy: policy.as_str().to_string(),
|
||||
error: None,
|
||||
applied_at: Some(now),
|
||||
});
|
||||
return Err(UsbControlError::PermissionDenied);
|
||||
}
|
||||
Err(err)
|
||||
}
|
||||
|
|
@ -219,10 +207,8 @@ mod windows_impl {
|
|||
|
||||
key.set_value("WriteProtect", &1u32)
|
||||
.map_err(map_winreg_error)?;
|
||||
} else {
|
||||
if let Ok(key) = hklm.open_subkey_with_flags(STORAGE_POLICY_PATH, KEY_ALL_ACCESS) {
|
||||
let _ = key.set_value("WriteProtect", &0u32);
|
||||
}
|
||||
} else if let Ok(key) = hklm.open_subkey_with_flags(STORAGE_POLICY_PATH, KEY_ALL_ACCESS) {
|
||||
let _ = key.set_value("WriteProtect", &0u32);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
|
|
@ -269,6 +255,7 @@ mod windows_impl {
|
|||
}
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn apply_policy_with_elevation(policy: UsbPolicy) -> Result<(), UsbControlError> {
|
||||
// Cria script temporário para aplicar as chaves via PowerShell elevado
|
||||
let temp_dir = std::env::temp_dir();
|
||||
|
|
@ -321,7 +308,7 @@ try {{
|
|||
policy = policy_str
|
||||
);
|
||||
|
||||
fs::write(&script_path, script).map_err(|e| UsbControlError::Io(e))?;
|
||||
fs::write(&script_path, script).map_err(UsbControlError::Io)?;
|
||||
|
||||
// Start-Process com RunAs para acionar UAC
|
||||
let arg = format!(
|
||||
|
|
@ -333,7 +320,7 @@ try {{
|
|||
.arg("-Command")
|
||||
.arg(arg)
|
||||
.status()
|
||||
.map_err(|e| UsbControlError::Io(e))?;
|
||||
.map_err(UsbControlError::Io)?;
|
||||
|
||||
if !status.success() {
|
||||
return Err(UsbControlError::PermissionDenied);
|
||||
|
|
@ -362,7 +349,7 @@ try {{
|
|||
.args(["/target:computer", "/force"])
|
||||
.creation_flags(CREATE_NO_WINDOW)
|
||||
.output()
|
||||
.map_err(|e| UsbControlError::Io(e))?;
|
||||
.map_err(UsbControlError::Io)?;
|
||||
|
||||
if !output.status.success() {
|
||||
// Nao e critico se falhar, apenas log
|
||||
|
|
|
|||
|
|
@ -50,6 +50,9 @@
|
|||
"icons/icon.png",
|
||||
"icons/Raven.png"
|
||||
],
|
||||
"resources": {
|
||||
"../service/target/release/raven-service.exe": "raven-service.exe"
|
||||
},
|
||||
"windows": {
|
||||
"webviewInstallMode": {
|
||||
"type": "skip"
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue