netlas-io/netlas-cookbookLe but de ce guide est très simple : apprendre à toute personne intéressée par la cybersécurité, quel que soit son niveau de connaissances, à tirer le meilleur parti de Netlas.io.
L'objectif de ce guide est d'enseigner à toute personne intéressée par la cybersécurité, quel que soit son niveau de connaissance, comment tirer le meilleur parti des outils de recherche Netlas. C'est une lecture longue. Nous avons rassemblé autant de cas d'utilisation simples que possible et montré comment les automatiser.
⭐️ Donnez-nous une étoile pour montrer votre appréciation
👁️ Abonnez-vous pour les mises à jour
Netlas est un moteur de recherche conçu pour trouver et analyser des informations sur toutes les adresses IP et tous les domaines disponibles sur Internet. Netlas possède certaines fonctionnalités de gestion de la surface d'attaque, mais ce guide se concentre principalement sur les outils de recherche Netlas et leur utilisation dans des automatisations.
Netlas comprend plusieurs outils de recherche :
Nous utiliserons principalement la recherche de réponses (résultats de scan Internet), mais tous les outils fonctionnent de la même manière. Si vous comprenez comment utiliser l'outil de recherche de réponses, vous pouvez utiliser n'importe quel autre.
Avant d'entrer dans les détails techniques, voyons comment fonctionne Netlas.io avec quelques exemples simples.
Ouvrez Netlas.io Infos IP/Domaine et saisissez le nom de domaine ou l'IP. Les informations suivantes seront affichées en résultat :
Si vous avez besoin de trouver des noms de domaine chinois ou autres internationalisés, convertissez-les en Punycode. Par exemple :``` domain:*.xn--fiqs8s
Vous pouvez le faire à l’aide d’outils en ligne spéciaux. Par exemple - [Charset.org](https://www.charset.org/punycode)
### Recherche de sites Web contenant un mot spécifique dans leur titre
Ouvrez [Netlas.io response search](https://app.netlas.io/responses/) et saisissez :```
http.title:g*thub
Cela trouvera tous les serveurs dont les titres HTTP contiennent un mot commençant par "g" et se terminant par "thub". En savoir plus sur l'utilisation des astérisques ci-dessous.
Apprenons maintenant comment fonctionnent les requêtes de recherche dans Netlas.io.
Netlas.io est basé sur Elasticsearch, un moteur de recherche distribué, RESTful, gratuit et open source. Les méthodes de recherche dans Netlas.io sont très similaires à celles des autres bases de données basées sur Elasticsearch.
La recherche dans les onglets Réponses, DNS, IP et Certificats vous permet d'utiliser des filtres (champs) dans les requêtes. Par exemple :``` http.body:netlas
[Essayez dans Netlas](https://app.netlas.io/responses/?q=http.body%3Anetlas&page=1&indices=)
Vous pouvez utiliser cette requête pour trouver des pages qui contiennent le mot « netlas » dans leur balise HTML `<body>`.
Une liste des filtres disponibles pour chaque type de recherche s'affiche sur le côté droit de la page.
Les filtres vous permettent de rechercher des serveurs en fonction de nombreux paramètres différents. Par exemple :
* `domain`
* `ip`
* `protocol`
* `certificate`
* `cve`
* `geolocation` (`city`, `continent`, `country`)
et bien d'autres.
### Opérateurs logiques
Vous pouvez utiliser plusieurs filtres dans une seule requête et les combiner à l'aide des opérateurs logiques `AND`, `OR`, `NOT`. Par exemple :```
http.title:netlas NOT port:443
Si vous souhaitez combiner plusieurs conditions dans votre requête, utilisez des parenthèses :``` http.title:(netlas OR shodan) NOT port:443
[Try in Netlas](https://nt.ls/OrFOY)
### Plages
Si vous utilisez une valeur numérique comme valeur d'un champ, vous pouvez la désigner comme une valeur de et à (limites extrêmes de la plage de valeurs) :```
ip:[173.194.222.0 TO 173.194.222.255]
Ou marquez uniquement la limite supérieure ou uniquement la limite inférieure de la valeur :``` host:"1.1.1.1" port:<=1000
[Essayer dans Netlas](https://app.netlas.io/responses/?q=host%3A%221.1.1.1%22%20port%3A%3C%3D1000&page=1&indices=)
### Jokers
Si vous ne connaissez pas la description exacte d'un certain caractère dans votre requête (par exemple, vous ne connaissez pas la zone exacte d'un domaine ou l'orthographe d'un nom), vous pouvez le remplacer par un astérisque :```
domain:google.*
Vous pouvez également utiliser le point d'interrogation :``` domain:google.?
[Try in Netlas](https://app.netlas.io/responses/?q=domain%3Agoogle.%3F&page=1&indices=)
`*` - many symbols, `?` - one symbol.
Vous pouvez aussi utiliser des astérisques dans les filtres. Par exemple :```
\*.banner:database
Cette requête effectue une recherche sur tous les types de bannières simultanément et remplace plusieurs filtres : amqp.banner:, ftp.banner:, dns.banner:, telnet.banner:, etc.
Si vous devez effectuer une recherche non pas par valeur exacte mais approximative d'un champ (par exemple, des pages dont les titres contiennent tous les noms en accord avec Joseph), ajoutez simplement ~ à la requête :```
http.title:Joseph~
[Try in Netlas](https://app.netlas.io/responses/?q=http.title%3AJoseph~&page=1&indices=)
### Expressions régulières
Une expression régulière est une séquence de caractères qui permet de rechercher, d'extraire et de remplacer des portions de texte dans un document source qui correspondent à certains motifs. Par exemple :
* Toute adresse e-mail : ```text
([a-zA-Z0–9+._-]+@[a-zA-Z0–9._-]+\.[a-zA-Z0–9_-]+)
Pour plus d'informations sur l'utilisation des expressions régulières, consultez les exemples du Netlas Cookbook (ce que vous lisez actuellement) et les liens ci-dessous :
Manuel de syntaxe des expressions régulières dans la documentation Elasticsearch
Vous pouvez enregistrer vos résultats (tous ou certains champs) aux formats JSON et CSV pour les visualiser dans un format qui vous convient ou les analyser automatiquement avec différents outils.
Vous pouvez grouper les résultats par différentes valeurs de champs pour accélérer le temps de recherche. Par exemple, par nom de domaine ou géolocalisation.
Vous pouvez librement partager des liens vers les résultats de recherche (aucune inscription n'est requise pour les ouvrir, sauf si l'utilisateur a dépassé la limite gratuite de 50 requêtes).
N'oubliez pas non plus que toutes les requêtes que vous avez effectuées peuvent être consultées sur votre page de profil (lien dans le coin supérieur droit).
La fonction la plus importante de Netlas.io est d'aider les personnes à mener des recherches en cybersécurité plus rapidement et plus efficacement. Le service dispose d'une API (interface de programmation d'application) qui permet d'automatiser l'exécution de diverses requêtes.
Elle peut être implémentée aussi bien dans de simples scripts Python ou Bash de quelques lignes que dans des applications multifonctionnelles complexes.
Vous pouvez en savoir plus sur l'utilisation de l'API Netlas dans le Netlas Cookbook (ce que vous lisez actuellement) ou dans la documentation officielle :
C'est le tout premier point à aborder avec l'API. Vous n'avez même pas besoin de payer un abonnement (50 requêtes par jour sont gratuites). Rendez-vous simplement sur la page de profil.
Vous n'avez pas besoin d'écrire des scripts ou de créer des applications pour commencer à utiliser l'API Netlas. Vous pouvez simplement la tester en utilisant votre client API préféré. Voir les instructions ici.
Comme pour les autres API, la réponse de l'API Netlas se compose d'en-têtes et d'un corps de réponse au format JSON (JavaScript Object Notation). Les fichiers JSON contiennent des données au format clé-valeur et peuvent être analysés avec presque n'importe quel langage de programmation.
Si vous utilisez Swagger, vous pouvez copier ou télécharger le corps de la réponse et le visualiser dans n'importe quel éditeur de texte ou analyseur JSON.
Un petit conseil qui vous sera utile lorsque vous écrirez du code utilisant l'API Netlas. Pour comprendre plus rapidement la structure d'un fichier JSON et trouver le chemin pour obtenir une certaine valeur, utilisez des outils spécialisés tels que :
Le moyen le plus simple d'automatiser les requêtes vers l'API Netlas est d'utiliser une bibliothèque (package) Python spécialement conçue.
Dépôt Github de la bibliothèque Netlas-Python
Voyons comment cela fonctionne avec un exemple simple. Tous les exemples de code du Netlas Cookbook se trouvent dans le dossier scripts. Vous pouvez cloner ce dépôt et les exécuter sur votre appareil :```shell git clone https://github.com/netlas-io/netlas-cookbook
Si vous n'avez jamais exécuté de script Python avant aujourd'hui et que vous ne savez pas comment faire, vous pouvez commencer par ouvrir le dépôt Netlas CookBook dans Gitpod.
Gitpod est un environnement de développement cloud basé sur Ubuntu (distribution Linux). Ouvrez simplement ce lien dans votre navigateur (connectez-vous avec votre compte Github) :
[Run Netlas Cookbook in Gitpod](https://gitpod.io#https://github.com/netlas-io/netlas-cookbook)
Installez la bibliothèque Python Netlas à l'aide de pip (installateur de paquets pour Python). Entrez dans la ligne de commande :```shell
pip install netlas
Vérifiez l'installation. Saisissez dans la ligne de commande :```shell netlas --help
Exécutez netlas_python_example.py:```shell
python3 scripts/netlas_python_example.py
Et bien sûr, vous pouvez simplement copier le code et l'enregistrer dans des fichiers. Voici le code du premier exemple :```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']}]")
### Exemples de clés de réponse pour obtenir des données utiles
Il est mentionné ci-dessus que pour trouver les correctifs JSON de la réponse API afin d'obtenir les données dont vous avez besoin, vous pouvez utiliser des applications en ligne spéciales (évaluateurs JSON). Pour améliorer encore votre vie, voici une petite liste d'exemples de clés de réponse de la bibliothèque Python qui sont le plus souvent nécessaires.```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']
Lorsque vous travaillez avec la bibliothèque Netlas Python, il est très important de spécifier correctement le type de données que vous souhaitez récupérer. Par défaut, le type response est renvoyé et de nombreux exemples du Netlas CookBook l'utilisent.
Mais pour certaines tâches, comme l'obtention d'informations whoois concernant un domaine ou la recherche de domaines dans un sous-réseau, vous devez utiliser un type de données différent. Par exemple :```python netlas_query = netlas_connection.query(query='a:"163.114.132.0/24"',datatype="domain")
Si vous pensez qu'une requête ne renvoie pas de résultats alors qu'elle le devrait, essayez simplement de modifier la valeur du paramètre **datatype**. Il est très probable que cela vous aide.
Types de données disponibles :
- **datatype="response"** correspond aux résultats que l'on peut obtenir dans [Recherche de réponses Netlas](https://app.netlas.io/responses/).
- **datatype="domain"** correspond aux résultats que l'on peut obtenir dans [Recherche DNS Netlas](https://app.netlas.io/domains/)
- **datatype="domain-whois"** correspond aux résultats que l'on peut obtenir dans [Recherche Whois de domaines Netlas](https://app.netlas.io/whois_domains/).
- **datatype="ip-whois"** correspond aux résultats que l'on peut obtenir dans [Recherche Whois d'IP Netlas](https://app.netlas.io/whois_ip/).
- **datatype="cert"** correspond aux résultats que l'on peut obtenir dans [Recherche de certificats Netlas](https://app.netlas.io/certs/).
### Outils CLI Netlas
Vous pouvez également utiliser la bibliothèque Python Netlas directement depuis la ligne de commande. Par exemple :```bash
netlas search "http.title:johnsmith" -f json >results.json
Cette simple commande recherche tous les serveurs qui contiennent le mot johnsmith dans leur en-tête, renvoie les résultats au format JSON et stocke les résultats dans le fichier resutls.json.
Toutes les autres fonctionnalités de l'API Netlas peuvent être utilisées de la même manière. Vous pouvez en apprendre plus à l'aide de l'aide (commande -h) et des exemples du Netlas Cookbook (ce que vous lisez actuellement).``` 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.
Avant d'exécuter différentes commandes Netlas CLI Tools, enregistrez la clé API dans les paramètres :```bash
netlas savekey YOUR_API_KEY
Nous avons également un dépôt Github avec quelques exemples d'automatisation de diverses tâches à l'aide de scripts bash et des outils CLI Netlas :
L'API Netlas propose de nombreuses méthodes, mais les plus couramment utilisées sont search et download. Elles sont très similaires entre elles, mais présentent tout de même quelques différences.
La méthode search charge une page de résultats (20 éléments) à la fois et permet de charger un maximum de 200 pages (20*200=4000 éléments). La méthode download télécharge tous les résultats (mais nécessite plus de ressources pour s'exécuter).
Il existe également une méthode host qui renvoie simplement les informations les plus basiques sur un domaine ou une adresse IP particulière (le type de données (comme pour les autres méthodes) n'a pas besoin d'être spécifié) :```bash netlas host "51.159.153.170"
### Paramètres supplémentaires des requêtes
L'API Netlas vous permet d'ajuster de manière flexible les données renvoyées par les requêtes avec des paramètres supplémentaires. Par exemple :
* indices - identifiant qui correspond à une date d'indexation spécifique. Pour connaître l'identifiant d'une date spécifique, ouvrez app.netlas.io, cliquez sur le calendrier à droite de la barre de saisie de requête, sélectionnez la date qui vous intéresse et observez comment le paramètre indices dans l'URL de la barre d'adresse du navigateur change.
* start - numéro de page des résultats (par défaut 0)
* fields - noms des champs à inclure dans les résultats (tous les champs par défaut). Cela sera utile pour accélérer et optimiser le code avec un grand nombre de requêtes.
### Effectuer des requêtes avec Python (sans la bibliothèque Netlas Python)
Vous pouvez trouver plus facile dans certains cas de ne pas utiliser la bibliothèque Netlas Python, mais d'utiliser le package standard Python requests, familier à de nombreux développeurs :
Saisissez dans la ligne de commande :```bash
python scripts/python_example.py
Code source 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())
Mais la bibliothèque Python de Netlas reste préférable car elle est conçue pour gérer différents problèmes de traitement des requêtes (erreurs, longues attentes, etc.).
### Exemples pour d'autres langages de programmation
Bien que nous recommandions d'utiliser notre bibliothèque Python pour automatiser la recherche Netlas, il convient de noter que l'API Netlas peut être intégrée dans la plupart des applications avec une grande variété de piles technologiques. L'essentiel est qu'elle soit capable d'effectuer des **requêtes REST** et d'**analyser les données JSON**.
Voici quelques exemples dans différents langages de programmation populaires.
#### NodeJS <!-- omit in toc -->
Saisissez dans la ligne de commande :```bash
node scripts/node_example.js
Si vous n'utilisez pas Gitpod, vous devriez avoir NodeJS installé sur votre appareil.
Code source 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 -->
Entrez dans la ligne de commande :```bash
ruby scripts/ruby_example.rb
Si vous n'utilisez pas Gitpod, vous devriez avoir Ruby installé sur votre appareil.
Code source 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 -->
Entrez dans la ligne de commande:```bash
bash scripts/bash_example.sh
Code source 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
### Utilitaire JQ
Notez que dans l'exemple ci-dessus, l'utilitaire JQ a été utilisé pour extraire des champs de données JSON.
Il est parfois appelé "comme sed pour les données JSON". C'est un outil étonnamment pratique pour travailler avec n'importe quelles données JSON. Voici quelques exemples de syntaxe.
Affiche le firt élément du JSON-array :```
.items[0]
Afficher tous les éléments d'un tableau JSON :``` .items[]
Afficher tous les sous-éléments 'data' du premier élément du JSON-array:```
.['items'][0]['data'][]
Afficher tous les sous-sous-éléments pour chaque élément du tableau JSON :``` .items[].data.technical[]
Vous pouvez en savoir plus sur JQ ici (je recommande de porter une attention particulière au filtrage des données) : [Documentation de l'utilitaire JQ](https://jqlang.github.io/jq/)
### Outils d'IA pour écrire du code
Si vous rencontrez des problèmes lors de la personnalisation des exemples du Netlas Cookbook, nous vous recommandons de solliciter l'aide d'outils d'IA pour améliorer et écrire du code. Par exemple :
[ChatGPT](https://chatgpt.com)
[Code Llama](https://huggingface.co/spaces/codellama/codellama-playground)
[You.com](https://you.com/)
Lorsque vous utilisez de tels services, il vous suffit de décrire en mots la tâche que vous souhaitez résoudre à l'aide du code.
### Vérificateurs de code
Lorsque vous retravaillez les exemples du Netlas Cookbook pour vos besoins, il se peut que le code ne s'exécute pas à cause de certaines erreurs. Des outils en ligne spécialisés peuvent vous aider à les trouver et à les corriger :
[ExtendsClass Python Tester](https://extendsclass.com/python-tester.html)
[Snyk](https://snyk.io/code-checker/python/)
Si vous ne souhaitez pas copier votre code sur des services tiers, vous pouvez le vérifier localement pour détecter les erreurs à l'aide de Pylint (analyseur statique de code) :
[Pylint Python Package](https://pypi.org/project/pylint/)
## Utiliser Netlas.io pour l'OSINT (Renseignement Open Source)
Netlas.io peut vous aider à collecter des données sur un domaine ou une entreprise, ainsi qu'à trouver des mentions d'une personne (ou de quiconque) sur Internet.
Il peut également être utilisé pour trouver d'anciennes versions de pages web (comme un équivalent de la Wayback Machine).
### Rechercher le pseudonyme ou l'email d'une personne dans les contacts WHOIS
La plupart du temps, les données WHOIS ne contiennent que les coordonnées de l'entreprise enregistrant les domaines. Mais il arrive parfois que des contacts personnels de personnes d'intérêt apparaissent. Cette requête vous aidera à les trouver.
*Cette méthode peut nécessiter un abonnement payant.* [Voir les tarifs](https://netlas.io/pricing/)
**Exemple de requête de recherche**
```
whois.related_nets.contacts.emails:sweetwater
Exemple de requête API
Outils 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
Exemple de code (bibliothèque Python Netlas)
Exécutez en ligne de commande :```bash python scripts/osint/whois_email_search.py
Code source 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 vous permet de rechercher des mentions de certains mots dans les titres et dans le code HTML des pages Web. Vous pouvez rechercher des mots par correspondance exacte, par correspondance approximative (voir la section des requêtes floues) et remplacer les caractères douteux par des astérisques.
Exemple de requête de recherche
```
http.title:sweetwater OR http.body:sweetwater
[Essayer dans Netlas](https://app.netlas.io/responses/?q=http.title%3Asweetwater%20OR%20http.body%3Asweetwater&page=1&indices=)
**Exemple de requête 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
**Exemple de code (bibliothèque Python Netlas)**
Exécuter en ligne de commande :```bash
python scripts/osint/title_body_search.py
Code source 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'])
### Rechercher des fichiers "Juicy Info Files" sur les sous-domaines du site de l'entreprise
Metagoofil est un outil populaire parmi les praticiens de l'OSINT depuis de nombreuses années. Il recherche sur Google des fichiers de documents sur le site Web d'une entreprise (pdf, xlsx, docx etc) et analyse leurs métadonnées.
Et ce qui n'est pas indexé par Google peut être trouvé avec Netlas, puis téléchargé sur votre ordinateur et analysé avec l'outil [MetaDetective](https://github.com/franckferman/MetaDetective).```
uri:*lidl.* AND http.body:pdf
Vous pouvez remplacer le filtre uri: par domain: et host: (je recommande de toujours comparer les résultats lors de l'utilisation de ces trois filtres).
Vous pouvez également rechercher une grande variété d'extensions de fichiers, selon ce que vous souhaitez trouver. Par exemple :``` 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
**Exemple de requête 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
**Exemple de code (bibliothèque Python Netlas)**
Exécutez en ligne de commande :```bash
python scripts/osint/juicyinfo_search.py
Code source 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'])
Pour automatiser les liens vers des documents PDF depuis le corps d'une page web, vous pouvez utiliser le package Python [Re](https://docs.python.org/3/library/re.html).
### Recherche de mentions de numéros de téléphone
Comme pour les pseudonymes et les e-mails, vous pouvez également rechercher des mentions d'un numéro de téléphone dans le code des pages web ou dans les informations de contact WHOIS.
Nous traitons cette tâche comme un exemple distinct, car la recherche d'un numéro de téléphone est compliquée par le fait qu'il peut être écrit sous différents formats.
**Exemple de requête de recherche**
```
http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999
Lorsque vous faites une requête, vous devez prendre en compte le format de saisie des numéros de téléphone accepté dans le pays propriétaire du numéro qui vous intéresse.
Exemple de requête API
Outils CLI Netlas :```bash netlas search "http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999" -f json
N'oubliez pas que vous pouvez rechercher des numéros de téléphone non seulement dans le corps de la page, mais aussi dans les informations de contact WHOIS. Cela peut être fait à l'aide du filtre **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
Exemple de code (Bibliothèque Python Netlas)
Exécuter en ligne de commande :```bash python scripts/osint/phonenumber_search.py
Code source 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'])
Imaginons que vous êtes musicien et que vous souhaitez trouver tous les sites où vos morceaux sont publiés. Vous pouvez le faire en recherchant des pages qui mentionnent votre nom et contiennent des liens vers des fichiers avec l'extension .mp3.
Exemple de requête de recherche
```
(http.title:alla OR http.body:alla) AND http.body:*.mp3
[Try in Netlas](https://nt.ls/HEhJj)
**Exemple de requête API**
Outils 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
**Exemple de code (bibliothèque Python Netlas)**
Exécuter en ligne de commande :```bash
python scripts/osint/file_mentions_search.py
Code source 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'])
### Collecte d'informations WHOIS de domaine
WHOIS est une base de données publique mondiale qui stocke des informations sur tous les domaines enregistrés dans le monde.
**Exemple de requête de recherche**
Utilisez [Recherche WHOIS de domaine](https://app.netlas.io/whois_domains/)```
github.com
Exemple de requête 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
Exemple de code (Bibliothèque Python Netlas)
Exécuter en ligne de commande :```bash python scripts/osint/whois_search.py
Code source 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 balise <address> se trouve à l'intérieur de la balise <head> d'une page web et peut contenir des adresses physiques. Grâce à une recherche utilisant cette balise, vous pouvez trouver des sites associés à une rue particulière, et parfois même à un bâtiment spécifique.
Exemple de requête de recherche
```
http.contacts.address:kirby
[Essayer dans Netlas](https://app.netlas.io/responses/?q=http.contacts.address%3Akirby&page=1&indices=)
Vous pouvez également utiliser http.contacts.email: pour la recherche d'email.
**Exemple de requête API**
Outils CLI 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
**Exemple de code (Netlas Python Library)**
Exécution en ligne de commande :```bash
python scripts/osint/contacts_search.py
Code source 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'])
### Rechercher le nom de l'auteur dans les balises Meta
Les balises `<meta>` sont situées à l'intérieur de la balise `<head>` d'une page web et contiennent les mots-clés les plus importants, la description, diverses informations de service et le nom de l'auteur.
La recherche de pseudonyme et de nom/prénom via les balises meta (http.meta) permet de trouver des sites associés à une personne particulière plus rapidement que la recherche dans l'ensemble du code html (http.body).
**Exemple de requête de recherche**
```
http.meta:nazar
Exemple de requête 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
Exemple de code (bibliothèque Netlas Python)
Exécutez en ligne de commande :```bash python scripts/osint/author_meta_search.py
Source code of 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'])
En plus du nom de l'auteur, les balises meta peuvent contenir diverses informations : encodage, langue, autorisation d'indexation de la page par les robots des moteurs de recherche, texte pour les cartes de liens dans les réseaux sociaux, métadonnées OpenGraph, et bien plus encore. Voici quelques exemples supplémentaires de balises meta pouvant contenir des informations utiles pour les investigations :
<meta name="description"> - description du contenu de la page Web.<meta name="keywords"> - mots-clés décrivant le contenu de la page Web.<meta name="generator"> - nom de l'outil utilisé pour générer le contenu de la page (utile pour rechercher des CMS et des plateformes d'hébergement).<meta name="copyright"> - nom de la personne ou de l'entreprise qui détient les droits d'auteur sur le contenu de la page Web.Une autre étape importante pour trouver des informations sur une personne ou une entreprise consiste à rechercher sa mention dans le texte des bannières de serveurs FTP. Il est possible que l'adresse IP des serveurs trouvés soit la clé pour trouver d'autres sites liés à la personne ou à l'entreprise qui vous intéresse. Et en cas de très grande chance, de trouver quelque chose d'intéressant dans les fichiers qui y sont placés (si le serveur FTP est ouvert).
Exemple de requête de recherche
```
ftp.banner:"Collado"
Si vous devez rechercher des serveurs FTP par un autre paramètre (comme la ville ou la plage d'adresses IP), utilisez le filtre prot7:ftp.
[Essayer dans Netlas](https://app.netlas.io/responses/?q=ftp.banner%3A%22Collado%22%20&page=1&indices=)
**Exemple de requête API**
Netlas CLI Tools:```bash
netlas search 'ftp.banner:"Collado"' -f json
Notez que lorsque des guillemets doubles sont utilisés dans les requêtes, la requête elle-même est écrite entre guillemets 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
**Exemple de code (Netlas Python Library)**
Exécuter en ligne de commande :```bash
python scripts/osint/ftp_banner_search.py
Code source 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'])
### Rechercher des informations de contact dans les certificats SSL
Un certificat SSL est un certificat numérique qui authentifie un site Web et permet l'utilisation d'une connexion cryptée. Il peut contenir des informations sur son propriétaire : nom de la personne de contact, nom de l'organisation, pays et parfois même l'adresse et le code postal. Vous pouvez rechercher ces informations en utilisant les filtres suivants (et bien d'autres) :
- `certificate.issuer.email_address`
- `certificate.issuer.given_name`
- `certificate.issuer.organization`
- `certificate.issuer.postal_code`
- `certificate.issuer.street_address`
- `certificate.issuer.surname`
Essayons de trouver des adresses IP qui contiennent un certain mot dans l'adresse de rue de leur certificat :```
certificate.issuer.street_address:*mcgill*
Exemple de requête 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
Exemple de code (bibliothèque Python Netlas)
Exécutez en ligne de commande :```bash python scripts/osint/certificates_search.py
Code source de scripts/osint/certificates_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `certificate.issuer.street_address:*mcgill*`
netlas_query = netlas_connection.query(query="certificate.issuer.street_address:*mcgill*")
print (type(netlas_query))
# iterate over data and print: ip, url, cetificate issuer
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['certificate']['issuer'])
Archive.org a été utilisé par les spécialistes OSINT pour rechercher des versions anciennes de sites web et de pages de profils sur les réseaux sociaux afin de trouver des coordonnées et autres informations désormais supprimées.
Mais malheureusement, archive.org ne sauvegarde pas des copies de tous les sites et ne le fait pas très souvent (pour certains sites seulement quelques fois par an ou moins).
Mais Netlas sauvegarde aussi des versions anciennes de sites depuis 2021 !
Les filtres suivants sont le plus souvent utilisés pour rechercher des sites :``` http.title:"github.com"
domain:github.com
host:github.com
Si vous cliquez sur l'icône la plus à droite à côté du champ de saisie des requêtes de recherche, vous verrez un menu pour sélectionner une date d'analyse. Vous pouvez l'utiliser pour filtrer les codes HTML des sites enregistrés à une date spécifique.
Pour voir à quoi ressemble le site, copiez le contenu du champ "body" (onglet réponse) dans n'importe quel éditeur de texte et supprimez les caractères \t\r\n du code HTML.
Ensuite, copiez le code dans l'un des visualiseurs HTML en ligne, comme [Code beautify](https://codebeautify.org/htmlviewer). Ou enregistrez simplement le fichier au format HTML et ouvrez-le dans un navigateur.
### 9 façons de rechercher des sites Web connexes
Lors de la collecte d'informations sur une personne ou une entreprise, il peut être important de trouver autant de sites que possible qui peuvent leur être liés d'une manière ou d'une autre. Il existe au moins 5 façons de le faire avec Netlas.
1. ID pour divers services (analytique, systèmes publicitaires, applications d'intégration avec les réseaux sociaux et les systèmes de publication). Leur chevauchement peut indiquer qu'une seule personne ou équipe a été impliquée. Quelques exemples :
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
Oui, tout cela se trouve dans le code sur certains sites.
Et une multitude d'autres identifiants que l'on trouve le plus souvent en haut du code HTML (mais parfois partout dans le code).
[Try in Netlas](https://nt.ls/BCrw9)
2. ID des programmes d'affiliation (utilisez aussi http.body pour les rechercher). Vous pouvez les trouver dans les liens d'affiliation qu'une personne publie sur d'autres sites ou sur les réseaux sociaux. Il peut s'agir des paramètres d'URL suivants (et de leurs équivalents) :```
aff_fcid=
user_id=
partner_id=
ref_id=
```
"GitHub, Inc."
[Essayer dans Netlas](https://app.netlas.io/whois_domains/?q=%22GitHub%2C%20Inc.%22&page=1&indices=)
4. Recherche par serveurs de messagerie dans la recherche DNS 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. Recherche de mentions de fichiers (principalement logos et avatars d'utilisateurs) [->](https://github.com/netlas-io/netlas-cookbook#search-file-mentions-looking-for-content-that-may-be-infringing-on-copyrights)
7. Recherche de sous-domaines [->](https://github.com/netlas-io/netlas-cookbook#search-subdomains)
8. Recherche de contacts WhoIs (dans la recherche de réponses Netlas) [->](https://github.com/netlas-io/netlas-cookbook#search-persons-nickname-or-email-in-whois-contacts)
9. Recherche par favicon [->](https://github.com/netlas-io/netlas-cookbook#favicon-search)
## Scraping (Extraire les données du corps de la page web)
L'API Netlas est un excellent outil pour collecter les coordonnées et autres données des sites web. Premièrement, elle vous permet de le faire rapidement. Deuxièmement, elle ne nécessite pas l'utilisation de proxy. Troisièmement, elle vous permet de collecter des données à partir de sites actuellement indisponibles.
Cependant, il existe certains inconvénients : Netlas ne scanne que les pages principales des sites et certains sites rares ne sont pas inclus dans sa base de données en raison de protections. Mais cela peut quand même être très utile.
Il existe trois approches principales pour le scraping : la collecte d'informations à partir de balises HTML et de sélecteurs CSS, l'extraction de données à l'aide d'expressions régulières, et le scraping par IA. Examinons de plus près les deux premières.
### Paquet Beatifulsoup
[Beatifulsoup](https://pypi.org/project/beautifulsoup4/) est l'un des packages Python les plus populaires au monde pour analyser le code HTML et les fichiers XML. Essayons de l'utiliser pour extraire les titres de pages (à partir des balises \<h1>, PAS des balises \<title>).
Tout d'abord, installez le package :```bash
pip install beautifulsoup4
Et exécutez scripts/osint/scraping_beatifulsoup.py:```bash python scripts/osint/scraping_beatifulsoup.py
Code source 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
Vous pouvez extraire des données d'autres éléments de pages web d'une manière similaire :``` 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.
### Package Re
[Re](https://docs.python.org/3/library/re.html) est un package Python préinstallé pour rechercher et extraire des données à l'aide d'expressions régulières. Il est utile pour extraire des informations de contact à partir de pages Web et pour de nombreuses autres tâches. Regardons un exemple de son fonctionnement.
Exécutez scripts/osint/scraping_re.py :```bash
python scripts/osint/scraping_re.py
Code source 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 même, vous pouvez extraire des liens, des numéros de téléphone, des adresses de portefeuille de cryptomonnaies et bien plus encore. Des motifs prêts à l'emploi sont disponibles dans les bibliothèques d'expressions régulières :
[Regex Lib](https://regexlib.com/)
[UI Bakery Regex Library](https://uibakery.io/regex-library)
[Regex 101](https://regex101.com/)
### Autres packages Python pour le scraping
Beaitiful soup et le package Re ne sont que quelques-uns des nombreux outils pour extraire des données de pages web en utilisant Python. Voici d'autres exemples de tels packages :
* [Scrapy](https://pypi.org/project/Scrapy/) : Il s'agit principalement d'un crawler (un outil pour parcourir les pages d'un site web en utilisant les liens trouvés sur d'autres pages) et, en outre, il possède des capacités étendues pour extraire des données de pages web.
* [Selenium](https://pypi.org/project/selenium/) : Un outil pour automatiser votre expérience de navigation. Permet d'extraire des données de contenu généré par JavaScript.
* [Lxml](https://pypi.org/project/lxml/) : Outil pour scraper et valider des fichiers XML.
* [PDFtoText](https://pypi.org/project/pdftotext/) - outil pour extraire le contenu textuel de fichiers PDF.
* [pyChatGPT](https://pypi.org/project/pyChatGPT/) - package non officiel pour l'interaction avec CHATGP (ne nécessite pas de clé API OpenAI), qui permet d'analyser des informations textuelles avec l'IA.
## Utilisation de Netlas.io pour les enquêtes crypto
Netlas offre une excellente opportunité pour les chercheurs spécialisés dans la criminalité liée aux cryptomonnaies. Premièrement, il peut être utilisé pour rechercher des références à des adresses de portefeuille et des numéros de transaction. Deuxièmement, il peut être utilisé pour rechercher des fermes de minage vulnérables, des nœuds et d'autres serveurs associés à l'infrastructure crypto.
### Rechercher des fermes de minage
Les fermes de minage Antminer, initialement publiées par Bitmain en 2013, sont l'une des lignes de modèles de fermes de minage les plus populaires au monde. Vous pouvez les trouver grâce à la présence du mot « antMiner » dans l'en-tête www_authenticate.```
http.headers.www_authenticate:antMiner
Vous pouvez également rechercher d'autres types de fermes de minage. Par exemple :``` http.headers.www_authenticate:XMR-Stak-Miner
Expérimentez en combinant différents filtres, les mots "miner/mining" et les noms de cryptomonnaies.
**Exemple de requête 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
**Exemple de code (bibliothèque Netlas Python)**
Exécuter en ligne de commande :```bash
python scripts/crypto/mining_farms_search.py
Code source 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'])
### Rechercher les sites Web infectés par des cryptomineurs
Coinhive, un service qui permet aux sites Web (pour la plupart piratés) d'utiliser les ordinateurs de leurs visiteurs pour miner des cryptomonnaies, a cessé ses activités en 2019. Cependant, des liens vers celui-ci sont encore intégrés dans de nombreux sites à travers le monde. Essayons de les trouver :```
http.body:coinhive.min.js domain:*
Notez que nous utilisons le filtre domain:* pour trouver spécifiquement des sites, et non tous les appareils.
De même, vous pouvez rechercher des sites infectés par d'autres cryptomineurs (ainsi que d'autres codes malveillants qui s'exécutent côté utilisateur).
Exemple de requête API
Outils Netlas CLI :```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
Exemple de code (bibliothèque Python Netlas)
Exécutez en ligne de commande :```bash python scripts/crypto/search_sites_injected_with_miners.py
Code source :```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'])
Les nœuds Bitcoin utilisent le port 8333 pour la connexion TCP. Par conséquent, il est facile de les trouver en utilisant le filtre de recherche "port:".``` port:8333 cve:*
Notez que nous utilisons le filtre "cve:*" pour rechercher les serveurs présentant des vulnérabilités.
**Exemple de requête 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
**Exemple de code (bibliothèque Python Netlas)**
Exécuter en ligne de commande :```bash
python scripts/crypto/search_bitcoin_nodes.py
Code source 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'])
## Utiliser Neltas pour le Pentest
Netlas.io vous permet de rechercher des sites présentant de nombreux types de vulnérabilités. Cela peut être fait par le numéro de vulnérabilité (CVE-...), le nom du logiciel installé sur le serveur, certains mots dans les en-têtes de page, et d'autres paramètres.
Vous pouvez suivre les CVE (Common Vulnerabilities and Exposures) les plus récemment publiées sur ces sites :
* [CVE Details](https://www.cvedetails.com/)
* [VulDB](https://vuldb.com/)
* [OpenCVE](https://www.opencve.io/)
Nous publions également régulièrement les requêtes les plus pertinentes pour rechercher des appareils et logiciels vulnérables sur nos fils [Twitter](https://twitter.com/Netlas_io), [Telegram](https://t.me/netlas) et [Discord](https://nt.ls/discord), ainsi que dans le dépôt Github [Netlas Dorks](https://github.com/netlas-io/netlas-dorks).
Dans cette section, nous couvrirons simplement les principes généraux de recherche de sites et de serveurs présentant des vulnérabilités.
### Recherche de sous-domaine
En utilisant des astérisques dans les requêtes de recherche, vous pouvez trouver tous les sous-domaines de différents niveaux (dont le nom se termine par le nom d'un domaine de premier niveau particulier (.com) ou d'un domaine de deuxième niveau (google.com)).
**Exemple de requête de recherche**
```
domain:*.github.com OR host:*.github.com
Exemple de requête API
Outils CLI 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
Exemple de code (bibliothèque Python Netlas)
Exécuter en ligne de commande :```bash python scripts/pentest/subdomain_search.py
Code source 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'])
Exemple de requête de recherche
```
cve.name:CVE-2022-22965
[Essayer dans Netlas](https://app.netlas.io/responses/?q=cve.name%3ACVE-2022-22965&page=1&indices=)
**Exemple de requête API**
Netlas CLI Tools:```bash
netlas search "cve.name:CVE-2022-22965" -f json
CVE-2022-22965 - Spring MVC ou une application Spring WebFlux exécutée sur JDK 9+ peut être vulnérable à une exécution de code à distance (RCE) via la liaison de données. Détails
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
**Exemple de code (bibliothèque Python Netlas)**
Exécuter en ligne de commande :```bash
python scripts/pentest/cve_search.py
Code source 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'])
### Rechercher des sites avec des vulnérabilités contenant un mot spécifique dans leur description
Si vous n'avez pas besoin d'étudier des serveurs avec un type spécifique de vulnérabilité, mais que vous souhaitez simplement voir les serveurs vulnérables dans un groupe spécifique (comme Oracle WebLogic Server ou les sites WordPress), vous pouvez les rechercher à l'aide de mots-clés et du filtre cve.description:.
Pour filtrer les sites qui ont des exploits publiés pour des vulnérabilités, utilisez cve.has_exploit:true.
**Exemple de requête de recherche**
```
cve.description:weblogic AND cve.has_exploit:true
Exemple de requête API
Outils CLI Netlas :```bash netlas search "cve.description:weblogic AND cve.has_exploit:true" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=cve.description%3Aweblogic%20AND%20cve.has_exploit%3Atrue&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY | jq .items[].data.uri
Exemple de code (bibliothèque Python Netlas)
Exécuter en ligne de commande :```bash python scripts/pentest/cve_description_search.py
Code source 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'])
Cette méthode vous permet de trouver les appareils fabriqués par une entreprise spécifique.
Exemple de requête de recherche
```
http.headers.server:"yawcam"
Rechercher des webcams YawCam.
[Essayer dans Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22yawcam%22&page=1&indices=)
**Exemple de requête API**
Netlas CLI Tools:```bash
netlas search 'http.headers.server:"yawcam"' -f json
Notez que lorsque des guillemets doubles sont utilisés dans les requêtes, la requête elle-même est écrite entre guillemets 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
**Exemple de code (bibliothèque Python Netlas)**
Exécutez en ligne de commande :```bash
python scripts/pentest/server_name_search.py
Code source 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'])
#### Identifiants et mots de passe par défaut <!-- omit in toc -->
Une application pratique de la recherche par nom de logiciel dans les en-têtes de serveur est de rechercher des appareils d'un fournisseur particulier. Cela peut être nécessaire à la fois pour rechercher des appareils présentant des vulnérabilités spécifiques et pour des appareils avec des identifiants et mots de passe standard.
Les identifiants et mots de passe standard pour différents modèles d'appareils peuvent être trouvés dans des listes spéciales. Par exemple :
* [Default Router Login Password For Top Router Models (2023 List)](https://www.softwaretestinghelp.com/default-router-username-and-password-list/)
* [Default Username – Password – IP Address for Security Cameras](https://www.a1securitycameras.com/blog/default-username-passwords-ip-addresses-for-surveillance-cameras/)
* [The Default Passwords of Nearly Every IP Camera](https://www.hackers-arise.com/post/the-default-passwords-of-nearly-every-ip-camera)
* [List of default passwords from Datarecovery](https://datarecovery.com/rd/default-passwords/)
N'oubliez pas que l'utilisation d'identifiants et mots de passe standard pour se connecter aux systèmes d'autrui enfreint les règles d'éthique et peut être illégale dans votre pays.
### Recherche de serveurs vulnérables par hash de favicon
Une façon de trouver des serveurs web exposés à une vulnérabilité particulière est de rechercher le favicon ico d'un logiciel de serveur web spécifique.
**Exemple de requête de recherche**
```
http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e
Cette requête recherche le favicon de SecurePoint (CVE-2023-22620).
Exemple de requête API
Outils CLI 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
Code example (Netlas Python Library)
Exécuter en ligne de commande :```bash python scripts/pentest/favicon_hash_search.py
Code source 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'])
Pour simplifier la recherche sur des serveurs exécutant différents logiciels, Netlas attribue automatiquement des balises spécifiques aux résultats de recherche.
Exemples de balises :
Vous pouvez effectuer une recherche par balise à l'aide du filtre "tag.name:". Vous pouvez également rechercher par catégorie de balise à l'aide du filtre "tag.category:". Une liste de toutes les balises et catégories disponibles s'affiche lorsque vous cliquez sur l'icône à droite de la zone de saisie de la requête de recherche sur la page d'accueil de Netlas.
Remarque : toutes les formules d'abonnement ne prennent pas en charge l'utilisation des balises.
Exemple de requête de recherche
```
tag.name:"adobe_coldfusion"
Cette requête recherche Adobe ColdFusion (CVE-2023-26359).
[Essayer dans Netlas](https://app.netlas.io/responses/?q=tag.name%3A%22adobe_coldfusion%22&page=1&indices=)
**Exemple de demande API**
Outils CLI Netlas :```bash
netlas search 'tag.name:"adobe_coldfusion"' -f json
Notez que lorsque des guillemets doubles sont utilisés dans les requêtes, la requête elle-même est écrite entre guillemets 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
**Exemple de code (bibliothèque Python Netlas)**
Exécutez en ligne de commande :```bash
python scripts/pentest/search_tag_name.py
Code source 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'])
### Recherche de serveurs et appareils vulnérables près de chez vous (ou dans tout autre lieu)
Voulez-vous savoir combien de sites et d'appareils vulnérables se trouvent autour de vous ? Recherchez simplement toutes les adresses IP dont le champ CVE est renseigné dans une géolocalisation spécifique.```
geo.city:London AND cve:*
Vous pouvez également utiliser d'autres filtres de géolocalisation.
geo.continentgeo.countrygeo.locationExemple de requête 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
Exemple de code (bibliothèque Python Netlas)
Exécutez en ligne de commande:```bash python scripts/pentest/cve_location_search.py
Code source 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'])
De nombreux sites et serveurs disposent de pages web de connexion et de mot de passe qui peuvent être utilisées pour obtenir un contrôle total du site ou du serveur (par l'utilisation de mots de passe par défaut, de brute force ou d'exploitation de vulnérabilités).
Vous pouvez les trouver en utilisant le filtre uri: ou/et http.title :```
uri:login.php
uri:login.aspx
uri:user http.title:login
uri:admin http.title:login
http.title:admin http.title:panel
Il y a tellement de combinaisons. Pour trouver uniquement les panneaux de serveurs vulnérables, utilisez le filtre `cve:*`.
De plus, n'oubliez pas que vous pouvez filtrer les serveurs par logiciel installé à l'aide de tags. Par exemple :```
tag.1c_bitrix:*
tag.Cisco:
tag.amazon_s3:*
tag.drupal:*
tag.wordpress:*
Essayons de rechercher un panneau d'administration phpMyAdmin vulnérable (l'un des logiciels les plus populaires pour administrer les bases de données MySQL) :``` http.title:phpMyAdmin cve:*
Et voici quelques exemples pour d'autres outils populaires d'administration de bases de données :
[Adminer](https://www.adminer.org/):```
http.title:adminer http.title:login cve:*
PostgreSQL``` http.title:(phpPgAdmin OR pgadmin) cve:*
Vous pouvez également rechercher des serveurs qui ont installé un logiciel pour différentes bases de données en utilisant les balises ou les filtres spéciaux :```
tag.adminer:*
tag.phpMyAdmin:*
tag.elastic:*
mongodb:*
mssql:*
mysql:*
django:*
Rechercher les panneaux d'administration pour les serveurs trouvés de cette manière peut ne pas être la chose la plus facile à faire, car les administrateurs de sites modifient souvent les liens standards pour des liens plus sécurisés.
L'injection SQL est un type de vulnérabilité qui permet d'effectuer des requêtes sur la base de données en manipulant les paramètres d'URL (cela peut être possible en raison de mauvaises configurations et d'un code de mauvaise qualité).
L'une des techniques les plus anciennes pour trouver des pages potentiellement vulnérables aux injections SQL consiste à rechercher des pages qui ont activé l'affichage des messages d'erreur dans les requêtes MySQl à l'aide de Google Dorks.
Une recherche similaire peut être effectuée dans Netlas :``` http.body:mysql_fetch_array http.body:warning
[Essayer sur Netlas](https://app.netlas.io/responses/?q=http.body%3Amysql_fetch_array%20http.body%3Awarning&page=1&indices=)
Quelques autres exemples :```
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
Exemple de requête API
Outils CLI Netlas :```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
Exemple de code (Netlas Python Library)
Exécuter en ligne de commande :```bash python scripts/pentest/sql_injection_search.py
Code source 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'])
Vous pouvez également utiliser les filtres suivants pour rechercher des serveurs MySQL vulnérables :
mysql.error_codemysql.error_idmysql.error_messageNetlas ne recherche pas seulement les sites web et les serveurs, mais tous les appareils connectés à Internet : appareils domestiques intelligents, caméras de surveillance, imprimantes, routeurs, feux de circulation, équipements médicaux, etc.
Il existe quatre méthodes principales pour trouver ces appareils.
La façon la plus simple est de simplement rechercher le nom du fabricant ou le type d'appareil dans le titre http de la réponse.
Essayez de rechercher les appareils domotiques Jeedom :``` http.title:Jeedom
[Essayer dans Netlas](https://app.netlas.io/responses/?q=http.title%3AJeedom&page=1&indices=)
Ou les webcams Avigilon :```
http.title:"Avigilon"
Il y a deux inconvénients à cette méthode. Le premier est le grand nombre de résultats inappropriés (simplement des sites web avec des mots pertinents dans le titre). Mais en utilisant des guillemets et des filtres de recherche supplémentaires comme port:, ils sont moins nombreux.
Le second est que de nombreux appareils IoT n'ont aucune information dans le titre http permettant de les identifier. Ainsi, d'autres filtres de recherche peuvent également être utiles.
De la même manière, vous pouvez essayer de rechercher des mots-clés dans le corps de la réponse http. Pour filtrer au moins une partie des sites web courants, utilisez le filtre NOT domain:. Essayons de rechercher des caméras Reolink :``` http.body:(clip-status) NOT domain:
L'exemple n'est pas tout à fait correct, donc ces caméras peuvent être trouvées à l'aide de balises (plus de détails ci-dessous).
### Recherche par numéro de port
Différents appareils IoT utilisent différents ports pour la communication. Et par le numéro de port ouvert, vous pouvez hypothétiquement supposer que l'adresse IP appartient à un certain type d'appareil (**souvent l'hypothèse est correcte, mais il peut y avoir des inexactitudes et des coïncidences**).
Essayez de rechercher une radio Internet (port 8000) :```
port:8000 http.title:radio
Ou tous les appareils avec le port 7547 ouvert (il est utilisé pour gérer à distance les routeurs via CWMP) :``` port:7547
[Try in Netlas](https://app.netlas.io/responses/?q=port%3A7547&page=1&indices=)
### Recherche par bannière
Recherchons les routeurs qui utilisent le protocole Telnet (vous pouvez aussi les filtrer avec port:23) :```
telnet.banner:router
Ou recherchez les bannières pour tous les protocoles :``` *.banner:router
[Essayez dans Netlas](https://app.netlas.io/responses/?q=%5C*.banner%3Arouter&page=1&indices=)
### Recherche par Favicon
L'un des moyens les plus simples de trouver des appareils qui ont un logiciel spécifique installé est de rechercher par favicon. Essayons de trouver où différents produits Cisco sont utilisés :```
http.favicon.hash_sha256:62a8461e328d5bace3780ff738d0b58f6502592c04afa564e0a8a792583a7bfb
Il existe trois façons principales de rechercher par favicon dans Netlas :
Il arrive parfois qu'il n'y ait pas d'information d'identification de développeur dans le titre http, mais qu'elle se trouve dans d'autres en-têtes. Par exemple, dans http.server.header :``` http.headers.server:"i-Catcher Console"
[Essayez dans Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22i-Catcher%20Console%22&page=1&indices=)
Netlas prend en charge la recherche sur plusieurs dizaines de types d'en-têtes. Essayez différentes variantes.
### Recherche par Cookies
Rechercher Eco JS Parking lots :```
http.headers.set_cookie:(regist_carNo=)
Cette méthode peut nécessiter un abonnement payant. Voir les tarifs
Vous pouvez également essayer de rechercher des appareils par tags (catégories).``` tag.category:"IoT" tag.category:"Web cameras"
[Essayez dans Netlas](https://app.netlas.io/responses/?q=tag.category%3A%22Web%20cameras%22&page=1&indices=)
Rappelez-vous simplement que les tags sont attribués automatiquement et que certains appareils appropriés peuvent ne pas être inclus dans la catégorie correspondante.
### Filtres de recherche supplémentaires
Il permet de rechercher des appareils IoT situés dans des géolocalisations spécifiques :
- `geo.city`
- `geo.country`
- `geo.continent`
Filtrer les appareils par plage d’adresses IP :```
ip:[162.245.241.131 TO 162.245.241.133]
Ou des appareils avec des vulnérabilités "fraîches" :``` cve.name:2023
Plus d'exemples de requêtes pour rechercher des appareils IoT peuvent être trouvés ici :
[Netlas Dorks](https://github.com/netlas-io/netlas-dorks)
## Utilisation de Netlas.io pour la recherche sur le Darknet
L'un des principaux avantages de Netlas est que vous pouvez l'utiliser pour rechercher des éléments qui ne sont pas indexés par Google. C'est ce que l'on peut conventionnellement appeler le DeepWeb. Par exemple, les serveurs FTP ou les serveurs Telnet :```
ftp.banner:*
telnet.banner:*
Malheureusement, Netlas n'indexe pas le Darknet (.onion, .i2p, etc.) car il ne scanne que les adresses IP globales. Mais il peut toujours être utilisé pour explorer l'infrastructure réseau alternative et trouver des liens vers des sites .onion.
Le nœud de sortie Tor est le point où le trafic web quitte le réseau Tor et est redirigé vers la destination. Une liste à jour des adresses IP des nœuds d'entrée Tor actifs est toujours disponible sur le site Web de TorProject :
Liste des nœuds de sortie du projet Tor
Voyons comment vous pouvez collecter des informations sur tous les nœuds de sortie Tor actifs en une seule fois en utilisant Netlas. Cet exemple sera utile pour toutes les autres tâches pour lesquelles vous devez collecter des informations sur une liste de domaines ou d'adresses IP.
Exécutez scripts/darknet/tor_nodes.py:```bash python scripts/darknet/tor_nodes.py
Code source 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
Utiliser le package time et la méthode sleep n'est valable que pour des exemples simples. La meilleure solution consiste à utiliser le paquet de limitation de débit.
Comme mentionné ci-dessus, Netlas ne scanne que les domaines globaux, il n'est donc pas possible de rechercher des domaines .onion. Mais vous pouvez rechercher des références à des domaines .onion dans le texte des pages web. Voici un exemple d'un script python simple (avec expression régulière) qui effectue cette tâche :
Exécutez scripts/darknet/onion_links.py :```bash python scripts/darknet/onion_links.py
Code source du fichier `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
Vous pouvez collecter des liens pour d'autres réseaux comme I2Pin de la même manière:``` http.body:*.i2p
## Recherche de répertoires de fichiers, sauvegardes et journaux
Il existe un grand nombre de sites et de serveurs qui laissent leurs répertoires de fichiers ouverts en raison d'une erreur de configuration (et parfois délibérément). Voici quelques exemples de requêtes qui vous aideront à les trouver.
Rechercher des répertoires de fichiers quelconques :```
http.title:Index http.title:of
Rechercher des répertoires contenant des fichiers journaux :``` http.title:Index http.title:of http.body:logs
Rechercher des répertoires contenant des dumps de base de données :```
http.title:Index http.title:of http.body:sql
Rechercher des répertoires contenant des sauvegardes archivées:``` http.title:Index http.title:of http.body:backup?zip
Rechercher des répertoires contenant des informations d'accès SSH :```
http.title:Index http.title:of http.body:("ssh_config" OR "ssh_known_hosts" OR "authorized_keys" OR "id_rsa" OR "id_dsa")
Rechercher des répertoires contenant des fichiers avec d'autres informations d'autorisation :``` http.title:Index http.title:of http.body:("pass" OR "logins" OR "config" OR "password")
Rechercher des répertoires avec des fichiers téléchargés par les utilisateurs :```
http.title:index http.title:of http.body:downloads
Rechercher des répertoires contenant des fichiers de configuration Docker :``` http.title:index http.title:of http.body:docker-compose
Vous pouvez penser à des centaines d'autres demandes similaires. Expérimentez avec différents noms de fichiers et extensions.
## Utiliser Netlas.io pour la Criminalistique Numérique et la Réponse aux Incidents
Cette section est très difficile à séparer de la section Netlas pour l'OSINT, car les requêtes qui y sont listées seront également utiles à ceux qui travaillent en criminalistique numérique.
Dans cette section, nous décrivons des requêtes plus "techniques" qui peuvent aider, par exemple, à recueillir des informations sur l'infrastructure technique des réseaux ou à enquêter sur des attaques de phishing.
### Collecte d'informations sur les serveurs SMTP
SMTP (Simple Mail Transfer Protocol) est un protocole de communication qui permet d'envoyer et de recevoir des emails. Dans la plupart des clients de messagerie, lors de la visualisation des emails, la fonction "Afficher l'original" est disponible, ce qui vous permet de voir l'adresse du serveur SMTP depuis lequel l'email a été envoyé.
Netlas vous permet d'obtenir des informations sur un serveur SMTP ainsi que sur toute autre adresse IP ou domaine, et également de rechercher dans le texte des bannières SMPT, ce qui vous permet de trouver des serveurs associés à un domaine, une entreprise ou un fournisseur d'hébergement particulier.
**Exemple de requête de recherche**
```
smtp.banner:fornex.cloud
Netlas CLI Tools:```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
Exemple de code (bibliothèque Python Netlas)
Exécuter en ligne de commande :```bash python scripts/dfir/smtp_banner_search.py
Code source 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'])
L'une des méthodes courantes des fraudeurs consiste à utiliser des domaines dont l'orthographe est très similaire à celle des domaines d'entreprises bien connues.
Vous pouvez trouver ces domaines pour une entreprise donnée en utilisant Netlas et la recherche floue.
Ouvrez la recherche Whois de domaine et saisissez le nom de domaine de l'entreprise suivi de ~. Par exemple :
`google.com~```` domain:facebook.com~
[Try in Netlas](https://app.netlas.io/whois_domains/?q=domain%3Afacebook.com~&page=1&indices=)
Après cela, cliquez sur l'icône de gauche, sélectionnez le type de fichier d'exportation, les noms de fichiers et les champs que vous souhaitez enregistrer dans le fichier. Cliquez sur « Télécharger » et attendez un moment.
Par exemple, vous pouvez sélectionner le format de fichier CSV et les champs domain, expiration_date, status. Un tel tableau peut être facilement consulté dans Excel, Numbers ou Google Docs.
### Recherche de Favicon
La recherche de favicon.ico a trois utilisations principales.
Premièrement, elle permet de trouver des sites et sous-domaines potentiellement liés. Essayez de trouver l'IP associée aux magasins Lidl :```
http.favicon.perceptual_hash:003c7e72207e3c00
Et aussi pour trouver des sites de phishing qui utilisent le design des réseaux sociaux populaires, des boutiques en ligne, etc.
Deuxièmement, il s'agit d'une recherche de divers appareils IoT. Essayez de trouver des produits HP :``` http.favicon.perceptual_hash:0c5ec8c181f37e2c
[Essayez dans Netlas](https://app.netlas.io/responses/?q=http.favicon.perceptual_hash%3A0c5ec8c181f37e2c&page=1&indices=)
Troisièmement, il recherche des serveurs sur lesquels certains logiciels sont exécutés. Essayez de trouver des serveurs avec PhpMyAdmin :```
http.favicon.perceptual_hash:00084e5e5fffff8d
Il existe trois façons principales de rechercher par hash de favicon dans Netlas :
Vous pouvez également utiliser les filtres suivants pour rechercher par favicon :
http.favicon.last_modifiedhttp.favicon.last_updatedhttp.favicon.urihttp.favicon.path
La recherche de domaine Netlas permet d'obtenir une liste complète des domaines associés à une adresse IP spécifique ou à une plage d'adresses. Par exemple :``` a:"163.114.132.0/24"
[Essayer dans Netlas](https://app.netlas.io/domains/?q=a%3A%22163.114.132.0%2F24%22&page=1&indices=)
Exemple de requête API
Outils CLI 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
**Exemple de code (bibliothèque Python Netlas)**
Exécuter en ligne de commande :```bash
python scripts/dfir/subnet_search.py
Code source 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'])
### Rechercher des serveurs contenant des logiciels malveillants
Netlas vous permet de trouver des serveurs sur lesquels divers malwares sont installés. Vous pouvez les trouver par la présence de certains mots dans http.title ou http.body, le hash du favicon, ssl et autres paramètres.
Voici un exemple de requête qui trouvera des serveurs sur lesquels GoFish (Open Source Phishing Framework) est installé :```
http.title:Gophish http.title:Login
Notez que la technique consistant à utiliser deux fois le même opérateur (au lieu d'un astérisque entre deux mots) est utilisée ici. Parfois, cela vous aide à obtenir plus de résultats de recherche.
Voici quelques autres exemples de demandes similaires :``` http.title:CALDERA http.title:login http.title:Deimos http.title:C2
**Exemple de requête 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
**Code example (Netlas Python Library)**
Exécutez en ligne de commande :```bash
python scripts/dfif/malware_search.py
Code source 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'])
## Recherche de technologies et d'exemples de code
Netlas, contrairement aux moteurs de recherche classiques, vous permet de rechercher l'intégralité du code HTML plutôt que le texte de la page. Cela vous permet de trouver des sites qui utilisent certaines bibliothèques JavaScript. Cela peut vous aider à trouver des exemples de code adaptés à vos tâches et à gagner du temps.
Par exemple, rechercher des sites qui utilisent une ancienne bibliothèque obscure pour dessiner des graphismes :```
http.body:kinetic.js
Vous pouvez également voir comment différents frameworks CSS sont utilisés sur des sites de certains thèmes et emprunter de bonnes idées de design :``` http.body:bootstrap.css http.title:travel
Vous pouvez également filtrer les sites qui utilisent des frameworks et technologies spécifiques en utilisant des tags :```
tag.bootstrap:*
tag.angularjs:*
tag.wordpress:*
tag.nextjs:*
Netlas, comme beaucoup d'autres moteurs de recherche, peut être utilisé sans but particulier, et explorer simplement avec son aide les recoins inexplorés d'Internet, en espérant y trouver quelque chose d'intéressant.
Voici quelques exemples de requêtes de recherche qui vous aideront à trouver ce que Google ne peut pas.
Recherche par texte des bannières de serveurs Telnet (oui, ils sont toujours vivants !) :``` telnet.banner:library
Recherche par texte des bannières des serveurs FTP:```
ftp.banner:*library*
Rechercher des liens vers des livres et documents :``` http.body:rowlingpdf
Rechercher des liens vers la musique et la vidéo :```
http.body:*cats*mp4
Rechercher des liens vers des fichiers torrents :``` http.body:catsmp4
Gardez à l'esprit que Netlas ne censure en aucun cas le contenu qu'il stocke dans sa base de données. Si vous trouvez quelque chose d'illégal ou d'immoral, vous devez vous plaindre auprès du fournisseur d'hébergement dont les contacts figurent dans les informations de domaine.
## Problèmes courants
### Erreur 429 - Demandes trop fréquentes
Si votre application inclut plusieurs requêtes vers l'API Netlas, vous pouvez rencontrer cette erreur :```json
{'detail': 'Request was throttled. Expected available in 1 second.'}
Une façon de résoudre ce problème est d'utiliser des bibliothèques Python spéciales pour configurer des limites de temps sur l'exécution des requêtes, comme Limiter Package.
Voici un exemple de son utilisation dans le code (limite de pas plus de 60 requêtes par minute). Tout d'abord, installez le paquet :``` pip install ratelimit
Et exécutez rate_limit.py:```bash
python scripts/common_problems/rate_limit.py
@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()
Des paquets similaires existent pour d'autres langages de programmation populaires, car dépasser la limite de requêtes est un problème très courant lorsqu'on travaille avec la plupart des API.
Si vous avez vraiment besoin de faire plus d'une demande par seconde, vous pouvez écrire à l'[équipe commerciale](https://netlas.io/sales/).
### KeyError
Un autre problème courant est l'absence d'une clé spécifique dans la réponse pour certains serveurs. Par exemple, ['data']['http']['title'] est souvent absent.
Si la clé est manquante, le script arrête son exécution. Une gestion standard des erreurs permettra d'éviter cela. Par exemple :```python
try:
print (response['data']['http']['title'])
except:
print ("no title")
Le principal avantage de travailler avec Netlas Python ou l'API Netlas par rapport à la simple saisie de requêtes dans la version web de Netlas.io est que vous pouvez gagner un temps considérable en saisissant des requêtes génériques. Par exemple, vous pouvez rapidement collecter des informations sur une longue liste de domaines en utilisant un code Python très simple.
Exécutez en ligne de commande :```bash python scripts/common_problems/domain_list_search.py
Code source 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'])
De même, vous pouvez travailler avec une liste de certificats, d'adresses IP, d'e-mails et tout ce que vous voulez.
Un exemple de recherche d'adresses IP à partir d'une liste chargée par URL se trouve dans Recherche de nœuds de sortie Tor.
Par défaut, la bibliothèque Python Netlas renvoie des données de type Dictionnaire (très similaire à JSON). Si vous souhaitez exporter les données vers MS Excel ou Google Sheets, un moyen simple est de les sauvegarder au format CSV.
Voici un exemple utilisant le paquet CSV. Exécutez 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
Vous pouvez ouvrir netlas_results.csv dans Excel ou n'importe quel éditeur de texte.
En utilisant Python, vous pouvez générer une grande variété de documents basés sur les données de Netlas, en insérant des images, des visualisations de données et en personnalisant la mise en page. Voici quelques exemples de packages utiles.
XLSXWriter - générer des fichiers Microsoft Excel.
PyPDF - générer des fichiers PDF.
PythonPPTX - générer des présentations Microsoft Power Point.
PythonDOCX - générer des fichiers Microsoft Word.
Comme mentionné ci-dessus, Netlas ne stocke pas les noms de domaine non latins dans leur encodage original, mais les encode en Punycode. Cela est nécessaire pour des raisons techniques, mais c'est complètement peu pratique pour la perception humaine.
Mais ce problème est facilement résolu avec quelques lignes de code Python.
Installez le package IDNA Python:```bash pip install idna
Et exécutez punycode.py en ligne de commande :```bash
python scripts/common_problems/punycode.py
--nmap-args vous permet de spécifier des arguments supplémentaires à fournir à Nmap lors des analyses.
--test-dns est un commutateur qui demande au fuzzer d'effectuer des tests DNS.
--timeout est une option pour définir le nombre de secondes à attendre avant d'abandonner
l'exécution d'une tentative de test. (Par défaut : 10)```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)
### Que faire si les requêtes de recherche ne renvoient aucun résultat ?
Parfois, vous pouvez rencontrer une situation où aucune ou très peu de résultats ne sont trouvés pour une requête, alors que vous êtes sûr qu'il devrait y en avoir beaucoup plus. Dans ce cas, nous vous recommandons d'expérimenter et d'essayer de modifier un peu les requêtes.
1. Essayez d'ajouter deux astérisques à votre mot-clé. Par exemple, `domain:*github.com*` renvoie 1 592 846 résultats. `domain:github.com` - seulement 7911 résultats.
2. Essayez d'utiliser différents filtres de recherche pour atteindre le même objectif. Par exemple, comparez les résultats pour `uri:*github.com*`, `host:*github.com*` et `domain:*github.com*`.
3. N'utilisez pas d'espaces dans les mots-clés. Si vous devez trouver l'expression "Bonjour le monde" dans `http.body`, utilisez la requête suivante : ```
http.body:hello http.body:world
ou ``` http.body:(hello AND world)
4. Affinez vos filtres de recherche autant que possible. Par exemple, la requête `cve:*2023*` ne renverra aucun résultat. Mais la requête `cve.name:*2023*` renverra plus de 28 millions de résultats.
5. Essayez différents onglets lorsque vous utilisez l'application web ou différents types de données lorsque vous utilisez l'API. Par exemple, lors de la recherche de domaines, il arrive que l'onglet Host ou Domain Whois (plutôt que response) donne de meilleurs résultats.
### Suppression des balises HTML du corps HTTP
La clé `['data']['http']['body']` renvoie par défaut le texte complet du corps de la page web, y compris toutes les balises HTML. Ce format n'est pas très facile à lire. Mais vous pouvez facilement les supprimer avec le package Python [Html2text](https://pypi.org/project/html2text/).
Exécutez en ligne de commande :```bash
python scripts/common_problems/htmltotext.py
Code source de htmltotext.py :```python import netlas import html2text
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.body:*phpMyAdmin*netlas_query = netlas_connection.query(query="http.body:phpMyAdmin")
---
[Read more](https://github.com/netlas-io/netlas-cookbook)
| Framework | Statut | Catégories | Paquets (NPM/Composer) |
|---|
| Atomik |  | Vérifications statiques, Aucune exécution de test, Analyse syntaxique | security-checker |
| Bramus | | Vérifications statiques, Aucune exécution de test, Analyse syntaxique, Analyse | bramus/security-checker |
| CodeIgniter |  | Vérifications statiques, Aucune exécution de test, Analyse syntaxique, Analyse, Scan | security-checker |
| Composer Dependencies | | Vérifications statiques, Aucune exécution de test, Analyse syntaxique, Analyse, Scan, Télémétrie | enlightn/security-checker |
| import netlas | |||
| from ratelimit import limits |