攻防世界-parallel-comparator-200 细读程序,详细分析

总代码先看一边，大概知道了有3个for循环。知道了用户输入的是user_string然后调用highly_optimized_parallel_comparsion(user_string)函数，传入用户输入的值user_string，在此 highly_optimized_parallel_comparsion函数中比较，并将返回的结果赋值给is_ok

int main()
{
    char *user_string = (char *)calloc(FLAG_LEN+1, sizeof(char));
    fgets(user_string, FLAG_LEN+1, stdin);
    int is_ok = highly_optimized_parallel_comparsion(user_string);
    if (is_ok)
        printf("You win!\n");
    else
        printf("Wrong!\n");
    return 0;
}

然后仔细看highly_optimized_parallel_comparsion函数
有3个循环。

void * checking(void *arg) {
    char *result = malloc(sizeof(char));
    char *argument = (char *)arg;
    *result = (argument[0]+argument[1]) ^ argument[2];
    return result;
}

int highly_optimized_parallel_comparsion(char *user_string)
{
    int initialization_number;
    int i;
    char generated_string[FLAG_LEN + 1];
    generated_string[FLAG_LEN] = '\0';

	//随机化函数值取值大于64 传值给initialization_number 
    while ((initialization_number = random()) >= 64);
    
    int first_letter;
    /*initialization_number 得到于64的随机值，取余运算，initialization_number % 26)余数肯定是在0~25范畴，
    然后加97，我数学不好，97+0~97+25,应该是97~122的范围内 */
    first_letter = (initialization_number % 26) + 97;

    pthread_t thread[FLAG_LEN];
    char differences[FLAG_LEN] = {0, 9, -9, -1, 13, -13, -4, -11, -9, -1, -7, 6, -13, 13, 3, 9, -13, -11, 6, -7};
    char *arguments[20];
    /*malloc(size_t size) 分配所需的内存空间，并返回一个指向它的指针,这里我们主要关注是 arguments数组，
    知道了arguments1，2，3分别对应first_letter，differences，user_string，同时使用pthread_create函数，
    并调用了checking方法，返回结果是(argument[0]+argument[1]) ^ argument[2] 的result    */
    for (i = 0; i < FLAG_LEN; i++) {
        arguments[i] = (char *)malloc(3*sizeof(char));
        arguments[i][0] = first_letter;
        arguments[i][1] = differences[i];
        arguments[i][2] = user_string[i];

        pthread_create((pthread_t*)(thread+i), NULL, checking, arguments[i]);
    }

    void *result;
    int just_a_string[FLAG_LEN] = {115, 116, 114, 97, 110, 103, 101, 95, 115, 116, 114, 105, 110, 103, 95, 105, 116, 95, 105, 115};
    /* 这里是上面for 循环返回的result结果 ，
    将generated_string赋值，即generated_string=(first_letter+differencs[i]) ^ user_string[i]+just_a_string[i] 
    */
    for (i = 0; i < FLAG_LEN; i++) {
        pthread_join(*(thread+i), &result);
        generated_string[i] = *(char *)result + just_a_string[i];
        free(result);
        free(arguments[i]);
    }

    int is_ok = 1;
    /*generated_string和just_a_string比较，
    即(first_letter+differencs[i]) ^ user_string[i]+just_a_string[i] ==just_a_string 返回1*/
    for (i = 0; i < FLAG_LEN; i++) {
        if (generated_string[i] != just_a_string[i])
            return 0;
    }

    return 1;
}

看highly_optimized_parallel_comparsion函数
有3个循环。
1：随机化函数值取值大于64 传值给initialization_number ，initialization_number 得到于64的随机值，取余运算，initialization_number % 26)余数肯定是在0_{25范畴，然后加97，我数学不好，97+0}97+25,应该是97~122的范围内。
malloc(size_t size) 分配所需的内存空间，并返回一个指向它的指针,这里我们主要关注是 arguments数组，知道了arguments1，2，3分别对应first_letter，differences，user_string，同时使用pthread_create函数，并调用了checking方法，返回结果是(argument[0]+argument[1]) ^ argument[2] 的result

2:第二个for ,是上面for 循环返回的result结果 ，将generated_string赋值，即generated_string=(first_letter+differencs[i]) ^ user_string[i]+just_a_string[i]

3:第三个forgenerated_string和just_a_string比较，即(first_letter+differencs[i]) ^ user_string[i]+just_a_string[i] ！=just_a_string ，则 return 0是异常中断。通过 return 1 表示返回1，正常。

那我们就知道（ first_letter+differencs[i]) ^ user_string[i]+just_a_string[i] ！=just_a_string，那么只能是0+just_a_string[i] ==just_a_string才能正常，所以（ first_letter+differencs[i]) ^ user_string[i]=0。异或a^ b=c,可以推出a^ c=b,所以first_letter+differences[i])^0=user_string[i]
只要知道first_letter+differences[i])^0的值 就得到了正确的flag
写脚本

just_letter =[115, 116, 114, 97, 110, 103, 101, 95, 115, 116, 114, 105, 110, 103, 95, 105, 116, 95, 105, 115]
differences = [0, 9, -9, -1, 13, -13, -4, -11, -9, -1, -7, 6, -13, 13, 3, 9, -13, -11, 6, -7]

first_letter = 97
for j in range(26): #0~25
    result = ''
    first_letter += 1
    for i in range(len(differences)):
        result+=chr((first_letter+differences[i])^0)
    print(result,"--",(first_letter+differences[i]))

flag: lucky_hacker_you_are