--- title: "Oktopus Cloud - Nibble: descubra quem está na sua rede local sem transformar o terminal em um laboratório forense" description: Aprenda a usar o Nibble para escanear sua rede local, identificar dispositivos, fabricantes, portas e serviços rapidamente pelo terminal. author: erikperin --- # Nibble: descubra quem está na sua rede local sem transformar o terminal em um laboratório forense Erik Perin 09 Novembro 2026 - - - - - - - - - - [![Nibble: descubra quem está na sua rede local sem transformar o terminal em um laboratório forense](https://www.oktopus.cloud/media/yootheme/cache/85/Nibble-857a14a2.png?src=images/blog/tutoriais/nibbles/Nibble.png&thumbnail=1000,563,&hash=3f7d91b6)](https://www.oktopus.cloud/index.php?option=com_content&view=article&id=20:nibble-descubra-quem-esta-na-sua-rede-local&catid=8) Você abre a tela de dispositivos do roteador e encontra algo parecido com isto: ``` DESKTOP-A12F9C android-7d83 Unknown Unknown ESP_3A91B2 192.168.1.47 ``` Excelente. Agora sabemos que existe um aparelho chamado **Unknown** na rede. A investigação está praticamente encerrada. É justamente para situações assim que ferramentas de descoberta de rede são úteis. Em uma casa, escritório ou laboratório moderno, é comum termos notebooks, celulares, televisores, câmeras, impressoras, servidores, dispositivos IoT, hubs de automação e uma coleção crescente de pequenas caixas que pedem um endereço IP antes mesmo de dizer bom dia. O **Nibble** é uma ferramenta de linha de comando voltada para esse tipo de descoberta. Sua proposta é bastante clara: **varrer redes locais com velocidade, interface amigável e o mínimo possível de cerimônia**. Em vez de exigir uma longa sequência de parâmetros antes de mostrar qualquer coisa, você executa: ``` nibble ``` escolhe a interface de rede e começa a explorar. O programa identifica hosts, fabricantes de hardware, portas abertas e alguns dos serviços encontrados. Tudo isso dentro de uma **TUI interativa**, navegável pelo teclado ou até pelo mouse. É quase como abrir o mapa da sua rede — só que sem precisar desenhar círculos e setas num quadro branco. > Use ferramentas de varredura somente em redes e dispositivos que você administra ou para os quais possui autorização. Descoberta de rede é extremamente útil para administração e troubleshooting, mas continua sendo atividade de rede. --- # O que é o Nibble? O **Nibble** é uma ferramenta CLI de descoberta e varredura de redes locais desenvolvida pela Backend Systems. O projeto é escrito em **Go** e utiliza o framework **Bubble Tea** para criar sua interface interativa no terminal. Sua função principal é bastante direta: ``` Escolher uma interface de rede ↓ Descobrir a sub-rede local ↓ Encontrar hosts ativos ↓ Analisar portas ↓ Identificar serviços e fabricantes ``` O foco do projeto não é ser uma suíte gigantesca de auditoria. O objetivo é fornecer uma ferramenta **rápida, prática e agradável para enxergar o que existe na rede**. Isso torna o Nibble especialmente interessante para administradores Linux, profissionais de infraestrutura, DevOps, suporte técnico, homelabs e usuários que simplesmente querem descobrir por que existem 27 aparelhos conectados ao Wi-Fi quando juravam ter comprado apenas oito. --- # O que o Nibble consegue descobrir? Durante uma varredura, o Nibble pode apresentar informações como: ``` 192.168.1.1 Gateway / roteador 192.168.1.10 Apple 443 HTTPS 192.168.1.25 Raspberry Pi 22 SSH 80 HTTP 192.168.1.42 Ubiquiti 22 SSH 443 HTTPS ``` A aparência real da interface é mais organizada, mas o conceito é esse. O programa é capaz de identificar os hosts encontrados, pesquisar o fabricante associado ao endereço de hardware, testar portas e tentar reconhecer serviços através de suas respostas. O banco de fabricantes utilizado pelo projeto contempla dezenas de milhares de identificadores de vendor. Isso significa que, em vez de descobrir apenas: ``` 192.168.1.67 ``` você pode ter uma pista como: ``` 192.168.1.67 Raspberry Pi Foundation ``` E subitamente aquele IP misterioso começa a parecer bem menos misterioso. --- # Nibble não é apenas um “ping em vários endereços” Uma ferramenta de descoberta de rede poderia simplesmente testar uma sequência de IPs e informar quais responderam. O Nibble vai além. Além de encontrar equipamentos, ele pode verificar portas comuns e identificar serviços associados. Por padrão, o projeto contempla serviços como: ``` SSH Telnet HTTP HTTPS SMB RDP ``` entre outros. Assim, um host pode aparecer associado a informações semelhantes a: ``` 192.168.1.20 22 SSH 80 HTTP 443 HTTPS ``` Isso ajuda bastante na administração. Imagine encontrar: ``` 192.168.1.45 Synology 5000 HTTP 5001 HTTPS ``` Provavelmente estamos olhando para um NAS. Ou: ``` 192.168.1.30 Raspberry Pi 22 SSH ``` Talvez seja aquele Raspberry Pi que você instalou seis meses atrás, colocou atrás do rack e depois deixou a memória humana executar seu tradicional processo de garbage collection. --- # Uma observação importante sobre banners de serviço O Nibble também pode ler **service banners**. Um banner é uma resposta fornecida por determinados serviços quando uma conexão é iniciada. Um servidor SSH, por exemplo, pode devolver algo semelhante a: ``` SSH-2.0-OpenSSH_9.x ``` Um servidor web pode revelar informações relacionadas ao software que está atendendo aquela conexão. Isso permite ao Nibble dar pistas sobre o serviço encontrado. Mas é importante entender a palavra **pista**. Nem todo serviço fornece banners, muitos escondem informações e alguns podem estar executando em portas não convencionais. Portanto: ``` porta aberta ≠ identificação infalível ``` A rede continua tendo direito a seus pequenos mistérios. --- # Uma interface que não parece ter sido desenhada em 1987 Um dos pontos mais interessantes do Nibble é a interface. O projeto utiliza uma **TUI — Terminal User Interface**. Isso significa que ele continua funcionando inteiramente no terminal, mas oferece uma interface visual e navegável. Você pode utilizar o mouse para clicar nos elementos ou navegar usando: ``` ↑ ↓ ← → ``` Também são aceitos: ``` w s a d ``` e, para usuários acostumados ao Vim: ``` h j k l ``` Sim, os três grupos. O Nibble decidiu evitar guerras religiosas entre usuários de teclado. Se você não lembrar os comandos, pressione: ``` ? ``` A ajuda é contextual, portanto as opções exibidas dependem da área da interface em que você estiver. --- # Instalando o Nibble no Linux O projeto oferece várias formas de instalação. ## Ubuntu, Linux Mint, Pop!_OS, Zorin OS e derivados Existe um PPA mantido pelo projeto. Adicione-o: ``` sudo add-apt-repository ppa:backendsystems/ppa ``` Depois instale: ``` sudo apt update sudo apt install nibble ``` Confirme: ``` nibble --help ``` Ou simplesmente execute: ``` nibble ``` --- # Fedora, RHEL e derivados Para sistemas baseados no ecossistema Red Hat, o projeto fornece um repositório COPR. Habilite-o: ``` sudo dnf copr enable @backendsystems/nibble ``` Depois: ``` sudo dnf install nibble ``` Execute: ``` nibble ``` --- # Arch Linux No Arch, o pacote binário está disponível através do AUR. Com `yay`: ``` yay -S nibble-bin ``` Depois: ``` nibble ``` --- # Instalando com Go Como o Nibble é escrito em Go, também pode ser instalado diretamente pelo ecossistema da linguagem: ``` go install github.com/backendsystems/nibble@latest ``` Normalmente, o executável será instalado em: ``` $HOME/go/bin ``` Caso o diretório ainda não esteja no seu `PATH`: ``` export PATH="$HOME/go/bin:$PATH" ``` --- # Instalando com npm Curiosamente, você também pode instalar o Nibble usando npm: ``` npm install -g @backendsystems/nibble ``` Ou executá-lo sem instalação global: ``` npx @backendsystems/nibble ``` O pacote funciona como uma forma de distribuir o binário. Você não está transformando o scanner em JavaScript por acidente. --- # Instalando com pipx Também existe distribuição via Python Package Index: ``` pipx install nibble-cli ``` Novamente, o objetivo aqui é facilitar a distribuição do executável. --- # macOS Com Homebrew: ``` brew install backendsystems/tap/nibble ``` Depois: ``` nibble ``` --- # Windows No Windows: ``` winget install backendsystems.nibble ``` O projeto também fornece binários pré-compilados. --- # Binários prontos As releases oficiais disponibilizam binários para: ``` Linux macOS Windows ``` e arquiteturas: ``` amd64 arm64 ``` Isso é interessante para servidores minimalistas ou máquinas nas quais você simplesmente não deseja configurar outro gerenciador de pacotes. --- # Primeiro scan: descobrindo sua rede Depois da instalação: ``` nibble ``` O Nibble exibirá as interfaces encontradas. A ferramenta utiliza ícones para ajudar a identificar o tipo: ``` 🔌 Ethernet 📶 Wi-Fi 📦 Container 🔒 VPN ``` Imagine uma máquina com: ``` enp3s0 wlan0 docker0 tun0 ``` Em vez de exigir que você descubra sozinho qual delas representa sua conexão doméstica, a interface ajuda a diferenciá-las. Escolha, por exemplo, sua interface Wi-Fi. O Nibble identifica a sub-rede correspondente e inicia a descoberta. Se sua máquina estiver em: ``` 192.168.1.34/24 ``` a rede provavelmente será: ``` 192.168.1.0/24 ``` O programa então analisa os possíveis hosts daquele segmento. Você não precisa calcular manualmente o CIDR para o uso interativo normal. Essa simplicidade é justamente parte da proposta. --- # O que significa `/24`? Se você ainda está começando em redes, algo como: ``` 192.168.1.0/24 ``` pode parecer uma coordenada de submarino. Não é. O `/24` representa a máscara da rede. Simplificando bastante, essa rede normalmente contém endereços no intervalo: ``` 192.168.1.1 até 192.168.1.254 ``` O Nibble consegue usar as informações da interface selecionada para entender qual segmento deve analisar. Isso poupa o usuário de precisar fornecer manualmente: ``` scanner 192.168.1.0/24 ``` durante o fluxo interativo. --- # O Nibble precisa de root? Um dos diferenciais declarados pelo projeto é que o Nibble **não exige privilégios administrativos nem permissões especiais** para seu funcionamento normal. Ou seja, geralmente basta: ``` nibble ``` em vez de: ``` sudo nibble ``` Isso reduz a quantidade de privilégios entregues a uma ferramenta que está interagindo com a rede. É uma característica bastante positiva. Em segurança, executar algo com menos privilégios sempre que possível é uma excelente tradição. --- # “Stealthy” não significa invisível O projeto descreve o Nibble como *stealthy* porque ele **não gera tráfego de rede antes que uma varredura seja iniciada**. É importante interpretar isso corretamente. Isso não significa: > “A ferramenta faz scans indetectáveis.” Quando você inicia uma varredura, naturalmente são feitas conexões e sondagens na rede. Firewalls, IDS, IPS, logs de serviços ou sistemas de monitoramento podem perceber esse tráfego. O que o projeto quer dizer é que o programa permanece quieto enquanto você apenas está navegando pela interface e escolhendo o que analisar. Em outras palavras: ``` Nibble aberto ≠ rede sendo varrida ``` A atividade começa quando você manda começar. --- # Descobrindo fabricantes dos dispositivos Um dos recursos mais úteis para redes domésticas e pequenas empresas é a identificação de fabricantes. Cada interface de rede possui um endereço MAC, por exemplo: ``` B8:27:EB:XX:XX:XX ``` Parte desse endereço pode indicar o fabricante responsável pelo hardware. O Nibble utiliza essa informação para mostrar empresas como: ``` Apple Ubiquiti Raspberry Pi Intel Samsung TP-Link ``` entre muitos outros. O projeto informa suporte a aproximadamente **40 mil identificadores de fabricantes**. Isso facilita bastante a identificação de aparelhos desconhecidos. Se você encontrar: ``` 192.168.1.91 Espressif ``` há boas chances de estar olhando para algum dispositivo IoT baseado em ESP. Pode ser: ``` lâmpada sensor tomada automação microcontrolador ``` Agora o mistério começa a ter contexto. --- # Nibble e redes com muitos dispositivos IoT Esse tipo de ferramenta é especialmente interessante em casas inteligentes. Uma residência pode facilmente possuir: ``` 2 celulares 3 notebooks 3 televisores 4 câmeras 12 lâmpadas 5 tomadas inteligentes 2 assistentes virtuais 1 NAS 1 videogame 1 impressora ``` Subitamente estamos falando de dezenas de hosts. Quando algo para de responder, abrir a administração do roteador nem sempre oferece informações suficientes. Com o Nibble, uma varredura permite observar rapidamente quais dispositivos continuam presentes e quais serviços estão acessíveis. Isso ajuda bastante em troubleshooting. --- # Escaneando portas personalizadas O Nibble permite definir portas específicas para análise. Por exemplo, suponha que você administre uma rede com serviços web e SSH. No modo headless: ``` nibble -i 192.168.1.0/24 -p 22,80,443 ``` Aqui: ``` -i ``` define os alvos. E: ``` -p ``` define as portas. Também podemos informar intervalos: ``` nibble -i 192.168.1.0/24 -p 22,80,443,8000-8100 ``` Assim, além das portas tradicionais, serão verificadas as portas entre: ``` 8000 e 8100 ``` Isso pode ser útil em redes de desenvolvimento, homelabs e servidores internos. --- # Modo Target: quando você já sabe onde olhar Nem sempre queremos analisar toda a rede. Às vezes já sabemos o IP do equipamento: ``` 192.168.1.223 ``` Nesse caso, podemos direcionar a análise para aquele host. O modo headless aceita alvos individuais: ``` nibble -i 192.168.1.223 ``` Ou múltiplos: ``` nibble -i 192.168.1.223,192.168.1.50 ``` Podemos ainda combinar endereços e CIDRs: ``` nibble -i 192.168.1.223,10.0.0.12/32 ``` Isso evita fazer uma descoberta completa quando o objetivo já está definido. --- # Modo Headless: Nibble sem interface Uma das funcionalidades mais interessantes para administradores é o **Headless Mode**. Quando usamos `-i`, o Nibble pode realizar a varredura sem abrir a TUI. Por exemplo: ``` nibble -i 192.168.1.0/24 ``` Nesse modo, a saída é produzida em **JSON**. Isso abre possibilidades para: ``` scripts inventário automação pipelines monitoramento integrações ``` É uma diferença importante entre: ``` nibble ``` e: ``` nibble -i 192.168.1.0/24 ``` O primeiro favorece exploração humana. O segundo favorece automação. --- # Salvando o resultado em um arquivo Utilize: ``` nibble -i 192.168.1.0/24 -o resultados.json ``` O parâmetro: ``` -o ``` faz com que a saída seja gravada em arquivo em vez de enviada para o terminal. Depois: ``` cat resultados.json ``` Ou, se você usa `jq`: ``` jq . resultados.json ``` Isso transforma uma descoberta de rede em dados estruturados que podem ser posteriormente analisados. --- # Usando um arquivo de alvos Também podemos manter os equipamentos que administramos em um arquivo. Por exemplo: ``` 192.168.1.10 192.168.1.20 192.168.1.30 192.168.1.40 ``` Salve como: ``` targets.txt ``` Depois: ``` nibble -i targets.txt -p 22,80,443 ``` Isso é interessante em ambientes onde você deseja verificar periodicamente um conjunto conhecido de equipamentos. --- # Códigos de saída O modo headless possui códigos de saída previsíveis: ``` 0 = sucesso 1 = erro 2 = uso inválido ``` Isso é especialmente importante em shell scripts. Um exemplo simples: ``` nibble -i 192.168.1.0/24 -o scan.json if [ $? -eq 0 ]; then echo "Varredura concluída" else echo "Falha durante a varredura" fi ``` Para automação mais sofisticada, naturalmente podemos tratar cada código separadamente. --- # Histórico de varreduras O modo interativo possui um recurso particularmente útil: **History Mode**. O Nibble mantém registros das varreduras anteriores e permite consultá-los posteriormente. Isso possibilita comparar mentalmente coisas como: ``` Ontem: 21 hosts Hoje: 23 hosts ``` Ou voltar a uma análise anterior e verificar os equipamentos encontrados. O atalho: ``` r ``` permite reescanear as portas dos hosts de uma análise histórica. Além disso, o histórico lembra sua posição entre sessões. Você fecha o programa, volta depois e consegue continuar de onde estava. É uma pequena comodidade que se torna muito agradável quando a rede começa a crescer. Vale notar que **varreduras em modo headless não são salvas nesse histórico interativo**. --- # Docker: descobrindo redes de containers O Nibble também reconhece ambientes Docker. Quando encontra um socket Docker disponível, pode oferecer acesso rápido às redes dos containers. Imagine: ``` docker network ls ``` produzindo: ``` bridge host my_app_network monitoring ``` Essas redes podem conter vários containers com IPs próprios. A integração permite inspecionar esses segmentos sem obrigar o usuário a descobrir manualmente toda a topologia primeiro. Para ambientes de desenvolvimento e homelabs, isso pode ser bastante conveniente. --- # Suporte a WSL O projeto também contempla **Windows Subsystem for Linux**. Quem utiliza Linux dentro do Windows conhece uma dificuldade recorrente: a camada de virtualização e rede pode tornar algumas operações de descoberta menos intuitivas. O Nibble possui suporte para acessar interfaces Windows a partir do WSL. Isso facilita utilizar a ferramenta dentro de um ambiente Linux mesmo quando a conectividade principal pertence ao Windows host. --- # Nibble substitui o Nmap? Não exatamente. E isso é uma coisa boa. O **Nmap** é uma ferramenta extremamente madura, profunda e flexível. Ele oferece uma quantidade enorme de métodos de descoberta, fingerprinting, scripts, detecção de sistema operacional e opções avançadas. O Nibble segue outra filosofia. Pense assim: ``` Nibble ↓ “Quero enxergar rapidamente minha rede.” Nmap ↓ “Quero controlar detalhadamente como essa análise será realizada.” ``` Para descobrir rapidamente dispositivos da sua LAN, fabricantes e serviços comuns, a simplicidade do Nibble é uma grande vantagem. Para auditorias aprofundadas, técnicas de detecção específicas ou análises profissionais mais complexas, ferramentas especializadas continuam tendo seu espaço. Nem toda tarefa precisa começar com 14 opções de linha de comando. Às vezes você só quer descobrir quem está usando o IP `192.168.1.57`. --- # Um fluxo simples para analisar sua rede doméstica Comece executando: ``` nibble ``` Selecione: ``` 📶 Wi-Fi ``` ou: ``` 🔌 Ethernet ``` Deixe a ferramenta descobrir os hosts. Depois observe principalmente: ``` IP fabricante portas serviços ``` Compare os dispositivos encontrados com aquilo que você sabe que existe na casa. Se aparecer: ``` Apple Samsung Raspberry Pi Ubiquiti ``` provavelmente será relativamente fácil identificar os aparelhos. Se surgir algum equipamento desconhecido, primeiro confira se ele não pertence a: ``` TV câmera lâmpada impressora assistente virtual hub smartwatch e-reader videogame ``` A quantidade de coisas que possuem Wi-Fi hoje é uma demonstração diária de que a humanidade aparentemente decidiu que até a cafeteira precisava de TCP/IP. --- # Um host desconhecido significa invasor? Não. Esse é um ponto importante. Encontrar: ``` Unknown ``` não significa automaticamente: > “Há um hacker dentro da minha rede.” A identificação depende de informações disponíveis. Alguns dispositivos usam **MAC Address Randomization**, recurso comum em celulares e notebooks modernos que dificulta identificar o fabricante através do endereço MAC tradicional. Outros simplesmente não fornecem informações suficientes. Além disso, muitos equipamentos IoT aparecem associados ao fabricante do módulo de rede, não à marca escrita na caixa. Uma lâmpada de determinada empresa pode aparecer como: ``` Espressif ``` porque utiliza um chip ESP. Portanto, trate o resultado como investigação, não como veredito. --- # Quando encontrar algo realmente desconhecido Primeiro consulte o painel DHCP do roteador e verifique: ``` hostname MAC IP tempo de concessão ``` Depois desligue temporariamente dispositivos suspeitos conhecidos e observe se o host desaparece. Se necessário, altere a senha do Wi-Fi, utilize WPA2 ou preferencialmente WPA3 quando disponível e revise dispositivos autorizados. Também é uma excelente oportunidade para abandonar aquela senha de Wi-Fi chamada: ``` 12345678 ``` Ela cumpriu seu papel histórico. Pode descansar. --- # O Nibble é seguro? O projeto possui uma política específica de segurança. Um ponto relevante é que os desenvolvedores fornecem correções de segurança apenas para a **versão major mais recente**. Portanto, manter o software atualizado é importante. Em Ubuntu: ``` sudo apt update sudo apt upgrade nibble ``` No macOS: ``` brew upgrade nibble ``` No Windows: ``` winget upgrade nibble ``` Para outras formas de instalação, utilize o mecanismo correspondente. --- # Encontrou uma vulnerabilidade no Nibble? O projeto pede explicitamente que problemas de segurança **não sejam divulgados publicamente antes da correção**. O método preferencial é utilizar o **Private Vulnerability Reporting** do GitHub através da área Security do repositório. Caso isso não seja possível, a recomendação é abrir uma issue genérica solicitando um canal privado, sem revelar detalhes sensíveis publicamente. É uma boa prática para qualquer projeto de segurança. Publicar uma vulnerabilidade inédita com reprodução completa antes de avisar os responsáveis raramente ajuda quem mantém o software. --- # Nibble para inventário rápido Uma aplicação interessante é utilizar o modo JSON como base para inventários. Por exemplo: ``` nibble -i 192.168.1.0/24 -o rede.json ``` O arquivo pode então ser armazenado periodicamente: ``` rede-2026-11-01.json rede-2026-11-08.json rede-2026-11-15.json ``` Com alguma automação, é possível comparar resultados e perceber: ``` novos hosts equipamentos removidos alterações de IP mudanças de serviços ``` O Nibble não é uma plataforma completa de Network Access Control nem um sistema de monitoramento contínuo. Mas como ferramenta de inspeção rápida, o JSON aumenta bastante suas possibilidades. --- # Um pequeno cheatsheet do Nibble Para uso interativo: ``` nibble ``` Para analisar uma sub-rede específica: ``` nibble -i 192.168.1.0/24 ``` Para verificar determinadas portas: ``` nibble -i 192.168.1.0/24 -p 22,80,443 ``` Para incluir um intervalo: ``` nibble -i 192.168.1.0/24 -p 22,80,443,8000-8100 ``` Para analisar apenas um equipamento: ``` nibble -i 192.168.1.50 ``` Para analisar alguns equipamentos: ``` nibble -i 192.168.1.10,192.168.1.20,192.168.1.30 ``` Para carregar alvos de arquivo: ``` nibble -i targets.txt -p 22,80,443 ``` Para salvar em JSON: ``` nibble -i 192.168.1.0/24 -o resultado.json ``` E, dentro da interface: ``` ? ajuda r reescanear hosts no histórico ``` Além da navegação por mouse, setas, WASD ou HJKL. --- # Quando o Nibble é especialmente útil? Ele faz bastante sentido quando você precisa responder rapidamente perguntas como: > Quais dispositivos estão conectados à minha rede? > Qual IP pertence ao meu Raspberry Pi? > Onde foi parar aquele servidor que recebia IP por DHCP? > Quais equipamentos possuem SSH ativo? > Minha câmera IP ainda está online? > Quais hosts existem nesta rede Docker? > Quem é aquele `192.168.1.73` que apareceu do nada? Para esse tipo de situação, a abordagem simples do Nibble funciona muito bem. --- # Conclusão: conhecer sua rede não deveria exigir um mapa do tesouro Redes pequenas deixaram de ser realmente pequenas. Uma casa moderna pode possuir dezenas de endereços IP. Um escritório pequeno pode facilmente ultrapassar uma centena. Acrescente containers, máquinas virtuais, VPNs, câmeras e dispositivos IoT e a ideia de “eu sei tudo que está conectado aqui” começa rapidamente a perder credibilidade. O **Nibble** tenta resolver justamente essa primeira camada do problema. Você executa: ``` nibble ``` escolhe a interface e começa a enxergar a rede. Ele combina descoberta de hosts, identificação de fabricantes, análise de portas, reconhecimento de serviços, histórico, redes Docker, suporte a WSL e uma interface amigável que funciona tanto com teclado quanto com mouse. Quando necessário, o modo headless transforma a mesma ferramenta em algo automatizável: ``` nibble -i 192.168.1.0/24 -o rede.json ``` O resultado é uma ferramenta que ocupa um espaço interessante entre os utilitários básicos e scanners de rede muito mais complexos. Não é uma substituição universal para ferramentas como Nmap e tampouco pretende ser uma plataforma completa de monitoramento. Seu mérito está justamente em outro lugar: **permitir que você entenda rapidamente o que existe na sua rede sem precisar transformar cada descoberta em uma investigação forense**. E talvez essa seja sua melhor característica. Porque se existem 38 dispositivos conectados à sua casa, descobrir quem são eles já é trabalho suficiente. Você não precisa que o scanner também complique a conversa. - - - - - - - - - - --- ## Outros Artigos [![duf no Linux: entenda para onde foi o espaço do seu disco sem decifrar o df](https://www.oktopus.cloud/media/yootheme/cache/c5/Ilustracao%20Isometrica%20do%20duf%20e%20Armazenamento-c5500061.png?src=images/blog/tutoriais/duf/Ilustracao%20Isometrica%20do%20duf%20e%20Armazenamento.png&thumbnail=610,510,&hash=8bb546ce)](https://www.oktopus.cloud/index.php?option=com_content&view=article&id=19:duf-no-linux-entenda-para-onde-foi-o-espaco-do-seu-disco-sem-decifrar-o-df&catid=8) [![Trippy: descubra onde sua rede está tropeçando sem enlouquecer no terminal](https://www.oktopus.cloud/media/yootheme/cache/cb/trippy-cbf06399.avif?src=images/blog/tutoriais/trippy/trippy.avif&thumbnail=610,510,&hash=0a428f52)](https://www.oktopus.cloud/index.php?option=com_content&view=article&id=18:trippy-descubra-onde-sua-rede-esta-tropecando-sem-enlouquecer-no-terminal&catid=8) [![Roteador próprio ou da operadora: o que realmente sustenta sua casa conectada?](https://www.oktopus.cloud/media/yootheme/cache/b0/wifis-b0fdee06.png?src=images/blog/tutoriais/wifi/wifis.png&thumbnail=610,510,&hash=350cab09)](https://www.oktopus.cloud/index.php?option=com_content&view=article&id=15:roteador-proprio-ou-da-operadora-o-que-realmente-sustenta-sua-casa-conectada&catid=8)