Domain - Subdomain-Suche mit Hilfe von Subfinder

Subfinder ist ein beliebtes Open-Source-Tool, das Subdomains einer Domain aus öffentlichen Quellen sammelt. Es wird häufig von Pentestern und Sicherheitsforschern genutzt, um schnell einen Überblick über die Angriffsfläche einer Domain zu erhalten. Das Tool durchsucht verschiedene öffentliche Datenquellen und aggregiert die gefundenen Subdomains in einer übersichtlichen Liste.

Wofür wird Subfinder genutzt?

Mit Subfinder kannst du herausfinden, welche Subdomains einer Domain öffentlich auffindbar sind. Das ist besonders nützlich für:

• Sicherheitsanalysen: Identifikation potenzieller Schwachstellen oder veralteter Systeme.
• Bug Bounty: Erhöhung der Chancen, bisher unentdeckte Subdomains und damit verbundene Sicherheitslücken zu finden.
• Infrastruktur-Überblick: Schnelle Übersicht über die digitale Präsenz eines Unternehmens.
  
  

Installation (Go-Toolchain)

Subfinder ist in Go geschrieben und lässt sich einfach installieren. Voraussetzung ist eine funktionierende Go-Umgebung. Die Installation erfolgt mit folgendem Befehl:

go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest

Nach der Installation steht dir der Befehl subfinder in deinem Terminal zur Verfügung.

Erste Schritte

Um Subdomains für eine Domain zu sammeln, führe einfach folgenden Befehl aus:

subfinder -d beispiel.de

Das Tool durchsucht nun verschiedene Quellen und gibt eine Liste aller gefundenen Subdomains aus.

Ähnlich wie theHarvester (Domain - Digitale Spurensuche mit dem Tool theHarvester), kann man auch hier für Dienste die einen API-Schlüssel benötigen diese hinterlegen. Siehe https://docs.projectdiscovery.io/opensource/subfinder/install#post-install-configuration.

Fazit

Subfinder ist ein mächtiges Werkzeug für jeden, der sich mit IT-Sicherheit, Pentesting oder Bug Bounty beschäftigt. Dank der einfachen Installation und Bedienung ist es ideal für den schnellen Einstieg in die Subdomain-Discovery.

Steam Deck - Mit Hilfe von Distrobox Linux-Distribution (Ubuntu) in einem Container starten

SteamOS setzt als Immutable System auf ein schreibgeschütztes Root-Dateisystem, weshalb Discover nur Flatpak-Pakete anbietet, klassische Kommandozeilenprogramme sucht man hier vergeblich. Zwar sind Basistools vorinstalliert, doch zusätzliche Software lässt sich nicht einfach über pacman nachinstallieren. Wer weitere Tools benötigt, kann auf das vorinstallierte Distrobox zurückgreifen.

Bei Distrobox handelt es sich um einen Wrapper für Podman oder Docker, welche durch im Hintergrund genutzt werden. Mit wenig Aufwand lassen sich so Images von verschiedenen Linux Distribution (z. B. Ubuntu oder Debian) nutzen, über die sich wiederum weitere Anwendungen installieren lassen.

Hintergrund: Distrobox startet andere Linux-Distributionen in Containern, so kann man deren Paketverwaltung nutzen und sogar auf schreibgeschützten Systemen "sudo" Befehle ausführen. Die Container sind nahtlos ins Host-System integriert. Sie greifen auf das Home-Verzeichnis, Netzwerk und USB-Geräte zu, nutzen aber den Kernel des Hosts, somit handelt es sich nicht um virtuelle Maschinen!

Um z.B. Ubuntu zu installieren ist jetzt eigentlich nur noch der folgende Befehl notwendig: 
distrobox-create -n ubuntu -i docker.io/library/ubuntu:24.04

Es empfiehlt sich aber die folgenden Anleitung "Install Distrobox and Podman PERMANENT on Steam Deck >= 3.5" durchzuführen.

nano ~/.bashrc Add the following line if it’s not already there:
export PATH=/home/deck/.local/bin:$PATH

Install and configure Distrobox To install Distrobox in the defined $PATH, use one of the following commands depending on whether you need the latest version (--next) or not:
curl -s https://raw.githubusercontent.com/89luca89/distrobox/main/install | sh -s -- --prefix $HOME/.local

After installing, create the file ~/.distroboxrc if it doesn't already exist. Open it with:
nano ~/.distroboxrc

Add the following lines to configure Distrobox:
# Ensure the graphical apps can talk to the Xwayland session
xhost +si:localuser:$USER >/dev/null
# Force the use of pulseaudio inside the container
export PIPEWIRE_RUNTIME_DIR=/dev/null
# Needed to ensure distrobox can find the podman binary we previously downloaded
export PATH=/home/deck/.local/bin:$PATH
export PATH=$PATH:/home/deck/.local/bin

Install and configure Podman To install Podman, download the latest version from the GitHub releases page:
curl -L -o /home/deck/Downloads/podman-launcher-amd64 https://github.com/89luca89/podman-launcher/releases/download/v0.0.5/podman-launcher-amd64

Next, move and rename the Podman binary with ROOT permissions to the $PATH:
mv /home/deck/Downloads/podman-launcher-amd64 /home/deck/.local/bin/podman

Then, make Podman executable:
chmod +x /home/deck/.local/bin/podman

Configure the deck user’s UID and GID mapping with the following commands:
sudo touch /etc/subuid /etc/subgid
sudo usermod --add-subuid 100000-165535 --add-subgid 100000-165535 deck 

Configure Distrobox Icon folder - (if you install distrobox with sudo) To ensure Distrobox can store its icons correctly, set the proper permissions on the /home/deck/.local/share/icons folder with:
chown deck:deck /home/deck/.local/share/icons

Verify installations After the installation steps, verify that both Distrobox and Podman are properly installed and configured. Use the following commands:
which distrobox which podman distrobox --version podman --version podman info

To create and test a ROOTLESS container, run:
distrobox create --image docker.io/library/ubuntu:24.04 --name ubuntu

For a ROOT container, use:
distrobox create --image docker.io/library/ubuntu:24.04 --name rubuntu --root

Jetzt lässt such Ubuntu mit dem folgenden Befehl starten: 
distrobox enter ubuntu

Jetzt lässt sich z.B. neofetch installieren:
sudo apt install neofetch 

Container starten / stoppen:
distrobox enter ubuntu
distrobox stop ubuntu

Einen Container löschen:
distrobox rm 

Welche Images zur Verfügung stehen:
distrobox create -C 

Liste der Container:
distrobox list

Container klonen:
distrobox create --clone ubuntu -n ubuntu-klon

Portweiterleitung einrichten:
distrobox create --unshare-netns -a "-p 8080:8000" -i ubuntu -n ubuntu-nonet
Mit "-p 8080:8000" landen alle Anfragen, die an Port 8080 des Host-Systems ankommen, direkt im Container an Port 8000.

Pakete bei distrobox create mithilfe von --additional-packages (-ap) direkt in den Container integrieren (z.B. neofetch und iproute2):
distrobox create -i debian:latest -n debian -ap "neofetch iproute2"

Container beim Erzeugen mit der Option --home einen beliebigen anderen Ordner als Heimatverzeichnis verwenden lassen:
distrobox create -i debian:latest -n debian --home ~/temp/debianhome

Anwendungen in das Startmenü des Host-Systems einbinden, mit --extra-flags kann Parameter hinzufügen:
distrobox-export
distrobox-export --app chromium

Domain - Digitale Spurensuche mit dem Tool theHarvester

theHarvester ist ein OSINT-Tool, das automatisiert öffentlich verfügbare Informationen zu Domains aggregiert. Es nutzt über 40 Datenquellen (Suchmaschinen, DNS-Scanner und Metadaten-Dienste), um IPs, Subdomains, E-Mail-Adressen und mehr für eine initiale Angriffsflächenanalyse zu erfassen. Eine weitere Möglichkeit hatte ich vor einiger Zeit unter Security - Amass (Automated Attack Surface Mapping).

theHarvester ist über Kali Linux bereits vorinstalliert (siehe auch Windows-Subsystem für Linux (WSL) - Installation Kali Linux). Alternativ lässt sich theHarvester auch via Docker, pipx oder über den Python-Paketmanager uv aus dem lokalen Quellcode starten. Siehe auch https://github.com/laramies/theHarvester/wiki/Installation.

Unter Windows 11 kann man die Module mit dem Paketmanager winget installieren:
winget install uv Git.Git
git clone https://github.com/laramies/theHarvester
cd theHarvester

Steam Deck (Arch Linux) Installation:
curl -LsSf https://astral.sh/uv/install.sh | sh
source ~/.local/bin/env
git clone https://github.com/laramies/theHarvester
cd theHarvester

Ausführen (-d 'shemel.de' Domain welche zu untersuchen ist, -b 'all' alle hinterlegten Quellen durchsuchen):
uv run theHarvester -d shemel.de -b all

Mit Hilfe von -f result, lassen sich alle Ergebnisse in eine result.xml und result.json schreiben.

Die Meldung "Missing API key for …" bedeutet, dass diese Dienste einen API-Schlüssel benötigen, für die in der Regel Gebühren anfallen. Den Schlüssel muss man in die Datei "api-keys.yaml" eintragen.

Security - Amass (Automated Attack Surface Mapping)

Amass ist ein vielseitiges Cybersicherheitstool zum Sammeln von Informationen über Internet-Domains. Amass fragt z.B. Suchmaschinen an, untersucht SSL-Zertifikate und sendet Reverse-DNS-Anfragen an die jeweilige Domain. So lassen sich z.B. vergessene Server aufspüren und gezielt angreifen.

Eine Installation mit Hilfe von Docker, ist sehr schnell möglich:

sudo docker build -t amass https://github.com/OWASP/Amass.git

Hinweis: Docker muss natürlich installiert sein (sudo apt install docker.io) und der Docker Daemon muss gestartet sein (sudo dockerd) "Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?". Siehe auch https://sebastianhemel.blogspot.com/2020/12/raspberry-pi-docker-installieren-arm.html .

Andere Installationsmöglichkeiten finden sich unter: https://github.com/OWASP/Amass/blob/master/doc/install.md

Zu dem ist Amass auch Bestandteil von Kali Linux einer Linux-Distribution (Debian basierend), die eine Sammlung von Tools für Penetrationstests und digitale Forensik umfasst. Siehe auch https://gitlab.com/kalilinux/packages/amass/blob/kali/master/doc/user_guide.md.

Das Ausführen über das Docker-Image ist relativ einfach und so kann man z.B. mit dem folgenden Befehl alle Subdomains einer bestimmten Domain herausfinden.

sudo docker run -v ~:/.config/amass/ amass enum -ip -d shemel.de

Amass verfügt über folgende Unterbefehle:

• amass intel -- Discover targets for enumerations
• amass enum -- Perform enumerations and network mapping
• amass viz -- Visualize enumeration results
• amass track -- Track differences between enumerations
• amass db -- Manipulate the Amass graph database

Weitere Informationen und Beispiele finden sich hier:

• https://github.com/OWASP/Amass/blob/master/doc/user_guide.md
• https://github.com/OWASP/Amass/blob/master/doc/tutorial.md

 

Raspberry Pi - Verwendung von Docker Compose (Beispiel OpenAPI-Generator c't 25/2020)

In diesem Beitrag zeige ich auf Basis des Artikels c't 25/2020 S. 160 OpenAPI-Generator, wie man Docker Compose verwendet. Die Installation wurde bereits in dem Artikel Raspberry Pi - Docker Compose installieren beschrieben.

Docker Compose ermöglicht mehrere Container mit einzelnen Anwendungen oder Komponenten zu starten oder um Container automatisch zu verknüpfen und Volumes einzurichten.

Die Verwendung von Docker Compose benötigt die folgenden Schritte

1. Erstellen eines Verzeichnis für die Installationsdateien.
• mkdir rest-api-demo
2. In diesem Verzeichnis muss jetzt die YAML-Datei docker-compose.yml abgelegt/erstellt werden.
• Images mit dem Apache Webserver und PHP-Compiler:
  version: "3"
  services:
    server:
      image: "jorgenjo/rpi-apache-php" #php:apache
      volumes:
        - ./server:/var/www/html
      ports:
        - 8001:80
    client:
      image: "jorgenjo/rpi-apache-php" #php:apache
      volumes:
        - ./client:/var/www/html
      ports:
        - 8000:80
      depends_on:
        - server
• Achtung: Auch hier muss ein anderes image (https://hub.docker.com/r/jorgenjo/rpi-apache-php) beim Pi verwendet werden, speziell für ARM. Siehe auch Raspberry Pi - Docker installieren (ARM - Exit Code 139).
  
• 
  
  
3. Im selben Verzeichnis, den/die Container zu starten.
• ~/rest-api-demo $ sudo docker-compose up -d
• 
  
• Hinweis: Docker-Compose wird im Hintergrund (-d) ausgeführ

Test der Umgebung (Server und Client)

In beiden Verzeichnissen (Server/Client) jeweils eine index.php Datei erstellen und anschließend aufrufen.

Server: index.php
<?php echo "Test"; ?>

Client: index.php
<?php echo file_get_content("http://server"); ?>

Die Basis ist jetzt geschafft, weiter geht es jetzt mit der Anleitung unter https://github.com/manuelottlik/ct-oas-praxis/.

Nützliche Docker Compose Befehle

Erstellte Container abzeigen:
sudo docker-compose ps

Container einer Anwendungsgruppe stoppen:
sudo docker-compose stop 

Containe entfernen (sofern gestoppt):
sudo docker-compose rm 

Alle Container in einer Anwendungsgruppe stoppen und gleichzeitig entfernen:
sudo docker-compose down

Alle Data-Volumes entfernen (-v):
sudo docker-compose down -v

Raspberry Pi - Docker Compose installieren

Docker Compose ist ein Tool zum Definieren und Ausführen von Docker-Anwendungen mit mehreren Containern. 

Hinweis: Docker muss zuvor installiert sein. Siehe auch Raspberry Pi - Docker installieren.

Compose verwendet eine YAML-Datei, um die Dienste der Anwendung zu konfigurieren. Anschließend kann man alle Dienste in der erstellten Konfiguration starten. Siehe hierzu auch https://docs.docker.com/compose/.

Die akutelle Compose-Version erhält man wie z.B. auch für Ubuntu über den Python-Paketmanager Pip.

Installation von Pip für Python 3:
sudo apt-get install python3-pip

Installation von Docker Compose:
sudo pip3 install docker-compose

Raspberry Pi - Docker installieren (ARM - Exit Code 139)

Die Installation von Docker ist relativ einfach, benötigt wird nur ein Raspberry Pi mit bereits installiertem Raspberry Pi OS und einem SSH-Zugang. Mit Hilfe der Docker Software kann man verschiedenste Anwendungen in einer Containervirtualisierung starten.

Installation von Docker

Die Installation ist mit dem folgenden Befehl per curl möglich. Siehe hierzu auch https://github.com/docker/docker-install.

curl -fsSL https://get.docker.com -o get-docker.sh

Hinweis: Docker wird in der Regel auf x64-Systemen ausgeführt, dies bedeutet es müssen spezielle ARM-Images verwendet werden. Normale Images sind daher nicht kompatibel. Siehe auch mein Hinweis unten!

Docker-Installation Überprüfen

Ermittlung der Version, Informationen abrufen:
sudo docker version
sudo docker info

Hello-World-Image herunterladen und starten:
sudo docker run hello-world # No output on Pi (ARM)
sudo docker run hypriot/armhf-hello-world 

Anzeigen der heruntergeladen Docker-Images:
sudo docker image ls

Anzeigen der aktuellen Docker-Prozesse:
sudo docker ps -a
sudo docker container ls

Logfile des Containers anzeigen
sudo docker logs 7dd670ad4109

Docker Container Exit Codes (Exit Code 139: SIGSEGV)

Beim Starten des oben genannten Hello-World-Image, gab es das Problem das keine Ausgabe des Image erfolgte. Der Grund war, dass hier ein nicht kompatibles Image für ARM verwendet wurde.

• Exit Code 139: Indicates failure as container received SIGSEGV => Speicherzugriffsverletzung 

Alle Container auflisten, die beendet wurden:
sudo docker ps --filter "status=exited"

Docker Container / Images löschen

# Delete all containers
sudo docker rm $(sudo docker ps -a -q)
# Delete all images
sudo docker rmi $(sudo docker images -q)