Let's Crax

Flag: flag{Th1s_Py7h0n_VM_h4s_n0_s3cr3t5_f0r_m3}

Challenge

7KB

letscrax.zip

archive

Ouvrir

Description

---

Aucune description

Solution

Commençons par quelques modifications pour automatiser nos essais. Terminé les print, on s'en cogne donc on commente :

180:    elif syscall_id == 0x4:
181:        # Display byte from memory
182:        self.add_pc(2)
183:        # print(chr(self.get_byte_from_mem(self.registers[2])), end="")
184:        return 1

Pareil pour l'input, on va passer le flag à tester directement lors de la création de la VM et remplacer la ligne de l'input par le flag en question :

20: class VM:
21:
22:    def __init__(self, flag: str) -> None:
23:        self.flag = flag

# [...] reste du code

185:        elif syscall_id == 0x5:
186:            # Read stdin to memory
187:            self.add_pc(2)
188:            # data = input()
189:            data = self.flag
190:            data_byte_array = bytearray(data.encode())

Maintenant, on est prêt...

Connaître la taille du flag

On va modifier le fichier vm.py. Pour ça, on ajoute dans run() la variable instruction_count au début, et dans sa boucle while, on va incrémenter cette variable. Enfin, on la retourne en fin de fonction.

Elle nous permet de compter le nombre d'instructions jouées, et donc de savoir si on a provoqué une modification en fonction de notre input.

  def run(self, entry_point: int) -> None:
        instructions_count = 0
        self.jmp(entry_point)
        while True:
            instructions_count += 1
            if self.registers[self.pc] == 0xBADC0DE:
# [...] Reste du code 

On va lancer la vm avec plein de flags de tailles différentes :

def start():
    program = open('program.bin', "rb").read()
    for i in range(45):
        vm = VM("a" * i)
        entry_point = vm.load_code(program)
        n = vm.run(entry_point)
        print(i, n)

# 40 1032
# 41 1032
# 42 1044   <-- Lezgoooo
# 43 1032
# 44 1032

Avec un flag de 42 caractères, on fait plus d'instructions. Donc, on comprend qu'il y avait une condition sur la taille du flag et qu'on l'a validée avec 42 caractères.

Début du flag

On va réutiliser le même principe en espérant que le binaire vérifie caractère par caractère le flag. Donc, on va tester tous les caractères possibles à la première position et voir s'il y a quelque chose qui change :

def start():
    program = open('program.bin', "rb").read()
  
    CHARSET = string.ascii_letters + string.digits + string.punctuation
    flag_size = 42
    base_flag = ''
    for c in CHARSET:
        flag = base_flag + c + 'a' * (flag_size - len(base_flag) - 1)
        vm = VM(flag)
        entry_point = vm.load_code(program)
        n = vm.run(entry_point)
        print(c, n)

# a 1044
# b 1044
# c 1044
# d 1044
# e 1044
# f 1048
# g 1044
# h 1044

Avec f il y a plus d'instructions jouées, comme si on avait passé une condition de plus. Si on continue en gardant le f au début et en testant le 2nd caractère, on obtient

j 1048
k 1048
l 1056
m 1048
n 1048

Le second caractère est l. Si on continue comme ça, on obtient le début flag{. Malheureusement, plus rien ensuite. En réfléchissant un peu, on se doute que le dernier caractère est }. Et ça tombe bien, ça augmente beaucoup nos instructions :

def start():
    program = open('program.bin', "rb").read()
    
    CHARSET = string.ascii_letters + string.digits + string.punctuation
    flag = 'flag{' + 'a' * 36 + '}'
    vm = VM(flag)
    entry_point = vm.load_code(program)
    n = vm.run(entry_point)
    print(n)
# 1354

Fonction de chiffrement

Ce qui se trouve à l'intérieur du flag est chiffré et vérifié. On peut le voir en ajoutant des lignes dans la fonction enc().

Un petit tour sur ChatGPT avec le bout de code en question nous apprend qu'il s'agit possiblement d'une variante de Tiny Encryption Algorithm et que c'est donc réversible !

Cette fonction est appelée une fois qu'on a trouvé le début et la fin du flag justement. On va donc afficher les variables qui la concerne et qui nous intéressent :

• k : la clé de chiffrement

• y et z : 4 caractères de notre input en clair au début et chiffrés à la fin

    def enc(self, reg1: int, reg2: int,  reg3: int) -> None:
# [...] reste du code

        print('BEFORE ENCRYPTION:')
        print(f'k: {k}')
        print(f'y: {y.value} -> {y.value.to_bytes(4, 'little')}')
        print(f'z: {z.value} -> {z.value.to_bytes(4, 'little')}')

        sum = c_uint32(0)
        delta = 0x9e3779b9
        n = 32

        while(n>0):
            sum.value += delta & 0xffffffff
            y.value += ( z.value << 4 ) + k[0] ^ z.value + sum.value ^ ( z.value >> 5 ) + k[1] & 0xffffffff
            z.value += ( y.value << 4 ) + k[2] ^ y.value + sum.value ^ ( y.value >> 5 ) + k[3] & 0xffffffff
            n -= 1
            
        print('AFTER ENCRYPTION:')
        print(f'y: {y.value} -> {y.value.to_bytes(4, 'little')}')
        print(f'z: {z.value} -> {z.value.to_bytes(4, 'little')}')

Ensuite, on sait qu'elles sont forcément comparés avec le flag, donc on va également afficher avec quoi elles le sont. Pour ça, direction la fonction cmp_regs() :

def cmp_regs(self, reg1: int, reg2: int) -> None:
    # 0x47
    print(self.registers[reg1], self.registers[reg2])

Maintenant, si on lance, on va avoir le résultat de notre input chiffré avec ce à quoi il devrait ressembler. Ici j'utilise le flag flag{abcdefghijklmnopqrstuvwxyzABCDEFGHIJ} :

0 0
0 0
BEFORE ENCRYPTION:
k: [3385206627, 632509235, 1634953960, 3929412302]
y: 1684234849 -> b'abcd'
z: 1751606885 -> b'efgh'
AFTER ENCRYPTION:
y: 2026883528 -> b'\xc8\xc9\xcfx'
z: 3029057199 -> b'\xaf\xbe\x8b\xb4'
2026883528 943156865
10 0
9 0

2026883528 c'est le début du flag chiffré 943156865 c'est le résultat du chiffrement qu'il faudrait

On va donc mettre à jour manuellement y pour éviter que ça quitte et pouvoir voir la prochaine comparaison. De cette façon, on sera capable de récupérer tous les y et z attendus !

J'ajoute la variable encryption_counter dans VM :

class VM:

    def __init__(self, flag: str) -> None:
        self.flag = flag
        self.encryption_counter = 0

Et ensuite, on va compléter notre tableau avec les valeurs attendues :

        compared_values = [
            (943156865, 0),
            (0, 0),
            (0, 0),
            (0, 0),
            (0, 0)
        ]
        y.value = compared_values[self.encryption_counter][0]
        z.value = compared_values[self.encryption_counter][1]
        self.encryption_counter += 1

On voit bien la prochaine comparaison 140430192 :

AFTER ENCRYPTION:
y: 2026883528 -> b'\xc8\xc9\xcfx'
z: 3029057199 -> b'\xaf\xbe\x8b\xb4'
943156865 943156865
0 140430192

Il suffit maintenant de compléter notre tableau au fur et à mesure pour obtenir finalement :

compared_values = [
    (943156865, 140430192),
    (2530532487, 129893444),
    (261106022, 2629986848),
    (3679519246, 3532129935),
    (794422906, 4144136265)
]

Déchiffrement

On a tout ce qu'il nous faut. De mon côté, j'ai demandé à ChatGPT de me faire la fonction de déchiffrement, mais elle est très largement faisable à la main étant donné que l'algo de chiffrement est simple.

from ctypes import c_uint32

def decrypt(y: int, z: int, k: tuple[int, int, int, int]):
    y = c_uint32(y)
    z = c_uint32(z)
    n = 32
    delta = 0x9e3779b9
    sum = c_uint32(delta * n)
    while n > 0:
        z.value -= ((y.value << 4) + k[2]) ^ (y.value + sum.value) ^ ((y.value >> 5) + k[3])
        y.value -= ((z.value << 4) + k[0]) ^ (z.value + sum.value) ^ ((z.value >> 5) + k[1])
        sum.value -= delta
        n -= 1
    return y.value.to_bytes(4, 'little'), z.value.to_bytes(4, 'little')


k = [3385206627, 632509235, 1634953960, 3929412302]
compared_values = [
    (943156865, 140430192),
    (2530532487, 129893444),
    (261106022, 2629986848),
    (3679519246, 3532129935),
    (794422906, 4144136265)
]

flag = b''
for values in compared_values:
  d = decrypt(values[0], values[1], k)
  flag += d[0] + d[1]
print(flag.decode())

# Th1s_Py7h0n_VM_h4s_n0_s3cr3t5_f0r_m3

Finalement, on peut relancer la vraie VM avec le programme en testant notre flag : flag{Th1s_Py7h0n_VM_h4s_n0_s3cr3t5_f0r_m3}

$ python3 vm.py program.bin
Ahoy ! Welcome aboard, matey! I've lost the password to the digital whisky reserve. Help me find it, and I'll be grateful!

Enter the password: flag{Th1s_Py7h0n_VM_h4s_n0_s3cr3t5_f0r_m3}
Good job !