---
# System prepended metadata

title: KCSC_TTV

---

{%hackmd @themes/orangeheart %}
# KCSC_TTV (Lê Thanh Trọng - AT19N0142 - MN)

## For

### VBS

Bài này thì có ta 1 file ``code.zip``, muốn unzip được file thì đã phải cần password. Do đó mình sử dụng ``fcrackzip`` để bruteforce password của file zip.

![image](https://hackmd.io/_uploads/ryTJ_xnUa.png)

Sau khi tìm được password unzip thì mình tiếp tục dùng lệnh ``strings`` cho file ``code.vbs`` thì tìm được 1 đoạn sau.

![image](https://hackmd.io/_uploads/S1dPOgn8a.png)

Truy cập vào đường link của trang pastebin thì được 1 chuỗi base64

![image](https://hackmd.io/_uploads/SJ2iuenIa.png)

Cuối cùng chỉ cần decode nó ra là có flag

> KCSC{Vb4_h01_lor""_ae_th0ng_c4m_=(((}

## RE

### Real Warmup

Bỏ file ``chall.exe`` vào ida ta thấy có 1 chuỗi, decode chuỗi đó bằng base64 thì có được flag.

![image](https://hackmd.io/_uploads/HkwW172Ua.png)

> KCSC{Ch40_M|_|n9`_D3N'_V01'_77\/_KCSC}

### Hide And Seek

Đầu tiên mình sử dụng ``strings`` vào file ``exe`` thì thấy được 1 chuỗi sau, đọc qua thì nó cho 1 mảng và cho từng phần tử trong mảng đó xor với ``0x55`` thì sẽ trả về FLAG

![image](https://hackmd.io/_uploads/B1HP9ln8T.png)

```
flagArray = [30, 22, 6, 22, 46, 43, 125, 11, 123, 10, 123, 124, 104, 11, 123, 10, 123, 11, 104, 125, 123, 10, 123, 11, 124, 43, 40]
flag = ''

for i in range(len(flagArray)):
    flag += chr(flagArray[i] ^ 0x55)

print(flag)
```

> KCSC{~(^._.)=^._.^=(._.^)~}

### Awg Mah Back 

source:

```
from pwn import *

with open('flag.txt', 'rb') as (f):
    flag = f.read()
a = flag[0:len(flag) // 3]
b = flag[len(flag) // 3:2 * len(flag) // 3]
c = flag[2 * len(flag) // 3:]
a = xor(a, int(str(len(flag))[0]) + int(str(len(flag))[1]))
b = xor(a, b)
c = xor(b, c)
a = xor(c, a)
b = xor(a, b)
c = xor(b, c)
c = xor(c, int(str(len(flag))[0]) * int(str(len(flag))[1]))
enc = a + b + c
with open('output.txt', 'wb') as (f):
    f.write(enc)

```

script:

```
from pwn import *
import base64

def decrypt():
    with open("output.txt", 'rb') as f:
        enc_flag = f.read()
    a = enc_flag[0:len(enc_flag) // 3]
    b = enc_flag[len(enc_flag) // 3:2 * len(enc_flag) // 3]
    c = enc_flag[2 * len(enc_flag) // 3:]

    c = xor(c, int(str(len(enc_flag))[0]) * int(str(len(enc_flag))[1]))
    c = xor(b, c)
    b = xor(a, b)
    a = xor(c, a)
    c = xor(b, c)
    b = xor(a, b)
    a = xor(a, int(str(len(enc_flag))[0]) + int(str(len(enc_flag))[1]))
    dec_flag = a + b + c

    return dec_flag


decrypted_flag = decrypt()
a = base64.b64decode(decrypted_flag)
b = base64.b64decode(a)
c = base64.b64decode(b)
print(c)
```

Bài này thì sau khi xor ngược lại theo source thì nó xuất hiện mấy đoạn mã giống base64, sau đó chỉ cần decode 3 lần là xong.

> KCSC{84cK_t0_BaCK_To_B4ck_X0r`_4nD_864_oM3g4LuL}

### Images

Bài này chỉ cần nhìn giá trị giống bảng mã ``ascii`` và giá trị của ``imul`` thì chính là vị trí của kí tự trong chuỗi sau đó ghép lại với nhau là ra flag =)))))))))))))))))

> KCSC{Cam_on_vi_da_kien_nhan_nhin_het_dong_anh_nay`}

## PWN

### A gift for pwners

Sau khi mở gift bằng ida ta tìm được 3 phần của flag và nối nó lại.

![image](https://hackmd.io/_uploads/HJPqJX3IT.png)

![image](https://hackmd.io/_uploads/Sygo1Qh8T.png)

![image](https://hackmd.io/_uploads/HkdiyX2Up.png)

> KCSC{A_gift_for_the_pwners_0xdeadbeef}

### Linux command

source:

```
#include <stdio.h>
#include <string.h>
void hidden()
{
    printf("Semicolon Operator in Linux");
    printf("part 1: KCSC{Linux_");
}

int main()
{
    setbuf(stdin, 0);
    setbuf(stdout, 0);
    setbuf(stderr, 0);
    printf("What is your name: ");
    char name[0x20];
    scanf("%31s", name);
    strncpy(name, "echo \"Welcome to KCSC\"", 22);
    system(name);
}
```

part 1: ``KCSC{Linux_``

Ta có thể thấy biến ``name`` được khai báo với ``32byte`` nhưng nó chỉ nhận có ``31byte`` vào

```strncpy(name, "echo "Welcome to KCSC"", 22);```

Dòng này gán 22byte đầu vào name là ``echo "Welcome to KCSC"``, ở byte tiếp theo mình sẽ tạo shell

``aaaaaaaaaaaaaaaaaaaaaa;sh``

![image](https://hackmd.io/_uploads/ByYn8SnUp.png)


Ta nối các phần lại với nhau là xong

> KCSC{Linux_Commands_You_MUST_Know_bc6680c1a0d13d77_8d73c59185b1e412}

## CRYPTO

### Ez_Ceasar 

source:

```
import string
import random

alphabet = string.ascii_letters + string.digits + "!{_}?"

flag = 'KCSC{s0m3_r3ad4ble_5tr1ng_like_7his}'
assert all(i in alphabet for i in flag)

key = random.randint(0, 2**256)

ct = ""
for i in flag:
    ct += (alphabet[(alphabet.index(i) + key) % len(alphabet)])

print(f"{ct=}")

# ct='ldtdMdEQ8F7NC8Nd1F88CSF1NF3TNdBB1O'
```

script:

```
import string
import random


alphabet = string.ascii_letters + string.digits + "!{_}?"

ct = 'ldtdMdEQ8F7NC8Nd1F88CSF1NF3TNdBB1O'
key = 42

def decrypt(ciphertext, key):
    plaintext = ""
    for char in ciphertext:
        if char in alphabet:
            index = (alphabet.index(char) - key) % len(alphabet)
            plaintext += alphabet[index]
        else:
            plaintext += char
    return plaintext

decrypted_text = decrypt(ct, key)

print(f"Decrypted text: {decrypted_text}")
```

> KCSC{C3as4r_1s_Cl4ss1c4l_4nd_C00l}

## MISC

### Prog1: Max 

```
from pwn import *
import json

def find_max_value(arr):
    if not arr:
        return None

    max_value = arr[0]
    for num in arr:
        if num > max_value:
            max_value = num

    return max_value
f = remote("103.162.14.116", 14002)

for i in range(500):
    f.recvuntil(b'arr = ')
    a = json.loads(f.readline())
    a = find_max_value(a)
    f.sendlineafter("max = ", str(a).encode())
```

> KCSC{Ezzz_Programmingggg}

### Prog4: Requiem 

```
from pwn import *
import json

def calc(n):
    if n == 0:
        return 1
    elif n % 2 == 0:
        return n * calc(n - 1)
    else:
        return n + calc(n - 1)

f = remote("103.162.14.116", 14005)
f.recv()
for i in range(500):
    f.recvuntil("n = ")
    recv = json.loads(f.recvline().decode().strip("\n"))
    n = recv
    # print(n)
    a_n = calc(n)
    
    f.sendlineafter("= ", str(a_n).encode())
    
f.recvline()
```

> KCSC{KOREGA_REQUIEM_DA!!!_WWHaaaaaa___}


## WEB

### Pokemon Hof Panel Level 1 

![image](https://hackmd.io/_uploads/SyKzeQ2IT.png)

Challenge này cho ta 1 form để nhập tên và chọn loại pokemon để bắt đầu, sau khi hoàn thành bước này thì trang web trả về là ``access denied``, tiếp tục check phần cookie và decode nó ra

![image](https://hackmd.io/_uploads/BJGqgQ38p.png)

Tiếp theo mình chỉ việc sửa ``b:0``  thành ``b:1`` sau đó encode nó lại và gửi request với cookie vừa encode

> KCSC{n0w_y0u_kn0w_s3r1al1z3_f0m4rt}

### Mi Tom Thanh Long 

![image](https://hackmd.io/_uploads/rJjb-m3La.png)

Challenge đưa ta vào 1 trang web pr trá hình, click vào phần ``FLAG`` thì có thể thấy thấy FLAG đang ở trong phần ``pages/flag.php``, tiếp theo mình test payload ``../../../etc/passwd`` lên phần tham số page, xuất hiện lỗi ``LFI``

![image](https://hackmd.io/_uploads/BJWuZmnLp.png)

Tiếp theo mình sẽ đọc phần nội dung chứa ``FLAG`` với payload ``php://filter/convert.base64-encode/resource=pages/flag.php``

![image](https://hackmd.io/_uploads/BJJ2Zm3LT.png)

Sau đó decode chuỗi base64 ra thì ta có được ``FLAG``

> KCSC{Lan_Dau_Tien_Trai_Thanh_Long_Co_Trong_KCSC:))}

### Apply To KCSC 

Challenge này cho 1 form để điền và upload 1 file pdf, dự đoán đây có thể là ``upload file vuln``

![image](https://hackmd.io/_uploads/Skt1E7nU6.png)

Đầu tiên mình tạo 1 file ``php.php`` với nội dung như sau để test

```
<?php phpinfo(); ?>
```

Sau đó upload file lên trang web nhưng trang web chỉ nhận những file pdf, do đó ở phần ``Content-Type`` mình sửa thành ``pdf`` và thế là mình có thể upload file thoải mái

![image](https://hackmd.io/_uploads/H1p8BX2La.png)

Tiếp theo mình list các file ra bằng hàm ``system``, và thấy được ở client trả về ``FLAG``

![image](https://hackmd.io/_uploads/rJ_2Sm3Lp.png)

Cuối cùng chỉ sử dụng hàm ``system`` để ``cat /flag`` nữa là xong

> KCSC{W3lc0m3_T0_KCSC_2023____}

### WarmupPHP 01 

Challenge đưa ta vào 1 trang web bình thường chả có gì ngoài tham số ``name`` trên URL, mình thử vào tệp ``robots.txt`` thì thấy có source trong này.

![image](https://hackmd.io/_uploads/r1rh8QhU6.png)

Sau khi test thử 1 vài payload thì mình thấy đây là lỗi ``SSTI`` và trong source có thư viện ``smarty`` nên mình nghĩ đấy là lỗi ``smarty SSTI``

![image](https://hackmd.io/_uploads/S1j-D73IT.png)

Tiếp theo nhìn vào source ta thấy biến ``$flag1`` được chứa trong ``FLAG1``, do đó mình sẽ xuất ``FLAG1`` ra với ``{FLAG1}`` và có được flag

> KCSC{warmup01_begin_using_smarty}