ALL Metrics
-
Views
-
Downloads
Get PDF
Get XML
Cite
Export
Track
Research Article

A novel homomorphic polynomial public key encapsulation algorithm

[version 1; peer review: 1 approved, 1 approved with reservations]
PUBLISHED 17 Oct 2023
Author details Author details
OPEN PEER REVIEW
REVIEWER STATUS

This article is included in the Cybersecurity collection.

Abstract

Background: One of the primary drivers in development of novel quantum-safe cryptography techniques is the ongoing National Institute of Standards and Technology (NIST) Post-Quantum Cryptography (PQC) competition, which aims to identify quantum-safe algorithms for standardization. Although NIST has recently announced candidates to be standardized, the development of novel PQC algorithms remains desirable to address the challenges of quantum computing. Furthermore, to enhance security and improve performance. Methods: This paper introduces a novel public key encapsulation algorithm that incorporates an additional layer of encryption during key construction procedure, through a hidden ring. This encryption involves modular multiplication over the hidden ring using a homomorphism operator that is closed under addition and scalar multiplication. The homomorphic encryption key is comprised of two values - one used to create the hidden ring and the other to form an encryption operator. This homomorphic encryption can be applied to any polynomials during key construction over a finite field with their coefficients considered private. Particularly, the proposed homomorphic encryption operator can be applied to the public key of the Multivariate Public Key Cryptography schemes (MPKC) to hide the structure of its central map construction. Results: This paper presents a new variant of the MPKC with its public key encrypted using the proposed homomorphic operator. This novel scheme is called the Homomorphic Polynomial Public Key (HPPK) algorithm, which simplifies MPKC central map to two multivariate polynomials constructed from polynomial multiplications. The HPPK algorithm employs a single polynomial vector for the plaintext and a multi-variate noise vector associated with the central map. In contrast, in MPKC, a single multivariate vector is created by segmenting the secret plaintext over a small finite field. The HPPK algorithm is Indistinguishability Under Chosen-Plaintext Attack (IND-CPA) secure, and its classical complexity for cracking is exponential in the size of the prime field GF(p).

Keywords

Post-Quantum Cryptography, PQC, Public-Key Cryptography, Multivariate Polynomial Public Key, MPPK, Key Encapsulation Mechanism, KEM, Multivariate Cryptography

Introduction

In 1978, Rivest et al. proposed homomorphic encryption, a technique for performing computations on encrypted data without knowledge of the decryption key or procedure.1 This was just one year after filing the patent for Rivest-Shamir-Adleman (RSA) public key cryptography.2 Homomorphic encryption is distinct from the cryptographic algorithms used for secure communication or storage with public key mechanisms like RSA,2 Diffie-Hellman,3 and elliptic curve cryptography,4,5 which are used to establish shared keys for symmetric encryption with algorithms like Advanced Encryption Standard (AES).

Homomorphic encryption can be divided into two categories: partially homomorphic and fully homomorphic. Partially homomorphic encryption supports either multiplicative or additive homomorphic operations. Examples of multiplicatively homomorphic systems include RSA6 and ElGamal cryptosystems,7 while additively homomorphic systems include Goldwasser-Micali,8 Benaloh,9 and Paillier.10 The first milestone for fully homomorphic encryption was achieved by Gentry in 2009 using lattice-based cryptography11 to support both addition and multiplication operators in the encrypted mode. Additionally, Chan proposed a symmetric homomorphic scheme based on an improved Hill Cipher12 in 2009, while Kipnis and Hibshoosh proposed their symmetric homomorphic scheme in 201213 with a randomization function for non-deterministic encryption. Gupta and Sharma proposed their symmetric homomorphic scheme based on linear algebraic computation in 2013.14 More recently, Li et al. proposed a new symmetric homomorphic scheme in 2016, called Li-Scheme, for outsourcing databases.15 Their scheme involves two finite fields: a secret small field Fq and a big public field Fp. It uses modular exponentiation with its secret base s followed by modular multiplication with plaintext message m. Li-Scheme supports both additive and multiplicative operations, making it a fully homomorphic encryption. However, in 2018, Wang et al. performed a cryptoanalysis of the Li-Scheme16 and broke the scheme with certain known plaintext-ciphertext pairs. They further improved their cryptoanalysis in 2019 and successfully recovered the secret key with the ciphertext-only attack using lattice reduction algorithm.17

Homomorphic encryption is a technique that enables performing mathematical operations on encrypted data without decrypting it first, thus providing data privacy. However, it would be interesting to extend this technique from data privacy to public key schemes. Specifically, it would be beneficial to explore cases where the public keys can provide privacy with variables that can take user inputs in a public key scheme. Some research in this area has yielded fruitful results,18,19 but there is still room for further research. Motivated by this need, we introduce a new asymmetric key encapsulation scheme called Homomorphic Polynomial Public Key (HPPK), which uses partial homomorphic encryption to encrypt public keys. The HPPK algorithm leverages multivariate polynomials to not only take advantage of the homomorphic properties of addition and scalar multiplication, but also to allow for the encryption of the input of the encrypting party during the creation of the ciphertext. In other words, the coefficients of the public key polynomial are encrypted using a homomorphic function to ensure that they are not truly public and to hide the structure of the public key. At the same time, treating the variables of the public key polynomials as user input allows for greater flexibility during the encryption process.

The HPPK cryptosystem possesses two distinct features. Firstly, it employs homomorphic encryption of the public key, which enables the inclusion of user input during ciphertext creation. Secondly, it utilizes a hidden ring. However, HPPK is not the first cryptosystem to employ hidden structure. For instance, Li et al. developed a cryptosystem that utilizes a hidden prime ring.15 Hidden Field Equations (HFE) cryptosystems are another notable example. Several asymmetric multivariate encryption schemes based on HFE have been proposed.2023 Additionally, various signature schemes based on HFE have been developed.2428 In HFE, both the private polynomials and the structure they are defined over, a field extension, are concealed using affine transformations.

The aforementioned algorithms based on HFE fall under the category of quantum-safe algorithms, specifically multivariate quantum-safe algorithms. With the advent of quantum computing, quantum-resistant cryptography has gained significant attention from both academia and industry leaders. The National Institution of Standards and Technology (NIST) played a pivotal role in this arena by initiating the post-quantum cryptography (PQC) standardization process in November 2017.2931 Recently, the NIST announced the third-round finalists, which include four key encapsulation mechanism schemes (KEM) and three digital signature finalists.29 The four KEM finalists include Classic McEliece, which is code-based32; CRYSTALS-KYBER, which is lattice-based33; NTRU, which is based on lattices34,35; and Saber.36 NIST has selected CRYSTALS-KYBER as the standardized algorithm for KEM. Besides the aforementioned finalists, Multivariate Public Key Cryptosystems (MPKC) are noteworthy for their simplicity and efficiency.37,38,27,28 Algorithms based on multivariate polynomial problems are considered quantum-safe and can also serve as excellent candidates for homomorphic encryption due to the use of multivariate polynomials.

The framework of MPKC is based on a system of quadratic polynomials, with the public key represented by a central map P:FpmFp, where m variables and polynomials are used.39 Since its introduction by Matsumoto and Imai in 1988,40 numerous variants of MPKC central map constructions have been proposed, including single field systems and mixed field systems.41 Single field MPKC comprises several triangular systems and the Oil and Vinegar system, which were first introduced by Patarin and Goubin in 1997,42 as well as the unbalanced Oil and Vinegar scheme proposed by Kipnis et al. in 1999.20 Mixed field MPKC refers to the Matsumoto-Imai system40 and the HFE.43 Moreover, Wang et al. proposed a Medium-Field MPKC scheme in 2006,44 which was improved upon in 2008.45 Additionally, Ding and Schmidt proposed Rainbow as a MPKC digital signature scheme in 2005.27

Attacks on MPKC cryptosystems are mainly classified into two categories: algebraic solving attacks and linear algebra attacks. Algebra solving attacks attempt to solve the MPKC multivariate equation system from the public key with ciphertext z1z2z to recover the pre-image x1x2xm. Faugére reported his first attack on MPKC in 199946 and in 200247 using Gröber bases (F4), later in 2003 Faugére and Antoine reported their attack on HFE Gröber bases (F5). Ding et al. proposed their new Zhuang-Zi algorithm to solve the multivariate system in 2006.48 In linear algebra attacks, Courtois et al. reported their attack on MPKC using the relinearization technique, aclled XL in 2000.49 The Minrank attack has been successfully applied by Goubin and Courtois on the single field system in 200050 and by Kipnis and Patarin on the mixed field system in 1999.51

A novel type of polynomial public key has recently been proposed by Kuang in 2021,52 based on univariate polynomial multiplications. Additionally, Kuang and Barbeau have further proposed a related public key in 2021,53,54,55 which utilizes multivariate polynomial multiplications with two noise functions to improve public key security against potential attacks. Recently, Kuang, Perepechaenko, and Barbeau have proposed a majorly improved Key Encapsulation Mechanism (KEM),56 where modular multiplication encryption over a hidden ring was applied for both noise functions. Building on top of this previous work,56 this paper investigates the potential benefits of combining a new homomorphic encryption with key construction to further enhance the security of MPPK cryptography for KEM and reduce the cipher size. Furthermore, a digital signature scheme based on the multivariate polynomial public key, or MPPK, has been introduced by Kuang, Perepechaenko, and Barbeau in 2022.57

Homomorphic encryption operator designed from a hidden ring

In contrast to conventional homomorphic cryptography used for data privacy, in this paper we propose homomorphic encryption to be applied to the public key in the framework of multivariate asymmetric cryptography. This will allow for an asymmetric scheme with encrypted public keys. Moreover, by construction, homomorphic encryption allows for user’s input during the ciphertext generation procedure. That is, the ciphertext can be created with the input of the encrypting party, however, the public key used for encryption is itself encrypted using a homomorphic operator. The decrypting party is the only party that has knowledge of the private key associated with the homomorphic encryption operator as well as the asymmetric scheme private key. Essentially, the homomorphic encryption defined in this paper provides a round-trip envelope for a public key encryption.

In a way, such approach combines three main areas of cryptography, namely, asymmetric cryptography, homomorphic cryptography, and symmetric cryptography with the self-shared key. This phenomenon is illustrated in Figure 1. In the figure, the traditional public key derived from a given asymmetric algorithm is called plain public key (PPK), the homomorphically encrypted PPK is called cipher public key or CPK. The cipher is produced by evaluating the public key polynomial values using a user-selected secret together with the random noise variables. The decryption would perform in two stages: homomorphic decryption and then secret extraction.

a015d272-9577-4d48-b5b1-122180ffdafb_figure1.gif

Figure 1. Illustration of a cryptosystem combining asymmetric cryptography, symmetric cryptography with a single self-shared key, and homomorphic encryption.

We begin by introducing the homomorphic encryption operator. In order to allow for the user’s input during ciphertext creation, and leverage additive and scalar multiplicative homomorphic features, the homomorphic encryption is applied to polynomials. We discuss the reason for this further. Hence, when introducing the said operator we assume that it will be applied to polynomials.

Homomorphic encryption operator

Let S be a positive integer, and R be a randomly chosen value such that RS and gcdRS=1. We propose a homomorphic encryption operator ̂RS, with a secret homomorphic key being a tuple RS. The values S and R are never shared. In its general form, the encryption operator is defined as a multiplicative operation modulo a hidden value S as

(1)
̂RSf=RfmodS,
where f denotes any univariate or multivariate polynomial f=i=0kfiXi, over Fq with Xi being its monomials. The encryption operator acts on the coefficients of f, which we refer to as plain coefficients.
̂RSfi=RfimodS=hi
for every i. Similarly, we can define a Homomorphic Decryption Operator as
(2)
̂R1Sh=R1hmodS.

Such operator decrypts the coefficients of the polynomial h. That is, it successfully decrypts the cipher coefficients back to the plain coefficients. More precisely,

̂R1Shi=R1RfimodS=R1RfimodS=fi
for any i. The above defined homomorphic operator ̂RS holds following homomorphic properties:
  • ̂RS is additively homomorphic: if a and b are two plain constants, then ̂RSa+b=Ra+bmodS=Ra+RbmodS=̂RSa+̂RSb;

  • ̂RS is scalar multiplicatively homomorphic: if a is a plain constant and x is a variable, then ̂RSax=Rax=Rax=̂RSax.

Thus, the operator ̂RS offers partially homomorphic encryption. We leave it to the reader to verify that the same properties hold true for the proposed homomorphic decryption operator ̂R1S. Note that these homomorphic properties come from linearity, and thus are natural to polynomials. Indeed, polynomials hold additive and scalar multiplicative properties through their coefficients. Moreover, polynomials can be defined and evaluated with coefficients in a field or a ring, different from a field or a ring for variables. We leverage this property, and thus, apply the homomorphic encryption to public key cryptosystems with polynomial public keys.

Homomorphically encrypted polynomials

As we have previously stated, the proposed homomorphic encryption is applicable to all polynomials over a ring q or finite field Fq characterized by a prime q. In this work, when we refer to polynomials, we imply that the plain polynomials, to be encrypted, are considered modulo q, unless stated otherwise. A generic multivariate polynomial has the following form

px1xm=j1=11jm=1mpij1jmx1j1xmjm.

Alternatively, let Xj=x1j1xmjm denote the monomials of such polynomial, then

(3)
px1xm=j=1LpjXj,
where L denotes the total number of terms. To successfully encrypt and decrypt any polynomial px1xm using the homomorphic encryption and decryption operators defined in Equation (1) and (2) respectively, the following conditions must be met:
  • The monomials Xj are to be computed as Xj=Xjmodq. The values of monomials reduced modulo q are used to compute the value of the polynomial px1xm.

  • The homomorphic secret key value S should satisfy the bit length condition: S2>2p2+L2.

The first condition ensures that polynomial px1xm is evaluated as if the monomials Xj are new variables over Fq, Indeed, the operator ̂RS is applied to the polynomial px1xm in the following way

(4)
̂RSpx1xm=j=1LRpjmodSXj.

Such encrypted polynomial can be computed as

j=1LRpjmodSXjmodq=p¯.

Note that the computed value was not reduced modulo any integer, nor is the arithmetic performed modulo any integer. Thus, the user’s input through monomials Xj remains intact and can be decrypted correctly. Let the plain value of the polynomial with user’s input, that is, if the polynomial was not encrypted with ̂RS, be

p̂=j=1LpjXjmodq.

To ensure successful decryption, the second condition must be met. If the size of S is sufficiently large, the values of coefficients and variables remains the same after decryption, and it is possible to recover p̂. Indeed,

(5)
̂R1Sp¯=j=1LR1RpjmodSXjmodq=j=1LpjXjmodq,
and then the value j=1LpjXjmodq can be reduced modulo q to yield j=1LpjXjmodq=p̂. To elaborate more on this, we present the reader with two examples of homomorphic encryption of linear and quadratic polynomials.

Linear polynomials

Recall, that we encrypt the coefficients of the polynomials defined over Fq, which successfully maps polynomials from Fqx1xm to Sx1xm, leaving x1,,xmFq. A generic linear multivariate polynomial over a finite field Fq has form

(6)
px1x2xm=j=1mpjxjmodq.

Conventionally, in the asymmetric encryption schemes, the public key inherits mathematical logic from the private key, making it vulnerable. Hence, if public key consists of polynomials, we wish to encrypt the coefficients of the said polynomials using homomorphic operator, to hide the mathematical logic. In this case we share the cipher public key, encrypted using homomorphic operator. To ensure that the ciphertext can be still created in the framework of asymmetric public key scheme, the variables in the public key polynomials are used for user’s input. They are not encrypted using homomorphic encryption, but only using the encryption procedure from the asymmetric scheme. Such variable values can consist of the plaintext only, or plaintext and noise used for obscurity.

Applying homomorphic encryption operator to the above linear polynomial, defined in Equation (6), produces a cipher linear polynomial with coefficients in a hidden ring S, and variables in Fq:

(7)
Px1x2xm=̂RSpx1x2xm=j=1mRpjmodSxj=j=1mPjxj.

While the plain coefficients, pj, are encrypted into cipher coefficients, Pj, the cipher polynomial Px1x2xm can still be evaluated with a set of chosen values r1,,rmFq to produce value P¯

(8)
P¯=Pr1r2rm=j=1mPjrjmodq.

Let the value p¯=i=1mpjrjmodq, be the original ciphertext of the asymmetric scheme. However, it is encrypted into the value P¯ using homomorphic encryption. To recover the plain polynomial value, that is, decrypt the cipher coefficients, into the plain coefficients and evaluate polynomial modulo q, we first apply the homomorphic decryption operator ̂R1S to get ̂R1SP¯, and then reduce this value modulo q. More precisely,

̂R1SP¯=j=1mR1PjmodSrjmodq=i=1mpjrjmodq,
which reduced modulo q is
i=1mpjrjmodq=p¯.

In a framework of asymmetric scheme with homomorphic encryption element, polynomials such as in Equation (6) are associated with plain coefficients, that is, the original public keys. The cipher polynomials have form as in Equation (7), with coefficients being encrypted from the plain public keys, using homomorphic encryption. Such cipher public keys are shared, and the plain public keys are stored securely and never shared. The ciphertext in this combined algorithm is of the form as in Equation (8). The decrypting party first needs to decrypt the ciphertext to nullify the homomorphic encryption of the public key, as shown in Equation (8). Afterwards, the decryption party can perform decryption procedure that corresponds to the given asymmetric scheme.

Quadratic polynomials

Multivariate quadratic polynomials serve as the foundation of Multivariate Public Key Cryptosystem or MPKC.39,5860 Thus, we want to pay special attention on applications of homomorphic encryption on multivariate quadratic polynomials. A general quadratic multivariate polynomial px1x2xn over a finite field Fq has the following form

(9)
px1x2xm=1ijmpijxixjmodq,
where the coefficients pij are considered as the privacy constants for this polynomial function so they must be hidden from public. This is done by applying the homomorphic encryption operator to this polynomial as follows
(10)
Px1x2xm=̂RSpx1x2xm
(11)
=1ijmRpijmodSxixj=1ijmPijxixj.
(12)
Px1x2xm=̂RSpx1x2xm=1ijmRpijmodSxixj=1ijmPijxixj.

Here, the encrypted coefficients are defined over the hidden ring S, however, all the variables x1,,xm are still elements of the field Fq. As we have previously mentioned, we refer to the coefficients pij as plain coefficients, and Pij are referred to as cipher coefficients. Similarly, Px1x2xm and px1x2xm are referred to as cipher and plain polynomials respectively. While coefficients are encrypted with homomorphic encryption operator, the polynomial Px1x2xm still accepts user’s input. That is, the cipher polynomial value P¯ can be still calculated with a chosen set of r1,,rm from the field Fq as follows

(13)
P¯=Pr1r2rm=1ijmPijxixjmodq.

Note that the computed value P¯ is an integer. The arithmetic to compute such value was not performed modulo any integer. The plain polynomial values are securely hidden through the hidden ring S. To recover the plain polynomial equation, decryption operator ̂R1S can be applied to the cipher polynomial value P¯, followed by reduction modq:

(14)
̂R1SP¯=R1P¯modS,then
(15)
R1P¯modSmodq=pr1r2rm=p¯.

The value p¯ is the plain polynomial value for the chosen values of variables x1,,xm by the encrypting party.

Similar to the linear case, the public key of the asymmetric scheme consist of quadratic polynomials of the form (9), to be encrypted using homomorphic encryption operators. The cipher public keys are of the form (10). Such cipher public keys are the ones shared, while the plain public keys are not. The ciphertext in the combined scheme is of the form (13), which needs to be decrypted back to the plain value. For that a homomorphic decryption operator is applied, as in Eq. (14), and the plain ciphertext value is recovered.

Homomorphic Polynomial Public Key Cryptosystem

The Homomorphic Polynomial Public Key Cryptosystem or HPPK for short is a variant of a MPKC scheme with public keys encrypted using homomorphic encryption operator. We feel it is valuable to provide the reader with a brief summary of MPKC to facilitate better understanding of the HPPK scheme.

Brief summary of MPKC

An interested reader can find the detail description of MPKC schemes by Ding and Yang.39 In this section, we briefly outline the basic mechanism of MPKC algorithms. The framework mainly consists of quadratic multivariate polynomials

p1x1xm,p2x1xm,,px1xm
in m variables over finite field Fq. Each polynomial pkx1xm can be written in its expanded form as
(16)
pkx1xm=i<j=1mpijkxixj
for k=1,2,,l. In the literature Equation (16) is generally written in a matrix form as
(17)
pkx1xm=x1xmp11kp12kp1mkpi1kpi2kpimkpm1kpm2kpmmkx1xmT
briefly expressed as
pkx1xm=xPkxT,
where Pk is an m×m square matrix. Considering all polynomials, we can write the MPKC map from Fqm to Fq as a 3-dimensional matrix Pmm, which is a trapdoor called the central map. The central map is selected to be easily invertible. In order to protect this central map and its structure, two affine linear invertible maps T and S are chosen to construct the MPKC public key:
  • Public Key: P¯=TPS.

  • Private Key: TPS.

The MPKC encryption procedure simply evaluates polynomials over the field Fq as

(18)
z=P¯x=z1=p1x1xmz2=p2x1xmz=px1xm
and decryption works as follows
u=T1z,v=P1u,x=S1v.

The major step to use MPKC is to construct the invertible central map P over a finite field Fq to perform a map: FqmFq.

There may be a potential way to enhance the security of MPKC cryptosystem by applying the proposed homomorphic encryption on its map: FqmFq. The homomorphic encryption effectively hides the public key construction logic over a hidden ring S. In this case, an encryption key Rk is required for each quadratic polynomial pkx1xm, with value Rk chosen over the hidden ring S for all k. Hence, there are a total of encryption keys for MPKC. The MPKC encryption in this case is almost the same as the original MPKC encryption. The ciphertext z1z2z is to be homomorphically decrypted to create original multivariate equation system, as illustrated in Equation (18). This means, Equation (18) is hidden under the hidden ring S. On one hand, applying the homomorphic encryption would increase the public key size for MPKC, however, the number of variables can be reduced due to the homomorphic encryption.

In this paper, we are not going to further explore this variant of MPKC schemes but we will focus on another variant of MPKC, called HPPK which we propose in the new section.

HPPK encapsulation

We propose a new variant of an MPKC scheme, called the Homomorphic Polynomial Public Key or HPPK, with the following considerations:

  • The vector on the left hand side of the map P is treated as xl and the vector on the right hand side as xr;

  • The vector xl is replaced with xl=x0x1x2xn, considering xl as a message vector in a polynomial vector space represented by a basis x0x1x2xn for a message variable x and xr=x1xm as a noise vector for noise variables x1,,xm;

  • The proposed homomorphic encryption is applied to the central map P, mapping the elements from FqS: P¯=̂RSP

    and the decryption is de-mapping from SFq: P=̂R1SP¯modq

  • The number of polynomials is reduced to =2;

  • The decryption mechanism is changed from inverting maps to modular division, which automatically cancels the noise used for obscurity.

Key construction

Without loss of generality, we change the notation of the unencrypted central map to P. Under the above considerations, the central map P consists of two multivariate polynomials

(19)
p1xx1x2xm=1x1xnp011p021p0m1p111p121p1m1pi11pi21pim1pn11pn21pnm1x1x2xmT,
and
(20)
p2xx1x2xm=1x1xnp012p122p0m2p112p122p1m2pi12pi22pim2pn12pn22pnm2x1x2xmT.

Note that the matrix maps P1 and P2 are of size n+1×m, thus, no longer square. The construction of p1xx1xm and p2xx1xm can alternatively be achieved with polynomial multiplications

(21)
p1xx1xm=Bxx1xmf1xp2xx1xm=Bxx1xmf2x,
where the base multivariate polynomial Bxx1x2xm and univariate polynomials f1x and f2x have the following generic forms
(22)
Bxx1xm=i=0nbj=1mbijxixj
f1x=i=0λf1ixi
f2x=i=0λf2ixi.

Here, nb and λ are orders of base multivariate polynomial and univariate polynomials with respect to message variable x respectively. Without loss of generality, we assume that the univariate polynomials f1x and f2x are solvable, in other words λ<5. Using Equations (21) and (22), we can express

(23)
p1xx1xm=i=0nj=1mpij1xixj=xlP1xrp2xx1xm=i=0nj=1mpij2xixj=xlP2xr,
with pij1=s+t=ibsjf1t and pij2=s+t=ibsjf2t being the coefficients, and n=nb+λ. It is apparent that the plain central map P as shown in Equation (19) and Equation (20) expanded as Equation (23) inherits a lot of structure. Given that the components of the central map are private key elements, the map in its unaltered form is not secure against potential attacks such as polynomial factorization, root finding, etc. To secure the central map, we apply homomorphic encryption operator to the plain central map by acting with ̂R1S on p1xx1xm and ̂R2S on p2xx1xm. To be more precise, the cipher central map consists of two polynomials
(24)
P1xx1xm=i=0nj=1mR1pij1modSxixj=xlP1xr
(25)
P2xx1xm=i=0nj=1mR2pij2modSxixj=xlP2xr.

We set public key to be the cipher central map P, while private key consists of the homomorphic operators, the hidden ring, together with univariate polynomials:

Security parameters: nb,λ, and the prime finite field Fq which is agreed on before the key generation procedure.

Private key:

  • hidden ring S with a randomly selected S for the required bit length;

  • homomorphic encryption key values R1 and R2 chosen from S;

  • univariate polynomials f1x and f2x with coefficients randomly selected from Fq;

Public key: the map P, consisting of

  • polynomial P1xlxr=xlP1xr

  • polynomial P2xlxr=xlP2xr

Encryption

Encryption is straightforward, by determining the value for the secret x and randomly choosing values for the noise variables x1,,xm over the field Fq and evaluating ciphertext integer values P¯1 and P¯2. That is, the ciphertext consists of two integer values C=P¯1P¯2, where

(26)
P¯1=i=0nj=1mPij1xjximodqP¯2=i=0nj=1mPij2xjximodq.

Here, Pij1 and Pij2 denote the cipher coefficients encrypted with the homomorphic encryption operators. Note that the cipher polynomials have coefficients in the hidden ring S, and all monomial calculations are performed modq, the rest of the arithmetic is performed over integers. The values P¯1, and P¯2 are integers forming the ciphertext C=P1P2.

Decryption

It is easy to verify that the HPPK map as in Equation (19) and Equation (20), under construction as shown in Equation (21), holds a division invariant property on the multiplicand or the base multivariate polynomial Bxx1x2xm. Indeed,

p1xx1xmp2xx1xm=Bxx1xmf1xBxx1xmf2x=f1xf2x.

The first step in the decryption process is to apply the homomorphic decryption operator to the ciphertext to recover plain polynomial values p¯1 and p¯2, which are evaluation results of plain multivariate polynomials p1xx1xm and p2xx1xm at the chosen message and noises respectively. This can be done as

̂R11SP¯1=p1xx1xm=p¯1̂R21SP¯2=p2xx1xm=p¯2.

These values are used to compute the ratio K modulo q of the form

(27)
K=p¯1p¯2=p1xx1xmp2xx1xm=f1xf2xmodq

Note that the noise vector xr is automatically eliminated through the division. The secret x can then be found from Equation (27) by radicals if f1x and f2x are solvable such as linear or quadratic polynomials. The optimal choice of λ is 1 in the framework of the HPPK algorithm. This division invariant property is the foundation for the HPPK encapsulation to be indistinguishable under chosen plaintext attacks.

A toy example

We demonstrate how HPPK works with a toy example.

Key pair generation

Considering a prime field F13 with the prime q=13 and two noise variables x1,x2 for the simplicity of the demonstration purpose only, we can choose the hidden ring characterized by an integer of length >12 bits. The private key consists of the following values:

  • S=6798,R1=4267,R2=6475

  • f1x=4+9x

  • f2x=10+7x

  • Bxx1x2=8+7xx1+5+11xx2 (note: just for key pair construction procedure; this polynomial is not stored in the memory)

The PPK is simply constructed as

P1xx1x2=f1xBxx1x2mod13=x16+9x+11x2+x27+11x+8x2,P2xx1x2=f2xBxx1x2mod13=x12+9x+10x2+x211+2x+12x2.

The PPK polynomials are encrypted with the self-shared key R1,R2 over the ring S

P1xx1x2=R1SP1xx1x2=x15208+4413x+6149x2+x22677+6149x+146x2P1=52082677441361496149146
P2xx1x2=R2SP2xx1x2=x16152+3891x+3568x2+x23245+6152x+2922x2P2=615232453891615235682922
to create the so-called CPK P1 and P2.

Encryption

We randomly choose variables from F13: x=8,x1=3,x2=6. We, then, pre-calculate values

x11=x1xmod13=8×3mod13=11,x12=x1x2mod13=82×3mod13=10,x21=x2xmod13=8×6mod13=9,x22=x2x2mod13=82×6mod13=7.

Now we can calculate the ciphertext C=198082192229 as follows

P¯1=x15208+4413x+6149x2+x22677+6149x+146x2=198082P¯2=x16152+3891x+3568x2+x23245+6152x+2922x2=192229

Decryption

We first perform the homomorphic decryption to rebuild the plain polynomial equations

P1xx1x2=f1xBxx1x2=R11S198082mod13=1980824267mod6798mod13=8
P2xx1x2=f2xBxx1x2=R21S192229mod13=1922296475mod6798mod13=9
then we can eliminate the noise introduced by the base multivariate polynomial
P1xx1x2P2xx1x2=4+9x10+7x=89mod13=11
where the secret x can be easily extracted as x=8. The encryption can be done with any possible values for x1 and x2 at a given secret x, which would produce different ciphertext C, but the decryption would reveal the same secret. This simple toy example demonstrates its capability of randomized encryption.

HPPK security analysis

In this section, we analyze the security of the proposed HPPK algorithm. The security of HPPK relies on the computational hardness of the Modular Diophantine Equation, introduced in Definition 0.1, and Hilbert’s tenth Problem, introduced in Definition 0.7. We begin by proving that HPPK satisfies the IND-CPA indistinguishability property. These results are then extended to prove that the task of recovering plaintext from the ciphertext in the framework of HPPK is NP-complete, and state its classical and quantum complexity. Afterward, we focus on the private key attack and prove that the problem of obtaining the private key from the public key is NP-complete. Here we also provide classical and quantum complexities of obtaining private key from the public key.

Plaintext attack

An attentive reader will notice that the evaluated ciphertext as illustrated in Equation (26) has not been reduced modulo any integer. Thus, an adversary looking to perpetrate an attack to recover the plaintext can treat the coefficients of the polynomials in Equation (26) and evaluated ciphertext as integers. The plaintext values, sought after by the adversary, are elements of the field Fq, thus the malicious party can reduce the public values of the ciphertext modulo q to solve for plaintext variables in the Equation (26). We formally phrase it in the following remark.

Remark 0.0.1.

For the purpose of obtaining the plaintext, the ciphertext and cipher coefficients as illustrated in the Equation (26) can be considered modulo q as follows

(28)
C=i=0nj=1mPij1xjxiP¯1=0modqi=0nj=1mPij2xjxiP¯2=0modq

Definition 0.1

(Modular Diophantine Equation). The Modular Diophantine Equation asks whether an integer solution exists to the equation

Py1yk1=0modq,
given as an input of a polynomial Py1yk and a prime q.

Remark 0.0.2.

A positive answer to this question would include a solution.

Let m+1>2. Note that the system in the Equation (28) can be normalized as

(29)
C=i=0nj=1mPij1xjxi1=0modq,i=0nj=1mPij2xjxi1=0modq.

A naive way of solving such a normalized system is to solve each equation and find a common solution. Each such equation is an instance of a Modular Diophantine Equation. The more obvious way to solve the system in Equation (28) would be to use Gaussian elimination and transform the system into a single equation. Indeed, since the coefficients of the ciphertext are publicly known, and the noise variables are linear in the ciphertext, the adversary can express any noise variable using the remaining terms of the equation and reduce the system to a single equation of the form

(30)
Hxx1xm11=0
over Fq with m unknowns, where m>1. We assume that the adversary favours the ciphertext form with fewer variables. Thus, from the perspective of the adversary the ciphertext has form as in Equation (30). From here on forward, we consider the ciphertext in the form given in Equation (30). We formally define said form below.
Definition 0.2

Let m+1>2. The ciphertext in its normalized reduced form is a single equation

(31)
Hxx1xm11=0
over Fq, where x corresponds to the plaintext variable and the remaining variables are noise variables.

Note that even in its normalized reduced form the ciphertext is an instance of a Modular Diophantine Equation. Since m+1>2 we can argue that the adversary does not benefit much by reducing the system in Equation (29) to a single equation (31), and eliminating one variable. The number of expected solutions to the Equation (31) remains qm1, and the adversary is facing with the problem of deciding which solution is the correct one. That is, a brute-force search algorithm can find a list of solutions to the Equation (31) by trying all the possible m1 variables values over Fq. The adversary is interested in a particular solution from the list.

One might argue that the attacker is interested only in the plaintext variable xFq. Thus, the adversary can simply guess the value x. The complexity of this guess is Oq. This is a probabilistic attack. For a deterministic result, this guess has to be tested for correctness. This will require coming up with values for the noise variables and testing whether the guess is correct. Moreover, NIST requires the size of the actually communicated secret to be 32 bytes.61 Thus, the secret that is transferred between two parties consists of v=32/q8 blocks, where each block is q2 bits. Each block corresponds to the HPPK secret x. The secret message is then v different values x concatenated together to form a 32 byte secret. Each such block x is encrypted separately using HPPK. The complexity of correctly guessing the transferred secret message is then Oqv, where v=32/q, comparing with the complexity Oqvm1 of attacking all blocks.

Theorem 0.1

The Modular Diophantine Equation Problem is NP-complete.

Proof.

The proof, using the Boolean Satisfiability Problem, is given by Moore and Meterns [,62 Section 5.4.4]. □

Theorem 0.1 states that a brute-force search algorithm can find a solution to the Modular Diophantine Equation by trying all the possible solutions. Thus, without loss of generality, we treat the ciphertext-only attack on a ciphertext in its normal reduced form as a Modular Diophantine Problem. Indeed, by Theorem 0.1 the algorithm to find a solution to a Modular Diophantine Equation does not simply terminate to give a solution, it is a brute-force search algorithm that considers every possible solution before producing a result. In other words, it goes through all the possibilities to choose the correct one.

IND-CPA indistinguishability property and ciphertext only attack

We suppose that the adversary will choose to perpetrate the attack on the ciphertext in its normal reduced form as in Equation (31), for its easier to attack. In the framework of HPPK, the public key elements are the coefficients of the ciphertext polynomials.

Theorem 0.2

(HPPK has IND-CPA property). Let m>1, where m is the total number of variables in the normalized reduced form of the ciphertext as in Equation (31). If the Modular Diophantine Equation is NP-complete, the HPPK encryption system is provably secure in the IND-CPA security model with a reduction loss of qm2.

Proof.

Assume that there exists an adversary A that tε-breaks the HPPK encryption system in the IND-CPA security model. We construct a simulator that solves the Modular Diophantine Equation. Given as input, a Modular Diophantine Equation instance qHxx1xm1, where Hxx1xm1 is of the form Equation (31) and m>1, the simulator runs A as follows. The simulator sets the normalized public key over Fp to the coefficients of the polynomial Hxx1xm1. The challenge consists of the following game. The adversary A generates two distinct messages m0 and m1Fq, and submits them to the simulator. The simulator randomly chooses b in 01 as well as random values r1,,rm1 for the noise variables, and sets the ciphertext to be the value

H¯=Hmbr1rm1.

The challenge for the adversary then consists of the following equation to be solved for x:

Ĥxx1xm11=0
over Fq. Here,
Ĥxx1xm1=1H¯Hxx1xm1.

This equation remains to meet the definition of the Modular Diophantine Equation Hxx1xm11=0, since the value 1H¯ can be pushed to the noise variables, which are random and do not influence the plaintext. Indeed, let hij be the coefficients of the polynomial Hxx1xm1 for any i0n and j1m1, then

i=0lj=1m1hijxixj×1Hmbr1rm1=i=0lj=1m1hijxixj,
where xj=xjH¯. The challenge in this case is correct, as it corresponds to the challenged plaintext and remains in the form of a Diophantine equation chosen by the simulator.

The coefficients of the challenge equation come from the submitted Diophantine equation, and thus, from the point of view of the adversary are random. The values r1,,rm1 are selected at random. The adversary does not have knowledge of the values x1xm1 and they can not be calculated from the other parameters given to the adversary. So the noise variables xj for all j1m1 are random. Hence, the simulation holds randomness property. By construction, the simulation is indistinguishable from a real attack. That is, the adversary is challenged with solving the equation as in the Equation (30), which is HPPK ciphertext in its normalized reduced form.

The simulator does not abort in the simulation while interacting with the adversary. The adversary outputs a random guess b of b. When b is equal to b, the adversary wins. Otherwise, the adversary looses. The probability of simply guessing the value for x is Pr=12. We will calculate the probability of solving the IND-CPA challenge with the advantage of the adversary, that is Pr=12+α. The advantage comes from the assumption that the adversary can break the HPPK cryptosystem.

The challenge has a general form as in the Equation (31), thus, the equation is expected to have qm1 distinct solutions, considering all m variables. On the other hand, it is known that the variable xm0m1. Assuming x=m0, there are now qm2 possible solutions to choose the correct solution from. The same is true for x=m1. That is, the probability of finding correct solution of the equation Hxx1xm11=0 is

Prcorrect solutionx0=m0=Prcorrect solutionx=m1=1qm2,
where Prcorrectsolution denotes probability of finding the correct solution to the equation Hxx1xm11=0. Then by the law of total probability, the probability of solving the challenge equation is
Prcorrect solution=Prcorrect solutionx=m0Prx=m0+Prcorrect solutionx=m1Prx=m1=1qm2.

Accounting for the advantage that the adversary has, the probability α is Prcorrect solution=εqm2. The total probability of solving the IND-CPA challenge is then 12+εqm2.

The simulation is indistinguishable from a real attack. So the adversary who can break the challenge ciphertext will uncover the solution to the given Modular Diophantine Equation problem. The probability of breaking the ciphertext is εqm2.

The advantage of solving the Diophantive Equation problem is then εqm2. Let Ts denote the time cost of the simulation. We have Ts=O1. The simulator solves the Modular Diophantine Equation with time cost and advantage t+Tsε/qm2=tε/qm2. Thus, contradicting the Theorem 0.1 so the initial assumption is wrong. □

The framework of the IND-CPA challenge entails known plaintext, in other words, the adversary knows that the secret xm0m1. We now state the complexity of the unknown plaintext ciphertext-only attack.

Lemma 0.3

(Ciphertext-only attack). Let m+1>2. The classical complexity of finding the plaintext from the ciphertext is Oqm1.

Proof.

Let the adversary favour the ciphertext in its reduced normal form (31). Without any knowledge about the plaintext, the adversary will need to solve the Equation (31) to obtain the plaintext along with the noise variables. A single equation over Fq with m variables is expected to have qm1 possible solutions over Fq. The correct one is among them. That is, the plaintext encapsulated in a single variable x is not the sole variable in the ciphertext equation. However, it is the only unknown of interest. The adversary can try and simply guess x, the complexity of the guess is Oq. However, they have to test whether their guess is correct. Moreover, the secret transferred between the communicating parties consist of 32 bytes as required by NIST. Thus, the adversary will have to guess K many values for x, where K=32×8q. In this case, the complexity is OqK. We expect K>m1. Quantum complexity of the described attack due to Grover’s search algorithm is Oqm12.

Private key attack

Lemma 0.4.

Let λ2. There exists a polynomial time algorithm to find coefficients of univariate polynomials f1x0 and f2x0 given the plain central maps P1 and P2.

Proof.

Note that all the plain coefficients of the polynomials p1xx1xm and p2xx1xm as defined in Equation (22) are defined over the prime field Fq. Thus, for any fixed j, it is possible to use Gaussian elimination to reduce the system of equations formed by the plain coefficients of p1xx1xm and p2xx1xm of the form

(32)
fz0b0j=p0jz,fz1b0j+fz0b1j=p1jz,fbnbj=pnjz,
where z12 corresponding to either plain polynomial p1xx1xm or p2xx1xm for any given noise variable xj. Gaussian elimination would produce a single polynomial in λ variables, namely fz2fz0 and fz1fz0 for λ=2 or fz1fz0 if λ=1. Such univariate or bivariate equation is solvable. Depending on the HPPK parameters, the adversary can simply use radical solutions, Evdokimov’s algorithm,63 or resultants together with Evdokimov’s algorithm to solve such equation.63,64 Gaussian elimination can be performed in polynomial time, and finding solutions by radicals, Evdokimov’s algorithm and computing resultants all have polynomial time complexity.63,64

Lemma 0.5.

Let λ2. Finding private key from the cipher public key in the framework of HPPK reduces to finding the homomorphic encryption key S,R1, and R2.

Proof.

The private key consists of the coefficients of the univariate polynomials f1x,f2x as well as values S,R1,R2 used to encrypt the plain public key to the cipher public key. By Lemma 0.4 once the values R1,R2 and S are known, the coefficients of f1x,f2x can be found in polynomial time. □

Definition 0.3

(Diophantine set). The Diophantine set is a set S associated with a Diophantine equation Pba1akba1ak, where k>0 such that

bSif and only ifa1akPba1am=0

Theorem 0.6

(MRDP Theorem). The Matiyasevich–Robinson–Davis–Putnam (MRDP) theorem states that every computably enumerable set is Diophantine, and every Diophantine set is computably enumerable.

Proof.

The result has been proven in various works, for instance.65

Theorem 0.7

(Hilbert's tenth problem) Hilbert’s tenth problem asks whether the general Diophantine Problem is solvable. Due to MRDP, Hilbert’s tenth problem is undecidable.

Proof.

For proof see.65

Theorem 0.8.

Private key attack is non-deterministic and has complexity of at least OT3, where T is the largest number with n+λ+1q2+|(|q2)2 bit-length.

Proof.

By Lemma 0.4 and 0.5 the attack on public key reduces to finding the values S,R1, and R2. From the perspective of the attacker, the values S,R1, and R2 could be treated as a one-time pad keys as they have been chosen at random, and can not be calculated from other parameters given to the attacker. An obvious attack would be a brute force search for all the three values, S,R1, and R2. The direct brute force search classical complexity would be greater than OT3 for the three values together, where T is the largest n+λ+1q2+|(|q2)2-bit number. Due to Grover’s algorithm, the quantum complexity is greater than OT32. Note however, because of the condition gcdSR1=gcdSR2=1, once S is found the search span for R1 and R2 reduces. Brute force search entails a non-deterministic result, however, we provide a more formal argument below.

For each fixed chose of j, each public key coefficient can be written in the integer domain as follows

(33)
fz0bz0j=r0jzS+P0jz,fz1bz0j+fz0bz1j=r1jzS+P1jz,fbznbj=rnjzS+Pnjz,
with j=1,,m, z=1,2, and bzij=Rzbij. Here, Rz, and S are unknowns from the hidden ring S. Values rijz are merely some unknown integers. The only known values are those of the form Pijz. Using Gaussian eliminations, all unknowns of the form bzij can be eliminated, and the equation system in Eq (33) can be reduced to a single equation over
(34)
Pfz0fr0jzrnjzSP¯=0.

Solving such equation by Theorem 0.6 and 0.7 is an NP-complete task. For each j, we can generate one such equation. Considering them all together, the adversary will arrive at an underdetermined system as the variables in the system depend on j. Each equation in such a system is a multivariate Diophantine equation. One way to solve this system is to solve each equation separately and search for common solutions. However, by Theorem 0.6 and 0.7 this is an NP-complete problem. Reducing the system to a single polynomial still produces a multivariate Diophantine equation, solving which is an NP-complete problem by Theorem 0.6 and 0.7. □

Security of the homomorphic operator

Recall, that the homomorphic operator ̂S,R is defined by the two secret values S,R. These values are known only to the decrypting party and are never shared. Thus, we assume that the adversary can not simply access the homomorphic encryption oracle. Indeed, if the adversary were to have access to such oracle, they could pass 1 to be encrypted, resulting in the output value R. Thus, the adversary would learn half of the homomorphic secret key. In order to find the value S, the adversary can pass values R1k to be encrypted, producing k mod S. The values k can be chosen to determine S. For instance, with public knowledge of the bit-size of S, the adversary can consider an interval between the smallest number of that bit-size and the largest number of that bit-size, and divide that interval in half, where k is the mark at the half. If kmodSk, then S must be smaller than k. If kmodS=k, then S is larger than k. In the first case, take the interval between the smallest number of bit-size 2p2+L2 and k, and consider the halfway mark. Repeat the experiment, each time decreasing the interval until the value S is “trapped” in a small interval and can be determined. Similarly for the latter case, take the interval between k and the largest number of bit-size 2p2+L2, mark a halfway and use that mark value to repeat the experiment. Based on whether or not the value changes, decrease the interval and repeat the experiment. This is only but one way to find S, while R is known.

Since the operation is deterministic, after the values of R and S are fixed, it is important that they remain secret and the adversary does not have access to the homomorphic encryption oracle. Note that in the framework of HPPK, the adversary has access to the public key polynomials which are essentially randomly chosen values encrypted using the homomorphic operator with secret values R,S. Without the knowledge of the values before they were acted on with R,S, finding R,S can be considered a brute force search problem.

Security conclusion

At large, the security of the HPPK cryptosystem relies on the problem of solving undetermined system of equations over Fq. Such system is expected to have qvw possible solutions, where v is the number of variables and w is the number of equations in the system. The attacker can solve this system to find all possible solutions, however, it is the problem of determining the correct solution from all the possible solutions that makes HPPK secure.

The ciphertext attack requires the adversary to solve an underdetermined system of equations over Fq, which can be reduced to a single Modular Diophantine equation. Solving this equation is an NP-complete problem.

The public key attack aimed to unveil the plaintext reduces to a brute force search for three unknown values S,R1,R2. To find these values, the attacker can either use brute-force search or solve an underdetermined system of equations over the integers. The former yields non-deterministic results and the latter is an NP-complete problem.

We conclude that from the point of view of the adversary, the following is true.

Proposition 0.8.1.

The best classical complexity to attack HPPK is Oqm1.

Proof.

We assume that the malicious party will take the most advantageous path for them. Thus, by Lemma 0.3, Lemma 0.4, Lemma 0.5, and Theorem 0.8 we can conclude that the best attack is to obtain the plaintext from the ciphertext. Such attack is non-deterministic with classical complexity of Oqm1.

Conclusions

In this paper, we introduce a new homomorphic encryption scheme intended to secure public keys of multivariate asymmetric cryptosystems. Unlike conventional homomorphic encryption, our scheme uses encrypted plain public keys or CPK that can be published for anyone to use to establish a secret sharing between two parties. Our homomorphic encryption is applied to polynomials, leveraging homomorphic properties and allowing for user input through variables. The homomorphic encryption and decryption operators are modular multiplication operators modulo a hidden value S, with values R1 and R2 chosen uniformly at random from the hidden ring S under certain conditions. We propose using this homomorphic encryption in conjunction with Multivariate Polynomial Public-key Cryptosystem (MPKC) to secure polynomial public keys, called Homomorphic Polynomial Public Key (HPPK). We describe the HPPK algorithm in detail, drawing from the framework of MPKC. HPPK public keys are product polynomials of a multivariate and univariate polynomials, encrypted with a homomorphic encryption operator. The ciphertext is created by the encrypting party through the input of plaintext and random noise as public polynomial variables. The decryption procedure involves first homomorphic decryption of the ciphertexts to produce plain polynomial values for a division of two plain polynomials. By construction, such division cancels the base multiplicand polynomial with the noise variable and retains a single equation in one variable. This variable is the plaintext, which can be found by radicals. We provide a thorough security analysis of the HPPK cryptosystem, proving that the hardness of breaking the HPPK algorithm comes from the NP-completeness problem of the Modular Diophantine Equation. We also show that HPPK holds the IND-CPA property. In the future work, we will perform a detailed benchmarking study with variety of configurations as well as a more extensive security analysis, considering attacks that have not been described in the work.

Author contributions

R.K. provided the core ideas. M.P. developed the security analysis. All authors reviewed the manuscript and approved its publication.

Comments on this article Comments (0)

Version 1
VERSION 1 PUBLISHED 17 Oct 2023
Comment
Author details Author details
Competing interests
Grant information
Copyright
Download
 
Export To
metrics
Views Downloads
F1000Research - -
PubMed Central
Data from PMC are received and updated monthly.
- -
Citations
CITE
how to cite this article
Kuang R and Perepechaenko M. A novel homomorphic polynomial public key encapsulation algorithm [version 1; peer review: 1 approved, 1 approved with reservations]. F1000Research 2023, 12:1347 (https://doi.org/10.12688/f1000research.133031.1)
NOTE: If applicable, it is important to ensure the information in square brackets after the title is included in all citations of this article.
track
receive updates on this article
Track an article to receive email alerts on any updates to this article.

Open Peer Review

Current Reviewer Status: ?
Key to Reviewer Statuses VIEW
ApprovedThe paper is scientifically sound in its current form and only minor, if any, improvements are suggested
Approved with reservations A number of small changes, sometimes more significant revisions are required to address specific details and improve the papers academic merit.
Not approvedFundamental flaws in the paper seriously undermine the findings and conclusions
Version 1
VERSION 1
PUBLISHED 17 Oct 2023
Views
4
Cite
Reviewer Report 22 Mar 2024
Taniya Hasija, Chitkara University Institute of Engineering and Technology,, Chitkara University, Rajpura, Punjab, India 
Approved with Reservations
VIEWS 4
A novel homomorphic polynomial public key encapsulation algorithm
The author has presented a proposed method named as homomorphic polynomial public key encapsulation algorithm that incorporates an additional layer of encryption during key construction procedure, through a hidden ring. The ... Continue reading
CITE
CITE
HOW TO CITE THIS REPORT
Hasija T. Reviewer Report For: A novel homomorphic polynomial public key encapsulation algorithm [version 1; peer review: 1 approved, 1 approved with reservations]. F1000Research 2023, 12:1347 (https://doi.org/10.5256/f1000research.145999.r242797)
NOTE: it is important to ensure the information in square brackets after the title is included in all citations of this article.
Views
9
Cite
Reviewer Report 01 Nov 2023
Gui-Lu Long, Department of Physics, Tsinghua University, Beijing, Beijing, China 
Approved
VIEWS 9
In this work, the authors presents a variant of the MPKC. It simplifies MPKC central map to two multivariate polynomials constructed from polynomial multiplications. The HPPK algorithm employs a single polynomial vector for the plaintext and a multi-variate noise vector associated ... Continue reading
CITE
CITE
HOW TO CITE THIS REPORT
Long GL. Reviewer Report For: A novel homomorphic polynomial public key encapsulation algorithm [version 1; peer review: 1 approved, 1 approved with reservations]. F1000Research 2023, 12:1347 (https://doi.org/10.5256/f1000research.145999.r216597)
NOTE: it is important to ensure the information in square brackets after the title is included in all citations of this article.

Comments on this article Comments (0)

Version 1
VERSION 1 PUBLISHED 17 Oct 2023
Comment
Alongside their report, reviewers assign a status to the article:
Approved - the paper is scientifically sound in its current form and only minor, if any, improvements are suggested
Approved with reservations - A number of small changes, sometimes more significant revisions are required to address specific details and improve the papers academic merit.
Not approved - fundamental flaws in the paper seriously undermine the findings and conclusions
Sign In
If you've forgotten your password, please enter your email address below and we'll send you instructions on how to reset your password.

The email address should be the one you originally registered with F1000.

Email address not valid, please try again

You registered with F1000 via Google, so we cannot reset your password.

To sign in, please click here.

If you still need help with your Google account password, please click here.

You registered with F1000 via Facebook, so we cannot reset your password.

To sign in, please click here.

If you still need help with your Facebook account password, please click here.

Code not correct, please try again
Email us for further assistance.
Server error, please try again.