Análise técnica da CVE-2026-88776, um integer underflow pré-autenticação no parser de registros Oracle TNS do nsppe do NetScaler, causando uma escrita fora dos limites e o crash do packet engine.
O NetScaler pode fazer balanceamento de carga de bancos de dados Oracle. Aponte um vserver do tipo ORACLE para ele e o packet engine começa a falar o próprio protocolo Oracle TNS, analisando o tráfego do cliente com um handler integrado. Esse handler mantém uma pequena máquina de estados por conexão para lembrar em que ponto de um registro TNS ele está.
Um desses estados significa "estou no meio de um registro, mais bytes estão chegando." Quando o próximo segmento chega, o handler lê seu comprimento e subtrai 10, porque 10 bytes de cada segmento são cabeçalho.
Ninguém nunca perguntou o que acontece se o segmento tiver menos de 10 bytes.
Envie um. Um segmento anão de 1 a 9 bytes entra nesse estado, o comprimento fica negativo e, como o comprimento vive em um registrador de 16 bits sem sinal, ele não fica negativo. Ele dá a volta para algo enorme, até cerca de 64 KB. O handler então faz memcpy alegremente dessa quantidade de dados do seu pacote para um buffer de rascunho fixo de 0x748 bytes em .bss. O engine não é PIE, então o endereço sendo sobrescrito nunca muda.
Você não precisa fazer login. Você nem precisa de um banco de dados atrás do vserver, porque o appliance responde ao handshake TNS por conta própria. O ataque inteiro é uma única conversa TCP.
Ambas as metades foram demonstradas ao vivo:
O handler armazena seu estado por conexão em [pcb+0x15a]. A maioria dos estados é entediante. O que importa aqui é 0x1F4, que significa "no meio do registro, aguardando continuação", e você direciona uma conexão para ele usando nada além de bytes de protocolo comuns:
record type 6 -> deep-parser state 6 -> byte 0x03 (TTIFUN)
-> state 0x126 -> TTC function byte 0x5e (OALL8)
-> jump table 0x23589e0, index 0x59 -> writer at bfe27b:
[pcb+0x15a] = 0x1F4
O próximo pacote nessa conexão então despacha em 0x1F4, através de bd49a7 para bd5362, e chega aqui:
bd5432: memset(0x30a7e60, 0, 0x748) ; scratch region (ends 0x30a85a8)
bd5445: mov rcx,[rbp-0x208] ; inbound packet buffer
bd544c: movzx eax,WORD [rcx+0xf2] ; u16 wire length of the segment
bd5453: add eax,0xfffffff6 ; len = len - 10 <== THE UNDERFLOW
bd5456: mov WORD [0x30a8476],ax ; wrapped length PERSISTED to .bss
bd545d: movzx edx,ax ; memcpy length (1..9 -> 0xfff7..0xffff)
bd5460: mov rsi,[rcx+0xe8]
bd5467: add rsi,0xa ; src = payload + 10
bd546b: mov edi,0x30a8075 ; dst = FIXED .bss global
bd5470: call 1b075e0 ; memcpy: up to ~64 KB OOB write
bd5475: mov BYTE [0x30a8478],1
Leia como uma frase. Pegue o comprimento do segmento. Subtraia 10. Armazene o resultado, passe-o para memcpy, pronto. Em nenhum momento algo pergunta se "comprimento menos 10" ainda é um número que faz sentido.
Contamos todas as referências a esse campo de comprimento nesta função. Trinta delas. Exatamente uma é uma verificação, em bd4083, e tudo o que ela faz é comparar com zero. Um segmento de comprimento zero é rejeitado. Todos os outros comprimentos, incluindo de 1 a 9, seguem direto para a subtração.
O código claramente acredita que a máquina de estados terá entregado um registro suficientemente completo quando o estado 0x1F4 for executado. A máquina de estados nunca prometeu nada disso. Um segmento truncado chegando como seu próprio pacote satisfaz todas as condições de despacho e aparece cinco bytes a menos.
A parte verdadeiramente irritante é que o fornecedor conhece essa classe de bug. Em outro ponto do mesmo binário, sub_119c940 faz a aritmética idêntica de comprimento menos constante e a protege com cmp eax,0x3f9 / ja. O padrão seguro estava ali o tempo todo. Este local simplesmente não o usou.
O destino, 0x30a8075, fica dentro de uma região de rascunho de 0x748 bytes com apenas 0x533 bytes de espaço legítimo à sua frente. A cópia com wraparound ultrapassa isso e invade as globais DataStream e de negociação ao lado, com seus bytes. E o próprio comprimento com wraparound é persistido em 0x30a8476, de onde o código posterior o lê de volta e confia nele. Essa é uma segunda via de corrupção, a um passo de distância do memcpy.
A configuração é uma linha de configuração, uma implantação padrão de DataStream:
add lb vserver v ORACLE <ip> 1521
Nenhum backend é necessário. O appliance termina o TNS por conta própria e constrói o seu próprio pacote Accept, incluindo a string de fornecedor "Netscaler" e tudo o mais.
A conversa decorre em quatro passos:
1. TNS Connect (version 0x13A)
<- the appliance answers Resend(11), then Accept(2), 32 bytes, v0x139
2. one complete, benign TTC round-trip
(some builds like to glue your runt onto the previous segment;
this resets the segmentation so the runt lands alone)
3. the arming segment: a TNS Data packet whose declared length is
actual + 32, carrying TTC bytes {03 5E} (TTIFUN / OALL8)
-> the state machine latches [pcb+0x15a] = 0x1F4, mid-record
4. the runt: 1-9 bytes, sent as its own TCP segment
-> passes the zero check, dispatches on 0x1F4
-> length - 10 wraps
-> memcpy(0x30a8075, payload+10, ~0xFFF6)
-> the packet engine dies
Os passos 1 a 3 são pura conversa. O passo 4 tem cinco bytes.
Isto foi disparado duas vezes num appliance 14.1-73.30, mesma máquina, mesma build, duas execuções independentes. Em ambas as vezes o motor de pacotes recebeu SIGSEGV com um core dump correspondente, o ns.log registou o sinal 11 dentro da janela, e o dataplane ficou inativo durante o warm restart de ~60 segundos.
O controlo negativo passou em ambas as execuções. Execute a conversa idêntica mas faça com que o segmento final seja 10 bytes coerentes e nada acontece. O motor processa-o e continua. O comprimento runt é a única variável que importa.