Publicly verifiable multi-user public key encryption

Introduction

Public key encryption (PKE) is a standard tool used in many protocols with two parties – sender and receiver. Sender uses receiver's public key to encrypt a secret message and receiver uses her private key to decrypt it. In modern (decentralized) protocols there's a third party – verifier. Verifier acts as an arbiter, she verifies that both parties (sender and receiver) follow the protocol correctly. When there's a need for privacy a PKE scheme does not offer the verifier to do her job – to get access to the encrypted message privacy property must be sacrificed.

To overcome this issue there's publicly verifiable public key encryption (PVPKE). In such a scheme the sender encrypts a message and proves certain useful properties about it such that the verifier can verify the proof (ie. that the properties do actually hold for the encrypted message without decrypting it) and the receiver can decrypt the message as usual.

Some useful properties about encrypted text might include the following:

• proof of decryptability, ie. that the receiver can indeed decrypt the message (and not claim that she can't, without revealing her private decryption key);
• proof of correct encryption, ie. that the sender has encrypted a valid message (and not some garbage).

Depending on the underlying platform (message space, key space) and provable properties there can be many approaches. In a general case encryption algorithm is represented as a circuit, then a proof system is used to construct a (non-interactive) proof for that circuit.

In this post we present an extension to multi-receiver ElGamal PKE extended with Bulletproofs-based proof of correct encryption and decryptability that can be used to construct a publicly verifiable secret sharing (PVSS) scheme and non-interactive threshold signature scheme (NITSS).

TSS case study

To better illustrate our goal with PVPKE, lets consider a threshold Schnorr signature scheme (TSS). In TSS any subset of

$t$-out-of-

$n$ signers can produce a valid signature. In the simplest case

$t$-out-of-

$n$ property is achieved with a secret sharing scheme (SSS). In a distributed multi-party protocol it's done with distributed key generation (DKG). In TSS a DKG protocol is used to generate keys and nonce during signing round. A DKG is usually constructed as multiple VSS sessions where each signer gets to act as a secret dealer. The pseudocode for a DKG protocol is presented below.

1. $Commitment{s}^i,Share{s}^i\leftarrow \mathtt{\text{VSS.ShareRandom}}()$
2. broadcast
   $Commitment{s}^i$
3. $Good\leftarrow \{\}$
4. for each
   $j$:
   4.1. receive
   $Commitment{s}^j$ from
   $Pee{r}^j$
   4.2. send
   $E_j^i=\mathtt{\text{PKE.Encrypt}}[P{K}^j](Shar{e}^i(j))$ to
   $Pee{r}^j$
   4.3. receive
   $E_i^j$ from
   $Pee{r}^j$
   4.4.
   $Shar{e}^j(i)\leftarrow \mathtt{\text{PKE.Decrypt}}[s{k}^i](E_i^j)$
   4.5. if
   $\mathtt{\text{VSS.Verify}}(Commitmen{t}^j,Shar{e}^j(i))$ then
   $Good\leftarrow Good\cup \{j\}$
   4.6. else handle bad dealer
   $Pee{r}^j$
5. $FinalShar{e}^i\leftarrow \sum _{j\in Good}Shar{e}^j(i)$
6. return
   $FinalShar{e}^i$

In order for the protocol to be correct peers need to know which secret shares exactly (ie. the set

$Good$) contribute to the final value (signing key, nonce, final signature). It's trivial if we consider that all peers are honest, ie. they won't try to disrupt the execution of the protocol, or forge a signature. This is not the case in real world and we have to account for that.

First, we need to assume asynchronous networking model. In it an adversary can block (but not reorder) some messages. That means that we have to communicate with all peers at once (and not sequentially as presented in the pseudocode). Next, the broadcast primitive must be reliable (ie. all honest nodes must receive the same commitments which is not true with an incorrect trivial "send-to-all" implementation of broadcast). Next, an adversary shall not be able to break a secure channel between peers (implemented with PKE in the pseudocode). Lastly, there should be a proper "handle bad dealer" procedure.

We shall focus on the last issue. Without PVPKE many DKG protocols do special "complaint-and-verify" rounds. In simple terms, the idea is for

$Pee{r}^k$ to decide which peer to trust in a dispute between

$Pee{r}^i$ and

$Pee{r}^j$ where

$Pee{r}^i$ complains that

$Pee{r}^j$ is bad and

$Pee{r}^j$ tries to prove otherwise. With PVPKE we can implement DKG as follows.

1. $Commitment{s}^i,Share{s}^i\leftarrow \mathtt{\text{PVSS.ShareRandom}}()$
2. $EncryptedShare{s}^i,Proof{s}^i\leftarrow \mathtt{\text{PVPKE.ProveEncrypt}}[\overrightarrow{PK}](Share{s}^i)$
3. broadcast
   $Commitment{s}^i,EncryptedShare{s}^i,Proof{s}^i$
4. $Good\leftarrow \{\}$
5. for each
   $j$:
   5.1. receive
   $Commitment{s}^j,EncryptedShare{s}^j,Proof{s}^j$ from
   $Pee{r}^j$
   5.2. if
   $\mathtt{\text{PVSS.Verify}}[P{K}^j](Commitment{s}^j,EncryptedShare{s}^j,Proof{s}^j)$ then
   $Good\leftarrow Good\cup \{j\}$
   5.3.
   $Shar{e}^j(i)\leftarrow \mathtt{\text{PVPKE.Decrypt}}[s{k}^i](EncryptedShare{s}_i^j)$
6. $FinalShar{e}^i\leftarrow \sum _{j\in Good}Shar{e}^j(i)$
7. return
   $FinalShar{e}^i$

An obvious drawback is added complexity to generate and verify proofs and increased size of broadcasted messages.

Overview

There is a number of well-known PKE/KEM systems such as ElGamal encryption, DHIES, Paillier, Kurosawa-Desmedt, Cramer-Shoup, RSA. The usual approach to PVPKE is to extend a PKE system with a non-interactive zero-knowledge proof (NIZKP), for example publicly verifiable ElGamal and RSA encryption, Paillier-based PVSS, Paillier-based IND-CCA secure PVPKE, pairing-based PVPKE, non-interactive DKG. These constructions target different properties such as semantic or IND-CCA2 security, homomorphic property, threshold compatibility, forward secrecy, pairing or RSA friendliness.

Among others we require the following properties:

1. assumed hardness of DL/DH problems or their variant;
2. semantic encryption "in scalar";
3. proofs of decryptability and correct encryption;
4. multi-user encryption;
5. aggregation and batch verification of proofs.

The first requirement means compatibility with Ed25519/X25519; no pairings, RSA, composite/unknown order groups are allowed. The second and third requirements enable a simple application in PVSS, DKG, and TSS constructions; we do not need a stronger IND-CCA2 security. The last two requirements make implementations efficient.

The obvious candidate for a suitable PKE is ElGamal encryption. It satisfies requirements 1 and 4. In order to be able to decrypt a scalar we need to be able to compute a discrete logarithm. It's only possible for small scalars, hence we need to split a secret scalar to be encrypted into sufficiently small chunks.

For decryptability proof we need to prove that the owner of the private key corresponding to the encryption public key is able to decrypt an encrypted small chunk. This is done with a preimage proof (ElGamal encryption is additively homomorphic) and range proof (that the secret scalar chunk is sufficiently small). Proof of correct encryption is also a preimage proof (but for a combined scalar, not individual chunks).

Preimage proofs are easily doable with Schnorr sigma protocol generalized by Maurer. Range proofs are much more difficult. To do that we use Bulletproofs – a succinct proof system in DL setting. If we use a straightforward approach we wouldn't fulfill requirement 5. Fortunately, Bulletproofs range proof can be modified to support ElGamal commitments (instead of Pedersen commitments which is used initially), extended statement for chunking proofs, and efficient aggregation (due to use of multi-user ElGamal encryption).

PVPKE & PVSS

Let

$\bar{X}=\bar{x}\cdot G$ be receivers' public keys, then lifted ElGamal multi-user encryption is defined by the following two equations.

$$\bar{C},R={\mathtt{\text{Enc}}}_{\bar{X}}(\bar{s},r)=\bar{s}\cdot H+r\cdot \bar{X},rG$$

$$s_j={\mathtt{\text{Dec}}}_{x_j}(C_j,R)={\mathtt{\text{DL}}}_H(C_j-x_{j}R)$$

$\mathtt{\text{Enc}}$ and

$\mathtt{\text{Dec}}$ have all the nice additively homomorphic properties allowing to use them in Bulletproofs.

${\mathtt{\text{DL}}}_H(s_{j}H)$ only works for

$s_j\in [0.{.2}^b)$ with small

$b$. For any

$s_j\in {\mathbb{Z}}_q$,

$s_j=\sum _{l=0}^{m-1}{2}^{bl}{s}_{j,l}$ we split it into

$m$ chunks

$s_{j,l}\in [0.{.2}^b)$.

$${\bar{C}}_l,R_l={\mathtt{\text{Enc}}}_{\bar{X}}({\bar{s}}_l,r_l)={\bar{s}}_l\cdot H+r_l\cdot \bar{X},r_{l}G$$

$$s_{j,l}={\mathtt{\text{Dec}}}_{x_j}(C_{j,l},R_l)={\mathtt{\text{DL}}}_H(C_{j,l}-x_j{R}_l)$$

This effectively increases

$m$ times the cipher text size.

In order to turn it into PVPKE we need to add some nice proofs.

Decryptability is the proof that the receiver can decrypt

$sH=C-xR$ (ie. the owner of the private key

$x$ is the actual receiver):

$$\mathtt{\text{Decryptability}}\{(C,R;s,r):C,R={\mathtt{\text{Enc}}}_X(s,r)\}$$

It's possible to use

$\mathtt{\text{Preimage}}$ proof with

${\mathtt{\text{Enc}}}_X(s,r)$ as one-way homomorphic map. Formally the proof means that the dealer knows

$s,r$, but semantically it means the receiver's public key

$X$ was used to encrypt

$s$. It's possible to aggregate the final proof to account for

$n$ receivers and

$m$ chunks.

Chunking is the proof that the receiver can bruteforce DLog

$s={\mathtt{\text{DL}}}_H(sH)$:

$$\mathtt{\text{Chunking}}\{(C;s,r):C=sH+rX\wedge s\in [0.{.2}^b)\}$$

We'll use a modified

$\mathtt{\text{RangeProof}}$ proof with

$C,R$ as ElGamal commitment. Formally this proof does also prove knowledge of

$s,r$. We need to make sure that it's safe to use public key

$X$ and

$H$ as CRS in ElGamal commitment.

We want to use our PVPKE scheme to construct a PVSS scheme. Let's recall Feldman's VSS:

1. The dealer generates random polynomial
   $f(x)=\sum _{k=0}^{t-1}{x}^k{f}_k$ such that
   $s=f_0=f(0)$ is the dealer's secret.
2. Next, the dealer publishes commitment
   $F_k=f_{k}H$ to
   $f(x)$.
   $F_0$ is the dealer's public key and
   $F(x)=\sum _{k=0}^{t-1}{x}^k{F}_k$ is commitment polynomial.
3. Next, the dealer computes shares
   $s_j=f(j)$ and securely delivers them to each receiver.
4. Receivers can use Feldman's verification equation
   $s_{j}H\stackrel{?}{=}F(j)$ to verify their shares.
5. The shared secret can be recovered via interpolation polynomial
   $\hat{f}(x)=\sum _{j\in J}{l}_j^J(x)s_j$ where
   $l_j^J(x)=\prod _{i\in J,i\ne j}\frac{x-i}{j-i}$ is Lagrange polynomial. Then the recovered secret is
   $\hat{s}=\hat{f}(0)$.

In a PVSS scheme scalars to be encrypted are secret shares satisfying certain verification equation

$s_{j}H=F(j)$. Thus we have to add a corresponding proof.

Sharing is the proof that encrypted share is correct, ie.

$s_{j}H=F(j)$:

$$\begin{gathered} \mathtt{\text{Sharing}}\{(F_k,C_{j,l},R_l,X_j;r_l): \\ \sum _l{2}^{bl}{C}_{j,l}-F(j)=\sum _l{2}^{bl}{r}_l{X}_j\wedge R_l=r_{l}G\} \end{gathered}$$

Again, we use

$\mathtt{\text{Preimage}}$ proof of knowledge with

$g_{X_j}(r_l)=(\sum _l{2}^{bl}{r}_l{X}_j,r_{l}G)$ as one-way homomorphic map. Formally it means the knowledge of

$r$ and equality of discrete logs. Semantically it means image of encrypted value is

$F(j)$.

Bulletproofs improved

Here we will specify in more detail Bulletproofs-based interactive protocol to support PVSS proofs. It can then be made non-interactive with Fiat-Shamir transform.

First, let's combine all the desired statements into one (secret share chunk here is

$v_{j,l}$ to be more consistent with the Bulletproofs paper and avoid clash of names):

$$\begin{gathered} \mathtt{\text{PVSS}}\{(F_k,C_{j,l},R_l,X_j;v_{j,l},r_l): \\ {C}_{j,l},R_l={\mathtt{\text{Enc}}}_{X_j}(v_{j,l},r_l)\wedge \\ {v}_{j,l}\in [0.{.2}^b)\wedge \\ \sum _l{2}^{bl}{C}_{j,l}-F(j)=\sum _l{2}^{bl}{r}_l{X}_j\}, \end{gathered}$$

where

$k=0..t-1,j=1..n,l=1..m$.

Here the following notation will be used:

• ${\overrightarrow{c}}^n=(c^i{)}_{i=0}^{n-1}\in {\mathbb{Z}}_q^n$;
• $x\cdot \overrightarrow{a}=(x{a}_i{)}_{i=0}^{n-1}$;
• $⟨\overrightarrow{a},\overrightarrow{b}⟩=\sum _{i=0}^{n-1}{a}_i{b}_i$;
• $\overrightarrow{a}\circ \overrightarrow{b}=(a_i{b}_i{)}_{i=0}^{n-1}$;
• $\overrightarrow{x}\times \overrightarrow{b}={\Vert }_{i=0}^{n-1}(x_i\cdot \overrightarrow{b})$;
• $v_j=\sum _{l=0}^{m-1}{2}^{bl}{v}_{j,l}$,
  $v={\Vert }_j(v_{j,l}{)}_l$;
• $\mathtt{\text{VCommit}}(a,b,c)=⟨a,\overrightarrow{G}⟩+⟨b,\overrightarrow{H}⟩+cK$.

Step 1.

The prover chooses nonces

$a_L$,

$a_R$ such that

$v_{j,l}\in [0.{.2}^b)$ can be rewritten as a system of

$nm+2bnm$ scalar equations:

$$\begin{gathered} ⟨a_{L,j,l},{\overrightarrow{2}}^b⟩=v_{j,l},\mathrm{\forall }j,\mathrm{\forall }l\wedge \\ {a}_L=a_R+{\overrightarrow{1}}^{bnm}\wedge \\ {a}_L\circ a_R={\overrightarrow{0}}^{bnm}, \end{gathered}$$

where

$a_L={\Vert }_{j=0}^{n-1}({\Vert }_{l=0}^{m-1}{a}_{L,j,l})$.

The prover chooses a random

$\alpha$ and publishes commitment

$A=\mathtt{\text{VCommit}}(a_L,a_R,\alpha )$.

Step 2.

The prover receives from the verifier challenge

$y$ and aggregates the previous system into the following one with

$nm+2$ scalar equations:

$$\begin{gathered} ⟨a_{L,j,l},{\overrightarrow{2}}^b⟩=v_{j,l},\mathrm{\forall }j,\mathrm{\forall }l\wedge \\ ⟨a_L-a_R-{\overrightarrow{1}}^{bnm},{\overrightarrow{y}}^{bnm}⟩=0\wedge \\ ⟨a_L,{\overrightarrow{y}}^{bnm}\circ a_R⟩=0. \end{gathered}$$

Step 3.

The prover receives from the verifier challenge

$z$ and further aggregates the system into

$1$ scalar equation:

$$\begin{gathered} z^2\sum _{j=1}^n\sum _{l=0}^{m-1}{z}^{(j-1)m+l}⟨a_{L,j,l},{\overrightarrow{2}}^b⟩+ \\ +z⟨a_L-a_R-{\overrightarrow{1}}^{bnm},{\overrightarrow{y}}^{bnm}⟩+ \\ +⟨a_L,{\overrightarrow{y}}^{bnm}\circ a_R⟩= \\ =z^2\sum _{j=1}^n\sum _{l=0}^{m-1}{z}^{(j-1)m+l}{v}_{j,l}. \end{gathered}$$

The same equation can be rewritten in inner-product form:

$$\begin{gathered} z^2⟨a_L,{\overrightarrow{z}}^{nm}\times {\overrightarrow{2}}^b⟩+z⟨a_L,{\overrightarrow{y}}^{bnm}⟩+⟨a_L,{\overrightarrow{y}}^{bnm}\circ a_R⟩- \\ -z⟨{\overrightarrow{y}}^{bnm},a_R⟩=z^2⟨z^{nm},v⟩+z⟨{\overrightarrow{y}}^{bnm},{\overrightarrow{1}}^{bnm}⟩, \end{gathered}$$

or in a folded form with only 1 inner product (the goal is to get inner product of

$a_L$ and

$a_R$):

$$\begin{gathered} ⟨a_L-z\cdot {\overrightarrow{1}}^{bnm},z^2\cdot z^{nm}\times {\overrightarrow{2}}^b+{\overrightarrow{y}}^{bnm}\circ (a_R+z\cdot {\overrightarrow{1}}^{bnm})⟩= \\ =z^2⟨z^{nm},v⟩+(z-z^2)⟨{\overrightarrow{y}}^{bnm},{\overrightarrow{1}}^{bnm}⟩-z^3⟨{\overrightarrow{1}}^{bnm},{\overrightarrow{z}}^{nm}\times {\overrightarrow{2}}^b⟩= \\ =z^2⟨z^{nm},v⟩+\delta (y,z). \end{gathered}$$

Step 4.

In order to use inner-product argument (IPA) and make proof zero-knowledge prover needs to blind

$a_L$ and

$a_R$.

The prover chooses random nonces

$s_L,s_R$, a random

$\rho$, publishes commitment

$S=\mathtt{\text{VCommit}}(s_L,s_R,\rho )$.

Step 5.

The prover receives from the verifier challenge

$x$ and constructs blindings:

$$l=a_L-z\cdot {\overrightarrow{1}}^{bnm}+x\cdot s_L$$

$$r=z^2\cdot z^{nm}\times {\overrightarrow{2}}^b+{\overrightarrow{y}}^{bnm}\circ (a_R+z\cdot {\overrightarrow{1}}^{bnm}+x\cdot s_R)$$

Note:

$l$ and

$r$ are polynomials in

$x$ over

${\mathbb{Z}}_q^{bnm}$

$$t=⟨l,r⟩=t_0+x{t}_1+x^2{t}_2$$

Equation

$t_0=z^2⟨z^{nm},v⟩+\delta (y,z)$ (

$t(x)$ evaluated at

$x=0$) is equivalent (with high probability) to the initial system and the statement that

$v_{j,l}$ is small.

Now, the prover can prove that

$t=z^2⟨z^{nm},v⟩+\delta (y,z)+x{t}_1+x^2{t}_2$ with IPA instead.

Step 6.

$t_1$,

$t_2$ serve as blindings for

$t_0$. The prover commits to

$t_1,t_2$ with ElGamal commitment (

${\mathtt{\text{Commit}}}_X(s,r)=sG+rX,rG$) using random

${\tau }_1,{\tau }_2$:

$$T_i,Q_i={\mathtt{\text{Commit}}}_{\bar{X}}(t_i,{\tau }_i),\text{for}i=1,2,$$

so that the following holds:

$$tG+{\tau }_x\bar{X}=z^2⟨z^{nm},C⟩+\delta (y,z)G+x{T}_1+x^2{T}_2.$$

We can use the equation above and the equations from the PVSS statement to deduce the form of the piece of proof

${\tau }_x$, the form of point

$\bar{X}$ and necessary verification equations.

More concretely, we use the following equations:

$C_{j,l}=v_{j,l}G+r_l{X}_j$,

$R_l=r_{l}G$

$⟨z^{nm},C⟩=\sum _{j=1}^n{z}^{(j-1)m}\sum _{l=0}^{m-1}{z}^l(v_{j,l}G+r_l{X}_j)$

$\sum _{j=1}^n{z}^{(j-1)m}\sum _{l=0}^{m-1}{z}^l{r}_l{X}_j=(\sum _{l=0}^{m-1}{z}^l{r}_l)(\sum _{j=1}^n{z}^{(j-1)m}{X}_j)$

Thus we get:

$$\bar{X}=\sum _{j=1}^n{z}^{(j-1)m}{X}_j$$

$${\tau }_x=z^2\sum _{l=0}^{m-1}{z}^l{r}_l+x{\tau }_1+x^2{\tau }_2$$

The prover publishes commitments

$T_i,Q_i$ for

$i=1,2$ and

${\tau }_x$ as part of proof.

Step 7.

The verifier verifies:

$$tG+{\tau }_x\bar{X}\stackrel{?}{=}{z}^2⟨z^{nm},C⟩+\delta (y,z)G+x{T}_1+x^2{T}_2$$

$${\tau }_{x}G\stackrel{?}{=}{z}^2⟨z^m,R⟩+x{Q}_1+x^2{Q}_2$$

Step 8.

The prover chooses random

$\eta$, published commitment

$N=\eta G$.

Step 9.

The prover receives challenge

$u$ from the verifier and publishes commitment

$M=\eta \sum _{j=1}^n{u}^j{X}_j$.

Step 10.

The prover receives challenge

$w$ from the verifier. The prover publishes proof:

$s=\eta +w\sum _l{2}^{bl}{r}_l$

Step 11.

The verifier verifies:

$$\begin{gathered} s(G+\sum _{j=1}^n{u}^j{X}_j)\stackrel{?}{=}N+M+ \\ +w(\sum _l{2}^{bl}{R}_l+\sum _{j=1}^n{u}^j(\sum _l{2}^{bl}{C}_{j,l}-F(j)) \end{gathered}$$

Step 12.

In order to be able to use IPA, the prover computes the following commitment:

$$\begin{gathered} P=\mathtt{\text{IPACommit}}(l,r)= \\ =(⟨a_L,\overrightarrow{G}⟩+⟨{\overrightarrow{y}}^{bnm}\circ a_R,\overrightarrow{H^{\prime }}⟩+\alpha K)+ \\ +x(⟨s_L,\overrightarrow{G}⟩+⟨{\overrightarrow{y}}^{bnm}\circ s_R,\overrightarrow{H^{\prime }}⟩+\rho K)- \\ -(\alpha +x\rho )K-⟨z\cdot {\overrightarrow{1}}^{bnm},\overrightarrow{G}⟩+⟨z^2\cdot z^{nm}\times {\overrightarrow{2}}^b+z\cdot {\overrightarrow{y}}^{bnm},\overrightarrow{H^{\prime }}⟩ \end{gathered}$$

Let's denote

$\overrightarrow{H^{\prime }}={\overrightarrow{y}}^{-bnm}\circ \overrightarrow{H}$, we can rewrite expression for

$P$ as follows:

$$P=A+xS-\mu K-z\cdot \overrightarrow{G}+⟨\gamma (y,z),\overrightarrow{H^{\prime }}⟩$$

The prover publishes

$\mu =\alpha +x\rho$ as part of proof (so that

$P$ can be reconstructed by the verifier). The prover constructs and publishes IPA.

Step 13.

The verifier reconstructs commitment

$P$ and verifies IPA.