# 0xL4ugh CTF 23'

Một giải đấu nhanh nhanh thôi có gì viết lấy vây:👾👾

## 1: Easy-Peasy

Mở IDA pro đọc và nhận thông tin:

```c
int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rbx
  void **v4; // rdx
  void **v5; // rax
  __int64 v6; // rax
  void **v7; // rdx
  __int64 v8; // rax
  void *v9; // rcx
  int v11[6]; // [rsp+20h] [rbp-50h]
  __int16 v12; // [rsp+38h] [rbp-38h]
  char v13; // [rsp+3Ah] [rbp-36h]
  __int64 v14; // [rsp+40h] [rbp-30h]
  void *Block[2]; // [rsp+48h] [rbp-28h] BYREF
  __int64 v16; // [rsp+58h] [rbp-18h]
  unsigned __int64 v17; // [rsp+60h] [rbp-10h]

  v14 = -2i64;
  v11[0] = 1947518052;
  v11[1] = 84227255;
  v11[2] = -181070859;
  v11[3] = -972881100;
  v11[4] = 1396909045;
  v11[5] = 1396929315;
  v12 = -10397;
  v13 = 0;
  v3 = 0i64;
  v16 = 0i64;
  v17 = 15i64;
  LOBYTE(Block[0]) = 0;
  sub_140001350(Block);
  sub_1400015D0(std::cout, "Enter The Flag: ");
  sub_140001A50(std::cin, Block);
  if ( v16 == 26 )
  {
    while ( 1 )
    {
      v4 = Block;
      if ( v17 >= 0x10 )
        v4 = (void **)Block[0];
      v5 = Block;
      if ( v17 >= 0x10 )
        v5 = (void **)Block[0];
      if ( *((unsigned __int8 *)v11 + v3) != ((*((char *)v4 + v3) >> 4) | (16 * (*((_BYTE *)v5 + v3) & 0xF))) )
        break;
      if ( ++v3 >= 26 )
      {
        v6 = sub_1400015D0(std::cout, "The Flag is: ");
        v7 = Block;
        if ( v17 >= 0x10 )
          v7 = (void **)Block[0];
        sub_140001C50(v6, v7, v16);
        goto LABEL_12;
      }
    }
  }
  v8 = sub_1400015D0(std::cout, "This will not work");
  std::ostream::operator<<(v8, sub_1400017A0);
LABEL_12:
  if ( v17 >= 0x10 )
  {
    v9 = Block[0];
    if ( v17 + 1 >= 0x1000 )
    {
      v9 = (void *)*((_QWORD *)Block[0] - 1);
      if ( (unsigned __int64)(Block[0] - v9 - 8) > 0x1F )
        invalid_parameter_noinfo_noreturn();
    }
    j_j_free(v9);
  }
  return 0;
}
```

Ta dễ dàng nhận thấy là trước khi in ra màn hình `This Flag is` thì có hàm if, và mấu chốt của bài này nằm ở đó.

Duyệt qua mỗi phần tử của flag input vào và kiểm tra điều kiện nếu đúng thì v3 tăng 1 (nghĩa là kiểm tra ký tự tiếp theo) cho đến hết string và `v3` thỏa mãn là `>=26` nghĩa là bằng 26 thì là đúng.

Nó đơn giản thôi dưới là solve của tôi:

```py
magic = [100, 196, 20, 116, 183, 52, 5, 5, 245, 19, 53, 245, 52, 3, 3, 198, 245, 35, 67, 83, 35, 115, 67, 83, 99, 215]

for i in magic:
    for j in range(0,127):
        if (j >> 4 | (j & 15) << 4 ) == i:
            print(chr(j),end='')
```

Phần magic là phần mà ta nhận được khi chạy debug.

## 2: Snake

Với thử thách này đọc bytecodes python nhé. Sau một giải tương tự thì đến với chall này thì tôi đã làm nhanh và ok luôn..

```py
  2           0 LOAD_CONST               1 (0)
              2 LOAD_CONST               0 (None)
              4 IMPORT_NAME              0 (base64)
              6 STORE_FAST               0 (base64)

  3           8 LOAD_CONST               1 (0)
             10 LOAD_CONST               2 (('Fernet',))
             12 IMPORT_NAME              1 (cryptography.fernet)
             14 IMPORT_FROM              2 (Fernet)
             16 STORE_FAST               1 (Fernet)
             18 POP_TOP

  4          20 LOAD_CONST               3 (b'gAAAAABj7Xd90ySo11DSFyX8t-9QIQvAPmU40mWQfpq856jFl1rpwvm1kyE1w23fyyAAd9riXt-JJA9v6BEcsq6LNroZTnjExjFur_tEp0OLJv0c_8BD3bg=')
             22 STORE_FAST               2 (encMessage)

  5          24 LOAD_FAST                0 (base64)
             26 LOAD_METHOD              3 (b64decode)
             28 LOAD_CONST               4 (b'7PXy9PSZmf/r5pXB79LW1cj/7JT6ltPEmfjk8sHljfr6x/LyyfjymNXR5Z0=')
             30 CALL_METHOD              1
             32 STORE_FAST               3 (key_bytes)

  6          34 BUILD_LIST               0
             36 STORE_FAST               4 (key)

  7          38 LOAD_FAST                3 (key_bytes)
             40 GET_ITER
        >>   42 FOR_ITER                 9 (to 62)
             44 STORE_FAST               5 (k_b)

  8          46 LOAD_FAST                4 (key)
             48 LOAD_METHOD              4 (append)
             50 LOAD_FAST                5 (k_b)
             52 LOAD_CONST               5 (160)
             54 BINARY_XOR
             56 CALL_METHOD              1
             58 POP_TOP
             60 JUMP_ABSOLUTE           21 (to 42)

 10     >>   62 LOAD_GLOBAL              5 (bytes)
             64 LOAD_FAST                4 (key)
             66 CALL_FUNCTION            1
             68 STORE_FAST               4 (key)

 11          70 LOAD_FAST                1 (Fernet)
             72 LOAD_FAST                4 (key)
             74 CALL_FUNCTION            1
             76 STORE_FAST               6 (fernet)

 12          78 LOAD_FAST                6 (fernet)
             80 LOAD_METHOD              6 (decrypt)
             82 LOAD_FAST                2 (encMessage)
             84 CALL_METHOD              1
             86 LOAD_METHOD              7 (decode)
             88 CALL_METHOD              0
             90 STORE_FAST               7 (decMessage)

 13          92 LOAD_GLOBAL              8 (print)
             94 LOAD_FAST                7 (decMessage)
             96 CALL_FUNCTION            1
             98 POP_TOP
            100 LOAD_CONST               0 (None)
            102 RETURN_VALUE
None
```

Code mà tôi viết lại như sau:

```py
from base64 import *
from __ctf import *
from cryptography.fernet import Fernet

encMessage = b'gAAAAABj7Xd90ySo11DSFyX8t-9QIQvAPmU40mWQfpq856jFl1rpwvm1kyE1w23fyyAAd9riXt-JJA9v6BEcsq6LNroZTnjExjFur_tEp0OLJv0c_8BD3bg='

key_bytes = b64decode(b'7PXy9PSZmf/r5pXB79LW1cj/7JT6ltPEmfjk8sHljfr6x/LyyfjymNXR5Z0=')

key = []

for i in key_bytes:
    key.append(i^160)
    
str = ""
for i in key:
    str +=chr(i)

fernet = Fernet(str)
decMessage = fernet.decrypt(encMessage).decode()
print(decMessage)
```

Đó chỉ có vậy thôi là xong ra flag...


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://viettaliii.gitbook.io/home/ctf/write-up/0xl4ugh-ctf-23.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.