netlas-io/netlas-cookbookL'obiettivo di questa guida è molto semplice - insegnare a chiunque sia interessato alla sicurezza informatica, indipendentemente dal proprio livello di conoscenza, come sfruttare al meglio Netlas.io.
L'obiettivo di questa guida è insegnare a chiunque sia interessato alla cybersecurity, indipendentemente dal proprio livello di conoscenza, come sfruttare al meglio gli strumenti di ricerca di Netlas. È una lunga lettura. Abbiamo raccolto quanti più casi d'uso semplici possibile e mostrato come automatizzarli.
⭐️ Dacci una stella per mostrare il tuo apprezzamento
👁️ Iscriviti per aggiornamenti
Netlas è un motore di ricerca progettato per trovare e analizzare informazioni su tutti gli indirizzi IP e domini disponibili su Internet. Netlas ha alcune funzionalità di gestione della superficie d'attacco, ma questa guida si concentra principalmente sugli strumenti di ricerca di Netlas e su come utilizzarli nelle automazioni.
Netlas include diversi strumenti di ricerca:
Utilizzeremo principalmente la ricerca delle risposte (risultati della scansione internet), ma tutti gli strumenti funzionano allo stesso modo. Se capisci come usare lo strumento di ricerca delle risposte, puoi gestire qualsiasi altro.
Prima di entrare nei dettagli tecnici, vediamo come funziona Netlas.io con alcuni semplici esempi.
Apri Netlas.io IP/Dominio info e inserisci il nome del dominio o l'IP. Verranno visualizzate le seguenti informazioni come risultato:
Se hai bisogno di trovare domini cinesi o altri nomi di dominio internazionalizzati, convertili in Punycode. Per esempio:``` domain:*.xn--fiqs8s
Puoi farlo con l'aiuto di strumenti online speciali. Ad esempio - [Charset.org](https://www.charset.org/punycode)
### Cercare Siti Web che Contengono una Determinata Parola nel Titolo
Apri [Netlas.io response search](https://app.netlas.io/responses/) e inserisci:```
http.title:g*thub
In questo modo verranno individuati tutti i server i cui titoli HTTP contengono una parola che inizia con "g" e termina con "thub". Scopri di più sull'uso degli asterischi qui sotto.
Ora impariamo di più su come funzionano le query di ricerca in Netlas.io.
Netlas.io si basa su Elasticsearch, un motore di ricerca gratuito, open source, distribuito e RESTful. I metodi di ricerca in Netlas.io sono molto simili a quelli di altri database basati su Elasticsearch.
Le ricerche in Response, DNS, IP e Certificati consentono di utilizzare filtri (campi) nelle query di ricerca. Ad esempio:``` http.body:netlas
[Try in Netlas](https://app.netlas.io/responses/?q=http.body%3Anetlas&page=1&indices=)
Puoi utilizzare questa query per trovare pagine che contengono la parola "netlas" all'interno del tag <body> html.
Un elenco dei filtri disponibili per ogni tipo di ricerca viene visualizzato sul lato destro della pagina.
I filtri ti consentono di cercare server in base a molti parametri diversi. Ad esempio:
* `domain`
* `ip`
* `protocol`
* `certificate`
* `cve`
* `geolocation` (`città`, `continente`, `paese`)
e molti altri.
### Operatori Logici
Puoi utilizzare più filtri in una singola query e combinarli usando gli operatori logici `AND`, `OR`, `NOT`. Ad esempio:```
http.title:netlas NOT port:443
Se vuoi combinare più condizioni nella tua query, usa le parentesi:``` http.title:(netlas OR shodan) NOT port:443
[Prova in Netlas](https://nt.ls/OrFOY)
### Intervalli
Se utilizzi un valore numerico come valore di un campo, puoi designarlo come un valore da e a (limiti estremi dell'intervallo di valori):```
ip:[173.194.222.0 TO 173.194.222.255]
Oppure segna solo il limite superiore o solo il limite inferiore del valore:``` host:"1.1.1.1" port:<=1000
[Prova su Netlas](https://app.netlas.io/responses/?q=host%3A%221.1.1.1%22%20port%3A%3C%3D1000&page=1&indices=)
### Wildcard
Se non conosci la descrizione esatta di un certo carattere nella tua query (ad esempio, non conosci la zona esatta per un dominio o la grafia di un nome), puoi sostituirlo con un asterisco:```
domain:google.*
Puoi anche usare il punto interrogativo:``` domain:google.?
[Try in Netlas](https://app.netlas.io/responses/?q=domain%3Agoogle.%3F&page=1&indices=)
`*` - molti simboli, `?` - un simbolo.
Puoi anche usare gli asterischi nei filtri. Per esempio:```
\*.banner:database
Questa query esegue una ricerca su tutti i tipi di banner contemporaneamente e sostituisce diversi filtri: amqp.banner:, ftp.banner:, dns.banner:, telnet.banner:, etc.
Se hai bisogno di cercare non per valore esatto, ma per valore approssimativo di un campo (ad esempio, pagine i cui titoli contengono tutti i nomi consonanti con Joseph), basta aggiungere ~ alla query:```
http.title:Joseph~
[Try in Netlas](https://app.netlas.io/responses/?q=http.title%3AJoseph~&page=1&indices=)
### Espressioni regolari
L'espressione regolare è una sequenza di caratteri che consente di cercare, recuperare e sostituire parti di testo in un documento sorgente che corrispondono a determinati schemi. Ad esempio:
* Qualsiasi indirizzo email: ```text
([a-zA-Z0–9+._-]+@[a-zA-Z0–9._-]+\.[a-zA-Z0–9_-]+)
Per maggiori informazioni sull'uso delle espressioni regolari, consulta gli esempi nel Netlas Cookbook (quello che stai leggendo) e i link qui di seguito:
Manuale di sintassi regex nella documentazione di Elasticsearch
Puoi salvare i tuoi risultati (tutti o campi selezionati) in formato JSON e CSV per visualizzarli in un formato che preferisci o analizzarli automaticamente con diversi strumenti.
Puoi raggruppare i risultati per diversi valori di campo per velocizzare il tempo di ricerca. Ad esempio, per nome di dominio o geolocalizzazione.
Puoi condividere liberamente i link ai risultati di ricerca (non è richiesta registrazione per aprirli, a meno che l'utente non abbia superato il limite gratuito di 50 richieste).
Ricorda anche che tutte le query che hai effettuato possono essere visualizzate nella tua pagina del profilo (link nell'angolo in alto a destra).
La funzione più importante di Netlas.io è aiutare le persone a condurre ricerche sulla cybersecurity più velocemente ed efficientemente. Il servizio dispone di un'API (interfaccia di programmazione delle applicazioni) che consente di automatizzare l'esecuzione di varie richieste.
Può essere implementata sia in semplici script Python o Bash di poche righe, sia in applicazioni complesse multifunzionali.
Puoi leggere ulteriori informazioni sull'utilizzo dell'API di Netlas nel Netlas Cookbook (quello che stai leggendo) o nella documentazione ufficiale:
Questo è il primissimo punto da cui iniziare con l'API. Non devi nemmeno pagare un abbonamento (50 richieste al giorno sono gratuite). Basta andare alla pagina del profilo.
Non devi scrivere script o creare applicazioni per iniziare a utilizzare l'API di Netlas. Puoi semplicemente testarla usando il tuo client API preferito. Consulta le istruzioni qui.
Simile ad altre API, la risposta dell'API Netlas è composta da intestazioni e un corpo di risposta in formato JSON (JavaScript Object Notation). I file JSON contengono dati in formato chiave-valore e possono essere analizzati utilizzando quasi tutti i linguaggi di programmazione.
Se usi Swagger, puoi copiare o scaricare il corpo della risposta e visualizzarlo in qualsiasi editor di testo o analizzatore JSON.
Un piccolo consiglio che tornerà utile quando si scrive codice utilizzando l'API di Netlas. Per comprendere più velocemente la struttura di un file JSON e trovare il percorso per ottenere un determinato valore, utilizza strumenti speciali come:
Il modo più semplice per automatizzare le richieste all'API di Netlas è utilizzare una libreria Python (pacchetto) appositamente progettata.
Repo Github della libreria Netlas-Python
Vediamo come funziona con un semplice esempio. Tutti gli esempi di codice del Netlas Cookbook si trovano nella cartella scripts. Puoi clonare questo repository ed eseguirli sul tuo dispositivo:```shell git clone https://github.com/netlas-io/netlas-cookbook
Se non hai mai eseguito uno script Python prima d'ora e non sai come fare, puoi iniziare aprendo il repository Netlas CookBook in Gitpod.
Gitpod è un ambiente di sviluppo cloud basato su Ubuntu (distribuzione Linux). Apri questo link nel tuo browser (accedi con il tuo account Github):
[Run Netlas Cookbook in Gitpod](https://gitpod.io#https://github.com/netlas-io/netlas-cookbook)
Installa la libreria Python di Netlas usando pip (gestore di pacchetti per Python). Digita nella riga di comando:```shell
pip install netlas
Controlla l'installazione. Inserisci nella riga di comando:```shell netlas --help
Esegui netlas_python_example.py:```shell
python3 scripts/netlas_python_example.py
E, naturalmente, puoi semplicemente copiare il codice e salvarlo nei file. Ecco il codice del primo esempio:```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']}]")
### Esempi di chiavi di risposta per ottenere dati utili
È stato menzionato sopra che per trovare le patch JSON delle risposte API per ottenere i dati necessari, è possibile utilizzare applicazioni online speciali (valutatori JSON). Per rendere la tua vita ancora più facile, ecco una piccola lista di esempi di chiavi di risposta della libreria Python che sono più spesso necessarie.```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']
Quando si lavora con la libreria Netlas Python, è molto importante specificare correttamente il tipo di dati che si desidera recuperare. Per impostazione predefinita, viene restituito il tipo response e molti esempi di Netlas CookBook lo utilizzano.
Ma per alcune attività, come ottenere informazioni whoois su un dominio o cercare domini in una sottorete, è necessario utilizzare un tipo di dati diverso. Ad esempio:```python netlas_query = netlas_connection.query(query='a:"163.114.132.0/24"',datatype="domain")
Se pensi che una query non restituisca risultati quando dovrebbe - prova semplicemente a cambiare il valore del parametro **datatype**. È molto probabile che questo aiuti.
Datatype disponibili:
- **datatype="response"** corrisponde ai risultati ottenibili in [Netlas Responses Search](https://app.netlas.io/responses/).
- **datatype="domain"** corrisponde ai risultati ottenibili in [Netlas DNS search](https://app.netlas.io/domains/)
- **datatype="domain-whois"** corrisponde ai risultati ottenibili in [Netlas Domain Whois Search](https://app.netlas.io/whois_domains/).
- **datatype="ip-whois"** corrisponde ai risultati ottenibili in [Netlas IP Whois Search](https://app.netlas.io/whois_ip/).
- **datatype="cert"** corrisponde ai risultati ottenibili in [Netlas Certificates Search](https://app.netlas.io/certs/).
### Netlas CLI Tools
Puoi anche utilizzare la libreria Python di Netlas direttamente dalla riga di comando. Ad esempio:```bash
netlas search "http.title:johnsmith" -f json >results.json
Questo semplice comando cerca tutti i server che hanno la parola johnsmith nell'header, restituisce i risultati in formato JSON e li salva nel file resutls.json.
Tutte le altre funzionalità dell'API Netlas possono essere utilizzate allo stesso modo. Puoi saperne di più tramite l'aiuto (comando -h) e gli esempi nel Netlas Cookbook (quello che stai leggendo ora).``` 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.
Prima di eseguire diversi comandi di Netlas CLI Tools, salva la chiave API nelle impostazioni:```bash
netlas savekey YOUR_API_KEY
Abbiamo anche un repository Github con alcuni esempi di automazione di varie attività utilizzando script bash e gli strumenti CLI di Netlas:
L'API di Netlas ha molti metodi, ma i più comunemente utilizzati sono i metodi search e download. Sono molto simili tra loro, ma presentano comunque alcune differenze.
Il metodo search carica una pagina di risultati (20 elementi) alla volta e consente di caricare un massimo di 200 pagine (20*200=4000 elementi). Il metodo download scarica tutti i risultati (ma richiede più risorse per l'esecuzione).
Esiste anche un metodo host che restituisce semplicemente le informazioni più basilari su un particolare dominio o IP (il datatype (come per altri metodi) non è necessario specificare):```bash netlas host "51.159.153.170"
### Parametri aggiuntivi della richiesta
L'API Netlas ti consente di regolare flessibilmente i dati restituiti dalle richieste con parametri aggiuntivi. Ad esempio:
* indices - id che corrisponde a una data di indicizzazione specifica. Per trovare l'id per una data specifica, apri app.netlas.io, clicca sul calendario a destra della barra di inserimento della query di ricerca, seleziona la data che ti interessa e osserva come cambia il parametro indices nell'URL nella barra degli indirizzi del browser.
* start - numero di pagina dei risultati (default 0)
* fields - nomi dei campi da includere nei risultati (tutti i campi di default). Sarà utile per velocizzare e ottimizzare il codice con un gran numero di richieste.
### Effettuare richieste con Python (senza la libreria Python Netlas)
Potresti trovare più facile in alcuni casi non utilizzare la Netlas Python Library, ma usare il pacchetto standard requests di Python, familiare a molti sviluppatori:
Inserisci nella riga di comando:```bash
python scripts/python_example.py
Codice sorgente di 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())
Ma la libreria Python di Netlas è comunque preferibile poiché progettata per gestire diversi problemi con l'elaborazione delle query (errori, lunghe attese, ecc.).
### Esempi per altri linguaggi di programmazione
Sebbene raccomandiamo l'uso della nostra libreria Python per automatizzare la ricerca in Netlas, vale la pena notare che l'API Netlas può essere integrata nella maggior parte delle applicazioni con un'ampia varietà di stack tecnologici. La cosa principale è che sia in grado di effettuare **richieste REST** e **analizzare dati JSON**.
Ecco alcuni esempi in diversi linguaggi di programmazione popolari.
#### NodeJS <!-- omit in toc -->
Inserisci nella riga di comando:```bash
node scripts/node_example.js
Se non stai utilizzando Gitpod, dovresti avere NodeJS installato sul tuo dispositivo.
Codice sorgente di 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 -->
Inserisci nella riga di comando:```bash
ruby scripts/ruby_example.rb
Se non stai usando Gitpod, dovresti avere Ruby installato sul tuo dispositivo.
Codice sorgente di 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 -->
Inserisci nella riga di comando:```bash
bash scripts/bash_example.sh
Codice sorgente di 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à JQ
Nota che nell'esempio precedente, l'utilità JQ è stata utilizzata per estrarre campi da dati JSON.
Viene talvolta definita "come sed per dati JSON". È uno strumento sorprendentemente utile per lavorare con qualsiasi dato JSON. Ecco alcuni esempi di sintassi.
Stampa il primo elemento dell'array JSON:```
.items[0]
Stampa tutti gli elementi dell'array JSON:``` .items[]
Stampa tutti i sottoelementi 'data' del primo elemento dell'array JSON:```
.['items'][0]['data'][]
Stampa tutti i sub-subitem per ogni elemento dell'array JSON:``` .items[].data.technical[]
Puoi leggere di più su JQ qui (ti consiglio di prestare particolare attenzione al filtraggio dei dati): [documentazione dell'utilità JQ](https://jqlang.github.io/jq/)
### Strumenti AI per Scrivere Codice
Se incontri problemi durante la personalizzazione degli esempi del Netlas Cookbook, ti consigliamo di cercare aiuto da strumenti AI per migliorare e scrivere codice. Per esempio:
[ChatGPT](https://chatgpt.com)
[Code Llama](https://huggingface.co/spaces/codellama/codellama-playground)
[You.com](https://you.com/)
Quando lavori con tali servizi, devi solo descrivere a parole il compito che vuoi risolvere con l'aiuto del codice.
### Verificatori di Codice
Quando rielabori gli esempi del Netlas Cookbook per adattarli ai tuoi scopi, potresti scoprire che il codice non verrà eseguito a causa di alcuni errori. Strumenti online speciali possono aiutarti a trovarli e correggerli:
[ExtendsClass Python Tester](https://extendsclass.com/python-tester.html)
[Snyk](https://snyk.io/code-checker/python/)
Se non vuoi copiare il tuo codice su servizi di terze parti, puoi verificarlo per errori sul tuo dispositivo utilizzando Pylint (analizzatore statico del codice):
[Pylint Python Package](https://pypi.org/project/pylint/)
## Utilizzo di Netlas.io per OSINT (Open Source Intelligence)
Netlas.io può aiutarti a raccogliere dati su un dominio o un'azienda, oltre a trovare menzioni di una persona (o chiunque) su Internet.
Può anche essere utilizzato per trovare versioni vecchie di pagine web (come analogo della Wayback Machine).
### Cerca Nickname o Email di una Persona nei Contatti WHOIS
Spesso i dati WHOIS contengono solo le informazioni di contatto dell'azienda che registra i domini. Ma a volte possono esserci contatti personali di persone di interesse. Questa query ti aiuterà a trovarli.
*Questo metodo potrebbe richiedere un abbonamento a pagamento.* [Vedi i prezzi](https://netlas.io/pricing/)
**Esempio di query di ricerca**
```
whois.related_nets.contacts.emails:sweetwater
Esempio di richiesta API
Strumenti CLI 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
Esempio di codice (Libreria Python Netlas)
Esegui nella riga di comando:```bash python scripts/osint/whois_email_search.py
Codice sorgente di 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 ti permette di cercare menzioni di determinate parole nelle intestazioni e nel codice html delle pagine web. Puoi cercare parole per corrispondenza esatta, per corrispondenza approssimativa (vedi la sezione query fuzzy) e sostituire con asterischi i caratteri di cui non sei sicuro.
Esempio di query di ricerca
```
http.title:sweetwater OR http.body:sweetwater
[Prova in Netlas](https://app.netlas.io/responses/?q=http.title%3Asweetwater%20OR%20http.body%3Asweetwater&page=1&indices=)
**Esempio di richiesta API**
Strumenti CLI di 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
**Esempio di codice (libreria Python Netlas)**
Esegui nella riga di comando:```bash
python scripts/osint/title_body_search.py
Codice sorgente di 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'])
### Ricerca di "Juicy Info Files" nei sottodomini del sito web dell'azienda
Metagoofil è stato uno strumento popolare tra i practitioner di OSINT per molti anni. Cerca su Google file di documenti sul sito web di un'azienda (pdf, xlsx, docx, ecc.) e analizza i loro metadati.
E ciò che non è indicizzato da Google può essere trovato con Netlas e poi scaricato sul tuo computer e analizzato con lo strumento [MetaDetective](https://github.com/franckferman/MetaDetective).```
uri:*lidl.* AND http.body:pdf
Puoi sostituire il filtro uri: con domain: e host: (ti consiglio di confrontare sempre i risultati quando usi questi tre filtri).
Puoi anche cercare un'ampia varietà di estensioni di file, a seconda di cosa vuoi trovare. Ad esempio:``` 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
**Esempio di richiesta 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
**Esempio di codice (Netlas Python Library)**
Esegui nella riga di comando:```bash
python scripts/osint/juicyinfo_search.py
Codice sorgente di 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'])
Per automatizzare i collegamenti a documenti PDF dal corpo della pagina web puoi utilizzare il pacchetto Python [Re](https://docs.python.org/3/library/re.html).
### Ricerca di menzioni di numeri di telefono
Come per nickname ed email, puoi anche cercare menzioni di un numero di telefono nel codice delle pagine web o nelle informazioni di contatto WHOIS.
Isoliamo questo compito come esempio separato, perché la ricerca di un numero di telefono è complicata dal fatto che può essere scritto in diversi formati.
**Esempio di query di ricerca**
```
http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999
Quando effettui una richiesta, devi tenere conto del formato di registrazione del numero di telefono accettato nel paese a cui appartiene il numero che ti interessa.
Esempio di richiesta 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
Non dimenticare che puoi cercare i numeri di telefono non solo nel corpo della pagina, ma anche nelle informazioni di contatto WHOIS. Questo può essere fatto utilizzando il 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
Esempio di codice (Netlas Python Library)
Esegui nella riga di comando:```bash python scripts/osint/phonenumber_search.py
Codice sorgente di 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'])
Immaginiamo che tu sia un musicista e desideri trovare tutti i siti in cui sono pubblicati i tuoi brani. Puoi farlo cercando pagine che menzionano il tuo nome e contengono link a file con estensione .mp3.
Esempio di query di ricerca
```
(http.title:alla OR http.body:alla) AND http.body:*.mp3
[Prova in Netlas](https://nt.ls/HEhJj)
**Esempio di richiesta API**
Strumenti CLI 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
**Esempio di codice (libreria Python Netlas)**
Esegui nella riga di comando:```bash
python scripts/osint/file_mentions_search.py
Codice sorgente di 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'])
### Raccolta di informazioni WHOIS sui domini
WHOIS è un database pubblico mondiale che memorizza informazioni su tutti i domini registrati nel mondo.
**Esempio di query di ricerca**
Utilizza [la ricerca WHOIS sui domini](https://app.netlas.io/whois_domains/)```
github.com
Esempio di richiesta 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
Esempio di codice (Netlas Python Library)
Esegui nella riga di comando:```bash python scripts/osint/whois_search.py
Codice sorgente di 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'])
Il tag <address> si trova all'interno del tag <head> di una pagina web e può contenere indirizzi fisici. Con una ricerca che utilizza questo tag, puoi trovare siti associati a una particolare via e talvolta anche a un edificio specifico.
Esempio di query di ricerca
```
http.contacts.address:kirby
[Prova in Netlas](https://app.netlas.io/responses/?q=http.contacts.address%3Akirby&page=1&indices=)
Puoi anche usare http.contacts.email: per la ricerca email.
**Esempio di richiesta API**
Netlas CLI Tools:```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
**Esempio di codice (Netlas Python Library)**
Esegui nella riga di comando:```bash
python scripts/osint/contacts_search.py
Codice sorgente di 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'])
### Cerca il nome dell'autore nei Meta Tag
I tag `<meta>` si trovano all'interno del tag `<head>` di una pagina web e contengono le parole chiave più importanti, la descrizione, informazioni di servizio varie e il nome dell'autore.
Cercare nickname e nome/cognome tramite meta tag (http.meta) consente di trovare siti associati a una persona specifica più velocemente rispetto alla ricerca dell'intero codice html (http.body).
**Esempio di query di ricerca**
```
http.meta:nazar
Esempio di richiesta API
Netlas CLI Tools:```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
Esempio di codice (Netlas Python Library)
Esegui nella riga di comando:```bash python scripts/osint/author_meta_search.py
Codice sorgente di 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'])
Oltre al nome dell'autore, i meta tag possono contenere una varietà di informazioni: codifica, lingua, autorizzazione all'indicizzazione della pagina da parte dei robot dei motori di ricerca, testo per le schede di collegamento nei social network, metadati OpenGraph e molto altro. Ecco alcuni ulteriori esempi di meta tag che possono contenere informazioni utili per le indagini:
<meta name="description"> - descrizione del contenuto della pagina web.<meta name="keywords"> - parole chiave che descrivono il contenuto della pagina web.<meta name="generator"> - nome dello strumento utilizzato per generare il contenuto della pagina (utile per la ricerca di CMS e piattaforme di hosting).<meta name="copyright"> - nome della persona o dell'azienda che detiene i diritti d'autore sul contenuto della pagina web.Un altro passo importante per trovare informazioni su una persona o un'azienda è cercare la sua menzione nel testo dei banner dei server FTP. È possibile che l'indirizzo IP dei server trovati sia la chiave per individuare altri siti correlati alla persona o all'azienda che ti interessa. E, in caso di grande fortuna, trovare qualcosa di interessante nei file lì pubblicati (se il server FTP è aperto).
Esempio di query di ricerca
```
ftp.banner:"Collado"
Se hai bisogno di cercare server FTP tramite un altro parametro (come città o intervallo di indirizzi IP), utilizza il filtro prot7:ftp.
[Prova su Netlas](https://app.netlas.io/responses/?q=ftp.banner%3A%22Collado%22%20&page=1&indices=)
**Esempio di richiesta API**
Netlas CLI Tools:```bash
netlas search 'ftp.banner:"Collado"' -f json
Nota che quando vengono usati doppi apici nelle query, la query stessa è scritta tra apici singoli.
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
**Esempio di codice (Netlas Python Library)**
Esegui nella riga di comando:```bash
python scripts/osint/ftp_banner_search.py
Source code of 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'])
### Ricerca di Informazioni di Contatto nei Certificati SSL
Un certificato SSL è un certificato digitale che autentica un sito web e consente l'uso di una connessione crittografata. Può contenere informazioni sul suo proprietario: nome della persona di contatto, nome dell'organizzazione, paese e talvolta anche l'indirizzo e il codice postale. Puoi cercare queste informazioni utilizzando i seguenti filtri (e molti altri):
- `certificate.issuer.email_address`
- `certificate.issuer.given_name`
- `certificate.issuer.organization`
- `certificate.issuer.postal_code`
- `certificate.issuer.street_address`
- `certificate.issuer.surname`
Proviamo a trovare indirizzi IP che hanno una certa parola nell'indirizzo stradale nel loro certificato:```
certificate.issuer.street_address:*mcgill*
Esempio di richiesta API
Strumenti CLI Netlas:```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
Esempio di codice (Libreria Python Netlas)
Esegui nella riga di comando:```bash python scripts/osint/certificates_search.py
Codice sorgente di 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 è stato utilizzato dagli specialisti OSINT per cercare vecchie versioni di siti web e pagine di profili di social media al fine di trovare informazioni di contatto e altri dati ormai cancellati.
Ma, sfortunatamente, archive.org non salva copie di tutti i siti e non lo fa molto spesso (per alcuni siti solo un paio di volte all'anno o meno).
Tuttavia, Netlas salva vecchie versioni dei siti anche dal 2021!
I seguenti filtri sono più spesso utilizzati per cercare siti:``` http.title:"github.com"
domain:github.com
host:github.com
Se fai clic sull'icona più a destra accanto al campo per inserire le query di ricerca, vedrai un menu per selezionare una data di scansione. Puoi usarlo per filtrare i codici html dei siti salvati in una data specifica.
Per vedere l'aspetto del sito, copia il contenuto del campo "body" (scheda response) in un qualsiasi editor di testo e cancella i caratteri \t\r\n dal codice html.
Dopodiché, copia il codice in uno dei visualizzatori html online, come [Code beautify](https://codebeautify.org/htmlviewer). Oppure salva il file in formato html e poi aprilo nel browser.
### 9 Modi per Cercare Siti Web Correlati
Quando si raccolgono informazioni su una persona o un'azienda, può essere importante trovare quanti più siti possibile che possano essere in qualche modo correlati ad essi. Ci sono almeno 5 modi per farlo con Netlas.
1. ID per vari servizi (analytics, sistemi pubblicitari, applicazioni per l'integrazione con social network e sistemi di pubblicazione). La loro sovrapposizione può indicare che è stata coinvolta una persona o un team. Alcuni esempi:
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ì, tutto si trova nel codice su alcuni siti.
E una serie di altri identificatori che si trovano più spesso in cima al codice HTML (ma a volte in tutto il codice).
[Try in Netlas](https://nt.ls/BCrw9)
2. ID dei programmi di affiliazione (usa anche http.body per cercarli). Puoi trovarli nei link di affiliazione che una persona pubblica su altri siti o nei social network. Possono essere i seguenti parametri URL (e simili):```
aff_fcid=
user_id=
partner_id=
ref_id=
```
"GitHub, Inc."
[Prova su Netlas](https://app.netlas.io/whois_domains/?q=%22GitHub%2C%20Inc.%22&page=1&indices=)
4. Cerca per server di posta nella ricerca DNS di Netlas
```
mx:*.parklogic.com
```
ns:ns?.parklogic.com
[Try in Netlas](https://app.netlas.io/domains/?q=mx%3A*.parklogic.com&page=1&indices=)
6. Ricerca menzioni di file (principalmente loghi e avatar degli utenti) [->](https://github.com/netlas-io/netlas-cookbook#search-file-mentions-looking-for-content-that-may-be-infringing-on-copyrights)
7. Ricerca sottodomini [->](https://github.com/netlas-io/netlas-cookbook#search-subdomains)
8. Ricerca contatti Whois (nella ricerca delle risposte Netlas) [->](https://github.com/netlas-io/netlas-cookbook#search-persons-nickname-or-email-in-whois-contacts)
9. Ricerca favicon [->](https://github.com/netlas-io/netlas-cookbook#favicon-search)
## Scraping (Estrarre dati dal corpo della pagina web)
L'API di Netlas è un ottimo strumento per raccogliere contatti e altri dati di siti web. In primo luogo, permette di farlo rapidamente. In secondo luogo, non richiede l'uso di proxy. In terzo luogo, permette di raccogliere dati da siti attualmente non disponibili.
Tuttavia, ci sono alcuni svantaggi: Netlas scansiona solo le pagine principali dei siti e alcuni siti rari non sono inclusi nel suo database a causa della protezione. Ma può comunque essere di grande utilità.
Esistono tre approcci principali allo scraping: raccogliere informazioni da tag HTML e selettori CSS, estrarre dati usando espressioni regolari e scraping basato su AI. Diamo un'occhiata più da vicino ai primi due.
### Pacchetto Beatifulsoup
[Beatifulsoup](https://pypi.org/project/beautifulsoup4/) è uno dei pacchetti Python più popolari al mondo per il parsing di codice HTML e file XML. Proviamo a usarlo per estrarre i titoli delle pagine (dai tag \<h1>, NON dai tag \<title> tages).
Prima, installa il pacchetto:```bash
pip install beautifulsoup4
Ed esegui scripts/osint/scraping_beatifulsoup.py:```bash python scripts/osint/scraping_beatifulsoup.py
Codice sorgente di 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
Puoi estrarre dati da altri elementi delle pagine web in modo simile:``` 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()
If you want to find all elements of a certain type use the find_all() method.
### Pacchetto Re
[Re](https://docs.python.org/3/library/re.html) è un pacchetto Python preinstallato per cercare e recuperare dati usando espressioni regolari. È utile per estrarre informazioni di contatto da pagine web e molti altri compiti. Vediamo un esempio di come funziona.
Esegui scripts/osint/scraping_re.py:```bash
python scripts/osint/scraping_re.py
Codice sorgente di 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
Allo stesso modo, puoi estrarre link, numeri di telefono, indirizzi di portafogli di criptovalute e altro ancora. I pattern pronti possono essere trovati nelle librerie di espressioni regolari:
[Regex Lib](https://regexlib.com/)
[UI Bakery Regex Library](https://uibakery.io/regex-library)
[Regex 101](https://regex101.com/)
### Altri pacchetti Python per lo scraping
I pacchetti Beautiful Soup e Re sono solo uno dei tanti strumenti per estrarre dati da pagine web usando Python. Ecco alcuni altri esempi di tali pacchetti:
* [Scrapy](https://pypi.org/project/Scrapy/): È principalmente un crawler (uno strumento per attraversare le pagine del sito web utilizzando i link trovati su altre pagine) e, inoltre, ha ampie capacità per estrarre dati dalle pagine web.
* [Selenium](https://pypi.org/project/selenium/): Uno strumento per automatizzare l'esperienza del browser. Permette di estrarre dati da contenuti generati da JavaScript.
* [Lxml](https://pypi.org/project/lxml/): Strumento per estrarre e validare file XML.
* [PDFtoText](https://pypi.org/project/pdftotext/) - strumento per estrarre contenuto testuale da file PDF.
* [pyChatGPT](https://pypi.org/project/pyChatGPT/) - pacchetto non ufficiale per l'interazione con CHATGPT (non richiede la chiave API di OpenAI), che permette di analizzare informazioni testuali con l'IA.
## Usare Netlas.io per le indagini sulle criptovalute
Netlas offre una grande opportunità per i ricercatori specializzati in crimini legati alle criptovalute. In primo luogo, può essere usato per cercare riferimenti a indirizzi di portafogli e numeri di transazione. In secondo luogo, può essere usato per cercare fattorie di mining vulnerabili, nodi e altri server associati all'infrastruttura delle criptovalute.
### Cerca fattorie di mining
Le fattorie di mining Antminer, rilasciate per la prima volta da Bitmain nel 2013, sono una delle linee di modelli di fattorie di mining più popolari al mondo. Puoi trovarle dalla presenza della parola "antMiner" nell'header www_authenticate.```
http.headers.www_authenticate:antMiner
Puoi anche cercare altri tipi di fattorie di mining. Ad esempio:``` http.headers.www_authenticate:XMR-Stak-Miner
Sperimenta combinando diversi filtri, le parole 'miner/mining' e i nomi delle criptovalute.
**Esempio di richiesta API**
Strumenti CLI Netlas:```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
**Esempio di codice (Netlas Python Library)**
Esegui nella riga di comando:```bash
python scripts/crypto/mining_farms_search.py
Codice sorgente di 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'])
### Cerca Siti Web Infettati da Cryptominer
Coinhive, un servizio che permette ai siti web (per lo più hackerati) di utilizzare i computer dei loro visitatori per minare criptovalute, chiuderà nel 2019. Ma nonostante ciò, i suoi link sono ancora incorporati in molti siti in tutto il mondo. Proviamo a trovarli:```
http.body:coinhive.min.js domain:*
Nota che utilizziamo il filtro domain:* per trovare specificamente i siti, non tutti i dispositivi.
Allo stesso modo, puoi cercare siti infettati da altri cryptominer (così come altri codici malevoli che vengono eseguiti sul lato dell'utente).
Esempio di richiesta 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
Esempio di codice (libreria Python Netlas)
Esegui nella riga di comando:```bash python scripts/crypto/search_sites_injected_with_miners.py
Codice sorgente:```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'])
I nodi Bitcoin utilizzano la porta 8333 per la connessione TCP. Pertanto, è facile trovarli usando il filtro di ricerca "port:".``` port:8333 cve:*
Nota che usiamo il filtro "cve:*" per cercare server con vulnerabilità.
**Esempio di richiesta 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
**Esempio di codice (Netlas Python Library)**
Esegui in riga di comando:```bash
python scripts/crypto/search_bitcoin_nodes.py
Codice sorgente di 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'])
## Usare Neltas per il Pentest
Netlas.io ti permette di cercare siti con molti diversi tipi di vulnerabilità. Questo può essere fatto tramite il numero di vulnerabilità (CVE-...), il nome del software installato sul server, certe parole negli header delle pagine, e altri parametri.
Puoi monitorare le CVE (Common Vulnerabilities and Exposures) pubblicate più di recente su questi siti:
* [CVE Details](https://www.cvedetails.com/)
* [VulDB](https://vuldb.com/)
* [OpenCVE](https://www.opencve.io/)
Pubbliciamo regolarmente anche le query più rilevanti per cercare dispositivi e software vulnerabili sui nostri feed [Twitter](https://twitter.com/Netlas_io), [Telegram](https://t.me/netlas) e [Discord](https://nt.ls/discord), così come nel repository Github di [Netlas Dorks](https://github.com/netlas-io/netlas-dorks).
In questa sezione, tratteremo semplicemente i principi generali della ricerca di siti e server con vulnerabilità.
### Ricerca dei Sottodomini
Usando gli asterischi nelle query di ricerca, puoi trovare tutti i sottodomini di diversi livelli (il cui nome termina con il nome di un particolare dominio di primo livello (.com) o di secondo livello (google.com)).
**Esempio di query di ricerca**
```
domain:*.github.com OR host:*.github.com
Esempio di richiesta API
Strumenti Netlas CLI:```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
Codice di esempio (Libreria Python Netlas)
Esegui da riga di comando:```bash python scripts/pentest/subdomain_search.py
Codice sorgente di 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'])
Esempio di query di ricerca
```
cve.name:CVE-2022-22965
[Try in Netlas](https://app.netlas.io/responses/?q=cve.name%3ACVE-2022-22965&page=1&indices=)
**Esempio di richiesta API**
Strumenti CLI di Netlas:```bash
netlas search "cve.name:CVE-2022-22965" -f json
CVE-2022-22965 - L'applicazione Spring MVC o Spring WebFlux in esecuzione su JDK 9+ può essere vulnerabile all'esecuzione remota di codice (RCE) tramite data binding. Dettagli
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
**Esempio di codice (Netlas Python Library)**
Esegui nella riga di comando:```bash
python scripts/pentest/cve_search.py
Codice sorgente di 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'])
### Cerca siti con vulnerabilità che contengono una certa parola nella loro descrizione
Se non hai bisogno di investigare server con un tipo specifico di vulnerabilità, ma vuoi semplicemente vedere server vulnerabili in un gruppo specifico (come Oracle WebLogic Server o siti WordPress), puoi cercarli utilizzando parole chiave e il filtro cve.description:.
Per filtrare i siti che hanno exploit pubblicati per le vulnerabilità, usa cve.has_exploit:true.
**Esempio di query di ricerca**
```
cve.description:weblogic AND cve.has_exploit:true
Esempio di richiesta 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
Esempio di codice (Netlas Python Library)
Esegui nella riga di comando:```bash python scripts/pentest/cve_description_search.py
Codice sorgente di 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'])
Questo metodo permette di trovare dispositivi prodotti da un'azienda specifica.
Esempio di query di ricerca
```
http.headers.server:"yawcam"
Cerca webcam YawCam.
[Prova su Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22yawcam%22&page=1&indices=)
**Esempio di richiesta API**
Strumenti CLI di Netlas:```bash
netlas search 'http.headers.server:"yawcam"' -f json
Nota che quando si usano le virgolette doppie nelle query, la query stessa è scritta tra virgolette singole.
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
**Esempio di codice (Netlas Python Library)**
Esegui nella riga di comando:```bash
python scripts/pentest/server_name_search.py
Codice sorgente di 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'])
#### Login e Password Predefiniti <!-- omit in toc -->
Un'applicazione pratica della ricerca per nome del software negli header del server è la ricerca di dispositivi di un particolare fornitore. Ciò può essere necessario sia quando si cercano dispositivi con vulnerabilità specifiche, sia per dispositivi con login e password standard.
Login e password standard per diversi modelli di dispositivi possono essere trovati in elenchi speciali. Per esempio:
* [Login e Password predefiniti del Router per i migliori modelli (Elenco 2023)](https://www.softwaretestinghelp.com/default-router-username-and-password-list/)
* [Nome utente – Password – Indirizzo IP predefiniti per telecamere di sicurezza](https://www.a1securitycameras.com/blog/default-username-passwords-ip-addresses-for-surveillance-cameras/)
* [Le Password Predefinite di Quasi Ogni Telecamera IP](https://www.hackers-arise.com/post/the-default-passwords-of-nearly-every-ip-camera)
* [Elenco delle password predefinite da Datarecovery](https://datarecovery.com/rd/default-passwords/)
Ricorda che l'uso di login e password standard per accedere a sistemi altrui viola le regole etiche e potrebbe essere illegale nel tuo paese.
### Ricerca di Server Vulnerabili tramite l'Hash del Favicon
Un modo per trovare server web esposti a una particolare vulnerabilità è cercare il favicon ico di un particolare software del server web.
**Esempio di query di ricerca**
```
http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e
Questa query cerca il favicon di SecurePoint (CVE-2023-22620).
Esempio di richiesta API
Strumenti CLI di Netlas:```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
Esempio di codice (Netlas Python Library)
Esegui nella riga di comando:```bash python scripts/pentest/favicon_hash_search.py
Codice sorgente di 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'])
Per semplificare la ricerca tra server che eseguono software diversi, Netlas aggiunge automaticamente tag specifici ai risultati di ricerca.
Esempi di tag:
Puoi cercare per tag usando il filtro "tag.name:". Puoi anche cercare per categoria di tag usando il filtro "tag.category:". Un elenco di tutti i tag e le categorie disponibili viene visualizzato quando clicchi sull'icona a destra della casella di inserimento della query di ricerca nella home page di Netlas.
Nota: Non tutti i piani tariffari supportano l'uso dei tag.
Esempio di query di ricerca
```
tag.name:"adobe_coldfusion"
Questa query cerca Adobe ColdFusion (CVE-2023-26359).
[Try in Netlas](https://app.netlas.io/responses/?q=tag.name%3A%22adobe_coldfusion%22&page=1&indices=)
**Esempio di richiesta API**
Netlas CLI Tools:```bash
netlas search 'tag.name:"adobe_coldfusion"' -f json
Nota che quando si usano le virgolette doppie nelle query, la query stessa è scritta tra virgolette singole.
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
**Esempio di codice (Libreria Python Netlas)**
Esegui nella riga di comando:```bash
python scripts/pentest/search_tag_name.py
Codice sorgente di 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'])
### Cerca server e dispositivi vulnerabili vicino a te (o in qualsiasi altra località)
Vuoi sapere quanti siti e dispositivi vulnerabili ci sono intorno a te? Basta cercare tutti gli indirizzi IP che hanno il campo CVE compilato in una geolocalizzazione specifica.```
geo.city:London AND cve:*
Puoi anche usare altri filtri di geolocalizzazione.
geo.continentgeo.countrygeo.locationEsempio di richiesta API
Strumenti CLI 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
Esempio di codice (Netlas Python Library)
Esegui nella riga di comando:```bash python scripts/pentest/cve_location_search.py
Codice sorgente di 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'])
Molti siti e server hanno pagine web di login e password che possono essere utilizzate per ottenere l'accesso al controllo completo del sito o del server (tramite l'uso di password predefinite, brute force o sfruttamento di vulnerabilità).
È possibile trovarli utilizzando il filtro uri: o/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
Ci sono così tante combinazioni. Per trovare solo pannelli di server vulnerabili usa il filtro `cve:*`. Inoltre, non dimenticare che puoi filtrare i server per software installato usando i tag. Ad esempio:```
tag.1c_bitrix:*
tag.Cisco:
tag.amazon_s3:*
tag.drupal:*
tag.wordpress:*
Proviamo a cercare il pannello di amministrazione vulnerabile di phpMyAdmin (uno dei software più popolari per l'amministrazione di database MySQL):``` http.title:phpMyAdmin cve:*
Ed ecco alcuni esempi per altri popolari strumenti di amministrazione di database:
[Adminer](https://www.adminer.org/):```
http.title:adminer http.title:login cve:*
PostgreSQL``` http.title:(phpPgAdmin OR pgadmin) cve:*
Puoi anche cercare server che hanno installato software per diversi database utilizzando i tag o filtri speciali:```
tag.adminer:*
tag.phpMyAdmin:*
tag.elastic:*
mongodb:*
mssql:*
mysql:*
django:*
Cercare pannelli di amministrazione per i server trovati in questo modo potrebbe non essere la cosa più facile da fare, poiché gli amministratori del sito spesso cambiano i link standard con altri più sicuri.
L'SQL injection è un tipo di vulnerabilità che consente di effettuare query al database manipolando i parametri dell'URL (ciò può essere possibile a causa di configurazioni errate e codice di scarsa qualità).
Una delle tecniche più antiche per trovare pagine potenzialmente vulnerabili a SQL Injection è cercare pagine che hanno abilitato la visualizzazione dei messaggi di errore nelle query MySQL utilizzando Google Dorks.
Una ricerca simile può essere effettuata in Netlas:``` http.body:mysql_fetch_array http.body:warning
[Prova in Netlas](https://app.netlas.io/responses/?q=http.body%3Amysql_fetch_array%20http.body%3Awarning&page=1&indices=)
Alcuni altri esempi:```
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
Esempio di richiesta 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
Esempio di codice (Netlas Python Library)
Esegui nella riga di comando:```bash python scripts/pentest/sql_injection_search.py
Codice sorgente di 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'])
Puoi anche utilizzare i seguenti filtri per cercare server MySQL vulnerabili:
mysql.error_codemysql.error_idmysql.error_messageNetlas non cerca solo siti web e server, ma tutti i dispositivi connessi a Internet: elettrodomestici smart, telecamere di sorveglianza, stampanti, router, semafori, apparecchiature mediche e altro ancora.
Ci sono quattro modi principali per trovare questi dispositivi.
Il modo più semplice è cercare il nome del fornitore o il tipo di dispositivo nel titolo http della risposta.
Prova a cercare i dispositivi di domotica Jeedom:``` http.title:Jeedom
[Prova in Netlas](https://app.netlas.io/responses/?q=http.title%3AJeedom&page=1&indices=)
Oppure webcam Avigilon:```
http.title:"Avigilon"
Ci sono due svantaggi in questo metodo. Il primo è l'elevato numero di risultati inappropriati (semplicemente siti web con parole pertinenti nel titolo). Ma quando si usano virgolette e filtri di ricerca aggiuntivi come port:, ce ne sono meno.
Il secondo è che molti dispositivi IoT non hanno informazioni nel titolo http attraverso cui possano essere identificati. Quindi, anche altri filtri di ricerca possono essere utili.
Allo stesso modo, puoi provare a cercare parole chiave nel corpo della risposta http. Per filtrare almeno alcuni dei siti web comuni, usa il filtro NOT domain:. Proviamo a cercare telecamere Reolink:``` http.body:(clip-status) NOT domain:
L'esempio non è del tutto corretto, quindi queste telecamere possono essere trovate usando i tag (maggiori informazioni di seguito).
### Ricerca per Numero di Porta
Dispositivi IoT diversi usano porte diverse per la comunicazione. E dal numero di porta aperta, puoi ipotizzare che l'indirizzo IP appartenga a un certo tipo di dispositivo (**spesso l'ipotesi è corretta, ma possono esserci imprecisioni e coincidenze**).
Prova a cercare una radio Internet (porta 8000):```
port:8000 http.title:radio
Oppure tutti i dispositivi con porta 7547 aperta (è usata per gestire i router da remoto tramite CWMP):``` port:7547
[Try in Netlas](https://app.netlas.io/responses/?q=port%3A7547&page=1&indices=)
### Ricerca per banner
Cerchiamo router che utilizzano il protocollo Telnet (puoi anche filtrarli con port:23):```
telnet.banner:router
Oppure cerca i banner per tutti i protocolli:``` *.banner:router
[Prova su Netlas](https://app.netlas.io/responses/?q=%5C*.banner%3Arouter&page=1&indices=)
### Ricerca per favicon
Uno dei modi più semplici per trovare dispositivi che hanno installato determinati software è cercare tramite favicon. Proviamo a trovare dove vengono utilizzati diversi prodotti Cisco:```
http.favicon.hash_sha256:62a8461e328d5bace3780ff738d0b58f6502592c04afa564e0a8a792583a7bfb
Ci sono tre modi principali per cercare tramite favicon in Netlas:
A volte capita che non ci siano informazioni identificative del dispositivo nel titolo http, ma potrebbero essere presenti in altri header. Ad esempio, in http.server.header:``` http.headers.server:"i-Catcher Console"
[Prova in Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22i-Catcher%20Console%22&page=1&indices=)
Netlas supporta la ricerca attraverso diverse dozzine di tipi di header. Prova diverse varianti.
### Ricerca per Cookie
Cerca parcheggi Eco JS:```
http.headers.set_cookie:(regist_carNo=)
Questo metodo potrebbe richiedere un abbonamento a pagamento. Vedi i prezzi
Puoi anche provare a cercare dispositivi per tag (categorie).``` 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=)
Ricorda che i tag vengono assegnati automaticamente e alcuni dispositivi idonei potrebbero non essere inclusi nella categoria corrispondente.
### Filtri di ricerca aggiuntivi
Può cercare dispositivi IoT situati in geolocalizzazioni specifiche:
- `geo.city`
- `geo.country`
- `geo.continent`
Filtra i dispositivi per intervallo di indirizzi IP:```
ip:[162.245.241.131 TO 162.245.241.133]
O dispositivi con vulnerabilità "fresche":``` cve.name:2023
Altri esempi di query per cercare dispositivi IoT sono disponibili qui:
[Netlas Dorks](https://github.com/netlas-io/netlas-dorks)
## Usare Netlas.io per la Ricerca nel Darknet
Uno dei principali vantaggi di Netlas è che puoi usarlo per cercare cose che non sono indicizzate da Google. Questo è ciò che può essere convenzionalmente chiamato DeepWeb. Ad esempio, server FTP o server Telnet:```
ftp.banner:*
telnet.banner:*
Ma sfortunatamente Netlas non indicizza il Darknet (.onion, .i2p, ecc.) poiché esegue la scansione solo di indirizzi IP globali. Tuttavia può ancora essere utilizzato per esplorare infrastrutture di rete alternative e trovare collegamenti a siti .onion.
Il nodo di uscita Tor è il punto in cui il traffico web lascia la rete Tor e viene inoltrato a destinazione. Un elenco aggiornato degli indirizzi IP dei nodi di ingresso Tor attivi è sempre disponibile sul sito web di TorProject:
Elenco dei nodi di uscita del Tor Project
Vediamo come puoi raccogliere informazioni su tutti i nodi di uscita Tor attivi contemporaneamente usando Netlas. Questo esempio sarà utile per tutte le altre attività per cui devi raccogliere informazioni su un elenco di domini o indirizzi IP.
Run scripts/darknet/tor_nodes.py:```bash python scripts/darknet/tor_nodes.py
Codice sorgente di 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
Utilizzare il pacchetto time e il metodo sleep è adatto solo per esempi semplici. La soluzione migliore è utilizzare il pacchetto rate limit.
Come accennato in precedenza, Netlas esegue la scansione solo dei domini globali, quindi non è possibile cercare domini .onion. Ma è possibile cercare riferimenti a domini .onion nel testo delle pagine web. Ecco un esempio di un semplice script Python (con espressioni regolari) che fa questo:
Run scripts/darknet/onion_links.py:```bash python scripts/darknet/onion_links.py
Codice sorgente di 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
Puoi raccogliere link per altre reti come I2Pin allo stesso modo:``` http.body:*.i2p
## Ricerca di directory di file, backup e log
Esiste un numero enorme di siti e server che lasciano aperti i loro archivi di file a causa di un errore di configurazione (e talvolta deliberatamente). Ecco alcuni esempi di query che ti aiuteranno a trovarli.
Cerca directory di file qualsiasi:```
http.title:Index http.title:of
Cerca directory con file di log:``` http.title:Index http.title:of http.body:logs
Cerca directory con dump di database:```
http.title:Index http.title:of http.body:sql
Cerca directory con backup archiviati:``` http.title:Index http.title:of http.body:backup?zip
Cerca directory con informazioni di accesso SSH:```
http.title:Index http.title:of http.body:("ssh_config" OR "ssh_known_hosts" OR "authorized_keys" OR "id_rsa" OR "id_dsa")
Cerca directory che contengono file con altre informazioni di autorizzazione:``` http.title:Index http.title:of http.body:("pass" OR "logins" OR "config" OR "password")
Cerca directory con file scaricati dagli utenti:```
http.title:index http.title:of http.body:downloads
Cerca directory con file di configurazione Docker:``` http.title:index http.title:of http.body:docker-compose
Si possono pensare a centinaia di altre richieste simili. Sperimenta con diversi nomi di file ed estensioni.
## Utilizzo di Netlas.io per la Digital Forensics e l'Incident Response
Questa sezione è molto difficile da separare dalla sezione Netlas per OSINT, poiché le query elencate in essa saranno utili anche a coloro che si occupano di digital forensics.
In questa sezione descriviamo query più "tecniche" che possono aiutare, ad esempio, a raccogliere informazioni sull'infrastruttura tecnica delle reti o a investigare attacchi di phishing.
### Raccolta di informazioni sui server SMTP
SMTP (Simple Mail Transfer Protocol) è un protocollo di comunicazione che consente di inviare e ricevere email. Nella maggior parte dei client di posta elettronica, quando si visualizzano le email, è disponibile la funzione "Mostra originale", che consente di visualizzare l'indirizzo del server SMTP da cui l'email è stata inviata.
Netlas ti permette di ottenere informazioni su un server SMTP così come su qualsiasi altro IP o dominio, e anche di cercare nel testo dei banner SMPT, il che consente di trovare server associati a un particolare dominio, azienda o provider di hosting.
**Esempio di query di ricerca**
```
smtp.banner:fornex.cloud
Strumenti CLI di 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
Esempio di codice (Netlas Python Library)
Esegui nella riga di comando:```bash python scripts/dfir/smtp_banner_search.py
Codice sorgente di 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 dei metodi popolari dei truffatori è utilizzare domini che sono molto simili nell'ortografia ai domini di aziende note.
Puoi trovare tali domini per una determinata azienda utilizzando Netlas e la ricerca fuzzy.
Apri la ricerca Whois del dominio e inserisci il nome del dominio aziendale + . Per esempio:```
domain:facebook.com
[Try in Netlas](https://app.netlas.io/whois_domains/?q=domain%3Afacebook.com~&page=1&indices=)
Dopo di che, clicca sull'icona a sinistra, seleziona il tipo di file di esportazione, i nomi dei file e i campi che desideri salvare nel file. Clicca su "Download" e attendi qualche istante.
Ad esempio, puoi selezionare il formato CSV e i campi domain, expiration_date, status. Una tabella di questo tipo può essere visualizzata comodamente in Excel, Numbers o Google Docs.
### Ricerca Favicon
La ricerca di favicon.ico ha tre utilizzi principali.
Innanzitutto, consente di trovare siti e sottodomini potenzialmente correlati. Prova a trovare l'IP associato ai negozi Lidl:```
http.favicon.perceptual_hash:003c7e72207e3c00
E anche per trovare siti di phishing che utilizzano il design di social network popolari, negozi online, ecc.
Secondo, è una ricerca di vari dispositivi IoT. Prova a trovare prodotti HP:``` http.favicon.perceptual_hash:0c5ec8c181f37e2c
[Prova su Netlas](https://app.netlas.io/responses/?q=http.favicon.perceptual_hash%3A0c5ec8c181f37e2c&page=1&indices=)
Terzo, cerca server che hanno determinati software in esecuzione. Prova a trovare server con PhpMyAdmin:```
http.favicon.perceptual_hash:00084e5e5fffff8d
Esistono tre modi principali per cercare tramite hash del favicon in Netlas:
Puoi anche utilizzare i seguenti filtri per cercare tramite favicon:
http.favicon.last_modifiedhttp.favicon.last_updatedhttp.favicon.urihttp.favicon.path
La ricerca dei domini in Netlas permette di ottenere un elenco completo dei domini associati a un indirizzo IP specifico o a un intervallo di indirizzi. Ad esempio:``` a:"163.114.132.0/24"
[Provalo su Netlas](https://app.netlas.io/domains/?q=a%3A%22163.114.132.0%2F24%22&page=1&indices=)
Esempio di richiesta API
Netlas CLI Tools:```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
**Esempio di codice (Netlas Python Library)**
Esegui nella riga di comando:```bash
python scripts/dfir/subnet_search.py
Codice sorgente di 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'])
### Ricerca di Server con Software Maligno
Netlas ti permette di trovare server su cui sono installati vari malware. Puoi trovarli tramite la presenza di determinate parole in http.title o http.body, hash del favicon, ssl e altri parametri.
Ecco un esempio di query che troverà server su cui è installato GoFish (Open Source Phishing Framework):```
http.title:Gophish http.title:Login
Nota che la tecnica di usare lo stesso operatore due volte (invece di un asterisco tra due parole) viene utilizzata qui. A volte questo ti aiuta a ottenere più risultati di ricerca.
Ecco alcuni ulteriori esempi di richieste simili:``` http.title:CALDERA http.title:login http.title:Deimos http.title:C2
**Esempio di richiesta 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
**Esempio di codice (Netlas Python Library)**
Esegui nella riga di comando:```bash
python scripts/dfif/malware_search.py
Codice sorgente di 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'])
## Ricerca di tecnologie ed esempi di codice
Netlas, a differenza dei motori di ricerca convenzionali, permette di cercare l'intero codice HTML anziché il testo della pagina. Ciò consente di trovare siti che utilizzano determinate librerie JavaScript. Questo può aiutarti a trovare esempi di codice adatti ai tuoi compiti e risparmiare tempo.
Ad esempio, cercando siti che utilizzano una vecchia libreria oscura per disegnare grafici:```
http.body:kinetic.js
Puoi anche vedere come diversi framework CSS vengono utilizzati su siti di determinati temi e prendere in prestito buone idee di design:``` http.body:bootstrap.css http.title:travel
Puoi anche filtrare i siti che utilizzano framework e tecnologie specifici usando i tag:```
tag.bootstrap:*
tag.angularjs:*
tag.wordpress:*
tag.nextjs:*
Netlas, come molti altri motori di ricerca, può essere utilizzato senza uno scopo specifico, e basta esplorare con il suo aiuto gli angoli inesplorati di Internet, sperando di trovare qualcosa di interessante.
Ecco alcuni esempi di query di ricerca che ti aiuteranno a trovare ciò che Google non può.
Ricerca per testo dei banner dei server Telnet (sì, sono ancora vivi!):``` telnet.banner:library
Cerca per testo dei banner dei server FTP:```
ftp.banner:*library*
Cerca link a libri e documenti:``` http.body:rowlingpdf
Cerca link a musica e video:```
http.body:*cats*mp4
Cerca collegamenti a file torrent:``` http.body:catsmp4
Tieni presente che Netlas non censura in alcun modo i contenuti archiviati nel proprio database. Se trovi qualcosa di illegale o immorale, dovresti sporgere reclamo al provider di hosting i cui contatti sono elencati nelle informazioni sul dominio.
## Problemi comuni
### Errore 429 - Richieste troppo frequenti
Se la tua applicazione include più richieste all'API di Netlas, potresti incontrare questo errore:```json
{'detail': 'Request was throttled. Expected available in 1 second.'}
Un modo per risolvere questo problema è utilizzare librerie Python speciali per configurare limiti di tempo sull'esecuzione delle query, come Limiter Package.
Ecco un esempio del suo utilizzo nel codice (limite di non più di 60 richieste al minuto). Per prima cosa, installa il pacchetto:``` pip install ratelimit
Ed esegui rate_limit.py:```bash
python scripts/common_problems/rate_limit.py
CONTENUTI```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()
Esistono pacchetti simili per altri linguaggi di programmazione popolari, poiché superare il limite di richieste è un problema molto comune quando si lavora con quasi tutte le API.
Se hai davvero bisogno di effettuare più di una richiesta al secondo, puoi scrivere al [team vendite](https://netlas.io/sales/).
### KeyError
Un altro problema comune è l'assenza di una chiave specifica nella risposta per alcuni server. Ad esempio, ['data']['http']['title'] è spesso assente.
Se la chiave manca, lo script smette di eseguire. Una corretta gestione degli errori aiuterà a evitare questo. Per esempio:```python
try:
print (response['data']['http']['title'])
except:
print ("no title")
Il principale vantaggio di lavorare con Netlas Python o l'API Netlas rispetto a digitare semplicemente query nella versione web di Netlas.io è che puoi risparmiare una quantità enorme di tempo digitando query valide per tutti. Ad esempio, puoi raccogliere rapidamente informazioni su un lungo elenco di domini usando un codice Python molto semplice.
Esegui nella riga di comando:```bash python scripts/common_problems/domain_list_search.py
Codice sorgente di 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'])
Allo stesso modo, puoi lavorare con un elenco di certificati, indirizzi IP, email e qualsiasi altra cosa tu voglia.
Un esempio di ricerca di indirizzi IP da un elenco caricato tramite URL può essere trovato in Ricerca nodi di uscita Tor.
Per impostazione predefinita, la libreria Python di Netlas restituisce dati di tipo Dictionary (molto simile a JSON). Se desideri esportare i dati in MS Excel o Google Sheets, un modo semplice per farlo è salvarli in formato CSV.
Ecco un esempio utilizzando il pacchetto CSV. Esegui 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
Puoi aprire netlas_results.csv in Excel o in qualsiasi editor di testo.
Usando Python, puoi generare un'ampia varietà di documenti basati sui dati di Netlas, inserendo immagini, visualizzazioni di dati e personalizzando il layout. Ecco alcuni esempi di pacchetti utili.
XLSXWriter - generare file Microsoft Excel.
PyPDF - generare file PDF.
PythonPPTX - generare presentazioni Microsoft Power Point.
PythonDOCX - generare file Microsoft Word.
Come accennato sopra, Netlas non memorizza i nomi di dominio non latini nella loro codifica originale, ma li codifica in Punycode. Ciò è necessario per ragioni tecniche, ma è completamente scomodo per la percezione umana.
Ma questo problema è facilmente risolvibile con un paio di righe di codice Python.
Installa il pacchetto Python IDNA:```bash pip install idna
Ed esegui punycode.py nella riga di comando:```bash
python scripts/common_problems/punycode.py
INPUT:```python import netlas import idna
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
domain:*.中国 OR host:*.中国 netlas_query = netlas_connection.query(query="domain:.xn--fiqs8s OR host:.xn--fiqs8s")
for response in netlas_query['items']: print (response['data']['ip']) decoded_domain = idna.decode(str(response['data']['domain'][0])) print (decoded_domain)
### Cosa fare se le query di ricerca non restituiscono risultati?
A volte potresti trovarti in una situazione in cui non vengono trovati risultati o ne vengono trovati pochissimi su una query, anche se sei sicuro che ce ne dovrebbero essere molti di più. In questo caso ti consigliamo di sperimentare e provare a modificare un po' le query.
1. Prova ad aggiungere due asterischi alla tua parola chiave. Ad esempio, domain:*github.com* restituisce 1,592,846 risultati. domain:githib.com - solo 7911 risultati.
2. Prova a utilizzare diversi filtri di ricerca per raggiungere lo stesso obiettivo. Ad esempio, confronta i risultati per uri:*github.com*, host:*github.com* e domain:*github.com*.
3. Non utilizzare spazi nelle parole chiave. Se devi trovare la frase "Hello world" in http.body, usa la seguente query: ```
http.body:hello http.body:world
o ``` http.body:(hello AND world)
4. Affina i filtri di ricerca il più possibile. Ad esempio, la query `cve:*2023*` non restituirà risultati. Ma la query `cve.name:*2023*` restituirà più di 28 milioni.
5. Prova diverse schede quando lavori con l'app web o diversi tipi di dati quando lavori con l'API. Ad esempio, quando cerchi domini, a volte Host o Domain Whois (piuttosto che response) funzionano meglio.
### Rimozione dei tag HTML dal corpo HTTP
La chiave ['data']['http']['body'] restituisce per impostazione predefinita il testo completo del corpo della pagina web, inclusi tutti i tag HTML. Questo formato non è molto facile da leggere. Ma puoi rimuoverli facilmente con il pacchetto Python [Html2text](https://pypi.org/project/html2text/).
Esegui nella riga di comando:```bash
python scripts/common_problems/htmltotext.py
Codice sorgente di 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'])))
## Gestione della superficie d'attacco
La piattaforma Netlas include strumenti per la gestione della superficie d'attacco, ma questo argomento esula dallo scopo di questa guida. Se sei interessato alla gestione della superficie d'attacco in generale e all'uso specifico di Netlas, ti consigliamo di iniziare con questi articoli:
- [Guida completa alla scoperta della superficie d'attacco](https://netlas.io/blog/attack_surface_discovery_guide/).
- [Migliori strumenti di visualizzazione della superficie d'attacco](https://netlas.io/blog/best_attack_surface_visualization_tools/).
## Lavorare con grandi quantità di dati
Se hai una sfida davvero grande davanti a te. Ad esempio, se devi raccogliere dati su centinaia di migliaia di domini, forse una soluzione più razionale in termini di tempi e costi finanziari sarà acquistare un dataset (csv/json) e lavorarci sul tuo server.
In [Netlas Datastore](https://app.netlas.io/datastore/) puoi trovare:
* Dataset dei nomi di dominio conosciuti (più di 2 miliardi di elementi)
* Dataset DNS diretto (più di 2 miliardi di elementi)
* Record PTR conosciuti (più di 1 miliardo di elementi) - GRATUITO
* I 1.000.000 di sottodomini più comuni
e altro ancora.
## Riconoscimenti
Molte grazie a [@cyb_detective](https://twitter.com/cyb_detective) per l'aiuto (https://cybdetective.com)