2023西湖论剑RE--BabyRE

XiaozaYa

已于 2023-03-05 18:13:44 修改

阅读量562

点赞数 1

文章标签：安全 Powered by 金山文档

于 2023-03-05 15:54:59 首次发布

本文链接：https://blog.csdn.net/qq_61670993/article/details/129345972

版权

用IDA打开附件，搜索字符串发现“Good, flag is DASCTF{your input}”字符串

一直交叉引用，发现以下三个函数

下面分析中的部分函数名，变量名和变量类型我做了修改

一、sub_401000函数

该函数先调用sub_401170函数，然后注册了一个退出函数sub_405770

进入sub_401170函数：该函数逻辑为输入字符串到Input，输入字符在'0'~'9'之间

进入sub_405770函数，最后跟踪到一个rc4算法函数

算法逻辑，首先将Input_base8(经过处理的Input)复制给data，大小为112(0x70)，然后对data数据进行rc4加密，密钥长度为6。最后将加密的data与cipher比较，如果相等则sucess!

所以我们需要做的是将cipher进行解密得到data(即Input_base8)，然后对解密后的data进行某种处理即可得到flag

其中cipher数据如下：

二、sub_401050函数

该函数先调用sub_401230函数，然后注册了一个退出函数sub_4057B0

进入sub_401230函数：该函数逻辑为将table_0_7数组的值取反

其中table_0_7内容如下：对其取反后变成0 1 2 3 4 5 6 7

进入sub_4057B0函数：该函数调用了sub_401CC0函数，跟进该函数可以发现该函数并没有对Input_base8进行处理

三、sub_4010A0函数

该函数先调用sub_4012B0函数，然后注册了一个退出函数sub_4057F0

进入sub_4012B0函数：取了句柄，加载dll，具体不知道干了啥，但这不影响

进入sub_4057F0函数：跟踪到sub_401670函数，可以看到这里有一个base_8函数对Input进行了处理，跟进base_8看看。

进入base_8函数：这个算法很简单，跟base64差不多。这里的table_0_7经过前面的分析知道是一个0~7的表。该函数就是把一个字符串每三个比特位变成一个8进制数，不足3位则在后面补0。

eg：字符串123 其二进制为：00110001 00110010 00110011 则三个为一组：

001 100 010 011 001 000 110 011 ==>14231063

综上分析：

Input 经过base_8编码经过rc4加密得到 cipher。所以：将cipher经过rc4解密 base_8解码后即可得到flag

cipher已知所以只需要得到rc4解密(加密，rc4为对称加密算法)时的密钥即可，但可以发现存储的key的值为0。这里我以为这里的key是在运行时动态生成的，但在IDA中没有发现对key进行操作的算法，动态调试时也没有发现。后来发现Input与key的地址是靠在一起的。

所以这里就明白了，key也是由我们进行输入，从Input到key中间是相差42，所以我们输入的Input应该为48位，后6为就会作为key，而经过前面分析Input的值只能在'0'~'9'之间，也就是说key的值也只能在'0'~'9'之间，所以这里的key可以直接进行爆破。

exp：其中base_8的逆函数的C语言代码是由chatgpt编写，python代码为我自己编写，我写的那个base_8解码函数是存在一定问题的，因为我没有考虑位数不足八位的情况，但是这个题目不影响，因为这个题目位数恰好是8的倍数。

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

char* base_8_decode(char* encoded_str);

unsigned char cipher[] =
{
  0x3F, 0x95, 0xBB, 0xF2, 0x57, 0xF1, 0x7A, 0x5A, 0x22, 0x61,
  0x51, 0x43, 0xA2, 0xFA, 0x9B, 0x6F, 0x44, 0x63, 0xC0, 0x08,
  0x12, 0x65, 0x5C, 0x8A, 0x8C, 0x4C, 0xED, 0x5E, 0xCA, 0x76,
  0xB9, 0x85, 0xAF, 0x05, 0x38, 0xED, 0x42, 0x3E, 0x42, 0xDF,
  0x5D, 0xBE, 0x05, 0x8B, 0x35, 0x6D, 0xF3, 0x1C, 0xCF, 0xF8,
  0x6A, 0x73, 0x25, 0xE4, 0xB7, 0xB9, 0x36, 0xFB, 0x02, 0x11,
  0xA0, 0xF0, 0x57, 0xAB, 0x21, 0xC6, 0xC7, 0x46, 0x99, 0xBD,
  0x1E, 0x61, 0x5E, 0xEE, 0x55, 0x18, 0xEE, 0x03, 0x29, 0x84,
  0x7F, 0x94, 0x5F, 0xB4, 0x6A, 0x29, 0xD8, 0x6C, 0xE4, 0xC0,
  0x9D, 0x6B, 0xCC, 0xD5, 0x94, 0x5C, 0xDD, 0xCC, 0xD5, 0x3D,
  0xC0, 0xEF, 0x0C, 0x29, 0xE5, 0xB0, 0x93, 0xF1, 0xB3, 0xDE,
  0xB0, 0x70
};

unsigned char key[256];
unsigned char data[256];
unsigned char s[256];

int check_is_valid() {
    
    //printf("checking...\n");
    for (int i = 0; i < 112; ++i) {    
        if (data[i] < '0' || data[i] > '9') return 0;
    }
    printf("key：%s\ndata：%s\n", key, data);
    char *x = base_8_decode((char *)data);
    printf("flag：%s%s\n", x, key);
    return 1;
}

void dfs(char k, int l) {

    key[l] = k;
    int flag = 0;
    if (l == 5) {
        rc4_init(s, key, 6);
        for (int i = 0; i < 112; i++) data[i] = cipher[i];
        rc4_crypt(s, data, 112);
        flag = check_is_valid();
        return;
    }
    if (flag) return;
    for (int i = '0'; i <= '9'; i++) dfs(i, l + 1);

}

char* base_8_decode(char* encoded_str) {
    int encoded_len = strlen(encoded_str);
    int decoded_len = encoded_len / 2 * 3 + ((encoded_len % 2 == 0) ? 0 : ((encoded_len % 4 == 1) ? 1 : 2));
    char* decoded_str = (char*)malloc(decoded_len + 1);

    int idx1 = 0, idx2 = 0, idx3 = 0;
    while (idx1 < encoded_len) {
        // Decode three characters at a time
        char c1 = encoded_str[idx1++];
        char c2 = encoded_str[idx1++];
        char c3 = encoded_str[idx1++];
        char c4 = encoded_str[idx1++];
        char c5 = encoded_str[idx1++];
        char c6 = encoded_str[idx1++];
        char c7 = encoded_str[idx1++];
        char c8 = encoded_str[idx1++];

        char b1 = (c1 - '0') << 5 | (c2 - '0') << 2 | (c3 - '0') >> 1;
        char b2 = (c3 - '0') << 7 | (c4 - '0') << 4 | (c5 - '0') << 1 | (c6 - '0') >> 2;
        char b3 = (c6 - '0') << 6 | (c7 - '0') << 3 | (c8 - '0');

        decoded_str[idx2++] = b1;
        if (idx1 <= encoded_len && c4 != '=') decoded_str[idx2++] = b2;
        if (idx1 <= encoded_len && c7 != '=') decoded_str[idx2++] = b3;
    }
    decoded_str[idx2] = '\0';
    return decoded_str;
}

int main(int argc, char *argv[]) {

    for (int i = '0'; i <= '9'; i++) dfs(i, 0);
    return 0;
}

//rc4算法即crypt.h头文件中函数的实现
unsigned char old_s[256] = { 0 };

void swap(unsigned char *s, int i, int j) {

    unsigned char tmp = 0;
    tmp = s[i];
    s[i] = s[j];
    s[j] = tmp;
}

unsigned char* rc4_init(unsigned char *s, unsigned char *key, unsigned long Len) {

    int i = 0, j = 0;
    char k[256] = { 0 };
    
    for (; i < 256; i++) {
        s[i] = i;
        k[i] = key[i%Len];
    }

    for (i = 0; i < 256; i++) {
        j = (j + s[i] + k[i]) % 256;
        swap(s, i, j);
    }

    //用old_s[i]暂时保留经过初始化的s[i]
    for (i = 0; i < 256; i++) {
        old_s[i] = s[i];
    }
    return old_s;
}

void rc4_crypt(unsigned char *s, unsigned char *Data, unsigned long Len) {

    int i = 0, j = 0, t = 0;
    unsigned long k = 0;

    for (; k < Len; k++) {
        i = (i + 1) % 256;
        j = (j + s[i]) % 256;
        swap(s, i, j);
        t = (s[i] + s[j]) % 256;
        Data[k] ^= s[t];
    }
}

#base_8解码函数python代码
#rc4_cipher为cipher经过rc4解密后的值
#key为爆破出来的的密钥
rc4_cipher = "1523306115230466162304651523346214431471150310701503207116032063140334661543446114434066142304661563446615430464"
key = "807391"
bin_cipher = ""
for i in rc4_cipher:
    bin_cipher += str(bin(int(i)))[2:].rjust(3,'0')
print(bin_cipher)
i = 0
flag = ""
while i < len(bin_cipher):
    w = chr(int(bin_cipher[i:i+8],2))
    if w != "=":
        flag += w
    print(flag)
    i += 8
flag += key
print("flag is DASCTF" + "{" + flag + "}")

结果如下：