Code-based Signatures from New Proofs of Knowledge for the Syndrome Decoding Problem

Loïc Bidoux^1, Philippe Gaborit^2, Mukul Kulkarni^1, Victor Mateu^1
$^1$ Technology Innovation Institute, UAE
$^2$ University of Limoges, France

In this paper, we study code-based signatures constructed from Proof of Knowledge (PoK).
This line of work can be traced back to Stern who introduces the first efficient PoK for the syndrome decoding problem in 1993 [43].
Afterward, different variations were proposed in order to reduce signature's size.
In practice, obtaining a smaller signature size relies on the interaction of two main considerations: (i) the underlying protocol and its soundness error and (ii) the type of optimizations which are compatible with a given protocol.
In particular, optimizations related to the possibility to use random seeds instead of mere vectors have a great impact on the final signature length.
Over the years, different variations were proposed to improve the Stern scheme such as the Veron scheme (with public key a noisy codeword rather than a syndrome) [47], the AGS scheme which is a 5-pass protocol with cheating probability asymptotically equal to 1/2 [4] and more recently the FJR approach which permits to decrease the cheating probability to 1/N but induces a performance overhead [26].
Overall the length of the signature depends on a trade-off between: the
scheme in itself, the possible optimizations and the cost of the
implementation. For instance, depending on the application one may prefer
a 30% shorter signature at the cost a ten times slower implementation
rather than a longer signature but a faster implementation. The recent
approaches which increase the cost of the implementation opens the door
to many different type of trade-offs.

In this paper we propose three new schemes and different trade-offs,
which are all interesting in themselves, since depending on potential
future optimizations a scheme may eventually become more efficient than
another. All the schemes we propose use a trusted helper:
a first scheme permits to get a 1/2 cheating probability,  a second
scheme permits to decrease the cheating probability in 1/N but with a
different approach than the recent FJR scheme and at last a third scheme
propose a Veron-like adaptation of the FJR scheme in which the public
key is a noisy codeword rather than a syndrome.
We provide an extensive comparison table which lists various trade-offs
between our schemes and previous ones. The table
shows the interest of our constructions for certain type of

§ INTRODUCTION

The goal of post-quantum cryptography is to provide cryptographic schemes that are secure against adversaries using both classical and quantum computers.
Code-based cryptography was introduced by McEliece in 1978 [38] and is nowadays one of the main alternative to classical cryptography.
This is illustrated by the ongoing NIST Post-Quantum Cryptography standardization process [21] whose round 3 features three code-based Key Encapsulation Mechanisms (KEM) [2, 6, 7].
Additional KEM were also considered during the round 2 of the competition; see [10, 5, 8].
Unlike the code-based KEM, designing digital signatures from coding theory has historically been challenging.
Two approaches have been studied in this regard namely signatures from the hash-and-sign paradigm and signatures based on proofs of knowledge (PoK).
Regarding signatures based on the hash-and-sign paradigm, a first (although inefficient) construction was proposed in 2001 [19].
The Wave construction [23] follows the same approach and features small signature sizes.
Regarding code-based signatures from PoK, the Schnorr-Lyubashevsky [41, 36] approach has been successfully used in the rank metric setting by the Durandal scheme [3].
In this paper, we focus on the Fiat-Shamir paradigm [27, 39] which relies on zero knowledge PoK.
In this approach, one transforms an honest verifier zero-knowledge interactive PoK into a signature scheme using the so called Fiat-Shamir heuristic.

The first efficient PoK for the syndrome decoding ($\SD$) problem over $\Ft$ was introduced by Stern in 1993 [43].
In 1997, Véron improved the Stern protocol by designing a protocol based on the general syndrome decoding ($\GSD$) problem rather than the $\SD$ one [47].
The $\SD$ and $\GSD$ problem are equivalent and only differ in the way used to represent the underlying code namely using a parity-check matrix in the former and using a generator matrix in the latter.
Stern and Véron protocols feature a soundness error equal to $2/3$ and as such need to be repeated several times in order to achieve a negligible soundness error.
In 2011, two 5-round code-based PoK reducing the soundness error close to $1/2$ (hence leading to smaller signature sizes) were proposed.
The first one (CVE) relies on the $\SD$ problem over $\Fq$ [22] while the second one (AGS) relies on the $\QCGSD$ problem over $\Ft$ namely the quasi-cyclic variant of the $\GSD$ problem [4].
A zero-knowledge issue impacting $\GSD$ based protocols (Véron and AGS) was identified in [32] and fixed in [9].
In addition, the AGS protocol have been improved by the BGS proposal by using an optimization specifically tailored to the $\QCSD$ problem [14].
Furthermore, it has been shown recently (see related work section bellow for additional details) that one can design a protocol achieving an arbitrarily small soundness error in [28] and [26].
Some of the aforementioned protocols have been adapted to the rank metric setting, see [20, 29, 12].

Recently,  Katz, Kolesnikov and Wang [33], designed a signature
scheme based on PoK  using the MPC-in-the-head paradigm introduced
by [31]. An important highlight of this design is that
it allows one to achieve much smaller soundness errors which can results in shorter
signatures in our case. While this benefit comes at the cost of
slightly involved protocols and performance overhead, with careful analysis and parameter selection it is possible to design signature schemes with acceptable performance and shorter sized using this framework.
Beullens generalized the work of [33] by introducing the notion of PoK with trusted helper and designing new PoK for the Multivariate Quadratic (MQ) problem, Permuted Kernel Problem (PKP) and Short Integer Solution (SIS) problem [13].
In this work, we propose a new code-based proof of knowledge (PoK) systems
with trusted helper for the syndrome decoding problem, and later construct signature schemes from the PoK by using the Fiat-Shamir transformation.

Contributions. We introduce three new PoK with trusted helper for the syndrome decoding problem over $\Ft$.
The first one (denoted PoK 1) is a PoK for the $\SD$ problem achieving a soundness error equal to $1/2$ without any extra assumption such as using quasi-cyclic variants of the problem or working over $\Fq$.
The second one (denoted PoK 2) is a PoK for the $\SD$ problem over $\Ft$ (using its $\GSD$ form to be precise) achieving an arbitrarily small soundness error.
The third one (denoted PoK 3) is a variant of PoK 2 using some ideas from [26].
Our proofs (as well as the [26] one) can leverage the quasi-cyclic variants of the $\SD$ or $\GSD$ problems to improve their performances although this is not mandatory.
Table <ref> compares our new PoK to existing ones with respect to their soundness error as well as their underlying security assumption.
The soundness error is directly linked to the resulting signature size (once the Fiat-Shamir heuristic have been applied) hence the smaller the soundness error is, the more compact the signature can be.
Regarding security assumptions, the $\SD$ problem over $\Ft$ has been arguably more studied than its counterpart over $\Fq$ hence can be considered as a slightly more conservative assumption.
The $\QCSD$ and $\QCGSD$ constitutes structured variants of the initial $\SD$ and $\GSD$ problems and as such are less conservative than the latter although they are believed to be hard by the community.
Similarly to our PoK, protocols over $\Fq$ could also use quasi-cyclicity to improve their performances which is not depicted in Table <ref>.

Soundness     1c|$\SD$/$\GSD$ over $\Ft$     1c|$\mathsf{QC}$-$\SD$/$\GSD$ over $\Ft$     1c|$\SD$/$\GSD$ over $\Fq$
2*2/3     [43]

[47], [9]

3*1/2     3*PoK 1 (Section <ref>)     [4], [9]     3* [22]

[14]

PoK 1 (Section <ref>)

3*1/N     [26]     [26]     3* [28]

PoK 2 (Section <ref>)     PoK 2 (Section <ref>)

PoK 3 (Section <ref>)     PoK 3 (Section <ref>)

PoK for $\SD$/$\GSD$ or $\QCSD$/$\QCGSD$ problems in Hamming metric

In addition, we explain how to transform our PoK with trusted helper into 3-round PoK without helper or 5-round PoK without helper.
These two transformations offer different trade-offs between communication cost and security.
Using 5-round PoK lead to smaller signature sizes however the security proof of the Fiat-Shamir heuristic is less tight in this case.
In practice, this means that one have to take into account attacks such as the one from [35].
We consider both transformations for our PoK 1 and denote the resulting PoK without helper by 3-round PoK 1 and 5-round PoK 1 respectively.
For the PoK 2 and PoK 3, we only consider the first transformation thus leading to PoK without helper denoted 3-round PoK 2 and 3-round PoK 3 respectively.
Furthermore, we present several optimizations for these PoK and describe how to convert them into signature schemes.
Our first signature is built from our 3-round PoK 1 and is denoted Sig 1 (3-round).
It features the most conservative design possible as it relies on the $\SD$ problem over $\Ft$ along with an underlying 3-round structure.
Our second signature is built from our 5-round PoK 1 and is denoted Sig 1 (5-round).
Both signatures can be instantiated using the plain $\SD$ problem or its quasi-cyclic variant $\QCSD$.
Sig 1 (3-round) and Sig 1 (5-round) both outperforms the Stern [43], [47] and [4] schemes with respect to signature size for comparable settings at the cost of a small performance overhead.
In addition, they achieve similar performances to [14] while relying on more conservative security assumptions.
Sig 2 and Sig 3 are constructed from 3-round PoK 2 and 3-round PoK 3 respectively and feature even smaller signature size however at the cost of a bigger performance overhead.
Sig 2 outperforms the recent proposal from [28] but is outperformed by the proposal from [26].
Finally, Sig 3 close this performance gap by mixing PoK 2 with the shared permutation idea from [26].

Related Work.
Gueron, Persichetti and Santini have recently proposed a new code-based signature built from a PoK with trusted helper for the $\SD$ problem over $\Fq$ that achieve an arbitrarily small soundness error [28].
Recently in an independent and concurrent work, Feneuil, Joux and Rivain have proposed a code-based signature based on a PoK for the $\SD$ problem over $\Ft$ that achieves an arbitrarily small soundness error [26].
These works present some similarities with our PoK 2 and its associated signature Sig 2.
A PoK for the $\SD$ problem requires to prove two statements: (i) there exists a value $\bm{x}$ such that $\bm{H} \bm{x}^{\top} = \bm{y}^{\top}$ and (ii) the weight of $\bm{x}$ is small.
To achieve an arbitrarily small soundness error, one need to prove both statements at once which is challenging to do while preserving the zero-knowledge property of the underlying proof.
Indeed, one generally proves the first property by masking $\bm{x}$ using $\bm{u} + \bm{x}$ with a uniform random value $\bm{u}$ and prove the second property by masking $\bm{x}$ using $\pi[\bm{x}]$ for some random permutation $\pi$ while reconciling the two parts of the proof thanks to a third value such as $\pi[\bm{u} + \bm{x}]$.
The authors of [28] solve this issue by revealing the permutation and later canceling it in their proof.
As such, their proposal reveals $\pi$ rather than $\pi[\bm{x}]$ contrarily to existing protocols.
The authors of [26] solve the aforementioned issue by introducing what they called a shared permutation namely by masking the permutation during the computation of some permuted vectors.
Doing so, they are able to compute a value related to $\pi[\bm{u} + \bm{x}]$ from $\bm{u} + \bm{x}$ without revealing anything on $\pi$.
Our PoK 2 relies on another approach by introducing several permutations and revealing all of them but one in order to prove the knowledge of the solution of a permuted $\SD$ problem instance.

We briefly discuss the main differences between these three approaches.
The PoK from [28] relies on the $\SD$ problem over $\Fq$ while our PoK 2 relies on the $\SD$ problem over $\Ft$.
As the $\SD$ problem over $\Ft$ has been arguably more studied than its counterpart over $\Fq$, it can be considered as a more conservative assumption.

Furthermore, using the protocol from [28], one has to send the permutation $\pi$ (which is fixed hence not replaceable by a seed) to prove the weight of $\bm{x}$ while our protocol only requires to send $\pi[\bm{x}]$ (which is a small weight vector hence can be compressed).
As sending a permutation of a vector of size $n$ over $\Fq$ is costly, the communication cost associated to the GPS proposal is bigger than the communication cost of our PoK 2.

In practice, this means that for comparable parameters, our Sig 2 outperforms the signature from [28].

The PoK from [26] and our PoK 2 are more closely related as they are both based on the $\SD$ problem over $\Ft$ and both achieve an arbitrarily small soundness error equal to $1/N$.
As such, they are equivalent from a theoretical point of view.
Nonetheless, the optimized version of the FJR protocol outperforms the optimized version of our PoK 2 in practice.
This is explained by the fact that some optimizations related to commitment compression bring a better improvement for the FJR protocol than for our PoK 2.
As a result, we also introduce PoK 3 which mixes PoK 2 with the shared permutation setting of [26].
Doing so, one can consider that our PoK 3 is a dual version (Véron-like) of the protocol from [26].

Paper Organization. We start by describing some preliminaries related to code-based cryptography and PoK in Section <ref>.
We present our new PoK with trusted helper in Section <ref> and <ref> respectively.
Then, we explain how to remove the trusted helper from the aforementioned protocols in Section <ref>.
Several optimizations reducing the bandwidth cost of these PoK are described in Section <ref>.
We explain how to transform our PoK into signature schemes in Section <ref>.
Parameters for these new signatures are provided in Section <ref> along with a comparison to existing code-based signatures.
To finish, we discuss some generalizations and variants of our PoK in Section <ref>.

§ PRELIMINARIES

Notations. Hereafter, vectors (respectively matrices) are represented using bold lower-case (respectively upper-case) letters.
Also, the vectors are assumed to be row vectors by default, and
we denote the column vectors by transpose of row of vector (such as $\bm{x}^T$).
The Hamming weight (number of non-zero coordinates) of a vector $\bm{x}$ is denoted by $\hw{\bm{x}}$.
For an integer $n > 0$, we use $\hperm{n}$ to denote the symmetric group of all permutations of $n$ elements.
For a finite set $S$, $x \sampler S$ denotes that $x$ is sampled uniformly at random from $S$ while $x \samples{\theta}$ denotes that $x$ is sampled uniformly at random from $S$ using the seed $\theta$.
In addition, we use the acronym $\ppt$ as an abbreviation for the term “probabilistic polynomial time”.
We also call a function negligible and denote it by
$\negl(\cdot)$ if for all sufficiently large $\lambda \in \mathbb{N}$,
$\negl(\lambda) < \lambda^{-c}$, for all constants $c > 0$.

§.§ Code-based Cryptography

We start by defining binary linear codes and quasi-cyclic codes.
Then, we describe the syndrome decoding ($\SD$) and general syndrome decoding ($\GSD$) problems which are hard problems commonly used in code-based cryptography.
These problems are equivalent and differ only in the way used to represent the underlying code namely using a parity-check matrix in the former and using a generator matrix in the latter.
The $\SD$ problem has been proven NP-complete in [17].
In addition, we also introduce the quasi-cyclic problems $\QCSD$ and $\QCGSD$ which are structured variants of the $\SD$ and $\GSD$ problems.

Let $n$ and $k$ be positive integers such that $k < n$. A binary linear $\mathcal{C}$ code (denoted $[n,k]$) is a $k$-dimensional subspace of $\Ftn$.
$\mathcal{C}$ can be represented in two equivalent ways: by a generator matrix $\bm{G} \in \Ft^{\ktn}$ such that $\mathcal{C} = \{\bm{mG} ~|~ \bm{m} \in \Ftk\}$ or by a parity-check matrix $\bm{H} \in \Ft^{\nmktn}$ such that $\mathcal{C} = \{ \bm{x} \in \Ftn ~|~ \bm{H}\bm{x}^{\top} = 0\}$.

A systematic binary quasi-cyclic code of index $\ell$ and rate $1/\ell$ is a
$[n=\ell k, k]$ code that can be represented by a $k \times \ell k = k \times n$ generator matrix $\bm{G} \in \mathcal{QC}(\Ft^{\ktn})$ of the form:

\begin{equation*}
\mathbf{G}=
\begin{bmatrix}
\mathbf{I}_k & \mathbf{A}_0 & \cdots & \mathbf{A}_{\ell-2}\\
\end{bmatrix}
\end{equation*}

where $\mathbf{A}_0,\ldots ,\mathbf{A}_{\ell-2}$ are circulant $k\times k$ matrices. Alternatively, it can be represented by an $(\ell-1)k \times \ell k = (n-k)\times n$ parity check matrix $\bm{H} \in \mathcal{QC}(\Ft^{(n - k) \times k})$ of the form:

\begin{equation*}
\mathbf{H}=
\begin{bmatrix}
\mathbf{I}_k & \cdots & 0 & \mathbf{B}_0\\
& \ddots &   & \vdots \\
0            & \cdots & \mathbf{I}_k & \mathbf{B}_{\ell-2}
\end{bmatrix}
\end{equation*}

where $\mathbf{B}_0,\ldots ,\mathbf{B}_{\ell-2}$ are circulant $k\times k$ matrices.

Given positive integers $n$, $k$, $w$, a random parity-check matrix $\bm{H} \sampler \Ft^{\nmktn}$ and a syndrome $\bm{y} \in \Ft^{\nmk}$, the syndrome decoding problem $\SD(n,k,w)$ asks to find $\bm{x} \in \Ftn$ such that $\bm{Hx}^\top = \bm{y}^\top$ and $\hw{\bm{x}} = w$.

Given positive integers $n$, $k$, $w$, a random generator matrix $\bm{G} \sampler \Ft^{\ktn}$ and a vector $\bm{y} \in \Ftn$, the general syndrome decoding problem $\GSD(n,k,w)$ asks to find $(\bm{x}, \bm{e}) \in \Ftk \times \Ftn$ such that $\bm{xG} + \bm{e} = \bm{y}$ and $\hw{\bm{e}} = w$.

Given positive integers $n, k, w$, with $n=\ell k$ for some $\ell$, a random parity-check matrix of a quasi-cyclic code $\bm{H} \sampler \mathcal{QC}(\Ft^{(n - k) \times n})$ and a syndrome $\bm{y} \in \Ft^{(n-k)}$, the syndrome decoding problem $\ell$-$\QCSD(n,k,w)$ asks to find $\bm{x} \in \Ft^{n}$, such that $\bm{Hx}^\top = \bm{y}^\top$ and $\hw{\bm{x}} = w$.

Given positive integers $n, k, w$, with $n=\ell k$ for some $\ell$, a random generator matrix of a quasi-cyclic code $\bm{G} \sampler \mathcal{QC}(\Ft^{\ktn})$ and a vector $\bm{y} \in \Ftn$, the general syndrome decoding problem $\ell$-$\QCGSD(n,k,w)$ asks to find $(\bm{x}, \bm{e}) \in \Ftk \times \Ftn$ such that $\bm{xG} + \bm{e} = \bm{y}$ and $\hw{\bm{e}} = w$.

§.§ Commitments Schemes

We now introduce commitment schemes as they are building blocks commonly used to construct proofs of knowledge.
We require such schemes to be both hiding and binding.
The former property ensures that the commitment does not leak any information on the committed message while the latter ensures that adversaries can not change their committed messages once the commitment is sent.
We now present the formal definition of the commitment schemes.

A (non-interactive) commitment scheme with underlying
message space $\mathcal{M}$ is tuple of algorithms
$(\keygen, \mathsf{Com}, \mathsf{Open})$ such that:

* $\mathbf{\keygen}$: Takes the security parameter
$\lambda$ as input and outputs pair of keys.
$(\mathsf{gk}, \mathsf{ck}) \samplen \keygen(1^\lambda)$.
Here $\mathsf{gk}$ is called the setup key and it serves as
an implicit input to the $\mathsf{Com}$ and $\mathsf{Open}$
algorithms, whereas $\mathsf{ck}$ is called
commitment key and it is given to the sender.
Note that, the commitment key $\mathsf{ck}$ can be
set to empty string $\varepsilon$, if only setup key
$\mathsf{gk}$ is sufficient for committing to the messages.

* $\mathbf{\mathsf{Com}}$: Takes a message $m \in \mathcal{M}$
and commitment key $\mathsf{ck}$ as input and output
a commitment $c$ and opening $d$. Formally,
$(c,d) \samplen \commit{\mathsf{ck},m}$.

* $\mathbf{\mathsf{Open}}$: Takes a commitment $c$,
opening $d$, message $m \in \mathcal{M}$ as input
and outputs a bit $b \in \lbrace 0, 1 \rbrace$ indicating
whether the commitment $c$ is a valid commitment of $m$.
Formally, $b := \open{c,d,m}$.

The commitment scheme is perfectly correct if
$ \forall \lambda \in \mathbb{N}, \, \forall m \in \mathcal{M} $
and for all valid key pairs $(\mathsf{gk}, \mathsf{ck})$,

$$ \Pr[\open{\commit{\mathsf{ck},m},m} = 1] = 1. $$

The commitment scheme satisfies two
security properties guaranteeing security from
malicious sender (prover) and from
malicious receiver (verifier):

* Hiding:  It is computationally hard
for an efficient adversary $ \mathcal{A} $ to generate two distinct
messages $m_0, m_1 \in \mathcal{M}$, such that $\mathcal{A}$
can distinguish between their respective commitments.
Formally, for any PPT adversary $\mathcal{A}$ it should hold that,

$$ \Pr \left[b = b' \quad  \bigg \vert  \quad \begin{matrix}
(\mathsf{gk}, \mathsf{ck}) \samplen \keygen(1^\lambda), \,
(m_0, m_1) \samplen \mathcal{A}(\mathsf{gk}, \mathsf{ck})\\
b \sampler \lbrace 0, 1 \rbrace,
(c,d) \samplen \commit{m_b, \mathsf{ck}},
b' \samplen \mathcal{A}(c)
\end{matrix} \right]  = \frac{1}{2} + \mathsf{negl}(\lambda).$$

* Binding:  It is computationally hard for an
efficient adversary to generate a triple $(c,d,d')$ such that
both $(c,d)$ and $(c, d')$ are valid commitment/opening
pairs for some $m, m' \in \mathcal{M}$ respectively, where
$m \neq m'$.
Formally, for any PPT adversary it should hold that,

$$\Pr \left[\begin{matrix}
m \neq m' \, \bigwedge \\ m, m' \in \mathcal{M}
\end{matrix} \quad \bigg \vert \quad \begin{matrix}
(\mathsf{gk}, \mathsf{ck}) \samplen \keygen(1^\lambda), \,
(c, d, d') \samplen \mathcal{A}(\mathsf{gk}, \mathsf{ck})\\
1 := \open{c,d,m},
1 := \open{c,d',m'} \end{matrix} \right] \leq \mathsf{negl}(\lambda) .$$

In this work, we assume that the commitment scheme is implemented using
a collision-resistant hash function $H$ modelled as random oracle.
To commit to a message $m$, we first sample a random
value $r \leftarrow \bit^\lambda$ and compute the commitment as
$c := H(r,m)$. The hiding follows since $H$ is modelled as
random oracle and the binding follows from the collision-resistance
of $H$. The random value $r$ serves as the opening $d$. The verifier
can simply re-compute $H(r,m)$ on receiving $r$ as opening
and check if $H(r,m)$ equals the commitment $c$.

A commitment scheme is a function $\mathsf{Com}: \bit^{\lambda} \times \bit^{*} \rightarrow \bit^{2\lambda}$ that takes as input $\lambda$ uniformly random bits $r$ where $\lambda$ is the security parameter as well as a message $m \in \bit^{*}$ and outputs a commitment $\commit{r, m}$ of size $2\lambda$ bits.

Let $(m_0, m_1)$ be a pair of messages, the advantage of an adversary $\adv$ against the commitment hiding experiment is:

\begin{equation*}
\mathsf{Adv}^{\mathsf{Hiding}}_{\mathsf{Com}, \adv}(1^\lambda) =
\Bigg| \, \prb \left[ \begin{array}{l}
b = b' \\
\end{array} \ \middle\vert~ \\ \begin{array}{l}
b \sampler \bit, \, r \sampler \bit^{\lambda} \\
b' \samplen \adv.\mathsf{guess}(\commit{r, \, m_b})
\end{array}\right]
- \frac{1}{2} \, \Bigg|.
\end{equation*}

A commitment scheme $\mathsf{Com}$ is computationally hiding if for all $\ppt$ adversaries $\adv$ and every pair of messages $(m_0, m_1)$, $\mathsf{Adv}^{\mathsf{Hiding}}_{\mathsf{Com}, \adv}(1^\lambda)$ is negligible in $\lambda$.

Let the advantage of an adversary $\adv$ against the commitment binding experiment be defined as:

\begin{equation*}
\mathsf{Adv}^{\mathsf{Binding}}_{\mathsf{Com}, \adv}(1^\lambda) = \prb
\left[ \begin{array}{l}
m_0 \neq m_1 \\
c_0 = c_1 \\
\end{array} \ \middle\vert~ \\ \begin{array}{l}
(r_0, r_1, m_0, m_1) \samplen \adv.\mathsf{choose}(1^{\lambda}) \\
c_0 = \commit{r_0, \, m_0}, ~ c_1 = \commit{r_1, \, m_1} \\
\end{array}\right].
\end{equation*}

A commitment scheme $\mathsf{Com}$ is computationally binding if for all $\ppt$ adversaries $\adv$, $\mathsf{Adv}^{\mathsf{Binding}}_{\mathsf{Com}, \adv}(1^\lambda)$ is negligible in $\lambda$.

§.§ Proofs of Knowledge with Helper

Following the work of Katz, Kolesnikov and Wang [33], Beullens introduced the notion of sigma protocols with helper in [13].
Given a relation $R = (x, w)$, these Honest-Verifier Zero-Knowledge Proofs of Knowledge (HVZK PoK) allow a prover to convince an honest verifier (namely a verifier that follows the protocol as described) that it knows a witness $w$ for the statement $x$ without revealing anything on $w$.
In our context, the relation $R = (x, w)$ is defined by an instance of the $\SD$ problem such that $x = (\bm{H}, \bm{y})$ and $w = \bm{x}$ namely the prover convinces the verifier that he knows a solution to an $\SD$ instance without revealing anything on its solution.
Alternatively, when the $\GSD$ form of the problem is considered, one has $x = (\bm{G}, \bm{y})$ and $w = (\bm{x}, \bm{e})$.

A protocol is a Sigma Protocol with helper for relation $R$ with challenge space $\mathcal{C}$ if it follows the form of Figure <ref> and satisfies:

$\bullet$ Completeness. If all parties ($\helperf$, $\proverf$ and $\verifierf$) follow the protocol on input $(x, w) \in R$, then the verifier always accepts.

$\bullet$ Special soundness. From an adversary $\adv$ that outputs two valid transcripts $(x, \aux, \com, \alpha, \rsp)$ and $(x, \aux, \com, \alpha', \allowbreak \rsp')$ with $\alpha \neq \alpha'$ and where $\aux = \setup(\theta)$ for some seed value $\theta$ (not necessarily known to the extractor), there exists an extractor $\Ext$ that efficiently extracts a witness $w$ such that $(x, w) \in R$ with probability $1 - \negl(\lambda)$.

$\bullet$ Special honest-verifier zero-knowledge. There exists a $\ppt$ simulator $\Sim$ that on input $x$, a random seed value $\theta$ and a random challenge $\alpha$ outputs a transcript $(x, \aux, \com, \alpha, \rsp)$ with $\aux = \setup(\theta)$ that is computationally indistinguishable from the probability distribution of transcript of honest executions of the protocol on input $(x, w)$ for some witness $w$ such that $(x, w) \in R$, conditioned on the auxiliary information being equal to $\aux$ and the challenge being equal to $\alpha$.

§.§ Signature schemes

In this section, we define signatures based on the Fiat-Shamir transform [27]
and then present the security definitions associated to these schemes.

A digital signature scheme $\mathsf{SIG}$ is a tuple of algorithms
$\mathsf{SIG} = (\mathsf{Gen}, \mathsf{Sign}, \mathsf{Verify})$,

* $\mathsf{Gen}$ takes security parameter $\lambda$ as input
and outputs the key pair $(\mathsf{pk}, \, \mathsf{sk})$.

* $\mathsf{Sign}$ takes a message $m$ along with the secret
(signing) key $\mathsf{sk}$ as input and produces signature $\sigma$ as output.

* The verification algorithm $\mathsf{Verify}$ takes the public (verification)
key $\mathsf{pk}$, message $m'$, and signature $\sigma$ as input
and returns $\mathsf{accept}$ or $\mathsf{reject}$.

A signature scheme $\mathsf{SIG}$ is said to have correctness error $\varepsilon$
if for all $(\mathsf{pk}, \mathsf{sk}) \leftarrow \mathsf{Gen}(1^\lambda)$,
and all messages $m \in \mathcal{M}$, it holds true that

$$ \prb \left[ \mathsf{Verify}(\mathsf{pk}, \mathsf{Sign}(\mathsf{sk},m), m) = \mathsf{reject}  \right] \leq \varepsilon.$$

A binary relation $R$ with instance generator $\mathsf{IG}$ is called hard
if for any (quantum) adversary $\adv$, it holds that

$$ \prb \left[  (x, \tilde{w}) \in R \, \vert \, (x, w) \leftarrow  \mathsf{IG}, \, \tilde{w} \leftarrow \adv(x)  \right] $$

is negligible, for any $\mathsf{IG}$ that
always outputs a valid pair $(x,w) \in R$.

A Fiat-Shamir signature scheme based on a public-coin interactive proof system
(or $\Sigma$-protocol) $ \Pi = (\mathsf{Prover}, \mathsf{Verifier})$
for a hard relation $R$ with instance generator $\mathsf{IG}$, denoted by
$\mathsf{SIG}[\Pi]$ is a tuple of algorithms
$\mathsf{SIG}[\Pi] = (\mathsf{GenFS}, \mathsf{SignFS}, \mathsf{VerifyFS})$,

* $\mathsf{GenFS}$ samples
$(x,w) \leftarrow \mathsf{IG}$ then outputs $\mathsf{sk} := (x,w)$ and
$\mathsf{pk} := x$.

* $\mathsf{SignFS}^H(\pk, \mathsf{sk}, m)$ outputs $(m, \sigma)$
where $ \sigma \leftarrow \mathsf{Prover}^H(x, w, m)$.

* $\mathsf{VerifyFS}^H(\mathsf{pk}, \sigma, \tilde{m})$ runs
$\mathsf{Verifier}^H(x, \sigma, \tilde{m})$ and returns its output.

Hereafter, we assume that the algorithms have oracle access to hash function $H$
which is modeled as (quantum) random oracle.

A signature scheme possesses
strong existential unforgeability under chosen message attack ($\mathsf{sEUF-CMA}$)
if for all (quantum) polynomial-time algorithms $\adv$ and for uniformly
random $H$, it holds that

$$ \prb \left[ \mathsf{Verify}^H(\mathsf{pk}, \sigma, m) \, \bigwedge \, (m, \sigma) \notin \mathbf{Sign-q} \, \vert \, (\mathsf{pk}, \mathsf{sk}) \leftarrow \mathsf{Gen},  \, (m, \sigma) \leftarrow \adv^{H,\mathbf{Sign}}(\mathsf{pk}) \right] $$

is negligible. Here, $\mathbf{Sign}$ is a classical oracle which on input $m$
returns $\mathsf{Sign}^H(\pk, \allowbreak \mathsf{sk}, m)$ and $\mathbf{Sign-q}$ is the list
of all ($q$) queries made to $\mathbf{Sign}$.

§ POK 1 - STERN PROTOCOL IMPROVEMENT

The first PoK for the $\SD$ problem over $\Ft$ was introduced by Stern in 1993 [43].
This 3-round protocol features a soundness error equal to $2/3$ and as such needs to be repeated several times in order to achieve a negligible soundness error.
Over the years, 5-round code-based PoK reducing the soundness error to $1/2$ (hence providing smaller communication costs) have been proposed.
Such protocols either rely on the $\SD$ problem over $\Fq$ [22] or leverage the structured $\QCGSD$ and $\QCSD$ problems over $\Ft$ [4, 14].
Hereafter, we introduce a PoK for the $\SD$ problem over $\Ft$ with soundness error equal to $1/2$.
Our new protocol (denoted PoK 1) can be either seen as (i) a modification of the initial Stern protocol leveraging the MPC-in-the-head paradigm along with several optimizations from [14] or as (ii) the BGS protocol [14] in which the quasi-cyclicity is replaced by the use of the MPC-in-head technique.

The initial Stern protocol permits to prove the knowledge of $\bm{x}$ such that $\bm{y}^\top = \bm{H} \bm{x}^\top$ and $\hw{\bm{x}} = w$.
Within the protocol, one proves the knowledge of $\bm{x}$ using $\bm{x} + \bm{u}$ for some random value $\bm{u}$ and prove that $\hw{\bm{x}} = w$ using $\pi[\bm{x}]$ for some random permutation $\pi$.
To this end, the prover starts by generating three commitments related to $\pi, \bm{x}$ and $\bm{u}$.
Next, the verifier samples a random challenge from $\{0, 1, 2\}$ and the prover outputs a response that is specific to the received challenge.
Amongst these three possible responses, one can be computed without knowing the secret $\bm{x}$ hence could be verified using the MPC-in-the-head paradigm,
Doing so, one can reduce the challenge space to $\bit$ thus achieving a soundness error equal to $1/2$.
Our PoK 1 follows this approach and is depicted as a sigma protocol with helper in Figure <ref>.

We explain in Section <ref> how to remove the helper from Figure <ref> in order to get both a 3-round HVZK PoK and a 5-round HVZK PoK.
Our 3-round PoK 1 features a very conservative design ($\SD$ assumption over $\Ft$ only, tighter Fiat-Shamir transformation proof thanks to the 3-round structure) therefore is comparable to the Stern [43] and Véron [47] proposals which provide the same security guarantees.
Our 3-round PoK 1 benefits from a smaller signature size than the Stern and Véron protocols at the cost of a small performance overhead due to the use of the MPC-in-the-head.
When coupled with quasi-cyclicity, our 5-round PoK 1 is comparable to the AGS [4] and BGS [14] protocols ($\QCSD$ assumption over $\Ft$, 5-round structure) while being more conservative security-wise as it relies on the $\QCSD$ problem directly rather than the $\DiffSD$ problem contrarily to the AGS and BGS protocols (see [14], Definition 11 for a description of the $\DiffSD$ problem).
Similarly to the 3-round case, our 5-round PoK 1 features a smaller signature size than the AGS and BGS protocols at the cost of a small performance overhead.

(H, y)

θ^λ,  πθ n,   u θ

r_0 θ ^λ,   _0 = r_0,   π  ||   H u^⊤

r_1 θ ^λ,   _1 = r_1,   π[u]

= (_0, _1)

Send  θ to the   and   to the

(x, H, y, θ)   (H, y, )

Compute  r_0, r_1, π and  u  from  θ

r ^λ,   = r,   π[u + x]

α= 0

z_1 = π,   z_2 = u + x

= (r_0,   r,   z_1,   z_2)

α= 1

z_3 = π[u],   z_4 = π[x]

= (r_1,   r,   z_3,   z_4)

α= 0

b_1 ( _0 = r_0,   z_1   ||   H z_2^⊤ - y^⊤ )

b_2 ( = r,   z_1[z_2] )

b_1 ∧b_2

α= 1

b_1 ( _1 = r_1,   z_3 )

b_2 ( = r,   z_3 + z_4 )

b_3 ( z_4 = ω)

b_1 ∧b_2 ∧b_3

ZK PoK with Helper for the $\SD$ problem over $\Ft$

If the commitment used is binding and hiding, then the protocol depicted in Figure <ref> is a proof of knowledge with helper for the $\SD$ problem with challenge space $\mathcal{C}$ such that $|\mathcal{C}| = 2$.

We need to prove that the protocol in Figure <ref>
satisfies the properties of correctness, special soundness, and special honest-verifier zero-knowledge.

Correctness. The correctness follows straightforwardly from the protocol description once the commitments are verified.

Special soundness. Given an adversary $\adv$ that outputs with non negligible probability two valid transcripts $(\bm{H}, \bm{y}, \aux, \com, \alpha, \rsp)$ and $(\bm{H}, \bm{y}, \aux, \com, \alpha', \allowbreak \rsp')$ with $\alpha \neq \alpha'$ and where $\aux = \setup(\theta)$ for some random seed $\theta$, one can easily build a knowledge extractor $\Ext$ that returns a solution to the $\SD$ instance defined by $(\bm{H}, \bm{y})$:

1. Compute and output  z_1^-1[z_4].

As $\alpha \neq \alpha'$, the extractor $\Ext$ has access to both transcripts $(z_1, \bm{z}_2)$ and $(\bm{z}_3, \bm{z}_4)$ therefore he can output $z_1^{-1}[\bm{z}_4]$.
We now explain why the extractor's output is a solution to the considered $\SD$ problem instance.
Using the binding property of $\com_{0}$ and $\com_{1}$, one has $z_1 = \pi$ and $\bm{H} \bm{z}_2^{\top} - \bm{y}^{\top} = \bm{H} \bm{u}^{\top}$ as well as $z_3 = \pi[\bm{u}]$.
In addition, from the binding property of $\com$, one has $z_1[\bm{z}_2] = \bm{z}_3 + \bm{z}_4$ thus $\bm{z}_2 = \bm{u} + \pi^{-1}[\bm{z}_4]$.
Using this expression within $\bm{H} \bm{z}_2^{\top} - \bm{y}^{\top} = \bm{H} \bm{u}^{\top}$, one can deduce that $\bm{H} (\pi^{-1}[\bm{z}_4])^{\top} = \bm{y}^{\top}$.
Given that $\hw{\bm{z}_4} = \omega$, one also has $\hw{\pi^{-1}[\bm{z}_4]} = \omega$ thus $z_1^{-1}[\bm{z}_4]$ is a solution to the considered $\SD$ problem instance.
Finally, $\Ext$ runs in polynomial time which completes the proof.

Special Honest-Verifier Zero-Knowledge.
We start by explaining why valid transcripts don't leak anything on the secret.
A valid transcript contains either $(\pi, \bm{u} + \bm{x})$ or $(\pi[\bm{u}], \pi[\bm{x}])$ namely the secret $\bm{x}$ is masked either by a random value $\bm{u}$ or by some random permutation $\pi$.
We now explain how to build a $\ppt$ simulator $\Sim$ that given $(\bm{H}, \bm{y})$, a random seed $\theta$ and a random challenge $\alpha$ outputs a transcript $(\bm{H}, \bm{y}, \aux, \com, \alpha, \rsp)$ such that $\aux = \setup(\theta)$ that is indistinguishable from the probability distribution of transcripts of honest executions of the protocol:

1. Compute  (r_0, r_1, u, π)  from  θ

2. If  α= 0,  compute  x̃  such that  H x̃ = y  (without constraint on the weight of $\bm{x}$)

If  α= 1,  compute  x̃ ω

3. Compute  r ^λ,    = r,   π[u + x̃]

4. If  α= 0,  compute  z_1 = π,   z̃_2 = u + x̃  and   = (r_0, r, z_1, z̃_2)

If  α= 1,  compute  z_3 = π[u],   z̃_4 = π[x̃]  and   = (r_1, r, z_3, z̃_4)

5. Output  (H, y, , , α, )

The transcript generated by the simulator $\Sim$ is $(\bm{H}, \bm{y}, \aux, \tilde{\com}, \alpha, \tilde{\rsp})$ where $\aux \samplen \setup(\theta)$.
One need to check that $\tilde{\com}$ and $\tilde{\rsp}$ are indistinguishable in the simulation and during the real execution.
If the commitment used is hiding, then $\com$ and $\tilde{\com}$ are indistinguishable in the simulation and during the real execution.
When $\alpha = 0$, one cannot distinguish between $\bm{\tilde{z}}_2$ and $\bm{z}_2$ as $\bm{u}$ is sampled uniformly at random.
When $\alpha = 1$, one cannot distinguish between $\bm{\tilde{z}}_4$ and $\bm{z}_4$ as $\pi[\bm{\tilde{x}}]$ follows the same probability distribution as $\pi[\bm{x}]$, since $\pi$ is a random permutation.
As a consequence, $\rsp$ and $\tilde{\rsp}$ are indistinguishable in the simulation and during the real execution.
Finally, $\Sim$ runs in polynomial time which completes the proof.

§ POK 2 & 3 - ARBITRARILY SMALL SOUNDNESS ERROR

In the previous section, we have leveraged the MPC-in-the-head technique in order to design a PoK for the $\SD$ problem over $\Ft$ achieving a soundness error of $1/2$.
Hereafter, we present two PoK for the $\GSD$ problem over $\Ft$ achieving an arbitrarily small soundness error equal to $1/N$ for some parameter $N$.

§.§ Reducing soundness using several permutations

We start by highlighting a particularity of PoK for the $\SD$ problem namely that it requires to prove two statements: (i) their exists a value $\bm{x}$ such that $\bm{H} \bm{x}^{\top} = \bm{y}^{\top}$ and (ii) the weight of $\bm{x}$ is small.
As a consequence, it is very natural to design these proofs with two parts checking respectively each one of the aforementioned properties (see [4, 22, 14] as well as our construction from Section <ref>) which leads to a soundness error equal to $1/2$.
In order to reduce the soundness error even further, one need to merge the two parts of the proof together which turn out to be challenging to do while preserving the zero-knowledge property of the underlying proof.
Indeed, one generally (see for instance Figure <ref>) prove the first property by masking $\bm{x}$ using $\bm{u} + \bm{x}$ for some random value $\bm{u}$ and prove the second property by masking $\bm{x}$ using $\pi[\bm{x}]$ for some random permutation $\pi$.
The verifier can then convince itself by checking some third value such as $\pi[\bm{u} + \bm{x}]$ which
binds the two parts of the proof together.
To enforce that the same permutation $\pi$ is used in both $\pi[\bm{x}]$ and $\pi[\bm{u} + \bm{x}]$, we can commit to the permutation $\pi$ and reveal it later such that at any given point (during or after the execution of the protocol) the verifier either knows $\pi$ or $\pi[\bm{x}]$ but not both.

Our second PoK (hereafter denoted PoK 2) solves this issue by introducing several permutations and revealing of all them but one in order to prove the knowledge of the solution of a permuted syndrome decoding problem instance.

In particular, we need to ensure the protocol guarantees soundness
(i.e. one can extract the permutations used in the protocol,
whenever more than one valid transcripts are given), and preserves
the zero-knowledge (i.e. all of the permutations cannot be retrieved
from any given (single) valid transcript).
Our PoK relies on the $\GSD$ problem namely the $\SD$ problem defined with a generator matrix instead of a parity-check matrix.
Given a $\GSD$ instance $(\bm{G}, \bm{y})$, we consider $N$ permuted instances $(\pi_i[\bm{G}], \pi_i[\bm{y}])_{i \in \intoneto{N}}$ satisfying $\pi_i[\bm{x} \bm{G}] + \pi_i[\bm{e}] = \pi_i[\bm{y}]$.
Here, the solution to the $\GSD$ problem $(\bm{x}, \bm{e})$ is the secret witness.
By adding random values $\bm{u}$ and $\bm{v}_i$, one get an equivalent equation namely $\pi_i[(\bm{u} + \bm{x})\bm{G}] + \bm{v}_i + \pi_i[\bm{e}] = \pi_i[\bm{y} + \bm{u}\bm{G}] + \bm{v}_i$.
Using the random mask $\bm{v}$ is mandatory as failing to do so (like in the initial Véron protocol) lead to a zero-knowledge issue that was identified in [32] and then fixed in [9].
To summarize, by adding random values $\bm{u}$ and $\bm{v}_i$, one get an equivalent equation namely $\pi_i[(\bm{u} + \bm{x})\bm{G}] + \bm{v}_i + \pi_i[\bm{e}] = \pi_i[\bm{y} + \bm{u}\bm{G}] + \bm{v}_i$.
This can be used for the verification while preserving the zero-knowledge.
We now explain how our PoK 2 achieve an arbitrarily small soundness error.
As shown in Figure <ref>, the helper can compute a commitment of
$\pi_i[\bm{y} + \bm{u}\bm{G}] + \bm{v}_i$ as this value does not involve any
secret information.
Thus, one can design a PoK for the $\GSD$ problem by revealing both $\pi_i[\bm{e}]$ and $\pi_i[(\bm{u} + \bm{x})\bm{G}] + \bm{v}_i$.

We now explain how to use the cut-and-choose technique
on the $N$ permutations of the considered $\GSD$ instance
in order to ensure that the latter value
$\pi_i[(\bm{u} + \bm{x})\bm{G}] + \bm{v}_i$ has been correctly computed.
Given some challenge $\alpha \in \intoneto{N} $, the prover can reveal
(i) the masked secret $\bm{u} + \bm{x}$,
(ii) all the permutations and random masks $\bm{v}_i$ except for
the instance $\alpha$ (denoted by $(\pi_i, \bm{v}_i)_{i \in \intoneto{N} \setminus \alpha}$)
as well as
(iii) the value to be checked $\pi_{\alpha}[(\bm{u} + \bm{x})\bm{G}] + \bm{v}_\alpha$, in the instance $\alpha$.
The verifier can then recompute $\pi_i[(\bm{u} + \bm{x})\bm{G}] + \bm{v}_i$ for
all $i \in \intoneto{N} \setminus \alpha$, using the public value $\bm{G}$.
This enforces that $\pi_{\alpha}[(\bm{u} + \bm{x})\bm{G}] + \bm{v}_\alpha$ has
been correctly generated except with arbitrarily small probability $1/N$.
As a technicality, our proof also requires $\bm{u}$ to be extractable for the soundness hence we define it as $\bm{u} = \sum\nolimits_{i \in \intoneto{N}} \bm{u}_i$.
The resulting protocol is described in Figure <ref>.
We explain in Section <ref> how to remove the helper in order to construct a 3-round HVZK PoK.
Our PoK 2 achieves an arbitrarily small soundness error and therefore lead to small signatures however at the cost of a significant overhead on performances.

(G, y)

i ∈N

θ_i θ ^λ,   π_i θ_i n

u_i θ_i ,   v_i θ_i

u = ∑_i ∈N u_i

i ∈N

r_i θ_i ^λ,   θ_i^* = (θ_j)_j ∈N ∖i

_i = r_i,   π_i[y + u G] + v_i   ||   θ_i^*

= (_i)_i ∈N

Send  θ to the   and   to the

(x, e, G, y, θ)   (G, y, )

Compute  (π_i, u_i, v_i, θ_i^*)_i ∈N  and  u  from  θ

i ∈[1, N]

s_i = π_i[(u + x) G] + v_i

r ^λ,   s = (s_i)_i ∈N

= r,   u + x   ||   s

z_1 = u_α+ x,   z_2 = π_α[e]

z_3 = s_α,   z_4 = θ_α^*

= (r_α, r, z_1, z_2, z_3, z_4)

Compute  (π̅_i, v̅_i)_i ∈N ∖α  from  z_4

z̅_1 = z_1 + ∑_i ∈N ∖α u_i

i ∈[1, N] ∖α

s̅_i = π̅_i[z̅_1 G] + v̅_i

s̅ = (s̅_1,   ⋯,   s̅_α- 1,   z_3,   s̅_α+ 1,   ⋯,   s̅_N)

b_1 ( = r,   z̅_1   ||   s̅ )

b_2 ( _α= r_α,   z_3 + z_2   ||   z_4 )

b_3 ( z_2 = ω)

b_1 ∧b_2 ∧b_3

ZK PoK with Helper for the $\GSD$ problem over $\Ft$

If the commitment scheme is computationally binding and computationally hiding, then the protocol depicted in Figure <ref> is a proof of knowledge with helper for the $\GSD$ problem with challenge space $\mathcal{C}$ such that $|\mathcal{C}| = N$, with computational soundness error $1/N$ and
honest-verifier computational zero-knowledge.
[Proof of Knowledge systems with computational soundness
are also called Arguments of Knowledge. Our PoK achieves
computational ZK since the random masks $(\bm{u}, \bm{v})$
added to hide the secrets are generated from seeds with the help
of pseudorandom objects such as XOF.]

We prove the correctness, special soundness and special honest-verifier zero-knowledge properties below.

One prove the correctness by showing that the input to the
$\com$ and $\com_{\alpha}$ used by the verifier in the final steps of
Figure <ref> are same as the input provided by the prover
while generating $\com$ and $\com_{\alpha}$. Once the inputs are
shown to be identical, the correctness follows from the correctness
of the commitment scheme.
We begin by considering the inputs to $\com$, we need to show that
$\bar{\bm{z}}_1 = \bm{u} + \bm{x}$ and $\bar{\bm{s}} = \bm{s}$.
Note that the verifier computes $\bar{\bm{z}}_1$ as $\bm{z}_1 + \sum\nolimits_{i \in \intoneto{N} \setminus \alpha} \bm{u}_i$.
Here, $\bm{z}_1$ is computed by the prover as $(\bm{u}_{\alpha} + \bm{x})$,
and the second term is summation of all $\bm{u}_i$ except $\bm{u}_{\alpha}$.
Therefore, it is easy to see that
$\bar{\bm{z}}_1 = (\bm{u}_{\alpha} + \bm{x}) + \sum\nolimits_{i \in \intoneto{N} \setminus \alpha} \bm{u}_i = \bm{u} + \bm{x}$.
Next, note that the verifier has access to all seeds $\theta_i$ except
$\theta_\alpha$ from the $z_4$ sent by the prover in the response $\rsp$.
The verifier can therefore compute all the permutation $\pi_i$ and
the random masks $\bm{v}_i$ except $\pi_\alpha$ and $\bm{v}_\alpha$.
As shown in previous step, the verifier also knows the value
$\bar{\bm{z}}_1 = \bm{u} + \bm{x}$. The verifier
can therefore compute
$\bar{\bm{s}}_i = \pi_i[\bar{\bm{z}}_1\bm{G}] + \bm{v}_i$ for all $i \in \intoneto{N} \setminus \alpha$ since $\bm{G}$ is public. Which is same as
$\bar{\bm{s}}_i = \pi_i[(\bm{u} + \bm{x})\bm{G}] + \bm{v}_i$ for all $i \in \intoneto{N} \setminus \alpha$, but this is exactly how
the $\bm{s}_i$ values are computed by the prover.
Therefore, we have shown that $\bar{\bm{s}}_i = \bm{s}_i$ for all $i \neq \alpha$. However, $\bar{\bm{s}}_\alpha = \bm{z}_3 = \bm{s}_\alpha$
since $\bm{z}_3$ is computed by the prover.
Therefore we have shown that $\bar{\bm{s}} = \bm{s}$.
This concludes the part related the commitment $\com$, since we have shown that
both the inputs are identical.
We now show the same for $\com_{\alpha}$. Here, we need to show that
(i) $\bm{z}_3 + \bm{z}_2 = \pi_{\alpha}[\bm{y} + \bm{u} \bm{G}] + \bm{v}_{\alpha}$ and,
(ii) $z_4 = \theta_{\alpha^*}$ where $\theta_{\alpha^*}$ denotes all the seeds
$\theta_i$ except for $i = \alpha$.
It is easy to verify and has been discussed earlier
that $z_4$ computed by the prover as $\theta_{\alpha^*}$ and
sent as part of the response to the verifier.
Thus, $z_4 = \theta_{\alpha^*}$ by just inspecting the prover's
Recall, that $\bm{z}_3 = \bm{s}_\alpha$ and
$\bm{s}_{\alpha} = \pi_{\alpha}[(\bm{u} + \bm{x}) \bm{G}] + \bm{v}_{\alpha}$.
Adding $\bm{z}_2$ to both sides and substituting $\bm{z}_2 = \pi_{\alpha}[\bm{e}]$, one get
$\bm{z}_{3} + \bm{z}_2 = \pi_{\alpha}[(\bm{u} + \bm{x}) \bm{G}] + \bm{v}_{\alpha} + \pi_{\alpha}[\bm{e}] = \pi_{\alpha}[\bm{x} \bm{G} + \bm{e} + \bm{u} \bm{G}] + \bm{v}_{\alpha} = \pi_{\alpha}[\bm{y} + \bm{u} \bm{G}] + \bm{v}_{\alpha}.$
Hence we have shown that both the inputs to $\com_\alpha$ are also
As mentioned earlier, since the inputs to $\com$ and $\com_\alpha$
are identical to their counterparts computed by the prover, the correctness
of the protocol follows from the correctness of the commitment scheme.

Special soundness.
In order to prove the special soundness,
one need to build an efficient knowledge extractor $\Ext$ which
returns a solution of the $\GSD$ instance defined by $(\bm{G}, \bm{y})$
with high probability,
when provided with two valid transcripts $(\bm{G}, \bm{y}, \aux, \com, \alpha, \rsp)$ and $(\bm{G}, \bm{y}, \aux, \com, \allowbreak \alpha', \rsp')$ with $\alpha \neq \alpha'$
generated by a PPT adversary (malicious prover) $\adv$,
where $\aux = \setup(\theta)$ for some random seed $\theta$.
The knowledge extractor $\Ext$ computes the solution as:

1. Compute  (π_i, u_i)_i ∈N  from  z_4  and  z_4'

2. Output  (z_1 - u_α, π_α^-1[z_2])

We now show that this can be computed efficiently by $\Ext$, and
then prove that the output is indeed a solution to the given $\GSD$ problem.
Recall from Figure <ref>, that the prover's response is
of the form $\rsp = (r_{\alpha}, r, \bm{z}_1, \bm{z}_2, \bm{z}_3, z_4)$
and $\rsp' = (r_{\alpha'}, r', \bm{z}_1', \bm{z}_2', \bm{z}_3', z_4')$.
Here, $z_4$ denotes all the seeds $\theta_i$ for $i \neq \alpha$ and
$z_4'$ denotes all the seeds $\theta_i$ for $i \neq \alpha'$.
Since, $\alpha \neq \alpha'$, the $\Ext$ has access to all the
seeds $\theta_i$ for $i \in \intoneto{N}$.
The extractor therefore can efficiently compute all the permutations $\pi_i$
and masks $\bm{u}_i$ for $i \in \intoneto{N}$, including $\pi_\alpha$ and
$\bm{u}_{\alpha}$. Using these the extractor can efficiently compute and
then output $(\bm{z}_1 - \bm{u}_{\alpha}, \pi_{\alpha}^{-1}[\bm{z}_2])$.

Let $\tilde{\bm{\theta}} = ({\tilde{\theta}}_{i})_{i \in \intoneto{N}}$ denote the seeds used to generate the commitments
$(\com_i)_{i \in \intoneto{N}}$ comprising the value $\aux$.
Note that if there exists an index $j \in \intoneto{N}$, such that
${\theta}_{j} \neq  {\tilde{\theta}}_{j}$ or
${\theta'}_{j} \neq  {\tilde{\theta}}_{j}$, then that particular
${\theta}_{j}$ or ${\theta'}_{j}$ can be used to break
the binding property of the commitment scheme as any commitment $\com_i$ in $\aux$ where $i \neq j$, can be
opened as valid commitment for two distinct messages where one contains
${\tilde{\theta}}_{j}$ and the other contains ${\theta}_{j}$.
Thus, the binding property of the commitment scheme ensures that
the extracted mask $\bm{u}_{\alpha}$ and the permutation
$\pi_{\alpha}$ are same as the those committed in the common
information $\aux$ and the first commitment $\com$.
We now explain why the extractor's output is a solution to the considered $\GSD$ problem instance.
Note that $\bm{z}_1$ is computed as $\bm{z}_1 = \bm{u}_{\alpha} + \bm{x}$,
therefore the extractor correctly recovers the secret $\bm{x}$
by computing $\bm{z}_1 - \bm{u}_{\alpha}$.
Also, $\bm{z}_2 = \pi_{\alpha}[\bm{e}]$, which can be inverted by
$\Ext$ after learning $\pi_{\alpha}$ as $\bm{e} = \pi_{\alpha}^{-1}[\bm{z}_2]$.
This proves that extracted solution
$(\bm{z}_1 - \bm{u}_{\alpha}, \pi_{\alpha}^{-1}[\bm{z}_2]) = (\bm{x}, \bm{e})$
is the correct solution to the $\GSD$ problem.

Special Honest-Verifier Zero-Knowledge.
We start by explaining why valid transcripts do not leak anything on the secret $(\bm{x}, \bm{e})$.
A valid transcript contains $(\bm{u}_{\alpha} + \bm{x}, \, \pi_{\alpha}[\bm{e}], \, \bm{s}_{\alpha}, \, (\pi_i, \bm{u}_i, \bm{v}_i)_{i \in \intoneto{N} \setminus \alpha})$ namely the secret $\bm{x}$ is masked by a random value $\bm{u}_{\alpha}$ and the secret $\bm{e}$ is masked by a random permutation $\pi_{\alpha}$.
From the protocol, one can compute $\bm{u}_{\alpha} + \bm{x}$ and $\bm{u} + \bm{x}$ however this does not leak anything on $\bm{x}$ as $\bm{u}_{\alpha}$ and $\bm{u}$ are both unknown.
The main difficulty concerns the permutation $\pi_\alpha$ as the protocol requires $\pi_{\alpha}[(\bm{u} + \bm{x}) \bm{G}]$ to be computed while both $(\bm{u} + \bm{x})$ and $\bm{G}$ are known.
To overcome this issue, the protocol actually computes $\pi_{\alpha}[(\bm{u} + \bm{x}) \bm{G}] + \bm{v}_{\alpha}$ for some random value $\bm{v}_{\alpha}$ hence the transcript does not leak anything on $\bm{e}$.
Formally, one can build a $\ppt$ simulator $\Sim$ that given the public values $(\bm{G}, \bm{y})$, a random seed $\theta$ and a random challenge $\alpha$ outputs a transcript $(\bm{G}, \bm{y}, \aux, \com, \alpha, \rsp)$ such that $\aux = \setup(\theta)$ that is computationally indistinguishable from the transcript of honest executions of the protocol:

1. Compute  (π_i, u_i, v_i, θ_i^*)_i ∈N  and  u  from  θ

2. Compute  x̃ ,   ẽ ω  and  ỹ = x̃ G + ẽ

3. Compute  s̃_i = π_i[(u + x̃) G] + v_i  for all  i ∈N ∖α

4. Compute  s̃_α = π_α[(u + x̃) G] + v_α + π_α[y - ỹ]

5. Compute  r ^λ,   s̃ = (s̃_i)_i ∈N  and   = r,   (u + x̃)   ||   s̃

6. Compute  z̃_1 = u_α + x̃,   z̃_2 = π_α[ẽ],   z̃_3 = s̃_α,   z_4 = θ_α^*

7. Compute    = (r_α, r, z̃_1, z̃_2, z̃_3, z_4)  and output  (G, y, , , α, )

The transcript generated by the simulator $\Sim$ is $(\bm{G}, \bm{y}, \aux, \tilde{\com}, \alpha, \tilde{\rsp})$ where $\aux \samplen \setup(\theta)$.
We now show that $\tilde{\com}$ and $\tilde{\rsp}$ are indistinguishable in the simulation and during the real execution.
If the commitment used is hiding, then $\com$ and $\tilde{\com}$ are indistinguishable in the simulation and during the real execution.
Since $\bm{\tilde{x}}$ (in the simulation) and $\bm{x}$ (in the real execution)
are masked by a random mask $\bm{u}_{\alpha}$ which is unknown
to the verifier, $\bm{\tilde{z}}_1$ and $\bm{z}_1$
are computationally indistinguishable.
Similarly, $\bm{\tilde{e}}$ and $\bm{e}$ have same hamming weight $\omega$,
and are masked by random permutation $\pi_{\alpha}$ which is never
known to the verifier. Thus, making $\bm{\tilde{z}}_2$ and $\bm{z}_2$
computationally indistinguishable.
In addition, as the mask $\bm{v}_{\alpha}$ is sampled uniformly at random
and is unknown to the verifier, it cannot distinguish between $\bm{\tilde{z}}_3$ and $\bm{z}_3$.
Finally, $z_4 = \theta_{\alpha^*}$ is identical in both cases.
As a consequence, $\rsp$ and $\tilde{\rsp}$ are
computationally indistinguishable
in the simulation and during the real execution.
Finally, $\Sim$ runs in polynomial time which completes the proof.

§.§ Reducing soundness using a shared permutation

The PoK 2 presented in the previous section achieves an arbitrarily small soundness error equal to $1/N$.
As such, it is theoretically equivalent to the proposal from [26].
Nonetheless, the optimized version of the FJR protocol outperforms the optimized version of our PoK 2 in practice.
This is explained by the fact that some optimizations bring a better improvement for the FJR protocol than for PoK 2.
We defer the interested reader to the paragraph “Commitment compression” in Section <ref> for additional details on this topic.
In this section, we show how one can adapt our PoK 2 to the shared permutation setting used in [26] to achieve similar performances.
The resulting protocol is denoted PoK 3 and can be seen as a dual version of the FJR protocol based on the $\GSD$ problem rather than the $\SD$ one.

(G, y)

i ∈N

θ_i θ ^λ,   π_i θ_i n

u_i θ_i ,   v_i θ_i

π= π_N ∘⋯∘π_1

u = ∑_i ∈N u_i

v = v_N + ∑_i ∈N - 1 π_N ∘⋯∘π_i + 1[v_i]

i ∈N

r_i θ_i ^λ,   θ_i^* = (θ_j)_j ∈N ∖i

_i = r_i,   π[y + u G] + v   ||   θ_i^*

= (_i)_i ∈N

Send  θ to the   and   to the

(x, e, G, y, θ)   (G, y, )

Compute  (π_i, u_i, v_i, θ_i^*)_i ∈N  and  u, π from  θ

s_0 = (u + x) G

i ∈[1, N]

s_i = π_i[s_i - 1] + v_i

r ^λ,   s = (s_i)_i ∈N

= r,   u + x   ||   s

z_1 = u_α+ x,   z_2 = π[e]

z_3 = s_α,   z_4 = θ_α^*

= (r_α, r, z_1, z_2, z_3, z_4)

Compute  (π̅_i, v̅_i)_i ∈N ∖α  from  z_4

z̅_1 = z_1 + ∑_i ∈N ∖α u_i

s̅_0 = z̅_1 G

i ∈[1, N] ∖α

s̅_i = π̅_i[s̅_i - 1] + v̅_i

s̅ = (s̅_1,   ⋯,   s̅_α- 1,   z_3,   s̅_α+ 1,   ⋯,   s̅_N)

b_1 ( = r,   z̅_1   ||   s̅ )

b_2 ( _α= r_α,   s̅_N + z_2   ||   z_4 )

b_3 ( z_2 = ω)

b_1 ∧b_2 ∧b_3

ZK PoK with Helper for the $\SD$ problem over $\Ft$

If the commitment is binding and
hiding, then the protocol depicted
in Figure <ref> is a proof of knowledge with helper
for the $\GSD$ problem with challenge space $\mathcal{C}$ such that $|\mathcal{C}| = N$, with computational soundness error $1/N$ and
honest-verifier computational zero-knowledge.

One need to prove the correctness, special soundness and special honest-verifier zero-knowledge properties to complete the proof.

Correctness. The proof for correctness follows
the same arguments as for the proof of correctness of Theorem <ref>,
with the only difference that the $\bm{s}_i$ values are computed
by composing the permutations $\pi_i$ in a nested manner.

Special soundness. Given an adversary $\adv$ that outputs
two valid transcripts $(\bm{G}, \bm{y}, \aux, \com, \alpha, \rsp)$ and $(\bm{G}, \bm{y}, \aux, \com, \allowbreak \alpha', \rsp')$ with $\alpha \neq \alpha'$ and where $\aux = \setup(\theta)$ for some random seed $\theta$, one can build a knowledge extractor $\Ext$ that returns a solution of the $\GSD$ instance defined by $(\bm{G}, \bm{y})$ with high probability as follows:

1. Compute  (π_i, u_i)_i ∈N  from  z_4  and  z_4'

2. Compute  π= π_N ∘⋯∘π_1

3. Output  (z_1 - u_α, π^-1[z_2])

The proof of soundness showing that the extractor $\Ext$ is efficient
and returns a valid solution for the $\GSD$ instance, follows
the same ideas as for the proof of soundness of Theorem <ref>,
with the only difference of computing the permutation
$\pi$ as composition of the permutations $\pi_i$ after
extracting $\pi_\alpha$.

Special Honest-Verifier Zero-Knowledge.
The proof of zero-knowledge follows
the same arguments as for the proof of zero-knowledge of Theorem <ref>.
We provide the description of the PPT simulator $\Sim$
which generates the indistinguishable transcript using
only the public information for the completeness below.

Formally, one can build a $\ppt$ simulator $\Sim$ that given the public values $(\bm{G}, \bm{y})$, a random seed $\theta$ and a random challenge $\alpha$ outputs a transcript $(\bm{G}, \bm{y}, \aux, \com, \alpha, \rsp)$ such that $\aux = \setup(\theta)$ that is computationally indistinguishable from the probability distribution of transcripts of honest executions of the protocol:

1. Compute  (π_i, u_i, v_i, θ_i^*)_i ∈N  and  u, π from  θ

2. Compute  x̃ ,   ẽ ω  and  ỹ = x̃ G + ẽ

3. Compute  s̃_0 = (u + x̃)G  and  s̃_i = π_i[s̃_i - 1] + v_i  for all  i ∈[1, α- 1]

4. Compute  s̃_α = π_α[(u + x̃) G] + v_α + π^-1_α+ 1 ∘⋯∘π^-1_N ∘π[y - ỹ]

5. Compute  s̃_i = π_i[s̃_i - 1] + v_i  for all  i ∈[α+ 1, N]

6. Compute  r ^λ,   s̃ = (s̃_i)_i ∈N  and   = r,   (u + x̃)   ||   s̃

7. Compute  z̃_1 = u_α + x̃,   z̃_2 = π[ẽ],   z̃_3 = s̃_α,   z_4 = θ_α^*

8. Compute    = (r_α, r, z̃_1, z̃_2, z̃_3, z_4)  and output  (G, y, , , α, )

§ POK WITHOUT TRUSTED HELPER

PoK with helper can be transformed into either 3-round HVZK PoK without helper or 5-round HVZK PoK without helper using the cut-and-choose paradigm as explained in [33, 13].
When the 5-round transformation is used, one must take into account the attack from [35] that specifically exploits the fact that the proof has a 5-round structure.
Choosing to use the 3-round or the 5-round transformation leads to different communication costs depending on the underlying proof and therefore must be decided on a case by case basis.
Hereafter, we present both transformations and discuss which ones to consider for the proof of knowledge introduced in Sections <ref> and <ref> respectively.

The main idea is to let the prover run the setup phase multiple times
with many independent seeds $\setup{(\theta^{(k)})}$ for $k \in \intoneto{M}$
and then share the auxiliary information $\aux^{(k)}$ for all the instances
with the verifier. The verifier then picks an arbitrary instance $\kappa$,
and the prover sends all the seeds $\theta^{(k)}$ for $k \neq \kappa$
to the verifier. The verifier can then verify that the received
auxiliary information $\aux^{(k)}$ has been honestly computed
by running the setup algorithm itself, if this check does not pass then
the verifier rejects. Otherwise, the prover and the verifier proceed
with the protocol for PoK using the seed $\theta^{(\kappa)}$.
If the soundness error of the PoK with the helper is $\frac{1}{N}$,
and the protocol without helper runs the setup $M$ times with independent
seeds, then the soundness error of the PoK without helper is
$\max(\frac{1}{M}, \frac{1}{N})$.

If the commitment used is binding and hiding, then the protocol depicted in Figure <ref> is a 3-round honest-verifier zero-knowledge proof of knowledge with challenge space $\mathcal{C}_1 \times \mathcal{C}_2$ such that $|\mathcal{C}_1| = M$ and $|\mathcal{C}_2| = N$ and soundness error equal to $\max(\frac{1}{M}, \frac{1}{N})$.

This is a direct application of Theorem 3 from [13] that permits to build a 3-round PoK without helper from a PoK with helper.

If the commitment used is binding and hiding, then the protocol depicted in Figure <ref> is a 5-round honest-verifier zero-knowledge proof of knowledge with challenge space $\mathcal{C}_1 \times \mathcal{C}_2$ such that $|\mathcal{C}_1| = M$ and $|\mathcal{C}_2| = N$ and soundness error equal to $\max(\frac{1}{M}, \frac{1}{N})$.

One can straightforwardly adapt the proof of Theorem 3 from [13] to the 5-round setting.

Removing the helper from PoK 1. For our first PoK (see Section <ref>), we will consider both the 3-round and 5-round transformations.
We defer the reader to Appendices <ref> and <ref> for the description of the 3-round PoK 1 and 5-round PoK 1 protocols which are obtained after respectively applying the 3-round and 5-round transformations to our fist proof of knowledge.
The 3-round PoK 1 protocol is a slightly more conservative choice while the 5-round PoK 1 lead to a slightly smaller signature (see Section <ref>).

Removing the helper from PoK 2 and PoK 3. For our PoK 2 and PoK 3 (see Section <ref>), we will only consider the 3-round transformation as it leads to smaller signatures when taking account the attack from [35].
We defer the reader to Appendices <ref> and <ref> for the description of the protocols.

§ COMMUNICATION COST AND OPTIMIZATIONS

In this section, we present optimizations that permits to reduce the communication cost of the aforementioned proofs of knowledge.
Several optimizations are related to the use of the MPC-in-the-head paradigm and were first introduced in [33].
We also consider code-based related optimizations that were introduced in [4] and [14].
Finally, we discuss a performance oriented optimization relying on the use of structured matrices.
The optimized versions of our 3-round PoK 1, 5-round PoK 1, 3-round PoK 2 and 3-round PoK 3 are described in Appendices <ref>, <ref>, <ref> and <ref> respectively.

Protocol repetition [33, 13].
The 3-round or 5-round PoK constructed by removing the helper (see Section <ref>) have a soundness error equal to $\max{(\frac{1}{M}, \frac{1}{N})}$.
In order to obtain a negligible soundness error with respect to security parameter $\lambda$, one can compute $\tau$ parallel executions of the protocol where $\tau = \frac{\lambda}{\log_2{(\min{(M, N)})}}$.
In that case, one needs to execute $\tau \cdot M$ setup steps (the $\helperf$ part in Figure <ref>) followed by $\tau$ executions of the protocol (the $\proverf$ part in Figure <ref>).
The key idea of the beating parallel repetition optimization from [33] is to
let the verifier choose $\tau$ out of $M$ (instead of only $1$ out of $M$) setups to execute,
which means the setup
phase is repeated only $M$ times (instead of $\tau \cdot M$ times).
However, this comes at the cost of increasing the number
executions (higher $\tau$) in the protocol as explained below.
Suppose, a malicious prover computes $e \leq \tau$ setup steps incorrectly, it can only convince the verifier if the latter
chooses to execute all these $e$ setups (hence never verifying any of them) which happens with probability $\binom{M - e}{\tau - e} \cdot \binom{M}{\tau}^{-1}$.
Moreover, the malicious prover needs to be accepted for the remaining $\tau - e$ executions with honest setups which can happen with probability $\leq (\frac{1}{N})^{\tau - e}$.
Therefore, using this optimization, one needs to execute $M$ setup steps followed by $\tau$ executions of the protocol and the soundness error is given by $\max\limits_{0 \leq e \leq \tau} \binom{M - e}{\tau - e} \cdot \binom{M}{\tau}^{-1} \cdot N^{-(\tau - e)}$.

1c|     3c||Parallel Repetition     3c|[33] Repetition
$N$              2       16      32      2       16      32
$M$              2       16      32      256     272     389
$\tau$           128     32      26      128     35      28
# Setup         256     512     832     256     272     389
# Execution     128     32      26      128     35      28

Example of parameters trade-off for $\lambda = 128$. The optimization greatly reduce the Setup's number for only a small increase of the Execution's number.

From here onward, the reader is advised to keep in mind that
during the protocol, the signer needs to
send information (seeds) corresponding to
(i) $M - \tau$ instances
of the underlying PoK which are generated during the setup phase but
are only used to verify that the setup was run honestly
and (ii) information associated with $\tau$
executions of the underlying PoK.

Seed compression [33]. For all the aforementioned PoK, one has to send the seeds $(\theta^{(k)})_{k \in \intoneto{M} \setminus K}$ used to recompute the auxiliary information $(\aux^{(k)})_{k \in \intoneto{M} \setminus K}$ (with $K \sampler \{ K \subset \{1, \cdots, M \}, \, |K| = \tau \}$) associated to the setups that are not going to be executed.
As explained in [33], one can use Merkle trees in order to reduce the cost of sending these seeds.
To this end, the prover samples a root seed and generates a binary tree of depth $\log(M)$ where each node is a seed derived from its parent node.
Doing so, he can send to the verifier the nodes that allows to recompute all the leafs of the tree except the $\tau$ seeds that should not be revealed thus reducing the cost associated to the $(\theta^{(k)})_{k \in \intoneto{M} \setminus K}$ seeds from $(M - \tau) \cdot \lambda$ to $\tau \log_2(\frac{M}{\tau}) \cdot \lambda$ where $\lambda$ is the security parameter.
A crucial observation is that this optimization works well only when $\tau$ is small with respect to $M$.
In particular for $\tau = M/2$, using a Merkle tree provides no benefit.
Hence, in the case of PoK 1 where $\tau = M/2$, we employ a variant of this optimization by considering $M/2$ binary trees of depth $1$ instead of single binary tree of depth $\log(M)$ which reduces the expected cost of sending the seeds to $3/4 \cdot (M - \tau) \cdot \lambda$ from $(M - \tau) \cdot \lambda$.

Commitment compression [33, 4]. When considering 3-round PoK, the first prover's message contains the commitments $(\aux^{(k)}, \allowbreak \com^{(k)})_{k \in \intoneto{M}}$ where $\aux^{(k)} = (\com^{(k)}_i)_{i \in \intoneto{N}}$.
In order to reduce the cost associated to these commitments, one can instead send a unique commitment $h = \commit{r, \, (\aux^{(k)} \, || \, \allowbreak \com^{(k)})_{k \in \intoneto{M}}}$ as suggested in [4].
Doing so, the prover has to give the verifier all the commitments that the latter cannot recompute himself in order to allow him to check the commitment $h$.
The situation is similar for 5-round PoK with $h = \commit{r, \, (\aux^{(k)})_{k \in \intoneto{M}}}$ and $h' = \commit{r', \, (\com^{(\kappa)})_{\kappa \in K}}$.
In this case, the verifier can recompute $h'$ by himself hence only the commitments contained in $h$ have to be considered.
To reduce the cost associated to these commitments, one can once again leverage Merkle trees as explained in [33].
Indeed, the prover will generate a Merkle tree of his commitments (from bottom to top contrarily to the previous case) and send the root to the verifier as well as all the nodes of the tree that permits to recompute the root from the commitments that the verifier can obtain by himself.

In our PoK 1 (3-round), $(\aux^{(k)})_{k \in \intoneto{M}}$ contains $2M$ commitments while $(\com^{(k)})_{k \in \intoneto{M}}$ contains $M$ commitments.
For the $M - \tau$ instances that are not executed, these commitments can be recomputed by the verifier from the $(\theta^{(k)})_{k \in \intoneto{M} \setminus K}$ seeds.
For the $\tau$ instances that are executed, one commitment from $(\aux^{(\kappa)})_{\kappa \in K}$ can be recomputed by the verifier while the other one can be given in the prover's response $\rsp$.
In addition, all the commitments from $(\com^{(k)})_{k \in \intoneto{M} \setminus K}$ need to be given to the verifier.
Given that $\tau = M/2$, this reduces the cost of sending the $3M$ commitments of our PoK 1 (3-round) to $(1 + 3/4 \cdot (M - \tau) + 7/8 \cdot \tau) \cdot |\com|$.
For PoK 1 (5-round), the cost is reduced from $3M$ commitments to $(2 + 7/8 \cdot \tau) \cdot |\com|$.

For PoK 2 and PoK 3, sending the $(M - \tau)$ commitments $(\com^{(k)})_{k \in \intoneto{M} \setminus K}$ can be done using Merkle trees hence cost $\tau \log_2(\frac{M}{\tau}) \cdot |\com|$.
For the the $M - \tau$ instances that are not executed, the $N(M - \tau)$ commitments from $(\aux^{(k)})_{k \in \intoneto{M} \setminus K}$ can be recomputed by the verifier from the $(\theta^{(k)})_{k \in \intoneto{M} \setminus K}$ seeds.
Interestingly, for the $\tau$ instances that are executed, the situation differs between PoK 2 and PoK 3 which explains why the optimized version of PoK 3 outperforms the optimized version of PoK 2 although both non optimized versions are equivalent.
In the case of PoK 2, only one commitment from $(\aux^{(\kappa)})_{\kappa \in K}$ can be recomputed by the verifier while the other $(N - 1)$ have to be given to him as he can not recomputed them due to the presence of the  value $\bm{u}$.
Hence, sending these commitments using Merkle trees cost $\log(N) \cdot |\com|$.
In contrast, in the [26] setting, $(N - 1)$ commitments from $(\aux^{(\kappa)})_{\kappa \in K}$ can be recomputed by the verifier hence the cost associated to sending the commitments from $(\aux^{(\kappa)})_{\kappa \in K}$ is only $|\com|$.

Small weight vector compression. [4].
One can leverage the small weight of some vectors such as $\pi[\bm{x}]$ in PoK 1 or $\pi[\bm{e}]$ in PoK 2 and PoK 3 by using a compression algorithm before sending them.
Hence, the cost of sending small weight vectors is reduced from $n$ to $n/2$ approximately.

Additional vector compression [14].
This optimization is specific to PoK 1 in which the prover have to send a permutation of a random vector $\pi[\bm{u}]$.
Instead of doing this, one can sample a random value $\bm{v} \samples{\psi} \Ftn$ from some random seed $\psi$ and compute the value $\bm{u} = \pi^{-1}[\bm{v}]$.
When the prover has to send $\pi[\bm{u}]$, he can send $\bm{v}$ instead which can be substituted by the seed $\psi$.
Doing so, one reduce the cost of sending such vectors from $n$ to $\lambda$.

Improved performances from structured matrices. In all aforementioned PoK, a matrix vector multiplication must be computed during each setup.
In order to improve the performance of these protocols, one may choose to use structured matrices featuring an efficient matrix vector multiplication.
For example, one can use quasi-cyclic matrices as their matrix vector multiplication can be performed efficiently by polynomial multiplication.
In this case, the security of the protocol relies on the quasi-cyclic variants $\QCSD$ or $\QCGSD$ of the syndrome decoding problem.

§ SIGNATURE SCHEMES

In this section, we explain how to transform our interactive HVZK PoKs without helper as detailed in Section <ref> into digital signatures using the strong Fiat-Shamir heuristic [27, 18].
We also discuss the security of the resulting signature schemes in both the random oracle model (ROM) and the quantum random oracle model (QROM).

The keystone idea of the Fiat-Shamir heuristic [27] is to “emulate" the random challenge sampling from the verifier by a call to a hash function modelled as a random oracle, thereby turning an interactive
protocol into non-interactive protocol with access to random oracle.

Figures <ref> and <ref> explain how to apply the Fiat-Shamir heuristic in the context of PoK with trusted helper.

We next present the signatures obtained by applying
the Fiat-Shamir transform
to HVZK PoK schemes from Sections <ref> and <ref>.
Starting with our PoK 1 with Helper (Section <ref>, Figure <ref>), PoK 2 with Helper (Section <ref>, Figure <ref>) and PoK 3 with Helper (Section <ref>, Figure <ref>), one can remove the helper using the constructions from Section <ref>.
Doing so, one get our non-optimized 3-round PoK 1 (Appendix <ref>), 5-round PoK 1 (Appendix <ref>), 3-round PoK 2 (Appendix <ref>) and 3-round PoK 3 (Appendix <ref>).
Hereafter, we assume that these protocols provide a negligible soundness error which in practice implies to perform a parallel repetition of the PoK.
By applying the results from Section <ref>, we obtain the optimized versions of our 3-round PoK 1 (Appendix <ref>), 5-round PoK 1 (Appendix <ref>), 3-round PoK 2 (Appendix <ref>) and 3-round PoK 3 (Appendix <ref>).
The optimized versions of our PoK include protocol repetitions hence achieve a negligible soundness error.
Then, using the Fiat-Shamir transformation presented in Figures <ref> and <ref>, we construct four signatures denoted Sig 1 (3-round), Sig 1 (5-round), Sig 2 (3-round) and Sig 3 (3-round)
that can be found in Appendices <ref>, <ref>, <ref> and <ref> respectively.

Similarly to the signatures constructed in [13] and [28], our security theorems apply to the non-optimized versions of our protocols while the optimized versions are the ones considered in practice.

Signatures built from the Fiat-Shamir heuristic have been proven existentially unforgeable in the ROM whenever the underlying HVZK PoK achieves a negligible soundness error, see [39, 40, 1].
These security guarantees can be extended to the QROM model following
the work of [44, 48, 45, 46, 34, 37, 25, 24].
Similarly to the signatures constructed in [13] and [28], our security theorems apply to the non-optimized versions of our protocols while the optimized versions are the ones considered in practice.
On a high level, this line of research has shown that the (multi-round)
Fiat-Shamir heuristic preserves the soundness and the other proof of knowledge
properties in the QROM setting and that transforming such protocols
into signature schemes provides (strong) existential unforgeability guarantees.

Before stating the security properties of the schemes proposed in this work, we define the “computationally unique responses” property which is required for the proof.

A $(2n+1)$ round public-coin interactive PoK is said to have
computationally unique responses if given a partial transcript
$(\com, \, \ch_1, \, \rsp_1, \, \ldots, \, \ch_i)$ it is computationally
infeasible to find two accepting  conversations which share the first
$(2i )$ messages as above but differ in at least one position.
That is,

$$\prb \left[ V(\trans_1) = \accept \bigwedge V(\trans_2) = \accept ~\big|~ (\trans_1, \trans_2) \leftarrow \adv \right]$$

is negligible for computationally bounded (quantum) adversary $\adv$,
$\trans_b = (\com, \, \ch_1, \, \rsp_1, \, \ldots, \, \ch_i, \, \rsp^b_i, \ch^b_{i+1}, \, \rsp^b_{i+1}, \, \ldots , \, \ch^b_{n}, \, \rsp^b_{n}, \,)$
for $b \in \{0,1\}$ such that $\rsp^0_i \neq \rsp^1_i$.

If the non-optimized variants of Sig 1 (3-round), Sig 1 (5-round), Sig 2 and Sig 3 signature schemes are instantiated with a collapsing hash function
as commitment scheme, then the  signature schemes are strong
existential unforgeable under chosen message attack (sUF-CMA) in the QROM.

The proof of Theorem <ref> is similar to those analyzing the
security of (multi-round) Fiat-Shamir transformation of PoK in the QROM [25, 24].
Here, we note that the first message is a commitment generated using
a collapsing hash function and hence is unpredictable.
Also, the second message in case of Sig 1 (5-round) is computed as a function of
the committed values in first message. Similar is the case for the final
responses, which additionally includes some opening information.
Due to the binding property  of the commitment, the second message
and the response for each of the schemes is computationally unique.
As shown earlier, the schemes are also HVZK.
This suffices to prove the
strong existential unforgeable under chosen message attack (sUF-CMA)
property of the schemes following Theorem 23, Theorem 28, Corollary 24,
Corollary 29, and Corollary 30 from [24].

§ PARAMETERS AND COMPARISON

§.§ Parameters choice

The system parameters $(n, k, w, M, N, \tau)$ are chosen such that all known attacks cost more than $2^{\lambda}$ elementary operations for a given security parameter $\lambda$.
The parameters $(n, k, w)$ are related to the difficulty of solving the underlying decoding problems while $(M, N, \tau)$ are related to the soundness of the PoK.
Resulting parameters are given in Table <ref>.

Decoding attack. We consider decoding problems instantiated with binary $[n, k]$ codes and secrets of small weight $w$.
Parameters are chosen according to the BJMM generic attack [15] along with estimates from [30].
For the PoK leveraging quasi-cyclicity, we take into account the DOOM attack from [42] which reduces the complexity by a factor $\sqrt n$.

Soundness error. When considering the beating parallel repetition optimization (see Section <ref>), one has to chose $(M, N, \tau)$ such that the soundness error $\max\limits_{0 \leq e \leq \tau} \binom{M - e}{\tau - e} \cdot \binom{M}{\tau}^{-1} \cdot N^{-(\tau - e)}$ is negligible with respect to $\lambda$.
In practice, this offer a trade-off between performances and signature sizes as one can increase $M$ and $N$ (degrading running time) in order to reduce $\tau$ (improving signature size).
We illustrate this trade-off by providing several parameter sets in Table <ref>.

Attack against 5-round protocols. An attack exploiting the structure of 5-round PoK has been identified in [35].
The main idea is to split the attacker work in two phases: (i) initially it tries to guess the first challenge for several repetitions and then (ii) to guess the second challenge for the remaining repetitions.
Our schemes feature the capability for early abort described in [35] therefore the cost of the attack is equal to $|\mathcal{C}_1|^{\tau^*} + |\mathcal{C}_2|^{\tau - \tau^*}$ where $\mathcal{C}_1$ and $\mathcal{C}_2$ are the challenge spaces and $\tau^* \in [0, \tau]$ is chosen by the adversary to minimize the attack's cost.

§.§ Resulting key and signature sizes

We now explain how to compute the sizes of the signatures Sig 1 (3-round), Sig 1 (5-round), Sig 2 and Sig 3 (see Appendices <ref>, <ref>, <ref> and <ref>).
Hereafter, we consider commitments instantiated from hash functions such that $|\com| = 2\lambda$ bits.
Resulting average sizes are given in Table <ref>.
In practice, the size of these signature varies depending on the challenges received.

Key pair. The key pair of the signature built from PoK 1 is defined by $\sk = (\bm{x})$ and $\pk = (\bm{H}, \bm{y}^{\top} = \bm{H} \bm{x}^{\top})$ while the key pair of the signature built from PoK 2 and PoK 3 is given by $\sk = (\bm{x}, \bm{e})$ and $\pk = (\bm{G}, \bm{y} = \bm{x} \bm{G} + \bm{e})$.
Both the secret values ($\bm{x}$ and $(\bm{x}, \bm{e})$) and the public matrices ($\bm{H}$ and $\bm{G}$) can be generated from seeds.
Therefore, $\sk$ has size $\lambda$ bits in both cases while $\pk$ is $(n - k) + \lambda$ bits long for PoK 1 and $n + \lambda$ bits long for PoK 2 and PoK 3.

Signature from PoK 1. In our Sig 1 (3-round), the signer has to send $(h, \xi, (\theta^{(k)}, \allowbreak \com^{(k)})_{k \in \intoneto{M} \setminus K}, (\rsp^{(\kappa)})_{\kappa \in K})$.
In the 5-round variant, the signer send $(h, h', \xi, \allowbreak (\theta^{(k)})_{k \in \intoneto{M} \setminus K}, (\rsp^{(\kappa)})_{\kappa \in K})$.
Both $h$ and $h'$ are commitments of size $|\com|$ bits while $\xi$ is a $\lambda$ bits long seed.
The $M - \tau$ values $\theta^{(k)}$ are the seeds corresponding to the setups that are checked by the verifier without being executed.
They can be sent using the aforementioned Merkle tree based optimization (see Section <ref>).
In the case of our Sig 1 parameters where $\tau = M/2$, the cost associated to the $\theta^{(k)}$ seeds is equal to $3/4 \cdot (M - \tau) \cdot \lambda$ bits (following the same argument as the one used for the seed compression in the response optimization).
The $(M - \tau)$ commitments $\com^{(k)}$ used in the 3-round variant can be sent in a similar way using $3/4 \cdot (M - \tau) \cdot |\com|$ bits.
The response $\rsp^{(\kappa)}$ differs with respect to the value of the challenge $\alpha$.
It either contains $(\phi^{(\kappa)}, \bm{u}^{(\kappa)} + \bm{x}, \com^{(\kappa)}_1)$ when $\alpha = 0$ or $(\psi^{(\kappa)}, \pi^{(\kappa)}[\bm{x}], \com^{(\kappa)}_0)$ when $\alpha = 1$.
The values $\phi^{(\kappa)}$ and $\psi^{(\kappa)}$ are seeds, the value $\bm{u}^{(\kappa)} + \bm{x}$ is a vector of size $n$ and $\pi^{(\kappa)}[\bm{x}]$ can be sent using $n/2$ bits thanks to the small weight vector compression optimization.
The cost of sending $\com^{(\kappa)}_0$ and $\com^{(\kappa)}_1$ can be reduced from $2|\com|$ to $7/8 \cdot 2|\com|$ using binary trees of length $1$ although this is less efficient than for $(\com^{(k)})_{k \in \intoneto{M} \setminus K}$ as one have to take into account the fact that some instances are not going to be executed.
Thus, the cost associated to the $\tau$ responses $\rsp^{(\kappa)}$ used in the PoK 1 is equal to $\tau/2 \cdot (3n/2 + 2 \lambda + 7/8 \cdot 2|\com|)$.
Overall, the signature constructed from 3-round PoK 1 has a size equal to $(1 + 3/4 \cdot (M - \tau)) \cdot (\lambda + |\com|) + \tau/2 \cdot (3n/2 + 2 \lambda + 7/8 \cdot 2|\com|) \approx \tau \cdot (0.75 n + 5 \lambda) $ bits.
Similarly, the signature constructed from 5-round PoK 1 has a size equal to $(2|\com| + \lambda) + 3/4 \cdot (M - \tau) \cdot \lambda + \tau/2 \cdot (3n/2 + 2 \lambda + 7/8 \cdot 2|\com|) \approx \tau \cdot (0.75 n + 3.5 \lambda)$ bits.
We have provided parameters suitable for the $\SD$ problem and its quasi-cyclic variant $\QCSD$ in Table <ref>.

Signature from PoK 2. In our Sig 2, the signer has to send $(h, \xi, (\theta^{(k)}, \allowbreak \com^{(k)})_{k \in \intoneto{M} \setminus K}, (\rsp^{(\kappa)})_{\kappa \in K})$.
The value $h$ is commitment of size $|\com|$ bits while $\xi$ is a $\lambda$ bits long seed.
The $(M - \tau)$ values $\theta^{(k)}$ and $\com^{(k)}$ are respectively the seeds and commitments  corresponding to the setups that are checked by the verifier without being executed.
By leveraging the Merkle tree based optimization, their cost is respectively equal to $\tau \log_2(M/\tau) \cdot \lambda$ bits and $\tau \log_2(M/\tau) \cdot |\com|$ bits.
The prover's response contains $(\bm{u}^{(\kappa)}_\alpha + \bm{x}, \pi^{(\kappa)}_{\alpha}[\bm{e}], \bm{s}^{(\kappa)}_\alpha, \allowbreak \theta^{(\kappa)}_{\alpha^*}, \aux^{(\kappa)}_{\alpha^*})$.
The vectors $\bm{u}^{(\kappa)}_\alpha + \bm{x}$ and $\bm{s}^{(\kappa)}_\alpha$ are of size $k = n/2$ and $n$ respectively.
In addition, $\pi^{(\kappa)}_{\alpha}[\bm{e}]$ can be sent using $n/2$ bits thanks to the small weight vector compression optimization.
The values $\theta^{(\kappa)}_{\alpha^*}$ and $\aux^{(\kappa)}_{\alpha^*}$ contains respectively $N - 1$ seeds and commitments that can be sent using $\lambda \cdot \log_2(N)$ bits and $|\com| \cdot \log_2(N)$ bits.
Hence the cost associated to the $\tau$ responses is equal to $\tau \cdot (2n + (\lambda + |\com|) \cdot \log_2(N))$ bits.
Overall, the signature constructed from 3-round PoK 2 has a size equal to $(|\com| + \lambda) \cdot (1 + \tau \log_2(M/\tau)) + \tau \cdot (2n + (\lambda + |\com|) \cdot \log_2(N)) \approx \tau \cdot (2n + 3 \lambda \cdot [\log_2(M/\tau) + \log_2(N)])$ bits.

Signature from PoK 3. The case of Sig 3 is very similar to the one of Sig 2 except that it benefits more of the commitment compression optimization as explained in Section <ref>.
As a result, the cost associated to the $\tau$ responses is equal to $\tau \cdot (2n + \lambda \cdot \log_2(N) + |\com|)$ instead of $\tau \cdot (2n + (\lambda + |\com|) \cdot \log_2(N))$.
Hence, the signature constructed from PoK 3 is of size $(|\com| + \lambda) \cdot (1 + \tau \log_2(M/\tau)) + \tau \cdot (2n + \lambda \cdot \log_2(N) + |\com|) \approx \tau \cdot (2n + \lambda \cdot [3\log_2(M/\tau) + \log_2(N) + 2])$ bits.

1c|     $n$     $k$     $w$     $M$     $N$     $\tau$     $\pk$     $\sigma$
Sig 1 (3-round) [$\QCSD$]     1238     619     137     2*256      2*2       2*128     0.1 kB     25.2 kB
1-4 8-9
Sig 1 (3-round) [$\SD$]       1190     595     132                                                                                0.1 kB     24.6 kB
1-4 5-9
Sig 1 (5-round) [$\QCSD$]     1238     619     137     2*256      2*2       2*143     0.1 kB     24.3 kB
1-4 8-9
Sig 1 (5-round) [$\SD$]       1190     595     132                                                                                0.1 kB     23.7 kB
3*Sig 2 (3-round) [$\QCGSD$]      3*1238     3*619     3*137     272     16     35     3*0.2 kB      22.6 kB
5-7 9-9
389     32     28                                  20.6 kB
5-7 9-9
631     64     23                                  19.3 kB
3*Sig 3 (3-round) [$\QCGSD$]      3*1238     3*619     3*137     272     16     35     3*0.2 kB      19.3 kB
5-7 9-9
389     32     28                                  17.0 kB
5-7 9-9
631     64     23                                  15.6 kB

Parameters and sizes for Sig 1, Sig 2 and Sig 3 ($\lambda = 128$)

§.§ Comparison to other code-based signatures

We first compare our new signatures to existing code-based signatures based on proofs on knowledge for the syndrome decoding. Next, we extend this comparison to any code-based signatures.

Comparison between code-based signatures using PoK. We compare the Stern [43], Véron [47, 9], AGS [4, 9], BGS [14], CVE [22], GPS [28] and FJR [26] schemes to our new proposals according to their security, sizes and performances.
To provide a meaningful comparison, we have updated the parameters of old schemes so that they achieve a security level $\lambda = 128$ and have applied recent optimizations to old schemes whenever relevant.
We have used the parameters $n = 1190$, $k = 595$ and $w = 132$ for the schemes based on the $\SD$ problem (without quasi-cyclicity), $n = 1238$, $k = 619$ and $w = 137$ for the schemes based on the $\QCSD$ problem and $n = 226$, $q = 256$, $k = 113$ and $w = 86$ for the schemes based on the $\SD$ problem over $\Fq$.
For recent GPS and FJR proposals, we have used the parameters proposed by their respective authors in [28] and [26].
As the parameters used in [26] differ from the ones used here, this induces small differences between FJR and Sig 3 although both schemes can achieve similar results.
As several of these schemes can be based either on the $\SD$ or $\QCSD$ problem, we have indicated the case considered in the comparison (which matches the initial design of the scheme) and have indicated the other possible case using parenthesis whenever relevant.
Since there is no implementation implementation available for most of these schemes yet, we provide an estimate of their relative performances.
For all these schemes, the first step (every operations executed by the prover before he outputs its first commitment) can be seen as repeating $\mu$ times the computation of $\nu$ operations whose cost is arbitrarily denoted as one $\texttt{cost\_unit}$.
This first step hence costs $\mu \cdot \nu \cdot \texttt{cost\_unit}$.
Using our PoK 2 for illustrative purposes, one can see that $\mu = M$, $\nu = N$ and the $\texttt{cost\_unit}$ encompasses all the operations required to compute $\com^{(k)}_{i}$ for a given $k \in \intoneto{M}$ and $i \in \intoneto{N}$.
We believe, this constitutes a good estimate of the relative performances between these schemes as this step will likely dominates their overall cost.
Indeed, the $\texttt{cost\_unit}$ generally contains the most costly operations (matrix / vector multiplication, randomness sampling and hash computation) and is repeated $\mu \cdot \nu$ time in order to obtain a negligible soundness error.
We define our cost estimate as $\mu \cdot \nu$ thus assuming that the $\texttt{cost\_unit}$ is similar for each schemes.
This introduces an approximation in our comparison which could only be solved by providing and benchmarking actual implementations of the aforementioned schemes.
In particular, this approximation hides the performance difference between using plain matrices and structured ones which is not negligible in practice.
As such, one should compare the schemes whose $\texttt{cost\_unit}$ includes a matrix / vector multiplication (the ones based on the plain $\SD$ problem) separately from the schemes whose $\texttt{cost\_unit}$ features an efficient one thanks to structured matrices (the ones based on the $\QCSD$ problem).
Moreover, the GPS scheme does not include such a multiplication hence its real $\texttt{cost\_unit}$ is likely to be smaller than the one of other schemes which means that the proposed estimate might overestimate its real cost.
Results are displayed in Table <ref>.
One can see that our new constructions provide various trade-offs between security assumptions, performances and sizes for code-based signatures built from PoK.
In particular, Sig 1 brings improvement with respect to Stern, Véron, AGS and BGS protocols at the cost of a very small overhead.
If one is willing to accept a greater performance overhead, then PoK 3 (and PoK 2 to a lesser extent) permits to achieve even smaller signature sizes.

1c|      3c|Performance     2c|Size     2*Security Assumption
1c|      $\mu$     $\nu$     Cost     $\pk$     $\sigma$
Stern                                219      2        438           0.1 kB                       37.6 kB                       $\SD$ (or $\QCSD$) over $\Ft$
Véron                                219      2        438           0.2 kB                       31.2 kB                       $\SD$ (or $\QCSD$) over $\Ft$
CVE                                  156      2        312           0.2 kB                       32.6 KB                       $\SD$ (or $\QCSD$) over $\Fq$
2*AGS                 151      2        302           0.2 kB                       30.5 kB                       2*$\QCSD$/$\DiffSD$ over $\Ft$
141      2        282           3.1 kB                       28.5 kB
2*BGS                 151      2        302           0.1 kB                       25.2 kB                       2*$\QCSD$/$\DiffSD$ over $\Ft$
141      2        282           1.7 kB                       23.5 kB
4*GPS                 512      128      65 536        0.2 kB                       27.1 kB                       4*$\SD$ (or $\QCSD$) over $\Fq$
1024     256      262 144       0.2 kB                       24.0 kB
2048     512      1 048 576     0.2 kB                       21.3 kB
4096     1024     4 194 304     0.2 kB                       19.8 kB
2*FJR                 187      8        1496          0.1 kB                       24.4 kB                       2*$\SD$ (or $\QCSD$) over $\Ft$
389      32       12 448        0.1 kB                       17.6 kB
2*Sig 1 (3-round)     256      2        512           0.1 kB                       25.2 kB                       $\QCSD$ over $\Ft$
256      2        512           0.1 kB                       24.6 kB                       $\SD$ over $\Ft$
2*Sig 1 (5-round)     256      2        512           0.1 kB                       24.3 kB                       $\QCSD$ over $\Ft$
256      2        512           0.1 kB                       23.7 kB                       $\SD$ over $\Ft$
3*Sig 2               272      16       4352          0.2 kB                       22.6 kB                       3*$\QCSD$ (or $\SD$) over $\Ft$
389      32       12 448        0.2 kB                       20.6 kB
631      64       40 384        0.2 kB                       19.3 kB
3*Sig 3               272      16       4352          0.2 kB                       19.3 kB                       3*$\QCSD$ (or $\SD$) over $\Ft$
389      32       12 448        0.2 kB                       17.0 kB
631      64       40 384        0.2 kB                       15.6 kB

Comparison between code-based signatures built from PoK ($\lambda = 128$)

Comparison to other signatures. We provide a comparison with existing code-based signatures (including Wave [23], LESS [16, 11] and Durandal [3]) in Table <ref>.
The LESS scheme relies on the code equivalence problem while Wave relies on both the $\SD$ problem (with large weight) and the indistinguishability of generalized $(U,U + V )$-codes.
We also include Durandal in our comparison even if it is a scheme based on the rank metric.
As such, it would be better to compare it with the rank-metric variants of our schemes.
Such variants are straightforward and are discussed in Section <ref>.

1c|     $\pk$     $\sigma$     $\pk + \sigma$     1c|Security Assumption
2*Wave         2*3.2 MB      2*0.93 kB      2*3.3 MB       Syndrome decoding over $\mathbb{F}_3$ (large weight)

Generalized $(U,U + V )$-codes indistinguishability
3*LESS         9.8 kB                       15.2 kB                       25.0 kB                       Linear Code Equivalence
206 kB                       5.3 kB                        212 kB                        2*Permutation Code Equivalence
11.6 kB                      10.4 kB                       22.0 kB
2*Durandal     15.3 kB                      4.1 kB                        19.4 kB                       Rank syndrome decoding over $\mathbb{F}_{2^m}$ (small weight)
18.6 kB                      5.1 kB                        23.7 kB                       Product spaces subspaces indistinguishability
2*Sig 1        0.1 kB                       24.6 kB                       24.6 kB                       2*Syndrome decoding over $\Ft$ (small weight)
0.1 kB                       22.1 kB                       23.7 kB
3*Sig 2        0.2 kB                       19.8 kB                       22.6 kB                       3*Syndrome decoding over $\Ft$ (small weight)
0.2 kB                       17.8 kB                       20.6 kB
0.2 kB                       15.6 kB                       19.3 kB
3*Sig 3        0.2 kB                       13.7 kB                       19.3 kB                       3*Syndrome decoding over $\Ft$ (small weight)
0.2 kB                       12.0 kB                       17.0 kB
0.2 kB                       10.9 kB                       15.6 kB

Comparison between code-based signatures ($\lambda = 128$)

§ GENERALIZATION AND VARIANTS

In this section, we briefly discuss the generalization of the proposed signatures to additional metrics as well several possible variants.

Generalization to additional metrics. Following the work of [14], we define a Full Domain Linear Isometry (FDLI) set as a set of linear isometries $I$ which has the property that given a random element $\phi \in I$, the image by $\phi$ of a random word $\bm{x}$ of weight $\omega$ is a random word $\bm{y}$ of weight $\omega$.
One can adapt our protocols to other metrics by (i) redefining the weight of vectors and by (ii) replacing the permutation $\pi \in \hperm{n}$ by a random element $\phi$ of a FDLI set $I$.
For instance, our protocols can be adapted easily to the rank metric setting using the FDLI set for rank metric described in [29] along with the rank weight and vectors over $\Fqmn$ in place of the Hamming weight and vectors over $\Ftn$.
This allows to further reduce the size of our signatures as illustrated in Table <ref>.

1c|     $q$     $m$     $n$     $k$     $w$     $M$     $N$     $\tau$     $\pk$     $\sigma$
Sig 1 (3-round)                      6*2     6*31     6*32     6*16     6*9     2*256     2*2     2*128     0.1 kB     22.8 kB
1-1 10-11
Sig 1 (5-round)                                                                                0.1 kB                       19.7 kB
1-1 7-9 10-11
2*Sig 2 (3-round)                                                                     230      8       45      2*0.2 kB      20.8 kB
7-9 11-11
207      16       39                                   19.1 kB
1-1 7-9 10-11
2*Sig 3 (3-round)                                                                     230      8       45      2*0.2 kB      17.4 kB
7-9 11-11
389      32       28                                   15.5 kB

Parameters and sizes in the rank metric setting ($\lambda = 128$)

Variants with others structured matrices. We have explained in Section <ref> how one can use structured matrices in order to improve the performances of our proofs of knowledge.
To this end, we suggest the use of quasi-cyclic matrices as they are commonly used in code-based cryptography.
One should note that this performance improvement could be achieved with any set of matrices that benefit from an efficient matrix / vector product.
Therefore, our protocols can be adapted to work with other kind of structured matrices such as Toeplitz matrices which is generalization of quasi-cyclic matrices.

[1]
Michel Abdalla, Jee Hea An, Mihir Bellare, and Chanathip Namprempre.
From Identification to Signatures via the Fiat-Shamir Transform:
Minimizing Assumptions for Security and Forward-Security.
In International Conference on the Theory and Applications of
Cryptographic Techniques (EUROCRYPT), 2002.

[2]
Martin R. Albrecht, Daniel J Bernstein, Tung Chou, Carlos Cid, Jan Gilcher,
Tanja Lange, Varun Maram, Ingo von Maurich, Rafael Misoczki, Ruben
Niederhagen, Kenneth G. Patterson, Edoardo Persichetti, Christiane Peters,
Peter Schwabe, Nicolas Sendrier, Jakub Szefer, Cen Jung Tjhai, Marlin
Tomlinson, and Wen Wang.
Classic McEliece.
NIST Post-Quantum Cryptography Standardization Project (Round
3), https://classic.mceliece.org, 2020.

[3]
Nicolas Aragon, Olivier Blazy, Philippe Gaborit, Adrien Hauteville, and Gilles
Durandal: a rank metric based signature scheme.
In Annual International Conference on the Theory and
Applications of Cryptographic Techniques (EUROCRYPT), 2019.

[4]
C. Aguilar, P. Gaborit, and J. Schrek.
A new zero-knowledge code based identification scheme with reduced
In IEEE Information Theory Workshop, 2011.

[5]
Carlos Aguilar Melchor, Nicolas Aragon, Magali Bardet, Slim Bettaieb, Loïc
Bidoux, Olivier Blazy, Jean-Christophe Deneuville, Philippe Gaborit, Adrien
Hauteville, Ayoub Otmani, Olivier Ruatta, Jean-Pierre Tillich, and Gilles
ROLLO - Rank-Ouroboros, LAKE & LOCKER.
NIST Post-Quantum Cryptography Standardization Project (Round
2), https://pqc-rollo.org, 2020.

[6]
Carlos Aguilar Melchor, Nicolas Aragon, Paulo Barreto, Slim Bettaieb, Loïc
Bidoux, Olivier Blazy, Jean-Christophe Deneuville, Philippe Gaborit, Santosh
Ghosh, Shay Gueron, Tim Güneysu, Rafael Misoczki, Edoardo Persichetti,
Nicolas Sendrier, Jean-Pierre Tillich, Valentin Vasseur, and Gilles
BIKE: Bit Flipping Key Encapsulation.
NIST Post-Quantum Cryptography Standardization Project (Round
3), https://bikesuite.org, 2020.

[7]
Carlos Aguilar Melchor, Nicolas Aragon, Slim Bettaieb, Loïc Bidoux,
Olivier Blazy, Jurjen Bos, Jean-Christophe Deneuville, Arnaud Dion, Philippe
Gaborit, Jérome Lacan, Edoardo Persichetti, Jean-Marc Robert, Pascal
Véron, and Gilles Zémor.
Hamming Quasi-Cyclic (HQC).
NIST Post-Quantum Cryptography Standardization Project (Round
3), https://pqc-hqc.org, 2020.

[8]
Carlos Aguilar Melchor, Nicolas Aragon, Slim Bettaieb, Loïc Bidoux,
Olivier Blazy, Maxime Bros, Alain Couvreur, Jean-Christophe Deneuville,
Philippe Gaborit, Adrien Hauteville, and Gilles Zémor.
Rank Quasi-Cyclic (RQC).
NIST Post-Quantum Cryptography Standardization Project (Round
2), https://pqc-rqc.org, 2020.

[9]
Slim Bettaieb, Loïc Bidoux, Olivier Blazy, and Philippe Gaborit.
Zero-Knowledge Reparation of the Véron and AGS Code-based
Identification Schemes.
In IEEE International Symposium on Information Theory (ISIT),

[10]
Marco Baldi, Alessandro Barenghi, Franco Chiaraluce, Gerardo Pelosi, and Paolo
NIST Post-Quantum Cryptography Standardization Project (Round
2), https://ledacrypt.org, 2020.

[11]
Alessandro Barenghi, Jean-François Biasse, Edoardo Persichetti, and Paolo
LESS-FM: Fine-tuning Signatures from a Code-based Cryptographic
Group Action.
In International Workshop on Post-Quantum Cryptography
(PQCrypto), 2021.

[12]
Emanuele Bellini, Florian Caullery, Philippe Gaborit, Marc Manzano, and Victor
Improved Véron Identification and Signature Schemes in the rank
In IEEE International Symposium on Information Theory (ISIT),

[13]
Ward Beullens.
Sigma Protocols for MQ, PKP and SIS, and Fishy Signature Schemes.
International Conference on the Theory and Applications of
Cryptographic Techniques (EUROCRYPT), 2020.

[14]
Loïc Bidoux, Philippe Gaborit, and Nicolas Sendrier.
Quasi-Cyclic Stern Proof of Knowledge.
In arXiv preprint arXiv:2110.05005, 2021.

[15]
Anja Becker, Antoine Joux, Alexander May, and Alexander Meurer.
Decoding random binary linear codes in $2^{n/20}$: How $1+1=0$
improves information set decoding.
In International Conference on the Theory and Applications of
Cryptographic Techniques (EUROCRYPT), 2012.

[16]
Jean-François Biasse, Giacomo Micheli, Edoardo Persichetti, and Paolo
LESS is more: Code-based signatures without syndromes.
In International Conference on Cryptology in Africa
(AFRICACRYPT), 2020.

[17]
Elwyn Berlekamp, Robert McEliece, and Henk Van Tilborg.
On the inherent intractability of certain coding problems.
IEEE Transactions on Information Theory, 24(3), 1978.

[18]
David Bernhard, Olivier Pereira, and Bogdan Warinschi.
How Not to Prove Yourself: Pitfalls of the Fiat-Shamir Heuristic and
Applications to Helios.
In International Conference on the Theory and Application of
Cryptology and Information Security (ASIACRYPT), 2012.

[19]
Nicolas Courtois, Matthieu Finiasz, and Nicolas Sendrier.
How to achieve a McEliece-based digital signature scheme.
In International Conference on the Theory and Application of
Cryptology and Information Security (ASIACRYPT), 2001.

[20]
Kefei Chen.
A new identification algorithm.
In International Conference on Cryptography: Policy and
Algorithms (CPA), 1995.

[21]
Lily Chen, Stephen Jordan, Yi-Kai Liu, Dustin Moody, Rene Peralta, Ray Perlner,
and Daniel Smith-Tone.
Report on post-quantum cryptography, volume 12.
US Department of Commerce, National Institute of Standards and
Technology, 2016.

[22]
Pierre-Louis Cayrel, Pascal Véron, and Sidi Mohamed El Yousfi Alaoui.
A Zero-Knowledge Identification Scheme Based on the q-ary Syndrome
Decoding Problem.
In International Conference on Selected Areas in Cryptography
(SAC), 2011.

[23]
Thomas Debris-Alazard, Nicolas Sendrier, and Jean-Pierre Tillich.
Wave: A New Family of Trapdoor One-Way Preimage Sampleable Functions
Based on Codes.
In International Conference on the Theory and Application of
Cryptology and Information Security (ASIACRYPT), 2019.

[24]
Jelle Don, Serge Fehr, and Christian Majenz.
The Measure-and-Reprogram Technique 2.0: Multi-round Fiat-Shamir and
In International Cryptology Conference (CRYPTO), 2020.

[25]
Jelle Don, Serge Fehr, Christian Majenz, and Christian Schaffner.
Security of the Fiat-Shamir Transformation in the Quantum
Random-Oracle Model.
In International Cryptology Conference (CRYPTO), 2019.

[26]
Thibauld Feneuil, Antoine Joux, and Matthieu Rivain.
Shared Permutation for Syndrome Decoding: New Zero-Knowledge
Protocol and Code-Based Signature.
Cryptology ePrint Archive, Report 2021/1576, 2021.

[27]
Amos Fiat and Adi Shamir.
How to Prove Yourself: Practical Solutions to Identification and
Signature Problems.
In International Cryptology Conference (CRYPTO), 1986.

[28]
Shay Gueron, Edoardo Persichetti, and Paolo Santini.
Designing a Practical Code-based Signature Scheme from
Zero-Knowledge Proofs with Trusted Setup.
Cryptology ePrint Archive, Report 2021/1020, 2021.

[29]
Philippe Gaborit, Julien Schrek, and Gilles Zémor.
Full Cryptanalysis of the Chen Identification Protocol.
In International Workshop on Post-Quantum Cryptography
(PQCrypto), 2011.

[30]
Yann Hamdaoui and Nicolas Sendrier.
A Non Asymptotic Analysis of Information Set Decoding.
In Cryptology ePrint Archive, Report 2013/162, 2013.

[31]
Yuval Ishai, Eyal Kushilevitz, Rafail Ostrovsky, and Amit Sahai.
Zero-Knowledge from Secure Multiparty Computation.
In Proceedings of the thirty-ninth annual ACM symposium on
Theory of computing, pages 21–30, 2007.

[32]
Abhishek Jain, Stephan Krenn, Krzysztof Pietrzak, and Aris Tentes.
Commitments and Efficient Zero-Knowledge Proofs from Learning Parity
with Noise.
In International Conference on the Theory and Application of
Cryptology and Information Security (ASIACRYPT), 2012.

[33]
Jonathan Katz, Vladimir Kolesnikov, and Xiao Wang.
Improved Non-Interactive Zero Knowledge with Applications to
Post-Quantum Signatures.
In Proceedings of the 2018 ACM Conference on Computer and
Communications Security (CCS), 2018.

[34]
Eike Kiltz, Vadim Lyubashevsky, and Christian Schaffner.
A Concrete Treatment of Fiat-Shamir Signatures in the Quantum
Random-Oracle Model.
In International Conference on the Theory and Applications of
Cryptographic Techniques (EUROCRYPT), 2018.

[35]
Daniel Kales and Greg Zaverucha.
An Attack on Some Signature Schemes Constructed From Five-Pass
Identification Schemes.
In International Conference on Cryptology and Network Security
(CANS), 2020.

[36]
Vadim Lyubashevsky.
Fiat-Shamir with Aborts: Applications to Lattice and Factoring-Based
In International Conference on the Theory and Application of
Cryptology and Information Security (ASIACRYPT), 2009.

[37]
Qipeng Liu and Mark Zhandry.
Revisiting Post-quantum Fiat-Shamir.
In International Cryptology Conference (CRYPTO), 2019.

[38]
Robert J McEliece.
A public-key cryptosystem based on algebraic coding theory.
Coding Thv, 4244, 1978.

[39]
David Pointcheval and Jacques Stern.
Security Proofs for Signature Schemes.
In International Conference on the Theory and Applications of
Cryptographic Techniques (EUROCRYPT), 1996.

[40]
David Pointcheval and Jacques Stern.
Security Arguments for Digital Signatures and Blind Signatures.
Journal of cryptology, 13(3), 2000.

[41]
Claus-Peter Schnorr.
Efficient Signature Generation by Smart Cards.
Journal of Cryptology, 1991.

[42]
Nicolas Sendrier.
Decoding One Out of Many.
In International Workshop on Post-Quantum Cryptography
(PQCrypto), 2011.

[43]
Jacques Stern.
A new identification scheme based on syndrome decoding.
In International Cryptology Conference (CRYPTO), 1993.

[44]
Dominique Unruh.
Quantum Proofs of Knowledge.
In International Conference on the Theory and Applications of
Cryptographic Techniques (EUROCRYPT), 2012.

[45]
Dominique Unruh.
Computationally Binding Quantum Commitments.
In International Conference on the Theory and Applications of
Cryptographic Techniques (EUROCRYPT), 2016.

[46]
Dominique Unruh.
Post-quantum Security of Fiat-Shamir.
In International Conference on the Theory and Application of
Cryptology and Information Security (ASIACRYPT), 2017.

[47]
Pascal Véron.
Improved Identification Schemes based on Error-Correcting Codes.
Applicable Algebra in Engineering, Communication and Computing,

[48]
Mark Zhandry.
How to Construct Quantum Random Functions.
In IEEE Symposium on Foundations of Computer Science FOCS,

§ POK 1 (3-ROUND, WITHOUT OPTIMIZATION)

(x, H, y)   (H, y)

k ∈M

θ^(k) ^λ

π^(k) θ^(k) n,   u^(k) θ^(k)

r_0 θ^(k) ^λ,   r_1 θ^(k) ^λ

^(k)_0 = r^(k)_0,   π^(k)   ||   H (u^(k))^⊤

^(k)_1 = r^(k)_1,   π^(k)[u^(k)]

^(k) = (^(k)_0, ^(k)_1)

r^(k) ^λ

^(k) = r^(k),   π^(k)[u^(k) + x]

*(^(k), ^(k))_k ∈M

*(κ, α)

α= 0

z_1 = π^(κ),   z_2 = u^(κ) + x

= (r_0^(κ),   r^(κ),   z_1,   z_2)

α= 1

z_3 = π^(κ)[u^(κ)],   z_4 = π^(κ)[x]

= (r_1^(κ),   r^(κ),   z_3,   z_4)

*(θ^(k))_k ∈M ∖κ,

k ∈M ∖κ

Compute  ^(k)  from  θ^(k)

(^(k) ≠^(k))   0

α= 0

b_1 ( ^(κ)_0 = r_0^(κ),   z_1   ||   H z_2^⊤ - y^⊤ )

b_2 ( ^(κ) = r^(κ),   z_1[z_2] )

b_1 ∧b_2

α= 1

b_1 ( ^(κ)_1 = r_1^(κ),   z_3 )

b_2 ( ^(κ) = r^(κ),   z_3 + z_4 )

b_3 ( z_4 = ω)

b_1 ∧b_2 ∧b_3

3-round HVZK PoK for the $\SD$ problem (without optimization)

§ POK 1 (3-ROUND, WITH OPTIMIZATIONS)

(x, H, y)   (H, y)

k ∈M

θ^(k) ^λ,   ϕ^(k) θ^(k) ^λ,   ψ^(k) θ^(k) ^λ

π^(k) ϕ^(k) n,   v^(k) ψ^(k) ,   u^(k) = (π^(k))^-1[v^(k)]

r^(k)_0 ϕ^(k) ^λ,   ^(k)_0 = r^(k)_0,   π^(k)   ||   H (u^(k))^⊤

r^(k)_1 ψ^(k) ^λ,   ^(k)_1 = r^(k)_1,   π^(k)[u^(k)]

^(k) = (^(k)_0, ^(k)_1)

r^(k) ξ ^λ,   ^(k) = r^(k),   π^(k)[u^(k) + x]

r ξ ^λ,   h = r,   (^(k)   ||   ^(k))_k ∈M

K { K ⊂{1, ⋯, M },   |K| = τ}

A ^τ

*(K, A)

(κ, α) ∈K ×A

α= 0

z^(κ)_1 = ϕ^(κ),   z^(κ)_2 = u^(κ) + x

^(κ) = (z^(κ)_1,   z^(κ)_2,   ^(κ)_1)

α= 1

z^(κ)_3 = ψ^(κ),   z^(κ)_4 = π^(κ)[x]

^(κ) = (z^(κ)_3,   z^(κ)_4,   ^(κ)_0)

= (ξ, (θ^(k), ^(k))_k ∈M ∖K,   (^(κ))_κ∈K)

Compute  r̅, (r̅^(κ))_κ∈K  from  ξ

k ∈M ∖K

Compute  ^(k)  from  θ^(k)

(κ, α) ∈K ×A

α= 0

z̅^(κ)_1 z^(κ)_1 n,   r̅^(κ)_0 z^(κ)_1 ^λ

^(κ)_0 = r̅_0^(κ),   z̅^(κ)_1   ||   H (z^(κ)_2)^⊤ - y^⊤

^(κ) = r̅^(κ),   z̅^(κ)_1[z^(κ)_2]

α= 1

z̅^(κ)_3 z^(κ)_3 ,   r̅^(κ)_1 z^(κ)_3 ^λ

^(κ)_1 = r̅_1^(κ),   z̅_3

^(κ) = r̅^(κ),   z̅_3 + z_4

b^(κ)_1 ( z^(κ)_4 = ω)

b_1 = ⋀_κ∈K b^(κ)_1

b_2 ( h = r,   (^(k)   ||   ^(k))_k ∈M )

b_1 ∧b_2

3-round HVZK PoK for the $\SD$ problem (with optimizations)

§ SIG 1 (3-ROUND)

ρ_1 ^λ,   x ρ_1  such that  x = ω

ρ_2 ^λ,   H ρ_2 ^,   y^⊤ = H x^⊤

(, ) = (ρ_1, (ρ_2, y))

(, , m)

k ∈M

θ^(k) ^λ,   ϕ^(k) θ^(k) ^λ,   ψ^(k) θ^(k) ^λ

π^(k) ϕ^(k) n,   v^(k) ψ^(k) ,   u^(k) = (π^(k))^-1[v^(k)]

r^(k)_0 ϕ^(k) ^λ,   ^(k)_0 = r^(k)_0,   π^(k)   ||   H (u^(k))^⊤

r^(k)_1 ψ^(k) ^λ,   ^(k)_1 = r^(k)_1,   π^(k)[u^(k)]

^(k) = (^(k)_0, ^(k)_1)

r^(k) ξ ^λ,   ^(k) = r^(k),   π^(k)[u^(k) + x]

r ξ ^λ,   h = r,   (^(k)   ||   ^(k))_k ∈M

(K,   A) m   ||     ||   h

(κ, α) ∈K ×A

α= 0

z^(κ)_1 = ϕ^(κ),   z^(κ)_2 = u^(κ) + x

^(κ) = (z^(κ)_1,   z^(κ)_2,   ^(κ)_1)

α= 1

z^(κ)_3 = ψ^(κ),   z^(κ)_4 = π^(κ)[x]

^(κ) = (z^(κ)_3,   z^(κ)_4,   ^(κ)_0)

= (ξ, (θ^(k), ^(k))_k ∈M ∖K,   (^(κ))_κ∈K)

σ= (h,   )

$\keygen$ and $\sign$ algorithms for Sig 1 (3-round)

(, σ, m)

Parse  σ as  σ= (h, )  and   as  = (ξ, (θ^(k), ^(k))_k ∈M ∖K,   (^(κ))_κ∈K)

(K,   A) m   ||     ||   h

Compute  r̅, (r̅^(κ))_κ∈K  from  ξ

k ∈M ∖K

Compute  ^(k)  from  θ^(k)

(κ, α) ∈K ×A

α= 0

z̅^(κ)_1 z^(κ)_1 n,   r̅^(κ)_0 z^(κ)_1 ^λ

^(κ)_0 = r̅_0^(κ),   z̅^(κ)_1   ||   H (z^(κ)_2)^⊤ - y^⊤

^(κ) = r̅^(κ),   z̅^(κ)_1[z^(κ)_2]

α= 1

z̅^(κ)_3 z^(κ)_3 ,   r̅^(κ)_1 z^(κ)_3 ^λ

^(κ)_1 = r̅_1^(κ),   z̅_3

^(κ) = r̅^(κ),   z̅_3 + z_4

b^(κ)_1 ( z^(κ)_4 = ω)

b_1 = ⋀_κ∈K b^(κ)_1

b_2 ( h = r,   (^(k)   ||   ^(k))_k ∈M )

b_1 ∧b_2

$\verif$ algorithm for Sig 1 (3-round)

§ POK 1 (5-ROUND, WITHOUT OPTIMIZATION)

(x, H, y)   (H, y)

k ∈M

θ^(k) ^λ

π^(k) θ^(k) n,   u^(k) θ^(k)

r_0 θ^(k) ^λ,   r_1 θ^(k) ^λ

^(k)_0 = r^(k)_0,   π^(k)   ||   H (u^(k))^⊤

^(k)_1 = r^(k)_1,   π^(k)[u^(k)]

^(k) = (^(k)_0, ^(k)_1)

*(^(k))_k ∈M

r^(κ) ^λ

^(κ) = r^(κ),   π^(κ)[u^(κ) + x]

*(θ^(k))_k ∈M ∖κ,   ^(κ)

k ∈M ∖κ

Compute  ^(k)  from  θ^(k)

(^(k) ≠^(k))   0

α= 0

z_1 = π^(κ),   z_2 = u^(κ) + x

= (r_0^(κ),   r^(κ),   z_1,   z_2)

α= 1

z_3 = π^(κ)[u^(κ)],   z_4 = π^(κ)[x]

= (r_1^(κ),   r^(κ),   z_3,   z_4)

α= 0

b_1 ( ^(κ)_0 = r_0^(κ),   z_1   ||   H z_2^⊤ - y^⊤ )

b_2 ( ^(κ) = r^(κ),   z_1[z_2] )

b_1 ∧b_2

α= 1

b_1 ( ^(κ)_1 = r_1^(κ),   z_3 )

b_2 ( ^(κ) = r^(κ),   z_3 + z_4 )

b_3 ( z_4 = ω)

b_1 ∧b_2 ∧b_3

5-round HVZK PoK for the $\SD$ problem (without optimization)

§ POK 1 (5-ROUND, WITH OPTIMIZATIONS)

(x, H, y)   (H, y)

k ∈M

θ^(k) ^λ,   ϕ^(k) θ^(k) ^λ,   ψ^(k) θ^(k) ^λ

π^(k) ϕ^(k) n,   v^(k) ψ^(k) ,   u^(k) = (π^(k))^-1[v^(k)]

r^(k)_0 ϕ^(k) ^λ,   ^(k)_0 = r^(k)_0,   π^(k)   ||   H (u^(k))^⊤

r^(k)_1 ψ^(k) ^λ,   ^(k)_1 = r^(k)_1,   π^(k)[u^(k)]

^(k) = (^(k)_0, ^(k)_1)

r ξ ^λ,   h = r,   (^(k))_k ∈M

K { K ⊂{ 1, ⋯, M },   |K| = τ}

r^(κ) ξ ^λ,   ^(κ) = r^(κ),   π^(κ)[u^(κ) + x]

r' ξ ^λ,   h' = r',   (^(κ))_κ∈K

A ^τ

(κ, α) ∈K ×A

α= 0

z^(κ)_1 = ϕ^(κ),   z^(κ)_2 = u^(κ) + x,   ^(κ) = (z^(κ)_1,   z^(κ)_2,   ^(κ)_1)

α= 1

z^(κ)_3 = ψ^(κ),   z^(κ)_4 = π^(κ)[x],   ^(κ) = (z^(κ)_3,   z^(κ)_4,   ^(κ)_0)

= ( ξ, (θ^(k))_k ∈M ∖K,   (^(κ))_κ∈K )

Compute  r̅, (r̅^(κ))_κ∈K  and  r̅'̅  from  ξ

k ∈M ∖K

Compute  ^(k)  from  θ^(k)

(κ, α) ∈K ×A

α= 0

z̅^(κ)_1 z^(κ)_1 n,   r̅^(κ)_0 z^(κ)_1 ^λ

^(κ)_0 = r̅_0^(κ),   z̅^(κ)_1   ||   H (z^(κ)_2)^⊤ - y^⊤

^(κ) = r̅^(κ),   z̅^(κ)_1[z^(κ)_2]

α= 1

z̅^(κ)_3 z^(κ)_3 ,   r̅^(κ)_1 z^(κ)_3 ^λ

^(κ)_1 = r̅_1^(κ),   z̅_3

^(κ) = r̅^(κ),   z̅_3 + z_4

b^(κ)_1 ( z^(κ)_4 = ω)

b_1 = ⋀_κ∈K b^(κ)_1

b_2 ( h = r̅,   (^(k))_k ∈M  )

b_3 ( h' = r̅'̅,   (^(κ))_κ∈K  )

b_1 ∧b_2 ∧b_3

5-round HVZK PoK for the $\SD$ problem (with optimizations)

§ SIG 1 (5-ROUND)

ρ_1 ^λ,   x ρ_1  such that  x = ω

ρ_2 ^λ,   H ρ_2 ^,   y^⊤ = H x^⊤

(, ) = (ρ_1, (ρ_2, y))

(, , m)

k ∈M

θ^(k) ^λ,   ϕ^(k) θ^(k) ^λ,   ψ^(k) θ^(k) ^λ

π^(k) ϕ^(k) n,   v^(k) ψ^(k) ,   u^(k) = (π^(k))^-1[v^(k)]

r^(k)_0 ϕ^(k) ^λ,   ^(k)_0 = r^(k)_0,   π^(k)   ||   H (u^(k))^⊤

r^(k)_1 ψ^(k) ^λ,   ^(k)_1 = r^(k)_1,   π^(k)[u^(k)]

^(k) = (^(k)_0, ^(k)_1)

r ξ ^λ,   h = r,   (^(k))_k ∈M

K m   ||     ||   h

r^(κ) ξ ^λ,   ^(κ) = r^(κ),   π^(κ)[u^(κ) + x]

r' ξ ^λ,   h' = r',   (^(κ))_κ∈K

A m   ||     ||   h   ||   h'

(κ, α) ∈K ×A

α= 0

z^(κ)_1 = ϕ^(κ),   z^(κ)_2 = u^(κ) + x,   ^(κ) = (z^(κ)_1,   z^(κ)_2,   ^(κ)_1)

α= 1

z^(κ)_3 = ψ^(κ),   z^(κ)_4 = π^(κ)[x],   ^(κ) = (z^(κ)_3,   z^(κ)_4,   ^(κ)_0)

= ( ξ, (θ^(k))_k ∈M ∖K,   (^(κ))_κ∈K )

σ= (h,   h',   )

$\keygen$ and $\sign$ algorithms for Sig 1 (5-round)

(, σ, m)

Parse  σ as  σ= (h, h', )  and   as  = ( ξ, (θ^(k))_k ∈M ∖K,   (^(κ))_κ∈K )

K m   ||     ||   h

A m   ||     ||   h   ||   h'

Compute  r̅, (r̅^(κ))_κ∈K  and  r̅'̅  from  ξ

k ∈M ∖K

Compute  ^(k)  from  θ^(k)

(κ, α) ∈K ×A

α= 0

z̅^(κ)_1 z^(κ)_1 n,   r̅^(κ)_0 z^(κ)_1 ^λ

^(κ)_0 = r̅_0^(κ),   z̅^(κ)_1   ||   H (z^(κ)_2)^⊤ - y^⊤

^(κ) = r̅^(κ),   z̅^(κ)_1[z^(κ)_2]

α= 1

z̅^(κ)_3 z^(κ)_3 ,   r̅^(κ)_1 z^(κ)_3 ^λ

^(κ)_1 = r̅_1^(κ),   z̅_3

^(κ) = r̅^(κ),   z̅_3 + z_4

b^(κ)_1 ( z^(κ)_4 = ω)

b_1 = ⋀_κ∈K b^(κ)_1

b_2 ( h = r̅,   (^(k))_k ∈M  )

b_3 ( h' = r̅'̅,   (^(κ))_κ∈K  )

b_1 ∧b_2 ∧b_3

$\verif$ algorithm for Sig 1 (5-round)

§ POK 2 (3-ROUND, WITHOUT OPTIMIZATION)

(x, e, G, y)   (G, y)

k ∈M

θ^(k) ^λ

i ∈N

θ^(k)_i θ^(k) ^λ,   π^(k)_i θ^(k)_i n

u^(k)_i θ^(k)_i ,   v^(k)_i θ^(k)_i

u^(k) = ∑_i ∈N u^(k)_i

i ∈N

r^(k)_i θ_i ^λ,   θ^(k)_i^* = (θ^(k)_j)_j ∈N ∖i

^(k)_i = r^(k)_i,   π^(k)_i[y + u^(k) G] + v^(k)_i   ||   θ^(k)_i^*

^(k) = (^(k)_i)_i ∈N

i ∈[1, N]

s^(k)_i = π^(k)_i[(u^(k) + x) G] + v^(k)_i

r^(k) ^λ,   s^(k) = (s^(k)_i)_i ∈N

^(k) = r^(k),   u^(k) + x   ||   s^(k)

*(^(k), ^(k))_k ∈M

*(κ, α)

z_1 = u^(κ)_α+ x,   z_2 = π^(κ)_α[e],   z_3 = s^(κ)_α,   z_4 = θ^(κ)_α^*

= (r_α^(κ), r^(κ), z_1, z_2, z_3, z_4)

*(θ^(k))_k ∈M ∖κ,

k ∈M ∖κ

Compute  ^(k)  from  θ^(k)

(^(k) ≠^(k))   0

Compute  (π̅_i^(κ), u̅_i^(κ), v̅_i^(κ))_i ∈N ∖α  from  z_4

z̅_1 = z_1 + ∑_i ∈N ∖α u̅^(κ)_i

i ∈[1, N] ∖α

s̅^(κ)_i = π̅^(κ)_i[z̅^(κ)_1G] + v̅^(κ)_i

s̅^(κ) = (s̅^(κ)_1,   ⋯,   s̅^(κ)_α- 1,   z_3,   s̅^(κ)_α+ 1,   ⋯,   s̅^(κ)_N)

b_1 ( ^(κ) = r^(κ),   z̅_1   ||   s̅^(κ) )

b_2 ( ^(κ)_α= r^(κ)_α,   z_3 + z_2   ||   z_4 )

b_3 ( z_2 = ω)

b_1 ∧b_2 ∧b_3

3-round ZK PoK for the $\GSD$ problem (without optimization)

§ POK 2 (3-ROUND, WITH OPTIMIZATIONS)

(x, e, G, y)   (G, y)

k ∈M

θ^(k) ^λ

i ∈N

θ^(k)_i θ^(k) ^λ,   π^(k)_i θ^(k)_i n

u^(k)_i θ^(k)_i ,   v^(k)_i θ^(k)_i

u^(k) = ∑_i ∈N u^(k)_i

i ∈N

r^(k)_i ξ ^λ,   θ^(k)_i^* = (θ^(k)_j)_j ∈N ∖i

^(k)_i = r^(k)_i,   π^(k)_i[y + u^(k) G] + v^(k)_i   ||   θ^(k)_i^*

s^(k)_i = π^(k)_i[(u^(k) + x) G] + v^(k)_i

^(k) = (^(k)_i)_i ∈N

s^(k) = (s^(k)_i)_i ∈N

r^(k) ξ ^λ,   ^(k) = r^(k),   u^(k) + x   ||   s^(k)

r ξ ^λ,   h = r,   (^(k)   ||   ^(k))_k ∈M

K { K ⊂{1, ⋯, M },   |K| = τ}

A ^τ

*(K, A)

(κ, α) ∈K ×A

z^(κ)_1 = u^(κ)_α+ x,   z^(κ)_2 = π^(κ)_α[e],   z^(κ)_3 = s^(κ)_α

z^(κ)_4 = θ^(κ)_α^*,   ^(κ)_α^* = (^(κ)_i)_i ∈N ∖α

^(κ) = (z^(κ)_1, z^(κ)_2, z^(κ)_3, z^(κ)_4, ^(κ)_α^*)

= (ξ, (θ^(k), ^(k))_k ∈M ∖K,   (^(κ))_κ∈K)

Compute  r̅, (r̅^(κ)_α, r̅^(κ))_(κ, α) ∈K ×A  from  ξ

k ∈M ∖K

Compute  ^(k)  from  θ^(k)

(κ, α) ∈K ×A

Compute  (π̅_i^(κ), u̅_i^(κ), v̅_i^(κ))_i ∈N ∖α  from  z^(κ)_4

z̅^(κ)_1 = z^(κ)_1 + ∑_i ∈N ∖α u̅^(κ)_i

i ∈[1, N] ∖α

s̅^(κ)_i = π̅^(κ)_i[z̅^(κ)_1 G] + v̅^(κ)_i

s̅^(κ) = (s̅^(κ)_1,   ⋯,   s̅^(κ)_α- 1,   z^(κ)_3,   s̅^(κ)_α+ 1,   ⋯,   s̅^(κ)_N)

^(κ) = r̅^(κ),   z̅^(κ)_1   ||   s̅^(κ)

^(κ)_α = r̅^(κ)_α,   z^(κ)_3 + z^(κ)_2   ||   z^(κ)_4

b_1^(κ) ( z_2^(κ) = ω)

b_1 = ⋀_κ∈K b_1^(κ)

b_2 ( h = r̅,   (^(k)   ||   ^(k))_k ∈M )

b_1 ∧b_2

ZK PoK for the $\GSD$ problem over $\Ft$ (with optimizations)

§ SIG 2

ρ_1 ^λ,   x ρ_1 ,   e ρ_1  such that  e = ω

ρ_2 ^λ,   G ρ_2 ^,   y = x G + e

(, ) = (ρ_1, (ρ_2, y))

(, , m)

k ∈M

θ^(k) ^λ

i ∈N

θ^(k)_i θ^(k) ^λ,   π^(k)_i θ^(k)_i n

u^(k)_i θ^(k)_i ,   v^(k)_i θ^(k)_i

u^(k) = ∑_i ∈N u^(k)_i

i ∈N

r^(k)_i ξ ^λ,   θ^(k)_i^* = (θ^(k)_j)_j ∈N ∖i

^(k)_i = r^(k)_i,   π^(k)_i[y + u^(k) G] + v^(k)_i   ||   θ^(k)_i^*

s^(k)_i = π^(k)_i[(u^(k) + x) G] + v^(k)_i

^(k) = (^(k)_i)_i ∈N

s^(k) = (s^(k)_i)_i ∈N

r^(k) ξ ^λ,   ^(k) = r^(k),   u^(k) + x   ||   s^(k)

r ξ ^λ,   h = r,   (^(k)   ||   ^(k))_k ∈M

(K, A) m   ||     ||   h

(κ, α) ∈K ×A

z^(κ)_1 = u^(κ)_α+ x,   z^(κ)_2 = π^(κ)_α[e],   z^(κ)_3 = s^(κ)_α

z^(κ)_4 = θ^(κ)_α^*,   ^(κ)_α^* = (^(κ)_i)_i ∈N ∖α

^(κ) = (z^(κ)_1, z^(κ)_2, z^(κ)_3, z^(κ)_4, ^(κ)_α^*)

= (ξ, (θ^(k), ^(k))_k ∈M ∖K,   (^(κ))_κ∈K)

σ= (h, )

$\keygen$ and $\sign$ algorithms for Sig 2

(, σ, m)

Parse  σ as  σ= (h, )  and   as  = (ξ, (θ^(k), ^(k))_k ∈M ∖K,   (^(κ))_κ∈K)

(K,   A) m   ||     ||   h

Compute  r̅, (r̅^(κ)_α, r̅^(κ))_(κ, α) ∈K ×A  from  ξ

k ∈M ∖K

Compute  ^(k)  from  θ^(k)

(κ, α) ∈K ×A

Compute  (π̅_i^(κ), u̅_i^(κ), v̅_i^(κ))_i ∈N ∖α  from  z^(κ)_4

z̅^(κ)_1 = z^(κ)_1 + ∑_i ∈N ∖α u̅^(κ)_i

i ∈[1, N] ∖α

s̅^(κ)_i = π̅^(κ)_i[z̅^(κ)_1 G] + v̅^(κ)_i

s̅^(κ) = (s̅^(κ)_1,   ⋯,   s̅^(κ)_α- 1,   z^(κ)_3,   s̅^(κ)_α+ 1,   ⋯,   s̅^(κ)_N)

^(κ) = r̅^(κ),   z̅^(κ)_1   ||   s̅^(κ)

^(κ)_α = r̅^(κ)_α,   z^(κ)_3 + z^(κ)_2   ||   z^(κ)_4

b_1^(κ) ( z_2^(κ) = ω)

b_1 = ⋀_κ∈K b_1^(κ)

b_2 ( h = r̅,   (^(k)   ||   ^(k))_k ∈M )

b_1 ∧b_2

$\verif$ algorithm for Sig 2

§ POK 3 (3-ROUND, WITHOUT OPTIMIZATION)

(x, e, G, y)   (G, y)

k ∈M

θ^(k) ^λ

i ∈N

θ^(k)_i θ^(k) ^λ,   π^(k)_i θ^(k)_i n

u^(k)_i θ^(k)_i ,   v^(k)_i θ^(k)_i

π^(k) = π^(k)_N ∘⋯∘π^(k)_1

u^(k) = ∑_i ∈N u^(k)_i

v^(k) = v^(k)_N + ∑_i ∈N - 1 π^(k)_N ∘⋯∘π^(k)_i + 1[v^(k)_i]

s^(k)_0 = (u^(k) + x) G

i ∈N

r^(k)_i θ^(k) ^λ,   θ^(k)_i^* = (θ^(k)_j)_j ∈N ∖i

s^(k)_i = π^(k)_i[s^(k)_i - 1] + v^(k)_i

^(k)_i = r^(k)_i,   π^(k)[y + u^(k) G] + v^(k)   ||   θ^(k)_i^*

^(k) = (^(k)_i)_i ∈N

r^(k) ^λ,   s^(k) = (s^(k)_i)_i ∈N

^(k) = r^(k),   u^(k) + x   ||   s^(k)

*(^(k), ^(k))_k ∈M

*(κ, α)

z_1 = u^(κ)_α+ x,   z_2 = π^(κ)[e]

z_3 = s^(κ)_α,   z_4 = θ^(κ)_α^*

= (r^(κ)_α, r^(κ), z_1, z_2, z_3, z_4)

*(θ^(k))_k ∈M ∖κ,

k ∈M ∖κ

Compute  ^(k)  from  θ^(k)

(^(k) ≠^(k))   0

Compute  (π̅_i, v̅_i)_i ∈N ∖α  from  z_4

z̅_1 = z_1 + ∑_i ∈N ∖α u^(κ)_i

s̅_0 = z̅_1 G

i ∈[1, N] ∖α

s̅^(κ)_i = π̅^(κ)_i[s̅^(κ)_i - 1] + v̅^(κ)_i

s̅^(κ) = (s̅^(κ)_1,   ⋯,   s̅^(κ)_α- 1,   z_3,   s̅^(κ)_α+ 1,   ⋯,   s̅^(κ)_N)

b_1 ( ^(κ) = r^(κ),   z̅_1   ||   s̅^(κ) )

b_2 ( ^(κ)_α= r^(κ)_α,   s̅^(κ)_N + z_2   ||   z_4 )

b_3 ( z_2 = ω)

3-round HVZK PoK for the $\GSD$ problem (without optimization)

§ POK 3 (3-ROUND, WITH OPTIMIZATIONS)

(x, e, G, y)   (G, y)

k ∈M

θ^(k) ^λ

i ∈N

θ^(k)_i θ^(k) ^λ,   π^(k)_i θ^(k)_i n

u^(k)_i θ^(k)_i ,   v^(k)_i θ^(k)_i

π^(k) = π^(k)_N ∘⋯∘π^(k)_1,   u^(k) = ∑_i ∈N u^(k)_i

v^(k) = v^(k)_N + ∑_i ∈N - 1 π^(k)_N ∘⋯∘π^(k)_i + 1[v^(k)_i]

s^(k)_0 = (u^(k) + x) G

i ∈N

r^(k)_1, i ξ ^λ,   ^(k)_1,i = r^(k)_1,i,   θ^(k)_i

s^(k)_i = π^(k)_i[s^(k)_i - 1] + v^(k)_i

r^(k)_2 ξ ^λ,   ^(k)_2 = r^(k)_2,   π^(k)[y + u^(k) G] + v^(k)

s^(k) = (s^(k)_i)_i ∈N,   ^(k) = (^(k)_1,i,   ^(k)_2)_i ∈N

r^(k) ξ ^λ,   ^(k) = r^(k),   u^(k) + x   ||   s^(k)

r ξ ^λ,   h = r,   (^(k)   ||   ^(k))_k ∈M

K { K ⊂{1, ⋯, M },   |K| = τ}

A ^τ

*(K, A)

(κ, α) ∈K ×A

z^(κ)_1 = u^(κ)_α+ x,   z^(κ)_2 = π^(κ)[e],   z^(κ)_3 = s^(κ)_α

z^(κ)_4 = θ^(κ)_α^* = (θ^(κ)_j)_j ∈N ∖α

^(κ) = (z^(κ)_1, z^(κ)_2, z^(κ)_3, z^(κ)_4, ^(κ)_1,α)

= (ξ, (θ^(k), ^(k))_k ∈M ∖K,   (^(κ))_κ∈K)

Compute  r̅, r̅'̅, (r̅^(κ)_1,i, r̅^(κ)_2)^κ∈K_i ∈N  from  ξ

k ∈M ∖K

Compute  ^(k)  from  θ^(k)

(κ, α) ∈K ×A

Compute  (θ^(κ)_i, π̅^(κ)_i, v̅^(κ)_i)_i ∈N ∖α  from  z_4

z̅^(κ)_1 = z^(κ)_1 + ∑_i ∈N ∖α u^(κ)_i,   s̅^(κ)_0 = z̅^(κ)_1 G

i ∈[1, N] ∖α

^(κ)_1,i = r^(κ)_1,i,   θ^(κ)_i

s̅^(κ)_i = π̅^(κ)_i[s̅^(κ)_i - 1] + v̅^(κ)_i

s̅^(κ) = (s̅^(κ)_1,   ⋯,   s̅^(κ)_α- 1,   z_3,   s̅^(κ)_α+ 1,   ⋯,   s̅^(κ)_N)

^(κ) = r̅^(κ),   z̅_1   ||   s̅^(κ)

^(κ)_2 = r̅^(κ)_2,   s̅^(κ)_N + z_2

b_1^(κ) ( z_2^(κ) = ω)

b_1 = ⋀_κ∈K b_1^(κ)

b_2 ( h = r̅,   (^(k)   ||   ^(k))_k ∈M  )

b_1 ∧b_2

3-round HVZK PoK for the $\GSD$ problem (with optimizations)

§ SIG 3

ρ_1 ^λ,   x ρ_1 ,   e ρ_1  such that  e = ω

ρ_2 ^λ,   G ρ_2 ^,   y = x G + e

(, ) = (ρ_1, (ρ_2, y))

(, , m)

k ∈M

θ^(k) ^λ

i ∈N

θ^(k)_i θ^(k) ^λ,   π^(k)_i θ^(k)_i n

u^(k)_i θ^(k)_i ,   v^(k)_i θ^(k)_i

π^(k) = π^(k)_N ∘⋯∘π^(k)_1,   u^(k) = ∑_i ∈N u^(k)_i

v^(k) = v^(k)_N + ∑_i ∈N - 1 π^(k)_N ∘⋯∘π^(k)_i + 1[v^(k)_i]

s^(k)_0 = (u^(k) + x) G

i ∈N

r^(k)_1, i ξ ^λ,   ^(k)_1,i = r^(k)_1,i,   θ^(k)_i

s^(k)_i = π^(k)_i[s^(k)_i - 1] + v^(k)_i

r^(k)_2 ξ ^λ,   ^(k)_2 = r^(k)_2,   π^(k)[y + u^(k) G] + v^(k)

s^(k) = (s^(k)_i)_i ∈N,   ^(k) = (^(k)_1,i,   ^(k)_2)_i ∈N

r^(k) ξ ^λ,   ^(k) = r^(k),   u^(k) + x   ||   s^(k)

r ξ ^λ,   h = r,   (^(k)   ||   ^(k))_k ∈M

(K, A) m   ||     ||   h

(κ, α) ∈K ×A

z^(κ)_1 = u^(κ)_α+ x,   z^(κ)_2 = π^(κ)[e],   z^(κ)_3 = s^(κ)_α

z^(κ)_4 = θ^(κ)_α^* = (θ^(κ)_j)_j ∈N ∖α

^(κ) = (z^(κ)_1, z^(κ)_2, z^(κ)_3, z^(κ)_4, ^(κ)_1,α)

= (ξ, (θ^(k), ^(k))_k ∈M ∖K,   (^(κ))_κ∈K)

σ= (h, )

$\keygen$ and $\sign$ algorithms for Sig 3

(, σ, m)

Parse  σ as  σ= (h, )  and   as  = (ξ, (θ^(k), ^(k))_k ∈M ∖K,   (^(κ))_κ∈K)

(K,   A) m   ||     ||   h

Compute  r̅, r̅'̅, (r̅^(κ)_1,i, r̅^(κ)_2)^κ∈K_i ∈N  from  ξ

k ∈M ∖K

Compute  ^(k)  from  θ^(k)

(κ, α) ∈K ×A

Compute  (θ^(κ)_i, π̅^(κ)_i, v̅^(κ)_i)_i ∈N ∖α  from  z_4

z̅^(κ)_1 = z^(κ)_1 + ∑_i ∈N ∖α u^(κ)_i,   s̅^(κ)_0 = z̅^(κ)_1 G

i ∈[1, N] ∖α

^(κ)_1,i = r^(κ)_1,i,   θ^(κ)_i

s̅^(κ)_i = π̅^(κ)_i[s̅^(κ)_i - 1] + v̅^(κ)_i

s̅^(κ) = (s̅^(κ)_1,   ⋯,   s̅^(κ)_α- 1,   z_3,   s̅^(κ)_α+ 1,   ⋯,   s̅^(κ)_N)

^(κ) = r̅^(κ),   z̅_1   ||   s̅^(κ)

^(κ)_2 = r̅^(κ)_2,   s̅^(κ)_N + z_2

b_1^(κ) ( z_2^(κ) = ω)

b_1 = ⋀_κ∈K b_1^(κ)

b_2 ( h = r̅,   (^(k)   ||   ^(k))_k ∈M  )

b_1 ∧b_2

$\verif$ algorithm for Sig 3