DEV Community: Evandro Carvalho

Acesso Remoto Seguro sem Abrir Portas no Roteador: Implementando Redes Mesh com Tailscale e WireGuard

Evandro Carvalho — Tue, 27 Oct 2026 21:38:50 +0000

Acessar ambientes de desenvolvimento locais, servidores de home lab ou painéis de administração a partir de redes externas (via 4G/5G ou Wi-Fi público) sempre foi um desafio repleto de atritos técnicos:

Bloqueio de CGNAT (Carrier-Grade NAT): Provedores de internet não entregam mais endereços IPv4 públicos para residências, impossibilitando o tradicional redirecionamento de portas (Port Forwarding);
Risco de Segurança de Portas Abertas: Expor portas TCP/UDP abertas diretamente na WAN atrai enxames de scanners automatizados, ataques de força bruta e tentativas de exploit;
Complexidade de VPNs Legadas: Configurar OpenVPN tradicional exige gerenciar certificados SSL complexos, servidores dedicados e ajustes manuais de roteamento.

A solução moderna para essa dor de cabeça é a rede em malha (Mesh VPN) baseada no protocolo ultraleve WireGuard, orquestrada pelo Tailscale.

Neste artigo prático, você aprenderá como subir uma malha segura ponto a ponto em menos de 5 minutos, garantindo acesso direto sem abrir nenhuma porta no roteador.

1. Como o Tailscale Fura o CGNAT (NAT Traversal)

Diferente de VPNs tradicionais que canalizam todo o tráfego através de um servidor central (hub-and-spoke), o Tailscale implementa uma topologia em malha ponto a ponto:

┌───────────────────────────┐                 ┌───────────────────────────┐
│     NOTEBOOK NA RUA       │                 │     SERVIDOR DE CASA      │
│      (Rede 4G Móvel)      │                 │    (Atrás de CGNAT / Wi-Fi)│
│  IP Tailscale: 100.80.1.5 │                 │  IP Tailscale: 100.80.1.20 │
└─────────────┬─────────────┘                 └─────────────┬─────────────┘
              │                                             │
              │  TÚNEL CRIPTOGRAFADO PONTO A PONTO (WIREGUARD)│
              └─────────────────────────────────────────────┘
                    (Bypass Automático de Firewall via STUN/DERP)

Utilizando técnicas avançadas de STUN (Session Traversal Utilities for NAT) e servidores DERP de apoio temporário, os dois dispositivos negociam chaves públicas e estabelecem uma conexão UDP direta criptografada ponta a ponta sem intermediação de pacotes.

2. Instalação e Configuração no Servidor Linux

No terminal do seu servidor (Raspberry Pi, Mini PC ou VPS):

# Instalação do repositório oficial do Tailscale
curl -fsSL https://tailscale.com/install.sh | sh

# Iniciar autenticação e registrar o nó na sua malha
sudo tailscale up

O comando exibirá uma URL de login. Abra o link no navegador, faça login com sua conta (GitHub, Google ou Microsoft) e seu servidor receberá instantaneamente um IP privado fixo na faixa 100.x.y.z com nome amigável via MagicDNS (ex: servidor-casa.tailnet.ts.net).

3. Acessando com MagicDNS sem Decorar IPs

Uma das maiores facilidades é a resolução nativa de nomes DNS:

No seu notebook ou celular conectado à sua conta Tailscale, você pode acessar seu servidor simplesmente digitando:

ssh usuario@servidor-casa

Ou abrir aplicações web locais no navegador:

http://servidor-casa:8080   (Open WebUI)
http://servidor-casa:11434  (Ollama REST API)
http://servidor-casa:3000   (Next.js Dev Server)

4. Recursos Avançados de Rede

Subnet Routers (Roteador de Sub-rede): Você pode configurar seu servidor Linux para atuar como gateway, permitindo que você acerte qualquer outro dispositivo da sua casa (inclusive impressoras e TVs que não rodam Tailscale) a partir do seu notebook na rua:

  sudo tailscale up --advertise-routes=192.168.1.0/24

Exit Nodes (Nó de Saída): Transforme seu servidor doméstico no seu gateway de internet, garantindo navegação 100% criptografada ao usar Wi-Fi aberto em cafés e aeroportos.

Conclusão e Recursos

A combinação de criptografia moderna com automação de topologia mesh tornou as VPNs corporativas antigas obsoletas. Você ganha velocidade nativa de WireGuard, zero portas expostas e acesso contínuo a qualquer serviço.

Confira a análise detalhada sobre roteadores compatíveis com OpenWrt e arquiteturas de borda no meu blog:

👉 Artigo Completo no Vexis Sentinel

Você ainda usa redirecionamento de portas tradicional ou já migrou seus serviços para Tailscale / Cloudflare Tunnel? Compartilhe sua experiência!

PHP2Shell: Como a IA Revelou Vulnerabilidades Críticas no Núcleo do PHP e Acelerou a Defesa de Servidores

Evandro Carvalho — Sat, 24 Oct 2026 17:16:51 +0000

Em outubro de 2026, a comunidade global de infraestrutura e cibersegurança foi confrontada com o PHP2Shell: um conjunto de vulnerabilidades críticas no núcleo da linguagem PHP (CVSS 9.2) que permite Execução Remota de Código (RCE) sem autenticação.

Além do impacto direto em sistemas que sustentam mais de 70% da web (WordPress, Drupal, Joomla, Magento e APIs corporativas), o caso é um marco histórico: a pesquisa conduzida pela Wiz Research e documentada pelo Google Cloud utilizou modelos avançados de IA (Wiz Atlas, Gemini 4 Argon e GPT-5.6 Sol) para identificar falhas de corrupção de memória que permaneceram invisíveis por mais de 10 anos.

Neste guia técnico, dissecamos os mecanismos das falhas, a terceira CVE divulgada posteriormente e o roteiro prático para proteger servidores em produção.

1. As Vulnerabilidades no Núcleo do PHP

Diferente de brechas comuns causadas por plugins desatualizados, as falhas residem na implementação em C do interpretador PHP:

CVE-2026-109618 — Corrupção de Memória em Out-of-Memory (OOM)

Quando uma requisição excede os limites de memória configurados, o PHP força a interrupção da execução. Se o gatilho de OOM ocorrer durante a inicialização parcial de estruturas internas, o mecanismo de limpeza (garbage collector / cleanup) processa blocos de memória incompletos ou desalocados como se estivessem consistentes. Isso gera corrupção arbitrária de ponteiros e viabiliza a execução de código arbitrário sem login.

CVE-2026-109619 — Use-After-Free (UAF) e OPcache

Determinados estados internos da requisição não eram completamente zerados após a liberação da memória. Quando o processo trabalhador (worker) atendia uma requisição subsequente, ele reutilizava referências para estruturas obsoletas. Como o OPcache gerencia scripts pré-compilados compartilhados entre processos, a violação de isolamento abriu portas para injeção remota de código.

2. A Terceira Vulnerabilidade: CVE-2026-115560

Dois dias após a publicação das correções iniciais, em 23 de outubro de 2026, o projeto PHP e o CERT-EU emitiram um comunicado urgente sobre a CVE-2026-115560: outra falha de RCE associada ao mecanismo de progresso de upload de sessões.

Essa falha não foi corrigida pelas versões de manutenção de 21 de outubro. A mitigação emergencial recomendada é desativar o recurso no php.ini:

; Adicione ou edite no seu php.ini (/etc/php/8.x/fpm/php.ini ou /etc/php.ini)
session.upload_progress.enabled = 0

3. Versões Corrigidas e Auditoria de Pacotes

Série do PHP	Versão Mínima Segura
PHP 8.5	`8.5.12`
PHP 8.4	`8.4.27`
PHP 8.3	`8.3.36`
PHP 8.2	`8.2.35`
PHP 8.1 ou anterior	Exige backports fornecidos pela distro Linux

Verificação do Pacote no Sistema Operacional

Nunca confie apenas em php -v. Distribuições Linux corporativas aplicam correções mantendo a numeração original do pacote:

# Debian / Ubuntu:
dpkg -l | grep -E "php.*(fpm|common|cli)"

# RHEL / CentOS / AlmaLinux:
rpm -qa | grep -E "php.*(fpm|common|cli)"

Aplicação das Atualizações e Reinício de Serviços

# Debian / Ubuntu
sudo apt update && sudo apt install --only-upgrade php*

# RHEL / AlmaLinux
sudo dnf upgrade php\*

# Reinício obrigatório dos daemons:
sudo systemctl restart php8.3-fpm # Ajuste para sua versão ativa
sudo systemctl restart nginx     # ou apache2

4. O Impacto da IA na Dinâmica da Segurança

O PHP2Shell demonstra que a IA alterou definitivamente a pesquisa de segurança ofensiva e defensiva:

Fuzzing e Raciocínio Semântico: Modelos de IA analisam rapidamente dependências cruzadas em códigos de alta complexidade.
Janela Zero de Exploração: O intervalo entre o anúncio de uma falha e o desenvolvimento de exploits automatizados encurtou dramaticamente.

A defesa moderna exige visibilidade contínua de ativos, postura agressiva de atualização e detecção comportamental no host.

Artigo completo publicado originalmente no blog de cibersegurança:

👉 PHP2Shell: Análise Completa no Sentinel Vexis One

Investigação OSINT na Prática: Como Extrair Metadados EXIF e Analisar Imagens sem Ferramentas Pagas

Evandro Carvalho — Thu, 22 Oct 2026 15:31:26 +0000

Na era digital, uma fotografia é muito mais do que uma matriz de pixels coloridos. Cada arquivo capturado por um smartphone ou câmera profissional carrega consigo uma camada invisível de dados chamada EXIF (Exchangeable Image File Format).

Para analistas de segurança, peritos forenses e pesquisadores de OSINT (Open Source Intelligence), metadados representam uma mina de ouro investigativa. Por outro lado, para desenvolvedores e usuários desprevenidos, o envio inadvertido de arquivos sem sanitização expõe coordenadas geográficas residenciais, números de série e rotinas pessoais.

Neste artigo prático, veremos como extrair, interpretar e sanitizar metadados de arquivos de imagem utilizando ferramentas de linha de comando (ExifTool) e scripts em Python.

1. O que Fica Gravado no Cabeçalho EXIF?

Ao fotografar uma cena, o sistema do smartphone grava automaticamente:

Geolocalização (GPS): Latitude, longitude, altitude e direção da bússola;
Identidade do Hardware: Fabricante, modelo exato, versão do firmware e número de série da lente;
Condições Técnicas: Abertura do diafragma, velocidade do obturador, ISO e se o flash disparou;
Timestamp Absoluto: Data, hora, minuto e fuso horário da captura.

Enquanto plataformas sociais (como Instagram) descartam esses dados na compressão, o compartilhamento direto via e-mail, Discord, Slack ou envio como arquivo no Telegram/WhatsApp preserva 100% dos dados originais.

2. Extração Rápida com o ExifTool

O ExifTool é o padrão ouro na indústria forense para leitura e manipulação de metadados:

# Instalação no Linux / Debian
sudo apt update && sudo apt install -y libimage-exiftool-perl

# Extrair todos os metadados com formato legível
exiftool foto_alvo.jpg

Para filtrar especificamente as coordenadas geográficas:

exiftool -GPSLatitude -GPSLongitude -GPSPosition foto_alvo.jpg

A saída entrega os graus decimais exatos (ex: -23.550520, -46.633308), permitindo plotar a localização diretamente no Google Maps ou OpenStreetMap com precisão métrica.

3. Automatizando a Extração e Limpeza em Python

Abaixo está um script em Python que faz tanto a leitura forense quanto a sanitização completa (remoção de metadados) antes do upload público:

import sys
from PIL import Image
from PIL.ExifTags import TAGS, GPSTAGS

def extract_exif(image_path):
    image = Image.open(image_path)
    exif_data = image._getexif()

    if not exif_data:
        print("[!] Nenhum metadado EXIF encontrado.")
        return

    print(f"=== METADADOS ENCONTRADOS: {image_path} ===")
    for tag_id, value in exif_data.items():
        tag_name = TAGS.get(tag_id, tag_id)
        # Oculta dados binários extensos
        if tag_name != "MakerNote":
            print(f"{tag_name:<25}: {value}")

def sanitize_image(image_path, output_path):
    """Cria uma cópia limpa da imagem sem nenhum metadado EXIF rastreável"""
    image = Image.open(image_path)
    # Criar uma nova imagem copiando apenas os pixels RGB
    clean_image = Image.new(image.mode, image.size)
    clean_image.putdata(list(image.getdata()))
    clean_image.save(output_path)
    print(f"[✔] Imagem sanitizada salva com sucesso em: {output_path}")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Uso: python exif_analyzer.py <imagem.jpg>")
        sys.exit(1)

    target = sys.argv[1]
    extract_exif(target)
    sanitize_image(target, "sanitized_" + target)

4. Recomendações de OPSEC (Segurança Operacional)

Desative Geotagging na Câmera: Nas configurações do app de câmera do seu celular, desative a opção "Salvar localização";
Crie Pipelines de Sanitização: Em aplicações web que recebem uploads de usuários (avatares, documentos, fotos de perfil), processe sempre as imagens através de bibliotecas como Pillow ou sharp para expurgar metadados antes de armazenar no bucket S3;
Atenção a Metadados em PDFs e Documentos Office: Arquivos .docx e .pdf frequentemente gravam o autor original, caminho de pastas no computador local (C:\Users\nome\...) e software utilizado.

Conclusão e Recursos

Compreender o poder dos metadados é essencial tanto para investigações defensivas de cibersegurança quanto para garantir a privacidade básica de dados em produtos digitais.

Confira o guia completo sobre investigação OSINT e armazenamento seguro de dados no meu blog:

👉 Artigo Completo no Vexis Sentinel

Você já utilizou o ExifTool em auditorias de segurança ou para verificar o que seus próprios arquivos expõem? Conte sua experiência!

Telemetria de Energia para Home Labs 24/7: Como Medir Consumo e Evitar Sobrecargas com Tomadas Inteligentes

Evandro Carvalho — Wed, 21 Oct 2026 17:15:21 +0000

Manter servidores domésticos, nós de IA e appliances de rede rodando 24 horas por dia traz uma dúvida comum para qualquer engenheiro ou entusiasta de infraestrutura: quanto isso realmente custa na conta de luz ao final do mês?

Além do fator financeiro, servidores sem supervisão em ambientes residenciais exigem controle térmico e proteção contra sobrecarga. Se um cooler travar ou um processo entrar em loop infinito de CPU, o consumo elétrico dispara junto com a temperatura dos componentes.

Neste artigo, veremos como instrumentar um sistema de telemetria elétrica contínua para seu home lab utilizando tomadas inteligentes IoT, automações em Python e regras de desligamento de emergência.

1. Métricas Essenciais de Telemetria Elétrica

Ao monitorar servidores, precisamos observar 4 grandezas físicas:

Potência Ativa (Watts - W): A taxa instantânea de energia consumida pela máquina em determinado segundo;
Tensão da Rede (Volts - V): Monitora a estabilidade da concessionária de energia (quedas de tensão podem forçar a fonte);
Corrente (Amperes - A): Ajuda a dimensionar disjuntores e filtros de linha com precisão;
Energia Acumulada (Quilowatt-hora - kWh): A unidade cobrada na fatura de energia elétrica (1 kWh = 1000W consumidos por 1 hora).

2. A Matemática do Custo Mensal

Para saber o custo exato do seu servidor:

$$\text{Custo Mensal (R\$)} = \frac{\text{Potência Média (W)} \times 24 \times 30}{1000} \times \text{Tarifa do kWh}$$

Exemplo Real (Mini PC rodando Docker em Idle a 14W):

Consumo Diário: 14W * 24h = 336 Wh = 0.336 kWh/dia
Consumo Mensal: 0.336 kWh * 30 dias = 10.08 kWh/mês
Custo com Tarifa Média (R$ 0,90 por kWh): 10.08 * 0.90 = R$ 9,07 por mês!

Ter 8GB a 16GB de RAM dedicada rodando seus próprios containers locais por menos de R$ 10 mensais é incomparavelmente mais barato do que qualquer instância equivalente em nuvem pública (AWS EC2, DigitalOcean ou Linode).

3. Automatizando Alertas de Sobrecarga em Python

Abaixo está um script em Python que consome a telemetria da tomada (via API local ou MQTT) e aciona medidas de proteção caso o consumo ultrapasse o limite de segurança por tempo prolongado:

import time
import requests
import subprocess
import logging

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger("PowerTelemetry")

# Limites de segurança do servidor
MAX_SAFE_WATTS = 65.0
SUSTAINED_LIMIT_SECONDS = 300 # 5 minutos

def get_current_power_watts():
    # Consulta endpoint local da tomada inteligente (Tasmota / Tuya Local / Home Assistant)
    try:
        r = requests.get("http://192.168.1.180/cm?cmnd=Status%208", timeout=3.0)
        data = r.json()
        return float(data.get("StatusSNS", {}).get("ENERGY", {}).get("Power", 0.0))
    except Exception as e:
        logger.warning(f"Erro ao consultar sensor de energia: {e}")
        return 0.0

def emergency_cooldown():
    logger.critical("⚠️ Consumo excessivo prolongado! Iniciando mitigação térmica...")
    # Para containers pesados de IA para aliviar a carga da CPU
    subprocess.run(["docker", "stop", "ollama-gpu-server"], check=False)
    # Envia notificação para o administrador (Telegram / Webhook)
    logger.info("Containers pesados congelados com sucesso para resfriamento.")

def monitor_loop():
    over_limit_start = None
    logger.info("Monitor de telemetria elétrica iniciado...")

    while True:
        watts = get_current_power_watts()
        logger.info(f"Consumo atual do Home Lab: {watts:.2f} W")

        if watts > MAX_SAFE_WATTS:
            if over_limit_start is None:
                over_limit_start = time.time()
                logger.warning(f"Consumo ultrapassou {MAX_SAFE_WATTS}W! Monitorando sustentação...")
            elif (time.time() - over_limit_start) >= SUSTAINED_LIMIT_SECONDS:
                emergency_cooldown()
                over_limit_start = None
        else:
            over_limit_start = None

        time.sleep(30)

if __name__ == "__main__":
    monitor_loop()

Conclusão e Recursos

Instrumentar o consumo elétrico traz previsibilidade financeira para seus projetos e protege o hardware físico contra superaquecimento silencioso.

Confira o guia completo sobre proteção elétrica com nobreaks senoidais e dimensionamento de cargas no meu blog:

👉 Artigo Completo no Vexis Sentinel

Você monitora o consumo dos seus servidores caseiros? Qual a potência média em Watts do seu setup em idle?

Honeypots em Redes Internas: Como Criar Portas Falsas para Detectar Varreduras e Movimentação Lateral

Evandro Carvalho — Thu, 15 Oct 2026 22:20:48 +0000

A maior parte dos esforços de segurança corporativa e doméstica foca exclusivamente no perímetro: firewalls bloqueando portas de entrada e filtros de DNS. No entanto, uma vez que um invasor (ou um dispositivo IoT comprometido) obtém acesso à rede Wi-Fi/LAN, ele ganha liberdade quase total para explorar outros hosts.

É aqui que entram os Honeypots Internos (ou Sistemas Canário).

Diferente de honeypots públicos que servem para atrair ataques da internet aberta, um honeypot interno serve como um sensor de alarme silencioso: ele escuta em portas de serviços vulneráveis clássicos (Telnet, FTP, SMB) dentro da sua sub-rede privada. Como nenhum usuário legítimo tem motivos para interagir com essas portas, qualquer tentativa de conexão é com 100% de certeza um sinal de anomalia, varredura (Nmap) ou tentativa de movimentação lateral.

Neste artigo, veremos como construir um honeypot multi-porta ultraleve em Python assíncrono.

1. O Conceito: Detectando o Invasor no Primeiro Toque

┌─────────────────────────────────────────────────────────────┐
│                    REDE LOCAL PRIVADA (LAN)                 │
└──────────────────────────────┬──────────────────────────────┘
                               │
            ┌──────────────────┴──────────────────┐
            ▼                                     ▼
     PC de Trabalho                        Dispositivo IoT
    (Tráfego Legítimo)                    (Comprometido / Bot)
                                                  │
                                                  │ Dispara Varredura de Portas (SYN)
                                                  ▼
                                      ┌───────────────────────┐
                                      │   HONEYPOT EM PYTHON  │
                                      │  Portas: 21, 23, 445  │
                                      └───────────┬───────────┘
                                                  │
                                                  ▼ Alerta Imediato
                                      ⚠️ Movimentação Lateral Detectada!
                                      Origem: 192.168.1.145 (TV Box)

2. Implementando o Honeypot em Python (`asyncio`)

O script abaixo simula banners de resposta realistas para induzir o invasor a continuar a interação, enquanto registra o IP de origem e o payload enviado:

import asyncio
import logging
from datetime import datetime

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s"
)
logger = logging.getLogger("InternalHoneypot")

# Portas de alta probabilidade de varredura
HONEYPOT_PORTS = {
    21: b"220 ProFTPD 1.3.5 Server (Ubuntu) [192.168.1.100]\r\n",
    23: b"Debian GNU/Linux 12\r\nLogin: ",
    445: b"\x00\x00\x00\x2f\xff\x53\x4d\x42", # Assinatura simples SMB
}

async def handle_probe(reader, writer, port, banner):
    client_ip, client_port = writer.get_extra_info("peername")
    logger.warning(f"🚨 [ALERTA DE SEGURANÇA] Sonda detectada! IP: {client_ip}:{client_port} na Porta: {port}")

    try:
        # Envia banner simulado
        writer.write(banner)
        await writer.drain()

        # Lê dados que o invasor tentar enviar (ex: credenciais)
        data = await asyncio.wait_for(reader.read(1024), timeout=5.0)
        if data:
            logger.info(f"Payload capturado de {client_ip} na porta {port}: {data[:100]}")
    except (asyncio.TimeoutError, ConnectionResetError):
        pass
    finally:
        writer.close()
        await writer.wait_closed()

async def start_honeypot():
    servers = []
    for port, banner in HONEYPOT_PORTS.items():
        try:
            server = await asyncio.start_server(
                lambda r, w, p=port, b=banner: handle_probe(r, w, p, b),
                "0.0.0.0",
                port
            )
            servers.append(server)
            logger.info(f"Honeypot ativo escutando na porta TCP {port}")
        except PermissionError:
            logger.error(f"Permissão negada para porta {port}. Execute com sudo ou use capabilities.")

    await asyncio.gather(*[s.serve_forever() for s in servers])

if __name__ == "__main__":
    try:
        asyncio.run(start_honeypot())
    except KeyboardInterrupt:
        logger.info("Honeypot desativado.")

3. Rodando com Menor Privilégio no Linux

Para escutar em portas privilegiadas (abaixo de 1024) sem precisar rodar o script como usuário root, você pode conceder a capacidade CAP_NET_BIND_SERVICE ao binário do Python:

sudo setcap 'cap_net_bind_service=+ep' $(readlink -f $(which python3))

4. O que Fazer Após o Alerta?

Identificar o Hardware: Use a tabela ARP para descobrir o endereço MAC do IP invasor e consulte o fabricante (IEEE OUI);
Isolar o Dispositivo: Se for um aparelho de TV Box, câmera IP ou sensor inteligente, migre-o imediatamente para uma VLAN de convidados/IoT com isolamento de clientes (Client Isolation) ativado no ponto de acesso;
Bloquear Comunicações WAN: Bloqueie requisições de DNS e portas de saída suspeitas no firewall do seu roteador para impedir comandos de C2 (Command & Control).

Conclusão e Recursos

A melhor segurança não é aquela que tenta prever todos os ataques, mas aquela que detecta a presença do invasor no primeiro segundo em que ele tenta explorar a rede interna.

Confira o guia completo sobre arquiteturas de defesa em profundidade e automações no meu blog:

👉 Guia Completo no Vexis Sentinel

Você já identificou aparelhos na sua rede fazendo requisições ou conexões para IPs estranhos? O que descobriu?

GitHub Copilot Privado e Gratuito: Como Usar o Continue.dev no VS Code com Modelos Locais

Evandro Carvalho — Wed, 14 Oct 2026 19:18:45 +0000

Assinaturas recorrentes de assistentes de IA (como GitHub Copilot, Cursor e Supermaven) pesam no bolso do desenvolvedor e representam um pesadelo de compliance para empresas que lidam com código confidencial, segredos industriais e exigências de LGPD/GDPR.

Com os saltos recentes nos modelos de código de pesos abertos — em especial a família Qwen 2.5 Coder da Alibaba Cloud —, agora é possível ter uma experiência idêntica de autocompletar e chat dentro do VS Code rodando 100% offline e de graça.

Neste artigo, você aprenderá a configurar a extensão Continue.dev integrada ao Ollama para autocompletar código nativo via tecla Tab.

1. A Stack: Continue.dev + Ollama + Qwen 2.5 Coder

Continue.dev: A extensão open-source líder para VS Code e JetBrains que atua como cliente universal para LLMs locais ou em nuvem.
Ollama: O motor de inferência local que gerencia a alocação de GPU/RAM e serve os modelos via API REST local (http://localhost:11434).
Qwen 2.5 Coder: Considerado atualmente o estado da arte em modelos abertos para programação, superando até modelos maiores em benchmarks como HumanEval e SWE-bench.

2. Passo 1: Baixando os Modelos no Ollama

No terminal da sua máquina (com Ollama instalado):

# Para autocompletar inline ultra-rápido (latência < 100ms)
ollama pull qwen2.5-coder:1.5b-base

# Para o chat lateral, refatoração e geração de testes complexos
ollama pull qwen2.5-coder:7b

3. Passo 2: Configurando o `config.json` do Continue

No VS Code, instale a extensão Continue pelo marketplace (Continue.continue).
Clique no ícone de engrenagem ⚙️ no painel do Continue e selecione Open config.json (localizado em ~/.continue/config.json).
Insira a configuração abaixo:

{
  "models": [
    {
      "title": "Qwen 2.5 Coder 7B (Local)",
      "provider": "ollama",
      "model": "qwen2.5-coder:7b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen 2.5 Coder 1.5B Autocomplete",
    "provider": "ollama",
    "model": "qwen2.5-coder:1.5b-base",
    "apiBase": "http://localhost:11434"
  },
  "customCommands": [
    {
      "name": "testes",
      "prompt": "Escreva testes unitários completos com alta cobertura para o código selecionado.",
      "description": "Gerar testes unitários"
    },
    {
      "name": "refatorar",
      "prompt": "Refatore o código selecionado aplicando princípios de Clean Code e tipagem estrita.",
      "description": "Refatorar código"
    }
  ]
}

Salve o arquivo (Ctrl + S). O Continue recarregará instantaneamente.

4. Usando no Dia a Dia

Autocompletar Inline: Ao digitar código, o modelo sugere continuações em cinza. Pressione Tab para aceitar.
Chat Lateral Contextual: Pressione Ctrl + L para abrir o chat. Use @Files ou @Code para referenciar arquivos específicos do seu repositório.
Refatoração no Local: Selecione um bloco de código e pressione Ctrl + I para instruir o modelo a alterar as linhas diretamente no editor.

Conclusão e Recursos

Ter um assistente de IA soberano dentro do seu próprio hardware elimina custos recorrentes e garante que nenhuma linha do seu código saia da sua rede privada.

Confira a análise detalhada de consumo de VRAM e placas de vídeo recomendadas no meu blog:

👉 Guia Completo no Vexis Sentinel

Você já experimentou programar com modelos locais? Sentiu diferença na velocidade ou precisão em comparação com os modelos pagos?

Hardening de Servidores Linux: Como Blindar o SSH com Chaves Ed25519 e Eliminar Ataques de Força Bruta

Evandro Carvalho — Mon, 12 Oct 2026 13:27:22 +0000

Basta alocar um IP público em qualquer VPS na AWS, DigitalOcean ou Hetzner para que, em questão de minutos, scanners automatizados comecem a bombardear a porta 22 do seu servidor com ataques de dicionário e força bruta.

Consultar o arquivo /var/log/auth.log (ou journalctl -u ssh) em servidores recém-criados revela milhares de tentativas de autenticação para usuários previsíveis como root, admin, user e postgres.

Neste guia prático de engenharia de sistemas, veremos os 4 passos obrigatórios para blindar o serviço OpenSSH, erradicar autenticação por senha e implementar detecção de intrusos com Fail2ban.

1. Por que Chaves Ed25519 em vez de RSA?

As chaves Ed25519 (baseadas na curva elíptica Curve25519) tornaram-se o padrão da indústria por motivos claros:

Segurança Imbatível: Oferecem segurança equivalente a chaves RSA de ~3000 bits com uma fração do tamanho do arquivo (apenas 68 caracteres);
Velocidade de Assinatura: O handshake SSH e a verificação criptográfica ocorrem em menos da metade do tempo;
Resistência a Canais Laterais: Menos suscetíveis a ataques baseados em tempo de resposta (timing attacks).

Gere sua chave localmente na sua máquina de desenvolvimento:

ssh-keygen -t ed25519 -C "seu-email@dominio.com" -f ~/.ssh/id_ed25519_servidor

Copie a chave pública para o servidor remoto:

ssh-copy-id -i ~/.ssh/id_ed25519_servidor.pub usuario@<IP-DO-SERVIDOR>

2. Configurando o `/etc/ssh/sshd_config.d/99-hardening.conf`

Em distribuições Linux modernas (Debian 12+, Ubuntu 22.04+), a melhor prática é não alterar o arquivo principal diretamente, mas criar um arquivo de substituição modular em /etc/ssh/sshd_config.d/:

# /etc/ssh/sshd_config.d/99-hardening.conf

# 1. Proibir login direto como superusuário (root)
PermitRootLogin no

# 2. Desativar completamente autenticação por senha
PasswordAuthentication no
PermitEmptyPasswords no
ChallengeResponseAuthentication no
KbdInteractiveAuthentication no

# 3. Forçar uso estrito de chaves públicas
PubkeyAuthentication yes

# 4. Limitar tentativas consecutivas de autenticação
MaxAuthTries 3
MaxSessions 2

# 5. Desativar encaminhamento X11 desnecessário
X11Forwarding no

# 6. Desconectar sessões ociosas automaticamente (após 10 minutos)
ClientAliveInterval 300
ClientAliveCountMax 2

Valide a sintaxe antes de reiniciar o daemon:

sudo sshd -t
sudo systemctl restart sshd

⚠️ Atenção: Mantenha uma janela de SSH aberta enquanto testa o login em uma nova janela para evitar ficar trancado fora do servidor!

3. Instalando e Ajustando o Fail2ban

O Fail2ban inspeciona os logs do sistema operacional e cria regras dinâmicas de firewall (nftables ou iptables) para banir IPs que apresentem comportamento suspeito:

sudo apt update && sudo apt install -y fail2ban

Crie o arquivo de regras locais em /etc/fail2ban/jail.local:

# /etc/fail2ban/jail.local
[DEFAULT]
bantime  = 24h
findtime  = 10m
maxretry = 3
banaction = nftables-multiport

[sshd]
enabled = true
port    = ssh
filter  = sshd
logpath = %(sshd_log)s
backend = systemd

Inicie e habilite o serviço:

sudo systemctl enable --now fail2ban

Para verificar o status das jails ativas e a lista de IPs banidos:

sudo fail2ban-client status sshd

Conclusão e Recursos

A segurança de um servidor começa pela superfície de ataque mais exposta. Eliminando o login por senha e aplicando chaves Ed25519 com Fail2ban, você neutraliza mais de 99% dos scanners automatizados da internet.

Confira o guia aprofundado com auditoria de chaves físicas FIDO2 e cofres criptografados no meu blog:

👉 Guia Completo de Hardening no Vexis Sentinel

Você mantém a porta 22 padrão ou costuma alterar para uma porta alta não padrão? Qual a sua estratégia favorita?

Reaproveitando Smartphones Antigos como Servidores de IA de Borda com Linux (PostmarketOS / ARM64)

Evandro Carvalho — Fri, 09 Oct 2026 01:02:13 +0000

A maioria dos desenvolvedores e entusiastas de hardware possui algum smartphone antigo esquecido em uma gaveta. Celulares topo de linha de gerações passadas (como os equipados com Snapdragon 845 ou Snapdragon 870) possuem:

6GB a 8GB de memória LPDDR4X rápida;
SoCs Octa-Core de 64 bits com excelente eficiência por Watt;
Armazenamento flash UFS veloz;
Uma bateria integrada (UPS/No-break nativo) que impede o desligamento súbito em caso de queda de energia.

Enquanto rodar ferramentas no Android via Termux frequentemente sofre com o OOM killer agressivo do sistema operacional móvel, instalar uma distribuição Linux real como o postmarketOS (baseado no Alpine Linux) transforma o celular em um micro-servidor bare-metal de baixo consumo.

Neste artigo, veremos como configurar um nó de inferência de IA local (Edge AI) rodando Ollama e Small Language Models (SLMs) diretamente no hardware ARM64.

1. Por que postmarketOS em vez de Android/Termux?

Aspecto	Android + Termux	postmarketOS (Alpine Linux)
Kernel	Kernel customizado do fabricante (antigo)	Kernel Linux mainline upstream
Overhead de RAM	~2.5GB consumidos pela JVM e serviços Android	Menos de 200MB de RAM em idle
Gerenciamento de Processos	Android suspende daemons em background	systemd / OpenRC padrão de servidor
Acesso a Pacotes	Repositórios limitados do Termux	Repositórios completos Alpine ARM64 (`apk`)

2. Preparando o Ambiente Headless

Após flashear o postmarketOS no dispositivo (ex: Xiaomi Pocophone F1, OnePlus 6, etc.), o primeiro passo para maximizar a memória disponível para os modelos de IA é desativar a interface gráfica (Phosh ou Plasma Mobile) e mascarar a suspensão profunda:

# Conectado via SSH no aparelho
# 1. Desativar suspensão para não derrubar a conexão de rede
sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target

# 2. Desativar interface gráfica no boot (modo servidor puro)
sudo systemctl set-default multi-user.target

Após reiniciar, o sistema consumirá míseros 150MB a 200MB de RAM, deixando mais de 5.5GB livres para carregar pesos de modelos de linguagem diretamente na memória unificada do SoC.

3. Instalando o Ollama no ARM64

O Ollama possui compilações oficiais compatíveis com a arquitetura aarch64. A instalação pode ser realizada via script oficial:

curl -fsSL https://ollama.com/install.sh | sh

Para garantir que o serviço escute em todas as interfaces da sua rede local privada (ou na malha Tailscale), configure as variáveis de ambiente do serviço:

sudo systemctl edit ollama.service

Insira:

[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_KEEP_ALIVE=24h"

Reinicie o serviço:

sudo systemctl daemon-reload
sudo systemctl restart ollama.service

4. Escolha e Benchmark de Modelos SLM para Edge

Em chips como o Snapdragon 845/870, modelos de 1B a 3B de parâmetros quantizados em 4 bits (GGUF) oferecem um equilíbrio ideal entre velocidade e consumo de memória:

# Modelo ultra-rápido para código e raciocínio lógico (consome ~1.2GB de RAM)
ollama pull qwen2.5-coder:1.5b

# Modelo excelente para conversação e triagem de tarefas gerais (consome ~2.1GB de RAM)
ollama pull llama3.2:3b

Resultados de Performance (Snapdragon 845 / 6GB RAM):

Qwen 2.5 Coder 1.5B (Q4_K_M): ~12 a 15 tokens/segundo.
Llama 3.2 3B (Q4_K_M): ~7 a 9 tokens/segundo.
Consumo Energético: Menos de 3 Watts sob carga máxima de inferência.

Conclusão e Recursos

Reaproveitar hardware existente reduz lixo eletrônico e oferece uma infraestrutura de IA privada 24/7 sem custos recorrentes em nuvem. Com a bateria interna do smartphone, você ganha ainda tolerância total contra oscilações de energia elétrica.

Confira o guia aprofundado com comparação de hardware dedicado e mini PCs no meu blog:

👉 Artigo Completo no Fymax Sentinel

Você tem algum smartphone antigo encostado? Já considerou rodar serviços locais ou nós de rede nele? Deixe seu comentário!

Como Montar um SIEM Doméstico no Linux com Detecção de Intrusos ARP e Fabricante OUI

Evandro Carvalho — Fri, 09 Oct 2026 01:01:05 +0000

Manter a visibilidade sobre o que está conectado na sua rede local (LAN) é o primeiro passo para qualquer postura séria de segurança. Na maioria das residências e pequenos escritórios, confiamos cegamente no roteador da operadora — que raramente oferece logs em tempo real, auditoria ou alertas de novos dispositivos desconhecidos.

Neste artigo prático, vamos construir um Sentinela Doméstico (Micro-SIEM) em Python que roda em qualquer Linux (Raspberry Pi, Mini PC ou servidor local), capaz de:

Ler a tabela ARP do kernel em tempo real;
Realizar varreduras ativas assíncronas via Ping Sweep em sub-redes /24 em menos de 2 segundos;
Resolver o fabricante do hardware via prefixo IEEE OUI (Apple, Samsung, Espressif, Intel, etc.) sem depender de APIs externas;
Disparar alertas de novos nós conectados para quarentena imediata.

1. Por que a Tabela ARP e não apenas Nmap?

Ferramentas como Nmap são excelentes para auditorias pontuais, mas executar scans pesados continuamente na rede pode:

Gerar ruído e tráfego desnecessário de broadcast;
Travar dispositivos IoT sensíveis (lâmpadas, tomadas Tuya/Sonoff);
Consumir CPU desnecessária no host de monitoramento.

No Linux, o próprio kernel já mantém um cache dinâmico de todos os dispositivos que trocaram pacotes recentemente no arquivo pseudo-sistema /proc/net/arp. Lendo esse arquivo diretamente, a verificação consome praticamente 0% de CPU.

2. O Script Sentinela em Python

Abaixo está a implementação base que combina a leitura da tabela ARP com a resolução de fabricantes offline:

import os
import re
import asyncio
import subprocess

# Mapeamento simplificado de prefixos OUI populares (3 primeiros octetos)
OUI_DATABASE = {
    "00:1A:2B": "Ayecom Technology",
    "DC:A6:32": "Raspberry Pi Trading",
    "B8:27:EB": "Raspberry Pi Foundation",
    "AC:D1:B8": "Apple, Inc.",
    "F4:F5:DB": "Apple, Inc.",
    "24:4C:E3": "Samsung Electronics",
    "EC:FA:BC": "Espressif (Tuya / Sonoff / IoT)",
    "30:AE:A4": "Espressif Systems",
    "00:E0:4C": "Realtek Semiconductor",
    "18:66:DA": "Intel Corporate",
}

def resolve_vendor(mac: str) -> str:
    prefix = mac.upper()[:8]
    return OUI_DATABASE.get(prefix, "Fabricante Desconhecido")

def read_kernel_arp_table():
    devices = []
    if not os.path.exists("/proc/net/arp"):
        return devices

    with open("/proc/net/arp", "r") as f:
        lines = f.readlines()[1:] # Pula o cabeçalho
        for line in lines:
            parts = line.split()
            if len(parts) >= 6:
                ip, hw_type, flags, mac, mask, device = parts[:6]
                # Flags 0x2 significa dispositivo resolvido/válido
                if flags == "0x2" and mac != "00:00:00:00:00:00":
                    devices.append({
                        "ip": ip,
                        "mac": mac.upper(),
                        "interface": device,
                        "vendor": resolve_vendor(mac)
                    })
    return devices

async def ping_sweep_subnet(subnet_base="192.168.1"):
    """Dispara pings assíncronos rápidos para forçar atualização da tabela ARP"""
    async def ping_ip(ip):
        proc = await asyncio.create_subprocess_exec(
            "ping", "-c", "1", "-W", "1", ip,
            stdout=asyncio.subprocess.DEVNULL,
            stderr=asyncio.subprocess.DEVNULL
        )
        await proc.wait()

    tasks = [ping_ip(f"{subnet_base}.{i}") for i in range(1, 255)]
    await asyncio.gather(*tasks)

async def main():
    print("[*] Atualizando cache ARP com varredura assíncrona...")
    await ping_sweep_subnet("192.168.1")

    print("\n[+] Dispositivos Ativos na LAN:")
    print(f"{'IP':<16} {'MAC':<18} {'INTERFACE':<10} {'FABRICANTE'}")
    print("-" * 65)
    for dev in read_kernel_arp_table():
        print(f"{dev['ip']:<16} {dev['mac']:<18} {dev['interface']:<10} {dev['vendor']}")

if __name__ == "__main__":
    asyncio.run(main())

3. Criando um Serviço em Segundo Plano (Systemd)

Para que o monitoramento seja ininterrupto, salve o script em /opt/network_sentry.py e configure o serviço no Linux:

# /etc/systemd/system/network-sentry.service
[Unit]
Description=EVM Network Sentry SIEM Daemon
After=network.target

[Service]
Type=simple
User=root
ExecStart=/usr/bin/python3 /opt/network_sentry.py
Restart=always
RestartSec=180

[Install]
WantedBy=multi-user.target

Ative o daemon para iniciar no boot:

sudo systemctl daemon-reload
sudo systemctl enable --now network-sentry.service

4. O que Fazer com Dispositivos Desconhecidos?

Quando um MAC que não está na sua lista de nós autorizados é detectado, a melhor prática não é apenas emitir um alerta visual, mas aplicar medidas de contenção:

Isolamento via VLAN: Separar dispositivos de automação (IoT) dos computadores pessoais de trabalho;
Quarentena no Switch/Roteador: Bloquear o encaminhamento de pacotes do IP atribuído via regras de iptables ou regras de firewall no roteador gerenciável (MikroTik / OpenWrt / pfSense).

Conclusão e Recursos

Ter visibilidade em nível de camada 2 (Data Link) é a fundação para qualquer ambiente seguro. Com poucas linhas de Python assíncrono, você transforma qualquer servidor Linux comum em uma sentinela permanente contra invasões e nós não autorizados.

Publiquei a arquitetura completa com integração de eventos e banco de dados SQLite WAL no meu blog:

👉 Artigo Completo no Fymax Sentinel

Como você monitora a entrada de novos aparelhos na sua rede doméstica hoje? Usa Pi-hole, ARPWatch ou regras no roteador? Compartilhe nos comentários!

Como Rodar Ollama com Docker e Aceleração de GPU NVIDIA (Guia Prático)

Evandro Carvalho — Tue, 06 Oct 2026 19:32:24 +0000

A demanda por executar modelos de linguagem locais (Llama, DeepSeek, Qwen, Mistral) para garantir soberania de dados, privacidade e zero custos com tokens de API explodiu.

O Ollama tornou-se o padrão mais simples e eficiente para isso. No entanto, instalar o binário ou drivers CUDA diretamente no sistema operacional do servidor muitas vezes gera conflito de dependências, quebra de bibliotecas após atualizações do kernel (apt upgrade) ou dificuldades para isolar ambientes.

Neste guia, você vai ver como isolar toda a stack de inferência dentro do Docker utilizando o NVIDIA Container Toolkit, com alocação correta de VRAM e boas práticas de segurança de rede.

1. Configurando o NVIDIA Container Toolkit (Host)

Para que o daemon do Docker consiga passar as GPUs e capacidades de computação CUDA para os containers, o host (Debian/Ubuntu) precisa do runtime oficial da NVIDIA.

Execute no terminal:

# 1. Adicionar o repositório oficial da NVIDIA
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

# 2. Instalar o toolkit e configurar o Docker daemon
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

2. O `compose.yaml` com Aceleração de GPU

Crie um arquivo compose.yaml (ou docker-compose.yml) na pasta do seu projeto.

O ponto crucial está na diretiva deploy.resources.reservations.devices, onde definimos o driver nvidia e as capacidades necessárias (gpu, compute, utility):

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama-gpu-server
    restart: unless-stopped
    ports:
      # Amarre ao localhost para não expor a API sem autenticação na rede externa!
      - "127.0.0.1:11434:11434"
    volumes:
      - ollama_models:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu, compute, utility]

volumes:
  ollama_models:
    name: ollama_models_volume

Suba o container em background:

docker compose up -d

3. Validando se a GPU está ativa dentro do Container

Para confirmar se o container está de fato enxergando a GPU NVIDIA e o CUDA:

docker exec -it ollama-gpu-server nvidia-smi

Se a saída do nvidia-smi exibir sua GPU (ex: RTX 3060, RTX 4060 Ti, A100, etc.), o passthrough foi configurado com sucesso!

4. Baixando e Testando Modelos

Você pode interagir diretamente com a CLI do Ollama dentro do container:

# Baixar e testar um modelo leve e rápido (ex: Llama 3.2 de 3B)
docker exec -it ollama-gpu-server ollama run llama3.2:3b

# Ou um modelo focado em código / raciocínio (ex: Qwen 2.5 Coder 7B)
docker exec -it ollama-gpu-server ollama run qwen2.5-coder:7b

Para listar os modelos que já estão persistidos no seu volume Docker:

docker exec -it ollama-gpu-server ollama list

5. Dica Crítica de Segurança de Rede

⚠️ Atenção: Por padrão, a API REST do Ollama (http://localhost:11434/api/...) não implementa camada de autenticação.

Se você alterar a porta para 0.0.0.0:11434, qualquer usuário na mesma rede local (ou na internet, se houver IP público) poderá:

Submeter prompts e consumir 100% da sua VRAM e CPU;
Excluir modelos baixados via chamada DELETE;
Fazer download de modelos arbitrários no seu disco.

Como proteger em produção:

Mantenha a porta amarrada estritamente em 127.0.0.1:11434 no Compose.
Utilize um reverse proxy como Caddy ou Nginx com autenticação por cabeçalho (Authorization: Bearer <seu-token>) e terminação SSL/TLS se precisar expor para outros serviços.
Se for para acesso remoto privado, utilize um túnel VPN moderno como Tailscale ou WireGuard.

Conclusão e Recursos

Rodar o Ollama via Docker Compose traz a tranquilidade de atualizar imagens sem medo de quebrar bibliotecas do sistema operacional, além de facilitar a réplica do ambiente em qualquer servidor.

Publiquei o guia completo com benchmarks de consumo de VRAM (8GB vs 12GB vs 16GB), dicas de dimensionamento de hardware e integrações no meu blog:

👉 Guia Completo: Ollama com Docker e GPU no Fymax Sentinel

Como você está rodando LLMs locais na sua infraestrutura hoje? Utiliza Docker, bare-metal ou soluções como vLLM/LocalAI? Deixe nos comentários!

AI-Powered Zero-Day Chaining: A Deep Dive into Claude Mythos & Project Glasswing

Evandro Carvalho — Sun, 03 May 2026 17:23:06 +0000

The cybersecurity landscape just shifted. Anthropic has confirmed Claude Mythos, a model capable of autonomously identifying and chaining Zero-Day vulnerabilities in under 120 seconds.

Key Technical Highlights:

IVD Architecture: Iterative Vulnerability Discovery allows the model to interact with virtualized environments in real-time, finding memory overflows that static analysis misses.
Polymorphic Payloads: Mythos generates code that changes its signature with every execution, making signature-based detection (AV/EDR) 94% less effective.
Attack Graphs: It maps multi-hop attack paths (up to 18 hops) that are virtually invisible to heuristic scanners.
We are officially entering the AI vs AI era. If you're still relying on legacy firewalls, you're defending a castle with a paper door.

Check out the full technical benchmarks and the performance comparison at Fymax Sentinel: 👉 https://en.landingfymax.com.br/cybersecurity/claude-mythos-ai-cyber-weapon-2026

How are you preparing your stack for autonomous exploit chaining? Let's discuss in the comments.

Llama 4 and the Rise of Sovereign AI: Why Open Source Won in 2026

Evandro Carvalho — Sat, 25 Apr 2026 01:13:55 +0000

This week in April 2026, the AI landscape shifted. Meta’s Llama 4 release isn't just about higher benchmarks; it's about who owns the intelligence. For the first time, organizations can deploy a top-tier model that matches proprietary performance while keeping 100% data ownership.

In this article, we explore the technical breakthroughs and the geopolitical impact of Meta’s boldest move yet.

https://en.landingfymax.com.br/artificial-intelligence/llama-4-meta-open-source-sovereignty-2026

DEV Community: Evandro Carvalho

Acesso Remoto Seguro sem Abrir Portas no Roteador: Implementando Redes Mesh com Tailscale e WireGuard

1. Como o Tailscale Fura o CGNAT (NAT Traversal)

2. Instalação e Configuração no Servidor Linux

3. Acessando com MagicDNS sem Decorar IPs

4. Recursos Avançados de Rede

Conclusão e Recursos

PHP2Shell: Como a IA Revelou Vulnerabilidades Críticas no Núcleo do PHP e Acelerou a Defesa de Servidores

1. As Vulnerabilidades no Núcleo do PHP

CVE-2026-109618 — Corrupção de Memória em Out-of-Memory (OOM)

CVE-2026-109619 — Use-After-Free (UAF) e OPcache

2. A Terceira Vulnerabilidade: CVE-2026-115560

3. Versões Corrigidas e Auditoria de Pacotes

Verificação do Pacote no Sistema Operacional

Aplicação das Atualizações e Reinício de Serviços

4. O Impacto da IA na Dinâmica da Segurança

Investigação OSINT na Prática: Como Extrair Metadados EXIF e Analisar Imagens sem Ferramentas Pagas

1. O que Fica Gravado no Cabeçalho EXIF?

2. Extração Rápida com o ExifTool

3. Automatizando a Extração e Limpeza em Python

4. Recomendações de OPSEC (Segurança Operacional)

Conclusão e Recursos

Telemetria de Energia para Home Labs 24/7: Como Medir Consumo e Evitar Sobrecargas com Tomadas Inteligentes

1. Métricas Essenciais de Telemetria Elétrica

2. A Matemática do Custo Mensal

Exemplo Real (Mini PC rodando Docker em Idle a 14W):

3. Automatizando Alertas de Sobrecarga em Python

Conclusão e Recursos

Honeypots em Redes Internas: Como Criar Portas Falsas para Detectar Varreduras e Movimentação Lateral

1. O Conceito: Detectando o Invasor no Primeiro Toque

2. Implementando o Honeypot em Python (asyncio)

3. Rodando com Menor Privilégio no Linux

4. O que Fazer Após o Alerta?

Conclusão e Recursos

GitHub Copilot Privado e Gratuito: Como Usar o Continue.dev no VS Code com Modelos Locais

1. A Stack: Continue.dev + Ollama + Qwen 2.5 Coder

2. Passo 1: Baixando os Modelos no Ollama

3. Passo 2: Configurando o config.json do Continue

4. Usando no Dia a Dia

Conclusão e Recursos

Hardening de Servidores Linux: Como Blindar o SSH com Chaves Ed25519 e Eliminar Ataques de Força Bruta

1. Por que Chaves Ed25519 em vez de RSA?

2. Configurando o /etc/ssh/sshd_config.d/99-hardening.conf

3. Instalando e Ajustando o Fail2ban

Conclusão e Recursos

Reaproveitando Smartphones Antigos como Servidores de IA de Borda com Linux (PostmarketOS / ARM64)

1. Por que postmarketOS em vez de Android/Termux?

2. Preparando o Ambiente Headless

3. Instalando o Ollama no ARM64

4. Escolha e Benchmark de Modelos SLM para Edge

Resultados de Performance (Snapdragon 845 / 6GB RAM):

Conclusão e Recursos

Como Montar um SIEM Doméstico no Linux com Detecção de Intrusos ARP e Fabricante OUI

1. Por que a Tabela ARP e não apenas Nmap?

2. O Script Sentinela em Python

3. Criando um Serviço em Segundo Plano (Systemd)

4. O que Fazer com Dispositivos Desconhecidos?

Conclusão e Recursos

Como Rodar Ollama com Docker e Aceleração de GPU NVIDIA (Guia Prático)

1. Configurando o NVIDIA Container Toolkit (Host)

2. O compose.yaml com Aceleração de GPU

3. Validando se a GPU está ativa dentro do Container

4. Baixando e Testando Modelos

5. Dica Crítica de Segurança de Rede

Como proteger em produção:

Conclusão e Recursos

AI-Powered Zero-Day Chaining: A Deep Dive into Claude Mythos & Project Glasswing

Llama 4 and the Rise of Sovereign AI: Why Open Source Won in 2026

2. Implementando o Honeypot em Python (`asyncio`)

3. Passo 2: Configurando o `config.json` do Continue

2. Configurando o `/etc/ssh/sshd_config.d/99-hardening.conf`

2. O `compose.yaml` com Aceleração de GPU