Introduction
The rapid growth of micro-electromechanical system and Wireless Sensor Networks (WSNs) is due to heavy application of them in our everyday life in resource constrained and hostile environments (for instance places where wired networks cannot be deployed, such as forests) supporting real-time application in healthcare, military surveillance, wildlife monitoring, intelligent transportation, vehicular tracking and environment control to name few. Thus, the WSNs are integral part of our daily lives [13], [32]. The wireless sensors possess limited communication and computation resources, thus it is vital to ensure that these operations do not result in heavy consumption of sensor’s power resources. The above is because the external users are in interest to access real-time information from the nodes. A WSN is formed with the help of a gateway node and other sensor nodes where each specific sensor node collects a data from a region, and then the attained data is forwarded to the gateway node over the communication channel where the gateway node is presumed to be possessing high computational abilities as to meet the demands. The issue in WSN is to identify the authentic user and grant access to the data, which becomes a key challenge in IIOT environments.
Moreover, protecting the data from malicious access, modifications and eavesdropping is also necessary. To meet the above requirements, it is essential that the user gets authenticated first. The general approach used is that user, gateway and the sensor node get authenticated adhered to which a secure session key will be enabled such that the user and the sensor node can exchange data. To proceed with this, the user sends the authentication message to the gateway adhered to which the gateway initiates the communication with the said sensor which collects the information desired by the user. Now, the gateway receives the information from the sensor node which is then provided to the user. In the real-time access of data sensor, data is collected using a mobile device owned by a valid user. Figure 1 depicts the real-time flow of data between WSNs [1]–[3], [5], [6]. Although the WSN networks are efficient and environment friendly, there exists many security issues in the said network. Privacy and security are major concerns in a WSN networks [1]–[12]. The security requirements for the proposed work were motivated from [1]–[12], [14], [24]–[28], [48]. The following are the security requirements which are essential to ensure security (also a safe exchange environemnt) of the WSN based schemes.
Known Session Specific Temporary Information Attack: The knowledge of temporary session information such as random number or timestamp or any other data should not be sufficient for an adversary to derive the exchanged session key or any other sensitive data (such as pseudonym).
Computational DOS Attack: The execution of the overall process should occupy less computation and communication overheads while ensuring high grade security.
Perfect Forward Secrecy: Every session key must be unique and session key derived from a set of long-term keys of gateway node
, user$GW$ and sensor node$U$ cannot be compromised if one of the long-term keys (of either gateway node, user or the sensor node) is compromised in the future.$SN$ Replay Attack: The gateway node
, sensor node$GW$ and user$SN$ should have the capability to detect the freshness of the message and reject the message which are not fresh. In this attack an adversary tries to impersonate the either of given entity by sending the previous message or replaying the legitimate message from one of the previous sessions in this session.$U$ Impersonation Attack: The adversary should not be able to successfully impersonate the gateway node
, sensor node$GW$ and user$SN$ , in this attack the adversary tries to masquerade the gateway node$U$ , sensor node$GW$ and user by modifying the authentication message sent by them, this is a serious issue in WSN environment if this is not prevented then the adversary can gain unauthorized access to the network (by impersonating user) or provide falsified data (if gateway node or sensor node impersonation is successful).$SN$ De-synchronization Attack: In this attack the pseudonym stored at the gateway node
and the sensor node$GW$ memory would not be the same, because of an adversary blocks the communication between the parties.$SN$ Suppress Replay Attack: The said attack exist due to different clock drift rates (the clocks counting time at different rates) of user’s mobile
, gateway node$U$ and sensor node$GW$ . The following attack is not noticeable by just checking the freshness of the messages, due to the lag between the clocks (thus the clock synchronization issue exists), it is possible that an adversary replays the message which is treated as fresh by$SN$ or$GW$ or$U$ . The said attack must be detected and eliminated, failure to do so will result in impersonation of the entity.$SN$ Identity Compromise Impersonation Attack: In this attack if the identity of either gateway node
, user$GW$ and sensor node$U$ is compromised or exposed, the knowledge of this should not help an adversary exceed it’s a-priori knowledge to cause disruptions in the system such as impersonation, modification, replay, attaining session key, etc.$SN$ Man-in-the-Middle Attack: The active adversary observing the messages in the network should not be able to attain any vital information from traffic analysis or perform malicious attacks.
Un-linkability: In the said attack the adversary should not be able to link two authentication messages coming from the same user
.$U$ Key-offset Attack: In this attack an active adversary can off-set the agreed session key by a value
, which is unknown to both$\sigma $ and$U$ .$GW$ Resist Stolen Device/ Smart Card Attack: In this attack, it is assumed that an adversary is able to corrupt the given device and attain the stored credentials on them, thus the knowledge of attained credentials should not be enough for an adversary to attain useful information to impersonate a valid user
.$U$ Known Key Attack: If a session key of a given session is compromised then, it should be infeasible for an adversary to attain the session key of next session. Thus, an authentication and key exchange protocol must be designed such that it can withstand this attack.
A novel lightweight conditional privacy preserving authentication and key agreement protocol scheme, where the entities make use of hidden and dynamic modulus as to enhance security. The proposed work is such that exposure of all current session based group key agreement information will not be sufficient to derive future information of modulus or the session key.
A novel scheme where the authentication process is expedited, here the suppress relay is detected. The proposed work makes use of only hash, xor based functions and a sequence number as to expedite the authentication process.
Secure and dynamic probabilistic session key establishment protocol, where the entities make use of dynamic session modulus, thus every entity generates its unique session specific modulus using which they converges on the common session key.
Using pseudonyms of different sensor nodes to communicate, the following is used as to prevent exposure of identity of sensor node. Thus providing anonymity of the sensor node during communication.
Cryptanalyzing Xiong et al. scheme [6] and overcoming the vulnerabilities and weaknesses described in the review (of Xiong et al. scheme) and the related works section (of different schemes).
Related Works
In the recent years, many user authentication protocols have been proposed for WSNs. The schemes can be broadly classified into three categories, scheme deploying symmetric encryption, schemes deploying hash based approaches and scheme depending on public key approaches. Wong et al. [10] proposed a hash based user authentication which motivated towards a lightweight, less complex scheme. The said scheme resulted in fast authentication and met many security properties but the said work is vulnerable to replay attack, forgery attack and stolen-verifier attack, thus making it vulnerable to real-time application in WSNs. Das [11] proposed a two factor authentication scheme using a password authenticated smart cards, although the scheme deployed two factor authentication, but the scheme was vulnerable to mutual authentication, user anonymity, offline password guessing, gateway bypassing and masquerade attack. Gope and Hwang [5] presented a hash based authentication scheme for WSN, the proposed work presented a means via which two entities can agree on a session key using hash functions only, the proposed work promises a practical application in WSNs but the said work is vulnerable to untraceablity, de-synchronization, stolen device attack [6], KSSTI attack (as session key is dependent on the temporary information) and fails to provide sensor anonymity (as sensor identity is exposed), thus making the scheme vulnerable in IIOT environment. However, the proposed work highlighted vulnerabilities in [35]–[37] which motivates to design system overcoming these issues. Shi and Gong [12] proposed an ECC based authentication protocol but Choi et al. [1] depicted that the previous work is vulnerable as it suffered from key share attack and stolen smart card attack. Although Choi et al scheme claims to be secure, but it suffers from many attacks such as absence of user anonymity, untraceability, clock synchronization [6], KSSTI attack (as session key is based on it), cannot withstand sensor node corruption (as user associated credentials will get exposed), suppress replay attack (due to clock synchronization issue) and fails to provide sensor node anonymity as its identity is known to the user in advance, thus making it vulnerable to real-time application in IIOT. Nam et al. [2] presented a authentication protocol depending on ECC which presented a provably secure scheme but the said work is vulnerable as it lacks password change phase, wrong password detection [6], KSSTI attack (as session key is dependent on temporary information), suppress replay attack (due to clock synchronization issue) and fails to provide sensor node anonymity (identity of the sensor node is known), thus making the proposed work vulnerable in IIOT environment. Jiang et al. [3] scheme presents a two factor ECC based authentication two factor authentication scheme for high security but the proposed work is vulnerable as it fails to provide perfect forward secrecy, password change phase [6], KSSTI attack (as session key is dependent on it), suppress replay attack (due to clock synchronization issue), and withstand sensor node corruption (as its corruption can expose user associated credentials), thus making the scheme vulnerable in IIOT environment. Paliwal et al. [4] presented a group key agreement scheme using modular exponentiation, the proposed work is secure against DOS attack but the said work is vulnerable to replay attacks (absence of timestamp or random number), identity of all entities must be known in order to initiate a communication, thus loss of anonymity exists and cannot withstand impersonation thus the proposed work is vulnerable in IIOT environment, the same holds for [29] as it is vulnerable to suppress replay attack, fails to preserve identity of the entities and is vulnerable to KSSTI attack. Recently, Li et al. [6] presented a authentication and group key agreement scheme depending on ECC approach suitable for WSN and IIOT application, the proposed work is vulnerable to many attacks such as DOS Attack, KSSTI attack, impersonation attack (user, sensor node and gateway) and key-offset attack, the vulnerabilities are discussed in next section. The proposed work aims to provide an authentication and key-agreement protocol based on hash functions, the proposed work aims to overcome vulnerabilities of existing schemes such that it can be easily deployed in resource constrained environments. The security proofs, assumptions and practices are followed from [5], [21], [38]–[40] as these are hash based schemes, similar to proposed work.
Review of Xiong $et ~al$
. Scheme
In this section a briefly review of Xiong et al.’s authentication and key agreement scheme for WSNs in IIOT [6] is presented. The proposed work of Xiong et al. has three phases: Registration Phase, Authentication and Key-Agreement Phase and Password Change Phase. The focus is given on first two phases.
A. Registration Phase
All registrations take place over a secure channel, here both the sensor and user registration takes place. The initial section depicts the registration of the sensor and the later depicts the registration of the user.
1) Sensor Node Registration
For every sensor node
2) User Registration
In this phase the user is successfully registered with the gateway node
Step 1:
freely selects an identity$U$ and a password$ID_{U} $ adhered to which it extracts biometric information in the device with fuzzy extractor$PW_{U}$ and$Gen(BIO_{U})=(R_{U}, P_{U})$ generates a random number$U$ which is used to calculate$r_{U} $ . Now, the$HPW_{U} =h(PW_{U} \vert \vert r_{U})$ submits request$U$ to$(ID_{U}, HPW_{U}, R_{U})$ over a secure channel.$GW$ Step 2:
When the
receives the said credentials it checks for identity in the database, here if the identity exists then the said request is rejected thus the user must generate new credentials. If the said identity is not existing the$GW$ computes$GW$ ,$B_{1} =h(ID_{U} \vert \vert HPW_{U} \vert \vert R_{U})$ and$B_{2} =h(ID_{U} \vert \vert \omega)$ . Now, the$B_{3} =h(HPW_{U} \vert \vert R_{U})\oplus B_{2} $ sends the credentials$GW$ to$(B_{1},B_{3}, X)$ over a secure channel.$U$ Step 3:
stores$U$ into the mobile device.$(P_{U}, r_{U}, B_{1}, B_{3},X,Gen(.),Rep(.))$
B. Authentication and Key-Agreement Phase
To gain access to the sensor data of the sensor node
Step 1:
$U\to GW:M_{1} =\{DID_{U}, D_{1}, D_{3}, D_{4} \}$ on the mobile device provides its authentication credentials$U$ . Once the above credentials are provided, the mobile device computes$ID_{U}, PW_{U}, BIO_{U}^{\prime } $ ,$R_{U} =Rep(BIO_{U}^{\prime }, P_{U})$ and checks if$B_{1}^{\prime } =h(ID_{U} \vert \vert h(PW_{U} \vert \vert r_{U})\vert \vert R_{U})$ holds. If it does then the mobile device of$B_{1}^{\ast } \mathop{=}\limits^{?} B_{1} $ generates a random number$U$ and computes$a\in Z_{n}^{\ast } $ ,$B_{2} =B_{3} \oplus h(h(PW_{U} \vert \vert r_{U})\vert \vert R_{U})$ ,$D_{1} =aP$ ,$D_{2} =aX$ ,$DID_{U} =ID_{U} \oplus h(D_{2})$ and$D_{3} =SN_{id} \oplus B_{2} \oplus h(D_{2})$ . Now, the mobile device sends the message$D_{4} = h(B_{2} \vert \vert D_{2} \vert \vert SN_{id})$ to the gateway node for authentication.$M_{1} $ Step 2:
$GW\to SN:M_{2} =\{D_{1}, D_{6}, D_{7} \}$ computes$GW$ ,$D_{2}^{\prime } =xD_{1} $ and checks if identity is valid. If the identity is valid then the$ID_{U}^{\prime } =DID_{U} \oplus h(D_{2}^{\prime })$ computes$GW$ ,$B_{2}^{\prime } =h(ID_{U}^{\prime } \vert \vert \omega)$ ,$SN_{id}^{\prime } =D_{3} \oplus B_{2}^{\prime } \oplus h(D_{2}^{\prime })$ and checks if$D_{4}^{\prime } =h(B_{2}^{\prime } \vert \vert D_{2}^{\prime } \vert \vert SN_{id}^{\prime })$ holds. If the above does then the$D_{4}^{\ast } \mathop{=}\limits^{?} D_{4} $ computes$GW$ ,$D_{5} =h(SN_{id}^{\prime } \vert \vert \omega)$ and$D_{6} =D_{5} \oplus r_{G} $ where$D_{7} =h(D_{1} \vert \vert r_{G} \vert \vert D_{5} \vert \vert SN_{id}^{\prime })$ is a random number generated by the$r_{G} $ . Now, the$GW$ sends the message$GW$ to the sensor node$M_{2}$ .$SN$ Step 3:
$SN\to GW:M_{3} =\{D_{8}, D_{9}, D_{10} \}$ computes$SN$ ,$r_{G}^{\prime } =K_{gs} \oplus D_{6} $ and checks if$D_{7}^{\prime } =h(D_{1} \vert \vert r_{G}^{\prime } \vert \vert K_{gs} \vert \vert SN_{id})$ holds. If the above condition holds then the$D_{7}^{\ast } \mathop{=}\limits^{?} D_{7} $ computes$SN$ ,$D_{8} =bP$ ,$SK=h(D_{1} \vert \vert D_{8} \vert \vert bD_{1})$ and$D_{9} =h(K_{gs} \vert \vert D_{8} \vert \vert r_{G}^{\prime } \vert \vert SN_{id})$ where$D_{10} =h(SN_{id} \vert \vert SK)$ . Now, the$b\in Z_{n}^{\ast }$ sends the message$SN$ to the sensor node$M_{3} $ .$GW$ Step 4:
$GW\to U:M_{4} =\{D_{8}, D_{10}, D_{11} \}$ computes ($GW$ ) and checks if$D_{9} =h(D_{5} \vert \vert D_{8} \vert \vert r_{G} \vert \vert SN_{id}^{\prime })$ holds. If the above holds, the$D_{9}^{\ast } \mathop{=}\limits^{?} D_{9}$ computes$GW$ and sends the message$D_{11} =h(ID_{U}^{\prime } \vert \vert D_{1} \vert \vert D_{8} \vert \vert B_{2}^{\prime })$ to the mobile device of the user.$M_{4}$ Step 5:
The mobile device computes
and checks if$(D_{11} =h(ID_{U}^{\prime } \vert \vert D_{1} \vert \vert D_{8} \vert \vert B_{2}^{\prime }))$ holds. If, the above holds then the mobile device computes the session key$D_{11}^{\ast } \mathop{=}\limits^{?} D_{11} $ ,$SK^{\prime }=h(D_{1} \vert \vert D_{8} \vert \vert aD_{8})$ and checks$D_{10}^{\prime } =h(SN_{id} \vert \vert SK^{\prime })$ if$(D_{10} =h(SN_{id} \vert \vert SK))$ holds. If it does then the session key is accepted.$D_{10}^{\ast } \mathop{=}\limits^{?} D_{10} $
Security Weakness and Design Flaws in Xiong $et~al$
. Scheme
In this section various security vulnerabilities in the Xiong et al. scheme is presented. These attacks prove that the said scheme is vulnerable. Before proceeding with the attack, several security assumptions are made, using [1]–[14], [20], [21], [23]–[27]. Following are the assumptions.
Definition 1:
All the system messages (except registration) are transmitted via an unreliable channel; thus, an adversary can delete, modify, append, intercept or replay any message. However, an adversary is not able to attain any information which is taking place via secure channel.
Definition 2:
The length of the long term key and the random number is so long that the adversary is not able to guess the long term key or any random number used in the system.
Definition 3:
The adversary can corrupt any honest entity and attain the pre-shared secret information used by the entity or by the group of entities. Moreover, the adversary can be a valid registered entity in the system, thus can attain all shared information in advance.
Definition 4:
The adversary has unbounded storage space which helps the adversary store several messages.
Definition 5:
The adversary has access to all sensor identities in the said system.
A. DOS Attack
The attack focuses on making the resources of the system unavailable temporarily or permanently to the hosts connected over a network. In the Xiong et al. scheme the said system is vulnerable to Gateway Node DOS attack and Sensor Node DOS attack [5], [31].
1) Gateway Node DOS Attack
The Xiong et al. scheme is vulnerable to Gateway DOS attack; the following are the steps an active adversary can make to perform the said attack.
Step 1:
The adversary can capture the authentication message
from different users$M_{1}$ and prevent these messages to reach the destination at distinctive time intervals. The adversary proceeds by bundles all of these messages together.$U$ Step 2:
Once sufficient number of messages are bundled, the adversary now sends these messages (
from different users) to the gateway node$M_{1}$ and$GW$ will accept these messages as fresh due to fresh random number.$GW$ Step 3:
The gateway node
proceeds further by authenticating these messages which will hold as valid, as these were valid authentication messages (as stated in [44] that server must check recently received nonce from client to check that they are not replayed. And in the above case, the message has never reached the gateway node before, thus the above messages will be accepted as fresh).$GW$ Step 4:
The gateway node
will now generate authentication message which will be directed to the sensor node, thus as a result, the$GW$ will have to generate multiple authentication message based on the message$GW$ it has attained. Thus, as a result DOS will take place due to excessive requests which needs to be processed.$M_{1}$
Thus, processing these bundled requests can result in slower processing of valid requests by
2) Sensor Node DOS Attack
The Xiong et al. scheme is vulnerable to Sensor Node DOS attack; the following are the steps an active adversary can make to perform the said attack.
Step 1:
The adversary can capture the authentication message
from different Gateway node$M_{2} $ and prevent these messages to reach the destination at distinctive time intervals. Now, the adversary bundles all of these messages together.$GW$ Step 2:
Once all the messages are bundled, the adversary now sends these messages (
for different sensors) to the sensor node$M_{2}$ with a specific sensor identity$SN$ and sensor node$SN_{id} $ will accept these messages as fresh due to fresh random number.$SN$ Step 3:
The sensor node
proceeds further by authenticating these messages which will hold for some and$SN$ will reject other as invalid. The above is because only few were valid authentication messages and now the$SN$ proceed by generating the session key for valid requests.$SN$ Step 4:
The sensor node
will repeat the above process for all the requests, and since the nonce on all will be fresh, the sensor node will accept it and perform above steps for all such requests.$SN$
In above case if very high numbers of messages are bundled then there is a good probability that the sent message is indeed intended for the sensor node
B. Identity Compromise Impersonation Attack
It is possible that an adversary may attain knowledge of identity of the user via some wicked means (such as Dumpster Diving, social engineering, pretext, vishing, phishing or other means) [22]. These attacks are done using the
1) Attaining Secret Parameters (When Identity is Exposed) and Performing User Impersonation Attack
In the proposed Xiong et al. scheme if user identity is attained by some wicked means then the adversary can impersonate the valid user
Step 1:
The adversary captures a valid authentication message
, fetches$M_{1} =\{DID_{U}, D_{1}, D_{3}, D_{4} \}$ and computes$DID_{U} $ . Once the value of$DID_{U} \oplus ID_{U} =h(D_{2})$ is attained then the adversary fetches$h(D_{2})$ and computes$D_{3} $ (as assumed previously that an adversary can attain information about the sensor node identities). It can be inferred that the value of$D_{3} \oplus SN_{ID} \oplus h(D_{2})=B_{2} $ is not verified; the adversary needs to generate multiple authentication messages based on$B_{2} $ information, and then once the message is authenticated by the gateway node. The adversary accepts the derived information as valid.$SN_{id} $ Step 2:
To validate the attained credentials the adversary generates a random number
and using the published parameters$u$ computes$\{E,G,n,P,X\}$ ,$D_{1} =uP$ ,$D_{2} =uX$ ,$DID_{U} =ID_{U} \oplus h(D_{2})$ ,$D_{3} =SN_{id} \oplus B_{2} \oplus h(D_{2})$ . The above process will be repeated till a request is accepted as valid (by the gateway node).$D_{4} =h(B_{2} \vert \vert h(D_{2})\vert \vert SN_{id})$
The above is feasible as in the system there are only limited sensor identities; the adversary can brute force the identities of
Further the adversary can impersonate the valid user
2) Key-Offset Attack
The previous knowledge can help perform key-offset attack [30]. The following are the steps the active adversary can take to proceed with a key-offset attack.
Step 1:
The adversary as before attains the values of
,$B_{2}$ adhered to this the adversary captures the authentication message$SN_{id} $ (Initially computes$M_{4} =\{D_{8}, D_{10}, D_{11} \}$ ).$DID_{U} \oplus ID_{U} =h(D_{2})$ Step 2:
Once the said credentials are captured then the adversary generates a random number
and computes$k$ ,$D_{8}^{Malicious} =kP$ ,$SK=h(D_{1} \vert \vert D_{8}^{Malicious} \vert \vert kD_{1})$ (computes$D_{10}^{Malicious} =h(SN_{id} \vert \vert SK)$ and checks if the sensor identity exists in the system. If a valid credentials are attained then the given session corresponds to the user whose credentials are known, else the adversary picks a different session) and$SN_{ID} =D_{3} \oplus B_{2} \oplus h(D_{2})$ . The adversary now sends the message$D_{11}^{Malicious} =h(ID_{U}^{\prime } \vert \vert D_{1} \vert \vert D_{8}^{Malicious} \vert \vert B_{2}^{\prime })$ to the mobile device of the user.$M_{4}^{Malicious} =\{D_{8}^{Malicious},D_{10}^{Malicious}, D_{11}^{Malicious} \}$ Step 3:
The mobile device now computes and checks if
holds. Now, the mobile device computes the session key$D_{11}^{\ast } \mathop{=}\limits^{?} D_{11} $ and checks if$SK^{\prime }=h(D_{1} \vert \vert D_{8}^{Malicious} \vert \vert aD_{8}^{Malicious})$ holds. Thus, at this point the session key is offset because of$D_{10}^{\ast } \mathop{=}\limits^{?} D_{10} $ .$k$
C. Known Session Specific Temporary Information Attack (KSSTI Attack)
The said attack makes the scheme highly vulnerable; the consequence of this attack produces vulnerabilities such as impersonation (user, gateway node and sensor node) attaining the session key and Modification attack [23], [30]. In this attack only session specific information such as nonce, timestamp, etc. are exposed, whereas the long term secrets are kept still unknown to the adversary.
1) User Impersonation
If the adversary is able to attain the session specific information ‘
Step 1:
The adversary fetches the message
and computes$M_{1} =\{DID_{U},D_{1}, D_{3}, D_{4} \}$ (where the public parameters are$D_{2} =aX$ ). Once the user attains the said credentials, the adversary computes$\{E,G,n,P,X\}$ ,$DID_{U} \oplus h(D_{2})=ID_{U}$ adhered to which the adversary fetches the sensor identity from set of identities to attain the value of$D_{3} \oplus SN_{ID} \oplus h(D_{2})= B_{2} $ and checks if$B_{2}^{\ast } $ holds. If, the above condition holds then the adversary can be certain that the sensor identity$D_{4}^{\ast } \mathop{=}\limits^{?} D_{4} $ is valid.$SN_{id} $ Step 2:
The adversary to gain access to any particular sensor node can generate authentication messages from this point as the value of
is known to the adversary. Thus, the adversary for any sensor node$\{ID_{U}, B_{2}, SN_{id} \}$ can generate authentication message$SN$ .$M_{1} =\{DID_{U}, D_{1}, D_{3}, D_{4} \}$
2) Gateway Node Impersonation and Sensor DOS Attack
If the adversary is able to attain the session specific information ‘
Step 1:
The adversary fetches the message
and computes$M_{2} =\{D_{1}, D_{6},D_{7} \}$ to attain the long term key$D_{6} \oplus r_{G} =D_{5} $ . Now, to attain the correct identity of the destination sensor node$K_{gs} $ , the adversary fetches the sensor identities and checks if$SN$ holds. If the said condition fails, then the adversary fetches another identity till the condition is met.$D_{7}^{\ast } \mathop{=}\limits^{?} D_{7}$ Step 2:
Once the long term key is attained then the adversary can impersonate the gateway node for this the adversary generates
where$M_{2}^{Malicious} =\{D_{1}, D_{6}^{Malicious}, D_{7}^{Malicious} \}$ and$D_{6}^{Malicious} =_{}D_{5} \oplus r_{G}^{Malicious}$ . Once the above credentials are generated then the adversary can send the message to sensor node$D_{7}^{Malicious} =h(D_{1} \vert \vert r_{G}^{Malicious} \vert \vert D_{5} \vert \vert {SN_{id}}^{\prime })$ .$SN$
Step 1:
The adversary generates multiple
messages Where$M_{2}^{Malicious} =\{D_{1}^{Malicious}, D_{6}^{Malicious}, D_{7}^{Malicious} \}$ (here$D_{1}^{Malicious} =AP$ is a random number),$A$ (here$D_{6}^{Malicious} =D_{5} \oplus B$ is a random number) and$B$ . Once the message is generated it is sent to the said sensor node for validation.$D_{7}^{Malicious} =h(D_{1} \vert \vert B\vert \vert D_{5} \vert \vert SN_{id}^{\prime })$ Step 2:
The sensor node verifies the attained credentials of message
as before, and generates the authentication message$M_{2}^{Malicious} $ and since the number of requests will be high, it will ultimately result in DOS attack.$M_{3} $
3) Sensor Node Impersonation and Key-Offset Attack
If the adversary is able to attain the session specific information ‘
Step 1:
The step is similar to that of gateway node impersonation, the adversary attains the credentials similar to the step1 (as depicted in gateway node impersonation) adhered to which the adversary produces fraudulent message
and sends it to the gateway node$M_{3}^{Malicious} =\{D_{8}^{Malicious}, D_{9}^{Malicious}, D_{\vphantom {D_{j}}10}^{Malicious} \}$ where$GW$ (here$D_{8}^{Malicious} =CP, SK=h(D_{1} \vert \vert D_{8}^{Malicious} \vert \vert CD_{1})$ is a random number),$C$ and$D_{9}^{Malicious} =h(K_{gs} \vert \vert D_{8}^{Malicious} \vert \vert r_{G}^{\prime } \vert \vert SN_{id})$ .$D_{10}^{Malicious} =h(SN_{id}\vert \vert SK)$ Step 2:
The gateway node
validates the message by checking if$GW$ holds, if it doesn’t then the request is rejected; if it does then the$D_{9}^{\ast } \mathop{=}\limits^{?} D_{9}^{Malicious} $ generates the authentication message$GW$ and sends it to the user$M_{4} =\{D_{8}^{Malicious}, D_{10}^{Malicious}, D_{11} \}$ where$U$ .$D_{11} =h(ID_{U} ^{\prime }\vert \vert D_{1} \vert \vert D_{8} \vert \vert B_{2}^{\prime })$ Step 3:
The mobile device of user
checks if$U$ holds, if it does then it computes$D_{11}^{\ast } \mathop{=}\limits^{?} D_{11} $ and checks if$SK=h(D_{1} \vert \vert D_{8} \vert \vert aD_{8})$ holds and now the session key has been established between the adversary and the mobile device of the user.$D_{10}^{\ast } \mathop{=}\limits^{?} D_{10} $
The same approach can be used to perform key-offset attack as the knowledge of all sensor node credentials is exposed. The following are the steps an adversary will take to perform key-offset attack.
Step 1:
The adversary captures the message
and stores the value$M_{2} =\{D_{1},D_{6}, D_{7} \}$ and derives the value of$D_{1}$ . Whereas, the adversary captures the authentication message$r_{G}^{\prime } =D_{6} \oplus K_{gs} $ and deletes it from the network.$M_{3} =\{D_{8},D_{9}, D_{10} \}$ Step 2:
Once the said credentials are discarded then the adversary generates a random number
and computes$k$ ,$D_{8}^{Malicious} =kP$ ,$SK=h(D_{1} \vert \vert D_{8}^{Malicious} \vert \vert kD_{1})$ and$D_{9}^{Malicious} =h(K_{gs} \vert \vert D_{8}^{Malicious} \vert \vert r_{G}^{\prime } \vert \vert SN_{id})$ . The adversary now sends the message$D_{10}^{Malicious} =h(SN_{id} \vert \vert SK)$ to the gateway node.$M_{3}^{Malicious} =\{D_{8}^{Malicious}, D_{9}^{Malicious},D_{10}^{Malicious} \}$ Step 3:
The gateway node validates the credentials by checking if
holds and then the scheme proceeds as before. Thus, the session key has been offset by$D_{9}^{\ast } \mathop{=}\limits^{?} D_{9}^{Malicious} $ without any detection.$k$
4) Attaining the Session Key
Here, if the adversary is given access to either of the ephemeral ‘
Proposed Scheme
In the proposed scheme there are three phases: Registration Phase, Authentication and Key-Agreement Phase and Password Change Phase.
A. Registration Phase
In this phase both the sensor node and the user is registered so that secure communication can take place in the system.
1) Sensor Node Registration
In this phase sensor node
2) User Registration
In this phase the user
Step 1:
The user
selects a unique identity$U$ , a password$ID_{U} $ , a random number$Pwd$ and the current timestamp$Nonce_{U} $ . Now, the$Timestamp_{U} $ computes$U$ ,$PublicIdentifier_{U} =h(ID_{U} \oplus Timestamp_{U} \oplus Nonce_{U})$ and sends the credentials$HPwd=h(Pwd\vert \vert Nonce_{U} \vert \vert Timestamp_{U})$ to the gateway node$\{ID_{U}, PublicIdentifier_{U}, HPwd\}$ .$GW$ Step 2:
The gateway node
checks if the$GW$ exist if it does then the request is rejected. If the above condition fails then the$ID_{U} $ computes$GW$ ,$GW_{1} =h(K\vert \vert ID_{U})\oplus Nonce_{GW} $ and$GW_{2} =HPwd\oplus Ke y_{U} $ where$GW_{3} =h(ID_{U} \vert \vert Key_{U} \vert \vert HPwd\vert \vert GW_{1})$ is a random number (selected by$Nonce_{GW} $ ),$GW$ is a random key assigned for the user. Now, the$Key_{U} $ a random sequence number$GW$ and sends the credentials$(Seq_{Num})$ ,$\{PublicIdentifier_{U}, GW_{1}, GW_{2}, GW_{3},Seq_{Num}, H(.)$ to the$Mod_{Set} \}$ over a secure channel and stores the said info.$U$ Step 3:
Now,
stores the random number$U$ and the timestamp$Nonce_{U} $ in the set and stores$Timestamp_{U} $ ,$\{PublicIdentifier_{U}$ ,$GW_{1}$ ,$GW_{2}$ ,$GW_{3}$ ,$Nonce_{U}$ ,$Seq_{Num}$ on the mobile device.$Timestamp_{U}, H(.),Mod_{Set} \}$
B. Authentication and Key-Agreement Phase
In this phase the user
Step 1:
,$U\to GW:M_{1} = \{PublicIdentifier_{U}$ ,$H_{\alpha 1}$ ,$H_{\alpha 2}$ $Timestamp_{U}^{1}, PublicIdentifier_{SN} \}$ The user
provides authentication credentials$U$ and$ID_{U} $ adhered to which the mobile device computes$Pwd$ (by fetching the random number$HPwd^{\ast }=h(Pwd^{\ast }\vert \vert Nonce_{U} \vert \vert Timestamp_{U})$ and timestamp$Nonce_{U} $ from the device),$Timestamp_{U} $ and checks the validity of the input credentials by verifying if$GW_{2} \oplus HPwd^{\ast }=Key_{U}^{\ast } $ holds. If the above condition fails then the request is rejected. However, if the condition does hold then the mobile device generates a random number$h(ID_{U}^{\ast } \vert \vert Key_{U}^{\ast } \vert \vert HPwd^{\ast }\vert \vert GW_{1})^{\ast }\mathop{=}\limits^{?} GW_{3} $ , fetches the current timestamp$Nonce_{U}^{1} $ and computes$Timestamp_{U}^{1} $ ,$H_{\alpha 1} =h(Nonce_{U}^{1}~\vert \vert ~GW_{2} ~\vert \vert ~Key_{U} ~\vert \vert ~ PublicIdentifier_{U} \vert \vert Timestamp_{U}^{1} \vert \vert ~PublicIdentifier_{SN})\oplus Seq_{Num} $ . Now, the mobile device computes three session specific modulus$H_{\alpha 2} =H(PublicIdentifier_{U} \vert \vert ~GW_{1}~\vert \vert ~PublicIdentifier_{SN} ~\vert \vert ~ID_{U} ~\vert \vert ~ Timestamp_{U}^{1} ~\vert \vert ~HPwd)~\oplus Nonce_{U}^{1} $ ,$h_{1} =h(Nonce_{U}^{1} \vert \vert ID_{U} \vert \vert Key_{U})$ ,$h_{2} =h(ID_{U} \vert \vert Seq_{Num} \vert \vert HPwd)$ adhered to which it checks if the computed Modulus lie within the specified$h_{3} =h(Timestamp_{U}^{1} \vert \vert Seq_{Num} \vert \vert ~PublicIdentifier_{U} ~\vert \vert ~ ID_{U} ~\vert \vert ~ Nonce_{U}^{1})$ range, if it doesn’t then the authentication message is generated again till the values satisfy. Once, the above credentials are generated then the said credentials are forwarded to the gateway node$Mod_{Set} $ .$GW$ Step 2:
,$GW\to U:M_{2} =\{PublicIdentifier_{U}$ ,$H_{\alpha 3}$ ,$H_{\alpha 4}$ ,$H_{\alpha 5}, Timestamp_{GW}, A,B\} ~GW\to SN:M_{3} =\{PublicIdentifier_{SN}$ ,$H_{\alpha 6}$ ,$H_{\alpha 7}$ ,$H_{\alpha 8}$ ,$Timestamp_{GW}$ ,$A_{SN}$ $B_{SN} \}$ The gateway node
fetches the timestamp and checks if$GW$ holds, if it does then the$Timestamp_{x} -Timestamp_{U}^{1} \le \Delta T$ fetches the credentials associated with$GW$ . Once the said credentials are fetched then the$PublicIdentifier_{U} $ proceeds by computing$GW$ and to verifies the attained credentials, the$H_{\alpha 2} \oplus H(PublicIdentifier_{U}^{\ast }~\vert \vert ~ GW_{1} \vert \vert PublicIdentifier_{SN} \vert \vert ID_{U} \vert \vert ~Timestamp_{U}^{1\ast }~\vert \vert ~ HPwd)=Nonce_{U}^{1\ast }$ checks if$GW$ holds. If the above holds then the user is authenticated and the request is legitimate. Now, the$H_{\alpha 1}^{\ast } \mathop{=}\limits^{?} H_{\alpha 1} $ generates the session specific modulus$GW$ respectively, adhered to which the$h_{1}, h_{2},h_{3} $ generates the session key and the authentication message for user and the sensor node$GW$ whose public identifier is$SN$ , so that they can attain the common session key. For generating the credentials,$PublicIdentifier_{SN} $ generates a random number$GW$ for$Nonce_{GW1} $ and computes$SN$ ,$h_{4} =h(Nonce_{GW1} \vert \vert ID_{SN} \vert \vert Nonce_{SN} \vert \vert Key_{SN})$ ,$h_{5} =h(ID_{SN} \vert \vert Seq_{SN} \vert \vert Nonce_{GW1})$ and checks if$h_{6} =h(Timestamp_{GW} \vert \vert Seq_{SN} \vert \vert ~PublicIdentifier_{SN} ~\vert \vert ~ID_{SN} ~\vert \vert ~ Nonce_{GW1})$ condition is satisfied. If the previous condition is satisfied then the$Mod_{Set} $ has a total of six session specific modulus. Now, the$GW$ produces the session key for which the$GW$ generates two random number$GW$ ,$A$ of arbitrary lengths such that$B$ , similarly since the session key is attained the$Key_{Session} = [\{A\bmod (h_{1})\}\cdot \{B\bmod (h_{2})\}] \bmod (h_{3})$ now selects a random number$GW$ and computes the value of$A_{SN} $ as$B_{SN}$ (here the session key by the$[\{B_{SN} \bmod (h_{5})\}]\bmod (h_{6})=[Key_{Session} \cdot ~\cdot \{A_{SN} \bmod (h_{4})\}^{-1}\bmod (h_{6})]\bmod (h_{6})$ has been computed as$GW$ and since the$Key_{Session} =[\{A\bmod (h_{1})\}\cdot \{B\bmod (h_{2})\}]\bmod (h_{3})$ has access to$GW$ ,$h_{4} $ ,$h_{5}$ and$h_{6} $ the$A_{SN} \bmod (h_{4})$ must now generate the value of$GW$ such that the computed session key equals$B_{SN} $ . Once, all the ephemerals are generated then the$Key_{Session} =[\{A_{SN} \bmod (h_{4})\}\cdot \cdot \{B_{SN} \bmod (h_{5})\}]\bmod (h_{6}))$ generates$GW$ where$M_{2} =\{PublicIdentifier_{U} ~,H_{\alpha 3}, H_{\alpha 4}, H_{\alpha 5}, Timestamp_{GW}, A,B\}$ (here$H_{\alpha 3} =h(PublicIdentifier_{U} ~\vert \vert ~ Timestamp_{GW} ~\vert \vert ~ NewSeq_{Num} ~\vert \vert ~ ~Nonce_{G} ~\vert \vert ~ Timestamp_{U}^{1})\oplus NewPublicIdentifier_{U}$ ),$NewPublicIdentifier_{U} =h(Timestamp_{GW} ~\vert \vert ~ ID_{U} ~\vert \vert ~ Nonce_{GW} ~ \vert \vert ~Key_{v1} ~\vert \vert ~ Nonce_{U}^{1} ~\vert \vert ~ Timestamp_{U}^{1})$ ,$H_{\alpha 4} =h(Timestamp_{U}^{1} ~\vert \vert ~Timestamp_{GW} ~\vert \vert ~B~\vert \vert ~ Nonce_{U}^{1} ~\vert \vert ~ PublicIdentifier_{U} ~\vert \vert ~ Key_{v1})\oplus ~Nonce_{G} \oplus Nonce_{U}^{1} $ and$H_{\alpha 5} =h(Nonce_{U}^{1} ~\vert \vert ~ ID_{U} ~\vert \vert ~ A~\vert \vert ~PublicIdentifier_{U} ~\vert \vert ~ NewPublicIdentifier_{U} \vert \vert B \vert \vert Timestamp_{GW}~\vert \vert ~ Timestamp_{U}^{1})\oplus NewSeq_{Num} $ ,$M_{3} =\{PublicIdentifier_{SN}$ where,$H_{\alpha 6},H_{\alpha 7}, H_{\alpha 8}, Timestamp_{GW}, A_{SN}, B_{SN} \}$ ,$H_{\alpha 6} =h(Nonce_{GW1} ~\vert \vert ~ Key_{SN} ~\vert \vert ~ B_{SN}~\vert \vert ~ Timestamp_{GW} ~\vert \vert ~PublicIdentifier_{SN} ~\vert \vert ~ NewSeq_{SNNum})\oplus Seq_{SN} $ , and$H_{\alpha 7} =h(PublicIdentifier_{SN} ~\vert \vert ~ ID_{SN} ~\vert \vert ~ Timestamp_{GW}~\vert \vert ~ A_{SN})\oplus ~Nonce_{GW1} $ . Now the message$H_{\alpha 8} =Seq_{SN} \oplus h(Key_{SN} \oplus Seq_{SN})\oplus NewSeq_{SNNum} $ ,$M_{2}$ is sent to the user and the sensor node respectively.$M_{3}$ Step 3:
The mobile device when receiving the message
checks if$M_{2} $ holds. If the above holds then the mobile device computes$Timestamp_{x} -Timestamp_{GW} \le \Delta T$ ,$H_{\alpha 4} \oplus ~Nonce_{U}^{1} \oplus h(Timestamp_{U}^{1} ~\vert \vert ~ Timestamp_{GW}^{\ast } ~\vert \vert ~ B^{\ast }~\vert \vert ~ Nonce_{U}^{1} \vert \vert ~PublicIdentifier_{U} ~\vert \vert ~ Key_{v1})=Nonce_{G}^{\ast }$ ,$NewPublicIdentifier_{U}^{\ast } =h(Timestamp_{GW}^{\ast }~\vert \vert ~ ID_{U} ~\vert \vert ~ Nonce_{GW}^{\ast }~\vert \vert ~ Key_{v1} ~\vert \vert ~ Nonce_{U}^{1} \vert \vert ~Timestamp_{U}^{1})$ and checks if$H_{\alpha 5} \oplus h(Nonce_{U}^{1} ~\vert \vert ~ ID_{U} ~\vert \vert A^{\ast }\vert \vert ~ PublicIdentifier_{U} ~\vert \vert ~ NewPublicIdentifier_{U}^{\ast } ~\vert \vert ~ B^{\ast }~\vert \vert ~ Timestamp_{GW}^{\ast } \vert \vert ~Timestamp_{U}^{1}) =NewSeq_{Num}^{\ast } $ holds. If it does then the attained credentials are correct and the mobile device computes the session key as$H_{\alpha 3}^{\ast } \mathop{=}\limits^{?} H_{\alpha 3} $ adhered to which the sequence number and new pseudonym is updated.$Key_{Session} =[\{A\bmod (h_{1})\}\cdot \{B\bmod (h_{2})\}]\bmod (h_{3})$ Step 4:
The sensor node
when receiving the message$SN$ checks if$M_{3} $ holds. If the above holds then the$Timestamp_{x} -Timestamp_{GW} \le \Delta T$ computes$SN$ ,$H_{\alpha 7} \oplus h(PublicIdentifier_{SN} \vert \vert ID_{SN} \vert \vert Timestamp_{GW} ^{\ast }\vert \vert A_{SN}^{\ast })=Nonce_{GW1}^{\ast }$ and validates it by checking if$H_{\alpha 8} \oplus h(Key_{SN} \oplus Seq_{SN})\oplus Seq_{SN} =NewSeq_{SNNum}^{\ast }$ holds. If above holds then the sensor node computes$H_{\alpha 6}^{\ast } \mathop{=}\limits^{?} H_{\alpha 6} $ ,$h_{4}$ ,$h_{5}$ and$h_{6}$ adhere-d to which it updates the sequence number.$Key_{Session} =[\{A_{SN} \bmod (h_{4})\}\cdot \{B_{SN} \bmod (h_{5})\}]\bmod (h_{6})$ Consider a small example, let us assume that the values of
are$\{h_{1},h_{2}, h_{3}, h_{4}, h_{5}, h_{6} \}$ ,$\{h_{1} =79,h_{2} =102$ and now the$,h_{3} =550,h_{4} =997,h_{5} =99,h_{6} =571\}$ needs to generate a pair$GW$ such that a session key is attained and both the entities are able to attain a new session key. Here,$(A,B)$ on basis of$GW$ parameter generates$Mod_{Set} $ pair (here$(A,B,h_{4},h_{5}, h_{6})$ is computed by the$\{h_{1}, h_{2}, h_{3} \}$ such that a session key is attained. For instance now the$GW)$ must select the value of$GW$ such that$(A,B),(A_{SN}, B_{SN})$ , now assuming that$[A\bmod (79)\ast B\bmod (102)]\bmod (550)=[A_{SN} \bmod (997)\ast B_{SN} \bmod (99)]\bmod (571)$ chooses the value randomly. thus value of$GW$ . The$\{A=466,B=495,A_{SN} =449\}$ after computing the value of$GW$ will get$\{B_{SN} \}$ (the process used is similar to what was initially defined in step 2), when$\{B_{SN} =13\}$ computes$GW$ and since the pair converge to the same output, thus$127=[466\bmod (79)\ast 495\bmod (102)]\bmod (550)=[449\bmod (997)\ast 13\bmod (99)]\bmod (571)$ sends them to both the entities. Thus both the entities will be able to converge to same output. If the above condition doesn’t hold then the$GW$ generates new pair of$GW$ alone or generates a new session key or requests the user to provide new modulus based credentials and a new$\{A_{SN}, B_{SN} \}$ pair till the condition is met. In the proposed key exchange part, the novelty exists in the fact that although the two different entities are communicating on different modulus bases, they end up converging on the same session key. The use of more than one modulus has been motivated by the standardized digital signature algorithm [41] (which was motivated from the ElGamal scheme [42]) and Elgamal scheme [42] which produces probabilistic scheme. Thus given a message collision of results which can return same value is attained, but finding it is infeasible to do in polynomial time. Motivated by previous schemes the security of the proposed work is further enhanced by making use of three session specific modulus, where these modulus values are hidden, thus making it infeasible for an adversary to computationally attain the session key. Moreover, it can be evident from the proposed scheme that given a session key and modulus it is feasible to produce$\{A_{SN}, B_{SN} \}$ or$A$ and attain the value of$A_{SN} $ ,$B$ such that same session key is attained (by both the entities) but finding other pairs is infeasible by an entity who has no information about the modulus (even if the adversary desires to attain the pair, the adversary must brute force across different ephemeral pairs to attain a successful one). Thus, given a session key, only a valid entity can generate many ephemeral pairs as to converge on the same session key. To best of knowledge, the proposed work is the only probabilistic hash modulus based key agreement protocol.$B_{SN}$ Step 5:
Both the mobile device and the sensor node send the hello message to the gateway node by using appropriate pseudonym and credentials (comprising data encrypted using the exchanged session key, where the data is the pseudonym, timestamp and the sequence numbers which were communicated earlier) when the first comm-unication is initiated. Thus, confirming the credibility of the session key, if either entity fails to send the message, the said session is terminated by the
.$GW$
In the proposed scheme, every exchanged info-rmation plays a very crucial role, for instance the role of random number generated by the
C. Password Change Phase
In this phase the user decides to change the password enabled on the device. The following are the steps involved in this phase.
Step 1:
The user
provides authentication credentials$U$ and$ID_{U}$ adhered to which the mobile device computes$Pwd$ (by fetching the random number$HPwd^{\ast }=h(Pwd^{\ast }\vert \vert Nonce_{U} \vert \vert Timestamp_{U})$ and timestamp$Nonce_{U} $ from the device),$Timestamp_{U} $ and checks the validity of the input credentials by verifying if$GW_{2} \oplus HPwd^{\ast }=Key_{U}^{\ast }$ holds. If the above condition fails then the request is rejected. However, if the condition does hold then the$h(ID_{U}^{\ast } \vert \vert Key_{U}^{\ast } \vert \vert HPwd^{\ast } \vert \vert GW_{1})^{\ast }\mathop{=}\limits^{?} GW_{3} $ provides new password credentials$U$ which is updated on the storage by computing$Pwd_{New}$ (where$HPwd=h(Pwd_{New} \vert \vert Nonce_{U} \vert \vert Timestamp_{\delta })$ is the fresh timestamp generated by the mobile device),$Timestamp_{\delta } $ ,$GW_{2}^{New} =HPwd_{New} \oplus Key_{U} $ . Thus, the previous authen-tication credentials are now updated with new authen-tication credentials. Now, the$GW_{3}^{New} = h(ID_{U} \vert \vert Key_{U} \vert \vert HPwd_{New} \vert \vert GW_{1})$ generates an authentication message so that the gateway node$U$ can update the said credentials, the$GW$ where$M_{4} =\{PublicIdentifier_{U}, H_{\alpha }, H_{\beta }, Timestamp_{\delta } \}$ and$H_{\alpha } =h(Pwd\vert \vert HPwd\vert \vert ID_{U} \vert \vert Timestamp_{U} \vert \vert Seq_{Num})\oplus HPwd_{New} $ . Now, the$H_{\beta } =h(HPwd_{New} \vert \vert ~Timestamp_{\delta } \vert \vert Seq_{Num})$ sends the message$U$ ,$M_{4} =\{PublicIdentifier_{U}, H_{\alpha } $ to the$H_{\beta },Timestamp_{\delta } \}$ .$GW$ Step 2:
The
computes$GW$ and checks if$H_{\alpha } \oplus H(Pwd ~\vert \vert ~ HPwd\vert \vert ID_{U} \vert \vert ~Timestamp_{U}^{\ast } \vert \vert Seq_{Num})=HPwd_{New}^{\ast } $ holds. If above holds then the password is updated else the request is rejected. Thus, the change of password enhances security (similar to [8], [15]), and makes it less vulnerable than [21], where there is no provision to change in password.$H_{\beta }^{\ast } \mathop{=}\limits^{?} H_{\beta } $
Security Analysis
In this section, an analysis is provided so that it is evident to the readers as of how the proposed scheme is secure against and it resists various wicked attacks.
A. Authentication Proof Using BAN Logic
BAN logic is used for examining the security of any authentication protocol. The aim is to ensure that successful authentication is taking place. The logic defined in [7], [15]–[18] is used to provide security proof of the protocol. For proving the depicted goals in later part, approach similar to that of [7], [15] is used. Following are the set of rules of interest.
Message Meaning Rule:
$R_{1} :\frac {P\vert \equiv P \mathrel {\mathop {\longleftrightarrow }\limits ^{K}}Q,P\triangleleft \{X\}_{K}}{P\vert \equiv Q\vert \sim X}$ Nonce Verification Rule:
$R_{2} :\frac {P\vert \equiv \# (X),P\vert \equiv Q\vert \sim X}{P\vert \equiv Q\vert \equiv X}$ Jurisdiction Rule:
$R_{3} :\frac {P\vert \equiv Q\Rightarrow X,P\vert \equiv Q\vert \equiv X}{P\vert \equiv X}$ Freshness Rule:
$R_{4} :\frac {P\vert \equiv \# (X)}{P\vert \equiv \# (X,Y)}$ Belief Rule:
$R_{5} :\frac {P\vert \equiv (X,Y)}{P\vert \equiv (X)}$ Seeing Rule:
$R_{6} :\frac {P\triangleleft (X,Y)}{P\triangleleft (X)}$ ER1 or Hash Verification Rule ([15]):
$R_{7} :\frac {P\vert \equiv Q \mathrel {\mathop {\longleftrightarrow }\limits ^{K}} P,P\triangleleft f(X,Y)}{P\vert \equiv Q\vert \sim X}$ Session Key Rule:
$R_{8} :\frac {P\vert \equiv \# (X),P\vert \equiv Q\vert \equiv X}{P\vert \equiv P \mathrel {\mathop {\longleftrightarrow }\limits ^{K}} Q}$
or\begin{equation*} \hspace {-2pc}U \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{~~PublicIdenitfier_{U}, Key_{V1}, GW_{1}, GW_{2}, GW_{3}, Seq_{Num}, ID_{U}, HPwd}}GW\end{equation*} View Source\begin{equation*} \hspace {-2pc}U \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{~~PublicIdenitfier_{U}, Key_{V1}, GW_{1}, GW_{2}, GW_{3}, Seq_{Num}, ID_{U}, HPwd}}GW\end{equation*}
\begin{equation*} \hspace {-2pc}GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{~~PublicIdenitfier_{U}, Key_{V1}, GW_{1}, GW_{2}, GW_{3}, Seq_{Num}, ID_{U}, HPwd}} U\end{equation*} View Source\begin{equation*} \hspace {-2pc}GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{~~PublicIdenitfier_{U}, Key_{V1}, GW_{1}, GW_{2}, GW_{3}, Seq_{Num}, ID_{U}, HPwd}} U\end{equation*}
or$GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{PublicIdenitfier_{SN}, ID_{SN}, Seq_{SN}, Key_{SN}}} SN$ $SN \mathrel {\mathop {\!\!\! \leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{~~PublicIdenitfier_{SN}, ID_{SN}, Seq_{SN}, Key_{SN}}} GWGW\vert \equiv U\Rightarrow {GW}$ $Gw \vert \equiv GW\Rightarrow (H_{\alpha 1}, H_{\alpha 2}, Nonce_{U}, h_{1}, h_{2}, h_{3})$ ,$U\vert \equiv GW\Rightarrow (H_{\alpha 3}, H_{\alpha 4}, H_{\alpha 5}, Nonce_{GW}, NewSeq_{Num}$ $NewPublicIdentifier_{U}, A,B)$ $SN\vert \!\equiv \! GW\!\Rightarrow \! (H_{\alpha 6}, H_{\alpha 7}, H_{\alpha 8}, Nonce_{GW1}, NewSeq_{Num}, A_{SN}, B_{SN})$ ,$U\vert \equiv \# (Timestamp_{GW}$ ,$Nonce_{G}$ ,$NewSeq_{Num}$ ,$NewPublicIdentifier_{U}$ ,$A$ $B)$ $GW\vert \equiv \# (Timestamp_{U}^{1}, Nonce_{U}^{1})$ $SN\vert \equiv \# (Timestamp_{GW}, Nonce_{GW}, NewSeq_{SNNum}, A_{SN}, B_{SN})$
$GW\vert \equiv \# (H_{\alpha 1}, H_{\alpha 2})$ $GW\vert \equiv (Seq_{Num})$ $GW\vert \equiv U \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Nonce_{U}^{1}}} GW$ $GW\vert \equiv U \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{h_{1}, h_{2}, h_{3}}} GW$ $U\vert \equiv \# (H_{\alpha 3}, H_{\alpha 4}, H_{\alpha 5}, A,B)$ $U\vert \equiv GW\vert \equiv (H_{\alpha 3}, H_{\alpha 4}, H_{\alpha 5}, A,B)$ $U\vert \equiv (NewSeq_{Num}, NewPublicIdentifier_{U})$ $U\vert \equiv GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\!\!\!-\!\!\!\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{NewSeq_{Num}, NewPublicIdentifier_{U}}}U$ $GW\vert \equiv GW \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}}}U$ $U\vert \equiv GW \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}}}U$ $U\vert \equiv GW\vert \equiv GW \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}}}U$ $GW\vert \equiv U\vert \equiv U \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}}}GW$ $SN\vert \equiv \# (H_{\alpha 6}, H_{\alpha 7}, H_{\alpha 8})$ $SN\vert \equiv SN \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{h_{4}, h_{5}, h_{6}}}GW$ $SN\vert \equiv NewSeq_{SNNum} $ $SN\vert \equiv GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}, NewSeq_{SNNum}}}SN$ $SN\vert \equiv GW\vert \equiv GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}, NewSeq_{SNNum}}}SN$
Using the message
, rule$M_{1} $ we get$R_{6} $ .$GW\triangleleft (H_{\alpha 1}, H_{\alpha 2})$ Using previous result from the step A, belief 1 and rule
we get$R_{7} $ .$GW\vert \equiv U\vert \sim (H_{\alpha 1}, H_{\alpha 2})$ With result of step A, belief 7 and rule
we get$R_{4} $ .$GW\vert \equiv \# (H_{\alpha 1}, H_{\alpha 2})$ With the result of step B, C and rule
we get$R_{2} $ .$GW\vert \equiv U\vert \equiv (H_{\alpha 1}, H_{\alpha 2})$ With the result of step D, belief 3 and rule
we get$R_{3} $ .$GW\vert \equiv (H_{\alpha 1}, H_{\alpha 2})$ Using the message
, with the result of step E and rule$M_{1} $ we get$R_{5} $ .$GW\vert \equiv (Seq_{Num})\left({\frac {GW\vert \equiv (Seq_{Num}, H_{\alpha 1})}{GW\vert \equiv (Seq_{Num})}}\right)$ Using the result of step C, D and rule
we get$R_{8} $ .$GW\vert \equiv U \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Nonce_{U}^{1}}}GW$ Using the result of step C, D and rule
we get$R_{8} $ .$GW\vert \equiv U \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{h_{1}, h_{2}, h_{3}, A,B}} GW$ Using the result of step C, D and rule
we get$R_{8} $ .$GW\vert \equiv GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}}} U$ Using the message
, rule$M_{2} $ we get$R_{6} $ ,$U\triangleleft (H_{\alpha 3}$ ,$H_{\alpha 4}$ ,$H_{\alpha 5}$ ,$A$ .$B)$ With the result of the step J, belief 1 and rule
we get$R_{7} $ .$U\vert \equiv GW\vert \sim (H_{\alpha 3}, H_{\alpha 4}, H_{\alpha 5}, A,B)$ With the result of the step J, belief 6 and rule
we get$R_{4} $ .$U\vert \equiv \# (H_{\alpha 3}, H_{\alpha 4}, H_{\alpha 5}, A,B)$ With the result of the step J, K and rule
we get$R_{2} $ .$U\vert \equiv GW\vert \equiv (H_{\alpha 3}, H_{\alpha 4}, H_{\alpha 5}, A,B)$ Using the result of step M, belief 4 and rule
we get$R_{3} $ .$U\vert \equiv (NewSeq_{Num}, NewPublicIdentifier_{U}, A,B)$ With the result of step L, M and rule
we get$R_{8} $ .$U\vert \equiv GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!\!\!\!-\!\!\!-\!\!\!-\!\!\!\!\!\!-\!\!\!\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{NewSeq_{Num}, NewPublicIdentifier_{U}, A,B}} U$ With the result of step L, M and rule
we get$R_{8} $ .$U\vert \equiv GW \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}}} U$ Using the result of step O, belief 4 and rule
(similar to [7]) we get$R_{2} $ .$U\vert \equiv GW\vert \equiv GW \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}}} U$ Using the result if step I, belief 3 and rule
(similar to [7]) we get$R_{2} $ .$GW\vert \equiv U\vert \equiv U \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}}} GW$ Using the message
, rule$M_{3} $ we get$R_{6} $ .$SN\triangleleft (H_{\alpha 6}, H_{\alpha 7}, H_{\alpha 8}, A_{SN}, B_{SN})$ Using previous result from the step S, belief 2 and rule
we get$R_{7} $ .$SN\vert \equiv GW\vert \sim (H_{\alpha 6}, H_{\alpha 7}, H_{\alpha 8}, A_{SN}, B_{SN})$ Using the result from step S, belief 8 and rule
we get$R_{4} $ .$SN\vert \equiv \# (H_{\alpha 6}, H_{\alpha 7}, H_{\alpha 8}, A_{SN}, B_{SN})$ Using the result T, U and rule
we get$R_{2} $ .$SN\vert \equiv GW\vert \equiv (H_{\alpha 6}, H_{\alpha 7}, H_{\alpha 8}, A_{SN}, B_{SN})$ Using the result of step V and rule
we get$R_{5} $ .$SN\vert \equiv NewSeq_{SNNum} $ Using the result of step U, V and rule
we get$R_{8} $ .$SN\vert \equiv SN \mathrel {\mathop {\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{h_{4}, h_{5}, h_{6}}} GW$ Using the result of step U, V and rule
we get$R_{8} $ .$SN\vert \equiv GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}, NewSeq_{SNNum}}} SN$ Using the result Y, belief 5 and rule and rule
(similar to [7]) we get$R_{2} $ .$SN\vert \equiv GW\vert \equiv GW \mathrel {\mathop {\!\!\!\leftarrow \!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!-\!\!\!\rightarrow }\limits ^{Key_{Session}, NewSeq_{SNNum}}}SN$
B. Formal Verification Using Real-or-Random Oracle Model and AVISPA
In this paper Real-Or-Random Oracle model is used to prove the semantic security of the scheme [9], [20], [21], [34], a design of a security model is very beneficial as it helps us in delivering of robust security goals, the said model has following components which are of interest:
Participants: The participants are the user (
), senor node ($U$ ) and the Gateway node ($SN$ ) where the communication is taking place between one of the subset of$GW$ ,$U (U_{i} \subseteq U)$ and a$SNSN_{j} \subseteq SN$ , each of the user from the subset must communicate keeping the abilities of adversary in check. Consider$GW$ be the three instances u, v of the subset user ‘u’, sensor node ‘v’ and a gateway node ‘w’. The above are defined as an oracle.$\prod \nolimits _{V_{i}}^{u}, \prod \nolimits _{SN_{j}}^{v}, \prod \nolimits _{TA}^{w} $ Accepted State: A given instance say
will be in an accepted state if it has received the last expected message from the protocol. The session IDs are defined by concatenating every exchanged message (sent and received) by the given instance$\prod ^{u}$ in the right order.$\prod ^{u}$ Partnering: Two instances
are said to be partners of each other if they satisfy all of the below conditions in parallel. (1) The three instances$\prod ^{u},\prod ^{v},\prod ^{w}$ are in the Accepted State, (2) The three instances$\prod ^{u},\prod ^{v},\prod ^{w}$ are in possession of the same session ID and are mutually authenticated and (3) The three instances$\prod ^{u},\prod ^{v},\prod ^{w}$ are mutual partners of each other.$\prod ^{u},\prod ^{v},\prod ^{w}$ Adversary: The adversary has various abilities which it might use to disrupt the scheme and perform wicked attacks. The adversary can play both active and passive attacks, the passive attack is where the adversary is observing the communication flow across two instances
while active attack is where the adversary takes an active part in the communication, the adversary can perform various attacks such as modification, forging, masquerade, etc. The following are the queries which define various adversarial abilities. (1)$\prod ^{u},\prod ^{v}$ : It is a passive attack where the adversary is able to capture various messages which are passed through the channel and the goal of the adversary here is to attain useful information to attain useful information from the communication, thus it can be viewed as a basic eavesdropping. (2)$Exec\left({\prod ^{u},\prod ^{v}}\right)$ : It is an active attack where an adversary tries to impersonate an honest user$SND\left({\prod ^{u},Msg_{\alpha } }\right),SND\left({\prod ^{v},Msg_{\beta } }\right)$ or the sensor node$U_{i} \subseteq U$ by sending fraudulent message$SN_{j} \subseteq SN$ and it receives a reply/response from$Msg_{\alpha } /Msg_{\beta } $ , in this attack an adversary usually takes a message from the previously exchanged sessions and tries to tamper with the message or replay (or suppress replay) the same message again, in hope it gets accepted. (3)$GW$ : It is an attack where the adversary is able to attain all the credentials from the mobile Unit of the user$Corrupt_{U} \left({\prod ^{u}}\right)$ , the said will be used by an adversary to gain secret information about either the password or the keys so that the adversary can impersonate the User$U$ . (4)$U_{i} \subseteq U$ : It is an attack where the adversary can gain information of either the long term key or the identity of the sensor node or user, but not both. (5)$LowCorrupt_{SN} \left({\prod ^{v}}\right)/LowCorrupt_{U} \left({\prod ^{u}}\right)$ : The said query is used to model the sematic security of the session key, the above query executed for a session then the said query returns the session key to the adversary or a random string length equivalent to the size of the actual key, the output is based on the initial assumption of bit ‘b’ made by an adversary, for instance if the bit ‘b’ is guessed correctly then the said query returns the session key. If the previous assumption is wrong then a random string of same length is returned; thus it can be said that the sematic security of the session key depends on the adversary ability to guess the bit ‘b’.$Test\left({\prod ^{u}}\right)$
Theorem 1:
In the proposed scheme, the advantage of an adversary
Proof:
For proving the semantic security of the session key the proof is distributed across different games, through succession of each game the ability of the adversary is increasing and the advantage
Game0:
is a real attack in the random oracle model, where an adversary$G_{0}^{KAU2SN}$ guesses the bit ‘b’ before beginning of the games. According to definition$A$ where\begin{equation*} Adv_{p}^{KAU2SN}=\vert 2\Pr [succ_{0} ]-1\vert\tag{1}\end{equation*} View Source\begin{equation*} Adv_{p}^{KAU2SN}=\vert 2\Pr [succ_{0} ]-1\vert\tag{1}\end{equation*}
defines an event where the adversary$succ$ is successful in breaking the semantic security of the proposed key agreement protocol.$A$ Game1:
is a passive attack where the adversary is eavesdropping on the public channel where the communication is taking place between the user and the gateway, thus in this game an adversary launches$G_{1}^{KAU2SN}$ query and based on the witnessed communication any attained information from the said communication, the adversary executes$Exec()$ query and then decides whether the output is the actual session key or a random number. It can be easily concluded that even when above two queries are provoked, the adversary will not be successful in breaking the semantic security of the proposed scheme as$Test()$ ,$Key_{Session} =[\{A\bmod (h_{1})\}\cdot \{B\bmod (h_{2})\}]\bmod (h_{3})$ and the info-rmation about the$Key_{Session} =[\{A_{SN} \bmod (h_{4})\}\cdot \{B_{SN} \bmod (h_{5})\}]\bmod (h_{6})$ is not present on any of the exchanged message$Key_{Session}$ whereas the information about the Modulus crumbs$\{M_{1}, M_{2}, M_{3} \}$ ,$(\{Nonce_{U}^{1}$ ,$ID_{U} $ ,$Key_{U} $ ,$Seq_{Num} $ ,$HPwd$ ,$Timestamp_{U}^{1}$ ,$PublicIdentifier_{U} \}$ ,$\{Nonce_{GW1} $ ,$ID_{SN} $ ,$Nonce_{SN} $ ,$Key_{SN}$ present on message$Timestamp_{GW}, Seq_{SN}, PublicIdentifier_{SN} \})$ will be enough for an adversary to generate the value of modulus$\{M_{1}, M_{2}, M_{3} \}$ ,$h_{1}$ ,$h_{2}$ or$h_{3}$ ,$h_{4}$ ,$h_{5}$ , but the adversary will not be able to do so because the adversary needs to find multiple collisions to converge and attain the session modulus values. In the above game if the key space is large then no information can be archived by the adversary using the above game, hence it can be concluded that$h_{6}$ \begin{equation*} \Pr [succ_{0} ]-\Pr [succ_{1} ]=0\tag{2}\end{equation*} View Source\begin{equation*} \Pr [succ_{0} ]-\Pr [succ_{1} ]=0\tag{2}\end{equation*}
Game2:
is an active attack, where an adversary$G_{2}^{KAU2SN}$ is taking an active part in the communication it is where an adversary has an access to$A$ query, thus an adversary is sending a query and is attaining a response in return from the$SND()$ . In this game the adversary procures an access to both$TA$ query and an oracle$SND()$ , thus an adversary$H_{Oracle} $ queries hash oracle to find a successful collision to produce fraudulent messages which will be accepted and in turn result in successful authentication of the adversary$A$ . In the proposed scheme, the message$A$ comprising$M_{1} $ (where$\{H_{\alpha 1},H_{\alpha 2} \}$ and$H_{\alpha 1} =h(Nonce_{U}^{1} ~\vert \vert ~GW_{2}~ \vert \vert ~Key_{U} ~\vert \vert ~ PublicIdentifier_{U} ~\vert \vert ~ Timestamp_{U}^{1} \vert \vert PublicIdentifier_{SN})\oplus Seq_{Num}$ is bounded by a Public identifier (which is changed after every session) and a timestamp, same holds for$H_{\alpha 2} =H(PublicIdentifier_{U} ~\vert \vert ~GW_{1} ~\vert \vert ~PublicIdentifier_{SN} ~\vert \vert ~ ID_{U} ~\vert \vert ~Timestamp_{U}^{1} \vert \vert HPwd)\oplus Nonce_{U}^{1})$ (because of new sequence number$M_{3} $ on every message) comprising of$NewSeq_{SNNum} $ ,$\{H_{\alpha 6} $ ,$H_{\alpha 7} $ (where$H_{\alpha 8} \}$ ,$H_{\alpha 6} =h(Nonce_{GW1} ~\vert \vert ~ Key_{SN} ~\vert \vert ~ B_{SN} ~\vert \vert ~Timestamp_{GW} ~\vert \vert ~PublicIdentifier_{SN} ~\vert \vert ~ NewSeq_{SNNum})\oplus Seq_{SN} $ , and$H_{\alpha 7} =h(PublicIdentifier_{SN} ~\vert \vert ~ID_{SN} ~\vert \vert Timestamp_{GW} \vert \vert ~A_{SN})\oplus ~Nonce_{GW1} $ . Thus it can be conclude that there will be no successful collisions in the$H_{\alpha 8} =Seq_{SN} \oplus h(Key_{SN} \oplus Seq_{SN})\oplus NewSeq_{SNNum})$ query due to presence of fresh timestamp, sequence number and a public identifier for every session. Thus conclusion associated with hash function from birthday paradox is to be used in order to prove the advantage of an adversary to break the semantic security of the proposed key agreement protocol. According to birthday paradox, the success of finding a collision is$SND()$ .$\frac {q_{h}^{2}}{2\vert H\vert }$ \begin{equation*} \vert \Pr [Succ_{1} ]-\Pr [Succ_{2} ]\vert \le \frac {q_{h}^{2}}{2\vert H\vert }\tag{3}\end{equation*} View Source\begin{equation*} \vert \Pr [Succ_{1} ]-\Pr [Succ_{2} ]\vert \le \frac {q_{h}^{2}}{2\vert H\vert }\tag{3}\end{equation*}
Game3:
is an attempt made by an adversary to derive secret values present on the on-board unit ($G_{3}^{KAU2SN}$ ), so that the adversary can be successful in performing various wicked attacks. In this game an adversary is given an access to the$OBU$ query, thus the adversary is now in possession of$Corrupt_{U} ()$ ,$\{PublicIdentifier_{U}, GW_{1}, GW_{2}, GW_{3}, Nonce_{U}, Seq_{Num}$ but to successfully attain the exchanged session key credentials, an adversary must rely on a successful dictionary attack to attain useful information and use the$Timestamp_{U}, H(.),Mod_{Set} \}$ .$OBU$ Moreover, the adversary can perform\begin{equation*} \vert \Pr [Succ_{2} ]-\Pr [Succ_{3} ]\vert \le \frac {q_{send}}{\vert D\vert }\tag{4}\end{equation*} View Source\begin{equation*} \vert \Pr [Succ_{2} ]-\Pr [Succ_{3} ]\vert \le \frac {q_{send}}{\vert D\vert }\tag{4}\end{equation*}
to attain the credential of either the long term key$LowCorrupt_{SN} ()$ or the identity$Key_{SN} $ . In either case the adversary must find collision in message$ID_{SN}$ in either$M_{3}$ or$H_{\alpha 6} $ to attain the other parameter.$H_{\alpha 7} $ \begin{equation*} \vert \Pr [Succ_{2} ]-\Pr [Succ_{3} ]\vert \le \frac {q_{h}^{2}}{2\vert H\vert }\tag{5}\end{equation*} View Source\begin{equation*} \vert \Pr [Succ_{2} ]-\Pr [Succ_{3} ]\vert \le \frac {q_{h}^{2}}{2\vert H\vert }\tag{5}\end{equation*}
Game4:
is a continuation of$G_{4}^{KAU2SN}$ where final attempt is made, here all of the above queries can be utilized by an adversary$G_{3}^{KAU2SN}$ to break the semantic security of the proposed group key agreement protocol to attain the session key. If even now the adversary is unable to break the semantic security and attain the session key, thus the adversaries attempt to disrupt the scheme lies in a guess.$A$ The result of step (6) can be utilized to conclude to the desired result specified earlier. Utilizing the triangular inequality it can be concluded\begin{equation*} \Pr [Succ_{3} ]=\frac {1}{2}\tag{6}\end{equation*} View Source\begin{equation*} \Pr [Succ_{3} ]=\frac {1}{2}\tag{6}\end{equation*}
Since, the value of\begin{align*} \vert \Pr [succ_{1} ]-\Pr [succ_{3} ]\vert\le&\vert \Pr [succ_{1} ]-\Pr [succ_{2} ]\vert \\&+\,\vert \Pr [succ_{2} ]-\Pr [succ_{3} ]\vert \\\le&\frac {q_{h} ^{2}}{2\vert H\vert }+\frac {q_{send}}{\vert D\vert }\tag{7}\end{align*} View Source\begin{align*} \vert \Pr [succ_{1} ]-\Pr [succ_{3} ]\vert\le&\vert \Pr [succ_{1} ]-\Pr [succ_{2} ]\vert \\&+\,\vert \Pr [succ_{2} ]-\Pr [succ_{3} ]\vert \\\le&\frac {q_{h} ^{2}}{2\vert H\vert }+\frac {q_{send}}{\vert D\vert }\tag{7}\end{align*}
thus$\Pr [Succ_{3} ]=\frac {1}{2}$ , using this result and the result of (1), (2)$\vert \Pr [succ_{1} ]-\frac {1}{2}\vert \le \frac {q_{h}^{2}}{2\vert H\vert }+\frac {q_{send}}{\vert D\vert }$ and thus resulting in (8) can be attained$2\left[{\Pr [succ_{0} ]-\frac {1}{2}}\right]\le 2\left[{\frac {q_{h}^{2}}{2\vert H\vert }+\frac {q_{send}}{\vert D\vert }}\right]$ Hence, it can be concluded that if the given hash space and the relative size of dictionary is large then it is infeasible for an adversary to break the semantic security and attain the session key. Moreover, if the\begin{equation*} Adv_{p}^{KAU2SN}\le \frac {q_{h}^{2}}{\vert H\vert }+\frac {2q_{send} }{\vert D\vert }\tag{8}\end{equation*} View Source\begin{equation*} Adv_{p}^{KAU2SN}\le \frac {q_{h}^{2}}{\vert H\vert }+\frac {2q_{send} }{\vert D\vert }\tag{8}\end{equation*}
approach is used then the result is$LowCorrupt_{SN} ()$ . Thus, depending on the size of dictionary either approach can be used.$Adv_{p}^{KAU2SN}\le \frac {2q_{h}^{2}}{\vphantom {D_{j}}\vert H\vert }$
Theorem 2:
The proposed system provides conditional security when mobile device is lost or stolen. The advantage of the adversary is given by
Proof:
To demonstrate this, a game
The table 3 depicts the simulation results in OFMC backend in AVISPA (a formal security verification tool). AVISPA is a simulation tool for security verification which justifies the security of the authentication schemes. It is also a software which is of type role related, where each participants acts as a role [7], [19], [33]. The AVISPA is written in HLPSL which is a High Level Protocol Specification Language which is then translated into IF which is an Intermediate Format lower level language can directly read by AVISPA”s back end. AVISPA has four back ends, namely, (i) OFMC (On – the – fly – Model – Checker, (ii) Constraint Logic Based Attack Searcher, (iii) SATMAC – SAT based Model Checker and Tree Automata based on Automatic Approximations. Table 3 depicts the simulation in AVISPA.
C. Informal Security Analysis
In this section informal security analysis is presented as to prove security of the proposed work against specified attack. The attack is mentioned adhered to which a description is provided which proves as of how the proposed work is secure against the specified attack.
1) Modification Attack
In this attack an adversary tries to modify the sent data so that the valid entities in the system accept these changes, the adversary in this attack can either impersonation a valid entity in the system or make malicious changes. In the proposed work, if the adversary manipulates the credentials on
2) Replay and Suppress Replay Attack
In this attack the adversary tries to impersonate the valid entity by replaying the honest authentication message generated by either
3) Known Session Specific Temporary Information Attack
In this attack, the session specific information such as
4) Impersonation Attack
In the proposed work impersonation of entities
5) DOS Attack
This attack focuses on making the resources of the system unavailable temporarily or permanently to the hosts connected to the network over the internet. In the proposed work, since every message is bounded by a timestamp
6) Identity Compromise Impersonation Attack
In the proposed work if the identity of sensor node
7) Perfect Forward Secrecy
The knowledge of current session key
8) Mobile Loss Attack
In the proposed work if the mobile device is lost, then the active adversary can attain the stored credentials
9) Known Key Attack
In the proposed work, if a session key
10) Unlinkability
In the proposed work, the pseudonym
11) Anonymity
In the proposed work since for every communication from the user
12) Man in the Middle Attack
In the proposed work, since any anomaly caused by the adversary (such as modifications, replays, etc.) on the message will be detected, thus the role of the adversary is limited to just observing the message.
Performance Analysis
In this section a tangible comparison of the proposed work is done with the existing scheme. The comparison of the proposed scheme is done in terms of execution time and communication overhead, and security features.
A. Communication Cost, Storage Cost and Execution Time
In this section the total computation cost and communication cost is presented. For communication cost of different protocols, the sensor node’s identity, gateway’s identity, output of hash function, random number are all taken as 160 bits. The length of user’s identity, pseudonym and timestamps are respectively 80 bits, 80 bits and 32 bits. The length of the modular exponentiation output is 1024 bits. The subgroup G of ECC is 160 bits, and the size of element in G is 320 bits. The block size of symmetric cryptography is 128 bits. The approach used is similar to [6], [9]. Fig 2 depicts the overall cost. The communication costs of different schemes are taken from [4], [6]. In the proposed work the exchanged messages are
The approach used is similar to that of [7], [45]. Using the similar sizes depicted earlier, it can be concluded the overall costs associated with the registration and storage cost on the storage device. For [1] the exchanged messages are
B. Comparison of Various Security Feature
The table above summarizes different attacks and depicts the vulnerabilities of different schemes. In this section several security features are provided, the term “YES” implies that the proposed scheme can withstand the said attack. While “NO” states that the said work does not satisfy the given feature. The proposed work has been motivated by [5], [38]–[40] where hash based lightweight scheme has been proposed, thus the proposed work utilizing these credentials has been developed. The proposed scheme brings more reliability due to enhanced security features. Moreover, the proposed work is secure against Privileged-insider-attack this can be proved using the approach depicted in [5], [39].
Conclusion
In this paper, a lightweight authentication and key agreement protocol for WSN in IIOT environment is proposed, where the proposed work resulted in fast authentication and unpredictable pseudonym update phase. The security of the proposed work is proved using Real-or-Random oracle model, AVISPA, BAN logic and informal security analysis. Moreover, the cryptanalysis of a ECC based authentication and key agreement scheme was presented as a result, new security goals were scoped; a new scheme overcoming vulnerabilities. The proposed work overcomes vulnerabilities present in the existing schemes and provides a new means to exchange session key faster. The rapid growth in IOT technology will lead to heavy applications in healthcare, intelligent transport systems and industrial fields where security and privacy are the major concerns. The proposed work, presents an approach which can make it useful for above applications.