#10 Incidente Panóptico: A Linearidade XOR Quebra o Esquema de Impressão Digital de Posição

Em 25 de agosto de 2025, com a assistência de Cantina e Seal911, a Panoptic conduziu uma operação de resgate white hat, protegendo aproximadamente $400K em fundos em risco [1]. A causa raiz foi uma falha na construção do s_positionsHash: o protocolo usava XOR para agregar hashes Keccak256 de IDs de posição em uma única impressão digital. Embora os hashes Keccak256 individuais permaneçam resistentes a colisões, a linearidade matemática do XOR torna a impressão digital composta insegura. Um atacante pode gerar um conjunto de IDs de posição forjados cujo hash agregado por XOR corresponde a qualquer impressão digital alvo, contornando a verificação de posição do protocolo e retirando colateral sem pagar a dívida.

Contexto

A Panoptic é um protocolo descentralizado de negociação de opções perpétuas construído na Ethereum que permite aos usuários negociar opções de venda e compra.

A função withdraw() possui um parâmetro de entrada positionList, que consiste em um conjunto de tokenIds. Cada tokenId representa uma posição. A função withdraw() verifica o status de dívida de cada posição com base no s_positionsHash e então recupera o colateral do usuário.

Para economizar gas, o protocolo não armazena cada posição (ou seja, tokenId) do usuário. Em vez disso, ele calcula uma impressão digital com base em todos os tokenIds do usuário e a registra em s_positionsHash. Os 8 bits mais significativos de cada s_positionsHash representam numLegs, enquanto os 248 bits inferiores representam o user position hash.

Para cada tokenId passado, o protocolo calcula seu hash, pega os 248 bits inferiores e atualiza o user position hash realizando um XOR bit a bit com os 248 bits inferiores do s_positionsHash atual.

Simultaneamente, countLegs é ajustado com base no intervalo numérico do tokenId: permanece inalterado quando o tokenId é menor que $2^{64}2^\{64\}$, e aumenta em 1, 2 ou 3 quando nos intervalos $(2^{64},2^{112})(2^\{64\},\; 2^\{112\})$, $(2^{112},2^{168})(2^\{112\},\; 2^\{168\})$ e $(2^{168},2^{208})(2^\{168\},\; 2^\{208\})$ respectivamente. Isso é finalmente escrito nos 8 bits superiores do s_positionsHash para atualizar numLegs.

Análise da Vulnerabilidade

A causa raiz é uma falha no algoritmo do contrato para construir o s_positionsHash, especificamente o uso da operação XOR para agregar resultados de hash Keccak256. Embora uma única função hash permaneça segura, a linearidade matemática da operação XOR torna o algoritmo de impressão digital geral (ou seja, a soma XOR de hashes) inseguro [2].

A linearidade implica que um atacante não precisa quebrar a própria função hash (ou seja, reverter o tokenId a partir do hash). Em vez disso, ele pode empregar uma estratégia combinatória: gerando um grande número de tokenIds aleatórios, calculando seu Keccak256(tokenId) e, a partir desses valores de hash, selecionando um subconjunto específico de modo que a soma XOR desses hashes de tokenId corresponda exatamente à impressão digital alvo da vítima.

Isso permite que um atacante passe um conjunto de tokenIds forjados ao chamar withdraw() para passar na verificação de saúde e recuperar todo o colateral correspondente ao s_positionsHash.

Teoria

Suponha que a impressão digital de posição do usuário s_positionsHash tenha um user position hash de $TT$ e numLegs de $kk$, com tokenIds do usuário $\{t_1,t_2,\dots ,t_n\}\backslash \{t\_1,\; t\_2,\; \backslash dots,\; t\_n\backslash \}$. Assim:

$$\underset{i=1}{\overset{k}{⨁}}[\text{Hash}(t_i)(\mathrm{m}\mathrm{o}\mathrm{d}{2}^{248})]=T\backslash bigoplus\_\{i=1\}^\{k\}\; [\backslash text\{Hash\}(t\_i)\; \backslash pmod\{2^\{248\}\}]\; =\; T$$

Aqui, cada valor de hash de 248 bits pode ser visto como um vetor de 248 dimensões.

$$\text{Hash}(t_i)(\mathrm{m}\mathrm{o}\mathrm{d}{2}^{248})=[b_0,b_1,\dots ,b_{247}{]}^T,where{b}_i\in \{0,1\}\backslash text\{Hash\}(t\_i)\; \backslash pmod\{2^\{248\}\}\; =\; [b\_0,\; b\_1,\; \backslash dots,\; b\_\{247\}]^T,\; where\backslash \; b\_i\; \backslash in\; \backslash \{0,\; 1\backslash \}$$

Portanto, $TT$ reside em um espaço de 248 dimensões composto de 0s e 1s (${\mathbb{F}}_2^{248}\backslash mathbb\{F\}\_2^\{248\}$). Neste espaço, a operação XOR é equivalente à adição vetorial (Apêndice I).

O objetivo do atacante é encontrar $nn$ vetores de 248 dimensões $\{v_1,v_2,\dots ,v_n\}\backslash \{v\_1,\; v\_2,\; \backslash dots,\; v\_n\backslash \}$ dentre todos os vetores disponíveis, de modo que os 248 bits inferiores de sua soma XOR sejam iguais a $TT$. Assim, podemos formular o objetivo do atacante como um sistema de equações lineares:

$$x_1{v}_1+x_2{v}_2+\cdots +x_n{v}_n=Tx\_1\; v\_1\; +\; x\_2\; v\_2\; +\; \backslash dots\; +\; x\_n\; v\_n\; =\; T$$

Especificamente, não precisamos tentar construir $TT$ diretamente. Em vez disso, selecionamos $nn$ vetores de hash linearmente independentes $\{v_1,v_2,\dots ,v_n\}\backslash \{v\_1,\; v\_2,\; \backslash dots,\; v\_n\backslash \}$ (onde $nn$ é igual à dimensão 248) e os usamos como vetores coluna para construir uma matriz $n\times nn\; \backslash times\; n$ $AA$:

$$A=[v_1,v_2,\dots ,v_n]A\; =\; [v\_1,\; v\_2,\; \backslash dots,\; v\_n]$$

O problema então se transforma em encontrar um vetor de coeficientes $xx$ tal que:

$$A\cdot x=TA\; \backslash cdot\; x\; =\; T$$

Onde $x=[x_1,x_2,\dots ,x_n{]}^{T}x\; =\; [x\_1,\; x\_2,\; \backslash dots,\; x\_n]^T$, e $x_i\in \{0,1\}x\_i\; \backslash in\; \backslash \{0,\; 1\backslash \}$.

De acordo com a teoria da álgebra linear, desde que a matriz $AA$ seja de posto completo, ela abrange todo o espaço $nn$-dimensional. Isso significa que para qualquer alvo $TT$, o sistema de equações possui uma solução única. Após resolver $xx$, simplesmente retemos os vetores $v_{i}v\_i$ para os quais $x_i=1x\_i=1$; sua soma XOR é $TT$.

Exemplo

Para facilitar a compreensão, demonstramos esse processo de construção com um estudo de caso. Suponha que os vetores sejam tridimensionais, com cada dimensão consistindo apenas de 0 ou 1, e o valor de hash alvo seja 101, ou seja, $T=[1,0,1{]}^{T}T\; =\; [1,\; 0,\; 1]^T$.

Em seguida, geramos aleatoriamente 3 valores de hash:

• $v_1=[1,1,0{]}^{T}v\_1\; =\; [1,\; 1,\; 0]^T$
• $v_2=[0,1,0{]}^{T}v\_2\; =\; [0,\; 1,\; 0]^T$
• $v_3=[0,1,1{]}^{T}v\_3\; =\; [0,\; 1,\; 1]^T$

Construímos a matriz $AA$ usando esses três vetores como colunas e configuramos a equação $Ax=TAx=T$:

Resolvendo via eliminação de Gauss, obtemos $x=[1,0,1{]}^{T}x\; =\; [1,\; 0,\; 1]^T$. Isso significa que precisamos selecionar $v_{1}v\_1$ e $v_{3}v\_3$ (correspondentes a $x_1=1,x_3=1x\_1=1,\; x\_3=1$), e sua soma XOR é exatamente igual ao alvo $TT$.

Selecionando n Vetores Linearmente Independentes

Como mencionado anteriormente, para resolver $Ax=TAx=T$, precisamos construir uma matriz $AA$ de posto completo. Dado que estamos lidando com um espaço vetorial extremamente grande ($m=2^{248}m\; =\; 2^\{248\}$), a questão central é: Como selecionamos rapidamente $nn$ vetores linearmente independentes nesse vasto espaço?

Considere o método mais simples: gerar $nn$ tokenIds aleatoriamente e selecionar seus resultados de hash como vetores.

Sobre ${\mathbb{F}}_2\backslash mathbb\{F\}\_2$, a probabilidade $PP$ de que $nn$ vetores $nn$-dimensionais selecionados aleatoriamente formem uma matriz de posto completo é:

$$P(n)=\prod _{k=0}^{n-1}(1-\frac{2^k}{2^n})P(n)\; =\; \backslash prod\_\{k=0\}^\{n-1\}\; \backslash left(1\; -\; \backslash frac\{2^k\}\{2^n\}\backslash right)$$

Quando $nn$ é grande (neste exemplo, $n=248n=248$), essa probabilidade converge para uma constante (Apêndice II):

$$\underset{n\to \mathrm{\infty }}{\lim }P(n)\approx 0.28879\backslash lim\_\{n\; \backslash to\; \backslash infty\}\; P(n)\; \backslash approx\; 0.28879$$

Isso significa que cada tentativa aleatória tem aproximadamente 28,9% de probabilidade de sucesso. Em média, um atacante precisa de apenas cerca de 3,5 tentativas para encontrar um conjunto de vetores linearmente independentes. Portanto, o custo computacional é extremamente baixo, e o atacante pode rapidamente construir uma matriz $AA$ que satisfaça as condições.

Para controlar o countLegs nos 8 bits superiores, precisamos apenas ajustar o intervalo dos valores de tokenId gerados aleatoriamente com base no countLegs alvo.

Por exemplo, se quisermos que o numLegs na impressão digital forjada seja 0, simplesmente garantimos que os $nn$ tokenIds gerados aleatoriamente sejam todos menores que $2^{64}2^\{64\}$. Como o incremento de leg para tokenIds nesse intervalo é 0, independentemente de quais vetores a solução $xx$ da eliminação de Gauss selecionar, o numLegs acumulado final será inevitavelmente 0.

Análise do Ataque

O resgatador white hat iniciou múltiplas transações de resgate. Por simplicidade, a discussão a seguir é baseada em apenas uma dessas transações [3].

A lógica central consiste nas seguintes 5 etapas:

1. Tomar emprestado 0,23e8 WBTC e 28e18 WETH via flash loan da Aave.
2. Depositar 0,23e8 WBTC e 28e18 WETH no contrato poWBTC e no contrato 0x1f8d_poWETH.
3. Chamar mintOptions() do contrato PanopticPool com um positionIdList normal para tomar fundos emprestados e abrir uma posição alavancada.
4. Chamar withdraw(), passando os tokenIds forjados. Como essas posições forjadas têm um positionSize de 0, a função retorna tokenRequired como 0, o que significa que o colateral total exigido para todas as posições é erroneamente calculado como zero. Enquanto isso, o s_positionsHash gerado por esses tokenIds é exatamente o mesmo que o gerado na etapa 3, permitindo que o resgatador recupere todo o colateral sem pagar nenhuma dívida.
5. Pagar o flash loan e executar a próxima rodada.

Resumo

Este incidente destaca duas falhas combinadas que juntas possibilitaram a retirada não autorizada de colateral.

• XOR não é uma função de agregação segura para hashes. O Keccak256 é resistente a colisões, mas a linearidade do XOR significa que a soma XOR de múltiplos hashes não herda essa propriedade. Construir um conjunto de entradas cujos hashes XOR resultem em qualquer valor alvo se reduz a resolver um sistema de equações lineares sobre ${\mathbb{F}}_2\backslash mathbb\{F\}\_2$, o que é computacionalmente trivial. A composição de hashes requer operações que preservem a resistência a colisões, como concatenação seguida de re-hashing.
• Validação ausente de IDs de posição. O protocolo não verificou se os positionIds passados correspondiam a posições de opção válidas. Valores abaixo de $2^{64}2^\{64\}$ carregam um countLegs de 0 e um positionSize de 0, o que significa que as posições forjadas não geram dívida. Isso permitiu que o atacante passasse na verificação de saúde com requisito de colateral zero enquanto correspondia à impressão digital alvo.

Referência

1. https://x.com/Panoptic_xyz/status/1961187739866644524

2. https://cseweb.ucsd.edu/~mihir/papers/inchash.pdf

3. https://app.blocksec.com/explorer/tx/eth/0x67a45dfe5ff4b190058674d7c791bbdc48e889f319f937c24fa13a5f9093f088

Apêndice

Os dois apêndices a seguir fornecem uma explicação e prova matemática das afirmações no texto principal, a saber, que a operação XOR é equivalente à adição vetorial (Apêndice I) e a probabilidade de que uma matriz aleatória seja de posto completo (Apêndice II).

Apêndice I

No corpo finito ${\mathbb{F}}_2=\{0,1\}\backslash mathbb\{F\}\_2\; =\; \backslash \{0,\; 1\backslash \}$, a adição é definida como adição módulo 2:

Observa-se que isso é idêntico à operação lógica OR Exclusivo (XOR, símbolo $\oplus \backslash oplus$).

Para o espaço vetorial $nn$-dimensional ${\mathbb{F}}_2^n\backslash mathbb\{F\}\_2^n$ (neste caso $n=248n=248$), a adição de dois vetores $u=[u_1,\dots ,u_n{]}^{T}u\; =\; [u\_1,\; \backslash dots,\; u\_n]^T$ e $v=[v_1,\dots ,v_n{]}^{T}v\; =\; [v\_1,\; \backslash dots,\; v\_n]^T$ é definida como adição componente a componente módulo 2:

$$u+v=\left[\begin{array}{c}{u}_1+v_1(\mathrm{m}\mathrm{o}\mathrm{d}2)\\ \mathrm{⋮}\\ u_n+v_n(\mathrm{m}\mathrm{o}\mathrm{d}2)\end{array}\right]=\left[\begin{array}{c}{u}_1\oplus v_1\\ \mathrm{⋮}\\ u_n\oplus v_n\end{array}\right]=u\oplus vu\; +\; v\; =\; \backslash begin\{bmatrix\}\; u\_1\; +\; v\_1\; \backslash pmod\; 2\; \backslash \backslash \; \backslash vdots\; \backslash \backslash \; u\_n\; +\; v\_n\; \backslash pmod\; 2\; \backslash end\{bmatrix\}\; =\; \backslash begin\{bmatrix\}\; u\_1\; \backslash oplus\; v\_1\; \backslash \backslash \; \backslash vdots\; \backslash \backslash \; u\_n\; \backslash oplus\; v\_n\; \backslash end\{bmatrix\}\; =\; u\; \backslash oplus\; v$$

Portanto, no espaço vetorial ${\mathbb{F}}_2^n\backslash mathbb\{F\}\_2^\{n\}$, a adição vetorial é equivalente à operação XOR bit a bit nos componentes do vetor.

Apêndice II

Para que a matriz seja de posto completo, esses $nn$ vetores devem ser linearmente independentes.

O primeiro vetor $v_{1}v\_1$ pode ser qualquer vetor em ${\mathbb{F}}_2^n\backslash mathbb\{F\}\_2^n$ exceto o vetor zero, fornecendo $2^n-12^n\; -\; 1$ escolhas; o segundo vetor $v_{2}v\_2$ não deve residir no subespaço gerado por $\{v_1\}\backslash \{v\_1\backslash \}$, que contém $2^{1}2^1$ vetores, deixando $2^n-22^n\; -\; 2$ escolhas; seguindo essa lógica, o $kk$-ésimo vetor $v_{k}v\_k$ não pode estar no subespaço gerado pelos $k-1k-1$ vetores anteriores, resultando em $2^n-2^{k-1}2^n\; -\; 2^\{k-1\}$ escolhas possíveis.

O número total de tais matrizes (ou seja, a ordem de $GL(n,{\mathbb{F}}_2)GL(n,\; \backslash mathbb\{F\}\_2)$) é:

$$N=\prod _{k=0}^{n-1}(2^n-2^k)=(2^n-1)(2^n-2)(2^n-4)\cdots (2^n-2^{n-1})N\; =\; \backslash prod\_\{k=0\}^\{n-1\}\; (2^n\; -\; 2^k)\; =\; (2^n\; -\; 1)(2^n\; -\; 2)(2^n\; -\; 4)\backslash cdots(2^n\; -\; 2^\{n-1\})$$

E o número total de todas as matrizes $n\times nn\; \backslash times\; n$ possíveis é $(2^n{)}^n=2^{n^2}(2^n)^n\; =\; 2^\{n^2\}$.

Assim, a probabilidade $PP$ é:

$$P=\frac{\prod _{k=0}^{n-1}(2^n-2^k)}{2^{n^2}}=\prod _{k=0}^{n-1}\left(\frac{2^n-2^k}{2^n}\right)=\prod _{k=0}^{n-1}(1-\frac{2^k}{2^n})P\; =\; \backslash frac\{\backslash prod\_\{k=0\}^\{n-1\}\; (2^n\; -\; 2^k)\}\{2^\{n^2\}\}\; =\; \backslash prod\_\{k=0\}^\{n-1\}\; \backslash left(\; \backslash frac\{2^n\; -\; 2^k\}\{2^n\}\; \backslash right)\; =\; \backslash prod\_\{k=0\}^\{n-1\}\; (1\; -\; \backslash frac\{2^k\}\{2^n\})$$

Fazendo $j=n-kj\; =\; n\; -\; k$, podemos reescrever essa expressão como:

$$P=\prod _{j=1}^n(1-\frac{1}{2^j})P\; =\; \backslash prod\_\{j=1\}^\{n\}\; \backslash left(1\; -\; \backslash frac\{1\}\{2^j\}\backslash right)$$

Quando $n\to \mathrm{\infty }n\; \backslash to\; \backslash infty$, esse produto converge para uma constante:

$$P\approx 0.288788P\; \backslash approx\; 0.288788$$

Isso significa que para $nn$ grande, a probabilidade de que uma matriz aleatória seja de posto completo é aproximadamente 28,9%.

Sobre a BlockSec

A BlockSec é um provedor completo de segurança blockchain e conformidade cripto. Desenvolvemos produtos e serviços que ajudam os clientes a realizar auditorias de código (incluindo contratos inteligentes, blockchain e carteiras), interceptar ataques em tempo real, analisar incidentes, rastrear fundos ilícitos e cumprir obrigações AML/CFT, ao longo de todo o ciclo de vida de protocolos e plataformas.

A BlockSec publicou múltiplos artigos de segurança blockchain em conferências de prestígio, relatou vários ataques zero-day em aplicações DeFi, bloqueou múltiplos hacks para resgatar mais de 20 milhões de dólares e protegeu bilhões em criptomoedas.

• Site oficial: https://blocksec.com/

• Conta oficial no Twitter: https://twitter.com/BlockSecTeam

• 🔗 Serviço de Auditoria BlockSec : Enviar uma solicitação

• 🔗 Phalcon Security APP: Agendar uma demonstração

• 🔗 Phalcon Compliance