<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="4.4.1">Jekyll</generator><link href="http://localhost:4000/blog/feed.xml" rel="self" type="application/atom+xml" /><link href="http://localhost:4000/blog/" rel="alternate" type="text/html" /><updated>2026-11-17T12:21:35-08:00</updated><id>http://localhost:4000/blog/feed.xml</id><title type="html">max.xz.ax blog</title><subtitle>stuff that i do i guess... thanks, chop0</subtitle><entry><title type="html">KawaiiconCTF 2026 pwn/professors-hash: Obtaining RCE from a templated hash table implementation in C</title><link href="http://localhost:4000/blog/kawaiiconctf-professors-hash-table-pwn/" rel="alternate" type="text/html" title="KawaiiconCTF 2026 pwn/professors-hash: Obtaining RCE from a templated hash table implementation in C" /><published>2026-11-16T00:00:00-08:00</published><updated>2026-11-16T00:00:00-08:00</updated><id>http://localhost:4000/blog/kawaiiconctf-2026-professors-hash</id><content type="html" xml:base="http://localhost:4000/blog/kawaiiconctf-professors-hash-table-pwn/"><![CDATA[<h1 id="kawaiiconctf-2026---professors-hash">KawaiiconCTF 2026 - professors-hash</h1>

<p>How can something as simple as a dictionary get your computer hacked?</p>

<p><code class="language-plaintext highlighter-rouge">professors-hash</code> was an advanced pwn challenge that I wrote for Kawaiicon CTF,
organized by my friends at VuwCTF in New Zealand.
During the event, players were tasked with exploiting a custom
templated hashmap library written in C.
Players were provided the C source code for the hash table as well as
the compiled executable binary and libc used on the server, and were tasked to
obtain a remote shell through the program and read the flag on the filesystem.
This was my first time really playing with glibc internals in a pwn context,
and I recieved a lot of great advice from my friend <a href="https://github.com/c-bassx">cbass</a>,
who taught me about the interesting libc details that made the solution path possible.
In this author writeup, I will explain the inspiration and mechanisms surrounding this
binary exploitation challenge.</p>

<h2 id="the-inspiration">The Inspiration</h2>

<p>This challenge was inspired by my continued musings about hash tables,
one of my favorite data structures. Several months ago, I took a look at a hashmap implementation from my friend’s CS lecture, and noticed a some
of really cursed bugs in the code, and wanted to turn the concept into a
CTF challenge. So, as an exercise, I implemented a custom
hashmap library in C, and carefully analyzed how a simple bug could
result in a complete takeover by an attacker. My favorite finding ended up
being a pwn challenge at Kawaiicon CTF. In order to solve this challenge,
we need to first understand how a hash table works.</p>

<h2 id="what-is-a-hash-table">What Is a Hash Table?</h2>

<p>A hash table is a data structure that implements an associative key-value store
(otherwise known as a dictionary or a map). Essentially, a hash table uses
a special technique called hashing to look up, insert, and remove key-value pairs quickly.
Instead of searching through the entire list of entries for the requested key,
a hash table first passes the key through a hash function to compute an integer index
into an array of slots or buckets. From there, the algorithm can directly search
the exact slot where the data lives, improving up lookup time.
The hash function should deterministically map keys to a uniform distribution of integers,
so that different keys will get distributed to different buckets, maintaining an even load
on the data structure.
Internally, my implementation uses a separately-managed array list of keys and values
behind each slot index<sup id="fnref:1"><a href="#fn:1" class="footnote" rel="footnote" role="doc-noteref">1</a></sup>.</p>

<h2 id="how-did-i-design-it-in-c">How Did I Design It in C?</h2>

<p>I wanted to make a hashmap library that could be customized to operate over
a variety of keys and values, abstracting away the core search algorithms from the
specifics of the data behing handled. In C, there are two common approaches
to writing type-generic code.</p>

<p>The first approach is to make the core functions completely type-agnostic
using void pointers, requiring the user to fully specify how
to manipulate the data at runtime (through parameters such as the data size,
hash/comparison functions pointers, etc.). This <code class="language-plaintext highlighter-rouge">void *</code> pattern is ubiquitous
in the C standard library: some examples that come to mind are the
<code class="language-plaintext highlighter-rouge">memmem</code>, <code class="language-plaintext highlighter-rouge">qsort</code>, and <code class="language-plaintext highlighter-rouge">malloc</code> functions (don’t ask me why).
The second approach uses preprocessor macros to generate a concrete implementation
of the data structure at compile-time. This results in native functions and types
tailored for the specific use case, which do not require constantly juggling
metadata about the data being passed around. This is the approach I decided to go with.<sup id="fnref:2"><a href="#fn:2" class="footnote" rel="footnote" role="doc-noteref">2</a></sup></p>

<p>I created a special template C file which would generate the types and functions for the
hashmap based on provided preprocessor macros: including <code class="language-plaintext highlighter-rouge">hashmap.c</code> would
define struct types and functions based on the provided
<code class="language-plaintext highlighter-rouge">HASHMAP_KEY_TYPE</code>, <code class="language-plaintext highlighter-rouge">HASHMAP_VALUE_TYPE</code>, and so on.</p>

<h2 id="the-c-implementation">The C Implementation</h2>

<p>Finally, we’re ready to take a look at the actual code. The template creates
a custom heap-allocated struct for our hashmap, which contains slot pointers.
Here is the struct layout for our hashmap:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">struct</span> <span class="nf">HASHMAP_LABEL</span><span class="p">(</span><span class="n">_hashmap</span><span class="p">)</span> <span class="n">HASHMAP_LABEL</span><span class="p">(</span><span class="n">_hashmap_t</span><span class="p">);</span>

<span class="k">struct</span> <span class="nf">HASHMAP_LABEL</span><span class="p">(</span><span class="n">_hashmap</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">HASHMAP_VALUE_TYPE</span> <span class="o">*</span><span class="n">value_slots</span><span class="p">[</span><span class="n">HASHMAP_NUM_SLOTS</span><span class="p">];</span>
    <span class="n">HASHMAP_KEY_TYPE</span> <span class="o">*</span><span class="n">key_slots</span><span class="p">[</span><span class="n">HASHMAP_NUM_SLOTS</span><span class="p">];</span>
    <span class="kt">size_t</span> <span class="n">slot_capacities</span><span class="p">[</span><span class="n">HASHMAP_NUM_SLOTS</span><span class="p">];</span>
    <span class="kt">size_t</span> <span class="n">slot_sizes</span><span class="p">[</span><span class="n">HASHMAP_NUM_SLOTS</span><span class="p">];</span>
<span class="p">};</span>
</code></pre></div></div>

<p>To determine the slot that a given key belongs to, we run our hash function, and
mod it to fit within the number of slots we have. Once we know the slot index,
we use our equality comparator to check if we have a match in the key array.</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">static</span> <span class="kt">size_t</span>
<span class="nf">HASHMAP_INTERNAL_LABEL</span><span class="p">(</span><span class="n">_hashmap_slot_index</span><span class="p">)(</span><span class="n">HASHMAP_KEY_TYPE</span> <span class="k">const</span> <span class="o">*</span><span class="n">key</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">return</span> <span class="p">(</span><span class="kt">size_t</span><span class="p">)(</span><span class="n">HASHMAP_HASH_FUNC</span><span class="p">(</span><span class="n">key</span><span class="p">)</span> <span class="o">%</span> <span class="n">HASHMAP_NUM_SLOTS</span><span class="p">);</span>
<span class="p">}</span>

<span class="k">static</span> <span class="kt">size_t</span>
<span class="nf">HASHMAP_INTERNAL_LABEL</span><span class="p">(</span><span class="n">_hashmap_slot_find_index</span><span class="p">)(</span><span class="n">HASHMAP_LABEL</span><span class="p">(</span><span class="n">_hashmap_t</span><span class="p">)</span> <span class="k">const</span> <span class="o">*</span><span class="n">map</span><span class="p">,</span>
                                                  <span class="kt">size_t</span> <span class="n">slot_index</span><span class="p">,</span>
                                                  <span class="n">HASHMAP_KEY_TYPE</span> <span class="k">const</span> <span class="o">*</span><span class="n">key</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">map</span><span class="o">-&gt;</span><span class="n">slot_sizes</span><span class="p">[</span><span class="n">slot_index</span><span class="p">];</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">if</span> <span class="p">(</span><span class="n">HASHMAP_KEY_CMP_FUNC</span><span class="p">(</span><span class="o">&amp;</span><span class="n">map</span><span class="o">-&gt;</span><span class="n">key_slots</span><span class="p">[</span><span class="n">slot_index</span><span class="p">][</span><span class="n">i</span><span class="p">],</span> <span class="n">key</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
            <span class="k">return</span> <span class="n">i</span><span class="p">;</span>
        <span class="p">}</span>
    <span class="p">}</span>
    <span class="k">return</span> <span class="n">SIZE_MAX</span><span class="p">;</span> <span class="c1">// entry not found</span>
<span class="p">}</span>
</code></pre></div></div>

<p>With these primitives, we can easily implement our core map operations.
It’s fairly straightforward, and the exact details aren’t necessary
for the challenge, so I won’t show all of the source code here.
Here’s a taste of what the code looks like for the <code class="language-plaintext highlighter-rouge">get</code> operation:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">int</span>
<span class="nf">HASHMAP_LABEL</span><span class="p">(</span><span class="n">_hashmap_get</span><span class="p">)(</span><span class="n">HASHMAP_LABEL</span><span class="p">(</span><span class="n">_hashmap_t</span><span class="p">)</span> <span class="k">const</span> <span class="o">*</span><span class="n">map</span><span class="p">,</span>
                           <span class="n">HASHMAP_KEY_TYPE</span> <span class="k">const</span> <span class="o">*</span><span class="n">key</span><span class="p">,</span>
                           <span class="n">HASHMAP_VALUE_TYPE</span> <span class="o">*</span><span class="n">value_out</span><span class="p">)</span> <span class="p">{</span>
    <span class="kt">size_t</span> <span class="n">slot_index</span><span class="p">;</span>
    <span class="kt">size_t</span> <span class="n">entry_index</span><span class="p">;</span>

    <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">map</span> <span class="o">||</span> <span class="o">!</span><span class="n">key</span> <span class="o">||</span> <span class="o">!</span><span class="n">value_out</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>

    <span class="n">slot_index</span> <span class="o">=</span> <span class="n">HASHMAP_INTERNAL_LABEL</span><span class="p">(</span><span class="n">_hashmap_slot_index</span><span class="p">)(</span><span class="n">key</span><span class="p">);</span>
    <span class="n">entry_index</span> <span class="o">=</span> <span class="n">HASHMAP_INTERNAL_LABEL</span><span class="p">(</span><span class="n">_hashmap_slot_find_index</span><span class="p">)(</span><span class="n">map</span><span class="p">,</span>
                                                                   <span class="n">slot_index</span><span class="p">,</span>
                                                                   <span class="n">key</span><span class="p">);</span>
    <span class="k">if</span> <span class="p">(</span><span class="n">entry_index</span> <span class="o">==</span> <span class="n">SIZE_MAX</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="c1">// not found</span>

    <span class="o">*</span><span class="n">value_out</span> <span class="o">=</span> <span class="n">map</span><span class="o">-&gt;</span><span class="n">value_slots</span><span class="p">[</span><span class="n">slot_index</span><span class="p">][</span><span class="n">entry_index</span><span class="p">];</span>
    <span class="k">return</span> <span class="mi">1</span><span class="p">;</span> <span class="c1">// success</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Just to recap, this is what the memory looks like when we retrieve a value
associated with a given key:</p>

<p><img src="/blog/assets/professors-hash/hash_table.png" alt="getting a value from a hash table." /></p>

<p>And there we have it! Using this library, we can generate concrete
hashmap implementations. Since the key and value types are provided to the
template, the generated code should be type-aware, and reject any code that
doesn’t pass in the correct data types at compile-time. Our library doesn’t
have any glaringly obvious bugs, so what could possibly be wrong?</p>

<h2 id="the-professors-hash-table">The Professor’s Hash Table</h2>

<p>The main entrypoint of the challenge runs a simple demo of the hash table library,
allowing users to insert and query entries in a table.
Our professor’s demo defines two datatypes: a <code class="language-plaintext highlighter-rouge">str255</code> pascal string,
as well as a <code class="language-plaintext highlighter-rouge">bin256</code> data type, each with a fixed size of 256 bytes.
These structs are used as the key and value types of the system, respectively.</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">struct</span> <span class="n">str255</span> <span class="p">{</span>
    <span class="kt">uint8_t</span> <span class="n">size</span><span class="p">;</span> <span class="c1">// the string's length, from 0-255</span>
    <span class="kt">char</span> <span class="n">data</span><span class="p">[</span><span class="mi">255</span><span class="p">];</span> <span class="c1">// the data</span>
<span class="p">}</span> <span class="n">str255_t</span><span class="p">;</span>

<span class="k">typedef</span> <span class="k">struct</span> <span class="n">bin256</span> <span class="p">{</span>
    <span class="kt">uint8_t</span> <span class="n">data</span><span class="p">[</span><span class="mi">256</span><span class="p">];</span>
<span class="p">}</span> <span class="n">bin256_t</span><span class="p">;</span>
</code></pre></div></div>

<p>Then, we invoke the template in the preprocessor to generate our str255-to-bin256 mapping.</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#define HASHMAP_TYPENAME professors_map
#define HASHMAP_NUM_SLOTS 256
#define HASHMAP_KEY_TYPE str255_t
#define HASHMAP_VALUE_TYPE bin256_t
#define HASHMAP_HASH_FUNC professors_hash_string
#define HASHMAP_KEY_CMP_FUNC professors_key_cmp
#include</span> <span class="cpf">"hashmap.c"</span><span class="cp">
#undef HASHMAP_KEY_CMP_FUNC
#undef HASHMAP_HASH_FUNC
#undef HASHMAP_VALUE_TYPE
#undef HASHMAP_KEY_TYPE
#undef HASHMAP_NUM_SLOTS
#undef HASHMAP_TYPENAME
</span></code></pre></div></div>

<p>These data types are quite innocuous, the code compiles and runs,
so what could possibly go wrong? Well, as the challenge name hints,
everything falls apart when we look at the professor’s hash function.</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">const</span> <span class="kt">double</span> <span class="n">HASH_BASE</span> <span class="o">=</span> <span class="mi">257</span><span class="p">.</span><span class="mi">0</span><span class="p">;</span>
<span class="k">const</span> <span class="kt">double</span> <span class="n">HASH_MOD</span> <span class="o">=</span> <span class="mi">1000000009</span><span class="p">.</span><span class="mi">0</span><span class="p">;</span>

<span class="cm">/**
 * Uses the professor's original floating-point polynomial hash.
 */</span>
<span class="kt">int</span>
<span class="nf">professors_hash_string</span><span class="p">(</span><span class="n">str255_t</span> <span class="k">const</span> <span class="o">*</span><span class="n">key</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">str255_t</span> <span class="k">const</span> <span class="o">*</span><span class="n">string</span> <span class="o">=</span> <span class="n">key</span><span class="p">;</span>

    <span class="c1">// dear professor... why?</span>
    <span class="kt">double</span> <span class="n">h</span> <span class="o">=</span> <span class="mi">0</span><span class="p">.</span><span class="mi">0</span><span class="p">;</span>
    <span class="kt">int</span> <span class="n">len</span> <span class="o">=</span> <span class="n">string</span><span class="o">-&gt;</span><span class="n">size</span><span class="p">;</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">len</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="kt">char</span> <span class="n">c</span> <span class="o">=</span> <span class="n">string</span><span class="o">-&gt;</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
        <span class="n">h</span> <span class="o">=</span> <span class="n">fmod</span><span class="p">(</span><span class="n">h</span> <span class="o">*</span> <span class="n">HASH_BASE</span> <span class="o">+</span> <span class="p">(</span><span class="kt">double</span><span class="p">)</span><span class="n">c</span><span class="p">,</span> <span class="n">HASH_MOD</span><span class="p">);</span>
    <span class="p">}</span>

    <span class="k">return</span> <span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="n">h</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>This code is extremely scuffed with its use of floating-point numbers
to calculate hashes. This is a big indicator of code smell, but,
contrary to popular belief, the use of <code class="language-plaintext highlighter-rouge">double</code>s here doesn’t actually
impact the determinism of the hash function[3]. This code falls apart
for a different reason: signedness. The <code class="language-plaintext highlighter-rouge">char</code>s in the string are treated
as signed integers, which could be negative if their
byte values exceed 127. This case would never be encountered with normal
ASCII input, which is why the code didn’t fail during basic testing.</p>

<p>Additionally, I’ve been kinda lying to you. The C math library’s <code class="language-plaintext highlighter-rouge">fmod</code>
function, as well as the <code class="language-plaintext highlighter-rouge">%</code> operator, don’t <em>actually</em> calculate the
mathematical modulo; they calculate the remainder of the division<sup id="fnref:4"><a href="#fn:4" class="footnote" rel="footnote" role="doc-noteref">3</a></sup>.
The remainder <code class="language-plaintext highlighter-rouge">x % y</code> will always have the same sign as the dividend <code class="language-plaintext highlighter-rouge">x</code>,
meaning we can obtain negative indices through this computation.
As a final blow, the <code class="language-plaintext highlighter-rouge">HASHMAP_NUM_SLOTS</code> parameter is is defined with
the raw integer literal <code class="language-plaintext highlighter-rouge">256</code>, which is also signed; this means that C
will <strong>never</strong> promote the slot index <code class="language-plaintext highlighter-rouge">HASHMAP_HASH_FUNC(key) % HASHMAP_NUM_SLOTS</code>
to an unsigned integer until it is too late. The array requires indices on
the range <code class="language-plaintext highlighter-rouge">[0, 256)</code>, but due to the signed integer bug, we’re actually able
to access negative indices too, on the range <code class="language-plaintext highlighter-rouge">(-256, 256)</code>.
This means that an attacker can trigger out of bounds
(negative) access on the hash table slot array.</p>

<h2 id="exploiting-the-hash-table">Exploiting the Hash Table</h2>

<p>Okay, we’ve identified an out of bounds bug in the hash map: malicious key strings
can hash into negative slot indices. But how is this exploitable, exactly?
The pointer topology of the hash table is actually quite awkward; we aren’t actually
able to directly read or write out of bounds using this negative hash index.
Recall that the hash table struct stores an array of pointers to slot arrays:
in the <code class="language-plaintext highlighter-rouge">put</code> function, we can only write to a specific index
<code class="language-plaintext highlighter-rouge">map-&gt;value_slots[slot_index][entry_index]</code> once we identify a matching index
for our key in <code class="language-plaintext highlighter-rouge">map-&gt;key_slots[slot_index]</code>. If slot array pointers
<code class="language-plaintext highlighter-rouge">map-&gt;key_slots[slot_index]</code> or <code class="language-plaintext highlighter-rouge">map-&gt;value_slots[slot_index]</code> aren’t valid
memory addresses, the program will segfault before we can even perform our
relative read or write!</p>

<h1 id="todo-diagram-of-us-doing-a-negative-oob-on-the-hash-table-and-dereferencing-unknown-values-">todo diagram of us doing a negative oob on the hash table and dereferencing unknown values ??</h1>

<p>Not only does the slot array address need to be <em>valid</em>, the pointer location needs
to be <em>useful</em> for us to build an exploit chain.
In order to make the most out of our undefined behavior, we’re going to need to
know exactly where we’re dereferencing into when we use a negative hash index.</p>

<p>The first thing that the code does with our slot is that it tries to
find the matching key in the array: the code searches for the index <code class="language-plaintext highlighter-rouge">i</code> where
<code class="language-plaintext highlighter-rouge">map-&gt;key_slots[-idx][i]</code> matches our query’s key.
Because the <code class="language-plaintext highlighter-rouge">key_slots</code> array is placed after the <code class="language-plaintext highlighter-rouge">value_slots</code> array in the
hashmap struct, an out of bound access <code class="language-plaintext highlighter-rouge">map-&gt;key_slots[-idx]</code>
is semantically equivalent to <code class="language-plaintext highlighter-rouge">map-&gt;value_slots[256-idx]</code>.
This is good news! When we use a negative slot index, <code class="language-plaintext highlighter-rouge">map-&gt;key_slots[-idx]</code>
still points to valid memory. In fact, it’s memory we can already control!
With a clever setup of type confusion between keys and values, we can successfully
navigate the key scan to land at whatever index <code class="language-plaintext highlighter-rouge">i</code> we want, by planting values
in the victim slot that match the keys we will use in the future.</p>

<p>The next part is harder: how do we steer our read/write primitive on the value slot
of the hashmap to obtain RCE? We can control both values <code class="language-plaintext highlighter-rouge">-idx</code> and <code class="language-plaintext highlighter-rouge">i</code> using a
careful setup, but we still don’t know where <code class="language-plaintext highlighter-rouge">map-&gt;value_slots[-idx][i]</code> will access.
Because the hashmap struct is allocated on the heap, accessing <code class="language-plaintext highlighter-rouge">map-&gt;value_slots[-idx]</code>
will result in a heap underflow. Is there any way we can coerce <code class="language-plaintext highlighter-rouge">map-&gt;value_slots[-idx]</code>
into returning a <em>useful</em> pointer that lets us craft an exploit?</p>

<h2 id="exploiting-the-glibc-heap">Exploiting the GLIBC Heap</h2>

<p>It turns out, we can get a very useful pointer leak if the previous chunk is free.
When a chunk is free, the user data section is repurposed as metadata, containing
<code class="language-plaintext highlighter-rouge">fd</code> and <code class="language-plaintext highlighter-rouge">bk</code> pointers to link the chunk into a bin. If this is the first chunk
of the given size to have been freed in the program, the <code class="language-plaintext highlighter-rouge">fd</code> pointer will point to
the large bin’s head in the libc <code class="language-plaintext highlighter-rouge">malloc_state</code> structure.</p>

<h1 id="todo-the-same-diagram-but-now-revealed-whats-before-the-heap">todo the same diagram but now revealed whats before the heap</h1>
<h1 id="bleh-libc-malloc_state">bleh libc malloc_state</h1>

<h2 id="blehhhhhh-stop">blehhhhhh stop</h2>

<h2 id="the-mistakes">The Mistakes</h2>

<p>My challenge had several quality control problems. The code wasn’t very well-structured, so it
had a bunch of unnecessary overcomplications (such as the <code class="language-plaintext highlighter-rouge">struct sized_object</code>).
Additionally, the <code class="language-plaintext highlighter-rouge">alloc_off_heap</code> function had a silly logic error which miscalculated the on-heap
size of an off-heap object, allowing users to corrupt the heap using integer overflow directly.
In the future, I’ll need to make sure to get proofreading on my challenges and ensure that there
aren’t any unintended solutions in the challenge.</p>

<h2 id="the-conclusion">The Conclusion</h2>

<p>Overall, 85 out of 400 teams solved the challenge within the first 24 hours. Despite the
technical problems, I think that <code class="language-plaintext highlighter-rouge">pwn/garden</code> was a very fun challenge. <code class="language-plaintext highlighter-rouge">garden</code> provides
a look into how custom heaps, garbage collection, and mitigations interact in a realistic
environment, similar to that of a real-world JVM implementation. I hope to create more
unique and advanced challenges in the future. Also, the flag contains a mandatory sponsored
message by FizzBuzz101:</p>

<p><code class="language-plaintext highlighter-rouge">dice{m1tig4ti0ns_nev3r_w0rk_y0u_escap3d_th3_w4ll3d_g4Rd3n}</code></p>

<h1 id="important-dont-delete-my-footnotes">IMPORTANT DONT DELETE MY FOOTNOTES</h1>

<div class="footnotes" role="doc-endnotes">
  <ol>
    <li id="fn:1">
      <p>There are many different layouts for storing entries in a hashmap: OpenJDK’s <a href="https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/HashMap.java">HashMap</a> manages a linked list of entries for each slot, and CPython’s <a href="https://github.com/python/cpython/blob/main/Objects/dictobject.c">dict</a> implementation stores all entries in a single array, with a custom <a href="https://en.wikipedia.org/wiki/Open_addressing">open addressing</a> algorithm to resolve collisions. Eclipse Collections’ <a href="https://github.com/eclipse-collections/eclipse-collections/blob/master/eclipse-collections/src/main/java/org/eclipse/collections/impl/map/mutable/UnifiedMap.java">UnifiedMap</a> implementation here actually <em>does</em> resemble the layout used in this challenge, with a contiguous array of entries for each slot in the table. <a href="#fnref:1" class="reversefootnote" role="doc-backlink">&#8617;</a></p>
    </li>
    <li id="fn:2">
      <p>I decided to use templates after my experience with the extremely scuffed <a href="https://github.com/firedancer-io/firedancer/blob/main/src/flamenco/vm/syscall/fd_vm_syscall_cpi_common.c">Firedancer CPI implementation</a>, which uses preprocessor templates to reuse common code while inlining custom functionality. Everyone must endure the wrath of scuffed preprocessor hacks. <a href="#fnref:2" class="reversefootnote" role="doc-backlink">&#8617;</a></p>
    </li>
    <li id="fn:4">
      <p>In the C spec, the division and remainder operators are the results obtained when the dividend is truncated towards zero by the diviso; this pairs cleanly, enforcing the property <code class="language-plaintext highlighter-rouge">(a / b) * b + (a % b) == a</code> (given the quotient is representable). The natermsmes “remainder” and “modulo” are often used interchangeably, but strictly speaking, the <code class="language-plaintext highlighter-rouge">%</code> operator in C computes the remainder, whereas in Python, it computes the modulo. <a href="#fnref:4" class="reversefootnote" role="doc-backlink">&#8617;</a></p>
    </li>
  </ol>
</div>]]></content><author><name></name></author><summary type="html"><![CDATA[KawaiiconCTF 2026 - professors-hash]]></summary></entry><entry><title type="html">DiceCTF 2026 pwn/garden: Exploiting a Moving Garbage Collector</title><link href="http://localhost:4000/blog/dicectf-garden-garbage-collector-exploitation/" rel="alternate" type="text/html" title="DiceCTF 2026 pwn/garden: Exploiting a Moving Garbage Collector" /><published>2026-04-08T00:00:00-07:00</published><updated>2026-04-08T00:00:00-07:00</updated><id>http://localhost:4000/blog/dicectf-2026-garden</id><content type="html" xml:base="http://localhost:4000/blog/dicectf-garden-garbage-collector-exploitation/"><![CDATA[<h1 id="dicectf-2026---garden">DiceCTF 2026 - garden</h1>

<p><code class="language-plaintext highlighter-rouge">pwn/garden</code> was the most sophisticated binary exploitation challenge I wrote for DiceCTF Quals 2026.
During the 24-hour online CTF, players were tasked with exploiting a custom
garbage-collected heap and achieve remote code execution on our
linux servers. Players were provided the C source code for the virtual machine as well as
the compiled executable binary and libc used on the server to solve this challenge.
In this author writeup, I will explain the inspiration and mechanisms surrounding this
binary exploitation challenge.</p>

<h2 id="the-vm">The VM</h2>

<p>This challenge was inspired by the <a href="https://github.com/anematode/b-jvm">b-jvm</a>, an open-source
Java Virtual Machine implementation that I worked on with my friends <a href="https://anemato.de/">Timothy</a>
and <a href="https://xz.ax/">Alec</a>. The b-jvm uses a custom tracing, moving garbage collection algorithm:
first, the GC identifies all reachable references, and then compacts the heap,
updating all object pointers to their new locations. My challenge provided a simple garbage-collected
bytecode VM based on the b-jvm heap implementation.</p>

<p>As a mitigation, the VM uses a memory cage: VM references are stored as offsets to a memory-mapped
32-bit address space. That way, memory accesses are contained within a reserved address range, isolating
the VM heap from the rest of the program’s memory. All objects followed the same header format, with fields
describing their size and payload type (storing either numbers or references to other objects):</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="kt">uint32_t</span> <span class="n">ref_t</span><span class="p">;</span>
<span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
    <span class="kt">uint16_t</span> <span class="n">length</span><span class="p">;</span>
    <span class="kt">uint16_t</span> <span class="n">mark_word</span><span class="p">;</span> <span class="c1">// object type indicated by LSB</span>
    <span class="n">ref_t</span> <span class="n">entries</span><span class="p">[];</span>
<span class="p">}</span> <span class="n">arr_header_t</span><span class="p">;</span>
</code></pre></div></div>

<p>To interact with external memory, the VM also supports a custom “off-heap” object type,
whose payload stores a raw pointer with bounds checking. This allows raw
memory to be safely accessed through special VM bytecodes, which prevents
out-of-bounds access.</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
    <span class="n">arr_header_t</span> <span class="n">header</span><span class="p">;</span>
    <span class="kt">uint32_t</span> <span class="o">*</span><span class="n">data</span><span class="p">;</span>
    <span class="kt">size_t</span> <span class="n">obj_size</span><span class="p">;</span>
<span class="p">}</span> <span class="n">off_heap_obj_t</span><span class="p">;</span>
</code></pre></div></div>

<p>The heap cage mitigation was meant to contain memory corruption, preventing attackers from escalating
a memory management bug into full control over the program’s memory. However, this off-heap buffer
feature still allows users to interact with direct memory pointers. If attackers could forge malicious
off-heap object headers on the heap, they would obtain arbitrary read/write on the host computer.
In order to exploit the heap, we need to understand how its garbage collector works.</p>

<h2 id="the-garbage-collector">The Garbage Collector</h2>

<p>At a high level, the VM’s moving garbage collector works by collecting a list of all reachable references,
and then updating all pointers to their new memory locations, compacting the heap for further use.
In the first phase, the GC recursively marks all reachable objects from a list of root nodes,
and adds them to an array list:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">struct</span> <span class="n">gc_ctx</span> <span class="p">{</span>
    <span class="n">sized_object</span> <span class="o">*</span><span class="n">objs</span><span class="p">;</span>
    <span class="kt">size_t</span> <span class="n">obj_count</span><span class="p">;</span>
    <span class="n">ref_t</span> <span class="o">*</span><span class="n">new_locations</span><span class="p">;</span>
<span class="p">}</span> <span class="n">gc_ctx_t</span><span class="p">;</span>

<span class="k">static</span> <span class="kt">void</span> <span class="nf">mark_reachable</span><span class="p">(</span><span class="n">ref_t</span> <span class="n">ref</span><span class="p">,</span> <span class="n">gc_ctx_t</span> <span class="o">*</span><span class="n">visited</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">arr_header_t</span> <span class="o">*</span><span class="n">arr</span> <span class="o">=</span> <span class="n">AS_ARR_HEADER</span><span class="p">(</span><span class="n">ref</span><span class="p">);</span>
    <span class="k">if</span> <span class="p">(</span><span class="n">arr</span><span class="o">-&gt;</span><span class="n">mark_word</span> <span class="o">&amp;</span> <span class="mh">0x2</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// already marked</span>
        <span class="k">return</span><span class="p">;</span>
    <span class="p">}</span>
    <span class="n">arr</span><span class="o">-&gt;</span><span class="n">mark_word</span> <span class="o">|=</span> <span class="mh">0x2</span><span class="p">;</span> <span class="c1">// mark it</span>
    <span class="c1">// add to visited list</span>
    <span class="n">visited</span><span class="o">-&gt;</span><span class="n">objs</span> <span class="o">=</span> <span class="n">realloc</span><span class="p">(</span><span class="n">visited</span><span class="o">-&gt;</span><span class="n">objs</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">sized_object</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">visited</span><span class="o">-&gt;</span><span class="n">obj_count</span> <span class="o">+</span> <span class="mi">1</span><span class="p">));</span>
    <span class="n">visited</span><span class="o">-&gt;</span><span class="n">objs</span><span class="p">[</span><span class="n">visited</span><span class="o">-&gt;</span><span class="n">obj_count</span><span class="o">++</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="n">sized_object</span><span class="p">)</span> <span class="p">{</span> <span class="p">.</span><span class="n">object</span> <span class="o">=</span> <span class="n">ref</span><span class="p">,</span> <span class="p">.</span><span class="n">size</span> <span class="o">=</span> <span class="n">arr</span><span class="o">-&gt;</span><span class="n">length</span> <span class="p">};</span>
    <span class="k">if</span> <span class="p">(</span><span class="n">arr</span><span class="o">-&gt;</span><span class="n">mark_word</span> <span class="o">&amp;</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// contains pointers</span>
        <span class="k">for</span> <span class="p">(</span><span class="kt">uint16_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">arr</span><span class="o">-&gt;</span><span class="n">length</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
            <span class="n">ref_t</span> <span class="n">entry</span> <span class="o">=</span> <span class="n">arr</span><span class="o">-&gt;</span><span class="n">entries</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
            <span class="k">if</span> <span class="p">(</span><span class="n">entry</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">)</span> <span class="c1">// skip null pointers</span>
                <span class="n">mark_reachable</span><span class="p">(</span><span class="n">entry</span><span class="p">,</span> <span class="n">visited</span><span class="p">);</span>
        <span class="p">}</span>
    <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>After collection, objects are sorted by pointer value, so that they can be compacted downwards
monotonically. By relocating the objects in the same order they appear on the heap, we can ensure
that objects never move upwards or overwrite important data. As a last step, we update all references
in the VM to point to their new memory locations. Here is the (messy) code for the garbage collection algorithm:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">void</span> <span class="nf">garbage_collect</span><span class="p">(</span><span class="n">ref_t</span> <span class="o">*</span><span class="n">roots</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">num_roots</span><span class="p">)</span> <span class="p">{</span>
    <span class="c1">// Simple mark-and-sweep garbage collector</span>
    <span class="c1">// mark phase</span>
    <span class="n">gc_ctx_t</span> <span class="n">ctx</span> <span class="o">=</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">num_roots</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">mark_reachable</span><span class="p">(</span><span class="n">roots</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">&amp;</span><span class="n">ctx</span><span class="p">);</span>
    <span class="p">}</span>
    <span class="c1">// sort the pointers so we can compact the heap</span>
    <span class="n">qsort</span><span class="p">(</span><span class="n">ctx</span><span class="p">.</span><span class="n">objs</span><span class="p">,</span> <span class="n">ctx</span><span class="p">.</span><span class="n">obj_count</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">sized_object</span><span class="p">),</span>
          <span class="p">(</span><span class="kt">int</span> <span class="p">(</span><span class="o">*</span><span class="p">)(</span><span class="k">const</span> <span class="kt">void</span> <span class="o">*</span><span class="p">,</span> <span class="k">const</span> <span class="kt">void</span> <span class="o">*</span><span class="p">))</span><span class="n">compare_sized_objects</span><span class="p">);</span>
    
    <span class="c1">// create lookup table for new locations</span>
    <span class="n">ctx</span><span class="p">.</span><span class="n">new_locations</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">ref_t</span><span class="p">)</span> <span class="o">*</span> <span class="n">ctx</span><span class="p">.</span><span class="n">obj_count</span><span class="p">);</span>
    <span class="c1">// copy objects to new locations</span>
    <span class="kt">size_t</span> <span class="n">new_heap_used</span> <span class="o">=</span> <span class="mi">128</span><span class="p">;</span> <span class="c1">// reserve first 128 bytes</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">ctx</span><span class="p">.</span><span class="n">obj_count</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">arr_header_t</span> <span class="o">*</span><span class="n">arr</span> <span class="o">=</span> <span class="n">AS_ARR_HEADER</span><span class="p">(</span><span class="n">ctx</span><span class="p">.</span><span class="n">objs</span><span class="p">[</span><span class="n">i</span><span class="p">].</span><span class="n">object</span><span class="p">);</span>
        <span class="n">arr</span><span class="o">-&gt;</span><span class="n">mark_word</span> <span class="o">&amp;=</span> <span class="o">~</span><span class="mh">0x2</span><span class="p">;</span> <span class="c1">// unmark for next GC</span>
        <span class="kt">size_t</span> <span class="n">total_size</span> <span class="o">=</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">arr_header_t</span><span class="p">)</span> <span class="o">+</span> <span class="n">ctx</span><span class="p">.</span><span class="n">objs</span><span class="p">[</span><span class="n">i</span><span class="p">].</span><span class="n">size</span> <span class="o">*</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">ref_t</span><span class="p">);</span>
        <span class="n">memmove</span><span class="p">(</span><span class="n">heap_base</span> <span class="o">+</span> <span class="n">new_heap_used</span><span class="p">,</span> <span class="n">arr</span><span class="p">,</span> <span class="n">total_size</span><span class="p">);</span>
        <span class="n">ctx</span><span class="p">.</span><span class="n">new_locations</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="n">ref_t</span><span class="p">)</span><span class="n">new_heap_used</span><span class="p">;</span>
        <span class="n">new_heap_used</span> <span class="o">+=</span> <span class="n">total_size</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="c1">// update pointers on heap</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">ctx</span><span class="p">.</span><span class="n">obj_count</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">arr_header_t</span> <span class="o">*</span><span class="n">arr</span> <span class="o">=</span> <span class="n">AS_ARR_HEADER</span><span class="p">(</span><span class="n">ctx</span><span class="p">.</span><span class="n">new_locations</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
        <span class="k">if</span> <span class="p">(</span><span class="n">arr</span><span class="o">-&gt;</span><span class="n">mark_word</span> <span class="o">&amp;</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// contains pointers</span>
            <span class="k">for</span> <span class="p">(</span><span class="kt">uint16_t</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="n">arr</span><span class="o">-&gt;</span><span class="n">length</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
                <span class="c1">// binary search for new location</span>
                <span class="n">ref_t</span> <span class="n">old_ref</span> <span class="o">=</span> <span class="n">arr</span><span class="o">-&gt;</span><span class="n">entries</span><span class="p">[</span><span class="n">j</span><span class="p">];</span>
                <span class="n">ref_t</span> <span class="n">new_ref</span><span class="p">;</span>
                <span class="k">if</span> <span class="p">(</span><span class="n">old_ref</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
                    <span class="n">new_ref</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="c1">// null pointer</span>
                <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
                    <span class="n">sized_object</span> <span class="n">search_key</span> <span class="o">=</span> <span class="p">{</span> <span class="p">.</span><span class="n">object</span> <span class="o">=</span> <span class="n">old_ref</span> <span class="p">};</span>
                    <span class="n">sized_object</span> <span class="o">*</span><span class="n">found</span> <span class="o">=</span> <span class="n">bsearch</span><span class="p">(</span><span class="o">&amp;</span><span class="n">search_key</span><span class="p">,</span> <span class="n">ctx</span><span class="p">.</span><span class="n">objs</span><span class="p">,</span> <span class="n">ctx</span><span class="p">.</span><span class="n">obj_count</span><span class="p">,</span>
                                        <span class="k">sizeof</span><span class="p">(</span><span class="n">sized_object</span><span class="p">),</span> <span class="n">compare_sized_objects</span><span class="p">);</span>
                    <span class="n">new_ref</span> <span class="o">=</span> <span class="n">ctx</span><span class="p">.</span><span class="n">new_locations</span><span class="p">[</span><span class="n">found</span> <span class="o">-</span> <span class="n">ctx</span><span class="p">.</span><span class="n">objs</span><span class="p">];</span>
                <span class="p">}</span>
                <span class="n">arr</span><span class="o">-&gt;</span><span class="n">entries</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_ref</span><span class="p">;</span>
            <span class="p">}</span>
        <span class="p">}</span>
    <span class="p">}</span>
    <span class="c1">// update pointers in roots</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">num_roots</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">ref_t</span> <span class="n">old_ref</span> <span class="o">=</span> <span class="n">roots</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
        <span class="n">ref_t</span> <span class="n">new_ref</span><span class="p">;</span>
        <span class="k">if</span> <span class="p">(</span><span class="n">old_ref</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
            <span class="n">new_ref</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="c1">// null pointer</span>
        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
            <span class="n">sized_object</span> <span class="n">search_key</span> <span class="o">=</span> <span class="p">{</span> <span class="p">.</span><span class="n">object</span> <span class="o">=</span> <span class="n">old_ref</span> <span class="p">};</span>
            <span class="n">sized_object</span> <span class="o">*</span><span class="n">found</span> <span class="o">=</span> <span class="n">bsearch</span><span class="p">(</span><span class="o">&amp;</span><span class="n">search_key</span><span class="p">,</span> <span class="n">ctx</span><span class="p">.</span><span class="n">objs</span><span class="p">,</span> <span class="n">ctx</span><span class="p">.</span><span class="n">obj_count</span><span class="p">,</span>
                                <span class="k">sizeof</span><span class="p">(</span><span class="n">sized_object</span><span class="p">),</span> <span class="n">compare_sized_objects</span><span class="p">);</span>
            <span class="n">new_ref</span> <span class="o">=</span> <span class="n">ctx</span><span class="p">.</span><span class="n">new_locations</span><span class="p">[</span><span class="n">found</span> <span class="o">-</span> <span class="n">ctx</span><span class="p">.</span><span class="n">objs</span><span class="p">];</span>
        <span class="p">}</span>
        <span class="n">roots</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_ref</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="n">heap_used</span> <span class="o">=</span> <span class="n">new_heap_used</span><span class="p">;</span>
    <span class="n">free</span><span class="p">(</span><span class="n">ctx</span><span class="p">.</span><span class="n">objs</span><span class="p">);</span>
    <span class="n">free</span><span class="p">(</span><span class="n">ctx</span><span class="p">.</span><span class="n">new_locations</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<h2 id="the-bug">The Bug</h2>

<p>The correct relocation of objects during garbage collection relies on the assumption that the heap is always being
compacted downwards: objects should never move upwards and corrupt other parts of the heap. Intuitively, these
assumptions seem reasonable: the set of reachable objects is always a subset of all objects allocated in the heap,
and we relocate them in increasing pointer order. However, this invariant does not actually hold in our VM.</p>

<p>Null references are special-cased in our VM and don’t actually correspond to any allocation, but our <code class="language-plaintext highlighter-rouge">mark_reachable</code>
algorithm does not exclude them during traversal. This means that a null pointer can get relocated during
garbage collection, occupying space that was never allocated in the first place. If the heap is already tightly
packed, then introducing this fake object during garbage collection forces subsequent objects to shift upwards.
Because we only move one object at a time, each <code class="language-plaintext highlighter-rouge">memmove</code> operation would overwrite the first four bytes
of the next object.</p>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Original heap:
[ length ][mrk_word][        a         ][ length ][mrk_word][        b         ]
\-------------- Object 1 --------------/\-------------- Object 2 --------------/

Objects to relocate: [null, Object 1, Object 2]

Place null object:
/------ null ------\
[    0   ][    0   ][        a         ][ length ][mrk_word][        b         ]
\-------------- Object 1 --------------/\-------------- Object 2 --------------/

Move Object 1 upwards:
                    /-------------- Object 1 --------------\
[    0   ][    0   ][    0   ][    0   ][        a         ][        b         ]
\------ null ------/                    \-------------- Object 2 --------------/

Move Object 2 upwards:
                                                            /-------------- Object 2 --------------\
[    0   ][    0   ][    0   ][    0   ][        a         ][        a         ][        b         ]
\------ null ------/\-------------- Object 1 --------------/

Resultant heap:
                    [ length ][mrk_word][        a         ][ length ][mrk_word][        b         ]
[    0   ][    0   ][    0   ][    0   ][        a         ][        a         ][        b         ]
\------ null ------/\-------------- Object 1 --------------/\-------------- Object 2 --------------/
</code></pre></div></div>

<p>After garbage collection, Object 2’s header got replaced by a user-controlled payload value!
This means can forge custom signatures for objects by placing a crafted payload before our target object on the heap,
and then garbage collecting with a null pointer on the heap to trigger the memory corruption.</p>

<p>An exploit can use this technique in two ways: it can convert an existing off-heap object into
a numerical array in order to leak off-heap pointers, and it can also convert a user-constructed number array
into an off-heap object, creating arbitrary read/write access. I won’t explain the exploit path
in detail here, but users can leverage these primitives in order to bypass ASLR and construct a ROP chain to
obtain RCE and get the flag.</p>

<h2 id="the-mistakes">The Mistakes</h2>

<p>My challenge had several quality control problems. The code wasn’t very well-structured, so it
had a bunch of unnecessary overcomplications (such as the <code class="language-plaintext highlighter-rouge">struct sized_object</code>).
Additionally, the <code class="language-plaintext highlighter-rouge">alloc_off_heap</code> function had a silly logic error which miscalculated the on-heap
size of an off-heap object, allowing users to corrupt the heap using integer overflow directly.
In the future, I’ll need to make sure to get proofreading on my challenges and ensure that there
aren’t any unintended solutions in the challenge.</p>

<h2 id="the-conclusion">The Conclusion</h2>

<p>Overall, 85 out of 400 teams solved the challenge within the first 24 hours. Despite the
technical problems, I think that <code class="language-plaintext highlighter-rouge">pwn/garden</code> was a very fun challenge. <code class="language-plaintext highlighter-rouge">garden</code> provides
a look into how custom heaps, garbage collection, and mitigations interact in a realistic
environment, similar to that of a real-world JVM implementation. I hope to create more
unique and advanced challenges in the future. Also, the flag contains a mandatory sponsored
message by FizzBuzz101:</p>

<p><code class="language-plaintext highlighter-rouge">dice{m1tig4ti0ns_nev3r_w0rk_y0u_escap3d_th3_w4ll3d_g4Rd3n}</code></p>]]></content><author><name></name></author><summary type="html"><![CDATA[DiceCTF 2026 - garden]]></summary></entry><entry><title type="html">What Cowponder Taught Me</title><link href="http://localhost:4000/blog/cowponder-lessons/" rel="alternate" type="text/html" title="What Cowponder Taught Me" /><published>2026-03-10T00:00:00-07:00</published><updated>2026-03-10T00:00:00-07:00</updated><id>http://localhost:4000/blog/cowponder-lessons</id><content type="html" xml:base="http://localhost:4000/blog/cowponder-lessons/"><![CDATA[<h1 id="what-cowponder-taught-me">What Cowponder Taught Me</h1>

<p>In ninth grade, my friend Alec gave me ssh access to his remote server. It was my first time really working with linux.
When I signed in, I was greeted by this randomized message of the day:</p>
<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>maxcai% ssh maxster@xz.ax
welcome to xz.ax, land of the free and home of the brave
 _____________________________________
( rain falling against the lonely     )
( tenement has set my mind to wander  )
 -------------------------------------
        o   ^__^
         o  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
xz% 
</code></pre></div></div>

<p>Initially, I was curious at how he made such a thing. I wanted to customize the motd and add more quotes.
By playing around with the concept, I would end up creating my first cli project: cowponder.
Developing cowponder led me on a journey of self-discovery, as I witnessed my potential through programming.
In a way, this project is a small, quirky demonstration of my growth as a high schooler.</p>

<h2 id="the-original-program">The Original Program</h2>

<p>Originally, this messsage was generated by a script in <code class="language-plaintext highlighter-rouge">/etc/update-motd.d/99-silly-message</code>. I added
some quotes of my own to the command, and wanted to test my changes. However, I didn’t know much
about the commandline; I knew there were commands such as <code class="language-plaintext highlighter-rouge">echo</code>, <code class="language-plaintext highlighter-rouge">ls</code>, and <code class="language-plaintext highlighter-rouge">python3</code> that
could do custom things, but I didn’t know how they were made. When Alec showed me where the file was,
I had no idea what to do with it. How do I <em>run</em> a file?</p>

<p><img src="/blog/assets/cowponder/how_to_run.png" alt="just run the file, silly goose!" /></p>

<h2 id="everything-is-a-file">Everything is a File</h2>

<p>Apparently, to run the file <code class="language-plaintext highlighter-rouge">/etc/update-motd.d/99-silly-message</code>, you literally just enter the file
<code class="language-plaintext highlighter-rouge">/etc/update-motd.d/99-silly-message</code> into the terminal. How simple! In order to avoid having to type the
full path of the file, you can place the executable into a directory listed on PATH environment variable,
where the computer searches when resolving a command name. Because the script starts with a shebang <code class="language-plaintext highlighter-rouge">#!</code>,
the operating system knows to interpret the file using <code class="language-plaintext highlighter-rouge">/usr/bin/python3</code>.
I ended up placing the <code class="language-plaintext highlighter-rouge">cowponder</code> file in <code class="language-plaintext highlighter-rouge">/usr/local/bin</code>. Amazing!</p>

<p><img src="/blog/assets/cowponder/dont_need_python3.png" alt="reaping massive improvements" /></p>

<h2 id="packaging-cowponder">Packaging Cowponder</h2>

<p>Everyone deserves a philosophical cow. I wanted to distribute cowponder so that anyone could run from commandline.
Initially, I created a deb package, which installed the files, but the installation process was inconvenient and
not portable to other platforms. I put aside the project for a few years, but finally revisited cowponder
in my senior year, when I had more free time.
Finally, I published cowponder on <a href="https://pypi.org/project/cowponder/">PyPI</a>,
making it available via <code class="language-plaintext highlighter-rouge">pip install cowponder</code>. Additionally, my friend Reid ported cowponder to
<a href="https://www.powershellgallery.com/packages/cowponder/0.0.3">PowerShell</a>, available with <code class="language-plaintext highlighter-rouge">Install-Module cowponder</code>.
Now, anyone can experience the joys of having philosophical cattle in their terminal!</p>

<h2 id="conclusion">Conclusion</h2>

<p>I’ve learned tons of invaluable lessons from working on projects during my time in high school.
Cowponder, despite being extremely basic, is still one of my most memorable projects.
Through cowponder, I learned some quirks about linux, but most importantly,
I discovered that I could actually write code for real users.
Programming extends beyond theoretical algorithms and data structures,
and can be used to accomplish real tasks with purpose.</p>

<p>I’m extremely grateful that Alec encouraged me to investigate, develop, and refine his
silly motd script. In high school, I implemented my own
<a href="https://github.com/maxcai314/java-dns-server">network protocols</a>,
<a href="https://github.com/maxcai314/cpu">designed a CPU</a>, and even had the opportunity to collaborate
on <a href="https://github.com/anematode/b-jvm">an open-source Java implementation</a>.
And it all started with cowponder.
Seeing my little terminal cow display messages showed me that
the tools we use aren’t as inaccessible and magicky as they initially seem — anything can
be created through code.</p>

<p>For any aspiring learners out there: create more projects.
Take an idea, no matter how simple or unoriginal, and make it your own.
See it through to the end.
Explore what’s out there.
Who knows, maybe your project will become your cowponder moment.</p>

<p><img src="/blog/assets/cowponder/cowponder.png" alt="cowponder." /></p>]]></content><author><name></name></author><summary type="html"><![CDATA[What Cowponder Taught Me]]></summary></entry><entry><title type="html">Automatically Generating AP Music Theory Chorales</title><link href="http://localhost:4000/blog/music-theory-chorale-generator/" rel="alternate" type="text/html" title="Automatically Generating AP Music Theory Chorales" /><published>2026-02-17T00:00:00-08:00</published><updated>2026-02-17T00:00:00-08:00</updated><id>http://localhost:4000/blog/chorale-generator</id><content type="html" xml:base="http://localhost:4000/blog/music-theory-chorale-generator/"><![CDATA[<h1 id="automatically-generating-ap-music-theory-chorales">Automatically Generating AP Music Theory Chorales</h1>

<p>Western music theory comes with a lot of rules: When writing counterpoint,
no parallel fifths or octaves are allowed. The soprano may not make
a leap in similar motion with the bass into a perfect fifth or octave.
In a second inversion chord, the root (chordal fifth) must be doubled.
For a beginner, all of these rules feel arbitrary and confusing!</p>

<p>In my AP music theory class, I decided to try writing a computer program
that could automatically solve these constraints. In doing so, I ended up
learning a lot about music, computing, and creativity.</p>

<h2 id="the-search-problem">The Search Problem</h2>

<p>One of the tasks on the exam is to realize a four-part (SATB)
chorale from a bass line and implied harmony (figured bass).
The curriculum defines strict rules for correct voice leading.
Here are the most important criteria to visualize the problem:</p>
<ul>
  <li>For any given harmonization, all notes spelled out by the chord must be represented.
    <ul>
      <li>Exceptions are made for dominant seventh triads or the final cadence, where omission of the fifth is allowed.</li>
    </ul>
  </li>
  <li>Voices must always play chord tones implied by the harmony.
    <ul>
      <li>The bass must use the given bass note.</li>
    </ul>
  </li>
  <li>Voices must maintain independent motion.
    <ul>
      <li>Parallel fifths and octaves between any two voices are forbidden.</li>
      <li>Direct fifths and octaves between a leaping soprano and bass in similar motion are also forbidden.</li>
      <li>The leading tone, as well as the chordal seventh must resolve in stepwise motion and may never be doubled.</li>
    </ul>
  </li>
  <li>Cross relations (one voice singing a diatonic pitch followed by another voice singing a chromatic alteration of it) are not allowed.</li>
  <li>The soprano must have a valid melodic contour.
    <ul>
      <li>The soprano line may not use augmented or diminished melodic intervals.</li>
      <li>Leaps in the soprano voice larger than a third must be approached and exited with conjunct motion in the opposite direction.</li>
      <li>The soprano may not make a leap greater than a perfect fifth.</li>
      <li>Tendency tones in the soprano must resolve correctly in stepwise motion.</li>
    </ul>
  </li>
  <li>Voices must be correctly spaced.
    <ul>
      <li>Each voice must stay within its own range. The exact ranges vary; I kept my soprano between C4 and G5, my alto between G3 and C5, and my tenor between C3 and G4.</li>
      <li>The soprano and alto may never be more than an octave apart.</li>
      <li>The alto and tenor may never be more than an octave apart.</li>
      <li>Voice crossings are not allowed.</li>
      <li>No voice may move beyond the pitch played by a neighboring voice on the previous note.</li>
    </ul>
  </li>
</ul>

<p>Writing these Bach-style chorales can be thought of as a constraint satisfaction
problem: the computer needs to find solutions (voicings) that use the given chords
to satisfy the constraints of eighteenth-century voice leading conventions.</p>

<p>Following the AP curriculum, I decided to start out by implementing only soprano-bass
counterpoint, where I only had to generate one valid soprano line that fit with the given
figured bass, not thinking about the other voices.</p>

<p>Even with a single voice, the solution space can be huge.
The number of potential candidates grows exponentially as the chorale gets longer;
for each chord, the soprano voice must choose one of the notes in the harmony to play.
As a naïve estimate, if the soprano voice can choose between four different notes
in a chord, a sixteen-chord chorale could have <code class="language-plaintext highlighter-rouge">4^16 = 4,294,967,296</code> possible combinations.
That’s a lot!
In order to generate chorales, I needed an optimised algorithm that could find a solution
without having to brute-force enumerate every single combination of notes.</p>

<h2 id="the-backtracking-algorithm">The Backtracking Algorithm</h2>

<p>Humans are able to solve this kind of puzzle more efficiently because of
a strategy called backtracking. When writing a chorale by hand, we only focus on one part
at a time. We start from the beginning, choose the next note, and check if it is valid.
If it is valid, we keep going. If not, we try a different choice. If we discover
at any point that there are no valid harmonizations for the next note, we have to
backtrack and find a different previous note that might lead to a solution.
With this strategy, we can build our chorale incrementally; we don’t actually need to evaluate 4,294,967,296 solutions. Backtracking solves these problems much more efficiently.</p>

<p>This strategy works pretty intuitively:
If the first two notes of a chorale already contain voice leading errors,
the solution is invalid regardless of what we write for the rest of the notes.
With a backtracking search, we can eliminate this entire set of incorrect solutions
from the search tree, take a single step back, and try a different option. Because of the
“compositional” nature of this problem, working step-by-step makes us <em>much</em> more likely
to find the valid solution, as we avoid wasting time on obvious mistakes or
completely restarting every time we run into a dead end.</p>

<p>With this in mind, I implemented my first attempt at generating chorales.
I wrote the program fairly quickly in one afternoon, and it seemed fairly successful.</p>

<audio controls="">
  
    <source src="/blog/assets/chorale/soprano_bass_major.mp3" type="audio/mpeg" />
  
  Your browser does not support the audio element.
</audio>

<p>The basic soprano-bass counterpoint worked! But in order to implement the full
four-voice chorale generator, I had to make several major revamps to my code design.</p>

<h2 id="modeling-tonality-in-code">Modeling Tonality in Code</h2>

<p>One of the major limitations in my original implementation was the fact that
my code modeled pitches and intervals as pure numbers. While the output music
<em>does</em> only care about the absolute pitches for the sound, my code needed to 
be able to analyze the <em>function</em> of each note in the diatonic scale in order to
rigorously check for melodic contour and cross relations. For example, C♯ and D♭
are enharmonic, but the diatonic interval between B and C♯ is a Major Second,
while the diatonic interval between B and D♭ is a Diminished Third. This means
that a soprano voice would be allowed to make the leap between these two pitches
if the key signature spelled the note as C♯, but not if it was written as a D♭,
due to it being a diminished interval. A chorale generator needs to keep track
of not only the pitch of the sound, but its function with respect to the
diatonic scale.</p>

<p>In order to track the function of each note, I designed a python data class which
tracks both the diatonic step size and chromatic size of each interval. Then,
I implemented all the necessary arithmetic operations, strictly keeping track of
all the interactions between the quality and size of the chord. In my system,
a Minor Third (3 semitones, 2 scale steps)
plus another Minor Third (3 semitones, 2 scale steps) would be equivalent to
a Diminished Fifth (6 semitones, 4 scale steps), whereas
a Major Third (4 semitones, 2 scale steps)
plus a Minor Second (2 semitones, 1 scale step)
would be equivalent to an Augmented Fourth (6 semitones, 3 scale steps).</p>

<p>After implementing and testing my new tonality library, I was ready to
tackle the four-part chorale.</p>

<h2 id="generating-four-part-harmony">Generating Four-Part Harmony</h2>

<p>Generating the parts for all four voices introduced extra challenges.
Now that I was in charge of writing all four parts, I had to make sure that
all the notes in the chord were represented, and that the voices
were spaced correctly. There would be even more possible permutations for each chord,
while adding extra limitations.</p>

<p>Again, my solution ended up being pretty similar to the strategies that we were
taught in class. This time, instead of writing one voice at a time, we would
write an entire vertical harmonization at once, then move on. If we found that a
harmonization made it hard to voice the next chord, we would go back and tweak the
previous voicing. In my code, I implemented this as a backtracking algorithm that
would choose between entire vertical harmonization choices. This way, I didn’t have
to think about the specific strategies used to plan out the triad, as long as
the end result was allowed.</p>

<p>This rewrite took me around two days of coding. I already knew roughly how the algorithm
would work from my first experience, but it took me a while to actually write the
algorithms and encode all the voice leading rules.</p>

<h2 id="improving-the-four-part-harmony">Improving the Four-Part Harmony</h2>

<p>My chorale generator worked, and the outputted chorales were technically valid, but
sometimes the computer would make awkward decisions when choosing the voicings.
For example, the inner voices in this chorale make awkward leaps of a fourth, making
the counterpoint feel unrefined in this C Major chorale:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>       S     A      T      B
000:  E5    E4     G3     C3   
001:  F5    A4     C4     C3   
002:  E5    E4     G3     C3   
003:  D5    G4     D4     B2   
004:  E5    E4     G3     C3   
005:  E5    C5     C4     A2   
006:  F5    F4     A3     D2   
007:  D5    G4     B3     G2   
008:  E5    E4     G3     C2   

I IV6/4 I V6 I vi ii V I
</code></pre></div></div>

<audio controls="">
  
    <source src="/blog/assets/chorale/c_major_awkward.mp3" type="audio/mpeg" />
  
  Your browser does not support the audio element.
</audio>

<p>In order to improve the quality of the output, I had to encode a way to
prefer more favorable solutions. I had to give my algorithm <em>taste</em>.</p>

<h2 id="the-heuristic">The Heuristic</h2>

<p>When writing chorales, we not only want to obey the rules, but we want to make our
voice leading as smooth as possible. We prefer to have the inner voices move
as little as possible, while employing contrary and oblique motion for
voice independence.</p>

<p>In order to encode these preferences into the generator, I used a heuristic
algorithm to evaluate the quality of each candidate solution, and then
sorted all the candidate solutions by how favorable they were. This way,
the backtracking solver always prioritizes the most favorable solutions,
and tries the next best option if it doesn’t work.</p>

<p>I wrote a custom evaluation function that assigns different costs and penalties
to different choices: similar motion between the soprano and bass incurs a small
penalty of 1 point, leaps in the inner voices incur a medium penalty of 3 points,
etc. The heuristic weighs the
tradeoffs between chordal doubling, smoothness, and contrary motion to
try to choose a good solution. Here’s the same chorale, except with the voicings
chosen based on my heuristic:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>       S     A      T      B
000:  E5    G4     C4     C3   
001:  F5    A4     C4     C3   
002:  G5    C5     E4     C3   
003:  D5    D4     G3     B2   
004:  E5    G4     G3     C3   
005:  E5    A4     C4     A2   
006:  F5    A4     D4     D2   
007:  D5    B4     D4     G2   
008:  C5    G4     E4     C2

I IV6/4 I V6 I vi ii V I
</code></pre></div></div>
<audio controls="">
  
    <source src="/blog/assets/chorale/c_major_smooth.mp3" type="audio/mpeg" />
  
  Your browser does not support the audio element.
</audio>

<h2 id="uniqueness">Uniqueness</h2>

<p>Even still, always choosing the best voicings may cause the generated chorales to be boring.
Simulating human creativity requires some spontaneity and variation. In order to add some
randomness into the chorales, I added a “temperature” setting to the generator, which
tweaks each voicing evaluation by a random offset. If the computer gets lucky, occasionally
a less favorable, but more quirky voicing is chosen. The higher the temperature, the more
randomness is introduced into the system. Here is the same C Major chorale, realized four
times with varying temperatures:</p>

<audio controls="">
  
    <source src="/blog/assets/chorale/c_major_temperature.mp3" type="audio/mpeg" />
  
  Your browser does not support the audio element.
</audio>

<p>The random generator is also seeded, so that subsequent runs with the same parameters
will yield the same results. More chorales are shown in the gallery
at the bottom of this page.</p>

<h2 id="conclusion">Conclusion</h2>

<p>When I started this project, I secretly believed that if I just encoded all the rules,
my computer would start writing beautiful music. Western music theory gives a long
checklist of criteria: no parallel fifths, resolve the leading tone, and so on.
I imagined following the rules would be enough to make a decent chorale.</p>

<p>Once I actually implemented the algorithm, I learned that the rules don’t generate
good music on their own. My first chorales were technically correct, but they
sounded stiff and awkward. They passed all the requirements, but lacked flow.
Even though music theory can explain how good music behaves, it isn’t enough
to make good music on its own. I had to code my own heuristic, my own value judgements,
in order to get the program to generate elegant voice leadings, and then add
random noise to imitate creativity.</p>

<p>This project made me understand what makes music truly meaningful.
A computer can easily identify parallel fifths and search enormous problem spaces, but
has a hard time finding human meaning in their logic. My custom heuristic was only
a crude approximation of what tasteful writing looks like. The computer only thinks about
the next chord. It doesn’t plan an outline for the piece, or build any tension. It can be
taught to resolve tendency tones, but it will never understand the true beauty of a
Phrygian Half Cadence.</p>

<p>Perhaps that’s the moral of the story.
The rules don’t make good music, they only serve to explain it.
Only taste can tell you whether music sounds right.</p>

<p>In the era of computing, when execution is cheap and correctness is abundant,
<strong>personal taste is the moat</strong>.</p>

<h2 id="gallery">Gallery</h2>

<p>Each of these chorales is generated four times, with different temperature settings:</p>

<p>C Major (Basic)</p>
<ul>
  <li>I V I I I6/4 V I</li>
</ul>
<audio controls="">
  
    <source src="/blog/assets/chorale/c_major_basic.mp3" type="audio/mpeg" />
  
  Your browser does not support the audio element.
</audio>

<p>F Minor (AP Practice, Starting Notes Given)</p>
<ul>
  <li>i i6 V viiø4/3 i6 V7 i</li>
</ul>
<audio controls="">
  
    <source src="/blog/assets/chorale/f_minor_practice.mp3" type="audio/mpeg" />
  
  Your browser does not support the audio element.
</audio>

<p>E Minor</p>
<ul>
  <li>i V7 VI iio6 i6/4 V7 i</li>
</ul>
<audio controls="">
  
    <source src="/blog/assets/chorale/e_minor_chorale.mp3" type="audio/mpeg" />
  
  Your browser does not support the audio element.
</audio>

<p>D Major (Pachelbel’s Canon Chord Progression)</p>
<ul>
  <li>I V vi iii IV I IV V</li>
</ul>
<audio controls="">
  
    <source src="/blog/assets/chorale/d_major_pachelbel.mp3" type="audio/mpeg" />
  
  Your browser does not support the audio element.
</audio>

<p>G Major (Uses Secondary Dominant, My Favorite)</p>
<ul>
  <li>I V6 I I6 IV V6/V V V7 I</li>
</ul>
<audio controls="">
  
    <source src="/blog/assets/chorale/g_major_secondary.mp3" type="audio/mpeg" />
  
  Your browser does not support the audio element.
</audio>

<p>The source code for this project is available on <a href="https://github.com/maxcai314/chorale-generator">GitHub</a>.</p>]]></content><author><name></name></author><summary type="html"><![CDATA[Automatically Generating AP Music Theory Chorales]]></summary></entry><entry><title type="html">VuwCTF 2025 string-inspector: Obfuscating control flow using execve syscalls</title><link href="http://localhost:4000/blog/string-inspector-execve-obfuscation/" rel="alternate" type="text/html" title="VuwCTF 2025 string-inspector: Obfuscating control flow using execve syscalls" /><published>2025-12-09T00:00:00-08:00</published><updated>2025-12-09T00:00:00-08:00</updated><id>http://localhost:4000/blog/VuWCTF-2025-string-inspector</id><content type="html" xml:base="http://localhost:4000/blog/string-inspector-execve-obfuscation/"><![CDATA[<h1 id="vuwctf-2025---string-inspector">VuwCTF 2025 - string-inspector</h1>

<p><img src="/blog/assets/string-inspector/discord.png" alt="mistakes happen." /></p>

<p>Of course one of my challenges had to be underconstrained.</p>

<p><code class="language-plaintext highlighter-rouge">string-inspector</code> actually wasn’t the hardest rev challenge I made for
<a href="https://vuwctf.com/">VuwCTF</a>’s hybrid CTF competition, but had by far
the funniest unexpected outcome. 
In this author writeup, I will talk about the design of the program and
some of the cursed things that caused this challenge to behave unexpectedly.</p>

<p><img src="/blog/assets/string-inspector/chall.png" alt="the program output" /></p>

<h2 id="the-program">The Program</h2>

<p>From some surface-level analysis, we can see that the binary expects
a flag with 13 digits inside. Putting this through strace, we
see some pretty weird behavior:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>&gt; strace ./inspector VuwCTF{9999999999999} 2&gt;&amp;1 | grep execve
execve("./inspector", ["./inspector", "VuwCTF{9999999999999}"], 0x7ffc92c7ddf8 /* 29 vars */) = 0
execve("./inspector", ["./inspector", "9999999999999", "0000000"], 0x7ffe3d3d6488 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "1532699999999", "0000000"], 0x7ffe22de7878 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0685969999999", "0000000"], 0x7ffcd1c3a4f8 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0601296999999", "1000000"], 0x7ffe21d83f68 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0516623999999", "2000000"], 0x7ffc3b2ce358 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0431950999999", "3000000"], 0x7ffcd8997108 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0347277999999", "4000000"], 0x7ffcb7c21718 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0262604999999", "5000000"], 0x7fff438d0c28 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0177931999999", "6000000"], 0x7ffca67cc3b8 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0093258999999", "7000000"], 0x7ffecccc8778 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0008585999999", "8000000"], 0x7fff3678c778 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0000118699999", "8100000"], 0x7fffce943ee8 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0000034026999", "8101000"], 0x7ffc5cf96d58 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0000025559699", "8101100"], 0x7fffae6f9f78 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0000017092399", "8101200"], 0x7ffea9265b78 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0000008625099", "8101300"], 0x7ffc03331d08 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0000000157799", "8101400"], 0x7ffd8c38f968 /* 0 vars */) = 0
execve("./inspector", ["./inspector", "0000000073126", "8101401"], 0x7ffc19d45b18 /* 0 vars */) = 0
</code></pre></div></div>

<p>This is pretty weird! The program seems to be doing some form of recursive iteration by calling itself,
each time slightly modifying the inputs until the code converges on a result. Each pass, the program
seems to only do some basic string algorithms on the numbers- it doesn’t even decode the entire string
into a binary number to perform ALU operations. The one-argument invocation with the flag is simply
an entrypoint into this bizzare, recursive calculation.</p>

<h2 id="the-algorithm">The Algorithm</h2>

<p>The code has three basic string algorithms which process our ascii decimal char strings.
This is the first function I implemented, with the comments removed:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">int</span> <span class="nf">can_subtract_from</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">source</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">source_offset</span><span class="p">,</span> <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">minuend</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">if</span> <span class="p">(</span><span class="n">strlen</span><span class="p">(</span><span class="n">source</span><span class="p">)</span> <span class="o">-</span> <span class="n">source_offset</span> <span class="o">&lt;</span> <span class="n">strlen</span><span class="p">(</span><span class="n">minuend</span><span class="p">))</span> <span class="p">{</span>
        <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
    <span class="p">}</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">source_offset</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">if</span> <span class="p">(</span><span class="n">source</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">!=</span> <span class="sc">'0'</span><span class="p">)</span> <span class="p">{</span>
            <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
        <span class="p">}</span>
    <span class="p">}</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">strlen</span><span class="p">(</span><span class="n">minuend</span><span class="p">);</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">if</span> <span class="p">(</span><span class="n">source</span><span class="p">[</span><span class="n">source_offset</span> <span class="o">+</span> <span class="n">i</span><span class="p">]</span> <span class="o">&lt;</span> <span class="n">minuend</span><span class="p">[</span><span class="n">i</span><span class="p">])</span> <span class="p">{</span>
            <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
        <span class="p">}</span>
        <span class="k">if</span> <span class="p">(</span><span class="n">source</span><span class="p">[</span><span class="n">source_offset</span> <span class="o">+</span> <span class="n">i</span><span class="p">]</span> <span class="o">&gt;</span> <span class="n">minuend</span><span class="p">[</span><span class="n">i</span><span class="p">])</span> <span class="p">{</span>
            <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
        <span class="p">}</span>
    <span class="p">}</span>
    <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>This code does an in-place comparison on two big-endian decimal strings
to check whether a minuend can be safely subtracted from a source string.
For example, <code class="language-plaintext highlighter-rouge">20000 - 12345</code> is allowed, but <code class="language-plaintext highlighter-rouge">9999 - 12345</code> isn’t.
This comparison requires the source to be at least as long as the minuend,
and for each significant digit to be no less than that of the minuend.
With compiler optimisations enabled, this algorithm would translate to
a O(n) traversal of the strings.</p>

<p>The next string algorithm is responsible for actually performing that
subtraction operation, borrowing digits if necessary. Due to the nature
of the encoding format, this code required a nested loop.</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">void</span> <span class="nf">subtract_from</span><span class="p">(</span><span class="kt">char</span> <span class="o">*</span><span class="n">source</span><span class="p">,</span> <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">minuend</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">strlen</span><span class="p">(</span><span class="n">minuend</span><span class="p">);</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">if</span> <span class="p">(</span><span class="n">source</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">&lt;</span> <span class="n">minuend</span><span class="p">[</span><span class="n">i</span><span class="p">])</span> <span class="p">{</span>
            <span class="kt">size_t</span> <span class="n">borrow_idx</span> <span class="o">=</span> <span class="n">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span>
            <span class="k">while</span> <span class="p">(</span><span class="n">source</span><span class="p">[</span><span class="n">borrow_idx</span><span class="p">]</span> <span class="o">==</span> <span class="sc">'0'</span><span class="p">)</span> <span class="p">{</span>
                <span class="n">source</span><span class="p">[</span><span class="n">borrow_idx</span><span class="p">]</span> <span class="o">=</span> <span class="sc">'9'</span><span class="p">;</span>
                <span class="n">borrow_idx</span><span class="o">--</span><span class="p">;</span>
            <span class="p">}</span>
            <span class="n">source</span><span class="p">[</span><span class="n">borrow_idx</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span><span class="p">;</span>
            <span class="n">source</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">10</span><span class="p">;</span>
        <span class="p">}</span>
        <span class="n">source</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">-=</span> <span class="p">(</span><span class="n">minuend</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">-</span> <span class="sc">'0'</span><span class="p">);</span>
    <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The final algorithm is the simplest of them all: it increments
a number, carrying any nines to the left.</p>
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">void</span> <span class="nf">increment_digit</span><span class="p">(</span><span class="kt">char</span> <span class="o">*</span><span class="n">number</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">idx</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">while</span> <span class="p">(</span><span class="n">number</span><span class="p">[</span><span class="n">idx</span><span class="p">]</span> <span class="o">==</span> <span class="sc">'9'</span><span class="p">)</span> <span class="p">{</span>
        <span class="n">number</span><span class="p">[</span><span class="n">idx</span><span class="p">]</span> <span class="o">=</span> <span class="sc">'0'</span><span class="p">;</span>
        <span class="n">idx</span><span class="o">--</span><span class="p">;</span>
    <span class="p">}</span>
    <span class="n">number</span><span class="p">[</span><span class="n">idx</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<h2 id="the-recursion">The Recursion</h2>

<p>The main code simply uses these functions to search for a place to subtract
a divisor to get the result. After the operation, it will perform a recursive
execve call, conveniently restarting the algorithm to avoid any problems.</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">size_t</span> <span class="n">dividend_len</span> <span class="o">=</span> <span class="n">strlen</span><span class="p">(</span><span class="n">dividend</span><span class="p">);</span>
<span class="kt">size_t</span> <span class="n">divisor_len</span> <span class="o">=</span> <span class="n">strlen</span><span class="p">(</span><span class="n">divisor</span><span class="p">);</span>
<span class="kt">size_t</span> <span class="n">quotient_len</span> <span class="o">=</span> <span class="n">strlen</span><span class="p">(</span><span class="n">quotient</span><span class="p">);</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">division_idx</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">division_idx</span> <span class="o">&lt;</span> <span class="n">dividend_len</span><span class="p">;</span> <span class="n">division_idx</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">if</span> <span class="p">(</span><span class="n">can_subtract_from</span><span class="p">(</span><span class="n">dividend</span><span class="p">,</span> <span class="n">division_idx</span><span class="p">,</span> <span class="n">divisor</span><span class="p">))</span> <span class="p">{</span>
        <span class="n">subtract_from</span><span class="p">(</span><span class="n">dividend</span> <span class="o">+</span> <span class="n">division_idx</span><span class="p">,</span> <span class="n">divisor</span><span class="p">);</span>
        <span class="n">increment_digit</span><span class="p">(</span><span class="n">quotient</span><span class="p">,</span> <span class="n">quotient_len</span> <span class="o">-</span> <span class="n">dividend_len</span> <span class="o">+</span> <span class="n">division_idx</span> <span class="o">+</span> <span class="n">divisor_len</span> <span class="o">-</span> <span class="mi">1</span><span class="p">);</span>

        <span class="kt">char</span> <span class="o">*</span><span class="n">new_argv</span><span class="p">[]</span> <span class="o">=</span> <span class="p">{</span>
            <span class="n">argv</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span>
            <span class="n">dividend</span><span class="p">,</span>
            <span class="n">quotient</span><span class="p">,</span>
            <span class="nb">NULL</span>
        <span class="p">};</span>
        <span class="kt">char</span> <span class="o">*</span><span class="n">new_environ</span><span class="p">[]</span> <span class="o">=</span> <span class="p">{</span> <span class="nb">NULL</span> <span class="p">};</span>
        
        <span class="n">execve</span><span class="p">(</span><span class="n">argv</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">new_argv</span><span class="p">,</span> <span class="n">new_environ</span><span class="p">);</span>
        <span class="n">exit</span><span class="p">(</span><span class="n">EXIT_FAILURE</span><span class="p">);</span>
    <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The recursive <code class="language-plaintext highlighter-rouge">execve</code> syscall will effectively reset the computation with the changed parameters,
meaning that the end of the loop is only ever reached if the code finds no place to subtract,
signalling that the computation is done. 
Putting all this together, we can see that this code emulates an inefficient long division algorithm
using only subtraction and iteration. After subtracting out all multiples of the dividend <code class="language-plaintext highlighter-rouge">84673</code>,
the code performs a simple constraint check, requiring the quotient to be equal to <code class="language-plaintext highlighter-rouge">0319993</code> and
the remainder to be equal to <code class="language-plaintext highlighter-rouge">0000000000042</code>.</p>

<p><em>One would expect that this arithmetic equation can only have one correct solution.</em></p>

<h2 id="the-mistake">The Mistake</h2>

<p>Each time this long division algorithm performs a subtraction, it needs to increment the count
at the appropriate place. In the main function, the code runs this code:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">increment_digit</span><span class="p">(</span><span class="n">quotient</span><span class="p">,</span> <span class="n">quotient_len</span> <span class="o">-</span> <span class="n">dividend_len</span> <span class="o">+</span> <span class="n">division_idx</span> <span class="o">+</span> <span class="n">divisor_len</span> <span class="o">-</span> <span class="mi">1</span><span class="p">);</span>
</code></pre></div></div>

<p><em>Note: this took me a solid ten minutes to think through and make sure there weren’t any off-by-one errors. I never want to work with reverse-order decimal arithmetic ever again.</em></p>

<p>As it turns out, if the quotient is too small, this code can actually compute a negative index to increment to,
making an out-of-bounds access and corrupting any data around this heap segment! This undefined behavior
didn’t cause the program to crash because the <code class="language-plaintext highlighter-rouge">execve</code> syscall reïnitializes a fresh copy of the runtime,
completely ignoring the corrupted heap metadata. Perhaps <code class="language-plaintext highlighter-rouge">execve</code> is the future of memory safety.</p>

<p><a href="https://snowbird91.github.io/ctf/write-ups/string-inspector/">Andyrew</a> from team tjcsc found two
alternative solutions that passed the flag verifier due to this underflow, realizing that the quotient
didn’t have to mathematically equal to <code class="language-plaintext highlighter-rouge">319993</code>, as long as the result was the same in the process (mod 10^7).
This means that the program accepted the flags <code class="language-plaintext highlighter-rouge">0873824767331</code> and <code class="language-plaintext highlighter-rouge">1720554767331</code>, despite invoking
out-of-bounds access and corrupting the glibc heap.</p>

<p>I genuinely did not see this coming, and didn’t even realize this bug existed in the challenge
until Andrew opened a ticket reporting the problem. I’m genuinely impressed that players not only
understood the program enough to solve the challenge, but also to find limitations in its logic.</p>

<p><img src="/blog/assets/string-inspector/conversation.png" alt="valid crashout" /></p>

<p>Hats off to you, Andrew! Though next time, maybe try all your possible solutions, and
immediately file a report when you find a discrepancy :^)</p>

<p>The correct input value was <code class="language-plaintext highlighter-rouge">84673 * 319993 + 42</code>, zero-extended to take up
all thirteen digits, making the intended flag <code class="language-plaintext highlighter-rouge">VuwCTF{0027094767331}</code>.</p>

<h2 id="the-conclusion">The Conclusion</h2>

<p>Unix has plenty of interesting syscalls which allow programs to do
bizzare actions that span beyond the scope of one singular runtime.
Through the use of the <code class="language-plaintext highlighter-rouge">execve</code> syscall, we can obfuscate control
and data flow, making both static and dynamic analysis harder.
In the <code class="language-plaintext highlighter-rouge">string-inspector</code> challenge, the code performs very simple
string looping algorithms and uses this recursion primitive to emulate
a more complex long division computation.</p>

<p>I tried to keep the code as simple as possible and omitted several
bounds checks in my program, assuming that it wouldn’t harm the 
overall integrity of my reverse engineering challenge. However, I was wrong.
One buffer underflow bug ended up introducing several
unintended solutions to my challenge, causing some players frustration.
In the future, I will make sure to be extra careful that my code is
written correctly, just in case someone tries to pwn my rev challenge.</p>]]></content><author><name></name></author><summary type="html"><![CDATA[VuwCTF 2025 - string-inspector]]></summary></entry><entry><title type="html">corCTF 2025 purely-functional-oop: Compiling object-oriented code into Google Sheets expressions</title><link href="http://localhost:4000/blog/spreadsheet-oop-lang-compiler/" rel="alternate" type="text/html" title="corCTF 2025 purely-functional-oop: Compiling object-oriented code into Google Sheets expressions" /><published>2025-09-18T00:00:00-07:00</published><updated>2025-09-18T00:00:00-07:00</updated><id>http://localhost:4000/blog/corCTF-2025-purely-functional-oop</id><content type="html" xml:base="http://localhost:4000/blog/spreadsheet-oop-lang-compiler/"><![CDATA[<h1 id="corctf-2025---purely-functional-oop">corCTF 2025 - purely-functional-oop</h1>

<p><em>This blog was also posted to the <a href="https://cor.team/posts/corctf-2025-purely-functional-oop/">Crusaders of Rust website</a>.</em></p>

<p>This challenge is the culmination of my adventures with Google Sheets functional programming. 
In <a href="https://max.xz.ax/blog/spreadsheet-functional-programming/">part one</a>, I implemented church 
numerals and arithmetic using only pure lambda abstractions and applications, and in <a href="https://max.xz.ax/blog/spreadsheet-object-oriented-programming/">part two</a>, I outlined a framework upon which smalltalk-style object-oriented message passing could be implemented. For corCTF 2025, I decided to implement those ideas into an actual product, compiling a custom object-oriented language into an executable Google Sheets formula.</p>

<p>Players were provided the source code for the compiler and were given access to a server running the same code, bound to the real flag. In order to solve this challenge, players had find a vulnerability in the compiler and 
submit code in the object-oriented language that, when compiled and executed, would reveal the flag.</p>

<p>I thought this challenge was really cool and allowed players to experiment with compilers in a new 
context without getting too deep into advanced concepts. In this blog, I will talk about the design 
of this compiler as well as the intended solution for this ctf challenge.</p>

<h2 id="the-language">The Language</h2>

<p><img src="/blog/assets/purely-functional-oop/teaser.png" alt="the snippet shown in the challenge teaser tweet" /></p>

<p>From the teaser, we get a basic demonstration of the features in the language. This is a 
pure object-oriented language, users can declare classes with constructors that assign 
instance fields, as well as methods. All values in the language are objects, 
even the built-in integer and string literals (which are wrapped with methods).</p>

<p>The code would then be automatically compiled into a google sheets formula, which
would be executed in a cell.</p>

<p><img src="/blog/assets/purely-functional-oop/teaser_execution.png" alt="the compiled code is run in a google sheets cell." /></p>

<p>In the service itself, we see that our submitted code is also linked with another 
class declaration, which gives users a chance to obtain the flag:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="sh">"""</span><span class="s">
class Challenge {
    constructor() {
        let this.n = 3;
        let this.flag = </span><span class="sh">"""</span> <span class="o">+</span> <span class="sa">f</span><span class="sh">'"</span><span class="si">{</span><span class="n">FLAG</span><span class="si">}</span><span class="sh">"'</span> <span class="o">+</span> <span class="sh">"""</span><span class="s">;
    }

    fn verifySolution(a, b, c) {
        let nonzeroInput = nonzero(a).and(nonzero(b)).and(nonzero(c));
        let integerInput = isInteger(a).and(isInteger(b)).and(isInteger(c));
        let satisfiesTheorem = pow(a, this.n).plus(pow(b, this.n)).equals(pow(c, this.n));
        
        let accepted = nonzeroInput.and(integerInput).and(satisfiesTheorem);
        return accepted ? this.flag : </span><span class="sh">"</span><span class="s">Solution rejected</span><span class="sh">"</span><span class="s">;
    }
}
</span><span class="sh">"""</span>
</code></pre></div></div>

<p>This code requires users to enter three nonzero integers that can satisfy <a href="https://en.wikipedia.org/wiki/Fermat%27s_Last_Theorem">Fermat’s Last Theorem</a> for n=3. Unfortunately, it has already been proven that no solutions exist for this 
mathematical problem — in order to get the flag, solvers would need to hack the compiler to trick the program.</p>

<h2 id="the-compiler">The Compiler</h2>

<p><em>This compiler was hastily written, so the exact terminologies used in the internal documentation may be inaccurate.</em></p>

<p>In order to compile code, the program uses python’s <a href="https://github.com/lark-parser/lark">lark</a> library to parse
the language’s grammar, and then uses a recursive algorithm to generate the formula substitutions for each node 
in the parse tree. The grammar defines four types of statements: class definitions, function definitions, 
constructor definitions, and instructions (class assignment, assignment, and return statements). 
Functions could be defined either statically (outside of any class), or as an instance method (inside of a class).
For simplicity, nested classes were not allowed in the language.</p>

<p>The recursive algorithm would generate the Google Sheets formula substitution, resolving each subtree until
finished. For example, a method call would boil down to this expression:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">args</span> <span class="o">=</span> <span class="sh">"</span><span class="s">, </span><span class="sh">"</span><span class="p">.</span><span class="nf">join</span><span class="p">(</span><span class="nf">parse_expression</span><span class="p">(</span><span class="n">arg</span><span class="p">,</span> <span class="n">scope</span><span class="p">,</span> <span class="n">outer_name</span><span class="p">)</span> <span class="k">for</span> <span class="n">arg</span> <span class="ow">in</span> <span class="n">argument_list</span><span class="p">.</span><span class="n">children</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">args</span><span class="p">:</span>
    <span class="k">return</span> <span class="sa">f</span><span class="sh">"</span><span class="si">{</span><span class="n">callee</span><span class="si">}</span><span class="s">(</span><span class="se">\"</span><span class="si">{</span><span class="n">method_name</span><span class="si">}</span><span class="se">\"</span><span class="s">)</span><span class="sh">"</span> <span class="c1"># no curried arguments
</span><span class="k">else</span><span class="p">:</span>
    <span class="k">return</span> <span class="sa">f</span><span class="sh">"</span><span class="si">{</span><span class="n">callee</span><span class="si">}</span><span class="s">(</span><span class="se">\"</span><span class="si">{</span><span class="n">method_name</span><span class="si">}</span><span class="se">\"</span><span class="s">)(</span><span class="si">{</span><span class="n">args</span><span class="si">}</span><span class="s">)</span><span class="sh">"</span>
</code></pre></div></div>

<p><em>In hindsight, it would’ve made more sense to make parameterless lambdas for no-argument methods. I didn’t know that existed at the time.</em></p>

<p>Otherwise, assignments and declarations would resolve into a string and expression pair that could be 
combined inside of a Google Sheets <code class="language-plaintext highlighter-rouge">LET</code> expression.</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">elif</span> <span class="n">statement_type</span> <span class="o">==</span> <span class="sh">"</span><span class="s">assignment</span><span class="sh">"</span><span class="p">:</span>
    <span class="n">variable_name</span> <span class="o">=</span> <span class="n">statement</span><span class="p">.</span><span class="n">children</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
    <span class="nf">ensure_valid_name</span><span class="p">(</span><span class="n">variable_name</span><span class="p">)</span>
    <span class="n">rhs</span> <span class="o">=</span> <span class="nf">parse_expression</span><span class="p">(</span><span class="n">statement</span><span class="p">.</span><span class="n">children</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">scope</span><span class="p">,</span> <span class="n">outer_name</span><span class="p">)</span>
    <span class="nf">return </span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="si">{</span><span class="n">variable_name</span><span class="si">}</span><span class="s">, </span><span class="si">{</span><span class="n">rhs</span><span class="si">}</span><span class="s">,</span><span class="se">\n</span><span class="sh">"</span><span class="p">,</span> <span class="bp">False</span><span class="p">)</span>
</code></pre></div></div>

<p>Things start to get a little complicated when we declare classes. We want both <code class="language-plaintext highlighter-rouge">this</code> and the original class 
to be available inside method calls, but in lambda calculus, explicit recursion isn’t possible. In order to 
implement this, I wrote this monstronsity of a template to handle double recursion:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># template for a class definition
</span><span class="n">compiled_result</span> <span class="o">=</span> <span class="sa">f</span><span class="sh">"""</span><span class="s">
class_</span><span class="si">{</span><span class="n">class_name</span><span class="si">}</span><span class="s">, LAMBDA(_constructor, LAMBDA(this,
    </span><span class="si">{</span><span class="n">constructor_opening</span><span class="si">}</span><span class="s">
        LAMBDA(_message,
            </span><span class="si">{</span><span class="n">message_handler</span><span class="si">}</span><span class="s">
        )
    </span><span class="si">{</span><span class="n">constructor_closing</span><span class="si">}</span><span class="s">
)),
bootstrap_new_</span><span class="si">{</span><span class="n">class_name</span><span class="si">}</span><span class="s">, LAMBDA(_f, 
    LAMBDA(</span><span class="si">{</span><span class="n">constructor_args_comma</span><span class="si">}</span><span class="s"> 
        class_</span><span class="si">{</span><span class="n">class_name</span><span class="si">}</span><span class="s">(
            LAMBDA(</span><span class="si">{</span><span class="n">constructor_args_comma</span><span class="si">}</span><span class="s"> 
                (LAMBDA(_message, _f(_f)(</span><span class="si">{</span><span class="n">constructor_args</span><span class="si">}</span><span class="s">)(_message)))
            )
        ) (LAMBDA(_message, 
            _f(_f)(</span><span class="si">{</span><span class="n">constructor_args</span><span class="si">}</span><span class="s">)(_message)
        )) (</span><span class="si">{</span><span class="n">constructor_args</span><span class="si">}</span><span class="s">)
    )
),
new_</span><span class="si">{</span><span class="n">class_name</span><span class="si">}</span><span class="s">, (bootstrap_new_</span><span class="si">{</span><span class="n">class_name</span><span class="si">}</span><span class="s">) (bootstrap_new_</span><span class="si">{</span><span class="n">class_name</span><span class="si">}</span><span class="s">),
</span><span class="sh">"""</span>
</code></pre></div></div>

<p><em>A similar, simpler recursive template was used to enable static function call recursion. For brevity, I won’t show it here.</em></p>

<p>All primitives are wrapped in objects with predefined methods for functionality. Internally, they are accessed using 
the <code class="language-plaintext highlighter-rouge">_rawVal</code> method:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">make_builtin_bootstrap</span><span class="p">,</span> <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">raw</span><span class="p">,</span>
    <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">_message</span><span class="p">,</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="n">raw</span><span class="p">,</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">plus</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">+</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">minus</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">-</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">times</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">*</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">divide</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">/</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">equals</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">=</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span> 
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">notEquals</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">&lt;&gt;</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span> 
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">and</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="nc">AND</span><span class="p">(</span><span class="n">raw</span><span class="p">,</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">)))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">or</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="nc">OR</span><span class="p">(</span><span class="n">raw</span><span class="p">,</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">)))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">xor</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="nc">XOR</span><span class="p">(</span><span class="n">raw</span><span class="p">,</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">)))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">lessThan</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">&lt;</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">lessThanOrEquals</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">&lt;=</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">greaterThan</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">&gt;</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">greaterThanOrEquals</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="n">raw</span> <span class="o">&lt;=</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">))),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">negate</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="nc">NOT</span><span class="p">(</span><span class="n">raw</span><span class="p">)),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">factorial</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="nc">FACT</span><span class="p">(</span><span class="n">raw</span><span class="p">)),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">log</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="nc">LOG</span><span class="p">(</span><span class="n">raw</span><span class="p">)),</span>
        <span class="nc">IF</span><span class="p">(</span><span class="nf">_message_match</span><span class="p">(</span><span class="sh">"</span><span class="s">concat</span><span class="sh">"</span><span class="p">)(</span><span class="n">_message</span><span class="p">),</span>
            <span class="nc">LAMBDA</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="nf">f</span><span class="p">(</span><span class="n">f</span><span class="p">)(</span><span class="nc">CONCAT</span><span class="p">(</span><span class="n">raw</span><span class="p">,</span> <span class="nf">rhs</span><span class="p">(</span><span class="sh">"</span><span class="s">_rawVal</span><span class="sh">"</span><span class="p">)))),</span>
        <span class="nf">_raise_error_internal</span><span class="p">()</span> 
        <span class="p">))))))))))))))))))</span>
    <span class="p">)</span>
<span class="p">)),</span>

<span class="n">make_builtin</span><span class="p">,</span> <span class="p">(</span><span class="n">make_builtin_bootstrap</span><span class="p">)</span> <span class="p">(</span><span class="n">make_builtin_bootstrap</span><span class="p">),</span>
</code></pre></div></div>

<p>Being derived from a functional programming language, everything here is immutable and pure. This means that 
repeated method calls on an object must always return the same value. Since there is no 
mathematical solution to the constraints, what inputs can we pass to the challenge to get the flag?</p>

<h2 id="the-exploit">The Exploit</h2>

<p>The compiler has a set of reserved keywords in order to prevent names from overlapping with 
other tokens used in the system. These are the keywords:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">RESERVED_KEYWORDS</span> <span class="o">=</span> <span class="p">{</span> 
    <span class="sh">"</span><span class="s">class</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">fn</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">constructor</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">let</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">return</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">new</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">this</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">true</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">false</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">_f</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">_message</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">_constructor</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">_message_match</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">_raise_error_internal</span><span class="sh">"</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Since there is no runtime type checking in this programming langauge, 
numbers behave just like 
any other object — There is actually nothing preventing us from 
writing custom number objects that define all those same methods. 
Notice that the <code class="language-plaintext highlighter-rouge">_rawVal</code> method isn’t a reserved keyword, so we can call and implement these methods 
on any system. My intended solution abuses this mechanic by creating a special 
boolean value that will always return the same truth value, no matter what 
logical methods are called from it. This code yields the flag, <code class="language-plaintext highlighter-rouge">corctf{p0lym0rpHic_fr33k_1n_th3_sh33ts}</code></p>

<div class="language-js highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">class</span> <span class="nc">TrapBoolean</span> <span class="p">{</span>
    <span class="nf">constructor</span><span class="p">(</span><span class="nx">inner</span><span class="p">)</span> <span class="p">{</span>
        <span class="kd">let</span> <span class="k">this</span><span class="p">.</span><span class="nx">inner</span> <span class="o">=</span> <span class="nx">inner</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="nx">fn</span> <span class="nf">_rawVal</span><span class="p">()</span> <span class="p">{</span>
        <span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="nx">inner</span><span class="p">.</span><span class="nf">_rawVal</span><span class="p">();</span>
    <span class="p">}</span>

    <span class="nx">fn</span> <span class="nf">and</span><span class="p">(</span><span class="nx">other</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">return</span> <span class="k">this</span><span class="p">;</span>
    <span class="p">}</span>
<span class="p">}</span>

<span class="kd">class</span> <span class="nc">TrapNumber</span> <span class="p">{</span>
    <span class="nf">constructor</span><span class="p">(</span><span class="nx">inner</span><span class="p">)</span> <span class="p">{</span>
        <span class="kd">let</span> <span class="k">this</span><span class="p">.</span><span class="nx">inner</span> <span class="o">=</span> <span class="nx">inner</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="nx">fn</span> <span class="nf">_rawVal</span><span class="p">()</span> <span class="p">{</span>
        <span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="nx">inner</span><span class="p">.</span><span class="nf">_rawVal</span><span class="p">();</span>
    <span class="p">}</span>

    <span class="nx">fn</span> <span class="nf">notEquals</span><span class="p">(</span><span class="nx">other</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">return</span> <span class="k">new</span> <span class="nc">TrapBoolean</span><span class="p">(</span><span class="kc">true</span><span class="p">);</span>
    <span class="p">}</span>
<span class="p">}</span>

<span class="kd">let</span> <span class="nx">chall</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Challenge</span><span class="p">();</span>
<span class="k">return</span> <span class="nx">chall</span><span class="p">.</span><span class="nf">verifySolution</span><span class="p">(</span><span class="k">new</span> <span class="nc">TrapNumber</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
</code></pre></div></div>

<h2 id="the-ctf">The CTF</h2>

<p>Unfortunately, this challenge had unintended solutions which took advantage of
Google Sheets’ type confusion, with the one-line exploit 
<code class="language-plaintext highlighter-rouge">return new Challenge().verifySolution("0", "0", "0");</code>. 
As my friend Drakon accurately pointed out, “this is why we need a strongly typed spreadsheet.” 
At least some teams found the intended solution! I’d like to shout out the team 
Squid Proxy Lovers for taking the time to write up <a href="https://spl.team/blog/cor-ctf-rev-write-ups-262bcc8ed7ef80b1beb1fe81ada9b7b6/#purely-functional-oop">their analysis and solution</a>, which actually took advantage 
of the language and compiler features.</p>

<h2 id="the-conclusion">The Conclusion</h2>

<p>Despite compiling to a platform with a completely different programming paradigm, 
the intended solution for this challenge does not involve any mechanics specific to Google Sheets. 
<code class="language-plaintext highlighter-rouge">purely-functional-oop</code> serves as a warning against the dangers of duck typing and polymorphism.</p>

<p>I loved playing with this new concept and exploring the relationship between functional 
and object-oriented programming. Even though there was a cheese to the challenge, 
creating a compiler for this challenge and playing with 
Google Sheets formula technology was a lot of fun. Although there is very little practical 
usage in bringing object-oriented programming into spreadsheets, 
I found it interesting nonetheless. Who knows, maybe some tinkerer in the future will 
develop this concept into a proper toolchain.</p>]]></content><author><name></name></author><summary type="html"><![CDATA[corCTF 2025 - purely-functional-oop]]></summary></entry><entry><title type="html">corCTF 2025 whatever-floats-your-boat: Obfuscation using IEEE 754 floating-point exceptions</title><link href="http://localhost:4000/blog/boat-vm-x86-floating-point-exceptions/" rel="alternate" type="text/html" title="corCTF 2025 whatever-floats-your-boat: Obfuscation using IEEE 754 floating-point exceptions" /><published>2025-08-04T00:00:00-07:00</published><updated>2025-08-04T00:00:00-07:00</updated><id>http://localhost:4000/blog/corCTF-2025-boat-vm</id><content type="html" xml:base="http://localhost:4000/blog/boat-vm-x86-floating-point-exceptions/"><![CDATA[<h1 id="corctf-2025---whatever-floats-your-boat">corCTF 2025 - whatever-floats-your-boat</h1>

<p><em>This blog was also posted to the <a href="https://cor.team/posts/corctf-2025-boat-vm/">Crusaders of Rust website</a>.</em></p>

<p><img src="/blog/assets/boat-vm/promotion.png" alt="fizzbuzz gives me a promotion" /></p>

<p>Well… how the heck did I end up here?</p>

<p><code class="language-plaintext highlighter-rouge">whatever-floats-your-boat</code> was my favorite challenge that I made for corCTF 2025. 
I had an absolute blast writing this challenge and learning about the mechanics of floating point arithmetic.</p>

<p>The rev challenge used a virtual machine based around several absolutely cursed concepts: 
IEEE 754 floating-point arithmetic and the x86 MXCSR FPU exception flags. 
In this blog, I will talk about the VM design and how floating-point algorithms were put together 
in order to create the challenge’s flag calculator program.</p>

<p><img src="/blog/assets/boat-vm/program_output.png" alt="the program output" /></p>

<p>The CTF challenge provided a VM binary as well as a 60-kilobyte program which promised to print the flag. 
Just one problem… this program isn’t expected to finish anytime within the next 10^50 years. 
By then, most of the matter in the universe will have condensed into supermassive black holes or clouds of gas.</p>

<p>Clearly, there must be a more efficient way to solve this challenge. In order to obtain the flag, 
players must understand what the VM is doing.</p>

<h2 id="the-virtual-machine">The Virtual Machine</h2>

<p><img src="/blog/assets/boat-vm/scheming.png" alt="thanks, timothy!" /></p>

<p>The idea for this VM originally came from my friend <a href="https://anemato.de/">Timothy Herchen</a>, 
but he didn’t have the time to turn this amazing concept into a challenge for corCTF.
As “head of rev dev,” I decided to take it into my own hands and implement the idea into a rev challenge. 
Thanks, Timothy!</p>

<p>As mentioned above, this VM is based entirely around the behavior of <a href="https://en.wikipedia.org/wiki/IEEE_754#Exception_handling">IEEE 754</a> floating-point arithmetic. x86’s SIMD extensions offer the 
<code class="language-plaintext highlighter-rouge">LDMXCSR</code> and <code class="language-plaintext highlighter-rouge">STMXCSR</code> instructions to access the <code class="language-plaintext highlighter-rouge">MXCSR</code> (Media eXtension Control and Status Register) state 
for programs to get and reset the exception flags raised by floating-point calculations.</p>

<p>The way <code class="language-plaintext highlighter-rouge">boat-vm</code> actually works is fairly standard, and is modeled after WebAssembly and the Java Virtual Machine. 
The VM contains a data stack and a separate function call stack, and the destinations of <code class="language-plaintext highlighter-rouge">CALL</code>/<code class="language-plaintext highlighter-rouge">RET</code> instructions 
are statically encoded into the instruction — there is no arbitrary “jump to the address in this register.” Outside of the data stack, there exist <code class="language-plaintext highlighter-rouge">LOAD</code> and <code class="language-plaintext highlighter-rouge">STORE</code> opcodes, which allow for random memory access.</p>

<p>However, the way the VM handles branching logic is very peculiar. Instead of usual “branch if zero” or 
“branch if nonzero” opcodes, branching behavior is decided using the 
<code class="language-plaintext highlighter-rouge">B_DIVBYZERO</code>, <code class="language-plaintext highlighter-rouge">B_INEXACT</code>, <code class="language-plaintext highlighter-rouge">B_INVALID</code>, <code class="language-plaintext highlighter-rouge">B_OVERFLOW</code>, <code class="language-plaintext highlighter-rouge">B_UNDERFLOW</code>, 
instructions, which read the FPU’s exception state to determine whether to take a branch. 
In order to use this primitive, there was also a <code class="language-plaintext highlighter-rouge">CLEAR_EXCEPT</code> instruction which would
reset the <code class="language-plaintext highlighter-rouge">MXCSR</code> register for future use. In C, this was implemented using <code class="language-plaintext highlighter-rouge">immintrin.h</code>’s <code class="language-plaintext highlighter-rouge">_MM_GET_EXCEPTION_STATE()</code> and <code class="language-plaintext highlighter-rouge">_MM_SET_EXCEPTION_STATE(0)</code> macros.</p>

<p>This changes things. FPU exceptions are “sticky,” meaning they accumulate as operations are performed in the VM. 
The “inexact” flag could be set by any previous instruction, which makes code much trickier to reason about.</p>

<p>Here is the full list of opcodes as named in the source code.</p>

<div class="language-c++ highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">enum</span> <span class="o">:</span> <span class="n">s64</span> <span class="p">{</span>
    <span class="n">PUSH_CONST</span><span class="p">,</span> <span class="n">POP</span><span class="p">,</span> <span class="n">DUP</span><span class="p">,</span> <span class="n">DUP2</span><span class="p">,</span> <span class="n">DUP_X1</span><span class="p">,</span> <span class="n">SWAP</span><span class="p">,</span> <span class="n">NOP</span><span class="p">,</span>
    <span class="n">ADD</span><span class="p">,</span> <span class="n">SUB</span><span class="p">,</span> <span class="n">MUL</span><span class="p">,</span> <span class="n">DIV</span><span class="p">,</span> <span class="n">FLOOR</span><span class="p">,</span> <span class="n">CEIL</span><span class="p">,</span> <span class="n">TRUNC</span><span class="p">,</span> <span class="n">ROUND</span><span class="p">,</span> <span class="n">ABS</span><span class="p">,</span> <span class="n">MIN</span><span class="p">,</span> <span class="n">MAX</span><span class="p">,</span>
    <span class="n">CLEAR_EXCEPT</span><span class="p">,</span> <span class="n">B_DIVBYZERO</span><span class="p">,</span> <span class="n">B_INEXACT</span><span class="p">,</span> <span class="n">B_INVALID</span><span class="p">,</span> <span class="n">B_OVERFLOW</span><span class="p">,</span> <span class="n">B_UNDERFLOW</span><span class="p">,</span> <span class="n">B_ANY</span><span class="p">,</span> <span class="n">B_ALWAYS</span><span class="p">,</span>
    <span class="n">CALL</span><span class="p">,</span> <span class="n">RET</span><span class="p">,</span>
    <span class="n">PRINT_FLOAT</span><span class="p">,</span> <span class="n">PRINT_CHAR</span><span class="p">,</span> <span class="n">READ_FLOAT</span><span class="p">,</span> <span class="n">READ_CHAR</span><span class="p">,</span>
    <span class="n">LOAD</span><span class="p">,</span> <span class="n">STORE</span>
<span class="p">}</span> <span class="n">insn_t</span><span class="p">;</span>
</code></pre></div></div>

<h2 id="about-floating-points">About Floating Points</h2>

<p><code class="language-plaintext highlighter-rouge">boat-vm</code> specifically relies on the behavior of the C <code class="language-plaintext highlighter-rouge">double</code> datatype, which on our platform, corresponds to the 
<a href="https://en.wikipedia.org/wiki/Double-precision_floating-point_format">IEEE 754 double-precision binary floating-point format</a>. A <code class="language-plaintext highlighter-rouge">double</code> includes a sign bit, an 11-bit biased exponent, 
and a 52-bit mantissa which represents the fractional component of the significand.</p>

<p><img src="/blog/assets/boat-vm/float_format.png" alt="The IEEE 754 double-precision binary floating-point format." /></p>

<p>The significand actually contains an implicit integer bit of value 1, which makes the total precision 
53 bits. For a normal floating-point numbers, this formula is used to compute the real value:</p>

<p><img src="/blog/assets/boat-vm/float_formula.png" alt="This formula is used to compute the value of normal floating point numbers." /></p>

<p>When the FPU cannot precisely represent the result of an arithmetic operation, 
it will raise the <code class="language-plaintext highlighter-rouge">INEXACT</code> exception flag, 
indicating the result. We can actually use this behavior to test the value of a floating point number: if a number is 
greater than equal to one, its exponent value must be at least zero, and therefore its mantissa cannot represent an additional value 2^53. In my assembler, this algorithm is used to test whether numbers are greater than or equal to one:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// function: return whether n greater than equal to 1</span>
<span class="kt">int</span> <span class="n">greaterThanOrEquals1Index</span> <span class="o">=</span> <span class="n">getProgramCount</span><span class="o">(</span><span class="n">buffer</span><span class="o">);</span> <span class="c1">// where the function starts</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"linking greaterThanOrEquals1Index at pc "</span> <span class="o">+</span> <span class="n">greaterThanOrEquals1Index</span><span class="o">);</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mf">0.000042006942069</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">MAX</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// add minimum threshold to 1) make positive 2) prevent small magnitude errors</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">makeDouble</span><span class="o">(</span><span class="kc">false</span><span class="o">,</span> <span class="o">-</span><span class="mi">53</span><span class="o">,</span> <span class="mi">0</span><span class="o">))</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CLEAR_EXCEPT</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">ADD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// n + 2^(-53) is inexact if n &gt;= 1 due to exponent</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// we didn't need the result, only the fpu flags</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">0</span><span class="o">)</span> <span class="c1">// 1, 0</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_INEXACT</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">2</span><span class="o">)</span> <span class="c1">// skip 2 instructions if inexact</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// 0, 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// if inexact, keep 1, else keep 0</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>
</code></pre></div></div>

<p>Similarly, when the magnitude of a floating-point computation overflows past the maximum possible real value into infinity, the <code class="language-plaintext highlighter-rouge">OVERFLOW</code> exception flag is set. When we divide the maximum possible real double value by any number less than one, the computation will overflow. By using the sticky property of FPU flags, we can divide that special number by 
both a number and its reciprocal, raising no exceptions only when the input number is exactly one. 
This is how my program implements that algorithm to check for strict equality to the value <code class="language-plaintext highlighter-rouge">1.0</code>:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// function: return whether n is exactly equal to 1</span>
<span class="kt">int</span> <span class="n">equals1Index</span> <span class="o">=</span> <span class="n">getProgramCount</span><span class="o">(</span><span class="n">buffer</span><span class="o">);</span> <span class="c1">// where the function starts</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"linking equals1Index at pc "</span> <span class="o">+</span> <span class="n">equals1Index</span><span class="o">);</span>
<span class="c1">// we need to normalize our value to check if *exactly* 1</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mf">0.000042006942069</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">MAX</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// add minimum threshold to make positive</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="nc">Double</span><span class="o">.</span><span class="na">MAX_VALUE</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// max_value, n</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP2</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// max_value, n, max_value, n</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// max_value, n, max_value, n, 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// max_value, n, max_value, 1/n</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CLEAR_EXCEPT</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// fire incoming !!!!!!!!!!!</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// raises fpu exception if 1/n &lt; 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// raises fpu exception if n &lt; 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_OVERFLOW</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">3</span><span class="o">);</span> <span class="c1">// implied OR gate because FPU exception flags are sticky</span>

<span class="c1">// no exception case: n == 1</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>

<span class="c1">// overflow exception: n != 1</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">0</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>
</code></pre></div></div>

<p>With these basic primitives covered, we can go about implementing the full challenge program.</p>

<h2 id="the-program">The Program</h2>

<p>Uncreatively, I decided to make the flag computer program solve a sudoku problem in order to decode the flag. 
At the time, I couldn’t think of any other interesting problems that could be implemented in a very inefficient way.</p>

<p>The program contained a function to load a hard-coded sudoku puzzle into the memory addresses 0-81, as well as 
a lookup table around the address 100 which would translate the sudoku keys into prime numbers which could be 
multiplied together to verify their correctness. You can think of it as a kind of check-product for each constraint 
on the board.</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// function: init puzzle</span>
<span class="kt">int</span> <span class="n">initPuzzleIndex</span> <span class="o">=</span> <span class="n">getProgramCount</span><span class="o">(</span><span class="n">buffer</span><span class="o">);</span>
<span class="nc">String</span> <span class="n">puzzle</span> <span class="o">=</span> <span class="s">".......1.4.........2...........5.4.7..8...3....1.9....3..4..2...5.1........8.6..."</span><span class="o">;</span>
<span class="c1">// for faster solve, use "....84512487512936125963874932651487568247391741398625319475268856129743274836159";</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">puzzle</span><span class="o">.</span><span class="na">length</span><span class="o">();</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
    <span class="kt">char</span> <span class="n">c</span> <span class="o">=</span> <span class="n">puzzle</span><span class="o">.</span><span class="na">charAt</span><span class="o">(</span><span class="n">i</span><span class="o">);</span>
    <span class="k">if</span> <span class="o">(</span><span class="n">c</span> <span class="o">==</span> <span class="sc">'.'</span><span class="o">)</span> <span class="o">{</span>
        <span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(-</span><span class="mf">1.0</span><span class="o">);</span> <span class="c1">// push -1 for empty cell</span>
    <span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
        <span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">((</span><span class="kt">double</span><span class="o">)</span> <span class="o">(</span><span class="n">c</span> <span class="o">-</span> <span class="sc">'0'</span><span class="o">));</span> <span class="c1">// push digit</span>
    <span class="o">}</span>
<span class="o">}</span> <span class="c1">// load entire puzzle into stack</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">puzzle</span><span class="o">.</span><span class="na">length</span><span class="o">());</span> <span class="c1">// push puzzle length</span>

<span class="c1">// loop start: check if TOS is 0; if so, break the loop</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// n, 1, n</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CLEAR_EXCEPT</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// clear fpu exceptions</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// calculate 1 / n, see if it gives div by 0 error</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// n</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_DIVBYZERO</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">6</span><span class="o">);</span> <span class="c1">// skip to end of loop</span>

<span class="c1">// loop body</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(-</span><span class="mi">1</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">ADD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// decrement index</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP_X1</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, val, index</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">STORE</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// store the val at index</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_ALWAYS</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(-</span><span class="mi">11</span><span class="o">);</span> <span class="c1">// jump to top of loop</span>

<span class="c1">// loop end</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span> <span class="c1">// pop the index</span>

<span class="c1">// set up lookup table</span>
<span class="kt">int</span><span class="o">[]</span> <span class="n">primeNumbers</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">int</span><span class="o">[]</span> <span class="o">{</span> <span class="mi">2</span><span class="o">,</span> <span class="mi">3</span><span class="o">,</span> <span class="mi">5</span><span class="o">,</span> <span class="mi">7</span><span class="o">,</span> <span class="mi">11</span><span class="o">,</span> <span class="mi">13</span><span class="o">,</span> <span class="mi">17</span><span class="o">,</span> <span class="mi">19</span><span class="o">,</span> <span class="mi">23</span> <span class="o">};</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">primeNumbers</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
    <span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">((</span><span class="kt">double</span><span class="o">)</span> <span class="n">primeNumbers</span><span class="o">[</span><span class="n">i</span><span class="o">])</span>
        <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">100</span> <span class="o">+</span> <span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="o">)</span> <span class="c1">// push prime number and its index</span>
        <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">STORE</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span> <span class="c1">// store it in the lookup table</span>
<span class="o">}</span>
<span class="c1">// lookup for -1 cell: garbage value</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(-</span><span class="mf">0.0000000000042069</span><span class="o">)</span>
        <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">99</span><span class="o">)</span> <span class="c1">// push prime number and its index</span>
        <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">STORE</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span> <span class="c1">// store it in the lookup table</span>

<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span> <span class="c1">// return from initPuzzle function</span>
</code></pre></div></div>

<p>Then, I made the functions to check whether the board had been solved for each required row, column, and 3x3 square. 
For brevity, I’ll only show the final, overall function, which combines them together:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// function: check solution</span>
<span class="c1">// for each set of 9 cells, look up into primes and compute product</span>
<span class="c1">// then divide that product by 223092870, the intended product</span>
<span class="c1">// then, we get a ratio that represents whether it solved correctly</span>
<span class="c1">// multiply all those ratios for each set and see if it &gt;= 1 using that function.</span>
<span class="kt">int</span> <span class="n">checkSolutionIndex</span> <span class="o">=</span> <span class="n">getProgramCount</span><span class="o">(</span><span class="n">buffer</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"linking checkSolutionIndex at pc "</span> <span class="o">+</span> <span class="n">checkSolutionIndex</span><span class="o">);</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">9</span><span class="o">);</span> <span class="c1">// loop from range (0,9)</span>

<span class="c1">// loop start: check if TOS is less than 1; if so, break the loop</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">greaterThanOrEquals1Index</span><span class="o">)</span> <span class="c1">// check if i &gt;= 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// i, bool, 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, 1, bool</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CLEAR_EXCEPT</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// clear fpu exceptions</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// calculate 1 / bool, see if it gives div by 0 exception</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_DIVBYZERO</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">13</span><span class="o">);</span> <span class="c1">// skip to end of loop if i &lt; 1</span>

<span class="c1">// loop body: decrement i and compute check-products</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SUB</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i--</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">getRowProductIndex</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">getColumnProductIndex</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">getSquareProductIndex</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_ALWAYS</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(-</span><span class="mi">19</span><span class="o">);</span> <span class="c1">// jump to top of loop</span>

<span class="c1">// loop end</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>

<span class="c1">// multiply all the check-products !!</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mf">1.0</span><span class="o">);</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="o">;</span> <span class="n">i</span><span class="o">&lt;</span><span class="mi">27</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
    <span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">MUL</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>
<span class="o">}</span>

<span class="c1">// we need to normalize our value to check if *exactly* 1</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">equals1Index</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>
</code></pre></div></div>

<p>Finally, I had to make the algorithm to solve the sudoku. On the VM, I implemented a simple recursive 
backtracking algorithm, which recursively attempts guesses for each unfilled square in the puzzle until the problem 
is solved. The base case for when index == 81 simply checks whether the board has been successfully solved. 
Note the use of the <code class="language-plaintext highlighter-rouge">DIVBYZERO</code> flag in order to break the loop.</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// function: attempt_solve_recursive(index)</span>
<span class="c1">// recursively brute forces the solver with index++ until index == 81.</span>
<span class="c1">// where it does a final check and returns boolean</span>
<span class="kt">int</span> <span class="n">attemptSolveRecursiveIndex</span> <span class="o">=</span> <span class="n">getProgramCount</span><span class="o">(</span><span class="n">buffer</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"linking attemptSolveRecursiveIndex at pc "</span> <span class="o">+</span> <span class="n">attemptSolveRecursiveIndex</span><span class="o">);</span>
<span class="c1">// if index == 81, simply do a check and return</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, index</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">81</span><span class="o">)</span> <span class="c1">// index, index, 81</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, index/81</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">equals1Index</span><span class="o">)</span> <span class="c1">// check if index == 81</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, 1, bool</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CLEAR_EXCEPT</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// we dont need result, just the exception flag</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_DIVBYZERO</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">4</span><span class="o">);</span> <span class="c1">// skip branch if not index == 81</span>

<span class="c1">// base case: just check if solved and return result (also pop the index)</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">checkSolutionIndex</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>

<span class="c1">// otherwise, do recursive guessing</span>
<span class="c1">// first, check if the cell is empty (&lt; 1)</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, index</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">LOAD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, curr_val</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">greaterThanOrEquals1Index</span><span class="o">)</span> <span class="c1">// check if i &gt;= 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// index, bool, 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, 1, bool</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CLEAR_EXCEPT</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// we dont need result, just the exception flag</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_DIVBYZERO</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">5</span><span class="o">);</span> <span class="c1">// skip branch if i still needs guessing; // index</span>

<span class="c1">// case: there is already a hint at this cell</span>
<span class="c1">// just recurse next without guesses and return that result</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">ADD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">attemptSolveRecursiveIndex</span><span class="o">)</span> <span class="c1">// recurse (index + 1)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>

<span class="c1">// regular case: make guesses [1, 9], break loop if returned true</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">9</span><span class="o">);</span> <span class="c1">// index, guess</span>

<span class="c1">// loop start: check if guess is still &gt;= 1</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, guess, guess</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">greaterThanOrEquals1Index</span><span class="o">)</span> <span class="c1">// check if guess &gt;= 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// index, guess, bool, 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, guess, 1, bool</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CLEAR_EXCEPT</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// we dont need result, just the exception flag</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_DIVBYZERO</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">22</span><span class="o">);</span> <span class="c1">// break loop if guess is zero now; // index, guess</span>

<span class="c1">// loop body: attempt guess and then decrement index</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP2</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, guess, index, guess</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, guess, guess, index                        </span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">STORE</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, guess</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// guess, index</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP_X1</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, guess, index</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">ADD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, guess, index + 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">attemptSolveRecursiveIndex</span><span class="o">)</span> <span class="c1">// recurse (index + 1); puts a bool on tos</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// index, guess, bool, 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index, guess, 1, bool</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CLEAR_EXCEPT</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// we dont need result, just the exception flag</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_DIVBYZERO</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">5</span><span class="o">);</span> <span class="c1">// skip this if guess failed; // index, guess</span>

<span class="c1">// success! we're done now</span>
<span class="c1">// pop index, guess; return 1</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// true</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>

<span class="c1">// otherwise, the guess didn't work. we need to decrement guess and loop again</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(-</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// index, guess, -1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">ADD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// guess--</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_ALWAYS</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(-</span><span class="mi">28</span><span class="o">);</span>

<span class="c1">// loop end</span>
<span class="c1">// all guesses failed; return false</span>
<span class="c1">// restore the value as -1 at index</span>
<span class="c1">// pop index, guess; return 0</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// index</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(-</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// index, -1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// -1, index</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">STORE</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// memory[index] = -1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">0</span><span class="o">)</span> <span class="c1">// false</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>
</code></pre></div></div>

<p>Finally, we make an entry function which starts the recursive chain.</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// function: attempt_solve() returns whether it worked</span>
<span class="kt">int</span> <span class="n">attemptSolveIndex</span> <span class="o">=</span> <span class="n">getProgramCount</span><span class="o">(</span><span class="n">buffer</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"linking attemptSolveIndex at pc "</span> <span class="o">+</span> <span class="n">attemptSolveIndex</span><span class="o">);</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">0</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">attemptSolveRecursiveIndex</span><span class="o">)</span> <span class="c1">// call algorithm starting with 0</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>
</code></pre></div></div>

<p><em>If you think that I must be insane for implementing my own recursive sudoku solver in my own made-up floating-point assembly language, you’re probably right.</em></p>

<p>After solving the sudoku, we hash the board in order to generate the flag using a simple multiply-and-add algorithm.</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// function: hash_board() loops through the board and returns a hash</span>
<span class="c1">// loops through from index 0 to 81, multiplying and adding</span>
<span class="kt">int</span> <span class="n">hashBoardIndex</span> <span class="o">=</span> <span class="n">getProgramCount</span><span class="o">(</span><span class="n">buffer</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"linking hashBoardIndex at pc "</span> <span class="o">+</span> <span class="n">hashBoardIndex</span><span class="o">);</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mf">0.00000000069</span><span class="o">)</span> <span class="c1">// seed value</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">200</span><span class="o">)</span> <span class="c1">// memory address</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">STORE</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// memory[200] = 0.00000000069, used for hash</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">0</span><span class="o">);</span> <span class="c1">// loop from 0 to 81</span>

<span class="c1">// loop start: check if TOS is greater than or equals 81; if so, break the loop</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">81</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">greaterThanOrEquals1Index</span><span class="o">)</span> <span class="c1">// check if i/81 &gt;= 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// i, bool, 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, 1, bool</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SUB</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, !bool</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// i, !bool, 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, 1, !bool</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CLEAR_EXCEPT</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DIV</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">POP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// we dont need result, just the exception flag</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_DIVBYZERO</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">17</span><span class="o">);</span> <span class="c1">// break loop if i/81 &gt;= 1 is true</span>

<span class="c1">// loop body: hash the current board state</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">LOAD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, memory[i]</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">200</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">DUP_X1</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">LOAD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, 200, memory[i], memory[200]</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="nc">Math</span><span class="o">.</span><span class="na">PI</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">MUL</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, 200, memory[i], memory[200] * Math.PI</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, 200, memory[200] * Math.PI, memory[i]</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">MUL</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, 200, memory[200] * Math.PI * memory[i]</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="nc">Math</span><span class="o">.</span><span class="na">E</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">ADD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, 200, memory[200] * Math.PI * memory[i] + e</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">SWAP</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i, new_hash, 200</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">STORE</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// store new_hash in memory[200]</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="c1">// i, 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">ADD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span> <span class="c1">// i + 1</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">B_ALWAYS</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(-</span><span class="mi">28</span><span class="o">);</span> <span class="c1">// jump back to loop start</span>

<span class="c1">// loop end</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PUSH_CONST</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="mi">200</span><span class="o">)</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">LOAD</span><span class="o">.</span><span class="na">encode</span><span class="o">())</span>
    <span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">RET</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span>
</code></pre></div></div>

<p>Finally, the program prints the flag. Many teams analyzed the hardcoded 
printed characters in the program, obtaining the incorrect flag <code class="language-plaintext highlighter-rouge">corctf{g3ntly_d0wn_th3_StR3AM_FPU_h4cks}</code> 
without noticing the crucial <code class="language-plaintext highlighter-rouge">PRINT_FLOAT</code> instruction in the middle, 
which prints the hash of the board. This is what the program actually does:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">CALL</span><span class="o">.</span><span class="na">encode</span><span class="o">()).</span><span class="na">putDouble</span><span class="o">(</span><span class="n">hashBoardIndex</span><span class="o">);</span> <span class="c1">// call hashBoard function</span>
<span class="n">printString</span><span class="o">(</span><span class="n">buffer</span><span class="o">,</span> <span class="s">"\nFlag: \n"</span><span class="o">);</span>
<span class="n">printString</span><span class="o">(</span><span class="n">buffer</span><span class="o">,</span> <span class="s">"corctf{g3ntly_d0wn_th3_StR3AM_"</span><span class="o">);</span>
<span class="n">buffer</span><span class="o">.</span><span class="na">putDouble</span><span class="o">(</span><span class="no">PRINT_FLOAT</span><span class="o">.</span><span class="na">encode</span><span class="o">());</span> <span class="c1">// prints the board hash</span>
<span class="n">printString</span><span class="o">(</span><span class="n">buffer</span><span class="o">,</span> <span class="s">"FPU_h4cks}\n"</span><span class="o">);</span>
<span class="n">printString</span><span class="o">(</span><span class="n">buffer</span><span class="o">,</span> <span class="s">"\nThank you for your patience!\n"</span><span class="o">);</span>
</code></pre></div></div>

<p>One way to obtain the flag is to solve the sudoku and then reïmplement the hash function. This is what 
my python solver looked like:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">BOARD_PROBLEM</span> <span class="o">=</span> <span class="sh">"</span><span class="s">.......1.4.........2...........5.4.7..8...3....1.9....3..4..2...5.1........8.6...</span><span class="sh">"</span>

<span class="k">def</span> <span class="nf">board_hash</span><span class="p">(</span><span class="n">board</span><span class="p">):</span>
    <span class="sh">"""</span><span class="s">Compute a hash of the board state.</span><span class="sh">"""</span>
    <span class="nb">hash</span> <span class="o">=</span> <span class="mf">0.00000000069</span>  <span class="c1"># seed
</span>    <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">board</span><span class="p">:</span>
        <span class="k">for</span> <span class="n">val</span> <span class="ow">in</span> <span class="n">row</span><span class="p">:</span>
            <span class="nb">hash</span> <span class="o">=</span> <span class="nb">hash</span> <span class="o">*</span> <span class="n">math</span><span class="p">.</span><span class="n">pi</span> <span class="o">*</span> <span class="nf">float</span><span class="p">(</span><span class="n">val</span><span class="p">)</span> <span class="o">+</span> <span class="n">math</span><span class="p">.</span><span class="n">e</span>
    <span class="k">return</span> <span class="nb">hash</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="sh">'</span><span class="s">__main__</span><span class="sh">'</span><span class="p">:</span>
    <span class="nf">test</span><span class="p">()</span>
    <span class="nf">solve_all</span><span class="p">([</span><span class="n">BOARD_PROBLEM</span><span class="p">],</span> <span class="sh">"</span><span class="s">custom</span><span class="sh">"</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="c1"># just for the display lol
</span>
    <span class="n">values</span> <span class="o">=</span> <span class="nf">to_array</span><span class="p">(</span><span class="nf">solve</span><span class="p">(</span><span class="n">BOARD_PROBLEM</span><span class="p">))</span>
    <span class="n">solution_string</span> <span class="o">=</span> <span class="sh">""</span><span class="p">.</span><span class="nf">join</span><span class="p">(</span><span class="sh">""</span><span class="p">.</span><span class="nf">join</span><span class="p">(</span><span class="nf">str</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="n">row</span><span class="p">)</span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">values</span><span class="p">)</span>
    <span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">Original: </span><span class="si">{</span><span class="n">BOARD_PROBLEM</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
    <span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">Solution: </span><span class="si">{</span><span class="n">solution_string</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
    <span class="nf">print</span><span class="p">()</span>

    <span class="nb">hash</span> <span class="o">=</span> <span class="nf">board_hash</span><span class="p">(</span><span class="n">values</span><span class="p">)</span>
    <span class="c1"># flag format: corctf{g3ntly_d0wn_th3_StR3AM_&lt;hash&gt;FPU_h4cks}
</span>    <span class="n">flag</span> <span class="o">=</span> <span class="sa">f</span><span class="sh">"</span><span class="s">corctf{{g3ntly_d0wn_th3_StR3AM_</span><span class="si">{</span><span class="nb">hash</span><span class="si">}</span><span class="s">FPU_h4cks}}</span><span class="sh">"</span>
    <span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">Hash of the solution: </span><span class="si">{</span><span class="n">flag</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
    <span class="nf">print</span><span class="p">()</span>

    <span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">flag: </span><span class="sh">"</span><span class="p">)</span>
</code></pre></div></div>

<p>Another solution was to patch the bytecodes hard-coding the sudoku, replacing it with the full solution 
and running the program again to immediately print the flag. And this time, it won’t take 
2.2185312001337001e+57 seconds to get the flag 
<code class="language-plaintext highlighter-rouge">corctf{g3ntly_d0wn_th3_StR3AM_3.0390693652230334e+89FPU_h4cks}</code>.</p>

<h2 id="the-ctf">The CTF</h2>

<p>From what I can understand, the patching approach was the most viable approach to solving the challenge. 
Many teams tried to emulate the VM’s behavior in python, but could only crudely approximate the 
<code class="language-plaintext highlighter-rouge">INEXACT</code> logic by hand. In any case, players had to work out what algorithm was running and solve the 
puzzle externally in order to speed up the program.</p>

<p>We received an insane amount of questions about this challenge because many teams found the plaintext of the 
flag template <code class="language-plaintext highlighter-rouge">corctf{g3ntly_d0wn_th3_StR3AM_FPU_h4cks}</code> without solving for the middle part, 
which would have produced the correct <code class="language-plaintext highlighter-rouge">corctf{g3ntly_d0wn_th3_StR3AM_3.0390693652230334e+89FPU_h4cks}</code> if 
the given program were theoretically run to completion. I’m not entirely sure how I can design the flag 
or program to not look like a confusing decoy, but next time I’ll try to make it more obvious, maybe by 
splitting the text into even more parts.</p>

<p>During the full 48-hour CTF competition, 13 teams were able to solve this challenge, 
making <code class="language-plaintext highlighter-rouge">whatever-floats-your-boat</code> one of the harder rev challenges for corCTF 2025. Despite using such an obscure 
concept for the VM, the actual operations were fairly simple to analyze as the control flow jump offsets 
were clearly defined, and the VM contained a clear data and call stack. Solvers could often infer what the 
program was doing via some basic static analysis and intuition. For future challenges, I could probably 
obfuscate the raw data of the puzzle a little bit more, so that players don’t just see things like 
“this program loads 81 numbers 1-9” or use a more niche algorithm which had to be fully understood 
in order to get the correct flag.</p>

<h2 id="the-conclusion">The Conclusion</h2>

<p>Although <code class="language-plaintext highlighter-rouge">boat-vm</code> doesn’t have clear instructions for boolean logic and value comparison, with some 
clever tricks, we can create efficient floating-point algorithms to control our code. 
In the end, the explicit, contained control flow of the VM made this challenge 
manageable for many participants.</p>

<p>I absolutely loved making this challenge and learning about IEEE 754 floating-point arithmetic. 
Although I didn’t realize what it had meant when I got assigned for corCTF a few months ago, 
reverse engineering turned out to be a great way to explore computing as a whole.
I hope to continue developing projects around niche and quirky concepts as a way to both
challenge others and continue to learn myself.</p>]]></content><author><name></name></author><summary type="html"><![CDATA[corCTF 2025 - whatever-floats-your-boat]]></summary></entry><entry><title type="html">corCTF 2025 bubble-vm: Obfuscation behind a two-pointer RISC VM</title><link href="http://localhost:4000/blog/bubble-vm/" rel="alternate" type="text/html" title="corCTF 2025 bubble-vm: Obfuscation behind a two-pointer RISC VM" /><published>2025-08-01T00:00:00-07:00</published><updated>2025-08-01T00:00:00-07:00</updated><id>http://localhost:4000/blog/corCTF-2025-bubble-vm</id><content type="html" xml:base="http://localhost:4000/blog/bubble-vm/"><![CDATA[<h1 id="corctf-2025---bubble-vm">corCTF 2025 - bubble-vm</h1>

<p><em>This blog was also posted to the <a href="https://cor.team/posts/corctf-2025-bubble-vm/">Crusaders of Rust website</a>.</em></p>

<p>This was my first year writing CTF challenges, and I mainly focused on software reverse engineering. 
I absolutely enjoyed playing with various models of computation and seeing other people try to solve my problems.</p>

<p>In this blog, I will talk about the design choices and decisions behind this VM architecture and 
how I created this challenge.</p>

<h2 id="the-virtual-machine">The Virtual Machine</h2>

<p><img src="/blog/assets/bubble-vm/chall.png" alt="the ctf challenge" /></p>

<p>I love virtual machines. 
According to my tallying, I invented four turing-complete systems for corCTF rev, and three of them were 
VMs. Although each challenge had its own quirks, <code class="language-plaintext highlighter-rouge">bubble-vm</code> ended up being the hardest VM with only 2 solves 
due to its obscure data manipulation and control flow tactics.</p>

<p>Having little prior experience with CTFs, I had no clue what types of challenges to write for corCTF 2025. 
I wanted to push myself by making an advanced challenge, and I found out that writing custom 
architectures was a potential way to isolate a challenge from existing analysis tools. 
I ended up stretching this idea in several different ways for this CTF, dabbling with 
all sorts of models of computation across three different challenge categories.</p>

<p><img src="/blog/assets/bubble-vm/scheming.png" alt="advice from a friend" /></p>

<p>This challenge is a testament to how complex program logic can emerge 
from a very simple and limited set of instructions. Borrowing from the
BF programming language, the machine had only two pointers operating on two tapes: 
a program counter, which dictates interpretation over an immutable instruction buffer, 
and a data pointer, which allows operations on a large tape of 64-bit integers.
Additionally, each instruction was encoded with a single character which couldn’t contain any metadata.</p>

<p>In order to facilitate more advanced computations, the instruction set also contained several binary operations
that operated with the data in the next cell — for example, the <code class="language-plaintext highlighter-rouge">ADD</code> instruction writes the sum of 
<code class="language-plaintext highlighter-rouge">data[A]</code> and <code class="language-plaintext highlighter-rouge">data[A+1]</code> into <code class="language-plaintext highlighter-rouge">data[A]</code>. The <code class="language-plaintext highlighter-rouge">BUBBLE</code> instruction, from which the VM derives its name, 
swaps the data in the current and next data cell, similar to a bubble sort. 
As you can probably imagine, most bytecodes in this system are very standard and
are straightforward to analyze.</p>

<p><img src="/blog/assets/bubble-vm/tapes.png" alt="the bubble vm contains an instruction tape and a data tape." /></p>

<p>What made this challenge hard was the way the VM enabled random access along its instruction and memory tape. 
The VM contained two perculiar instructions which manipulated the program state in oddly specific ways: 
the <code class="language-plaintext highlighter-rouge">SHIFT</code> instruction would move the data pointer to the value stored in <code class="language-plaintext highlighter-rouge">data[A]</code> and copy 
the value stored in the previous neighbor <code class="language-plaintext highlighter-rouge">data[A+1]</code> into the new location,
and the <code class="language-plaintext highlighter-rouge">JUMP</code> instruction would set the program count to the value stored in <code class="language-plaintext highlighter-rouge">data[A]</code> and write back 
into the same cell the successor of the original program count. If that sounds confusing, just
remember that I had to write an entire 10,000-bytecode program using this system using my own assembler.</p>

<p>Here is the (sloppy) internal documentation of the bytecodes for <code class="language-plaintext highlighter-rouge">bubble-vm</code>:</p>
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cm">/*
 * The VM is made of a linear memory space of cells which are addressable via indexing.
 * The VM has one register: a cell pointer A, which is used to calculate the A+1 pointer.
 * 
 * The program starts with A pointing to the cell at index 0.
 * Cell 0 is initially set to the length of the cell buffer, and all other cells are cleared.
 * 
 * Instruction set:
 * BUBBLE - swap values at A and A+1
 * TAKE - set A to A+1 value
 * LEFT, RIGHT - decrement/increment A pointer
 * BZ, BNZ - relative branch by numerical value in A if A+1 is zero/nonzero
 * ADD, SUB, MUL, DIV, MOD   - do integer operation on A and A+1 and store result in A
 * SLL, SRL, SRA, XOR, AND, OR - do integer operation on A and A+1 and store result in A
 * NONZERO - set cell A to 1 if A is nonzero, 0 otherwise (convert int to boolean 1/0)
 * NOT - flip bits of A
 * INC, DEC - increment/decrement the numerical value of A
 * CLEAR - set cell A to zero
 * INPUT - reads a char to A
 * PRINT - outputs A as char
 * EXIT - halt program and exit
 * IDENTITY - store cell address of A in A
 * SHIFT   - shift to A and write prev A+1 value (copies A+1 to target address)
 * JUMP - jump to A and write prev next instruction address (return address)
 */</span>
</code></pre></div></div>

<h2 id="the-control-primitives">The Control Primitives</h2>

<p>Remember those obscure <code class="language-plaintext highlighter-rouge">SHIFT</code> and <code class="language-plaintext highlighter-rouge">JUMP</code> instructions? As it turns out, 
these instructions serve critical roles in managing the logic of the VM.</p>

<p>The <code class="language-plaintext highlighter-rouge">JUMP</code> opcode always writes back a return address, and is therefore ideal for emulating function calls.
Combining this with the fact that most instructions operate on data to the right of the data pointer, 
it naturally makes sense for programs to use a downwards-growing stack, 
starting from the highest memory address and sliding left to obtain more space. When a function needs to return,
it will simply slide the data pointer back to where it started, and call the <code class="language-plaintext highlighter-rouge">JUMP</code> instruction on the return address, 
returning control to the callee.</p>

<p>The <code class="language-plaintext highlighter-rouge">SHIFT</code> instruction, however, is trickier. It may seem quite bizzare and useless, since it can 
only transport a single data value to the target location without an obvious way to return back to the
original position, but through a careful construction, we can enable arbitrary reads and writes to global
memory addresses from anywhere on the callstack. The key is to use a sparse, two-wide memory layout, 
where load/store cells contain a temporary slot which can get overwritten, while the important data is stored in the
cell’s neighbor.</p>

<p>I won’t bore you with all the details. Here’s how I implemented the load and store primitives in my assembler:
<img src="/blog/assets/bubble-vm/load_store.png" alt="load and store primtives can be implemented using a careful sequence of bytecodes." /></p>

<p>Using these two instructions, we can create a call stack and access global variables at any point in the program.</p>

<h2 id="the-data-primitives">The Data Primitives</h2>

<p><code class="language-plaintext highlighter-rouge">bubble-vm</code> doesn’t have instructions to load immediate data into the program, so I wrote a macro in my 
python assembler to create numbers using a bitmasking algorithm. The code first loads in the absolute value 
because it tends to be more efficient for negative numbers. This function probably isn’t the most optimal way 
to load in a number into the program, but it did the job.</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">u64_to_bitstring</span><span class="p">(</span><span class="n">num</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">num</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
        <span class="k">raise</span> <span class="nc">ValueError</span><span class="p">(</span><span class="sh">"</span><span class="s">Cannot convert negative number to bits</span><span class="sh">"</span><span class="p">)</span>
    <span class="n">binary_string</span> <span class="o">=</span> <span class="nf">bin</span><span class="p">(</span><span class="n">num</span><span class="p">)</span> <span class="c1"># format 0b1001
</span>    <span class="k">return</span> <span class="n">binary_string</span><span class="p">[</span><span class="mi">2</span><span class="p">:]</span>    

<span class="c1"># loads a number into a cell. 
# Use this when exact sizing is not critical, and there is space to the left.
</span><span class="k">def</span> <span class="nf">load_number</span><span class="p">(</span><span class="n">num</span><span class="p">):</span>
    <span class="n">needs_negate</span> <span class="o">=</span> <span class="n">num</span> <span class="o">&lt;</span> <span class="mi">0</span>
    <span class="n">unsigned_num</span> <span class="o">=</span> <span class="nf">abs</span><span class="p">(</span><span class="n">num</span><span class="p">)</span>

    <span class="c1"># algorithm: bitmask the absval, and then subtract from 0 if negative
</span>    <span class="n">prologue</span> <span class="o">=</span> <span class="p">[</span><span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">]</span>
    <span class="c1"># sets up format [result, mask, 1], initially [0, 1, 1]
</span>    <span class="n">bitmask</span> <span class="o">=</span> <span class="p">[]</span>
    <span class="k">for</span> <span class="n">digit</span> <span class="ow">in</span> <span class="nf">u64_to_bitstring</span><span class="p">(</span><span class="n">unsigned_num</span><span class="p">)[::</span><span class="o">-</span><span class="mi">1</span><span class="p">]:</span>
        <span class="k">if</span> <span class="n">digit</span> <span class="o">==</span> <span class="sh">'</span><span class="s">1</span><span class="sh">'</span><span class="p">:</span>
            <span class="n">bitmask</span> <span class="o">+=</span> <span class="p">[</span><span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">OR</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">]</span>
        <span class="n">bitmask</span><span class="p">.</span><span class="nf">append</span><span class="p">(</span><span class="sh">"</span><span class="s">SLL</span><span class="sh">"</span><span class="p">)</span> <span class="c1"># shift the mask bit to the left
</span>    <span class="n">pos_epilogue</span> <span class="o">=</span> <span class="p">[</span><span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">]</span>
    <span class="n">neg_epilogue</span> <span class="o">=</span> <span class="p">[</span><span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">SUB</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">]</span>
    <span class="n">epilogue</span> <span class="o">=</span> <span class="n">neg_epilogue</span> <span class="k">if</span> <span class="n">needs_negate</span> <span class="k">else</span> <span class="n">pos_epilogue</span>

    <span class="k">return</span> <span class="n">prologue</span> <span class="o">+</span> <span class="n">bitmask</span> <span class="o">+</span> <span class="n">epilogue</span>
</code></pre></div></div>

<h2 id="the-control-flow-part-two">The Control Flow, Part Two</h2>

<p>The way the code loads numbers poses a problem to our control flow management. Functions must be called 
using a precise target address, but our VM doesn’t guarantee a fixed-length solution for loading numbers. 
This creates a nightmare for linking functions in our program — we would have to resolve a circular loop 
of dependencies between functions in order for the code to behave. This problem would be made even more 
annoying when a function call was made on a conditional branch, where the branch offset also required a 
precise offset calculation.</p>

<p>Rather than creating an overcomplicated symbol linker which solved the complex network of dependencies 
between objects in my code, I decided to make a jump table that would handle all the function offsets 
in a single location at the beginning of the program. This way, function callers would only need to 
load the index of the function they want to call, and jump to a fixed location for the dynamic dispatch.</p>

<p><img src="/blog/assets/bubble-vm/jump_table.png" alt="dynamic dispatch using a jump table." /></p>

<p>This ended up being my code for linking programs together. Although it is fairly cumbersome, it was 
much easier having this logic all in one place, rather than across the entire program.</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1"># Jump table: does a bunch of BZ and DEC insns
</span><span class="k">def</span> <span class="nf">link_program</span><span class="p">():</span>
    <span class="n">prologue</span> <span class="o">=</span> <span class="p">[</span><span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">]</span> <span class="c1"># the name of the VM!
</span>
    <span class="c1"># convention: [extra_space, ret_addr, idx, args] (idx missing on _start)
</span>    <span class="n">_start_impl</span> <span class="o">=</span> <span class="p">[</span><span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">DEC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">SHIFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">main</span><span class="sh">"</span><span class="p">),</span> <span class="sh">"</span><span class="s">EXIT</span><span class="sh">"</span><span class="p">]</span>
    <span class="n">jump_table_handler</span> <span class="o">=</span> <span class="p">[</span>
        <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="nf">len</span><span class="p">(</span><span class="n">_start_impl</span><span class="p">),</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BNZ</span><span class="sh">"</span><span class="p">,</span>
            <span class="o">*</span><span class="n">_start_impl</span><span class="p">,</span> <span class="c1"># skip _start if ret addr exists
</span>    <span class="p">]</span>

    <span class="n">relevant_functions</span> <span class="o">=</span> <span class="n">FUNCTIONS</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
    
    <span class="k">for</span> <span class="n">funct_name</span> <span class="ow">in</span> <span class="n">relevant_functions</span><span class="p">:</span>
        <span class="k">if</span> <span class="n">funct_name</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">CALLED_FUNCTIONS</span><span class="p">:</span>
            <span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">Warning: function </span><span class="si">{</span><span class="n">funct_name</span><span class="si">}</span><span class="s"> is linked in program but not called anywhere</span><span class="sh">"</span><span class="p">)</span>

    <span class="n">function_impls</span> <span class="o">=</span> <span class="p">[</span><span class="n">FUNCTION_IMPLEMENTATIONS</span><span class="p">[</span><span class="n">funct_name</span><span class="p">]</span> <span class="k">for</span> <span class="n">funct_name</span> <span class="ow">in</span> <span class="n">relevant_functions</span><span class="p">]</span>
    <span class="n">function_lengths</span> <span class="o">=</span> <span class="p">[</span><span class="nf">len</span><span class="p">(</span><span class="n">function_impl</span><span class="p">)</span> <span class="k">for</span> <span class="n">function_impl</span> <span class="ow">in</span> <span class="n">function_impls</span><span class="p">]</span>
    <span class="n">function_offsets</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span>
    <span class="k">for</span> <span class="n">function_length</span> <span class="ow">in</span> <span class="n">function_lengths</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">]:</span>
        <span class="n">function_offsets</span><span class="p">.</span><span class="nf">append</span><span class="p">(</span><span class="n">function_offsets</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="n">function_length</span><span class="p">)</span>
    <span class="n">function_data_segment</span> <span class="o">=</span> <span class="p">[</span><span class="n">insn</span> <span class="k">for</span> <span class="n">funct_impl</span> <span class="ow">in</span> <span class="n">function_impls</span> <span class="k">for</span> <span class="n">insn</span> <span class="ow">in</span> <span class="n">funct_impl</span><span class="p">]</span>
    
    <span class="n">jump_table_calculation_estimate</span> <span class="o">=</span> <span class="nf">sum</span><span class="p">(</span>
        <span class="nf">load_number_estimate</span><span class="p">(</span><span class="n">offset</span><span class="p">)</span> <span class="o">+</span> <span class="nf">load_number_estimate</span><span class="p">(</span><span class="nf">load_number_estimate</span><span class="p">(</span><span class="n">offset</span><span class="p">))</span> <span class="o">+</span> <span class="mi">15</span>
        <span class="k">for</span> <span class="n">offset</span> <span class="ow">in</span> <span class="n">function_offsets</span>
    <span class="p">)</span>
    <span class="n">function_data_start</span> <span class="o">=</span> <span class="mi">50</span> <span class="o">+</span> <span class="n">jump_table_calculation_estimate</span>  <span class="c1"># assume this starts in a good location
</span>
    <span class="c1"># handle function jump table [extra_space, ret_addr, idx, args]
</span>    <span class="n">jump_table_handler</span> <span class="o">+=</span> <span class="nf">load_number</span><span class="p">(</span><span class="n">function_data_start</span><span class="p">)</span> <span class="c1"># [data_start, ret_addr, idx, args] at data_start
</span>    <span class="n">jump_table_handler</span> <span class="o">+=</span> <span class="p">[</span>
        <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span> <span class="c1"># bubble sort! drag idx back 2 spaces
</span>    <span class="p">]</span> <span class="c1"># [extra_space, idx, data_start, ret_addr, args] at idx
</span>
    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span class="nf">len</span><span class="p">(</span><span class="n">relevant_functions</span><span class="p">)):</span>
        <span class="n">funct_name</span> <span class="o">=</span> <span class="n">relevant_functions</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
        <span class="n">funct_offset</span> <span class="o">=</span> <span class="n">function_offsets</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
        <span class="c1"># Original layout: [extra_space, idx, data_start, ret_addr, args] at idx
</span>        <span class="c1"># Becomes at invocation: [offset, temp, idx, data_start, ret_addr, args] at temp
</span>        <span class="n">table_invoke</span> <span class="o">=</span> <span class="p">[</span><span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">ADD</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span><span class="p">]</span>
        <span class="n">funct_handler</span> <span class="o">=</span> <span class="p">[</span>
            <span class="sh">"</span><span class="s">DEC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># decrease index, go to extra space
</span>            <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="n">funct_offset</span><span class="p">),</span> <span class="c1"># [offset, idx, data_start, ret_addr, args] at offset
</span>            <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">TAKE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [offset, temp, idx, data_start, ret_addr, args] at temp
</span>            <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="nf">len</span><span class="p">(</span><span class="n">table_invoke</span><span class="p">),</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BNZ</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [offset, skip_amount, idx, data_start, ret_addr, args]
</span>                <span class="o">*</span><span class="n">table_invoke</span><span class="p">,</span> <span class="c1"># add offset to data_start and invoke. skip this if not zero (not matched)
</span>            <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span> <span class="c1"># otherwise, go back and try next iteration
</span>        <span class="p">]</span>

        <span class="n">jump_table_handler</span> <span class="o">+=</span> <span class="n">funct_handler</span>
    
    <span class="c1"># if no function found, panic, print something, and exit
</span>    <span class="n">jump_table_handler</span> <span class="o">+=</span> <span class="p">[</span>
        <span class="sh">"</span><span class="s">NOP</span><span class="sh">"</span><span class="p">,</span>
        <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">SHIFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># go to somewhere safe
</span>        <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">101</span><span class="p">),</span> <span class="c1"># ASCII 'e'
</span>        <span class="sh">"</span><span class="s">PRINT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">PRINT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">PRINT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">EXIT</span><span class="sh">"</span>
    <span class="p">]</span>

    <span class="k">def</span> <span class="nf">get_padding_insn</span><span class="p">(</span><span class="n">i</span><span class="p">):</span>
        <span class="c1"># return "EXIT"
</span>        <span class="n">choice_list</span> <span class="o">=</span> <span class="nf">list</span><span class="p">(</span><span class="n">INSNS</span><span class="p">.</span><span class="nf">keys</span><span class="p">())</span>
        <span class="k">return</span> <span class="n">choice_list</span><span class="p">[(</span><span class="n">i</span> <span class="o">*</span> <span class="mi">5</span> <span class="o">+</span> <span class="mi">5</span> <span class="o">*</span> <span class="n">i</span> <span class="o">**</span> <span class="mi">3</span> <span class="o">+</span> <span class="mi">16</span> <span class="o">-</span> <span class="n">i</span> <span class="o">**</span> <span class="mi">2</span><span class="p">)</span> <span class="o">%</span> <span class="nf">len</span><span class="p">(</span><span class="n">choice_list</span><span class="p">)]</span>

    <span class="n">padding</span> <span class="o">=</span> <span class="p">[</span><span class="nf">get_padding_insn</span><span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span class="n">function_data_start</span> <span class="o">-</span> <span class="nf">len</span><span class="p">(</span><span class="n">jump_table_handler</span><span class="p">)</span> <span class="o">-</span> <span class="nf">len</span><span class="p">(</span><span class="n">prologue</span><span class="p">))]</span>

    <span class="n">beginning_length</span> <span class="o">=</span> <span class="nf">len</span><span class="p">(</span><span class="n">prologue</span><span class="p">)</span> <span class="o">+</span> <span class="nf">len</span><span class="p">(</span><span class="n">jump_table_handler</span><span class="p">)</span> <span class="o">+</span> <span class="nf">len</span><span class="p">(</span><span class="n">padding</span><span class="p">)</span>
    <span class="k">for</span> <span class="n">funct_name</span> <span class="ow">in</span> <span class="n">relevant_functions</span><span class="p">:</span>
        <span class="n">funct_impl</span> <span class="o">=</span> <span class="n">FUNCTION_IMPLEMENTATIONS</span><span class="p">[</span><span class="n">funct_name</span><span class="p">]</span>
        <span class="n">funct_len</span> <span class="o">=</span> <span class="nf">len</span><span class="p">(</span><span class="n">funct_impl</span><span class="p">)</span>
        <span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">linking </span><span class="si">{</span><span class="n">funct_name</span><span class="si">}</span><span class="s"> at program count </span><span class="si">{</span><span class="n">beginning_length</span><span class="si">}</span><span class="s"> - </span><span class="si">{</span><span class="n">beginning_length</span> <span class="o">+</span> <span class="n">funct_len</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
        <span class="n">beginning_length</span> <span class="o">+=</span> <span class="n">funct_len</span>

    <span class="k">return</span> <span class="n">prologue</span> <span class="o">+</span> <span class="n">jump_table_handler</span> <span class="o">+</span> <span class="n">padding</span> <span class="o">+</span> <span class="n">function_data_segment</span>
</code></pre></div></div>

<p>With this system, as long as a function was declared beforehand, it could be called from anywhere, and there would 
not be any additional constraints during linkage. As a result, we are able to write very complex programs supporting function calls, recursion, global variables, and more using a very simple bytecode architecture.</p>

<h2 id="the-program">The Program</h2>

<p>The actual program running on the VM was a flag verifier that requested a flag <code class="language-plaintext highlighter-rouge">corctf{...}</code> with a body 
of 36 characters. As those characters were read, they were processed through a pseudorandom algorithm which would
scramble the case of the letters:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
<span class="n">HASH_MULTIPLIER</span> <span class="o">=</span> <span class="mi">13</span>
<span class="n">HASH_SEED</span> <span class="o">=</span> <span class="mh">0xDEADBEEF</span> <span class="c1"># as a long (+3735928559)
</span>
<span class="nf">define_function</span><span class="p">(</span><span class="sh">"</span><span class="s">init_hash</span><span class="sh">"</span><span class="p">,</span> <span class="p">[</span>
    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="n">HASH_MULTIPLIER</span><span class="p">),</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">148</span><span class="p">),</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span>
    <span class="o">*</span><span class="nf">memory_store</span><span class="p">(),</span> <span class="c1"># store multiplier at 148
</span>    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="n">HASH_SEED</span><span class="p">),</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">146</span><span class="p">),</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># store seed at 146
</span>    <span class="o">*</span><span class="nf">memory_store</span><span class="p">(),</span> <span class="c1"># store seed as hash state
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span> <span class="c1"># return
</span><span class="p">])</span>

<span class="c1"># recursively calls until num_iter is zero
</span><span class="nf">define_function</span><span class="p">(</span><span class="sh">"</span><span class="s">update_hash_inner</span><span class="sh">"</span><span class="p">,</span> <span class="p">[</span> <span class="c1"># [ret_addr, temp, num_iter, data]
</span>    <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">TAKE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">TAKE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span>
    <span class="c1"># [num_iter, data, ret_addr] args copied over, at data
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">5</span><span class="p">),</span> <span class="sh">"</span><span class="s">BNZ</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, num_iter, data, ret_addr] at temp
</span>        <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># skip if num_iter is nonzero; return if zero
</span>    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">148</span><span class="p">),</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">memory_load</span><span class="p">(),</span> <span class="c1"># [temp, hash_multiplier, data, ret_addr]
</span>    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">146</span><span class="p">),</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">memory_load</span><span class="p">(),</span> <span class="c1"># [temp, old_state, hash_multiplier, data, ret_addr]
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">MUL</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">ADD</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, new_state, ret_addr]
</span>    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">146</span><span class="p">),</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">memory_store</span><span class="p">(),</span> <span class="c1"># store new state at 146
</span>    <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">TAKE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">TAKE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span>
    <span class="c1"># [num_iter, data, ret_addr] args copied over, at data
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">DEC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, num_iter - 1, data, ret_addr] at temp
</span>    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">update_hash_inner</span><span class="sh">"</span><span class="p">),</span> <span class="c1"># recursive call (no tail-call optimization)
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span> <span class="c1"># return from function
</span><span class="p">])</span>

<span class="c1"># updates the hash with the data five times
</span><span class="nf">define_function</span><span class="p">(</span><span class="sh">"</span><span class="s">update_hash</span><span class="sh">"</span><span class="p">,</span> <span class="p">[</span> <span class="c1"># [ret_addr, data]
</span>    <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">TAKE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># pull function arg behind return address on stack
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">5</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, num_iter, data, ret_addr] at temp
</span>    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">update_hash_inner</span><span class="sh">"</span><span class="p">),</span> <span class="c1"># call inner recursive function
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span> <span class="c1"># return from function
</span><span class="p">])</span>

<span class="nf">define_function</span><span class="p">(</span><span class="sh">"</span><span class="s">get_hash</span><span class="sh">"</span><span class="p">,</span> <span class="p">[</span>
    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">146</span><span class="p">),</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">memory_load</span><span class="p">(),</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># load hash state from 146
</span>    <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># put result behind return address
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span> <span class="c1"># return from function
</span><span class="p">])</span>

<span class="c1"># flips the upper/lower case of a character depending on the hash value
</span><span class="nf">define_function</span><span class="p">(</span><span class="sh">"</span><span class="s">get_char_scramble</span><span class="sh">"</span><span class="p">,</span> <span class="p">[</span>
    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">get_hash</span><span class="sh">"</span><span class="p">),</span> <span class="c1"># [temp, hash_value] at temp
</span>    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">32</span><span class="p">),</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">SRL</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [hash_value &gt;&gt; 32, _]
</span>    <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">2</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">MOD</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">MOD</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># normalize to 0 or 1
</span>    <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mh">0x20</span><span class="p">),</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INPUT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [input, 0x20, _, bool]
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">update_hash</span><span class="sh">"</span><span class="p">),</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">6</span><span class="p">,</span> <span class="sh">"</span><span class="s">BZ</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [input, 0x20, skip_offset, bool] at skip_offset
</span>        <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">XOR</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># skip if zero
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, scrambled_input, _, ret_addr]
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, ret_addr, scrambled_input]
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span> <span class="c1"># return from function
</span><span class="p">])</span>
</code></pre></div></div>

<p>The code performs a loop which iterates 36 times, processing the character through the scrambler and then 
encoding it into a number in a 6x6 matrix:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">#ahaHa
# 0: a  (97)
# 1: h  (104)
# -1: H (72)
# 5: everything else (bad)
# [temp, _, addr, _, _, _, 72, 32] at temp
</span><span class="n">read_and_store</span> <span class="o">=</span> <span class="p">[</span>
    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">get_char_scramble</span><span class="sh">"</span><span class="p">),</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span>
    <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">4</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">4</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [_, temp, addr, _, _, scrambled_input, 72, 32] at temp
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">5</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">SUB</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># subtract 72. Should be zero if 'H'
</span>    <span class="c1"># "CLEAR", # : forces it to set to 'H' and -1 override
</span>    <span class="c1"># "RIGHT", "PRINT", "LEFT", # santity check. hope this is actually an H
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">9</span><span class="p">,</span> <span class="sh">"</span><span class="s">BNZ</span><span class="sh">"</span><span class="p">,</span>
        <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">DEC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">6</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># skip this if nonzero
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">SUB</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># sub another 32. Should be zero if 'h'
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># restore the [72, 32]
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">7</span><span class="p">,</span> <span class="sh">"</span><span class="s">BNZ</span><span class="sh">"</span><span class="p">,</span>
        <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">DEC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">4</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># skip this if nonzero
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">7</span><span class="p">,</span> <span class="c1"># add 7. Should be zero if 'a'
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">8</span><span class="p">,</span> <span class="sh">"</span><span class="s">BNZ</span><span class="sh">"</span><span class="p">,</span>
        <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">DEC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="mi">5</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># skip this if zero
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, temp, temp, addr, num, _, _, 72, 32] at num
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">TAKE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, addr_copy, temp, addr, num, _, 72, 32]
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">TAKE</span><span class="sh">"</span><span class="p">,</span>
    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, addr_copy, num_copy, addr, num, _, 72, 32] at num_copy
</span>    <span class="c1">#"CLEAR", *["INC"] * 1, # TODO REMOVE THIS, SET TO 5 FORCEFULLY
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">memory_store</span><span class="p">(),</span> <span class="c1"># [temp, addr, num, _, 72, 32] at temp
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">144</span><span class="p">),</span> <span class="sh">"</span><span class="s">SUB</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># increment address (twice), compare
</span>    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span>
<span class="p">]</span>

<span class="n">read_and_store</span> <span class="o">+=</span> <span class="nf">load_back_branch_offset</span><span class="p">(</span><span class="nf">len</span><span class="p">(</span><span class="n">read_and_store</span><span class="p">))</span>
<span class="n">read_and_store</span><span class="p">.</span><span class="nf">append</span><span class="p">(</span><span class="sh">"</span><span class="s">BNZ</span><span class="sh">"</span><span class="p">)</span> <span class="c1"># keep looping until we reach the end
</span>
<span class="nf">define_function</span><span class="p">(</span><span class="sh">"</span><span class="s">read_input_as_b</span><span class="sh">"</span><span class="p">,</span> <span class="p">[</span>
    <span class="o">*</span><span class="nf">flatten</span><span class="p">(</span>
        <span class="p">[</span><span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="nf">ord</span><span class="p">(</span><span class="n">c</span><span class="p">)),</span> <span class="sh">"</span><span class="s">PRINT</span><span class="sh">"</span><span class="p">]</span>
        <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="sh">"</span><span class="s">Flag Verifier</span><span class="se">\n</span><span class="s">Enter flag in this format:</span><span class="se">\n</span><span class="s">corctf{36_ascii_chars_inside___}</span><span class="se">\n</span><span class="sh">"</span>
    <span class="p">),</span>
    <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INPUT</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="nf">len</span><span class="p">(</span><span class="sh">"</span><span class="s">corctf{</span><span class="sh">"</span><span class="p">),</span> <span class="c1"># dispose of first 7 characters
</span>    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">32</span><span class="p">),</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">72</span><span class="p">),</span>
    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="mi">72</span><span class="p">),</span>
    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, _, addr, _, _, _, 72, 32] at temp
</span>    <span class="o">*</span><span class="n">read_and_store</span><span class="p">,</span> <span class="c1"># loops until done, at same register location
</span>    <span class="sh">"</span><span class="s">INPUT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># consume closing brace }
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span>
    <span class="o">*</span><span class="nf">flatten</span><span class="p">(</span>
        <span class="p">[</span><span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="nf">ord</span><span class="p">(</span><span class="n">c</span><span class="p">)),</span> <span class="sh">"</span><span class="s">PRINT</span><span class="sh">"</span><span class="p">]</span>
        <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="sh">"</span><span class="se">\n</span><span class="s">Checking flag...</span><span class="se">\n</span><span class="sh">"</span>
    <span class="p">),</span>
    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># go back to return address and return
</span><span class="p">])</span>
</code></pre></div></div>

<p>The flag verifier required this encoded matrix to be the inverse of a given matrix:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">TARGET_MATRIX</span> <span class="o">=</span> <span class="p">[</span>
    <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span>
    <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span>
    <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span>
    <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span>
    <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span>
    <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span>
<span class="p">]</span>

<span class="nf">define_function</span><span class="p">(</span><span class="sh">"</span><span class="s">load_matrix_a</span><span class="sh">"</span><span class="p">,</span> <span class="p">[</span>
    <span class="sh">"</span><span class="s">IDENTITY</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">SHIFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># go to 0, transport return address
</span>    <span class="o">*</span><span class="nf">flatten</span><span class="p">(</span>
        <span class="p">[</span><span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">CLEAR</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="p">[</span><span class="sh">"</span><span class="s">INC</span><span class="sh">"</span><span class="p">]</span> <span class="o">*</span> <span class="n">load_value</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">]</span>
        <span class="k">for</span> <span class="n">load_value</span> <span class="ow">in</span> <span class="n">TARGET_MATRIX</span>
    <span class="p">),</span>
    <span class="o">*</span><span class="nf">flatten</span><span class="p">([</span><span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">]</span> <span class="k">for</span> <span class="n">load_value</span> <span class="ow">in</span> <span class="n">TARGET_MATRIX</span><span class="p">),</span>
    <span class="sh">"</span><span class="s">SHIFT</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># initialized cells 0, 2, 4, ..., 70
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span> <span class="c1"># return
</span><span class="p">])</span>
</code></pre></div></div>

<p>Finally, I put together the pieces of my program together, defining the <code class="language-plaintext highlighter-rouge">main</code> function:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">accept</span> <span class="o">=</span> <span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">accept_flag</span><span class="sh">"</span><span class="p">)</span>
<span class="n">reject</span> <span class="o">=</span> <span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">reject_flag</span><span class="sh">"</span><span class="p">)</span>

<span class="nf">define_function</span><span class="p">(</span><span class="sh">"</span><span class="s">main</span><span class="sh">"</span><span class="p">,</span> <span class="p">[</span>
    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">init_hash</span><span class="sh">"</span><span class="p">),</span>
    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">load_matrix_a</span><span class="sh">"</span><span class="p">),</span>
    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">read_input_as_b</span><span class="sh">"</span><span class="p">),</span>
    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">mult_a_b_into_a</span><span class="sh">"</span><span class="p">),</span>
    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">reduce_a_bitwise_or</span><span class="sh">"</span><span class="p">),</span> <span class="c1"># [temp, a, ret_addr] (a must be 1)
</span>    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">mult_a_b_into_a</span><span class="sh">"</span><span class="p">),</span>
    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">a_sub_b</span><span class="sh">"</span><span class="p">),</span>
    <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">reduce_a_bitwise_or</span><span class="sh">"</span><span class="p">),</span> <span class="c1"># [temp, b, a, ret_addr] (b must be 0)
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">DEC</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">LEFT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">OR</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">BUBBLE</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># [temp, flag_reject, ret_addr] at temp
</span>    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="nf">len</span><span class="p">(</span><span class="n">accept</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span><span class="p">),</span> <span class="sh">"</span><span class="s">BNZ</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># skip if nonzero
</span>        <span class="o">*</span><span class="n">accept</span><span class="p">,</span> <span class="c1"># accept flag
</span>    <span class="o">*</span><span class="nf">load_number</span><span class="p">(</span><span class="nf">len</span><span class="p">(</span><span class="n">reject</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span><span class="p">),</span> <span class="sh">"</span><span class="s">BZ</span><span class="sh">"</span><span class="p">,</span> <span class="c1"># skip if nonzero
</span>        <span class="o">*</span><span class="n">reject</span><span class="p">,</span> <span class="c1"># reject flag
</span>    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span>
    <span class="o">*</span><span class="nf">call_function</span><span class="p">(</span><span class="sh">"</span><span class="s">thank_user</span><span class="sh">"</span><span class="p">),</span>
    <span class="sh">"</span><span class="s">RIGHT</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">JUMP</span><span class="sh">"</span> <span class="c1"># return from main
</span><span class="p">])</span>
</code></pre></div></div>

<h2 id="the-ctf">The CTF</h2>

<p>This was the intended flag for the program: <code class="language-plaintext highlighter-rouge">corctf{aHAhaHHAaAaAAAAhAhhahAaAAAaAAhhaHahA}</code></p>

<p>This challenge was released 24 hours into corCTF, and was solved by two teams, making it the hardest rev 
challenge in the CTF. Although I’m pretty satisfied with the results, I feel like the challenge could’ve 
been made improved by making more control flow decisions dependent on the flag’s data. The current program operated 
“blindly” on the flag data, so a simulator could easily trace the symbolic relationship between the flag 
payload and the program result without the state space blowing up. Next time, I’ll be sure to put a 
more complex algorithm inside my VM.</p>

<p>I actually made some mistakes in my flag verifier program, and teams discovered another flag that 
also got accepted. Oops! Next time, I will make sure to have more quality assurance and code reviews 
on my challenges.</p>

<p>Additionally, since I put so much effort into making a sophisticated assembler, 
I probably could’ve written another layer of virtualization within the VM to force players 
to carefully decipher how the entire VM worked, rather than just fuzzing and diffing pieces to 
get a rough estimate of what was going on.</p>

<h2 id="the-conclusion">The Conclusion</h2>

<p><code class="language-plaintext highlighter-rouge">bubble-vm</code> doesn’t have explicit push, pop, read, write, call, or return instructions, 
and barely even supports random indexing, 
yet through careful manipulation of memory layouts and tape positions, we can create powerful abstractions which 
allow us to scale programs far beyond what a human can statically analyze. Even with extremely limiting architectures, 
complex behaviors can emerge from a handful of primtive constructions, allowing us to model any computable problem.</p>

<p>I had a lot of fun creating this VM and writing my own program and assembler for it. Working on this challenge has
definitely changed my viewpoint on computing and program design, and I hope to continue to write more cool 
projects and CTF challenges in the future.</p>]]></content><author><name></name></author><summary type="html"><![CDATA[corCTF 2025 - bubble-vm]]></summary></entry><entry><title type="html">Rethinking Object-Oriented Programming in Java Education</title><link href="http://localhost:4000/blog/rethinking-oop/" rel="alternate" type="text/html" title="Rethinking Object-Oriented Programming in Java Education" /><published>2025-07-11T00:00:00-07:00</published><updated>2025-07-11T00:00:00-07:00</updated><id>http://localhost:4000/blog/teaching-java-object-oriented-programming</id><content type="html" xml:base="http://localhost:4000/blog/rethinking-oop/"><![CDATA[<p>Code.org’s <a href="https://studio.code.org/courses/csa-2024?viewAs=Instructor">2024 AP Computer Science A (APCSA) course</a> explains in Unit 1, Lesson 3, that “In Java, a class is a programmer-defined blueprint from which objects are created. An object is an instance of a class.” On the very next slide, the instructors elaborate by saying “An instance of a class means that it is a copy of the class with its own unique set of information. Without the class, you can’t create an object!”</p>

<p>For beginning CS students, this circular explanation doesn’t clarify or motivate anything. Why do we need blueprints? What is an instance? We haven’t even finished the first week of school!</p>

<p>Object-oriented programming (OOP) is widely used in the software industry, but it involves concepts that are abstract and difficult to motivate without a strong foundational understanding of the language. Furthermore, forcing these concepts onto students hinders critical thinking — students don’t learn why a pattern should be employed, or that there even exists a choice.</p>

<p>Curriculum designers introduce these concepts early on because introductory courses have to prepare students to be able to write real programs within a short timeframe. OOP is used extensively in real-world applications to facilitate modularity, so students must be familiar with OOP design in addition to basic syntax and logic.</p>

<p>This expectation is reasonable: learning a programming language is like learning a foreign language. When students start learning computer science, however, they must not only learn the syntax and vocabulary of their language, but also how to express their ideas to other programmers. In order to accomplish this, students must learn structured ways to represent their logic using classes, constructors, methods, and getters and setters.</p>

<p>However, teaching these design patterns without justification is confusing. Students don’t understand the abstract theories about blueprints and instances (or why they should even care). Even when students memorize these templates, they don’t fully learn their purpose or limitations, and therefore can’t detach their thought process from this system. In fact, many problems don’t even need object-oriented design, and this pedagogy actually leads students to obey dogma rather than thinking critically about the nature of the problem. Fundamentally, this solution doesn’t work because students don’t even know what practical problem these object-oriented features aim to solve.</p>

<p>In order to really understand these tools, students need to understand their purpose in real situations. This requires starting from scratch, gaining familiarity with a subset of the language, and only introducing new features as necessary. As I will demonstrate in this blog, <strong>object-oriented design can actually be extremely intuitive and obvious to students</strong> when its use is contextualized with real practice and purpose. With this change to the curriculum, students can think critically about industrial code design while still meeting the timeline.</p>

<h2 id="inspiration">Inspiration</h2>
<p>This proposal is inspired by Northeastern University Computer Science Professor Matthias Felleisen’s <a href="https://felleisen.org/matthias/Thoughts/The_Design_Recipe.html">design recipe</a> and <a href="https://felleisen.org/matthias/Thoughts/dev.html">curriculum</a>, as well as Ethan McCue’s <a href="https://javabook.mccue.dev/">approach to teaching modern Java</a>. At a high level, their goals for a foundational computer science curriculum are as follows:</p>

<ul>
  <li>Students should start somewhere simple.</li>
  <li>Students should start writing their own programs as soon as possible.</li>
  <li>Students should practice by writing their own code to solve problems of increasing complexity (provided by the instructor).</li>
  <li>No new language features or concepts should be introduced until all the prerequisites have been covered and students understand why it is needed.</li>
  <li>Students should be able to practice and use any concept in isolation.</li>
  <li>By providing challenges that get progressively more complex, students will realize that certain tasks are either extremely tedious or straight-up impossible with their limited toolkit — only then should an instructor introduce a new concept.</li>
</ul>

<p>In the rest of this blog, I will give some examples of how key concepts can be explained using this new style of teaching.</p>

<h2 id="the-beginning">The Beginning</h2>
<p>Java famously comes with tons of boilerplate for simple things like the entry point for a program. Although the syntax around <code class="language-plaintext highlighter-rouge">public class Main { public static void main(String[] args) { ... } }</code> does technically carry meaning, these symbols cannot be meaningfully explained to students yet, so it’s not suitable for a day-one project. Furthermore, it tends to cause confusion with students messing up their parentheses or writing code in the wrong place (which is reasonable, because students haven’t even learned what these curly brackets are meant for anyway!).</p>

<p>In order to decouple beginning students from the highly front-loaded design of the Java language (with <code class="language-plaintext highlighter-rouge">static</code> and <code class="language-plaintext highlighter-rouge">class</code> keywords), Java’s upcoming JDK 25 introduces <a href="https://openjdk.org/jeps/512">compact source files and instance main methods</a> as a builtin feature, which I recommend for beginning students. Alternatively, JShell can be used if the newest install isn’t available. These serve as educational tools for students to easily experiment with code without a strict source tree and proper static scoping. This comes in handy later on as students can explore OOP bit by bit, without requiring a fully formed code structure.</p>

<p>The basic setup for the classic Hello World program is as follows:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Hello, World!"</span><span class="o">);</span>
</code></pre></div></div>
<p>No extra syntax is required. Students can quickly learn that Java code is structured as a sequence of semicolon-terminated statements, executed one after another:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Hello, World!"</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Nice to meet you!"</span><span class="o">);</span>
</code></pre></div></div>

<p>This system allows students to familiarize themselves with the basics of Java, writing imperative code with variables and common datatypes. In the <a href="https://apcentral.collegeboard.org/media/pdf/ap-computer-science-a-course-and-exam-description-effective-fall-2025.pdf">revised 2025-2026 APCSA curriculum</a>, this corresponds roughly to sections 1.2–1.6. Students can explore basic console inputs, code comments, arithmetic, and control flow:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">java.util.Scanner</span><span class="o">;</span>

<span class="c1">// create a scanner to read system input</span>
<span class="nc">Scanner</span> <span class="n">scanner</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Scanner</span><span class="o">(</span><span class="nc">System</span><span class="o">.</span><span class="na">in</span><span class="o">);</span>

<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"What is your name?"</span><span class="o">);</span>
<span class="nc">String</span> <span class="n">name</span> <span class="o">=</span> <span class="n">scanner</span><span class="o">.</span><span class="na">nextLine</span><span class="o">();!</span>

<span class="c1">// greet the user</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Hello, "</span> <span class="o">+</span> <span class="n">name</span> <span class="o">+</span> <span class="s">"!"</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Nice to meet you!"</span><span class="o">);</span>

<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"What is your age?"</span><span class="o">);</span>
<span class="kt">int</span> <span class="n">age</span> <span class="o">=</span> <span class="n">scanner</span><span class="o">.</span><span class="na">nextInt</span><span class="o">();</span>

<span class="kt">boolean</span> <span class="n">isTeen</span> <span class="o">=</span> <span class="n">age</span> <span class="o">&gt;=</span> <span class="mi">13</span> <span class="o">&amp;&amp;</span> <span class="n">age</span> <span class="o">&lt;=</span> <span class="mi">19</span><span class="o">;</span>
<span class="k">if</span> <span class="o">(</span><span class="n">isTeen</span><span class="o">)</span> <span class="o">{</span>
    <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"You are a teenager!"</span><span class="o">);</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
    <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"You are not a teenager!"</span><span class="o">);</span>
<span class="o">}</span>
</code></pre></div></div>

<h2 id="procedural-abstractions">Procedural Abstractions</h2>
<p>One of the goals of this curriculum is to not force students to use any particular tool, but to demonstrate when it is useful for students by highlighting its pros and cons. Instructors can work their way to introducing new concepts by giving an example challenge where it might be necessary to use it (instead of what was already available to students). For example, consider this code snippet:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">int</span> <span class="n">myNumber</span> <span class="o">=</span> <span class="mi">91</span><span class="o">;</span>
<span class="kt">boolean</span> <span class="n">myNumberPrime</span> <span class="o">=</span> <span class="kc">true</span><span class="o">;</span>
<span class="kt">int</span> <span class="n">mySearchNum</span> <span class="o">=</span> <span class="mi">2</span><span class="o">;</span>
<span class="k">while</span> <span class="o">(</span><span class="n">mySearchNum</span> <span class="o">&lt;</span> <span class="n">myNumber</span><span class="o">)</span> <span class="o">{</span>
    <span class="k">if</span> <span class="o">(</span><span class="n">myNumber</span> <span class="o">%</span> <span class="n">mySearchNum</span> <span class="o">==</span> <span class="mi">0</span><span class="o">)</span> <span class="o">{</span>
        <span class="n">myNumberPrime</span> <span class="o">=</span> <span class="kc">false</span><span class="o">;</span>
    <span class="o">}</span>
    <span class="n">mySearchNum</span><span class="o">++;</span>
<span class="o">}</span>

<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"My number is "</span> <span class="o">+</span> <span class="n">myNumber</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">myNumber</span> <span class="o">+</span> <span class="s">" is prime? "</span> <span class="o">+</span> <span class="n">myNumberPrime</span><span class="o">);</span>

<span class="kt">int</span> <span class="n">yourNumber</span> <span class="o">=</span> <span class="mi">27644437</span><span class="o">;</span>
<span class="kt">boolean</span> <span class="n">yourNumberPrime</span> <span class="o">=</span> <span class="kc">true</span><span class="o">;</span>
<span class="kt">int</span> <span class="n">yourSearchNum</span> <span class="o">=</span> <span class="mi">2</span><span class="o">;</span>
<span class="k">while</span> <span class="o">(</span><span class="n">yourSearchNum</span> <span class="o">&lt;</span> <span class="n">yourNumber</span><span class="o">)</span> <span class="o">{</span>
    <span class="k">if</span> <span class="o">(</span><span class="n">yourNumber</span> <span class="o">%</span> <span class="n">yourSearchNum</span> <span class="o">==</span> <span class="mi">0</span><span class="o">)</span> <span class="o">{</span>
        <span class="n">yourNumberPrime</span> <span class="o">=</span> <span class="kc">false</span><span class="o">;</span>
    <span class="o">}</span>
    <span class="n">yourSearchNum</span><span class="o">++;</span>
<span class="o">}</span>

<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Your number is "</span> <span class="o">+</span> <span class="n">yourNumber</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">yourNumber</span> <span class="o">+</span> <span class="s">" is prime? "</span> <span class="o">+</span> <span class="n">yourNumberPrime</span><span class="o">);</span>
</code></pre></div></div>

<p>Students will quickly realize that writing this type of code is highly repetitive, and requires careful management of unique variable names for each situation. What if we want to replace the while loop with a for loop? What if we want to use a more efficient algorithm for determining if a number is prime? Whenever we want to make an adjustment, we have to carefully sift through the entire code to find old usages and patch it, while also adjusting the variable names in each case. This process should clearly be generalized. Methods can be logically introduced as a named piece of code that can generalize over its input parameters to yield some sort of result:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">boolean</span> <span class="nf">isPrime</span><span class="o">(</span><span class="kt">int</span> <span class="n">num</span><span class="o">)</span> <span class="o">{</span>
    <span class="kt">boolean</span> <span class="n">result</span> <span class="o">=</span> <span class="kc">true</span><span class="o">;</span>
    <span class="kt">int</span> <span class="n">searchNum</span> <span class="o">=</span> <span class="mi">2</span><span class="o">;</span>
    <span class="k">while</span> <span class="o">(</span><span class="n">searchNum</span> <span class="o">&lt;</span> <span class="n">num</span><span class="o">)</span> <span class="o">{</span>
        <span class="k">if</span> <span class="o">(</span><span class="n">num</span> <span class="o">%</span> <span class="n">searchNum</span> <span class="o">==</span> <span class="mi">0</span><span class="o">)</span> <span class="o">{</span>
            <span class="n">result</span> <span class="o">=</span> <span class="kc">false</span><span class="o">;</span>
        <span class="o">}</span>
        <span class="n">searchNum</span><span class="o">++;</span>
    <span class="o">}</span>
    <span class="k">return</span> <span class="n">result</span><span class="o">;</span>
<span class="o">}</span>

<span class="kt">int</span> <span class="n">myNumber</span> <span class="o">=</span> <span class="mi">91</span><span class="o">;</span>
<span class="kt">boolean</span> <span class="n">myNumberPrime</span> <span class="o">=</span> <span class="n">isPrime</span><span class="o">(</span><span class="n">myNumber</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"My number is "</span> <span class="o">+</span> <span class="n">myNumber</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">myNumber</span> <span class="o">+</span> <span class="s">" is prime? "</span> <span class="o">+</span> <span class="n">myNumberPrime</span><span class="o">);</span>

<span class="kt">int</span> <span class="n">yourNumber</span> <span class="o">=</span> <span class="mi">27644437</span><span class="o">;</span>
<span class="kt">boolean</span> <span class="n">yourNumberPrime</span> <span class="o">=</span> <span class="n">isPrime</span><span class="o">(</span><span class="n">yourNumber</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Your number is "</span> <span class="o">+</span> <span class="n">yourNumber</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">yourNumber</span> <span class="o">+</span> <span class="s">" is prime? "</span> <span class="o">+</span> <span class="n">yourNumberPrime</span><span class="o">);</span>
</code></pre></div></div>

<p>Teachers and students are encouraged to justify these choices rather than prescribing certain doctrines. For example, this refactor is useful because it defines a practical and reusable named section of code that performs a certain function. It also makes higher-level code resilient to changes in the internal implementation of the logic, such as improvements to the prime sieve algorithm (with adjusted loop bounds and short-circuiting when a factorization is found). In fancy words, methods encapsulate code and hide it behind a uniform interface (API) that can be easily accessed. Students learn to make their own design choices out of necessity, not only for their own benefit, but also to communicate their ideas to anyone they’re working with (including their teacher when asking for help).</p>

<p>With this approach, the introduction of procedural abstractions seems natural and motivated, and students are encouraged to think critically about code structure.</p>

<h2 id="data-abstractions">Data Abstractions</h2>
<p>Even after repeated practice at modeling real-world problems with procedural abstractions, students will inevitably encounter limitations to the types of data that their code can handle. It’s difficult for code to model compound data when you can only pass around <code class="language-plaintext highlighter-rouge">int</code>, <code class="language-plaintext highlighter-rouge">boolean</code>, and <code class="language-plaintext highlighter-rouge">String</code>. All we need to do is define a custom data classification:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">class</span> <span class="nc">Cash</span> <span class="o">{</span>
    <span class="kt">int</span> <span class="n">twenties</span><span class="o">;</span>
    <span class="kt">int</span> <span class="n">tens</span><span class="o">;</span>
    <span class="kt">int</span> <span class="n">ones</span><span class="o">;</span>
<span class="o">}</span>
</code></pre></div></div>

<p>All this does is create a custom named type that contains the listed fields. None of the complicated object-oriented relationships need to come in play yet — students can build tools around this using methods (which they already learned):</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nc">Cash</span> <span class="nf">makeCash</span><span class="o">(</span><span class="kt">int</span> <span class="n">twenties</span><span class="o">,</span> <span class="kt">int</span> <span class="n">tens</span><span class="o">,</span> <span class="kt">int</span> <span class="n">ones</span><span class="o">)</span> <span class="o">{</span>
    <span class="nc">Cash</span> <span class="n">c</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Cash</span><span class="o">();</span>
    <span class="n">c</span><span class="o">.</span><span class="na">twenties</span> <span class="o">=</span> <span class="n">twenties</span><span class="o">;</span>
    <span class="n">c</span><span class="o">.</span><span class="na">tens</span> <span class="o">=</span> <span class="n">tens</span><span class="o">;</span>
    <span class="n">c</span><span class="o">.</span><span class="na">ones</span> <span class="o">=</span> <span class="n">ones</span><span class="o">;</span>
    <span class="k">return</span> <span class="n">c</span><span class="o">;</span>
<span class="o">}</span>

<span class="kt">int</span> <span class="nf">value</span><span class="o">(</span><span class="nc">Cash</span> <span class="n">c</span><span class="o">)</span> <span class="o">{</span>
    <span class="k">return</span> <span class="mi">20</span> <span class="o">*</span> <span class="n">c</span><span class="o">.</span><span class="na">twenties</span> <span class="o">+</span> <span class="mi">10</span> <span class="o">*</span> <span class="n">c</span><span class="o">.</span><span class="na">tens</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">*</span> <span class="n">c</span><span class="o">.</span><span class="na">ones</span><span class="o">;</span>
<span class="o">}</span>

<span class="nc">Cash</span> <span class="nf">plus</span><span class="o">(</span><span class="nc">Cash</span> <span class="n">c</span><span class="o">,</span> <span class="nc">Cash</span> <span class="n">other</span><span class="o">)</span> <span class="o">{</span>
    <span class="k">return</span> <span class="nf">makeCash</span><span class="o">(</span>
        <span class="n">c</span><span class="o">.</span><span class="na">twenties</span> <span class="o">+</span> <span class="n">other</span><span class="o">.</span><span class="na">twenties</span><span class="o">,</span>
        <span class="n">c</span><span class="o">.</span><span class="na">tens</span> <span class="o">+</span> <span class="n">other</span><span class="o">.</span><span class="na">tens</span><span class="o">,</span>
        <span class="n">c</span><span class="o">.</span><span class="na">ones</span> <span class="o">+</span> <span class="n">other</span><span class="o">.</span><span class="na">ones</span>
    <span class="o">);</span>
<span class="o">}</span>

<span class="nc">String</span> <span class="nf">description</span><span class="o">(</span><span class="nc">Cash</span> <span class="n">c</span><span class="o">)</span> <span class="o">{</span>
    <span class="k">return</span> <span class="s">"Cash[20*"</span> <span class="o">+</span> <span class="n">c</span><span class="o">.</span><span class="na">twenties</span>
        <span class="o">+</span> <span class="s">" + 10*"</span> <span class="o">+</span> <span class="n">c</span><span class="o">.</span><span class="na">tens</span>
        <span class="o">+</span> <span class="s">" + 1*"</span> <span class="o">+</span> <span class="n">c</span><span class="o">.</span><span class="na">ones</span>
        <span class="o">+</span> <span class="s">" = "</span> <span class="o">+</span> <span class="n">value</span><span class="o">(</span><span class="n">c</span><span class="o">)</span> <span class="o">+</span> <span class="s">"]"</span><span class="o">;</span>
<span class="o">}</span>

<span class="c1">// example usage</span>
<span class="nc">Cash</span> <span class="n">pocket</span> <span class="o">=</span> <span class="n">makeCash</span><span class="o">(</span><span class="mi">0</span><span class="o">,</span> <span class="mi">1</span><span class="o">,</span> <span class="mi">3</span><span class="o">);</span>
<span class="nc">Cash</span> <span class="n">wallet</span> <span class="o">=</span> <span class="n">makeCash</span><span class="o">(</span><span class="mi">3</span><span class="o">,</span> <span class="mi">2</span><span class="o">,</span> <span class="mi">7</span><span class="o">);</span>
<span class="nc">Cash</span> <span class="n">total</span> <span class="o">=</span> <span class="n">plus</span><span class="o">(</span><span class="n">wallet</span><span class="o">,</span> <span class="n">pocket</span><span class="o">);</span>
<span class="kt">int</span> <span class="n">totalValue</span> <span class="o">=</span> <span class="n">value</span><span class="o">(</span><span class="n">total</span><span class="o">);</span>

<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span>
    <span class="s">"I have a total of $"</span> <span class="o">+</span> <span class="n">totalValue</span>
    <span class="o">+</span> <span class="s">" in my pocket and wallet: "</span> <span class="o">+</span> <span class="n">description</span><span class="o">(</span><span class="n">total</span><span class="o">)</span>
<span class="o">);</span>
</code></pre></div></div>

<p>Notice that, like with the procedural abstractions, none of these methods are part of any particular class, reducing the cognitive load. Students can manipulate these data objects using tools they already know. Each lesson only introduces a small concept, which can be reviewed independently, so teachers can still cover all the material within the timeline.</p>

<p>Students can immediately understand why this feature is useful — it would be incredibly tedious (and error-prone!) to always pass around the three constituent parameters (and also impossible to return from a method). Additionally, data modeling is easier to understand and practice than the full object-oriented system, and is a core part of the design process. By attempting to model actual business logic with and without certain features, students can develop a stronger understanding of not only the language, but the general problem-solving process.</p>

<p>Each individual concept can be practiced in isolation (without relying on provided template code which students don’t understand)! Just like how we can teach arithmetic and for loops by giving example applications and small challenges, we can teach individual OOP concepts using extremely small, isolated challenges covering each skill. For example, Ethan McCue provides several <a href="https://javabook.mccue.dev/classes/challenges">challenges</a> after introducing classes, covering concepts such as field access and reference aliasing, before instance methods are even introduced. Each challenge comes with a very small code file which students can run and evaluate entirely on their own. There is no hidden code, mysterious template, or autograder. All of the example problems involve code which students could plausibly write on their own, so there is no mismatch between the lesson material and the assignments.</p>

<h2 id="putting-it-all-together">Putting it all Together</h2>
<p>Again, the use of language features should always be informed by their actual necessity. Object-oriented programming isn’t our target, it’s a result that stems from the fundamental demand for powerful generalizations to handle complex, real-world logic. In particular, fully-formed classes are a result of directly binding functionality with member data. In our previous example, several different methods took in the same <code class="language-plaintext highlighter-rouge">Cash c</code> as its first parameter. Arguably, those methods should simply belong to that first parameter. In Java, there is a simple transformation that can turn individual functions into class methods: rename the first parameter into <code class="language-plaintext highlighter-rouge">Cash this</code>, and place it inside the body of the class. A similar operation can be done to generate a constructor. Then, the invocation of these methods is always associated with a particular instance of the object, which is implicitly treated as the <code class="language-plaintext highlighter-rouge">this</code> parameter:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">class</span> <span class="nc">Cash</span> <span class="o">{</span>
    <span class="kt">int</span> <span class="n">twenties</span><span class="o">;</span>
    <span class="kt">int</span> <span class="n">tens</span><span class="o">;</span>
    <span class="kt">int</span> <span class="n">ones</span><span class="o">;</span>

    <span class="nc">Cash</span><span class="o">(</span><span class="kt">int</span> <span class="n">twenties</span><span class="o">,</span> <span class="kt">int</span> <span class="n">tens</span><span class="o">,</span> <span class="kt">int</span> <span class="n">ones</span><span class="o">)</span> <span class="o">{</span>
        <span class="k">this</span><span class="o">.</span><span class="na">twenties</span> <span class="o">=</span> <span class="n">twenties</span><span class="o">;</span>
        <span class="k">this</span><span class="o">.</span><span class="na">tens</span> <span class="o">=</span> <span class="n">tens</span><span class="o">;</span>
        <span class="k">this</span><span class="o">.</span><span class="na">ones</span> <span class="o">=</span> <span class="n">ones</span><span class="o">;</span>
    <span class="o">}</span>

    <span class="kt">int</span> <span class="nf">value</span><span class="o">(</span><span class="nc">Cash</span> <span class="k">this</span><span class="o">)</span> <span class="o">{</span>
        <span class="k">return</span> <span class="mi">20</span> <span class="o">*</span> <span class="k">this</span><span class="o">.</span><span class="na">twenties</span> <span class="o">+</span> <span class="mi">10</span> <span class="o">*</span> <span class="k">this</span><span class="o">.</span><span class="na">tens</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">*</span> <span class="k">this</span><span class="o">.</span><span class="na">ones</span><span class="o">;</span>
    <span class="o">}</span>

    <span class="nc">Cash</span> <span class="nf">plus</span><span class="o">(</span><span class="nc">Cash</span> <span class="k">this</span><span class="o">,</span> <span class="nc">Cash</span> <span class="n">other</span><span class="o">)</span> <span class="o">{</span>
        <span class="k">return</span> <span class="k">new</span> <span class="nf">Cash</span><span class="o">(</span>
            <span class="k">this</span><span class="o">.</span><span class="na">twenties</span> <span class="o">+</span> <span class="n">other</span><span class="o">.</span><span class="na">twenties</span><span class="o">,</span>
            <span class="k">this</span><span class="o">.</span><span class="na">tens</span> <span class="o">+</span> <span class="n">other</span><span class="o">.</span><span class="na">tens</span><span class="o">,</span>
            <span class="k">this</span><span class="o">.</span><span class="na">ones</span> <span class="o">+</span> <span class="n">other</span><span class="o">.</span><span class="na">ones</span>
        <span class="o">);</span>
    <span class="o">}</span>

    <span class="nc">String</span> <span class="nf">description</span><span class="o">(</span><span class="nc">Cash</span> <span class="k">this</span><span class="o">)</span> <span class="o">{</span>
        <span class="k">return</span> <span class="s">"Cash[20*"</span> <span class="o">+</span> <span class="k">this</span><span class="o">.</span><span class="na">twenties</span>
            <span class="o">+</span> <span class="s">" + 10*"</span> <span class="o">+</span> <span class="k">this</span><span class="o">.</span><span class="na">tens</span>
            <span class="o">+</span> <span class="s">" + 1*"</span> <span class="o">+</span> <span class="k">this</span><span class="o">.</span><span class="na">ones</span>
            <span class="o">+</span> <span class="s">" = "</span> <span class="o">+</span> <span class="k">this</span><span class="o">.</span><span class="na">value</span><span class="o">()</span> <span class="o">+</span> <span class="s">"]"</span><span class="o">;</span>
    <span class="o">}</span>
<span class="o">}</span>

<span class="c1">// example usage</span>
<span class="nc">Cash</span> <span class="n">pocket</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Cash</span><span class="o">(</span><span class="mi">0</span><span class="o">,</span> <span class="mi">1</span><span class="o">,</span> <span class="mi">3</span><span class="o">);</span>
<span class="nc">Cash</span> <span class="n">wallet</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Cash</span><span class="o">(</span><span class="mi">3</span><span class="o">,</span> <span class="mi">2</span><span class="o">,</span> <span class="mi">7</span><span class="o">);</span>
<span class="nc">Cash</span> <span class="n">total</span> <span class="o">=</span> <span class="n">wallet</span><span class="o">.</span><span class="na">plus</span><span class="o">(</span><span class="n">pocket</span><span class="o">);</span>
<span class="kt">int</span> <span class="n">totalValue</span> <span class="o">=</span> <span class="n">total</span><span class="o">.</span><span class="na">value</span><span class="o">();</span>

<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span>
    <span class="s">"I have a total of $"</span> <span class="o">+</span> <span class="n">totalValue</span>
    <span class="o">+</span> <span class="s">" in my pocket and wallet: "</span> <span class="o">+</span> <span class="n">total</span><span class="o">.</span><span class="na">description</span><span class="o">()</span>
<span class="o">);</span>
</code></pre></div></div>

<p>Then, the parameter <code class="language-plaintext highlighter-rouge">this</code> can be omitted, because it is already implied by being a method declared inside of the outer class. The result is a well-contained unit of code that declares a Cash class and several useful operations it can perform. Conventionally, this would be declared in a separate file with the class’s name (in this case, <code class="language-plaintext highlighter-rouge">Cash.java</code>.), so that it can be easily located in a codebase and redistributed.</p>

<p>Teachers should emphasize the isomorphism between the old- and new-style functions, and that the “this” parameter doesn’t actually give us new functionality, but is just a shorthand. Once again, students can understand the purpose and motivation of this language feature.</p>

<h2 id="extra-keywords">Extra Keywords</h2>
<p>Once students understand the core concepts of object-oriented design (data modeling, then binding with required functionality), students can start to graduate to the “real” Java environment, with classes stored in separate files. (If using JShell, files might need to be linked to the main runnable using the /open command.) Then, the keywords <code class="language-plaintext highlighter-rouge">public</code> and <code class="language-plaintext highlighter-rouge">private</code> can be introduced as a way to enforce encapsulation and containment (to prevent accidental logic errors). These are useful in large codebases to prevent unintentional mutation or misinterpretations of variables, where the explicitly-defined, public API of a code serves as a key reference to teams of developers. Additionally, the <code class="language-plaintext highlighter-rouge">static</code> keyword can be used to avoid binding a method to a target instance <code class="language-plaintext highlighter-rouge">this</code>, while keeping it part of the class definition (since named Java files require all code to be defined in the body of the class).</p>

<p>In the end, students will reach a full comprehension of the Java language and object-oriented design without having to make any assumptions or logical leaps.</p>

<h2 id="conclusion">Conclusion</h2>
<p>If it sounds like this curriculum encourages students to write bad code, it’s because it does. Beginning CS students don’t instinctively know the difference between good and bad code, so constantly forcing them to do things the “right” way doesn’t teach them anything. Students should gain this intuition by gaining firsthand experience and <em>living</em> with repetitive, frustrating, or clunky code. Only then will design choices and abstractions make sense.</p>

<p>As educators, we should rethink the way we teach abstract concepts to students. Introductory CS courses such as APCSA ought to teach <strong>program design at a fundamental level</strong>, not only the specific language’s syntax and logic. That means accepting that students will write awkward code before they write elegant code, and resisting the urge to patch every inefficiency before it becomes a meaningful lesson.</p>

<p>What experienced programmers perceive as obvious or “natural” is the result of years of experience — not something that can be frontloaded through templates or rules. A well-designed curriculum must create the conditions for that experience to form, by carefully choosing which concepts to introduce while practicing writing real code all along the way. As I have demonstrated in this blog, teaching object-oriented abstractions can be made extremely intuitive, when taught in an iterative way.</p>

<h2 id="tldr">TL;DR</h2>
<p>Java is a complex programming language designed to support the advanced models and relationships present in industrial software. The platform offers built-in patterns for object classes and modern abstraction hierarchies, but beginning students aren’t necessarily ready to take it all in at once. Despite being one of the most widely-used programming paradigms in the software industry, in my observations of APCSA, OOP patterns are often where students struggle the most. By taking a step back and starting with a simplified version of the programming language, students can build a stronger foundation of program design and acquire their own intuition around code architecture decisions. Through repeated practice and exposure to new forms of abstractions, learners gain familiarity with the logical problem-solving process and learn powerful lessons that stretch far beyond the Java programming language. Coding best practices don’t need to be memorized from a textbook; they can be made intuitive and obvious through a logical progression of program complexity.</p>]]></content><author><name></name></author><summary type="html"><![CDATA[Code.org’s 2024 AP Computer Science A (APCSA) course explains in Unit 1, Lesson 3, that “In Java, a class is a programmer-defined blueprint from which objects are created. An object is an instance of a class.” On the very next slide, the instructors elaborate by saying “An instance of a class means that it is a copy of the class with its own unique set of information. Without the class, you can’t create an object!”]]></summary></entry><entry><title type="html">Object-Oriented Programming in Google Sheets</title><link href="http://localhost:4000/blog/spreadsheet-object-oriented-programming/" rel="alternate" type="text/html" title="Object-Oriented Programming in Google Sheets" /><published>2025-04-18T00:00:00-07:00</published><updated>2025-04-18T00:00:00-07:00</updated><id>http://localhost:4000/blog/spreadsheet-object-oriented-programming</id><content type="html" xml:base="http://localhost:4000/blog/spreadsheet-object-oriented-programming/"><![CDATA[<p>In <a href="https://max.xz.ax/blog/spreadsheet-functional-programming/">this previous post</a>, we defined abstractions that could be used to build boolean and number systems from pure functional programming, and then applied it to implement the factorial function. This pure system can become difficult to write with and often struggles to generalize complex data types, whereas languages such as Java and Python support more complex abstractions combining data and functionality as objects that can be interfaced with, composed, and inherited.</p>

<p>In this post, we will rederive all of our favorite object-oriented principles from scratch using the Google Sheets ecosystem. This means that we have to reïnvent method calls, constructors, inheritance, error propagation, dynamic dispatch, and even self references via a <code class="language-plaintext highlighter-rouge">this</code> keyword using only pure functions. While functional programming and object-oriented programming might seem fundamentally incompatible, the two paradigms at their core (as we will demonstrate) are actually very closely related.</p>

<h2 id="the-original-object-oriented-language">The Original Object-Oriented Language</h2>
<p>Smalltalk approached the problem of easy abstraction by introducing a brand-new programming paradigm, object-oriented programming, in the 1970s. However, unlike other (and later!) languages such as C++ which evolved from the notion of simply binding functions to existing struct pointer data types, Smalltalk presented object-oriented programming as a pure message-passing system, where everything is an object which is programmed to respond to different messages which implement its methods.</p>

<p>The idea of passing messages to objects is actually an extremely functional concept — you give the name of the method you want to invoke by simply using it as the parameter while applying the function. The idea of invoking a method on an object in Java syntax would be <code class="language-plaintext highlighter-rouge">rectangle.getWidth()</code>, but in Smalltalk, it would look simply like <code class="language-plaintext highlighter-rouge">rectangle getWidth</code>, borrowing the structure from Lisp function application. (Unfortunately, since Google Sheets requires the use of brackets, the best we can do is <code class="language-plaintext highlighter-rouge">rectangle("getWidth")</code>.) None of our code needs to have any side effects if we stick to a pure message-passing framework, which strictly binds data values to their implementations.</p>

<h2 id="number-abstractions">Number Abstractions</h2>
<p>To start, we can define some number objects which wrap their data in an interface that responds to messages such as <code class="language-plaintext highlighter-rouge">"*"</code>, <code class="language-plaintext highlighter-rouge">"+"</code>, which allow us to transparently define a contract rather than relying on built-in operators which can only work on built-in types:</p>

<pre><code class="language-excel">=LET(
    message_match, LAMBDA(expected, LAMBDA(actual,
        IFERROR((actual = expected), FALSE)
    )),
    handle_unknown_message, LAMBDA(message, "unknown value"),

    DEFINE_CLASS_NUMBER, "object wrapper for builtin numbers",
    make_number_bootstrap, LAMBDA(f, LAMBDA(raw,
        LAMBDA(message,
            IF(message_match("rawNumVal")(message),
                raw,
            IF(message_match("+")(message),
                LAMBDA(rhs, f(f)(raw + rhs("rawNumVal"))),
            IF(message_match("*")(message),
                LAMBDA(rhs, f(f)(raw * rhs("rawNumVal"))),
            IF(message_match("factorial")(message),
                f(f)(FACT(raw)),
            IF(message_match("log")(message),
                f(f)(LOG(raw)),
            IF(message_match("displayString")(message),
                CONCAT("", raw),
            handle_unknown_message(message) 
            ))))))
        )
    )),
    make_number, (make_number_bootstrap)(make_number_bootstrap),

    RETURN_VALUE, "the output of this program cell",
    make_number(3)("factorial")("factorial")("log")("displayString")
)
</code></pre>

<p>This demonstration of unary message chaining was taken directly from the <a href="https://en.wikipedia.org/wiki/Smalltalk#Expressions">Wikipedia page for Smalltalk</a>, and as expected, yields the number <code class="language-plaintext highlighter-rouge">2.85733...</code>. This format of applying functions by passing the right-hand-side message to the object yields a syntax that feels surprisingly imperative — in Java, this code might equivalently be written this way:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">new</span> <span class="nc">NumWrapper</span><span class="o">(</span><span class="mi">3</span><span class="o">).</span><span class="na">factorial</span><span class="o">().</span><span class="na">factorial</span><span class="o">().</span><span class="na">log</span><span class="o">().</span><span class="na">toString</span><span class="o">()</span>
</code></pre></div></div>

<p>We just used message passing notation to transform the infamously indirect functional programming style into an active, imperative sequence, with a well-defined order of operations. No nested parentheses required. When we need to, however, we can use parentheses to alter the default left-to-right parsing of operations, for example evaluating <code class="language-plaintext highlighter-rouge">3 + (4 * 5) = 23</code>:</p>

<pre><code class="language-excel">three, make_number(3),
four,  make_number(4),
five,  make_number(5),

RETURN_VALUE, "the output of this program cell",
(three)("+")((four)("*")(five))("displayString")
</code></pre>

<p>That’s right — this programming paradigm offers both the “subject-verb-object” notation offered by Java syntax and the intuitive mathematical expression form! Theoretically, we could continue implementing all of our data classes like this.</p>

<h2 id="self-context-references">Self-Context References</h2>
<p>Although our current system is technically sufficient for implementing all sorts of data records, we run into slight inconveniences when building more advanced behavior. Consider, for example, this rectangle implementation:</p>

<pre><code class="language-excel">DEFINE_CLASS_RECTANGLE, "rectangle with length and width",
make_rectangle, LAMBDA(l, w,
    LAMBDA(message,
        IF(message_match("length")(message),
            l,
        IF(message_match("width")(message),
            w,
        IF(message_match("area")(message),
            (l)(*)(w),
        IF(message_match("name")(message),
            "Rectangle",
        IF(message_match("description")(message),
            CONCATENATE(
                "Rectangle",
                " [length=", l("displayString"),
                ", width=", w("displayString"), "]",
                " has area=", (l)("*")(w)("displayString")
            ),
        handle_unknown_message(message) 
        )))))
    )
),
</code></pre>

<p>While this implementation is technically correct, we’ve had to duplicate all of our code in order to implement the “description” method. Not only is this inconvenient for large chunks of code, but it harms overall reusability when we need to change a certain method’s implementation. In Java, this issue is solved with a <code class="language-plaintext highlighter-rouge">this</code> keyword, which can be used for an object to access its own members.</p>

<p>We can take a similar approach by requiring the class declaration to pass in a lambda reference to its own implementation, which should respond to messages exactly the same way as the original object would’ve:</p>

<pre><code class="language-excel">DEFINE_CLASS_RECTANGLE, "rectangle with length and width",
rectangle_class, LAMBDA(this, LAMBDA(l, w,
    LAMBDA(message,
        IF(message_match("length")(message),
            l,
        IF(message_match("width")(message),
            w,
        IF(message_match("area")(message),
            (this("length"))("*")(this("width")),
        IF(message_match("name")(message),
            "Rectangle",
        IF(message_match("description")(message),
            CONCATENATE(
                this("name"),
                " [length=", this("length")("displayString"),
                ", width=", this("width")("displayString"), "]",
                " has area=", this("area")("displayString")
            ),
        handle_unknown_message(message) 
        )))))
    )
)),
new_rectangle_bootstrap, LAMBDA(f,
    LAMBDA(l, w, rectangle_class(LAMBDA(message, f(f)(l, w)(message))) (l, w))
),
new_rectangle, (new_rectangle_bootstrap)(new_rectangle_bootstrap),
</code></pre>

<p>Admittedly, this solution is a bit more complicated in a pure functional system (using combinatory logic and recursion rather than references), but this way, we don’t need to repeat any code, and objects can transparently interact with its own implementations, enabling more advanced abstractions.</p>

<h2 id="inheritance">Inheritance</h2>
<p>This structure for dynamic self-invocations using <code class="language-plaintext highlighter-rouge">this</code> actually paves the way for a new object-oriented abstraction. By simply overriding the <code class="language-plaintext highlighter-rouge">"name"</code> method to return <code class="language-plaintext highlighter-rouge">"Square"</code> instead of <code class="language-plaintext highlighter-rouge">"Rectangle"</code>, and wrapping the constructor, we can actually reuse all of the other functions our rectangle class already defined. In effect, since all objects are functions that handle method names, their implementations are themselves vtables. With the basic fall-through logic of if-else statements, we can implement methods which will take priority over the superclass’s functions. Similarly, since <code class="language-plaintext highlighter-rouge">this</code> is not <em>explicitly</em> required to be bound to the exact same identity class, we could pass the original vtable <code class="language-plaintext highlighter-rouge">this</code> from the subclass to the superclass, so that it also receives the overrides. This allows a class to be used both as-is, and as part of an inheritance hierarchy:</p>

<pre><code class="language-excel">DEFINE_CLASS_SQUARE, "subclass with a single side length parameter",
square_class, LAMBDA(this, LAMBDA(s,
    LAMBDA(message,
        IF(message_match("name")(message),
            "Square",
        rectangle_class(this)(s, s)(message)
        )
    )
)),
new_square_bootstrap, LAMBDA(f, LAMBDA(s, square_class(LAMBDA(message, f(f)(s)(message))) (s))),
new_square, (new_square_bootstrap)(new_square_bootstrap),
</code></pre>

<p>Just like Java code, our square implementation comes with an explicit call to the superclass, forwarding the single constructor parameter <code class="language-plaintext highlighter-rouge">s</code> to both the length and width parameters. This pattern can also be used to create abstract classes! I won’t include a demonstration here, but an abstract class works the exact same way — an abstract class invokes methods on <code class="language-plaintext highlighter-rouge">this</code> which it expects to be implemented by a subclass, accessed using dynamic dispatch.</p>

<h2 id="error-propagation">Error Propagation</h2>
<p>By this point, we’ve <strong>definitely</strong> implemented enough features to prove that object-oriented programming can exist even within a functional landscape. Just as a challenge to bolster the idea of control flow with message passing, let’s try to implement some error handling so that rather than returning a generic eval failure in Google Sheets, we can see a rough stack trace of what happened. We can use <code class="language-plaintext highlighter-rouge">handle_unknown_message</code> to generate a special object that accumulates traces of everything that happens to it as the result of an invalid method call gets used throughout a system:</p>
<pre><code class="language-excel">as_err_string, LAMBDA(message, fallback_message,
    IFERROR(
        CONCAT("", message),
        IFERROR(
            IF(is_nil(message),
                "[nil]",
                CONCAT(CONCAT("Object[ ", message("displayString")), " ]")
            ),
            fallback_message
        )
    )
),

next_error_message, LAMBDA(original_err_message, message,
    CONCAT(CONCAT(
        as_err_string(original_err_message, "[Invalid Trace]"),
        " | "),
        as_err_string(message, "[Unknown Argument]")
    )
),

DEFINE_CLASS_INVALID_METHOD_TRACE, "object that accumulates traces of invalid method calls",
make_invalid_method_trace_bootstrap, LAMBDA(f, LAMBDA(err_message,
    LAMBDA(message,
        IF(message_match("displayString")(message),
            CONCAT(CONCAT("InvalidMethodTrace[ Object | ", as_err_string(err_message, "Undefined")), " ]"),
            f(f)(next_error_message(err_message, message))
        )
    )
)),
make_invalid_method_trace, (make_invalid_method_trace_bootstrap)(make_invalid_method_trace_bootstrap),
</code></pre>

<p>We can make a similar object to track the usages of a “nil” value throughout the code. As an extreme example of mangled statements, this is the result my framework produces from evaluating this code:</p>
<pre><code class="language-excel">nil("cope")("invalidmethod")("+")((nil)("*")(nil))
    (make_rectangle(nil, nil)("nonExistentMethod"))("displayString")
</code></pre>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>NilTargetTrace[ [nil] | cope | invalidmethod | + | Object[ NilTargetTrace[ [nil] | * | [nil] ] ]
     | Object[ InvalidMethodTrace[ Object | nonExistentMethod ] ] ]
</code></pre></div></div>

<p>The overall code for this blog can be accessed <a href="https://gist.github.com/maxcai314/092a8220a5a36f6faf6a22e55976fbe5">here</a>.</p>

<h2 id="conclusion">Conclusion</h2>
<p>While functional programming may seem very unpermissive to other programming styles, and object-oriented programming may seem incompatible with more “pure” implementations, we demonstrated that all of our object-oriented ideas, such as method calls, dynamic dispatch, method overriding, inheritance are possible in the Google Sheets environment. We even introduced some helpful debugging functions that can help detect errors rather than ominously crashing. Overall, I don’t think that functional and object-oriented programming are necessarily opposites — the same design principles for clear thinking apply to any programming paradigm.</p>]]></content><author><name></name></author><summary type="html"><![CDATA[In this previous post, we defined abstractions that could be used to build boolean and number systems from pure functional programming, and then applied it to implement the factorial function. This pure system can become difficult to write with and often struggles to generalize complex data types, whereas languages such as Java and Python support more complex abstractions combining data and functionality as objects that can be interfaced with, composed, and inherited.]]></summary></entry></feed>