Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2026-1801C — Analisi statica di reverse-engineering delle euristiche di input di movimento nel motore Source 2, che identifica casi limite strutturali nell'automazione dell'input e nelle routine di limitazione della frequenza dei salti. | Kitploit
Strumenti/GitHubGitHub/misterdengi/cve-2026-1801c
Analisi delle VulnerabilitàExploitReverse EngineeringAnalisi di BinariPaper e Ricerca
GitHubmisterdengi/cve-2026-1801c

CVE-2026-1801C

Analisi statica di reverse-engineering delle euristiche di input di movimento nel motore Source 2, che identifica casi limite strutturali nell'automazione dell'input e nelle routine di limitazione della frequenza dei salti.

Vedi Repository
25h 46m faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2026-1801C (QUANTUM-SHIFT) / CVE-2026-180A7 (BAL-JUMP): Analisi Statica delle Euristiche di Input di Movimento in Source 2 (server.dll)

Abstract

Questo documento presenta un'analisi statica di reverse-engineering di due routine di verifica del movimento lato client implementate nel motore di Counter-Strike 2 (server.dll): il valutatore di automazione input / SOCD (sub_1801C6B30, designato CVE-2026-1801C / QUANTUM-SHIFT) e il limitatore di frequenza delle richieste di salto (sub_180A7EDB0, designato CVE-2026-180A7 / BAL-JUMP). Attraverso l'analisi del disassembly e la modellazione matematica formale delle macchine a stati sottostanti, dimostriamo casi limite strutturali in entrambe le euristiche. Nello specifico, documentiamo come la quantizzazione temporale discreta in sub_1801C6B30 crei un confine di classificazione invariante sotto offset di fase fissi a tick singolo, e come si basi su una metrica di intervallo univariata ($\Delta t$) che rimane invariante sotto trigger a singolo impulso bloccati in fase.

sub_180A7EDB0

1. Verifica dell'Automazione Input (sub_1801C6B30)

1.1 Specifica della Routine

  • Binario di Destinazione: server.dll (Build Retail Win64)
  • Offset del Simbolo: 0x1C6B30
  • Interfaccia: void __fastcall sub_1801C6B30(int *pMovementServices, __int64 pPlayerController, __int64 pUserCmdPB)

1.2 Pipeline di Esecuzione e Rappresentazione dello Stato

La routine valuta gli eventi di transizione dei pulsanti di movimento (+moveleft / +moveright) inviati tramite payload CBaseUserCmdPB del client. L'esecuzione segue una pipeline condizionale:

  1. Gating della Velocità: La magnitudine scalare al quadrato della velocità 2D del pawn del giocatore deve superare una soglia statica: $$|v_{xy}|^2 > (0.52 \cdot 260.0)^2 = 18279.04 \text{ unità}^2/\text{s}^2$$
  2. Quantizzazione Temporale: I delta di fase di transizione ($\Delta t_{\text{trans}}$) vengono quantizzati in unità discrete di tick di frame: $$k = \text{round}\left( \frac{\Delta t_{\text{trans}}}{\tau_{\text{tick}}} \right), \quad \tau_{\text{tick}} \approx 15.625\text{ ms}$$
  3. Classificazione Simbolica: Il valore intero $k \in [0, 15]$ viene mappato a un codice evento discreto $c \in {1, 2, 3}$: $$c = \begin{cases} 1 & \text{se } k = 0 \text{ (Transizione ideale a 0 tick)} \ 2 & \text{se } k \ge 1 \text{ e lo stato è Overlap} \ 3 & \text{se } k \ge 1 \text{ e lo stato è Underlap} \end{cases}$$
  4. Archiviazione in Buffer Circolare: Il codice di classificazione $c$ viene memorizzato in un array di cronologia circolare con capacità $N$ (sv_auto_cstrafe_attempt_window, default 100).

1.3 Logica Decompilata (sub_1801C6B30)

root@kitploit:~
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]);
    
    // Gating: Soglia minima di velocità
    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;

    // Assegnazione del Simbolo
    char symbolCode;
    if (roundedTicks == 0)
        symbolCode = 1; // Successo / 0-tick perfetto
    else
        symbolCode = bIsOverlap ? 2 : 3; // Overlap o Underlap

    // Recupero dei puntatori di configurazione ConVar
    unsigned int windowCap = *GetConVarUInt(&unk_181DDBD30, &qword_181DDBD38);
    if (windowCap - 1 > 999)
        return;

    sub_1801ECEA0(pMovementServices, windowCap);

    // Aggiunta del simbolo al buffer circolare
    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;
        }
    }

    // Aggiornamento degli istogrammi di frequenza dei tick discreti
    if (bIsOverlap)
        pMovementServices[roundedTicks + 7]++;
    else
        pMovementServices[roundedTicks + 23]++;

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

    // Valutazione delle metriche di sequenza a finestra scorrevole
    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++;
            }
        }

        // Aggiornamento della finestra scorrevole
        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); // Default 20.0%
            float upperPct = *GetConVarFloat(&unk_181DDBD60, &qword_181DDBD68); // Default 5.0%
            
            dynamicLimit = (lowerPct - upperPct) * successRatio + upperPct;
        }
    }

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

    // Condizione di Violazione: Il limite dinamico supera il rapporto di overlap osservato
    if (dynamicLimit > observedOverlapPct)
    {
        sub_1801ECEA0(pMovementServices, 0); // Svuota lo stato del buffer
        
        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);
            
            // Codice di Disconnessione 162: NETWORK_DISCONNECT_KICKED_INPUTAUTOMATION
            pfnKickClient(pEngine, (unsigned int)(slotIdx - 1), 0, 162);
        }
    }
}

1.4 Modello Matematico e Analisi della Classificazione

Sia $\mathbf{S} = {s_1, s_2, \dots, s_N}$ la sequenza di simboli evento nel buffer di cronologia di dimensione $N$. Il parametro $S_{\text{max}}$ denota il numero massimo di simboli di codice $1$ ($s_i = 1$) all'interno di qualsiasi sottosequenza contigua di lunghezza $L$:

$$S_{\text{max}} = \max_{0 \le j \le N - L} \sum_{i=j}^{j+L-1} \mathbb{I}(s_i = 1)$$

La funzione di soglia adattiva $T(S_{\text{max}})$ è condizionata da $S_{\text{max}} \ge S_{\text{thresh}}$:

$$T(S_{\text{max}}) = \begin{cases} \theta_{\text{upper}} + (\theta_{\text{lower}} - \theta_{\text{upper}}) \cdot \frac{S_{\text{max}} - S_{\text{thresh}}}{L - S_{\text{thresh}}} & \text{se } S_{\text{max}} \ge S_{\text{thresh}} \ 0 & \text{se } S_{\text{max}} < S_{\text{thresh}} \end{cases}$$

Dove i valori di configurazione predefiniti sono definiti come:

  • $L = 15$ (sv_auto_cstrafe_sequence_length)
  • $S_{\text{thresh}} = 10$ (sv_auto_cstrafe_success_threshold)
  • $\theta_{\text{lower}} = 20.0$ (sv_auto_cstrafe_lower_overlap_pct_threshold)
  • $\theta_{\text{upper}} = 5.0$ (sv_auto_cstrafe_upper_overlap_pct_threshold)

Una violazione viene dichiarata se e solo se $T(S_{\text{max}}) > P_{\text{overlap}}$, dove $P_{\text{overlap}}$ è il rapporto campionario degli eventi di codice $2$:

$$P_{\text{overlap}} = \frac{100}{N} \sum_{i=1}^{N} \mathbb{I}(s_i = 2)$$

Invariante Strutturale

Per qualsiasi flusso di input in cui l'offset di fase $\Delta t_{\text{trans}}$ è vincolato in modo tale che $k = \text{round}(\Delta t_{\text{trans}} / \tau_{\text{tick}}) \ge 1$:

  1. $s_i \in {2, 3}$ per tutti gli $i$, producendo $\mathbb{I}(s_i = 1) = 0$.
  2. Di conseguenza, $S_{\text{max}} = 0$.
  3. Poiché $0 < S_{\text{thresh}}$, $T(S_{\text{max}}) = 0$ vale in modo identico.
  4. La disuguaglianza $0 > P_{\text{overlap}}$ risulta falsa per tutti i $P_{\text{overlap}}$ non negativi. Il percorso di valutazione che termina in pfnKickClient rimane non eseguito.

2. Limitazione della Frequenza di Salto (sub_180A7EDB0)

2.1 Specifica della Routine

  • Binario di Destinazione: server.dll (Build Retail Win64)
  • Offset del Simbolo: 0x1A7EDB0
  • Interfaccia: void* __fastcall sub_180A7EDB0(__int64 pMovementServices, __int64 pMoveData)

2.2 Logica Decompilata (sub_180A7EDB0)

root@kitploit:~
void *__fastcall sub_180A7EDB0(__int64 pMovementServices, __int64 pMoveData)
{
    __int64 pPawn = *(_QWORD *)(pMovementServices + 8);
    sub_180C28550(pPawn, 2i64);
    
    if (!*(_QWORD *)(pPawn + 56))
        nullsub_908(pPawn);

    // Valutazione dell'hull di collisione e del contatto con il suolo
    (*(void (__fastcall **)(_QWORD))(**(_QWORD **)(pPawn + 56) + 1624i64))(*(_QWORD *)(pPawn + 56));
    sub_1803CBD30(*(_QWORD *)(pPawn + 56));
    sub_1803CD4C0(*(_QWORD *)(pPawn + 56), v14);

    if (dword_181FDB358)
        --dword_181FDB358;

    // Verifica del bit IN_JUMP (0x2) nella maschera dei pulsanti del comando
    if ((*(_BYTE *)(pPawn + 88) & 2) != 0 || sub_180C28550(pPawn, 2i64))
    {
        _BYTE *pPenaltyActive = (_BYTE *)(pMovementServices + 16);
        if (*pPenaltyActive)
        {
            float curTime = *((float *)off_181C9F350 + 12);
            float lastJumpTime = *(float *)(pMovementServices + 20);
            float penaltyInterval = sub_18029CE70(&unk_181FDB4D8, 0xFFFFFFFFi64); // sv_jump_spam_penalty_time

            // Valutazione dell'intervallo: curTime > lastJumpTime + penaltyInterval
            if (curTime > (penaltyInterval + lastJumpTime))
            {
                if (*pPenaltyActive)
                {
                    sub_180A99DE0(pMovementServices + 16, 0xFFFFFFFFi64, 0xFFFFFFFFi64);
                    *pPenaltyActive = 0; // Azzeramento dello stato di penalità
                }

                // Applicazione dell'impulso di salto
                sub_180A7F550(pMovementServices, pMoveData);

                if (!*pPenaltyActive)
                {
                    sub_180A99DE0(pPenaltyActive, 0xFFFFFFFFi64, 0xFFFFFFFFi64);
                    *pPenaltyActive = 1; // Attivazione dello stato di penalità
                }

                if (sub_180C28550(*(_QWORD *)(pMovementServices + 8), 2i64))
                {
                    // Memorizzazione del timestamp di salto: lastJumpTime = curTime - frameTime
                    *(float *)(pMovementServices + 20) = *((float *)off_181C9F350 + 12) - 
                                                         *((float *)off_181C9F350 + 13);
                }
                return pMovementServices;
            }
        }

        bool bDebugSpam = *GetConVarByte(&unk_181FDB640, &qword_181FDB648);
        if (!bDebugSpam)
        {
            // Applicazione dell'impulso di salto quando il debug della penalità è disabilitato
            sub_180A7F550(pMovementServices, pMoveData);
            if (!*pPenaltyActive)
            {
                sub_180A99DE0(pPenaltyActive, 0xFFFFFFFFi64, 0xFFFFFFFFi64);
                *pPenaltyActive = 1;
            }
            *(float *)(pMovementServices + 20) = *((float *)off_181C9F350 + 12) - 
                                                 *((float *)off_181C9F350 + 13);
        }
    }
    return pMovementServices;
}

2.3 Modello Temporale e Valutazione dell'Intervallo

Sia $t_n$ il timestamp di esecuzione della $n$-esima richiesta di salto, e $\tau_{\text{penalty}}$ il valore di sv_jump_spam_penalty_time (tipicamente $1$ tick, o $\approx 15.625\text{ ms}$). La transizione di stato per il flag di penalità $P \in {0, 1}$ e l'attivazione dell'impulso $I \in {0, 1}$ è definita da:

$$I_n = \begin{cases} 1 & \text{se } P_{n-1} = 0 \text{ oppure } t_n - t_{n-1} > \tau_{\text{penalty}} \ 0 & \text{se } P_{n-1} = 1 \text{ e } t_n - t_{n-1} \le \tau_{\text{penalty}} \end{cases}$$

Analisi degli Input ad Alta Frequenza vs. Bloccati nello Stato a Terra

  1. Flussi di Input ad Alta Frequenza: I flussi di input discreti generati su frame consecutivi producono intervalli $t_n - t_{n-1} \approx \tau_{\text{tick}} \le \tau_{\text{penalty}}$. In questa condizione, $I_n = 0$, sopprimendo la generazione dell'impulso verticale.
  2. Blocco di Fase nello Stato a Terra: Se un comando di salto viene emesso esclusivamente alla transizione di stato verso FL_ONGROUND ($P_{\text{ground}} = 1$), la durata tra le richieste corrisponde alla durata del volo balistico $T_{\text{flight}}$:

$$t_n - t_{n-1} = T_{\text{flight}} \ge \frac{2 \cdot v_z}{g} \approx 300\text{--}500\text{ ms}$$

Poiché $T_{\text{flight}} \gg \tau_{\text{penalty}}$, il predicato $t_n - t_{n-1} > \tau_{\text{penalty}}$ vale incondizionatamente per tutti gli $n$, impedendo l'attivazione del percorso di soppressione.

3. Riepilogo della Mitigazione Strutturale

ComponenteSimbolo di DestinazionePrimitiva AttualeDebolezza AnaliticaMitigazione Proposta
Automazione Inputsub_1801C6B30Classificazione binaria ($k=0$ vs $k \ge 1$) + sogliaL'offset di fase fisso ($k=1$) produce $S_{\text{max}} = 0$ in modo identicoValutare la varianza campionaria $\sigma^2(\Delta t)$ su tutti i $k$; segnalare le distribuzioni a bassa varianza indipendentemente dall'indice del bin
Limitazione della Frequenza di Saltosub_180A7EDB0Confronto scalare del delta temporale ($t_n - t_{n-1} > \tau$)Invariante sotto ritardi di fase in volo ($T_{\text{flight}} \gg \tau$)Valutare la continuità del vettore di velocità e la durata del contatto con il suolo ($\Delta t_{\text{contact}}$)
Scarica lo strumento