攻防世界新手逆向区题解

学完了汇编，刷一下攻防世界新手区的逆向题玩玩

simple-unpack

题目描述

  • 菜鸡拿到了一个被加壳的二进制文件

分析如下

  • strings filename |grep flag 得到不完整flag
  • 说了有壳应该要查壳脱壳
  • 查壳为upx，吾爱破解工具包脱壳失败
  • 扔到kali里upx -d filename脱壳成功
  • strings filename |grep flag得到flag

open-soure

题目描述

  • 菜鸡学逆向学得头皮发麻，终于它拿到了一段源代码
  • 题目直接给出源码如下
    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 <string.h>

    int main(int argc, char *argv[]) {
        if (argc != 4) {
        	printf("what?\n");
        	exit(1);
        }

        unsigned int first = atoi(argv[1]);
        if (first != 0xcafe) {
        	printf("you are wrong, sorry.\n");
        	exit(2);
        }

        unsigned int second = atoi(argv[2]);
        if (second % 5 == 3 || second % 17 != 8) {
        	printf("ha, you won't get it!\n");
        	exit(3);
        }

        if (strcmp("h4cky0u", argv[3])) {
        	printf("so close, dude!\n");
        	exit(4);
        }

        printf("Brr wrrr grr\n");

        unsigned int hash = first * 31337 + (second % 17) * 11 + strlen(argv[3]) - 1615810207;

        printf("Get your key: ");
        printf("%x\n", hash);
        return 0;
    }

    分析如下

  • 很明显要输入三个参数(为什么是3而不是4可参考C语言argc详解)
  • first=0xcafe(有眼就行),注意转换为十进制
  • second需要满足不是5x+3并且取余17为8
  • third=”h4cky0u”(有眼就行)

题解

    1. 直接爆破second，编译源程序然后输入三个参数即可
      1
      2
      3
      4
      gcc 1.c -o flag
      ./flag 51966 25 h4cky0u
      Brr wrrr grr
      Get your key: c0ffee
    1. 直接写出解题脚本如下，运行即可
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      #include <stdio.h>
      #include <string.h>
      int main()
      {
      	int first = 51966;
      	int second = 0;
      	for (int i = 0;; i++)
      	{
      		if (i % 5 != 3 && i % 17 == 8)
      		{
      			second = i;
      			break;
      		}
      	}
      	char third[] = "h4cky0u";
      	unsigned int hash = first * 31337 + (second % 17) * 11 + strlen(third) - 1615810207;
      	printf("%x\n", hash);
      	return 0;
      }

insanity

题目描述

  • 菜鸡觉得前面的题目太难了，来个简单的缓一下

    题解

    1. 我直接strings filename|grep flag就出来了。。。应该是非预期
    1. 非预期解是32位ida打开文件，F5反编译，搜flag字符串就找到了

getit

题目描述

  • 菜鸡发现这个程序偷偷摸摸在自己的机器上搞事情，它决定一探究竟

    思路分析

    反编译得到以下核心代码
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
      LODWORD(v5) = 0;
      while ( (signed int)v5 < strlen(s) )
      {
        if ( v5 & 1 )
          v3 = 1;
        else
          v3 = -1;
        *(&t + (signed int)v5 + 10) = s[(signed int)v5] + v3;
        LODWORD(v5) = v5 + 1;
      }
    }
    以s做正向加密得到t，t便是flag

数据段寻找变量s和t，发现

1
2
s=c61b68366edeb7bdce3c6820314b7498
t=SharifCTF{????????????????????????????????}

解题脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
int main()
{
	int	v3	= 0;
	int	v5	= 0;
	char	s[]	= "c61b68366edeb7bdce3c6820314b7498";
	char	t[]	= "????????????????????????????????";
	while ( v5 < 32 )
	{
		if ( v5 & 1 )
		{
			v3 = 1;
		}else{
			v3 = -1;
		}
		*(&t[v5]) = s[v5] + v3;
		v5++;
	}
	printf( "%s", t );
}

python-trade

题目描述

  • 菜鸡和菜猫进行了一场Py交易

    思路分析

  • 给了个pyc文件，在线反编译pyc文件或者uncompyle得到源码
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    import base64

    def encode(message):
        s = ''
        for i in message:
            x = ord(i) ^ 32
            x = x + 16
            s += chr(x)
        
        return base64.b64encode(s)

    correct = 'XlNkVmtUI1MgXWBZXCFeKY+AaXNt'
    flag = ''
    print 'Input flag:'
    flag = raw_input()
    if encode(flag) == correct:
        print 'correct'
    else:
        print 'wrong'

    解题思路

    思路很清晰，直接写脚本就行
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    import base64
    s=base64.b64decode("XlNkVmtUI1MgXWBZXCFeKY+AaXNt")
    print(s)
    def decode(message):
    	s=''
    	for i in message:
    		x=(i-16)^32
    		s+=chr(x)
    	return s
    print(decode(s))

re1

题目描述

  • 菜鸡开始学习逆向工程，首先是最简单的题目

题目分析&题目思路

  • IDA发现核心逻辑代码
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
     _mm_storeu_si128((__m128i *)&v5, _mm_loadu_si128((const __m128i *)&word_413E34));
      v7 = 0;
      v6 = *(_QWORD *)&byte_413E44;
      v8 = 0;
      printf(&byte_413E4C);
      printf(&byte_413E60);
      printf(&byte_413E80);
      scanf("%s", &v9);
      v3 = strcmp((const char *)&v5, &v9);
      if ( v3 )
        v3 = -(v3 < 0) | 1;
      if ( v3 )
        printf(aFlag);
      else
        printf((const char *)&unk_413E90);
      system("pause");
      return 0;
    }
  • 逻辑很明确，word_413E34的值拷贝到v5，比较v5和v9相等，所以直接看word_413E34，hex中可以直接看到flag

game

题目描述

  • 菜鸡最近迷上了玩游戏，但它总是赢不了，你可以帮他获胜吗？

解题分析

  • 追踪main函数，发现核心加密过程，简单异或，直接写exp就行
    1
    2
    3
    4
    5
    for ( i = 0; i < 56; ++i )
      {
        *(&v5 + i) ^= *(&v62 + i);
        *(&v5 + i) ^= 0x13u;
      }

解题脚本

根据加密逻辑及异或的对称性，直接写出解密脚本即可。

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
# include <stdio.h>
int main() {
	char v[116];
	v[59]= 18;
	v[60]= 64;
	v[61]= 98;
	v[62]= 5;
	v[63]= 2;
	v[64]= 4;
	v[65]= 6;
	v[66]= 3;
	v[67]= 6;
	v[68]= 48;
	v[69]= 49;
	v[70]= 65;
	v[71]= 32;
	v[72]= 12;
	v[73]= 48;
	v[74]= 65;
	v[75]= 31;
	v[76]= 78;
	v[77]= 62;
	v[78]= 32;
	v[79]= 49;
	v[80]= 32;
	v[81]= 1;
	v[82]= 57;
	v[83]= 96;
	v[84]= 3;
	v[85]= 21;
	v[86]= 9;
	v[87]= 4;
	v[88]= 62;
	v[89]= 3;
	v[90]= 5;
	v[91]= 4;
	v[92]= 1;
	v[93]= 2;
	v[94]= 3;
	v[95]= 44;
	v[96]= 65;
	v[97]= 78;
	v[98]= 32;
	v[99]= 16;
	v[100] = 97;
	v[101] = 54;
	v[102] = 16;
	v[103] = 44;
	v[104] = 52;
	v[105] = 32;
	v[106] = 64;
	v[107] = 89;
	v[108] = 45;
	v[109] = 32;
	v[110] = 65;
	v[111] = 15;
	v[112] = 34;
	v[113] = 18;
	v[114] = 16;
	v[115] = 0;
	v[2] =123;
	v[3] =32;
	v[4] =18;
	v[5] =98;
	v[6] =119;
	v[7] =108;
	v[8] =65;
	v[9] =41;
	v[10]= 124;
	v[11]= 80;
	v[12]= 125;
	v[13]= 38;
	v[14]= 124;
	v[15]= 111;
	v[16]= 74;
	v[17]= 49;
	v[18]= 83;
	v[19]= 108;
	v[20]= 94;
	v[21]= 108;
	v[22]= 84;
	v[23]= 6;
	v[24]= 96;
	v[25]= 83;
	v[26]= 44;
	v[27]= 121;
	v[28]= 104;
	v[29]= 110;
	v[30]= 32;
	v[31]= 95;
	v[32]= 117;
	v[33]= 101;
	v[34]= 99;
	v[35]= 123;
	v[36]= 127;
	v[37]= 119;
	v[38]= 96;
	v[39]= 48;
	v[40]= 107;
	v[41]= 71;
	v[42]= 92;
	v[43]= 29;
	v[44]= 81;
	v[45]= 107;
	v[46]= 90;
	v[47]= 85;
	v[48]= 64;
	v[49]= 12;
	v[50]= 43;
	v[51]= 76;
	v[52]= 86;
	v[53]= 13;
	v[54]= 114;
	v[55]= 1;
	v[56]= 117;
	v[57]= 126;
	v[58]= 0;
	int i;
	for ( i = 0;i < 56;++i ) {
		v[2+i] ^= v[59+i];
		v[2+i]^= 0x13u;
	}
	for ( i = 0;i < 56;++i ) {
		printf("%c",v[2+i]);
	}
}

Hello,CTF

题目描述

  • 菜鸡发现Flag似乎并不一定是明文比较

    题目分析

  • 追踪main函数发现字符串”437261636b4d654a757374466f7246756e”
  • 输入的字符会和该字符串做对比，长度为17
  • 十六进制转字符串得到flag为CrackMeJustForFun

logmein

题目描述

  • 菜鸡开始接触一些基本的算法逆向了

题目分析

  • IDA跟随主函数找到核心加密代码
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    v9 = 0;
    strcpy(v8, ":\"AL_RT^L*.?+6/46");
    v7 = 0x65626D61726168LL;
    v6 = 7;
    printf("Welcome to the RC3 secure password guesser.\n", a2, a3);
    printf("To continue, you must enter the correct password.\n");
    printf("Enter your guess: ");
    __isoc99_scanf("%32s", s);
    v3 = strlen(s);
    if ( v3 < strlen(v8) )
      sub_4007C0();
    for ( i = 0; i < strlen(s); ++i )
    {
      if ( i >= strlen(v8) )
        sub_4007C0();
      if ( s[i] != (char)(*((_BYTE *)&v7 + i % v6) ^ v8[i]) )
        sub_4007C0();
    }
  • sub_4007C0函数为密码错误，所以正确的密码指定就是if语句里的判断条件
  • 写出exp即可

解题脚本

  • 注意一下小端序和BYTE与字符串的转换即可
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # include <stdio.h>
    # include <string.h>
    int main()
    {
    int v6=7;
    long long  v7=28537194573619560;
    char v8[]=":\"AL_RT^L*.?+6/46";
    char s[18]="";
    for(int i=0;i<strlen(v8);i++)
    	 s[i]= (char)(*((char *)&v7 + i % v6) ^ v8[i]);
    printf("%s",s);
    }

no-strings-attached

题目描述

  • 菜鸡听说有的程序运行就能拿Flag？

题目分析

  • 跟着wp走的，基础gdb汇编调试
  • 放到IDA分析，找到关键函数名，gdb调试程序，b对函数下断点，r跑起来，n运行到下一步，查看eax寄存器的值，即可得到flag

题解及知识点

1
2
3
4
5
gdb filename：开启gdb调试
b func_name：对函数下断点
r ：程序跑起来
n：运行到下一步
x/sw：查看内存寄存器的值

csaw2013reversing2

题目描述

  • 听说运行就能拿到Flag，不过菜鸡运行的结果不知道为什么是乱码

题目分析

  • IDA分析程序流程
  • 正常程序流程为直接跳过解密flag的程序弹窗，所以为乱码
  • 使用OD修改程序跳转，先使得程序跳转到解密函数，然后再跳转至弹窗界面即可。

    程序题解

  • OD打开程序，搜索Flag找到程序定位点

  • 00301092下断点
  • 修改00301094的je指令跳转到00301096
  • 修改003010B7的jmp指令跳转到003010B9
  • 将INT3修改为NOP(我的电脑会报错，所以改掉)

  • 执行程序得到flag

maze

题目描述

  • 菜鸡想要走出菜狗设计的迷宫

题目分析

  • 四个if可以判断出来是迷宫类问题
  • 根据函数来判断所代表的字符串与方向对应关系
  • 寻找地图求解并得到flag即可

解题方案

Label15之中找到地图，为8*8

1
2
3
4
5
6
7
8
  ******
*   *  *
*** * **
**  * **
*  *#  *
** *** *
**     *
********
  • 右下右右下下左下下下右右右右上上左左
  • 转换为flag即可
  • nctf{o0oo00O000oooo..OO}
本文作者： yd0ng
本文链接： https://yd0ng.github.io/2020/11/03/%E6%94%BB%E9%98%B2%E4%B8%96%E7%95%8C%E6%96%B0%E6%89%8B%E9%80%86%E5%90%91%E5%8C%BA%E9%A2%98%E8%A7%A3/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！
赏

谢谢您的打赏，大家一起加油喔~

支付宝
微信

扫一扫，分享到微信

微信分享二维码

阅读数: 次   
载入天数...载入时分秒...

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

网络安全<br>敬畏技术<br>保持正直