839 lines
29 KiB
Python
839 lines
29 KiB
Python
|
import os
|
||
|
|
import sys
|
||
|
|
import json
|
||
|
|
import time
|
||
|
|
import psutil
|
||
|
|
import requests
|
||
|
|
import win32gui
|
||
|
|
import win32process
|
||
|
|
import win32api
|
||
|
|
import win32evtlog
|
||
|
|
import win32evtlogutil
|
||
|
|
import winreg
|
||
|
|
import sqlite3
|
||
|
|
import shutil
|
||
|
|
from datetime import datetime
|
||
|
|
from pathlib import Path
|
||
|
|
import pystray
|
||
|
|
from PIL import Image, ImageDraw
|
||
|
|
from threading import Thread
|
||
|
|
import schedule
|
||
|
|
import atexit
|
||
|
|
import argparse
|
||
|
|
import subprocess
|
||
|
|
|
||
|
|
API_URL = "https://admin.noidle.tech/api"
|
||
|
|
CONFIG_FILE = Path(os.getenv('APPDATA')) / 'NoIdle' / 'config.json'
|
||
|
|
INSTALL_DIR = Path(os.getenv('ProgramFiles')) / 'NoIdle'
|
||
|
|
INSTALL_EXE = INSTALL_DIR / 'NoIdle.exe'
|
||
|
|
MONITOR_INTERVAL = 10 # 10 segundos (mais frequente para capturar mudanças)
|
||
|
|
IDLE_THRESHOLD = 30 # 30 segundos para considerar ocioso
|
||
|
|
|
||
|
|
class Config:
|
||
|
|
def __init__(self):
|
||
|
|
self.config_dir = CONFIG_FILE.parent
|
||
|
|
self.config_dir.mkdir(parents=True, exist_ok=True)
|
||
|
|
self.data = self.load()
|
||
|
|
|
||
|
|
def load(self):
|
||
|
|
if CONFIG_FILE.exists():
|
||
|
|
with open(CONFIG_FILE, 'r') as f:
|
||
|
|
return json.load(f)
|
||
|
|
return {}
|
||
|
|
|
||
|
|
def save(self):
|
||
|
|
with open(CONFIG_FILE, 'w') as f:
|
||
|
|
json.dump(self.data, f, indent=2)
|
||
|
|
|
||
|
|
def get(self, key, default=None):
|
||
|
|
return self.data.get(key, default)
|
||
|
|
|
||
|
|
def set(self, key, value):
|
||
|
|
self.data[key] = value
|
||
|
|
self.save()
|
||
|
|
|
||
|
|
def has(self, key):
|
||
|
|
return key in self.data
|
||
|
|
|
||
|
|
class ActivationWindow:
|
||
|
|
def __init__(self):
|
||
|
|
self.activation_key = None
|
||
|
|
self.result = None
|
||
|
|
|
||
|
|
def show(self):
|
||
|
|
import tkinter as tk
|
||
|
|
from tkinter import messagebox
|
||
|
|
|
||
|
|
root = tk.Tk()
|
||
|
|
root.title("NoIdle - Ativacao")
|
||
|
|
root.geometry("500x300")
|
||
|
|
root.resizable(False, False)
|
||
|
|
root.eval('tk::PlaceWindow . center')
|
||
|
|
|
||
|
|
title = tk.Label(root, text="NoIdle", font=("Arial", 24, "bold"), fg="#2563eb")
|
||
|
|
title.pack(pady=20)
|
||
|
|
|
||
|
|
subtitle = tk.Label(root, text="Zero Idle, Maximum Productivity", font=("Arial", 10))
|
||
|
|
subtitle.pack()
|
||
|
|
|
||
|
|
instruction = tk.Label(root, text="Insira a chave de ativacao:", font=("Arial", 10))
|
||
|
|
instruction.pack(pady=20)
|
||
|
|
|
||
|
|
key_var = tk.StringVar()
|
||
|
|
entry = tk.Entry(root, textvariable=key_var, font=("Courier", 12), width=40, justify="center")
|
||
|
|
entry.pack(pady=10)
|
||
|
|
entry.focus()
|
||
|
|
|
||
|
|
error_label = tk.Label(root, text="", fg="red", font=("Arial", 9))
|
||
|
|
error_label.pack()
|
||
|
|
|
||
|
|
def on_activate():
|
||
|
|
key = key_var.get().strip()
|
||
|
|
if not key:
|
||
|
|
error_label.config(text="Insira uma chave")
|
||
|
|
return
|
||
|
|
|
||
|
|
error_label.config(text="Ativando...")
|
||
|
|
root.update()
|
||
|
|
|
||
|
|
try:
|
||
|
|
result = activate_device(key)
|
||
|
|
if result.get('success'):
|
||
|
|
self.activation_key = key
|
||
|
|
self.result = result
|
||
|
|
messagebox.showinfo("Sucesso", "Dispositivo ativado com sucesso!")
|
||
|
|
root.destroy()
|
||
|
|
else:
|
||
|
|
error_label.config(text=result.get('message', 'Erro ao ativar'))
|
||
|
|
except Exception as e:
|
||
|
|
error_label.config(text=str(e))
|
||
|
|
|
||
|
|
btn = tk.Button(root, text="Ativar", command=on_activate, bg="#2563eb", fg="white", font=("Arial", 11, "bold"), padx=30, pady=10)
|
||
|
|
btn.pack(pady=20)
|
||
|
|
entry.bind('<Return>', lambda e: on_activate())
|
||
|
|
root.mainloop()
|
||
|
|
return self.result
|
||
|
|
|
||
|
|
def activate_device(activation_key):
|
||
|
|
try:
|
||
|
|
import platform
|
||
|
|
response = requests.post(
|
||
|
|
f"{API_URL}/devices/activate",
|
||
|
|
json={
|
||
|
|
'activation_key': activation_key,
|
||
|
|
'device_name': os.environ.get('COMPUTERNAME', 'Unknown'),
|
||
|
|
'hostname': os.environ.get('COMPUTERNAME', 'Unknown'),
|
||
|
|
'username': os.environ.get('USERNAME', 'Unknown')
|
||
|
|
},
|
||
|
|
timeout=10
|
||
|
|
)
|
||
|
|
result = response.json()
|
||
|
|
if result.get('success') and 'device_id' in result:
|
||
|
|
return {'success': True, 'device_id': result['device_id']}
|
||
|
|
return result
|
||
|
|
except Exception as e:
|
||
|
|
return {'success': False, 'message': str(e)}
|
||
|
|
|
||
|
|
def get_chrome_history():
|
||
|
|
"""Captura histórico recente do Chrome"""
|
||
|
|
try:
|
||
|
|
username = os.environ.get('USERNAME')
|
||
|
|
history_db = Path(f"C:/Users/{username}/AppData/Local/Google/Chrome/User Data/Default/History")
|
||
|
|
|
||
|
|
if not history_db.exists():
|
||
|
|
return []
|
||
|
|
|
||
|
|
# Copiar database porque Chrome mantém lock
|
||
|
|
temp_db = Path(os.getenv('TEMP')) / 'chrome_history_temp.db'
|
||
|
|
try:
|
||
|
|
shutil.copy2(history_db, temp_db)
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao copiar histórico do Chrome: {e}")
|
||
|
|
return []
|
||
|
|
|
||
|
|
conn = sqlite3.connect(str(temp_db))
|
||
|
|
cursor = conn.cursor()
|
||
|
|
|
||
|
|
# Pegar URLs dos últimos 2 minutos
|
||
|
|
try:
|
||
|
|
cursor.execute("""
|
||
|
|
SELECT url, title, last_visit_time
|
||
|
|
FROM urls
|
||
|
|
WHERE last_visit_time > (strftime('%s','now') - 120) * 1000000 + 11644473600000000
|
||
|
|
ORDER BY last_visit_time DESC
|
||
|
|
LIMIT 20
|
||
|
|
""")
|
||
|
|
results = cursor.fetchall()
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao ler histórico do Chrome: {e}")
|
||
|
|
results = []
|
||
|
|
finally:
|
||
|
|
conn.close()
|
||
|
|
temp_db.unlink(missing_ok=True)
|
||
|
|
|
||
|
|
urls = []
|
||
|
|
for url, title, timestamp in results:
|
||
|
|
if url and url.strip():
|
||
|
|
urls.append({
|
||
|
|
'url': url,
|
||
|
|
'title': title or url,
|
||
|
|
'browser': 'Chrome'
|
||
|
|
})
|
||
|
|
|
||
|
|
return urls
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao ler Chrome: {e}")
|
||
|
|
return []
|
||
|
|
|
||
|
|
def get_edge_history():
|
||
|
|
"""Captura histórico recente do Edge"""
|
||
|
|
try:
|
||
|
|
username = os.environ.get('USERNAME')
|
||
|
|
history_db = Path(f"C:/Users/{username}/AppData/Local/Microsoft/Edge/User Data/Default/History")
|
||
|
|
|
||
|
|
if not history_db.exists():
|
||
|
|
return []
|
||
|
|
|
||
|
|
temp_db = Path(os.getenv('TEMP')) / 'edge_history_temp.db'
|
||
|
|
try:
|
||
|
|
shutil.copy2(history_db, temp_db)
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao copiar histórico do Edge: {e}")
|
||
|
|
return []
|
||
|
|
|
||
|
|
conn = sqlite3.connect(str(temp_db))
|
||
|
|
cursor = conn.cursor()
|
||
|
|
|
||
|
|
try:
|
||
|
|
cursor.execute("""
|
||
|
|
SELECT url, title, last_visit_time
|
||
|
|
FROM urls
|
||
|
|
WHERE last_visit_time > (strftime('%s','now') - 120) * 1000000 + 11644473600000000
|
||
|
|
ORDER BY last_visit_time DESC
|
||
|
|
LIMIT 20
|
||
|
|
""")
|
||
|
|
results = cursor.fetchall()
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao ler histórico do Edge: {e}")
|
||
|
|
results = []
|
||
|
|
finally:
|
||
|
|
conn.close()
|
||
|
|
temp_db.unlink(missing_ok=True)
|
||
|
|
|
||
|
|
urls = []
|
||
|
|
for url, title, timestamp in results:
|
||
|
|
if url and url.strip():
|
||
|
|
urls.append({
|
||
|
|
'url': url,
|
||
|
|
'title': title or url,
|
||
|
|
'browser': 'Edge'
|
||
|
|
})
|
||
|
|
|
||
|
|
return urls
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao ler Edge: {e}")
|
||
|
|
return []
|
||
|
|
|
||
|
|
def get_firefox_history():
|
||
|
|
"""Captura histórico recente do Firefox"""
|
||
|
|
try:
|
||
|
|
username = os.environ.get('USERNAME')
|
||
|
|
# Firefox pode ter múltiplos perfis
|
||
|
|
firefox_profiles = Path(f"C:/Users/{username}/AppData/Roaming/Mozilla/Firefox/Profiles")
|
||
|
|
|
||
|
|
if not firefox_profiles.exists():
|
||
|
|
return []
|
||
|
|
|
||
|
|
urls = []
|
||
|
|
|
||
|
|
# Procurar em todos os perfis
|
||
|
|
for profile_dir in firefox_profiles.iterdir():
|
||
|
|
if not profile_dir.is_dir():
|
||
|
|
continue
|
||
|
|
|
||
|
|
places_db = profile_dir / 'places.sqlite'
|
||
|
|
if not places_db.exists():
|
||
|
|
continue
|
||
|
|
|
||
|
|
# Copiar database porque Firefox mantém lock
|
||
|
|
temp_db = Path(os.getenv('TEMP')) / f'firefox_history_temp_{profile_dir.name}.db'
|
||
|
|
try:
|
||
|
|
shutil.copy2(places_db, temp_db)
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao copiar histórico do Firefox: {e}")
|
||
|
|
continue
|
||
|
|
|
||
|
|
conn = sqlite3.connect(str(temp_db))
|
||
|
|
cursor = conn.cursor()
|
||
|
|
|
||
|
|
try:
|
||
|
|
# Firefox usa formato diferente: moz_places e moz_historyvisits
|
||
|
|
# last_visit_date está em microssegundos desde epoch
|
||
|
|
two_minutes_ago = (time.time() - 120) * 1000000
|
||
|
|
|
||
|
|
cursor.execute("""
|
||
|
|
SELECT p.url, p.title, MAX(v.visit_date) as last_visit
|
||
|
|
FROM moz_places p
|
||
|
|
JOIN moz_historyvisits v ON p.id = v.place_id
|
||
|
|
WHERE v.visit_date > ?
|
||
|
|
GROUP BY p.id
|
||
|
|
ORDER BY last_visit DESC
|
||
|
|
LIMIT 20
|
||
|
|
""", (two_minutes_ago,))
|
||
|
|
|
||
|
|
results = cursor.fetchall()
|
||
|
|
|
||
|
|
for url, title, timestamp in results:
|
||
|
|
if url and url.strip():
|
||
|
|
urls.append({
|
||
|
|
'url': url,
|
||
|
|
'title': title or url,
|
||
|
|
'browser': 'Firefox'
|
||
|
|
})
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao ler histórico do Firefox: {e}")
|
||
|
|
finally:
|
||
|
|
conn.close()
|
||
|
|
temp_db.unlink(missing_ok=True)
|
||
|
|
|
||
|
|
return urls
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao ler Firefox: {e}")
|
||
|
|
return []
|
||
|
|
|
||
|
|
def send_activity_log(device_id, window_title, application_name, idle_time_seconds=0, urls=None):
|
||
|
|
try:
|
||
|
|
data = {
|
||
|
|
'device_id': device_id,
|
||
|
|
'window_title': window_title,
|
||
|
|
'application_name': application_name,
|
||
|
|
'idle_time_seconds': idle_time_seconds
|
||
|
|
}
|
||
|
|
|
||
|
|
# Adicionar URLs se houver
|
||
|
|
if urls and len(urls) > 0:
|
||
|
|
data['urls'] = urls
|
||
|
|
|
||
|
|
response = requests.post(
|
||
|
|
f"{API_URL}/activity/log",
|
||
|
|
json=data,
|
||
|
|
timeout=10
|
||
|
|
)
|
||
|
|
if response.status_code == 200:
|
||
|
|
print(f"✅ Atividade enviada: {application_name} - {window_title[:50]}")
|
||
|
|
else:
|
||
|
|
print(f"⚠️ Erro ao enviar atividade: {response.status_code}")
|
||
|
|
except Exception as e:
|
||
|
|
print(f"❌ Erro ao enviar log: {e}")
|
||
|
|
|
||
|
|
def send_session_event(device_id, event_type):
|
||
|
|
"""Envia evento de login/logout"""
|
||
|
|
try:
|
||
|
|
response = requests.post(
|
||
|
|
f"{API_URL}/activity/session",
|
||
|
|
json={
|
||
|
|
'device_id': device_id,
|
||
|
|
'event_type': event_type,
|
||
|
|
'username': os.environ.get('USERNAME', 'Unknown')
|
||
|
|
},
|
||
|
|
timeout=10
|
||
|
|
)
|
||
|
|
if response.status_code == 200:
|
||
|
|
print(f"✅ Evento de sessão enviado: {event_type}")
|
||
|
|
else:
|
||
|
|
print(f"⚠️ Erro ao enviar evento: {response.status_code}")
|
||
|
|
except Exception as e:
|
||
|
|
print(f"❌ Erro ao enviar evento de sessão: {e}")
|
||
|
|
|
||
|
|
def get_active_window_info():
|
||
|
|
"""Captura informações da janela ativa - CORRIGIDO"""
|
||
|
|
try:
|
||
|
|
# Obter janela ativa
|
||
|
|
hwnd = win32gui.GetForegroundWindow()
|
||
|
|
|
||
|
|
if hwnd == 0:
|
||
|
|
return None
|
||
|
|
|
||
|
|
# Obter título da janela
|
||
|
|
window_title = win32gui.GetWindowText(hwnd)
|
||
|
|
|
||
|
|
# Obter processo
|
||
|
|
try:
|
||
|
|
_, pid = win32process.GetWindowThreadProcessId(hwnd)
|
||
|
|
process = psutil.Process(pid)
|
||
|
|
process_name = process.name()
|
||
|
|
|
||
|
|
# Garantir que tenha .exe
|
||
|
|
if not process_name.lower().endswith('.exe'):
|
||
|
|
process_name = f"{process_name}.exe"
|
||
|
|
|
||
|
|
# Se não conseguiu obter título, usar nome do processo
|
||
|
|
if not window_title or window_title.strip() == '':
|
||
|
|
window_title = process_name
|
||
|
|
|
||
|
|
# NUNCA retornar "System Idle" ou "[IDLE]" se há uma janela ativa
|
||
|
|
if window_title.lower() in ['system idle', '[idle]', 'idle']:
|
||
|
|
window_title = process_name
|
||
|
|
|
||
|
|
return {
|
||
|
|
'process_name': process_name,
|
||
|
|
'window_title': window_title
|
||
|
|
}
|
||
|
|
except psutil.NoSuchProcess:
|
||
|
|
# Processo não existe mais, mas ainda temos o título
|
||
|
|
if window_title and window_title.strip():
|
||
|
|
return {
|
||
|
|
'process_name': 'Unknown.exe',
|
||
|
|
'window_title': window_title
|
||
|
|
}
|
||
|
|
return None
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao obter processo: {e}")
|
||
|
|
# Se conseguiu o título, usar mesmo sem processo
|
||
|
|
if window_title and window_title.strip():
|
||
|
|
return {
|
||
|
|
'process_name': 'Unknown.exe',
|
||
|
|
'window_title': window_title
|
||
|
|
}
|
||
|
|
return None
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao obter janela ativa: {e}")
|
||
|
|
return None
|
||
|
|
|
||
|
|
def get_idle_time():
|
||
|
|
"""Calcula tempo ocioso em segundos"""
|
||
|
|
try:
|
||
|
|
last_input_info = win32api.GetLastInputInfo()
|
||
|
|
tick_count = win32api.GetTickCount()
|
||
|
|
idle_time = (tick_count - last_input_info) / 1000.0
|
||
|
|
return idle_time
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao calcular tempo ocioso: {e}")
|
||
|
|
return 0
|
||
|
|
|
||
|
|
def monitor_activity():
|
||
|
|
"""Monitora atividade + URLs de navegadores - CORRIGIDO"""
|
||
|
|
config = Config()
|
||
|
|
device_id = config.get('device_id')
|
||
|
|
if not device_id:
|
||
|
|
print("⚠️ Device ID não configurado")
|
||
|
|
return
|
||
|
|
|
||
|
|
# Calcular tempo ocioso
|
||
|
|
idle_time = get_idle_time()
|
||
|
|
idle_time_seconds = int(idle_time)
|
||
|
|
|
||
|
|
# Tentar capturar janela ativa
|
||
|
|
window_info = get_active_window_info()
|
||
|
|
|
||
|
|
# Coletar URLs dos navegadores
|
||
|
|
urls = []
|
||
|
|
try:
|
||
|
|
urls.extend(get_chrome_history())
|
||
|
|
urls.extend(get_edge_history())
|
||
|
|
urls.extend(get_firefox_history())
|
||
|
|
except Exception as e:
|
||
|
|
print(f"Erro ao coletar URLs: {e}")
|
||
|
|
|
||
|
|
# LÓGICA CORRIGIDA: Sempre tentar enviar dados reais
|
||
|
|
if window_info and window_info.get('window_title') and window_info.get('process_name'):
|
||
|
|
# Temos dados reais da janela ativa
|
||
|
|
window_title = window_info['window_title']
|
||
|
|
application_name = window_info['process_name']
|
||
|
|
|
||
|
|
# Só considerar ocioso se realmente estiver ocioso por muito tempo
|
||
|
|
if idle_time_seconds > IDLE_THRESHOLD:
|
||
|
|
# Mesmo ocioso, enviar dados da janela (pode estar minimizada)
|
||
|
|
send_activity_log(
|
||
|
|
device_id,
|
||
|
|
window_title,
|
||
|
|
application_name,
|
||
|
|
idle_time_seconds,
|
||
|
|
urls if urls else None
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
# Usuário ativo, enviar dados reais
|
||
|
|
send_activity_log(
|
||
|
|
device_id,
|
||
|
|
window_title,
|
||
|
|
application_name,
|
||
|
|
0,
|
||
|
|
urls if urls else None
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
# Não conseguiu capturar janela ativa
|
||
|
|
# Só enviar "System Idle" se realmente estiver ocioso
|
||
|
|
if idle_time_seconds > IDLE_THRESHOLD:
|
||
|
|
send_activity_log(
|
||
|
|
device_id,
|
||
|
|
'[IDLE]',
|
||
|
|
'System Idle',
|
||
|
|
idle_time_seconds,
|
||
|
|
None
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
# Tentar novamente na próxima iteração
|
||
|
|
print("⚠️ Não foi possível capturar janela ativa, mas usuário não está ocioso")
|
||
|
|
|
||
|
|
def send_heartbeat(device_id):
|
||
|
|
"""Envia heartbeat para manter dispositivo ativo"""
|
||
|
|
try:
|
||
|
|
response = requests.post(
|
||
|
|
f"{API_URL}/devices/heartbeat",
|
||
|
|
json={'device_id': device_id},
|
||
|
|
timeout=10
|
||
|
|
)
|
||
|
|
if response.status_code == 200:
|
||
|
|
print(f"💓 Heartbeat enviado")
|
||
|
|
except Exception as e:
|
||
|
|
print(f"❌ Erro ao enviar heartbeat: {e}")
|
||
|
|
|
||
|
|
def on_logon():
|
||
|
|
config = Config()
|
||
|
|
device_id = config.get('device_id')
|
||
|
|
if device_id:
|
||
|
|
send_session_event(device_id, 'logon')
|
||
|
|
|
||
|
|
def on_logoff():
|
||
|
|
config = Config()
|
||
|
|
device_id = config.get('device_id')
|
||
|
|
if device_id:
|
||
|
|
send_session_event(device_id, 'logoff')
|
||
|
|
|
||
|
|
def monitor_windows_events():
|
||
|
|
"""Monitora eventos de logon/logoff do Windows Event Log"""
|
||
|
|
config = Config()
|
||
|
|
device_id = config.get('device_id')
|
||
|
|
if not device_id:
|
||
|
|
return
|
||
|
|
|
||
|
|
try:
|
||
|
|
# Abrir o log de segurança do Windows
|
||
|
|
hand = win32evtlog.OpenEventLog(None, "Security")
|
||
|
|
|
||
|
|
# Ler eventos recentes (últimos 100 eventos)
|
||
|
|
flags = win32evtlog.EVENTLOG_BACKWARDS_READ | win32evtlog.EVENTLOG_SEQUENTIAL_READ
|
||
|
|
events, _ = win32evtlog.ReadEventLog(hand, flags, 0, 100)
|
||
|
|
|
||
|
|
# IDs de eventos do Windows para logon/logoff
|
||
|
|
# 4624 = Logon bem-sucedido
|
||
|
|
# 4634 = Logoff bem-sucedido
|
||
|
|
# 4647 = Logoff iniciado pelo usuário
|
||
|
|
# 4625 = Falha no logon (não vamos usar)
|
||
|
|
|
||
|
|
logon_event_ids = [4624]
|
||
|
|
logoff_event_ids = [4634, 4647]
|
||
|
|
|
||
|
|
last_checked_time = config.get('last_event_check_time', 0)
|
||
|
|
current_time = time.time()
|
||
|
|
new_events_found = False
|
||
|
|
|
||
|
|
for event in events:
|
||
|
|
try:
|
||
|
|
event_id = event.EventID
|
||
|
|
event_time = event.TimeGenerated.timestamp()
|
||
|
|
|
||
|
|
# Só processar eventos novos (desde a última verificação)
|
||
|
|
if event_time <= last_checked_time:
|
||
|
|
continue
|
||
|
|
|
||
|
|
# Verificar se é evento de logon
|
||
|
|
if event_id in logon_event_ids:
|
||
|
|
username = None
|
||
|
|
# Tentar extrair username do evento
|
||
|
|
try:
|
||
|
|
event_strings = win32evtlogutil.SafeFormatMessage(event, "Security")
|
||
|
|
# Procurar por padrões comuns no evento
|
||
|
|
if 'Account Name:' in event_strings or 'Subject:' in event_strings:
|
||
|
|
# Extrair username (simplificado)
|
||
|
|
for line in event_strings.split('\n'):
|
||
|
|
if 'Account Name:' in line or 'Account:' in line:
|
||
|
|
parts = line.split(':')
|
||
|
|
if len(parts) > 1:
|
||
|
|
username = parts[-1].strip()
|
||
|
|
break
|
||
|
|
except:
|
||
|
|
pass
|
||
|
|
|
||
|
|
if not username:
|
||
|
|
username = os.environ.get('USERNAME', 'Unknown')
|
||
|
|
|
||
|
|
print(f"🔐 Evento de LOGON detectado: {username}")
|
||
|
|
send_session_event(device_id, 'logon')
|
||
|
|
new_events_found = True
|
||
|
|
|
||
|
|
# Verificar se é evento de logoff
|
||
|
|
elif event_id in logoff_event_ids:
|
||
|
|
username = os.environ.get('USERNAME', 'Unknown')
|
||
|
|
print(f"🔐 Evento de LOGOFF detectado: {username}")
|
||
|
|
send_session_event(device_id, 'logoff')
|
||
|
|
new_events_found = True
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
# Ignorar erros em eventos individuais
|
||
|
|
continue
|
||
|
|
|
||
|
|
win32evtlog.CloseEventLog(hand)
|
||
|
|
|
||
|
|
# Atualizar timestamp da última verificação
|
||
|
|
if new_events_found or current_time - last_checked_time > 60:
|
||
|
|
config.set('last_event_check_time', current_time)
|
||
|
|
|
||
|
|
except Exception as e:
|
||
|
|
# Se não conseguir ler eventos (pode ser falta de permissão), usar método alternativo
|
||
|
|
print(f"⚠️ Não foi possível ler Event Log: {e}")
|
||
|
|
print(f"⚠️ Tentando método alternativo...")
|
||
|
|
|
||
|
|
# Método alternativo: verificar mudanças na sessão atual
|
||
|
|
try:
|
||
|
|
current_session_id = win32api.GetCurrentProcess()
|
||
|
|
last_session_id = config.get('last_session_id')
|
||
|
|
|
||
|
|
if last_session_id != str(current_session_id):
|
||
|
|
if last_session_id:
|
||
|
|
# Sessão mudou, pode ser logon
|
||
|
|
print(f"🔐 Possível evento de LOGON detectado (mudança de sessão)")
|
||
|
|
send_session_event(device_id, 'logon')
|
||
|
|
config.set('last_session_id', str(current_session_id))
|
||
|
|
except:
|
||
|
|
pass
|
||
|
|
|
||
|
|
def install_to_program_files():
|
||
|
|
"""Instala o executável em Program Files"""
|
||
|
|
try:
|
||
|
|
# Verificar se já está instalado
|
||
|
|
current_exe = Path(sys.executable)
|
||
|
|
if INSTALL_EXE.exists() and current_exe.exists():
|
||
|
|
try:
|
||
|
|
if INSTALL_EXE.samefile(current_exe):
|
||
|
|
print(f"✅ Já instalado em: {INSTALL_DIR}")
|
||
|
|
return True
|
||
|
|
except (OSError, ValueError):
|
||
|
|
# Arquivos diferentes ou erro ao comparar
|
||
|
|
pass
|
||
|
|
|
||
|
|
# Criar diretório se não existir
|
||
|
|
INSTALL_DIR.mkdir(parents=True, exist_ok=True)
|
||
|
|
|
||
|
|
# Copiar executável atual para Program Files
|
||
|
|
current_exe = Path(sys.executable)
|
||
|
|
if current_exe.exists():
|
||
|
|
print(f"📦 Instalando em: {INSTALL_DIR}")
|
||
|
|
shutil.copy2(current_exe, INSTALL_EXE)
|
||
|
|
print(f"✅ Instalado com sucesso: {INSTALL_EXE}")
|
||
|
|
return True
|
||
|
|
else:
|
||
|
|
print(f"⚠️ Executável atual não encontrado: {current_exe}")
|
||
|
|
return False
|
||
|
|
except PermissionError:
|
||
|
|
print(f"❌ Erro de permissão ao instalar. Execute como Administrador.")
|
||
|
|
return False
|
||
|
|
except Exception as e:
|
||
|
|
print(f"❌ Erro ao instalar: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
def set_startup_registry():
|
||
|
|
"""Configura para iniciar automaticamente com o Windows"""
|
||
|
|
try:
|
||
|
|
# Caminho do executável instalado COM parâmetro --silent
|
||
|
|
exe_path = f'"{str(INSTALL_EXE)}" --silent'
|
||
|
|
|
||
|
|
# Abrir chave do registro para inicialização automática
|
||
|
|
key = winreg.OpenKey(
|
||
|
|
winreg.HKEY_CURRENT_USER,
|
||
|
|
r"Software\Microsoft\Windows\CurrentVersion\Run",
|
||
|
|
0,
|
||
|
|
winreg.KEY_SET_VALUE
|
||
|
|
)
|
||
|
|
|
||
|
|
# Adicionar entrada
|
||
|
|
winreg.SetValueEx(key, "NoIdle", 0, winreg.REG_SZ, exe_path)
|
||
|
|
winreg.CloseKey(key)
|
||
|
|
|
||
|
|
print(f"✅ Configurado para iniciar automaticamente no boot")
|
||
|
|
|
||
|
|
# BACKUP: Criar Task Scheduler também (mais confiável)
|
||
|
|
try:
|
||
|
|
create_task_scheduler()
|
||
|
|
except Exception as e:
|
||
|
|
print(f"⚠️ Task Scheduler não configurado: {e}")
|
||
|
|
|
||
|
|
return True
|
||
|
|
except PermissionError:
|
||
|
|
print(f"⚠️ Erro de permissão ao configurar inicialização automática")
|
||
|
|
return False
|
||
|
|
except Exception as e:
|
||
|
|
print(f"❌ Erro ao configurar inicialização: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
def create_task_scheduler():
|
||
|
|
"""Cria uma tarefa no Task Scheduler para maior confiabilidade"""
|
||
|
|
try:
|
||
|
|
task_name = "NoIdle_Monitor"
|
||
|
|
exe_path = str(INSTALL_EXE)
|
||
|
|
|
||
|
|
# Comando PowerShell para criar tarefa agendada
|
||
|
|
ps_command = f'''
|
||
|
|
$action = New-ScheduledTaskAction -Execute '"{exe_path}"' -Argument '--silent'
|
||
|
|
$trigger = New-ScheduledTaskTrigger -AtLogOn -User $env:USERNAME
|
||
|
|
$principal = New-ScheduledTaskPrincipal -UserId $env:USERNAME -LogonType Interactive -RunLevel Limited
|
||
|
|
$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1)
|
||
|
|
Register-ScheduledTask -TaskName "{task_name}" -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force
|
||
|
|
'''
|
||
|
|
|
||
|
|
# Executar PowerShell
|
||
|
|
result = subprocess.run(
|
||
|
|
['powershell', '-Command', ps_command],
|
||
|
|
capture_output=True,
|
||
|
|
text=True,
|
||
|
|
timeout=30
|
||
|
|
)
|
||
|
|
|
||
|
|
if result.returncode == 0:
|
||
|
|
print(f"✅ Task Scheduler configurado: {task_name}")
|
||
|
|
return True
|
||
|
|
else:
|
||
|
|
print(f"⚠️ Erro ao criar Task Scheduler: {result.stderr}")
|
||
|
|
return False
|
||
|
|
except Exception as e:
|
||
|
|
print(f"⚠️ Não foi possível criar Task Scheduler: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
def check_and_install():
|
||
|
|
"""Verifica se precisa instalar e configura inicialização automática"""
|
||
|
|
config = Config()
|
||
|
|
|
||
|
|
# Verificar se já foi instalado
|
||
|
|
if config.get('installed', False):
|
||
|
|
# Verificar se o executável ainda existe
|
||
|
|
if INSTALL_EXE.exists():
|
||
|
|
return True
|
||
|
|
else:
|
||
|
|
# Reinstalar se foi removido
|
||
|
|
config.set('installed', False)
|
||
|
|
|
||
|
|
# Tentar instalar
|
||
|
|
if install_to_program_files():
|
||
|
|
# Configurar inicialização automática
|
||
|
|
set_startup_registry()
|
||
|
|
config.set('installed', True)
|
||
|
|
|
||
|
|
# Se não estamos rodando do Program Files, iniciar a versão instalada
|
||
|
|
current_exe = Path(sys.executable)
|
||
|
|
if INSTALL_EXE.exists() and current_exe.exists():
|
||
|
|
try:
|
||
|
|
if not INSTALL_EXE.samefile(current_exe):
|
||
|
|
print(f"🔄 Reiniciando versão instalada...")
|
||
|
|
try:
|
||
|
|
import subprocess
|
||
|
|
subprocess.Popen([str(INSTALL_EXE)], shell=False)
|
||
|
|
sys.exit(0)
|
||
|
|
except Exception as e:
|
||
|
|
print(f"⚠️ Erro ao iniciar versão instalada: {e}")
|
||
|
|
except (OSError, ValueError):
|
||
|
|
# Erro ao comparar, assumir que são diferentes
|
||
|
|
if INSTALL_EXE.exists():
|
||
|
|
print(f"🔄 Reiniciando versão instalada...")
|
||
|
|
try:
|
||
|
|
import subprocess
|
||
|
|
subprocess.Popen([str(INSTALL_EXE)], shell=False)
|
||
|
|
sys.exit(0)
|
||
|
|
except Exception as e:
|
||
|
|
print(f"⚠️ Erro ao iniciar versão instalada: {e}")
|
||
|
|
|
||
|
|
return True
|
||
|
|
else:
|
||
|
|
print(f"⚠️ Instalação falhou, continuando da localização atual")
|
||
|
|
return False
|
||
|
|
|
||
|
|
def create_image():
|
||
|
|
img = Image.new('RGB', (64, 64), color='#2563eb')
|
||
|
|
draw = ImageDraw.Draw(img)
|
||
|
|
draw.rectangle([16, 16, 48, 48], fill='white')
|
||
|
|
return img
|
||
|
|
|
||
|
|
def on_quit(icon, item):
|
||
|
|
on_logoff()
|
||
|
|
icon.stop()
|
||
|
|
sys.exit(0)
|
||
|
|
|
||
|
|
def create_tray_icon():
|
||
|
|
menu = pystray.Menu(pystray.MenuItem('Sair', on_quit))
|
||
|
|
return pystray.Icon("NoIdle", create_image(), "NoIdle - Monitoramento Ativo", menu)
|
||
|
|
|
||
|
|
def main():
|
||
|
|
# Parse argumentos de linha de comando
|
||
|
|
parser = argparse.ArgumentParser(description='NoIdle - Monitoramento de Atividade')
|
||
|
|
parser.add_argument('--silent', action='store_true', help='Executar em modo silencioso (sem janela de ativação)')
|
||
|
|
parser.add_argument('--minimized', action='store_true', help='Iniciar minimizado')
|
||
|
|
args = parser.parse_args()
|
||
|
|
|
||
|
|
silent_mode = args.silent or args.minimized
|
||
|
|
|
||
|
|
# Verificar e instalar em Program Files + configurar inicialização automática
|
||
|
|
check_and_install()
|
||
|
|
|
||
|
|
config = Config()
|
||
|
|
|
||
|
|
# Se não tem device_id e não está em modo silencioso, mostrar janela de ativação
|
||
|
|
if not config.has('device_id'):
|
||
|
|
if silent_mode:
|
||
|
|
# Modo silencioso mas não configurado - sair e aguardar configuração manual
|
||
|
|
print("⚠️ Dispositivo não ativado. Execute sem --silent para ativar.")
|
||
|
|
sys.exit(0)
|
||
|
|
else:
|
||
|
|
result = ActivationWindow().show()
|
||
|
|
if not result or not result.get('success'):
|
||
|
|
print("❌ Ativação cancelada ou falhou")
|
||
|
|
sys.exit(1)
|
||
|
|
device_id = result.get('device_id')
|
||
|
|
if device_id:
|
||
|
|
config.set('device_id', device_id)
|
||
|
|
else:
|
||
|
|
print("❌ Device ID não recebido")
|
||
|
|
sys.exit(1)
|
||
|
|
|
||
|
|
device_id = config.get('device_id')
|
||
|
|
print(f"✅ NoIdle iniciado - Device ID: {device_id}")
|
||
|
|
|
||
|
|
on_logon()
|
||
|
|
atexit.register(on_logoff)
|
||
|
|
|
||
|
|
# Monitorar atividade a cada 10 segundos
|
||
|
|
schedule.every(MONITOR_INTERVAL).seconds.do(monitor_activity)
|
||
|
|
|
||
|
|
# Enviar heartbeat a cada 30 segundos
|
||
|
|
schedule.every(30).seconds.do(lambda: send_heartbeat(device_id))
|
||
|
|
|
||
|
|
# Monitorar eventos de logon/logoff do Windows a cada 60 segundos
|
||
|
|
schedule.every(60).seconds.do(monitor_windows_events)
|
||
|
|
|
||
|
|
# Primeira execução imediata
|
||
|
|
monitor_activity()
|
||
|
|
send_heartbeat(device_id)
|
||
|
|
|
||
|
|
def run_schedule():
|
||
|
|
while True:
|
||
|
|
schedule.run_pending()
|
||
|
|
time.sleep(1)
|
||
|
|
|
||
|
|
Thread(target=run_schedule, daemon=True).start()
|
||
|
|
|
||
|
|
# Se estiver em modo silencioso, não mostrar tray icon (apenas rodar em background)
|
||
|
|
if silent_mode:
|
||
|
|
print("🔇 Modo silencioso ativado - Rodando em segundo plano")
|
||
|
|
# Manter o programa rodando sem tray icon
|
||
|
|
try:
|
||
|
|
while True:
|
||
|
|
time.sleep(60)
|
||
|
|
except KeyboardInterrupt:
|
||
|
|
print("❌ Encerrando...")
|
||
|
|
on_logoff()
|
||
|
|
sys.exit(0)
|
||
|
|
else:
|
||
|
|
create_tray_icon().run()
|
||
|
|
|
||
|
|
if __name__ == '__main__':
|
||
|
|
main()
|
||
|
|
|