netlas-io/netlas-cookbookEl objetivo de esta guía es muy simple - enseñar a cualquier persona interesada en ciberseguridad, independientemente de su nivel de conocimiento, cómo aprovechar al máximo Netlas.io.
El objetivo de esta guía es enseñar a cualquier persona interesada en ciberseguridad, independientemente de su nivel de conocimiento, cómo aprovechar al máximo las herramientas de búsqueda de Netlas. Es una lectura extensa. Hemos recopilado la mayor cantidad posible de casos de uso simples y mostrado cómo automatizarlos.
⭐️ Danos una estrella para mostrar tu agradecimiento
👁️ Suscríbete para recibir actualizaciones
Netlas es un motor de búsqueda diseñado para encontrar y analizar información sobre todas las direcciones IP y dominios disponibles en Internet. Netlas tiene algunas funciones de gestión de superficie de ataque, pero esta guía se centra principalmente en las herramientas de búsqueda de Netlas y cómo usarlas en automatizaciones.
Netlas incluye varias herramientas de búsqueda:
Usaremos principalmente la búsqueda de respuestas (resultados de escaneo de Internet), pero todas las herramientas funcionan de la misma manera. Si entiendes cómo usar la Herramienta de Búsqueda de Respuestas, podrás manejar cualquier otra.
Antes de entrar en los detalles técnicos, veamos cómo funciona Netlas.io con algunos ejemplos simples.
Abre Netlas.io Información de IP/Dominio e ingresa el nombre de dominio o la IP. Como resultado se mostrará la siguiente información:
Si necesitas encontrar nombres de dominio chinos u otros internacionalizados, conviértelos a Punycode. Por ejemplo:``` domain:*.xn--fiqs8s
Puedes hacer esto con la ayuda de herramientas especiales en línea. Por ejemplo - [Charset.org](https://www.charset.org/punycode)
### Buscar sitios web que contengan una palabra determinada en su título
Abre [la búsqueda de respuestas de Netlas.io](https://app.netlas.io/responses/) e ingresa:```
http.title:g*thub
Esto encontrará todos los servidores cuyos títulos HTTP contengan una palabra que comience con "g" y termine en "thub". Lea más sobre el uso de asteriscos a continuación.
Ahora aprendamos más sobre cómo funcionan las consultas de búsqueda en Netlas.io.
Netlas.io se basa en Elasticsearch, un motor de búsqueda RESTful distribuido, gratuito y abierto. Y los métodos de búsqueda en Netlas.io son muy similares a los de otras bases de datos basadas en Elasticsearch.
La búsqueda de Respuesta, DNS, IP y Certificados le permite usar filtros (campos) en las consultas de búsqueda. Por ejemplo:
`http.title:github```` http.body:netlas
[Try in Netlas](https://app.netlas.io/responses/?q=http.body%3Anetlas&page=1&indices=)
Puede usar esta consulta para encontrar páginas que contengan la palabra "netlas" dentro de su etiqueta HTML <body>.
Se muestra una lista de filtros disponibles para cada tipo de búsqueda en el lado derecho de la página.
Los filtros permiten buscar servidores basándose en muchos parámetros diferentes. Por ejemplo:
* `domain`
* `ip`
* `protocol`
* `certificate`
* `cve`
* `geolocation` (`city`, `continent`, `country`)
y muchos otros.
### Operadores Lógicos
Puede usar varios filtros en una sola consulta y combinarlos usando los operadores lógicos `AND`, `OR`, `NOT`. Por ejemplo:```
http.title:netlas NOT port:443
Si deseas combinar múltiples condiciones en tu consulta, usa paréntesis:``` http.title:(netlas OR shodan) NOT port:443
[Try in Netlas](https://nt.ls/OrFOY)
### Rangos
Si usas un valor numérico como valor de un campo, puedes designarlo como un valor desde y hasta (límites extremos del rango de valores):```
ip:[173.194.222.0 TO 173.194.222.255]
O marque solo el límite superior o solo el inferior del valor:``` host:"1.1.1.1" port:<=1000
[Probar en Netlas](https://app.netlas.io/responses/?q=host%3A%221.1.1.1%22%20port%3A%3C%3D1000&page=1&indices=)
### Comodines
Si no conoces la descripción exacta de un determinado carácter en tu consulta (por ejemplo, no conoces la zona exacta de un dominio o la ortografía de un nombre), puedes reemplazarlo con un asterisco:```
domain:google.*
También puedes usar el signo de interrogación:``` domain:google.?
[Prueba en Netlas](https://app.netlas.io/responses/?q=domain%3Agoogle.%3F&page=1&indices=)
`*` - many symbols, `?` - one symbol.
También puedes usar asteriscos en los filtros. Por ejemplo:```
\*.banner:database
Esta consulta realiza una búsqueda en todos los tipos de banner simultáneamente y reemplaza varios filtros: amqp.banner:, ftp.banner:, dns.banner:, telnet.banner:, etc.
Si necesitas buscar no por el valor exacto, sino por un valor aproximado de un campo (por ejemplo, páginas cuyos títulos contengan todos los nombres consonantes con Joseph), solo agrega ~ a la consulta:```
http.title:Joseph~
[Prueba en Netlas](https://app.netlas.io/responses/?q=http.title%3AJoseph~&page=1&indices=)
### Expresiones regulares
Una expresión regular es una secuencia de caracteres que permite buscar, recuperar y reemplazar fragmentos de texto en un documento fuente que coinciden con ciertos patrones. Por ejemplo:
* Cualquier dirección de correo electrónico: ```text
([a-zA-Z0–9+._-]+@[a-zA-Z0–9._-]+\.[a-zA-Z0–9_-]+)
Para obtener más información sobre el uso de expresiones regulares, consulta los ejemplos en el Netlas Cookbook (lo que estás leyendo ahora) y los siguientes enlaces:
Manual de sintaxis de expresiones regulares en la documentación de Elasticsearch
Puedes guardar tus resultados (todos o campos seleccionados) en formato JSON y CSV para verlos en un formato que te guste o analizarlos automáticamente con diferentes herramientas.
Puedes agrupar resultados por diferentes valores de campo para acelerar el tiempo de búsqueda. Por ejemplo, por nombre de dominio o geolocalización.
Puedes compartir libremente enlaces a los resultados de búsqueda (no se requiere registro para abrirlos, a menos que el usuario haya excedido el límite gratuito de 50 solicitudes).
Recuerda también que todas las consultas que hayas realizado se pueden ver en tu página de perfil (enlace en la esquina superior derecha).
La función más importante de Netlas.io es ayudar a las personas a realizar investigaciones de ciberseguridad de manera más rápida y eficiente. El servicio tiene una API (interfaz de programación de aplicaciones) que te permite automatizar la ejecución de varias solicitudes.
Se puede implementar tanto en scripts simples de Python o Bash de unas pocas líneas de longitud como en aplicaciones complejas multifuncionales.
Puedes leer más sobre el uso de la API de Netlas en el Netlas Cookbook (lo que estás leyendo ahora) o en la documentación oficial:
Este es el primer lugar para comenzar con la API. Ni siquiera tienes que pagar por una suscripción (50 solicitudes por día son gratuitas). Simplemente ve a la página de perfil.
No tienes que escribir scripts ni crear aplicaciones para empezar a usar la API de Netlas. Puedes probarla simplemente con tu cliente API favorito. Consulta las instrucciones aquí.
Al igual que otras API, la respuesta de la API de Netlas consta de encabezados y un cuerpo de respuesta en formato JSON (JavaScript Object Notation). Los archivos JSON contienen datos en formato clave-valor y se pueden analizar usando casi cualquier lenguaje de programación.
Si usas Swagger, puedes copiar o descargar el cuerpo de la respuesta y verlo en cualquier editor de texto o analizador JSON.
Un pequeño consejo que te será útil al escribir código usando la API de Netlas. Para comprender más rápido la estructura de un archivo JSON y encontrar la ruta para obtener un valor determinado, utiliza herramientas especiales como:
La forma más sencilla de automatizar solicitudes a la API de Netlas es usar una biblioteca (paquete) de Python diseñada especialmente.
Repositorio de Github de la biblioteca Netlas-Python
Veamos cómo funciona con un ejemplo sencillo. Todos los ejemplos de código del Netlas Cookbook se encuentran en la carpeta scripts. Puedes clonar este repositorio y ejecutarlos en tu dispositivo:```shell git clone https://github.com/netlas-io/netlas-cookbook
Si no has ejecutado un script de Python antes y no sabes cómo hacerlo, puedes empezar abriendo el repositorio Netlas CookBook en Gitpod.
Gitpod es un entorno de desarrollo en la nube basado en Ubuntu (distribución Linux). Simplemente abre este enlace en tu navegador (inicia sesión con tu cuenta de Github):
[Ejecutar Netlas Cookbook en Gitpod](https://gitpod.io#https://github.com/netlas-io/netlas-cookbook)
Instala la biblioteca Python de Netlas usando pip (instalador de paquetes para Python). Ingresa en la línea de comandos:```shell
pip install netlas
Verifica la instalación. Ingresa en la línea de comandos:```shell netlas --help
Ejecutar netlas_python_example.py:```shell
python3 scripts/netlas_python_example.py
Y, por supuesto, puedes simplemente copiar el código y guardarlo en archivos. Aquí está el código del primer ejemplo:```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']}]")
### Ejemplos de Claves de Respuesta para Obtener Datos Útiles
Se ha mencionado anteriormente que para encontrar parches JSON de la respuesta de la API y obtener los datos que necesitas, puedes usar aplicaciones especiales en línea (evaluadores de JSON). Para hacer tu vida aún más fácil, aquí tienes una pequeña lista de ejemplos de claves de respuesta de la biblioteca de Python que se necesitan con más frecuencia.```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']
Al trabajar con la librería Netlas Python, es muy importante especificar correctamente el tipo de datos que deseas recuperar. Por defecto, se devuelve el tipo response y muchos ejemplos de Netlas CookBook lo utilizan.
Pero para algunas tareas, como obtener información whoois sobre un dominio o buscar dominios en una subred, necesitas usar un tipo de datos diferente. Por ejemplo:```python netlas_query = netlas_connection.query(query='a:"163.114.132.0/24"',datatype="domain")
Si crees que alguna consulta no devuelve resultados cuando debería, simplemente intenta cambiar el valor del parámetro **datatype**. Es muy probable que esto ayude.
Tipos de datos disponibles:
- **datatype="response"** corresponde a los resultados que se pueden obtener en [Netlas Responses Search](https://app.netlas.io/responses/).
- **datatype="domain"** corresponde a los resultados que se pueden obtener en [Netlas DNS search](https://app.netlas.io/domains/)
- **datatype="domain-whois"** corresponde a los resultados que se pueden obtener en [Netlas Domain Whois Search](https://app.netlas.io/whois_domains/).
- **datatype="ip-whois"** corresponde a los resultados que se pueden obtener en [Netlas IP Whois Search](https://app.netlas.io/whois_ip/).
- **datatype="cert"** corresponde a los resultados que se pueden obtener en [Netlas Certificates Search](https://app.netlas.io/certs/).
### Herramientas CLI de Netlas
También puedes usar la librería Python de Netlas directamente desde la línea de comandos. Por ejemplo:```bash
netlas search "http.title:johnsmith" -f json >results.json
Este comando simple busca todos los servidores que tengan la palabra johnsmith en su encabezado, devuelve los resultados en formato JSON y almacena los resultados en el archivo resutls.json.
Todas las demás funciones de la API de Netlas se pueden usar de la misma manera. Puede obtener más información al respecto desde la ayuda (comando -h) y los ejemplos en el Netlas Cookbook (lo que está leyendo ahora).``` 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 ejecutar diferentes comandos de Netlas CLI Tools, guarde la clave API en la configuración:```bash
netlas savekey YOUR_API_KEY
También tenemos un repositorio de Github con un par de ejemplos de automatización de varias tareas usando bash script y Netlas CLI tools:
La API de Netlas tiene muchos métodos, pero los más comúnmente usados son search y download. Son muy similares entre sí, pero aún tienen algunas diferencias.
El método search carga una página de resultados (20 elementos) a la vez y permite cargar un máximo de 200 páginas (20*200=4000 elementos). El método download descarga todos los resultados (pero requiere más recursos para ejecutarse).
También hay un método host que simplemente devuelve la información más básica sobre un dominio o IP particular (datatype (como otros métodos) no necesita especificarse):```bash netlas host "51.159.153.170"
### Parámetros Adicionales de Solicitud
La API de Netlas le permite ajustar de manera flexible los datos devueltos por las solicitudes con parámetros adicionales. Por ejemplo:
* indices - id que corresponde a una fecha de indexación específica. Para averiguar el id de una fecha concreta, abra app.netlas.io, haga clic en el calendario a la derecha de la barra de entrada de la consulta de búsqueda, seleccione la fecha que le interese y observe cómo cambia el parámetro indices en la URL de la barra de direcciones del navegador.
* start - número de página de resultados (por defecto 0)
* fields - nombres de los campos que se incluirán en los resultados (todos los campos por defecto). Será útil para acelerar y optimizar el código con un gran número de solicitudes.
### Realizar Solicitudes con Python (sin Netlas Python Library)
Puede resultarle más fácil en algunos casos no usar la biblioteca Netlas Python, sino usar el paquete estándar request de Python, que es familiar para muchos desarrolladores:
Ingrese en la línea de comandos:```bash
python scripts/python_example.py
Código fuente 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())
Pero la Biblioteca Python de Netlas sigue siendo preferible, ya que está diseñada para manejar diferentes problemas con el procesamiento de consultas (errores, largas esperas, etc.).
### Ejemplos para otros lenguajes de programación
Si bien recomendamos usar nuestra Biblioteca Python para automatizar la búsqueda en Netlas, vale la pena señalar que la API de Netlas se puede integrar en la mayoría de las aplicaciones con una amplia variedad de pilas tecnológicas. Lo principal es que pueda realizar **solicitudes REST** y **analizar datos JSON**.
Aquí hay algunos ejemplos en diferentes lenguajes de programación populares.
#### NodeJS <!-- omit in toc -->
Ingrese en la línea de comandos:```bash
node scripts/node_example.js
Si no estás usando Gitpod, deberías tener NodeJS instalado en tu dispositivo.
Código fuente 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 -->
Ingrese en la línea de comandos:```bash
ruby scripts/ruby_example.rb
Si no estás usando Gitpod, deberías tener Ruby instalado en tu dispositivo.
Código fuente de 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 -->
Ingrese en la línea de comandos:```bash
bash scripts/bash_example.sh
Código fuente 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
### Utilidad JQ
Nótese que en el ejemplo anterior, se utilizó la utilidad JQ para extraer campos de datos JSON.
A veces se le conoce como "como sed para datos JSON". Es una herramienta sorprendentemente útil para trabajar con cualquier dato JSON. Aquí hay algunos ejemplos de sintaxis.
Imprimir el primer elemento de un arreglo JSON:```
.items[0]
Imprimir todos los elementos del JSON-array:``` .items[]
Imprimir todos los subelementos 'data' del primer elemento de JSON-array:```
.['items'][0]['data'][]
Imprimir todos los sub-subelementos para cada elemento del array JSON.``` .items[].data.technical[]
Puede leer más sobre JQ aquí (recomiendo prestar especial atención al filtrado de datos): [Documentación de la utilidad JQ](https://jqlang.github.io/jq/)
### Herramientas de IA para Escribir Código
Si encuentra algún problema al personalizar los ejemplos de Netlas Cookbook, le recomendamos buscar ayuda de herramientas de IA para mejorar y escribir código. Por ejemplo:
[ChatGPT](https://chatgpt.com)
[Code Llama](https://huggingface.co/spaces/codellama/codellama-playground)
[You.com](https://you.com/)
Al trabajar con estos servicios, solo necesita describir con palabras la tarea que desea resolver con la ayuda del código.
### Comprobadores de Código
Cuando adapte los ejemplos de Netlas Cookbook a sus propósitos, puede que el código no se ejecute debido a algunos errores. Herramientas en línea especiales pueden ayudarle a encontrarlos y solucionarlos:
[ExtendsClass Python Tester](https://extendsclass.com/python-tester.html)
[Snyk](https://snyk.io/code-checker/python/)
Si no desea copiar su código a servicios de terceros, puede verificar si tiene errores en su dispositivo usando Pylint (analizador de código estático):
[Paquete Pylint de Python](https://pypi.org/project/pylint/)
## Usando Netlas.io para OSINT (Inteligencia de Fuentes Abiertas)
Netlas.io puede ayudarle a recopilar datos sobre un dominio o empresa, así como a encontrar menciones de una persona (o de cualquiera) en Internet.
También se puede usar para encontrar versiones antiguas de páginas web (como un análogo de Wayback Machine).
### Buscar Apodo o Correo Electrónico de una Persona en los Contactos WHOIS
La mayoría de las veces, los datos WHOIS solo contienen la información de contacto de la empresa que registra los dominios. Pero a veces puede haber contactos personales de personas de interés. Esta consulta le ayudará a encontrarlos.
*Este método puede requerir una suscripción de pago.* [Consulte los precios](https://netlas.io/pricing/)
**Ejemplo de consulta de búsqueda**
```
whois.related_nets.contacts.emails:sweetwater
Ejemplo de solicitud de API
Herramientas CLI de 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
Ejemplo de código (Biblioteca Python de Netlas)
Ejecutar en la línea de comandos:```bash python scripts/osint/whois_email_search.py
Código fuente 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'])
Netlas le permite buscar menciones de ciertas palabras en los encabezados y en el código HTML de las páginas web. Puede buscar palabras por coincidencia exacta, por coincidencia aproximada (consulte la sección de consultas difusas) y reemplazar caracteres de los que no esté seguro con asteriscos.
Ejemplo de consulta de búsqueda
```
http.title:sweetwater OR http.body:sweetwater
[Pruébalo en Netlas](https://app.netlas.io/responses/?q=http.title%3Asweetwater%20OR%20http.body%3Asweetwater&page=1&indices=)
**Ejemplo de solicitud de API**
Netlas CLI Tools:```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
**Ejemplo de código (Netlas Python Library)**
Ejecutar en la línea de comandos:```bash
python scripts/osint/title_body_search.py
Código fuente 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'])
### Buscar "Archivos de información jugosa" en subdominios del sitio web de la empresa
Metagoofil ha sido una herramienta popular entre los practicantes de OSINT durante muchos años. Busca en Google archivos de documentos en el sitio web de una empresa (pdf, xlsx, docx, etc.) y analiza sus metadatos.
Y lo que no está indexado por Google se puede encontrar con Netlas, luego descargarlo a su computadora y analizarlo con la herramienta [MetaDetective](https://github.com/franckferman/MetaDetective).```
uri:*lidl.* AND http.body:pdf
Puedes reemplazar el filtro uri: con domain: y host: (recomiendo siempre comparar los resultados al usar estos tres filtros).
También puedes buscar una amplia variedad de extensiones de archivo, dependiendo de lo que quieras encontrar. Por ejemplo:``` 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
**Ejemplo de solicitud 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
**Ejemplo de código (Biblioteca Python de Netlas)**
Ejecutar en la línea de comandos:```bash
python scripts/osint/juicyinfo_search.py
Código fuente 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 los enlaces a documentos PDF desde el cuerpo de la página web, puedes usar el paquete Python [Re](https://docs.python.org/3/library/re.html).
### Búsqueda de menciones de números de teléfono
Al igual que con los apodos y correos electrónicos, también puedes buscar menciones de un número de teléfono en el código de las páginas web o en la información de contacto WHOIS.
Destacamos esta tarea como un ejemplo aparte, porque buscar un número de teléfono se complica por el hecho de que puede escribirse en diferentes formatos.
**Ejemplo de consulta de búsqueda**
```
http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999
Al realizar una solicitud, debes tener en cuenta el formato de grabación del número de teléfono aceptado en el país al que pertenece el número de teléfono que te interesa.
Ejemplo de solicitud 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
No olvides que puedes buscar números de teléfono no solo en el cuerpo de la página, sino también en la información de contacto WHOIS. Esto se puede hacer usando el 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
Ejemplo de código (Biblioteca de Netlas para Python)
Ejecutar en la línea de comandos:```bash python scripts/osint/phonenumber_search.py
Código fuente 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'])
Imaginemos que eres un músico y quieres encontrar todos los sitios donde se publican tus pistas. Puedes hacerlo buscando páginas que mencionen tu nombre y tengan enlaces a archivos con la extensión .mp3.
Ejemplo de consulta de búsqueda
```
(http.title:alla OR http.body:alla) AND http.body:*.mp3
[Probar en Netlas](https://nt.ls/HEhJj)
**Ejemplo de solicitud API**
Herramientas CLI de Netlas:```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
**Ejemplo de código (biblioteca Python de Netlas)**
Ejecutar en la línea de comandos:```bash
python scripts/osint/file_mentions_search.py
Código fuente 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'])
### Recopilación de información WHOIS de dominio
WHOIS es una base de datos pública mundial que almacena información sobre todos los dominios registrados en el mundo.
**Ejemplo de consulta de búsqueda**
Utilice [Búsqueda de dominio WHOIS](https://app.netlas.io/whois_domains/)```
github.com
Ejemplo de solicitud 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
Ejemplo de código (biblioteca Python de Netlas)
Ejecutar en la línea de comandos:```bash python scripts/osint/whois_search.py
Código fuente 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'])
La etiqueta <address> se encuentra dentro de la etiqueta <head> de una página web y puede contener direcciones físicas. Con una búsqueda usando esta etiqueta, puedes encontrar sitios asociados con una calle en particular, y a veces incluso un edificio específico.
Ejemplo de consulta de búsqueda
```
http.contacts.address:kirby
[Probar en Netlas](https://app.netlas.io/responses/?q=http.contacts.address%3Akirby&page=1&indices=)
También puedes usar http.contacts.email: para búsqueda por correo electrónico.
**Ejemplo de solicitud API**
Herramientas CLI de 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
**Ejemplo de código (Netlas Python Library)**
Ejecutar en la línea de comandos:```bash
python scripts/osint/contacts_search.py
Código fuente 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'])
### Buscar Nombre del Autor en Metaetiquetas
Las etiquetas `<meta>` se ubican dentro de la etiqueta `<head>` de una página web y contienen las palabras clave más importantes, la descripción, información miscelánea del servicio y el nombre del autor.
Buscar apodo y nombre/apellido mediante metaetiquetas (http.meta) permite encontrar sitios asociados con una persona en particular más rápido que buscar en todo el código HTML (http.body).
**Ejemplo de consulta de búsqueda**
```
http.meta:nazar
Ejemplo de solicitud API
Herramientas CLI de 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
Ejemplo de código (Biblioteca Python de Netlas)
Ejecutar en línea de comandos:```bash python scripts/osint/author_meta_search.py
Código fuente 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'])
Además del nombre del autor, las metaetiquetas pueden contener una variedad de información: codificación, idioma, permiso para indexar la página por parte de los robots de los motores de búsqueda, texto para tarjetas de enlace en redes sociales, metadatos de OpenGraph y mucho más. Aquí hay algunos ejemplos adicionales de metaetiquetas que pueden contener información útil para investigaciones:
<meta name="description"> - descripción del contenido de la página web.<meta name="keywords"> - palabras clave que describen el contenido de la página web.<meta name="generator"> - nombre de la herramienta que se utilizó para generar el contenido de la página (útil para buscar CMS y plataformas de alojamiento)<meta name="copyright"> - el nombre de la persona o empresa que posee los derechos de autor del contenido de la página web.Otro paso importante para encontrar información sobre una persona o empresa es buscar su mención en el texto de los banners de los servidores FTP. Es posible que la dirección IP de los servidores encontrados sea la clave para encontrar otros sitios relacionados con la persona o empresa que le interesa. Y en caso de mucha suerte, encontrar algo interesante en los archivos publicados allí (si el servidor FTP está abierto).
Ejemplo de consulta de búsqueda
```
ftp.banner:"Collado"
Si necesita buscar servidores FTP por algún otro parámetro (como ciudad o rango de direcciones IP), entonces use el filtro prot7:ftp.
[Probar en Netlas](https://app.netlas.io/responses/?q=ftp.banner%3A%22Collado%22%20&page=1&indices=)
**Ejemplo de solicitud de API**
Netlas CLI Tools:```bash
netlas search 'ftp.banner:"Collado"' -f json
Tenga en cuenta que cuando se usan comillas dobles en las consultas, la consulta en sí se escribe entre comillas 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
**Ejemplo de código (Netlas Python Library)**
Ejecutar en la línea de comandos:```bash
python scripts/osint/ftp_banner_search.py
Código fuente 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'])
### Buscar información de contacto en certificados SSL
Un certificado SSL es un certificado digital que autentica un sitio web y permite el uso de una conexión cifrada. Puede contener información sobre su propietario: nombre de la persona de contacto, nombre de la organización, país y, a veces, incluso la dirección y el código postal. Puede buscar esta información utilizando los siguientes filtros (y muchos otros):
- `certificate.issuer.email_address`
- `certificate.issuer.given_name`
- `certificate.issuer.organization`
- `certificate.issuer.postal_code`
- `certificate.issuer.street_address`
- `certificate.issuer.surname`
Intentemos encontrar direcciones IP que tengan una palabra determinada en la dirección de la calle en su certificado:```
certificate.issuer.street_address:*mcgill*
Ejemplo de solicitud 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
Ejemplo de código (Biblioteca Python de Netlas)
Ejecutar en la línea de comandos:```bash python scripts/osint/certificates_search.py
Source code of 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'])
Archive.org ha sido utilizado por especialistas en OSINT para buscar versiones antiguas de sitios web y páginas de perfiles de redes sociales con el fin de encontrar información de contacto y otros datos que ya han sido eliminados.
Pero, desafortunadamente, archive.org no guarda copias de todos los sitios y no lo hace con mucha frecuencia (para algunos sitios solo un par de veces al año o menos).
¡Pero Netlas también está guardando versiones antiguas de sitios desde 2021!
Los siguientes filtros se utilizan con mayor frecuencia para buscar sitios:``` http.title:"github.com"
domain:github.com
host:github.com
Si haces clic en el icono más externo a la derecha junto al campo para introducir consultas de búsqueda, verás un menú para seleccionar una fecha de escaneo. Puedes usarlo para filtrar los códigos html de los sitios guardados en una fecha específica.
Para ver cómo se ve el sitio, copia el contenido del campo "body" (pestaña de respuesta) en cualquier editor de texto y elimina los caracteres \t\r\n del código html.
Después de eso, copia el código en uno de los promotores html en línea, como [Code beautify](https://codebeautify.org/htmlviewer). O simplemente guarda el archivo en formato html y luego ábrelo en el navegador.
### 9 Maneras de Buscar Sitios Web Relacionados
Al recopilar información sobre una persona o empresa, puede ser importante encontrar tantos sitios como sea posible que puedan estar relacionados de alguna manera. Hay al menos 5 formas de hacer esto con Netlas.
1. ID para varios servicios (analítica, sistemas publicitarios, aplicaciones para integración con redes sociales y sistemas de publicación). Su superposición puede indicar que una persona o equipo estuvo involucrado. Algunos ejemplos:
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
Sí, todo se encuentra en el código de algunos sitios.
Y una gran cantidad de otros identificadores que a menudo se encuentran en la parte superior del código HTML (pero a veces en todo el código).
[Try in Netlas](https://nt.ls/BCrw9)
2. ID de programas de afiliados (también use http.body para buscarlos). Puede encontrarlos en los enlaces de afiliados que una persona publica en otros sitios o en redes sociales. Estos pueden ser los siguientes parámetros de URL (y similares):```
aff_fcid=
user_id=
partner_id=
ref_id=
```
"GitHub, Inc."
[Try in Netlas](https://app.netlas.io/whois_domains/?q=%22GitHub%2C%20Inc.%22&page=1&indices=)
4. Búsqueda por servidores de correo en la búsqueda de DNS Netlas
```
mx:*.parklogic.com
```
ns:ns?.parklogic.com
[Probar en Netlas](https://app.netlas.io/domains/?q=mx%3A*.parklogic.com&page=1&indices=)
6. Búsqueda de menciones de archivos (principalmente logotipos y avatares de usuarios) [->](https://github.com/netlas-io/netlas-cookbook#search-file-mentions-looking-for-content-that-may-be-infringing-on-copyrights)
7. Búsqueda de subdominios [->](https://github.com/netlas-io/netlas-cookbook#search-subdomains)
8. Búsqueda de contactos Whois (en la búsqueda de respuestas de Netlas) [->](https://github.com/netlas-io/netlas-cookbook#search-persons-nickname-or-email-in-whois-contacts)
9. Búsqueda de favicon [->](https://github.com/netlas-io/netlas-cookbook#favicon-search)
## Scraping (Extraer datos del cuerpo de la página web)
La API de Netlas es una excelente herramienta para recopilar contactos y otros datos de sitios web. Primero, te permite hacerlo rápidamente. Segundo, no requiere el uso de proxy. Tercero, te permite recopilar datos de sitios que actualmente no están disponibles.
Sin embargo, tiene algunas desventajas: Netlas escanea solo las páginas principales de los sitios y algunos sitios poco comunes no están incluidos en su base de datos debido a la protección. Pero aún así puede ser de gran utilidad.
Hay tres enfoques principales para el scraping: recopilar información a partir de etiquetas HTML y selectores CSS, extraer datos usando expresiones regulares y scraping con IA. Veamos más de cerca los dos primeros.
### Paquete Beatifulsoup
[Beatifulsoup](https://pypi.org/project/beautifulsoup4/) es uno de los paquetes de Python más populares del mundo para analizar código HTML y archivos XML. Probemos a usarlo para extraer títulos de página (de etiquetas \<h1>, NO de etiquetas \<title>).
Primero, instala el paquete:```bash
pip install beautifulsoup4
Y Ejecuta scripts/osint/scraping_beatifulsoup.py:```bash python scripts/osint/scraping_beatifulsoup.py
Código fuente 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
Puedes extraer datos de otros elementos de páginas web de manera similar:``` 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()
Si deseas encontrar todos los elementos de un determinado tipo, usa el método find_all().
### Paquete Re
[Re](https://docs.python.org/3/library/re.html) es un paquete de Python preinstalado para buscar y recuperar datos usando expresiones regulares. Es útil para extraer información de contacto de páginas web y muchas otras tareas. Veamos un ejemplo de cómo funciona.
Ejecuta scripts/osint/scraping_re.py:```bash
python scripts/osint/scraping_re.py
Código fuente 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
De manera similar, puedes extraer enlaces, números de teléfono, direcciones de billeteras de criptomonedas y más. Los patrones listos se pueden encontrar en bibliotecas de expresiones regulares:
[Regex Lib](https://regexlib.com/)
[UI Bakery Regex Library](https://uibakery.io/regex-library)
[Regex 101](https://regex101.com/)
### Otros Paquetes de Python para Scraping
Los paquetes Beaitiful soup y Re son solo una de las muchas herramientas para extraer datos de páginas web usando Python. Aquí hay algunos ejemplos más de estos paquetes:
* [Scrapy](https://pypi.org/project/Scrapy/): Es principalmente un rastreador (una herramienta para recorrer páginas web usando enlaces encontrados en otras páginas) y, además, tiene amplias capacidades para extraer datos de páginas web.
* [Selenium](https://pypi.org/project/selenium/): Una herramienta para automatizar tu experiencia en el navegador. Te permite extraer datos de contenido que es generado por JavaScript.
* [Lxml](https://pypi.org/project/lxml/): Herramienta para extraer y validar archivos XML.
* [PDFtoText](https://pypi.org/project/pdftotext/) - herramienta para extraer contenido de texto de archivos PDF.
* [pyChatGPT](https://pypi.org/project/pyChatGPT/) - paquete no oficial para interacción con CHATGP (no requiere clave API de OpenAI), que permite analizar información de texto con IA.
## Usando Netlas.io para Investigaciones de Criptomonedas
Netlas brinda una gran oportunidad para investigadores especializados en delitos con criptomonedas. En primer lugar, se puede usar para buscar referencias a direcciones de billeteras y números de transacciones. En segundo lugar, se puede usar para buscar granjas de minería vulnerables, nodos y otros servidores asociados con la infraestructura cripto.
### Buscar Granjas de Minería
Las granjas de minería Antminer, que fueron lanzadas por primera vez por Bitmain en 2013, son una de las líneas de modelos de granjas de minería más populares del mundo. Puedes encontrarlas por la presencia de la palabra "antMiner" en el encabezado www_authenticate.```
http.headers.www_authenticate:antMiner
También puedes buscar otros tipos de granjas de minería. Por ejemplo:``` http.headers.www_authenticate:XMR-Stak-Miner
Experimenta combinando diferentes filtros, las palabras 'miner/mining' y nombres de criptomonedas.
**Ejemplo de solicitud 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
**Ejemplo de código (Netlas Python Library)**
Ejecutar en la línea de comandos:```bash
python scripts/crypto/mining_farms_search.py
Código fuente 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'])
### Buscar sitios web infectados con criptomineros
Coinhive, un servicio que permite a los sitios web (en su mayoría hackeados) usar los ordenadores de sus visitantes para minar criptomonedas, cerró en 2019. Pero sin embargo, los enlaces a él siguen incrustados en muchos sitios de todo el mundo. Intentemos encontrarlos:```
http.body:coinhive.min.js domain:*
Tenga en cuenta que usamos el filtro domain:* para encontrar sitios específicamente, no todos los dispositivos.
De manera similar, puede buscar sitios infectados con otros criptomineros (así como otro código malicioso que se ejecuta del lado del usuario).
Ejemplo de solicitud 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
Code example (Netlas Python Library)
Ejecutar en la línea de comandos:```bash python scripts/crypto/search_sites_injected_with_miners.py
Código fuente:```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'])
Los nodos de Bitcoin utilizan el puerto 8333 para la conexión TCP. Por lo tanto, es fácil encontrarlos usando el filtro de búsqueda "port:".``` port:8333 cve:*
Tenga en cuenta que usamos el filtro "cve:*" para buscar servidores con vulnerabilidades.
**Ejemplo de solicitud API**
Herramientas CLI de Netlas:```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
**Ejemplo de código (Netlas Python Library)**
Ejecutar en la línea de comandos:```bash
python scripts/crypto/search_bitcoin_nodes.py
Código fuente 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 Neltas para Pentest
Netlas.io te permite buscar sitios con muchos tipos diferentes de vulnerabilidades. Esto se puede hacer por número de vulnerabilidad (CVE-...), el nombre del software instalado en el servidor, ciertas palabras en los encabezados de las páginas y otros parámetros.
Puedes rastrear los CVEs (Common Vulnerabilities and Exposures) más recientemente publicados en estos sitios:
* [CVE Details](https://www.cvedetails.com/)
* [VulDB](https://vuldb.com/)
* [OpenCVE](https://www.opencve.io/)
También publicamos regularmente las consultas más relevantes para buscar dispositivos y software vulnerables en nuestros feeds de [Twitter](https://twitter.com/Netlas_io), [Telegram](https://t.me/netlas) y [Discord](https://nt.ls/discord), así como en el repositorio de Github [Netlas Dorks](https://github.com/netlas-io/netlas-dorks).
En esta sección, cubriremos simplemente los principios generales de búsqueda de sitios y servidores con vulnerabilidades.
### Búsqueda de Subdominios
Usando asteriscos en las consultas de búsqueda, puedes encontrar todos los subdominios de diferentes niveles (cuyo nombre termina con el nombre de un dominio de primer nivel (.com) o de segundo nivel (google.com) en particular.
**Ejemplo de consulta de búsqueda**
```
domain:*.github.com OR host:*.github.com
Ejemplo de solicitud de API
Herramientas CLI de Netlas:```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
Ejemplo de código (Netlas Python Library)
Ejecutar en línea de comandos:```bash python scripts/pentest/subdomain_search.py
Código fuente 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'])
Ejemplo de consulta de búsqueda
```
cve.name:CVE-2022-22965
[Probar en Netlas](https://app.netlas.io/responses/?q=cve.name%3ACVE-2022-22965&page=1&indices=)
**Ejemplo de solicitud API**
Netlas CLI Tools:```bash
netlas search "cve.name:CVE-2022-22965" -f json
CVE-2022-22965 - La aplicación Spring MVC o Spring WebFlux que se ejecuta en JDK 9+ puede ser vulnerable a ejecución remota de código (RCE) mediante enlace de datos. Detalles
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
**Ejemplo de código (Netlas Python Library)**
Ejecutar en la línea de comandos:```bash
python scripts/pentest/cve_search.py
Código fuente 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'])
### Buscar sitios con vulnerabilidades que contengan una palabra específica en sus descripciones
Si no necesitas investigar servidores con un tipo específico de vulnerabilidad, sino que solo deseas ver servidores vulnerables en un grupo concreto (como Oracle WebLogic Server o sitios WordPress), puedes buscarlos usando palabras clave y el filtro `cve.description:`.
Para filtrar sitios que tienen exploits publicados para vulnerabilidades, usa `cve.has_exploit:true`.
**Ejemplo de consulta de búsqueda**
```
cve.description:weblogic AND cve.has_exploit:true
Ejemplo de solicitud API
Netlas CLI Tools:```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
Ejemplo de código (Biblioteca de Netlas Python)
Ejecutar en línea de comandos:```bash python scripts/pentest/cve_description_search.py
Código fuente 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 le permite encontrar dispositivos fabricados por una empresa específica.
Ejemplo de consulta de búsqueda
```
http.headers.server:"yawcam"
Buscar cámaras web YawCam.
[Probar en Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22yawcam%22&page=1&indices=)
**Ejemplo de solicitud de API**
Herramientas CLI de Netlas:```bash
netlas search 'http.headers.server:"yawcam"' -f json
Tenga en cuenta que cuando se usan comillas dobles en las consultas, la consulta en sí se escribe entre comillas 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
**Ejemplo de código (Netlas Python Library)**
Ejecutar en la línea de comandos:```bash
python scripts/pentest/server_name_search.py
Código fuente 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'])
#### Inicios de sesión y contraseñas predeterminados <!-- omit in toc -->
Una aplicación práctica de buscar por nombre de software en los encabezados del servidor es buscar dispositivos de un proveedor específico. Esto puede ser necesario tanto al buscar dispositivos con vulnerabilidades específicas como para dispositivos con inicios de sesión y contraseñas estándar.
Los inicios de sesión y contraseñas estándar para diferentes modelos de dispositivos se pueden encontrar en listas especiales. Por ejemplo:
* [Lista de contraseñas de inicio de sesión de router predeterminadas para los mejores modelos de router (2023)](https://www.softwaretestinghelp.com/default-router-username-and-password-list/)
* [Nombre de usuario – Contraseña – Dirección IP predeterminados para cámaras de seguridad](https://www.a1securitycameras.com/blog/default-username-passwords-ip-addresses-for-surveillance-cameras/)
* [Las contraseñas predeterminadas de casi todas las cámaras IP](https://www.hackers-arise.com/post/the-default-passwords-of-nearly-every-ip-camera)
* [Lista de contraseñas predeterminadas de Datarecovery](https://datarecovery.com/rd/default-passwords/)
Recuerde que usar inicios de sesión y contraseñas estándar para acceder a los sistemas de otras personas viola las reglas éticas y puede ser ilegal en su país.
### Búsqueda de servidores vulnerables por hash de favicon
Una forma de encontrar servidores web expuestos a una vulnerabilidad particular es buscar el favicon ico de un software de servidor web específico.
**Ejemplo de consulta de búsqueda**
```
http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e
Esta consulta busca el favicon de SecurePoint (CVE-2023-22620).
Ejemplo de solicitud 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
Ejemplo de código (Biblioteca Python de Netlas)
Ejecutar en línea de comandos:```bash python scripts/pentest/favicon_hash_search.py
Código fuente 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 la búsqueda entre servidores que ejecutan diferentes software, Netlas etiqueta automáticamente los resultados de búsqueda con etiquetas específicas.
Ejemplos de etiquetas:
Puede buscar por etiquetas usando el filtro "tag.name:". También puede buscar por categoría de etiqueta usando el filtro "tag.category:". Se muestra una lista de todas las etiquetas y categorías disponibles al hacer clic en el icono a la derecha del cuadro de entrada de consulta de búsqueda en la página principal de Netlas.
Nota: No todos los planes de precios admiten el uso de etiquetas.
Ejemplo de consulta de búsqueda
```
tag.name:"adobe_coldfusion"
Esta consulta busca Adobe ColdFusion (CVE-2023-26359).
[Prueba en Netlas](https://app.netlas.io/responses/?q=tag.name%3A%22adobe_coldfusion%22&page=1&indices=)
**Ejemplo de solicitud de API**
Netlas CLI Tools:```bash
netlas search 'tag.name:"adobe_coldfusion"' -f json
Tenga en cuenta que cuando se usan comillas dobles en las consultas, la consulta en sí se escribe entre comillas 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
**Ejemplo de código (librería Python de Netlas)**
Ejecutar en la línea de comandos:```bash
python scripts/pentest/search_tag_name.py
Código fuente 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'])
### Buscar Servidores y Dispositivos Vulnerables Cerca de Ti (o Cualquier Otra Ubicación)
¿Quieres saber cuántos sitios y dispositivos vulnerables hay a tu alrededor? Simplemente busca todas las direcciones IP que tengan el campo CVE poblado en una geolocalización específica.```
geo.city:London AND cve:*
También puedes usar otros filtros de geolocalización.
geo.continentgeo.countrygeo.locationEjemplo de solicitud API
Netlas CLI Tools:``` 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
Ejemplo de código (Netlas Python Library)
Ejecutar en la línea de comandos:```bash python scripts/pentest/cve_location_search.py
Código fuente 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'])
Muchos sitios y servidores tienen páginas web de inicio de sesión y contraseña que pueden utilizarse para obtener acceso al control total del sitio o servidor (mediante el uso de contraseñas predeterminadas, fuerza bruta o explotación de vulnerabilidades).
Puedes encontrarlos usando el filtro uri: o/y http.title:```
uri:login.php
uri:login.aspx
uri:user http.title:login
uri:admin http.title:login
http.title:admin http.title:panel
Hay tantas combinaciones. Para encontrar solo paneles de servidores vulnerables usa el filtro `cve:*`.
Además, no olvides que puedes filtrar servidores por software instalado usando etiquetas. Por ejemplo:```
tag.1c_bitrix:*
tag.Cisco:
tag.amazon_s3:*
tag.drupal:*
tag.wordpress:*
Intentemos buscar un panel de administración vulnerable de phpMyAdmin (uno de los software más populares para administrar bases de datos MySQL):``` http.title:phpMyAdmin cve:*
Y aquí hay algunos ejemplos para otras herramientas populares de administración de bases de datos:
[Adminer](https://github.com/netlas-io/netlas-cookbook/blob/main/Adminer):```
http.title:adminer http.title:login cve:*
PostgreSQL``` http.title:(phpPgAdmin OR pgadmin) cve:*
También puedes buscar servidores que tengan software instalado para diferentes bases de datos utilizando las etiquetas o filtros especiales:```
tag.adminer:*
tag.phpMyAdmin:*
tag.elastic:*
mongodb:*
mssql:*
mysql:*
django:*
Buscar paneles de administración para servidores encontrados de esta manera puede no ser lo más fácil de hacer, ya que los administradores de sitios a menudo cambian los enlaces estándar por otros más seguros.
La inyección SQL es un tipo de vulnerabilidad que permite realizar consultas a la base de datos manipulando parámetros de URL (esto puede ser posible debido a malas configuraciones y código de baja calidad).
Una de las técnicas más antiguas para encontrar páginas potencialmente vulnerables a inyección SQL es buscar páginas que tengan habilitada la visualización de mensajes de error en consultas MySQL utilizando Google Dorks.
Se puede realizar una búsqueda similar en Netlas:``` http.body:mysql_fetch_array http.body:warning
[Try in Netlas](https://app.netlas.io/responses/?q=http.body%3Amysql_fetch_array%20http.body%3Awarning&page=1&indices=)
Algunos otros ejemplos:```
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
Ejemplo de solicitud 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
Ejemplo de código (Netlas Python Library)
Ejecutar en la línea de comandos:```bash python scripts/pentest/sql_injection_search.py
Código fuente 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'])
También puede utilizar los siguientes filtros para buscar servidores MySQL vulnerables:
mysql.error_codemysql.error_idmysql.error_messageNetlas no solo busca sitios web y servidores, sino todos los dispositivos conectados a Internet: electrodomésticos inteligentes, cámaras de vigilancia, impresoras, routers, semáforos, equipos médicos y más.
Hay cuatro formas principales de encontrar estos dispositivos.
La forma más sencilla es simplemente buscar el nombre del fabricante o el tipo de dispositivo en el título http de la respuesta.
Intente buscar dispositivos de domótica Jeedom:``` http.title:Jeedom
[Try in Netlas](https://app.netlas.io/responses/?q=http.title%3AJeedom&page=1&indices=)
O cámaras web Avigilon:```
http.title:"Avigilon"
Hay dos desventajas en este método. La primera es la gran cantidad de resultados inapropiados (solo sitios web con palabras relevantes en el título). Pero al usar comillas y filtros de búsqueda adicionales como port:, hay menos.
La segunda es que muchos dispositivos IoT no tienen ninguna información en el título http que permita identificarlos. Por lo tanto, otros filtros de búsqueda también pueden ser útiles.
Del mismo modo, puedes intentar buscar palabras clave en el cuerpo de la respuesta http. Para filtrar al menos algunos de los sitios web comunes, usa el filtro NOT domain:. Probemos a buscar cámaras Reolink:``` http.body:(clip-status) NOT domain:
El ejemplo no es del todo correcto, por lo que estas cámaras se pueden encontrar usando etiquetas (más sobre eso a continuación).
### Búsqueda por número de puerto
Diferentes dispositivos IoT usan diferentes puertos para la comunicación. Y por el número de puerto abierto, se puede suponer hipotéticamente que la dirección IP pertenece a un cierto tipo de dispositivo (**a menudo la suposición es correcta, pero puede haber imprecisiones y coincidencias**).
Intente buscar radio por Internet (puerto 8000):```
port:8000 http.title:radio
O todos los dispositivos con el puerto 7547 abierto (se usa para gestionar routers de forma remota mediante CWMP):``` port:7547
[Try in Netlas](https://app.netlas.io/responses/?q=port%3A7547&page=1&indices=)
### Búsqueda por Banner
Busquemos routers que usen el protocolo Telnet (también podrías filtrarlos con puerto:23):```
telnet.banner:router
O busca banners para todos los protocolos:``` *.banner:router
[Probar en Netlas](https://app.netlas.io/responses/?q=%5C*.banner%3Arouter&page=1&indices=)
### Búsqueda por favicon
Una de las formas más sencillas de encontrar dispositivos que tienen cierto software instalado es buscar por favicon. Intentemos encontrar dónde se utilizan diferentes productos de Cisco:```
http.favicon.hash_sha256:62a8461e328d5bace3780ff738d0b58f6502592c04afa564e0a8a792583a7bfb
Hay tres formas principales de buscar por favicon en Netlas:
A veces sucede que no hay información identificativa del dispositivo en el título http, pero puede estar en otras cabeceras. Por ejemplo, en http.server.header:``` http.headers.server:"i-Catcher Console"
[Probar en Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22i-Catcher%20Console%22&page=1&indices=)
Netlas admite la búsqueda en varios tipos de encabezados. Prueba diferentes variantes.
### Búsqueda por cookies
Buscar estacionamientos Eco JS:```
http.headers.set_cookie:(regist_carNo=)
Este método puede requerir una suscripción de pago. Ver precios
También puedes intentar buscar dispositivos por etiquetas (categorías).``` tag.category:"IoT" tag.category:"Web cameras"
[Try in Netlas](https://app.netlas.io/responses/?q=tag.category%3A%22Web%20cameras%22&page=1&indices=)
Solo recuerda que las etiquetas se asignan automáticamente y algunos dispositivos adecuados pueden no estar incluidos en la categoría correspondiente.
### Filtros de búsqueda adicionales
Puede buscar dispositivos IoT ubicados en geolocalizaciones específicas:
- `geo.city`
- `geo.country`
- `geo.continent`
Filtrar dispositivos por rango de direcciones IP:```
ip:[162.245.241.131 TO 162.245.241.133]
O dispositivos con vulnerabilidades "nuevas":``` cve.name:2023
Más ejemplos de consultas para buscar dispositivos IoT se pueden encontrar aquí:
[Netlas Dorks](https://github.com/netlas-io/netlas-dorks)
## Usando Netlas.io para la investigación en Darknet
Una de las principales ventajas de Netlas es que puedes usarlo para buscar cosas que no están indexadas por Google. Esto es lo que se puede llamar convencionalmente DeepWeb. Por ejemplo, servidores FTP o servidores Telnet:```
ftp.banner:*
telnet.banner:*
Pero desafortunadamente Netlas no indexa la Darknet (.onion, .i2p, etc.) ya que solo escanea direcciones IP globales. Sin embargo, aún se puede usar para explorar infraestructuras de red alternativas y encontrar enlaces a sitios .onion.
El nodo de salida de Tor es el punto donde el tráfico web sale de la red Tor y se dirige al destino. Una lista actualizada de direcciones IP de nodos de entrada de Tor activos está siempre disponible en el sitio web de TorProject:
Lista de nodos de salida de Tor Project
Veamos cómo puedes recopilar información sobre todos los nodos de salida de Tor activos a la vez usando Netlas. Este ejemplo será útil para todas las demás tareas para las que necesites recopilar información sobre una lista de dominios o direcciones IP.
Run scripts/darknet/tor_nodes.py:```bash python scripts/darknet/tor_nodes.py
Código fuente 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
Usar el paquete time y el método sleep solo es adecuado para ejemplos simples. La mejor solución es usar el paquete de límite de tasa.
Como se mencionó anteriormente, Netlas solo escanea dominios globales, por lo que no es posible buscar dominios .onion. Pero puedes buscar referencias a dominios .onion en el texto de las páginas web. Aquí hay un ejemplo de un script simple de Python (con expresión regular) que hace esto:
Ejecuta scripts/darknet/onion_links.py:```bash python scripts/darknet/onion_links.py
Código fuente 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
Puedes recolectar enlaces para otras redes como I2P de la misma manera:``` http.body:*.i2p
## Búsqueda de Directorios de Archivos, Copias de Seguridad y Registros
Hay una gran cantidad de sitios y servidores que dejan sus directorios de archivos abiertos debido a un error de configuración (y a veces deliberadamente). Aquí hay algunos ejemplos de consultas que te ayudarán a encontrarlos.
Buscar cualquier directorio de archivos:```
http.title:Index http.title:of
Buscar directorios con archivos de registro:``` http.title:Index http.title:of http.body:logs
Buscar directorios con volcados de base de datos:```
http.title:Index http.title:of http.body:sql
Buscar directorios con copias de seguridad archivadas:``` http.title:Index http.title:of http.body:backup?zip
Buscar directorios con información de acceso SSH:```
http.title:Index http.title:of http.body:("ssh_config" OR "ssh_known_hosts" OR "authorized_keys" OR "id_rsa" OR "id_dsa")
Buscar directorios con archivos que contengan otra información de autorización:``` http.title:Index http.title:of http.body:("pass" OR "logins" OR "config" OR "password")
Busca directorios con archivos descargados por usuarios:```
http.title:index http.title:of http.body:downloads
Buscar directorios con archivos de configuración de Docker:``` http.title:index http.title:of http.body:docker-compose
Puedes pensar en cientos de otras solicitudes similares. Experimenta con diferentes nombres y extensiones de archivo.
## Usando Netlas.io para la Informática Forense y la Respuesta a Incidentes
Esta sección es muy difícil de separar de la sección Netlas para OSINT, ya que las consultas allí listadas también serán útiles para quienes se dedican a la informática forense.
En esta sección, describimos consultas más "técnicas" que pueden ayudar, por ejemplo, a recopilar información sobre la infraestructura técnica de redes o a investigar ataques de phishing.
### Recopilación de Información de Servidores SMTP
SMTP (Protocolo Simple de Transferencia de Correo) es un protocolo de comunicación que permite enviar y recibir correos electrónicos. En la mayoría de los clientes de correo, al ver los correos electrónicos, está disponible la función "Mostrar original", que permite ver la dirección del servidor SMTP desde el cual se envió el correo.
Netlas permite obtener información sobre un servidor SMTP, así como sobre cualquier otra IP o dominio, y también buscar en el texto de los banners SMTP, lo que permite encontrar servidores asociados a un dominio, empresa o proveedor de alojamiento específico.
**Ejemplo de consulta de búsqueda**
```
smtp.banner:fornex.cloud
Herramientas CLI de 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
Ejemplo de código (biblioteca Python de Netlas)
Ejecutar en la línea de comandos:```bash python scripts/dfir/smtp_banner_search.py
Código fuente 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'])
Uno de los métodos populares de los estafadores es utilizar dominios que son muy similares en ortografía a los dominios de empresas conocidas.
Puede encontrar dichos dominios para una empresa determinada utilizando Netlas y la búsqueda difusa.
Abra la búsqueda de dominios Whois e ingrese el nombre de dominio de la empresa + ~. Por ejemplo:
netlas whois -q "example.com~"
domain:facebook.com~
[Probar en Netlas](https://app.netlas.io/whois_domains/?q=domain%3Afacebook.com~&page=1&indices=)
Después, haga clic en el icono izquierdo, seleccione el tipo de archivo de exportación, los nombres de archivo y los campos que desea guardar en el archivo. Haga clic en "Descargar" y espere un momento.
Por ejemplo, puede seleccionar el formato de archivo CSV y los campos dominio, expiration_date, status. Dicha tabla se puede ver cómodamente en Excel, Numbers o Google Docs.
### Búsqueda de Favicon
La búsqueda de favicon.ico tiene tres usos principales.
Primero, permite encontrar sitios y subdominios potencialmente relacionados. Intente encontrar la IP asociada a las tiendas Lidl:```
http.favicon.perceptual_hash:003c7e72207e3c00
Y también para encontrar sitios de phishing que utilizan el diseño de redes sociales populares, tiendas en línea, etc.
Segundo, es una búsqueda de varios dispositivos IoT. Intente encontrar productos HP:``` http.favicon.perceptual_hash:0c5ec8c181f37e2c
[Try in Netlas](https://app.netlas.io/responses/?q=http.favicon.perceptual_hash%3A0c5ec8c181f37e2c&page=1&indices=)
En tercer lugar, busca servidores que tengan cierto software ejecutándose en ellos. Intenta encontrar servidores con PhpMyAdmin:```
http.favicon.perceptual_hash:00084e5e5fffff8d
Hay tres formas principales de buscar por hash de favicon en Netlas:
También puede usar los siguientes filtros para buscar por favicon:
http.favicon.last_modifiedhttp.favicon.last_updatedhttp.favicon.urihttp.favicon.path
La búsqueda de dominios de Netlas permite obtener una lista completa de dominios asociados a una dirección IP o rango de direcciones específico. Por ejemplo:``` a:"163.114.132.0/24"
[Probar en Netlas](https://app.netlas.io/domains/?q=a%3A%22163.114.132.0%2F24%22&page=1&indices=)
Ejemplo de solicitud a la API
Herramientas CLI de 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
**Ejemplo de código (Netlas Python Library)**
Ejecutar en línea de comandos:```bash
python scripts/dfir/subnet_search.py
Código fuente 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'])
### Búsqueda de servidores con software malicioso
Netlas te permite encontrar servidores que tienen varios programas maliciosos instalados. Puedes localizarlos por la presencia de ciertas palabras en http.title o http.body, hash de favicon, ssl y otros parámetros.
Aquí tienes un ejemplo de una consulta que encontrará servidores que tengan instalado GoFish (Marco de phishing de código abierto):```
http.title:Gophish http.title:Login
Ten en cuenta que la técnica de usar el mismo operador dos veces (en lugar de un asterisco entre dos palabras) se usa aquí. A veces esto te ayuda a obtener más resultados de búsqueda.
Aquí hay algunos ejemplos más de solicitudes similares:``` http.title:CALDERA http.title:login http.title:Deimos http.title:C2
**Ejemplo de solicitud 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
**Ejemplo de código (Netlas Python Library)**
Ejecutar en la línea de comandos:```bash
python scripts/dfif/malware_search.py
Código fuente 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'])
## Búsqueda de tecnologías y ejemplos de código
Netlas, a diferencia de los motores de búsqueda convencionales, te permite buscar en todo el código HTML en lugar del texto de la página. Esto te permite encontrar sitios que utilizan ciertas bibliotecas de JavaScript. Esto puede ayudarte a encontrar ejemplos de código adecuados para tus tareas y ahorrarte tiempo.
Por ejemplo, buscar sitios que usen una antigua biblioteca oscura para dibujar gráficos:```
http.body:kinetic.js
También puedes ver cómo se utilizan diferentes frameworks CSS en sitios de ciertos temas y tomar prestadas buenas ideas de diseño:``` http.body:bootstrap.css http.title:travel
También puedes filtrar sitios que usen frameworks y tecnologías específicas usando etiquetas:```
tag.bootstrap:*
tag.angularjs:*
tag.wordpress:*
tag.nextjs:*
Netlas, como muchos otros motores de búsqueda, se puede utilizar sin un propósito específico, y simplemente explorar con su ayuda rincones inexplorados de Internet, con la esperanza de encontrar algo interesante allí.
Aquí hay algunos ejemplos de consultas de búsqueda que te ayudarán a encontrar lo que Google no puede.
Búsqueda por texto de banners de servidores Telnet (¡sí, todavía están vivos!):``` telnet.banner:library
Buscar por texto de banners de servidores FTP:```
ftp.banner:*library*
Buscar enlaces a libros y documentos:``` http.body:rowlingpdf
Buscar enlaces a música y video:```
http.body:*cats*mp4
Buscar enlaces a archivos torrent:``` http.body:catsmp4
Ten en cuenta que Netlas no censura de ninguna manera el contenido que almacena en su base de datos. Si encuentras algo ilegal o inmoral, debes presentar una queja ante el proveedor de alojamiento cuyos contactos están listados en la información del dominio.
## Problemas Comunes
### Error 429 - Solicitudes Demasiado Frecuentes
Si tu aplicación incluye múltiples solicitudes a la API de Netlas, es posible que encuentres este error:```json
{'detail': 'Request was throttled. Expected available in 1 second.'}
Una forma de resolver este problema es usar bibliotecas especiales de Python para configurar límites de tiempo en la ejecución de consultas, como el Paquete Limiter.
Aquí hay un ejemplo de su uso en código (límite de no más de 60 solicitudes por minuto). Primero, instala el paquete:``` pip install ratelimit
Y ejecuta rate_limit.py:```bash
python scripts/common_problems/rate_limit.py
INPUT:```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()
Existen paquetes similares para otros lenguajes de programación populares, ya que superar el límite de solicitudes es un problema muy común al trabajar con casi todas las API.
Si realmente necesitas hacer más de una consulta por segundo, puedes escribir al [equipo de ventas](https://netlas.io/sales/).
### KeyError
Otro problema común es la falta de una clave específica en la respuesta de algunos servidores. Por ejemplo, `['data']['http']['title']` falta con bastante frecuencia.
Si la clave falta, el script deja de ejecutarse. El manejo estándar de errores ayudará a evitarlo. Por ejemplo:```python
try:
print (response['data']['http']['title'])
except:
print ("no title")
La principal ventaja de trabajar con Netlas Python o la API de Netlas en lugar de simplemente escribir consultas en la versión web de Netlas.io es que puedes ahorrar una enorme cantidad de tiempo al escribir consultas genéricas. Por ejemplo, puedes recopilar rápidamente información sobre una larga lista de dominios utilizando código Python muy simple.
Ejecutar en la línea de comandos:```bash python scripts/common_problems/domain_list_search.py
Código fuente 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'])
Del mismo modo, puedes trabajar con una lista de certificados, direcciones IP, correos electrónicos y cualquier otra cosa que desees.
Un ejemplo de búsqueda de direcciones IP desde una lista cargada por URL se puede encontrar en Búsqueda de nodos de salida Tor.
Por defecto, la Netlas Python Library devuelve datos de tipo Dictionary (que es muy similar a JSON). Si deseas exportar los datos a MS Excel o Google Sheets, una forma sencilla de hacerlo es guardarlos en formato CSV.
Aquí tienes un ejemplo usando el paquete CSV. Ejecuta csv_export.py:```bash python scripts/common_problems/csv_export.py
INPUT:```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
Puede abrir netlas_results.csv en Excel o en cualquier editor de texto.
Usando Python, puede generar una amplia variedad de documentos basados en datos de Netlas, insertando imágenes, visualizaciones de datos y personalizando el diseño. Aquí hay algunos ejemplos de paquetes útiles.
XLSXWriter - generar archivos de Microsoft Excel.
PyPDF - generar archivos PDF.
PythonPPTX - generar presentaciones de Microsoft Power Point.
PythonDOCX - generar archivos de Microsoft Word.
Como se mencionó anteriormente, Netlas no almacena nombres de dominio no latinos en su codificación original, sino que los codifica en Punycode. Esto es necesario por razones técnicas, pero es completamente incómodo para la percepción humana.
Pero este problema se resuelve fácilmente con un par de líneas de código Python.
Instale el paquete IDNA Python:
pip install idna
``````bash
pip install idna
Y ejecuta punycode.py en la línea de comandos:```bash python scripts/common_problems/punycode.py
Please provide the Markdown content to translate.```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)
A veces puedes encontrarte con una situación en la que no se encuentran resultados o muy pocos al realizar una consulta, aunque estés seguro de que debería haber muchos más. En este caso, te recomendamos experimentar e intentar cambiar un poco las consultas.
o ``` http.body:(hello AND world)
4. Refina tus filtros de búsqueda tanto como sea posible. Por ejemplo, la consulta cve:*2023* no devolverá resultados. Pero la consulta cve.name:*2023* devolverá más de 28 millones.
5. Prueba diferentes pestañas cuando trabajes con la aplicación web o diferentes tipos de datos cuando trabajes con la API. Por ejemplo, al buscar dominios, a veces Host o Domain Whois (en lugar de response) funciona mejor.
### Eliminando Etiquetas HTML del Cuerpo HTTP
La clave ['data']['http']['body'] por defecto devuelve el texto completo del cuerpo de la página web, incluyendo todas las etiquetas html. Este formato no es muy fácil de leer. Pero puedes eliminarlas fácilmente con el paquete de Python [Html2text](https://pypi.org/project/html2text/).
Ejecuta en la línea de comandos:
pip install html2text
python scripts/common_problems/htmltotext.py
```
Código fuente de htmltotext.py:```python
import netlas
import html2text
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.body:*phpMyAdmin*`
netlas_query = netlas_connection.query(query="http.body:*phpMyAdmin*")
# iterate over data and print: ip, web page text
for response in netlas_query['items']:
print (response['data']['ip'])
print (html2text.html2text(str(response['data']['http']['body'])))
```
## Gestión de la Superficie de Ataque
La plataforma Netlas incluye herramientas para la gestión de la superficie de ataque, pero este tema está fuera del alcance de esta guía. Si está interesado en la gestión de la superficie de ataque en general y en el uso específico de Netlas, le recomendamos comenzar con estos artículos:
- [Guía completa sobre el descubrimiento de la superficie de ataque](https://netlas.io/blog/attack_surface_discovery_guide/).
- [Las mejores herramientas de visualización de la superficie de ataque](https://netlas.io/blog/best_attack_surface_visualization_tools/).
## Trabajo con Grandes Volúmenes de Datos
Si tiene un desafío realmente grande por delante. Por ejemplo, necesita recopilar datos sobre cientos de miles de dominios, entonces quizás una solución más racional en términos de tiempo y costos financieros sea comprar un conjunto de datos (csv/json) y trabajar con él en su propio servidor.
En [Netlas Datastore](https://app.netlas.io/datastore/) puede encontrar:
* Conjunto de datos de nombres de dominio conocidos (más de 2 mil millones de elementos)
* Conjunto de datos de DNS directo (más de 2 mil millones de elementos)
* Registros PTR conocidos (más de 1 mil millones de elementos) - GRATUITO
* Los 1,000,000 subdominios más comunes
y más.
## Agradecimientos
Muchas gracias a [@cyb_detective](https://twitter.com/cyb_detective) por su ayuda (https://cybdetective.com)