CVE-2026-1801C (QUANTUM-SHIFT) / CVE-2026-180A7 (BAL-JUMP): सोर्स 2 (server.dll) में मूवमेंट इनपुट ह्यूरिस्टिक्स का स्टैटिक विश्लेषण

सारांश

यह पेपर काउंटर-स्ट्राइक 2 इंजन (server.dll) में लागू दो क्लाइंट-साइड मूवमेंट सत्यापन रूटीन का स्टैटिक रिवर्स-इंजीनियरिंग विश्लेषण प्रस्तुत करता है: इनपुट ऑटोमेशन / SOCD मूल्यांकनकर्ता (sub_1801C6B30, जिसे CVE-2026-1801C / QUANTUM-SHIFT नामित किया गया है) और जंप अनुरोध दर सीमक (sub_180A7EDB0, जिसे CVE-2026-180A7 / BAL-JUMP नामित किया गया है)। डिसअसेंबली विश्लेषण और अंतर्निहित स्टेट मशीनों के औपचारिक गणितीय मॉडलिंग के माध्यम से, हम दोनों ह्यूरिस्टिक्स में संरचनात्मक एज केस प्रदर्शित करते हैं। विशेष रूप से, हम दस्तावेजित करते हैं कि कैसे sub_1801C6B30 में असतत अस्थायी क्वांटीकरण निश्चित सिंगल-टिक फेज़ ऑफसेट के तहत एक अपरिवर्तनीय वर्गीकरण सीमा बनाता है, और कैसे sub_180A7EDB0 एक यूनीवेरिएंट अंतराल मीट्रिक ($\Delta t$) पर निर्भर करता है जो फेज़-लॉक्ड सिंगल-इम्पल्स ट्रिगर्स के तहत अपरिवर्तनीय रहता है।

---

1. इनपुट ऑटोमेशन सत्यापन (sub_1801C6B30)

1.1 रूटीन विनिर्देश

• लक्ष्य बाइनरी: server.dll (Win64 रिटेल बिल्ड)
• सिंबल ऑफसेट: 0x1C6B30
• इंटरफेस: void __fastcall sub_1801C6B30(int *pMovementServices, __int64 pPlayerController, __int64 pUserCmdPB)

1.2 निष्पादन पाइपलाइन और स्टेट प्रतिनिधित्व

रूटीन क्लाइंट CBaseUserCmdPB पेलोड के माध्यम से प्रस्तुत मूवमेंट बटन ट्रांज़िशन इवेंट (+moveleft / +moveright) का मूल्यांकन करता है। निष्पादन एक सशर्त पाइपलाइन का अनुसरण करता है:

1. वेलोसिटी गेटिंग: प्लेयर पॉन के स्केलर 2D वेलोसिटी परिमाण का वर्ग एक स्थिर थ्रेशोल्ड से अधिक होना चाहिए: $$|v_{xy}|^2 > (0.52 \cdot 260.0)^2 = 18279.04 \text{ unit}^2/\text{s}^2$$
2. अस्थायी क्वांटीकरण: ट्रांज़िशन फेज़ डेल्टा ($\Delta t_{\text{trans}}$) को असतत फ्रेम टिक इकाइयों में क्वांटाइज़ किया जाता है: $$k = \text{round}\left( \frac{\Delta t_{\text{trans}}}{\tau_{\text{tick}}} \right), \quad \tau_{\text{tick}} \approx 15.625\text{ ms}$$
3. प्रतीकात्मक वर्गीकरण: पूर्णांक मान $k \in [0, 15]$ एक असतत इवेंट कोड $c \in {1, 2, 3}$ में मैप होता है: $$c = \begin{cases} 1 & \text{if } k = 0 \text{ (आदर्श 0-टिक ट्रांज़िशन)} \ 2 & \text{if } k \ge 1 \text{ और स्टेट ओवरलैप है} \ 3 & \text{if } k \ge 1 \text{ और स्टेट अंडरलैप है} \end{cases}$$
4. रिंग बफर भंडारण: वर्गीकरण कोड $c$ को क्षमता $N$ के एक वृत्ताकार इतिहास सरणी में संग्रहीत किया जाता है (sv_auto_cstrafe_attempt_window, डिफ़ॉल्ट 100)।

1.3 डीकंपाइल्ड लॉजिक (sub_1801C6B30)

void __fastcall sub_1801C6B30(int *pMovementServices, __int64 pPlayerController, __int64 pUserCmdPB)
{
    if (!pPlayerController || (*(_BYTE *)(pUserCmdPB + 16) & 1) == 0)
        return;

    __int64 pPawn = sub_180B137A0(pPlayerController);
    if (!pPawn || !(*(unsigned __int8 (__fastcall **)(__int64))(*(_QWORD *)pPawn + 3216i64))(pPawn))
        return;

    float *pVel = (float *)sub_1803CBD90(pPawn, &szVelocityBuf);
    float vSq = (pVel[0] * pVel[0]) + (pVel[1] * pVel[1]) + (pVel[2] * pVel[2]);
    
    // गेटिंग: न्यूनतम वेलोसिटी थ्रेशोल्ड
    if (vSq <= 18279.04f)
        return;

    int rawTicks = *(_DWORD *)(pUserCmdPB + 24);
    bool bIsOverlap = (rawTicks >= 0);
    int absTicks = bIsOverlap ? rawTicks : ~rawTicks;

    double curTime = sub_1801F46D0(off_181C9F350);
    if (curTime * 1e-9 * (double)absTicks >= 15.5)
        return;

    int roundedTicks = (int)V_roundd();
    if ((unsigned int)roundedTicks > 15)
        return;

    // प्रतीक असाइनमेंट
    char symbolCode;
    if (roundedTicks == 0)
        symbolCode = 1; // सफलता / परफेक्ट 0-टिक
    else
        symbolCode = bIsOverlap ? 2 : 3; // ओवरलैप या अंडरलैप

    // ConVar कॉन्फ़िगरेशन पॉइंटर्स प्राप्त करें
    unsigned int windowCap = *GetConVarUInt(&unk_181DDBD30, &qword_181DDBD38);
    if (windowCap - 1 > 999)
        return;

    sub_1801ECEA0(pMovementServices, windowCap);

    // वृत्ताकार बफर में प्रतीक जोड़ें
    int bufCap = pMovementServices[0];
    if (bufCap > 0)
    {
        int writeIdx = pMovementServices[6];
        if (writeIdx >= 0 && writeIdx < bufCap)
        {
            *(_BYTE *)(writeIdx + *((_QWORD *)pMovementServices + 1)) = symbolCode;
            if (++pMovementServices[6] == bufCap)
                pMovementServices[6] = 0;
        }
    }

    // असतत टिक आवृत्ति हिस्टोग्राम अपडेट करें
    if (bIsOverlap)
        pMovementServices[roundedTicks + 7]++;
    else
        pMovementServices[roundedTicks + 23]++;

    int seqLen = *GetConVarInt(&unk_181DDBD40, &qword_181DDBD48);
    if ((unsigned int)(seqLen - 1) > 999)
        return;

    // स्लाइडिंग विंडो अनुक्रम मीट्रिक का मूल्यांकन करें
    int totalValid = 0;
    int totalOverlaps = 0;
    int curSequenceSuccesses = 0;
    int maxSequenceSuccesses = 0;

    for (int i = 0; i < (int)windowCap; ++i)
    {
        if (i < bufCap)
        {
            int readIdx = i + pMovementServices[6] - bufCap;
            if (i + pMovementServices[6] < bufCap)
                readIdx = i + pMovementServices[6];

            char sym = *(_BYTE *)(readIdx + *((_QWORD *)pMovementServices + 1));
            if (sym != 0)
            {
                totalValid++;
                if (sym == 2) totalOverlaps++;
                else if (sym == 1) curSequenceSuccesses++;
            }
        }

        // स्लाइडिंग विंडो अपडेट
        if (i >= seqLen && (i - seqLen) >= 0)
        {
            if ((i - seqLen) < bufCap)
            {
                int popIdx = i + pMovementServices[6] - seqLen - bufCap;
                if (i + pMovementServices[6] - seqLen < bufCap)
                    popIdx = i + pMovementServices[6] - seqLen;

                if (*(_BYTE *)(popIdx + *((_QWORD *)pMovementServices + 1)) == 1)
                    curSequenceSuccesses--;
            }
        }

        if (maxSequenceSuccesses < curSequenceSuccesses)
            maxSequenceSuccesses = curSequenceSuccesses;
    }

    int minAttempts = *GetConVarInt(&unk_181DDBD20, &qword_181DDBD28);
    float dynamicLimit = 0.0f;

    if (totalValid >= minAttempts)
    {
        int minSuccessThreshold = *GetConVarInt(&unk_181DDBD50, &qword_181DDBD58);
        if (maxSequenceSuccesses >= minSuccessThreshold)
        {
            float successRatio = 0.0f;
            if (seqLen > minSuccessThreshold)
            {
                successRatio = (float)(maxSequenceSuccesses - minSuccessThreshold) / 
                               (float)(seqLen - minSuccessThreshold);
            }

            float lowerPct = *GetConVarFloat(&unk_181DDBD70, &qword_181DDBD78); // डिफ़ॉल्ट 20.0%
            float upperPct = *GetConVarFloat(&unk_181DDBD60, &qword_181DDBD68); // डिफ़ॉल्ट 5.0%
            
            dynamicLimit = (lowerPct - upperPct) * successRatio + upperPct;
        }
    }

    float observedOverlapPct = ((float)totalOverlaps / (float)totalValid) * 100.0f;

    // उल्लंघन की स्थिति: गतिशील सीमा अवलोकित ओवरलैप अनुपात से अधिक है
    if (dynamicLimit > observedOverlapPct)
    {
        sub_1801ECEA0(pMovementServices, 0); // बफर स्टेट फ्लश करें
        
        bool bEnableKick = *GetConVarByte(&unk_181DDBD90, &qword_181DDBD98);
        if (bEnableKick)
        {
            __int64 pEngine = qword_182012050;
            void (__fastcall *pfnKickClient)(__int64, unsigned int, _QWORD, __int64) = 
                *(void (__fastcall **)(__int64, unsigned int, _QWORD, __int64))(*(_QWORD *)pEngine + 768i64);

            int slotIdx = -1;
            sub_181265470(pPlayerController, &slotIdx);
            
            // डिस्कनेक्ट कोड 162: NETWORK_DISCONNECT_KICKED_INPUTAUTOMATION
            pfnKickClient(pEngine, (unsigned int)(slotIdx - 1), 0, 162);
        }
    }
}

1.4 गणितीय मॉडल और वर्गीकरण विश्लेषण

मान लें कि $\mathbf{S} = {s_1, s_2, \dots, s_N}$ आकार $N$ के इतिहास बफर में इवेंट प्रतीकों के अनुक्रम का प्रतिनिधित्व करता है। पैरामीटर $S_{\text{max}}$ लंबाई $L$ के किसी भी सन्निहित उप-अनुक्रम के भीतर कोड $1$ प्रतीकों ($s_i = 1$) की अधिकतम संख्या को दर्शाता है: