Uvicorn blog

CTFZone23 - Messenger.zone Writeup

Thu, 17 Aug 2023 05:00:00 +0700

Uvicorn blog https://uvicorn.github.io/posts/ctfzone23-messenger.zone/ -

Messenger.zone (4 solves)

At this ctf we took the third place

Actually Messenger.zone wasn’t difficult crypto, just difficult exploitation challenge. I don’t have any english words to describe exploitation, but in russian it sounds like “через три пизды”.

Introduction

Source code and task description:

We developed secure messenger based on signal specification. We also used only secure analogs of known algorithms. But our comminications has been compromised. An attacker was able to intercepted the message with flag (flag.pcapng). He knows that it was 8th message between clients and they had started chat about 1 min before intercepted message. Can he decrypt the flag?

We got 8th message between clients:

POST /send HTTP/1.1
Host: localhost:7777
User-Agent: python-requests/2.31.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Length: 531
Content-Type: application/json
{
"from_m": "B",
"to_m": "A",
"header": "10007557092155308918620703319005578742802155531542215927047486636897385017421026687658302411228112816312151375158019561914808361055666669789420151300043193;6987718573966126734765996266581284255829614508168823941052245373167186664467200288000376804417263861590165057549101655594459771412333345116018563168510146;1;0",
"message": "b3f3ca9e16fc1c33c86bb08e9ecee860462cdd6716dd2c32a6701b978c76035ec2973e2c6eac490d54f7918a0167179037459cbda47e4abcd5028a405d8374ada62fd23e3fcb29ab1e36e44ef7cfa438"
}
HTTP/1.1 201 Created
Server: TornadoServer/6.1
Content-Type: application/json; charset=UTF-8
Date: Sun, 16 Jul 2023 21:53:34 GMT
Content-Length: 33
{"message": "Save msg on server"}

we have basic client-server messenger and 2 clients A and B:

Client: B
1 - Change client
2 - Send msg
3 - Pull msgs
q - quit
>

Initial analysis

Server side is just database logic that is not interesting for us. If we look at client we can see 400 lines of code with some strange crypto GOSTs(russian state standard):

Scared? Me too. But with detailed review we can see that most of this code its just bullshit.

First thing we need to notice - usage of random.seed:

size=64
start_time = int(time.time())
random.seed(start_time)
def generate_bytes(n=size):
return random.randbytes(n)

If we set start_time to some constant and run, then we can see all generated parameters are the same. I ran 2 instances and sent messages “avtor_ti_cho_tvorish???” and “eto rofls” with start_time=1337: As you can see headers are the same, but encrypted messages aren’t.

Lets look at header generation:

class Server:
def store_message(self, from_m, to_m, header, message):
print('Save msg on server')
print('To:',to_m)
print('From:',from_m)
print('header:',header)
print('message:',message)
data = {'from_m':from_m, 'to_m':to_m, 'header': header_to_string(header), 'message':message.hex()}
print(data)
r = requests.post(server_url+send_api, json=data)
print(r.json())
return r.json()['message'] == 'Save msg on server'
# by XREFs on store_message we can find this:
class Client:
def __init__(self, ...):
...
self.RATCHET_dict = dict()
...
def send(self, m_to, msg, send=True):
if m_to not in self.RATCHET_dict.keys():
self.start_x3dh(m_to)
msg = pad2(msg, block_size)
AD = (self.name + m_to).encode('utf-8')
head, cipher = self.RATCHET_dict[m_to].RatchetEncrypt(msg, AD)
if send:
print('SEND', header_to_string(head).encode('utf-8'), cipher, AD)
self.server.store_message(self.name, m_to, head, cipher)
return True
# found by XREFs on RatchetEncrypt
class Ratchet:
def RatchetEncrypt(self, plaintext, AD):
self.CKs, mk = KDF_CK(self.CKs)
header = HEADER(self.DHs, self.PN, self.Ns)
self.Ns += 1 # Number of Sended messages
return header, ENCRYPT(mk, plaintext, CONCAT(AD, header))
# client.send -> server.store_message
# client.send(msg) -> RatchetEncrypt(msg) which uses header

On this moment we have pseudocode of send_msg function:

self.RATCHET_dict = {}
# doing some things with RATCHET_dict
def send_msg(msg,from_m, to_m):
head, cipher = self.RATCHET_dict[m_to].RatchetEncrypt(msg)
return {"header": header_to_string(head), "msg": cipher, ...}

Lets check header_to_string realization:

def header_to_string(header):
print([header.dh, header.pn, header.n])
return ';'.join([str(header.dh[0]), str(header.dh[1]), str(header.pn), str(header.n)])
def HEADER(dh_pair, pn, n):
a = Header()
a.dh = dh_pair[1]
a.pn = pn
a.n = n
return a
class Header(object):
pass

Lets look at header’s format 376876138...04158;666457945261308...71871794;0;2 By playing with code we can see that last two parameters are count of received and sent messages. First two are more interesting. As we saw

class Ratchet:
def RatchetEncrypt(self, plaintext, AD):
self.CKs, mk = KDF_CK(self.CKs)
header = HEADER(self.DHs, self.PN, self.Ns)
self.Ns += 1
return header, ENCRYPT(mk, plaintext, CONCAT(AD, header))

This means header_to_string format looks like "self.DHs[0];self.DHs[1];to_m_count;from_m_count". I found two places of self.DHs generation:

in _DHRatchet which used in RatchetDecrypt necessary for pulling messages (we’ll come back to that later.)

class Ratchet:
def _DHRatchet(self, header):
self.PN = self.Ns
self.Ns = 0
self.Nr = 0
self.DHr = header.dh
self.RK, self.CKr = KDF_RK(self.RK, DH(self.DHs, self.DHr))
self.DHs = GENERATE_DH()
self.RK, self.CKs = KDF_RK(self.RK, DH(self.DHs, self.DHr))

in start_x3dh which used in first client.send call (actually self.DHs modifying in receive_x3dh but it also uses GENERATE_DH algo)

class Client:
def start_x3dh(self, m_to):
...
DHs_A=GENERATE_DH()
RK_A, CKs_A = KDF_RK(SK, DH(DHs_A, PK_B))
self.RATCHET_dict[m_to] = Ratchet(DHs=DHs_A, DHr=PK_B, RK=RK_A, CKs=CKs_A)
def send(self, m_to, msg, send=True):
if m_to not in self.RATCHET_dict.keys():
self.start_x3dh(m_to)
...

Look at GENERATE_DH function:

def GENERATE_DH():
prv_key = gost3410.prv_unmarshal(generate_bytes(64))
pub_key = gost3410.public_key(CURVE, prv_key)
return (prv_key, pub_key)

Omg, it uses generate_bytes, which uses random.randbytes. This is why we got same header with fixed seed.

Let’s hook generate_bytes

start_time = 1337 #int(time.time())
random.seed(start_time)
size=64
MSG_NUM = 1
def generate_bytes(n=size):
global MSG_NUM
rand = random.randbytes(n)
print('MSG_NUM CALLED', MSG_NUM)
print('GENERATED rand', debug_print_dh(rand))
MSG_NUM+=1
return rand
def debug_print_dh(rand):
prv_key = gost3410.prv_unmarshal(rand)
pub_key = gost3410.public_key(CURVE, prv_key)
return pub_key[0]

yeah, that’s correct. At this moment we know that all parameters generated with random module and we know algo which used for that.

Second attempt to recover random seed (Success)

From task description we know He knows that it was 8th message between clients and they had started chat about 1 min before intercepted message. Ok, Date: Sun, 16 Jul 2023 21:53:34 GMT -> unix timestamp 1689544414. Lets bruteforce time and compare our GENERATE_DH() results with original header:

from pygost import gost3410
import random
search = "10007557092155308918620703319005578742802155531542215927047486636897385017421026687658302411228112816312151375158019561914808361055666669789420151300043193"
start_time = 1689544414 # int(time.time())
random.seed(start_time)
CURVE = gost3410.CURVES["id-tc26-gost-3410-2012-512-paramSetA"]
def generate_bytes(n=64):
return random.randbytes(n)
def GENERATE_DH():
prv_key = gost3410.prv_unmarshal(generate_bytes(64))
pub_key = gost3410.public_key(CURVE, prv_key)
return (prv_key, pub_key)
for j in range(200):
t = start_time - j
print(j)
random.seed(t)
arr = [str((GENERATE_DH()[1])[0]) for i in range(20)] # pub_key[0]
if search in arr:
print("SEED RECOVERED", t)
print("MSG_NUM CALLED", arr.index(search)+1) # because MSG_NUM beggining from 1
break

and we see

64
65
66
SEED RECOVERED 1689544348
MSG_NUM CALLED 10

then we have this GENERATE_DH, in which we need

[
'9264589598917214570356576028637286965316409427254818227493078254039255165721359928330096074586822045454591272668453788514652534124577717080803397323837753',
'5882838151079707917212895213006119673676890363161552333914448586032078639206645580866944258673556248686928883063120090222874182146824264129454879986035719',
'6356725936561061752235179817746125611162703105753208009200752643649999618267446822075106985582287873377398980657379412925058956059861218407756501430626927',
'2887626599271120182764806265394113921448284156247717458149074760790256212900772489341554363321357077449592555181818332405145513141515880148664404651010552',
'2216900006373410088238948423035178444110439136989098412941526318911086854342633422828594482332725423331627448229960406207026042091000046928246514259533395',
'2065978910820990851915215841599391978415392480535782437522299103928746742945880018832732484334365811051266269087678987390370004457623474476295627178062519',
'12580783417477889603032614422211297881357618632629370530972814208266292685499754494342954304811493970406677227245281245667848862501108323925026691208119146',
'11118815991327334922664302532246147692704095619978833554028959589828597949540394350413685937115099333628326943518745314022450906666032282699751140012678971',
'649690232490058282951690312227812912664432393914555704120385988873130546340547752604856744054079240351159264632950984887792529728373140985426012556105651',
# original header:
'10007557092155308918620703319005578742802155531542215927047486636897385017421026687658302411228112816312151375158019561914808361055666669789420151300043193'
]

Repeat traffic

Since we know all encryption keys, it will be easiest just repeat the same actions that the clients performed and decrypt the 8th message.

Let’s patch encryption function by adding flag decryption:

def RatchetEncrypt(self, plaintext, AD):
self.CKs, mk = KDF_CK(self.CKs)
header = HEADER(self.DHs, self.PN, self.Ns)
self.Ns += 1
enc = ENCRYPT(mk, plaintext, CONCAT(AD, header))
decrypted_text = DECRYPT(mk, enc, CONCAT(AD, header))
# print('MK = ', mk)
print('decrypted: ', decrypted_text)
ff = unhexlify('b3f3ca9e16fc1c33c86bb08e9ecee860462cdd6716dd2c32a6701b978c76035ec2973e2c6eac490d54f7918a0167179037459cbda47e4abcd5028a405d8374ada62fd23e3fcb29ab1e36e44ef7cfa438')
print('FLAG', DECRYPT(mk, ff, CONCAT(AD, header))) # try to decrypt encrypted flag
return header, enc

But if we run client.py with correct seed, we can see this is not original header

But why this header is not original? Why can’t we make some more calls GENERATE_DH and then get correct header? The reason for this is that when sending multiple messages, the header is fixed after the first one.

At this time we need to remember that we did not used pull messages option yet.

When i tried use this option During CTF in most cases it failed

I thought we need to send msg from B at the end. For this reason we can only connect, send msg from A, pull messages from A. But in sum it gives 4+2+1=7, not 9.

I removed unpad function and it works well this time. But i can’t understand why author left bug in the source code, and hence i thought that we should not use this function.

Get back to the task. As we remember we have to_m_count and from_m_count fields in header.

By playing with client we can see that in original header to_m_count=2 (A->B) and from_m_count=1 or 0 (B->A). But as we’ll see later, this was another bug lol.

Time to play with client.py again (here we go again). I guessed that if we send 2 1 3 (send msg + change client + pull msg) two times, then we can generate new header for client

Why it works? As we saw before, self.DHs changes here, and it is used when constructing the header

 def RatchetDecrypt(self, header, ciphertext, AD):
plaintext = self._TrySkippedMessageKeys(header, ciphertext, AD)
if plaintext != None:
return plaintext
if header.dh != self.DHr:
self._SkipMessageKeys(header.pn)
self._DHRatchet(header)
self._SkipMessageKeys(header.n)
self.CKr, mk = KDF_CK(self.CKr)
self.Nr += 1
return DECRYPT(mk, ciphertext, CONCAT(AD, header))
def _DHRatchet(self, header):
self.PN = self.Ns
self.Ns = 0
self.Nr = 0
self.DHr = header.dh
self.RK, self.CKr = KDF_RK(self.RK, DH(self.DHs, self.DHr))
print('HERE WE GO')
self.DHs = GENERATE_DH()
self.RK, self.CKs = KDF_RK(self.RK, DH(self.DHs, self.DHr))

if we run we can see HERE WE GO when we pull messages.

Final payload: 213 213 213 213 2.

Epilogue

Task author told me that it was really Signal specification:

-btw, did it really use the Signal specification?

-Yeah you can look at it here. It was interesting to write it from scratch.))

https://signal.org/docs/

The first attempt to recover random seed (Fail)

On this step i lost more than 6 hours. Since pull messages options was broken, I thought to use only send msg. And since only 8 messages are needed, it was easier to bruteforce all the combinations of sending them A->B or B->A (it need only 2^8 runs, but one run is ~5 seconds) and then we would get the right one. Of course it didn’t work

You can see this shit here

- https://uvicorn.github.io/posts/ctfzone23-messenger.zone/ -

ImaginaryCTF 2022 reverse writeups

Wed, 20 Jul 2022 19:14:22 +0700

Uvicorn blog https://uvicorn.github.io/posts/ictf2022_rev/ -

English version - https://uvicorn.github.io/ictf2022_rev_en/

Вступление

На прошедшем Imaginaryctf мы заняли 7 место, закрыв весь реверс.

Небольшое описание задач:

The House Always Wins - glibc random prediction
Jormungandr - python virual machine
One Liner Revenge - python labyrinth
xobeert - another python virual machine
wired - avr rng

The House Always Wins

Дан бинарь следующего содержания

unsigned int get_rand()
{
FILE *stream; // [rsp+8h] [rbp-18h]
 int j; // [rsp+14h] [rbp-Ch]
 int i; // [rsp+18h] [rbp-8h]
 unsigned int seed; // [rsp+1Ch] [rbp-4h]

rand();
if ( !init )
{
init = 1;
seed = 0;
stream = fopen("/dev/urandom", "r");
for ( i = 0; i <= 7; ++i )
{
seed += fgetc(stream);
if ( i != 7 )
seed <<= 8;
}
fclose(stream);
srand(seed);
for ( j = 0; j < rand() >> 15; ++j )
rand();
}
return rand() >> 15; // 17 bit
}
int main(int argc, const char **argv, const char **envp)
{
char v3[59]; // [rsp+0h] [rbp-70h] BYREF
 char aswer; // [rsp+3Bh] [rbp-35h] BYREF
 unsigned int stavka; // [rsp+3Ch] [rbp-34h] BYREF
 FILE *v6; // [rsp+40h] [rbp-30h]
 int rand2; // [rsp+4Ch] [rbp-24h]
 unsigned int v8; // [rsp+50h] [rbp-20h]
 unsigned int v9; // [rsp+54h] [rbp-1Ch]
 float v10; // [rsp+58h] [rbp-18h]
 float v11; // [rsp+5Ch] [rbp-14h]
 int rand; // [rsp+60h] [rbp-10h]
 unsigned int prize; // [rsp+64h] [rbp-Ch]
 int is_win; // [rsp+68h] [rbp-8h]
 unsigned int dollar; // [rsp+6Ch] [rbp-4h]

puts("You start with $100. Get 1 billion dollars, and we'll give you the flag.");
puts("Run out of money, and we kick you out of the casino.\n");
puts("Are you feeling lucky?\n");
dollar = 100;
while ( 1 )
{
rand = get_rand();
printf("Current money: %u\n", dollar);
if ( dollar > 1000000000 )
break;
puts("How much are you betting? (minimum bet $5)");
printf(">>> ");
__isoc99_scanf("%u%c", &stavka, &dead);
if ( stavka <= 4 || dollar < stavka )
{
puts("You can't bet that!");
puts("Get out of here, and come back with some real money!");
exit(1);
}
dollar -= stavka;
printf("The first number is %d.\n\n", (unsigned int)rand);
v11 = (float)((float)rand + 1.0) / 65536.0; / (r+1)/65536
v10 = 1.0 - v11;
v9 = (int)((double)(int)stavka * 0.99 / v11);
v8 = (int)((double)(int)stavka * 0.99 / (float)(1.0 - v11));
printf(
"Odds of higher: %.2f\tPayout of higher: %u\n",
(float)(100.0 * v10),
(unsigned int)(int)((double)(int)stavka * 0.99 / v10));
printf("Odds of lower: %.2f\tPayout of lower: %u\n\n", (float)(100.0 * v11), v9);
puts("Do you think the next number will be:");
puts("1) Higher");
puts("2) Lower\n");
puts("Remember, the house wins ties!");
printf(">>> ");
__isoc99_scanf("%c%c", &aswer, &dead);
rand2 = get_rand();
is_win = 0;
prize = 0;
printf("The second number is %d!\n", (unsigned int)rand2);
if ( aswer == '1' && rand < rand2 )
{
is_win = 1;
prize = v8;
}
else if ( aswer == '2' && rand > rand2 )
{
is_win = 1;
prize = v9;
}
if ( is_win )
{
printf("Congrats! You won %u dollars!\n\n", prize);
dollar += prize;
}
else
{
puts("You lost... Better luck next time!\n");
}
}
v6 = fopen("./flag.txt", "r");
__isoc99_fscanf(v6, "%s", v3);
printf("How'd you beat the house? %s\n", v3);
exit(0);
}

Нам дают результат get_rand и просят по нему угадать будет ли больше или меньше результат вызова следующего get_rand. Так как srand вызывается один раз при первом запуске get_rand , то функция приобретает вид

unsigned int get_rand()
{
rand();
return rand() >> 15; // 17 bit
}

В этой статье хорошо описывается рандом в glibc и как его предиктить:

Так как за один ход rand вызывается 4 раза - [0,n1,0,n2] (где n1 нам известен, 0 - нет, n2 нам нужно угадать), то выражение принимает вид o[i] = o[i-31-3] + o[i-31-31] + o[i-3-3] + o[i-3-31] = o[i-62] + o[i-9] + 2*o[i-34], следовательно i>=62, то есть нам нужно 62//4=16 раундов чтобы начать выигрывать. Нам понадобится примерно log(1000000000, 2)~=30 запросов чтобы достать флаг, то eсть можно не заморачиваться над оптимизацией всего этого.

Для начала затестим алгоритм предсказания рандома на локалке:

from os import urandom
from ctypes import CDLL
libc = CDLL("libc.so.6")
def init():
seed = int.from_bytes(urandom(8), "big")
libc.srand(seed)
for _ in range(libc.rand() >> 15):
libc.rand()
def get_random():
libc.rand()
return libc.rand() >> 15
init()
o = []
for i in range(50):
o.append(-1)
libc.rand()
o.append(libc.rand() >> 15)
get_mod = lambda x: ((x << 15) % 2147483647) >> 15
for i in range(63,100,4):
print(o[i] - get_mod(o[i - 62] + o[i - 6] + o[i - 34] * 2))

Работает! Разница между предсказанным и реальным значением меньше 4, что нам подходит, так как настолько точного результата и нам не надо. Финальный код решения:

from pwn import remote, context
context.log_level = "debug"
r = remote("the-house-always-wins.chal.imaginaryctf.org", 1337)
r.recvlines(6)
o = []
def bet():
current_money = int(r.recvline().split()[-1])
r.recvline()
r.recv(4)
if len(o) >= 31:
r.sendline(str(current_money).encode())
o.append(int(r.recvline().split()[-1][:-1]))
predict = (((o[-17] * 2 + o[-31] + o[-3]) << 15) % 2147483647) >> 15
if predict > o[-1]:
status = b"1"
else:
status = b"2"
else:
r.sendline(b"5")
o.append(int(r.recvline().split()[-1][:-1]))
status = b"1"
r.recvlines(9)
r.recv(4)
r.sendline(status)
o.append(int(r.recvline().split()[-1][:-1]))
r.recvlines(2)
for i in range(200):
bet()
# ictf{if_the_house_isn't_using_cryptographically_secure_PRNG_the_house_deserves_to_lose}

Здесь диллер дурак,
Ёр буллшит фак!
Порядок другоооооой!

Ты где их береееееешь?
Ты дегенераааааааат!
Порядок у карт
В киосках был взяят,
Ты че, долбоеб?

Jormungandr

Нам дана следующая стековая виртуальная машина на питоне:

find=lambda v:(i:=0,len([(i:=i+1)for(c)in(iter(lambda:text[i].startswith(v), True))]))[1]
def p(N):
Enter =1
prime=2# flag
while Enter<N:
prime+=(1+prime%2)
s =prime%N
for( hile)in range(3, prime,int( hex (2),16)):# salt
if( prime%hile)==0 : break
j__f = prime
else:
Enter+=1
return(prime)
text=open( __file__).read().split()
try:
while False:0
while 1:
{**{chr(i):lambda:0for(i)in range(32,127)},**{
'l':lambda:text.insert(find(text[0][1:])+1,input()),
's':lambda:text.append(text.pop(0)),
'd':lambda:(text.pop(),text.pop()),
'w':lambda:(text.pop(find(text[0][1:])+1),text.insert(find(text[0][1:])+1,text[1])),
'i':lambda:(b:=text[1],text.pop(1),text.insert(1,('{:0%dx}'%(len(b))).format((int(b[:len(b)],16)*(3**p(len(text)))+p(len(text)))%16**(len(b)))),text.append(text.pop(0))),# lit
'q':lambda:[text.pop()for( d)in iter(int,1)],
'j':lambda:( chile :=text[0][1:],[text.append(text.pop(0))for(i)in(iter(lambda:text[0].startswith(chile),True))]),'p':lambda:print(text[1],end=' j__f '*0),# kite ce10e59f40c8d954d9dad1ea81811a834d26580107149d16c3a769198fb158f0cb0e33dbd98f8dc8bb874105974b71719790b23c971736e8fe8ec88e8695 p
'not' :lambda: print(' bad... '),
'c':lambda:text.append(text.pop(0))if text[find(text[0][1:])+1][1]==text[1][0]else[text.append(text.pop(0))for(i)in' q'],
'k':lambda:text.append(text.pop(0))if text[find(text[0][1:])+1]==text[1]else[text.append(text.pop(0))for(i)in' q'],
}
}[text[0][0]]()
text.append(text.pop(0))
except:
pass

Файл читает сам себя и, видимо, на этом основывается байткод для вм:

text=open(__file__).read().split()
...
text.insert(find(text[0][1:])

Эта проблема легко решается созданием нового файла и смены __file__ на original.py

text явно является стеком нашей машины, а словарь {'l':lambda:..., 's': lambda: ...,} похож на обработчики инструкций. Напишем для них дисассемблер:

def disp(opc): # disp(text[0][0])
if opc == 'l':
print(f"text[{find(text[0][1:])+1}] = input()")
elif opc == 's':
print('POPINS # {text[0]}')
elif opc == 'd':
print('POP 2')
elif opc == 'w':
print(f'POP text[{find(text[0][1:])+1}] && text[{find(text[0][1:])+1}] = text[1] # {text[1]}')
elif opc == 'i':
b = text[1]
pp = p(len(text)-1) # I spent 6 hours searching for an error in this opcode logger.
res = (int(b,16)*(3**pp)+pp) % (16**(len(b))) # b*3**p + p mod 16**len(b)
print(f'text[1] = ({int(b,16)} * {(3**pp)} + {pp}) % ({16**(len(b))}) = {res} && POPINS # pp = {pp}')
elif opc == 'q':
print(f'text = [] # QUIT')
elif opc == 'j':
print(f"POPINS while (text[0] not start '{text[0][1:]}' )")
elif opc == 'p':
print(f"Print {text[1]}")
elif opc == 'c':
print(f'if text[{find(text[0][1:])+1}][1] ({text[find(text[0][1:])+1][1]}) == text[1][0] ({text[1][0]}) then POPINS else POPINS 2')
elif opc == 'k':
print(f'if text[{find(text[0][1:])+1}] ({text[find(text[0][1:])+1]}) == text[1] ({text[1]}) then POPINS else POPINS 2
print(f"POPINS")

Небольшой комментарий к инструкциям:

l - считывает из ввода и кладет в стек
s - POPINS (POP & INSERT), то есть снимает нижний элемент стека и пушит его на верх( проще говоря, сдвигает стек на 1 элемент влево)
d - удаляет 2 верних элементов стека
w - удаляет элемент по индексу find(text[0][1:])+1, а затем кладет по этому же индексу text[1] # если find(text[0][1:])+1 == 0, то это будет find(...) вернет уже новый индекс
q - удаляет все элементы из стека, что вызывает exception, из-за чего работа машины прерывается
j - сдвигает стек влево пока text[i] не начинается с text[0][1:]
p - выводит text[1] в консоль
c, k - какие-то сравнения
i - пушит на верх стека b*3**p + p mod 16**len(b) (где b=text[1], pp = p(len(text)-1), функция p выдает n-ное простое число)
После этих и любых других опкодов вм сделает POPINS

Итак, запускаем наш дисассемблер, вводя a:

Как видим, в обработчик i передается int(input(), 16), а затем результат функции идет дальше, пока не доходит до обработчика k (сравнения), в котором сравнивает результаты с некой константой и в зависимости от этого выдает bad... или not bad...:

В итоге имеем уравнение вида ((b * 3^p1 + p2) * 3^p3 + p4) * ... == 0xce10e... mod m Решаем его при помощи sage и забираем флаг

m = 16**124 # легко угадать, смотря на длину сравниваемой константы ~= log(0xce10..., 16)
n = Mod(0xce10e59f40c8d954d9dad1ea81811a834d26580107149d16c3a769198fb158f0cb0e33dbd98f8dc8bb874105974b71719790b23c971736e8fe8ec88e8695,m)
n -= 277
n /= 1454077510067338869372316944847370699315973030897976908309312512336980481738317971337352174999857054574561953999845406588476984323763
n -= 283
n /= 1060022504839090035772419052793733239801344339524625166157488821493658771187233801104929735574895792784855664465887301402999721572023227
n -= 307
n /= 299381664701132778293030021884627147018656102332612973563127175701392996827190480510641050862491714816103809471587812971633152346558576658975844187
n -= 313
n /= 218249233567125795375618885953893190176600298600474857727519711086315494687021860292257326078756460100939677104787515656320568060641202384393390412323
n -= 331
n /= 84554224792451089968936207473892531191988484041341985013001115226199070159922911068116016183264280284215039063438883556666870418811396281309653281910088285947
n -= 347
n /= 3639782124011924976038695589926766574205325707740600894440840379831043263633626934257002144272462342660405490567954921015326460861727327341974159433117917530528729787
print(long_to_bytes(n)) # ictf{welcome_to_the_flag_at_the_end_of_the_universe!_8762a9ab}

xobeert

Нам дан дамп ast (абстрактное синтаксическое дерево) проги на питоне. Пытаемся распарсить его при помощи ast.unparse (эту чудесную функцию ввели в 3.9), но получаем AttributeError: 'Assign' object has no attribute 'lineno', что фиксится при помощи ast.fix_missing_locations:

from ast import *
tree = eval(open('boxast.txt').read()[1:-3])
tree = ast.fix_missing_locations(tree)
decompiled = unparse(tree)
open('out.py', 'w').write(decompiled)

Получаем еще один адовый обфусцированный код (привет one liner):

Как видим, все завязано на декораторах. Легче всего понять что это на примере функцию main из этой задачи, которую можно переписать следующим образом:

def main():
pass
main = print(fffffffffffffffffffffffffffffffffff(main))

Так вот, начнем деобфускацию декораторов функции main:

первым декоратором на очереди будет функция, стоящая перед bytes.decode на скрине выше:

Как видим, эта функцию вызывает какой-то метод из random, заведем функцию log, чтобы посмотреть что находится в bytes.decode перед вызовом random.__dict__.get:

def log(string):
print(string)
return string

хорошо, это функция random.seed.

поднимаемся по функции main выше

Функция берет длину нашего ввода, обзовем ее get_input_len , а функцию с получением ввода get_input

поднимаемся еще выше

с помощью log выясняем, что это random.randbytes

идем дальше

Эта функция ксорит наш ввод с массивом y, который передается в нее, пока обзовем ее xor_with_input

финал

Последняя функция сравнивает переданное ей значение с неким константным массивом, который мы можем вытащить при помощи обычного принта ([123, 250, 94, 95, 121, 195, 249, 70, 71, 59, 137, 59, 5, 67, 65, 226, 17, 160, 205, 100, 251, 169, 50, 118, 184, 177, 1, 175, 133]), а затем пишет wrong или correct. Обзовем функцию cmp_with_some_array.

Итак, у нас есть деобфусцированный main:

С помощью log вытаскиваем изначальный сид для рандома - debdbeef_or_sth , а дальше все довольно просто:

import random
cmp_arr = [123, 250, 94, 95, 121, 195, 249, 70, 71, 59, 137, 59, 5, 67, 65, 226, 17, 160, 205, 100, 251, 169, 50, 118, 184, 177, 1, 175, 133]
random.seed('debdbeef_or_sth')
seed2 = random.randbytes(len(cmp_arr)) # так как ввод должен сравниваться с массивом равной длины 
random.seed(seed2)
print(xor(random.randbytes(len(cmp_arr)), cmp_arr)) # ictf{wh0_n33d5_c4ll5_4nyw4y?}

P.S. этот таск был сломан и оргам удалось починить его только со второй попытки

One Liner Revenge

Нам дают файл следующего содержания (дальше идут еще лямбды):

Я немного опешил. После jormungandr вообще не хотелось это решать, но все таки удалось себя убедить, что это сон и нужно лишь немного деобфусцировать код и все будет хорошо. Итак, первые строчки кода превращаются в

# globals().__setitem__(chr(0x67),globals())
g = globals()
# g.__setitem__(chr(0x74),lambda*a:bytes.fromhex('{:x}'.format(a[0])).decode())
t = lambda*a: bytes.fromhex('{:x}'.format(a[0])).decode()

Дальше по коду мы видим, что t расшифровывает строчки. Заменяем ее вызовы на расшифрованные строчки, пытаясь привести код к человеческому виду:

Это все таки лучше изначального ада, но все еще ужасно. На 7 строчке видим проверку на то, что файл не патчили (как ее обходить, думаю, и без меня понятно). Можно было бы и дальше деобфусцировать этот кринж, но мне в голову пришла идея получше. Что если протрейсить исполнение огромного массива лямбд и уже ориентироваться по ним что делать дальше? Итак, заводим функцию aboba , которая будет нам с этим помогать, и пробуем ее вставить в лямбду:

def aboba(a, *equations):
print(a, equations)
return equations
...
# *(lambda*a:(51*a[10]+56*a[0]+...), ...) -> *(lambda*a:aboba(a, 51*a[10]+56*a[0]+...)

Как видим, в лямбды передается наш ввод, а на выходе получаем результат исполнения 4 уравнений. Я сразу попытался сделать так, чтобы все уравнения выдали мне True, но это не сработало. Тогда пробуем посмотреть в каком порядке лямбды исполняются:

def aboba(a, num, *equations):
print(a, num, equations)
return equations
...
# *(lambda*a:(51*a[10]+56*a[0]+...), ...) -> *(lambda*a:aboba(a,1, 51*a[10]+56*a[0]+...)

То есть прога выходит после двух лямбд. Стоп, а что если подменить (False,False,False,False), допустим, на (2,2,2,2) ? Прога выкидывает ошибку ValueError: invalid literal for int() with base 2: '2222', по которой мы находим ее виновника:

Я предположил, что для перехода к следующей паре уравнений мне необходимо найти нужную пару результатов лямбд, то есть перебрать 2^8=256(в результате лямбды может быть 4 значения true или false) значений. Для этого пришлось немного извернуться, добавив в код новый инпут и убрав предыдующий:

i2 = list(map(int, input().split())) # вводим лишний 0, который преобразуется в (0,0,0,0) и (0,0,0,0), чтобы увидеть прошли ли мы на 2 следующих лямбды
print(i2)
def to_bits(i):
return [int(j) for j in '{0:08b}'.format(int(i))]
bits = []
for i in i2:bits.extend(to_bits(i))
ctr = 4
def aboba(a, num, *equations):
global ctr
print(a, num, equations)
res = bits[ctr-4:ctr]
ctr+=4
return res

И запускаем все это при помощи костылей:

for i1 in range(256):
os.system(f"echo '{i1} {0}' | python3.9 ./ff2.py") # 0 это и есть одно лишнее значение

18 (а точнее 0, 0, 0, 1 и 0, 0, 1, 0) и является нужным результатом первой пары лямбды, чтобы перейти к исполнению второй (лабиринт какой-то). Подобным образом дампим нужные значения оставшихся пар лямбд(я это сделал руками, нужно было всего 8 запросов) - [18, 52, 86, 120, 154, 188, 222, 240]

Ура, путь в лабиринте лямбд найден, осталось только сделать так, чтобы наш ввод позволил нам пройти его. Итоговый скрипт для решения:

import z3
def to_bits(i):
return [int(j) for j in '{0:08b}'.format(int(i))]
ll = (lambda *a: 51*a[10]+56*a[0]+... , lambda *a: ...)
sp = [16, 1, 15, 2, 14, 3, 13, 4, 12, 5, 11, 6, 10, 7, 9, 8]
lambd_results = [18, 52, 86, 120, 154, 188, 222, 240]
a = [z3.Int(f"flag[{i}]") for i in range(24)]
cons = []
for lambd_res in lambd_results:
t = to_bits(lambd_res)
cons.append(t[:4])
cons.append(t[4:])
s = z3.Solver()
for i in range(16):
l_result = ll[sp[i]-1](*a)
for j in range(4):
if cons[i][j] == 1:
s.add(l_result[j])
else:
s.add(not l_result[j])
for k in range(24):
s.add(a[k] <= 126)
s.add(a[k] >= 32)
print(s.check())
res = s.model()
flag = ""
for letter in a:
flag += chr(res.eval(letter).as_long())
print(flag)
# sat
# ictf{0n3l1n3is5uperior!}

wired

Нам дают прошивку под ардуино и видосик с тем, как плата выдает нам флаг, зашифрованный при помощи hardware rng module. Сам видосик.

Находим хороший райтап с подробным гайдом по реверсу avr, из которого мы забираем себе

модуль процессора ATmega328 для иды
плагин diaphora, с помощью которого мы можем облегчить себе жизнь, найдя дифф между скомпиленным нами бинарем, содержащим встроенные функции, и нужным бинарем. Это нужно, чтобы восстановить имена функций, в нашем случае это восстановятся только 3 функции:

Смотря на видосик и замеряя задержку, которая создается при помощи delay, между порядком загорания светодиодов понимаем, что она примерно равна 200 миллисекундам, что соответствует следующему циклу:

Отсюда извлекаем порядок битов (Наскальные рисунки древних шизов в моем исполнении):

Алгоритм шифрования:

Генерируем random stream (на самом деле он сразу ксорит его с флагом, но для простоты повествования опущу это)

Видим цикл, в котором прога ждет ввода аналогового сигнал (вольтажа) и преобразует его в десятибитное число, которое разбивается на регистры r24 и r25.

Выясняем, что это seed для нашего RNG. Так как он занимает всего 10 бит, то нам понадобится 2^10=1024 попыток чтобы угадать его, то есть его можно сбрутить.

Алгоритм генерации rng stream находится выше, втупую переписываем его на си, добавиви брут seed.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

unsigned char orig[] = {????}; // вывод программы

int check_rng(unsigned char r24, unsigned char r25) {
unsigned char work[21];
memcpy(work, orig, 21);
for(int i = 0; i < 20; i ++) {
unsigned char *c = &work[i];
*c = *c ^ r24;
unsigned char r18 = r24;
unsigned char r19 = r25;
unsigned int r25r24 = (r25 << 8) | r24;
r25r24 = r25r24 >> 1;
r25 = (r25r24 & 0xFF00) >> 8;
r24 = (r25r24 & 0xFF);
if (r18 & 1) {
r25 ^= 0xAD;
}
}
write(1, work, 20);
}
int main() {
for(int seed = 0; seed < 1024; seed++) {
unsigned char r24 = (seed & 0xFF00) >> 8;
unsigned char r25 = (seed & 0xFF);
check_rng(r25, r24);
}
}

ксорим флаг по адресу 0x100 с rng stream
выводим его на светодиоды, некоторые из которых инвертированы

Если говорить совсем просто, то при попадании на ветку с sbrc у нас инвертируется бит, при попадании на sbrs - нет. Получаем маску, которая обозначает светодиоды, на которых биты инвертированы - 0b10011010

Выводим формулу получения флага: flag[i] ^ rng[i] ^ invert_mask = out[i] => flag[i] = rng[i] ^ 0b10011010 ^ out[i]

По видосику определяем массив out и сразу накладываем на него маску.

a = [0b01010110, 0b10101011, 0b01000111, 0b10101000, 0b11001011, 0b01111000, 0b00110101, 0b00010110, 0b10011010, 0b11000111, 0b01011001, 0b00100110, 0b10010011, 0b01001110, 0b10011100, 0b00001111, 0b11111101, 0b10000011, 0b01101101, 0b00101101]
out = list(map(lambda o: o ^ 0b10011010, a)) # [204, 49, 221, 50, 81, 226, 175, 140, 0, 93, 195, 188, 9, 212, 6, 149, 103, 25, 247, 183]

Итоговый код решения:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

unsigned char orig[] = {204, 49, 221, 50, 81, 226, 175, 140, 0, 93, 195, 188, 9, 212, 6, 149, 103, 25, 247, 183, 0};
int check_rng(unsigned char r24, unsigned char r25) {
unsigned char work[21];
memcpy(work, orig, 21);
for(int i = 0; i < 20; i ++) {
unsigned char *c = &work[i];
*c = *c ^ r24;
unsigned char r18 = r24;
unsigned char r19 = r25;
unsigned int r25r24 = (r25 << 8) | r24;
r25r24 = r25r24 >> 1;
r25 = (r25r24 & 0xFF00) >> 8;
r24 = (r25r24 & 0xFF);
if (r18 & 1) {
r25 ^= 0xAD;
}
}
write(1, work, 20);
}
int main() {
for(int i = 0; i < 1024; i ++) {
unsigned char r24 = (i & 0xFF00) >> 8;
unsigned char r25 = (i & 0xFF);
check_rng(r25, r24);
}
}

Запускаем:

./a.out | grep -oaiP 'ictf{.*?}'
ictf{weird_rng_912b}

- https://uvicorn.github.io/posts/ictf2022_rev/ -

Инъекция в процесс для обхода Nanomites

Sun, 29 May 2022 15:54:21 +0700

Uvicorn blog https://uvicorn.github.io/posts/nanomites/ -

Вступление

После прочтения нескольких райтапов на реверс Nanomites ( метод антиотладки, при котором родительский процесс запускает дочерний, с которым постоянно обменивается информацией, что и затрудняет дебаг) понял, что проще всего с этим бороться при помощи инъекции в процесс с переопределением функции ptrace(мб не только ее). Проще всего это реализовать при помощи загрузки своей библиотеки через LD_PRELOAD.

Собсна, сами райтапы:

Пример инъекции в процесс через LD_PRELOAD

Код в main.c:

#include "stdio.h"

int main(){
puts("some message");
return 0;
}

Код lib.c:

#define _GNU_SOURCE

#include <stdio.h>
#include "dlfcn.h"

int (*default_puts)(const char* message);
int puts(const char *message)
{
printf("OUR NEW MESSAGE: %s\n", message);
return 0;
}
__attribute__((constructor)) static void Constructor(void) {
default_puts = dlsym(RTLD_NEXT, "puts");
default_puts("constructor called\n");
}
__attribute__((destructor)) static void Destructor(void) {
default_puts("destructor called\n");
}

Компиляция и запуск:

$ gcc lib.c -o mylib.so -fPIC -shared -ldl
$ gcc main.c -o f
$ LD_PRELOAD=./mylib.so ./f
constructor
OUR NEW MESSAGE: some message
destructor

FULL POST HERE

- https://uvicorn.github.io/posts/nanomites/ -

Forkbomb reverse ch2

Sat, 12 Feb 2022 02:48:00 +0700

Uvicorn blog https://uvicorn.github.io/posts/forkbomb_ch2-writeup/ -

Как писать райтапы, если решений не осталось

Braindead

Реверс брейнфака. Находим райтап и следуя ему с помощью этого скрипта транслируем брейнфак в си, который позднее компилируем с -O3. Закидываем бинарь в иду и по вызовам putchar находим нечто похожее на strcmp по своей логике:

 v320 = *(_DWORD *)&v350[16];
v322 = 0;
v319 = 1;
do
{
while ( 1 )
{
v323 = v357;
if ( v357 )
{
v357 = 0;
v321 += v323;
}
if ( v321 )
v357 += v321;
v324 = v320;
v325 = v320 + v323; // v325 = v323 // v323 - кол-во сиволов, которые совпали
 if ( !v323 )
v325 = v324;
if ( v325 == 32 ) // сравниваются только первые 32 символа -> длина флага = 32
 break;
++v398;
v321 = 0;
v320 = 0;
if ( !--v319 )
goto LABEL_989;
}
++v322;
v321 = 0;
v320 = 0;
--v319;
}
while ( v319 );
LABEL_989:
*(_QWORD *)&v350[12] = 0LL;
v3 = 0;
v356 = 0;
v358 = 32;
*(_DWORD *)&v350[4] = v322;
if ( !v322 ) // if v322 == 0
 goto lose;
printf("Congratulations! The flag you have entered is correct");
lose:
printf("No, that's wrong");

В дебаггере обнаруживаем, что в v323 (rdx) хранится кол-во введенных символов, которые совпадают с символами флага. Я, как существо ленивое, не захотел копаться в бинаре и решил написать нейросеть-брутфорсер:

import time
gdb.execute('b *0x55555555888f') # адрес v325 = v320 + v323;
dlt = 32*"6"
gdb.execute('r <<<"' + dlt +'"')
m_val = int(str(gdb.parse_and_eval("$rdx")),16)+1 # rdx - v323
print(m_val, len(dlt))
time.sleep(2)
gdb.execute('c')
st = ''
for i in range(len(st),32):
for ch in '\'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345789{|}^_ !#$%&()*+,-./:;<=>?@':
print(st+ch)
gdb.execute('r <<<"'+ "6"*len(st) + ch + "6"*(31-len(st)) +'"') # r <<< "6666666666666_66666666666666666"
val = int(str(gdb.parse_and_eval("$rdx")),16)
if val >= m_val:
st += ch
print("SUCCESS ", st)
time.sleep(3)
gdb.execute('c')
break
gdb.execute('c')

Идея состоит в том, чтобы проверять каждый символ отдельно, заполняя 31 оставшийся шестерками (можно заполнять любыми символами), после чего переходить к следующему символу. Стоит сказать, что нейросеть не идеальна, так как при переборе некоторых символов приходилось убавлять m_val на 1, а иногда и вовсе оставлять символ неразгаданным. Тем не менее, минут через 15 получаем что-то похожее на флаг:spbctf{h4vE_%_B%%n_br41NWa5%3d?}. Находим возможные оставшиеся неизвестные символы (%):

dct = dict()
gdb.execute('b *0x55555555888f')
for ch in range(32,127):
if ch in (34,):continue # двойная кавычка демотивировала гдб продолжать работу 
st = "spbctf{h4vE_%_B%%n_br41NWa5%3d?}".replace('%',chr(ch))
gdb.execute(f'r <<<"{st}"')
val = int(str(gdb.parse_and_eval("$rdx")),16)
dct[st] = val
gdb.execute('c')
for key, val in dct.items():
if val != 29:
print(key, val)

По завершению работы скрипта получаем

spbctf{h4vE_$_B$$n_br41NWa5$3d?} 23
spbctf{h4vE_1_B11n_br41NWa513d?} 30
spbctf{h4vE_3_B33n_br41NWa533d?} 30
spbctf{h4vE_\_B\\n_br41NWa5\3d?} 14
spbctf{h4vE_`_B``n_br41NWa5`3d?} 12
spbctf{h4vE_h_Bhhn_br41NWa5h3d?} 30

Соответственно, возможные оставшиеся символы - 1, 3, h. Ручками подгоняем флаг до spbctf{h4vE_1_B33n_br41NWa5h3d?}.

CatGirl Industrials Shell

Реверс виртуальной машины на питоне.

def avogado6(*args):
exit(1)
def beca(st):
padding = "=" * ((4 - len(st)) % 4)
mpl = list(b64decode(st + padding))
return mpl
def do_magic(st): return "".join(chr(ord(i) ^ 0x13 ^ 0x37) for i in st)
def pet_the_cat(st): return sum(ord(i) for i in st)
def love(a0, a1): return a0+a1
def peace(a0, a1): return a0 - a1
def hopes_and_dreams(st): return st
class _outer_:pass
class _naruto_:pass
class _conti_:pass
class _petergeize_:pass
class _non_:pass
class _romane_:pass
class _rerere_:pass
class _outer_pointer_:pass
class _ghost_out_of_the_shell_:pass
class _ghost_in_the_shell_:pass
def dmagic(xval, st):
ans = ""
st = bytes(st.encode())
for i in range(len(st)):
ans += chr(st[i] ^ xval)
xval ^= (ord(ans[i]) | st[i])
return ans
memory = [ # bytecode
print,
do_magic,
0,
...
]
data = [ # stack 
[do_magic("Welcome to our CatGirl Industrials shell! There is an offline auth")],
...
]
def execute():
pointer = 0
while 1:
if memory[pointer] == 0:
print("STOP VM")
break
elif memory[pointer] is _petergeize_:
pointer += 1
jt = memory[pointer]
pointer += jt-1
elif memory[pointer] is _romane_:
pointer += 1
pointer = memory[pointer] - 1
elif memory[pointer] is _conti_:
p0, p1 = data.pop(), data.pop()
data.append([*p0, *p1])
pointer += 1
elif memory[pointer] is _non_:
p0, p1 = data.pop(), data.pop()
pointer += 1
jp = memory[pointer]
if p0 == p1:
pointer += 1
else:
pointer += jp-1
elif memory[pointer] is _rerere_:
f0, o0 = data.pop()[0], data.pop()[0]
memory[pointer+o0] = f0
pointer += 1
elif memory[pointer] is _ghost_in_the_shell_:
f0 = data.pop()
data.append([f0])
pointer += 1
elif memory[pointer] is _ghost_out_of_the_shell_:
f0 = data.pop()
f0 = f0[0]
data.append(f0)
pointer += 1
elif memory[pointer] is _naruto_:
p0 = data.pop()
data.append(p0)
data.append(p0)
pointer += 1
elif memory[pointer] is _outer_:
pointer += 1
p0 = memory[pointer]
data.append([p0])
pointer += 1
elif memory[pointer] is _outer_pointer_:
pointer += 1
data.append([pointer])
else:
fcall = []
while memory[pointer] != 0:
fcall.append(memory[pointer])
pointer += 1
param = data.pop()
for fun in fcall[::-1]:
param = [fun(*param)]
if param[0] is not None:
data.append(param)
pointer += 1
execute()

Переименуем функции:

avogado6 -> ext
do_magic -> xor_36
pet_the_cat -> sum_chars
love -> add
peace -> sub
hopes_and_dreams -> nop
_outer_ -> PUSH
_naruto_ -> COPY
_conti_ -> DOUBLE_PACK
_petergeize_ -> JMP_PLUS
_non_ -> JNE
_romane_ -> JMP
_rerere_ -> _rerere_ # инструкция не использовалась в байткоде, поэтому я забил на ее переименование
_outer_pointer_ -> PUSH_PTR
_ghost_out_of_the_shell_ -> UNPACK
_ghost_in_the_shell_ -> PACK

И встроим в обработчик инструкций дисассемблер:

def ext(*args):
p('EXIT')
exit(1)
DEBUG = True
def p(*args): # debug print
global pointer
if DEBUG:
print(f"{pointer}>", *args)
pointer = 0
while 1:
if memory[pointer] == 0: # EXIT
p('EXIT')
print("STOP VM")
break
elif memory[pointer] is JMP_PLUS: # JMP pointer+arg
addr = memory[pointer+1]
p(f'JMP_PLUS {addr}')
pointer += addr
elif memory[pointer] is JMP: # JMP arg
pointer = memory[pointer+1] - 1
p(f'JMP {pointer}')
elif memory[pointer] is DOUBLE_PACK: # PUSH [POP, POP]
p('POP; POP; PACK')
p0, p1 = data.pop(), data.pop()
data.append([*p0, *p1])
pointer += 1
elif memory[pointer] is JNE: # JNE arg
p0, p1 = data.pop(), data.pop()
pointer += 1
jp = memory[pointer]
p(f'CMP {p0} == {p1}; JNE {jp-1}')
if p0 == p1:
pointer += 1
else:
pointer += jp-1
elif memory[pointer] is _rerere_: # я хз что это вообще
f0, o0 = data.pop()[0], data.pop()[0]
memory[pointer+o0] = f0
pointer += 1
elif memory[pointer] is PACK: # PUSH [POP] # [3] -> [[3]]
f0 = data.pop()
p(f'PACK # {f0} => [{f0}]')
data.append([f0])
pointer += 1
elif memory[pointer] is UNPACK: # [[3]] -> [3]
f0 = data.pop()
f0 = f0[0]
p(f'UNPACK # [{f0}] => {f0}')
data.append(f0)
pointer += 1
elif memory[pointer] is COPY: # pop ; push; push # копирует элемент на стеке
p0 = data.pop()
p(f"POP {p0}; PUSH ; PUSH")
data.append(p0)
data.append(p0)
pointer += 1
elif memory[pointer] is PUSH: # PUSH arg
pointer += 1
p0 = memory[pointer]
data.append([p0])
p(f'PUSH {[p0]}')
pointer += 1
elif memory[pointer] is PUSH_PTR: # PUSH pointer
pointer += 1
p(f'PUSH PTR {[pointer]}')
data.append([pointer])
else:
fcall = []
while memory[pointer] != 0:
fcall.append(memory[pointer])
pointer += 1
param = data.pop()
st = str(param)[1:-1]
for fun in fcall[::-1]:
st = f"{fun.__name__}({st})"
param = [fun(*param)]
p("PUSH "+st)
if param[0] is not None:
data.append(param)
pointer += 1

Перед тем, как приступим к реверсу байткода, скажу, что вы можете скачать код с дисассемблером тут.

Находим первые пять символов флага в CMP:

Ради следующих шести придется развернуть строку moc.eb

Ксор xor_36('\x0bSEPGL\x1bR\x19') == '/watch?v='

Опять сравнение с CMP

На последнем шаге нужно будет дисассемблировать байткод чуть дальше текущего указателя и получить нужный массив (последняя часть флага - b64encode(bytes([27, 97, 79, 25, 132])))

Соберем флаг воедино: youtube.com/watch?v=H3w1G2FPGYQ

ЗЫ: Автор таска сказал, что по данному адресу должны были находиться бурятские песенки, но правообладатель их заблочил

Movfuscator

Решение этого таска я объяснить не могу, потому что решил его при помощи своих экстрасенсорных навыков.

Итак, нам дают бинарник, состоящий из инструкций вида mov rcx, 0x1234. Да, можно было заосинтить деобфускатор, но это путь слабых. Я же после пары запусков подопытного угадал алгоритм шифрования

st = input()
res = ''
for i in range(len(st)):
res += chr(ord(st[i]) - i)
print(res)

Что здесь происходит догадаться нетрудно

Затем закинул бинарь в гдб и начал прожимать nexti, просматривая память в поисках шифротекста, с которым сравнивается наш ввод. Где-то на адресе 0x4006f0 обнаруживаю заветную строку: t2f\iDAAlPUb$bA!f"3_> И расшифровываю ее

st = "t2f\\iDAAlPUb$bA!f\"3_>"
res = ''
for i in range(len(st)):
res += chr(ord(st[i]) + i)
print(res) # t3h_mIGHtY_m0oO0v3ErR

А кто-то говорил, что стега от менада ничему не учит…

Check Summer

К бинарю на паскале прилагается трасса инструкций вида

004216CF Main CALL check_su.0040D760
0040D760 Main PUSH EBX
0040D761 Main MOV EDX,DWORD PTR DS:[5CC020]
0040D767 Main TEST EDX,EDX
0040D769 Main JE SHORT check_su.0040D776
0040D76B Main MOV EAX,DWORD PTR DS:[5CB320]
0040D770 Main CALL EDX

Логику работы бинарника за меня опишет эта гифка:

По xref-ам находим алгоритм создания хеша от флага

И сам алгоритм хеширования:

int __usercall UNIT1____CRC32_ANSISTRING__ANSISTRING@<eax>(unsigned __int8 *input@<eax>)
{
unsigned int state, length; // ebx
 unsigned __int8 *inp; // [esp+38h] [ebp-4h]

inp = input; // адрес - 0x04244B0
 // ...
 v7 = FPC_SETJMP();
if ( !v7 )
{
state = 0xFFFFFFFF;
length = (int)inp;
if ( inp )
length = *((_DWORD *)inp - 1);
if ( length >= 1 )
{
inp_i = 0;
do
{
state ^= inp[inp_i++]; // 0x0424507
 for ( i = 8; i > 0; --i )
{
if ( (state & 1) != 0 ) // если state нечетное
 state = (state >> 1) ^ 0xEDB88320; // адрес - 0x0424519
 else // четное
 state >>= 1; // адрес - 0x0424527
 }
}
while ( length > inp_i );
}
SYSUTILS____INTTOHEX_QWORD_LONGINT__ANSISTRING(~state, 0);
}
// ...
 return state; // адрес - 0x0424568
}

Идея моего решения состоит в том, чтобы по четности стейта и его значению на предыдущей итерации цикла while, определить символ, с которым стейт был поксорен.

Финальный код решения:

data = open('check_summer_rtrace.txt').read().split('\n')[:-1]
addrs = [i.split()[0] for i in data]
start_crc_func = '004244B0' # начало функции
end_crc_func = '00424568' # конец функции 
xor_state_addr = '00424507' # state ^= inp[inp_i++]
is_state_odd_addr = '00424519' # state = (state >> 1) ^ 0xEDB88320
is_state_even_addr = '00424527' # state >>= 1
addrs = addrs[addrs.index(end_crc_func)+1:] # на гифке видно, что при снятии трассы хеш берется 2 раза (от слова SPbCTF и от флага), нам нужен именно последний , поэтому отбрасываем часть трассы с хешированием SPbCTF
func_block = addrs[addrs.index(start_crc_func):addrs.index(end_crc_func)]
check_arr = []
for addr in func_block:
if addr == is_state_odd_addr:
check_arr.append(1)
elif addr == is_state_even_addr:
check_arr.append(0)
state_prev = 0xFFFFFFFF
flag = ''
# длину флага находим по кол-ву совершенных state ^= inp[inp_i++]
flag_len = func_block.count(xor_state_addr)
for inp_i in range(flag_len):
for char in range(32,127):
state = state_prev ^ char
new_state_check_arr = []
for i in range(8):
if (state & 1) != 0:
new_state_check_arr.append(1)
state = (state >> 1) ^ 0xEDB88320
else:
new_state_check_arr.append(0)
state >>= 1
if new_state_check_arr == check_arr[inp_i*8:inp_i*8+8]:
state_prev = state
flag += chr(char)
break
print(flag)
# spbctf{June_1st_it5_r34lly_sUmm3R}

- https://uvicorn.github.io/posts/forkbomb_ch2-writeup/ -

Forkbomb reverse ch1

Mon, 31 Jan 2022 04:55:00 +0700

Uvicorn blog https://uvicorn.github.io/posts/forkbomb_ch1-writeup/ -

Lemballovo

Запускаем игру и ловим непонятную ошибку:

Закидываем бинарь в иду и по xref-ам находим место, где вылетает ошибка:

Патчим на

И, о чудо, нас ждет уже другая ошибка

Запатчив игру еще пару раз подобным образом, она заработает и выдаст флаг.

Полный список адресов, по которым нужно запатчить:

httpsec

Пропрыгав по xref-ам находим алгоритм получения флага:

int sub_138D()
{
int v1; // eax
 int v2; // eax
 char v3[136]; // [rsp+0h] [rbp-C0h] BYREF
 FILE *stream; // [rsp+88h] [rbp-38h]
 int v5; // [rsp+94h] [rbp-2Ch]
 char *check_st; // [rsp+98h] [rbp-28h]
 int i; // [rsp+A4h] [rbp-1Ch]
 int res; // [rsp+A8h] [rbp-18h]
 int v9; // [rsp+ACh] [rbp-14h]
 int v10; // [rsp+B0h] [rbp-10h]
 int v11; // [rsp+B4h] [rbp-Ch]
 int v12; // [rsp+B8h] [rbp-8h]
 int v13; // [rsp+BCh] [rbp-4h]

if ( !strcmp("/", s2) && !strcmp("GET", http_method) )
{
puts("HTTP/1.1 200 OK\r\n\r");
return puts("Welcome to our fast web-server\r");
}
else if ( strcmp(s2, "/secret/") == 1 && !strcmp("GET", http_method) )
{
check_st = get_header_content("X-Auth");
if ( check_st )
{
st_len = strlen(check_st);
if ( st_len == 8 )
{
v13 = check_st[4] + *check_st - check_st[6];
v12 = check_st[6] + check_st[3] - check_st[2];
v11 = check_st[7] + check_st[1] - check_st[3];
v10 = check_st[2] + check_st[5] - check_st[7];
v9 = check_st[3] + check_st[1] - check_st[2];
res = 0;
for ( i = 0; i <= 7; ++i )
{
if ( (v12 & 1) != 0 )
{
v10 -= v13;
if ( (v10 & 1) != 0 )
{
v11 -= v9;
v2 = v12 + v13;
}
else
{
v12 -= v9;
v2 = v11 + v12;
}
res += v2;
}
else
{
v9 -= v11;
if ( (v13 & 1) != 0 )
{
v13 -= v12;
v1 = v10 + v9;
}
else
{
v10 -= v11;
v1 = v13 + v12;
}
res += v1;
}
v13 ^= v12;
v12 ^= v11;
v11 ^= v10;
v10 ^= v9;
v9 ^= v13;
}
if ( res == 444 )
{
stream = fopen("flag.txt", "r");
fgets(v3, 128, stream);
fclose(stream);
puts("HTTP/1.1 200 OK\r\n\r");
return printf("Flag: %s\r\n", v3);
}
}
}
}
}

Попытка решить все это дело с помощью z3 не увенчалась успехом, поэтому пришлось брутить:

import requests,random
arr = [0]*5
while True:
st = [random.randint(32,126) for _ in range(8)]
arr[4] = st[4] + st[0] - st[6]
arr[3] = st[6] + st[3] - st[2]
arr[2] = st[7] + st[1] - st[3]
arr[1] = st[2] + st[5] - st[7]
arr[0] = st[3] + st[1] - st[2]
check_var_444 = 0
for i in range(8):
if ( (arr[3] & 1) != 0 ):
arr[1] -= arr[4]
if ( (arr[1] & 1) != 0 ):
arr[2] -= arr[0]
v1 = arr[3] + arr[4]
else:
arr[3] -= arr[0]
v1 = arr[2] + arr[3]
else:
arr[0] -= arr[2];
if ( (arr[4] & 1) != 0 ):
arr[4] -= arr[3]
v1 = arr[1] + arr[0]
else:
arr[1] -= arr[2];
v1 = arr[4] + arr[3]
check_var_444 += v1
arr[4] ^= arr[3]
arr[3] ^= arr[2]
arr[2] ^= arr[1]
arr[1] ^= arr[0]
arr[0] ^= arr[4]
if check_var_444 == 444:
print(requests.get('http://109.233.56.90:11544/secret/',headers = {"X-Auth": ''.join(map(chr,st))}).content)
break

P.S.: Нужно было сразу брутфорсить, а не загонять в z3, но я подумал, что брутить будет слишком долго. Вот так неверная оценка сложности шифрования может привести к нескольким потерянным часам.

Gython

~~О нет голанг~~ Закидываем в иду и наслаждаемся псевдокодом.

Алгоритм работы бинаря прост - дропнуть __init__.pyc на диск и запустить ее (в агрументах при этом передается что-то похожее на ключ - HzURFvGeN7sClEVLJDBnZVnlrTUBDw41RFefNmcB7bdfFg==).

Вытащить адрес проживания пики можно strace-ом:

Декомпилируем пику и получаем следующие:

import base64, hashlib, os, sys, urllib.request
KEY = b'K[\x87\xb7\xddR\x1e\xc0I\x1d/\xa2\xea\xa4\xadGW?Z\xffN\x80k\x9d\xe1\xfc4\xffs\xb2\x86k1'
def byte_xor(ba1, ba2):
return bytes([_a ^ _b for _a, _b in zip(ba1, ba2)])
def encrypt(key, plaintext):
while len(key) < len(plaintext):
key += hashlib.sha256(key).digest()
key = key[::-1]
return byte_xor(key[:len(plaintext)], plaintext)
def check(params):
if len(params) != 1:
return False
else:
return hashlib.sha256(encrypt(KEY, base64.b64decode(params[0]))).hexdigest() == 'fb0d5faa2b54bc25b1654a90106913bd1dd7e5a0400986f7676ec1e0afa93d71'
try:
if check(sys.argv[1:]):
r = urllib.request.urlopen('https://forkbomb.ru/?answer=' + str(encrypt(KEY, str(os.getuid()).encode())))
with open('1.txt', 'w') as (f):
f.write(r.read(1024).decode('utf-8'))
except:
pass
with open(__file__, 'wb') as (f):
f.write('')

В check передаются argv, то есть тот странный ключ.

На этом моменте я долго тупил и не понимал куда идти дальше. Спустя пару дней решение пришло само собой:

encrypt(KEY, base64.b64decode('HzURFvGeN7sClEVLJDBnZVnlrTUBDw41RFefNmcB7bdfFg=='))

Speedreading

Задача состоит в получении премиум доступа в приложении для Андроида.

Исследование апк в jadx заводит в com.safonov.speedreading.application.util.PremiumUtil:

Видно, что уровень доступа(премиум или нет) проверяется только на клиенте, соответственно мы можем запатчить этот самый клиент.

Извлечем байткод из classes.dex, который находится внутри апк: apktool d ./SpeedRead.apk.

Откроем PremiumUtil.smali и изменим код функции isPremiumUser с

.method public isPremiumUser()Z
.locals 1
.prologue
.line 22
iget-boolean v0, p0, Lcom/safonov/speedreading/application/util/PremiumUtil;->premiumUser:Z
return v0
.end method

На

.method public isPremiumUser()Z
.locals 1
.prologue
.line 22
const/4 v0, 0x1 # v0 = true
return v0
.end method

Пересоберем приложение: apktool b ./SpeedRead -o SpeedRead_Patched.apk

Запускаем приложение и получаем желаемое:

- https://uvicorn.github.io/posts/forkbomb_ch1-writeup/ -

Sad Rendel

Tue, 30 Nov 2021 04:20:25 +0700

Uvicorn blog https://uvicorn.github.io/posts/sad-rendel-writeup/ -

~~Ссылка на таск~~ без vpn конфига не работает

И его сорцы

Немного истории

Таск был взят с Moscow School Ctf 2021, на которой я играл в команде Shadow Kitties (8 место).

Удивлен, что его решило всего 2 команды. Решил я только этот таск. В свое оправдание скажу, что в тот день писал олимпиаду Верченко по криптографии, пол дня провел в городе и приехал домой мертвый.

Решение

Заглянем в main.py и обнаружим условие получения флага.

from cookies import encrypt_cookie, decrypt_cookie
def get_user(request):
cookie = request.cookies.get('sess')
if cookie is None:
return None
session_data = decrypt_cookie(cookie)
return int(session_data["user_id"])
async def get_flag(request):
user = get_user(request)
if user is None:
return templates.TemplateResponse('flag_page.html', {
'request': request,
'flag': 'Flag is not available to anonymous users'
})
if user == 1:
return templates.TemplateResponse('flag_page.html', {
'request': request,
'flag': FLAG
})
else:
return templates.TemplateResponse('flag_page.html', {
'request': request,
'flag': 'Only admin can read a flag'
})

Разобравшись, что get_user берет информацию о пользователе из куки и возвращает его user_id, используя при этом функцию decrypt_cookie, идем в cookies.py к этой самой функции.

def decrypt_cookie(encrypted_cookie):
envelope_data = json.loads(base64.b64decode(encrypted_cookie))
iv = base64.b64decode(envelope_data['iv'])
cbc = AES.new(KEY2, AES.MODE_CBC, iv)
second_layer = base64.b64decode(envelope_data['data'])
first_layer = cbc.decrypt(second_layer)
nonce = base64.b64decode(envelope_data['nonce'])
ctr = AES.new(KEY1, AES.MODE_CTR, nonce=nonce)
data = ctr.decrypt(first_layer)
return json.JSONDecoder().raw_decode(data.decode('utf8', errors='replace'))[0]

Так как нам доступен IV, мы можем провести атаку bit flip на CBC.

Суть в том, что P = Dec(C) ⊕ IV, соответственно мы можем подменить часть IV (в нашем случае 1 байт, потому что user_id занимает именно столько), чтобы получить желаемый плейнтекст (нам известен исходный P , поэтому проблем не возникнет).

Второй этап расшифрования не представляет угрозы, так как при CTR шифротекст не используется в функции Dec.

Итак, заходим в бурп, логинимся, берем куку, подменяем в ней IV и забираем флаг.

Вот код решения.

import json
from base64 import b64decode, b64encode
iv_user_id_index = json.dumps({"user_id":9}).index('9') # всегда 12
def bit_flip(cook, user_id=0):
user_id ^= 1
recv_json = json.loads(b64decode(cook).decode())
iv = recv_json['iv']
iv = list(b64decode(iv))
iv[iv_user_id_index] ^= user_id
recv_json['iv'] = b64encode(bytes(iv)).decode()
return b64encode(json.dumps(recv_json).encode())
cook = input()
user_id = int(input())
print(bit_flip(cook, user_id).decode())

Опа флаг

Я до конца думал, что это unintended решение (иначе зачем класть таск на крипту вместе с тасками на веб), но содержимое флага развеяло сомнения

Эпилог

Мой первый райтап, мог написать дичь, не стесняйтесь критиковать.

- https://uvicorn.github.io/posts/sad-rendel-writeup/ -