netlas-io/netlas-cookbookO objetivo deste guia é muito simples - ensinar qualquer pessoa interessada em segurança cibernética, independentemente do seu nível de conhecimento, como aproveitar ao máximo o Netlas.io.
O objetivo deste guia é ensinar qualquer pessoa interessada em cibersegurança, independentemente do seu nível de conhecimento, a aproveitar ao máximo as Ferramentas de Pesquisa do Netlas. Esta é uma leitura longa. Coletamos o máximo possível de casos de uso simples e demonstramos como automatizá-los.
⭐️ Dê-nos uma estrela para mostrar seu apreço
👁️ Inscreva-se para atualizações
Netlas é um mecanismo de busca projetado para encontrar e analisar informações sobre todos os endereços IP e domínios disponíveis na Internet. O Netlas possui alguns recursos de gerenciamento de superfície de ataque, mas este guia foca principalmente nas Ferramentas de Pesquisa do Netlas e em como usá-las em automações.
O Netlas inclui várias ferramentas de pesquisa:
Usaremos principalmente a pesquisa de Respostas (resultados de varredura da internet), mas todas as ferramentas funcionam da mesma forma. Se você entender como usar a Ferramenta de Pesquisa de Respostas, conseguirá lidar com qualquer outra.
Antes de entrarmos nos detalhes técnicos, vamos ver como o Netlas.io funciona com alguns exemplos simples.
Abra Informações de IP/Domínio do Netlas.io e digite o nome do domínio ou IP. As seguintes informações serão exibidas como resultado:
Se você precisar encontrar nomes de domínio chineses ou outros internacionalizados, converta-os para Punycode. Por exemplo:``` domain:*.xn--fiqs8s
Você pode fazer isso com a ajuda de ferramentas online especiais. Por exemplo - [Charset.org](https://www.charset.org/punycode)
### Procurando por sites que contêm uma certa palavra em seu título
Abra a [pesquisa de respostas do Netlas.io](https://app.netlas.io/responses/) e digite:```
http.title:g*thub
Isso encontrará todos os servidores cujos títulos HTTP contêm a palavra que começa com "g" e termina com "thub". Leia mais sobre o uso de asteriscos abaixo.
Agora vamos aprender mais sobre como as consultas de pesquisa funcionam no Netlas.io.
O Netlas.io é baseado no Elasticsearch, um mecanismo de busca livre, aberto, distribuído e RESTful. E os métodos de pesquisa no Netlas.io são muito semelhantes aos de outros bancos de dados baseados no Elasticsearch.
As pesquisas de Response, DNS, IP e Certificates permitem que você use filtros (campos) nas consultas de pesquisa. Por exemplo:``` http.body:netlas
[Experimente no Netlas](https://app.netlas.io/responses/?q=http.body%3Anetlas&page=1&indices=)
Você pode usar esta consulta para encontrar páginas que contenham a palavra "netlas" dentro da tag <body> html.
Uma lista de filtros disponíveis para cada tipo de busca é exibida no lado direito da página.
Os filtros permitem que você busque servidores com base em muitos parâmetros diferentes. Por exemplo:
* `domain`
* `ip`
* `protocol`
* `certificate`
* `cve`
* `geolocation` (`city`, `continent`, `country`)
e muitos outros.
### Operadores Lógicos
Você pode usar vários filtros em uma única consulta e combiná-los usando operadores lógicos `AND`, `OR`, `NOT`. Por exemplo:```
http.title:netlas NOT port:443
Se você quiser combinar múltiplas condições na sua consulta, use parênteses:``` http.title:(netlas OR shodan) NOT port:443
[Try in Netlas](https://nt.ls/OrFOY)
### Ranges
Se você usar um valor numérico como valor de um campo, pode designá-lo como um valor de e para (limites extremos do intervalo de valores):```
ip:[173.194.222.0 TO 173.194.222.255]
Ou marque apenas o limite superior ou apenas o limite inferior do valor:``` host:"1.1.1.1" port:<=1000
[Experimente no Netlas](https://app.netlas.io/responses/?q=host%3A%221.1.1.1%22%20port%3A%3C%3D1000&page=1&indices=)
### Curingas
Se você não souber a descrição exata de um determinado caractere em sua consulta (por exemplo, você não sabe a zona exata de um domínio ou a grafia de um nome), você pode substituí-lo por um asterisco:```
domain:google.*
Experimente no Netlas Você também pode usar o ponto de interrogação:``` domain:google.?
[Teste no Netlas](https://app.netlas.io/responses/?q=domain%3Agoogle.%3F&page=1&indices=)
`*` - muitos símbolos, `?` - um símbolo.
Você também pode usar asteriscos em filtros. Por exemplo:```
\*.banner:database
Esta consulta realiza uma pesquisa em todos os tipos de banner simultaneamente e substitui vários filtros: amqp.banner:, ftp.banner:, dns.banner:, telnet.banner:, etc.
Se precisar pesquisar não pelo valor exato, mas pelo valor aproximado de um campo (por exemplo, páginas cujos títulos contenham todos os nomes consoantes com Joseph), basta adicionar ~ à consulta:```
http.title:Joseph~
[Try in Netlas](https://app.netlas.io/responses/?q=http.title%3AJoseph~&page=1&indices=)
### Expressões Regulares
Expressão regular é uma sequência de caracteres que permite pesquisar, recuperar e substituir partes de texto em um documento fonte que correspondem a certos padrões. Por exemplo:
* Qualquer endereço de e-mail: ```text
([a-zA-Z0–9+._-]+@[a-zA-Z0–9._-]+\.[a-zA-Z0–9_-]+)
Para mais informações sobre o uso de expressões regulares, veja os exemplos no Netlas Cookbook (o que você está lendo agora) e os links abaixo:
Regex Syntax Manual na documentação do Elasticsearch
Como expressões regulares podem ser úteis em OSINT. Teoria e alguma prática usando Google Sheets
Você pode salvar seus resultados (todos ou campos selecionados) no formato JSON e CSV para visualizá-los em um formato de sua preferência ou analisá-los automaticamente com diferentes ferramentas.
Você pode agrupar resultados por diferentes valores de campo para acelerar o tempo de pesquisa. Por exemplo, por nome de domínio ou geolocalização.
Você pode compartilhar livremente links para resultados de pesquisa (nenhum registro é necessário para abri-los, a menos que o usuário tenha excedido o limite gratuito de 50 requisições).
Lembre-se também de que todas as consultas que você fez podem ser visualizadas na sua página de perfil (link no canto superior direito).
A função mais importante do Netlas.io é ajudar as pessoas a conduzir pesquisas em segurança cibernética de forma mais rápida e eficiente. O serviço possui uma API (interface de programação de aplicações) que permite automatizar a execução de várias requisições.
Pode ser implementada tanto em scripts simples de Python ou Bash com poucas linhas de código quanto em aplicações complexas e multifuncionais.
Você pode ler mais sobre o uso da API Netlas no Netlas Cookbook (o que você está lendo agora) ou na documentação oficial:
Este é o primeiro lugar para começar com a API. Você nem precisa pagar por uma assinatura (50 requisições por dia são gratuitas). Basta ir para a página de perfil.
Você não precisa escrever scripts ou criar aplicações para começar a usar a API Netlas. Pode simplesmente testá-la usando seu cliente de API favorito. Veja instruções aqui.
Semelhante a outras APIs, a resposta da API Netlas consiste em cabeçalhos e um corpo de resposta no formato JSON (JavaScript Object Notation). Os arquivos JSON contêm dados no formato chave-valor e podem ser analisados usando praticamente qualquer linguagem de programação.
Se você usar o Swagger, pode copiar ou baixar o corpo da resposta e visualizá-lo em qualquer editor de texto ou analisador JSON.
Uma pequena dica que será útil ao escrever código usando a API Netlas. Para entender a estrutura de um arquivo JSON mais rapidamente e encontrar o caminho para obter um determinado valor, use ferramentas especiais como:
A maneira mais fácil de automatizar requisições para a API Netlas é usar uma biblioteca Python especialmente projetada (pacote).
Repositório Github da biblioteca Netlas-Python
Vamos ver como funciona com um exemplo simples. Todos os exemplos de código do Netlas Cookbook estão localizados na pasta scripts. Você pode clonar este repositório e executá-los em seu dispositivo:```shell git clone https://github.com/netlas-io/netlas-cookbook
Se você nunca executou scripts Python antes e não sabe como fazer, você pode começar abrindo o repositório Netlas CookBook no Gitpod.
Gitpod é um ambiente de desenvolvimento em nuvem baseado no Ubuntu (distribuição Linux). Apenas abra este link no seu navegador (faça login com sua conta do Github):
[Run Netlas Cookbook in Gitpod](https://gitpod.io#https://github.com/netlas-io/netlas-cookbook)
Instale a biblioteca Python do Netlas usando pip (instalador de pacotes do Python). Digite na linha de comando:```shell
pip install netlas
Verifique a instalação. Digite na linha de comando:```shell netlas --help
Execute netlas_python_example.py:```shell
python3 scripts/netlas_python_example.py
E, claro, você pode simplesmente copiar o código e salvar em arquivos. Aqui está o código do primeiro exemplo:```python import netlas
apikey = "YOUR API KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
port:7001netlas_query = netlas_connection.query(query="port:7001")
for response in netlas_query['items']: print(f"{response['data']['ip']}:{response['data']['port']}{response['data']['path']} [{response['data']['protocol']}]")
### Exemplos de Chaves de Resposta para Obter Dados Úteis
Foi mencionado acima que, para encontrar as patches JSON da resposta da API e obter os dados necessários, você pode usar aplicativos online especiais (JSON-evaluators). Para tornar sua vida ainda mais fácil, aqui está uma pequena lista de exemplos de chaves de resposta da biblioteca Python que são mais frequentemente necessárias.```python
# Main domain/ip info
response['data']['uri']
response['data']['ip']
response['data']['http']['title']
response['data']['http']['meta']
response['data']['http']['body']
# Geo info
response['data']['geo']['continent']
response['data']['geo']['country']
response['data']['geo']['city']
response['data']['geo']['location']['lat']
response['data']['geo']['location']['long']
# Whois geo info
response['data']['whois']['net']['country']
response['data']['whois']['net']['address']
response['data']['whois']['net']['city']
response['data']['whois']['net']['contacts']['emails']
response['data']['whois']['net']['contacts']['phones']
# Http status and favicon ico info
response['data']['port']
response['data']['http']['status_code']
response['data']['http']['status_line']
response['data']['http']['favicon']['image']
response['data']['http']['favicon']['path']
# Basic CVE info
response['data']['cve'][0]['name']
response['data']['cve'][0]['description']
response['data']['cve'][0]['base_score']
response['data']['cve'][0]['has_exploit']
response['data']['cve'][0]['exploit_links']
Ao trabalhar com a Netlas Python Library, é muito importante especificar corretamente o tipo de dados que você deseja recuperar. Por padrão, o tipo response é retornado e muitos exemplos do Netlas CookBook o utilizam.
Mas para algumas tarefas, como obter informações whois sobre um domínio ou pesquisar domínios em uma sub-rede, você precisa usar um tipo de dados diferente. Por exemplo:```python netlas_query = netlas_connection.query(query='a:"163.114.132.0/24"',datatype="domain")
Se acha que alguma consulta não está retornando resultados quando deveria - basta tentar alterar o valor do parâmetro **datatype**. É muito provável que isso ajude.
Datatypes disponíveis:
- **datatype="response"** corresponde aos resultados que podem ser obtidos em [Netlas Responses Search](https://app.netlas.io/responses/).
- **datatype="domain"** corresponde aos resultados que podem ser obtidos em [Netlas DNS search](https://app.netlas.io/domains/)
- **datatype="domain-whois"** corresponde aos resultados que podem ser obtidos em [Netlas Domain Whois Search](https://app.netlas.io/whois_domains/).
- **datatype="ip-whois"** corresponde aos resultados que podem ser obtidos em [Netlas IP Whois Search](https://app.netlas.io/whois_ip/).
- **datatype="cert"** corresponde aos resultados que podem ser obtidos em [Netlas Certificates Search](https://app.netlas.io/certs/).
### Ferramentas CLI do Netlas
Você também pode usar a Biblioteca Python do Netlas diretamente da linha de comando. Por exemplo:```bash
netlas search "http.title:johnsmith" -f json >results.json
Este comando simples procura por todos os servidores que têm a palavra johnsmith em seu cabeçalho, retorna os resultados em formato JSON e armazena os resultados no arquivo resutls.json.
Todos os outros recursos da API Netlas podem ser usados da mesma forma. Você pode aprender mais sobre isso a partir da ajuda (comando -h) e exemplos no Netlas Cookbook (o que você está lendo agora).``` Usage: netlas [OPTIONS] COMMAND [ARGS]...
Options: -h, --help Show this message and exit.
Commands: count Calculate count of query results. download Download data. host Host (ip or domain) information. indices Get available data indices. profile Get user profile data. savekey Save API key to the local system. search (query) Search query. stat Get statistics for query.
Antes de executar diferentes comandos das Ferramentas CLI do Netlas, salve a chave da API nas configurações:```bash
netlas savekey YOUR_API_KEY
We also have a Github repository with a couple of examples of automating various tasks using bash script and Netlas CLI tools:
A API Netlas tem muitos métodos, mas os métodos mais comumente usados são search e download. Eles são muito semelhantes entre si, mas ainda têm algumas diferenças.
O método search carrega uma página de resultados (20 itens) por vez e permite carregar no máximo 200 páginas (20*200=4000 itens). O método download baixa todos os resultados (mas requer mais recursos para executar).
Há também um método host que simplesmente retorna as informações mais básicas sobre um domínio ou IP específico (datatype (como outros métodos) não precisa ser especificado):```bash netlas host "51.159.153.170"
### Parâmetros Adicionais de Solicitação
A API Netlas permite ajustar flexivelmente os dados retornados pelas solicitações com parâmetros adicionais. Por exemplo:
* indices - id que corresponde a uma data de indexação específica. Para descobrir o id de uma data específica, abra app.netlas.io, clique no calendário à direita da barra de entrada da consulta de pesquisa, selecione a data de seu interesse e veja como o parâmetro indices na URL na barra de endereços do navegador muda.
* start - número da página de resultados (padrão 0)
* fields - nomes dos campos a serem incluídos nos resultados (todos os campos por padrão). Será útil para acelerar e otimizar o código com um grande número de solicitações.
### Fazer Solicitações com Python (sem a Biblioteca Python Netlas)
Pode ser mais fácil em alguns casos não usar a Biblioteca Python Netlas, mas usar o pacote de solicitação Python padrão, que é familiar para muitos desenvolvedores:
Digite na linha de comando:```bash
python scripts/python_example.py
Código-fonte de python_example.py:```python import requests
response = requests.get("https://app.netlas.io/api/domains/?q=ivanov.com&source_type=include&start=0&fields=*",{'X-API-Key': 'YOUR API KEY'})
print(response.json())
Mas a biblioteca Netlas Python ainda é preferível, pois foi projetada para lidar com diferentes problemas no processamento de consultas (erros, longas esperas, etc.).
### Exemplos para Outras Linguagens de Programação
Embora recomendemos o uso da nossa biblioteca Python para automatizar a pesquisa no Netlas, vale notar que a API do Netlas pode ser incorporada na maioria das aplicações com uma grande variedade de stacks tecnológicas. O principal é que ela seja capaz de fazer **requisições REST** e **analisar dados JSON**.
Aqui estão alguns exemplos em diferentes linguagens de programação populares.
#### NodeJS <!-- omit in toc -->
Digite na linha de comando:```bash
node scripts/node_example.js
Se você não estiver usando Gitpod, você deve ter NodeJS instalado no seu dispositivo.
Código-fonte de nodejs_example.js:```javascript fetch('https://app.netlas.io/api/domains/?q=ivanov.com&source_type=include&start=0&fields=*', { headers: { "X-API-Key": "YOUR_API_KEY", }, }) .then((response) => response.text()) .then((body) => { var jsonArray = JSON.parse(body); console.log(jsonArray['items'][0]); });
#### Ruby <!-- omit in toc -->
Digite na linha de comando:```bash
ruby scripts/ruby_example.rb
Se você não estiver usando o Gitpod, deve ter o Ruby instalado no seu dispositivo.
Código-fonte do ruby_example.rb:```ruby require 'net/http' require 'uri' require 'json'
uri = URI("https://app.netlas.io/api/domains/?q=ivanov.com&source_type=include&start=0&fields=*") req = Net::HTTP::Get.new(uri) req['X-API-Key'] = "YOUR_API_KEY"
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') { |http| http.request(req) }
jsonArray = JSON.parse(res.body)
puts jsonArray['items'][0]['data']['domain']
#### Bash <!-- omit in toc -->
Digite na linha de comando:```bash
bash scripts/bash_example.sh
Código fonte de bash_example.sh:```
curl -X 'GET'
'https://app.netlas.io/api/domains/?q=ivanov.com&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[0].data.last_updated
### Utilitário JQ
Observe que no exemplo acima, o utilitário JQ foi usado para extrair campos de dados JSON.
Às vezes é referido como "like sed for JSON data". É uma ferramenta surpreendentemente útil para trabalhar com qualquer dado JSON. Aqui estão alguns exemplos de sintaxe.
Imprimir o primeiro item do JSON-array:```
.items[0]
Imprima todos os itens do array JSON:``` .items[]
Imprima todos os subitens 'data' do primeiro item do array JSON:```
.['items'][0]['data'][]
Imprimir todos os sub-subitens para cada item do array JSON:``` .items[].data.technical[]
Pode ler mais sobre JQ aqui (recomendo prestar atenção especial à filtragem de dados): [Documentação da utilidade JQ](https://jqlang.github.io/jq/)
### Ferramentas de IA para Escrever Código
Se encontrar algum problema ao personalizar os exemplos do Netlas Cookbook, recomendamos que procure ajuda de ferramentas de IA para melhorar e escrever código. Por exemplo:
[ChatGPT](https://chatgpt.com)
[Code Llama](https://huggingface.co/spaces/codellama/codellama-playground)
[You.com](https://you.com/)
Ao trabalhar com esses serviços, basta descrever em palavras a tarefa que deseja resolver com a ajuda de código.
### Verificadores de Código
Ao reformular os exemplos do Netlas Cookbook para atender às suas necessidades, pode descobrir que o código não será executado devido a alguns erros. Ferramentas online especiais podem ajudá-lo a encontrá-los e corrigi-los:
[ExtendsClass Python Tester](https://extendsclass.com/python-tester.html)
[Snyk](https://snyk.io/code-checker/python/)
Se não quiser copiar o seu código para serviços de terceiros, pode verificá-lo quanto a erros no seu dispositivo usando o Pylint (analisador de código estático):
[Pylint Python Package](https://pypi.org/project/pylint/)
## Usando o Netlas.io para OSINT (Inteligência de Fontes Abertas)
O Netlas.io pode ajudá-lo a recolher dados sobre um domínio ou empresa, bem como encontrar menções a uma pessoa (ou qualquer um) na internet.
Também pode ser usado para encontrar versões antigas de páginas web (como um análogo da Wayback Machine).
### Procurar Apelido ou Email de Pessoa nos Contactos WHOIS
Na maioria das vezes, os dados WHOIS contêm apenas as informações de contacto da empresa que regista os domínios. Mas às vezes pode haver contactos pessoais de pessoas de interesse. Esta consulta ajudará a encontrá-los.
*Este método pode exigir uma subscrição paga.* [Veja os preços](https://netlas.io/pricing/)
**Exemplo de consulta de pesquisa**
```
whois.related_nets.contacts.emails:sweetwater
Exemplo de requisição de API
Ferramentas CLI do Netlas:```bash netlas search "whois.related_nets.contacts.emails:sweetwater*" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=whois.related_nets.contacts.emails%3Asweetwater*&fields=' \
-H 'accept: application/json' \
-H 'X-API-Key: aqkd8L4MR93Tkcaz2UXDXrRleV8Vlvbv' | jq .items[].data.uri
Exemplo de código (Biblioteca Python Netlas)
Execute na linha de comando:```bash python scripts/osint/whois_email_search.py
Código fonte de scripts/osint/whois_email_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `whois.related_nets.contacts.emails:sweetwater`
netlas_query = netlas_connection.query(query="whois.related_nets.contacts.emails:sweetwater*")
# iterate over data and print: URL, Country, Related nets data
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['geo']['country'])
print (response['data']['whois']['related_nets'])
O Netlas permite pesquisar menções de certas palavras em cabeçalhos e no código html de páginas web. Você pode pesquisar palavras por correspondência exata, por correspondência aproximada (veja a seção de consultas fuzzy) e substituir caracteres dos quais não tem certeza por asteriscos.
Exemplo de consulta de pesquisa
```
http.title:sweetwater OR http.body:sweetwater
[Experimente no Netlas](https://app.netlas.io/responses/?q=http.title%3Asweetwater%20OR%20http.body%3Asweetwater&page=1&indices=)
**Exemplo de requisição API**
Ferramentas CLI do Netlas:```bash
netlas search "http.title:sweetwater OR http.body:sweetwater" -f json
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=whois.related_nets.contacts.emails%3Asweetwater*&fields='
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
**Exemplo de código (Biblioteca Python Netlas)**
Execute na linha de comando:```bash
python scripts/osint/title_body_search.py
Código fonte de scripts/osint/title_body_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.title:sweetwater OR http.body:sweetwaternetlas_query = netlas_connection.query(query="http.title:sweetwater OR http.body:sweetwater*")
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri']) print (response['data']['http']['title'])
### Procura por "Arquivos de Informações Suculentas" em Subdomínios do Site da Empresa
Metagoofil tem sido uma ferramenta popular entre praticantes de OSINT há muitos anos. Ela pesquisa no Google por arquivos de documentos no site de uma empresa (pdf, xlsx, docx etc) e analisa seus metadados.
E o que não é indexado pelo Google pode ser encontrado com o Netlas e depois baixado para o seu computador e analisado com a ferramenta [MetaDetective](https://github.com/franckferman/MetaDetective).```
uri:*lidl.* AND http.body:pdf
Podes substituir o filtro uri: por domain: e host: (recomendo sempre comparar os resultados ao usar estes três filtros).
Também podes pesquisar por uma grande variedade de extensões de ficheiro, dependendo do que queres encontrar. Por exemplo:``` http.body:xls http.body:xlsx http.body:doc http.body:docx http.body:ppt http.body:pptx http.body:mdb http.body:csv http.body:sql http.body:sqlite
**Exemplo de requisição API**
Netlas CLI Tools:```bash
netlas search "uri:*lidl.* AND http.body:pdf"
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=uri%3A*lidl.*%20AND%20http.body%3Apdf&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.domain
**Exemplo de código (Netlas Python Library)**
Execute na linha de comando:```bash
python scripts/osint/juicyinfo_search.py
Código fonte de scripts/osint/juicyinfo_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
uri:*lidl.* AND http.body:pdfnetlas_query = netlas_connection.query(query='uri:lidl. AND http.body:pdf')
for response in netlas_query['items']: print (response['data']['uri']) print (response['data']['http']['body'])
Para automatizar links para documentos PDF a partir do corpo da página web, você pode usar o pacote Python [Re](https://docs.python.org/3/library/re.html).
### Pesquisa de Menções a Números de Telefone
Assim como com apelidos e e-mails, você também pode procurar menções a um número de telefone no código de páginas web ou nas informações de contato do WHOIS.
Destacamos esta tarefa como um exemplo separado, porque a pesquisa por um número de telefone é complicada pelo fato de que ele pode ser escrito em diferentes formatos.
**Exemplo de consulta de pesquisa**
```
http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999
Ao fazer uma requisição, você deve levar em consideração o formato de registro do número de telefone aceito no país que possui o número de telefone no qual você está interessado.
Exemplo de requisição da API
Netlas CLI Tools:```bash netlas search "http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999" -f json
Não se esqueça de que você pode procurar números de telefone não apenas no corpo da página, mas também nas informações de contato WHOIS. Isso pode ser feito usando o filtro **whois.related_nets.contacts.phones:**
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.body%3A1%3F234%3F567%3F89%3F99%20OR%20http.body%3A12345678999%20OR%20http.body%3A1234%3F5678%3F999&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' jq .items[].data.uri
Exemplo de código (Biblioteca Python Netlas)
Execute na linha de comando:```bash python scripts/osint/phonenumber_search.py
Código-fonte de scripts/osint/phonenumber_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999`
netlas_query = netlas_connection.query(query="http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999")
# iterate over data and print: ip, url
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['uri'])
Vamos imaginar que você é um músico e deseja encontrar todos os sites onde suas faixas estão publicadas. Você pode fazer isso pesquisando por páginas que mencionam seu nome e que contêm links para arquivos com a extensão .mp3.
Exemplo de consulta de pesquisa
```
(http.title:alla OR http.body:alla) AND http.body:*.mp3
[Experimente no Netlas](https://nt.ls/HEhJj)
**Exemplo de requisição à API**
Netlas CLI Tools:```bash
netlas search "(http.title:alla OR http.body:alla) AND http.body:*.mp3" -f json
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=(http.title%3Aalla%20OR%20http.body%3Aalla)%20AND%20http.body%3A*.mp3&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.http.title
**Exemplo de código (Netlas Python Library)**
Execute na linha de comando:```bash
python scripts/osint/file_mentions_search.py
Código fonte de scripts/osint/file_mentions_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
(http.title:alla OR http.body:alla) AND http.body:*.mp3netlas_query = netlas_connection.query(query="(http.title:alla OR http.body:alla) AND http.body:*.mp3")
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri']) print (response['data']['http']['title'])
### Coleta de Informações WHOIS de Domínio
WHOIS é um banco de dados público mundial que armazena informações sobre todos os domínios registrados no mundo.
**Exemplo de consulta de pesquisa**
Use [Pesquisa de Domínio WHOIS](https://app.netlas.io/whois_domains/)```
github.com
Exemplo de requisição de API
Netlas CLI Tools:```bash netlas host github.com -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/whois_domains/?q=github.com&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.technical.street
Exemplo de código (Biblioteca Python Netlas)
Execute na linha de comando:```bash python scripts/osint/whois_search.py
Código-fonte de scripts/osint/whois_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from whois for google.com domain
netlas_query = netlas_connection.query(query="google.com",datatype="whois-domain")
# iterate over data and print: owner name
for response in netlas_query['items']:
print (response['data']['technical']['name'])
A tag <address> está localizada dentro da tag <head> de uma página web e pode conter endereços físicos. Com uma pesquisa usando esta tag, você pode encontrar sites associados a uma rua específica e, às vezes, até mesmo a um edifício específico.
Exemplo de consulta de pesquisa
```
http.contacts.address:kirby
[Experimente no Netlas](https://app.netlas.io/responses/?q=http.contacts.address%3Akirby&page=1&indices=)
Você também pode usar http.contacts.email: para pesquisa de e-mail.
**Exemplo de solicitação de API**
Ferramentas CLI do Netlas:```bash
netlas search "http.contacts.address:kirby" -f json
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=http.contacts.address%3Akirby&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.http.contacts
**Exemplo de código (Biblioteca Python Netlas)**
Executar na linha de comando:```bash
python scripts/osint/contacts_search.py
Código fonte de scripts/osint/contacts_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.contacts.address:kirbynetlas_query = netlas_connection.query(query="http.contacts.address:kirby")
for response in netlas_query['items']: print (response['data']['uri']) print (response['data']['http']['contacts'])
### Pesquisar Nome do Autor em Meta Tags
As tags `<meta>` estão localizadas dentro da tag `<head>` de uma página web e contêm as palavras-chave mais importantes, descrição, informações de serviço diversas e o nome do autor.
Pesquisar por apelido e nome/sobrenome através de meta tags (http.meta) permite encontrar sites associados a uma pessoa específica mais rapidamente do que pesquisar todo o código HTML (http.body).
**Exemplo de consulta de pesquisa**
```
http.meta:nazar
Exemplo de requisição de API
Ferramentas CLI do Netlas:```bash netlas search "http.meta:nazar" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.meta%3Anazar&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.http.meta
Exemplo de código (Netlas Python Library)
Execute na linha de comando:```bash python scripts/osint/author_meta_search.py
Código fonte de scripts/osint/author_meta_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.meta:nazar`
netlas_query = netlas_connection.query(query="http.meta:nazar")
# iterate over data and print: ip, url
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['http']['title'])
print (response['data']['http']['meta'])
Além do nome do autor, as meta tags podem conter uma variedade de informações: codificação, idioma, permissão para indexação da página por robôs de mecanismos de busca, texto para cartões de links em redes sociais, metadados OpenGraph e muito mais. Aqui estão mais alguns exemplos de meta tags que podem conter informações úteis para investigações:
<meta name="description"> - descrição do conteúdo da página web.<meta name="keywords"> - palavras-chave que descrevem o conteúdo da página web.<meta name="generator"> - nome da ferramenta que foi usada para gerar o conteúdo da página (útil para pesquisar CMS e plataformas de hospedagem).<meta name="copyright"> - nome da pessoa ou empresa que detém os direitos autorais do conteúdo da página web.Outro passo importante na busca por informações sobre uma pessoa ou empresa é procurar sua menção no texto dos banners de servidores FTP. É possível que o endereço IP dos servidores encontrados seja a chave para encontrar outros sites relacionados à pessoa ou empresa de seu interesse. E, com muita sorte, encontrar algo interessante nos arquivos ali disponibilizados (se o servidor FTP estiver aberto).
Exemplo de consulta de pesquisa
```
ftp.banner:"Collado"
Se precisar procurar por servidores FTP por algum outro parâmetro (como cidade ou faixa de endereço IP), então use o filtro prot7:ftp.
[Experimente no Netlas](https://app.netlas.io/responses/?q=ftp.banner%3A%22Collado%22%20&page=1&indices=)
**Exemplo de solicitação de API**
Ferramentas de linha de comando do Netlas:```bash
netlas search 'ftp.banner:"Collado"' -f json
Note que quando aspas duplas são usadas em consultas, a própria consulta é escrita entre aspas simples.
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=ftp.banner%3A%22Collado%22&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
**Exemplo de código (Netlas Python Library)**
Execute na linha de comando:```bash
python scripts/osint/ftp_banner_search.py
Código-fonte de scripts/osint/ftp_banner_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
ftp.banner:"Collado"netlas_query = netlas_connection.query(query='ftp.banner:"Collado"')
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri']) print (response['data']['ftp']['banner'])
### Pesquisar por Informações de Contato em Certificados SSL
Um Certificado SSL é um certificado digital que autentica um site e permite o uso de uma conexão criptografada. Ele pode conter informações sobre seu proprietário: nome da pessoa de contato, nome da organização, país e, às vezes, até mesmo o endereço e o código postal. Você pode pesquisar essas informações usando os seguintes filtros (e muitos outros):
- `certificate.issuer.email_address`
- `certificate.issuer.given_name`
- `certificate.issuer.organization`
- `certificate.issuer.postal_code`
- `certificate.issuer.street_address`
- `certificate.issuer.surname`
Vamos tentar encontrar endereços IP que tenham uma determinada palavra no endereço em seu certificado:```
certificate.issuer.street_address:*mcgill*
Exemplo de requisição à API
Netlas CLI Tools:```bash netlas search "certificate.issuer.street_address:mcgill" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=certificate.issuer.street_address%3A*mcgill*&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' jq .items[].data.uri
Exemplo de código (Biblioteca Python Netlas)
Execute na linha de comando:```bash python scripts/osint/certificates_search.py
Código fonte de scripts/osint/certificates_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `certificate.issuer.street_address:*mcgill*`
netlas_query = netlas_connection.query(query="certificate.issuer.street_address:*mcgill*")
print (type(netlas_query))
# iterate over data and print: ip, url, cetificate issuer
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['certificate']['issuer'])
O Archive.org tem sido usado por especialistas em OSINT para pesquisar versões antigas de sites e páginas de perfis de redes sociais, a fim de encontrar informações de contato e outros dados que foram excluídos.
Mas, infelizmente, o archive.org não salva cópias de todos os sites e não o faz com muita frequência (para alguns sites, apenas algumas vezes por ano ou menos).
No entanto, o Netlas também salva versões antigas de sites desde 2021!
Os seguintes filtros são mais frequentemente usados para pesquisar sites:``` http.title:"github.com"
domain:github.com
host:github.com
Se você clicar no ícone mais externo à direita, ao lado do campo para inserir consultas de pesquisa, verá um menu para selecionar uma data de varredura. Você pode usá-lo para filtrar os códigos html de sites salvos em uma data específica.
Para ver como o site se parece, copie o conteúdo do campo "body" (aba de resposta) para qualquer editor de texto e exclua os caracteres \t\r\n do código html.
Depois disso, copie o código para um dos visualizadores de html online, como [Code beautify](https://codebeautify.org/htmlviewer). Ou apenas salve o arquivo no formato html e depois abra-o no navegador.
### 9 Maneiras de Pesquisar Sites Relacionados
Ao reunir informações sobre uma pessoa ou empresa, pode ser importante encontrar o maior número possível de sites que possam estar relacionados a eles de alguma forma. Existem pelo menos 5 maneiras de fazer isso com o Netlas.
1. ID para vários serviços (analytics, sistemas de publicidade, aplicativos para integração com redes sociais e sistemas de publicação). A sobreposição deles pode indicar que uma pessoa ou equipe estava envolvida. Alguns exemplos:
Google Analytics:```
http.tracker.google_analytics:"G-X82FSVSMTV"
Google Tag Manager:``` http.tracker.google_analytics:"GTM-N6462KFQ"
AddThis:```
http.body:"AT-ra-500bcd681b192302"
Facebook Pixel:``` http.tracker.facebook_pixel:317853189093681
Yandex Metrika```
http.tracker.yandex_metrica:89723437
Amazon Publisher Servies:``` http.body:APS-XXXX
Sim, tudo isso é encontrado no código em alguns sites.
E uma série de outros identificadores que geralmente podem ser encontrados no topo do código HTML (mas às vezes em todo o código).
[Experimente no Netlas](https://nt.ls/BCrw9)
2. ID de programas de afiliados (use também http.body para pesquisá-lo). Você pode encontrá-los em links de afiliados que uma pessoa publica em outros sites ou em redes sociais. Estes podem ser os seguintes parâmetros de URL (e similares):```
aff_fcid=
user_id=
partner_id=
ref_id=
```
"GitHub, Inc."
[Experimente no Netlas](https://app.netlas.io/whois_domains/?q=%22GitHub%2C%20Inc.%22&page=1&indices=)
4. Pesquise por servidores de correio na pesquisa DNS do Netlas
```
mx:*.parklogic.com
```
ns:ns?.parklogic.com
[Experimente no Netlas](https://app.netlas.io/domains/?q=mx%3A*.parklogic.com&page=1&indices=)
6. Pesquisa de menções a ficheiros (principalmente logótipos e avatares de utilizadores) [->](https://github.com/netlas-io/netlas-cookbook#search-file-mentions-looking-for-content-that-may-be-infringing-on-copyrights)
7. Pesquisa de subdomínios [->](https://github.com/netlas-io/netlas-cookbook#search-subdomains)
8. Pesquisa de contactos Whois (na pesquisa de respostas do Netlas) [->](https://github.com/netlas-io/netlas-cookbook#search-persons-nickname-or-email-in-whois-contacts)
9. Pesquisa de favicons [->](https://github.com/netlas-io/netlas-cookbook#favicon-search)
## Scraping (Extrair dados do corpo da página web)
A API Netlas é uma excelente ferramenta para recolher contactos e outros dados de websites. Primeiro, permite fazê-lo rapidamente. Segundo, não requer o uso de proxy. Terceiro, permite recolher dados de sites que estão atualmente indisponíveis.
No entanto, existem algumas desvantagens: a Netlas apenas analisa as páginas principais dos sites e alguns sites raros não estão incluídos na sua base de dados devido a proteção. Mas ainda pode ser de grande utilidade.
Existem três abordagens principais para scraping: recolha de informação a partir de tags HTML e seletores CSS, extração de dados usando expressões regulares e AI scraping. Vamos analisar mais detalhadamente as duas primeiras.
### Pacote Beatifulsoup
[Beatifulsoup](https://pypi.org/project/beautifulsoup4/) é um dos pacotes Python mais populares do mundo para análise de código HTML e ficheiros XML. Vamos experimentar usá-lo para extrair títulos de página (de tags \<h1>, NÃO de tags \<title>).
Primeiro, instale o pacote:```bash
pip install beautifulsoup4
E execute scripts/osint/scraping_beatifulsoup.py:```bash python scripts/osint/scraping_beatifulsoup.py
Código fonte de scripts/osint/scraping_beatifulsoup.py:```python
import netlas
from bs4 import BeautifulSoup
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.body:shop`
netlas_query = netlas_connection.query(query="http.body:shop")
# iterate over data and print: URL, h1 tags from body
for response in netlas_query['items']:
print (response['data']['uri'])
soup = BeautifulSoup(response['data']['http']['body'], "html.parser")
try:
print(soup.find("h1").get_text())
except Exception:
print("no h1 tags")
pass
Você pode extrair dados de outros elementos de páginas web de forma semelhante:``` soup.find("h3").get_text() soup.find("id='loginform'").get_text() soup.find("class='forms'").get_text() soup.find("href='https://example.com'").get_text()
Se você quiser encontrar todos os elementos de um determinado tipo, use o método find_all().
### Pacote Re
O [Re](https://docs.python.org/3/library/re.html) é um pacote Python pré-instalado para pesquisar e recuperar dados usando expressões regulares. É útil para extrair informações de contato de páginas web e muitas outras tarefas. Vamos ver um exemplo de como funciona.
Execute scripts/osint/scraping_re.py:```bash
python scripts/osint/scraping_re.py
Código fonte de scripts/osint/scraping_re.py:```python import netlas import re
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.body:shopnetlas_query = netlas_connection.query(query="http.body:shop")
for response in netlas_query['items']: print (response['data']['uri']) emails = re.findall("[a-zA-Z0-9-.]+@[a-zA-Z0-9-.]+", response['data']['http']['body']) try: print(emails) except Exception: print("no emails") pass
Da mesma forma, você pode extrair links, números de telefone, endereços de carteiras de criptomoedas e muito mais. Padrões prontos podem ser encontrados em bibliotecas de expressões regulares:
[Regex Lib](https://regexlib.com/)
[UI Bakery Regex Library](https://uibakery.io/regex-library)
[Regex 101](https://regex101.com/)
### Outros Pacotes Python para Raspagem (Scraping)
Beautiful Soup e o pacote Re são apenas algumas das muitas ferramentas para raspar dados de páginas web usando Python. Aqui estão mais alguns exemplos de tais pacotes:
* [Scrapy](https://pypi.org/project/Scrapy/): É principalmente um rastreador (uma ferramenta para percorrer páginas de sites usando links encontrados em outras páginas) e, além disso, possui amplas capacidades para extrair dados de páginas web.
* [Selenium](https://pypi.org/project/selenium/): Uma ferramenta para automatizar a experiência do seu navegador. Permite extrair dados de conteúdo gerado por JavaScript.
* [Lxml](https://pypi.org/project/lxml/): Ferramenta para raspar e validar arquivos XML.
* [PDFtoText](https://pypi.org/project/pdftotext/) - ferramenta para extrair conteúdo de texto de arquivos PDF.
* [pyChatGPT](https://pypi.org/project/pyChatGPT/) - pacote não oficial para interação com o CHATGPT (não requer chave da API OpenAI), que permite analisar informações textuais com IA.
## Usando o Netlas.io para Investigações Cripto
O Netlas oferece uma grande oportunidade para pesquisadores especializados em crimes de criptomoedas. Em primeiro lugar, pode ser usado para pesquisar referências a endereços de carteiras e números de transações. Em segundo lugar, pode ser usado para pesquisar fazendas de mineração vulneráveis, nós e outros servidores associados à infraestrutura cripto.
### Pesquisar Fazendas de Mineração
As fazendas de mineração Antminer, que foram lançadas pela primeira vez pela Bitmain em 2013, são uma das linhas de modelos de fazendas de mineração mais populares do mundo. Você pode encontrá-las pela presença da palavra "antMiner" no cabeçalho www_authenticate.```
http.headers.www_authenticate:antMiner
Você também pode pesquisar por outros tipos de fazendas de mineração. Por exemplo:``` http.headers.www_authenticate:XMR-Stak-Miner
Experimente combinar diferentes filtros, as palavras "minerador/mineração" e nomes de criptomoedas.
**Exemplo de requisição de API**
Netlas CLI Tools:```bash
netlas search "http.headers.www_authenticate:antMiner"
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=http.headers.www_authenticate%3AantMiner&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.uri
**Exemplo de código (Netlas Python Library)**
Execute na linha de comando:```bash
python scripts/crypto/mining_farms_search.py
Código fonte de scripts/crypto/mining_farms_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.headers.www_authenticate:antMinernetlas_query = netlas_connection.query(query='http.headers.www_authenticate:antMiner')
for response in netlas_query['items']: print (response['data']['uri']) print (response['data']['http']['headers'])
### Pesquise por Sites Infectados por Criptomineradores
Coinhive, um serviço que permite que sites (em sua maioria hackeados) usem os computadores de seus visitantes para minerar criptomoedas, está encerrando suas atividades em 2019. No entanto, links para ele ainda estão incorporados em muitos sites ao redor do mundo. Vamos tentar encontrá-los:```
http.body:coinhive.min.js domain:*
Observe que usamos o filtro domain:* para encontrar sites especificamente, não todos os dispositivos.
Da mesma forma, você pode pesquisar por sites infectados com outros cryptominers (assim como outros códigos maliciosos que são executados no lado do usuário).
Exemplo de solicitação de API
Netlas CLI Tools:```bash netlas search "http.body:coinhive.min.js domain:*"
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.body%3Acoinhive.min.js%20domain%3A*&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.uri
Exemplo de código (Netlas Python Library)
Execute na linha de comando:```bash python scripts/crypto/search_sites_injected_with_miners.py
Código fonte:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.body:coinhive.min.js domain:*`
netlas_query = netlas_connection.query(query='http.body:coinhive.min.js domain:*')
# iterate over data and print: uri
for response in netlas_query['items']:
print (response['data']['uri'])
Os nós Bitcoin usam a porta 8333 para conexão TCP. Portanto, é fácil encontrá-los usando o filtro de pesquisa "port:".``` port:8333 cve:*
Note que usamos o filtro "cve:*" para procurar servidores com vulnerabilidades.
**Exemplo de solicitação da API**
Netlas CLI Tools:```bash
netlas search "port:8333 cve:*"
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=port%3A8333%20cve%3A*&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.uri
**Exemplo de código (Netlas Python Library)**
Execute na linha de comando:```bash
python scripts/crypto/search_bitcoin_nodes.py
Código-fonte de scripts/crypto/search_bitcoin_nodes.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
port:8333 cve:*netlas_query = netlas_connection.query(query='port:8333 cve:*')
for response in netlas_query['items']: print (response['data']['uri']) print (response['data']['cve'][0]['name']) print (response['data']['cve'][0]['description'])
## Usando o Neltas para Pentest
O Netlas.io permite pesquisar sites com muitos tipos diferentes de vulnerabilidades. Isso pode ser feito pelo número da vulnerabilidade (CVE-...), pelo nome do software instalado no servidor, por certas palavras nos cabeçalhos das páginas e outros parâmetros.
Você pode acompanhar os CVEs (Common Vulnerabilities and Exposures) publicados mais recentemente nestes sites:
* [CVE Details](https://www.cvedetails.com/)
* [VulDB](https://vuldb.com/)
* [OpenCVE](https://www.opencve.io/)
Também postamos regularmente as consultas mais relevantes para pesquisar dispositivos e software vulneráveis em nossos feeds do [Twitter](https://twitter.com/Netlas_io), [Telegram](https://t.me/netlas) e [Discord](https://nt.ls/discord), bem como no repositório do Github [Netlas Dorks](https://github.com/netlas-io/netlas-dorks).
Nesta seção, vamos simplesmente abordar os princípios gerais de pesquisa por sites e servidores com vulnerabilidades.
### Pesquisa de Subdomínios
Usando asteriscos nas consultas de pesquisa, você pode encontrar todos os subdomínios de diferentes níveis (cujo nome termina com o nome de um domínio de primeiro nível específico (.com) ou domínio de segundo nível (google.com)).
**Exemplo de consulta de pesquisa**
```
domain:*.github.com OR host:*.github.com
Exemplo de requisição de API
Netlas CLI Tools:```bash netlas search "domain:.github.com OR host:.github.com" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=domain%3A*.github.com%20OR%20host%3A*.github.com&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
Exemplo de código (Biblioteca Python Netlas)
Execute na linha de comando:```bash python scripts/pentest/subdomain_search.py
Código fonte de scripts/pentest/subdomain_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `domain:*.github.com OR host:*.github.com`
netlas_query = netlas_connection.query(query="domain:*.github.com OR host:*.github.com")
# iterate over data and print: ip, url
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['uri'])
Exemplo de consulta de pesquisa
```
cve.name:CVE-2022-22965
[Try in Netlas](https://app.netlas.io/responses/?q=cve.name%3ACVE-2022-22965&page=1&indices=)
**Exemplo de requisição de API**
Ferramentas Netlas CLI:```bash
netlas search "cve.name:CVE-2022-22965" -f json
CVE-2022-22965 - A aplicação Spring MVC ou Spring WebFlux executando no JDK 9+ pode estar vulnerável a execução remota de código (RCE) via vinculação de dados. Detalhes
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=http.body%3A1%3F234%3F567%3F89%3F99%20OR%20http.body%3A12345678999%20OR%20http.body%3A1234%3F5678%3F999&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' jq .items[].data.uri
**Exemplo de código (Biblioteca Python Netlas)**
Execute na linha de comando:```bash
python scripts/pentest/cve_search.py
Código fonte de scripts/pentest/cve_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
cve.name:CVE-2022-22965netlas_query = netlas_connection.query(query="cve.name:CVE-2022-22965")
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri'])
### Pesquise por sites com vulnerabilidades que contenham uma determinada palavra em suas descrições
Se você não precisa investigar servidores com um tipo específico de vulnerabilidade, mas apenas deseja ver servidores vulneráveis em um grupo específico (como Oracle WebLogic Server ou sites WordPress), você pode pesquisá-los usando palavras-chave e o filtro cve.description:.
Para filtrar sites que possuem exploits publicados para vulnerabilidades, use cve.has_exploit:true.
**Exemplo de consulta de pesquisa**
```
cve.description:weblogic AND cve.has_exploit:true
Exemplo de requisição de API
Ferramentas de CLI do Netlas:```bash netlas search "cve.description:weblogic AND cve.has_exploit:true" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=cve.description%3Aweblogic%20AND%20cve.has_exploit%3Atrue&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY | jq .items[].data.uri
Exemplo de código (Netlas Python Library)
Execute na linha de comando:```bash python scripts/pentest/cve_description_search.py
Código-fonte de scripts/pentest/cve_description_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `cve.description:weblogic AND cve.has_exploit:true`
netlas_query = netlas_connection.query(query="cve.description:weblogic AND cve.has_exploit:true")
# iterate over data and print: url, first CVE name first CVE description
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['cve'][0]['name'])
print (response['data']['cve'][0]['description'])
Este método permite que você encontre dispositivos fabricados por uma empresa específica.
Exemplo de consulta de pesquisa
```
http.headers.server:"yawcam"
Pesquisar webcams YawCam.
[Experimente no Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22yawcam%22&page=1&indices=)
**Exemplo de solicitação de API**
Ferramentas CLI do Netlas:```bash
netlas search 'http.headers.server:"yawcam"' -f json
Note que quando aspas duplas são usadas em consultas, a própria consulta é escrita entre aspas simples.
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=http.headers.server%3A%22yawcam%22&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
**Exemplo de código (Biblioteca Python Netlas)**
Execute na linha de comando:```bash
python scripts/pentest/server_name_search.py
Código-fonte de scripts/pentest/server_name_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.headers.server:"yawcam"netlas_query = netlas_connection.query(query='http.headers.server:"yawcam"')
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['http']['headers']['server'])
#### Logins e Senhas Padrão <!-- omit in toc -->
Uma aplicação prática de buscar pelo nome do software nos cabeçalhos do servidor é pesquisar dispositivos de um fornecedor específico. Isso pode ser necessário tanto ao procurar dispositivos com vulnerabilidades específicas quanto para dispositivos com logins e senhas padrão.
Logins e senhas padrão para diferentes modelos de dispositivos podem ser encontrados em listas especiais. Por exemplo:
* [Senha de Login Padrão do Roteador para os Principais Modelos de Roteadores (Lista 2023)](https://www.softwaretestinghelp.com/default-router-username-and-password-list/)
* [Nome de Usuário Padrão – Senha – Endereço IP para Câmeras de Segurança](https://www.a1securitycameras.com/blog/default-username-passwords-ip-addresses-for-surveillance-cameras/)
* [As Senhas Padrão de Quase Todas as Câmeras IP](https://www.hackers-arise.com/post/the-default-passwords-of-nearly-every-ip-camera)
* [Lista de senhas padrão da Datarecovery](https://datarecovery.com/rd/default-passwords/)
Lembre-se de que usar logins e senhas padrão para acessar sistemas de outras pessoas viola as regras de ética e pode ser ilegal no seu país.
---
### Busca por Servidores Vulneráveis pelo Hash do Favicon
Uma maneira de encontrar servidores web expostos a uma vulnerabilidade específica é buscar pelo favicon ico de um software de servidor web específico.
**Exemplo de consulta de busca**
```
http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e
Esta consulta pesquisa o favicon do SecurePoint (CVE-2023-22620).
Exemplo de requisição à API
Netlas CLI Tools:```bash netlas search "http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.favicon.hash_sha256%3Aebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
Exemplo de código (Netlas Python Library)
Execute na linha de comando:```bash python scripts/pentest/favicon_hash_search.py
Código fonte de scripts/pentest/favicon_hash_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e`
netlas_query = netlas_connection.query(query="http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e")
# iterate over data and print: IP,URL,web page title
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['uri'])
print (response['data']['http']['title'])
Para simplificar a pesquisa entre servidores executando softwares diferentes, o Netlas adiciona automaticamente tags específicas aos resultados da pesquisa.
Exemplos de tags:
Você pode pesquisar por tags usando o filtro "tag.name:". Você também pode pesquisar por categoria de tag usando o filtro "tag.category:". Uma lista de todas as tags e categorias disponíveis é exibida quando você clica no ícone à direita da caixa de entrada de consulta de pesquisa na página inicial do Netlas.
Nota: Nem todos os planos de preços suportam o uso de tags.
Exemplo de consulta de pesquisa
```
tag.name:"adobe_coldfusion"
Esta consulta pesquisa o Adobe ColdFusion (CVE-2023-26359).
[Try in Netlas](https://app.netlas.io/responses/?q=tag.name%3A%22adobe_coldfusion%22&page=1&indices=)
**Exemplo de solicitação de API**
Ferramentas CLI do Netlas:```bash
netlas search 'tag.name:"adobe_coldfusion"' -f json
Observe que quando aspas duplas são usadas em consultas, a consulta em si é escrita entre aspas simples.
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=tag.name%3A%22adobe_coldfusion%22&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
**Exemplo de código (Netlas Python Library)**
Execute na linha de comando:```bash
python scripts/pentest/search_tag_name.py
Código fonte de scripts/pentest/search_tag_name.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
tag.name:"adobe_coldfusion"netlas_query = netlas_connection.query(query='tag.name:"adobe_coldfusion"')
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri'])
### Procurar por Servidores e Dispositivos Vulneráveis Perto de Você (ou em Qualquer Outro Local)
Você quer saber quantos sites e dispositivos vulneráveis estão ao seu redor? Basta pesquisar por todos os endereços IP que têm o campo CVE preenchido em uma geolocalização específica.```
geo.city:London AND cve:*
Você também pode usar outros filtros de geolocalização.
geo.continentgeo.countrygeo.locationExemplo de solicitação de API
Ferramentas CLI do Netlas:``` geo.city:London AND cve:*
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=geo.city%3ALondon%20AND%20cve%3A*&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.domain
Exemplo de código (Netlas Python Library)
Execute na linha de comando:```bash python scripts/pentest/cve_location_search.py
Código fonte de scripts/pentest/cve_location_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `geo.city:London AND cve:*`
netlas_query = netlas_connection.query(query='geo.city:London AND cve:*')
# iterate over data and print: uri, cve name, location
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['cve'][0]['name'])
print (response['data']['geo']['city'])
Muitos sites e servidores possuem páginas web de login e senha que podem ser usadas para obter acesso ao controle total do site ou servidor (através do uso de senhas padrão, força bruta ou exploração de vulnerabilidades).
Você pode encontrá-los usando o filtro uri: ou/e http.title:```
uri:login.php
uri:login.aspx
uri:user http.title:login
uri:admin http.title:login
http.title:admin http.title:panel
Existem tantas combinações. Para encontrar apenas painéis de servidores vulneráveis, use o filtro `cve:*`.
Além disso, não se esqueça de que você pode filtrar servidores pelo software instalado usando tags. Por exemplo:```
tag.1c_bitrix:*
tag.Cisco:
tag.amazon_s3:*
tag.drupal:*
tag.wordpress:*
Vamos tentar procurar por painéis de administração phpMyAdmin vulneráveis (um dos softwares mais populares para administrar bancos de dados MySQL):``` http.title:phpMyAdmin cve:*
E aqui estão alguns exemplos para outras ferramentas populares de administração de banco de dados:
[Adminer](https://www.adminer.org/):```
http.title:adminer http.title:login cve:*
PostgreSQL``` http.title:(phpPgAdmin OR pgadmin) cve:*
Você também pode pesquisar por servidores que possuem software instalado para diferentes bancos de dados usando as tags ou filtros especiais:```
tag.adminer:*
tag.phpMyAdmin:*
tag.elastic:*
mongodb:*
mssql:*
mysql:*
django:*
Procurar por painéis de administração para servidores encontrados dessa forma pode não ser a tarefa mais fácil, pois os administradores de sites frequentemente alteram links padrão para links mais seguros.
SQL injection é um tipo de vulnerabilidade que permite fazer consultas ao banco de dados manipulando parâmetros de URL (isso pode ser possível devido a configurações incorretas e código de baixa qualidade).
Uma das técnicas mais antigas para encontrar páginas potencialmente vulneráveis a SQL Injection é buscar por páginas que tenham a exibição de mensagens de erro habilitada em consultas MySQL usando Google Dorks.
Uma busca semelhante pode ser feita no Netlas:``` http.body:mysql_fetch_array http.body:warning
[Experimente no Netlas](https://app.netlas.io/responses/?q=http.body%3Amysql_fetch_array%20http.body%3Awarning&page=1&indices=)
Alguns outros exemplos:```
http.body:mysql_num_rows http.body:warning
http.body:mysql_connect http.body:denied
http.body:mysql_query http.body:warning
http.body:pg_connect http.body:fatal
Exemplo de requisição API
Netlas CLI Tools:```bash netlas search "http.body:mysql_fetch_array http.body:warning" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.body%3Amysql_fetch_array%20http.body%3Awarning&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' jq .items[].data.uri
Exemplo de código (Netlas Python Library)
Execute na linha de comando:```bash python scripts/pentest/sql_injection_search.py
Código fonte de scripts/pentest/sql_injection_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# search in Netlas "http.body:mysql_fetch_array http.body:warning"
netlas_query = netlas_connection.query(query="http.body:mysql_fetch_array http.body:warning")
# iterate over data and print: uri, web page body
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['http']['body'])
Você também pode usar os seguintes filtros para pesquisar servidores MySQL vulneráveis:
mysql.error_codemysql.error_idmysql.error_messageO Netlas pesquisa não apenas sites e servidores, mas todos os dispositivos conectados à Internet: eletrodomésticos inteligentes, câmeras de vigilância, impressoras, roteadores, semáforos, equipamentos médicos e muito mais.
Existem quatro maneiras principais de encontrar esses dispositivos.
A maneira mais fácil é simplesmente pesquisar pelo nome do fornecedor ou tipo de dispositivo no título http da resposta.
Tente pesquisar dispositivos de automação residencial Jeedom:``` http.title:Jeedom
[Testar no Netlas](https://app.netlas.io/responses/?q=http.title%3AJeedom&page=1&indices=)
Ou câmeras Avigilon:```
http.title:"Avigilon"
Existem duas desvantagens neste método. A primeira é o grande número de resultados inadequados (apenas sites com palavras relevantes no título). Mas ao usar aspas e filtros de pesquisa adicionais como port:, há menos deles.
A segunda é que muitos dispositivos IoT não possuem nenhuma informação no título http pela qual possam ser identificados. Portanto, outros filtros de pesquisa também podem ser úteis.
Da mesma forma, você pode tentar pesquisar palavras-chave no corpo da resposta http. Para filtrar pelo menos alguns dos sites comuns, use o filtro NOT domain:. Vamos tentar pesquisar câmeras Reolink:``` http.body:(clip-status) NOT domain:
O exemplo não está totalmente correto, então estas câmeras podem ser encontradas usando tags (mais sobre isso abaixo).
### Pesquisa por Número de Porta
Diferentes dispositivos IoT usam portas diferentes para comunicação. E pelo número da porta aberta, você pode hipoteticamente supor que o endereço IP pertence a um certo tipo de dispositivo (**muitas vezes a suposição está correta, mas pode haver imprecisões e coincidências**).
Tente pesquisar rádio Internet (porta 8000):```
port:8000 http.title:radio
Ou todos os dispositivos com a porta 7547 aberta (usada para gerenciar remotamente roteadores via CWMP):``` port:7547
[Try in Netlas](https://app.netlas.io/responses/?q=port%3A7547&page=1&indices=)
### Pesquisa por Banner
Vamos procurar roteadores que usam o protocolo Telnet (você também pode filtrá-los com port:23):```
telnet.banner:router
Ou pesquise banners por todos os protocolos:``` *.banner:router
[Try in Netlas](https://app.netlas.io/responses/?q=%5C*.banner%3Arouter&page=1&indices=)
### Pesquisa por Favicon
Uma das formas mais fáceis de encontrar dispositivos que possuem determinado software instalado é pesquisar pelo favicon. Vamos tentar descobrir onde diferentes produtos Cisco são usados:```
http.favicon.hash_sha256:62a8461e328d5bace3780ff738d0b58f6502592c04afa564e0a8a792583a7bfb
Existem três maneiras principais de pesquisar por favicon no Netlas:
Às vezes, acontece que não há informações identificadoras do dispositivo no título http, mas pode haver em outros cabeçalhos. Por exemplo, em http.server.header:``` http.headers.server:"i-Catcher Console"
[Try in Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22i-Catcher%20Console%22&page=1&indices=)
Netlas suporta a pesquisa em várias dezenas de tipos de cabeçalho. Tente variantes diferentes.
### Pesquisar por Cookies
Pesquisar estacionamentos Eco JS:```
http.headers.set_cookie:(regist_carNo=)
Este método pode exigir uma assinatura paga. Veja os preços
Você também pode tentar pesquisar dispositivos por tags (categorias).``` tag.category:"IoT" tag.category:"Web cameras"
[Experimentar no Netlas](https://app.netlas.io/responses/?q=tag.category%3A%22Web%20cameras%22&page=1&indices=)
Lembre-se de que as tags são atribuídas automaticamente e alguns dispositivos adequados podem não estar incluídos na categoria correspondente.
### Filtros de Pesquisa Adicionais
É possível pesquisar dispositivos IoT localizados em geolocalizações específicas:
- `geo.city`
- `geo.country`
- `geo.continent`
Filtrar dispositivos por faixa de endereço IP:```
ip:[162.245.241.131 TO 162.245.241.133]
Ou dispositivos com vulnerabilidades 'novas':``` cve.name:2023
Mais exemplos de consultas para pesquisar dispositivos IoT podem ser encontrados aqui:
[Netlas Dorks](https://github.com/netlas-io/netlas-dorks)
## Usando Netlas.io para Pesquisa na Darknet
Uma das principais vantagens do Netlas é que você pode usá-lo para pesquisar coisas que não são indexadas pelo Google. Isso é o que pode ser convencionalmente chamado de DeepWeb. Por exemplo, servidores FTP ou servidores Telnet:```
ftp.banner:*
telnet.banner:*
Mas, infelizmente, o Netlas não indexa a Darknet (.onion, .i2p, etc.), pois ele apenas verifica endereços IP globais. Mas ainda pode ser usado para explorar infraestruturas de rede alternativas e encontrar links para sites .onion.
O nó de saída Tor é o ponto onde o tráfego da web sai da rede Tor e é encaminhado ao destino. Uma lista atualizada dos endereços IP dos nós de entrada Tor ativos está sempre disponível no site do TorProject:
Lista de nós de saída do Tor Project
Vamos ver como você pode coletar informações sobre todos os nós de saída Tor ativos de uma só vez usando o Netlas. Este exemplo será útil para todas as outras tarefas em que você precisar coletar informações sobre uma lista de domínios ou endereços IP.
Execute scripts/darknet/tor_nodes.py:```bash python scripts/darknet/tor_nodes.py
Código fonte de scripts/darknet/tor_nodes.py:```python
import netlas
import urllib
import time
apikey = 'YOUR_API_KEY'
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# read file with Tor Exit Nodes IPs line by line
response = urllib.request.urlopen('https://check.torproject.org/torbulkexitlist?ip=1.1.1.1')
ip_lines = response.readlines()
# save each line to ip variable
for ip in ip_lines:
# wait one second
time.sleep(1)
# conver byte string to text
ip=ip.decode("utf-8")
# retrieve data from responses by query `ip: + tor exit node ip`
netlas_query = netlas_connection.query(query="ip:"+ip)
# iterate over data and print: ip, geo data, banner text
for response in netlas_query['items']:
print(response['data']['ip'])
print(response['data']['geo'])
print(response['data']['ntp']['banner'])
pass
pass
Using time package and sleep method é bom apenas para exemplos simples. A melhor solução é usar o pacote de limite de taxa.
Conforme mencionado acima, o Netlas apenas escaneia domínios globais, portanto não é possível pesquisar por domínios .onion. Mas você pode pesquisar por referências a domínios .onion no texto de páginas web. Aqui está um exemplo de um script Python simples (com expressão regular) que faz isso:
Run scripts/darknet/onion_links.py:```bash python scripts/darknet/onion_links.py
Código-fonte de scripts/darknet/onion_links.py:```python
import netlas
import re
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.body:*.onion AND forum`
netlas_query = netlas_connection.query(query="http.body:(*.onion AND forum)")
# iterate over data and print: URL, .onion link from body
for response in netlas_query['items']:
print(response['data']['uri'])
onion_links = re.findall("[a-z-1-9]*\.onion", response['data']['http']['body'])
try:
print(onion_links)
except:
print("no onion links")
pass
Você pode coletar links para outras redes como I2Pin da mesma forma:``` http.body:*.i2p
## Pesquisa de Diretórios de Arquivos, Backups e Logs
Há um enorme número de sites e servidores que deixam seus diretórios de arquivos abertos devido a um erro de configuração (e às vezes deliberadamente). Aqui estão alguns exemplos de consultas que ajudarão você a encontrá-los.
Pesquisar por quaisquer diretórios de arquivos:```
http.title:Index http.title:of
Pesquisar por diretórios com arquivos de log:``` http.title:Index http.title:of http.body:logs
Procurar por diretórios com dumps de banco de dados:```
http.title:Index http.title:of http.body:sql
Pesquisar por diretórios com backups arquivados:``` http.title:Index http.title:of http.body:backup?zip
Pesquisar por diretórios com informações de acesso SSH:```
http.title:Index http.title:of http.body:("ssh_config" OR "ssh_known_hosts" OR "authorized_keys" OR "id_rsa" OR "id_dsa")
Pesquisar por diretórios com arquivos que contenham outras informações de autorização:``` http.title:Index http.title:of http.body:("pass" OR "logins" OR "config" OR "password")
Pesquisar por diretórios com arquivos baixados por usuários:```
http.title:index http.title:of http.body:downloads
Procurar por diretórios com arquivos de configuração do Docker:``` http.title:index http.title:of http.body:docker-compose
Você pode pensar em centenas de outras solicitações desse tipo. Experimente diferentes nomes de arquivos e extensões.
## Usando o Netlas.io para Perícia Digital e Resposta a Incidentes
Esta seção é muito difícil de separar da seção Netlas para OSINT, pois as consultas listadas nela também serão úteis para aqueles envolvidos em perícia digital.
Nesta seção, descrevemos consultas mais "técnicas" que podem ajudar, por exemplo, a reunir informações sobre a infraestrutura técnica de redes ou investigar ataques de phishing.
### Coleta de Informações de Servidores SMTP
SMTP (Simple Mail Transfer Protocol) é um protocolo de comunicação que permite enviar e receber e-mails. Na maioria dos clientes de e-mail, ao visualizar e-mails, a função "Mostrar Original" está disponível, que permite visualizar o endereço do servidor SMTP do qual o e-mail foi enviado.
O Netlas permite que você obtenha informações sobre um servidor SMTP, bem como sobre qualquer outro IP ou domínio, além de pesquisar o texto de banners SMPT, o que permite encontrar servidores associados a um domínio, empresa ou provedor de hospedagem específico.
**Exemplo de consulta de busca**
```
smtp.banner:fornex.cloud
Ferramentas CLI Netlas:```bash netlas search "smtp.banner:fornex.cloud" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=smtp.banner%3Afornex.cloud&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.smtp.banner
Exemplo de código (Biblioteca Netlas Python)
Execute na linha de comando:```bash python scripts/dfir/smtp_banner_search.py
Código-fonte de scripts/dfir/smtp_banner_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `smtp.banner:fornex.cloud`
netlas_query = netlas_connection.query(query="smtp.banner:fornex.cloud")
# iterate over data and print: SMTP banner, URL, ISP
for response in netlas_query['items']:
print (response['data']['smtp']['banner'])
print (response['data']['uri'])
print (response['data']['isp'])
Um dos métodos populares dos golpistas é usar domínios que são muito semelhantes na grafia aos domínios de empresas conhecidas.
Você pode encontrar esses domínios para uma determinada empresa usando Netlas e fuzzy search.
Abra a pesquisa de domínio Whois e insira o nome de domínio da empresa + . Por exemplo:```
domain:facebook.com
[Try in Netlas](https://app.netlas.io/whois_domains/?q=domain%3Afacebook.com~&page=1&indices=)
Depois disso, clique no ícone à esquerda, selecione o tipo de arquivo de exportação, os nomes dos arquivos e os campos que deseja salvar no arquivo. Clique em "Download" e aguarde um pouco.
Por exemplo, você pode selecionar o formato de arquivo CSV e os campos domain, expiration_date, status. Essa tabela pode ser visualizada convenientemente no Excel, Numbers ou Google Docs.
### Pesquisa de Favicon
Pesquisar por favicon.ico tem três usos principais.
Primeiro, permite encontrar sites e subdomínios potencialmente relacionados. Tente encontrar o IP associado às lojas Lidl:```
http.favicon.perceptual_hash:003c7e72207e3c00
E também para encontrar sites de phishing que usam o design de redes sociais populares, lojas online, etc.
Em segundo lugar, é uma busca por vários dispositivos IoT. Tente encontrar produtos HP:``` http.favicon.perceptual_hash:0c5ec8c181f37e2c
[Experimente no Netlas](https://app.netlas.io/responses/?q=http.favicon.perceptual_hash%3A0c5ec8c181f37e2c&page=1&indices=)
Terceiro, ele procura por servidores que possuem determinado software em execução. Tente encontrar servidores com PhpMyAdmin:```
http.favicon.perceptual_hash:00084e5e5fffff8d
Existem três maneiras principais de pesquisar pelo hash do favicon no Netlas:
Você também pode usar os seguintes filtros para pesquisar por favicon:
http.favicon.last_modifiedhttp.favicon.last_updatedhttp.favicon.urihttp.favicon.path
A pesquisa de domínios do Netlas permite obter uma lista completa de domínios associados a um endereço IP específico ou a um intervalo de endereços. Por exemplo:``` a:"163.114.132.0/24"
[Experimentar no Netlas](https://app.netlas.io/domains/?q=a%3A%22163.114.132.0%2F24%22&page=1&indices=)
Exemplo de solicitação de API
Ferramentas CLI do Netlas:```bash
netlas search -d domain a:\"163.114.132.0/24\"
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/domains/?q=a%3A%22163.114.132.0%2F24%22&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.domain
**Exemplo de código (Netlas Python Library)**
Execute na linha de comando:```bash
python scripts/dfir/subnet_search.py
Código fonte de scripts/dfir/subnet_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
a:"163.114.132.0/24"netlas_query = netlas_connection.query(query='a:"163.114.132.0/24"',datatype="domain")
for response in netlas_query['items']: print (response['data']['domain'])
### Pesquisar por Servidores com Software Malicioso
O Netlas permite encontrar servidores que possuem vários tipos de malware instalados. Você pode encontrá-los pela presença de certas palavras em http.title ou http.body, hash do favicon, SSL e outros parâmetros.
Aqui está um exemplo de consulta que encontrará servidores que possuem o GoFish (Framework de Phishing de Código Aberto) instalado:```
http.title:Gophish http.title:Login
Note que a técnica de usar o mesmo operador duas vezes (em vez de um asterisco entre duas palavras) é usada aqui. Às vezes, isso ajuda a obter mais resultados de pesquisa.
Aqui estão mais alguns exemplos de solicitações semelhantes:``` http.title:CALDERA http.title:login http.title:Deimos http.title:C2
**Exemplo de requisição API**
Netlas CLI Tools:```bash
netlas search "http.title:Gophish http.title:Login" -f json
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=http.title%3AGophish%20http.title%3ALogin&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' jq .items[].data.uri
**Código de exemplo (Biblioteca Python Netlas)**
Execute na linha de comando:```bash
python scripts/dfif/malware_search.py
Código-fonte de scripts/dfir/malware_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
netlas_query = netlas_connection.query(query="http.title:Gophish http.title:Login")
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['http']['title'])
print (response['data']['geo']['country'])
## Pesquisar por Tecnologias e Exemplos de Código
O Netlas, ao contrário dos mecanismos de busca convencionais, permite pesquisar todo o código HTML em vez do texto da página. Isso permite encontrar sites que usam determinadas bibliotecas JavaScript. Isso pode ajudá-lo a encontrar exemplos de código adequados para suas tarefas e economizar seu tempo.
Por exemplo, procurando sites que usam uma biblioteca antiga e obscura para desenhar gráficos:```
http.body:kinetic.js
Você também pode ver como diferentes frameworks CSS são usados em sites de certos temas e aproveitar boas ideias de design:``` http.body:bootstrap.css http.title:travel
Você também pode filtrar sites que usam frameworks e tecnologias específicas usando tags:```
tag.bootstrap:*
tag.angularjs:*
tag.wordpress:*
tag.nextjs:*
Netlas, como muitos outros motores de busca, pode ser usado sem qualquer propósito específico, apenas para explorar com sua ajuda cantos inexplorados da Internet, na esperança de encontrar algo interessante lá.
Aqui estão alguns exemplos de consultas de pesquisa que o ajudarão a encontrar o que o Google não consegue.
Pesquisar pelo texto dos banners de servidores Telnet (sim, eles ainda estão vivos!):``` telnet.banner:library
Pesquise pelo texto dos banners de servidores FTP:```
ftp.banner:*library*
Procurar links para livros e documentos:``` http.body:rowlingpdf
Pesquise por links de música e vídeo:```
http.body:*cats*mp4
Pesquisar links para arquivos torrent:``` http.body:catsmp4
Lembre-se de que o Netlas não censura de forma alguma o conteúdo que armazena em seu banco de dados. Se você encontrar algo ilegal ou imoral, deve reclamar ao provedor de hospedagem, cujos contatos estão listados nas informações do domínio.
## Problemas Comuns
### Erro 429 - Requisições Muito Frequentes
Se sua aplicação incluir múltiplas requisições à API do Netlas, você pode encontrar esse erro:```json
{'detail': 'Request was throttled. Expected available in 1 second.'}
Uma maneira de resolver esse problema é usar bibliotecas Python especiais para configurar limites de tempo na execução de consultas, como o Limiter Package.
Aqui está um exemplo de seu uso em código (limite de no máximo 60 requisições por minuto). Primeiro, instale o pacote:``` pip install ratelimit
E execute rate_limit.py:```bash
python scripts/common_problems/rate_limit.py
ENTRADA:```python import netlas from ratelimit import limits
@limits(calls=1, period=1) def netlas_query(): apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `cve.description:weblogic AND cve.has_exploit:true`
netlas_query = netlas_connection.query(query="cve.description:weblogic AND cve.has_exploit:true")
# iterate over data and print: url, first CVE name first CVE description
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['cve'][0]['name'])
print (response['data']['cve'][0]['description'])
netlas_query()
Existem pacotes semelhantes para outras linguagens de programação populares, pois exceder o limite de requisições é um problema muito comum ao trabalhar com quase todas as APIs.
Se você realmente precisa fazer mais de uma consulta por segundo, pode entrar em contato com a [equipe de vendas](https://netlas.io/sales/).
### KeyError
Outro problema comum é a ausência de uma chave específica na resposta para alguns servidores. Por exemplo, ['data']['http']['title'] costuma estar ausente.
Se a chave estiver ausente, o script para de ser executado. O tratamento padrão de erros ajuda a evitar isso. Por exemplo:```python
try:
print (response['data']['http']['title'])
except:
print ("no title")
A principal vantagem de trabalhar com o Netlas Python ou a API do Netlas em vez de apenas digitar consultas na versão web do Netlas.io é que você pode economizar uma quantidade enorme de tempo digitando consultas padronizadas. Por exemplo, você pode coletar rapidamente informações sobre uma longa lista de domínios usando um código Python muito simples.
Execute na linha de comando:```bash python scripts/common_problems/domain_list_search.py
Código-fonte de domain_list_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# read file domains.txt line by line
with open("scripts/common_problems/domains.txt") as f:
# save each line to domain variable
for domain in f:
# retrieve data from responses by query `domain:domainname`
netlas_query = netlas_connection.query(
query=f"domain:{domain}", datatype="domain-whois"
)
# iterate over data and print: ip, isp
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['isp'])
Da mesma forma, você pode trabalhar com uma lista de certificados, endereços IP, e-mails e o que mais desejar.
Um exemplo de pesquisa de endereços IP a partir de uma lista carregada por URL pode ser encontrado em Pesquisa de nós de saída Tor.
Por padrão, a Netlas Python Library retorna dados do tipo Dictionary (que é muito semelhante a JSON). Se você deseja exportar os dados para o MS Excel ou Google Sheets, uma maneira fácil de fazer isso é salvá-los no formato CSV.
Aqui está um exemplo usando o pacote CSV. Execute csv_export.py:```bash python scripts/common_problems/csv_export.py
Você pode inserir uma variedade de detalhes a serem exibidos no formulário de consentimento. Os dados são exportados como um arquivo JSON após o usuário assinar o formulário de consentimento. O arquivo JSON contém os seguintes campos:
- `project_name`: O nome do projeto
- `project_institution`: A instituição que conduz o projeto
- `project_pi`: O investigador principal (PI) do projeto
- `project_cotrainer`: O co-treinador (se houver) do projeto
- `project_funding_source`: A fonte de financiamento do projeto
- `project_version`: A versão do projeto
- `project_description`: Uma descrição do projeto
- `subject_id`: O ID atribuído ao sujeito
- `subject_initials`: As iniciais do sujeito
- `subject_age`: A idade do sujeito
- `subject_gender`: O gênero do sujeito
- `subject_date_of_birth`: A data de nascimento do sujeito
- `subject_notes`: Quaisquer notas adicionais sobre o sujeito```python
import netlas
import csv
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.meta:nazar`
netlas_query = netlas_connection.query(query="http.meta:nazar")
with open('netlas_results.csv', 'w') as csv_file:
# Create CSV writer object
writer = csv.writer(csv_file, delimiter =';')
# Create a list with data headers:
header = ['IP', 'URL', 'Title']
# Write headers to CSV file
writer.writerow(header)
# iterate over data and print: ip and url to CSV file
for response in netlas_query['items']:
# Create a list with one line of data:
data = [response['data']['ip'], response['data']['uri']]
# Write line to file
writer.writerow(data)
pass
Você pode abrir netlas_results.csv no Excel ou em qualquer editor de texto.
Usando Python, você pode gerar uma grande variedade de documentos baseados em dados do Netlas, inserindo imagens, visualizações de dados e personalizando o layout. Aqui estão alguns exemplos de pacotes úteis.
XLSXWriter - gerar arquivos Microsoft Excel.
PyPDF - gerar arquivos PDF.
PythonPPTX - gerar apresentações do Microsoft Power Point.
PythonDOCX - gerar arquivos Microsoft Word.
Como mencionado acima, o Netlas não armazena nomes de domínio não latinos em sua codificação original, mas os codifica em Punycode. Isso é necessário por razões técnicas, mas é completamente inconveniente para a percepção humana.
Mas esse problema é facilmente resolvido com algumas linhas de código Python.
Instale o pacote Python IDNA:```bash pip install idna
E execute punycode.py na linha de comando:```bash
python scripts/common_problems/punycode.py
export async function revokeActiveAccessTokens(token) {
``````python
import netlas
import idna
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `domain:*.中国 OR host:*.中国 `
netlas_query = netlas_connection.query(query="domain:*.xn--fiqs8s OR host:*.xn--fiqs8s")
# iterate over data and print: ip, domain (decoded from punycode)
for response in netlas_query['items']:
print (response['data']['ip'])
decoded_domain = idna.decode(str(response['data']['domain'][0]))
print (decoded_domain)
Às vezes você pode se deparar com uma situação onde nenhum ou muito poucos resultados são encontrados na consulta, embora tenha certeza de que deveria haver muitos mais. Neste caso, recomendamos que experimente e tente alterar um pouco as consultas.
ou ``` http.body:(hello AND world)
4. Refine seus filtros de busca o máximo possível. Por exemplo, a consulta cve:*2023* não retornará resultados. Mas a consulta cve.name:*2023* retornará mais de 28 milhões.
5. Experimente diferentes abas ao usar o aplicativo web ou diferentes tipos de dados ao usar a API. Por exemplo, ao buscar por domínios, às vezes Host ou Domain Whois (em vez de response) funciona melhor.
### Removendo Tags HTML do Corpo HTTP
A chave ['data']['http']['body'] por padrão retorna o texto completo do corpo da página web, incluindo todas as tags HTML. Este formato não é muito fácil de ler. Mas você pode removê-los facilmente com o pacote Python [Html2text](https://pypi.org/project/html2text/).
Execute na linha de comando:```bash
python scripts/common_problems/htmltotext.py
Código-fonte de htmltotext.py:```python import netlas import html2text
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.body:*phpMyAdmin*netlas_query = netlas_connection.query(query="http.body:phpMyAdmin")
for response in netlas_query['items']: print (response['data']['ip']) print (html2text.html2text(str(response['data']['http']['body'])))
## Gerenciamento de Superfície de Ataque
A plataforma Netlas inclui ferramentas para gerenciamento de superfície de ataque, mas este tópico está fora do escopo deste guia. Se você estiver interessado em gerenciamento de superfície de ataque em geral e em usar o Netlas especificamente, recomendamos começar com estes artigos:
- [Guia Completo para Descoberta de Superfície de Ataque](https://netlas.io/blog/attack_surface_discovery_guide/).
- [Melhores Ferramentas de Visualização de Superfície de Ataque](https://netlas.io/blog/best_attack_surface_visualization_tools/).
## Trabalhando com Grandes Volumes de Dados
Se você tem um desafio realmente grande pela frente. Por exemplo, se você precisa coletar dados de centenas de milhares de domínios, talvez uma solução mais racional em termos de tempo e custos financeiros seja comprar um conjunto de dados (csv/json) e trabalhar com ele em seu próprio servidor.
No [Netlas Datastore](https://app.netlas.io/datastore/) você pode encontrar:
* Conjunto de dados de nomes de domínio conhecidos (mais de 2 bilhões de itens)
* Conjunto de dados de DNS direto (mais de 2 bilhões de itens)
* Registros PTR conhecidos (mais de 1 bilhão de itens) - GRÁTIS
* Top 1,000,000 subdomínios mais comuns
e mais.
## Agradecimentos
Muitos agradecimentos a [@cyb_detective](https://twitter.com/cyb_detective) pela ajuda (https://cybdetective.com)