1. Introduction
While the increasingly close possibility of bringing about quantum technology for massive use in the coming years approaches, which will render current public key schemes insecure, the cryptographic community has devoted efforts to design, implement, and deploy quantum-safe public key primitives that replace current public key algorithms. Thus far, many candidates have been proposed via standardization calls for proposals and independent and individual efforts [
1,
2,
3]. Those candidates may roughly be classified into several categories or groups, namely lattice-based schemes, code-based schemes, isogeny schemes, MPC-in-the-Head schemes, multivariate schemes, and symmetric-based schemes [
1,
2,
3].
Nevertheless, recent papers [
4,
5,
6,
7] propose different, promising cryptographic schemes based on group ring generalizations, which seem to be quantum-secure [
8]. The research articles [
5,
6,
7] introduce cryptographic protocols whose security hinges on algebraic problems defined on the structure of a twisted dihedral group algebra, while [
4] presents constructions that are supported on a skew dihedral group ring structure. Specifically, Ref. [
7] proposes a two-cocycle
to form the twisted algebra
for a non-square
in the field
, where
is the dihedral group of order
. More precisely, the two-cocycle
is defined by
for
,
with
and
otherwise. Furthermore, following an incremental-like methodology as employed by us in this paper, the authors of [
7] introduce a key exchange protocol, a probabilistic public key scheme, and a key-encapsulation mechanism over the twisted algebra
. Furthermore, their constructions and their proof-of-concept implementation are enhanced by exploiting the properties of the twisted algebra. On the other hand, Ref. [
4] proposes cryptographic protocols supported on an algebraic structure that is called the skew dihedral group ring. This algebraic platform, denoted by
, is formed of the dihedral group
and the group homomorphism described by
, where
for all
, for
,
, and
otherwise. Furthermore, using an incremental-like methodology, the authors of [
4] similarly propose a key-exchange protocol, a probabilistic public key scheme, and a key-encapsulation mechanism over the skew dihedral group ring
.
Concerning other related works, the research articles [
9,
10] investigate ideals as codes in twisted-skew group rings. In particular, they characterize all linear codes that are twisted-skew group codes in terms of their automorphism group.
Our main contribution is generalizing previous approaches [
4,
5,
6,
7] in the sense that we present a novel algebraic structure, which is a twisted-skew group ring and generalizes those in [
4,
5,
6,
7], and exhibit various cryptographic protocols supported on this structure. This structure features a two-cocycle
and a group homomorphism
. We particularly consider
G to be a finite group of even order and
such that
, i.e.,
, and hence,
with
. For
, the map
as
if
and
and
otherwise is a two-cocycle of the group
G over
. Also, the map
defined by
if
and
otherwise is a group homomorphism. We then define the twisted-skew group ring
, over which we build cryptographic constructions. By closely following an incremental-like methodology as previously used in [
4,
7], we construct a key-agreement protocol and then generalize it to a group key-agreement protocol. We then proceed to build a probabilistic public key encryption from our two-party key agreement and, finally, introduce a key-encapsulation mechanism from a well-known generic construction applied to the probabilistic public encryption. Furthermore, we provide an in-depth security analysis for each cryptographic construction under new related algebraic assumptions and supply a proof-of-concept implementation for various candidate chosen groups.
The outline of the paper is as follows. In
Section 2, we will present background material and formally introduce the twisted-skew group ring over which we will build our cryptographic protocols.
Section 3 will formally introduce our intractability assumptions. In particular, we will formally define attack games for the algebraic problems on which the security of our cryptographic constructions rely.
Section 4 first gives a detailed account of our two-party key-agreement protocol together with its corresponding security analysis and then focuses on its generalization along with the corresponding security analysis.
Section 5 will delineate a probabilistic public key-encryption scheme derived from our two-party key-agreement protocol and the corresponding security analysis.
Section 6 will portray our key-encapsulation mechanism derived from the probabilistic public key-encryption scheme from
Section 5. In
Section 7, we will describe the pseudo-code of our proof-of-concept Python implementation for our cryptographic constructions and conclude this section by hinting at potential applications of our protocols. Finally,
Section 8 will conclude our work and outline future research directions.
2. A Twisted-Skew Group Ring
Let
G be a finite group and
be the finite field of order
and characteristic
p. We denote the automorphism group of
by
, and
always denotes the group of all automorphisms of
that fix
, which is called the Galois group of
over
. A well-known result is that the Galois group
is a cyclic group of order
k and that the Frobenius automorphism
of
over
is a generator, which is defined as
for all
. Moreover, by
and
, we denote the set of group homomorphisms from
G to
and
, respectively. Additionally, the map
is called a two-cocycle of
G if
and
for all
. Let
denote the set of all two-cocycles of
G.
We say that the cocycle
is stabilized by the group
, if
for all
.
For
, we define
as
for all
. With this operation,
becomes a multiplicative Abelian group. If
is a map such that
, the
coboundary defined by
for all
is in
. We denote the set of all coboundaries of
G by
, which forms a subgroup of the group
. Given a two-cocycle
, its coset is denoted by
. Additionally, we call the quotient group
the second cohomology group of
G with values in
.
Definition 1 (See [
10]).
Let G be a finite multiplicative group; let be a two- of G; let be a group homomorphism. The twisted-skew group ring is the set of all formal sums , where , with the following twisted-skew multiplication: In [
10], it is proven that, if the cocycle
is stabilized by
, then
is an associative ring with identity
Note that
is nothing else than the group algebra
, while
is the twisted group algebra
, and
is the skew group ring
(see [
4,
9,
10]). Moreover, by [
10], Lemma 1.5, for
, we have that
and
are isomorphic, if
is a coboundary. In particular,
as
-algebras, if
is a coboundary.
Definition 2 (See [
10]).
For an element , we define its adjunct as In the sequel, we will always consider that G is a finite group of even order and such that , i.e., , and hence, with . Also, we assume the elements of G are ordered according to some fixed order. In particular, and Some possible groups G satisfying the previous conditions are as follows:
Dihedral group: A presentation of the dihedral group
D of order
is given by
where
and
.
Quasidihedral group: A presentation of the quasidihedral group
of order
is given by
where
and
.
Modular maximal-cyclic group: A presentation of the modular maximal-cyclic group
of order
is given by
where
and
.
Generalized quaternion group: A presentation of the generalized quaternion group
of order
is given by
where
and
.
Lemma 1. Let . Then, we have the following:
is a free -module with basis . Therefore, as the direct sum of -vector spaces.
as -modules.
For , if or if .
If , then .
If , then .
Proof. Let :
Since is a transversal of N, the assertion follows.
Consider the map given by for all , then is an -module isomorphism.
Since , then if and only if or . Therefore, the assertion follows.
If , then since N is a subgroup. Hence, the assertion follows.
If , then since . Hence, the assertion follows.
□
Definition 3. We define the -reversible subspace of as the vector subspace
The following lemma introduces the two-cocycle on the group G, for a given element in .
Lemma 2. Let . Then, the map defined by if and and otherwise is a two-cocycle of the group G over .
Proof. By definition, . Therefore, is a two-cocycle if for all . Let us first assume and , then a straightforward calculation shows that holds. On the other hand, if , then a straightforward calculation also shows that holds. □
Lemma 3. Let be the two-cocycle defined in Lemma 2:
If λ is a square in , then is a coboundary.
If λ is a non-square in and there exists such that , then cannot be a coboundary.
If , are non-squares in , then and are congruent.
Proof. Suppose is a square in , then there exists such that . Let us define if , or else . We have for all , since if and only if or
Suppose there exists a function such that and . Therefore, , a contradiction.
Let be a primitive element of . Since , are non-squares in , then and with and being odd. Therefore, , where is even, i.e., is a square in . Let us define if and otherwise. We, therefore, have for all , since if and only if or
□
Remark 1. Note that, since , for all and , then and are isomorphic. By this, we will assume that .
Let be a quadratic extension of . From now on, we only will take into consideration a quadratic extension of since the ambient space over which we define our cryptographic constructions is the twisted-skew group ring , where is a group homomorphism. We next introduce .
Lemma 4. Let be the Frobenius automorphism of over . Then, the map defined by if and otherwise is a group homomorphism.
Proof. Let and . There are four cases to check:
is easy to check.
y , .
y , .
, .
□
Remark 2. relies on the Frobenius automorphism σ. Moreover, since , then Furthermore, if , then , i.e., it is a square, and also, is stabilized by the group ; therefore, the twisted-skew group ring is isomorphic to the skew group ring introduced in [4]. However, if , then the cocycle is not stabilized by the group , and so, the twisted-skew multiplication is not necessarily associative. In fact, for none of the possible four groups G we consider the twisted-skew multiplication is associative. Lemma 5. Let be the two-cocycle defined in Lemma 2 and the group homomorphism defined in Lemma 4. Then, we have the following:
for .
for .
for .
for .
Proof. Let
and
Note that the second sum of Equations (
2) and (
3) follows from the definitions of
and
. Therefore,
.
Let
and
Then,
can be expressed as
and
as
The first sum of Equations (
4) and (
5) follows from the definitions and that, for all
,
. The second sum of Equations (
4) and (
5) follows from
being a homomorphism, and thus,
for
and
.
Since
, then
and
for
. Therefore, the
-th term
of
in (
4) coincides with the
-th term
of
in (
5), which implies the equality.
Let
and
Then, we can write
as
and
is
The last sum of Equations (
6) and (
7) follows from the definitions,
and
for
.
Since
, then
and
for
. Therefore, the
-th term
of
in (
4) coincides with the
-th term
of
in (
5), which implies the equality.
□
3. Intractability Assumptions
This section will describe some attack games concerning the algebraic problems on which the security of our cryptographic constructions lies [
4,
7,
11,
12]. Before giving a detailed account of them, we will introduce some notation that we will use for the remaining part of this paper:
Let G be a finite group of even order and such that .
Let p be a prime number and for some . Let be the quadratic extension of .
The two-cocycle is instantiated by selecting such that it is a non-square in . Additionally, is chosen as specified by Lemma 4.
We set as a public element, where and are random non-zero elements.
We denote the secret key space by . Given a secret key , we denote by . Besides, we define as .
Game 1 (Twisted-Skew Product Decomposition). Let be an efficient adversary. We define the Twisted-Skew Product Decomposition (TSPD) Attack Game as shown by Algorithm 1
Algorithm 1 defines the Twisted-Skew Product Decomposition (TSPD) Attack Game |
- 1:
; - 2:
; - 3:
; - 4:
return
|
In the TSPD attack game, denotes a Boolean value, which is 1 when , or 0 otherwise. We define as the event that the TSPD attack game outputs 1 after plays it for . Furthermore, we define ’s advantage in solving the TSPD problem for as the probability of and denote it by .
Definition 4 (Twisted-Skew Product Decomposition Assumption). We say that the TSPD assumption holds for if, for all efficient adversaries , the quantity is negligible.
Game 2 (Computational Twisted-Skew Product). Let be an efficient adversary. We define the Computational Twisted-Skew Product (CTSP) Attack Game as shown by Algorithm 2.
Algorithm 2 defines the Computational Twisted-Skew Product Attack Game |
- 1:
- 2:
- 3:
- 4:
- 5:
- 6:
; - 7:
return
|
We define as the event that the CTSP attack game outputs 1 after plays it for . Moreover, we define ’s advantage in solving the CTSP problem for as the probability of and denote it by .
Definition 5 (Computational Twisted-Skew Product Assumption). We say that the CTSP assumption holds for if, for all efficient adversaries , the quantity is negligible.
Lemma 6. If the TSPD assumption does not hold for , then the CTSP assumption does not hold for .
Proof. Since the TSPD assumption does not hold for , then there exists an efficient adversary that can win the TSPD attack game with non-negligible probability , i.e., can output such that with non-negligible probability .
We now construct an efficient adversary
that plays and wins the CTSP attack game with non-negligible probability
.
simply uses
as the subroutine. Upon receiving
and
from its challenger,
calls
upon the input either
or
. In either case, if
succeeds in returning a
such that
, then
will calculate
, with
, and return
to its challenger. Because of the choice of
and
and Lemma 5, then
In conclusion, is an efficient adversary and may succeed in computing the correct in the CTSP attack game with non-negligible probability . □
Game 3 (Decisional Twisted-Skew Product). Let be an efficient adversary. We define the Decisional Twisted-Skew Product (DTSP) Attack Game by two experiments indexed by a bit b as shown by Algorithm 3.
Algorithm 3 defines the Decisional Twisted-Skew Product Attack Game |
For Experiment b, the challenger executes |
- 1:
- 2:
- 3:
- 4:
- 5:
- 6:
- 7:
return
|
Remark 3. Game 3 defines two experiments indexed by a random bit b chosen by the challenger. Therefore, the challenger returns either or to the adversary , depending on the experiment the challenger is playing, i.e., the challenger gives to . We denote the experiment b by .
We define as the event that outputs the bit 1 after playing the experiment in the DTSP attack game for . Furthermore, we define ’s advantage in solving the DTSP problem for as and denote it by
Definition 6 (Decisional Twisted-Skew Product Assumption). We say that the DTSP assumption holds for if, for all efficient adversaries , the quantity is negligible.
Lemma 7. If the CTSP assumption does not hold for , then the DTSP assumption does not hold for .
Proof. Since the CTSP assumption does not hold for , then there exists an efficient adversary that outputs such that after being given public keys and with non-negligible probability.
We now construct an efficient adversary that plays and wins the DTSP attack game with non-negligible probability. This adversary uses as the subroutine. In particular, upon receiving from its challenger, calls upon the input . If solves this instance of the CTSP problem for given and and returns to , then compares and to see whether they are equal. If so, then returns 0, or 1 otherwise.
In summary, is an efficient adversary and may succeed in winning the DTSP attack game with non-negligible probability. □
The Hardness of the TSPD Problem
The TSPD problem is similar to both the Dihedral Product Decomposition (DPD) and Skew Dihedral Product Decomposition (SDPD) problems. The former was introduced in [
5], then formalized in [
7] and extended in [
6], while the latter was introduced in [
4] as an extension of the former. The key difference between both is that the latter is defined over the Dihedral Skew Group Ring
, which is structurally different from the algebra
over which the former is defined.
We remark that the algorithmic analysis presented for the DPD problem over
in [
7] can be adjusted easily to both the SDPD and TSPD problems. Furthermore, note that, if
is non-square, then the twisted-skew multiplication defined over
is not associative, which motives the claim that the TSPD problem is defined over a less-structured algebraic structure.
5. An Encryption Scheme from Twisted-Skew Group Rings
This section focuses on presenting a public key-encryption scheme that is procured from the two-party key-agreement protocol analyzed in
Section 4.2. Our derivation approach mimics a well-known generic approach previously employed to obtain a probabilistic encryption scheme from instances of a key-exchange protocol [
4,
5,
7,
12,
24] as, for instance, ElGamal encryption [
25] being obtained from instances of the Diffie–Hellman protocol [
26].
Before presenting our probabilistic public key encryption, we first establish some notation. The public key space is denoted by ; the message space is denoted by ; finally, the ciphertext space is denoted by .
We now introduce the public key-encryption scheme
. Algorithm 6 describes the function
Gen; Algorithm 7 depicts the function
Enc; finally, Algorithm 8 presents the function
Dec.
Algorithm 6 generates a key pair |
- 1:
function Gen() - 2:
- 3:
- 4:
- 5:
return - 6:
end function
|
Algorithm 7 encrypts a message and returns a ciphertext |
- 1:
function Enc() - 2:
- 3:
- 4:
- 5:
- 6:
return - 7:
end function
|
Algorithm 8 decrypts a ciphertext and returns a message |
- 1:
function Dec() - 2:
- 3:
- 4:
- 5:
return - 6:
end function
|
Theorem 3. Let
h
be a public element in , and let be the public key-encryption scheme:
Proof. The proofs of these two items are an adaptation of the proofs of Lemma
and Theorem
, respectively, from [
7]:
Given
,
uniformly chosen at random and
, then we have
By calling
, then
and therefore,
For this statement, we consider an efficient adversary and define as the semantic security (SS) attack game against . Algorithm 9 depicts .
Algorithm 9 depicts attack games defined for the proof of Theorem 3 |
- 1:
function - 2:
; - 3:
; - 4:
; - 5:
; ; - 6:
; - 7:
; - 8:
; - 9:
return ; - 10:
end function
| - 1:
function - 2:
; - 3:
; - 4:
; - 5:
; ; - 6:
; ; - 7:
; - 8:
; - 9:
return ; - 10:
end function
|
Recall denotes a Boolean value. In particular, is 0 if both and differ, or 1 otherwise. In , sends the challenger two messages of the same length in bits.
Let us define as the event of returning 1, then ’s SS-advantage is given by . The proof essentially will show that is negligible if the DTSP assumption holds. Let us define by modifying as shown in Algorithm 9.
Let us define as the event of outputting 1. From , it is clear that , , , and are mutually independent; so are and , and hence, .
We now demonstrate an adversary
that performs the DTSP attack game 3 defined in
Section 3. In particular, the adversary
will assume the role of challenger for
, and its part is as follows.
will first communicate with its own challenger from which it will receive the three-tuple
. It then forwards
to
. When it obtains
from
, then
chooses a bit
at random, computes
, and transmits
to
. Once
finally procures a final response bit
by
, it returns
in the DTSP attack game. Clearly,
is an efficient adversary, since
is also an efficient adversary.
Recall that
is the event that
outputs 1 in game
; thus,
’s advantage for solving the DTSP problem for
is given by
A key observation here is the following.
On the one hand, whenever
’s challenger is playing game
,
is in turn playing
, since
obtains from its challenger
Therefore, .
On the other hand, whenever
’s challenger is playing Game
,
is in turn playing
, because
obtains from its challenger
Therefore,
By hypothesis, is negligible; therefore, is negligible, and the assertion follows.
□
6. A Key-Encapsulation Mechanism from Twisted-Skew Group Rings
In this section, we will focus on deriving a CCA-secure key-encapsulation mechanism from our probabilistic public key encryption
. To accomplish this task, we will apply a generic transformation from [
27] to
. We will next describe this generic transformation a bit more.
Let
be a public key-encryption scheme with message space
, ciphertext space
, and randomness space
. Let
and
and
be hash functions. This transformation is a variant of the Fujisaki–Okamoto transformation with “implicit rejection” of inconsistent ciphertexts. Formally, it is defined as
KEM =
K0 U
(see [
27] for more details). Algorithm 10 summarizes functions
after applying the transformation to
PKE, converting it into a CCA-secure key-encapsulation mechanism. We remark that the proof that this generic transformation converts a public key encryption scheme into a CCA-secure key-encapsulation mechanism may be found in [
27].
Algorithm 10 depicts the CCA-secure key-encapsulation mechanism from |
- 1:
function() - 2:
; - 3:
; - 4:
; - 5:
return ; - 6:
end function
- 1:
function () - 2:
;
| - 1:
function () - 2:
; - 3:
if then - 4:
return ; - 5:
else - 6:
return ; - 7:
end if - 8:
end function
|
- 3:
; - 4:
; - 5:
return ; - 6:
end function
| |
To apply this transformation to our scheme , we proceed by establishing the following. Let be the key space and be a function that returns the binary representation of x. Furthermore, recall that the randomness space is , the public key space is , the message space is , and the ciphertext space is . Finally, we will define the hash function and as follows:
is a hash function, which, upon the input of a variable-length bit string
, returns
. Using the notation of [
28], this function may be defined as
, where
is the bit length of the output and
. The bit string
returned by
can be converted into a element in
by carefully dividing the
bit string into two parts, the first of length
bits and the second of length
bits, each being employed to derive
, respectively.
Let , and we define
is a hash function that, upon the input of a variable-length bit string , returns . This function may be defined as , where is the bit length of the output and is a prepended fixed bit string to make it different from .
Let . We define .
After applying the generic transformation to
, i.e., U
, we obtain
Algorithm 11 describes the functions
KeyGen,
Encaps and
Decaps.
Algorithm 11 depicts the CCA-secure key-encapsulation mechanism from |
- 1:
functionKeyGen() - 2:
- 3:
- 4:
return - 5:
end function
- 1:
function Encaps() - 2:
- 3:
| - 1:
function Decaps() - 2:
- 3:
- 4:
if then - 5:
return - 6:
else - 7:
return - 8:
end if - 9:
end function
|
- 4:
- 5:
- 6:
return - 7:
end function
|
|
7. Implementation of Our Cryptographic Constructions
The proof-of-concept implementation of our cryptographic constructions was coded in Python. The interested reader can see it on Google Colaboratory [
29].
7.1. Group Representation
Recall that , where . For our protocols, we only considered . For any choice, is a cyclic group, and thus, a group element is of the form , which may be represented as an integer , where and
The computation of the integer representation of either
or
,
, will hinge on the form of the group elements and the specific presentation of
G. Note that, by exploiting each group presentation, explicit formulae can be derived to compute both
and
efficiently. The interested reader can see the implementation [
29].
7.2. Two-Cocycle
The function takes two group element representations, and , as the input, then the function returns if and . Otherwise, it returns 1.
7.3. Homomorphism
The function
takes a group element representation,
, as the input, then this function returns a pointer to the function
if
. Otherwise, it returns a pointer to the identity function
I. Algorithm 12 shows both functions.
Algorithm 12 presents functions involved in computing the homomorphism |
- 1:
function () - 2:
- 3:
| - 1:
function () - 2:
return a - 3:
end function
|
- 4:
for do - 5:
; - 6:
if then - 7:
; - 8:
end if - 9:
end for - 10:
return r; - 11:
end function
|
|
7.4. The Twisted-Skew Group Ring
To represent an element
in the group ring
, we make use of an array of
field elements
, where
is the representation of the field element
. Algorithms 13 and 14 describe the addition and product operations, respectively.
Algorithm 13 computes the addition of two ring elements |
- 1:
function addition() - 2:
; - 3:
for do - 4:
; - 5:
end for - 6:
return c; - 7:
end function
|
Algorithm 14 computes the product of two ring elements |
- 1:
function product() - 2:
; - 3:
for do - 4:
for do - 5:
; - 6:
; - 7:
; - 8:
; - 9:
; - 10:
end for - 11:
end for - 12:
return c; - 13:
end function
|
Addition and Product Costs
We now quantify the cost of Algorithms 13 and 14. Let us denote
and as the costs of a field addition and a field multiplication respectively.
and as bounds on the cost of calling and the number of field multiplications to compute respectively.
as the constant cost of executing .
On the one hand, Algorithm 13 has a cost of when computing a ring element . On the other hand, Algorithm 14 has a cost of .
7.5. Auxiliary Functions
As auxiliary functions, we implemented the following functions:
Algorithm 15 computes the adjunct of a ring element, and its cost is , where is a bound on the cost of calling .
Functions for computing random elements in different sets are implemented. They are described in Algorithm 16.
Algorithm 15 computes the adjunct of a ring element |
- 1:
function adjunct() - 2:
; - 3:
for do - 4:
; - 5:
- 6:
- 7:
; - 8:
end for - 9:
return c - 10:
end function
|
Algorithm 16 presents functions for computing a random element in different sets |
- 1:
function () - 2:
; - 3:
while do - 4:
; - 5:
; - 6:
; - 7:
while do - 8:
if then - 9:
; - 10:
end if - 11:
; - 12:
end while - 13:
; - 14:
; - 15:
while do - 16:
if then - 17:
; - 18:
end if - 19:
; - 20:
end while - 21:
; - 22:
end while
| - 1:
function () - 2:
; - 3:
for do - 4:
; - 5:
end for - 6:
return c; - 7:
end function
- 1:
function () - 2:
; - 3:
for do - 4:
; - 5:
end for - 6:
return c; - 7:
end function
- 1:
function () - 2:
; - 3:
for do - 4:
; - 5:
end for - 6:
return c; - 7:
end function
|
- 23:
return a; - 24:
end function
- 1:
function () - 2:
; - 3:
; - 4:
; - 5:
for do - 6:
; - 7:
; - 8:
end for - 9:
return c; - 10:
end function
|
|
7.6. Key Sizes
We next provide estimates for the memory sizes in bits required to store both a public key and a private key.
A field element requires bits. On the one hand, a public key is a ring element, which can be stored as an array of field elements. Therefore, storing a public key requires bits.
On the other hand, a private key
is a pair of two ring elements. Therefore, storing a full private key requires
bits. This number of bits can be decreased further if the form of the private key is exploited. Note that, since
, only
field elements need storing, and hence, a compressed private key requires
bits. For completeness, Algorithms 17 and 18 describe the process of compressing and decompressing a private key, respectively.
Algorithm 17 compresses a private key |
- 1:
function () - 2:
; - 3:
; - 4:
for do - 5:
; - 6:
end for - 7:
for do - 8:
; - 9:
end for - 10:
return c; - 11:
end function
|
Algorithm 18 decompresses a private key |
- 1:
function () - 2:
; - 3:
; - 4:
; - 5:
for do - 6:
; - 7:
end for - 8:
; - 9:
for do - 10:
; - 11:
; - 12:
end for - 13:
return ; - 14:
end function
|
7.7. Parameter Choices
In reference to our key-encapsulation mechanism, we suggest using the parameters displayed by
Table 1, which supplies varying and increasing security levels.
Table 1 displays four sets of parameters, where
denotes the output key length. The values displayed in the column labeled as “Level of Security in Bits” have been computed as proposed in [
7]. The interested reader may see our implementation here [
29].
7.8. Potential Applications
We believe that our protocols might find applications in environments like the Internet of Things (IoT) for various reasons. One first reason is that they may potentially be implemented in constrained devices and the overhead of running them in those devices might be small. This viewpoint stems from observing that the algorithms involved in computing encryptions (or shared keys) are relatively simple, as evinced in this section. Secondly, the key sizes are relatively small compared to other schemes [
3], which offers an advantage for storing purposes. Furthermore, we remark that the study on the deployability of post-quantum cryptographic algorithms on constrained devices is of current interest, as evidenced in [
30]. On the other hand, we also believe that it might be possible to derive password authentication key exchange (PAKE) protocols from our protocols. If so, these PAKE protocols are versatile and may be used in many scenarios, such as credential recovery, device paring, and end-to-end (E2E)-secure channels, as shown in [
31]. However, our protocols per se might be adapted and used in some of those potential scenarios, particularly E2E-secure channels.
8. Conclusions
This paper introduced the twisted-skew group ring , where is a two-cocycle, a group homomorphism, and G a finite group of even order with such that , i.e., , and hence, with . Over this algebraic platform, we built several cryptographic constructions following a incremental-like methodology. In particular, we first introduced a two-party key-agreement protocol and its generalization. Additionally, we derived a probabilistic public key encryption from the two-party key-agreement protocol and key-encapsulation mechanism from the probabilistic public key encryption.
As a future research direction, it would be interesting to explore the possibility of constructing other key-exchange protocols from twisted-skew group rings, namely a password authentication key exchange protocol, which might be suitable in environments like the IoT.