arcane

okay. this question is way too repetitive. I kinda gave up after doing level 4 and gave it to my teammate to finish. You can see the rest of the solution here https://moon-sun.xyz/tu/

Level 0

so for level 0, its basically just a simple hex decode. All i did for this is literally convert the hex into plaintext

    def solve_level0(self, hex_str):
        hex_clean = re.sub(r'[^0-9a-fA-F]', '', hex_str)
        return bytes.fromhex(hex_clean).decode('utf-8')                        

Level 1

things got slightly harder, but I figured out that the characters where shifted by 28. and that seemed to work for the most part. The characters near the end of the alphabet seemed to be wrong but its pretty obvious what they should be so i just hard coded them in :p

    def solve_level1(self, hex_str):
                hex_clean = re.sub(r'[^0-9a-fA-F]', '', hex_str)
                adjusted = bytes([(int(hex_clean[i:i+2], 16) + 28) % 256
                for i in range(0, len(hex_clean), 2)])
                # Decode and replace specific characters
                decoded = adjusted.decode('utf-8', errors='replace')
                decoded = decoded.replace('_', 'y').replace(']', 'w')
                return decoded

Level 2

I kinda bruteforced this one, i just mapped each character to its plaintext equivalent. if it works i guess it works

    def solve_level2(self, hex_str):
        hex_values = hex_str.strip().split()
        return ''.join([self.hex_to_char.get(h, '_') for h in hex_values])

    self.hex_to_char = {
            "b8": "A", "b9": "B", "ba": "C", "bb": "D", "bc": "E",
            "bd": "F", "be": "G", "bf": "H", "b0": "I", "b1": "J",
            "b2": "K", "b3": "L", "b4": "M", "b5": "N", "b6": "O",
            "c7": "P", "c8": "Q", "c9": "R", "ca": "S", "cb": "T", 
            "cc": "U", "cd": "V", "ce": "W", "cf": "X", "c0": "Y", 
            "c1": "Z"
        }

Level 3

it kinda gets tricky and it took a toll on my lovely mental health like all ctf questions, you bruteforce the fuck out of it and i had no rhyme or reason for how i arrived at my solution.

It turned out to be a vigenere cipher when I put it into dcodefr. I suspected there was a key involved because the previous levels there wasn't any keys.

And also if you watch the show (please go watch arcane i love my little lesbians) you know that Vi is short for her full name, Violet. This will be our key for the cipher

    def solve_level3(self, hex_str):
        # Convert hex to ASCII characters
        encrypted_chars = [bytes.fromhex(h).decode('latin-1') for h in hex_str.strip().split()]
        
        # Decrypt using Vigenère cipher with key "VIOLET"
        key = "VIOLET"
        decrypted = []
        for i, c in enumerate(encrypted_chars):
            key_char = key[i % len(key)]
            # Convert to 0-25 values
            e_code = ord(c.upper()) - ord('A')
            k_code = ord(key_char.upper()) - ord('A')
            p_code = (e_code - k_code) % 26
            decrypted.append(chr(p_code + ord('A')))
        return ''.join(decrypted)
        }

Level 4

Level 4 is where it ended for me. This took an embarrassing amount of time, and went to sleep after shortly after solving this eventually found out that the encryption is as follows:

The plaintext is split into 2. The start point is then determined based on the number of characters (n)
If n is even, start point is (n // 2) - 1
If n is odd, start point is ((n - 1) // 2) - 1

The permutation is generated by decrementing from the start point and wrapping around the word going backwards.
If n=6, the letters are arranged like [2, 1, 0, 5, 4, 3]
If n=5, the letters are arranged like [1, 0, 4, 3, 2]

    def solve_level4(self, hex_str):
            hex_values = hex_str.strip().split()
            encrypted = [bytes.fromhex(h).decode('latin-1') for h in hex_values]
            n = len(encrypted)
            # Generate permutation based on word length
            if n % 2 == 0:
                start = (n // 2) - 1  # Even: start at middle-1
            else:
                start = ((n - 1) // 2) - 1  # Odd: start at middle-2
            permutation = []
            current = start
            for _ in range(n):
                permutation.append(current)
                current = (current - 1) % n
            # Reorder encrypted characters using permutation
            decrypted = [encrypted[i] for i in permutation]
            return ''.join(decrypted)
            }