队伍成绩：
1029pt/13kill/50名/1396有解/1938登录/2358报名
个人成绩：522pt/5kill/73名/2234有解/7622登录/10147报名
Misc
谍影重重
拿到题目，一个带密码的压缩包，一个配置文件，一个流量包。
压缩包密码说是要拿到api address，大概在流量包里。
配置文件里面看起来只给了一部分必要参数？
根据关键词"config.json" "settings" "clients" "id"查询可以发现，Google首屏结果与V2Ray高度相关，所以推测流量包是VMess协议，后续放出来的hint也证实了这一点。
看下流量包，只有127.0.0.1:37886 - 127.0.0.1:10087的往返流量，发起方是127.0.0.1:37886，所以V2Ray服务器是127.0.0.1:10087
那就想办法解析流量呗，先是去看了一下V2Fly组织（因为原组织Project V的主导者失踪了）对VMess协议的一些数据包细节：VMess 协议 | V2Fly.org。
尝试写Python脚本去解析流量，在第一天中午的时候马上搞定对开头认证信息的解析（因为真的很标准，没啥难度），爆破出了流量的时间戳是1615528982（2021-03-12 14:03:02）。
from hashlib import md5
import hmac
uuid = bytes.fromhex("b831381d-6324-4d53-ad4f-8cda48b30811".replace('-', ''))
t = int(time.time())
target = "4dd11f9b04f2b562b9db539d939f1d52b48b35bf592c09b21545392f73f6cef91143786464578c1c361aa72f638cd0135f25343555f509aef6c74cd2a2b86ee0a9eb3b93a81a541def4763cc54f91ba02681add1b815e8c50e028c76bde0ee8a9593db88d901066305a51a9586a9e377ee100e7d4d33fcfc0453c86b1998a95275cd9368a68820c2a6a540b6386c146ea7579cfe87b2e459856772efdcf0e4c6ab0f11d018a15561cf409cbc00491d7f4d22b7c486a76a5f2f25fbef503551a0aeb90ad9dd246a9cc5e0d0c0b751eb7b54b0abbfef198b1c4e5e755077469c318f20f3e418af03540811ab5c1ea780c886ea2c903b458a26"
while True:
t -= 1
result = hmac.new(uuid, t.to_bytes(8, "big"), md5).digest().hex()
if target[0:32] == result:
print(t, result)
break于是开始尝试写指令部分的解析，这里花了一个小时左右搞定了大致的解析，但是版本号 Ver不知道为什么不是文档说的固定值1，校验 F也不知道为什么算不对，找了一下午+一晚上的原因都没找到，于是进度卡住了。
半夜突然想到可以调用V2Ray项目直接解析看看，于是找找看看有没有现成的解析流量相关的测试接口（因为这种大型项目发版前肯定要验证的），成功找到了proxy/vmess/encoding/encoding_test.go这个测试流程，里面有通过NewServerSession函数对ServerSession进行实例化，然后调用DecodeRequestHeader函数来解析客户端发过来的认证信息+指令部分，跟过去看了下，还有个DecodeRequestBody函数可以解析数据部分，而且这俩传参都是字节流，还有这种好事？
直接把整个项目拉下来，因为对于Golang不太熟悉（之前只写过一个简单的C/S架构网络小项目，所以勉强算会写的程度），所以也有样学样创建测试流程去解析吧，毕竟万一创建主程序出事了呢？
package encoding_test
import (
"bytes"
"encoding/hex"
"fmt"
"github.com/v2fly/v2ray-core/v5/common"
"testing"
"github.com/v2fly/v2ray-core/v5/common/protocol"
"github.com/v2fly/v2ray-core/v5/proxy/vmess"
. "github.com/v2fly/v2ray-core/v5/proxy/vmess/encoding"
)
func TestCtf(t *testing.T) {
user := &protocol.MemoryUser{
Level: 0,
Email: "[email protected]",
}
account := &vmess.Account{
Id: "b831381d-6324-4d53-ad4f-8cda48b30811",
AlterId: 0,
}
user.Account = toAccount(account)
userValidator := vmess.NewTimedUserValidator(protocol.DefaultIDHash)
userValidator.Add(user)
defer common.Close(userValidator)
sessionHistory := NewSessionHistory()
defer common.Close(sessionHistory)
server := NewServerSession(userValidator, sessionHistory)
requestHex := "4dd11f9b04f2b562b9db539d939f1d52b48b35bf592c09b21545392f73f6cef91143786464578c1c361aa72f638cd0135f25343555f509aef6c74cd2a2b86ee0a9eb3b93a81a541def4763cc54f91ba02681add1b815e8c50e028c76bde0ee8a9593db88d901066305a51a9586a9e377ee100e7d4d33fcfc0453c86b1998a95275cd9368a68820c2a6a540b6386c146ea7579cfe87b2e459856772efdcf0e4c6ab0f11d018a15561cf409cbc00491d7f4d22b7c486a76a5f2f25fbef503551a0aeb90ad9dd246a9cc5e0d0c0b751eb7b54b0abbfef198b1c4e5e755077469c318f20f3e418af03540811ab5c1ea780c886ea2c903b458a26"
requestBuffer, _ := hex.DecodeString(requestHex)
requestBufferReader := bytes.NewReader(requestBuffer)
requestHeader, err := server.DecodeRequestHeader(requestBufferReader)
if err != nil {
t.Error(err)
}
fmt.Println(requestHeader)
requestBody, err := server.DecodeRequestBody(requestHeader, requestBufferReader)
if err != nil {
t.Error(err)
}
fmt.Println(requestBody)
}然后不出意外地报错了，具体原因的话，猜测是系统当前时间的锅，因为V2Ray的加密是基于当前秒级时间戳的，具体的话，文档里面有写，说是随机取上下30s的时间戳当关键参数，并且其存在贯穿了整个数据交互。那么咱们系统当前时间戳就应该要在1615528982左右才行。
那么想办法hook掉或者硬编码掉取系统当前时间的返回值吧，上面有个vmess.NewTimedUserValidator的调用，看名字应该就是基于用户id+当前时间的验证器，进去看看怎么取当前时间的，发现用的是语言层的函数time.Now()。
跟进去看看实现，先下个断点调一下看看值的格式。
看起来应该是改第一个秒钟sec就行，在第二行加一句sec = 1615528982试试，成功pass掉刚才的测试。
不过RequestHeader和RequestBody似乎都没有文本化的实现，那就去下个断点看看值吧。
看着似乎没有咱们想要的数据啊，就一个代理目标是127.0.0.1:5000，走的TCP，这个之前用Python去解析的时候就知道了。然后用加密协议怎么变成AES-128-GCM了，之前Python解析出来加密方式 Sec字段是3啊，按照文档说的应该是ChaCha20-Poly1305才对。于是去看一下代码里的相关定义，好家伙，文档居然是错的，这文档是得多久没更新也没人看啊...
那看看各自有啥函数能调用吧，应该有读取数据的接口的。
RequestHeader就一个Destination函数，看着应该是解析出代理目标用的，应该是个字段的类型转换器，没啥用。
RequestBody就一个ReadMultiBuffer函数，不过看着似乎很像咱们要的东西。
看一下项目里对这个函数的用法，因为这个函数是buf.Reader来的，所以其他各种地方的用法应该也一样。
看着似乎是要for循环一直判断有没有读完到EOF，这画风...太流式了哈哈哈。
那就照着写吧，成功搞定http请求的解析。
但是着看着没啥东西啊，就一个http://127.0.0.1:5000/out的GET访问，本来刚开始以为这个就是压缩包密码说的那个api address的，但是后来放hint表示需要的是c2的地址。
所以那就继续解析http返回吧。
根据刚才的经验，合理猜测ClientSession类应该会有DecodeResponseHeader和DecodeResponseBody两个方法，那就去用NewClientSession方法实例化咯。代码依旧从项目原本的测试流程里抄。
返回流量的hex的话，因为tcp会有粘包、半包的“特性”，所以根据V2Ray1发1收的流程，下一个发送的非空数据包之前收到数据都是同一个包的半包（实际的网络情况会更复杂，毕竟还有延迟、并发啥的，这题总共就俩非空发送包，所以应该上不用考虑）
第二个数据包（92号数据流）：
package encoding_test
import (
"bytes"
"context"
"encoding/hex"
"fmt"
"github.com/v2fly/v2ray-core/v5/common"
"io"
"testing"
"github.com/v2fly/v2ray-core/v5/common/protocol"
"github.com/v2fly/v2ray-core/v5/proxy/vmess"
. "github.com/v2fly/v2ray-core/v5/proxy/vmess/encoding"
)
func TestCtf(t *testing.T) {
user := &protocol.MemoryUser{
Level: 0,
Email: "[email protected]",
}
account := &vmess.Account{
Id: "b831381d-6324-4d53-ad4f-8cda48b30811",
AlterId: 0,
}
user.Account = toAccount(account)
userValidator := vmess.NewTimedUserValidator(protocol.DefaultIDHash)
userValidator.Add(user)
defer common.Close(userValidator)
sessionHistory := NewSessionHistory()
defer common.Close(sessionHistory)
server := NewServerSession(userValidator, sessionHistory)
requestHex := "4dd11f9b04f2b562b9db539d939f1d52b48b35bf592c09b21545392f73f6cef91143786464578c1c361aa72f638cd0135f25343555f509aef6c74cd2a2b86ee0a9eb3b93a81a541def4763cc54f91ba02681add1b815e8c50e028c76bde0ee8a9593db88d901066305a51a9586a9e377ee100e7d4d33fcfc0453c86b1998a95275cd9368a68820c2a6a540b6386c146ea7579cfe87b2e459856772efdcf0e4c6ab0f11d018a15561cf409cbc00491d7f4d22b7c486a76a5f2f25fbef503551a0aeb90ad9dd246a9cc5e0d0c0b751eb7b54b0abbfef198b1c4e5e755077469c318f20f3e418af03540811ab5c1ea780c886ea2c903b458a26"
requestBuffer, _ := hex.DecodeString(requestHex)
requestBufferReader := bytes.NewReader(requestBuffer)
requestHeader, err := server.DecodeRequestHeader(requestBufferReader)
if err != nil {
t.Error(err)
}
fmt.Println(requestHeader)
requestBody, err := server.DecodeRequestBody(requestHeader, requestBufferReader)
if err != nil {
t.Error(err)
}
fmt.Println(requestBody)
for {
requestBodyBuffer, err := requestBody.ReadMultiBuffer()
if err != nil {
if err == io.EOF {
break
} else {
t.Error(err)
}
}
fmt.Print(requestBodyBuffer.String())
}
fmt.Println()
client := NewClientSession(context.TODO(), false, protocol.DefaultIDHash, 0)
responseHex := "这里贴返回包的hex，特别长，放不下，就不贴了，4a231cf7开头63b871c8结尾的"
responseBuffer, _ := hex.DecodeString(responseHex)
responseBufferReader := bytes.NewReader(responseBuffer)
responseHeader, err := client.DecodeResponseHeader(responseBufferReader)
if err != nil {
t.Error(err)
}
fmt.Println(responseHeader)
responseBody, err := client.DecodeResponseBody(requestHeader, responseBufferReader)
if err != nil {
t.Error(err)
}
fmt.Println(responseBody)
}成功报错了...
到这里进度又卡了好久，因为没想明白为什么还会有问题。
后来半夜的时候一想，文档说返回包用的key和iv是发送包里的，那咱这解析返回头的时候好像没传requestHeader啊？找了下也没地方传，毕竟正常情况下，咱作为一个客户端，key和iv就是自己生成的，没必要传啊。
所以去看下客户端存储key和iv的地方。
再看看怎么赋值的。
这怎么还跟AEAD有关系啊，文档没说啊，文档就说了非AEAD的那个情况，所以文档真的是八百年前的了...
算了不管文档，直接抄过来。然后爆红了，说是private了。
那就public一下这俩字段。
然后是key和iv的来源，和原来一样从客户端自己这边拿肯定不行，因为咱们的客户端是刚建的，不是正常情况，所以就从服务端那边拿咯。
看一下服务器的字段，确实也有存这俩东西。那就也public一下拿来用呗。
if !client.IsAEAD {
client.ResponseBodyKey = md5.Sum(server.RequestBodyKey[:])
client.ResponseBodyIV = md5.Sum(server.RequestBodyIV[:])
} else {
BodyKey := sha256.Sum256(server.RequestBodyKey[:])
copy(client.ResponseBodyKey[:], BodyKey[:16])
BodyIV := sha256.Sum256(server.RequestBodyIV[:])
copy(client.ResponseBodyIV[:], BodyIV[:16])
}但是还是报错了。
这回感觉没啥不对的了，只有那个AEAD是和Auth功能有关，所以关掉客户端的isAEAD看看。
这回报错变了，但是有点不理解是啥意思，去看看报错的代码细节吧。
看了下是在比对返回头的第0个字节和responseHeader，那这就是文档的响应认证 V字段啊，确实忘记这回事了，也和key/iv一样初始化一下。
client.ResponseHeader = server.ResponseHeader成功解析。
那就补上读取过程看看内容。
for {
responseBodyBuffer, err := responseBody.ReadMultiBuffer()
if err != nil {
if err == io.EOF {
break
} else {
t.Error(err)
}
}
fmt.Print(responseBodyBuffer.String())
}
fmt.Println()
成功读取到html内容。看了下主要内容是js里面在解一大段Base64。
但是这里明显没输出完，应该是GoLand的异步日志问题，如果主进程结束太快但是日志又多的话，日志输出的内容有时候会吞掉最后的那部分。
所以根据经验，在结束之前下个断点再放行就没问题。
看了下js的大致逻辑，就是打开页面自动把Base64的解析结果保存成一个文件。
所以直接把返回包的html部分保存一下访问就能拿到一个word。
那么根据之前的hint，c2 api address大概率是在这个word的宏里了，因为宏病毒带cnc太常见了。
本来是打算用oletools去查看宏的，但是尝试了下发现有混淆，而且最后是写了个病毒文件，然后作为Word主题模板的dll文件让Word去调用，最后执行dll里面的cnc相关代码。
也就是说还得逆向？感觉不对啊。直接用云沙箱看看网络请求吧：样本报告-微步在线云沙箱
看了下就一个应该是查本机ip的请求，剩下应该还有三个请求因为域名解析失败没被记录。
推测是微步这个样本分析的是时候，c2服务器已经挂了，所以没解析成，于是又去找了个时间更早的外国沙箱分析报告（因为c2的域名是俄罗斯的，推测国外样本捕获比国内早）：3a5648f7de99c4f87331c36983fc8adcd667743569a19c8dafdd5e8a33de154d | ANY.RUN - Free Malware Sandbox Online
确实有另外几个请求。
看一下详细的请求情况。
推测satursed.com是主服，主服没反应再看sameastar.ru次服，如果还不行才是微步那个ludiesibut.ru备用服。
先看了下api.ipify.org的请求，确实就是个查ip的api，不是c2。
然后看了下sameastar.ru的请求，确实就是经典的数据统计+加密控制流一条龙的c2请求
所以题目要的api address应该就是下面这几个之一了：
http://satursed.com/8/forum.php
http://sameastar.ru/8/forum.php
http://ludiesibut.ru/8/forum.php
satursed.com/8/forum.php
sameastar.ru/8/forum.php
ludiesibut.ru/8/forum.php
satursed.com
sameastar.ru
ludiesibut.ru
/8/forum.php
8/forum.php
/forum.php
forum.php但是试了好久都不对，md5的大小写也试了，16位32位也试了，愣是没有一个是对的。
最后不抱希望地试了下api.ipify.org的md5值08229f4052dde89671134f1784bed2d6，结果真是压缩包密码...
这他妈的我查个ip就是c2服务器了？作者不认识c2可以不出题...
解压出来发现有个描述：This is a Gob File!。
那就用degob看看序列化之前的结构体类型吧。
实际上就是个map[string][]byte型，写个反序列化脚本看看。
package main
import (
"encoding/gob"
"fmt"
"io/ioutil"
"math/rand"
"os"
)
func main() {
var a map[string][]byte
File, _ := os.Open("flag")
D := gob.NewDecoder(File)
err := D.Decode(&a)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(a)
}
给了刚才的gob提示、一个时间、一个png文件，但是png被加密了。
根据题目hint，说是数据被随机打乱了，那么和时间放一起，可以联想到Golang的math/rand随机库有个Shuffle功能，正好适合用来打乱，然后时间可以变成时间戳当作随机数种子去使用。
而其最常见的用法如下（来自Shuffle a slice or array · YourBasic Go）：
a := []int{1, 2, 3, 4, 5, 6, 7, 8}
rand.Seed(time.Now().UnixNano())
rand.Shuffle(len(a), func(i, j int) { a[i], a[j] = a[j], a[i] })那就照着这个用法写呗。
package main
import (
"encoding/gob"
"fmt"
"io/ioutil"
"math/rand"
"os"
)
func main() {
var a map[string][]byte
File, _ := os.Open("flag")
D := gob.NewDecoder(File)
err := D.Decode(&a)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(a)
b := make([]byte, len(a["PNG File"]))
copy(b, a["PNG File"])
rand.Seed(1658213396)
rand.Shuffle(len(b), func(i, j int) {
b[i], b[j] = b[j], b[i]
})
err = ioutil.WriteFile("b.png", b, 0777)
if err != nil {
panic(err)
}
}结果发现还是没解开。那再打乱下标尝试一下。
package main
import (
"encoding/gob"
"fmt"
"io/ioutil"
"math/rand"
"os"
)
func main() {
var a map[string][]byte
File, _ := os.Open("flag")
D := gob.NewDecoder(File)
err := D.Decode(&a)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(a)
b := make([]byte, len(a["PNG File"]))
copy(b, a["PNG File"])
c := make([]int, len(b))
for i := 0; i < len(b); i++ {
c[i] = i
}
rand.Seed(1658213396)
rand.Shuffle(len(b), func(i, j int) {
c[i], c[j] = c[j], c[i]
})
for i := 0; i < len(b); i++ {
b[c[i]] = a["PNG File"][i]
}
err = ioutil.WriteFile("b.png", b, 0777)
if err != nil {
panic(err)
}
}成功解开得到如下图片。
找半天发现flag在a通道，但是数据很散。
保存出来去掉0xff应该就行了。
成功得到flag。
flag{898161df-fabf-4757-82b6-ffe407c69475}
Crypto
myJWT
这题就给了个源码和公共容器。
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.security.KeyPair;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.*;
import java.util.Base64;
import java.util.Scanner;
import com.alibaba.fastjson.*;
class ECDSA{
public KeyPair keyGen() throws Exception {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
keyPairGenerator.initialize(384);
KeyPair keyPair = keyPairGenerator.genKeyPair();
return keyPair;
}
public byte[] sign(byte[] str, ECPrivateKey privateKey) throws Exception {
Signature signature = Signature.getInstance("SHA384withECDSAinP1363Format");
signature.initSign(privateKey);
signature.update(str);
byte[] sig = signature.sign();
return sig;
}
public boolean verify(byte[] sig, byte[] str ,ECPublicKey publicKey) throws Exception {
Signature signature = Signature.getInstance("SHA384withECDSAinP1363Format");
signature.initVerify(publicKey);
signature.update(str);
return signature.verify(sig);
}
}
public class jwt{
public static int EXPIRE = 60;
public static ECDSA ecdsa = new ECDSA();
public static String generateToken(String user, ECPrivateKey ecPrivateKey) throws Exception {
JSONObject header = new JSONObject();
JSONObject payload = new JSONObject();
header.put("alg", "myES");
header.put("typ", "JWT");
String headerB64 = Base64.getUrlEncoder().encodeToString(header.toJSONString().getBytes());
payload.put("iss", "qwb");
payload.put("exp", System.currentTimeMillis() + EXPIRE * 1000);
payload.put("name", user);
payload.put("admin", false);
String payloadB64 = Base64.getUrlEncoder().encodeToString(payload.toJSONString().getBytes());
String content = String.format("%s.%s", headerB64, payloadB64);
byte[] sig = ecdsa.sign(content.getBytes(), ecPrivateKey);
String sigB64 = Base64.getUrlEncoder().encodeToString(sig);
return String.format("%s.%s", content, sigB64);
}
public static boolean verify(String token, ECPublicKey ecPublicKey) throws Exception {
String[] parts = token.split("\\.");
if (parts.length != 3) {
return false;
}else {
String headerB64 = parts[0];
String payloadB64 = parts[1];
String sigB64 = parts[2];
String content = String.format("%s.%s", headerB64, payloadB64);
byte[] sig = Base64.getUrlDecoder().decode(sigB64);
return ecdsa.verify(sig, content.getBytes(), ecPublicKey);
}
}
public static boolean checkAdmin(String token, ECPublicKey ecPublicKey, String user) throws Exception{
if(verify(token, ecPublicKey)) {
String payloadB64 = token.split("\\.")[1];
String payloadDecodeString = new String(Base64.getUrlDecoder().decode(payloadB64));
JSONObject payload = JSON.parseObject(payloadDecodeString);
if(!payload.getString("name").equals(user)) {
return false;
}
if (payload.getLong("exp") < System.currentTimeMillis()) {
return false;
}
return payload.getBoolean("admin");
} else {
return false;
}
}
public static String getFlag(String token, ECPublicKey ecPublicKey, String user) throws Exception{
String err = "You are not the administrator.";
if(checkAdmin(token, ecPublicKey, user)) {
File file = new File("/root/task/flag.txt");
BufferedReader br = new BufferedReader(new FileReader(file));
String flag = br.readLine();
br.close();
return flag;
} else {
return err;
}
}
public static boolean task() throws Exception {
Scanner input = new Scanner(System.in);
System.out.print("your name:");
String user = input.nextLine().strip();
System.out.print(String.format("hello %s, let's start your challenge.\n", user));
KeyPair keyPair = ecdsa.keyGen();
ECPrivateKey ecPrivateKey = (ECPrivateKey) keyPair.getPrivate();
ECPublicKey ecPublicKey = (ECPublicKey) keyPair.getPublic();
String menu = "1.generate token\n2.getflag\n>";
Integer choice = 0;
Integer count = 0;
while (count <= 10) {
count++;
System.out.print(menu);
choice = Integer.parseInt(input.nextLine().strip());
if(choice == 1) {
String token = generateToken(user, ecPrivateKey);
System.out.println(token);
} else if (choice == 2) {
System.out.print("your token:");
String token = input.nextLine().strip();
String flag = getFlag(token, ecPublicKey, user);
System.out.println(flag);
input.close();
break;
} else {
input.close();
break;
}
}
return true;
}
public static void main(String[] args) throws Exception {
task();
}
}这题用的验证是ECDSA，而今年这玩意在Java上就有个大洞，具体原理可以看CVE-2022-21449。
通俗地讲，用全0的签名值就可以100%通过验证。
所以就连上去先搞个格式看看。随手输个用户名，然后拿一下token。
得到：
eyJ0eXAiOiJKV1QiLCJhbGciOiJteUVTIn0=.eyJpc3MiOiJxd2IiLCJuYW1lIjoiV2Fua2tvIFJlZSIsImFkbWluIjpmYWxzZSwiZXhwIjoxNjU5MzIxMzI4NDM4fQ==.n9etXBkmMevswYAF1prJ3245n4o-emhq4JVUq4ocoCOfbPpPjJtVB092o0h1U5SgE8b-pKaCstkhxQYH78yXYEpgI-GqHLaIc7DKZ2cHF5IZU6wdci18TFh_YspAIwpn第一段根据之前的代码可以知道是固定的东西，不用管，第二段解码之后是{"iss":"qwb","name":"Wankko Ree","admin":false,"exp":1659321328438}，按照代码的逻辑，需要admin为true，然后过期时间戳要比现在还未来（说人话就是别过期），而传过来的是之前那个时刻的时间戳，所以只要增大就完事。比如说改成{"iss":"qwb","name":"Wankko Ree","admin":true,"exp":1759321328438}，那么其Base64就是eyJpc3MiOiJxd2IiLCJuYW1lIjoiV2Fua2tvIFJlZSIsImFkbWluIjp0cnVlLCJleHAiOjE3NTkzMjEzMjg0Mzh9，然后最后的签名值，全置0就完事，也就是AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA。
所以发送：
eyJ0eXAiOiJKV1QiLCJhbGciOiJteUVTIn0=.eyJpc3MiOiJxd2IiLCJuYW1lIjoiV2Fua2tvIFJlZSIsImFkbWluIjp0cnVlLCJleHAiOjE3NTkzMjEzMjg0Mzh9.AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
就可以拿到flag。
flag{cve-2022-21449_Secur1ty_0f_c0de_1mplementation}
Reverse
GameMaster
拿到题目看一下分析，发现是C#写的，那就直接dnSpy一把梭。
先是在goldFunc找到了奇怪的解码过程。
甚至看情况有AchivePoint1就有AchivePoint2、AchivePoint3，所以继续找。
看过程就是先把Program.memory每字节异或34，然后用那个key（实际上是Brainstorming!!!的ascii化结果）解AES-ECB，存到Program.m，最后反序列化一下。
那先去看看Program.memory是哪里初始化的。
可以看出是从gamemessage文件读取的，那就先写个脚本解一下。
from Crypto.Cipher import AES
def main():
with open('gamemessage', 'rb') as f:
data = bytearray(f.read())
for i in range(len(data)):
data[i] ^= 34
cipher = AES.new(b"Brainstorming!!!", AES.MODE_ECB)
with open('gamemessage.de', 'wb') as f:
f.write(cipher.decrypt(data))
if __name__ == '__main__':
main()成功得到序列化的结果。
在文件尾发现一个dll。
提取出来用dnSpy再看下，大致可以判断出来，Check1函数用array生成array2，然后array2要等于first。然后ParseKey函数用array生成array4，再用array4循环异或array5，就是最后flag。
而关键的array来自num，num又是从之前那个AchivePoint来的，但这玩意不确定具体记录的时候是多少，因为游戏是随机的，分数全看缘分。
那么只能用first和Check1函数的逻辑倒推array了。
就一堆位运算，那就直接z3解方程吧。
from z3 import *
x, y, z = BitVecs('x y z', 64)
solver = Solver()
first = [101, 5, 80, 213, 163, 26, 59, 38, 19, 6, 173, 189, 198, 166, 140, 183, 42, 247, 223, 24, 106, 20, 145, 37, 24, 7, 22, 191, 110, 179, 227, 5, 62, 9, 13, 17, 65, 22, 37, 5]
k = [0 for i in range(40)]
num = -1
for i in range(320):
x = ((x >> 29 ^ x >> 28 ^ x >> 25 ^ x >> 23) & 1) | x << 1
y = ((y >> 30 ^ y >> 27) & 1) | y << 1
z = ((z >> 31 ^ z >> 30 ^ z >> 29 ^ z >> 28 ^ z >> 26 ^ z >> 24) & 1) | z << 1
if i % 8 == 0:
num += 1
k[num] = (k[num] << 1) | ((z >> 32 & 1 & (x >> 30 & 1)) ^ (((z >> 32 & 1) ^ 1) & (y >> 31 & 1)))
for i in range(40):
solver.add(k[i] & 0xff == first[i])
print(solver.check())
print(solver.model())
得到y = 868387187, x = 156324965, z = 3131229747。
那模拟一下ParseKey然后搞一下最后的循环异或就能出结果。
l = [156324965, 868387187, 3131229747]
key = [0 for i in range(12)]
for i in range(3):
for j in range(4):
key[i*4+j] = l[i] >> j * 8 & 0xff
mask = [60, 100, 36, 86, 51, 251, 167, 108, 116, 245, 207, 223, 40, 103, 34, 62, 22, 251, 227]
for i in range(len(mask)):
mask[i] ^= key[i % len(key)]
print(bytes(mask))
flag{Y0u_@re_G3meM3s7er!}
强网先锋
polydiv
题目给了俩文件和一个容器：
class Polynomial2():
'''
模二多项式环，定义方式有三种
一是从高到低给出每一项的系数
>>> Polynomial2([1,1,0,1])
x^3 + x^2 + 1
二是写成01字符串形式
>>> Polynomial2('1101')
x^3 + x^2 + 1
三是直接给出系数为1的项的阶
>>> Poly([3,1,4])
x^4 + x^3 + x
>>> Poly([]) # 加法元
0
>>> Poly(0) # 乘法元
1
>>> Poly(1,2) * Poly(2,3)
x^5 + x^3
'''
def __init__(self,ll):
if type(ll) == str:
ll = list(map(int,ll))
self.param = ll[::-1]
self.ones = [i for i in range(len(self.param)) if self.param[i] == 1] # 系数为1的项的阶数列表
self.Latex = self.latex()
self.b = ''.join([str(i) for i in ll]) # 01串形式打印系数
self.order = 0 # 最高阶
try:self.order = max(self.ones)
except:pass
def format(self,reverse = True):
'''
格式化打印字符串
默认高位在左
reverse = False时，低位在左
但是注意定义多项式时只能高位在右
'''
r = ''
if len(self.ones) == 0:
return '0'
if reverse:
return ((' + '.join(f'x^{i}' for i in self.ones[::-1])+' ').replace('x^0','1').replace('x^1 ','x ')).strip()
return ((' + '.join(f'x^{i}' for i in self.ones)+' ').replace('x^0','1').replace('x^1 ','x ')).strip()
def __call__(self,x):
'''
懒得写了，用不到
'''
print(f'call({x})')
def __add__(self,other):
'''
多项式加法
'''
a,b = self.param[::-1],other.param[::-1]
if len(a) < len(b):a,b = b,a
for i in range(len(a)):
try:a[-1-i] = (b[-1-i] + a[-1-i]) % 2
except:break
return Polynomial2(a)
def __mul__(self,other):
'''
多项式乘法
'''
a,b = self.param[::-1],other.param[::-1]
r = [0 for i in range(len(a) + len(b) - 1)]
for i in range(len(b)):
if b[-i-1] == 1:
if i != 0:sa = a+[0]*i
else:sa = a
sa = [0] * (len(r)-len(sa)) + sa
#r += np.array(sa)
#r %= 2
r = [(r[t] + sa[t])%2 for t in range(len(r))]
return Polynomial2(r)
def __sub__(self,oo):
# 模二多项式环，加减相同
return self + oo
def __repr__(self) -> str:
return self.format()
def __str__(self) -> str:
return self.format()
def __pow__(self,a):
# 没有大数阶乘的需求，就没写快速幂
t = Polynomial2([1])
for i in range(a):
t *= self
return t
def latex(self,reverse=True):
'''
Latex格式打印...其实就是给两位及以上的数字加个括号{}
'''
def latex_pow(x):
if len(str(x)) <= 1:
return str(x)
return '{'+str(x)+'}'
r = ''
if len(self.ones) == 0:
return '0'
if reverse:
return (' + '.join(f'x^{latex_pow(i)}' for i in self.ones[::-1])+' ').replace('x^0','1').replace(' x^1 ',' x ').strip()
return (' + '.join(f'x^{latex_pow(i)}' for i in self.ones)+' ').replace('x^0','1').replace(' x^1 ',' x ').strip()
def __eq__(self,other):
return self.ones == other.ones
def __lt__(self,other):
return max(self.ones) < max(other.ones)
def __le__(self,other):
return max(self.ones) <= max(other.ones)
def Poly(*args):
'''
另一种定义方式
Poly([3,1,4]) 或 Poly(3,1,4)
'''
if len(args) == 1 and type(args[0]) in [list,tuple]:
args = args[0]
if len(args) == 0:
return Polynomial2('0')
ll = [0 for i in range(max(args)+1)]
for i in args:
ll[i] = 1
return Polynomial2(ll[::-1])
PP = Polynomial2
P = Poly
# 简化名称,按长度区分 P 和 PP
if __name__ == '__main__':
p = Polynomial2('10011')
p3 = Polynomial2('11111')
Q = p*p3import socketserver
import os, sys, signal
import string, random
from hashlib import sha256
from secret import flag
from poly2 import *
pad = lambda s:s + bytes([(len(s)-1)%16+1]*((len(s)-1)%16+1))
testCases = 40
class Task(socketserver.BaseRequestHandler):
def _recvall(self):
BUFF_SIZE = 2048
data = b''
while True:
part = self.request.recv(BUFF_SIZE)
data += part
if len(part) < BUFF_SIZE:
break
return data.strip()
def send(self, msg, newline=True):
try:
if newline:
msg += b'\n'
self.request.sendall(msg)
except:
pass
def recv(self, prompt=b'> '):
self.send(prompt, newline=False)
return self._recvall()
def close(self):
self.send(b"Bye~")
self.request.close()
def proof_of_work(self):
random.seed(os.urandom(8))
proof = ''.join([random.choice(string.ascii_letters+string.digits) for _ in range(20)])
_hexdigest = sha256(proof.encode()).hexdigest()
self.send(f"sha256(XXXX+{proof[4:]}) == {_hexdigest}".encode())
x = self.recv(prompt=b'Give me XXXX: ')
if len(x) != 4 or sha256(x+proof[4:].encode()).hexdigest() != _hexdigest:
return False
return True
def guess(self):
from Crypto.Util.number import getPrime
a,b,c = [getPrime(i) for i in [256,256,128]]
pa,pb,pc = [PP(bin(i)[2:]) for i in [a,b,c]]
r = pa*pb+pc
self.send(b'r(x) = '+str(r).encode())
self.send(b'a(x) = '+str(pa).encode())
self.send(b'c(x) = '+str(pc).encode())
self.send(b'Please give me the b(x) which satisfy a(x)*b(x)+c(x)=r(x)')
#self.send(b'b(x) = '+str(pb).encode())
return self.recv(prompt=b'> b(x) = ').decode() == str(pb)
def handle(self):
#signal.alarm(1200)
if not self.proof_of_work():
return
for turn in range(testCases):
if not self.guess():
self.send(b"What a pity, work harder.")
return
self.send(b"Success!")
else:
self.send(b'Congratulations, this is you reward.')
self.send(flag)
class ThreadedServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
#class ForkedServer(socketserver.ForkingMixIn, socketserver.TCPServer):
class ForkedServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
if __name__ == "__main__":
HOST, PORT = '0.0.0.0', 10000
server = ForkedServer((HOST, PORT), Task)
server.allow_reuse_address = True
server.serve_forever()题目的意思其实挺简单的，就是过完POW之后来个40轮的模二多项式环求解，具体就是给了a * b + c == r，已知a、c、r，求b，那不是反向运算就完事嘛：b = (r - c) / a嘛。
结果看了下题目给的Polynomial2没实现div运算...那就上网找吧（因为不太熟悉这玩意）。
结果找着照着就找到了出题人这个类的代码出处：模二多项式环 及 BCH码 的纯python实现和一些问题（不过这个站是盗文站，原文章在CSDN上，但是被删了）
所以把里面的除法实现抄到题目的类里就完事：
def div(self,other):
r,b = self.param[::-1],other.param[::-1]
if len(r) < len(b):
return Polynomial2([0]),self
q=[0] * (len(r) - len(b) + 1)
for i in range(len(q)):
if len(r)>=len(b):
index = len(r) - len(b) + 1 # 确定所得商是商式的第index位
q[-index] = int(r[0] / b[0])
# 更新被除多项式
b_=b.copy()
b_.extend([0] * (len(r) - len(b)))
b_ = [t*q[i] for t in b_]
r = [(r[t] - b_[t])%2 for t in range(len(r))]
for j in range(len(r)): #除去列表最左端无意义的0
if r[0]==0:
r.remove(0)
else:
break
else:
break
return Polynomial2(q),Polynomial2(r)
def __floordiv__(self,other): # 只重载了整除，即//
return self.div(other)[0]然后写个脚本和服务器交互，其中关于表达式解析，我的思路是用题目给的Poly函数去实例化，传入[3,1,4]这种环中1的下标就行，所以就先把结尾的1换成0（因为下标是0），然后去一下两头的换行符啥的，再按 + 去分割一下，再把里面的x、^都给去掉，那就只剩下文本格式的数字了，但是也有特殊情况比如说x会变成空字符，所以额外判断一下长度，有字符就转int，没有下标就肯定是1。然后传给Poly函数就可以开始反向运算了。
def pow(end, sha256_result) -> bytes:
import string
from hashlib import sha256
base = string.ascii_letters+string.digits
for i in base:
for j in base:
for k in base:
for l in base:
pow_key = f"{i}{j}{k}{l}{end}".encode()
if sha256(pow_key).hexdigest() == sha256_result:
print(pow_key)
return pow_key[:4]
def main():
from pwn import connect, context
context.log_level = 'debug'
conn = connect("59.110.212.61", 24906)
conn.recvuntil(b"sha256(XXXX+")
end = conn.recvn(16).decode()
conn.recvuntil(b") == ")
sha256_result = conn.recvn(64).decode()
conn.sendline(pow(end, sha256_result))
for _ in range(40):
conn.recvuntil(b"r(x) = ")
r = conn.recvline().decode().replace('1\n', '0\n').strip().split(' + ')
r = Poly([int(i) if len(i) > 0 else 1 for i in [i.strip("x^") for i in r]])
conn.recvuntil(b"a(x) = ")
a = conn.recvline().decode().replace('1\n', '0\n').strip().split(' + ')
a = Poly([int(i) if len(i) > 0 else 1 for i in [i.strip("x^") for i in a]])
conn.recvuntil(b"c(x) = ")
c = conn.recvline().decode().replace('1\n', '0\n').strip().split(' + ')
c = Poly([int(i) if len(i) > 0 else 1 for i in [i.strip("x^") for i in c]])
conn.recvuntil(b"> b(x) = ")
b = (r - c) // a
conn.sendline(str(b).encode())
print(conn.recvline())
print(conn.recvline())
print(conn.recvline())
print()
if __name__ == '__main__':
main()
成功得到flag。
flag{768782a0-e637-4982-9415-4b8f005e466b}
ASR
题目给的脚本：
from Crypto.Util.number import getPrime
from secret import falg
pad = lambda s:s + bytes([(len(s)-1)%16+1]*((len(s)-1)%16+1))
n = getPrime(128)**2 * getPrime(128)**2 * getPrime(128)**2 * getPrime(128)**2
e = 3
flag = pad(flag)
print(flag)
assert(len(flag) >= 48)
m = int.from_bytes(flag,'big')
c = pow(m,e,n)
print(f'n = {n}')
print(f'e = {e}')
print(f'c = {c}')
'''
n = 8250871280281573979365095715711359115372504458973444367083195431861307534563246537364248104106494598081988216584432003199198805753721448450911308558041115465900179230798939615583517756265557814710419157462721793864532239042758808298575522666358352726060578194045804198551989679722201244547561044646931280001
e = 3
c = 945272793717722090962030960824180726576357481511799904903841312265308706852971155205003971821843069272938250385935597609059700446530436381124650731751982419593070224310399320617914955227288662661442416421725698368791013785074809691867988444306279231013360024747585261790352627234450209996422862329513284149
'''先是n == (p * q * r * s)^2，那就先开方咯。
from gmpy2 import *
n = 8250871280281573979365095715711359115372504458973444367083195431861307534563246537364248104106494598081988216584432003199198805753721448450911308558041115465900179230798939615583517756265557814710419157462721793864532239042758808298575522666358352726060578194045804198551989679722201244547561044646931280001
e = 3
c = 945272793717722090962030960824180726576357481511799904903841312265308706852971155205003971821843069272938250385935597609059700446530436381124650731751982419593070224310399320617914955227288662661442416421725698368791013785074809691867988444306279231013360024747585261790352627234450209996422862329513284149
nn = iroot(n, 2)[0]
assert nn**2 == n
print(nn)得到2872432989693854281918578458293603200587306199407874717707522587993136874097838265650829958344702997782980206004276973399784460125581362617464018665640001。
然后看着p、q、r、s也都不大，就128位，感觉可以yafu直接爆。
跑了十几分钟也确实爆出来了。那按照公式phi = (p^(k-1)) * (p-1) * ...直接求。
结果发现有几个因子的p-1居然和e不互素...
p = 260594583349478633632570848336184053653
q = 218566259296037866647273372633238739089
r = 223213222467584072959434495118689164399
s = 225933944608558304529179430753170813347
assert p*q*r*s == nn
print(gcd((p*(p-1)), e)) # 1
print(gcd((q*(q-1)), e)) # 3
print(gcd((r*(r-1)), e)) # 1
print(gcd((s*(s-1)), e)) # 3这就给我整不会了啊，于是进度就卡这了。第二天随便乱试的时候，发现用那俩正常的因子重新构造n == (p * r)^2，可以解出flag，具体原理我也不知道...
from Crypto.Util.number import long_to_bytes
phi = (p*(p-1))*(r*(r-1))
d = invert(e, phi)
m = pow(c, d, p**2*r**2)
print(long_to_bytes(m))
flag{Fear_can_hold_you_prisoner_Hope_can_set_you_free}
Comments NOTHING