You are currently viewing a new version of our website. To view the old version click .
Cryptography
  • Article
  • Open Access

10 December 2025

Efficient CCA2-Secure IBKEM from Lattices in the Standard Model

,
and
1
Department of Mathematics and Physics, University of Information Technology, Vietnam National University, Ho Chi Minh City 720325, Vietnam
2
Institute of Cybersecurity and Cryptology, School of Computing and Information Technology, University of Wollongong, Northfields Avenue, Wollongong, NSW 2522, Australia
3
Data Science, Deakin University, Melbourne, VIC 3125, Australia
*
Author to whom correspondence should be addressed.

Abstract

Recent work at SCN 2020 by Boyen, Izabachène, and Li introduced a lattice-based key-encapsulation mechanism (KEM) that achieves CCA2-security in the standard model without relying on generic transformations. Their proof, however, leaves a few gaps that prevent a fully rigorous security justification. Building on the same design rationale, we revisit that construction and refine it to obtain a more compact and provably secure KEM under the Learning With Errors assumption. Furthermore, we extend this framework to derive an identity-based variant (IBKEM) whose security is established in the same model. The resulting schemes combine conceptual simplicity with improved efficiency and complete proofs of adaptive-ciphertext security.

1. Introduction

Public-key encryption (PKE) remains a cornerstone primitive in modern cryptography. There are two common notions for the security of PKE: security against adaptive chosen-plaintext attacks (CPA) and security against adaptive chosen-ciphertext attacks (CCA). In the CPA security model, an adversary is allowed to adaptively query the encryption of messages chosen by himself, and at the end, he must guess which of the two challenge plaintexts corresponds to a given ciphertext. CCA1 security is a stronger notion in which the adversary can request the decryption of arbitrary ciphertexts before seeing the challenge ciphertext. If the adversary can query the decryption oracle even after receiving the challenge ciphertext, we refer to this as CCA2 security. From a design perspective, achieving CCA2 security is preferable because it captures realistic attack scenarios in which ciphertexts can be modified or replayed.
Recently, Key Encapsulation Mechanisms (KEMs) have been introduced as a modular and efficient alternative to traditional PKE. A KEM is a public-key primitive allowing a sender to securely encapsulate a random session key under the public key of the receiver. The receiver can later decapsulate this ciphertext to recover the same shared key, which can then be used with a symmetric encryption scheme (Data Encapsulation Mechanism, or DEM) to achieve hybrid encryption. The security of a KEM is typically defined under the IND-CCA model, ensuring that the encapsulated key is indistinguishable from random even under adaptive decryption queries.
The motivation for studying Identity-Based KEMs (IB-KEMs) stems from the need to simplify key management in large-scale systems. Traditional public-key infrastructures (PKIs) require certificates to bind identities to public keys, which introduces significant overhead. In contrast, identity-based cryptography allows public keys to be derived directly from user identities, such as email addresses, thus eliminating the need for certificates. When combined with the KEM framework, IB-KEM provides an efficient and modular way to establish shared keys under the identity-based setting while maintaining strong CCA security guarantees.
Following the work of Boyen, Izabachène and Li in [1], several directions have been investigated for building lattice-based public-key or key-encapsulation mechanisms that achieve adaptive-ciphertext security in the standard model. The first uses transformations, such as the BCHK conversion [2], applied to identity-based encryption frameworks. The second relies on lossy-trapdoor functions [3], which are injective for one key distribution but statistically lossy for another, as in [4]. The third incorporates non-interactive zero-knowledge (NIZK) proofs within lattice encryption to certify ciphertext validity, following ideas similar to the Naor–Yung paradigm. However, all of those three approaches have certain drawbacks. The first approach is quite popular but it produces an overhead in the ciphertext because they depend on one-time signature mechanisms to bind tags. The problem with the second approach is that all currently known lossy trapdoor functions from lattices [3,5] require large parameters and rely on strong lattice assumptions. The third approach is not practical. Boyen, Izabachène, and Li then proposed, in [1], a new approach to construct an efficient KEM from lattices without using any generic constructions as the aforementioned three approaches. Their technique is adapted from previous work [6] on CCA2-secure PKE construction in pairings to lattice setting. They start from the tag-based CCA1-secure PKE scheme in [7] and replace the tag in a suitable way to achieve CCA2-security. The proof of security reduces to a special form of the Learning With Errors problem, which they denote as the SISnLWE assumption (see Section 2 for the details). However, the security proof of [1] is not complete. In fact, it missed one case in the proof and it is not clear how to argue the security in this situation. In addition, it is non-trivial to obtain an identity-based KEM (IBKEM) from the construction of Boyen, Izabachène, and Li in [1].

1.1. Contribution

The central goal of this paper is to design an identity-based key-encapsulation mechanism (IBKEM) over lattices that achieves selective chosen-ciphertext (CCA2) security, presented in Section 3. This work builds upon the CCA2-secure KEM construction by Boyen, Izabachène, and Li [1], and integrates it with the strong G-trapdoor technique from [7] to enable efficient private key extraction for identities. However, the proposed approach is not an immediate adaptation of [1], due to a technical issue in its security proof. Specifically, the proof of the KEM in [1] does not cover all possible cases of well-formed ciphertexts submitted to the decapsulation oracle. In particular, one security branch was left unaddressed, which leaves the argument for completeness unclear. To address this, we propose in Section 2 a simple modification to the CCA2-secure KEM of [1]. With this refinement, we provide a complete reduction demonstrating that the new KEM satisfies adaptive-ciphertext security. Building on this foundation, our IBKEM inherits the improved security guarantees, achieving IND-sID-CCA2 protection in the standard model under the hardness assumptions of the SIS and SISnLWE problems.

1.2. Our Approach

Let us recall the construction in [1]. In the KEM from [1], the ciphertext CT = ( c 0 , c 1 , t ) is of the form
c 0 T = s T A + e 0 T , c 1 T = s T ( A 1 + FRD ( t ) G ) + e 1 T , t = H ( c 0 , U e 1 )
where matrices A , A 1 , U and hash function H are public and s = k q / 2 + s ¯ is a transformation of the session key k { 0 , 1 } * with noise s ¯ . Here, G Z q n × ω is a gadget matrix (see Section 2.3 for the detail) and FRD is a full-rank difference encoding introduced in [8]; readers are referred to the formal definition in Section 2.3. The decapsulation algorithm extracts s , e 0 , e 1 and recovers session key k .
We first attempted to extend the original construction of CCA2-secure KEM in [1] to a CCA2-secure IBKEM. Our first challenge was to find a way to generate a trapdoor for each identity in the decapsulation algorithm. In many IBKEM schemes based on lattices (e.g., [8,9]), the ciphertexts for identities id are usually of the form
c = s T F id + e T
where F id = [ A | A 1 + FRD ( id ) G ) ] Z q n × ( m + ω ) is the matrix tied to the identity id whose trapdoor is the secret keys for id . Note that the trapdoor in [1] is a G-trapdoor [7], not the short vectors or bases of the lattices Λ q ( F id ) , as in many works such as [8,10]. Moreover, there was no existing scheme using G-trapdoor extraction. We then come up with a way of extracting G-trapdoor by considering
F id = [ A | A 1 + FRD ( id ) G | C + FRD ( t ) G ] Z q n × 3 m ,
where A , A 1 , C are public matrices.
The most difficult challenge was in answering the decapsulation queries without leaking any information in the case of some parts of query tuples ( CT = ( c 0 , c 1 , t ) , id ) that coincide with the challenge ( CT * = ( c 0 * , c 1 * , t * ) , id * ) . The adversary may request decryptions for ( CT , id ) ( CT * , id * ) . The appearance of identities id in queries in IBKEM yields more cases to deal with than in KEM. Therefore, we failed to use the original KEM construction of Boyen [1] to extend to IBKEM, which motivated us to revise it.
In the IND-CCA2 experiment for the KEM [1], the challenger sends the adversary A a ciphertext CT * = ( c 0 * , c 1 * , t * ) together with either the genuine session key k * or a random key k . The adversary’s task is to decide whether the received key is authentic or random. If A can successfully submit a well-formed ciphertext CT = ( c 0 , c 1 , t ) to the decryption oracle, with c 0 = c 0 * = ( k * q / 2 + s ¯ ) T A + e 0 T , then the oracle must return the correct session key k * , enabling A to distinguish the challenge. Therefore, we need to deal with such a case. As the query CT is different from the challenge ciphertext CT * , when c 0 = c 0 * , there are three cases:
(i)
c 1 = c 1 * and t t * ;
(ii)
c 1 c 1 * and t = t * ;
(iii)
c 1 c 1 * and t t * .
Case (i) occurs with negligible probability by Lemma 7 [1]. Case (ii) is also considered in Lemma 8 [1]. To be more precise, in Lemma 8, the authors mentioned the case where “ c 0 = c 0 * (thus, t = t * ) and c 1 c 1 * ”. The assumption that c 0 = c 0 * implies that t = t * is incorrect because e 1 can be sampled independently of c 0 . We double-checked the proof of the Lemma 8 to ascertain if it is a typo, but from the arguments in Lemma 8, only the case (ii) is considered. As a result, the case (iii) is missing in [1] and it is not clear how to argue the security in this case in the original construction. Therefore, the security proof of Boyen [1] is not complete. However, we observe that to deal with case (iii), such k should not be considered as the whole valid session key. Our solution is setting session key
K = U e 1 + k ,
deriving the session key not just from c 0 but also from the SIS hash of e 1 . When receiving the session key K from the decapsulation oracle for any kind of ciphertext, an adversary cannot find any linkability to challenge the session key except in the case that c 0 = c 0 * and c 1 = c 1 * , which can happen with negligible probability, and in the case that t = t * , which is unlikely to happen, assuming the computational intractability of the SIS assumption. Within our updated session-key framework, this adjustment enhances the proof, yielding IND-sID-CCA2 protection for the proposed IBKEM.
To preserve these guarantees, we further adapt the gadget matrix G in [1] by enlarging its dimension while maintaining its algebraic characteristics. This modification ensures that the resulting matrix continues to satisfy the essential properties required for the correctness and trapdoor extraction procedures.

1.3. Related Work

Micciancio and Peikert [7] introduced one of the earliest lattice-based public-key encryption schemes that achieved CCA1 security within the standard model. It is of the form of tag-based encryption and has inspired several follow-up works in this line of research. The BCHK transformation [2] can be used to transform the CCA1-secure scheme in [7], either using an MAC or a signature scheme, to achieve CCA2-security. Boyen, Izabachène, and Li, in [1], proposed a simple and efficient CCA2-secure KEM, starting from the tag-based encryption scheme in [7]. However, the proof in [1] remains incomplete and the parameter choice is inconsistent: the authors required the matrix R used for key generation to act as a right inverse rather than the left inverse adopted in [7]. As a consequence, configurations in which the number of rows in R exceeds its number of columns no longer satisfy the necessary properties. To fix this, we need the reverse. Unfortunately, the adjustment introduces a trade-off between the matrix dimension and the trapdoor quality. Our work revises that construction and parameter selection to obtain a CCA2-secure KEM with a full proof of security that matches the efficiency of the earlier design. A comparative summary of our approach with existing lattice-based PKE/KEM schemes is shown in Table 1. We adopt the same notation as in [1] for consistency: MP12 for the CCA1-secure scheme in [7], MP12-MAC and MP12-SIG for the CCA2-secure schemes obtained from using the BCHK transformation. We also note that Zhang et al. [11] proposed another lattice-based encryption achieving CCA2 resistance, though Boyen et al. [1] later observed that the associated proof omits one crucial case; we, therefore, exclude that scheme from our direct comparison.
Table 1. Comparison for CCA2-secure PKE/KEM schemes.
Agrawal et al. [8,10] and Cash et al. [12] pioneered identity-based encryption constructions grounded on lattice assumptions in the standard model. Subsequent studies by Yamada [13] and Zhang et al. [14] enhanced efficiency, achieving adaptive IBE with compact public keys of size O ( log λ ) . At PKC’2021, Jager et al. [9] proposed the blockwise partitioning technique, which enables practical realization of adaptive identity-based key-encapsulation mechanisms (IB-KEMs) from lattices under the same model. Their design achieves smaller master key dimensions and milder LWE parameters than those required by Yamada [13] and Zhang et al. [14], though its security remains confined to the CPA level. In contrast, the present work develops an identity-based KEM that attains CCA2 security in the standard model while maintaining comparable efficiency. Our current construction supports selective security; improving it toward a fully adaptive guarantee is left as a direction for future study.
Recent research has also advanced CCA-secure IBKEM in non-lattice settings. Qiao et al. [15] proposed a continuously leakage-resilient IBKEM secure under chosen-ciphertext attacks, and Li et al. [16] introduced an identity-based multi-receiver KEM tailored for privacy-preserving federated learning. Earlier, Tomita, Ogata, and Kurosawa [17] presented a leakage-resilient CCA-secure IBKEM from simple group-based assumptions. These works represent the most recent developments on strengthening IBKEM security; however, all rely on group-based hardness assumptions such as bilinear pairings. Our construction is fundamentally different in that it achieves CCA2 security entirely from lattice assumptions, thereby contributing to post-quantum–secure IBKEM in a setting not addressed by the above works.

2. Preliminaries

2.1. Key Encapsulation Mechanism (KEM)

This part summarizes the framework of a Key Encapsulation Mechanism (KEM) and the associated security definitions.
Definition 1
(KEM). A KEM scheme Π is defined by three polynomial-time algorithms:
  • Setup ( λ ) : Given the security parameter λ, the algorithm outputs a public/secret key pair   ( PK , SK ) .
  • Encap ( PK ) : On input of the public key   PK , it produces a ciphertext   CT that encapsulates a random session key   K , and outputs the pair   ( CT , K ) .
  • Decap ( PK , CT , SK ) : Using the public key   PK , the ciphertext   CT , and the secret key   SK , it recovers the corresponding session key   K  if the ciphertext is valid; otherwise it returns the rejection symbol ⊥.
Correctness: For every λ N , a KEM is correct if the session key produced by encapsulation is recovered with probability 1 by decapsulation:
Pr Decap ( PK , CT , SK ) = K ( PK , SK ) Setup ( λ ) ( CT , K ) Encap ( PK ) = 1 .
Security models of KEM
The confidentiality of a KEM is captured by the adaptive chosen-ciphertext attack (IND-CCA2) experiment between a challenger C and an adversary A .
  • Setup:  C runs Setup ( λ ) to generate ( PK , SK ) and gives T PK to A , while keeping SK secret.
  • Phase 1:  A may query the decapsulation oracle O Decap on any ciphertexts of its choice and receive the corresponding session keys.
  • Challenge: The challenger C generates ( CT * , K 1 * ) Encap ( PK ) and chooses a random session key K 0 * in the key space. Then C picks a bit b { 0 , 1 } randomly and sends ( CT * , K b * ) to A .
  • Phase 2:  A continues to query O Decap on any ciphertext CT CT * .
  • Guess: Finally, A outputs a bit b { 0 , 1 } and wins if b = b .
The adversary’s advantage is
Adv A , Π IND CCA 2 : = Pr [ b = b ] 1 2 .
A KEM is IND-CCA2 secure if this advantage is negligible for all probabilistic polynomial-time adversaries.

2.2. Identity Based Key Encapsulation Mechanism (IBKEM)

This section outlines the structure and security formulation of an Identity-Based Key Encapsulation Mechanism (IBKEM).
Definition 2
(IBKEM). An IBKEM scheme Π is specified by four efficient algorithms:
  • Setup ( λ ) : Given the security parameter λ, the algorithm produces a master public key and a master secret key, denoted  ( MPK , MSK ) .
  • Extract ( MPK , MSK , id ) : On input of the master keys and an identity  id , the algorithm outputs the secret key  SK id  associated with that identity.
  • Encap ( MPK , id ) : Using the master public key and the target identity  id , the algorithm generates a ciphertext  CT that encapsulates a random session key  K . It then returns  ( CT , K ) .
  • Decap ( MPK , CT , SK id ) : Given the master public key, a ciphertext, and the identity’s secret key, the algorithm recovers the session key  K  if the ciphertext is valid; otherwise it outputs ⊥.
Correctness
The correctness of IBKEM scheme requires that for all λ N , and all identities id in the identity space, it holds that
Pr Decap ( MPK , CT , SK id ) = K ( MPK , MSK ) Setup ( λ ) SK id Extract ( MPK , MSK , id ) ( CT , K ) Encap ( MPK , id ) = 1 .
Security models of IBKEM
We define the selective-identity chosen-ciphertext (IND-sID-CCA2) security of an IBKEM scheme through an interactive game between a challenger C and an adversary A :
  • Setup: The challenger C executes Setup ( λ ) to produce a master key pair ( MPK , MSK ) . It provides MPK to the adversary while keeping MSK secret.
  • Initial:  A declares a target identity id * .
  • Phase 1: The adversary A may issue a polynomial number of queries to two oracles, in any sequence:
    O Extract : On input of an identity id id * , it outputs the corresponding private key SK id .
    O Decap : Given an identity id and a ciphertext CT , it returns the session key K Decap ( MPK , CT , SK id ) using the secret key SK id associated with the identity id .
  • Challenge: The challenger C computes ( CT * , K 1 * ) Encap ( MPK , id * ) and chooses a random session key K 0 * in the key space. Then C selects a bit b { 0 , 1 } randomly and sends the pair ( CT * , K b * ) to A .
  • Phase 2:  A continues to query both oracles under the restrictions that
    The challenge identity id * is never used in O Extract .
    The pair ( id * , CT * ) cannot be submitted to O Decap .
    All other queries are answered as in Phase 1.
  • Guess: Finally, A outputs a bit b { 0 , 1 } . It wins if b = b .
The advantage of A is defined as
Adv A , Π IND sID CCA 2 : = Pr [ b = b ] 1 2 .
A scheme is IND-sID-CCA2 secure when this advantage is negligible for every probabilistic polynomial-time adversary.

2.3. Lattices

Lattices can be viewed as discrete subgroups of Z m . Let B = { b 1 , , b n } be a set of linearly independent vectors in Z m . The lattice generated by B is defined as
Λ : = i = 1 n c i b i | c i Z , i = 1 , , n .
Here, Λ is of rank n and the matrix B serves as a basis of Λ . When n = m , the lattice is said to have full-rank.
In this work we focus primarily on q-ary lattices, a family of full-rank lattices that contain q Z m . For a matrix M Z n × m and u Z q n , we define
Λ q ( M ) : = u Z m | v Z q n , M T v = u mod q Λ q ( M ) : = v Z m | M v = 0 mod q
and the translation of Λ q ( M ) of the form
Λ q u ( M ) : = v Z m | M v = u mod q .
For a vector family B = { v 1 , , v k } R m , we write B : = max 1 i k v i for the length of its longest generator. If B is linearly independent, its Gram–Schmidt orthogonalization B ˜ = { v ˜ 1 , , v ˜ k } is obtained by processing the vectors in order, and B ˜ denotes the Gram–Schmidt norm of B .
For any matrix M Z n × m , there exists a singular value decomposition M = U D V T , where U R n × n , V R m × m are orthogonal matrices, and D R n × m is a rectangular diagonal matrix with non-negative diagonal entries s i , arranged in non-increasing order. Such diagonal entries are uniquely determined by M and are called the singular values of M , denoted s i ( M ) . They satisfy s 1 ( M ) M and s 1 ( M ) M T .
A matrix M in Z m × m is said to be Z q -invertible when its reduction modulo q is invertible as an element of Z q m × m .
Gaussian distribution. 
We now recall the definition of the discrete Gaussian distribution, which plays a central role in our construction.
Definition 3.
Let  L Z m  be a lattice. For a center vector  c R m  and a positive parameter  σ R , we define the following:
ρ σ , c ( x ) = exp π x c 2 σ 2 and ρ σ , c ( L ) = x L ρ σ , c ( x ) .
The discrete Gaussian distribution over  L  with center  c  and parameter σ is
y L , D L , σ , c ( y ) = ρ σ , c ( y ) ρ σ , c ( L ) .
For simplicity, we often omit the center when it is the origin and write ρ σ and D L , σ in place of ρ σ , 0 and D L , σ , 0 , respectively. When the parameter takes the value σ = 1 , we denote the function simply as ρ (i.e., ρ 1 ).
We will utilize the following well-known results on lattices in [18].
Lemma 1.
For  x D Λ q u ( A ) , σ , Pr [ x > σ m ] negl ( n ) .
Lemma 2.
Let q be a prime and  m , n  be positive integers satisfying  m 2 n log q . For all but at most  q n  fraction of matrices  A Z n × m , the shortest vector in the lattice  Λ q ( A )  has a length of at least  q / 4 .
Lemma 3.
Let q be a prime and  m , n > 0  with  m 2 n log q . Except for at most a  2 q n  fraction of matrices  A Z n × m  and for every  σ ω ( log m ) , the distribution of vector  { A r Z q n | r D Z , σ m }  is statistically indistinguishable from the uniform distribution over  Z q n . Moreover, for any fixed u Z q n , the conditional distribution of  r , given that  A r = u , follows the discrete Gaussian D Λ q u ( A ) , σ .
This lemma is used in our proof to justify correctness and to analyze the session-key distribution within the key space K .
Lemma 4.
Let q be prime and m , n > 0  such that  m 2 n log q . Let  U Z q n × m  and draw  e D Z , σ m  for some  σ ω ( log m ) . For a binary vector  k { 0 , 1 } n , the distribution of  K = U e + k Z q n  is statistically close to the uniform distribution over  Z q n .
Lattice trapdoors. 
In our construction, (master) secret keys are G-trapdoors, as introduced in [7]. Below, we revisit this definition along with some useful algorithms from [7].
Definition 4.
( G -trapdoor) Let n be a positive integer, q 2  a prime and set , m n log q . Let F Z q n × m  and G Z q n × m  be public matrices, and let H Z q n × n  be invertible. A matrix R Z ( m m ) × m  is called a G -trapdoor for F  with tag H  if F R I m = H G mod q .
In [7], G refers to the gadget matrix I n g T Z q n × n k where k = log q and g T = ( 1 , 2 , 4 , , 2 k 1 ) . The lattice Λ q ( G ) has a publicly known short basis T G Z m × m satisfying T ˜ G 5 and T G max ( 5 , k ) . The same work also provides an algorithm for generating a pseudorandom matrix F Z q n × ( m ¯ + m ) together with a “strong” G -trapdoor for Λ q ( F ) whenever m ¯ n log q :
  • Sample A Z q n × m ¯ and R ( D Z m ¯ , σ R ) m for an invertible H Z q n × n .
  • Output F = [ A | A R + H G ] together with trapdoor R .
The matrix R ( D Z m ¯ , σ R ) m serves as a low-norm basis for Λ q ( F ) and, thus, forms a valid trapdoor. Its quality is determined by its largest singular value, which satisfies s 1 ( R ) = σ . O ( m ¯ + m ) except with negligible probability. The resulting matrix F = [ A | A R + H G ] is nearly uniform.
To extend this construction, we follow [7] (Theorem 5.1) by introducing G ¯ = [ G | O ] as an augmented gadget matrix and treat the corresponding trapdoor R ¯ analogously.
Lemma 5.
Let  n 1 , m ¯ n log q , q 2 , m n log q . Let  G ¯  be the  n × m  matrix obtained by adding  m n log q  zero columns to the right of the gadget matrix  G . Let  A Z q n × m ¯ , R ( D Z m ¯ , σ R ) m , and  H Z q n × n  be an invertible matrix. Set  F = [ A | A R + H G ¯ ] . Then
  • F  is computationally indistinguishable from uniform.
  • For any  b T = s T F + e T  with  s Z q n , e T = [ e 0 T | e 1 T ] Z m ¯ + m  with  e 1 T e 0 T R < q / 4 , there exists an algorithm  Invert ( R , F , b )  that, with overwhelming probability, recovers  s  and  e 0 , e 1 .
The next lemma (adapted from SampleRight of Agrawal et al. [8]) will later be employed for correctness analysis in our construction.
Lemma 6.
Let  n 1 , m ¯ n log q , q > 2 , m n log q . Let  G ¯  be the  n × m  matrix obtained by adding  m n log q  zero columns to the right of the gadget matrix  G . Let  A Z q n × m ¯ , R ( D Z m ¯ , σ R ) m , and  H Z q n × n  be invertible. Define  F = [ A | A R + H G ¯ ] . If the parameter s satisfies  s 5 · s 1 ( R ) · ω ( log m ) , then there exists a PPT algorithm  SamplePre ( R , F , H , U , s )  that outputs a matrix  T Z ( m ¯ + m ) × m  whose distribution is statistically close to  D Λ q U ( F ) , s . In particular, it holds that  F T = U .

Hardness Assumptions

Definition 5
(Short Integer Solution—SIS Problem). Let λ be the security parameter, n = n ( λ ) , m = m ( λ ) , q = q ( λ )  be positive and a real  β = β ( λ ) > 0 . Given a uniformly random matrix  A Z q n × m , the  SIS n , m , q , β  problem asks for a non-zero integer vector  e Z m  of small norm  e β  such that  A e = 0 mod q .
For an algorithm  A solving SIS n , m , q , β , its success probability is written as Adv A S I S n , m , q , β ( λ ) . The SIS n , m , q , β  assumption holds if, for every PPT algorithm A , this advantage is negligible in λ.
Definition 6
(Learning With Errors - LWE problem). Let q be prime, n > 0  be an integer, and χ be a distribution over  Z q . An instance of the ( Z q , n , χ ) - LWE  problem provides oracle access to samples drawn either from:
O s :
Returns pairs  ( a i , b i ) = ( a i , s T a i + e i ) Z q n × Z q , where  a i  is uniformly sampled from  Z q n  and  e i Z q  is a noise withdrawn from χ.
O $ :
Returns uniformly random pairs in  Z q n × Z q .
The goal of an adversary  A  is to distinguish which oracle it is interacting with. Its advantage is defined as
Adv A LWE : = Pr [ A O s = 1 ] Pr [ A O $ = 1 ] .
The LWE assumption asserts that this advantage is negligible for all efficient  A .
Hardness reductions show that LWE is at least as difficult as approximating certain worst-case lattice problems to within polynomial factors when χ D Z , α and α ( 0 , 1 ) , α q > n in [19].
Theorem 1
(Genise et al. [20]). Let  A Z q n × m  be primitive, s Z n , e Z m , and set b T = s T A + e T . For r , r ¯ > 0  and for some negligible ϵ such that η ϵ ( Λ q ( A ) ) ( ( 1 / r ) 2 + ( e / r ¯ ) 2 ) 1 / 2 r , the pair
( a = A r , b = b T r + e ¯ )
where r D Z , r m , e ¯ D Z , r ˜  is within negligible statistical distance of an ( Z q , n , D Z , t ) - LWE  instance where t 2 = ( r e ) 2 + r ¯ 2 .
The security of our schemes relies upon the so-called the Normal form LWE with an SIS hint (SISnLWE) problem, introduced by Boyen et al. [1].
Definition 7
(Normal-form LWE with an SIS hint—SISnLWE problem). Let λ be the security parameter and define n = n ( λ ) , q = q ( λ ) , m = O ( n log q ) . Let X  be a distribution over Z q . The SISnLWE n , m , q , X  problem is a distinguishing task formulated as follows: given the tuple
( A , b T , z , Z ) ,
where A Z q n × m , b Z q m , Z Z q n × m , z = Z e mod q , and e X m , decide whether b T = s T A + e T mod q  for some s X n  or whether b Z q n  is drawn uniformly random from Z q n .
For an adversary  A  attempting to solve the  SISnLWE n , m , q , X  problem, its distinguishing advantage is denoted by  Adv A SISnLWE n , m , q , X ( λ ) .
Boyen et al. [1] established that SISnLWE n , m , q , X is computationally as hard as the standard LWE n , m , q , X problem whenever m = O ( n log q ) .
In the security analysis of our IBKEM construction, we rely on a computational version of this assumption, given below.
Definition 8
(Computational SISnLWE problem). Let λ be the security parameter and set n = n ( λ ) , q = q ( λ ) , m = m ( λ ) = O ( n log q ) , and let X  be a noise distribution over Z q . The SISnLWE n , m , q , X  problem provides the adversary with the challenge tuple
( A , b T , z , Z )
where A Z q n × m , Z Z q n × m , z = Z e mod q , e X m and b T = s T A + e T ( mod q ) Z q m , s X n . The objective is to recover s .
The following lemma will later be used to bound statistical distance terms in our KEM security proof.
Lemma 7
([21]). Let X 1 , X 2 , B  be events in a common probability space such that X 1 ¬ B  is equivalent to X 2 ¬ B . Then, | Pr [ X 1 ] Pr [ X 2 ] | Pr [ B ] .

3. CCA2-Secure KEM in the Standard Model

In this section, we revisit the CCA2-secure KEM of Boyen et al. [1] and provide a slight modification with the complete security proof with a change in setting for parameters.

3.1. Parameters

Our KEM scheme involves several parameters, defined as follows.
  • Let λ be the security parameter and suppose that all parameters are functions of λ .
  • Let q = q ( λ ) denote a large prime modulus, and let n = n ( λ ) represent the number of rows in the public matrix.
  • Following [1], the secret key R is an m × ( n log q ) matrix. To ensure correctness, their work requires that m 2 n log q . However, in their security proof, the simulator needs to sample a trapdoor R such that R T has a left inverse modulo q. This requires m 2 n log q , which is not noticed in [1]. Therefore, in our scheme, we set m = 2 n log q and let R be a square matrix of size m.
  • α is an error rate with the requirement that 1 / α = 7 · m 3 / 2 · ω ( log m ) is sufficiently large.
  • Set σ = α q m · ω ( log m ) to be a Gaussian parameter.
  • Let G ¯ be the n × m matrix obtained by adding m n log q zero columns to the right of the gadget matrix G .
  • We use the SISnLWE n , m , q , D Z , α q problem where we denote by D Z , α q the discrete Gaussian distribution parameterized by α q .
  • D m × m is a conditional distribution over Z m × m , defined as ( D Z m , σ R ) m , such that the resulting matrices are Z q -invertible with σ R = n log q · ω ( log m ) .
We also recall the following useful encoding techniques which are essential for both of the KEM and IBKEM constructions:
  • FRD : Z q n Z q n × n is a full-rank difference encoding (FRD) introduced in [8] such that every image is an invertible matrix and so is FRD ( u ) FRD ( v ) Z q n × n for all distinct u , v Z q n .
  • H : { 0 , 1 } * Z q n is a hash function that is second-pre-image resistant. Without loss of generality, we assume that an efficiently computable injective encoding exists so that each hash output can be represented as an element of Z q n .

3.2. Construction

This section presents our Key Encapsulation Mechanism (KEM). It uses the parameters q , n , m , α , σ , as described in Section 3.1, and consists of the following three algorithms.
Setup( λ ).
Given a security parameter λ , the algorithm proceeds as follows.
  • Choose a second-pre-image resistant hash function H : { 0 , 1 } * Z q n .
  • Generate a random matrix A Z q n × m and a trapdoor matrix R D m × m .
  • Define A 1 A R .
  • Sample another uniform matrix U Z q n × m .
  • Output
    PK = ( A , A 1 , U ) , SK = R .
Encap( PK ).
On inputting the pubic key PK , the encapsulation algorithm works as follows:
  • Draw a random key seed k { 0 , 1 } n .
  • Sample noise vectors e 0 D Z , α q m , e 1 D Z , σ m .
  • Set s k q 2 + s ¯ where s ¯ D Z , α q n .
  • Compute c 0 T s T A + e 0 T .
  • Compute c 2 U e 1 and t = H ( c 0 , c 2 ) .
  • Compute c 1 T = s T ( A 1 + FRD ( t ) G ¯ ) + e 1 T .
    (To reduce the ciphertext size, we can set t = H ( c 0 , c 2 ) { 0 , 1 } λ and then encode it as an element in Z q n prior to being input to FRD ( · ) ).
  • Return the ciphertext CT = ( c 0 , c 1 , t ) and the session key K = c 2 + k .
Decap( PK , CT , SK ).
Given the public key PK , a ciphertext CT , and the secret key SK , the decapsulation procedure proceeds as follows:
  • Parse CT = ( c 0 , c 1 , t ) ; if the format is invalid, output ⊥.
  • Form F = [ A | A 1 + FRD ( t ) G ¯ ] , then recover s , e 0 , e 1 using Invert ( R , F , [ c 0 T | c 1 T ] ) .
  • If either e 0 > α q m or e 1 > α q m 3 / 2 · ω ( log m ) , reject and output ⊥.
  • Compute H ( c 0 , U e 1 ) ; if the result differs from t , output ⊥.
  • For each coordinate s [ i ] , determine the corresponding bit k [ i ] 0 if s [ i ] is closer to 0 or k [ i ] 1 if s [ i ] is closer to q 2 .
  • If s k α q n output K = c 2 + k ; otherwise, output ⊥.

3.3. Correctness

We follow the work of Boyen [1] to prove the correctness of the KEM scheme. During the decapsulation process, the algorithm Invert ( R , F , [ c 0 T | c 1 T ] ) must successfully output s with overwhelming probability. According to Lemma 1, we obtain e 0 α q m , e 1 σ m , R σ R m = 1 2 m · ω ( log m ) with overwhelming probability. By Lemma 5, we obtain
e 1 T e 0 T R e 1 T e 0 T R e 1 T + e 0 T ˙ R σ m + ( α q m ) 1 2 m · ω ( log m ) α q · m 3 / 2 · ω ( log m ) + 1 2 α q · m 3 / 2 · ω ( log m ) ( 1 + 1 2 ) α q · m 3 / 2 · ω ( log m )
Therefore, for a large enough 1 / α = 7 · m 3 / 2 · ω ( log m ) , we have e 1 T e 0 T R q 4 , and the algorithm Invert ( R , F , [ c 0 T | c 1 T ] ) correctly returns e 0 , e 1 , s . Finally, as s ¯ D Z , α q n , we have s ¯ q 4 , which means, for each i { 1 , , n } , | s ¯ [ i ] | q 4 , that the Decap algorithm can output k from s = k q 2 + s ¯ in step (5) and return the session key K = c 2 + k with overwhelming probability.

3.4. Security Analysis

We now establish that our proposed KEM construction attains IND-CCA2 security under standard lattice assumptions.
Theorem 2.
Let  Π : = ( Setup , Encap , Decap )  denote our KEM with parameters  ( q , n , m , α , σ ) . Assume that  H  is a second-pre-image collision resistant hash function and  SIS n , q , β , SVP n , m , q , τ , SISnLWE n , m , q , D Z , α q  problems are computationally hard. Then, for any probabilistic polynomial-time adversary  A  that can win the IND-CCA2 experiment with advantage ϵ, there exist algorithms  B 1 , B 2 , B 3 , and  B 4  such that
Adv A , Π IND CCA 2 Adv B 2 SIS n , q , β ( λ ) + Adv B 3 SISnLWE n , m , q , D Z , α q ( λ ) + negl ( λ ) .
Proof. 
To argue the theorem, we employ a standard game-hopping technique. Starting from the original IND-CCA2 experiment (Game 0), we progressively transform the challenger’s behavior while ensuring that the adversary’s distinguishing advantage changes only negligibly between consecutive games. Let S i denote the event that the adversary A win Game i. □
Game 0.
This initial game matches the standard selective IND-CCA2 experiment between adversary A and challenger B . The challenger runs KeyGen( λ ) to obtain a public/secret key pair ( PK = ( A , A 1 , U ) , SK ) , and forward PK to A . It chooses uniformly random k 1 , s ¯ { 0 , 1 } n and sets s * k 1 q 2 + s ¯ . B computes the challenge ciphertext CT * = ( c 0 * , c 1 * , t * ) :
c 0 * T = s * T A + e 0 * T , c 1 * T = s * T ( A 1 + FRD ( t * ) G ¯ ) + e 1 * T , t * = H ( c 0 * , c 2 * )
where c 2 * = U e 1 * , together with a valid session key K 1 * = c 2 + k 1 and a random session key K 0 * . A random bit b { 0 , 1 } n is selected and ( CT * , K b * ) is sent to A . The challenger B subsequently answers the decapsulation queries by invoking the genuine decapsulation procedure. The adversary A outputs a bit b and wins the game if b = b . This completes the description of Game 0, which coincides with the real IND-CCA2 attack experiment:
Adv A , Π IND CCA 2 = Pr [ S 0 ] 1 2 = Pr [ b = b ] 1 2 .
Game 1.
Let E 1 denote the event that the adversary A asks the decapsulation oracle O Decap to decap CT = ( c 0 , c 1 , t ) with c 0 = c 0 * , c 1 = c 1 * . Game 1 is the same as Game 0 unless the decapsulation oracle O Decap rejects if the event E 1 happens.
Assume that event E 1 happens, then the corresponding errors e 0 , e 1 in the valid ciphertext CT must satisfy e 0 = e 0 * , e 1 = e 1 * w.h.p., and thus t = H ( c 0 , U e 1 ) = H ( c 0 * , U e 1 * ) = t * w.h.p. However, as CT CT * and c 0 = c 0 * , c 1 = c 1 * , one has t t * . This implies that the probability that E 1 happens is negligible, i.e., Pr [ E 1 ] negl ( λ ) . We note that Game 0 is similar to Game 1 except that E 1 happens. This implies that Game 0 and Game 1 differ in the adversary’s view only up to a negligible distance.
| Pr [ S 1 ] Pr [ S 0 ] | Pr [ E 1 ] negl ( λ ) .
Game 2.
Game 2 is the same as Game 1 except in the case that O Decap does not accept CT = ( c 0 , c 1 , t ) with t = t * .
Denote by E 2 the event that A outputs CT = ( c 0 , c 1 , t ) where t = t * . Assume that E 2 happens. Then, we have H ( c 0 , c 2 ) = H ( c 0 * , c 2 * ) . As H is collision resistant under pre-image ( c 0 * , c 2 * ) , we obtain c 0 = c 0 * and c 2 = c 2 * w.h.p. As CT is valid, CT CT * , and t = t * , we deduce that c 1 c 1 * w.h.p.
Assume that the decapsulation query is a valid ciphertext CT = ( c 0 , c 1 , t * ) where c 0 T = s T A + e 0 T = c 0 * T , c 1 T = s T ( A 1 + FRD ( t * ) G ¯ ) + e 1 T c 1 * T with the corresponding errors e 0 , e 1 . Then, challenger B can use its trapdoor and run a decapsulation algorithm to recover e 0 , e 1 , s .
  • Consider the case that e 1 e 1 * . As c 2 = c 2 * , we have U e 1 = U e 1 * . Then, challenger B is able to find e = e 1 e 1 * 0 as a solution for the SIS problem. Therefore, such a case happens with negligible probability. One has
    e e 1 e 1 * 2 σ m 2 α q m · ω ( log m ) · m 2 m 3 / 2 α q · ω ( log m ) = β .
  • If e 1 = e 1 * , then, as c 1 c 1 * , we have s s * . As c 0 = c 0 * , we have c 0 T = s T A + e 0 T = c 0 * T . This implies that ( s s * ) T A = ( e 0 * e 0 ) T . By Lemma 5.3 in [18], it happens with negligible probability.
In short, as Game 2 is the same as Game 1 except in the case that E 2 happens, we have
| Pr [ S 2 ] Pr [ S 1 ] | Pr [ E 2 ] Adv B 2 SIS n , q , β ( λ ) + negl ( λ ) .
Game 3.
Game 3 is similar to Game 2 except that we modify the way that the public parameters PK are generated and the way the challenge ciphertext CT * is constructed, as follows:
  • Select H : { 0 , 1 } * Z q n to be a hash function.
  • Sample A Z q n × m and Z Z q n × m .
  • Sample R T D m × m of rank m. Find ( R T ) 1 Z m × m such that ( R T ) 1 R T = I m . According to the definition of the distribution D m × m , sampling such matrix R is successful with a high probability.
  • Choose U Z ( R T ) 1 .
  • Choose e 0 * D Z , α q m , v D Z , σ / 2 m and set e 1 * T e 0 * T R + v T .
  • Compute c 2 * Z e 0 * + U v = U e 1 * .
  • Choose k 1 { 0 , 1 } n , s ¯ D Z , α q n and set s * k 1 q 2 + s ¯ .
  • Compute c 0 * T s * T A + e 0 * T , t * = H ( c 0 * , c 2 * ) and c 1 * T c 0 * T R + v T .
  • Set A 1 A R FRD ( t * ) G ¯ .
  • Set the public key PK = ( A , A 1 , U ) , secret key SK = R , challenge ciphertext CT * = ( c 0 * , c 1 * , t * ) , and the valid session key K 1 * = c 2 * + k 1 * .
Challenger B sends A PK , H , and CT * together with the session key K b * .
Here, to respond to the decapsulation queries, the challenger in Game 3 computes
F = [ A | A R + ( FRD ( t ) FRD ( t * ) ) G ¯ ] .
Note that O Decap rejects any CT = ( c 0 , c 1 , t ) if t = t * . If t t * , then FRD ( t ) FRD ( t * ) is an invertible matrix so R is still a G -trapdoor for F , which enables the decapsulation oracle to provide answers to queries.
Note that A and H are correctly distributed as in the previous game. As R T D m × m , by Lemma 3, in A ’s view, A 1 = A R FRD ( t * ) G ¯ in Game 3 and A 1 in Game 2 are statistically close as well as statistically close to uniform over Z q n × m . In addition, Z is sampled uniformly at random in Z q n × m , and we obtain that U = Z ( R T ) 1 is uniformly random in Z q n × m as in Game 2. Thus, the public parameters in Game 3 and Game 2 are indistinguishable.
In this game, c 0 * = s * T A + e 0 * T is correctly distributed. Moreover, according to Theorem 1,  e 1 * T = e 0 * T R + v T is statistically close to D Z , σ m where σ . c 1 * defined in step (8) above also satisfies
c 1 * T = c 0 * T R + v T = ( s * T A + e 0 * T ) R + v T = s * T A R + e 0 * T R + v T = s * T ( A 1 + FRD ( t * ) G ¯ ) + e 1 * T .
Moreover, we have
t * = H ( c 0 * , Z e 0 * + U v ) = H ( c 0 * , U R T e 0 * + U v ) = H ( c 0 * , U e 1 * ) .
Therefore, CT * = ( c 0 * , c 1 * , t * ) in Game 3 is correctly distributed as in the previous game.
Hence, in A ’s view, Game 3 and Game 2 are indistinguishable.
| Pr [ S 3 ] Pr [ S 2 ] | negl ( λ ) .
Game 4.
Game 4 is similar to Game 3 unless both session key K 0 * and K 1 * are sampled uniformly at random. In this case, A does not have any advantage, i.e.,
Pr [ S 4 ] = 1 2 .
We need to show that distinguishing between Game 4 and Game 3 is reduced to solving the SISnLWE n , m , q , D Z , α q problem.
Suppose A can distinguish between Games 4 and Game 3 with non-negligible probability. We will construct an algorithm B to solve the SISnLWE problem.
Recall from Definition 8 that an SISnLWE problem instance provides its challenge ( A , b T , z = Z e 0 mod q , Z ) where A Z q n × m , b Z q m , Z Z q n × m and e 0 D Z , α q m and asks if there is a vector s ¯ D Z , α q n such that b T = s ¯ T A + e 0 T or if b Z q n is random. The challenger B utilizes A and proceeds as follows:
  • Select a hash function H : { 0 , 1 } * Z q n .
  • Set A Z q n × m from the SISnLWE challenge.
  • Sample R D m × m and find ( R T ) 1 Z m × m such that ( R T ) 1 R T = I m .
  • Set U Z ( R T ) 1 so that Z = U R T .
  • Sample v D Z , σ / 2 m .
  • Set c 2 * z + U v with z Z q n from the challenge.
  • Select k 0 , k 1 { 0 , 1 } n and set c 0 * T k 1 q 2 T A + b T .
  • Define t * = H ( c 0 * , c 2 * ) and c 1 * T c 0 * T R + v T .
  • Set A 1 A R FRD ( t * ) G ¯ .
  • Set PK = ( A , A 1 , U , H ) , SK = R , CT * = ( c 0 * , c 1 * , t * ) . Set K 1 * = c 2 * + k 1 and choose a random session key K 0 * in the key space.
  • Return MPK , CT * , and K b * with b { 0 , 1 } and keep MSK secret.
  • The challenger B answer O Extract and O Decap as in the previous game.
When the SISnLWE oracle is pseudorandom, meaning that b T = s ¯ T A + e 0 T , we have
c 0 * T = k 1 q 2 T A + b T = s * T A + e 0 T c 1 * T = c 0 * T R + v T = s * T A R + e 0 T R + v T = s * T ( A 1 + FRD ( t * ) G ¯ ) + e 1 * T
and
t * = H ( c 0 * , z + U v ) = H ( c 0 * , Z e 0 + U v ) = H ( c 0 * , U e 1 * ) .
where s * = k 1 q 2 + s ¯ and e 1 * T = e 0 T R + v T . Therefore, CT * is distributed exactly as in Game 3.
When the SISnLWE oracle is random, we have that b is uniform in Z q n . Thus, c 0 * in step (7) and c 2 in step (6) above are uniform in Z q n . In particular, the challenge session keys K 0 * , K 1 * are uniform and do not depend on CT * as in Game 4. Hence, B ’s advantage in solving the SISnLWE problem is the same as A ’s advantage in distinguishing Game 3 and Game 4, i.e.,
| Pr [ S 4 ] Pr [ S 3 ] | Adv B 4 SISnLWE n , m , q , D Z , α q ( λ ) + negl ( λ ) .
From the above, one has
Adv A , Π IND CCA 2 Adv B 2 SIS n , q , β ( λ ) + Adv B 3 SISnLWE n , m , q , D Z , α q ( λ ) + negl ( λ ) .
This completes the proof.

4. CCA2-Secure IBKEM in the Standard Model

This section introduces an IBKEM scheme obtained from our KEM scheme, and provides its IND-sID-CCA2 security proof in the standard model. We have to deal with more cases than in KEM’s security proof because of the appearance of identities in the queries of the adversary.

4.1. Parameters

The IBKEM involves several parameters, which are functions of the security parameter λ .
  • Let q = q ( λ ) be prime, n = n ( λ ) Z be positive, and set m = 2 n log q .
  • Let G Z q n × n log q be the gadget matrix and G ¯ be the n × m matrix obtained by adding m n log q zero columns to the right of G .
  • α is an error rate for LWE such that 1 / α = ω ( m 3 · ( log m ) 3 / 2 ) .
  • We use the SISnLWE n , m , q , D Z , α q problem.
  • D m × m is a distribution on Z m × m defined as ( D Z m , σ R ) m conditioned on the resulting matrix being Z q -invertible where σ R = n log q · ω ( log m ) .
  • σ = α q m · ω ( log m ) is a Gaussian parameter.
  • s = 5 · σ R · O ( m ) · ω ( log 2 m ) .

4.2. Construction

This section describes the proposed IBKEM with parameters q , n , m , ω , α , σ , s specified as in Section 4.1. Our IBKEM construction is as follows:
Setup( λ ).
On input security parameter λ , it proceeds as follows:
  • Choose a second-pre-image collision resistant hash function H : { 0 , 1 } * Z q n .
  • Select uniformly random matrices A Z q n × m and R D m × m .
  • Set A 1 A R Z q n × m .
  • Sample uniformly random matrices C Z q n × m , U Z q n × 2 m .
  • Return the master key pair
    ( MPK = ( A , A 1 , C , U , H ) , MSK = R ) .
Extract( MPK , MSK , id ).
On inputting the master pubic key MPK , the master secret key MSK , and an identity id Z q n × m , the algorithm proceeds as follows:
  • Compute F id = [ A | A 1 + FRD ( id ) G ¯ ] Z q n × 2 m .
  • Sample T id SamplePre ( R , F id , FRD ( id ) , C , s ) Z q 2 m × m s.t. F id T id = C .
  • Return secret key SK id = T id .
Encap( MPK , id ).
On inputting the master pubic key MPK and an identity id , the algorithm proceeds as follows:
  • Sample k { 0 , 1 } n .
  • Sample noise vectors e 0 D Z , α q m , e 1 D Z , σ 2 m .
  • Set s k q 2 + s ¯ where s ¯ D Z , α q n .
  • Compute c 0 T s T A + e 0 T Z q m .
  • Compute c 2 U e 1 Z q n and t = H ( c 0 , c 2 ) .
  • Compute c 1 T = s T [ A 1 + FRD ( id ) G ¯ | C + FRD ( t ) G ¯ ] + e 1 T Z q 2 m .
  • Return CT = ( c 0 , c 1 , t ) and the session key K = c 2 + k .
Decap( MPK , CT , SK id ).
On inputting MPK , it uses SK id to decap CT as follows:
  • Parse CT = ( c 0 , c 1 , t ) ; output ⊥ if CT does not parse.
  • Set F id = [ F id | C + FRD ( t ) G ¯ ] = [ A | A 1 + FRD ( id ) G ¯ | C + FRD ( t ) G ¯ ] Z q n × 3 m and recover s , e 0 , e 1 via Invert ( T id , F id , [ c 0 T | c 1 T ] ) .
  • If e 0 > α q m or e 1 > σ 2 m , output ⊥.
  • If H ( c 0 , U e 1 ) t , output ⊥.
  • Set k [ i ] 0 if the i-th coordinate s [ i ] of s is closer to 0 or k [ i ] 1 if s [ i ] is closer to q 2 .
  • If s k α q n then return the session key K = U e 1 + k ; otherwise, return ⊥.

4.3. Correctness

Following the procedure of the scheme described above, during decryption of CT encapsulated a session key K for an identity id , we have that the algorithm Invert ( T id , F id , [ c 0 T | c 1 T ] ) will recover s , e 0 , e 1 with overwhelming probability. As e 0 D Z , α q m , e 1 D Z , σ 2 m , where σ = α q m · ω ( log m ) and T id has the distribution D Z , s 2 m × m , according to Lemma 1, we have e 0 α q m , e 1 σ 2 m , T id s 2 m except with a negligible probability. Let e 1 = [ e 1 , 1 | e 1 , 2 ] , and by Lemma 5, we obtain
e 1 , 2 T ( [ e 0 T | e 1 , 1 T ] ) T id e 1 , 2 T ( [ e 0 T | e 1 , 1 T ] ) T id e 1 , 2 T + ( e 1 , 1 T + e 0 T ) T id σ m + ( σ m + α q m ) · s 2 m · α q · ω ( m 3 ( log m ) 3 / 2 ) .
Therefore, for a large enough 1 / α = 4 ω ( m 3 · ( log m ) 3 / 2 ) , the algorithm Invert ( T id , F , [ c 0 T | c 1 T ] ) correctly returns e 0 , e 1 , s . Finally, as s ¯ D Z , α q n , we obtain s ¯ q 4 , which means that for each i = 1 , , n , we have | s ¯ [ i ] | < q 4 . Thus, we obtain k from s = k q 2 + s ¯ in step (5) of the Decap algorithm and return K = c 2 + k with overwhelming probability.

4.4. Security Analysis

In this section, we prove that our proposed scheme is IND - sID - CCA 2 secure against an adaptive adversary A (cf. Theorem 3).
Theorem 3.
The IBKEM scheme Π : = ( Setup , Extract , Encap , Decap )  with parameters  ( q , n , m , α , σ , s )  achieves  IND - sID - CCA 2  security with conditions that H is a second-pre-image collision resistant hash function  H and  SIS n , q , β SVP n , m , q , τ , and  SISnLWE n , m , q , D Z , α q  are hard. In particular, if there exists an adversary A  against the IND - sID - CCA 2  game with advantage ϵ, then there are some adversaries  C , B and  B  such that
Adv A , Π IND sID CCA 2 Adv C SIS n , q , β ( λ ) + Adv B SISnLWE n , m , q , D Z , α q ( λ ) + Adv B C SISnLWE n , m , q , D Z , α q + negl ( λ ) .
Proof. 
We will proceed in a sequence of games to prove the security where Game 0 is the original game and A has no advantage in winning the game in the last game. Let S i denote the event that the adversary A wins Game i. □
Game 0.
It is the selectively IND - sID - CCA 2 security game between A and an IND - sID - CCA 2 challenger.
After receiving the challenge identity id * from A , the challenger C operates Setup ( λ ) to generate MPK = ( A , A 1 , C , U , H ) and MSK = R . Then, C sends MPK through to A , keeps MSK secret, chooses uniformly random k 1 { 0 , 1 } n , s ¯ D α q n , and sets s * k 1 q 2 + s ¯ . It then computes the challenge ciphertext CT * = ( c 0 * , c 1 * , t * ) :
c 0 * T = s * T A + e 0 * T , c 1 * T = s * T [ A 1 + FRD ( id * ) G ¯ | C + FRD ( t * ) G ¯ ] + e 1 * T , t * = H ( c 0 * , c 2 * )
where c 2 * = U e 1 * , together with a valid session key K 1 * = c 2 * + k 1 , and samples a random session key K 0 * from the key space K . Finally, C picks a random bit b { 0 , 1 } n and sends the pair ( CT * , K b * ) through to the adversary A .
The challenger C implements the key extraction oracle O Extract and the decapsulation oracle O Decap by following the real algorithms in the construction. The adversary A returns a bit b and wins the game if b = b . By the definition, we have
Adv A , Π IND - sID - CCA 2 = Pr [ S 0 ] 1 2 = Pr [ b = b ] 1 2 .
Game 1.
Game 1 is identical to Game 0 except that the decapsulation oracle O Decap rejects any ciphertext CT = ( c 0 , c 1 , t ) of the challenge identity id * if t = t * .
Let E 1 be the event that the adversary A issues a decap of CT = ( c 0 , c 1 , t ) of id * where t = t * , id = id * .
Assuming that event E 1 happens, we have t = H ( c 0 , c 2 ) = H ( c 0 * , c 2 * ) = t * . Because of the pre-image collision resistance of H, c 0 = c 0 * and c 2 = c 2 * w.h.p. As CT is valid, CT CT * , and t = t * , we obtain c 1 c 1 * w.h.p.
Assume that the decapsulation query is a valid ciphertext CT = ( c 0 , c 1 , t * ) , where c 0 T = s T A + e 0 * T = c 0 * T , c 1 T = s T [ A 1 + FRD ( id * ) G ¯ | C + FRD ( t * ) G ¯ ] + e 1 T c 1 * T with the corresponding errors e 0 , e 1 . Then, the challenger C can use its trapdoor and run a decapsulation algorithm to recover e 0 , e 1 , s .
  • If e 1 e 1 * , then, as c 2 = c 2 * , we must have U e 1 = U e 1 * with overwhelming probability, and e = e 1 e 1 * is actually a solution for the SIS problem. Such a case happens with negligible probability. We have
    e e 1 e 1 * 2 σ 2 m 8 · α q m 3 / 2 · ω ( log m ) = β .
  • If e 1 = e 1 * , then, as c 1 c 1 * , we have s s * . As c 0 = c 0 * , we have c 0 T = s T A + e 0 T = s * T A + e 0 * T = c 0 * T . This implies that ( s s * ) T A = ( e 0 * e 0 ) T . This happens with negligible probability by Lemma 5.3 [22].
In short, as Game 1 is the same as Game 0 unless E 1 happens, then
| Pr [ S 1 ] Pr [ S 0 ] | Pr [ E 1 ] Adv C SIS n , q , β ( λ ) + negl ( λ ) .
Game 2.
Game 2 is similar to Game 1 unless that we modify the way MPK is generated and the way CT * together with the valid session K 1 * are constructed, as follows:
  • Select a hash function H : { 0 , 1 } * Z q n .
  • Sample A Z q n × m and Z Z q n × m .
  • Sample R 1 , R 2 D m × m and set R T = [ R 1 | R 2 ] T Z 2 m × m . Find ( R T ) 1 Z m × 2 m such that ( R T ) 1 R T = I m .
    We can successfully sample such matrix R of rank m with an overwhelming probability.
  • Set U Z ( R T ) 1 Z q n × 2 m .
  • Sample e 0 * D Z , α q m , v D Z , σ / 2 2 m and set e 1 * T e 0 * T R + v T .
  • Compute c 2 * Z e 0 * + U v = U e 1 * .
  • Sample k 1 { 0 , 1 } n , s ¯ D Z , α q n and set s * k 1 q 2 + s ¯ .
  • Compute c 0 * T s * T A + e 0 * T , t * = H ( c 0 * , c 2 * ) , and c 1 * T c 0 * T R + v T .
  • Set A 1 A R 1 FRD ( id * ) G ¯ .
  • Set C A R 2 FRD ( t * ) G ¯ .
  • Set MPK = ( A , A 1 , C , U , H ) , MSK = R 1 , CT * = ( c 0 * , c 1 * , t * ) , and the valid session key K 1 * = c 2 * + k 1 * .
Challenger C sends MPK and CT * together with the session key K b * to A .
  • We do not allow A to query O Extract for id * . To answer the key extraction query for id , the challenger C computes
    F id = [ A | A R 1 + ( FRD ( id ) FRD ( id * ) ) G ¯ ] .
    By the property of FRD , ( FRD ( id ) FRD ( id * ) ) is an invertible matrix in Z q n × n , so C can sample
    SK id = T id SamplePre ( R 1 , F id , FRD ( id ) FRD ( id * ) , C , s ) .
  • Let E 2 be the event that A asks for the decapsulation queries CT = ( c 0 , c 1 , t * ) of identity id id * . Let the game abort when event E 2 happens.
    Note that the case t = t * consists of the case { id = id * , t = t * } and the case { id id * , t = t * } . This means that Game 2 aborts if t = t * .
  • To answer to the decapsulation oracle of a valid CT = ( c 0 , c 1 , t ) of id * with t t * , the challenger C computes
    F id * = [ A | A R 1 | A R 2 + ( FRD ( t ) FRD ( t * ) ) G ¯ ]
    and sets the secret key SK id * = T id * = R 1 + R 2 I ω .
    As t t * , FRD ( t ) FRD ( t * ) is invertible, so the decapsulation oracle is able to respond to valid ciphertext CT = ( c 0 , c 1 , t ) by invoking Invert ( T id * , F id * , [ c 0 T , c 1 T ] ) to recover s , e 0 and e 1 .
Note that A is correctly distributed as in the previous game. As R 1 , R 2 D m × m , by using Lemma 3, in A ’s view, the matrices A 1 = A R FRD ( id * ) G ¯ , C = A R 2 FRD ( t * ) G ¯ in Game 2 and A 1 , C in Game 1 are indistinguishable and statistically close to uniform over Z q n × m . In addition, Z is chosen uniformly at random in Z q n × m , so U = Z ( R T ) 1 is a uniformly random matrix in Z q n × 2 m as in Game 1. Hence, the public parameters in Game 2 and Game 1 are indistinguishable.
In this game, c 0 * = s * T A + e 0 * T is correctly distributed. By Theorem 1, we have that e 1 * T = e 0 * T R + v T is statistically close to D Z , σ 2 m as
( σ R e 0 ) 2 + ( σ / 2 ) 2 σ 2 .
The vector c 1 * defined in step (8) above also satisfies
c 1 * T = c 0 * T R + v T = ( s * T A + e 0 * T ) R + v T = s * T [ A R 1 | A R 2 ] + e 0 * T R + v T = s * T [ A 1 + FRD ( id * ) G ¯ | C + FRD ( t * ) G ¯ ] + e 1 * T .
Moreover, we have
t * = H ( c 0 * , Z e 0 * + U v ) = H ( c 0 * , U R T e 0 * + U v ) = H ( c 0 * , U e 1 * ) .
Therefore, CT * = ( c 0 * , c 1 * , t * ) in Game 2 is correctly distributed as in the previous game.
Hence, in A ’s view, Game 2 and Game 1 are indistinguishable.
| Pr [ S 2 ] Pr [ S 1 ] | Pr [ E 2 ] + negl ( λ )
Game 3.
Game 3 is similar to Game 2 unless K 0 * and K 1 * are uniformly random. We have Pr [ S 3 ] = 1 / 2 .
We now show that Game 3 and Game 2 are computationally indistinguishable by reducing to the SISnLWE n , m , q , D Z , α q problem.
Suppose the adversary A can distinguish Game 3 and Game 2 with non-negligible advantage. We will then build the simulator B that can solve the SISnLWE problem. Recall from Definition 8 that an SISnLWE problem instance provides its challenge ( A , b T , z = Z e 0 mod q , Z ) , where A Z q n × m , b Z q m , Z Z q n × m and e 0 D Z , α q m , and asks if there is a vector s ¯ D Z , α q n such that b T = s ¯ T A + e 0 T or if b Z q n is random. B uses A as follows:
  • Choose a hash function H : { 0 , 1 } * Z q n .
  • Set A Z q n × m from the SISnLWE challenge.
  • Sample R 1 , R 2 D m × m and set R T = [ R 1 | R 2 ] T Z 2 m × m is of rank m. Find ( R T ) 1 Z m × 2 m such that ( R T ) 1 R T = I m .
  • Set U Z ( R T ) 1 Z q n × 2 m .
  • Sample v D Z , σ / 2 2 m .
  • Set c 2 * z + U v where z Z q n is from the SISnLWE challenge.
  • Sample k 1 { 0 , 1 } n and set c 0 * T k 1 q 2 T A + b T .
  • Set t * = H ( c 0 * , c 2 * ) and c 1 * T c 0 * T R + v T .
  • Set A 1 A R 1 FRD ( id * ) G ¯ .
  • Set C A R 2 FRD ( t * ) G ¯ .
  • Set MPK = ( A , A 1 , C , U , H ) , MSK = R 1 , CT * = ( c 0 * , c 1 * , t * ) . Set K 1 * = c 2 * + k 1 and choose K 0 * randomly in the key space.
  • B sends A the triple MPK , CT * and K b * where b { 0 , 1 } and keeps MSK secret.
  • The simulator B answers queries to O Extract and O Decap as in the previous game.
  • When B receives b as a guess for b from A , it outputs b as a solution to the SISnLWE challenge.
We provide the argument that when the SISnLWE oracle is pseudorandom, meaning b T = s ¯ T A + e 0 T , CT * is distributed exactly as in Game 2. Note that
c 0 * T = k 1 q 2 T A + b T = s * T A + e 0 * T c 1 * T = c 0 * T R + v T = s * T [ A R 1 | A R 2 ] + e 0 * T R + v T = s * T [ A 1 + FRD ( id * ) G ¯ | C + FRD ( t * ) G ¯ ] + e 1 * T
and
t * = H ( c 0 * , z + U v ) = H ( c 0 * , Z e 0 + U v ) = H ( c 0 * , U e 1 * ) .
where s * = k 1 q 2 + s ¯ and e 1 * T = e 0 T R + v T .
Moreover, by Lemma 4 any valid K 1 * = c 2 * + k 1 is distributed statistically close to uniform in K .
When the SISnLWE oracle is random, we have that b is uniform in Z q n . Thus, c 0 * defined in step (7) and c 2 in step (6) above are uniform in Z q n . In particular, the challenge session keys K 0 * , K 1 * are uniform and independent of CT * as in Game 3.
We conclude that the advantage of B in solving the SISnLWE problem is the same as the advantage of A in distinguishing Game 2 and Game 3, i.e.,
| Pr [ S 3 ] Pr [ S 2 ] | Adv B SISnLWE n , m , q , D Z , α q ( λ ) + negl ( λ ) .
It remains to be shown that the abort event E 2 = { id id * , t = t * } happens with negligible probability under the hardness assumption of the Computational SISnLWE problem. Indeed, we can construct a simulator B similarly to B where B can solve the Computational SISnLWE problem when adversary A provides B with a valid ciphertext CT = ( c 0 , c 1 , t ) , where t = t * for an identity id id * . Given a Computational SISnLWE instance ( A , b T = s ¯ A + e 0 T , Z , z = Z e 0 ) , B runs as step 1 to step 12 of B . Consider the case where adversary A provides B with a valid ciphertext CT = ( c 0 , c 1 , t = t * ) for an identity id id * . As t = t * , we have H ( c 0 , c 2 ) = H ( c 0 * , c 2 * ) w.h.p, meaning that c 0 = c 0 * and c 2 = c 2 * w.h.p. We must have s = s * , e 0 = e 0 * , e 1 = e 1 * with overwhelming probability where s * = k 1 q 2 + s ¯ and e 1 * T = e 0 T R + v T .
As CT is a valid ciphertext for id id * , we deduce that
c 1 T c 1 * T = s * T [ ( FRD ( id ) FRD ( id * ) ) G ¯ | 0 ] .
Set M = [ ( FRD ( id ) FRD ( id * ) ) G ¯ | 0 ] Z q n × 2 m where 0 Z n × m . As ( FRD ( id ) FRD ( id * ) ) Z q n × n is invertible and G is a gadget matrix, there exists M 1 Z q 2 m × n such that M . M 1 = I n . Therefore, the simulator B is able to find s * by calculating ( c 1 c 1 * ) M 1 and then finding s ¯ , which solves the Computational SISnLWE problem.
We deduce that the probability
Pr [ E 2 ] Adv B C SISnLWE n , m , q , D Z , α q + negl ( λ ) .
Combining all of the inequalities above, we have that
Adv A , Π IND - sID - CCA 2 Adv C SIS n , q , β ( λ ) + Adv B SISnLWE n , m , q , D Z , α q ( λ ) + Adv B C SISnLWE n , m , q , D Z , α q + negl ( λ ) .
This concludes the proof.

5. Conclusions

In this paper, we modified the CCA2-secure KEM by Boyen et al. [1] to obtain an efficient CCA2-secure KEM scheme with a complete security proof. We also introduced a construction of an efficient and simple CCA2-secure IBKEM based on the hardness of Normal-form Learning With Errors with a Shortest Integer Solution hint problem defined by Boyen et al. [1]. Our IBKEM obtained selectively-security only. One can apply Yamada’s technique [13] for adaptive setting but computations on parameters show that it is inefficient. Therefore, it is an interesting challenge to design a comparable efficient CCA2-secure IBKEM with adaptive security.

Author Contributions

Conceptualization, N.A.V.N. and D.H.D.; methodology, N.A.V.N. and D.H.D.; validation, N.A.V.N. and D.H.D.; formal analysis, N.A.V.N., D.H.D., and M.T.T.P.; writing—original draft preparation, N.A.V.N. and M.T.T.P.; writing—review and editing, N.A.V.N., D.H.D., and M.T.T.P.; visualization, N.A.V.N. and M.T.T.P.; supervision, D.H.D.; project administration, N.A.V.N. and D.H.D.; funding acquisition, N.A.V.N. All authors have read and agreed to the published version of the manuscript.

Funding

This research was funded by Vietnam National University HoChiMinh City (VNU-HCM) under grant number DS.C2025-26-20.

Data Availability Statement

No new data were generated or analyzed in support of this research.

Conflicts of Interest

The authors declare no conflicts of interest. The funders had no role in the design of the study; in the collection, analyses, or interpretation of data; in the writing of the manuscript; or in the decision to publish the results.

References

  1. Boyen, X.; Izabachène, M.; Li, Q. A Simple and Efficient CCA-Secure Lattice KEM in the Standard Model. In Proceedings of the 12th International Conference on Security and Cryptography for Networks, SCN 2020, Amalfi, Italy, 14–16 September 2020; Galdi, C., Kolesnikov, V., Eds.; Springer: Cham, Switzerland, 2020; pp. 321–337. [Google Scholar]
  2. Boneh, D.; Canetti, R.; Halevi, S.; Katz, J. Chosen-Ciphertext Security from Identity-Based Encryption. SIAM J. Comput. 2007, 36, 1301–1328. [Google Scholar] [CrossRef]
  3. Peikert, C.; Vaikuntanathan, V.; Waters, B. A Framework for Efficient and Composable Oblivious Transfer. In Proceedings of the 28th Annual International Cryptology Conference, Advances in Cryptology—CRYPTO 2008, Santa Barbara, CA, USA, 17–21 August 2008; Proceedings; Lecture Notes in Computer Science. Wagner, D.A., Ed.; Springer: Berlin/Heidelberg, Germany, 2008; Volume 5157, pp. 554–571. [Google Scholar] [CrossRef]
  4. Boyen, X.; Li, Q. Direct CCA-Secure KEM and Deterministic PKE from Plain LWE. In Proceedings of the 10th International Conference, PQCrypto 2019, Chongqing, China, 8–10 May 2019; Revised Selected Papers; Lecture Notes in Computer Science. Ding, J., Steinwandt, R., Eds.; Springer: Cham, Switzerland, 2019; Volume 11505, pp. 116–130. [Google Scholar] [CrossRef]
  5. Bellare, M.; Kiltz, E.; Peikert, C.; Waters, B. Identity-Based (Lossy) Trapdoor Functions and Applications. In Proceedings of the Advances in Cryptology–EUROCRYPT 2012–31st Annual International Conference on the Theory and Applications of Cryptographic Techniques, Cambridge, UK, 15–19 April 2012; Proceedings; Lecture Notes in Computer Science. Pointcheval, D., Johansson, T., Eds.; Springer: Berlin/Heidelberg, Germany, 2012; Volume 7237, pp. 228–245. [Google Scholar] [CrossRef]
  6. Boyen, X.; Mei, Q.; Waters, B. Direct chosen ciphertext security from identity-based techniques. In Proceedings of the 12th ACM Conference on Computer and Communications Security, CCS 2005, Alexandria, VA, USA, 7–11 November 2005; Atluri, V., Meadows, C.A., Juels, A., Eds.; ACM: New York, NY, USA, 2005; pp. 320–329. [Google Scholar] [CrossRef]
  7. Micciancio, D.; Peikert, C. Trapdoors for lattices: Simpler, tighter, faster, smaller. In Proceedings of the Annual International Conference on the Theory and Applications of Cryptographic Techniques, Cambridge, UK, 15–19 April 2012; Springer: Berlin/Heidelberg, Germany, 2012; pp. 700–718. [Google Scholar]
  8. Agrawal, S.; Boneh, D.; Boyen, X. Efficient lattice (H)IBE in the standard model. In Proceedings of the Annual International Conference on the Theory and Applications of Cryptographic Techniques, French Riviera, France, 30 May–3 June 2010; Springer: Berlin/Heidelberg, Germany, 2010; pp. 553–572. [Google Scholar]
  9. Jager, T.; Kurek, R.; Niehues, D. Efficient Adaptively-Secure IB-KEMs and VRFs via Near-Collision Resistance. In Proceedings of the Public-Key Cryptography–PKC 2021–24th IACR International Conference on Practice and Theory of Public Key Cryptography, Virtual Event, 10–13 May 2021; Proceedings, Part I; Lecture Notes in Computer Science. Garay, J.A., Ed.; Springer: Cham, Switzerland, 2021; Volume 12710, pp. 596–626. [Google Scholar] [CrossRef]
  10. Agrawal, S.; Boneh, D.; Boyen, X. Lattice Basis Delegation in Fixed Dimension and Shorter-Ciphertext Hierarchical IBE. In Proceedings of the Advances in Cryptology–CRYPTO 2010—30th Annual Cryptology Conference, Santa Barbara, CA, USA, 15–19 August 2010; Rabin, T., Ed.; Springer: Berlin/Heidelberg, Germany, 2010; pp. 98–115. [Google Scholar]
  11. Zhang, J.; Yu, Y.; Fan, S.; Zhang, Z. Improved lattice-based CCA2-secure PKE in the standard model. Sci. China Inf. Sci. 2020, 63, 182101. [Google Scholar] [CrossRef]
  12. Cash, D.; Hofheinz, D.; Kiltz, E.; Peikert, C. Bonsai trees, or how to delegate a lattice basis. In Proceedings of the Annual International Conference on the Theory and Applications of Cryptographic Techniques, French Riviera, France, 30 May–3 June 2010; Springer: Berlin/Heidelberg, Germany, 2010; pp. 523–552. [Google Scholar]
  13. Yamada, S. Asymptotically compact adaptively secure lattice IBEs and verifiable random functions via generalized partitioning techniques. In Proceedings of the Annual International Cryptology Conference, 37th Annual International Cryptology Conference, Santa Barbara, CA, USA, 20–24 August 2017; Springer: Cham, Switzerland, 2017; pp. 161–193. [Google Scholar]
  14. Zhang, J.; Chen, Y.; Zhang, Z. Programmable Hash Functions from Lattices: Short Signatures and IBEs with Small Key Sizes. In Proceedings of the Advances in Cryptology–CRYPTO 2016–36th Annual International Cryptology Conference, Santa Barbara, CA, USA, 14–18 August 2016; Proceedings, Part III; Lecture Notes in Computer Science. Robshaw, M., Katz, J., Eds.; Springer: Berlin/Heidelberg, Germany, 2016; Volume 9816, pp. 303–332. [Google Scholar] [CrossRef]
  15. Qiao, Z.; Zhu, Y.; Zhou, Y.; Yang, B. A continuous leakage-resilient CCA secure identity-based key encapsulation mechanism in the standard model. J. Syst. Archit. 2025, 162, 103388. [Google Scholar] [CrossRef]
  16. Li, Y.; Wang, C.; Hu, S. KD-IBMRKE-PPFL: A Privacy-Preserving Federated Learning Framework Integrating Knowledge Distillation and Identity-Based Multi-receiver Key Encapsulation. In Proceedings of the Information Security and Privacy, 30th Australasian Conference, ACISP 2025, Wollongong, NSW, Australia, 14–16 July 2025; Susilo, W., Pieprzyk, J., Eds.; Springer: Singapore, 2025; pp. 105–123. [Google Scholar]
  17. Tomita, T.; Ogata, W.; Kurosawa, K. CCA-Secure Leakage-Resilient Identity-Based Key-Encapsulation from Simple (Not q-type) Assumptions. In Proceedings of the Advances in Information and Computer Security, 14th International Workshop on Security, IWSEC 2019, Tokyo, Japan, 28–30 August 2019; Attrapadung, N., Yagi, T., Eds.; Springer International Publishing: Cham, Switzerland, 2019; pp. 3–22. [Google Scholar]
  18. Gentry, C.; Peikert, C.; Vaikuntanathan, V. How to Use a Short Basis: Trapdoors for Hard Lattices and New Cryptographic Constructions. Electron. Colloq. Comput. Complex. 2008, 14. [Google Scholar]
  19. Regev, O. On lattices, learning with errors, random linear codes, and cryptography. J. ACM 2009, 56, 34. [Google Scholar] [CrossRef]
  20. Genise, N.; Micciancio, D.; Peikert, C.; Walter, M. Improved Discrete Gaussian and Subgaussian Analysis for Lattice Cryptography. In Proceedings of the 23rd IACR International Conference on Practice and Theory of Public-Key Cryptography, Edinburgh, UK, 4–7 May 2020; Lecture Notes in Computer Science. Kiayias, A., Kohlweiss, M., Wallden, P., Zikas, V., Eds.; Springer: Cham, Switzerland, 2020; Volume 12110, pp. 623–651. [Google Scholar]
  21. Shoup, V. Sequences of Games: A Tool for Taming Complexity in Security Proofs. Cryptology ePrint Archive, Report 2004/332. 2004. Available online: https://ia.cr/2004/332 (accessed on 2 December 2025).
  22. Gentry, C.; Peikert, C.; Vaikuntanathan, V. Trapdoors for hard lattices and new cryptographic constructions. In Proceedings of the 40th Annual ACM Symposium on Theory of Computing, Victoria, BC, Canada, 17–20 May 2008; Dwork, C., Ed.; ACM: New York, NY, USA, 2008; pp. 197–206. [Google Scholar]
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Article Metrics

Citations

Article Access Statistics

Multiple requests from the same IP address are counted as one view.