...
victory_tile = pygame.Vector2(10, 10)
...
def GenerateFlagText(x, y):
    key = x + y*20
    encoded = "\xa5\xb7\xbe\xb1\xbd\xbf\xb7\x8d\xa6\xbd\x8d\xe3\xe3\x92\xb4\xbe\xb3\xa0\xb7\xff\xbd\xbc\xfc\xb1\xbd\xbf"
    return ''.join([chr(ord(c) ^ key) for c in encoded])
...
		if not victory_mode:
            # are they on the victory tile? if so do victory
            if player.x == victory_tile.x and player.y == victory_tile.y:
                victory_mode = True
                flag_text = GenerateFlagText(player.x, player.y)
                flag_text_surface = flagfont.render(flag_text, False, pygame.Color('black'))
                print("%s" % flag_text)

def GenerateFlagText(x, y):
    key = x + y*20
    encoded = "\xa5\xb7\xbe\xb1\xbd\xbf\xb7\x8d\xa6\xbd\x8d\xe3\xe3\x92\xb4\xbe\xb3\xa0\xb7\xff\xbd\xbc\xfc\xb1\xbd\xbf"
    return ''.join([chr(ord(c) ^ key) for c in encoded])

flag_text = GenerateFlagText(10,10)
print("%s" % flag_text)

import base64

encoded_string = "cQoFRQErX1YAVw1zVQdFUSxfAQNRBXUNAxBSe15QCVRVJ1pQEwd/WFBUAlElCFBFUnlaB1ULByRdBEFdfVtWVA=="
decoded_bytes = base64.b64decode(encoded_string)
result = []
  
with open("key.dump","rb") as f:
    key = f.read()
    
for i in range(0x40):
    v18 = i - 11 * (((i * 0x5D1745D1745D1746) >> 64) >> 2)
    result.append(key[v18] ^ decoded_bytes[i])

for r in result:
    print(chr(r),end = '')
#7fd7dd1d0e959f74c133c13abb740b9faa61ab06bd0ecd177645e93b1e3825dd

import "hash"

rule aray
{
    meta:
        description = "Matches on b7dc94ca98aa58dabb5404541c812db2"
    condition:
        filesize == 85 and hash.md5(0, filesize) == "b7dc94ca98aa58dabb5404541c812db2" and filesize ^ uint8(11) != 107 and uint8(55) & 128 == 0 and uint8(58) + 25 == 122 and uint8(7) & 128 == 0 and uint8(48) % 12 < 12 and uint8(17) > 31 and uint8(68) > 10 and uint8(56) < 155 and uint32(52) ^ 425706662 == 1495724241 and uint8(0) % 25 < 25 and filesize ^ uint8(75) != 25
        ...

import re
import zlib
import hashlib

def possible32(possible_bytes,index,num):
    possible_bytes[index+3] = [num >> 24]
    possible_bytes[index+2] = [(num >> 16) & 0xFF]
    possible_bytes[index+1] = [(num >> 8) & 0xFF]
    possible_bytes[index+0] = [num & 0xFF]
def solve_uint32_condition(possible_bytes):
    #uint32(52) ^ 425706662 == 1495724241 
    possible32(possible_bytes, 52, 1495724241 ^ 425706662)
    #uint32(17) - 323157430 == 1412131772
    possible32(possible_bytes, 17, 1412131772 + 323157430)
    #uint32(59) ^ 512952669 == 1908304943
    possible32(possible_bytes, 59, 1908304943 ^ 512952669) 
    #uint32(28) - 419186860 == 959764852
    possible32(possible_bytes, 28, 959764852 + 419186860)
    #uint32(66) ^ 310886682 == 849718389 
    possible32(possible_bytes, 66, 849718389 ^ 310886682)
    #uint32(10) + 383041523 == 2448764514
    possible32(possible_bytes, 10, 2448764514 - 383041523)
    #uint32(37) + 367943707 == 1228527996
    possible32(possible_bytes, 37, 1228527996 - 367943707)
    #uint32(22) ^ 372102464 == 1879700858
    possible32(possible_bytes, 22, 1879700858 ^ 372102464)
    #uint32(46) - 412326611 == 1503714457
    possible32(possible_bytes, 46, 1503714457 + 412326611) 
    #uint32(70) + 349203301 == 2034162376
    possible32(possible_bytes, 70, 2034162376 - 349203301) 
    #uint32(80) - 473886976 == 69677856
    possible32(possible_bytes, 80, 69677856 + 473886976) 
    #uint32(3) ^ 298697263 == 2108416586 
    possible32(possible_bytes, 3, 2108416586 ^ 298697263)
    #uint32(41) + 404880684 == 1699114335 
    possible32(possible_bytes, 41, 1699114335 - 404880684)
    

def read_condition(file):
    with open(file,'r') as f:
        data = f.read()
    return data

def check_condition_8(possible_bytes,condition):
    result = []
    pattern = r'uint8\((\d+)\)'
    indices = re.findall(pattern, condition)
    indices = [int(index) for index in indices]
    if len(indices) !=1:
        return False
    index = indices[0]
    
    condition = condition.replace('(','[').replace(')',']').replace("filesize","85")
    for i in possible_bytes[index]:
        current_condition = condition.replace(f'uint8[{index}]', str(i))
        if eval(current_condition):
            result.append(i)
    possible_bytes[index] = result     
    return True

def calculate_crc32(possible_bytes,index,num):
    for i in possible_bytes[index]:
        for j in possible_bytes[index+1]:
            data = bytes([i,j])
            if zlib.crc32(data) & 0xFFFFFFFF == num:
                possible_bytes[index] = [i]
                possible_bytes[index+1] = [j]
                return True
    return False

def calculate_md5(possible_bytes,index,num):
    for i in possible_bytes[index]:
        for j in possible_bytes[index+1]:
            data = bytes([i,j])
            if hashlib.md5(data).hexdigest() == num:
                possible_bytes[index] = [i]
                possible_bytes[index+1] = [j]
                return True
    return False

def calculate_sha256(possible_bytes,index,num):
    for i in possible_bytes[index]:
        for j in possible_bytes[index+1]:
            data = bytes([i,j])
            if hashlib.sha256(data).hexdigest() == num:
                possible_bytes[index] = [i]
                possible_bytes[index+1] = [j]
                return True
    return False

def solve_hash_condition(possible_bytes):
    # hash.crc32(8, 2) == 0x61089c5c
    calculate_crc32(possible_bytes,8,0x61089c5c)
    #hash.crc32(34, 2) == 0x5888fc1b
    calculate_crc32(possible_bytes,34,0x5888fc1b)
    #hash.crc32(63, 2) == 0x66715919
    calculate_crc32(possible_bytes,63,0x66715919)
    #hash.sha256(14, 2) == "403d5f23d149670348b147a15eeb7010914701a7e99aad2e43f90cfa0325c76f"
    calculate_sha256(possible_bytes,14,"403d5f23d149670348b147a15eeb7010914701a7e99aad2e43f90cfa0325c76f")
    #hash.sha256(56, 2) == "593f2d04aab251f60c9e4b8bbc1e05a34e920980ec08351a18459b2bc7dbf2f6"
    calculate_sha256(possible_bytes, 56, "593f2d04aab251f60c9e4b8bbc1e05a34e920980ec08351a18459b2bc7dbf2f6")
    #hash.md5(0, 2) == "89484b14b36a8d5329426a3d944d2983"
    calculate_md5(possible_bytes, 0, "89484b14b36a8d5329426a3d944d2983")
    #hash.crc32(78, 2) == 0x7cab8d64
    calculate_crc32(possible_bytes,78,0x7cab8d64)
    #hash.md5(76, 2) == "f98ed07a4d5f50f7de1410d905f1477f" 
    calculate_md5(possible_bytes,76,"f98ed07a4d5f50f7de1410d905f1477f")
    #hash.md5(50, 2) == "657dae0913ee12be6fb2a6f687aae1c7" 
    calculate_md5(possible_bytes,50,"657dae0913ee12be6fb2a6f687aae1c7")
    #hash.md5(32, 2) == "738a656e8e8ec272ca17cd51e12f558b" 
    calculate_md5(possible_bytes,32,"738a656e8e8ec272ca17cd51e12f558b")
    
    
if __name__=='__main__':
    data = read_condition('./aray.txt')
    hash_condition=[]
    arr = [i for i in range(256)]
    possible_bytes = []
    filesize = 85
    for i in range(filesize):
        possible_bytes.append(arr) 
    conditions = data.split("and")
    
    solve_uint32_condition(possible_bytes)
    
    for condition in conditions:
        if "hash" in condition:
            continue
        elif "uint32" in condition:
            continue
        elif "uint8" in condition:
            if check_condition_8(possible_bytes,condition):
                continue
            else:
                print(condition) #uint8 원소가 2개 이상 선언된 경우 => 없음
        else:
            print(condition) # => 없음
                
    solve_hash_condition(possible_bytes)
    
    for i in range(filesize):
        if len(possible_bytes[i])==1:
            print(chr(possible_bytes[i][0]),end='')
        else:
            print()
            print(i,end = ' : ')
            print(possible_bytes[i])

from Crypto.Cipher import ChaCha20

def scd_decode():
    key_hex = "943df638a81813e2de6318a507f9a0ba2dbb8a7ba63666d08d11a65ec914d66f"
    nonce_hex = "f236839f4dcd711a52862955"
    key = bytes.fromhex(key_hex)
    nonce = bytes.fromhex(nonce_hex)
    
    with open("scd_encoded.dump","rb") as f:
        ciphertext = f.read()
    cipher = ChaCha20.new(key=key, nonce=nonce)
    plaintext = cipher.decrypt(ciphertext)
    
    with open("scd_decoded", "wb") as f:
        f.write(plaintext)

import struct
import os

# 회전 함수 정의
def rotl32(v, n):
    return ((v << n) & 0xffffffff) | (v >> (32 - n))

# 쿼터 라운드 함수 정의
def quarter_round(x, a, b, c, d):
    x[a] = (x[a] + x[b]) & 0xffffffff
    x[d] ^= x[a]
    x[d] = rotl32(x[d], 16)

    x[c] = (x[c] + x[d]) & 0xffffffff
    x[b] ^= x[c]
    x[b] = rotl32(x[b], 12)

    x[a] = (x[a] + x[b]) & 0xffffffff
    x[d] ^= x[a]
    x[d] = rotl32(x[d], 8)

    x[c] = (x[c] + x[d]) & 0xffffffff
    x[b] ^= x[c]
    x[b] = rotl32(x[b], 7)

# ChaCha20 블록 함수 정의
def chacha20_block(key, counter, nonce):
    # 초기 상태 설정
    constants = (b'expand 32-byte K') #CUTOMIZED!!!!
    key = struct.unpack('<8L', key)
    nonce = struct.unpack('<3L', nonce)

    state = [
        struct.unpack('<L', constants[i:i + 4])[0] for i in range(0, 16, 4)
    ] + list(key) + [counter] + list(nonce)

    # 상태 복사본 생성
    working_state = list(state)

    # 20 라운드 진행 (10번의 더블 라운드)
    for _ in range(10):
        # 열 라운드
        quarter_round(working_state, 0, 4, 8, 12)
        quarter_round(working_state, 1, 5, 9, 13)
        quarter_round(working_state, 2, 6, 10, 14)
        quarter_round(working_state, 3, 7, 11, 15)
        # 대각선 라운드
        quarter_round(working_state, 0, 5, 10, 15)
        quarter_round(working_state, 1, 6, 11, 12)
        quarter_round(working_state, 2, 7, 8, 13)
        quarter_round(working_state, 3, 4, 9, 14)

    # 최종 상태 계산
    block = [(working_state[i] + state[i]) & 0xffffffff for i in range(16)]
    return struct.pack('<16L', *block)

# ChaCha20 암호화 함수 정의
def chacha20_encrypt(key, counter, nonce, plaintext):
    key = key.ljust(32, b'\0')[:32]
    nonce = nonce.ljust(12, b'\0')[:12]
    ciphertext = b''

    for i in range(0, len(plaintext), 64):
        block = chacha20_block(key, counter, nonce)
        counter = (counter + 1) & 0xffffffff
        keystream = block[:len(plaintext[i:i+64])]
        ciphertext += bytes([p ^ k for p, k in zip(plaintext[i:i+64], keystream)])

    return ciphertext


if __name__ == "__main__":
    key = bytes.fromhex("8D EC 91 12 EB 76 0E DA 7C 7D 87 A4 43 27 1C 35 D9 E0 CB 87 89 93 B4 D9 04 AE F9 34 FA 21 66 D7".replace(" ", ""))
    nonce = bytes.fromhex("11 11 11 11 11 11 11 11 11 11 11 11".replace(" ", ""))    
    counter = 0
    with open("file_encoded.dump", "rb") as f:
        ciphertext = f.read()

    # 복호화
    decrypted = chacha20_encrypt(key, counter, nonce, ciphertext)
    print("Decrypted:", decrypted)