GSW

Around 2013, Gentry, Sahai and Waters proposed a new way of building FHE schemes whose homomorphic multiplication algorithms are more natural than those presented in BFV or BGV. A distinguished feature of the scheme we are about to present is an asymmetric formula for the growth of the noise when multiplying two ciphertexts. Due to this feature, certain types of circuits have a very slow noise growth rate. Based on this asymmetry, Alperin-Sheriff and Peikert found a very efficient bootstrapping technique for the GSW scheme.

More efficient FHE schemes based on ring variants of GSW have been proposed since then. These achieve very fast bootstrapping via various optimisation techniques, such as "refreshing the ciphertexts" after every single homomorphic operation. To our knowledge, among the schemes based on GSW (and not only), TFHE holds the record for fastest bootstrapping. In the literature, the schemes based on the aformentioned work of Gentry, Sahai and Waters are commonly referred to as "third generation FHE". The authors provide a reduction to the LWE problem (see Section 1.3.4) of GSW , basic the security of their scheme only on the LWE problem.

Overview of the GSW scheme

We follow the exposition in the paper "Homomorphic Encryption from Learning with Errors: Conceptually-Simpler, Asymptotically-Faster, Attribute-Based" by Gentry, Sahai and Waters.

The description of this scheme is strikingly simple. In GSW, homomorphic encryption based on LWE is achieved while the homomorphic addition and multiplications correspond to matrix addition and multiplication, respectively.

Let $q$ be a natural number, representing some modulus and $N$ a dimension parameter. A ciphertext is a matrix $C$ of dimension $N\times N$ with "small" entries from $\mathbb {Z} _{q}$. A secret key ${\vec {v}}$ is a $N$-dimensional vector over $\mathbb {Z} _{q}$ with one big coefficient $v_{i}$. We can intuitively think of "small" as meaning much smaller (in order of magnitude) than $q$ and "big" meaning the same order of magnitude as $q$. In fact, we will make use of the case when the entries of $C$ belong to $\{0,1\}$. We also restrict the message $\mu$ to be a "small" integer.

$C$ encrypts $\mu$ under ${\vec {v}}$ if $C\cdot {\vec {v}}=\mu \cdot {\vec {v}}+{\vec {e}}$, where ${\vec {e}}$ is a small error vector.

To decrypt, one first exacts the $i$-th row $C_{i}$ of $C$. Compute $x\leftarrow \langle C_{i},{\vec {v}}\rangle =\mu \cdot v_{i}+e_{i}$. Now, as $v_{i}$ is large and $e_{i}$ small, we have

$\mu =\lfloor x/v_{i}\rceil$.

Basically, ${\vec {v}}$ is almost an eigenvector for $C$ corresponding to the eigenvalue $\mu$. This is commonly referred to being an approximate eigenvector.

Observe that if $C_{1}$ and $C_{2}$ encrypt $\mu _{1}$ and $\mu _{2}$ respectively under the same key vector $v$, then

$(C_{1}+C_{2})\cdot {\vec {v}}=(\mu _{1}+\mu _{2})\cdot {\vec {v}}+{\vec {e_{1}}}+{\vec {e_{2}}}$,

where ${\vec {e_{i}}}$ represents the error vector of $C_{i}$, for $i\in \{1,2\}$ . As long as the sum ${\vec {e_{1}}}+{\vec {e_{2}}}$ is small, the sum matrix $C_{1}+C_{2}$ is an encryption of $\mu _{1}+\mu _{2}$.

Looking at the equality

$(C_{1}\cdot C_{2})\cdot {\vec {v}}=C_{1}\cdot (\mu _{2}\cdot {\vec {v}}+{\vec {e_{2}}})=\mu _{1}\mu _{2}\cdot {\vec {v}}+\mu _{2}\cdot {\vec {e_{1}}}+C_{1}\cdot {\vec {e_{2}}}$

,

we observe that $C_{1}\cdot C_{2}$ is an encryption of the product $\mu _{1}\mu _{2}$, which can be decrypted correctly if the $i$-th component of the vector $\mu _{2}\cdot {\vec {e_{1}}}+C_{1}\cdot {\vec {e_{2}}}$ is smaller than $v_{i}$.

Remark that $C_{2}\cdot C_{1}$ is also an encryption of $\mu _{1}\mu _{2}$, even though matrix multiplication is not commutative. The essence of the previously anticipated asymmetry is captured by the fact that the noises of $C_{1}\cdot C_{2}$ and $C_{2}\cdot C_{1}$ are very different.

Flattening ciphertexts and keeping the noise small

We can decrypt homomorphically evaluated ciphertext $C$ as long as the $i$-th component of the error vector ${\vec {e}}$ is small enough. As we saw in the overview section, the noise might grow quickly with each multiplication. To mitigate this and to perform homomorphically evaluations of deep circuits (in the sense of multiplication depth), observing that the noise growth depends of the size of the coefficients of the ciphertexts, the size of the messages and the fresh error size (in an asymmetric way), we can try to restrict the message space and the entries of the ciphertexts to $\{0,1\}$. We also impose a bound $B$ for the entries of the fresh fresh error vectors ${\vec {e}}$.

Such ciphertexts will be further called $B$-strongly bounded, terminology that is used throughout the paper GSW .

The homomorphic operations performed on ciphertexts should correspond to operations "in the clear" that keep the message within the set $\{0,1\}$. To achieve this, we will use only NAND gates to evaluate any circuit.

Notice that if $C_{1},C_{2}$ are two $B$-strongly bounded ciphertexts, the ciphertext $C_{3}\leftarrow I_{N}-C_{1}C_{2}$ obtained by evaluating a NAND gate has underlying message in $\{0,1\}$, but the coefficients of $C_{3}$'s error vector have magnitude at most $(N+1)B$. If one could ensure that the coefficients of $C_{3}$ have magnitude at most $1$, then the noise after evaluating a NAND gate will remain quite small, allowing us to evaluate deeper circuits.

The authors introduce an operation on ciphertexts called flattening, inspired by ideas in second generation FHE schemes such as BGV. Flattening is basically an operation that modify vectors without affecting their dot product.

Let $N=k\cdot l$ , where $l=\lfloor \log _{2}{q}+1\rfloor$ and $k$ is a positive integer. We will consider ${\vec {a}},{\vec {b}}\in \mathbb {Z} _{q}^{k}$, two $k$-dimensional vector spaces.

$BitDecomp({\vec {a}})=(a_{1,0},\dots ,a_{1,l-1},\dots ,a_{k,0},\dots ,a_{k,l-1}),$ where $a_{i,j}$ is the $j$-th bit in the binary decomposition of $a_{i}$, so a $N$-dimensional vector.

For any $N$-dimensional vector ${\vec {a'}}=(a_{1,0},\dots ,a_{1,l-1},\dots ,a_{k,0},\dots ,a_{k,l-1})$, define

$BitDecomp^{-1}({\vec {a'}})=\left(\sum 2^{j}\cdot a_{1,j},\dots ,\sum 2^{j}\cdot a_{k,j}\right)$, now a $k$ dimensional vector,

and

$Flatten({\vec {a'}})=BitDecomp(BitDecomp^{-1}({\vec {a}}))\in \mathbb {Z} _{q}^{N}$.

The authors also introduce

$Powersof2({\vec {b}})=(b_{1},2b_{1},\dots ,2^{l-1}b_{1},\dots ,b_{k},2b_{k},\dots ,2^{l-1}b_{k})$, an $N$-dimensional vector.

Some obvious properties of these definitions are

• $\langle BitDecomp({\vec {a}}),Powersof2({\vec {b}})\rangle =\langle a,b\rangle$;

• For any $N$-dimensional ${\vec {a'}}$, we have that

$\langle {\vec {a'}},Powersof2({\vec {b}})\rangle =\langle BitDecomp^{-1}({\vec {a'}}),{\vec {b}}\rangle =\langle Flatten({\vec {a'}}),Powersof2({\vec {b}})\rangle .$

The latter is showing us an interesting feature of $Flatten$, i.e. it makes the coefficients of a vector "small", without changing its inner product with $Powersof2({\vec {b}})$

We will have to "flatten" ciphertexts, which are matrices. When $Flatten$ is applied to a $N\times N$ matrix $C$ , this will be done by applying $Flatten$ to each row of $C$. Recall that a step in the decryption process is multiplying the ciphertext matrix $C$ with a secret key vector ${\vec {v}}$. We will always use ${\vec {v}}=Powersof2({\vec {s}})$, a vector of this special form in order for flattening to preserve the product between $C$ and ${\vec {v}}$ required for decryption.

Now, for any $N\times N$ ciphertext matrix $C$, we have

$Flatten(C)\cdot {\vec {v}}=C\cdot {\vec {v}}$

After computing a ciphertext $C_{3}\leftarrow I_{N}-C_{1}\cdot C_{2}$ for the NAND gate, we will immediately flatten it, namely we will set

$C^{NAND}\leftarrow Flatten(C_{3})$.

The basic algorithms of the encryption scheme

Let $\lambda$ be the security parameter and $L$ a natural number representing the multiplicative level of homomorphic operations this scheme can achieve. If we know the maximal level $L$ that we want to evaluate, we can choose parameters such that the scheme can handle circuits of depth $L$. Thus, the scheme described here is a priori a Somewhat Homomorphic Encryption scheme and can be made fully homomorphic after applying Gentry's bootstrapping theorem.

• Setup($1^{\lambda },1^{L}$): We choose a modulus $q=q(\lambda ,L)$, depending of $\lambda ,L$, a lattice dimension parameter $n=n(\lambda ,L)$ and an error distribution $\chi =\chi (\lambda ,L)$ such that the scheme achieves at least $2^{\lambda }$ security against known attacks. We also choose a parameter $m=m(\lambda ,L)=O(n\log _{q})$. We set the paramaters of the scheme $params=(n,q,\chi ,m)$ and let $l=\lfloor \log _{2}q\rfloor +1$ and $N=(n+1)\cdot l$.

• SecretKeyGen($params$): Sample ${\vec {t}}\leftarrow \mathbb {Z} _{q}^{n}$ uniformly. Output $sk={\vec {s}}\leftarrow (1,-t_{1},\dots ,-t_{n})\in \mathbb {\mathbb {Z} } _{q}^{n+1}$. Let ${\vec {v}}=Powersof2({\vec {s}})$.

• PublicKeyGen($params$): Generate a matrix $B=\mathbb {Z} _{q}^{m\times n}$ and a vector with small entries (noise) ${\vec {e}}\leftarrow \chi ^{m}$. Set ${\vec {b}}=B\cdot {\vec {t}}+{\vec {e}}$ and $A$ to be the $(n+1)$ column matrix which is obtained by the placing ${\vec {b}}$ on the first column, fllowed by the $n$ columns of $B$. Set the public key $pk=A$. We observe that $A\cdot {\vec {s}}={\vec {e}}.$

• Enc($params,pk,\mu$): To encrypt a message $\mu \in \mathbb {Z} _{q}$, sample a uniform matrix $R\in \{0,1\}^{N\times m}$ and output the ciphertext

$C\leftarrow Flatten(\mu \cdot I_{N}+BitDecomp(R\cdot A))\in \mathbb {Z} _{q}^{N\times N}$

Disclaimer: The decryption algorithm we describe below decrypts correctly only messages in $\{0,1\}$. This can be easily generalised to recover any $\mu \in \mathbb {Z} _{q}$, bit by bit, starting with the least significant one. The interested reader should consult for example the paper of Micciano and Peikert.

• Dec($params,sk,C$): Observe that the first $l$ coefficients of ${\vec {v}}$ are $1,2,\dots ,2^{l-1}$. Let us choose, among these coefficients, the unique $v_{i}=2^{i}\in (q/4,q/2]$. Let $C_{i}$ be the $i$-th row of $C$. We output

$\mu '=\left\lfloor {\frac {\langle C_{i},{\vec {v}}\rangle }{v_{i}}}\right\rceil$ .

We remark that $Dec$ is only applied to one row of the ciphertext, however extra rows will play a role in the homomorphic operations. If $C$ is properly generated (fresh), then by the properties of $BitDecomp$ described above, we have

$C\cdot {\vec {v}}=\mu \cdot v+R\cdot A\cdot {\vec {s}}=\mu \cdot v+R\cdot {\vec {e}}$

The $i$-th coefficient of the above expression is $x_{i}=\mu \cdot v_{i}+\langle R,{\vec {e}}\rangle$. In the encryption scheme, we set $\chi$ to ensure that the error ${\vec {e}}$ is $B$-bounded with very high probability.

Homomorphic operations

• Add($C_{1},C_{2}$): To add ciphertexts $C_{1},C_{2}\in \mathbb {Z} _{q}^{N\times N}$, output $Flatten(C_{1}+C_{2})$.

• Mult($C_{1},C_{2}$): To multiply ciphertexts $C_{1},C_{2}\in \mathbb {Z} _{q}^{N\times N}$, output $Flatten(C_{1}\cdot C_{2})$.

• MultConst(C, $\alpha$): To multiply a ciphertext $C\in \mathbb {Z} _{q}^{N\times N}$ by a known constant $\alpha \in \mathbb {Z} _{q}$, given in the clear, we set $M_{\alpha }\leftarrow \alpha \cdot I_{N}$ and output $Flatten(M_{\alpha }\cdot C)$.

One could compute multiplication by $\alpha$ by repeating additions. However, by repeating additions, the error of the resulting ciphertext will be linear in $\alpha$. On the other hand, if one uses MultConst(), the error term depends only on the dimension $N$ and not on $\alpha$. This turns out to be extremely convenient for when $\alpha$ is very large (possible applications of this includes homomorphic fast Fourier transforms).

• NAND(): To NAND ciphertexts $C_{1},C_{2}\in \mathbb {Z} _{q}^{N\times N}$ that are known to encrypt messages $\mu _{1},\mu _{2}\in \{0,1\}$, output $Flatten(I_{N}-C_{1}\cdot C_{2})$.

The NAND homomorphic operation increases the error by a factor of at most $N+1$.

By iteratively applying the homomorphic operations above, different types of (boundeddepth) circuits may be homomorphically computed while maintaining correctness of decryption. The simplest ones to analyse are Boolean circuits computed over encryptions of $\{0,1\}$ values. Here the circuit can be converted to use only NAND gates, and the final ciphertext’s error will be bounded by $(N+1)^{L}\cdot B$, where L is the NAND-depth of the circuit, and $B$ is the original bound on the error of a fresh encryption of $\{0,1\}$.