GGH encryption scheme

The Goldreich–Goldwasser–Halevi (GGH) cryptosystem makes use of the fact that the closest vector problem can be a hard problem. This system was published in 1997 by Oded Goldreich, Shafi Goldwasser, and Shai Halevi, and uses a trapdoor one-way function which relies on the difficulty of lattice reduction. The idea included in this trapdoor function is that, given any basis for a lattice, it is easy to generate a vector which is close to a lattice point, for example taking a lattice point and adding a small error vector. But to return from this erroneous vector to the original lattice point a special basis is needed.

The GGH encryption scheme was cryptanalyzed (broken) in 1999 by Phong Q. Nguyen. Nguyen and Oded Regev had cryptanalyzed the related GGH signature scheme in 2006.

Operation

GGH involves a private key and a public key.

The private key is a basis $B$ of a lattice $L$ with good properties (such as short nearly orthogonal vectors) and a unimodular matrix $U$ .

The public key is another basis of the lattice $L$ of the form $B^{'} = U B$ .

For some chosen M, the message space consists of the vector $(m_{1}, . . ., m_{n})$ in the range $- M < m_{i} < M$ .

Encryption

Given a message $m = (m_{1}, . . ., m_{n})$ , error $e$ , and a public key $B^{'}$ compute

v = \sum m_{i} b_{i}^{'}

In matrix notation this is

v = m \cdot B^{'}

Remember $m$ consists of integer values, and $b^{'}$ is a lattice point, so v is also a lattice point. The ciphertext is then

c = v + e = m \cdot B^{'} + e

Decryption

To decrypt the ciphertext one computes

c \cdot B^{- 1} = (m \cdot B^{'} + e) B^{- 1} = m \cdot U \cdot B \cdot B^{- 1} + e \cdot B^{- 1} = m \cdot U + e \cdot B^{- 1}

The Babai rounding technique will be used to remove the term $e \cdot B^{- 1}$ as long as it is small enough. Finally compute

m = m \cdot U \cdot U^{- 1}

to get the message.

3 more chapters are free with a Lably account.

Example

Let $L \subset R^{2}$ be a lattice with the basis $B$ and its inverse $B^{- 1}$

B = (\begin{matrix} 7 & 0 \\ 0 & 3 \end{matrix})

and

B^{- 1} = (\begin{matrix} \frac{1}{7} & 0 \\ 0 & \frac{1}{3} \end{matrix})

With

U = (\begin{matrix} 2 & 3 \\ 3 & 5 \end{matrix})

and

U^{- 1} = (\begin{matrix} 5 & - 3 \\ - 3 & 2 \end{matrix})

this gives

B^{'} = U B = (\begin{matrix} 14 & 9 \\ 21 & 15 \end{matrix})

Let the message be $m = (3, - 7)$ and the error vector $e = (1, - 1)$ . Then the ciphertext is

c = m B^{'} + e = (- 104, - 79) .

To decrypt one must compute

c B^{- 1} = (\frac{- 104}{7}, \frac{- 79}{3}) .

This is rounded to $(- 15, - 26)$ and the message is recovered with

m = (- 15, - 26) U^{- 1} = (3, - 7) .

Security of the scheme

In 1999, Nguyen showed that the GGH encryption scheme has a flaw in the design. He showed that every ciphertext reveals information about the plaintext and that the problem of decryption could be turned into a special closest vector problem much easier to solve than the general CVP.

In 2020, Mandangan, Kamarulhaili & Asbullah proposed a countermeasure that repairs the specific flaw exploited by Nguyen's attack without altering the rest of the original GGH design. Nguyen's attack works by first eliminating the error vector $e$ from the encryption equation, which is only possible because the original scheme draws every entry of $e$ from the two-element set ${- σ, + σ}$ . The countermeasure instead draws each entry of $e$ from the four-element set ${σ - 2, σ - 1, σ, σ + 1}$ , using a specified distribution across the four values. This breaks the congruence used in the elimination stage of Nguyen's attack, so the attack can no longer reduce the problem to the easier Nguyen_GGH-CVP instance, while a matching choice of distribution keeps the Euclidean norm of the error vector at $‖ e ‖ = σ \sqrt{n}$ , the same benchmark norm as the original scheme. The authors show that decryption still succeeds without error under this modification, so the countermeasure preserves both the practicality of GGH and its reliance on the original (harder) GGH-CVP instance.

Implementations

TheGaBr0/GGH – A Python implementation of the GGH cryptosystem and its optimized variant GGH-HNF. The library includes key generation, encryption, decryption, basic lattice reduction techniques, and demonstrations of known attacks. It is intended for educational and research purposes and is available via PyPI.