Breaking The Mutant Language's "Encryption (Writeup)"

    Breaking The Mutant Language's "Encryption (Writeup)"

    • Y Combinator
      Reddit
      Mastodon
    AppSec Village DEF CON 31 CTF^2 (developer) winning entry. Bypassed the encryption and mutation techniques of the Mutant Language.

    Last year, my friend Gaurav Gogia presented Mutant Programming Language at Nullcon Goa 2022 as a way to "push security left". He developed this language as a way to encrypt the code by "mutating byte code" in runtime. In his talk, he explained that the language tries to "Mutate Byte Code" and uses encryption to make reverse engineering hard. While well ambitioned, his approach seems to be security through obscurity rather than encryption.

    I submitted this language as a challenge entry for CTF^2 in AppSec Village, DEF CON 31. The obfuscation technique presented as encryption was quite fun to dissect and to solve the challenge player must read the code of Mutant's compiler and develop a decompiler or you can say deobfuscator. You can find the one I developed at https://github.com/0xcrypto/mutant-cure. This is supposed to be a full-fledged decompiler in the future, so maybe give it a star or watch to keep track of changes.

    Writeup

    I will try to explain the challenge from the player's perspective but I have CTF developer bias so I might assume a few things while writing. Leave questions in the comments, if any.

    The challenge starts with a PDF file having the password L'oreal. After entering the password, we get the letter from Lucius Malfoy to his fellow death eaters.

    Subject: Urgent: Securing the NSCP Software for Our Cause
    
    From: Lucius Malfoy
    
    To: Death Eaters
    
    Dear Death Eaters,
    
    I trust this message reaches you amidst the shadows of secrecy and loyalty to our noble cause. Today, I
    come forth with a matter of utmost importance, one that requires your unwavering commitment to the Dark
    Lord's vision and the safeguarding of classified information.
    
    We have acquired a weapon of immense power, the Nuclear Strike Coordination Protocol (NSCP) software.
    This unparalleled tool will grant us the means to exert our dominance over the Muggle world. With this
    software, we can control their ultimate weapon and hit them with their own creation. However, we must
    approach this acquisition with the utmost caution and security.
    
    The NSCP software is unlike any other program; it has been crafted using the Mutant Programming
    Language (MPL), an encrypted programming language known for its impenetrable defenses against any
    Wizard’s interference. This ensures that our adversaries remain oblivious to our actions until it is too late.
    Muggles are stupid as always, but Dumbledore’s army is trying to find ways to beat the encryption. Those
    children have no chance against us. They are unaware that this software only runs in the vm of Mutant
    Programming Language which you will find at https://github.com/gaurav-gogia/mutant.
    
    As loyal Death Eaters, I am entrusting each of you with the sacred duty of safeguarding the NSCP
    software. Your first task is to ensure it remains hidden in the deepest vaults of our lairs, protected by
    enchantments and ancient spells, far from the prying eyes of any outsider.
    
    Only those among us, with the utmost loyalty and dedication to the Dark Lord, shall have access to the
    software. Restrict it to a select few and never let it fall into the hands of traitors or infiltrators. Should you
    detect any sign of treachery or attempted breaches, report it to me immediately.
    
    The Dark Lord's plan hinges on the successful deployment of this powerful weapon against the Muggles.
    Thus, the responsibility that comes with its possession cannot be overstated. Failure to safeguard the
    software could spell doom for our cause and the glorious future that awaits us.
    
    Remember, our allegiance binds us as one, and our success depends on our collective vigilance. I expect
    each of you to uphold the highest standards of secrecy and loyalty. Any breach of trust will be met with
    severe consequences.
    
    I shall be expecting swift compliance and adherence to these instructions. We must remain one step ahead
    of our enemies and ensure the triumphant rise of the Dark Lord's reign. The future of our kind rests in your
    hands, dear Death Eaters. May darkness be our ally, and victory be our destiny.
    
    Slytherin's legacy lives on in us,
    
    Lucius Malfoy
    

    After the letter, there's some base64 encoded text with some extra words and symbols. At this point, it is unclear what kind of code this is but as the letter tells, it is written in Mutant Programming Language. Let's see how it works.

    The letter suggests downloading Mutant Language from https://github.com/gaurav-gogia/mutant. There are two ways to use mutant language. Using source code to build mutant, and using binary. After downloading and installing the compiler, we can use the command mutant to compile and run the code. To understand how to compile the code, we can read the documentation of the language which is available at https://mudocs.netlify.app. Using the documentation, I created a hello world program and saved it as hello.mut (.mut is the source code file for mutant language)

    puts("Hello, World!");
    

    Now using mutant to compile the code:

    $ mutant hello.mut
    Compiled in: 553.985µs
    

    After compiling, we can see that the compiler produced hello.mu file in the same directory. Let's run the compiled code

    $ mutant hello.mu
    Hello, World!
    

    The code runs, let us try to see what kind of binary it makes with the file command

    $ file hello.mu 
    hello.mu: ASCII text, with very long lines (1493), with no line terminators
    

    So the compiled code is a text file. That means we can see the content with cat

    $ cat hello.mu
    MUT|QTVCdVo3ZWFwMjllZSt1SURnTlp5OTVtRlg0eHl2T3lmdC95LzdBeGhlVFhWRXliUDZ3N2x0TCtabzB4WlYzb3dVY1lLcFRMMVJVZTQrbUJrMmZvMzljUFN2TVRKejRyUkNKK1V4SURnek83cWl5bitlem1vTHZBUFRTWmdLWlk2Vk43d1BOa003bzhKcEQ1RnExWUQreDk3dVc3WW82eTRzUjFsTzdlbk1BMTVtK2VNS1V3RWNEOVA2QlE4Z1pnOXJUalpnSHFnbEJQZEdjRVhJRTNTUEg1emUxL2R3QWl3aUM5VnMvSVpxL3dabmhtSzZrdnUra2hxVlRWVytZemZHRklUYUk4RUJzY08wSnZObWpZZ3lVekJ4NjVVWkJoQVlSa3NnPT18NmFhM2RkNWY1ZDVkNTQxZTI1MjgzOTFmMzMzODM5NWRhM2RlNWM1ZDVlNWQ1MDE1MzIyZjI4MmUyOTNmMjgzNQ==|5154564364566f335a5746774d6a6c6c5a5374315355526e546c70354f545674526c673065486c3254336c6d644339354c7a64426547686c5646685752586c6955445a334e32783054437461627a4234576c597a6233645659316c4c6346524d4d564a565a54517262554a724d6d5a764d7a6c6a55464e325456524b656a5279556b4e4b4b3156345355526e656b383363576c356269746c656d317654485a4255465254576d644c576c6b32566b34336431424f61303033627a684b63455131526e45785755517265446b3364566333575738326554527a556a4673547a646c626b31424d5456744b32564e5331563352574e454f564132516c45345a31706e4f584a55616c706e5348466e62454a515a45646a5256684a52544e5455456731656d55784c32523351576c3361554d35566e4d76535670784c336461626d6874537a5a72646e557261326878566c52575679745a656d5a48526b6c5559556b3452554a7a59303877536e5a4f6257705a5a336c56656b4a344e6a5656576b4a6f51566c5361334e6e505431384e6d46684d32526b4e5759315a44566b4e5451785a5449314d6a677a4f54466d4d7a4d7a4f444d354e5752684d32526c4e574d315a44566c4e5751314d4445314d7a49795a6a49344d6d55794f544e6d4d6a677a4e513d3dd41d8cd98f00b204e9800998ecf8427e|ANT
    

    So the code is similar to the one provided in the challenge. Let's put that text into death.mu file. The content of the file from the PDF is

    MUT|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|5891ef6d6f6f662c171a0b2d010a0b6f91ec6e6f6c6f6227001d1a1c1b0d1a07|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|ANT
    

    Now let's try to run it:

    $ mutant death.mu
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⠶⠟⠛⠛⠛⠶⢦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⢠⡾⠋⠀⠀⠀⠀⠀⠀⠀⠀⠉⢷⡀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⢠⣿⠁⠀⠀⡀⠀⠀⠀⠀⠀⠀⠀⣾⣷⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⣾⠟⢉⣀⣀⡈⠃⠀⠀⠒⣉⣀⡀⠈⢻⡄⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⡏⠀⣴⣶⣿⣿⣷⠂⠀⣾⣿⣿⣿⣆⢠⡇⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⢸⣿⠀⠻⠿⢿⡿⠃⣰⣆⠙⣿⡿⠿⠋⠸⣧⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⣿⠁⠀⠀⠀⠈⠀⠠⣿⠿⠀⠀⣀⣀⣀⠀⣿⣦⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⣼⣿⣶⣾⣿⣿⡟⢀⠀⠀⠀⢀⢀⢻⣿⣿⣿⣿⢻⡇⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⣇⢸⡇⠻⢿⣿⠇⡜⢸⠀⡇⢸⠘⣼⣿⠿⠉⠙⣿⡇⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⣿⣾⣿⣦⠀⣿⣷⣷⣾⣤⣷⣾⣿⣿⢋⣴⣶⣶⣿⡀⠀⠀⠀⠀⠀
    ⠀⠀⠀⣠⠞⠙⠻⣿⣿⣷⣿⣿⣿⠿⠿⠻⠟⠋⠀⣼⣿⣿⡿⣻⣿⣦⡀⠀⠀⠀
    ⠀⢀⡼⢿⡦⣠⣴⢿⣿⣿⣿⣏⣿⣤⠀⠀⢰⡔⣶⣾⣿⠏⠀⠀⠀⣿⣿⣄⠀⠀
    ⠀⡾⢡⣏⢰⣯⠃⣼⣿⡿⢿⡟⢿⡋⠀⠀⢸⣽⣿⣿⡿⣇⠀⠀⠀⢈⡿⡿⣆⠀
    ⢸⡿⠿⠏⢰⠇⢸⡿⠋⠀⠀⣿⡟⠀⠀⠀⠈⡟⠀⠉⠳⣿⣿⠆⠀⢿⣙⡇⣿⡄
    ⣿⠀⠀⠀⢸⢰⣿⠁⠀⠀⠀⢸⣧⣤⠀⠀⡼⡇⠀⠀⠀⢹⣾⠀⠀⠈⢻⡇⢹⡇
    ⣿⣿⣷⠀⢸⣸⣿⠀⠀⠀⠀⠀⢷⣿⠀⠀⠳⡇⠀⠀⠀⢸⡟⠀⠀⠀⡸⠀⢼⡇
    ⢿⣟⠋⠀⢸⡿⣿⠀⠀⠀⠀⠀⠘⣿⢲⣦⠀⢹⡀⠀⠀⡼⠀⣤⣤⣴⠃⢠⣾⠇
    ⠸⡏⣿⠆⠘⢷⣼⣷⣄⠀⠀⠀⠀⠹⣿⡇⠀⠘⢵⣤⡾⢁⡤⣡⠞⠁⠀⣸⠟⠀
    ⠀⠹⣧⠀⢀⣀⠀⠸⣯⣽⣷⣦⣄⡀⢻⣷⣦⣄⣤⠙⣷⡼⠞⠁⣀⢄⣾⠏⠀⠀
    ⠀⠀⠈⠻⣟⠙⢧⣀⣀⠀⠘⢳⣾⣿⣿⣿⣿⣮⡻⣤⡌⠛⢶⣵⣵⡿⠁⠀⠀⠀
    ⠀⠀⠀⠀⠈⠳⢶⣤⣿⣦⠖⡉⠕⠊⢉⣿⣿⣿⣷⣾⣧⣖⣦⠙⢿⣄⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⣸⠟⠠⠈⠀⢀⣰⣿⣿⣿⣿⣿⣟⢿⣿⣿⣠⡴⢮⢳⣄⠀⠀
    ⠀⠀⠀⠀⠀⠀⣼⡫⠂⠀⠀⠀⣶⡿⣿⣿⣿⠁⠘⢿⣆⠙⣿⣿⣅⢺⡇⠛⢷⡄
    ⠀⠀⠀⠀⠀⢰⣿⠁⠀⠀⠀⣼⠏⠀⠈⢿⣿⠀⠀⢀⣿⠀⢸⣿⢿⣿⣷⢺⡆⣿
    ⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⢰⣿⠀⠀⠀⠈⣏⢻⡇⢷⣾⡇⢸⣿⠃⠘⢿⣼⣧⣿
    ⠀⠀⠀⠀⠀⢸⣇⠀⠀⠀⢉⢿⣆⠀⠀⠀⣿⡟⠀⠀⢹⣷⣿⡏⠀⠀⢽⣿⣿⠏
    ⠀⠀⠀⠀⠀⠀⢻⡆⠀⠀⠀⠸⢻⢿⣶⣶⣿⢻⡆⢀⣼⣿⠏⠀⠀⣠⣹⣿⠋⠀
    ⠀⠀⠀⠀⠀⠀⠀⠻⣷⣀⣀⠀⠈⠈⠘⣿⡇⡿⠃⣸⢸⣿⢀⣠⣦⡿⠛⠁⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠳⠶⣤⣴⣾⣿⣠⡇⠐⣇⣿⣿⠿⠛⠉⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢉⣿⠁⠀⠀⣹⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣧⡀⠀⣀⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⢧⡟⠁⣾⢻⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⠞⠃⢠⣆⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠃⠀⠀⠀⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⡄⠀⡀⣸⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡏⣼⠋⣸⢹⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣷⠿⠀⢫⣾⠁⠀⠀⠀⡠⠚⢉⣉⠓⣦⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠀⠀⢰⡟⠀⠀⢀⣼⢱⣿⣾⣿⣷⣼⡄⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣆⠀⢠⣾⠇⠀⣼⡥⢃⣾⣿⣿⣿⡟⠈⠻⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⡇⡿⠂⢸⣸⠀⢰⣏⠔⠛⠛⢻⣿⣿⣧⢠⡄⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⡇⠀⠘⢿⡆⠸⣇⠀⠀⠀⠀⠈⠉⠉⣩⠇⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣷⣦⡄⠸⣷⡀⢹⣷⠄⠀⠀⢠⣤⠾⠃⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡍⠳⠤⠾⠿⠛⠁⠀⠀⣨⡿⠁⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣄⠀⠀⠀⠀⢀⠀⢤⡾⠁⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠓⠦⣴⣴⣶⠶⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀
    Enter the password: password
    We understand the significance of this tool in fulfilling our noble cause,
    but only those with the right credentials may gain entry.
    
    Should you require further assistance or have any concerns, get familiar with mutant's compiler
    Together, we shall uphold the integrity of our mission and the safety of our fellow Death Eaters.
    May the darkness guide us towards victory,
    
    The Dark Lord's Loyal Servants
    

    Obviously, the password fails. (Creator secret: bruteforcing the password won't work as the password is damn long). The code runs and it looks like the flag is hidden behind its source code. The code looks like base64 so maybe we can decode it. Let's try decoding with the hello world program. Looking in the hello.mu file, we can notice that the encoded code starts with MU| and ends with |ANT. The text in between looks like base64. Further, there are two strings wrapped between MUT| and |ANT in this encoded text.

    QTVCdVo3ZWFwMjllZSt1SURnTlp5OTVtRlg0eHl2T3lmdC95LzdBeGhlVFhWRXliUDZ3N2x0TCtabzB4WlYzb3dVY1lLcFRMMVJVZTQrbUJrMmZvMzljUFN2TVRKejRyUkNKK1V4SURnek83cWl5bitlem1vTHZBUFRTWmdLWlk2Vk43d1BOa003bzhKcEQ1RnExWUQreDk3dVc3WW82eTRzUjFsTzdlbk1BMTVtK2VNS1V3RWNEOVA2QlE4Z1pnOXJUalpnSHFnbEJQZEdjRVhJRTNTUEg1emUxL2R3QWl3aUM5VnMvSVpxL3dabmhtSzZrdnUra2hxVlRWVytZemZHRklUYUk4RUJzY08wSnZObWpZZ3lVekJ4NjVVWkJoQVlSa3NnPT18NmFhM2RkNWY1ZDVkNTQxZTI1MjgzOTFmMzMzODM5NWRhM2RlNWM1ZDVlNWQ1MDE1MzIyZjI4MmUyOTNmMjgzNQ==
    

    and

    5154564364566f335a5746774d6a6c6c5a5374315355526e546c70354f545674526c673065486c3254336c6d644339354c7a64426547686c5646685752586c6955445a334e32783054437461627a4234576c597a6233645659316c4c6346524d4d564a565a54517262554a724d6d5a764d7a6c6a55464e325456524b656a5279556b4e4b4b3156345355526e656b383363576c356269746c656d317654485a4255465254576d644c576c6b32566b34336431424f61303033627a684b63455131526e45785755517265446b3364566333575738326554527a556a4673547a646c626b31424d5456744b32564e5331563352574e454f564132516c45345a31706e4f584a55616c706e5348466e62454a515a45646a5256684a52544e5455456731656d55784c32523351576c3361554d35566e4d76535670784c336461626d6874537a5a72646e557261326878566c52575679745a656d5a48526b6c5559556b3452554a7a59303877536e5a4f6257705a5a336c56656b4a344e6a5656576b4a6f51566c5361334e6e505431384e6d46684d32526b4e5759315a44566b4e5451785a5449314d6a677a4f54466d4d7a4d7a4f444d354e5752684d32526c4e574d315a44566c4e5751314d4445314d7a49795a6a49344d6d55794f544e6d4d6a677a4e513d3dd41d8cd98f00b204e9800998ecf8427e
    

    Decoding the first base64 string, we get

    A5BuZ7eap29ee+uIDgNZy95mFX4xyvOyft/y/7AxheTXVEybP6w7ltL+Zo0xZV3owUcYKpTL1RUe4+mBk2fo39cPSvMTJz4rRCJ+UxIDgzO7qiyn+ezmoLvAPTSZgKZY6VN7wPNkM7o8JpD5Fq1YD+x97uW7Yo6y4sR1lO7enMA15m+eMKUwEcD9P6BQ8gZg9rTjZgHqglBPdGcEXIE3SPH5ze1/dwAiwiC9Vs/IZq/wZnhmK6kvu+khqVTVW+YzfGFITaI8EBscO0JvNmjYgyUzBx65UZBhAYRksg==|6aa3dd5f5d5d541e2528391f3338395da3de5c5d5e5d5015322f282e293f2835
    

    This again looks like two strings separated with a vertical bar. Decoding the base64 again we get gibberish code which is a binary file.

    ��ng·�§o^{ë���YËÞf�~1Êó²~ßòÿ°1�ä×TL�?¬;�Òþf�1e]èÁG�*�ËÕ��ãé��gèß×�Jó�'>+D"~S���3»ª,§ùìæ »À=4��¦XéS{Àód3º<&�ù�­X�ì}îå»b�²âÄu�îÞ�À5æo�0¥0�Àý? Pò�`ö´ãf�ê�POtg�\�7HñùÍí�w�" ½VÏÈf¯ðfxf+©/»é!©TÕ[æ3|aHM¢<���;Bo6hØ�%3��¹Q�a��d²
    

    Let's run binwalk on this

    $ echo "A5BuZ7eap29ee+uIDgNZy95mFX4xyvOyft/y/7AxheTXVEybP6w7ltL+Zo0xZV3owUcYKpTL1RUe4+mBk2fo39cPSvMTJz4rRCJ+UxIDgzO7qiyn+ezmoLvAPTSZgKZY6VN7wPNkM7o8JpD5Fq1YD+x97uW7Yo6y4sR1lO7enMA15m+eMKUwEcD9P6BQ8gZg9rTjZgHqglBPdGcEXIE3SPH5ze1/dwAiwiC9Vs/IZq/wZnhmK6kvu+khqVTVW+YzfGFITaI8EBscO0JvNmjYgyUzBx65UZBhAYRksg==" | base64 --decode - > /tmp/binary_found_in_mu
    $ binwalk /tmp/binary_found_in_mu
    
    DECIMAL       HEXADECIMAL     DESCRIPTION
    --------------------------------------------------------------------------------
    

    Looks like the file does not contain any known binary. Let's see what kind of file is it.

    $ file /tmp/binary_found_in_mu
    /tmp/binary_found_in_mu: data
    

    Running strings is no luck as well. At this point, the code is just unreadable. But the compiler is reading it somehow. Let's dive into the compiler's source code to understand how it works.

    $ git clone https://github.com/gaurav-gogia/mutant
    

    Now lets start with main.go. As we know the compiler does two things, compile the code and run the code. We are interested in the running process. Looking in the main.go file, we find the following code

    if strings.HasSuffix(os.Args[1], global.MutantByteCodeCompiledFileExtension) {
        cli.RunCode(os.Args[1])
        return
    }
    

    Let's dig in further by reading the cli/cli.go file as the above code is giving the file name to cli.RunCode function. Within the cli/cli.go file, we find the RunCode function

    func RunCode(src string) {
        srcpath, err := filepath.Abs(src)
        if err != nil {
            fmt.Println(err)
            return
        }
    
        if err, errtype := runner.Run(srcpath); err != nil {
            switch errtype {
            case errrs.ERROR:
                fmt.Println(err)
            case errrs.VM_ERROR:
                errrs.PrintMachineError(os.Stdout, err.Error())
            }
        }
    }
    

    Here, the user provided file path is converted to absolute path and sent to runner.Run function. Lets look into that in file runner/runner.go

    func Run(srcpath string) (error, errrs.ErrorType) {
        signedCode, err := ioutil.ReadFile(srcpath)
        if err != nil {
            return err, errrs.ERROR
        }
    
        if err := security.VerifyCode(signedCode); err != nil {
            return err, errrs.ERROR
        }
    
        bytecode, err := decode(signedCode)
        if err != nil {
            return err, errrs.ERROR
        }
    
        return runvm(bytecode)
    }
    

    This is an interesting function. It is verifying and decodes the code and sending the bytecode to runvm. We are interested in decoding the code. The decode function is right below this Run function and looks like this:

    func decode(data []byte) (*compiler.ByteCode, error) {
        decodedData, err := decryptCode(data)
        if err != nil {
            return nil, err
        }
        reader := bytes.NewReader(decodedData)
    
        var bytecode *compiler.ByteCode
        registerTypes()
        dec := gob.NewDecoder(reader)
        if err := dec.Decode(&bytecode); err != nil {
            return nil, err
        }
    
        return bytecode, nil
    }
    

    We got another trail here, decryptCode. It seems decodedData is a serialized gob and bytecode contains the deserialized go object (struct). Gob is a serialization in Golang. Let's understand how decryptCode works now. The decryptCode function is also in the same file

    func decryptCode(signedCode []byte) ([]byte, error) {
        encryptedCode := security.GetEncryptedCode(signedCode)
        decryptedData, err := security.AESDecrypt(encryptedCode)
        if err != nil {
            return nil, err
        }
        decodedData := security.XOR(decryptedData, len(decryptedData))
        return decodedData, nil
    }
    

    Here, we see that the compiler is decrypting with AES. We can also notice it calling security.GetEncryptedCode. It is calling a user-defined function security.AESDecrypt which is in mutant/security module. We should look into it as well as security.XOR, let's read security/signatures.go and security/crypto.go one by one.

    In security/signatures.go, we find VerifyCode

    func VerifyCode(signedCode []byte) error {
        signedCodeString := string(signedCode)
        values := strings.Split(signedCodeString, SEPERATOR)
    
        if values[0] != HEADER {
            return ErrWrongSignature
        }
    
        integrity := md5.New().Sum([]byte(values[1]))
        integString := hex.EncodeToString(integrity)
        if integString != values[2] {
            return ErrWrongSignature
        }
    
        if values[3] != FOOTER {
            return ErrWrongSignature
        }
    
        return nil
    }
    

    This just raises an error if the hexes don't match. It splits the signed code using SEPERATOR. This SEPERATOR constant can be found in security/const.go as |. So we know that we have been doing the same thing manually. After split, we get values[0] which is "MUT". Later it creates an MD5 hash to check the integrity of the code which is the second string value s[1] (base64) in the mut file. It then matches the hash with values[2] which is the hex string we had. Finally, it matches FOOTER which is "ANT". Now we know that the base64 encoded string is the code.

    We also find GetEncryptedCode. This seems to be splitting the code with the same method mentioned above and returning the base64 encoded code.

    func GetEncryptedCode(signedCode []byte) string {
        signedCodeString := string(signedCode)
        return strings.Split(signedCodeString, SEPERATOR)[1]
    }
    

    In security/crypto.go we have XOR which is the usual XOR function, and AESDecrypt, let's read it:

    func AESDecrypt(encodedCipherData string) ([]byte, error) {
        cipData, err := base64.StdEncoding.DecodeString(encodedCipherData)
        if err != nil {
            return nil, err
        }
    
        values := strings.Split(string(cipData), SEPERATOR)
        cipherString := values[0]
        keyString := values[1]
    
        cypher, err := base64.StdEncoding.DecodeString(cipherString)
        if err != nil {
            return nil, err
        }
        key, err := hex.DecodeString(keyString)
        if err != nil {
            return nil, err
        }
    
        c, err := aes.NewCipher(key)
        if err != nil {
            return nil, err
        }
    
        gcm, err := cipher.NewGCM(c)
        if err != nil {
            return nil, err
        }
    
        nonceSize := gcm.NonceSize()
        if len(cypher) < nonceSize {
            return nil, errors.New("wrong nonce")
        }
    
        nonce, cipherText := cypher[:nonceSize], cypher[nonceSize:]
        data, err := gcm.Open(nil, nonce, cipherText, []byte(ENCSIG))
    
        return data, nil
    }
    

    It starts with base64 decode of the data provided by GetEncryptedCode, then splits it further. We already know that the code is twice base64 encoded. Now we have two things, a cipherString and keyString. These both are used to decrypt the AES. This means that the second hex string we found was the key for AES. Now we can either create our own AES decryption script or we could just utilize what Mutant's source code provides us.

    I chose the second part as it is easier. I created a new file called deobfuscate-mutant.go at the root of the mutant language. I will use this to write my deobfuscator. We know that the function decode decodes the whole code and gives a compiler.ByteCode struct. But since decode is a private function (only names with first letter uppercase are publicly accessible in go), we need to create a new publicly accessible decode. To do this, I added a wrapper function in runner/runner.go next to the decode function as follows

    func Decode(data []byte) (*compiler.ByteCode, error) {
        return decode(data)
    }
    

    Now, we can call decode through runner.Decode in our deobfuscate-mutant.go.

    package main
    
    import (
        "io/ioutil"
        "mutant/runner"
        "os"
        "fmt"
    )
    
    func main() {
        signedCode, _ := ioutil.ReadFile(os.Args[1])
        byteCode, _ := runner.Decode(signedCode)
        fmt.Println(byteCode)
    }
    

    Now I tried running the code with go run new-obfuscate.go death.mu but it is stuck in an infinite loop. Looks like something's stopping the print. Let's look into the compiler.ByteCode structure returned by runner.Decode. The code is in compiler/compiler.go file

    type ByteCode struct {
        Instructions code.Instructions
        Constants    []object.Object
    }
    

    This is interesting. The code is not stored as is but in assembly like code structure. There are instructions and constants. If you are familiar with the basics of assembly, you might know that each instruction has operators and operands. The same can also be called instructions and constants. There is more to it. This struct is instantiated by ByteCode function down below

    func (c *Compiler) ByteCode() *ByteCode {
        return &ByteCode{
            Instructions: c.currentInstructions(),
            Constants:    c.constants,
        }
    }
    

    Here. we find that c which is Compiler object has constants and currentInstructions. We have a ByteCode object (struct). That means we can call Constants and see the constant values stored within the memory of this compiler during runtime. Let's try to print them to stdout.

    package main
    
    import (
        "io/ioutil"
        "mutant/runner"
        "os"
        "fmt"
    )
    
    func main() {
        signedCode, _ := ioutil.ReadFile(os.Args[1])
        byteCode, _ := runner.Decode(signedCode)
        fmt.Println(byteCode.Constants)
    }
    

    Running the code on hello.mu, we get:

    $ go run deobfuscate-mutant.go hello.mu
    [0xc00006d320]
    

    Looks like this array of hexadecimal here. Let's try to get the first value as string.

    package main
    
    import (
        "io/ioutil"
        "mutant/runner"
        "os"
        "fmt"
    )
    
    func main() {
        signedCode, _ := ioutil.ReadFile(os.Args[1])
        byteCode, _ := runner.Decode(signedCode)
        fmt.Println(string(byteCode.Constants[0]))
    }
    

    we get

    $ go run deobfuscate-mutant.go hello.mu
    # command-line-arguments
    ./deobfuscate-mutant.go:13:24: cannot convert byteCode.Constants[0] (variable of type object.Object) to type string
    

    So byteCode.Constants is an array of object.Object which is in file object/object.go. In object/object.go,

    package object
    
    type ObjectType string
    
    const (
        INTEGER_OBJ      = "INTEGER"
        BOOLEAN_OBJ      = "BOOLEAN"
        NULL_OBJ         = "NULL"
        RETURN_VALUE_OBJ = "RETURN_VALUE"
        ERROR_OBJ        = "ERROR_OBJ"
        FUNCTION_OBJ     = "FUNCTION"
        STRING_OBJ       = "STRING"
        BUILTIN_OBJ      = "BUILTIN"
        ARRAY_OBJ        = "ARRAY"
        HASH_OBJ         = "HASH"
        QUOTE_OBJ        = "QUOTE"
        MACRO_OBJ        = "MACRO"
        COMPILED_FN_OBJ  = "COMPILED_FN_OBJ"
        CLOSURE_OBJ      = "CLOSURE"
        ENCRYPTED_OBJ    = "ENCRYPTED"
    )
    
    type Object interface {
        Type() ObjectType
        Inspect() string
    }
    

    we find an interface. Further, we see the data types. So ByteCode.Constants contain the data. Let's look at a few more data-type objects like string. In object/stringObj.go we find the code

    package object
    
    type String struct{ Value string }
    
    func (s *String) Type() ObjectType { return STRING_OBJ }
    func (s *String) Inspect() string  { return s.Value }
    

    Again, there's Inspect function in this object. Let's try to call that in our deobfuscate-mutant.go

    package main
    
    import (
        "io/ioutil"
        "mutant/runner"
        "os"
        "fmt"
    )
    
    func main() {
        signedCode, _ := ioutil.ReadFile(os.Args[1])
        byteCode, _ := runner.Decode(signedCode)
        fmt.Println(byteCode.Constants[0].Inspect())
    }
    

    But the result is almost the same. We are still in an array of numerics. If you look closely, the array is of exact length as "Hello, World!" string. And there are repititve letters same as well, for example, 60 60 signifies ll in Hello. But let's try to read the code instead of doing mathematical magic here. There is not much information in objects about these numbers. To understand what these numbers are, we need to run the code the way the virtual machine does. So we move back to our runner/runner.go and try to read Run function again.

    func Run(srcpath string) (error, errrs.ErrorType) {
        signedCode, err := ioutil.ReadFile(srcpath)
        if err != nil {
            return err, errrs.ERROR
        }
    
        if err := security.VerifyCode(signedCode); err != nil {
            return err, errrs.ERROR
        }
    
        bytecode, err := decode(signedCode)
        if err != nil {
            return err, errrs.ERROR
        }
    
        return runvm(bytecode)
    }
    

    We don't need to verify the integrity of our code, and we have used Decode that calls decode which gives us ByteCode struct in our code similar to this Run function. In the end, it uses runvm which we haven't checked out yet. So let's look into it. In the runner/runner.go we have this runvm function:

    func runvm(bytecode *compiler.ByteCode) (error, errrs.ErrorType) {
        globals := make([]object.Object, global.GlobalSize)
        machine := vm.NewWithGlobalStore(bytecode, globals)
    
        if err := machine.Run(); err != nil {
            return err, errrs.VM_ERROR
        }
    
        last := machine.LastPoppedStackElement()
        io.WriteString(os.Stdout, last.Inspect())
        io.WriteString(os.Stdout, "\n")
    
        return nil, ""
    }
    

    Here it is doing some globals thing, creating a machine and then running it. After running, we see it also calls machine.LastPoppedStackElement which suggests there's a stack of something. You might know that a computer calls instructions from a stack from top to bottom order.

    Finally, we notice that there's last.Inspect() call which we did in our deobfuscator too. We look further into the vm.NewWithGlobalStore to understand how it works. In vm/vm.go we find this code:

    func NewWithGlobalStore(bc *compiler.ByteCode, globals []object.Object) *VM {
        vm := New(bc)
        vm.globals = globals
        return vm
    }
    

    and New which the above function uses to create vm is:

    func New(bc *compiler.ByteCode) *VM {
        mainfn := &object.CompiledFunction{Instructions: bc.Instructions}
        frames := make([]*Frame, global.MaxFrames)
    
        mainClosure := &object.Closure{Fn: mainfn}
        mainFrame := NewFrame(mainClosure, 0)
        frames[0] = mainFrame
    
        return &VM{
            constants:    bc.Constants,
            stack:        make([]object.Object, global.StackSize),
            stackPointer: 0,
            globals:      make([]object.Object, global.GlobalSize),
            frames:       frames,
            frameIndex:   1,
            inslen:       len(bc.Instructions),
        }
    }
    

    Here, we notice that it takes a ByteCode and assigns a few things to the VM struct. We see constants, but no instructions assigned. There are also other frame and closure things we probably don't know about nor we are interested in. What we are looking for is a way to decode those numeric values. So we go back and look at the next important function call in runvm function, machine.Run. This function also is in vm/vm.go

    func (vm *VM) Run() error {
        var ip int
        var ins code.Instructions
        var op code.Opcode
    
        for vm.currentFrame().ip < len(vm.currentFrame().Instructions())-1 {
            vm.currentFrame().ip++
    
            ip = vm.currentFrame().ip
            ins = vm.currentFrame().Instructions()
            ins[ip] = security.XOROne(ins[ip], vm.inslen)
            op = code.Opcode(ins[ip])
            ins[ip] = security.XOROne(ins[ip], vm.inslen)
    
            switch op {
            case code.OpConstant:
                constIndex := code.ReadUint16(ins[ip+1:], vm.inslen)
                vm.currentFrame().ip += 2
    
                if err := vm.push(vm.constants[constIndex]); err != nil {
                    return err
                }
            case code.OpBang:
                if err := vm.executeBangOperation(); err != nil {
                    return err
                }
            case code.OpMinus:
                if err := vm.executeMinusOperation(); err != nil {
                    return err
                }
            case code.OpAdd, code.OpSub, code.OpMul, code.OpDiv:
                if err := vm.execBinaryOperation(op); err != nil {
                    return err
                }
            case code.OpTrue:
                if err := vm.push(global.True); err != nil {
                    return err
                }
            case code.OpFalse:
                if err := vm.push(global.False); err != nil {
                    return err
                }
            case code.OpArray:
                numElements := int(code.ReadUint16(ins[ip+1:], vm.inslen))
                vm.currentFrame().ip += 2
                array := vm.buildArray(vm.stackPointer-numElements, vm.stackPointer)
                if err := vm.push(array); err != nil {
                    return err
                }
            case code.OpHash:
                numElements := int(code.ReadUint16(ins[ip+1:], vm.inslen))
                vm.currentFrame().ip += 2
                hash, err := vm.buildHash(vm.stackPointer-numElements, vm.stackPointer)
                if err != nil {
                    return err
                }
                vm.stackPointer = vm.stackPointer - numElements
                if err := vm.push(hash); err != nil {
                    return err
                }
            case code.OpEqual, code.OpUnEqual, code.OpGreater:
                if err := vm.executeComparison(op); err != nil {
                    return err
                }
            case code.OpJump:
                pos := int(code.ReadUint16(ins[ip+1:], vm.inslen))
                vm.currentFrame().ip = pos - 1
            case code.OpJumpFalse:
                pos := int(code.ReadUint16(ins[ip+1:], vm.inslen))
                vm.currentFrame().ip += 2
                condition := vm.pop()
                if !isTruthy(condition) {
                    vm.currentFrame().ip = pos - 1
                }
            case code.OpSetGlobal:
                globalIndex := code.ReadUint16(ins[ip+1:], vm.inslen)
                vm.currentFrame().ip += 2
                vm.globals[globalIndex] = vm.pop()
            case code.OpGetGlobal:
                globalIndex := code.ReadUint16(ins[ip+1:], vm.inslen)
                vm.currentFrame().ip += 2
                if err := vm.push(vm.globals[globalIndex]); err != nil {
                    return err
                }
            case code.OpSetLocal:
                localIndex := code.ReadUint8(ins[ip+1:], vm.inslen)
                vm.currentFrame().ip++
                frame := vm.currentFrame()
                obj := vm.pop()
                encObj, err := mutil.EncryptObject(obj, vm.inslen)
                if err != nil {
                    vm.stack[frame.bp+int(localIndex)] = obj
                } else {
                    vm.stack[frame.bp+int(localIndex)] = encObj
                }
            case code.OpGetLocal:
                localIndex := code.ReadUint8(ins[ip+1:], vm.inslen)
                vm.currentFrame().ip++
                frame := vm.currentFrame()
                if err := vm.push(vm.stack[frame.bp+int(localIndex)]); err != nil {
                    return err
                }
            case code.OpGetBuiltin:
                builtinIndex := code.ReadUint8(ins[ip+1:], vm.inslen)
                vm.currentFrame().ip++
                definition := object.Builtins[builtinIndex]
                if err := vm.push(definition.Builtin); err != nil {
                    return err
                }
            case code.OpGetFree:
                freeIndex := code.ReadUint8(ins[ip+1:], vm.inslen)
                vm.currentFrame().ip++
                currentClosure := vm.currentFrame().cl
                if err := vm.push(currentClosure.Free[freeIndex]); err != nil {
                    return err
                }
            case code.OpIndex:
                index := vm.pop()
                left := vm.pop()
                if err := vm.execIndexOperation(left, index); err != nil {
                    return err
                }
            case code.OpClosure:
                constIndex := code.ReadUint16(ins[ip+1:], vm.inslen)
                numFree := code.ReadUint8(ins[ip+3:], vm.inslen)
                vm.currentFrame().ip += 3
                if err := vm.pushClosure(int(constIndex), int(numFree)); err != nil {
                    return err
                }
            case code.OpCurrentClosure:
                currentClosure := vm.currentFrame().cl
                if err := vm.push(currentClosure); err != nil {
                    return err
                }
            case code.OpCall:
                numArgs := code.ReadUint8(ins[ip+1:], vm.inslen)
                vm.currentFrame().ip++
                if err := vm.executeCall(int(numArgs)); err != nil {
                    return err
                }
            case code.OpReturnValue:
                returnValue := vm.pop()
                frame := vm.popFrame()
                vm.stackPointer = frame.bp - 1
                if err := vm.push(returnValue); err != nil {
                    return err
                }
            case code.OpReturn:
                frame := vm.popFrame()
                vm.stackPointer = frame.bp - 1
                if err := vm.push(global.Null); err != nil {
                    return err
                }
            case code.OpNull:
                if err := vm.push(global.Null); err != nil {
                    return err
                }
            case code.OpPop:
                vm.pop()
            }
        }
        return nil
    }
    

    This is an interesting one. It is checking for the OpCode using a switch case statement. The switch is matching for op which comes from op = code.Opcode(ins[ip]). ins here is an array of instructions and ip stands for instruction pointer which tells which instruction to read.

    There are a few XOROne running to flip the instruction pointer here and there. Interestingly, there are vm.push call which is very likely pushing instructions to the stack to run. Let's confirm that by looking at the code. The same file, we see

    func (vm *VM) push(obj object.Object) error {
        if vm.stackPointer >= global.StackSize {
            return fmt.Errorf("stack overflow")
        }
    
        if encObj, err := mutil.EncryptObject(obj, vm.inslen); err == nil {
            obj = encObj
        }
    
        vm.stack[vm.stackPointer] = obj
        vm.stackPointer++
    
        return nil
    }
    

    and this push function calls EncryptObject to encrypt the object while being pushed. Let's look into that. EncryptObject comes from mutil/util.go file

    func EncryptObject(obj object.Object, length int) (object.Object, error) {
        var encObj object.Object
        var err error
    
        switch obj.Type() {
        case object.INTEGER_OBJ:
            val := obj.(*object.Integer).Value
            bite := make([]byte, 8)
            binary.LittleEndian.PutUint64(bite, uint64(val))
            bite = security.XOR(bite, length)
    
            encObj = &object.Encrypted{
                EncType: object.INTEGER_OBJ,
                Value:   bite,
            }
    
        case object.STRING_OBJ:
            val := obj.(*object.String).Value
            bite := security.XOR([]byte(val), length)
    
            encObj = &object.Encrypted{
                EncType: object.STRING_OBJ,
                Value:   bite,
            }
    
        case object.BOOLEAN_OBJ:
            val := obj.(*object.Boolean).Value
            str := strconv.FormatBool(val)
            bite := security.XOR([]byte(str), length)
    
            encObj = &object.Encrypted{
                EncType: object.BOOLEAN_OBJ,
                Value:   bite,
            }
    
        default:
            err = errors.New("wrong obj type")
        }
    
        return encObj, err
    }
    

    This function is doing XOR over the values of the object and returns them as object.Encrypted which is then being used in the vm.stack. Here, we notice that this function encrypts object.Object. Since there is an EncryptObject function, there might be a DecryptObject too. We find that in the same mutil/util.go file right below EncryptObject function

    func DecryptObject(obj object.Object, length int) (object.Object, error) {
        decObj := obj
        var err error
    
        if decObj.Type() == object.ENCRYPTED_OBJ {
            biteVal := decObj.(*object.Encrypted).Value
            bite := make([]byte, len(biteVal))
            copy(bite, biteVal)
            bite = security.XOR(bite, length)
    
            switch decObj.(*object.Encrypted).EncType {
            case object.INTEGER_OBJ:
                val := binary.LittleEndian.Uint64(bite)
                decObj = &object.Integer{Value: int64(val)}
    
            case object.STRING_OBJ:
                decObj = &object.String{Value: string(bite)}
    
            case object.BOOLEAN_OBJ:
                str := strings.ToLower(string(bite))
                if str == "true" {
                    decObj = global.True
                } else {
                    decObj = global.False
                }
            }
    
            return decObj, nil
        }
    
        err = errors.New("wrong obj type")
        return obj, err
    }
    

    Here, we see that it is taking object.Encrypted and performs the reverse of XOR and returns the exact object. Reading all these we learned two things. Let's use this in our deobfuscate-mutant.go:

    package main
    
    import (
        "io/ioutil"
        "mutant/runner"
        "os"
        "fmt"
        "mutant/mutil"
    )
    
    func main() {
        signedCode, _ := ioutil.ReadFile(os.Args[1])
        byteCode, _ := runner.Decode(signedCode)
        deobfuscatedObj, _ := mutil.DecryptObject(byteCode.Constants[0], len(byteCode.Instructions))
        fmt.Println(deobfuscatedObj.Inspect())
    }
    

    and running it:

    $ go run deobfuscate-mutant.go hello.mu
    Hello, World!
    

    We got the data! But we are only reading the first constant. Let's try to decrypt all constants.

    package main
    
    import (
        "io/ioutil"
        "mutant/mutil"
        "mutant/runner"
        "os"
        "fmt"
    )
    
    func main() {
        signedCode, _ := ioutil.ReadFile(os.Args[1])
        byteCode, _ := runner.Decode(signedCode)
    
        for i := 0; i < len(byteCode.Constants); i++ {
            obfuscatedObj := byteCode.Constants[i]
            deobfuscatedObj, _ := mutil.DecryptObject(obfuscatedObj, len(byteCode.Instructions))
            fmt.Println(deobfuscatedObj.Inspect());
        }
    }
    

    Let's try running it on our death.mu which contains the challenge flag

    $ go run deobfuscate-mutant.go death.mu
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⠶⠟⠛⠛⠛⠶⢦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⢠⡾⠋⠀⠀⠀⠀⠀⠀⠀⠀⠉⢷⡀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⢠⣿⠁⠀⠀⡀⠀⠀⠀⠀⠀⠀⠀⣾⣷⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⣾⠟⢉⣀⣀⡈⠃⠀⠀⠒⣉⣀⡀⠈⢻⡄⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⡏⠀⣴⣶⣿⣿⣷⠂⠀⣾⣿⣿⣿⣆⢠⡇⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⢸⣿⠀⠻⠿⢿⡿⠃⣰⣆⠙⣿⡿⠿⠋⠸⣧⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⣿⠁⠀⠀⠀⠈⠀⠠⣿⠿⠀⠀⣀⣀⣀⠀⣿⣦⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⣼⣿⣶⣾⣿⣿⡟⢀⠀⠀⠀⢀⢀⢻⣿⣿⣿⣿⢻⡇⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⣇⢸⡇⠻⢿⣿⠇⡜⢸⠀⡇⢸⠘⣼⣿⠿⠉⠙⣿⡇⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⣿⣾⣿⣦⠀⣿⣷⣷⣾⣤⣷⣾⣿⣿⢋⣴⣶⣶⣿⡀⠀⠀⠀⠀⠀
    ⠀⠀⠀⣠⠞⠙⠻⣿⣿⣷⣿⣿⣿⠿⠿⠻⠟⠋⠀⣼⣿⣿⡿⣻⣿⣦⡀⠀⠀⠀
    ⠀⢀⡼⢿⡦⣠⣴⢿⣿⣿⣿⣏⣿⣤⠀⠀⢰⡔⣶⣾⣿⠏⠀⠀⠀⣿⣿⣄⠀⠀
    ⠀⡾⢡⣏⢰⣯⠃⣼⣿⡿⢿⡟⢿⡋⠀⠀⢸⣽⣿⣿⡿⣇⠀⠀⠀⢈⡿⡿⣆⠀
    ⢸⡿⠿⠏⢰⠇⢸⡿⠋⠀⠀⣿⡟⠀⠀⠀⠈⡟⠀⠉⠳⣿⣿⠆⠀⢿⣙⡇⣿⡄
    ⣿⠀⠀⠀⢸⢰⣿⠁⠀⠀⠀⢸⣧⣤⠀⠀⡼⡇⠀⠀⠀⢹⣾⠀⠀⠈⢻⡇⢹⡇
    ⣿⣿⣷⠀⢸⣸⣿⠀⠀⠀⠀⠀⢷⣿⠀⠀⠳⡇⠀⠀⠀⢸⡟⠀⠀⠀⡸⠀⢼⡇
    ⢿⣟⠋⠀⢸⡿⣿⠀⠀⠀⠀⠀⠘⣿⢲⣦⠀⢹⡀⠀⠀⡼⠀⣤⣤⣴⠃⢠⣾⠇
    ⠸⡏⣿⠆⠘⢷⣼⣷⣄⠀⠀⠀⠀⠹⣿⡇⠀⠘⢵⣤⡾⢁⡤⣡⠞⠁⠀⣸⠟⠀
    ⠀⠹⣧⠀⢀⣀⠀⠸⣯⣽⣷⣦⣄⡀⢻⣷⣦⣄⣤⠙⣷⡼⠞⠁⣀⢄⣾⠏⠀⠀
    ⠀⠀⠈⠻⣟⠙⢧⣀⣀⠀⠘⢳⣾⣿⣿⣿⣿⣮⡻⣤⡌⠛⢶⣵⣵⡿⠁⠀⠀⠀
    ⠀⠀⠀⠀⠈⠳⢶⣤⣿⣦⠖⡉⠕⠊⢉⣿⣿⣿⣷⣾⣧⣖⣦⠙⢿⣄⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⣸⠟⠠⠈⠀⢀⣰⣿⣿⣿⣿⣿⣟⢿⣿⣿⣠⡴⢮⢳⣄⠀⠀
    ⠀⠀⠀⠀⠀⠀⣼⡫⠂⠀⠀⠀⣶⡿⣿⣿⣿⠁⠘⢿⣆⠙⣿⣿⣅⢺⡇⠛⢷⡄
    ⠀⠀⠀⠀⠀⢰⣿⠁⠀⠀⠀⣼⠏⠀⠈⢿⣿⠀⠀⢀⣿⠀⢸⣿⢿⣿⣷⢺⡆⣿
    ⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⢰⣿⠀⠀⠀⠈⣏⢻⡇⢷⣾⡇⢸⣿⠃⠘⢿⣼⣧⣿
    ⠀⠀⠀⠀⠀⢸⣇⠀⠀⠀⢉⢿⣆⠀⠀⠀⣿⡟⠀⠀⢹⣷⣿⡏⠀⠀⢽⣿⣿⠏
    ⠀⠀⠀⠀⠀⠀⢻⡆⠀⠀⠀⠸⢻⢿⣶⣶⣿⢻⡆⢀⣼⣿⠏⠀⠀⣠⣹⣿⠋⠀
    ⠀⠀⠀⠀⠀⠀⠀⠻⣷⣀⣀⠀⠈⠈⠘⣿⡇⡿⠃⣸⢸⣿⢀⣠⣦⡿⠛⠁⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠳⠶⣤⣴⣾⣿⣠⡇⠐⣇⣿⣿⠿⠛⠉⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢉⣿⠁⠀⠀⣹⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣧⡀⠀⣀⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⢧⡟⠁⣾⢻⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⠞⠃⢠⣆⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠃⠀⠀⠀⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⡄⠀⡀⣸⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡏⣼⠋⣸⢹⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣷⠿⠀⢫⣾⠁⠀⠀⠀⡠⠚⢉⣉⠓⣦⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠀⠀⢰⡟⠀⠀⢀⣼⢱⣿⣾⣿⣷⣼⡄⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣆⠀⢠⣾⠇⠀⣼⡥⢃⣾⣿⣿⣿⡟⠈⠻⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⡇⡿⠂⢸⣸⠀⢰⣏⠔⠛⠛⢻⣿⣿⣧⢠⡄⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⡇⠀⠘⢿⡆⠸⣇⠀⠀⠀⠀⠈⠉⠉⣩⠇⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣷⣦⡄⠸⣷⡀⢹⣷⠄⠀⠀⢠⣤⠾⠃⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡍⠳⠤⠾⠿⠛⠁⠀⠀⣨⡿⠁⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣄⠀⠀⠀⠀⢀⠀⢤⡾⠁⠀⠀⠀⠀⠀⠀⠀
    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠓⠦⣴⣴⣶⠶⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀
    sdlpfjui1wesrj3qkew4rj213k4j8(IASDH*(ADSY^(*AHSDOIJKJDFRKLW#M%RKLW#$J%)I#UIFSDJFKLSDHFOIJYU#)I$%I@#_O$KDFJHIOSDYFIO#JR%$KLJWMDSFKOSDF(I)CVXC&*V\)\(*&ERW#$(%)_@#*%()UJDFDSFJSDOPIFJ
    ASV{0bfu5c4710n_15_n07_3ncryp710n}
    We understand the significance of this tool in fulfilling our noble cause,
    but only those with the right credentials may gain entry.
    
    Should you require further assistance or have any concerns, get familiar with mutant's compiler
    Together, we shall uphold the integrity of our mission and the safety of our fellow Death Eaters.
    May the darkness guide us towards victory,
    
    The Dark Lord's Loyal Servants
    Compiled Function[0xc0000a1e60]
    Enter the password: 
    string
    

    We got the flag ASV{0bfu5c4710n_15_n07_3ncryp710n}.

    I hope you enjoyed it. It was a long read nearly 4200+ words including code. If you have read this far, congratulations.

    References