DEF CON Quals 2019 : Vitor

Vitor

mm

Defcon 2019 qualifiersda sorulmuş android reverse kategorisine ait bir ctf sorusu. Matruşka misali birkaç bölümden oluşuyor. Soruda bize bir apk veriliyor. Uygulama bizden input olarak flagi istiyor ve doğruluğunu kontrol ediyor.

Aşama 1 : Dex

Verilen apkyı jadx gibi araçlarla decompile edip java kodunu inceleyebiliyoruz. Classlara göz attığımızda fc class’ını görüyoruz. Genel olarak her aşamada yapılacak olanlar birbirine benzer. Sadece ilk aşama için detaylı bir açıklama yapacağım. Flagi kontrol eden fonksiyonumuz şu şekilde:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static boolean cf(MainActivity mainActivity, String str) {
boolean z = false;
try {
cfa(mainActivity, p1EncFn);
cfa(mainActivity, p5EncFn);
cfa(mainActivity, randEncFn);
cfa(mainActivity, rand2EncFn);
if (str.startsWith("OOO{") && str.endsWith("}") && str.length() == 45) {
if (cf(mainActivity, dp1(mainActivity, new File(mainActivity.getFilesDir(), p1EncFn), g0(str.substring(4, 44))), str)) {
File file = new File(mainActivity.getFilesDir(), "bam.html");
WebView webView = mainActivity.mWebView;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("file:///");
stringBuilder.append(file.getAbsolutePath());
stringBuilder.append("?flag=");
stringBuilder.append(Uri.encode(str));
webView.loadUrl(stringBuilder.toString());
z = mValid;
}
}
} catch (Exception e) {
}
return z;
}

İlk kontrolden anlıyoruzki Flag OOO{ ile başlayıp } ile bitiyor. Uzunluğu 45. Ardından sırasıyla incelersek:

g0(str.substring(4, 44))) : g0 fonksiyonuna flagimizin süslü parantezler içerisinde kalan input yollanıyor. g0 fonksiyonu :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static byte[] g0(String str) {
int i;
byte[] bArr = new byte[4];
byte[] bytes = str.getBytes();
for (i = 0; i < 4; i++) {
bArr[i] = (byte) null;
}
for (int i2 = 0; i2 < 10; i2++) {
for (i = 0; i < 4; i++) {
bArr[i] = (byte) ((byte) (bArr[i] ^ bytes[(i2 * 4) + i]));
}
}
return bArr;
}

Fonksiyon 4 bytelık bir array döndürüyor. Bu 4 byte’ı da şu şekilde hesaplıyor:

1
2
3
4
byte[0] = flag[0]^flag[8]^flag[16]^flag[24]^flag[32]
byte[1] = flag[1]^flag[9]^flag[17]^flag[25]^flag[33]
byte[2] = flag[2]^flag[10]^flag[18]^flag[26]^flag[34]
byte[3] = flag[3]^flag[11]^flag[19]^flag[27]^flag[35]

g0 fonksiyonundan dönen 4byte, dp1 fonksiyonuna 3. parametre olarak gidiyor.

dp1(mainActivity, new File(mainActivity.getFilesDir(), p1EncFn), g0(str.substring(4, 44)))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private static File dp1(Context context, File file, byte[] bArr) throws Exception {
byte[] hash = hash(bArr);
byte[] readAllBytes = Files.readAllBytes(file.toPath());
try {
AlgorithmParameterSpec ivParameterSpec = new IvParameterSpec(initVector);
Key secretKeySpec = new SecretKeySpec(hash, "AES");
Cipher instance = Cipher.getInstance("AES/CBC/PKCS5PADDING");
instance.init(2, secretKeySpec, ivParameterSpec);
readAllBytes = instance.doFinal(readAllBytes);
File file2 = new File(context.getFilesDir(), p1Fn);
OutputStream fileOutputStream = new FileOutputStream(file2);
fileOutputStream.write(readAllBytes, 0, readAllBytes.length);
fileOutputStream.flush();
fileOutputStream.close();
return file2;
} catch (Exception e) {
return null;
}
}

Bu fonksiyonda önce 4byte’ın md5ini alıyor. Bu digest değerini aes keyi olarak kullanıyor ve input olarak verilen dosyayı decrypt ediyor. dp1’i çağırıken class’ın başında tanımlanmış
public static String p1EncFn = "ckxalskuaewlkszdva"; değeri kullanılıyor. Apk’ımızın içerisindeki asset klasorune bakarsak bu dosyayı görebiliyoruz. Peki bu dosyayı decrypt edip ne yapıyor ?

1
2
3
4
5
6
7
8
9
private static boolean cf(Context context, File file, String str) {
File file2 = new File(context.getFilesDir().getAbsolutePath());
try {
Class loadClass = new DexClassLoader(file.getAbsolutePath(), file2.getAbsolutePath(), file2.getAbsolutePath(), ClassLoader.getSystemClassLoader()).loadClass("ooo.p1.P1");
return ((Boolean) loadClass.getDeclaredMethod("cf", new Class[]{Context.class, String.class}).invoke(loadClass, new Object[]{context, str})).booleanValue();
} catch (Exception e) {
return false;
}
}

Decrypt edilen dosya DexClassLoader APIsi ile contexte yükleniyor. Bu olayı android malwarelerinde çok görüyoruz. Tersine mühendisliği zorlaştırmak için “packing” yöntemini sıklıkla kullanıyorlar.

ooo.p1.P1 class’ı invoke edilip o class içerisinden bir fonksiyon çağırılıyor. Bu fonksiyon boolean bir değer döndürüyor ( O fonksiyonda baska fonksiyonlar cagiriyor tabi ). Ve flagin doğruluğu kontrol edilmiş oluyor .

Aşama 1’i toparlasak:

  • Flagin belli indexlerini XORla ve 4byte’ı al
  • md5
  • ckxalskuaewlkszdva dosyasını bu keyle decrypt et
  • decrypt edilen dosya içerisinden ooo.p1.P1 classını load et.

Peki biz bu 4byte’ı nasıl bulabiliriz ?

Biliyoruzki decrypt edilen dosyanın bir jar dosyası olması lazım. Neden ? Çünkü kullanılan DexClassLoader fonksiyonu dosya formatı olarak jar kabul ediyor. Jar dosyaları da bir nevi zip ve zip dosyalarının Magic Byte’ını yani dosya tipini anladığımız header kısmını biliyoruz. \x50\x4b\x03\x04 dosya headerı olarak bu byteları arayacağız.

Şimdi brute için şu şekilde bir python scripti yazalım:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
from Crypto.Cipher import AES
import hashlib

IV = bytes([19, 55, 19, 55, 19, 55, 19, 55, 19, 55, 19, 55, 19, 55, 19, 55])
N_BIT = 4
S_BIT = 2**7 + 1

DATA = open('ckxalskuaewlkszdva', 'rb').read(32)


for key_1 in range(S_BIT):
for key_2 in range(S_BIT):
print(key_1, key_2, end='\r')
for key_3 in range(S_BIT):
for key_4 in range(S_BIT):
key = hashlib.md5(
bytes([key_1, key_2, key_3, key_4])).digest()
aes = AES.new(key, AES.MODE_CBC, IV)
decrypted_data = aes.decrypt(DATA)
if decrypted_data.startswith(b'\x50\x4b\x03\x04'):
print(key_1, key_2, key_3, key_4)
IV = bytes([19, 55, 19, 55, 19, 55, 19, 55, 19, 55, 19, 55, 19, 55, 19, 55])
f= open("ckxalskuaewlkszdva","rb")
DATA = f.read()
f.close()
key = hashlib.md5(
bytes([key_1, key_2, key_3, key_4])).digest()
aes = AES.new(key, AES.MODE_CBC, IV)
decrypted_data = aes.decrypt(DATA)
f = open("out.zip","wb")
f.write(decrypted_data)
f.close()

Girdiğimiz stringler sonuçta ASCII yani 7bitlik aralıkta olduğu için XOR sonucu elde edilecek byte aralığıda bu aralığa sahip olmak zorunda.

Burda dikkatinizi DATA = open('ckxalskuaewlkszdva', 'rb').read(32) satırına vermenizi rica ediyorum. Neden 32 byte okuyorum burada ?

aes

AES CBC encryption şemasında sizin dosyanız ne kadar büyüse de ilk bloğun son halini ilgilendiren bir olay gerçekleşmiyor. Yani biz sadece ilk blok için deneme yaparak keyi bulabiliriz. Bu çok büyük ölçüde işimizi kolaylaştırıyor. 1.6 MB dosyanın boyutunu 32byte’a düşürmüş oluyoruz.

Bu scripti çalıştırdığımızda birkaç dakika içerisinde ilk keyimizi alıyoruz.

Key 1 : \x17\x01\x2f\x03

Her aşamamızda flagin belirli bytelarına dair bilgi ede ede ilerliyoruz.

Aşama 2 : SO

İlk aşamaya benzer bir dex dosyası ile karşılaşıyoruz.

Bu sefer jar dosyası yerine bir adet .so dosyası oluşturulması gerekiyor ve XORlanan indexler değişik.

1
2
3
4
5
for (int i2 = 0; i2 < 10; i2 += 2) {
for (i = 0; i < 4; i++) {
bArr[i] = (byte) ((byte) (bArr[i] ^ bytes[((i2 + 1) * 4) + i]));
}
}
1
2
3
4
byte[0] = flag[4]^flag[12]^flag[20]^flag[28]^flag[36]
byte[1] = flag[5]^flag[13]^flag[21]^flag[29]^flag[37]
byte[2] = flag[6]^flag[14]^flag[22]^flag[30]^flag[38]
byte[3] = flag[7]^flag[15]^flag[23]^flag[31]^flag[39]

Aynı scripti kullanarak zip headeri yerine .so dosyanın yani ELF headerini \x7f\x45\x4c\x46 yazıyoruz, input dosyasını mmdffuoscjdamcnssn olarak değiştirip ikinici keyimizi de alıyoruz.

Key2 : \x3c\x27\x43\x60

Aşama 3 Shellkod:

Bu sefer işler değişiyor. Biliyoruzki so dosyasından xxx fonksiyonu çağırılıyor.

1
private native String xxx(String str, String str2);

So dosyanı IDA ile açıp incelediğimizde bu fonksiyonu görebiliyoruz.

ida1.png

Daha kolay anlaşılması için değişken ve fonksiyonlari isimlendirdim.

Önce asset klasorunden xtszswemcwohpluqmi dosyası okunuyor ve key hesaplandıktan sonra bu dosya decrypt ediliyor. Bu sefer biraz olaylar farklı. Keyi hesaplamak için fonksiyon şu şekilde:

1
2
3
4
5
K2_0 = 0;
flaga = flag + 4;
for ( i = 3; i < 10; i += 3 )
K2_0 ^= *&flaga[4 * (i - 1)];
return K2_0;

yani :

1
2
3
4
byte[0] = flag[8]^flag[20]^flag[32]
byte[1] = flag[9]^flag[21]^flag[33]
byte[2] = flag[10]^flag[22]^flag[34]
byte[3] = flag[11]^flag[23]^flag[35]

Key hesaplandiktan sonra:

1
2
3
4
5
for ( i = 0; i < 100; ++i )
{
*&p3enc[4 * i] ^= K2_0;
K2_0 += 0x31333337;
}

fonksiyonuna veriliyor ve dosya bu şekilde decrypt ediliyor. Peki bu sefer neye göre decrypt edicez ? Decrypt edildikten sonra bir assembly kodu elde ediceğimiz belli. Çünkü fonksiyonun devamında bu alani fonksiyon şeklinde çağrılıyor.

ida2

Bu cepte. Fonksiyon çağırılmadan önceki android log’unun bastığı değere baktığımızda

Jumping to nopsled in 3, 2, 1, ... stringini görüyoruz. Nop sled ne demekti shellkod demekti. NOP instructionunı shellkod yazan herkes illaki kullanmıştır. Instruction’ın byte karşılığı 0x90. Sled olunca da bundan bir sürü demek. Decrypt ederken 4byte 4byte gidildiği için encrypted dosyanın ilk 4 byteını 0x90909090 ile XORlarsak keyimizi elde ederiz.

hex(0x90909090^0xfef3b7de) : \x6e\x63\x27\x4e keyini veriyor. Bu key ile dosyayi decrypt etmek istersek :

Key3: \x6e\x63\x27\x4e

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from pwn import *

f = open("xtszswemcwohpluqmi","rb")
data = f.read()
f.close()

#K2_0 = hex(0x90909090^0xfef3b7de)
#endianess
K2_0 = 0x4e27636e

f = open("shell_out.dat","wb")

for i in range(100):

f.write(xor(data[4*i:4*i+4],p32(K2_0)))
K2_0 += 0x31333337
K2_0 = K2_0 & 0xffffffff

f.close()

Oluşan dosyayı ndisasm -b 32 shell_out.dat şeklinde kontrol edebilirsiniz.

Aşama 4 : ROP

En zor kısım burası. Shellkodun ne yaptığını anlamamız gerek.

Fonksiyona girmeden önce stackteki değerlerimize bakalım:

1
2
3
4
5
6
7
.text:00008C8F                 mov     edx, [ebp+flag?]
.text:00008C92 mov ebx, [ebp+cx_data]
.text:00008C98 mov esi, [ebp+size]
.text:00008C9E mov [esp], edx ; s
.text:00008CA1 mov [esp+4], ebx ; src
.text:00008CA5 mov [esp+8], esi ; n
.text:00008CB5 call ecx

Shellkod çağırılırken ret adresi de pushlanacağı için stack değerlerimiz 4 artıyor.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
...
...
90 nop
E800000000 call 0x25 // 0x25i stacke pushla
5B pop ebx // ebx = 0x25
83EB05 sub ebx,byte +0x5 // ebx = 0x20
83EB20 sub ebx,byte +0x20 // ebx = 0x0 + (Shellkodun yüklendiği base)
8B7C2404 mov edi,[esp+0x4] //flag
31C9 xor ecx,ecx
83C710 add edi,byte +0x10 //4byte kaydır = flag[0]
BA02000000 mov edx,0x2
330F xor ecx,[edi] //flag[i:i+4] ^ ecx
83C710 add edi,byte +0x10 //4byte kaydır
83EA01 sub edx,byte +0x1 //edxi azalt
75F6 jnz 0x3a //loop 2 yapıcak yani flag[0:4] ^ flag[16:20]
83EF20 sub edi,byte +0x20 //flagın basına geri dön
89D8 mov eax,ebx //eax = 0
05C8000000 add eax,0xc8 //eax = 200;
BA32000000 mov edx,0x32 //edx = 50;
3108 xor [eax],ecx //ecxte key vardı; 200 ofsetindeki değerler anlamsız
83C004 add eax,byte +0x4 //4byte ilerle
83EA01 sub edx,byte +0x1 //edx-1 ; 50 kez xorlanıcak; 50*4 =200; 200+200=400 tam dosya boyu
75F6 jnz 0x53 //loop; yine bir decryption
89D8 mov eax,ebx //eax = 0
052C010000 add eax,0x12c //eax = 300
BA19000000 mov edx,0x19 //edx = 25
0118 add [eax],ebx //[eax]taki değerlere base'i ekle
83C004 add eax,byte +0x4 //4byte ilerle
83EA01 sub edx,byte +0x1 //dec
75F6 jnz 0x69 //loop
89D8 mov eax,ebx //eax = base
052C010000 add eax,0x12c //eax = 300
89E2 mov edx,esp //save esp
8B7C2404 mov edi,[esp+0x4] //edi = flag
8B742408 mov esi,[esp+0x8] //esi = data
8B5C240C mov ebx,[esp+0xc] //ebx = size
89C4 mov esp,eax //esp = 300
C3 ret

Simdi kodumuz ne yapıyor kabaca bahsedersek:

  • Key hesapla
  • 200-400 arasını bu key ile xorla
  • 300den sonrası için shellkodun yüklendiği base’i ekle
  • esp’ye 300un offsetini ata
  • ret
  • ret’ten sonra kod executionu 300den devam edicek

Şimdi bizim if’i geçebilmemiz için bu fonksiyondan dönen değerin 0x31337 olması lazım. Şuan görünürde bu değer yok. 300’e gittikten sonra bu işi yapması lazım.

200-400 arasını XORlayacak keyi bulmak için bu aralığa bir bakalım.

1
2
3
4
5
6
7
8
9
10
11
12
13
000000c0: 9090 9090 9090 9090 fa18 3313 42db b0d3  ..........3.B...
000000d0: 46db f09a b2db b815 8129 3dd0 c1de 37d0 F........)=...7.
000000e0: c1f3 37d0 3c19 f04b 819b df0b 81a0 3a13 ..7.<..K......:.
000000f0: 4218 f0ab 750b 3013 8191 ebd0 cbd3 f09a B...u.0.........
00000100: 8adb f2d2 4adb 02da 812b 7c07 812b 7c3b ....J....+|..+|;
00000110: 8188 a383 d288 a383 d288 a383 d288 a383 ................
00000120: d288 a383 d288 a383 d288 a383 4419 3313 ............D.3.
00000130: 4b19 3313 4f19 3313 9b18 3313 9e18 3313 K.3.O.3...3...3.
00000140: 4019 3313 a218 3313 a618 3313 ab18 3313 @.3...3...3...3.
00000150: b118 3313 c918 3313 4218 3313 4218 3313 ..3...3.B.3.B.3.
00000160: 4218 3313 4218 3313 4218 3313 4218 3313 B.3.B.3.B.3.B.3.
00000170: 4218 3313 4218 3313 4218 3313 4218 3313 B.3.B.3.B.3.B.3.
00000180: 4218 3313 4218 3313 4218 3313 4218 3313 B.3.B.3.B.3.B.3.

Bloğun sonuna bakarsanız hep tekrar eden değerler görüyoruz. Bloğun başı işe anlamsız datalardan oluşuyor. Burda bloğun sonunun 0x0 lerle bittiğini düşünerek XOR keyi olarak 0x42183313 kullandım.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
00000000  B800000000        mov eax,0x0
00000005 C3 ret
00000006 83C004 add eax,byte +0x4
00000009 C3 ret
0000000A C3 ret
0000000B 89F0 mov eax,esi
0000000D C3 ret
0000000E 8B06 mov eax,[esi]
00000010 C3 ret
00000011 310E xor [esi],ecx
00000013 C3 ret
00000014 83C604 add esi,byte +0x4
00000017 C3 ret
00000018 83EB04 sub ebx,byte +0x4
0000001B C3 ret
0000001C 7E01 jng 0x1f
0000001E C3 ret
0000001F 58 pop eax
00000020 C3 ret
00000021 83EC18 sub esp,byte +0x18
00000024 C3 ret
00000025 B809000000 mov eax,0x9
0000002A C3 ret
0000002B B837130300 mov eax,0x31337
00000030 C3 ret
00000031 89D8 mov eax,ebx
00000033 C3 ret
00000034 89CB mov ebx,ecx
00000036 C3 ret
00000037 89C8 mov eax,ecx
00000039 C3 ret
0000003A C1C108 rol ecx,byte 0x8
0000003D C3 ret
0000003E 31C9 xor ecx,ecx
00000040 C3 ret
00000041 334F14 xor ecx,[edi+0x14]
00000044 C3 ret
00000045 334F28 xor ecx,[edi+0x28]
00000048 C3 ret
...
00000063 90 nop
00000064 06 push es
00000065 0100 add [eax],eax
00000067 0009 add [ecx],cl
00000069 0100 add [eax],eax
0000006B 000D010000D9 add [dword 0xd9000001],cl
00000071 0000 add [eax],al
00000073 00DC add ah,bl
00000075 0000 add [eax],al
00000077 0002 add [edx],al
00000079 0100 add [eax],eax
0000007B 00E0 add al,ah
0000007D 0000 add [eax],al
0000007F 00E4 add ah,ah
00000081 0000 add [eax],al
00000083 00E9 add cl,ch
00000085 0000 add [eax],al
00000087 00F3 add bl,dh

Bloğumuzun başı rop gadgetleri. Altı ise bu gadgetların adresleri. Disasm bozuk göstersede şu şekilde :

0x0106 0x0109 0x010d 0x00d9 .. 0x00f3

Bu değerler espye atanmıştı. ret yapıldıkça bu değerler poplana poplana gidicek. Yani bu bizim çalışacak kodumuz. Şimdi fonksiyonun 0x31337 dönmesini istiyorduk. Bakalım rop chain döndürüyormu. Son offset 0xf3

200’u 0 kabul edip hesaplarsak : hex(0xf3-200) : 0x2b . Şimdi yukarıdan 0x2bye bakalım.

1
2
0000002B  B837130300        mov eax,0x31337
00000030 C3 ret

evet istediğimiz değer dönüyor. Rop için key:

Bu aşamadaki key şu şekilde hesaplanıyor :

1
2
3
4
byte[0] = flag[16]^flag[32]
byte[1] = flag[17]^flag[33]
byte[2] = flag[18]^flag[34]
byte[3] = flag[19]^flag[35]

Bulduğumuz xor keyi :

Key4 : \x42\x18\x33\x13

Aşama 5 : JS

Tabi rop chain sadece 0x31337 döndürmüyor ondan öncesinde fonksiyona verilen başka bir encrypted datayı decrypt ediyor.

ida3

Bir html dosyası. Html dosyasini rop chain oluşturuyor. Cağırılan gadgetlara bakalim:

1
2
3
4
5
6
7
8
9
xor_ecx_ecx         
xor_ecx_[edi+20] //flag[20:24]
xor_ecx_[edi+40] //flag[40:44] ^ flag[20:24]
xor_[esi]_ecx //eside encrypted data var
add_esi_4 //esi_4
rol_ecx_8 //rotate left ecx
sub_ebx_4 //size - 4
loop
mov_eax_31337

Rotate left yapmadan önce ilk aşamada direk gelen xorkeyi kullaniliyor. Bu yüzden yine xor keyini hesaplayabiliriz. Headerin html olduğunu biliyoruz. Encrypted dosyanın ilk 4byte’ı ile xorlarsak

Key5: = hex(0x3c68746d^0x6a452630): \x56\x2d\x52\x5d

1
2
3
4
byte[0] = flag[20]^flag[40]
byte[1] = flag[21]^flag[41]
byte[2] = flag[22]^flag[42]
byte[3] = flag[23]^flag[43]

Decryption routinini implemente edicek python scripti yazalim:

1
2
3
4
5
6
7
8
9
10
11
12
13
f = open("assets/cxnvhaekljlkjxxqkq","rb")
data = f.read()
f.close()
#rol8 4 iterasyondan sonra kendisine geri dönücek
a = [0x562d525d,0x5d562d52,0x525d562d,0x2d525d56]

f = open("bam.html","wb")

for i in range(int(len(data)/4)):

f.write(xor(data[4*i:4*i+4],p32(a[i%4])))

f.close()

Bam.htmli ilk açtığımız apk dosyasından hatırlarsak :

1
2
3
4
5
6
7
8
9
File file = new File(mainActivity.getFilesDir(), "bam.html");
WebView webView = mainActivity.mWebView;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("file:///");
stringBuilder.append(file.getAbsolutePath());
stringBuilder.append("?flag=");
stringBuilder.append(Uri.encode(str));
webView.loadUrl(stringBuilder.toString());
z = mValid;

Son aşama olarak flag stringi bu html dosyasına parametre olarak gidiyor. Html dosyasını açtığımızda obfuscated bir javascriptle karşılaşıyoruz. theempire_ saolsun bu adımı tak diye çözdü. Flagin 24. karakterinden sornasinın => pHd_1w_e4rL13r;)} ‘a eşit olması gerektiğini anlıyoruz.

Elimizde 5 key ve flagin 24-44 arası karakterleri var.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
key0_0 = "4 ^ 12 ^ 20 ^ 28 ^ 36"
key0_1 = "5 ^ 13 ^ 21 ^ 29 ^ 37"
key0_2 = "6 ^ 14 ^ 22 ^ 30 ^ 38"
key0_3 = "7 ^ 15 ^ 23 ^ 31 ^ 39"

key1_0 = "8 ^ 16 ^ 24 ^ 32 ^ 40"
key1_1 = "9 ^ 17 ^ 25 ^ 33 ^ 41"
key1_0 = "10 ^ 18 ^ 26 ^ 34 ^ 42"
key1_1 = "11 ^ 19 ^ 27 ^ 35 ^ 43"

key2_0 = "12 ^ 24 ^ 36"
key2_1 = "13 ^ 25 ^ 37"
key2_2 = "14 ^ 26 ^ 38"
key2_3 = "15 ^ 27 ^ 39"

key3_0 = "16 ^ 32"
key3_1 = "17 ^ 33"
key3_2 = "18 ^ 34"
key3_3 = "19 ^ 35"

key4_0 = "20 ^ 40"
key4_1 = "21 ^ 41"
key4_2 = "22 ^ 42"
key4_3 = "23 ^ 43"

Biraz kopya cekerek script yazarsak.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from pwn import *
key0 = b'\x17\x01\x2f\x03'
key1 = b'\x3c\x27\x43\x60'
key2 = b'\x6e\x63\x27\x4e'
key3 = b'\x42\x18\x33\x13'
key4 = b'\x56\x2d\x52\x5d'

f6, f7, f8, f9, f10 = group(4, ' => pHd_1w_e4rL13r;)')
f5 = xor(key4, f10)
f4 = xor(key3, f8)
f3 = xor(xor(key2, f6), f9)
f2 = xor(xor(xor(xor(key1, f4), f6), f8), f10)
f1 = xor(xor(xor(xor(xor(key0, key1), f3), f5), f7), f9)

theflag = 'OOO{' + f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + '}'
print theflag

flag : OOO{pox&mpuzz,U_solve_it => pHd_1w_e4rL13r;)}