1. Introduction
The availability of quantum computers in the forthcoming future will make current public-key schemes insecure. Therefore, there is a need to devise quantum-secure cryptographic public-key primitives to replace the current public-key algorithms. This need undoubtedly has propelled research towards creating quantum-secure public-key schemes. There have been many proposed candidates thus far, most classified into five families. These families are lattice-based cryptography, multivariate cryptography, hash-based cryptography, code-based cryptography, and supersingular elliptic curve isogeny cryptography. The last round of the post-quantum cryptography standardization process run by the National Institute of Standards and Technology (NIST) includes various candidates in each of the mentioned families [
1].
However, recently, a new promising family of cryptographic constructions, believed to be quantum-secure and based on variations of group rings [
2,
3,
4], has been introduced. In particular, the recent works in [
2,
3,
4] exploit the structure of dihedral twisted group rings to introduce cryptographic constructions. The work in [
3] introduces a 2-cocycle 
 to construct a dihedral twisted group algebra 
. Over 
, the authors introduce a two-party key-exchange protocol and a probabilistic public-key scheme. Following an alternative approach, the authors of [
2] propose a key exchange protocol, a probabilistic public-key scheme, and a key encapsulation mechanism. They also introduce a 2-cocycle 
 to form the resulting twisted algebra 
 non-equivalent to 
 for a non-square 
 in the field 
. They explore its properties and exploit them to enhance the introduced key exchange protocol.
In other related works, the authors in [
5] investigate right ideals as codes in twisted group rings. In particular, they characterize all linear codes that are twisted group codes in terms of their automorphism group.
Our work takes an alternative path by introducing a skew dihedral group ring which is the main tool for constructing a group key exchange protocol, a probabilistic public-key scheme, and a derived key encapsulation mechanism. We first formally define the notion of a skew group ring and explore some of its properties. We then study skew dihedral group rings and later construct a specific skew dihedral group ring by defining the group homomorphism  stated in Lemma 4. In particular, given the presentation  of the dihedral group, the map , where  for all , for , , and  otherwise is a group homomorphism. Over the resulting skew dihedral group ring , we realize our cryptographic constructions and analyze their security. Finally, we present a proof-of-concept implementation of our cryptographic constructions.
The outline of the paper is as follows. In 
Section 2, we show the basic definitions and results we need, whereas, in 
Section 3, we show the concrete presentation of the dihedral group ring we use. 
Section 4 presents the proposed key exchange protocol and analyzes its intractability assumptions. 
Section 5 introduces a group key agreement protocol that generalizes the two-party key agreement protocol presented in 
Section 4. 
Section 6 presents a probabilistic public-key encryption scheme, and 
Section 7 introduces a key encapsulation mechanism using the ideas from the previous sections. 
Section 8 presents the pseudo-codes of a proof-of-concept Python implementation for our cryptographic constructions. Finally, 
Section 9 concludes our work and presents future research directions.
  2. Preliminaries
Let  be the finite field with  elements where p is a prime number and let  be the automorphism group of . Recall that any automorphism  of the finite field  is of the type . Denote by  the Galois group of  over , i.e., the set of all automorphisms of  that fix the subfield . It holds that , in particular . It is well-known that  is a cyclic group of order k generated by the Frobenius automorphism  of  over  defined as  for all . Furthermore, we denote  and  as the set of homomorphisms from G to  and , respectively. Note that 
In the following paragraphs, we summarize the definitions and properties we need on skew group rings.
Definition 1. Let G be a finite multiplicative group and let  be a group homomorphism. The skew group ring  is the set of all formal sums , where , with the following skew multiplication  Note that at -vector space the skew group ring  coincides with the group ring . However, rings not only may not coincide, but in general they are non-isomorphic. More precisely, we have the following result.
Lemma 1. Let  be homomorphisms. There is an -linear ring isomorphism  mapping  to  for some  if and only  is a group isomorphism such that  for all .
 Proof.  Denote by  the product in  and denote  the product in . The image of  in  is . The product in  of the images of  and  are  The two elements coincide if and only if  for all . □
 Remark 1. Note that in general  for  and ; therefore,  may not be an algebra.
 Lemma 2. The map ,  is a ring anti-isomorphism of .
 Proof.  Let 
. Then, we have
        
□
 Definition 2. For an element , we define its adjunct as    3. A Skew Dihedral Group Ring
Let  be a presentation of the dihedral group of order .
Lemma 3. Let  be the cyclic subgroup of  generated by x. Then, we have
- 1. 
-  is a free -module with basis . Therefore,  as direct sum of -vector spaces. 
- 2. 
-  as -modules. 
- 3. 
- For ,  if  or  if . 
- 4. 
- If , then . 
- 5. 
- If , then . 
 Proof.  In what follows, the symbol  for  denotes .
        
- Since  is a transversal for  in , then , and the assertion follows. 
- Since  and  for all , the assertions follow. 
- Since  and  for all , the assertions follow. 
- Since  for all , then the assertion follows. 
- Since  for all , then the assertion follows. 
□
 Definition 3. We define the θ-reversible subspace of  as the vector subspace  The following lemma introduces the group homomorphism  which depends on the Frobenius automorphism , where  is a quadratic extension of . Note that since , then  Furthermore, from here on, we only consider a quadratic extension of  due to the ambient space over which we define our cryptographic constructions as the skew group ring .
Lemma 4. Let  be the Frobenius automorphism of  over . Then, the map  defined by  for ,  and  otherwise is a group homomorphism.
 Proof.  This assertion follows straightforwardly.    □
 Lemma 5. Let  be the group homomorphism defined in Lemma 4. Then, we have  for .
 Proof.  Let 
 and 
 Then
        
        and
        
The first sum of Equations (
1) and (
2) follows from the definitions. The second sum of Equations (
1) and (
2) follows from 
 being a homomorphism, and thus 
 for 
.
Since 
, then 
 and 
 for 
, then 
 and 
 (since 
 by construction). Therefore, the 
i-th term 
 of 
 in (
1) coincides with the 
-th term 
 of 
 in (
2), which implies that 
 for all 
. □
   4. A Key Exchange Protocol
This section presents a two-party key exchange protocol based on two-sided multiplications over a skew dihedral group ring. We remark that other works have considered two-sided semi-group actions or matrices over group rings for key exchange [
2,
3,
4,
6,
7,
8,
9]. However, we follow an alternative approach. Recent papers [
2,
3,
4] propose two-party key exchange protocols using two-sided multiplications over dihedral twisted group rings. Following their constructions, we introduce a two-party key exchange protocol over the skew group ring 
.
Remark 2. Since  is not an algebra, our protocol works over a different algebraic structure than that of [2,3,4].    4.1. The Construction
We start by setting up our key exchange protocol’s public parameters.
        
- Choose  and a prime number p such that p divides n. We then set  and the finite field . 
- Choose the map  as it was defined in Lemma 4. We remark that for  with , , where  for all , and  otherwise. 
- Choose a random non-zero element  and a random non-zero element . Set  and make  public. 
- Let  be the secret key space, and  be a secret key; we define  as . Furthermore, let us define the function  as  and  as a set of identifiers. 
Let 
 and 
 be two parties and 
s be a bit-string that identifies a session. Let us denote as 
 the identifier of the party 
. The key exchange protocol between 
 and 
 runs as shown by Algorithm 1.
        
| Algorithm 1 Two-party key exchange protocol | 
| 1:The initiator , on input , chooses a secret pair  and sends  to .2:Upon receipt of ,  chooses a secret pair  and sends  to , computes , erases , and outputs the key  under the session-id s.3:Upon receipt of ,  computes , erases , and outputs the key  under the session-id s.
 | 
We remark that if both 
 and 
 are uncorrupted during the exchange of the key and complete the protocol for session-id 
s, they then establish the same key. Because of the choice of 
, by Lemma 5, it follows
        
  4.2. Intractability Assumptions
With the notation above, let 
 be a public element in 
, where 
 is a random non-zero element from 
 and 
 is a random non-zero element from 
. We now present attack games [
10,
11] for algebraic problems related to the security of our key exchange protocol.
Game 1 (Skew Dihedral Product Decomposition). For a given adversary , we define the following attack game:
We define ’s advantage in solving the Skew Dihedral Product Decomposition Problem for , denoted , as the probability that .
 Definition 4 (Skew Dihedral Product Decomposition Assumption). We say that the Skew Dihedral Product Decomposition (SDPD) assumption holds for  if for all efficient adversaries  the quantity  is negligible.
 Game 2 (Computational Skew Dihedral Product). For a given adversary , we define the following attack game:
We define ’s advantage in solving the Computational Skew Dihedral Product (CSDP) Problem for , denoted , as the probability that .
 Definition 5 (Computational Skew Dihedral Product Assumption). We say that the Computational Skew Dihedral Product (CSDP) assumption holds for  if for all efficient adversaries  the quantity  is negligible.
 Lemma 6. If the SDPD assumption does not hold for , then the CSDP assumption does not hold for .
 Proof.  This assertion follows straightforwardly. □
 Game 3 (Decisional Skew Dihedral Product). For a given adversary , we define two experiments:
- The challenger computes - 1: 
                  
- 2: 
                  
- 3: 
                  
- 4: 
                  
- ;  
- 5: 
                  
 
- and gives the triple  to the adversary. 
- The adversary outputs a bit . 
Let  be the event that  outputs 1 in experiment . We define ’s advantage in solving the Decisional Skew Dihedral Product Problem for  as  Definition 6 (Decisional Skew Dihedral Product Assumption). We say that the Decisional Skew Dihedral Product (DSDP) assumption holds for  if for all efficient adversaries  the quantity  is negligible.
 Note that  is chosen as , with  being a random non-zero element from  and  being a random non-zero element from , to not let the attacker win the DSDP Game trivially. Indeed, if  is chosen as  with , then  and  by Lemma 3. Similarly, if  is chosen as  with , then  and  by Lemma 3. Therefore, the attacker can win the DSDP Game for both cases with non-negligible probability. Additionally, we have the following:
Lemma 7. If the CSDP assumption does not hold for , then DSDP assumption does not hold for .
 Proof.  This assertion follows straightforwardly. □
   4.3. The Hardness of the SDPD Problem
The SDPD problem is similar to the Dihedral Product Decomposition (DPD) Problem introduced in [
3], then formalized in [
2], and extended in [
4]. In [
2], the authors provide an algorithmic and algebraic analysis of their DPD problem, which is the underlying computational problem associated with the security of their cryptographic constructions. In particular, they define the twisted dihedral group algebra 
, where the 2-cocycle 
 is defined by 
 (a non-square in 
) for 
, 
 with 
 and 
 otherwise. Furthermore, [
2] demonstrates that 
 as a direct sum of 
-vector spaces and also defines 
 in a similar way.
In [
2], the DPD attack game is defined as follows. Let 
 be a public element in 
, where 
 is a random non-zero element from 
 and 
 is a random non-zero element from 
. For a given adversary 
,
        
The ’s advantage in solving the Dihedral Product Decomposition Problem for  is defined as the probability that .
The authors of [
2] analyze how an adversary may try to solve their DPD problem by exploiting quantum algorithms [
12,
13] or algebraic techniques [
14]. We remark that since the DPD problem and SDPD problem are alike, such an algebraic and algorithmic analysis for the DPD problem presented in [
2] may be adapted easily to the SDPD problem. However, we remark that adjusting such an analysis to the SDPD problem does not mean that both the DPD and SDPD problems are computationally equivalent. It is indeed an open question to prove whether the DPD problem (or any of its variants) and SDPD problem are computationally equivalent or not.
  4.4. Security Analysis in the Authenticated-Links Adversarial Model
This subsection is devoted to further analyzing our two-party key exchange protocol in an appropriate security model [
15,
16,
17]. In particular, we aim to prove that our protocol is session-key secure in the authenticated-links adversarial model (AM) of Canetti and Krawczyk [
17], assuming the DSDP assumption holds for 
. The definition of session-key security in the authenticated-links adversarial model of Canetti and Krawczyk is introduced in [
17]. We add a description of it as follows:
- Let  be a finite set of parties. 
- Let  be an adversary that controls all communication between two parties, however,
             -  is not allowed to inject or modify messages, except for messages sent by corrupted parties or sessions. 
-  may choose not to forward a message at all. However, if  decides to forward a message m, then  has to send it to the correct destination for m only once and without modifying m. 
- Parties give outgoing messages to , who has control over their delivery via the Send query.  can activate a party  by Send queries, i.e., the adversary has control over the creation of protocol sessions, which takes place within each party. Two sessions  and  are matching if the outgoing messages of one are the incoming messages of the other and vice versa. Additionally,  is allowed to query the oracles SessionStateReveal, SessionKeyReveal, and Corrupt.
                 - -
- If  queries the SessionStateReveal oracle for a specified session-id s within some party , then  obtains the contents of the specified session-id s within , including any secret information. This event is noted and produces no further output. 
- -
- If  queries the SessionKeyReveal for a specified session-id s, then  obtains the session key for the specified session s, assuming that s has an associated session. 
- -
- If  queries the Corrupt oracle for a specified party , then  takes over the party , i.e.,  has access to all information in ’s memory, including long-lived keys and any session-specific information still stored. A corrupted party produces no further output. 
 
- Finally,  receives access to the test oracle, which can be queried once and at any stage to a completed, fresh, and unexpired session-id s. On input s, the test oracle chooses , then it outputs the session key for the specified session-id s if . Otherwise, it returns a random value in the key space. Moreover,  can issue subsequent queries as desired, but it cannot expose the test session. At any point, the adversary can try to guess b. Let  be the event that  correctly guesses b, and define the advantage . 
 
Theorem 4. If the DSDP assumption holds for , then our key exchange protocol is session-key secure in the the authenticated-links adversarial model, i.e., for any  in the authenticated-links adversarial model (AM), then the following holds:
- 1. 
- The key-exchange protocol satisfies the property that if two uncorrupted parties complete matching sessions, they both output the same key. 
- 2. 
-  is negligible. 
 Proof.  The proof is an adaptation of the proof for the key-exchange protocol over a twisted dihedral group algebra 
 given in [
2].
          
- The proof of the first statement is given at the end of the  Section 4.1- . 
- To prove this statement, we proceed by contradiction. Let us suppose that there is an adversary  -  in the authentication-links model against our protocol that has a non-negligible advantage  -  in guessing the bit  b-  chosen by the  test-  oracle (when queried). Let  l-  be an upper bound on the number of sessions invoked by  -  in any interaction. We now present a distinguisher  -  (Algorithm 2) for the DSDP problem.
               | Algorithm 2 A distinguisher for the DSDP problem |  | 1:function()2:    ;3:    Invoke  on a simulated interaction in the AM with parties  with identifiers , except for the  session;4:    For the r-th session, let  send  to  and let  send  to ;5:    if the r-th session is selected by  as the test session then6:      Give  to  as the answer to his query;7:      ;8:    else9:      ;10:    end if11:    return d12:end function
 |  
 - 
              On the one hand, let us suppose that  -  picks the  r- -th as the test session, then  -  is provided with either  -  or  - , since the DSDP challenger gives either of the two keys to  - . Therefore, the probability that  -  correctly distinguishes is  -  with non-negligible  -  (by assumption). On the other hand, assume that  -  does not choose the  r- -th as the test session, then  -  always returns a random bit, and the distinguishing probability for the input is  - . 
- Note that the probability that the test session and the r-th session coincide is . So, these do not coincide with probability . Hence, the overall probability for  to win the DSDP Game is , which is non-negligible. 
 □
   5. Group Key Agreement
Here, we introduce a group key agreement protocol that generalizes the interactive two-party key agreement protocol presented in 
Section 4.1. Let us assume there are 
 participants with distinct identifiers 
. Algorithm 3 shows our group key agreement, and it runs as follows:
	  
| Algorithm 3 Group key exchange protocol | 
| Participant |  | Participant | 
|  |  |  | 
| computes |  |  | 
|  | ⋮ |  | 
|  | ⋮ |  | 
| Participant |  | Participant | 
|  |  |  | 
| computes |  |  | 
|  | ⋮ |  | 
|  | ⋮ |  | 
| Participant |  |  | 
|  |  | 
| computes  and |  | Each participant | 
|  |  | computes  from | 
- The participant  -  randomly selects a secret pair  -  and then sends the list of messages  -  to the participant  - , where
           
- For , the participant  randomly selects a secret pair  and then sends the list of messages  to the participant , where  contains
           - (a)
-  when i is even. 
- (b)
-  when i is odd. 
 
- The participant  randomly selects a secret pair  and then computes  containing
           - (a)
-  when o is even. 
- (b)
-  when o is odd. 
 
- 
          and then sets  as the shared key, and finally broadcasts  to all other participants. 
- For , the participant  computes  when o is odd or  when o is even and sets  as the shared key. 
Lemma 8. After a complete run of the above protocol, the participants  agree on a common key .
 Proof.  We prove the previous statement by induction on the number of participants o.
Base Case
When o is 2, we obtain the two-party key agreement protocol.
Inductive Case
We now proceed with two cases:
        
- Assume that the number of participants is o (odd) and that after running the protocol with o participants, the participant  obtains the shared key via computing , while the participant o obtains the shared key via computing . - Suppose that there are  (even) participants. We show that after running the protocol with  participants, the participant  obtains the shared key via computing , while the participant o obtains the shared key via computing . - On the one hand, note that
             - 
            for  - . On the other hand,
             
- Assume now that the number of participants is o (even) and that after running the protocol with o participants, the participant  obtains the shared key via computing  and the participant o obtains the shared key via computing . - Suppose that there are  (odd) participants. We show that after running the protocol with  participants, the participant  obtains the shared key via computing , while the participant o obtains the shared key via computing . - On the one hand, note that
             - 
            for  - . On the other hand,
             
 □
   Security Analysis
Since our group key exchange protocol follows a similar idea as that of a group key exchange protocol over twisted group rings introduced in [
3,
4], we can adapt the analysis of its security presented in [
4] to this setting. Specifically, based on the idea of [
18], the authors of [
4] prove that if their Decisional Dihedral Product Assumption holds, then their group key management verifies that an adversary cannot distinguish the shared group key from an arbitrary element (see Theorem 1 from [
4]).
Theorem 5. If the DSDP assumption holds for , then our group key exchange protocol verifies that an adversary cannot distinguish the shared group key from an arbitrary element.
 Proof.  The proof of Theorem 1 in [
4] can be easily adapted to this setting. □
   6. Probabilistic Public Key Encryption
We now derive a probabilistic public key encryption from the key exchange protocol introduced in 
Section 4, in much the same way that the Elgamal encryption follows from the Diffie–Hellman protocol. This approach is used, for example, in [
2,
3,
11,
19].
Following the notation above,
      
- Let  be the public key space,  be the message space, and  the cipher-text space. 
- Choose a random non-zero element  and a random non-zero element . Set  and make  public. 
We now define the public key encryption scheme 
, where 
Gen is shown by Algorithm 4, 
Enc is shown by Algorithm 5 and 
Dec is shown by Algorithm 6.
      
| Algorithm 4 Generates a key pair | 
| 1:functionGen()2:    3:    4:    5:    return 6:end function
 | 
| Algorithm 5 Encrypts a plaintext | 
| 1:functionEnc()2:    3:    4:    5:    6:    return 7:end function
 | 
| Algorithm 6 Decrypts a ciphertext | 
| 1:functionDec()2:    3:    4:    5:    6:    return 7:end function
 | 
Lemma 9 (Correctness). Let h be a public element in . Consider the encryption scheme  constructed above. For any message ,  and  it holds that 
 Proof.  Since
        
        and 
, then
        
        and therefore
        
 □
 Remark 3.  must be randomly chosen each time  (Algorithm 5) is called to guarantee it to be probabilistic.
 Theorem 6. If the DSDP assumption holds for , then  is semantically secure.
 Proof.  The proof of Theorem 
 in [
2] can be easily adapted to this setting. □
   7. A Key Encapsulation Mechanism
By applying a generic transformation of Hofheinz, Hövelmanns, and Kiltz [
20] to 
, we introduce a CCA-secure key encapsulation mechanism. Let 
 be the key space and 
 be a function that simply returns the binary representation of 
x. Additionally, we construct the following two functions:
-  is a hash function that takes in a bit-string, say  - , and then uses a cryptographic hash function, e.g.,  - , to compute a key in the keyspace from it. Following the notation of [ 21- ],  - , where  -  is the bit length of the output. From this bit-string, the corresponding pair  -  can be obtained easily. 
-  is a hash function that applies a cryptographic hash function, e.g., , to the input. Specifically, , where  is a pre-pended fixed bit-string to make it different from . - Applying the generic transformation  -  from [ 20- ], we obtain
       - 
      where  KeyGen-  is shown by Algorithm 7,  Encaps-  is shown by Algorithm 8 and  Decaps-  is shown by Algorithm 9. 
| Algorithm 7 Generates a key pair | 
| 1:functionKeyGen()2:    3:    4:    return 5:end function
 | 
| Algorithm 8 Encapsulates a key | 
| 1:functionEncaps()2:    3:    4:    5:    6:    return 7:end function
 | 
| Algorithm 9 Decapsulates a key | 
| 1:functionDecaps()2:    3:    4:    if  then5:      6:      return 7:    else8:      return 9:    end if10:end function
 | 
Remark 4. We refer the reader to [20] to see a proof of why this generic construction is CCA-secure.    8. Implementation
We implemented our proposed public-key encryption scheme and key encapsulation mechanism as proof-of-concept in Python. The interested reader can see it on Google Colaboratory [
22].
  8.1. Dihedral Group
To implement a dihedral group of order , we simply represent a dihedral group element  as the integer . Moreover, we compute a  integer array table such that the row ,  stores a  array with the integer representations of . To compute the operation of two given group elements,  and , we simply return , where  and . To compute the multiplicative inverse of a given group element , the function  returns 0 if , or  if , or  if .
  8.2. Homomorphism  
The homomorphism 
 is implemented as described next. Given 
 and 
, two representations of two group elements, then the function 
 returns a pointer to the function 
 (shown by Algorithm 10) if 
 and 
. Otherwise, it returns a pointer to the function identity 
 (shown by Algorithm 11).
        
| Algorithm 10 Computes the Frobenius automorphism | 
| 1:function()2:    3:    4:    for  do5:      6:      if  then7:        8:      end if9:    end for10:    return r11:end function
 | 
| Algorithm 11 Computes the identity function | 
| 1:function()2:    return a3:end function
 | 
  8.2.1. The Skew Dihedral Group Ring  
An element 
 in the group ring 
 is represented as an array of 
 field elements 
, where 
 is the representation of the field element 
. Algorithm 12 shows the addition of two ring elements, and Algorithm 13 shows the product of two ring elements.
          
| Algorithm 12 Computes the addition of two ring elements | 
| 1:functionaddition()2:    3:    for  do4:      ;5:  end for6:  return c7:end function
 | 
| Algorithm 13 Computes the product of two ring elements | 
| 1:functionproduct()2:    3:    for  do4:      for  do5:        ;6:        ;7:        ;8:      end for9:    end for10:    return c11:end function
 | 
On the one hand, the addition function has a cost of  field additions to compute a ring element . On the other hand, the product function has a cost of  field additions and  field multiplications, where f is the number of field multiplication to compute . Furthermore, Algorithm 14 computes the adjunct of a ring element, and its cost is  multiplications.
We also implement some helper functions. In particular, 
 denotes a function that returns a random element in 
. Furthermore, Algorithms 15–18 show functions to compute random elements from 
, 
, 
, and 
 respectively. Finally, Algorithm 19 shows a function to compute a random public element 
h.
          
| Algorithm 14 Computes the adjunct of a ring element | 
| 1:functionadjunct()2:    3:    for  do4:      5:      6:    end for7:    return c8:end function
 | 
| Algorithm 15 Computes a random element from | 
| 1:function()2:    3:    4:    5:    for  do6:      7:      8:    end for9:    return c10:end function
 | 
| Algorithm 16 Computes a random element from | 
| 1:function()2:    3:    for  do4:      5:    end for6:    return c7:end function
 | 
| Algorithm 17 Computes a random element from | 
| 1:function()2:    3:    for  do4:      5:    end for6:    return c7:end function
 | 
| Algorithm 18 Computes a random element from | 
| 1:function()2:    3:    for  do4:      5:    end for6:    return c7:end function
 | 
| Algorithm 19 Computes a random public element h | 
| 1:function()2:    3:    while  do4:      5:      6:      7:      while  do8:        if  then9:          10:        end if11:        12:      end while13:      14:      15:      while  do16:        if  then17:          18:        end if19:        20:      end while21:      22:    end while23:    return a24:end function
 | 
  8.2.2. Parameters Choice
For our key encapsulation mechanism, we propose to use the parameters shown by 
Table 1, which provide varying degrees of security.
Table 1 shows four sets of parameters providing various degrees of security, where 
 refers to the length of the output key. We calculated the values in the level of security column as proposed in [
2]. To see the code of our implementation, please see [
22].
   9. Conclusions
In this paper, we introduced skew dihedral group rings and constructed a specific skew dihedral group ring by defining the group homomorphism  stated in Lemma 4. Over the resulting skew dihedral group ring , we built our cryptographic protocols and analyzed their security. Finally, we presented a proof-of-concept implementation of our cryptographic constructions.
As a future research direction, it may be interesting to explore the design of other cryptographic protocols over skew group rings, e.g., password-authenticated key exchange or sigma protocols.