netlas-io/netlas-cookbookDas Ziel dieses Leitfadens ist sehr einfach - jedem, der sich für Cybersicherheit interessiert, unabhängig von seinem Wissensstand, beizubringen, wie man das Beste aus Netlas.io herausholt.
Das Ziel dieses Leitfadens ist es, jedem, der sich für Cybersicherheit interessiert, unabhängig von seinem Wissensstand, zu zeigen, wie man Netlas Search Tools optimal nutzt. Es ist eine lange Lektüre. Wir haben so viele einfache Anwendungsfälle wie möglich gesammelt und gezeigt, wie man sie automatisiert.
⭐️ Gib uns einen Stern, um deine Wertschätzung zu zeigen
👁️ Abonniere für Updates
Netlas ist eine Suchmaschine, die entwickelt wurde, um Informationen über alle im Internet verfügbaren IP-Adressen und Domains zu finden und zu analysieren. Netlas verfügt über einige Funktionen zur Angriffsflächenverwaltung, aber dieser Leitfaden konzentriert sich hauptsächlich auf die Netlas Search Tools und deren Verwendung in Automatisierungen.
Netlas umfasst mehrere Suchwerkzeuge:
Wir werden hauptsächlich die Antwortsuche (Internetscan-Ergebnisse) verwenden, aber alle Werkzeuge funktionieren auf die gleiche Weise. Wenn Sie verstehen, wie man das Antwort-Suchwerkzeug verwendet, können Sie auch jedes andere bedienen.
Bevor wir uns mit den technischen Details befassen, sehen wir uns anhand einiger einfacher Beispiele an, wie Netlas.io funktioniert.
Öffnen Sie Netlas.io IP/Domain-Info und geben Sie den Domainnamen oder die IP ein. Als Ergebnis werden folgende Informationen angezeigt:
Wenn Sie chinesische oder andere internationalisierte Domainnamen finden müssen, konvertieren Sie diese in Punycode. Zum Beispiel:``` domain:*.xn--fiqs8s
### Suche nach Websites, die ein bestimmtes Wort im Titel enthalten
Öffnen Sie [Netlas.io response search](https://app.netlas.io/responses/) und geben Sie ein:```
http.title:g*thub
Dies findet alle Server, deren HTTP-Titel ein Wort enthalten, das mit "g" beginnt und auf "thub" endet. Lesen Sie weiter unten mehr über die Verwendung von Sternchen.
Jetzt erfahren wir mehr darüber, wie Suchabfragen in Netlas.io funktionieren.
Netlas.io basiert auf Elasticsearch, einer freien und offenen, verteilten, RESTful-Suchmaschine. Und die Suchmethoden in Netlas.io sind denen anderer Elasticsearch-basierter Datenbanken sehr ähnlich.
Die Suche nach Response, DNS, IP und Zertifikaten ermöglicht es Ihnen, Filter (Felder) in Suchabfragen zu verwenden. Zum Beispiel:``` http.body:netlas
[Try in Netlas](https://app.netlas.io/responses/?q=http.body%3Anetlas&page=1&indices=)
Mit dieser Abfrage können Sie Seiten finden, die das Wort "netlas" in ihrem <body>-HTML-Tag enthalten.
Eine Liste der verfügbaren Filter für jeden Suchtyp wird auf der rechten Seite der Seite angezeigt.
Filter ermöglichen es Ihnen, nach Servern anhand vieler verschiedener Parameter zu suchen. Zum Beispiel:
* `domain`
* `ip`
* `protocol`
* `certificate`
* `cve`
* `geolocation` (`city`, `continent`, `country`)
und viele andere.
### Logische Operatoren
Sie können mehrere Filter in einer einzelnen Abfrage verwenden und sie mit logischen Operatoren `AND`, `OR`, `NOT` kombinieren. Zum Beispiel:```
http.title:netlas NOT port:443
Wenn Sie mehrere Bedingungen in Ihrer Abfrage kombinieren möchten, verwenden Sie Klammern:``` http.title:(netlas OR shodan) NOT port:443
[In Netlas testen](https://nt.ls/OrFOY)
### Bereiche
Wenn Sie einen numerischen Wert als Feldwert verwenden, können Sie ihn als einen Wert von und bis (äußerste Grenzen des Wertebereichs) angeben:```
ip:[173.194.222.0 TO 173.194.222.255]
Oder markieren Sie nur die obere oder nur die untere Grenze des Werts:``` host:"1.1.1.1" port:<=1000
[Try in Netlas](https://app.netlas.io/responses/?q=host%3A%221.1.1.1%22%20port%3A%3C%3D1000&page=1&indices=)
### Platzhalter
Falls Sie die genaue Beschreibung eines bestimmten Zeichens in Ihrer Abfrage nicht kennen (z. B. wenn Sie die genaue Zone für eine Domain oder die Schreibweise eines Namens nicht kennen), können Sie es durch ein Sternchen ersetzen:```
domain:google.*
Sie können auch ein Fragezeichen verwenden:``` domain:google.?
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=domain%3Agoogle.%3F&page=1&indices=)
`*` - viele Symbole, `?` - ein Symbol.
Sie können auch Sternchen in Filtern verwenden. Zum Beispiel:
domain:google
\*.banner:database
```
Diese Abfrage führt eine Suche in allen Banner-Typen gleichzeitig durch und ersetzt mehrere Filter: `amqp.banner:`, `ftp.banner:`, `dns.banner:`, `telnet.banner:`, usw.
### Fuzziness (Unscharfe Suche)
Wenn Sie nicht nach einem exakten, sondern nach einem ungefähren Wert eines Feldes suchen müssen (z. B. Seiten, deren Titel alle mit Joseph konsonanten Namen enthalten), fügen Sie einfach `~` zur Abfrage hinzu:```
http.title:Joseph~
```
[Try in Netlas](https://app.netlas.io/responses/?q=http.title%3AJoseph~&page=1&indices=)
### Reguläre Ausdrücke
Ein regulärer Ausdruck ist eine Zeichenfolge, mit der Sie Textteile in einem Quelldokument suchen, abrufen und ersetzen können, die bestimmten Mustern entsprechen. Zum Beispiel:
* Jede E-Mail-Adresse: ```text
([a-zA-Z0–9+._-]+@[a-zA-Z0–9._-]+\.[a-zA-Z0–9_-]+)
```
* Jeder HTML-Tag: ```text
<.*?>
```
* Jede Telefonnummer: ```text
^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$
```
* Jede Bitcoin-Adresse: ```text
^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$
```
Weitere Informationen zur Verwendung regulärer Ausdrücke finden Sie in den Beispielen im Netlas Cookbook (das Sie gerade lesen) und unter den folgenden Links:
[Regex-Syntax-Handbuch in der Elasticsearch-Dokumentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/regexp-syntax.html)
[Wie reguläre Ausdrücke in der OSINT nützlich sein können. Theorie und etwas Praxis mit Google Sheets](https://publication.osintambition.org/this-article-consists-of-three-short-parts-31d31efabd5)
### Andere Suchfunktionen von Netlas.io
#### Ergebnisse herunterladen <!-- omit in toc -->
Sie können Ihre Ergebnisse (alle oder ausgewählte Felder) im JSON- und CSV-Format speichern, um sie in einem für Sie passenden Format anzuzeigen oder automatisch mit verschiedenen Tools zu analysieren.
#### Ergebnisse gruppieren <!-- omit in toc -->
Sie können Ergebnisse nach verschiedenen Feldwerten gruppieren, um die Suchzeit zu verkürzen. Zum Beispiel nach Domainname oder Geodaten.
#### Ergebnisse teilen <!-- omit in toc -->
Sie können Links zu Suchergebnissen frei teilen (eine Registrierung ist nicht erforderlich, um sie zu öffnen, es sei denn, der Benutzer hat das kostenlose Limit von 50 Anfragen überschritten).
#### Suchverlauf <!-- omit in toc -->
Denken Sie auch daran, dass alle von Ihnen gestellten Abfragen auf Ihrer Profilseite (Link oben rechts) eingesehen werden können.
## API-Anfragen
Die wichtigste Funktion von Netlas.io ist es, Menschen bei der Durchführung von Cybersicherheitsforschung schneller und effizienter zu unterstützen. Der Dienst verfügt über eine API (Programmierschnittstelle), mit der Sie die Ausführung verschiedener Anfragen automatisieren können.
Sie kann sowohl in einfachen Python- oder Bash-Skripten von wenigen Zeilen Länge als auch in komplexen multifunktionalen Anwendungen implementiert werden.
Weitere Informationen zur Verwendung der Netlas-API finden Sie im Netlas Cookbook (das Sie gerade lesen) oder in der offiziellen Dokumentation:
[API-Dokumentation →](https://docs.netlas.io/api-reference/)
### Wie finde ich den API-Key?
Dies ist der allererste Ort, um mit der API zu beginnen. Sie müssen nicht einmal für ein Abonnement bezahlen (50 Anfragen pro Tag sind kostenlos). Gehen Sie einfach zur [Profilseite](https://app.netlas.io/profile/).
### Werkzeuge zum Debuggen von API-Anfragen
Sie müssen keine Skripte schreiben oder Anwendungen erstellen, um die Netlas-API zu nutzen. Sie können sie einfach mit Ihrem bevorzugten API-Client testen. Siehe [Anleitung hier](https://docs.netlas.io/api-reference/).
### Struktur der Netlas API JSON-Antwort
Ähnlich wie bei anderen APIs besteht die Netlas-API-Antwort aus Headern und einem Antworttext im JSON-Format (JavaScript Object Notation). JSON-Dateien enthalten Daten im Schlüssel-Wert-Format und können mit nahezu jeder Programmiersprache analysiert werden.
Wenn Sie Swagger verwenden, können Sie den Antworttext kopieren oder herunterladen und in einem beliebigen Texteditor oder JSON-Analyzer anzeigen.
### Werkzeuge zum Arbeiten mit Daten im JSON-Format
Ein kleiner Tipp, der sich beim Schreiben von Code mit der Netlas-API als nützlich erweisen wird. Um die Struktur einer JSON-Datei schneller zu verstehen und den Pfad zu einem bestimmten Wert zu finden, verwenden Sie spezielle Tools wie:
- [JSON Path Online Evaluator](https://jsonpath.com)
- [JSON Path Finder](https://jsonpathfinder.com)
### Netlas Python-Bibliothek
Der einfachste Weg, Anfragen an die Netlas-API zu automatisieren, ist die Verwendung einer speziell entwickelten Python-Bibliothek (Paket).
[Netlas-Python-Bibliothek GitHub-Repo](https://github.com/netlas-io/netlas-python)
Sehen wir uns an, wie es mit einem einfachen Beispiel funktioniert. Alle Codebeispiele aus dem Netlas Cookbook befinden sich im **scripts**-Ordner. Sie können dieses Repository klonen und auf Ihrem Gerät ausführen:```shell
git clone https://github.com/netlas-io/netlas-cookbook
```
Wenn Sie noch nie ein Python-Skript ausgeführt haben und nicht wissen, wie das geht, können Sie zunächst das Netlas CookBook-Repository in Gitpod öffnen.
Gitpod ist eine cloudbasierte Entwicklungsumgebung auf Basis von Ubuntu (Linux-Distribution). Öffnen Sie einfach diesen Link in Ihrem Browser (melden Sie sich mit Ihrem Github-Konto an):
[Run Netlas Cookbook in Gitpod](https://gitpod.io#https://github.com/netlas-io/netlas-cookbook)
Installieren Sie die Netlas Python-Bibliothek mit pip (Paketinstallationsprogramm für Python). Geben Sie in der Befehlszeile ein:```shell
pip install netlas
```
Überprüfen Sie die Installation. Geben Sie in der Befehlszeile ein:```shell
netlas --help
```
netlas_python_example.py ausführen:```shell
python3 scripts/netlas_python_example.py
```
Und natürlich können Sie den Code einfach kopieren und in Dateien speichern. Hier ist der Code des ersten Beispiels:```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 `port:7001`
netlas_query = netlas_connection.query(query="port:7001")
# iterate over data and print: IP address, port, path and protocol
for response in netlas_query['items']:
print(f"{response['data']['ip']}:{response['data']['port']}{response['data']['path']} [{response['data']['protocol']}]")
```
### Beispiele für Antwort-Schlüssel zum Erhalten nützlicher Daten
Wie bereits erwähnt, können Sie spezielle Online-Anwendungen (JSON-Evaluatoren) verwenden, um JSON-Patches der API-Antwort zu finden und die benötigten Daten zu erhalten. Um Ihr Leben noch einfacher zu machen, finden Sie hier eine kleine Liste von Beispielen für Antwort-Schlüssel der Python-Bibliothek, die am häufigsten benötigt werden.```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']
```
### Netlas Python Antwortdatentypen
Bei der Arbeit mit der Netlas Python Bibliothek ist es sehr wichtig, den Typ der abzurufenden Daten korrekt anzugeben. Standardmäßig wird der `response`-Typ zurückgegeben, und viele Beispiele im Netlas CookBook verwenden ihn.
Aber für einige Aufgaben, wie das Abrufen von whoois-Informationen über eine Domain oder die Suche nach Domains in einem Subnetz, müssen Sie einen anderen Datentyp verwenden. Zum Beispiel:```python
netlas_query = netlas_connection.query(query='a:"163.114.132.0/24"',datatype="domain")
```
Wenn Sie glauben, dass eine Abfrage keine Ergebnisse liefert, obwohl sie es sollte - versuchen Sie einfach, den Wert des Parameters **datatype** zu ändern. Sehr wahrscheinlich wird das helfen.
Verfügbare Datentypen:
- **datatype="response"** entspricht den Ergebnissen, die in [Netlas Responses Search](https://app.netlas.io/responses/) abgerufen werden können.
- **datatype="domain"** entspricht den Ergebnissen, die in [Netlas DNS search](https://app.netlas.io/domains/) abgerufen werden können.
- **datatype="domain-whois"** entspricht den Ergebnissen, die in [Netlas Domain Whois Search](https://app.netlas.io/whois_domains/) abgerufen werden können.
- **datatype="ip-whois"** entspricht den Ergebnissen, die in [Netlas IP Whois Search](https://app.netlas.io/whois_ip/) abgerufen werden können.
- **datatype="cert"** entspricht den Ergebnissen, die in [Netlas Certificates Search](https://app.netlas.io/certs/) abgerufen werden können.
### Netlas CLI Tools
Sie können die Netlas Python-Bibliothek auch direkt von der Befehlszeile aus verwenden. Zum Beispiel:```bash
netlas search "http.title:johnsmith" -f json >results.json
```
Dieser einfache Befehl durchsucht alle Server, die das Wort johnsmith in ihrem Header haben, gibt die Ergebnisse im JSON-Format zurück und speichert die Ergebnisse in der Datei resutls.json.
Alle anderen Funktionen der Netlas-API können auf die gleiche Weise verwendet werden. Weitere Informationen hierzu finden Sie in der Hilfe (-h Befehl) und in den Beispielen im Netlas Cookbook (das Sie gerade lesen).```
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.
```
Bevor Sie verschiedene Netlas CLI Tools-Befehle ausführen, speichern Sie den API-Schlüssel in den Einstellungen:```bash
netlas savekey YOUR_API_KEY
```
Wir haben auch ein Github-Repository mit einigen Beispielen für die Automatisierung verschiedener Aufgaben mit Bash-Skripten und Netlas CLI-Tools:
[Netlas Scripts](https://github.com/netlas-io/netlas-scripts)
### Suchen vs. Herunterladen vs. Host-Methoden
Die Netlas-API hat viele Methoden, aber die am häufigsten verwendeten sind Suchen und Herunterladen. Sie sind sich sehr ähnlich, haben aber dennoch einige Unterschiede.
Die Suchmethode lädt jeweils eine Seite mit Ergebnissen (20 Elemente) und erlaubt maximal 200 Seiten zu laden (20*200=4000 Elemente). Die Download-Methode lädt alle Ergebnisse herunter (benötigt jedoch mehr Ressourcen zur Ausführung).
Es gibt auch eine Host-Methode, die einfach die grundlegendsten Informationen zu einer bestimmten Domain oder IP zurückgibt (der Datentyp muss (wie bei anderen Methoden) nicht angegeben werden):```bash
netlas host "51.159.153.170"
```
### Zusätzliche Anfrageparameter
Die Netlas-API ermöglicht es Ihnen, die von Anfragen zurückgegebenen Daten mit zusätzlichen Parametern flexibel anzupassen. Zum Beispiel:
* indices – ID, die einem bestimmten Indexierungsdatum entspricht. Um die ID für ein bestimmtes Datum zu ermitteln, öffnen Sie app.netlas.io, klicken Sie auf den Kalender rechts neben der Suchanfragen-Eingabeleiste, wählen Sie das gewünschte Datum aus und beobachten Sie, wie sich der Parameter `indices` in der URL der Browseradressleiste ändert.
* start – Seitennummer der Ergebnisse (Standard: 0)
* fields – Namen der Felder, die in die Ergebnisse aufgenommen werden sollen (standardmäßig alle Felder). Dies ist nützlich, um den Code bei einer großen Anzahl von Anfragen zu beschleunigen und zu optimieren.
### Anfragen mit Python stellen (ohne Netlas-Python-Bibliothek)
In manchen Fällen kann es einfacher sein, nicht die Netlas-Python-Bibliothek, sondern das standardmäßige Python-Request-Paket zu verwenden, das vielen Entwicklern vertraut ist:
Geben Sie in der Befehlszeile ein:```bash
python scripts/python_example.py
```
Quellcode von 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())
```
Aber die Netlas Python-Bibliothek ist immer noch vorzuziehen, da sie entwickelt wurde, um verschiedene Probleme bei der Abfrageverarbeitung (Fehler, lange Wartezeiten usw.) zu bewältigen.
### Beispiele für andere Programmiersprachen
Während wir die Verwendung unserer Python-Bibliothek zur Automatisierung der Netlas-Suche empfehlen, ist es erwähnenswert, dass die Netlas-API in die meisten Anwendungen mit einer Vielzahl von Technologie-Stacks integriert werden kann. Die Hauptsache ist, dass sie in der Lage sein sollte, **REST-Anfragen** zu stellen und **JSON-Daten** zu parsen.
Hier sind einige Beispiele in verschiedenen populären Programmiersprachen.
#### NodeJS <!-- omit in toc -->
Geben Sie in der Befehlszeile ein:```bash
node scripts/node_example.js
```
Falls du Gitpod nicht verwendest, solltest du [NodeJS](https://nodejs.org/en/download/package-manager) auf deinem Gerät installiert haben.
Quellcode von 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 -->
Geben Sie in der Kommandozeile ein:```bash
ruby scripts/ruby_example.rb
```
Wenn Sie Gitpod nicht verwenden, sollten Sie [Ruby](https://www.ruby-lang.org/en/documentation/installation/) auf Ihrem Gerät installiert haben.
Quellcode von 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 -->
Geben Sie in der Befehlszeile ein:```bash
bash scripts/bash_example.sh
```
Quellcode von 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
```
### JQ-Dienstprogramm
Beachten Sie, dass im obigen Beispiel das JQ-Dienstprogramm verwendet wurde, um Felder aus JSON-Daten zu extrahieren.
Es wird manchmal als „wie sed für JSON-Daten“ bezeichnet. Es ist ein überraschend nützliches Werkzeug für die Arbeit mit beliebigen JSON-Daten. Hier sind einige Syntaxbeispiele.
Erstes Element des JSON-Arrays ausgeben:```
.items[0]
```
Alle Elemente des JSON-Arrays ausgeben:```
.items[]
```
Drucke alle 'data'-Unterelemente des ersten Elements des JSON-Arrays aus:```
.['items'][0]['data'][]
```
Drucke alle Unter-Unterelemente für jedes Element des JSON-array:```
.items[].data.technical[]
```
Hier können Sie mehr über JQ lesen (ich empfehle, besonders auf die Datenfilterung zu achten): [JQ utility documentation](https://jqlang.github.io/jq/)
### KI-Tools zum Schreiben von Code
Wenn Sie beim Anpassen der Netlas Cookbook-Beispiele auf Probleme stoßen, empfehlen wir Ihnen, Hilfe von KI-Tools zum Verbessern und Schreiben von Code zu suchen. Zum Beispiel:
[ChatGPT](https://chatgpt.com)
[Code Llama](https://huggingface.co/spaces/codellama/codellama-playground)
[You.com](https://you.com/)
Bei der Arbeit mit solchen Diensten müssen Sie lediglich die Aufgabe, die Sie mit Hilfe von Code lösen möchten, in Worten beschreiben.
### Code-Prüfer
Wenn Sie die Netlas Cookbook-Beispiele für Ihre Zwecke umarbeiten, stellen Sie möglicherweise fest, dass der Code aufgrund einiger Fehler nicht ausgeführt wird. Spezielle Online-Tools können Ihnen helfen, diese zu finden und zu beheben:
[ExtendsClass Python Tester](https://extendsclass.com/python-tester.html)
[Snyk](https://snyk.io/code-checker/python/)
Wenn Sie Ihren Code nicht auf Dienste von Drittanbietern kopieren möchten, können Sie ihn auf Ihrem Gerät mit Pylint (statischer Code-Analysator) auf Fehler überprüfen:
[Pylint Python Package](https://pypi.org/project/pylint/)
## Verwendung von Netlas.io für OSINT (Open Source Intelligence)
Netlas.io kann Ihnen helfen, Daten über eine Domain oder ein Unternehmen zu sammeln sowie Erwähnungen einer Person (oder von irgendjemandem) im Internet zu finden.
Es kann auch verwendet werden, um alte Versionen von Webseiten zu finden (als Analogie zur Wayback Machine).
### Suche nach dem Nicknamen oder der E-Mail einer Person in WHOIS-Kontakten
Meistens enthalten WHOIS-Daten nur die Kontaktinformationen des Unternehmens, das die Domains registriert. Aber manchmal können persönliche Kontakte von interessierenden Personen vorhanden sein. Diese Abfrage hilft Ihnen, diese zu finden.
*Diese Methode erfordert möglicherweise ein kostenpflichtiges Abonnement.* [Siehe die Preisgestaltung](https://netlas.io/pricing/)
**Suchabfragebeispiel**
```
whois.related_nets.contacts.emails:sweetwater
```
[Ausprobieren in Netlas](https://app.netlas.io/responses/?q=whois.related_nets.contacts.emails%3Asweetwater&page=1&indices=)
**API-Anfragebeispiel**
Netlas CLI-Werkzeuge:```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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/osint/whois_email_search.py
```
Quellcode von 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'])
```
### Suche nach Spitzname oder E-Mail einer Person in Titel und Text einer Webseite
Netlas ermöglicht es Ihnen, nach Erwähnungen bestimmter Wörter in Überschriften und im HTML-Code von Webseiten zu suchen. Sie können nach Wörtern mit exakter Übereinstimmung, mit ungefährer Übereinstimmung (siehe Abschnitt „Fuzzy-Queries“) suchen und Zeichen, bei denen Sie sich nicht sicher sind, durch Sternchen ersetzen.
**Suchabfrage-Beispiel**
```
http.title:sweetwater OR http.body:sweetwater
```
[In Netlas testen](https://app.netlas.io/responses/?q=http.title%3Asweetwater%20OR%20http.body%3Asweetwater&page=1&indices=)
**API-Anfragebeispiel**
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
```
**Codebeispiel (Netlas Python Library)**
In der Befehlszeile ausführen:```bash
python scripts/osint/title_body_search.py
```
Quellcode von scripts/osint/title_body_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.title:sweetwater OR http.body:sweetwater`
netlas_query = netlas_connection.query(query="http.title:sweetwater OR http.body:sweetwater*")
# 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'])
```
### Suche nach "Juicy Info Files" auf Subdomains der Firmenwebsite
Metagoofil ist seit vielen Jahren ein beliebtes Tool unter OSINT-Praktikern. Es sucht Google nach Dokumentdateien auf einer Firmenwebsite (pdf, xlsx, docx usw.) und analysiert deren Metadaten.
Und was nicht von Google indexiert wird, kann mit Netlas gefunden, dann auf Ihren Computer heruntergeladen und mit dem Tool [MetaDetective](https://github.com/franckferman/MetaDetective) analysiert werden.```
uri:*lidl.* AND http.body:pdf
```
[Probieren Sie es in Netlas aus](https://app.netlas.io/responses/?q=uri%3A*lidl.*%20AND%20http.body%3A.pdf&page=1&indices=)
Sie können den Filter uri: durch domain: und host: ersetzen (ich empfehle, die Ergebnisse bei Verwendung dieser drei Filter immer zu vergleichen).
Sie können auch nach einer Vielzahl von Dateierweiterungen suchen, je nachdem, was Sie finden möchten. Zum Beispiel:```
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
```
**API-Anfragebeispiel**
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/osint/juicyinfo_search.py
```
Quellcode von scripts/osint/juicyinfo_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 `uri:*lidl.* AND http.body:pdf`
netlas_query = netlas_connection.query(query='uri:*lidl.* AND http.body:pdf')
# iterate over data and print: uri, body
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['http']['body'])
```
Um Links zu PDF-Dokumenten aus dem Webseitenkörper zu automatisieren, können Sie das Python [Re](https://docs.python.org/3/library/re.html) Paket verwenden.
### Suche nach Telefonnummern-Erwähnungen
Wie bei Benutzernamen und E-Mails können Sie auch nach Erwähnungen einer Telefonnummer im Code von Webseiten oder in WHOIS-Kontaktinformationen suchen.
Wir heben diese Aufgabe als separates Beispiel hervor, da die Suche nach einer Telefonnummer dadurch erschwert wird, dass sie in verschiedenen Formaten geschrieben sein kann.
**Beispiel für Suchanfrage**
```
http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999
```
[Versuch es in Netlas](https://app.netlas.io/responses/?q=http.body%3A1%3F234%3F567%3F89%3F99%20OR%20http.body%3A12345678999%20OR%20http.body%3A1234%3F5678%3F999&page=1&indices=)
Bei einer Anfrage sollten Sie das Format der Telefonnummernaufzeichnung berücksichtigen, das in dem Land akzeptiert wird, dem die Telefonnummer gehört, an der Sie interessiert sind.
**API-Anfragebeispiel**
Netlas CLI Tools:```bash
netlas search "http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999" -f json
```
Vergessen Sie nicht, dass Sie Telefonnummern nicht nur im Seitenkörper, sondern auch in den WHOIS-Kontaktinformationen suchen können. Dies kann mit dem Filter **whois.related_nets.contacts.phones:** erfolgen.
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/osint/phonenumber_search.py
```
Quellcode von 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'])
```
### Suche nach Dateierwähnungen (Suche nach Inhalten, die Urheberrechte verletzen könnten)
Stellen Sie sich vor, Sie sind Musiker und möchten alle Websites finden, auf denen Ihre Tracks veröffentlicht sind. Sie können dies tun, indem Sie nach Seiten suchen, die Ihren Namen erwähnen und Links zu Dateien mit der Erweiterung .mp3 enthalten.
**Beispiel für eine Suchanfrage**
```
(http.title:alla OR http.body:alla) AND http.body:*.mp3
```
[Try in Netlas](https://nt.ls/HEhJj)
**API-Anfragebeispiel**
Netlas CLI Tools:```bash
netlas search "(http.title:alla OR http.body:alla) AND http.body:*.mp3" -f json
```
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=(http.title%3Aalla%20OR%20http.body%3Aalla)%20AND%20http.body%3A*.mp3&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.http.title
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/osint/file_mentions_search.py
```
Quellcode von scripts/osint/file_mentions_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.title:alla OR http.body:alla) AND http.body:*.mp3`
netlas_query = netlas_connection.query(query="(http.title:alla OR http.body:alla) AND http.body:*.mp3")
# 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'])
```
### Domain WHOIS Informationssammlung
WHOIS ist eine weltweite öffentliche Datenbank, die Informationen über alle registrierten Domains der Welt speichert.
**Beispiel für eine Suchanfrage**
Nutzen Sie die [WHOIS Domain-Suche](https://app.netlas.io/whois_domains/)```
github.com
```
**API-Anfragebeispiel**
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/osint/whois_search.py
```
Quellcode von 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'])
```
### Standort in `<address>`-Tag suchen
Das `<address>`-Tag befindet sich innerhalb des `<head>`-Tags einer Webseite und kann physische Adressen enthalten. Mit einer Suche über dieses Tag können Sie Seiten finden, die mit einer bestimmten Straße, manchmal sogar einem bestimmten Gebäude, verknüpft sind.
**Suchabfragebeispiel**
```
http.contacts.address:kirby
```
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=http.contacts.address%3Akirby&page=1&indices=)
Sie können auch http.contacts.email: für die E-Mail-Suche verwenden.
**API-Anfragebeispiel**
Netlas CLI Tools:```bash
netlas search "http.contacts.address:kirby" -f json
```
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.contacts.address%3Akirby&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.http.contacts
```
**Codebeispiel (Netlas Python Library)**
In der Befehlszeile ausführen:```bash
python scripts/osint/contacts_search.py
```
Quellcode von scripts/osint/contacts_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.contacts.address:kirby`
netlas_query = netlas_connection.query(query="http.contacts.address:kirby")
# iterate over data and print: URL, Contacts
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['http']['contacts'])
```
### Autorennamen in Meta-Tags suchen
`<meta>`-Tags befinden sich im `<head>`-Tag einer Webseite und enthalten die wichtigsten Keywords, Beschreibung, verschiedene Service-Informationen und den Namen des Autors.
Das Suchen nach Nickname und Name/Nachname über Meta-Tags (http.meta) ermöglicht es, Seiten, die mit einer bestimmten Person verbunden sind, schneller zu finden als die Suche im gesamten HTML-Code (http.body).
**Beispiel für eine Suchanfrage**
```
http.meta:nazar
```
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=http.meta%3Anazar&page=1&indices=)
**API-Anfragebeispiel**
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
```
**Codebeispiel (Netlas Python Library)**
In der Kommandozeile ausführen:```bash
python scripts/osint/author_meta_search.py
```
Quellcode von 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'])
```
### Welche anderen interessanten Dinge können in den Meta-Tags eines HTML-Dokuments gefunden werden?
Zusätzlich zum Namen des Autors können Meta-Tags eine Vielzahl von Informationen enthalten: Kodierung, Sprache, Erlaubnis zur Indexierung der Seite durch Suchmaschinen-Roboter, Text für Link-Karten in sozialen Netzwerken, OpenGraph-Metadaten und vieles mehr. Hier sind einige weitere Beispiele für Meta-Tags, die nützliche Informationen für Untersuchungen enthalten können:
* `<meta name="description">` - Beschreibung des Webseiteninhalts.
* `<meta name="keywords">` - Schlüsselwörter, die den Inhalt der Webseite beschreiben.
* `<meta name="generator">` - Name des Tools, das zur Generierung des Seiteninhalts verwendet wurde (nützlich für die Suche nach CMS und Hosting-Plattformen).
* `<meta name="copyright">` - Name der Person oder Firma, die das Urheberrecht am Inhalt der Webseite besitzt.
### Suche nach FTP-Server-Banner-Text
Ein weiterer wichtiger Schritt bei der Informationssuche über eine Person oder ein Unternehmen ist die Suche nach deren Erwähnung im Text von FTP-Server-Bannern. Es ist möglich, dass die IP-Adresse der gefundenen Server der Schlüssel zur Suche nach anderen Webseiten ist, die mit der interessierenden Person oder dem Unternehmen zusammenhängen. Und bei sehr viel Glück könnte man etwas Interessantes in den dort abgelegten Dateien finden (falls der FTP-Server offen ist).
**Beispiel für eine Suchanfrage**
```
ftp.banner:"Collado"
```
Wenn Sie nach FTP-Servern mit einem anderen Parameter suchen müssen (z. B. Stadt oder IP-Adressbereich), dann verwenden Sie den Filter prot7:ftp.
[Ausprobieren in Netlas](https://app.netlas.io/responses/?q=ftp.banner%3A%22Collado%22%20&page=1&indices=)
**API-Anfragebeispiel**
Netlas CLI Tools:```bash
netlas search 'ftp.banner:"Collado"' -f json
```
Beachten Sie, dass, wenn in Abfragen doppelte Anführungszeichen verwendet werden, die Abfrage selbst in einfache Anführungszeichen geschrieben wird.
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/osint/ftp_banner_search.py
```
Quellcode von scripts/osint/ftp_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 `ftp.banner:"Collado"`
netlas_query = netlas_connection.query(query='ftp.banner:"Collado"')
# iterate over data and print: IP, URL, ftp banner text
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['uri'])
print (response['data']['ftp']['banner'])
```
### Suche nach Kontaktinformationen in SSL-Zertifikaten
Ein SSL-Zertifikat ist ein digitales Zertifikat, das eine Website authentifiziert und die Nutzung einer verschlüsselten Verbindung ermöglicht. Es kann Informationen über seinen Besitzer enthalten: Name der Kontaktperson, Name der Organisation, Land und manchmal sogar Adresse und Postleitzahl. Sie können diese Informationen mit den folgenden Filtern (und vielen weiteren) durchsuchen:
- `certificate.issuer.email_address`
- `certificate.issuer.given_name`
- `certificate.issuer.organization`
- `certificate.issuer.postal_code`
- `certificate.issuer.street_address`
- `certificate.issuer.surname`
Versuchen wir, IP-Adressen zu finden, die ein bestimmtes Wort in der Straßenadresse ihres Zertifikats enthalten:```
certificate.issuer.street_address:*mcgill*
```
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=certificate.issuer.street_address%3A*mcgill*&page=1&indices=)
**API-Anfragebeispiel**
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/osint/certificates_search.py
```
Quellcode von 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'])
```
### Verwendung von Netlas als Alternative zur WayBack Machine
Archive.org wird von OSINT-Spezialisten genutzt, um alte Versionen von Websites und Social-Media-Profilseiten zu durchsuchen, um inzwischen gelöschte Kontakt- und andere Informationen zu finden.
Aber leider speichert archive.org keine Kopien aller Websites und tut dies auch nicht sehr häufig (bei manchen Websites nur ein- oder zweimal im Jahr oder seltener).
Aber Netlas speichert ebenfalls alte Versionen von Websites aus dem Jahr 2021!
Die folgenden Filter werden am häufigsten verwendet, um nach Websites zu suchen:```
http.title:"github.com"
```
```
domain:github.com
```
```
host:github.com
```
Wenn Sie auf das äußere Symbol ganz rechts neben dem Feld zur Eingabe von Suchanfragen klicken, sehen Sie ein Menü zur Auswahl eines Scandatums. Damit können Sie die HTML-Codes von Websites filtern, die an einem bestimmten Datum gespeichert wurden.
Um zu sehen, wie die Website aussieht, kopieren Sie den Inhalt des Feldes "body" (Registerkarte "response") in einen beliebigen Texteditor und löschen Sie die Zeichen \t\r\n aus dem HTML-Code.
Kopieren Sie den Code anschließend in einen der Online-HTML-Viewer wie [Code beautify](https://codebeautify.org/htmlviewer). Oder speichern Sie die Datei einfach im HTML-Format und öffnen Sie sie im Browser.
### 9 Möglichkeiten zur Suche verwandter Websites
Bei der Informationssammlung über eine Person oder ein Unternehmen kann es wichtig sein, so viele Websites wie möglich zu finden, die in irgendeiner Weise mit ihnen in Verbindung stehen könnten. Mit Netlas gibt es mindestens 5 Möglichkeiten, dies zu tun.
1. IDs für verschiedene Dienste (Analytics, Werbesysteme, Anwendungen zur Integration mit sozialen Netzwerken und Publikationssystemen). Ihre Überschneidung kann darauf hindeuten, dass eine Person oder ein Team beteiligt war. Einige Beispiele:
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
```
Ja, das alles findet man im Code auf einigen Websites.
Und eine Reihe anderer Identifikatoren, die meist am Anfang des HTML-Codes zu finden sind (manchmal aber auch überall im Code).
[Try in Netlas](https://nt.ls/BCrw9)
2. IDs von Affiliate-Programmen (verwende auch http.body für die Suche). Du findest sie in Affiliate-Links, die eine Person auf anderen Websites oder in sozialen Netzwerken veröffentlicht. Dies können die folgenden URL-Parameter (und ähnliche) sein:```
aff_fcid=
user_id=
partner_id=
ref_id=
```
3. Suche nach Organisationnamen in Domain Whois Netlas search
```
"GitHub, Inc."
```
[In Netlas ausprobieren](https://app.netlas.io/whois_domains/?q=%22GitHub%2C%20Inc.%22&page=1&indices=)
4. Suche nach Mail-Servern in der DNS-Netlas-Suche
```
mx:*.parklogic.com
```
[In Netlas testen](https://app.netlas.io/domains/?q=mx%3A*.parklogic.com&page=1&indices=)
5. Suche nach Nameservern in der DNS Netlas-Suche
```
ns:ns?.parklogic.com
```
[Try in Netlas](https://app.netlas.io/domains/?q=mx%3A*.parklogic.com&page=1&indices=)
6. Dateien (hauptsächlich Benutzerlogos und Avatare) Erwähnungen suchen [->](https://github.com/netlas-io/netlas-cookbook#search-file-mentions-looking-for-content-that-may-be-infringing-on-copyrights)
7. Subdomain-Suche [->](https://github.com/netlas-io/netlas-cookbook#search-subdomains)
8. Whois-Kontaktsuche (in der Netlas-Antwortsuche) [->](https://github.com/netlas-io/netlas-cookbook#search-persons-nickname-or-email-in-whois-contacts)
9. Favicon-Suche [->](https://github.com/netlas-io/netlas-cookbook#favicon-search)
## Scraping (Daten aus dem Webseiten-Textkörper extrahieren)
Die Netlas-API ist ein großartiges Werkzeug zum Sammeln von Kontakt- und anderen Websitedaten. Erstens ermöglicht sie es, dies schnell zu erledigen. Zweitens erfordert sie keine Nutzung von Proxys. Drittens ermöglicht sie das Sammeln von Daten von Seiten, die derzeit nicht verfügbar sind.
Es gibt jedoch einige Nachteile: Netlas scannt nur die Hauptseiten von Websites und einige seltene Websites sind aufgrund von Schutzmaßnahmen nicht in seiner Datenbank enthalten. Dennoch kann es sehr nützlich sein.
Es gibt drei Hauptansätze für das Scraping: das Sammeln von Informationen aus HTML-Tags und CSS-Selektoren, das Extrahieren von Daten mithilfe regulärer Ausdrücke und KI-Scraping. Schauen wir uns die ersten beiden genauer an.
### Beautifulsoup-Paket
[Beautifulsoup](https://pypi.org/project/beautifulsoup4/) ist eines der weltweit beliebtesten Python-Pakete zum Parsen von HTML-Code und XML-Dateien. Versuchen wir, es zu verwenden, um Seitentitel (aus \<h1>-Tags, NICHT aus \<title>-Tags) zu extrahieren.
Zuerst Paket installieren:
pip install beautifulsoup4```bash
pip install beautifulsoup4
```
Und führe scripts/osint/scraping_beatifulsoup.py aus:```bash
python scripts/osint/scraping_beatifulsoup.py
```
Quellcode von 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
```
Sie können Daten aus anderen Elementen von Webseiten auf ähnliche Weise extrahieren:```
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()
```
Wenn Sie alle Elemente eines bestimmten Typs finden möchten, verwenden Sie die Methode find_all().
### Re Paket
[Re](https://docs.python.org/3/library/re.html) ist ein vorinstalliertes Python-Paket zum Suchen und Abrufen von Daten mithilfe regulärer Ausdrücke. Es ist nützlich zum Extrahieren von Kontaktinformationen aus Webseiten und vielen anderen Aufgaben. Sehen wir uns ein Beispiel an, wie es funktioniert.
Führen Sie scripts/osint/scraping_re.py aus:```bash
python scripts/osint/scraping_re.py
```
Quellcode von scripts/osint/scraping_re.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:shop`
netlas_query = netlas_connection.query(query="http.body:shop")
# iterate over data and print: URL, emails from body
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
```
Ebenso können Sie Links, Telefonnummern, Kryptowährungs-Wallet-Adressen und mehr extrahieren. Fertige Muster finden Sie in Bibliotheken für reguläre Ausdrücke:
[Regex Lib](https://regexlib.com/)
[UI Bakery Regex Library](https://uibakery.io/regex-library)
[Regex 101](https://regex101.com/)
### Andere Python-Pakete für das Scraping
Beaitiful soup und die Re-Pakete sind nur einige der vielen Werkzeuge zum Scraping von Daten aus Webseiten mit Python. Hier sind einige weitere Beispiele für solche Pakete:
* [Scrapy](https://pypi.org/project/Scrapy/): Es ist in erster Linie ein Crawler (ein Werkzeug zum Durchlaufen von Website-Seiten mithilfe von Links, die auf anderen Seiten gefunden werden) und verfügt darüber hinaus über umfangreiche Funktionen zum Extrahieren von Daten aus Webseiten.
* [Selenium](https://pypi.org/project/selenium/): Ein Werkzeug zur Automatisierung Ihres Browser-Erlebnisses. Ermöglicht das Extrahieren von Daten aus Inhalten, die von JavaScript generiert werden.
* [Lxml](https://pypi.org/project/lxml/): Werkzeug zum Scraping und Validieren von XML-Dateien.
* [PDFtoText](https://pypi.org/project/pdftotext/) - Werkzeug zum Extrahieren von Textinhalten aus PDF-Dateien.
* [pyChatGPT](https://pypi.org/project/pyChatGPT/) - inoffizielles Paket für die Interaktion mit CHATGP (benötigt keinen OpenAI-API-Schlüssel), das die Analyse von Textinformationen mit KI ermöglicht.
## Verwendung von Netlas.io für Krypto-Ermittlungen
Netlas bietet eine großartige Möglichkeit für Forscher, die sich auf Kryptowährungskriminalität spezialisiert haben. Erstens kann es verwendet werden, um nach Verweisen auf Wallet-Adressen und Transaktionsnummern zu suchen. Zweitens kann es verwendet werden, um nach anfälligen Mining-Farmen, Nodes und anderen mit der Krypto-Infrastruktur verbundenen Servern zu suchen.
### Suche nach Mining-Farmen
Antminer-Mining-Farmen, die erstmals 2013 von Bitmain veröffentlicht wurden, sind eine der beliebtesten Reihen von Mining-Farm-Modellen der Welt. Sie finden sie anhand des Vorhandenseins des Wortes "antMiner" im www_authenticate-Header.```
http.headers.www_authenticate:antMiner
```
[Try in Netlas](https://app.netlas.io/responses/?q=http.headers.www_authenticate%3AantMiner&page=1&indices=)
Sie können auch nach anderen Arten von Mining-Farmen suchen. Zum Beispiel:```
http.headers.www_authenticate:XMR-Stak-Miner
```
Experimentieren Sie durch die Kombination verschiedener Filter mit den Wörtern "miner/mining" und Kryptowährungsnamen.
**API-Anfragebeispiel**
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
```
**Codebeispiel (Netlas Python Library)**
In der Befehlszeile ausführen:```bash
python scripts/crypto/mining_farms_search.py
```
Quellcode von scripts/crypto/mining_farms_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.headers.www_authenticate:antMiner`
netlas_query = netlas_connection.query(query='http.headers.www_authenticate:antMiner')
# iterate over data and print: uri, http headers
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['http']['headers'])
```
### Suche nach Websites, die mit Kryptominern infiziert sind
Coinhive, ein Dienst, der es Websites (meist gehackten) ermöglicht, die Rechner ihrer Besucher zum Schürfen von Kryptowährungen zu nutzen, wird im Jahr 2019 eingestellt. Dennoch sind Links dazu weiterhin auf vielen Websites weltweit eingebettet. Versuchen wir, sie zu finden:```
http.body:coinhive.min.js domain:*
```
Beachten Sie, dass wir den domain:* Filter verwenden, um spezifisch nach Sites zu suchen, nicht nach allen Geräten.
Ebenso können Sie nach Sites suchen, die mit anderen Cryptominern (sowie anderen Schadcodes, die auf der Benutzerseite ausgeführt werden) infiziert sind.
**API-Anfragebeispiel**
Netlas CLI Tools:```bash
netlas search "http.body:coinhive.min.js domain:*"
```
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.body%3Acoinhive.min.js%20domain%3A*&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.uri
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/crypto/search_sites_injected_with_miners.py
```
Quellcode:```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'])
```
### Nach angreifbaren Bitcoin-Knoten suchen
Bitcoin-Knoten verwenden Port 8333 für TCP-Verbindungen. Daher ist es einfach, sie mit dem Suchfilter "port:" zu finden.```
port:8333 cve:*
```
Beachten Sie, dass wir den Filter "cve:*" verwenden, um nach Servern mit Schwachstellen zu suchen.
**API-Anfragebeispiel**
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
```
**Codebeispiel (Netlas Python Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/crypto/search_bitcoin_nodes.py
```
Quellcode von scripts/crypto/search_bitcoin_nodes.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 `port:8333 cve:*`
netlas_query = netlas_connection.query(query='port:8333 cve:*')
# iterate over data and print: uri, CVE name and description
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['cve'][0]['name'])
print (response['data']['cve'][0]['description'])
```
## Verwendung von Neltas für Pentests
Netlas.io ermöglicht es Ihnen, nach Websites mit vielen verschiedenen Arten von Schwachstellen zu suchen. Dies kann über die Schwachstellennummer (CVE-...), den Namen der auf dem Server installierten Software, bestimmte Wörter in Seitenkopfzeilen und andere Parameter erfolgen.
Sie können die aktuellsten veröffentlichten CVEs (Common Vulnerabilities and Exposures) auf diesen Websites verfolgen:
* [CVE Details](https://www.cvedetails.com/)
* [VulDB](https://vuldb.com/)
* [OpenCVE](https://www.opencve.io/)
Wir posten auch regelmäßig die relevantesten Abfragen zur Suche nach anfälligen Geräten und Software auf unseren [Twitter](https://twitter.com/Netlas_io)-, [Telegram](https://t.me/netlas)- und [Discord](https://nt.ls/discord)-Feeds sowie im [Netlas Dorks](https://github.com/netlas-io/netlas-dorks) Github-Repository.
In diesem Abschnitt werden wir lediglich die allgemeinen Prinzipien der Suche nach Websites und Servern mit Schwachstellen behandeln.
### Subdomain-Suche
Durch die Verwendung von Sternchen in Suchabfragen können Sie alle Subdomains verschiedener Ebenen finden (deren Name mit dem Namen einer bestimmten First-Level-Domain (.com) oder Second-Level-Domain (google.com) endet).
**Beispiel für eine Suchabfrage**
```
domain:*.github.com OR host:*.github.com
```
[Testen in Netlas](https://app.netlas.io/responses/?q=domain%3A*.github.com%20OR%20host%3A*.github.com&page=1&indices=)
**API-Anforderungsbeispiel**
Netlas CLI-Tools:```bash
netlas search "domain:*.github.com OR host:*.github.com" -f json
```
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=domain%3A*.github.com%20OR%20host%3A*.github.com&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/pentest/subdomain_search.py
```
Quellcode von 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'])
```
### Suche nach Websites mit spezifischen Schwachstellen
**Suchabfrage-Beispiel**
```
cve.name:CVE-2022-22965
```
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=cve.name%3ACVE-2022-22965&page=1&indices=)
**API-Anfragebeispiel**
Netlas CLI Tools:```bash
netlas search "cve.name:CVE-2022-22965" -f json
```
CVE-2022-22965 - Spring MVC- oder Spring WebFlux-Anwendung, die auf JDK 9+ läuft, kann über Datenbindung anfällig für Remote-Codeausführung (RCE) sein. [Details](https://nvd.nist.gov/vuln/detail/cve-2022-22965)
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/pentest/cve_search.py
```
Quellcode von scripts/pentest/cve_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.name:CVE-2022-22965`
netlas_query = netlas_connection.query(query="cve.name:CVE-2022-22965")
# iterate over data and print: ip, url
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['uri'])
```
### Suche nach Websites mit Schwachstellen, die ein bestimmtes Wort in ihrer Beschreibung enthalten
Wenn Sie keine Server mit einem bestimmten Schwachstellentyp untersuchen müssen, sondern lediglich verwundbare Server in einer bestimmten Gruppe sehen möchten (z. B. Oracle WebLogic Server oder WordPress-Seiten), können Sie mithilfe von Schlüsselwörtern und dem Filter cve.description: danach suchen.
Um Websites herauszufiltern, für die Exploits für Schwachstellen veröffentlicht wurden, verwenden Sie cve.has_exploit:true.
**Beispiel für eine Suchanfrage**
```
cve.description:weblogic AND cve.has_exploit:true
```
[Testen in Netlas](https://app.netlas.io/responses/?q=cve.description%3Aweblogic%20AND%20cve.has_exploit%3Atrue&page=1&indices=)
**API-Anfragebeispiel**
Netlas CLI-Tools:```bash
netlas search "cve.description:weblogic AND cve.has_exploit:true" -f json
```
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=cve.description%3Aweblogic%20AND%20cve.has_exploit%3Atrue&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY | jq .items[].data.uri
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/pentest/cve_description_search.py
```
Quellcode von 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'])
```
### Suche nach Server-HTTP-Header
Diese Methode ermöglicht es Ihnen, Geräte zu finden, die von einem bestimmten Unternehmen hergestellt wurden.
**Beispiel für eine Suchanfrage**
```
http.headers.server:"yawcam"
```
YawCam-Webcams durchsuchen.
[Try in Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22yawcam%22&page=1&indices=)
**API-Anfragebeispiel**
Netlas CLI Tools:```bash
netlas search 'http.headers.server:"yawcam"' -f json
```
Beachten Sie, dass wenn doppelte Anführungszeichen in Abfragen verwendet werden, die Abfrage selbst in einfache Anführungszeichen geschrieben wird.
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/pentest/server_name_search.py
```
Quellcode von scripts/pentest/server_name_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.headers.server:"yawcam"`
netlas_query = netlas_connection.query(query='http.headers.server:"yawcam"')
# iterate over data and print: IP, URL, server name
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['http']['headers']['server'])
```
#### Standard-Logins und Passwörter <!-- omit in toc -->
Eine praktische Anwendung der Suche nach Softwarenamen in Server-Headern besteht darin, nach Geräten eines bestimmten Herstellers zu suchen. Dies kann sowohl bei der Suche nach Geräten mit bestimmten Schwachstellen als auch bei Geräten mit Standard-Logins und Passwörtern erforderlich sein.
Standard-Logins und Passwörter für verschiedene Gerätemodelle finden sich in speziellen Listen. Zum Beispiel:
* [Standard-Router-Login-Passwort für die wichtigsten Router-Modelle (Liste 2023)](https://www.softwaretestinghelp.com/default-router-username-and-password-list/)
* [Standard-Benutzername – Passwort – IP-Adresse für Sicherheitskameras](https://www.a1securitycameras.com/blog/default-username-passwords-ip-addresses-for-surveillance-cameras/)
* [Die Standard-Passwörter fast jeder IP-Kamera](https://www.hackers-arise.com/post/the-default-passwords-of-nearly-every-ip-camera)
* [Liste der Standard-Passwörter von Datarecovery](https://datarecovery.com/rd/default-passwords/)
Denken Sie daran, dass die Verwendung von Standard-Logins und Passwörtern zum Einloggen in fremde Systeme gegen die Ethikregeln verstößt und in Ihrem Land illegal sein kann.
### Suche nach anfälligen Servern anhand des Favicon-Hash
Eine Möglichkeit, Webserver zu finden, die für eine bestimmte Schwachstelle anfällig sind, ist die Suche nach dem Favicon-Icon einer bestimmten Webserver-Software.
**Suchbeispiel**
```
http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e
```
Diese Abfrage durchsucht das SecurePoint-Favicon (CVE-2023-22620).
[Try in Netlas](https://app.netlas.io/responses/?q=http.favicon.hash_sha256%3Aebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e&page=1&indices=)
**API-Anfragebeispiel**
Netlas CLI Tools:```bash
netlas search "http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e" -f json
```
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.favicon.hash_sha256%3Aebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
```
**Codebeispiel (Netlas Python Library)**
In der Befehlszeile ausführen:```bash
python scripts/pentest/favicon_hash_search.py
```
Quellcode von 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'])
```
### Suche nach verwundbaren Servern nach Tag-Name
Um die Suche über Server, die unterschiedliche Software ausführen, zu vereinfachen, markiert Netlas Suchergebnisse automatisch mit bestimmten Tags.
Beispiele für Tags:
* Blogs - medium, wordpress, tumblr
* CDN - google_cloud, cloudflare, keycdn
* CMS - ucoz, joomla, pyrocms
* E-Commerce - opencart, magento, wix
Sie können mithilfe des Filters „tag.name:“ nach Tags suchen. Sie können auch mithilfe des Filters „tag.category:“ nach Tag-Kategorien suchen. Eine Liste aller verfügbaren Tags und Kategorien wird angezeigt, wenn Sie auf der Netlas-Startseite auf das Symbol rechts neben dem Eingabefeld für die Suchanfrage klicken.
*Hinweis*: Nicht alle Tarife unterstützen die Verwendung von Tags.
**Beispiel für eine Suchanfrage**
```
tag.name:"adobe_coldfusion"
```
Diese Abfrage sucht nach Adobe ColdFusion (CVE-2023-26359).
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=tag.name%3A%22adobe_coldfusion%22&page=1&indices=)
**API-Anfragebeispiel**
Netlas CLI-Tools:```bash
netlas search 'tag.name:"adobe_coldfusion"' -f json
```
Beachten Sie, dass bei der Verwendung von doppelten Anführungszeichen in Abfragen die Abfrage selbst in einfache Anführungszeichen geschrieben wird.
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/pentest/search_tag_name.py
```
Quellcode von scripts/pentest/search_tag_name.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 `tag.name:"adobe_coldfusion"`
netlas_query = netlas_connection.query(query='tag.name:"adobe_coldfusion"')
# iterate over data and print: IP,URL
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['uri'])
```
### Suche nach verwundbaren Servern und Geräten in Ihrer Nähe (oder an einem anderen Ort)
Möchten Sie wissen, wie viele verwundbare Websites und Geräte sich in Ihrer Umgebung befinden? Suchen Sie einfach nach allen IP-Adressen, die in einer bestimmten Geolokalisierung das CVE-Feld ausgefüllt haben.```
geo.city:London AND cve:*
```
[Try in Netlas](https://app.netlas.io/responses/?q=geo.city%3ALondon%20AND%20cve%3A*&page=1&indices=)
Sie können auch andere Geolokalisierungsfilter verwenden.
- `geo.continent`
- `geo.country`
- `geo.location`
**API-Anfragebeispiel**
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/pentest/cve_location_search.py
```
Quellcode von 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'])
```
### Suche nach Login-/Admin-Panels
Viele Websites und Server verfügen über Anmelde- und Passwort-Webseiten, die genutzt werden können, um vollen Zugriff auf die Website oder den Server zu erhalten (durch die Verwendung von Standardpasswörtern, Brute-Force-Angriffen oder Ausnutzung von Schwachstellen).
Sie können sie mithilfe des Filters `uri:` und/oder `http.title` finden:```
uri:*login.php*
uri:*login.aspx*
uri:*user* http.title:login
uri:*admin* http.title:login
http.title:admin http.title:panel
```
Es gibt so viele Kombinationen. Um nur Panels von verwundbaren Servern zu finden, verwenden Sie den Filter `cve:*`.
Vergessen Sie auch nicht, dass Sie Server nach installierter Software mithilfe von Tags filtern können. Zum Beispiel:```
tag.1c_bitrix:*
tag.Cisco:
tag.amazon_s3:*
tag.drupal:*
tag.wordpress:*
```
### Suche nach anfälligen Datenbank-Admin-Panels
Versuchen wir, nach einem anfälligen [phpMyAdmin](https://www.phpmyadmin.net/)-Admin-Panel zu suchen (der beliebtesten Software zur Verwaltung von MySQL-Datenbanken):```
http.title:phpMyAdmin cve:*
```
Und hier sind einige Beispiele für andere beliebte Datenbankverwaltungstools:
[Adminer](https://www.adminer.org/):```
http.title:adminer http.title:login cve:*
```
[PostgreSQL](https://www.postgresql.org/)```
http.title:(phpPgAdmin OR pgadmin) cve:*
```
Sie können auch nach Servern suchen, die Software für verschiedene Datenbanken installiert haben, indem Sie die Tags oder speziellen Filter verwenden:```
tag.adminer:*
tag.phpMyAdmin:*
tag.elastic:*
mongodb:*
mssql:*
mysql:*
django:*
```
Nach Admin-Panels für so gefundene Server zu suchen, ist möglicherweise nicht die einfachste Sache, da Site-Administratoren oft Standardlinks durch sicherere ersetzen.
### Nach Sites suchen, die anfällig für SQL-Injection sind
SQL-Injection ist eine Art von Schwachstelle, die es ermöglicht, Datenbankabfragen durch Manipulation von URL-Parametern durchzuführen (dies kann aufgrund von Fehlkonfigurationen und schlechter Codequalität möglich sein).
Eine der ältesten Techniken, um potenziell anfällige Seiten für SQL-Injection zu finden, besteht darin, nach Seiten zu suchen, die die Anzeige von Fehlermeldungen in MySQL-Abfragen mittels Google Dorks aktiviert haben.
Eine ähnliche Suche kann in Netlas durchgeführt werden:```
http.body:mysql_fetch_array http.body:warning
```
[Versuch in Netlas](https://app.netlas.io/responses/?q=http.body%3Amysql_fetch_array%20http.body%3Awarning&page=1&indices=)
Einige andere Beispiele:```
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
```
**API-Anfragebeispiel**
Netlas CLI Tools:```bash
netlas search "http.body:mysql_fetch_array http.body:warning" -f json
```
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.body%3Amysql_fetch_array%20http.body%3Awarning&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' jq .items[].data.uri
```
**Codebeispiel (Netlas Python Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/pentest/sql_injection_search.py
```
Quellcode von 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'])
```
Sie können auch die folgenden Filter verwenden, um nach anfälligen MySQL-Servern zu suchen:
- `mysql.error_code`
- `mysql.error_id`
- `mysql.error_message`
-
## IoT-Suche: 9 grundlegende Methoden
Netlas durchsucht nicht nur Websites und Server, sondern alle mit dem Internet verbundenen Geräte: Smart-Home-Geräte, Überwachungskameras, Drucker, Router, Ampeln, medizinische Geräte und mehr.
Es gibt vier Hauptwege, diese Geräte zu finden.
### Suche nach Titel
Der einfachste Weg ist, einfach nach dem Namen des Herstellers oder dem Gerätetyp im HTTP-Titel der Antwort zu suchen.
Versuchen Sie, nach Jeedom-Homeautomation-Geräten zu suchen:```
http.title:Jeedom
```
[Testen in Netlas](https://app.netlas.io/responses/?q=http.title%3AJeedom&page=1&indices=)
Oder Avigilon-Webcams:```
http.title:"Avigilon"
```
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=http.title%3A%22Avigilon%22&page=1&indices=)
Diese Methode hat zwei Nachteile. Der erste ist die große Anzahl unpassender Ergebnisse (nur Websites mit relevanten Wörtern im Titel). Aber bei Verwendung von Anführungszeichen und zusätzlichen Suchfiltern wie port: gibt es weniger davon.
Der zweite ist, dass viele IoT-Geräte keine Informationen im http-Titel haben, anhand derer sie identifiziert werden können. Daher können auch andere Suchfilter nützlich sein.
### Suche im Body
Ebenso können Sie versuchen, im Body der http-Antwort nach Schlüsselwörtern zu suchen. Um zumindest einige der häufig vorkommenden Websites herauszufiltern, verwenden Sie den Filter NOT domain:*. Versuchen wir, Reolink-Kameras zu suchen:```
http.body:(clip-status) NOT domain:*
```
Das Beispiel ist nicht ganz korrekt, daher können diese Kameras mithilfe von Tags gefunden werden (mehr dazu weiter unten).
### Suche nach Port Nummer
Verschiedene IoT-Geräte nutzen unterschiedliche Ports zur Kommunikation. Und anhand der offenen Portnummer kann man hypothetisch annehmen, dass die IP-Adresse zu einem bestimmten Gerätetyp gehört (**oft ist die Annahme korrekt, aber es kann Ungenauigkeiten und Zufälle geben**).
Versuchen Sie, Internetradio zu suchen (Port 8000):```
port:8000 http.title:radio
```
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=port%3A8000%20http.title%3Aradio&page=1&indices=)
Oder alle Geräte mit geöffnetem Port 7547 (wird zur Fernverwaltung von Routern über CWMP verwendet):```
port:7547
```
[Probier es in Netlas aus](https://app.netlas.io/responses/?q=port%3A7547&page=1&indices=)
### Suche nach Banner
Suchen wir nach Routern, die das Telnet-Protokoll verwenden (Sie könnten sie auch mit port:23 filtern):```
telnet.banner:router
```
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=telnet.banner%3Arouter&page=1&indices=)
Oder durchsuchen Sie Banner nach allen Protokollen:```
\*.banner:router
```
[Try in Netlas](https://app.netlas.io/responses/?q=%5C*.banner%3Arouter&page=1&indices=)
### Suche nach Favicon
Eine der einfachsten Möglichkeiten, Geräte zu finden, auf denen bestimmte Software installiert ist, ist die Suche nach dem Favicon. Versuchen wir herauszufinden, wo verschiedene Cisco-Produkte verwendet werden:```
http.favicon.hash_sha256:62a8461e328d5bace3780ff738d0b58f6502592c04afa564e0a8a792583a7bfb
```
[Try in Netlas](https://app.netlas.io/responses/?q=http.favicon.hash_sha256%3A62a8461e328d5bace3780ff738d0b58f6502592c04afa564e0a8a792583a7bfb&page=1&indices=)
Es gibt drei Hauptmöglichkeiten, um in Netlas nach Favicons zu suchen:
1. Klicken Sie auf das Symbol links neben dem Suchergebnis.
2. Klicken Sie auf die Favicon-Suche-Schaltfläche rechts neben der Suchleiste und fügen Sie den Favicon-Link in das Pop-up-Fenster ein.
3. Klicken Sie auf die Favicon-Suche-Schaltfläche rechts neben der Suchleiste und laden Sie die Favicon-Datei hoch.
### Suche nach Server-Headern
Manchmal kommt es vor, dass sich keine identifizierenden Geräteinformationen im HTTP-Titel befinden, aber sie können in anderen Headern vorhanden sein. Zum Beispiel in http.server.header:```
http.headers.server:"i-Catcher Console"
```
[Try in Netlas](https://app.netlas.io/responses/?q=http.headers.server%3A%22i-Catcher%20Console%22&page=1&indices=)
Netlas unterstützt die Suche über mehrere Dutzend Header-Typen. Probieren Sie verschiedene Varianten aus.
### Suche nach Cookies
Suche Eco JS Parkplätze:```
http.headers.set_cookie:(regist_carNo=)
```
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=http.headers.set_cookie%3Aregist_carNo%3D&page=1&indices=)
### Suche nach Tag
*Diese Methode erfordert möglicherweise ein kostenpflichtiges Abonnement.* [Preise ansehen](https://netlas.io/pricing/)
Sie können auch versuchen, nach Geräten nach Tags (Kategorien) zu suchen.```
tag.category:"IoT"
tag.category:"Web cameras"
```
[Try in Netlas](https://app.netlas.io/responses/?q=tag.category%3A%22Web%20cameras%22&page=1&indices=)
Denk daran, dass Tags automatisch zugewiesen werden und einige passende Geräte möglicherweise nicht in der entsprechenden Kategorie enthalten sind.
### Zusätzliche Suchfilter
Es kann nach IoT-Geräten in bestimmten geografischen Standorten suchen:
- `geo.city`
- `geo.country`
- `geo.continent`
Filtere Geräte nach IP-Adressbereich:```
ip:[162.245.241.131 TO 162.245.241.133]
```
Oder Geräte mit "frischen" Schwachstellen:```
cve.name:*2023*
```
Mehr Beispiele für Abfragen zur Suche nach IoT-Geräten finden Sie hier:
[Netlas Dorks](https://github.com/netlas-io/netlas-dorks)
## Verwendung von Netlas.io für die Darknet-Forschung
Einer der Hauptvorteile von Netlas ist, dass Sie damit nach Dingen suchen können, die nicht von Google indexiert werden. Dies wird gemeinhin als Deep Web bezeichnet. Zum Beispiel FTP-Server oder Telnet-Server:```
ftp.banner:*
```
```
telnet.banner:*
```
Aber leider indiziert Netlas das Darknet nicht, da es nur globale IP-Adressen scannt. Aber es kann dennoch verwendet werden, um alternative Netzwerkinfrastruktur zu erkunden und Links zu .onion-Seiten zu finden.
### Suche nach Tor-Exit-Knoten
Ein Tor-Exit-Knoten ist der Punkt, an dem der Webverkehr das Tor-Netzwerk verlässt und an das Ziel weitergeleitet wird. Eine aktuelle Liste der IP-Adressen aktiver Tor-Eingangsknoten ist immer auf der TorProject-Website verfügbar:
[Liste der Exit-Knoten des Tor-Projekts](https://check.torproject.org/torbulkexitlist?ip=1.1.1.1)
Lassen Sie uns sehen, wie Sie mit Netlas Informationen über alle aktiven Tor-Exit-Knoten auf einmal sammeln können. Dieses Beispiel wird für alle anderen Aufgaben nützlich sein, für die Sie Informationen über eine Liste von Domains oder IP-Adressen sammeln müssen.
Führen Sie scripts/darknet/tor_nodes.py aus:```bash
python scripts/darknet/tor_nodes.py
```
Quellcode von 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
```
Die Verwendung des time-Pakets und der sleep-Methode ist nur für einfache Beispiele geeignet. Die beste Lösung ist die Verwendung des [rate limit package](https://github.com/netlas-io/netlas-cookbook#error-429---too-frequent-requests).
### Sammeln von Links zu .onion-Seiten
Wie bereits erwähnt, scannt Netlas nur globale Domains, daher ist es nicht möglich, nach .onion-Domains zu suchen. Sie können jedoch nach Verweisen auf .onion-Domains im Text von Webseiten suchen. Hier ist ein Beispiel eines einfachen Python-Skripts (mit regulärem Ausdruck), das dies tut:
Run scripts/darknet/onion_links.py:```bash
python scripts/darknet/onion_links.py
```
Quellcode von 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
```
Sie können auf die gleiche Weise Links für andere Netzwerke wie I2Pin sammeln:```
http.body:*.i2p
```
## Suche nach Datei-, Backup- und Log-Verzeichnissen
Es gibt eine riesige Anzahl von Websites und Servern, die aufgrund eines Konfigurationsfehlers (und manchmal absichtlich) ihre Dateiverzeichnisse offen lassen. Hier sind einige Beispiele für Abfragen, die Ihnen helfen, diese zu finden.
Suche nach beliebigen Dateiverzeichnissen:```
http.title:Index http.title:of
```
Suche nach Verzeichnissen mit Logdateien:```
http.title:Index http.title:of http.body:logs
```
Suche nach Verzeichnissen mit Datenbank-Dumps:```
http.title:Index http.title:of http.body:sql
```
Suche nach Verzeichnissen mit archivierten Backups:```
http.title:Index http.title:of http.body:backup?zip
```
Suche nach Verzeichnissen mit SSH-Zugriffsinformationen:```
http.title:Index http.title:of http.body:("ssh_config" OR "ssh_known_hosts" OR "authorized_keys" OR "id_rsa" OR "id_dsa")
```
Suche nach Verzeichnissen mit Dateien, die andere Autorisierungsinformationen enthalten:```
http.title:Index http.title:of http.body:("pass" OR "logins" OR "config" OR "password")
```
Suche nach Verzeichnissen mit von Benutzern heruntergeladenen Dateien:```
http.title:index http.title:of http.body:downloads
```
Durchsuchen Sie Verzeichnisse nach Docker-Konfigurationsdateien:```
http.title:index http.title:of http.body:docker-compose
```
Sie können sich Hunderte anderer solcher Anfragen vorstellen. Experimentieren Sie mit verschiedenen Dateinamen und Erweiterungen.
## Verwendung von Netlas.io für digitale Forensik und Incident Response
Dieser Abschnitt ist nur schwer von dem Abschnitt über Netlas für OSINT zu trennen, da die dort aufgeführten Abfragen auch für diejenigen nützlich sein werden, die in der digitalen Forensik tätig sind.
In diesem Abschnitt beschreiben wir eher "technische" Abfragen, die beispielsweise helfen können, Informationen über die technische Infrastruktur von Netzwerken zu sammeln oder Phishing-Angriffe zu untersuchen.
### SMTP-Server-Informationserfassung
SMTP (Simple Mail Transfer Protocol) ist ein Kommunikationsprotokoll, das das Senden und Empfangen von E-Mails ermöglicht. In den meisten E-Mail-Clients steht beim Anzeigen von E-Mails die Funktion "Show Original" zur Verfügung, mit der Sie die Adresse des SMTP-Servers anzeigen können, von dem die E-Mail gesendet wurde.
Netlas ermöglicht es Ihnen, Informationen über einen SMTP-Server sowie über jede andere IP oder Domain zu erhalten, und den Text von SMPT-Bannern zu durchsuchen, was es Ihnen ermöglicht, Server zu finden, die mit einer bestimmten Domain, einem Unternehmen oder einem Hosting-Anbieter verbunden sind.
**Beispiel für eine Suchanfrage**
```
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/dfir/smtp_banner_search.py
```
Quellcode von 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'])
```
### Suche nach Domains, die potenziell für Phishing verwendet werden könnten
Eine der beliebtesten Methoden von Betrügern ist die Verwendung von Domains, die in der Schreibweise den Domains bekannter Unternehmen sehr ähnlich sind.
Sie können solche Domains für ein bestimmtes Unternehmen mit Netlas und der unscharfen Suche finden.
Öffnen Sie die Whois-Domainsuche und geben Sie den Domainnamen des Unternehmens + ~ ein. Zum Beispiel:```
domain:facebook.com~
```
[In Netlas ausprobieren](https://app.netlas.io/whois_domains/?q=domain%3Afacebook.com~&page=1&indices=)
Klicken Sie anschließend auf das linke Symbol, wählen Sie den Export-Dateityp, die Dateinamen und die Felder aus, die Sie in der Datei speichern möchten. Klicken Sie auf "Download" und warten Sie einen Moment.
Sie können beispielsweise das CSV-Dateiformat sowie die Felder domain, expiration_date, status auswählen. Eine solche Tabelle lässt sich bequem in Excel, Numbers oder Google Docs anzeigen.
### Favicon-Suche
Die Suche nach favicon.ico hat drei Hauptanwendungen.
Erstens können Sie damit potenziell verwandte Websites und Subdomains finden. Versuchen Sie, die IP zu finden, die mit Lidl-Filialen verbunden ist:```
http.favicon.perceptual_hash:003c7e72207e3c00
```
[In Netlas testen](https://app.netlas.io/responses/?q=http.favicon.perceptual_hash%3A003c7e72207e3c00&page=1&indices=)
Und auch, um Phishing-Seiten zu finden, die das Design beliebter sozialer Netzwerke, Online-Shops usw. verwenden.
Zweitens ist es eine Suche nach verschiedenen IoT-Geräten. Versuchen Sie, HP-Produkte zu finden:```
http.favicon.perceptual_hash:0c5ec8c181f37e2c
```
[In Netlas ausprobieren](https://app.netlas.io/responses/?q=http.favicon.perceptual_hash%3A0c5ec8c181f37e2c&page=1&indices=)
Drittens sucht es nach Servern, auf denen bestimmte Software ausgeführt wird. Versuchen Sie, Server mit PhpMyAdmin zu finden:```
http.favicon.perceptual_hash:00084e5e5fffff8d
```
[Testen in Netlas](https://app.netlas.io/responses/?q=http.favicon.perceptual_hash%3A00084e5e5fffff8d&page=1&indices=)
Es gibt drei Hauptmöglichkeiten, um nach Favicon-Hash in Netlas zu suchen:
1. Klicken Sie auf das Symbol links vom Suchergebnis.
2. Klicken Sie auf die Favicon-Suche-Schaltfläche rechts neben der Suchleiste und fügen Sie den Favicon-Link in das Popup-Fenster ein.
3. Klicken Sie auf die Favicon-Suche-Schaltfläche rechts neben der Suchleiste und laden Sie die Favicon-Datei hoch.
Sie können auch die folgenden Filter verwenden, um nach Favicon zu suchen:
- `http.favicon.last_modified`
- `http.favicon.last_updated`
- `http.favicon.uri`
- `http.favicon.path`
### Suche nach Domains, die mit einem bestimmten Subnetz verbunden sind
Die Netlas-Domänensuche ermöglicht es, eine vollständige Liste der Domains zu erhalten, die mit einer bestimmten IP-Adresse oder einem Adressbereich verbunden sind. Zum Beispiel:```
a:"163.114.132.0/24"
```
[In Netlas ausprobieren](https://app.netlas.io/domains/?q=a%3A%22163.114.132.0%2F24%22&page=1&indices=)
API-Anfragebeispiel
Netlas CLI-Tools:```bash
netlas search -d domain a:\"163.114.132.0/24\"
```
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/domains/?q=a%3A%22163.114.132.0%2F24%22&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.domain
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/dfir/subnet_search.py
```
Quellcode von scripts/dfir/subnet_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 `a:"163.114.132.0/24"`
netlas_query = netlas_connection.query(query='a:"163.114.132.0/24"',datatype="domain")
# iterate over data and print: domain
for response in netlas_query['items']:
print (response['data']['domain'])
```
### Suche nach Servern mit schädlicher Software
Netlas ermöglicht Ihnen, Server zu finden, auf denen verschiedene Schadsoftware installiert ist. Sie können dies anhand bestimmter Wörter in http.title oder http.body, des Favicon-Hash, ssl und anderer Parameter erkennen.
Hier ist ein Beispiel für eine Abfrage, die Server findet, auf denen GoFish (Open Source Phishing Framework) installiert ist:```
http.title:Gophish http.title:Login
```
Beachten Sie, dass hier die Technik der doppelten Verwendung desselben Operators (anstelle eines Sternchens zwischen zwei Wörtern) angewendet wird. Manchmal hilft dies, mehr Suchergebnisse zu erhalten.
Hier sind einige weitere Beispiele für ähnliche Anfragen:```
http.title:CALDERA http.title:login
http.title:Deimos http.title:C2
```
**API-Anfragebeispiel**
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
```
**Codebeispiel (Netlas Python-Bibliothek)**
In der Befehlszeile ausführen:```bash
python scripts/dfif/malware_search.py
```
Quellcode von scripts/dfir/malware_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 "http.title:Gophish http.title:Login"
netlas_query = netlas_connection.query(query="http.title:Gophish http.title:Login")
# iterate over data and print: uri, title, country
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['http']['title'])
print (response['data']['geo']['country'])
```
## Suchen nach Technologien und Codebeispielen
Netlas ermöglicht es Ihnen im Gegensatz zu herkömmlichen Suchmaschinen, den gesamten HTML-Code anstelle des Texts der Seite zu durchsuchen. So können Sie Websites finden, die bestimmte JavaScript-Bibliotheken verwenden. Dies kann Ihnen helfen, für Ihre Aufgaben geeignete Codebeispiele zu finden und Zeit zu sparen.
Suchen Sie beispielsweise nach Websites, die eine alte, obskure Bibliothek zum Zeichnen von Grafiken verwenden:```
http.body:kinetic.js
```
Sie können auch sehen, wie verschiedene CSS-Frameworks auf Websites bestimmter Themen verwendet werden, und sich gute Designideen ausleihen:```
http.body:bootstrap.css http.title:travel
```
Sie können auch Websites filtern, die bestimmte Frameworks und Technologien verwenden, indem Sie Tags verwenden:```
tag.bootstrap:*
```
```
tag.angularjs:*
```
```
tag.wordpress:*
```
```
tag.nextjs:*
```
## Netlas.io aus Spaß oder zum Netstalking nutzen
Netlas kann, wie viele andere Suchmaschinen, auch ohne bestimmten Zweck genutzt werden, um mit ihrer Hilfe unerforschte Ecken des Internets zu erkunden, in der Hoffnung, dort etwas Interessantes zu finden.
Hier sind einige Beispiele für Suchanfragen, die Ihnen helfen, das zu finden, was Google nicht kann.
Suche nach Text von Telnet-Server-Bannern (ja, sie leben noch!):```
telnet.banner:library
```
Suche nach Text von FTP-Server-Bannern:```
ftp.banner:*library*
```
Suche nach Links zu Büchern und Dokumenten:```
http.body:*rowling*pdf
```
Suche nach Links zu Musik und Videos:```
http.body:*cats*mp4
```
Suche nach Links zu Torrent-Dateien:```
http.body:*cats*mp4
```
Beachten Sie, dass Netlas den Inhalt, den es in seiner Datenbank speichert, in keiner Weise zensiert. Wenn Sie etwas Illegales oder Unmoralisches finden, sollten Sie sich beim Hosting-Anbieter beschweren, dessen Kontaktdaten in den Domaininformationen aufgeführt sind.
## Häufige Probleme
### Fehler 429 - Zu viele Anfragen
Wenn Ihre Anwendung mehrere Anfragen an die Netlas-API stellt, kann dieser Fehler auftreten:```json
{'detail': 'Request was throttled. Expected available in 1 second.'}
```
Eine Möglichkeit, dieses Problem zu lösen, ist die Verwendung spezieller Python-Bibliotheken zur Konfiguration von Zeitlimits für die Abfrageausführung, wie z. B. [Limiter Package](https://pypi.org/project/ratelimit/).
Hier ist ein Beispiel für dessen Verwendung im Code (Limit von nicht mehr als 60 Anfragen pro Minute). Installieren Sie zuerst das Paket:```
pip install ratelimit
```
Und führen Sie rate_limit.py aus:```bash
python scripts/common_problems/rate_limit.py
```
[<img src="https://raw.github.com/nicholas-leonard/word2vec/master/word2vec.png" width=400px>](https://github.com/nicholas-leonard/word2vec)
 
[word2vec](https://crates.io/crates/word2vec) ist eine Rust-Implementierung des Word2Vec-Algorithmus zum Erlernen von Wortvektoren aus großen Textkorpora. Es unterstützt sowohl das Continuous Bag of Words (CBOW)- als auch das Skip-gram-Modell, mit Negativem Sampling und hierarchischem Softmax als Trainingsmethoden. Diese Implementierung zielt darauf ab, effizient und einfach zu bedienen zu sein, mit einem Fokus auf Leistung.
## Funktionen
- **CBOW und Skip-gram**: Beide Architekturen werden unterstützt.
- **Trainingsmethoden**: Negatives Sampling und hierarchisches Softmax.
- **Multithreading**: Das Training kann über mehrere Threads parallelisiert werden.
- **Konfigurierbar**: Viele Hyperparameter können angepasst werden (Fenstergröße, Vektordimension, Lernrate usw.).
- **Subsampling**: Optionales Subsampling häufiger Wörter, um das Training zu beschleunigen und die Qualität zu verbessern.
- **Vokabularerstellung**: Integrierte Funktionalität zum Erstellen eines Vokabulars aus Text.
- **Serialisierung**: Trainierte Wortvektoren speichern und laden.
- **Kommandozeilenschnittstelle**: Einfache CLI für Training und Inferenz.
- **Rust API**: Verwendung als Bibliothek in Rust-Projekten.
## Installation
Fügen Sie dies zu Ihrer `Cargo.toml` hinzu:
```toml
[dependencies]
word2vec = "0.1.0"
```
Oder verwenden Sie das Kommandozeilenwerkzeug:
```bash
cargo install word2vec
```
## Schnellstart
### Training aus einer Textdatei
```bash
word2vec train --input text.txt --output vectors.bin --cbow 1 --size 100 --window 5 --threads 4
```
### Vektoren laden und ähnliche Wörter finden
```rust
use word2vec::Word2Vec;
fn main() {
let mut model = Word2Vec::load("vectors.bin").expect("Fehler beim Laden des Modells");
let neighbors = model.find_nearest("king", 10).expect("Wort nicht gefunden");
for (word, similarity) in neighbors {
println!("{}: {}", word, similarity);
}
}
```
## Dokumentation
Die vollständige Dokumentation ist unter [docs.rs/word2vec](https://docs.rs/word2vec) verfügbar.
## Lizenz
Lizenziert unter einer der folgenden Lizenzen
* Apache License, Version 2.0, ([LICENSE-APACHE](https://github.com/netlas-io/netlas-cookbook/blob/HEAD/LICENSE-APACHE) oder http://www.apache.org/licenses/LICENSE-2.0)
* MIT-Lizenz ([LICENSE-MIT](https://github.com/netlas-io/netlas-cookbook/blob/HEAD/LICENSE-MIT) oder http://opensource.org/licenses/MIT)
nach Ihrer Wahl.```python
import netlas
from ratelimit import limits
# One second - one call
@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()
```
Ähnliche Pakete existieren für andere gängige Programmiersprachen, da das Überschreiten des Anfragenlimits ein sehr häufiges Problem bei der Arbeit mit fast allen APIs ist.
Wenn Sie wirklich mehr als eine Anfrage pro Sekunde stellen müssen, können Sie an das [Verkaufsteam](https://netlas.io/sales/) schreiben.
### KeyError
Ein weiteres häufiges Problem ist das Fehlen eines bestimmten Schlüssels in der Antwort für einige Server. Zum Beispiel fehlt ['data']['http']['title'] recht häufig.
Wenn der Schlüssel fehlt, stoppt das Skript die Ausführung. Eine Standardfehlerbehandlung hilft, dies zu vermeiden. Zum Beispiel:```python
try:
print (response['data']['http']['title'])
except:
print ("no title")
```
### Automatisierung der Arbeit mit der Liste der Anfragen
Der Hauptvorteil der Arbeit mit Netlas Python oder der Netlas API gegenüber dem einfachen Eingeben von Abfragen in der Webversion von Netlas.io besteht darin, dass Sie eine Menge Zeit sparen können, indem Sie Einheitsabfragen eingeben. Sie können beispielsweise schnell Informationen über eine lange Liste von Domänen mit sehr einfachem Python-Code sammeln.
In der Befehlszeile ausführen:```bash
python scripts/common_problems/domain_list_search.py
```
Quellcode von 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'])
```
Ebenso kannst du mit einer Liste von Zertifikaten, IP-Adressen, E-Mails und allem anderen arbeiten, was du möchtest.
Ein Beispiel für die Suche nach IP-Adressen aus einer über eine URL geladenen Liste findest du unter [Tor Exit Nodes Suche](#tor-exit-nodes-search).
### Daten im CSV-Format speichern
Standardmäßig gibt die Netlas Python-Bibliothek Daten vom Typ Dictionary zurück (was JSON sehr ähnlich ist). Wenn du die Daten nach MS Excel oder Google Sheets exportieren möchtest, ist eine einfache Möglichkeit, sie im CSV-Format zu speichern.
Hier ist ein Beispiel mit dem [CSV](https://docs.python.org/3/library/csv.html) Paket. Führe csv_export.py aus:```bash
python scripts/common_problems/csv_export.py
```
Bitte fügen Sie den zu übersetzenden Markdown-Inhalt ein.```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
```
Sie können netlas_results.csv in Excel oder einem beliebigen Texteditor öffnen.
### Speichern von Daten in anderen Formaten
Mit Python können Sie eine Vielzahl von Dokumenten auf der Grundlage von Daten aus Netlas erstellen, Bilder, Datenvisualisierungen einfügen und das Layout anpassen. Hier sind einige Beispiele für nützliche Pakete.
[XLSXWriter](https://xlsxwriter.readthedocs.io/) - Erstellen Sie Microsoft Excel-Dateien.
[PyPDF](https://pypdf.readthedocs.io/en/stable/) - Erstellen Sie PDF-Dateien.
[PythonPPTX](https://python-pptx.readthedocs.io/en/latest/) - Erstellen Sie Microsoft PowerPoint-Präsentationen.
[PythonDOCX](https://python-docx.readthedocs.io/en/latest/) - Erstellen Sie Microsoft Word-Dokumente.
### Dekodieren von Punycode-Domains
Wie oben erwähnt, speichert Netlas nicht-lateinische Domainnamen nicht in ihrer ursprünglichen Kodierung, sondern kodiert sie in Punycode. Dies ist aus technischen Gründen notwendig, aber für die menschliche Wahrnehmung völlig unpraktisch.
Aber dieses Problem lässt sich mit ein paar Zeilen Python-Code leicht lösen.
Installieren Sie das [IDNA-Python-Paket](https://pypi.org/project/idna/):```bash
pip install idna
```
Und führen Sie punycode.py in der Kommandozeile aus:```bash
python scripts/common_problems/punycode.py
```
Bitte fügen Sie den zu übersetzenden Markdown-Text ein.```python
import netlas
import idna
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `domain:*.中国 OR host:*.中国 `
netlas_query = netlas_connection.query(query="domain:*.xn--fiqs8s OR host:*.xn--fiqs8s")
# iterate over data and print: ip, domain (decoded from punycode)
for response in netlas_query['items']:
print (response['data']['ip'])
decoded_domain = idna.decode(str(response['data']['domain'][0]))
print (decoded_domain)
```
### Was tun, wenn Suchanfragen keine Ergebnisse liefern?
Manchmal kann es vorkommen, dass bei einer Abfrage keine oder nur sehr wenige Ergebnisse gefunden werden, obwohl Sie sicher sind, dass es viel mehr geben sollte. In diesem Fall empfehlen wir Ihnen, zu experimentieren und die Abfragen ein wenig zu ändern.
1. Versuchen Sie, zwei Sternchen zu Ihrem Suchbegriff hinzuzufügen. Zum Beispiel liefert `domain:*github.com*` 1.592.846 Ergebnisse. `domain:githib.com` – nur 7911 Ergebnisse.
2. Versuchen Sie, verschiedene Suchfilter zu verwenden, um das gleiche Ziel zu erreichen. Vergleichen Sie zum Beispiel die Ergebnisse für `uri:*github.com*`, `host:*github.com*` und `domain:*github.com*`.
3. Verwenden Sie keine Leerzeichen in Schlüsselwörtern. Wenn Sie die Phrase „Hello world“ im http.body finden müssen, verwenden Sie die folgende Abfrage: ```
http.body:hello http.body:world
```
oder ```
http.body:(hello AND world)
```
4. Verfeinern Sie Ihre Suchfilter so weit wie möglich. Zum Beispiel gibt die Abfrage cve:*2023* keine Ergebnisse zurück. Aber die Abfrage cve.name:*2023* liefert mehr als 28 Millionen.
5. Probieren Sie verschiedene Tabs in der Web-App oder verschiedene Datentypen in der API aus. Bei der Suche nach Domains funktionieren manchmal Host oder Domain Whois (statt response) besser.
### Entfernen von HTML-Tags aus dem HTTP-Textkörper
Der Schlüssel ['data']['http']['body'] gibt standardmäßig den vollständigen Textkörper der Webseite zurück, einschließlich aller HTML-Tags. Dieses Format ist nicht sehr gut lesbar. Aber Sie können sie leicht mit dem Python-Paket [Html2text](https://pypi.org/project/html2text/) entfernen.
In der Befehlszeile ausführen:```bash
python scripts/common_problems/htmltotext.py
```
Quellcode von htmltotext.py:```python
import netlas
import html2text
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.body:*phpMyAdmin*`
netlas_query = netlas_connection.query(query="http.body:*phpMyAdmin*")
# iterate over data and print: ip, web page text
for response in netlas_query['items']:
print (response['data']['ip'])
print (html2text.html2text(str(response['data']['http']['body'])))
```
## Attack Surface Management
Die Netlas-Plattform umfasst Werkzeuge für das Angriffsflächenmanagement, aber dieses Thema geht über den Rahmen dieses Leitfadens hinaus. Wenn Sie sich allgemein für Angriffsflächenmanagement und speziell für die Nutzung von Netlas interessieren, empfehlen wir Ihnen, mit diesen Artikeln zu beginnen:
- [Vollständiger Leitfaden zur Erkennung von Angriffsflächen](https://netlas.io/blog/attack_surface_discovery_guide/).
- [Beste Werkzeuge zur Visualisierung von Angriffsflächen](https://netlas.io/blog/best_attack_surface_visualization_tools/).
## Arbeiten mit sehr großen Datenmengen
Wenn Sie eine wirklich große Herausforderung vor sich haben. Zum Beispiel müssen Sie Daten über Hunderttausende von Domains sammeln, dann ist es möglicherweise eine vernünftigere Lösung im Hinblick auf Zeit- und Kostenaufwand, einen Datensatz (csv/json) zu kaufen und auf Ihrem eigenen Server damit zu arbeiten.
Im [Netlas Datastore](https://app.netlas.io/datastore/) finden Sie:
* Datensatz bekannter Domainnamen (mehr als 2 Milliarden Einträge)
* Datensatz des Forward-DNS (mehr als 2 Milliarden Einträge)
* Bekannte PTR-Einträge (mehr als 1 Milliarde Einträge) - KOSTENLOS
* Top 1,000,000 häufigste Subdomains
und mehr.
## Danksagungen
Vielen Dank an [@cyb_detective](https://twitter.com/cyb_detective) für die Hilfe (https://cybdetective.com)