A new lattice-based password authenticated key exchange scheme with anonymity and reusable key

View article
PeerJ Computer Science

Main article text

 

Introduction

Literature review

Motivation and contribution

  • The first BiGISIS-based PAKE scheme, which provides anonymity and reusable key features, is proposed for post-quantum security of mobile devices.

  • The BiP approach is used to reduce the time spent on key generation by obtaining a reusable key. Unlike the methods in the literature, the reusable key feature does not cause SLA thanks to the part selection-based reconciliation method, the most significant bit (MSB).

  • Anonymity is achieved to prevent illegal user login attempts by using pseudo-identity components and additional hash functions.

  • The security analysis is presented by following the RoR model assumptions. As a result of security analysis, PFS and integrity are satisfied, and the resistance against eavesdropping, hash function simulation, manipulation, impersonation, MitM, KKS, and offline PDA are captured.

  • To the best of our knowledge, it is the first SLA-resistant lattice-based PAKE scheme that provides anonymity and reusable key.

Organization

Preliminaries

  • aT: The transpose of the vector a.

  • ℜ:ℤ[x]/(xn + 1), ℜq:ℤq[x]/(xn + 1).

  • m ≥ 2: Module dimension.

  • a ∈ U(x): a is randomly chosen from the distribution x.

  • Am×mq: m × m-dimensional matrix A is defined in ℜq.

  • ś: Server. m´: Mobile user.

  • σ=α(nl/log(nl))14: Standard derivation.

  • χ = Dm,σ: Discrete Gaussian Distribution is defined in ℜm with σ.

  • ∣∣: The concatenate operator.

  • H{i=0,1,2}(a1a2, …, a): Hash functions produce the outputs according to the specification, detailed in Proposed PAKE section. The input is determined by concatenating sub-components.

  • Xrχ: X is randomly chosen from χ.

  • pwaida: The password and the ID value of a, respectively.

  • neg(n): Let ϖ > 0 and n > n0. If there is an n0 ∈ ℕ such that neg(n) < nϖ, neg is called negligible function.

Definition 1

Definition 1: BiGISIS Problem; Jing et al., 2019

Let x1 = As1 + e1modq and xT2=sT2A+eT2modq is computed by using Am×mq, {s1,sT2}rχ, and {e1,eT2}rχ. The main purpose of the BiGISIS problem is to obtain the secret keys s1 and sT2, given the public keys x1 and xT2.

Lemma 1

Let |Pr[PPA(A,x1,xT2)=1]Pr[PPA(A,x1,xT2)=1]|<neg(n) be for any probabilistic polynomial time algorithm (PPA). Then, with a negligible probability, the PPA algorithm can distinguish the distributions K1={A,x1,xT2}BiGISIS and K2={A,x1,xT2}U(m×mq)×U(mq)×U(mq) (Jing et al., 2019).

Conclusion 1

Assume that the hardness assumption of the DBiGISIS problem given by Lemma 1 is satisfied. Then, the hardness of the DBiGISIS problem is equivalent to the hardness of the decisional-M-LWE problem (Jing et al., 2019).

Remark 1

In Langlois & Stehlé (2015), it was shown that there is no polynomial time algorithm to solve the decisional-M-LWE problem, even if in the presence of quantum computers. Based on these proofs, there is also no PPA to solve the DBiGISIS problem since there is a reduction between decisional-M-LWE.

Definition 2

Definition 2: MSB Function

Let x ∈ ℤq be input. There are two possible outputs for y = MSB(x). If q4<|x|<q2 then y = 1, otherwise y = 0.

Definition 3

Definition 3: Anonymity

Anonymity means that the identity of one party is kept confidential even from the other party with whom it is communicating. It seems like an anti-authentication feature as one party wants no one to be able to identify it to protect its privacy. Although anonymity and authentication are two opposite features in practice, the user who wants to remain anonymous also wants to be sure of the other party’s identity (Feng et al., 2018). Cyber attackers cannot use or track the user’s identity thanks to the anonymity feature. So, an anonymous PAKE allows legitimate users to log into the server over an unsecured network without compromising their identity. Anonymous authentication has been one of the features evaluated in the PAKE protocol design, as personal security will be protected in online interactions (Goldberg, Stebila & Ustaoglu, 2013). To achieve anonymity in the PAKE scheme design, the user’s identity is stored anonymously with so-called additional components and some operations.

Definition 4

Definition 4: Reusable Key

In KE schemes, it is desired that the public key be reusable to reduce the time in the key generation and storage costs. Different techniques have been proposed to provide the reusable key feature for lattice-based key-sharing schemes (Akleylek & Seyhan, 2020; Seyhan et al., 2021; Zhang et al., 2015; Ding, Branco & Schmitt, 2019; Gao et al., 2018; Ding et al., 2018). The reusable key feature can make the constructed protocols vulnerable to SLA (Bindel, Stebila & Veitch, 2021). An SLA can occur with the reuse of the keys in protocols that use an additional information-based reconciliation mechanism since the shared key and additional information can leak information about the secret key (Qin et al., 2022).

Definition 5

Definition 5: BiP Method

Let Am×mq, g2,gT1rχ, H2:{0, 1} → χ be a hash function, and {x1,xT2} is generated by consideringDefinition 1. The BiP components is defined with {x1=x1+AH1(x1)+g2} and {x2T=xT2+H1(x2)TA+gT1} and provide the reusable key feature due to the same distribution properties. There are two possible situations. {1.If{x1,xT2}BiGISIS,then{x1,x2T}BiGISIS,2.Otherwise,{x1,x2T}BiGISIS The PPA that can solve the BiGISIS problem in case 1 with the BiP method is unknown. In case 2, the components are close to the uniform distribution. The reusable keys are satisfied since any attacker (Ă) cannot obtain information about previous secret keys using these components.

Remark 2

Note that in order to provide the reusable key feature with the BiP method, a reconciliation structure that does not include sending additional information should be used. The SLA-resistant reusable key feature is achieved since the MSB function, which provides reconciliation with the most significant region, is used in the proposed protocol. We refer to Akleylek & Seyhan (2020), Seyhan et al. (2021) to check the detailed proof that shows the reusable key power of the BiP method.

Definition 6

Definition 6: CDF-Zipf Model

Let Correctpw be the event of adversary’s guessing a correct password with the PDA, DS be the size of password dictionary, and nop be the maximum number of active password-guessing attempts before a corrupt query. The probability of event correctpw in the conventional approaches is Pr[Correctpw]=nopDS+negl(n). Since these methods underestimate the adversary’s power in real-world applications, CDF-Zipf, which provides the characterized password distribution, is preferred to obtain a realistic examination of password guess. Let C′ ∈ [0.001, 0.1] and f ∈ [0.15, 0.30] be CDF constants that can be computed by linear regression. According to CDF-Zipf, the probability of Correctpw is determined by using Eq. (1). Pr[Correctpw]=Cnfop+negl(n)

Proposed PAKE

Setup phase

  • n is chosen to be the power of 2. The sensitivity of the application is also considered in the selection of n. Then, the module dimension m is chosen such that m ≥ 2.

  • The odd prime number q is selected such that qmod2n = 1.

  • The common public key Arm×mq is selected and the distribution χ is defined.

  • ś generates the static public key pTś=sTśA+eTś, where sTś,eTśrχ.

  • Three different hash functions H0:{0, 1} → {0, 1}l, H1:{0,1}lm×1q, and H2:{0, 1} → χ are specified for the BiP, authentication check, and password-based shared key generation.

Registration phase

Login&password-based mutual authentication phase

  • Lines 1–8 for Mobile User: In line 1, the mobile user recalls the parameters that were generated during the registration phase. In lines 2–3, he/she computes the password (PW) to use it in the protocol flow. Between lines 4 and 7, he/she generates static (p) and temporary (x) public keys by following the BiGISIS distribution. Finally, in lines 8–9, the mobile user computes and sends its packaged public key with the password (x) to the server.

  • Lines 10–21 for Server: In line 10–11, the server decrypts the packaged mobile user public key (x) with the help of the fetched password (PW) by using pid. In lines 13–14, the server generates its temporary public key (xTś). In lines 15–17, the server determines and computes BiP components to provide the reusable key feature. Based on these calculations, the server generates its key component (kś). Then, he/she uses MSB reconciliation to agree on the same shared key. Finally, the server sends its public key (xTś) and authentication component (αś) to the mobile user.

  • Lines 22–34 for Mobile User: In lines 22–24, the mobile user computes BiP-related components to ensure the reusable key feature with the computation of (xTś). In lines 25–27, he/she generates the key component of the server (kś) based on its computations and determines the reconciliation value (ψś) to check the first step of successful authentication (αś?=H0(x,xTś,ψś)). In line 28, he/she determines the pseudo-secret key (s) to use it in the second authentication check. Then, the mobile user computes its key component (k) and generates its reconciliation value (ψ). In line 31, cid computation is occurred to assist the anonymity feature. Finally, lines 32-33, shared secret key (skm´ś=H0(id,cid,x,ψ,α,xTś,ψś,αś)) is generated by using third authentication check component (α).

  • Lines 35–41 for Server: Like the mobile user, in lines 35–39, the server computes server-related parameters such as key component (k), reconciliation value (ψ), anonymity item (id), pseudo-secret key (s), and authentication component (α). Finally, the server also generates the shared key (skś m´=H0(id,cid,x,ψ,α,xTś,ψś,αś)) based on generated values.

Password update phase

  • Lines 1–4 for mobile user: By using fetched {pidd}, he/she determines the password component (v) to derive the main password (PW) and sends it to server to check the password update requirement.

  • Lines 5–8 for server: The server brings back the stored password (PW) by using pid. In line 6, if a match is achieved, the server sends a warning message and allows the mobile user to initiate the password update process.

  • Lines 9–13 for mobile user: In lines 9–12, the password-related components (pwnew, dnew, PWnew) are re-generated and new password information (dnew) is stored in the database. Finally, the mobile user sends the updated password (PWnew) to the server.

  • Line 14 for server: The updated password is received from the mobile user and is stored in the server database.

Correctness analysis

Additional properties of proposed PAKE

  • Anonymity: According to Definition 3, id value should not be obtained by the attacker (Ă) to ensure anonymity. In the proposed PAKE, with step 37, id=cidH0(x,ψ,xTś,ψś) is determined. Let’s show that Ă cannot obtain all the components included in this calculation through possible attempts. Suppose that Ă captures {pidx}, {xTś,αś}, and {cidα} with MitM attack. Ă obtains xTś=rTśA+fTś using the modified rTś,fTśrχ. Also, by using kś=(sTś+rTś+zT)(p+x)(sTśp)+hTś, Ă can compute ψś. Although Ă can get sTś with Corrupt-ś(śj) query, defined in Section ‘Security Analysis’, the BiP method component rTś is unknown. The only possible way to get rTś is to solve the BiGISIS problem. It is known that even in the presence of quantum computers, rTś cannot be obtained as a result of Lemma 1 and Conclusion 1. Overall, Ă cannot get id and anonymity is ensured.

  • Reusable Key: In the proposed PAKE, the reusable key is provided with the help of BiP component, added in steps 17 and 24. According to Definition 5, the computed BiP component x=x+Ay+gś and xTś=xTś+zTA+gT have same distribution properties with x and xTś, respectively and hide the general properties of x and xTś. So, even if an Ă gets skś m´=H0(id,cid,x,ψ,α,xTś,ψś,αś)=skm´ś, he/she cannot obtain any information about real/static secret keys when the session is run multiple times. So, the reusable key property is satisfied.

Security Analysis

  • send (UiM): The message M is sent to the i-th instance U. According to the protocol flow, the instance generates the components and gives the outputs to Ă.

  • execute (m´, i, ś, j): The protocol is run between i-th instance m´ and j-th instance ś. The output is the executed protocol transcript and is returned to Ă.

  • corrupt (U): The password of instance U is returned to Ă.

  • reveal (Ui): This query is made by Ă and obtains the session key of U. The shared key of the i-th instance of user U is sent to Ă as an output. This query is constructed with the requirement that a session key captured by Ă should not affect other sessions.

  • test (Ui): i-th instance U flips a bit b. If b = 1, the output is the authenticated shared key of i-th instance U. Otherwise, a uniformly random key is selected as an output.

  • Corrupt-m´(m´i): The manipulation situation in which the user device is captured by A is examined. Performing Corrupt-m´(m´i) query assumes that Ă has captured all sensitive information stored on m´’s mobile device.

  • Corrupt-śj): With this query, it is assumed that the static secret of ś and the secure database of ś are captured by Ă.

Definition 7

Definition 7: Semantic Security (Abdalla, Fouque & Pointcheval, 2005; Dabra, Bala & Kumari, 2020)

The semantic security is examined by Ă’s success in guessing the bit bobtained by the test query. Let Succeed (S) be the event of Ă correctly guessing b. IfEq. (4) is satisfied, the proposed scheme is said to be semantically secure. AdvPAKEĂ=2|Pr[S]12|<negl(n)

Theorem 1

Let Ă be the PPA adversary attempting to generate the shared key during the login&password-based mutual authentication phase of the BiGISIS.PAKE scheme. The advantage of Ă (Adv) in breaking the scheme’s semantic security by obtaining the shared key between m´- ś is given byEq. (5). AdvBiGISIS.PAKEĂ2(q2H02dH0+q2H12dH1+(qsend+qexecute)22dχ+qsenddiddpw+2AdvBiGISISm×1q+Cnfop2)

Proof 1

The proof of Theorem 1 is defined by examining the game sequence Gi={0,1,…,6}. Let SGi be the event of correctly guessing b in the test queries of Ă in every game Gi. b is generated by flipping a coin before the game sequence. Then, it is stored in Ă for games containing test queries.

  • Ă queries oracles H0 and H1 to find {ααś} collision. H2 oracle is not examined in this game since the parameters of H2 are in the flow of the scheme and can be obtained by execute queries. Let qH0 and qH1 be the number of hash function queries, dH0 = 2l and dH1 = qnm be the output space dimension of H0 and H1, respectively. By considering the birthday paradox, the probability of the collisions of hash functions is maximum q2H02dH0+q2H12dH1.

  • Ă also makes send and execute queries to find {x,xTś} collision. In the normal flow, these parameters are calculated with {r,rTś,f,fTś} selected from χ, depending on the BiGISIS distribution. Let the output space dimension of the χ be dχ, and the number of execute and send queries are qexecute and qsend. By considering the birthday paradox, the probability of the collisions of {x,xTś} is maximum (qsend+qexecute)22dχ.

  • Ă can obtain the session key (skś m´=H0(id,cid,x,ψ,α,xTś,ψś,αś)=skm´ś) by using reveal query. In this case, Ă uses these components to examine whether the parties can obtain static and temporary secret keys. Let’s assume that Ă impersonates the mobile user and obtains the shared key. Ă must also know the correct password (PW) and the correct static/temporary public keys (x, p) and authentication components (ids) to bypass the authentication control. The probability of obtaining PW is determined as 1dpwdid since Ă should capture the correct ID and PW values, where dpw and did be the dimension of the passwords and ID’s dictionaries, respectively. The correct computation probability of public keys is 2AdvBiGISISm×1q since the static and temporary ones can be obtained only by solving the DBiGISIS problem. So, the maximum probability of capturing shared key is 2AdvBiGISISm×1q.

  • With the Corrupt-ś (śj) query: {pid,PW,sTś,sTś}

  • With the excute query: {pid,x}, {xTś,αś}, {cidα}

Security proofs

  • Integrity: In the proposed PAKE, authentication checks are done with the help of the controls defined in steps 27 and 40. If these steps (α?=α where α=H0(id,s,cid,x,ψ,xTś,ψś,αś) and αś?=H0(x,xTś,ψś)) are satisfied correctly, then ś and m´ will be valid. The components examined in authentication include all messages exchanged between the two parties and are generated with a secure hash function (H0). Thus, the protocol satisfies the integrity and authentication of the message.

  • Impersonation Attack: In the proposed idea, the authentication checks are done by looking αś?=H0(x,xTś,ψś) and α=H0(id,s,cid,x,ψ,xTś,ψś,αś). When Ă tries to impersonate the parties, he/she needs to have {id,s,ψś,ψ}. Ă can not obtain id with the anonymity property and get {s,ψś,ψ} get since the hardness of BiGISIS. So, the impersonation attempts of Ă do not work against the proposed PAKE.

  • MitM Attack: With MitM, Ă can obtain {pid,x}, {xTś,αś}, and {cidα}. By using these components, Ă cannot impersonate parties due to the hash functions (H{i=0,1,2}), authentication checks, and no polynomial-time algorithm to solve BiGISIS problem.

  • Offline PDA: Let Ă captures the mobile device at the registration stage and obtains d=dH0(id,t)H0(id,pw) and v = H0(idpwd) given in Fig. 1. In this case, even if Ă guesses pw correctly, Ă cannot complete the registration phase without id. Overall, it is resistant to offline dictionary attacks.

  • KKS: In the constructed PAKE, shared key is computed with skś m´=H0(id,cid,x,ψ,α,xTś,ψś,αś). Each component varies depending on the session and unique parties. In addition, the reusable key feature is provided. So, the attacker cannot obtain information about previous or subsequent sessions and KKS is provided.

Comparison

  • Registration: For m´, 3 × TH0 + 1 × TH1 = 3 × 0, 4392 + 10, 2406 ≈ 11, 5582 is calculated. For ś , 2 × TH0 + 1 × Tsamp(χ) = 2 × 0, 1344 + 1, 4778 ≈ 1, 7466 is obtained.

  • Login&Password-Based Mutual Authentication: For m´, 6 × TH0 + 1 × TH1 + 2 × TH2 + 6 × Tsamp(χ) + 6 × Tmul(×) + 2 × Tmsb(MSB) = 6 × 0, 4392 + 1 × 10, 2406 + 2 × 11, 2723 + 6 × 8, 8761 + 6 × 11, 1852 + 2 × 6, 3641 ≈ 168, 5164is computed. For ś , 5 × TH0 + 2 × TH2 + 4 × Tsamp(χ) + 5 × Tmul(×) + 2 × Tmsb(MSB) = 5 × 0, 1344 + 2 × 2, 7113 + 4 × 1, 4778 + 5 × 7, 5872 + 2 × 1, 408 ≈ 52, 7578 is determined.

  • Password Update: 4 × TH0 + 2 × TH1 = 4 × 0, 4392 + 2 × 10, 2406 ≈ 22, 238 is calculated for m´.

Note 2

Unlike (Ding, Cheng & Qin, 2022), TSig components are not included in the calculation because the proposed PAKE does not use additional information.

Conclusion

Additional Information and Declarations

Competing Interests

Sedat Akleylek is a Section Editor of PeerJ Computer Science.

Author Contributions

Kübra Seyhan conceived and designed the experiments, performed the experiments, analyzed the data, performed the computation work, prepared figures and/or tables, and approved the final draft.

Sedat Akleylek conceived and designed the experiments, performed the experiments, analyzed the data, performed the computation work, authored or reviewed drafts of the article, and approved the final draft.

Data Availability

The following information was supplied regarding data availability:

This article did not use raw data or code.

Funding

This research was supported by TUBITAK under Grant No. 121R006. The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.

4 Citations 1,215 Views 98 Downloads