forensic-cli 1.2.5__py3-none-any.whl

cli/commands/browser.py

@@ -0,0 +1,220 @@
+import os
+import json
+import typer
+from pathlib import Path
+
+from core.browser.browser_history import extract_google_edge_history, extract_firefox_history
+from core.browser.downloads_history import extract_downloads_history
+from core.browser.fav_screen import carregar_json, extrair_urls_validas, processar_urls
+from core.browser.unusual_patterns import processar_historico_da_pasta
+from core.browser.logins import collect_chrome_logins, collect_edge_logins
+from core.browser.common_words import extract_words
+
+browser_app = typer.Typer()
+
+@browser_app.command("history")
+def history(
+    chrome: bool = typer.Option(False, "--chrome", help="Extrair histórico do Chrome"),
+    edge: bool = typer.Option(False, "--edge", help="Extrair histórico do Edge"),
+    firefox: bool = typer.Option(False, "--firefox", help="Extrair histórico do Firefox"),
+    all: bool = typer.Option(False, "--all", help="Extrair histórico de todos navegadores")
+):
+    usuario = os.getlogin()
+    home = str(Path.home())
+
+    if all or chrome:
+        caminho_chrome = os.path.join(home, "AppData", "Local", "Google", "Chrome", "User Data", "Default", "History")
+        if os.path.exists(caminho_chrome):
+            typer.echo("[*] Extraindo histórico do Chrome...")
+            extract_google_edge_history(caminho_chrome, "Chrome", usuario)
+        else:
+            typer.echo("[!] Chrome não encontrado.")
+
+    if all or edge:
+        caminho_edge = os.path.join(home, "AppData", "Local", "Microsoft", "Edge", "User Data", "Default", "History")
+        if os.path.exists(caminho_edge):
+            typer.echo("[*] Extraindo histórico do Edge...")
+            extract_google_edge_history(caminho_edge, "Edge", usuario)
+        else:
+            typer.echo("[!] Edge não encontrado.")
+
+    if all or firefox:
+        caminho_firefox_perfis = os.path.join(home, "AppData", "Roaming", "Mozilla", "Firefox", "Profiles")
+        if os.path.exists(caminho_firefox_perfis):
+            for perfil in os.listdir(caminho_firefox_perfis):
+                caminho_sqlite = os.path.join(caminho_firefox_perfis, perfil, "places.sqlite")
+                if os.path.exists(caminho_sqlite):
+                    typer.echo(f"[*] Extraindo histórico do Firefox ({perfil})...")
+                    extract_firefox_history(caminho_sqlite, usuario)
+                    break
+            else:
+                typer.echo("[!] places.sqlite do Firefox não encontrado.")
+        else:
+            typer.echo("[!] Perfis do Firefox não encontrados.")
+
+@browser_app.command("downloads")
+def downloads(
+    output_dir: Path = typer.Option(
+        Path("artefatos/downloads"),
+        "--output-dir",
+        "-o",
+        help="Diretório de saída para salvar os artefatos dos downloads.",
+        resolve_path=True
+    ),
+    chrome: bool = typer.Option(False, "--chrome", help="Extrair downloads do Chrome"),
+    edge: bool = typer.Option(False, "--edge", help="Extrair downloads do Edge"),
+    firefox: bool = typer.Option(False, "--firefox", help="Extrair downloads do Firefox"),
+    all: bool = typer.Option(False, "--all", help="Extrair downloads de todos os navegadores")
+):
+    output_dir.mkdir(parents=True, exist_ok=True)
+    typer.echo(f"📂 Salvando artefatos em: {output_dir}")
+
+    navegadores = {
+        "chrome": chrome,
+        "edge": edge,
+        "firefox": firefox
+    }
+
+    if all or not any(navegadores.values()):
+        navegadores = {k: True for k in navegadores}
+
+    extract_downloads_history(
+        output_dir=output_dir,
+        chrome=navegadores["chrome"],
+        edge=navegadores["edge"],
+        firefox=navegadores["firefox"]
+    )
+
+    typer.echo("✅ Extração concluída!")
+
+@browser_app.command("favscreen")
+def favscreen(
+    input_dir: Path = typer.Option(
+        Path("artefatos/historico"),
+        "--input-dir",
+        "-i",
+        help="Diretório contendo os JSONs de histórico para processar.",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True
+    ),
+    output_dir: Path = typer.Option(
+        Path("artefatos/favscreen"),
+        "--output-dir",
+        "-o",
+        help="Diretório de saída para salvar favicons e prints.",
+        exists=False,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True
+    )
+):
+    try:
+        arquivos_json = [input_dir / arquivo for arquivo in os.listdir(input_dir) if arquivo.endswith(".json")]
+        todas_urls = []
+
+        for caminho in arquivos_json:
+            print(f"[INFO] Carregando: {caminho}")
+            dados = carregar_json(caminho)
+            urls = extrair_urls_validas(dados)
+            todas_urls.extend(urls)
+
+        if todas_urls:
+            todas_urls = list(set(todas_urls))
+            processar_urls(todas_urls, output_dir)
+            typer.echo("\n✅ Processamento finalizado.")
+        else:
+            typer.echo("\n⚠️ Nenhum arquivo JSON válido encontrado ou sem URLs úteis.")
+
+    except Exception as erro:
+        typer.echo(f"\n❌ Erro geral: {erro}")
+
+@browser_app.command("logins")
+def logins(
+    chrome: bool = typer.Option(False, "--chrome", help="Extrair logins do Chrome"),
+    edge: bool = typer.Option(False, "--edge", help="Extrair logins do Edge"),
+    all: bool = typer.Option(False, "--all", help="Extrair logins de todos os navegadores"),
+    output_dir: Path = typer.Option(
+        Path("artefatos/logins"),
+        "--output-dir",
+        "-o",
+        help="Diretório para salvar os logins em JSON",
+        resolve_path=True
+    )
+):
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    navegadores = {
+        "chrome": chrome,
+        "edge": edge
+    }
+
+    if all or not any(navegadores.values()):
+        navegadores = {k: True for k in navegadores}
+
+    if navegadores["chrome"]:
+        typer.echo("[*] Extraindo logins do Chrome...")
+        data_chrome = collect_chrome_logins()
+        arquivo_chrome = output_dir / "chrome_logins.json"
+        with open(arquivo_chrome, "w", encoding="utf-8") as f:
+            json.dump(data_chrome, f, indent=2, ensure_ascii=False)
+        typer.echo(f"✅ Logins do Chrome salvos em: {arquivo_chrome}")
+
+    if navegadores["edge"]:
+        typer.echo("[*] Extraindo logins do Edge...")
+        data_edge = collect_edge_logins()
+        arquivo_edge = output_dir / "edge_logins.json"
+        with open(arquivo_edge, "w", encoding="utf-8") as f:
+            json.dump(data_edge, f, indent=2, ensure_ascii=False)
+        typer.echo(f"✅ Logins do Edge salvos em: {arquivo_edge}")
+
+@browser_app.command("patterns")
+def patterns(
+    input_dir: Path = typer.Option(
+        Path("artefatos/historico"),
+        "--input-dir",
+        "-i",
+        help="Diretório contendo os JSONs de histórico para analisar padrões.",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True
+    ),
+    output_dir: Path = typer.Option(
+        Path("artefatos/patterns_output"),
+        "--output-dir",
+        "-o",
+        help="Diretório para salvar gráficos e relatórios.",
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True
+    )
+):
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        typer.echo(f"[*] Processando arquivos em: {input_dir}")
+        typer.echo(f"[*] Salvando resultados em: {output_dir}")
+
+        processar_historico_da_pasta(str(input_dir), str(output_dir))
+
+        typer.echo("\n✅ Processamento concluído.")
+
+    except Exception as erro:
+        typer.echo(f"\n❌ Erro ao executar patterns: {erro}")
+
+@browser_app.command("words")
+def words(
+    chrome: bool = typer.Option(True, "--chrome", help="Extrair palavras mais pesquisadas do Chrome"),
+    output_dir: Path = typer.Option(
+        Path("artefatos/words_output"),
+        "--output-dir",
+        "-o",
+        help="Diretório para salvar o JSON com palavras mais pesquisadas",
+        resolve_path=True
+    )
+):
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    extract_words(chrome=chrome, output_dir=output_dir)

cli/commands/describe.py

@@ -0,0 +1,54 @@
+import typer
+from rich import print
+
+describe_app = typer.Typer()
+
+@describe_app.command("func")
+def describe(
+    func: str = typer.Argument(..., help="Digite o nome da função que você deseja entender")
+):
+    docs = {
+        "map": {
+            "description": "Retorna informações detalhadas de cada host da rede.",
+            "example_return": [{
+                "host": "192.168.1.1",
+                "hostname": "router",
+                "mac": "AA:BB:CC:DD:EE:FF",
+                "vendor": "Cisco",
+                "open_ports": [22, 80],
+                "os_info": "Linux"
+            }]
+        },
+        "sweep": {
+            "description": "Faz um ping sweep na rede e retorna os hosts ativos.",
+            "example_return": ["192.168.1.1", "192.168.1.3"]
+        },
+        "scan": {
+            "description": "Verifica quais portas estão abertas, fechadas e filtradas.",
+            "example_return": [{
+                "port": 53,
+                "protocol": "UDP",
+                "status": "open|filtered",
+                "banner": "sem resposta",
+                "alert": "DNS"
+            }]
+        },
+        "fingerprinting": {
+            "description": "Detecta o sistema operacional, tipo de host, serviços e possíveis alertas de vulnerabilidade de um host.",
+            "example_return": {
+                "os": "Windows",
+                "host_type": "Servidor",
+                "services": ["SMB", "Web HTTP", "MySQL"],
+                "alerts": ["SMB vulnerável (Samba 3.0)"]
+            }
+        }
+    }
+
+    if func in docs:
+        info = docs[func]
+        print(f"[bold blue]Nome da Função:[/bold blue] {func}")
+        print(f"[bold blue]Descrição:[/bold blue] {info['description']}")
+        print("[bold blue]Exemplo de Retorno:[/bold blue]")
+        print(info['example_return'])
+    else:
+        typer.echo(f"Função {func} não encontrada.")

cli/commands/email.py

@@ -0,0 +1,3 @@
+import typer
+
+email_app = typer.Typer()

cli/commands/network.py

@@ -0,0 +1,126 @@
+import typer
+from rich import print
+from rich.text import Text
+
+from core.network.network_map import run as run_network_map
+from core.network.port_scanner import scan_host
+from core.network.ping_sweep import parse_network, ping_host
+from core.network.fingerprinting import detect_os
+from core.network.traceroute import traceroute_host
+from core.network.arp_scan import arp_scan
+from core.network.dns_recon import dns_recon
+from core.network.ip_info import ip_info_lookup
+from core.network.smb_scan import smb_scan
+from core.network.snmp_scan import snmp_scan
+
+network_app = typer.Typer(help="Conjunto de ferramentas para análise e exploração de redes")
+
+@network_app.command("map", help="Mapeia dispositivos ativos na rede e salva os resultados em JSON/CSV")
+def map(
+    network: str = typer.Option(..., help="Range de IPs da rede. Exemplo: 192.168.1.1-254"),
+    output_dir: str = typer.Option("../../output", help="Diretório para salvar os resultados"),
+):
+    result = run_network_map(network, output_dir)
+    typer.echo(f"Resultados salvos em: {result['json_file']} e {result['csv_file']}")
+
+@network_app.command("scan", help="Realiza um scan de portas em um host específico")
+def scan(
+    ip: str = typer.Option(..., help="Endereço IP do host. Exemplo: 192.168.0.10")
+):
+    result = scan_host(ip)
+    print(result)
+
+@network_app.command("sweep", help="Verifica hosts ativos em um range de IPs via ping")
+def sweep(
+    network: str = typer.Option(..., help="Range de IPs da rede. Exemplo: 192.168.1.1-254"),
+):
+    ips = parse_network(network)
+    alive_hosts = []
+
+    with typer.progressbar(ips, label="Scanning network") as progress:
+        for ip in progress:
+            if ping_host(ip):
+                alive_hosts.append(ip)
+
+    typer.echo(f"Hosts ativos: {alive_hosts}")
+
+@network_app.command("fingerprinting", help="Detecta SO, serviços e portas abertas em um host")
+def fingerprinting(
+    ip: str = typer.Option(..., help="Endereço IP do host. Exemplo: 192.168.0.10")
+):
+    typer.echo(f"[+] Verificando se {ip} está ativo...")
+    if not ping_host(ip):
+        typer.echo(f"[-] Host {ip} inatingível. Ping falhou.")
+        return
+
+    typer.echo(f"[+] Escaneando portas de {ip}...")
+    ports = scan_host(ip)
+
+    typer.echo(f"[+] Detectando SO, serviços e alertas...")
+    result = detect_os(ip, ports=ports)
+
+    print(result)
+
+@network_app.command("traceroute", help="Exibe o caminho (hops) até um domínio ou host")
+def traceroute(
+    domain: str = typer.Option(..., help="Informe um domínio ou hostname. Exemplo: google.com")
+):
+    typer.echo(f"[+] Iniciando traceroute para {domain}...")
+
+    hops = traceroute_host(domain)
+
+    with typer.progressbar(hops, label="Traceroute") as progress:
+        for h in hops:
+            rtt = h["rtt"]
+            hop_text = Text(f" Hop {h['hop']}: {h.get('domain', h['ip'])} - RTT: ")
+
+            if rtt is None:
+                hop_text.append("inacessível", style="grey50")
+            elif rtt < 10:
+                hop_text.append(f"{rtt} ms", style="green")
+            elif rtt < 50:
+                hop_text.append(f"{rtt} ms", style="yellow")
+            else:
+                hop_text.append(f"{rtt} ms", style="red")
+
+            print(hop_text)
+            progress.update(1)
+
+@network_app.command("arpscan", help="Realiza varredura ARP para identificar dispositivos na rede local")
+def arp(
+    network: str = typer.Option(..., help="Range de IPs da rede. Exemplo: 192.168.1.1-254"),
+):
+    result = arp_scan(network)
+    print(result)
+
+@network_app.command("dnscan", help="Realiza reconhecimento DNS em um domínio ou IP")
+def dns(
+    target: str = typer.Option(..., help="Informe o domínio ou IP alvo. Exemplo: exemplo.com ou 8.8.8.8"),
+    output_dir: str = typer.Option(None, help="Diretório para salvar os resultados (JSON e CSV)"),
+    with_subdomains: bool = typer.Option(False, help="Tentar descobrir subdomínios comuns do domínio informado"),
+):
+    result = dns_recon([target], output_dir=output_dir, with_subdomains=with_subdomains)
+
+    typer.echo("[+] Resultados encontrados:")
+    print(result)
+
+@network_app.command("ipinfo", help="Obtém informações detalhadas sobre um IP ou hostname")
+def ip_info(
+    ip: str = typer.Option(..., help="IP ou hostname do destino. Exemplo: 8.8.8.8"),
+):
+    result = ip_info_lookup(ip)
+    print(result)
+
+@network_app.command("smbscan", help="Verifica serviços SMB ativos em um host")
+def smb(
+    ip: str = typer.Option(..., help="IP ou hostname do destino. Exemplo: 192.168.0.10"),
+):
+    result = smb_scan([ip])
+    print(result)
+
+@network_app.command("snmpscan", help="Executa varredura SNMP para identificar informações de dispositivos")
+def snmp(
+    ip: str = typer.Option(..., help="IP ou hostname do destino. Exemplo: 192.168.0.10"),
+):
+    result = snmp_scan(ip)
+    print(result)

cli/commands/utils.py

@@ -0,0 +1,3 @@
+import typer
+
+utils_app = typer.Typer()

cli/main.py

@@ -0,0 +1,18 @@
+import typer
+
+from cli.commands.network import network_app
+from cli.commands.browser import browser_app
+from cli.commands.email import email_app
+from cli.commands.utils import utils_app
+from cli.commands.describe import describe_app
+
+app = typer.Typer()
+
+app.add_typer(network_app, name="network", help="Ferramentas para análise e operações em redes")
+app.add_typer(browser_app, name="browser", help="Ferramentas para coleta e análise de dados de navegadores")
+app.add_typer(email_app, name="email", help="Ferramentas para análise e manipulação de dados de e-mail")
+app.add_typer(utils_app, name="utils", help="Funções utilitárias de apoio ao sistema")
+app.add_typer(describe_app, name="describe", help="Explicações detalhadas sobre as funcionalidades disponíveis")
+
+if __name__ == "__main__":
+    app()

core/browser/browser_history.py

@@ -0,0 +1,156 @@
+import os
+import sqlite3
+import time
+import json
+import shutil
+from pathlib import Path
+
+def timestamp_chrome(microsegundos):
+    return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(microsegundos / 1000000 - 11644473600))
+
+def timestamp_firefox(microsegundos):
+    return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(microsegundos / 1000000))
+
+def save_as_json(dados, navegador, usuario):
+    os.makedirs("artefatos/historico", exist_ok=True)
+    nome_arquivo = f"artefatos/historico/Historico_{navegador}_{usuario}.json"
+    with open(nome_arquivo, "w", encoding="utf-8") as f:
+        json.dump(dados, f, indent=4, ensure_ascii=False)
+    print(f"[OK] Histórico salvo: {nome_arquivo}")
+
+def copy_database(origem):
+    destino = f"temp_{os.path.basename(origem)}"
+    shutil.copy2(origem, destino)
+    return destino
+
+def extract_google_edge_history(caminho_banco, navegador, usuario):
+    caminho_temp = copy_database(caminho_banco)
+    try:
+        conn = sqlite3.connect(caminho_temp)
+        cursor = conn.cursor()
+
+        cursor.execute("""
+            SELECT url, title, visit_count, last_visit_time
+            FROM urls
+            ORDER BY last_visit_time DESC;
+        """)
+        rows = cursor.fetchall()
+
+        historico_completo = []
+        for url, titulo, visitas, ultimo_acesso in rows:
+            historico_completo.append({
+                "url": url,
+                "titulo": titulo,
+                "visitas": visitas,
+                "ultimo_acesso": timestamp_chrome(ultimo_acesso) if ultimo_acesso else "N/A"
+            })
+
+        ultimas_10 = historico_completo[:10]
+
+        cursor.execute("""
+            SELECT url, SUM(visit_count) as total_visitas
+            FROM urls
+            GROUP BY url
+            ORDER BY total_visitas DESC
+            LIMIT 5;
+        """)
+        top_5 = [{"url": u, "total_visitas": v} for u, v in cursor.fetchall()]
+
+        dados = {
+            "usuario": usuario,
+            "navegador": navegador,
+            "ultimas_10_urls": ultimas_10,
+            "top_5_sites": top_5,
+            "historico_completo": historico_completo
+        }
+
+        save_as_json(dados, navegador, usuario)
+
+    except Exception as e:
+        print(f"[!] Erro ({navegador}): {e}")
+    finally:
+        conn.close()
+        os.remove(caminho_temp)
+
+def extract_firefox_history(caminho_banco, usuario):
+    caminho_temp = copy_database(caminho_banco)
+    try:
+        conn = sqlite3.connect(caminho_temp)
+        cursor = conn.cursor()
+
+        cursor.execute("""
+            SELECT url, title, visit_count, last_visit_date
+            FROM moz_places
+            ORDER BY last_visit_date DESC;
+        """)
+        rows = cursor.fetchall()
+
+        historico_completo = []
+        for url, titulo, visitas, ultimo_acesso in rows:
+            historico_completo.append({
+                "url": url,
+                "titulo": titulo,
+                "visitas": visitas,
+                "ultimo_acesso": timestamp_firefox(ultimo_acesso) if ultimo_acesso else "N/A"
+            })
+
+        ultimas_10 = historico_completo[:10]
+
+        cursor.execute("""
+            SELECT url, SUM(visit_count) as total_visitas
+            FROM moz_places
+            GROUP BY url
+            ORDER BY total_visitas DESC
+            LIMIT 5;
+        """)
+        top_5 = [{"url": u, "total_visitas": v} for u, v in cursor.fetchall()]
+
+        dados = {
+            "usuario": usuario,
+            "navegador": "Firefox",
+            "ultimas_10_urls": ultimas_10,
+            "top_5_sites": top_5,
+            "historico_completo": historico_completo
+        }
+
+        save_as_json(dados, "Firefox", usuario)
+
+    except Exception as e:
+        print(f"[!] Erro (Firefox): {e}")
+    finally:
+        conn.close()
+        os.remove(caminho_temp)
+
+def locale_database():
+    usuario = os.getlogin()
+    home = str(Path.home())
+
+    caminho_chrome = os.path.join(home, "AppData", "Local", "Google", "Chrome", "User Data", "Default", "History")
+    if os.path.exists(caminho_chrome):
+        print("[*] Extraindo histórico do Chrome...")
+        extract_google_edge_history(caminho_chrome, "Chrome", usuario)
+    else:
+        print("[!] Chrome não encontrado.")
+
+    caminho_edge = os.path.join(home, "AppData", "Local", "Microsoft", "Edge", "User Data", "Default", "History")
+    if os.path.exists(caminho_edge):
+        print("[*] Extraindo histórico do Edge...")
+        extract_google_edge_history(caminho_edge, "Edge", usuario)
+    else:
+        print("[!] Edge não encontrado.")
+
+    caminho_firefox_perfis = os.path.join(home, "AppData", "Roaming", "Mozilla", "Firefox", "Profiles")
+    if os.path.exists(caminho_firefox_perfis):
+        for perfil in os.listdir(caminho_firefox_perfis):
+            caminho_sqlite = os.path.join(caminho_firefox_perfis, perfil, "places.sqlite")
+            if os.path.exists(caminho_sqlite):
+                print(f"[*] Extraindo histórico do Firefox ({perfil})...")
+                extract_firefox_history(caminho_sqlite, usuario)
+                break
+        else:
+            print("[!] places.sqlite do Firefox não encontrado.")
+    else:
+        print("[!] Perfis do Firefox não encontrados.")
+
+if __name__ == "__main__":
+    locale_database()

core/browser/common_words.py

@@ -0,0 +1,60 @@
+# core/browser/words_extractor.py
+import sqlite3
+import shutil
+import tempfile
+import re
+from collections import Counter
+from urllib.parse import unquote
+from pathlib import Path
+import json
+import typer
+
+def extract_words(chrome: bool = True, output_dir: Path = Path("artefatos/words_output")):
+    termos_pesquisa = []
+
+    if chrome:
+        chrome_history_path = Path.home() / "AppData/Local/Google/Chrome/User Data/Default/History"
+        if not chrome_history_path.exists():
+            typer.echo("[!] Histórico do Chrome não encontrado.")
+            return
+
+        tmp_file = tempfile.NamedTemporaryFile(delete=False)
+        shutil.copy2(chrome_history_path, tmp_file.name)
+
+        conn = sqlite3.connect(tmp_file.name)
+        cursor = conn.cursor()
+
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+        tabelas = [t[0] for t in cursor.fetchall()]
+
+        if 'keyword_search_terms' in tabelas:
+            cursor.execute("SELECT term FROM keyword_search_terms")
+            termos = cursor.fetchall()
+            termos_pesquisa = [t[0] for t in termos]
+        else:
+            typer.echo("Tabela 'keyword_search_terms' não encontrada. Usando fallback por URL...")
+            cursor.execute("SELECT url FROM urls")
+            urls = cursor.fetchall()
+            for (url,) in urls:
+                match = re.search(r"[?&]q=([^&]+)", url)
+                if match:
+                    termo = unquote(match.group(1))
+                    termos_pesquisa.append(termo)
+
+        conn.close()
+        tmp_file.close()
+
+    todas_palavras = []
+    for termo in termos_pesquisa:
+        palavras = re.findall(r'\b\w+\b', termo.lower())
+        todas_palavras.extend(palavras)
+
+    contagem = Counter(todas_palavras)
+    palavras_mais_comuns = contagem.most_common(50)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_file = output_dir / "most_searched_words.json"
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(palavras_mais_comuns, f, indent=2, ensure_ascii=False)
+
+    typer.echo(f"✅ Palavras mais pesquisadas salvas em: {output_file}")