极客少年挑战赛2022 writeup by 树木

树木有点绿

已于 2022-08-25 16:55:01 修改

阅读量611

点赞数 1

分类专栏： CTF 文章标签：安全网络安全 python

于 2022-08-25 12:00:00 首次发布

本文链接：https://blog.csdn.net/JEWSWS/article/details/126502407

版权

CTF 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

前言

最近强网杯什么的虽然打了，但是排名太低了，写出来怕师傅们笑话qwq

这次写个简单点的WriteUP，嘿嘿嘿

WEB

DSDS

我们直接访问一波环境，发现出现如下内容

百度搜索一波，发现有个叫. DS_Store的文件

直接下载一波，用记事本打开

把所有空格替换成空字符

然后直接访问一手

flag{a0830f190b42f7ce0c7323fd096c3084}

GoGoGo也有Web

下载附件，拿到一个这样的Go文件

我们也是直接采用必应搜索法，搜到这个文章

Go SSTI初探 | tyskillのBlog

对比了一下，发现两段代码相似度很高，再观察代码，发现POST的body部分有个name参数，可以用该参数和Evil函数去读文件，下面放出payload

name={{.Evil "/flag"}}

POST该payload，得到flag

flag{b3e62a1d26068a2a79022afd93870a25}

REVERSE

easy_re

下载附件，发现给了个pyc文件，我们在线反编译一下，得到如下代码

简单读一下代码，发现还是很简单的，先将用户输入的字符串拆分成一个一个字，然后把每个字转Ascii后异或50，然后再加5后返回对应的Ascii字符，拼接在一起与密文进行验证

那么我们直接逆着写就好了，把加号改建好，顺序换一下，代码如下：

import base64

correct = 'WWNYWk5cWEZQckdQVlQ='
s=''
correct_d=base64.b64decode(correct)
for i in correct_d:
    x=ord(i)-5
    x=x^50
    s+=chr(x)
print s

运行得到flag

flag{easy_pyc}

fllaa

在程序的Mainactivity中我们发现其加载了fllaa.so文件，我们手动修改apk为zip并提取

接下来我们获取一下用户输入的部分

将字符串加密后对输入进行处理

随后我们直接分析check函数

我们给打印的字符串赋值，然后将decode后的进行decode

但是每一次都要调用decode函数，且在so文件中RC4的密钥加密过，出题人有点恶心

所以我们选择使用IDA进行动态调试

然后就是对base64编码后的部分进行魔改的RC4，还是很恶心

对前32个内容异或一下0Xc6

剩余部分同样异或0xC6

多异或一个0x73

通过动调我们可以知道decode后的RC4_key为Hikari#a0344y3y#19301211

接下来就可以直接写RC4解密的脚本了

#include<stdio.h>

#include <string.h>

char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

void Rc4_init(unsigned char* S, unsigned char* K, unsigned char* key, unsigned long len)

{

    unsigned char  tmp = 0;

    for (int i = 0; i < 256; ++i)

    {

        S[i] = i;

        K[i] = key[i % len];

    }

    int j = 0;

    for (int i = 0; i < 256; ++i)

    {

        j = (j + S[i] + K[i]) % 256;

        tmp = S[i];

        S[i] = S[j];

        S[j] = tmp;

    }

    return;

}

void Rc4_encrypt(unsigned char* S, unsigned  char* flag, char* flag1)

{

    int len = strlen(flag1);

    int i = 0, j = 0, t = 0;

    unsigned char tmp = 0;

    for (unsigned long k = 0; k < len; ++k)

    {

        i = (i + 1) % 256;

        j = (j + S[i]) % 256;

        tmp = S[i];

        S[i] = S[j];

        S[j] = tmp;

        t = (S[i] + S[j]) % 256;

        flag[k] ^= S[t];

    }

}



int findIndex(char c, char b64_table[])

{

    for (int i = 0; i < 64; ++i)

    {

        if (c == b64_table[i])

            return i;

    }

}

int str_len;

char* base64_decode(char code[], char str[], char b64_table[])

{

    char memstr[200] = { 0 };

    memcpy(memstr, code, strlen(code));



    int len = strlen(code);

    if (strstr(code, "=="))

        str_len = len / 4 * 3 - 2;

    else if (strstr(code, "="))

        str_len = len / 4 * 3 - 1;

    else

        str_len = len / 4 * 3;



    for (int i = 0, i_ = 0; i < len; i += 4, i_ += 3)

    {

        str[i_] = (findIndex(memstr[i], b64_table) << 2) | (findIndex(memstr[i + 1], b64_table) & 0x30) >> 4;

        str[i_ + 1] = (findIndex(memstr[i + 1], b64_table) & 0xf) << 4 | (findIndex(memstr[i + 2], b64_table) & 0x3c) >> 2;

        str[i_ + 2] = (findIndex(memstr[i + 2], b64_table) & 0x03) << 6 | (findIndex(memstr[i + 3], b64_table));

    }

    str[str_len] = 0;

    return str;

}

int main()

{

    unsigned char S[256] = { 0 };

    unsigned char K[256] = { 0 };

    char decode[100] = { 0 };

    char code[512] = { 0xF0, 0x90, 0x10, 0xB7, 0xD1, 0x6E, 0x1D, 0x9A, 0xF0, 0x6D, 0xD8, 0x86, 0x3C, 0xC1, 0xB5, 0x4F,

    0x4D, 0x96, 0x9A, 0x85, 0xD9, 0xEC, 0x42, 0x5A, 0xCB, 0x16, 0x42, 0x9A, 0x4D, 0x32, 0x51, 0xD6,

    0xC6, 0x71, 0x6D, 0xB6, 0xF3, 0x04, 0x48, 0x3A, 0xC2, 0x26, 0x2D, 0xE4, 0x4D, 0x27, 0xBC, 0x3C };

    char key[] = "Hikari#a0344y3y#19301211";

    Rc4_init(S, K, (unsigned char*)key, strlen(key));

    for (int i = 0; i < 48; ++i) {

        code[i] ^= 0x73;

    }

    Rc4_encrypt(S, (unsigned char*)code, code);

    for (int i = 0; i < 48; ++i) {

        code[i] ^= 0xC6;

    }

    base64_decode(code, decode, base64_table);

    printf("%s", decode);

    return 0;

}

运行得到flag

flag{-fll@_s0_n@1ve##you_find_me!!!}

PWN

一道题都不会捏qwq

MISC

1+1=all

下载附件解压，得到flag1和flag2两个文件

先看看flag1

把它缩小后我们发现它跟二维码的相似度非常之高

我们从记事本左下角可以看出一共有160000个字符，所以对它开方，发现是400的二次方

那就一切都说得通了，这是一个400*400的二维码

直接用python把它转换成二维码

from PIL import Image

MAX = 400

pic = Image.new("RGB",(MAX, MAX))

str = "这里是那个txt文档的内容，因为太大了就不写在这里了qwq"

i=0

for y in range (0,MAX):

    for x in range (0,MAX):

        if(str[i] == '1'):

            pic.putpixel([x,y],(0, 0, 0))

        else:

            pic.putpixel([x,y],(255,255,255))

        i = i+1

pic.show()

pic.save("1.png")

运行后得到了半个二维码（CSDN不让发二维码，这里打个马赛克）

那说明另外半个二维码肯定就在flag2中了

我们观察发现这是ZIP文件，尝试了伪加密，发现不对，试着爆破一下，结果爆破出来了

解压这个压缩包，得到个图片

使用010editor打开它，发现它的CRC不正确

猜测是宽高被改了，使用脚本爆破一下CRC，这里百度就能搜到

import zlib

import struct

import  binascii



file = 'flag.png'

fr = open(file,'rb').read()

data = bytearray(fr[12:29])



#crc32key = eval(str(fr[29:33]).replace('\\x','').replace("b'",'0x').replace("'",''))

crc32key = struct.unpack('>I',fr[29:33])[0]&0xffffffff

print(crc32key)

#data = bytearray(b'\x49\x48\x44\x52\x00\x00\x01\xF4\x00\x00\x01\xF1\x08\x06\x00\x00\x00')

n = 4096

for w in range(n):

    width = bytearray(struct.pack('>i', w))

    for h in range(n):

        height = bytearray(struct.pack('>i', h))

        for x in range(4):

            data[x+4] = width[x]

            data[x+8] = height[x]

            #print(data)

        crc32result = zlib.crc32(data)

        if crc32result == crc32key:

            print(crc32key)

            print(width,height)

            print(data)

            newpic = bytearray(fr)

            for x in range(4):

                newpic[x+16] = width[x]

                newpic[x+20] = height[x]

            fw = open(file+'.png','wb')

            fw.write(newpic)

            fw.close

运行脚本，得到下半段二维码