# Memory Forensics
## Khái niệm
* **Memory Forensics** là quá trình thu thập và phân tích dữ liệu trong bộ nhớ máy tính (**RAM**) hoặc các dạng tương tự (dump file, minidump, hibernate file, pagefile/swap, …).
* Mục tiêu: tìm dấu vết hoạt động hệ thống, ứng dụng và hoạt động tấn công/mã độc.
* Các thông tin có thể thu được bao gồm:
* **Process**: danh sách tiến trình (bao gồm tiến trình ẩn hoặc `injected`).
* **File**: các file đang mở hoặc đã load vào **RAM**.
* **Network**: kết nối mạng, socket, bảng **ARP**, routing table.
* **Registry/System config**: thông tin hệ thống cần thiết để duy trì hoạt động.
* **User activity**: clipboard, lịch sử lệnh, shellbags, **IE/Edge** history.
* **Credentials**: password hash, **LSA** secrets (tùy hệ điều hành, có thể bị hạn chế).
* **Malware artifacts**: injected code, **API** hooks, rootkits, **DLL** ẩn, driver lạ.
## Đặc điểm
* **RAM** có tính chất `volatile` (dữ liệu thay đổi liên tục và biến mất khi tắt máy).
* Khác với **Disk Forensics** (dữ liệu ổ cứng ổn định, tồn tại lâu dài).
## Profiles và Symbol Tables
* Mỗi hệ điều hành/quản lý **RAM** khác nhau → cần `profile` (`Volatility 2`) hoặc `symbol table` (`Volatility 3`) để phân tích.
* Cách dùng:
* **Volatility 2** (`Python2`): tương thích tốt với các file `memdump` từ hệ điều hành cũ (**WinXP**, **Win7**).
* Build profile với **Vol2**: https://github.com/volatilityfoundation/volatility/wiki/
* **Volatility 3** (`Python3`): hỗ trợ hệ điều hành mới, nhưng không tương thích ngược với **Vol2**.
* Build profile với **Vol3**: https://volatility3.readthedocs.io/en/latest/
* Khuyến nghị: cài cả **Vol2** và **Vol3**, thử **Vol2** trước, nếu lỗi thì chuyển sang **Vol3**.
## Công cụ hỗ trợ
* **Volatility** (mã nguồn mở, phổ biến nhất).
* **Rekall** (phân nhánh từ **Volatility**, nay ít dùng hơn).
* **Memoryze** (`FireEye`), **LiME** (`Linux Memory Extractor`), **DumpIt**, **WinPMEM**: dùng để tạo `memory dump`.
## Ứng dụng
* **Điều tra mã độc**: phát hiện tiến trình bị tiêm code, file thực thi ẩn.
* **Phân tích tấn công**: xác định hành vi `attacker` qua `command line`, kết nối mạng.
* **Khôi phục dữ liệu tạm thời**: clipboard, văn bản đang mở, lịch sử lệnh.
* **Hỗ trợ pháp y số**: cung cấp bằng chứng bổ sung ngoài `disk forensics`.
# Tìm hiểu cách Dump RAM
* **RAM Dump** (`Memory Dump`): quá trình ghi lại toàn bộ nội dung bộ nhớ **RAM** tại một thời điểm nhất định.
* Thông tin trong `dump` bao gồm:
* Hệ điều hành: thành phần, tiến trình cốt lõi.
* Ứng dụng: chương trình đang chạy và trạng thái của chúng.
* Trạng thái hệ thống: tiến trình, luồng, kết nối mạng, dữ liệu tạm thời.
* **RAM Dump** cung cấp `snapshot` bộ nhớ, phục vụ cho xử lý sự cố, điều tra pháp y số, nghiên cứu bảo mật, tối ưu hóa hệ thống.
## Lý do cần Dump RAM
* Xử lý sự cố hệ thống:
* Xác định mã lỗi, driver lỗi, trạng thái hệ thống trước khi crash.
* Điều tra an ninh:
* Phân tích `malware` và hành vi tấn công.
* Thu thập bằng chứng số phục vụ điều tra.
* Phát hiện xâm nhập, truy cập trái phép.
* Tối ưu hóa hiệu suất:
* Phát hiện `memory leak`.
* Kiểm tra cách ứng dụng phân bổ bộ nhớ.
* Phát triển phần mềm
* Gỡ lỗi ứng dụng.
* Kiểm tra quản lý bộ nhớ trong quá trình phát triển.
## Công cụ phân tích RAM Dump
* **WinDbg**: debugger của **Microsoft**, phân tích `dump` trên **Windows**.
* **Volatility Framework**: mã nguồn mở, hỗ trợ **Windows/Linux/Mac**.
* **Rekall**: phân tích bộ nhớ đa nền tảng.
* Kỹ thuật phân tích chính
* **String search**: tìm chuỗi/text trong **RAM**.
* **Process analysis**: kiểm tra tiến trình, command line, trạng thái.
* **Memory structure analysis**: phân tích cấu trúc **OS**, module, vùng nhớ nghi ngờ.
# Các phương pháp Dump RAM
## Dump RAM với Windows
### Task Manager
* Khi dùng **Task Manager** → **Create Dump File**, ta không dump toàn bộ **RAM**, mà chỉ dump bộ nhớ liên quan đến 1 tiến trình → gọi là **Process Dump** hoặc **Minidump**.
* Vì vậy, `memdump` này không chứa dữ liệu `kernel`, không chứa tiến trình khác, mà chỉ tập trung vào tiến trình đã chọn.
* Đợi tí là có file `dump`:
* Để phân tích file `dump` có thể dùng **Windbg**:
### Windows Crash Dump
* **Windows** tích hợp cơ chế tạo file `dump` khi hệ thống gặp `crash` (**BSOD** – `Blue Screen of Death`). Người dùng có thể cấu hình để lưu:
* **Small Memory Dump** (`Minidump`)
* **Kernel Memory Dump**
* **Complete Memory Dump** (`Full Dump`)
#### Small Memory Dump (Minidump)
* Kích thước: ~256 KB.
* Chứa:
* **Stop error code** (mã lỗi khi `crash`).
* **Processor context** tại thời điểm lỗi (`registers`, `call stack`, **CPU**).
* Danh sách driver đã nạp tại thời điểm lỗi.
* Thông tin cơ bản về `process` và `threads` chạy trên **CPU** khi `crash`.
* Ứng dụng: Phân tích sự cố nhanh, hỗ trợ kỹ thuật.
* Công cụ: **WinDbg**, **BlueScreenView**.
#### Kernel Memory Dump
* Kích thước: Tùy dung lượng `kernel`, nhỏ hơn nhiều so với **RAM** thực tế.
* Chứa:
* **Kernel-mode memory** (`executive memory`, `kernel stacks`, `driver data`).
* Không bao gồm dữ liệu `user-space` (không chứa thông tin của các ứng dụng đang chạy).
* Ứng dụng: Phân tích lỗi `driver`, `kernel`.
* Công cụ: **WinDbg**, **Volatility**.
#### Complete Memory Dump (Full Dump)
* Kích thước: ≈ dung lượng **RAM**.
* Chứa:
* Toàn bộ **RAM** (`kernel-mode` + `user-mode`).
* Tất cả `process`, `threads`, `module`, `driver` đang chạy.
* Dữ liệu `user-space` (ứng dụng).
* Ứng dụng: Phân tích chuyên sâu cả hệ điều hành lẫn ứng dụng.
* Công cụ: **Volatility**, **Rekall**, **WinDbg**.
#### Cấu hình và demo dump thử
* Mặc định file `dump` sẽ được lưu tại `C:\Windows\MEMORY.DMP`.
* Cấu hình như sau:
* Demo thử với **Complete Memory Dump**. Điều kiện làm được đương nhiên phải trigger crash, nói cách khác là khiến máy bị **BSOD**.
* Có nhiều cách nhưng mà có thể tham khảo ở [Can You Trigger a BSoD Intentionally?](https://www.fortect.com/fix-blue-screen-of-death/trigger-bsod-intentionally/)
```py
TASKKILL /IM svchost.exe /F
```
* Ngon luôn :))
* Ta thấy số **RAM** không chênh lệch quá nhiều.
* `2GB×1024×1024=2,097,152KB`
### DumpIt
* Cái này `dump` **RAM** có vẻ dễ nhất. Tải ở [đây](https://www.toolwar.com/2014/01/dumpit-memory-dump-tools.html) nha.
* Chạy quyền **Admin**:
* Bấm `y` hoi:
### FTK Imager
* Ngoài phân tích `disk image` thì **FTK Imager** cũng có chức năng `dump` **RAM**.
* Chọn `path` lưu và tên file `dump`:
### WinPMEM
* **WinPMEM** là một phần của **Rekall Framework** được thiết kế để `dump` bộ nhớ từ máy **Windows**.
* Có thể tải ở [đây](https://github.com/Velocidex/WinPmem/releases) nhaaa.
## Dump RAM với Linux
* So với **Windows**, việc `dump` **RAM** trên **Linux** phức tạp hơn vì sự khác biệt giữa các phiên bản `kernel`.
* Trước đây có thể `dump` **RAM** trực tiếp từ ``/dev/mem`` hoặc ``/proc/kcore``.
* Tuy nhiên, kể từ **Linux Kernel** `2.6` trở lên (đặc biệt từ `2.6.36`), tùy chọn `CONFIG_STRICT_DEVMEM` đã hạn chế truy cập trực tiếp vào bộ nhớ vật lý để ngăn chặn tiến trình độc hại.
* Trên các `kernel` mới (`5.x+`), việc `dump` **RAM** cần sử dụng `module kernel` (`LiME`, `fmem`, `kdump`...) thay vì đọc trực tiếp từ file hệ thống.
### Trên kernel cũ (trước khi hạn chế ``/dev/mem``)
#### /dev/mem
* Cho phép truy cập trực tiếp vào bộ nhớ vật lý. Có thể `dump` bằng:
```py
sudo dd if=/dev/mem of=/path/to/dump.raw bs=1M
```
* **`if` (input file)**: `/dev/mem` – bộ nhớ vật lý.
* **`of` (output file)**: file `dump` cần lưu.
* **`bs` (block size)**: kích thước đọc, ví dụ `1MB`.
#### /proc/kcore
* ``/proc/kcore`` là một file giả lập đại diện cho bộ nhớ `kernel` (tương tự file core `dump`).
```py
sudo cp /proc/kcore /path/to/kcore.dump
```
* Nhược điểm:
* Chỉ áp dụng cho `kernel` cũ, dễ bị giới hạn quyền truy cập.
* Trên `kernel` mới, hai cách này thường không khả dụng hoặc `dump` không đầy đủ.
### Trên kernel mới (hiện đại)
* Trên các `kernel` **Linux** mới, `dump` **RAM** cần thông qua `kernel module` có quyền trong `kernel space`.
* Nguyên lý:
* Nạp module vào hệ thống (yêu cầu `root`).
* Module có thể đọc toàn bộ bộ nhớ vật lý.
* Dữ liệu được ghi ra file theo định dạng tùy chọn.
#### LiME (Linux Memory Extractor)
* [LiME Github](https://github.com/504ensicsLabs/LiME)
* Hoạt động bằng cách build module `lime.ko`, rồi nạp module để `dump` **RAM**.
```py
sudo insmod lime.ko "path=/path/to/dump.mem format=raw"
```
* `path`: đường dẫn file `dump`.
* `format`: có thể chọn
* `raw`: nối tất cả các vùng **RAM** hệ thống.
* `lime`: thêm `header` chứa thông tin địa chỉ bộ nhớ.
* `padded`: vùng **RAM** không dùng sẽ được điền 0.
* Lưu ý:
* Sau khi `make`, file module có thể bị đổi tên (ví dụ `lime-<version>.ko`).
* Trên bản **Linux** mới (như **Kali**), có thể cần build profile để phân tích bằng **Volatility**.
#### fmem
* Một `kernel` module khác để `dump` **RAM**, tạo ra thiết bị ``/dev/fmem``.
* Nạp module:
```py
sudo insmod fmem.ko
```
* Dump **RAM** bằng `dd`:
```py
sudo dd if=/dev/fmem of=dumpfile.raw bs=1M count=4096
```
* `count` giúp giới hạn dung lượng (`VD: 4096 MB = 4GB`).
* Nhược điểm:
* Nếu không dùng `count`, `fmem` khiến `dump` file tiếp tục ghi mãi → file có thể > **RAM** thực tế.
* Do đó luôn cần thêm tham số `count` để tránh `overflow`.
### So sánh nhanh các phương pháp
| Phương pháp | Kernel hỗ trợ | Ưu điểm | Nhược điểm |
| ------------- | -------------------------- | ------------------------------------------- | -------------------------------------- |
| `/dev/mem` | **Kernel** cũ (<2.6.36) | Đơn giản, không cần module | Bị hạn chế trên kernel mới |
| `/proc/kcore` | **Kernel** cũ | Dễ copy | Thường không đầy đủ, dễ bị chặn |
| `LiME` | **Kernel** mới (4.x, 5.x, 6.x) | Hỗ trợ phân tích forensics, nhiều định dạng | Cần build & nạp module |
| `fmem` | **Kernel** mới | Dễ dùng, tạo `/dev/fmem` | Có bug dump vô hạn, cần giới hạn count |
# Phân tích bộ nhớ với Volatility
## Volatility là gì?
* **Volatility** là `framework` mã nguồn mở dùng để phân tích bộ nhớ (`memory forensic`). Nó cho phép trích xuất thông tin chi tiết từ file `dump` **RAM**, như:
* Danh sách tiến trình (`process`, `thread`).
* **Module kernel**, **driver**.
* Kết nối mạng.
* File/**DLL** đang được nạp.
* **Registry** (`Windows`).
* **Volatility** hỗ trợ cả **Windows**, **Linux**, và **macOS**. Đây là công cụ cực kỳ phổ biến trong **Incident Response** và **Digital Forensics**.
## Tại sao có Volatility 3?
* **Volatility 2** được viết bằng **Python 2** (đã `end-of-life` từ 2020), nên gặp hạn chế:
* Khó bảo trì và mở rộng.
* Chậm khi phân tích bộ nhớ lớn.
* Cần `profile` riêng cho từng hệ điều hành/`kernel`.
* → **Volatility 3** được phát triển để giải quyết các vấn đề đó:
* Viết bằng **Python 3**, hiện đại, dễ mở rộng.
* Không cần `profile` thủ công (như **Vol2**).
* Dùng `symbol table` và tự động phân tích cấu trúc `kernel`.
* Tối ưu tốc độ, dễ tích hợp **CI/CD** trong các `pipeline` phân tích số lượng lớn.
* Tuy nhiên, số `plugins` của **Vol3** hiện chưa nhiều bằng **Vol2**, nên thực tế người ta thường cài song song cả **Vol2** và **Vol3** để tận dụng ưu điểm của cả hai.
## Cài đặt Volatility 2 và Volatility 3
* Trên **Kali**/**Ubuntu**, có thể cài song song. Có thể tham khảo [How to Install Volatility 2 and Volatility 3 on Debian, Ubuntu, or Kali Linux](https://seanthegeek.net/1172/how-to-install-volatility-2-and-volatility-3-on-debian-ubuntu-or-kali-linux/) nhaaa.
* Cái này cứ cài theo lệnh họ hướng dẫn là được á.
* Như này là được rồi nha:
* Còn với **Volatility 3**:
## Plugins
* Có thể tham khảo [Volatility cheatsheet](https://blog.onfvp.com/post/volatility-cheatsheet/) hoặc [Volatility foundation](https://downloads.volatilityfoundation.org/releases/2.4/CheatSheet_v2.4.pdf) nhaaa.
# Thực hành
* Lý thuyết nhiều thì cũng chán, ~~súc miệng~~ thử vài bài là biết có hiểu không ngay ấy mà :))
* Mọi người có thể tải bài tại https://github.com/stuxnet999/MemLabs
## MemLabs Lab 1 - Beginner's Luck
* **Description**:
* Đầu tiên, mình thử xác định hệ điều hành & profile.
* Với **Volatility 2**:
```python
python2 vol.py -f MemoryDump_Lab1.raw imageinfo
```
* Ta xác định được profile là `Win7SP1x64`, tiến hành phân tích tiếp.
* Mình thử liệt kê các tiến trình:
```py
vol.py -f MemoryDump_Lab1.raw --profile=Win7SP1x64 pslist
```
* Tuy nhiên đến đây mình vẫn chưa có hướng đi tiếp, chính xác hơn là mình chưa biết tiến trình nào ~~sú~~, mình có nhớ ra là chưa đọc **Description**.
* Mình thấy có 2 thứ có thể coi là hint. 1 là `black window pop up`, 2 là `When the crash happened, she was trying to draw something`. Vậy mình nghĩ có 2 tiến trình mà khả năng cao cần xem đầu tiên đó là `cmd.exe` và `mspaint.exe`.
* Đối với `cmd.exe`, mình thử xem `console output`:
```py
vol.py -f MemoryDump_Lab1.raw --profile=Win7SP1x64 consoles
```
* Hẹ hẹ, mút luôn cái `flag` đầu tiên.
* **Flag 1**: ||`flag{th1s_1s_th3_1st_st4g3!!}`||
* Mình nghĩ sau `console` thì có thể phân tích thêm `cmdline`:
```py
vol.py -f MemoryDump_Lab1.raw --profile=Win7SP1x64 cmdline
```
* Kiên nhẫn ngồi ~~đọc~~ 1 chút thì mình thấy **WinRar** khá sú:
* Sau khi `grep`, mình tìm thấy có 3 entry file **Important.rar**, mình `dump` hết ra luôn:
* Sau khi xem dạng file, mình thấy có 1 file **RAR** và 1 file **Bitmap**:
* File **Bitmap** có lẽ liên quan tới tiến trình `mspaint.exe` nên mình để sau, phân tích file **Rar** trước.
* Tuy nhiên khi mình giải nén thì nó đòi password:
* Cụ thể là nó yêu cầu pass là **NTLM** hash của **Alissa**. Có thể `dump` hash ra như sau:
```py
vol.py -f MemoryDump_Lab1.raw --profile=Win7SP1x64 hashdump
```
* Có được `F4FF64C8BAAC57D22F22EDC681055BA6` là password cần tìm òi, do nó yêu cầu `uppercase` á.
* Để mở ảnh có thể dùng `xdg-open flag3.png`.
* Có vẻ giải không đúng thứ tự rồi :))
* **Flag 3**: ||`flag{w3ll_3rd_stage_was_easy}`||
* Còn lại tiến trình `mspaint.exe`, đấm nốt nó nào. Như đã phân tích ở trên, tiến trình **WinRar** và 1 file **Bitmap** khá là sú.
* Mình thử mở nó xem thì không thấy gì:
* Thử grep thì cũng không có gì:
* Sau 1 hồi mình ~~thúc đít **chatGPT**~~ thì làm như sau, đổi file `2424.dmp` thành `2424.data` và ném vào **GIMP**.
* Sau 1 hồi ~~rất lâu~~ để chỉnh thì mình thấy như này:
* Ảnh bị ngược thì phải, và sau 1 hồi mò mò thì mình tìm được flag.
* **Flag 2: flag{G00d_BoY_good_girL}**
## MemLabs Lab 2 - A New World
* **Description**:
* Đầu tiên vẫn là phải xác định các `profile` và `process` quan trọng:
```py
vol.py -f MemoryDump_Lab2.raw imageinfo
```
* Đọc **Description** thì thấy có vẻ chúng ta nên quan tâm tới những tiến trình dạng như **browser**.
```py
vol.py -f MemoryDump_Lab2.raw --profile=Win7SP1x64 pslist
```
* Mình sẽ thử với `chrome.exe` trước:
* Thử `dump` nó ra và strings nhưng không có gì:
* Hơi bế tắc chút, và ẻm ~~GPT~~ gạ mình thử `dump` history thử.
* Cái cuối cuối trông sú đét, `dump` thử nó xem có gì không.
* Thấy có file **SQLite3** - **Chrome History** sú sú, mở thử nó xem.
* Trong tables **urls**, mình thấy có link `mega` đáng nghi.
* Wut thế nào lại tìm được miếng flag thứ 3 ngay đầu tiên :))
* Tải nó về và `unzip`:
* Nó nói pass là sha1 của flag thứ 3 lap 1.
* **Flag 3**: ||`flag{oK_So_Now_St4g3_3_is_DoNE!!}`||
* Phần còn lại mình lục lọi các thứ nhưng chẳng có gì, vậy chắc là `chrome.exe` không chứa thêm miếng flag nào nữa.
* Ngoài `chrome.exe` thì vẫn còn 1 thằng nữa đáng nghi là `Keepass`, có dạng `.kdbx`.
```py
vol.py -f MemoryDump_Lab2.raw --profile=Win7SP1x64 filescan | grep ".kdbx"
```
* Tuy nhiên muốn mở ``.kdbx`` → cần `master password`
* Tiến hành `dump` thử xem:
* Thực sự mấy bài này mình không có hướng làm lắm, nên nhờ **GPT** nó soi đường cho.
```py
strings 1064.dmp | grep -i password
```
* Wut ảnh mà lại tên là password ư. `Dump` ảnh ra thôi:
* Pass là `P4SSw0rd_123`, đây chắc là `master password` cần tìm:
```py
keepassxc file.None.0xfffffa8001593ba0.dat
```
* Mò 1 lúc thì thấy flag trong **Recycle Bin**:
* **Flag 2**: ||`flag{w0w_th1s_1s_Th3_SeC0nD_ST4g3_!!}`||
* Còn cái flag nữa, mình vọc lại thử cái **Description** thì có 1 chi tiết khá lmao:
`a very popular "environmental" activist`
* Khả năng cao là liên quan tới biến môi trường:
```py
python2 vol.py -f MemoryDump_Lab2.raw --profile Win7SP1x64 envars
```
* 1 hồi tìm ~~sưng mắt~~ thì mình để ý có cái này:
* **Flag 1**: ||`flag{w3lc0m3_T0_$T4g3_!_Of_L4B_2}`||
## MemLabs Lab 3 - The Evil's Den
* **Description**:
* Đầu tiên vẫn là xác định profile:
```py
python2 vol.py -f MemoryDump_Lab3.raw imageinfo
```
* Xem các tiến trình xem có gì không:
```py
vol.py -f MemoryDump_Lab3.raw --profile=Win7SP1x86_23418 pslist
```
* Để ý có 2 cái `notepad`:
```py
vol.py -f MemoryDump_Lab3.raw --profile=Win7SP1x86_23418 cmdline
```
```py
python2 vol.py -f MemoryDump_Lab3.raw --profile=Win7SP1x86_23418 dumpfiles -Q 0x000000003e727e50 --dump-dir ./dumps
python2 vol.py -f MemoryDump_Lab3.raw --profile=Win7SP1x86_23418 dumpfiles -Q 0x000000003de1b5f0 --dump-dir ./dumps
```
* Rất rõ ràng, code này mã hóa với input là chuỗi base64, đem xor với 3 và in kết quả vào `vip.txt`.
* Ngon, được miếng flag đầu tiên là `inctf{0n3_h4lf`.
* Đến với phần 2, thì mình loay hoay khá lâu và thấy ở **Desktop** có gì đó:
```py
vol.py -f MemoryDump_Lab3.raw --profile=Win7SP1x86_23418 filescan | grep "Desktop"
```
* Cái ảnh `suspision1.jpeg` trông có vẻ lmao đấy, `dump` thôi còn chần chờ gì nữa. ~~(Thực ra do tên nó sú thế kia cơ mà :))~~
```py
python2 vol.py -f MemoryDump_Lab3.raw --profile=Win7SP1x86_23418 dumpfiles -Q 0x0000000004f34148 --dump-dir ./dumps
```
* Tiếp theo thì extract nó ra xem. Nó đòi passphrase thì mình đọc lại **Description** thấy nói phải có `flag1` mới giải được tiếp, vậy `flag1` chính là passphrase.
* Ngon luôn, vậy đủ 2 miếng flag òi.
* **Flag: ||`inctf{0n3_h4lf_1s_n0t_3n0ugh}`||**
## MemLabs Lab 4 - Obsession
* **Description**:
* Cũng đã quen tay với 3 bài trước, mình lại đi xác định profile và process như thói quen.
```py
vol.py -f MemoryDump_Lab4.raw imageinfo
```
```py
vol.py -f MemoryDump_Lab4.raw --profile=Win7SP1x64 pslist
```
* Tuy nhiên chả có cái gì đáng nghi cả.
* Sau 1 thời gian chơi forensic nhất định, mình cảm thấy **Description** có thể là hint rất quan trọng, nhưng mình thường bỏ qua nó cho đến khi bế tắc :))
* Gợi ý có nói liên quan tới những file bị xóa, và ~~**GPT**~~ cũng khuyến khích mình dùng **MFT**.
```py
vol.py -f MemoryDump_Lab4.raw --profile=Win7SP1x64 mftparser > mft
```
* Tuy nhiên nó ra 1 mớ bùi nhùi như này, mình lướt thấy có rất nhiều luôn.
* Mình có thử grep mấy file mà các bài trước hay dùng, thì `important` được :))))
```py
grep -i "Important.rar" mft
```
* Dump file đó ra thì mình được flag.
```py
python2 vol.py -f MemoryDump_Lab4.raw --profile=Win7SP1x86_23418 mftparser | grep -i important -A 30
```
* **Flag**: ||`inctf{1_is_n0t_EQu4l_7o_2_bUt_th1s_d0s3nt_m4ke_s3ns3}`||
## MemLabs Lab 5 - Black Tuesday
* **Description**:
* Vẫn là check profile với process trước:
```py
vol.py -f MemoryDump_Lab5.raw imageinfo
```
```py
vol.py -f MemoryDump_Lab5.raw --profile=Win7SP1x64 pslist
```
* Trông 2 cái này sú đét:
```py
vol.py -f MemoryDump_Lab5.raw --profile=Win7SP1x64 cmdline
```
* Lmao, `notepad` này ở trong **Videos** :))
* **WinRar** còn có 1 file sú, mình sẽ `dump` hết nó ra.
```py
vol.py -f MemoryDump_Lab5.raw --profile=Win7SP1x64 filescan | grep "NOTEPAD.EXE"
vol.py -f MemoryDump_Lab5.raw --profile=Win7SP1x64 filescan | grep "SW1wb3J0YW50"
```
* Mình tính giải nén thì nó yêu cầu pass:
* Mình thử tất cả các plugins và dừng lại ở `screenshot`:
```py
vol.py -f MemoryDump_Lab5.raw --profile=Win7SP1x64 screenshot -D ./dumps
```
* Trong các ảnh, thì mình thấy `session_1.WinSta0.Default.png` nó không hoàn toàn màu trắng:
* Hẹ hẹ, có ngay cái flag.
* **Flag 1**: ||`flag{!!_w3LL_d0n3_St4g3-1_0f_L4B_5_D0n3_!!}`||
* **Flag 1** chính là pass để unzip cái file **WinRar** kia.
* Hẹ hẹ, được thêm cái flag thứ 2.
* **Flag 2**: ||`flag{W1th_th1s_$taGe_2_1s_c0mPL3T3_!!}`||
* Tới đây mình thấy bịp bịp, tại **Description** nói có 3 flag cơ, sao đây mới stage 2 mà final flag rồi. 🤷♂️
* Quên mất là còn `NOTEPAD.EXE` chưa sờ tới nó, mình thử `dump` xem có gì không.
* Wut, sao lại file **PE** nhỉ, à nó là **NOTEPAD.EXE** mà :))
* Ném vào **IDA** thử xem.
* Ngon mở ra có flag lun.
* **Flag 3**: ||`bi0s{M3m_l4B5_OVeR_!}`||
## MemLabs Lab 6 - The Reckoning
* **Description**:
* Vẫn là các thao tác quen thuộc, check profile và process:
```py
vol.py -f MemoryDump_Lab6.raw imageinfo
```
```py
vol.py -f MemoryDump_Lab6.raw --profile=Win7SP1x64 pslist
```
* **Description** gợi ý: `David communicated with his workers via the internet` khả năng là sú các browser, và có lẽ cả history nữa.
* Kiểm tra với `sqlite3`:
```py
sqlite3 file.None.0xfffffa800369c2f0.dat
```
* Sau 1 hồi ~~rất rất lâu~~ mò, thì mình thấy file [pastebin](https://pastebin.com/RSGSi1hk):
* Nó redirect mình sang 1 file `.doc`, đọc 1 hồi thì thấy có 1 file [mega](https://mega.nz/#!SrxQxYTQ):
* Âu dia :))
* Wut, biết kiếm đâu key giờ.
* Ơ string grep có này :))
* Giải nén và tải về thì được 1 file ảnh, nhưng lại không mở được.
* Ném vô **HxD** thì mình thấy chunk đầu tiên sai, cụ thể là `i` thay vì `I`:
* Vậy sửa lại cho đúng:
* Ý ngon đét :))
* Đến đây thì mình lại mò tiếp, sau 1 hồi thì mình thấy lại là **WinRar**:
```py
python2 vol.py -f MemoryDump_Lab6.raw --profile=Win7SP1x64 cmdline
```
* Sú này, `dump` nó ra hoi.
* Lại cần password nựa :v
* 1 lần nữa strings grep được :))
* Ấu dìa, có miếng flag còn lại òi.
* **Flag**: ||`inctf{thi5_cH4LL3Ng3!s_g0nn4_b3_?aN_Am4zINg!_i_gU3Ss???}`||
# Refs
https://hackmd.io/@phgvee/rywrwpwq6
Sign in with Wallet
Connect another wallet