Introduction

In this post we just want to cover a fun bug we found: fun because the math itself is interesting, and fun because it breaks just the right way. The bug is issue #44 in Inferno, which is a Rust implementation of the Limbo MPC-in-the-head zero-knowledge argument, which is an improvement upon the KKW scheme. The bug in the implementation is one character long, surprisingly common, usually not game ending, but over binary extension fields everything breaks in just the right way…

Limbo

Limbo proves satisfiability of an arithmetic circuit $C$ over any field $\FFp$ , usually, applied to small fields, as in Inferno, $\FFp = \FFtwo$ . So every wire carries a binary value, addition is XOR and multiplication is bitwise AND. The advantage is that you don’t pay “embedding into a large field for soundness”-overhead for each of the bits you want to operate on, which means very good concrete computational and communication costs. The “disadvantage” of Limbo is that of classical MPC-in-the-head: communication/verifier cost is linear.

The way that things work in Limbo is that the prover commits to every wire value of $C$ evaluated on $w$ via additive secret sharings between $n$ virtual MPC parties, run “in the prover’s head”; the verifier later opens a subset of the parties’ views and checks consistency.

Linear gates (addition, scalar multiplication) act locally on shares, so the parties evaluate them for free with no additional commitments. Multiplication gates are the hard part: shares of $x_\ell$ and $y_\ell$ do not combine locally into a sharing of $x_\ell \cdot y_\ell$ . So for every multiplication gate $\ell \in [m]$ the prover additionally commits to a sharing of the claimed output $z_\ell$ , and the verifier has to check that the prover did not lie:

\forall \ell \in [m].\ z_\ell = x_\ell \cdot y_\ell

Where $x_\ell, y_\ell$ are the input wires to the $\ell$ -th multiplication gate (themselves linear combinations of earlier wires, hence already shared) and $z_\ell$ is the freshly committed claim. Every multiplication gate contributes a gate error:

e_\ell \coloneqq x_\ell y_\ell - z_\ell \in \FFp

The prover is honest iff every $e_\ell = 0$ . Checking each gate individually is expensive, so Limbo collapses all $m$ gate errors into a single check. The errors live in $\FFp$ , but the verifier picks a challenge $r \in \FFq$ from a large extension field $\FFq \supseteq \FFp$ , in Inferno we have $\FFq = \FFtsf$ , and asks the prover to convince him that:

f(r) \coloneqq \sum_{\ell = 1}^{m} e_\ell \cdot r^\ell = 0

The errors $e_\ell$ become the coefficients of a polynomial $f(X) \in \FFp[X]$ , and $r$ is a uniformly random evaluation point in $\FFq$ . If the prover is honest, $f$ is the zero polynomial and $f(r) = 0$ trivially. If even one $e_\ell$ is non-zero, $f$ is a non-zero polynomial of degree at most $m$ , so by Schwartz-Zippel it vanishes at $r$ with probability at most $m / |\FFq|$ . This is Π-MultCheck from Limbo, §4.1, and the rest of the protocol is built on top of it.

Note: the field $\FFtsf$ in Inferno is not large enough for computational soundness, this is solved by simply repeating the check multiple times in parallel when compiling the protocol with Fiat-Shamir.

The Code

Here is the relevant snippet of round.rs which implements the evaluation of $f(r)$ :

pub(crate) fn round1<S: LinearSharing<F, N>, F: FiniteField, const N: usize>(
    round0: Round<S::SelfWithPrimeField>,
    mults: &[S::SelfWithPrimeField],
    challenge: F,
) -> Round<S> {
    let mut sum = S::default();
    let mut xs = vec![S::default(); round0.xs.len()];
    let mut ys = vec![S::default(); round0.ys.len()];
    let mut r = challenge;
    for (i, ((x, y), z)) in round0
        .xs
        .iter()
        .zip(round0.ys.iter())
        .zip(mults.iter())
        .enumerate()
    {
        sum += S::multiply_by_superfield(z, r);
        xs[i] = S::multiply_by_superfield(x, r);
        ys[i] = S::lift_into_superfield(y);
        r *= r;
    }
    Round { xs, ys, z: Some(sum) }
}

The intent is for r to take the values $r, r^2, r^3, \ldots, r^m$ , the intention is to compute:

\begin{align} \mathsf{sum} &= \sum_i r^i \cdot z_i \\ \mathsf{xs}_i &= r_i \cdot x_i \\ \mathsf{ys}_i &= y_i \end{align}

The triple $(\mathsf{xs}, \mathsf{ys}, \mathsf{sum})$ is the inner-product instance that the rest of the protocol verifies: downstream the verifier checks that $\langle \mathsf{xs}, \mathsf{ys} \rangle = \mathsf{sum}$ . With the intended values, completeness is automatic when the prover is honest ( $z_i = x_i y_i$ ). Soundness reduces to evaluating $f$ at $r$ :

\begin{align} \langle \mathsf{xs}, \mathsf{ys} \rangle - \mathsf{sum} &= \langle \vec{r} \circ \vec{x}, \vec{y} \rangle - \mathsf{sum} \\ &= \sum_i r^i \cdot x_i y_i - \sum_i r^i \cdot z_i \\ &= \sum_i r^i \cdot (x_i y_i - z_i) \\ &= \sum_i r^i \cdot e_i = f(r) \end{align}

So checking $\langle \mathsf{xs}, \mathsf{ys} \rangle = \mathsf{sum}$ is exactly checking $f(r) = 0$ .

The Bug

The problem is that, instead of r *= challenge, the code uses r *= r, maybe you already spotted this. This is repeated squaring, not successive powers, so r actually takes the values: $r, r^2, r^4, r^8, \ldots, r^{2^{m-1}}$ and the check the verifier ends up performing is therefore:

f(r) \coloneqq \sum_{i=0}^{m-1} e_i \cdot r^{2^i} = 0

Where $e_i = x_i y_i - z_i$ is the error at multiplication gate $i$ .

Observe that $f(r)$ does not have degree $m-1$ , but instead has degree $2^{m-1}$ ; which is huge! So the usual soundness argument, based on the Schwartz–Zippel lemma:

f(X) \neq 0 \implies \prob_{r}\left[ f(r) = 0 \right] \leq \frac{\deg(f)}{|\FFq|}

Yields nothing when $m \geq 64$ , in which case the right side is greater than $1$ for Inferno because $\FFq = \FFtsf$ . Okay, so theoretically broken, but is this just a proof gap? It turns out no, to see why, we need to look at the Frobenius endomorphism…

The Frobenius Endomorphism

The Frobenius endomorphism on $\FFtwok$ is the map:

\Frob: \FFtwok \to \FFtwok,\quad \Frob(x) = x^2

Its $i$ -th power is repeated squaring, which is the same as raising to the $2^i$ -th power:

\Frob^i(x) = \underbrace{\Frob(\Frob(\ldots(x)\ldots))}_{i\text{ times}} = x^{2^i}

Linearity.
Observe that $\Frob$ is $\FFtwo$ -linear, because of the “Freshman’s dream”:

\begin{align} \Frob(a + b) &= (a + b)^2 = a^2 + 2ab + b^2 \\ &= a^2 + b^2 = \Frob(a) + \Frob(b) \end{align}

Because $2 = 0$ in characteristic 2, and multiplication by scalars in $\FFtwo$ also works:

\Frob(0 \cdot a) = 0 = 0 \cdot \Frob(a),\quad \Frob(1 \cdot a) = \Frob(a) = 1 \cdot \Frob(a)

Composition of $\FFtwo$ linear maps is also $\FFtwo$ -linear, so every power $\Frob^i$ is also linear. Furthermore, any linear combination of linear maps is of course also linear, so:

X \mapsto \sum_i e_i \cdot \Frob^i(X) = \sum_i \Frob^i(e_i \cdot X) = \sum e_i \cdot X^{2^i}

Where $e \in \FFtwo$ is also a linear map from $\FFq$ to $\FFq$ .

Periodicity.
Finally, on $\FFtwok$ we have $\Frob^k = \Id$ , because for every element of $x \in \FFtwok$ :

x^{2^k-1} = 1 \implies x^{2^k} = x \implies \Frob^k(x) = x

Hence:

\Frob^i = \Frob^{i \bmod k}

Only $k$ distinct powers exist as functions $\FFtwok \to \FFtwok$ : $\Frob^0, \Frob^1, \ldots, \Frob^{k-1}$ .

The Exploit

All of this spells doom…

The obvious issue is that $f(r)$ is a combination of these powers-of-Frobenius, so if e.g.

f(r) = \sum_{i=0}^{64} e_i \cdot r^{2^i}

Then $\vec{e} = (0, 0, \ldots, 0)$ and $\vec{e} = (1, 0, 0, \ldots, -1)$ have the same evaluation for every $r$ since: $x = \Frob^{64}(x)$ so $r - \Frob^{64}(r) = 0$ for every $r$ . Observe that $-1 = 1$ in $\FFtwo$ and the simplest attack is therefore to simply “flip” the results of the two multiplications: pick any two multiplication gates with indices $a \neq b$ but such that $a \equiv b \pmod{64}$ , and set both errors to $1$ :

\begin{align} f(r) &= \Frob^a(r) + \Frob^b(r) \\ &= \Frob^{a \bmod 64}(r) + \Frob^{b \bmod 64}(r) = 0 \end{align}

All this requires is a circuit with more than $64$ multiplication gates, which is pretty certain to be the case, not many useful circuits with less than $65$ multiplications…

However the curious reader might wonder if this could be exploited with fewer than $65$ gates. The answer is yes, partially. If we view $r \in \FFtsf$ as a vector in a $64$ -dimensional $\FFtwo$ -vector space, the attack works whenever:

r \in \ker(f_{e})

Where $f_e$ is the linear map:

r \mapsto \sum_i e_i \cdot \Frob^i(r)

The acceptance probability for this error vector is:

\frac{|\ker(f_e)|}{|\FFtsf|} = 2^{\dim_{\FFtwo}(\ker(f_e)) - 64}

For the attack we only need to exhibit an error vector with a large kernel. Let:

N = \Frob + \Id

This is the map $N(r) = r^2 + r$ . Since $\Frob^{64} = \Id$ on $\FFtsf$ , we have:

N^{64} = (\Frob + \Id)^{64} = \Frob^{64} + \Id = 0

Where we used the Freshman’s dream for commuting maps in characteristic $2$ . Also:

\ker(N) = \{ r \in \FFtsf : r^2 + r = 0 \} = \FFtwo

So $\dim_{\FFtwo}\ker(N) = 1$ . Now consider the kernels obtained by successively applying $N$ :

\begin{align} \{0\} = \ker(N^0) &\subseteq \ker(N) \subseteq \ker(N^2) \\ &\subseteq \cdots \subseteq \ker(N^{64}) = \FFtsf \end{align}

Each step can add at most one dimension. Indeed, modulo $\ker(N^j)$ , the only new information in $r \in \ker(N^{j + 1})$ is $N^j r$ , and this lies in the one-dimensional space $\ker(N)$ . But the chain starts at dimension $0$ and ends at dimension $64$ , so every step adds exactly one dimension to the kernel:

\dim_{\FFtwo}\ker(N^t) = \dim_{\FFtwo}\ker(N^{t - 1}) + 1 = t

Now choose the gate errors so that the broken check is exactly $N^t$ . Expanding $N^t$ gives:

\begin{align} N^t &= (\Frob + \Id)^t = \sum_{i=0}^t \binom{t}{i}\Frob^i \\ &= \sum_{i=0}^t e_i \Frob^i,\quad e_i = \binom{t}{i} \bmod 2 \end{align}

Set the error at gate $i$ to this coefficient $e_i$ . Then:

f_e(r) = \sum_{i=0}^t e_i \Frob^i(r) = N^t(r)

Hence $\dim_{\FFtwo}\ker(f_e) = t$ , and the verifier accepts this error vector with probability $2^{t - 64}$ . For $t = 32$ , the Freshman’s dream gives $N^{32} = \Frob^{32} + \Id$ , so we only need errors at gates $0$ and $32$ . This is a circuit with $33$ multiplication gates. The intended check would have accepted with probability around $33/2^{64}$ , the broken check accepts with probability $2^{-32}$ .