# Wargames (Trò chơi chiến tranh)
## Bandit (Kẻ cướp)
### Level 0
Kết nối máy chủ
- `ssh` : Lệnh để kết nối đến máy chủ từ xa qua giao thức SSH.
- `-p 2220` : Chỉ định cổng 2220 (vì SSH mặc định dùng cổng 22, nhưng game này sử dụng cổng 2220).
## `ssh [e-mail] -p 2220`
### Level 0 → Level 1
- Tìm file chứa mật khẩu: `ls` (viết tắt của "list")
- Đọc nội dung file `readme`: `cat readme` (viết tắt của "concatenate")
### Level 1 → Level 2
Do file có tên là ``-``, bạn không thể trực tiếp dùng lệnh ``cat -`` vì hệ thống sẽ hiểu ``-`` là tham số thay vì tên file. Để đọc nội dung của file, bạn có thể sử dụng cách sau: `cat ./-`
Giải thích về ``./`` :
- ``./`` giúp bạn tham chiếu đến các file hoặc thư mục trong thư mục hiện tại.
- Nó cũng được sử dụng để chạy các file có trong thư mục hiện tại mà không bị nhầm lẫn với các lệnh hệ thống.
### Level 2 → Level 3
`Cách 1`: Dùng dấu ``\`` (escape character)
- Dấu ``\`` được sử dụng để escape (thoát) khoảng trắng, nghĩa là nó báo cho hệ thống biết khoảng trắng này là một phần của tên file chứ không phải là dấu phân tách giữa các đối số.
## `cat spaces\ in\ this\ filename`
`Cách 2`ls: Dùng dấu nháy đơn hoặc nháy kép
- Bạn có thể đặt toàn bộ tên file trong dấu nháy đơn ``(')`` hoặc dấu nháy kép ``(")`` để giúp hệ thống hiểu rằng tất cả các ký tự bên trong là một phần của tên file.
### Level 3 → Level 4
Bước 1: Kiểm tra thư mục inhere có tồn tại không: `ls`
Bước 2: Vào thư mục inhere: `cd inhere`
- Bạn không thể chạy lệnh cat inhere vì inhere là một thư mục, không phải file.

Bước 3: Hiển thị danh sách file (kể cả file ẩn): `ls -a`
Bước 4: Đọc nội dung file ẩn:
### Level 4 → Level 5
Bước 1: Kiểm tra thư mục inhere có tồn tại không: `ls`
Bước 2: Vào thư mục inhere: `cd inhere`
- Kiểm tra danh sách file trong thư mục `inhere`

Bước 3: Kiểm tra kiểu file: `file ./*`
Bước 4: Đọc nội dung file chứa mật khẩu: `cat ./-file07`
- File `-file07` là dạng ASCII text, nghĩa là có thể đọc được!

Lệnh file * giúp kiểm tra loại nội dung của tất cả các file trong thư mục hiện tại.

file: Dùng để xác định kiểu dữ liệu của một file.

* (dấu sao): Là wildcard (ký tự đại diện), có nghĩa là chọn tất cả các file trong thư mục.
### Level 5 → Level 6
- Di chuyển vào thư mục inhere: `cd inhere`
- Tìm file phù hợp với tiêu chí:
Sử dụng lệnh find để tìm file có kích thước 1033 bytes, có thể đọc được, và không thực thi:
`find . -type f -size 1033c ! -executable`
- Giải thích:
``.`` → Tìm trong thư mục hiện tại (inhere).
``-type f`` → Chỉ tìm file (không tìm thư mục).
``-size 1033c`` → Tìm file có đúng 1033 bytes (c là đơn vị byte).
``! -executable`` → Lọc ra các file không thể thực thi.
### Level 6 → Level 7
Yêu cầu đề bài :
- owned by user bandit7
- owned by group bandit6
- 33 bytes in size

Dùng lệnh :
- `find / -type f -user bandit7 -group bandit6 -size 33c 2>/dev/null`
-`find /` Tìm từ thư mục gốc ``/`` (toàn bộ hệ thống).
-`type f` Chỉ tìm file, bỏ qua thư mục.
-`user bandit7` Chỉ tìm file thuộc sở hữu của user bandit7.
-`group bandit6` Chỉ tìm file thuộc sở hữu của group bandit6.
-`size 33c` Chỉ tìm file có kích thước 33 byte.
-`2>/dev/null` Bỏ qua các lỗi "Permission denied".
### Level 7 → Level 8
- Liệt kê các tệp trong thư mục hiện tại để xác nhận sự tồn tại của data.txt: `ls`
- Sử dụng lệnh `grep` để tìm kiếm dòng chứa từ ``"millionth"``:
- Trong hệ điều hành Unix và Linux, lệnh `grep` được sử dụng để tìm kiếm các mẫu văn bản trong tệp tin hoặc đầu vào. Tên grep là viết tắt của cụm từ ``"Global Regular Expression Print"``.
- Giải thích các thành phần của tên gọi:
-`Global`: Tìm kiếm trên toàn bộ nội dung.
-`Regular Expression`: Sử dụng biểu thức chính quy để xác định mẫu tìm kiếm.
-`Print`: In ra các dòng khớp với mẫu tìm kiếm.
### Level 8 → Level 9
- Liệt kê các tệp trong thư mục hiện tại để xác nhận sự tồn tại của data.txt: `ls`
- Sử dụng kết hợp các lệnh `sort` và `uniq` để tìm dòng duy nhất:
-`sort data.txt`: Sắp xếp các dòng trong tệp data.txt.
-``| (pipe)``: Chuyển đầu ra của lệnh sort làm đầu vào cho lệnh tiếp theo.
-`uniq -u`: Hiển thị các dòng chỉ xuất hiện một lần trong đầu vào nhận được.
### Level 9 → Level 10
- Trích xuất các chuỗi có thể đọc được từ tệp data.txt: `strings data.txt`
- Lọc các chuỗi bắt đầu bằng dấu '=': `grep =`
### Level 10 → Level 11
- Bước 1: Xem nội dung file `cat data.txt`
- Bước 2: Giải mã base64 để lấy nội dung thật `base64 -d data.txt`
-`base64`: lệnh dùng để mã hóa hoặc giải mã base64.
-``-d``: viết tắt của decode → yêu cầu giải mã.
-`data.txt`: chính là file chứa chuỗi base64.
### Level 11 → Level 12
- Bước 1: Xem nội dung file `cat data.txt`
- Bước 2: Giải mã ROT13 `cat data.txt | tr 'A-Za-z' 'N-ZA-Mn-za-m'`
-`tr` là ``“translate”``, lệnh thay thế ký tự.
-Cú pháp `tr` 'from' 'to'
`A B C D E F G H I J K L M N O P Q R S T U V W X Y Z`
``↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓``
`N O P Q R S T U V W X Y Z A B C D E F G H I J K L M`
-Chữ cái từ A đến Z có 26 ký tự.
Để thực hiện xoay 13 ký tự (`ROT13`), bạn phải viết `TO` theo thứ tự bắt đầu từ `N → Z`, sau đó quay lại `A → M`.
### Level 12 → Level 13
- Tệp `data.txt` là `hexdump` của một tệp đã bị nén nhiều lớp bằng các định dạng
- Bạn cần giải mã từng lớp, đến khi tìm được dòng chứa `The password is ...`
- Bước 1: Tạo thư mục tạm và copy file vào: `mkdir /tmp/bandit12tmp`
-📙 `mkdir`: viết tắt của `make directory` → tạo thư mục
-🧠 ``/tmp`` là nơi chứa các file tạm → ta làm việc ở đây cho gọn
-Copy file data.txt vào thư mục làm việc: `cp data.txt /tmp/bandit12tmp`
-Di chuyển vào thư mục mới để làm việc tiếp: `cd /tmp/bandit12tmp`
- Bước 2: Chuyển từ hexdump về file nhị phân (binary)
1. ``Trước tiên: Hexdump là gì?``
-`data.txt` chứa `hexdump` – nghĩa là một bản “dịch mã” của file nhị phân sang dạng chữ để dễ đọc và lưu trữ.
2. Ví dụ một đoạn hexdump có thể trông như:
-`0000000: 1f8b 0800 0000 0000 0003 edd3 b16e c320 ... ← dòng này là dạng HEX`
-Đây là dữ liệu nhị phân (bị nén, mã hóa...) đã được chuyển sang dạng chữ (hex) để lưu trong file data.txt.

👉 Muốn làm gì đó với nó (giải nén, đọc nội dung...), bạn phải chuyển nó lại về file gốc.

3. Lệnh sử dụng: `xxd -r data.txt data`
-``📙 xxd``: công cụ tạo hoặc đảo chiều hex dump
-``-r = reverse`` → chuyển ngược từ hex về file gốc
-🎯 Giờ bạn có file mới tên data chứa nội dung nhị phân thật sự (đã được nén)
- Bước 3: Kiểm tra loại file data để biết cách giải nén
1. Kiểm tra file data : File data vẫn là một file nén gzip
2. Đổi tên để dễ giải nén : Bây giờ hệ thống sẽ hiểu là file gzip
3. Giải nén lớp gzip tiếp theo : File data.gz biến mất, file data mới xuất hiện
4. Kiểm tra kiểu file tiếp theo : `data: bzip2 compressed data, block size = 900k`
- ... cứ theo công thức giải nén thì sẽ tìm được mật khẩu.
### Level 13 → Level 14
- Bước 1: Kiểm tra file đang có: `ls` -> `sshkey.private`
- Bước 2: Đăng nhập vào bandit14 bằng SSH key: `ssh -i sshkey.private bandit14@localhost`
- ``-i`` là viết tắt của: `identity file` = "file định danh". Tức là file chứa khóa riêng (private key) để xác thực danh tính khi bạn đăng nhập.
- Bước 3: Đọc mật khẩu: `cat /etc/bandit_pass/bandit14`
-``/etc/bandit_pass/bandit14`` Là nơi chứa mật khẩu cho level 14, được hệ thống Bandit tạo sẵn
-Khi bạn dùng SSH để đăng nhập vào user bandit14, bạn đã có quyền đọc file này, nhưng chỉ user bandit14 mới có quyền đọc nó (không phải bandit13)
### Level 14 → Level 15
- Kết quả của lệnh cat chính là mật khẩu bandit14
- Bạn lấy kết quả đó, rồi dùng:
-`echo [kết_quả_cat] | nc localhost 30000`
-Hệ thống Bandit đã mở một chương trình đang chạy ở cổng 30000
-Nó chờ bạn gửi đúng mật khẩu của bandit14 vào
-Nếu đúng ⇒ Nó trả về mật khẩu của bandit15
### Level 15 → Level 16
- Mục tiêu đề bài: `Gửi mật khẩu cấp hiện tại (bandit15) đến cổng 30001 trên localhost (máy hiện tại) qua kết nối mã hóa SSL/TLS, để nhận lại mật khẩu cho bandit16.`
- Bước 1: Xem lại mật khẩu bandit15: `cat /etc/bandit_pass/bandit15`
- Bước 2: Gửi mật khẩu đến port 30001 qua SSL/TLS
### Level 16 → Level 17
- BƯỚC 1: Tìm cổng đang mở trong phạm vi 31000–32000: `nmap -p31000-32000 localhost`
-`nmap`: Network Mapper, công cụ quét cổng.
-``-p31000-32000``: chỉ định dải cổng.
-`localhost`: máy hiện tại (127.0.0.1).
- BƯỚC 2: Kiểm tra xem cổng nào dùng SSL/TLS: `openssl s_client -connect localhost:31518`
-`openssl`: bộ công cụ mã hóa
-`s_client`: dùng để kết nối thử SSL
-``-connect``: kết nối tới địa chỉ + cổng
-Các cổng bị lỗi sẽ hiện những dòng như là : `wrong version number` ; `unexpected message`
-Nếu nó hiện ra rất nhiều dòng bắt đầu bằng `CONNECTED`, `Certificate`, `SSL handshake...` → là cổng SSL.
-Nếu có nhiều cổng đúng thì đối chiếu lại với phần này được ghi trong đề bài: `Chỉ có 1 máy chủ sẽ cung cấp thông tin xác thực tiếp theo, các máy chủ khác sẽ chỉ gửi lại cho bạn bất cứ thông tin nào bạn gửi đến máy chủ đó.`
- BƯỚC 3: Kết nối đến máy chủ SSL hợp lệ và lấy private key
-Dùng lệnh: ``ncat --ssl localhost:31790``
- BƯỚC 4: Lưu private key vào một file tạm
-Dùng lệnh: `nano /tmp/bandit17.key`
-Dòng `nano /tmp/bandit17.key` giúp bạn:
+Tạo file mới (hoặc mở nếu đã tồn tại).
+Dán nội dung key vào để sau này dùng với `ssh -i`.
-Tiếp đó ta phân quyền an toàn cho khóa riêng (Private Key): `chmod 600 /tmp/bandit17.key` bởi vì:
+SSH sẽ bảo vệ private key rất nghiêm ngặt. Nếu file key có quyền truy cập quá "mở" (ai cũng xem được), SSH sẽ từ chối dùng nó. Nếu bạn không chạy `chmod 600`, bạn sẽ bị lỗi: `Permissions 0644 for 'bandit17.key' are too open.`
- BƯỚC 5: Dùng khóa riêng để SSH vào bandit17
-`ssh -i /tmp/bandit17.key [e-mail] -p 2220`
### Level 17 → Level 18
- MỤC TIÊU:
Tìm dòng khác nhau giữa 2 tệp `passwords.old` và `passwords.new`. Dòng bị thay đổi chính là mật khẩu cho level tiếp theo.
- BƯỚC 1: Liệt kê các tệp trong thư mục hiện tại: `ls`
- BƯỚC 2: So sánh nội dung 2 tệp
- Dòng ở `passwords.new` là dòng bạn cần lấy!
### Level 18 → Level 19
- Dùng lệnh: `ssh -T [e-mail] -p 2220`.
- Dùng `cat` đọc file `readme` để lấy mật khẩu.
- ``-T`` trong SSH, được dùng để vô hiệu hóa môi trường `pseudo-terminal` khi kết nối đến máy chủ từ xa. Điều này hữu ích khi bạn muốn chạy lệnh mà không cần giao diện tương tác.
- Tắt `pseudo-tty` với tùy chọn ``-T`` có ích trong bài `Bandit Level 18 → Level 19` vì nó cho phép bạn chạy một lệnh trên máy chủ từ xa mà không cần mở một terminal tương tác (TTY). Điều này giúp tránh việc ``.bashrc`` tự động đăng xuất khi bạn đăng nhập vào shell.
### Level 19 → Level 20
- Bước 1: Kiểm tra thư mục home của `bandit19`: `ls -l /home/bandit19/`
-Kết quả bạn sẽ thấy tệp bandit20-do: `-rwsr-x--- 1 bandit20 bandit19 14880 Sep 19 2024 bandit20-do`
-Trong đó, `rws` ở quyền của chủ sở hữu tệp (`bandit20`) cho biết tệp có quyền `setuid`, tức là chương trình sẽ chạy dưới quyền của người sở hữu tệp (ở đây là bandit20).
- Bước 2: Kiểm tra tệp bandit20-do: `file bandit20-do`
-Kết quả: `bandit20-do: setuid ELF 32-bit LSB executable`, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 3.2.0, not stripped
-Điều này cho biết tệp `bandit20-do` là một `tệp nhị phân thực thi` với quyền setuid. Chương trình này sẽ thực thi dưới quyền của người sở hữu tệp (`bandit20`).
- Bước 3: Chạy tệp bandit20-do: `./bandit20-do cat /etc/bandit_pass/bandit20`
-``./bandit20-do``: Chạy tệp bandit20-do dưới quyền của bandit20 nhờ quyền setuid.
-`cat /etc/bandit_pass/bandit20`: Lệnh này sẽ đọc nội dung tệp mật khẩu của bandit20, tệp này chứa mật khẩu cần thiết để bạn tiến lên Level 20.
### Level 20 → Level 21
- Bước 1. Gửi mật khẩu qua nc: `echo "0qXahG8ZjOVMN9Ghs7iOWsCfZyXOUbYO" | nc -l localhost 33001`
-``-l``: Lắng nghe kết nối đến trên một cổng nhất định.
-`33001`: Số cổng nơi Netcat lắng nghe. Cổng này được chỉ định để chương trình suconnect kết nối tới.
- Bước 2. Chạy chương trình `suconnect`:
-``./suconnect``: Chạy chương trình nhị phân suconnect (setuid binary) từ thư mục hiện tại.
-`33001`: Số cổng mà suconnect sẽ kết nối tới localhost.
-Ngoài ra trong code còn lệnh ``^Z`` và `bg` để chạy một lệnh khác trong terminal chính.
### Level 21 → Level 22
- Di chuyển đến thư mục `cron job`: ``cd /etc/cron.d/``.
- Liệt kê tệp cron job và kiểm tra nội dung: `ls` và `cat cronjob_bandit22`.
- Xem nội dung script liên quan: `cat /usr/bin/cronjob_bandit22.sh`.
- Truy cập tệp lưu mật khẩu: `cat /tmp/t706lds9S0RqQh9aMcz6ShpAoZKF7fgv`.
### Level 22 → Level 23
- Đề vẫn yêu cầu ta vào thư mục `etc/cron.d/` để xem có những gì.
- Bước 1: Xem cron job
- Bước 2: Phân tích script `cronjob_bandit23.sh`
-script `cronjob_bandit23.sh` có nhiệm vụ sao chép mật khẩu của `Level 23` vào một tệp trong thư mục ``/tmp/``, nhưng cái tên của tệp đó được mã hóa để khó đoán. Dưới đây là cách script hoạt động, từng bước một:
+Script kiểm tra xem ai đang chạy nó bằng lệnh `whoami` (trả về tên người dùng hiện tại, ví dụ: `bandit23`). Kết quả được lưu vào biến `myname`.
+Tạo tên tệp bí mật: Lấy chuỗi ``"I am user bandit23"`` (thay ``$myname`` bằng `bandit23`). Sử dụng hàm `md5sum` để băm (hash) chuỗi này thành một giá trị duy nhất (một chuỗi ký tự dài 32 ký tự). Dùng `cut` để chỉ lấy phần mã băm, bỏ phần dư thừa.
### Level 23 → Level 24
- Đề vẫn yêu cầu ta vào thư mục `etc/cron.d/` để xem có những gì.
- Giải thích nội dung của file ``/usr/bin/cronjob_bandit24.sh``
-Biến `myname` sẽ có giá trị là `bandit24`, vì `cronjob` này được chạy bởi `user bandit24`.
-`cd /var/spool/$myname/foo`: Đây là thư mục mà `script` của bạn phải được copy vào nếu muốn được thực thi bởi `cronjob`.
-``"$owner" = "bandit23"``: Nếu file được sở hữu bởi bandit23, thì mới được chạy. Đây là lý do tại sao file bạn tạo phải là của bạn (`bandit23`) – nếu bạn đổi quyền sở hữu hoặc copy từ nơi khác mà không giữ quyền này, thì `cronjob` sẽ bỏ qua không thực thi.
- Tổng hợp lại: Bạn (`user bandit23`) sẽ tạo `script` và `cronjob` sẽ chạy dưới `user bandit24`. Do đó, quyền sở hữu file của bạn cần phải là `bandit23` để `cronjob` có thể thực thi.
- Bước 1: Tạo 1 file script (do bạn sở hữu):

Nội dung:
#!/bin/bash
cat /etc/bandit_pass/bandit24 > /tmp/pass24

Giải thích:
1. /etc/bandit_pass/bandit24 là file mình không thể đọc
được nên mình chuyển dữ liệu sang một file có sẵn, file
mình có thể đọc được là /tmp/pass24  
2. Lý do mình không chuyển dữ liệu sang /var/spool/bandit24/foo
để cronjob đọc cho nhanh bởi vì lý do ở ảnh ngay phía dưới:

- Bước 2: Cấp quyền thực thi:

Nội dung:
chmod +x scrip.sh

Giải thích:
1. chmod: lệnh thay đổi quyền truy cập file.
2. +x: thêm quyền thực thi (execute).
3. scrip.sh: tên file bạn đang áp dụng lệnh lên.
" x - execute - Chạy file như chương trình/script - Truy cập vào thư mục "

- Bước 3: Đặt nó vào đúng nơi cron job kiểm tra:

Nội dung:
cp scrip.sh /var/spool/bandit24/foo

1. Cron job được thiết lập trong /etc/cron.d/ sẽ tự
động chạy bất kỳ file nào tại /var/spool/bandit24/.
2. Nhưng chỉ chạy file nếu:
-Chủ sở hữu là bandit23 (bạn)
-File có quyền thực thi (+x)
-File không bị xóa mất (do hệ thống hoặc do bạn tạo sai)

- Bước 4: Đọc kết quả:

cat /tmp/pass24

### Level 24 → Level 25
- Mục tiêu:
``Cung cấp mật khẩu cho Bandit 25 thông qua việc brute-force mã PIN (4 chữ số) kết hợp với mật khẩu của Bandit 24.``
- Bước 1: Tạo và chỉnh sửa `script brute-force`: `vim /tmp/brute.sh`

-Nội dung:

#!/bin/bash
PASSWORD="gb8KRRCsshuZXI0tUuR6ypOFjiZbf3G8"
for i in $(seq -w 0000 9999); do
  echo "$PASSWORD $i"
done | nc localhost 30002

-`PASSWORD="gb8KRRCsshuZXI0tUuR6ypOFjiZbf3G8"` : Đoạn này định nghĩa một biến có tên `PASSWORD` và gán giá trị chuỗi ``"gb8KRRCsshuZXI0tUuR6ypOFjiZbf3G8"``. Đây là mật khẩu cần phải sử dụng trong quá trình gửi yêu cầu tới `máy chủ`.

-`for i in $(seq -w 0000 9999); do` : Dòng này khởi tạo một `vòng lặp for`, trong đó biến ``i sẽ nhận giá trị từ dãy số 0000 đến 9999.`` `seq -w 0000 9999` tạo ra dãy số từ 0000 đến 9999, với dấu ``-w`` đảm bảo rằng tất cả các số sẽ có `độ dài 4 ký tự`, ví dụ: 0000, 0001, ..., 9999. Vòng lặp sẽ lặp qua tất cả các giá trị này, và mỗi lần lặp i sẽ nhận giá trị tiếp theo trong dãy số.

-`echo "$PASSWORD $i"` : Lệnh echo sẽ in ra một chuỗi bao gồm mật khẩu và số i trong mỗi lần lặp. Ví dụ, lần lặp đầu tiên sẽ in ra: ``"gb8KRRCsshuZXI0tUuR6ypOFjiZbf3G8 0000"``, lần lặp tiếp theo là: ``"gb8KRRCsshuZXI0tUuR6ypOFjiZbf3G8 0001"``, và cứ thế tiếp tục.

-`done | nc localhost 30002` : Sau khi vòng lặp hoàn thành, tất cả các chuỗi đã in ra sẽ được truyền vào lệnh ``nc (Netcat)`` thông qua ``pipe (|)``. `nc localhost 30002` kết nối đến máy chủ localhost tại cổng 30002. Mỗi chuỗi mật khẩu và số sẽ được gửi vào cổng này.
- Bước 2: Cấp quyền thực thi cho script:
`chmod +x /tmp/brute.sh`
- Bước 3: Chạy script brute-force:
`/tmp/brute.sh`
### Level 25 → Level 26 + Level 26 → Level 27
- `Bước 1: Thông tin ban đầu`
1. Người dùng nhập lệnh `ls` và nhận được kết quả hiển thị tệp `bandit26.sshkey`, đây là một `tệp khóa SSH`.
2. Thực hiện kết nối SSH: `ssh -i bandit26.sshkey -p 2220 bandit26@localhost` => `Ngay lập tức bạn bị thoát khỏi phiên SSH.` Đó là vì:

-``🔐`` `Shell` mặc định của `user bandit26` không phải là ``/bin/bash``, mà là một chương trình khác, thường dùng để `hạn chế` truy cập shell, và trong bài này, nó là một shell tùy biến (custom shell) được viết ra để kiểm soát bạn.
-``✅`` Mục tiêu của level: Tìm cách `thoát khỏi shell` hạn chế đó và truy cập được vào một `shell thật sự` (bash, sh,...) để lấy mật khẩu cấp tiếp theo.
- `Bước 2: Xem shell mặc định của bandit26`
1. `cat /etc/passwd | grep bandit26`:
-``/etc/passwd``: Đây là một file hệ thống chứa thông tin về tất cả người dùng.
-Tệp ``/etc/passwd`` thường chứa danh sách tất cả người dùng trên hệ thống, nhưng với lệnh `grep`, bạn chỉ lọc ra thông tin cụ thể liên quan đến `bandit26`.
-`bandit26:x:...:/home/bandit26:/usr/bin/showtext`: Vậy chương trình `showtext` là shell của bandit26.
2. Kiểm tra nội dung file showtext:
-Lệnh: `cat /usr/bin/showtext`
-Mục đích: Đọc nội dung của file script shell ``/usr/bin/showtext``

#!/bin/sh
export TERM=linux
exec more ~/text.txt
exit 0

-Đây là một script đơn giản, mục tiêu chính là hiển thị nội dung của tệp text.txt theo cách dễ đọc (từng trang) khi được gọi. Nó thường được dùng để kiểm soát đầu ra và giúp người dùng xem nội dung mà không cần cuộn nhanh.
- `Bước 3: Thu nhỏ cửa sổ terminal`
-Ép `terminal` lại tầm khoảng bằng `1/9 terminal` gốc bằng cách kéo các cạnh thu hẹp lại. Điều này dẫn đến việc lúc máy chủ in ra thông tin sẽ không hiển thị ra hết được, dẫn đến việc xuất hiện dòng ``more 83%`` (hoặc khác). Nghĩa là bạn đã xem được ``83%`` nội dung của file, còn ``17%`` nội dung chưa hiển thị. Vì là chưa hiển thị hết nội dung nên không thể bị thoát khỏi phiên SSH nữa giống như `bước 1`.Dưới đây là ví dụ và nội dung các nguồn mà tôi đã tìm hiểu được :
1. Kết nối SSH giống như `bước 1`
-Khi `more` hiện ra → ấn phím `v`. `more` sẽ mở chương trình `vi` hoặc `vim`. Bạn sẽ thấy giao diện giống trình soạn thảo văn bản.
-Trong `vim`, gõ lệnh:

:set shell=/bin/bash (nhấn enter rồi tiếp tục gõ)
:shell

-``:set shell=/bin/bash`` Đổi shell dùng khi thoát tạm từ vim
-``:shell`` Mở một shell mới dưới quyền bandit26
-Khi SSH vào bandit26, bạn bị nhốt trong chương trình showtext, không thể gõ lệnh. Nhưng nếu nhấn v → vào được vim. Tóm lại: Dùng vim để vượt qua shell giới hạn và truy cập được shell thật.
-Chúng ta lợi dụng `vim` (được chạy bởi bandit26) để mở một ``terminal (shell)`` với quyền `bandit26`. Mở được shell này xong, bạn sẽ xem được mật khẩu ở ``/etc/bandit_pass/bandit26``.
(`v trong more → mở vim`: Những thứ này được ghi lại trong tài liệu sử dụng chính thức và kinh nghiệm thực hành từ cộng đồng. Đều được rút ra từ kinh nghiệm thực chiến + kiến thức về hệ thống Unix/Linux.)

bandit25 ➜ chạy showtext (SUID bandit26)
              ➜ gọi "more ~/text.txt"
                    ➜ dùng trick để vào vim
                          ➜ trong vim gõ :shell
                                ➜ được một bash shell của bandit26

2. Kết nối thành công
- Khi bạn dùng ``:shell`` trong vim, bạn vẫn đang ở shell, nhưng:
-Là shell "tạm thời".
-Không hiện màu xanh hoặc hostname như shell SSH thông thường.
-Nhưng vẫn có quyền `bandit26`, vì vim được mở bởi chương trình showtext có gắn SUID.
- Tức vẫn là `bandit26` nhưng ở một shell "đặc biệt", không phải shell như thông thường thôi. Bạn có thể gõ `cat /etc/bandit_pass/bandit26` → Lấy password sau đó exit ra và nhập mật khẩu làm bài tiếp theo. Nhưng tôi tận dụng shell này làm luôn bandit `26-27` vì nó cũng khá là dễ.
- Bước 1: Kiểm tra file trong thư mục: Hiện ra 2 file: `text.txt` và `bandit27-do`.
- Bước 2: Chạy chương trình `bandit27-do`: Từ nội dung hiển thị tức là bạn có thể chạy lệnh dưới quyền `bandit27`!
- Bước 3: Chạy lệnh để lấy mật khẩu: `./bandit27-do cat /etc/bandit_pass/bandit27`
Kết quả: `upsNCc7vzaRDx6oZC6GiR6ERwe1MowGB`
### Level 27 → Level 28
- Bước 1: Tạo thư mục làm việc tạm và di chuyển vào đó

mkdir /tmp/bandit27-28
cd /tmp/bandit27-28

-Tạo thư mục tạm trong ``/tmp``: Đây là thư mục dùng để lưu trữ các file tạm thời, `không ảnh hưởng đến các file hệ thống` hoặc các thư mục quan trọng khác.
-Lý do tạo thư mục tạm: Giúp bạn làm việc sạch sẽ, dễ dàng quản lý và xóa bỏ sau khi xong công việc mà `không làm ảnh hưởng đến môi trường làm việc chính`. Ngoài ra, thư mục /tmp giúp bạn `tránh gặp phải các vấn đề về quyền truy cập` khi làm việc trong các thư mục khác.
- Bước 2: `Clone Git` repository từ server

git clone ssh://bandit27-git@localhost:2220/home/bandit27-git/repo

-`git clone`: Lệnh này giúp bạn `sao chép repository` từ server về thư mục hiện tại.
-`Cổng 2220`: Bandit yêu cầu kết nối SSH qua cổng này. Vì vậy, bạn cần chỉ định đúng cổng khi `clone repo` bằng cách thêm phía trước `localhost` là `:2220`, tránh bị lỗi như mình khi kết nối ở `bước 1` và nhận `cảnh báo` như trên.
-Lệnh này sẽ yêu cầu bạn nhập mật khẩu cho người dùng `bandit27-git`, mật khẩu này giống với mật khẩu của `bandit27`.
- Sau khi `clone repo` thành công, bạn cần di chuyển vào thư mục repo để làm việc. Repo sẽ được lưu dưới thư mục repo, và bạn cần vào trong đó để kiểm tra các file.
- Cứ làm từng bước đơn giản như phía dưới ảnh thì sẽ dễ dàng tìm được mật khẩu và tiến tới cấp độ tiếp theo ...
### Level 28 → Level 29
- Làm các bước giống như bài `27 -> 28`.
- Ta thấy có `file README` — giống như bài Level `27 → 28`.
- Thấy rằng đây là 1 tệp chứa thông tin `password` đã bị che đi.
- Xem lịch sử commit kèm theo phần thay đổi chi tiết của từng commit (`diff`): `git log -p`
-`git log`: hiển thị `danh sách các commit` (lịch sử commit).
-``-p``: viết tắt của “`patch`” → thêm phần `thay đổi cụ thể` trong từng commit, tức là bạn sẽ thấy dòng nào được thêm vào hoặc xóa đi trong từng file.

+ Thêm dòng mới
- Xóa dòng cũ

- Phần `--` là phần bị thay đổi, là password ban đầu.
- Phần `+-` là phần được thêm vào, là password hiện tại.
### Level 29 → Level 30
- Làm các bước giống như bài trước
- Tiếp tục đọc file `README` thấy: `password: <no passwords in production!>`. Password không ở môi trường `production` thì khả năng nó sẽ nằm ở một môi trường khác.
- Bước 1: Kiểm tra các nhánh có sẵn trong Git repo: `git branch -a`
-`git branch` : Dùng để xem các nhánh (branch) trong Git. Mỗi nhánh là một “bản sao” của mã nguồn để làm việc riêng biệt.
-``-a`` : Viết tắt của all (tất cả). Hiển thị cả:
_____Nhánh cục bộ (trên máy mình).
_____Nhánh từ xa (trên server).
-`remotes/origin/master` (nhánh mặc định)
-`Nhận xét`: Có nhánh `dev` đáng chú ý, cần kiểm tra.
- Bước 2: Chuyển sang nhánh `dev`: `git checkout dev` : Git tự động thiết lập để theo dõi nhánh origin/dev.
- Bước 3: Kiểm tra nội dung thư mục repo sau khi chuyển nhánh. Làm theo các bước như ảnh dưới đây:
### Level 30 → Level 31
- Tiếp tục `git clone` về và xem thử
- Bước 1: Tạo thư mục tạm và truy cập repo:
-Tạo thư mục ``/tmp`` để làm việc an toàn.
-Vào thư mục repo chứa `Git project` sau khi clone thành công.
- Bước 2: Đọc nội dung file README.md: `cat README.md`
-Kết quả: `just an empty file… muahaha`.
-Tệp trông như "`rỗng`" nhưng có thể ẩn nội dung ở nơi khác (ví dụ: ``tag, commit cũ...``).
- Bước 3: Kiểm tra nhánh hiện có: `git branch -a`
-Kết quả: Chỉ thấy `master` và `origin/master`
→ Không có nhánh ẩn nào đặc biệt.
- Bước 4: Kiểm tra các tag: `git tag`
-Kết quả: Thấy một tag tên là `secret`
- Bước 5: Xem nội dung tag ``"secret"``: `git show secret`
-Kết quả: `fb5S2xb7bRyFmAvQYQGEqsbhVyJqhnDy`
### Level 31 → Level 32
- Tiếp tục `git clone` về và xem thử
- `Bước 1`: Tạo thư mục tạm và truy cập repo:
-Tạo thư mục ``/tmp`` để làm việc an toàn.
-Vào thư mục repo chứa `Git project` sau khi clone thành công.
- `Bước 2`: Đọc nội dung file README.md: `cat README.md`
-Kết quả:

This time your task is to push a file to the remote repository.
Details:
File name: key.txt  
Content: "May I come in?"  
Branch: master

-Lần này, nhiệm vụ của bạn là ``đẩy (push)`` một tệp lên remote `Git repository` (kho chứa Git từ xa).
-👉 Đây là bước nâng cấp so với các bài trước chỉ là clone hay checkout.
- `Bước 3`: Tạo và xác nhận tệp tin
-Tạo tệp tin và thêm nội dung: Sử dụng lệnh `echo "May I come in?" > key.txt` để tạo tệp `key.txt` và thêm nội dung vào.
-Sao chép tệp tin vào thư mục dự án: Sử dụng lệnh ``cp key.txt repo/`` để sao chép tệp vào thư mục `repo`.
-Thêm và xác nhận thay đổi trên Git:

+Di chuyển đến thư mục dự án bằng lệnh `cd repo`.
+Thêm tệp tin vào Git bằng lệnh `git add key.txt -f`.
+Xác nhận thay đổi với lệnh ``git commit -m "dola27"``.
- `Ví dụ 1`:
🔁 Ví dụ tương tự ngoài đời:
-Bạn làm bài xong (tạo file),
-chọn những phần bạn muốn nộp (git add),
-rồi ghi chú "Tôi đã làm bài xong phần toán" (git commit -m "...")
-và nộp bài cho giáo viên (git push).
- `Ví dụ 2`:
📦 Hãy tưởng tượng Git giống như một hộp thư gửi bài:
-📄 Bạn tạo key.txt (viết bài xong)
-📥 Dùng git add để cho vào hộp thư
-📝 Dùng git commit để niêm phong + ghi chú: “đây là bài key.txt chứa nội dung yêu cầu”
-📤 Dùng git push để gửi bài đến server
- `Bước 4`: Đẩy tệp tin lên kho lưu trữ từ xa
-Sử dụng lệnh `git push origin master`.
-Xác nhận kết nối khi được hỏi (nhập `yes`).
- Mật khẩu sẽ hiện ra ngay khi bạn xác nhận kết nối như ảnh dưới đây:
### Level 32 → Level 33
- Mục tiêu của bài này là thoát khỏi một shell bị giới hạn có tên `UPPERCASE SHELL` và tìm mật khẩu cho level tiếp theo.
- Xem tình hình hiện tại:
-Bạn đang ở trong `UPPERCASE SHELL`, nơi mọi lệnh bạn gõ đều bị chuyển thành `chữ hoa`.
-Lệnh bạn thử như `ls`, `cat`, hay `whoami` đều không thể chạy do bị chuyển thành dạng chữ hoa (``LS, CAT, WHOAMI, v.v.``).
- Bước 1: Dùng ``$0`` để thoát khỏi shell hiện tại
Để thoát khỏi ``"UPPERCASE SHELL"``, bạn sẽ sử dụng lệnh ``$0``. Lệnh này sẽ khởi động lại shell của bạn và đưa bạn về shell bình thường, nơi bạn có thể thực thi các lệnh như bình thường.
- Bước 2: Kiểm tra lại shell hiện tại
-Sau khi sử dụng ``$0``, bạn có thể kiểm tra xem bạn đã vào được shell bình thường chưa bằng cách sử dụng lệnh `whoami`.
-Lệnh này sẽ trả về tên người dùng hiện tại, bạn sẽ thấy kết quả là `bandit33`, xác nhận bạn đã vào được shell của người dùng `bandit33`.
- Bước 3: Tìm mật khẩu cho Bandit Level 33
-Mật khẩu của level này nằm trong tệp ``/etc/bandit_pass/bandit33``. Để xem mật khẩu, bạn chỉ cần gõ lệnh sau:
`cat /etc/bandit_pass/bandit33`
-Sau khi chạy lệnh trên, bạn sẽ nhận được mật khẩu cho Bandit Level 33. Đây là mật khẩu bạn cần để tiếp tục vào level tiếp theo. Mật khẩu sẽ là:
`tQdtbs5D5i2vJwkO8mEyYEyTL8izoeJ0`
### Level 33 → Level 34
``🥳🥂 Hãy tự thưởng cho mình một chút thư giãn trước khi chinh phục những thử thách tiếp theo nhé! 🚀🚀🚀``