Robust Authentication and Session Key Agreement Protocol for Satellite Communications

: Satellite networks are recognized as the most essential communication infrastructures in the world today, which complement land networks and provide valuable services for their users. Extensive coverage and service stability of these networks have increased their popularity. Since eavesdropping and active intrusion in satellite communications are much easier than in terrestrial networks, securing satellite communications is vital. So far, several protocols have been proposed for authentication and key exchange of satellite communications, but none of them fully meet the security requirements. In this paper, we examine one of these protocols and identify its security vulnerabilities. Moreover, we propose a robust and secure authentication and session key agreement protocol using the elliptic curve cryptography (ECC). We show that the proposed protocol meets common security requirements and is resistant to known security attacks. Moreover, we prove that the proposed scheme satisfies the security features using the Automated Validation of Internet Security Protocols and Applications (AVISPA) formal verification tool and On-the fly Model-Checker (OFMC) and ATtack SEarcher (ATSE) model checkers. We have also proved the security of the session key exchange of our protocol using the Real or Random (RoR) model. Finally, the comparison of our scheme with similar methods shows its superiority.


Figure 1: An overview of satellite communications
Because satellite communications are more susceptible to security attacks due to their broadcast nature, these communications need to be secure. Therefore, a session key is required for each communication session to encrypt the messages. There is also a need for strong authentication of both parties.
In recent years, various protocols for securing satellite communications have been proposed, most of which have security flaws. In particular, some authentication and key management protocols have provided ECC-based solutions leveraging the elliptic curve discrete logarithm problem (ECDLP) [10][11][12][13][14]. In this paper, we examine Qi et al.'s work [12] and show its security vulnerabilities. We propose a secure and robust protocol for key exchange in satellite communications, which is resistant to known security attacks and satisfies the security requirements. Further, a thorough analysis of the proposed protocol shows that it performs better in terms of security than other ECC-based protocols.
The contributions of this paper are as follows: • Analysis of key exchange protocol introduced by Qi et al. [12] and security vulnerabilities are revealed. • A secure ECC-based authentication and key exchange protocol that resists common attacks and meets common security requirements. • A thorough security analysis of the proposed protocol and its resistance to various types of attacks. • Formal security verification of the proposed protocol on AVISPA tool, considering different model checking techniques that the proposed protocol meets different security requirements. • The proof of security of the proposed key exchange protocol using the RoR model.
The rest of the paper is structured as follows: In Section 2, some essential related works are discussed. Section 3 provides background information on elliptic curve cryptography and the threat models. Section 4 describes Qi et al.'s protocol [12] and analyzes its security. Section 5 describes the proposed authentication and key exchange protocol for satellite communications. The security analysis of the proposed method is described in Section 6. In Section 7, the proposed protocol is compared with other similar protocols in terms of time complexity, communication cost, and security features. Finally, Section 8 is devoted to the conclusion.

Related Works
To provide satellite communications over unsecured networks, Cruickshank [15] developed the first satellite communication protocol in 1996. Since then, many protocols were introduced to secure satellite communications, and later on, other researchers take turns finding out weaknesses and flaws in those protocols and propose improved protocols.
Chen et al. [16] proposed an authentication mechanism for mobile satellite communication systems. Later on, Lasc et al. [17] showed that Chen et al.'s protocol was not resistant to the Denial of Service (DoS) attack and then suggested an improvement. Next, Chang et al. [18] revealed that Lasc et al.'s protocol was susceptible to impersonation attack through a stolen smart card. Then they proposed an authentication protocol for satellite communications. The newly proposed protocol was claimed to be resistant to all kinds of attacks. However, Zhang et al. [19] showed that the protocol proposed by Chang et al. was not resistant against the DoS attack and the impersonation attack.
Lee et al. [20] introduced an authentication and key exchange protocol for mobile satellite communications systems and claimed that it is resistant to all kinds of attacks. Later, Zhang et al. [21] revealed that Lee et al.'s protocol was not resistant against replay attacks, DoS attacks, and attacks from a stolen smart card. Then they developed a new protocol for satellite communication authentication. In 2018, Qi et al. [10] stated that Zhang et al.' protocol was insecure against the stolen-verifier attack and DoS attack. Then they proposed an ECC-based protocol for satellite communication authentication. In 2019, Ostad-sharif et al. [11] showed that Qi and Chen's protocol could not meet the security requirements of perfect forward secrecy and did not resist the ephemeral secret leakage attack.
Liu et al. [22] proposed a Lightweight protocol for satellite communications authentication. Later on, Qi et al. [12] showed that the protocol proposed by Liu et al. does not meet the perfect forward security requirement. Then they introduced an authentication protocol based on ECC. In this paper, we prove that the protocol of Qi et al. is not resistant to Known-session-specific temporary information attacks and insider attacks.
Altaf et al. [14] proposed an authentication and key agreement scheme which is based on the (ECDLP problem. Then, Chen and Chen [13] proved that Altaf et al.'s protocol does not provide perfect forward secrecy. Moreover, we found that their scheme is vulnerable to DoS attack. The attacker can resend the request message to the NCC many times and force it to do the time-expensive point multiplication operation many times and thus overwhelms the NCC. Furthermore, Hosseini-Seno et al. [23] have proposed an authentication and key management protocol to provide patient privacy in Tele-medical information system. The proposed protocol cautiously considers all aspects of security requirements including the perfect forward secrecy.

Elliptic Curve Cryptography (ECC)
ECC uses the elliptic curve y 2 = x 3 + ax + b over the finite field F p , where p is a prime number with typically 256-bit (or more) length. All operations in the filed F p are in the modular form. Therefore, the ECC is defined as (1): where a, b ∈ F p , 4a 3 + 27b 2 mod p = 0, and O is the point at infinity.
The ECC E p (a, b) is an Abelian group with addition as the group operation. Therefore, the addition of every two points on the curve leads to a new point on the curve. We can simulate scalar multiplication using the addition operation. The multiplication of scalar k in point R is k. R = R + · · · + R k times . The building block for elliptic curve cryptography is the elliptic curve discrete logarithm problem: Given two points R and S over E p (a, b), find k such that S = k.R. If the parameters of the elliptic curve are properly chosen, the ECDLP is believed to be infeasible with current technology [24].
To select a suitable elliptic curve, in addition to determining the values of a, b, and p, we should also define the generator G. In some elliptic curves, all points on the curve (n) can be generated with a single G. In this case, the curve has only one subgroup (h = 1). Sometimes, the curve has several subgroups (h > 1), and it is necessary to find a separate generator for each one. In the proposed method, we use ECCs with h = 1, such as secp192r1 [25]. Therefore, the ECC parameters in the proposed method are shown with a five-tuple a, b, p, n, G .

Threat Models
The most popular threat model is the Dolev-Yao model [26], which is an abstract model of agents' capabilities. The Dolev-Yao model strips away the extraneous details of communications and shows a simple view of exchanged messages. The Dolev-Yao model presents term of algebra and models the protocol messages as terms. It presents some term derivation rules which define how agents can build new terms from the old ones.
Suppose Ag, K, and N represent the set of agents, keys, and nonces, respectively. We define the set of basic terms as B = Ag ∪ N ∪ K. We denote the public key and private key of the agent A ∈ Ag using pk(A) and sk(A), respectively. Moreover, for A, B ∈ Ag we use k(A, B) to denote the shared symmetric key between them. The inverse of each k ∈ K is defined in (2)-(4).
where t 0 , t 1 ∈ B and k ∈ K.
The intruder in the Dolev-Yao model is one of the agents and has access to the hash function, public keys of all agents, his private key, and his shared key with other entities. Moreover, the intruder has full control over all communication messages between agents. He can eavesdrop, intercept, or replay the messages [27]. However, in examining the strength of security protocols, a stricter threat model such as the Canetti-Krawczyk (CK) [28] model is usually used. The attacker in the CK model not only has complete control over communications but also has the ability to obtain secret data in the system's memories. Therefore, the adversary may access private keys of parties or session-specific temporary keys. We consider the CK treat model in the analysis of our protocol.

Review and Analysis of Qi et al. Protocol
This section analyzes the protocol introdued by Qi et al. [12]. The protocol consists of four phases, namely, 1) initialization, 2) user registration, 3) login and authentication with key agreement, and 4) password update. In the registration phase, each user firstly selects his ID and password (ID i , pw i ), and sends them to the NCC with ID i , mp i = H(ID i ||pw i ) via a secure channel [12].
When the message is received, the NCC checks that the selected ID i does not belong to a duplicate user. It then performs the operations in the registration phase and finally delivers the smart card to the user. During the login and authentication phase, the user enters his smart card into the card reader and then inputs the user and password (ID i , pw i ). If it is determined that the smart card belongs to the person, the user and the NCC agree on a shared key of (SK i = αβ.G) by transmitting messages to each other. So, from now on, the user and the NCC can communicate using the shared key.
We demonstrate that the protocol proposed by Qi et al. is vulnerable against attacks, as follows.

Known Session-Specific Temporary Information Attack
If the random parameters generated in a protocol are captured by the attacker, the session key should not be revealed. However, in the Qi et al.'s protocol, the session key SK i = αβ. G is generally made up of random numbers α and β and a base point, which is considered general. So, by revealing random numbers, the attacker gains the key to the session.

Insider Attack
It is assumed that the internal attacker (here NCC) tries to obtain the password of each user. Since the user sends the mp i = H(ID i ||pw i ) and ID i to the NCC, and the password is usually short, the internal attacker on the NCC side can guess the password using the hash table.

The Proposed Protocol
The proposed protocol uses elliptic curve encryption and consists of initialization, registration, and authentication and key agreement steps. Tab. 1 shows the symbols used in the proposed protocol.

Initialization Phase
In this phase, the NCC sets some parameters to be used in authentication and key management. As explained in the previous section, to use the ECC cryptosystem, the NCC needs to set the five-tuple a, b, p, n, G . Besides, the NCC chooses a random number S NCC ∈ F p and computes its related public key P NCC = S NCC .G. Moreover, the NCC needs to choose the hash function h(.).

Registration Phase
To use the NCC services, the user needs to register first. The steps of user registration are depicted in Fig. 2 and are as follows: Step 1. The user U i first asks the NCC via a secure channel to send him the initialized parameters, a, b, p, n, G, h(.), ID NCC , P NCC . Step 2. After receiving the necessary parameters, the user chooses an ID and password. He also selects a random number S i ∈ F p as the private key and calculates his public key P i = S i .G. The user then calculates his masked password to hide his password from the NCC. The masked password is defined in (6).
Finally, he sends the triple ID i , P i , MPW i through the secure channel to the NCC.
Step 3. Upon receiving ID i , P i , MPW i , the NCC checks the validity of ID i . If the ID is legitimate, the NCC computes M i , which is a combination of the user's identity, the NCC's identity, and the NCC's private key as defined in (7).
Then, the NCC performs the XOR operation on M i and MPW i to calculate A i as defined in (8).
Finally, the NCC sends A i to U i via the secure channel.
Step 4. The user calculates the hash of his identity, his password, and his private key as defined in (9).
Finally, he stores [ a, b, p, n, G , h(.), ID NCC , P NCC , A i , S i , HIDP i ] in his mobile device.

Authentication and Key Agreement Phase
Upon completion of the registration, the user and the NCC start a two-way authentication and key exchange process to communicate with each other via an insecure channel. A complete description of this phase is given in Fig. 3 and is described in the following steps: Step 1. The user enters his identity and password (ID i , PW i ). Here, the ID and password are shown using the prime symbol to indicate that these values are re-entered in this step and may differ from the ID and password values in the previous phase. Then [ a, b, p, n, G , h(.), ID NCC , P NCC , A i , S i , HIDP i ] is extracted from the mobile device memory. After that, HIDP i is calculated and checked to see if this value is the same as HIDP i in the device memory (10).
If these two values are not the same, the user does not enter the correct ID and password, and the session ends. Here again, the primed form is used to indicate the recalculation of the variable in this step. Then the user's mobile device calculates the masked password MPW i and M i in (11) and (12).
It then selects a random number e i,s ∈ F p as the ephemeral private key of the session and calculates the ephemeral public key of the session E i,s = e i,s .G. The user also calculates another ephemeral secret (C i,s ) as defined in (13).
Then the mobile device calculates the masked identity of the user for this session as defined in (14).
The mobile device then sets the timestamp T i,s and calculates Res i,s as defined in (15).
Finally, the mobile device sends the four-tuple MID i,s , Res i,s , E i,s , T i,s to the LEO. Upon receiving the four-tuple, the LEO adds its own identity ID LEO to it and forwards the five-tuple Step 2. Upon receiving the message MID i,s , Res i,s , E i,s , T i,s , ID LEO , the NCC checks the validity of the LEO. Then it verifies the freshness of the message by checking that the difference between receiving time (T rec ) and the timestamp T i,s is less than Δt. Afterward, it calculates C i,s as defined in (16).
Moreover, the NCC computes ID i as defined in (18), and it aborts the session if it is not valid.
Note that here we use the double prime symbol to indicate that the variables are calculated in a new step of the protocol.
Then the NCC calculates M i and Res i,s as defined in (18) and (19).
Then the NCC selects the ephemeral private key of the session, e NCC,s ∈ F p , and computes the ephemeral public key, E NCC,s = e NCC,s .G. Moreover, the NCC calculates another secret, C NCC,s , as defined in (20). The NCC then sets the timestamp T NCC,s and calculates the session key, SK, and the verifier, Auth NCC,s , as defined in (21) and (22).
Finally, the NCC sends the four-tuple Auth NCC,s , E NCC,s , T NCC,s , MID i,s to the LEO, and the LEO forwards the triple Auth NCC,s , E NCC,s , T NCC,s to the mobile device.
Step 3. The mobile device verifies the freshness of the received message by checking T rec − T NCC,s <Δt, and it ends the session if the message is not fresh. It then calculates C NCC,s and Auth NCC,s as defined in (23) and (24).
Then, the mobile device checks whether Auth NCC,s is equal to Auth NCC,s . If it is true, it calculates the shared session key as defined in (25).
Next, the mobile device computes T s = T i,s + T NCC,s and creates Auth i,s as defined in (26).
Finally, it sends Auth i,s , T s to the LEO, and the LEO forwards Auth i,s , T s , ID LEO to the NCC.
Step 4. The NCC authenticates the user by checking whether the received Auth i,s is equal to h(ID i C i,s C NCC,s T i,s + T NCC,s ).

Security Analysis of the Proposed Protocol
In this section, we describe the security features, the robustness against several security attacks of the proposed protocol, and formally verify the correctness of the proposed protocol in terms of satisfying security features using AVISPA.

Security Features 6.1.1 Mutual Authentication
Key agreement protocols require the parties to authenticate each other. In our proposed method, the user selects the ephemeral private key e i,s and generates the ephemeral public key E i,s and the secret key C i,s . To request services, the user sends E i,s and some other messages to the NCC and keeps C i,s hidden. Except for the user, the only entity that can reproduce C i,s is NCC. The NCC reproduces the C i,s using E i,s and incorporates it into its authentication message (Auth NCC,s ). On the other hand, the NCC selects the ephemeral private key e NCC,s , from which it generates the ephemeral public key E NCC,s and the secret key C NCC,s . The NCC sends the E NCC,s to the user and holds the secret key C NCC,s . Except for NCC, the only entity that can reproduce C NCC,s is the user. The user can regenerate C NCC,s and Auth NCC,s . If the reconstructed Auth NCC,s is equal to the sent Auth NCC,s , NCC will be authenticated to the user. The user then inserts C NCC,s in his authentication message (Auth i,s ) and sends it to the NCC. If Auth i,s is equal to h(ID i C i,s C NCC,s ), the user is authenticated for NCC.

Session Key Security
The session key generated in the proposed method is shared between the user and the NCC, and no other entity can access the session key. The session key on the server-side is calculated with which requires knowing the ephemeral private key e NCC,s and the private key S NCC . The session key on the user side is calculated with NCC,s ) and requires knowledge of the ephemeral private key e i,s , the private key S i , the password PW i , and A i .

Perfect Forward Secrecy
The perfect forward secrecy guarantees the security of the session key, even though the long-term secret keys of parties are compromised. The proposed method preserves this feature because the session key is built using both long-term private keys and temporary secret keys. Even if the adversary A gets access to S i and S NCC , he cannot guess the session key.

User Anonymity
The proposed method does not send the user identity in plain text over insecure channels, but the masked user identity, MID i,s = ID i ⊕ h(C i,s ), is sent. Only the NCC can calculate C i,s using S NCC and know the user ID. Therefore, user anonymity is preserved against other entities.

Security Attacks 6.2.1 Replay Attack
Our proposed method is resistant against the replay attack because, in addition to sending the timestamp T i,s explicitly, we also embed it in the Res i,s message. So, if the adversary A updates the timestamp T i,s to T new i,s and resends the message MID i,s , Res i,s , E i,s , T new i,s , the NCC detects the attack by checking Res i,s . Also, if the attacker repeats the message Auth NCC,s , E NCC,s , T new NCC,s by changing the timestamp T NCC,s , the user will notice the attack by checking Auth NCC,s .

Man-in-the-Middle Attack
If the adversary A interrupts the communication between the valid user U i and the NCC, he should be able to send legitimate message MID i,s , Res i,s , E i,s , T i,s to the NCC. However, to build a valid Res i,s , the adversary has to know the password and the private key of U i .

Insider Attack
The user does not send the password to NCC in the registration phase explicitly but sends it in hidden form, Since the NCC does not know the user's private key S i , it cannot guess the user's password.

Impersonation Attack
If the adversary A wants to impersonate the user, he must be able to forget the request message MID i,s , Res i,s , E i,s , T i,s . Assuming that the adversary is one of the users, he can generate a random number e i,s and the secret key C i,s and create MID i,s by accessing the user ID. He can also generate E i,s and T i,s , but he cannot generate RES i,s without M i , and knowing M i relies on knowing A i and the user password PW i or knowing the NCC's private key, S NCC . 5902 CMC, 2022, vol.71, no.3

Known-Session-Specific Temporary Information Attack
If the attacker accesses the temporary session parameters in any way, he should not be able to access the session key. Since the session key, SK = h(ID i ID NCC e NCC,s .E i,s M i T NCC,s ), in our scheme is composed of both temporary and long-term parameters, it is resistant to this attack.

Smart Card Loss Attack
If the user's mobile device (or smart card) is stolen, the adversary A should not be able to impersonate the user. Our proposed method is resistant to this attack because even if the adversary access smart card information [ a, b, p, n, G , h(.), ID NCC , P NCC , A i , S i , HIDP i ], he cannot impersonate the user without the correct ID and password.

Stolen Verifier Attack
In our proposed method, NCC does not store any information about users other than their ID. Therefore, if the adversary accesses the NCC database, it will not receive any additional information.

DoS Attack
Denial of Service attacks can be done on satellite communications entities, including the users and the NCC. By persuading the NCC to perform a large number of heavy-weight point multiplication operations on the elliptic curve, the attacker causes the NCC to crash and makes it impossible to provide services to authorized users. Our proposed protocol is resistant to this attack because if one of the users wants to carry out this attack against the NCC, he himself will suffer the same heavy-weight operations. Also, due to the resistance of the proposed method to replay attacks, the adversary is not able to resend the request message to the NCC. For the same reason, it is not possible to perform this attack on system users.

Formal Security Analysis with AVISPA
AVISPA is a role-based language that provides a formal language for specifying protocols and security properties and uses several back-ends to analyze them [29,30]. Each participant in the protocol is represented by a role, which communicates with other roles by channels. The HLPSL specification is translated to an intermediate format, which is then analyzed by some back-ends. The four back-ends used by AVISPA include Tree Automata-based Protocol Analyzer (TA4SP), OFMC [31], Constraint Logic-based Attack Searcher (CL-ATSE) [32], and satisfiability-based Model-Checker (SATMC) [33].
We have implemented our protocol in the HLPSL language. We have defined a role for the user, role_Ui, and a role for the NCC, role_NCC. We have also defined a session role that specifies a session of the protocol. In addition, we have considered an environment role and defined three sessions in it. The first session is between the user and the NCC. In the second session, the intruder impersonates the user, and in the third session, the intruder impersonates the NCC. In addition, we have defined the intruder's knowledge and the security goals.
The goal of secrecy_of sec_1 examines the confidentiality of e i,s for the user. If the goal is satisfied by the protocol, the secrecy of e i,s is guaranteed. Similarly, the goal of secrecy_of sec_2 checks the confidentiality of e NCC,s for the NCC. Moreover, the goal of secrecy_of sec_3 examines that the SK is confidential between the user and the NCC, and the attacker cannot access it. Besides, the goals authentication_on auth_1 and authentication_on auth_2 examine the mutual authentication of the user and the NCC. The goal predicates request(Ui, NCC, auth_1, Eis) in role_Ui and witness(NCC, Ui, auth_1, Eis') in role_NCC are used to declare the authentication of the user by NCC. Similarly, request(NCC, Ui, auth_2, Enccs) in role_NCC and witness(Ui, NCC, auth_2, Enccs') in role_Ui are used to examine the authentication of NCC by the user. To check whether these goals are satisfied by our protocol, we use OFMC and ATSE. The results in Figs. 4 and 5 show that both of these model checkers find our protocol safe, which means that our protocol meets the secrecy of the session key and the mutual authentication of parties.

Proving the Security of Proposed Key Exchange Protocol Using RoR Model
We examine semantic security of the session key of the proposed protocol using the Real-or-Random model [34,35]. In this model, adversary A obtains a session key or a random value by querying protocol participants. The adversary must guess whether the output returned to him is a real key or a random value. For this purpose, we introduce various concepts such as participants, participant instances, oracles available to A, queries to these oracles, and the concept of partnering.
Participants. The two disjoint sets of our proposed protocol participants are U and NCC. We represent the set of all participants with P = U ∪ NCC. Moreover, we represent the j th participant of the protocol with P j ∈ P.
Participant Instances. During the execution of the protocol by the adversary, several instances of each participant may be executed. The instance i of the participant P j is denoted by Π i P j and is called an oracle.
Long-Lived Keys. Each participant P ∈ P has a secret key S P ∈ F p .
Ephemeral Keys. Each participant P ∈ P in a session s has an ephemeral key e P,s ∈ F p .
Acceptance. To simulate the protocol, first, a user instance, Π i U , sends a message, and an NCCinstance, Π j NCC , responds with another message. This process continues until both instances are terminated. At this point, each instance enters the accepted mode and has a session ID (SID), a session key (SK), and a partner ID (PID).
Partnering. Two oracles Π i U and Π j NCC which are in accepted mode are partners if both have the same session keys, SK(Π i U ) = SK(Π j NCC ), the same session IDs, SID(Π i U ) = SID(Π j NCC ), and PID(Π i U ) = Π j NCC , and PID(Π j NCC ) = Π i U . Protocol Execution. A protocol indicates how participant instances behave in response to signals received from the environment [36]. Intending to break the protocol security, the adversary sends signals to the instances of the participants (oracles) and receives a response according to the rules of the protocol. In fact, the adversary sends queries to oracles, and these queries model the attacker's ability in a real attack. Types of queries include: • Execute(Π i U , Π j NCC ). With this query, the adversary models a passive attack in which the adversary eavesdrops on messages exchanged between the i th instance of U, Π i U , and the jth instance of NCC, Π j NCC . • Send(Π i P j , m). With this query, the adversary models an active attack. The adversary sends the message m to oracle Π i P j , and the oracle responds according to the protocol. • Reveal(Π i P j ). If oracle Π i P j is in accepted mode (has a session key), this query will reveal the session key to the adversary A. The session key may be revealed for a variety of reasons, such as hacking a participant. Of course, disclosing the key of one session does not break other sessions. If a Reveal(Π i P j ) query is asked by A, the oracle Π i P j is opened. • Corrupt(Π i P j ). Using this query, the adversary can access the long-lived key of the oracle Π i P j . This query lets us examine the forward secrecy requirement of the protocol.
• Test(Π i P j ). This query measures the semantic security of the session key (if any) of the oracle Π i P j . If the session key is not defined for Π i P j , ⊥ is returned. Otherwise, coin c is tossed first. If c = 0, then the session key is returned to A, and if c = 1, a random value (with the same distribution as the valid session keys) is returned.
Freshness. An oracle Π i P j is fresh if it is in the accept mode, and Π i P j and its partner are not open (by Reveal query).
Semantic Security of A Key Exchange Protocol. Suppose adversary A executes the key exchange protocol PRO and has access to Execute, Send, Reveal, Corrupt, Corrupt_Ephemeral, and Test queries. The adversary can ask the Test query up to one time for each fresh oracle. Suppose the adversary's guess for the Test query is c . The adversary wins the game if c = c, where c is the value of the coin set before the game. The protocol PRO is secure if the advantage of the probabilistic polynomial-time adversary in breaking the session key is negligible, as shown in (27).
Theorem 1. Suppose adversary A can execute a maximum of N h Hash query, N s Send query, and N e Execute query to break our proposed key exchange protocol, PRO_SAT. The advantage of A in breaking the PRO_SAT protocol is given in (28): where |H| is the range space of the Hash oracle, |D| is the size of the password dictionary, and p is the prime number in F p .
Proof. To prove Theorem 1, we define a six-step game: G0 to G5.
G0. Game 0 is the real attack of A against our proposed protocol, PRO_SAT. Intuitively, the adversary can win the game with the probability of 1/2. The advantage of the adversary to break the semantic security of PRO is |Pr(SUCC 0 ) − 1/2|, where SUCC 0 is the event in which A guesses the coin correctly and wins the game. Rescaling it, we can define the advantage of A as (29).
G1. In this game, we simulate passive attacks by the adversary. The adversary eavesdrops on messages between oracles Π i U and Π j NCC with an Execute query. The adversary then decides with the Test query that the session key returned to him is real or random. To create a session key in the proposed protocol, the ephemeral keys of the user and NCC, as well as long-term keys of both parties are needed.
To be more precise, the session key is made in the client using the long-term key S i and the ephemeral private key e i,s . It is made in NCC using the long-term key S NCC and the temporary private key e NCC,s . The adversary cannot gain access to any of these keys by simulating eavesdropping attacks, and his advantage in violating the security of the session key does not increase, as shown in (30).
G2. In this game, in addition to simulating eavesdropping attacks, active attacks are also simulated with the Send query. Active attacks by the adversary can be one of three attacks: replay attack, man-inthe-middle, or impersonation attack. As stated in sections 6.2.1, 6.2.2, and 6.2.4, the proposed method is immune to these attacks. Therefore, the advantage of A in this game does not increase. Therefore, we have: G3. In this game, the adversary queries the Hash oracle N h times to find collisions. The birthday paradox states that the probability of collisions in the output of the Hash oracle is at most N 2 h /2|H|.
Moreover, since S i , S NCC , e i,s , and e NCC,s are randomly selected from F p , the probability of collision in the Send and Execute oracles is at most (N s + N e ) 2 /2p. So, we have: G4. This game simulates the smart card loss attack. If the mobile device (or smart card) of the user is stolen, A may try to guess the password using an online dictionary attack. Since the number of password failures is limited by the protocol, we have: G5. In this game, the adversary asks the Corrupt query and gets the oracle's long-lived key in response.
Of course, to get the session key, A needs the long-lived keys of both oracles in communication. Also, to create the session key, A needs to have access to ephemeral keys for each session. To access the onetime keys of each session, the adversary must be able to solve the ECDLP problem. If the advantage of A for breaking the ECDLP is Adv ECDLP (A), we have: Given that Pr(SUCC 5 ) = 1/2, we can calculate the advantage of A using (29) to (34), as shown in (35).

Performance Analysis and Comparison
In this section, we examine the computational complexity of the proposed method. The messages in the proposed protocol are obtained by combining xor, hash, and scalar multiplication on the elliptic curve. In calculating time complexity, we ignore the xor time execution, and we calculate the time required for hash and scalar multiplication based on the time reported in [37]. The computation times of various cryptographic operations, reported by Xu et al. [37], are as follows: • T h is the time of the one-way hash function, which is 0.0004 ms.
• T sm is the time of scalar multiplication on elliptic curves, which is 7.3529 ms.
• T me is the time of modular exponentiation, which is 1.8269 ms.
• T s is the time of symmetric encryption/decryption, which is 0.1303 ms.
The time complexity of our protocol includes the time spent by the user's mobile device and the time spent by the NCC. The time spent by the mobile device is 7T h + 4T sm and the time consumed by the NCC is 6T h + 4T sm , and the total time is 13T h + 8T sm , which is equal to 58.8284 milliseconds.
To measure the communication cost of the proposed method, we need to measure the size of the messages exchanged between the different entities of the protocol. Messages consist of a combination of IDs, hash values, timestamps, and points on the elliptic curve. To calculate the communication cost, suppose each identifier is 64 bits long, the hash size is 256 bits, the timestamp is 64 bits, and the point size on the elliptic curve is 192 bits (due to secp192r1 selection).
To exchange the session key between the user and the NCC, it is necessary to send messages MID i,s , Res i,s , E i,s , T i,s , MID i,s , Res i,s , E i,s , T i,s , ID LEO , Auth NCC,s , E NCC,s , T NCC,s , MID i,s , and Auth NCC,s , E NCC,s , T NCC,s . Therefore, the communication cost of our protocol is 4 × ecc + 7 × hash + ID + 3 × timestamp = 4 × 192 + 7 × 256 + 64 + 3 × 64 = 2816 bits.
At the end of this section, we compare the proposed method with several similar methods, which are all based on the ECDLP problem, in terms of security features and computational cost. As shown in Tab. 2, Tsai et al.'s protocol [38] does not satisfy perfect forward secrecy. Moreover, it is vulnerable to the known-session-specific temporary information attack and DoS attack. The protocol of Qi and Chen [10] does not meet the perfect forward secrecy and is not resistant against the known-sessionspecific temporary information attack. The protocol of Qi et al. [12] is vulnerable to insider attack and the known-session-specific temporary information attack. Finally, Altaf et al.'s protocol [14] is vulnerable to DoS attack and does not meet perfect forward secrecy. We see that our method, by spending a little more time, is resistant to the known attacks and meets security requirements. We also see that the communication cost of the proposed method is almost similar to other methods except [12] in which modular exponentiation are used.

Conclusion and Future Work
This paper contributes towards the widespread deployment of satellite applications by tackling one of the main challenges, i.e., security issues. This paper first analyzed the authentication protocol for satellite communications proposed by Qi et al. and proved its vulnerability to two kinds of security attacks. Then this paper presented a robust secure authentication and key agreement protocol based on elliptic curve cryptography for secure satellite communications. Moreover, a thorough security analysis of the proposed protocol was performed. The security analysis showed that it is resistant to all known attacks. Besides, the formal verification of the proposed method proved that it satisfies the security requirements.
As future work, the protocol performance can be improved in terms of time execution by reducing the number of scalar multipliers while preserving the security requirements. Implementation on application in blockchain [39] and software defined network [40] are also considered as future works.

Funding Statement:
The authors received no specific funding for this study.

Conflicts of Interest:
The authors declare that they have no conflicts of interest to report regarding the present study.