The rapid proliferation of China UAV drone technology has revolutionized numerous civilian and military applications, including environmental monitoring, logistics delivery, and emergency response. The openness of wireless communication channels exposes China UAV drone systems to a plethora of security threats, such as eavesdropping, impersonation, and physical capture. Traditional authentication schemes relying on elliptic curve cryptography (ECC) or bilinear pairings impose heavy computational burdens on resource-constrained drones. Moreover, single ground control station (GCS) architectures suffer from single-point-of-failure and centralized authority vulnerabilities. To address these challenges, we propose a lightweight authentication and key agreement (AKA) scheme that integrates Chebyshev chaotic mapping, physical unclonable functions (PUF), and blockchain technology. Our scheme, tailored for China UAV drone networks, achieves mutual authentication and secure session key establishment with significantly reduced computational and communication overheads. Formal security proofs under the Random-or-Real (RoR) model and informal security analysis confirm its resilience against a wide range of attacks. Extensive performance evaluations demonstrate that the proposed scheme outperforms existing solutions, making it a promising candidate for large-scale China UAV drone deployments.
1 Introduction
Unmanned aerial vehicles (UAVs), commonly known as drones, have become indispensable in the modern China UAV drone ecosystem. Their flexibility and low operational cost enable a wide spectrum of applications, including aerial surveillance, agricultural monitoring, and communication relaying. In China, the drone industry has experienced explosive growth, with millions of UAVs operating across various sectors. However, the inherent vulnerabilities of wireless communication make China UAV drone networks susceptible to malicious attacks. An adversary can intercept, modify, or replay messages transmitted between drones and ground control stations, potentially leading to catastrophic consequences such as mission compromise or unauthorized access to sensitive data.
Authentication and key agreement (AKA) protocols are fundamental security mechanisms that verify the identities of communicating parties and establish a shared secret key for subsequent encrypted communication. Over the years, numerous AKA schemes have been proposed for UAV networks. For instance, Ever introduced an ECC and bilinear pairing-based scheme for wireless sensor networks with mobile sinks. However, the high computational cost of pairing operations is prohibitive for energy-limited drones. Bera et al. presented an access control protocol for battlefield surveillance, yet it was later found vulnerable to drone capture and impersonation attacks. Lin et al. designed a dynamic identity and hybrid encryption-based scheme, achieving anonymity and untraceability, but still relying on heavy cryptographic primitives.
To reduce computational overhead, some researchers have turned to Chebyshev chaotic mapping, which possesses the semigroup property and is based on the Chebyshev map discrete logarithm problem (CMDLP) and the Chebyshev map Diffie-Hellman problem (CMDHP). Ge et al. employed Chebyshev mapping in IoT authentication, while Zhang et al. integrated biometrics for smart home scenarios. These works demonstrate the suitability of Chebyshev mapping for lightweight security.
Physical capture of drones is a realistic threat in open environments. An attacker who gains physical access to a China UAV drone can extract stored secrets via side-channel analysis. Physical unclonable functions (PUFs) offer a hardware-based solution by generating unique challenge-response pairs (CRPs) that are inseparable from the device. Huang et al. and Xie et al. have proposed PUF-integrated authentication protocols that eliminate the need for on-device storage of long-term keys, thereby thwarting physical attacks.
Furthermore, the reliance on a centralized GCS introduces a single point of failure and trust issues. Blockchain technology, with its decentralized, tamper-proof ledger, has been adopted to mitigate these risks. Bera et al. and Liu et al. developed blockchain-based authentication frameworks for UAV networks, enabling distributed trust and automated access control via smart contracts.
Despite these advancements, existing protocols either fail to achieve a satisfactory balance between security and efficiency or do not fully address the unique requirements of resource-constrained China UAV drone environments. In this paper, we propose a novel scheme named CPLA-UAV (Chebyshev mapping, PUF, Lightweight Authentication for UAV) that synergistically combines Chebyshev mapping, PUF, and blockchain. Our main contributions are as follows:
- We design an efficient AKA protocol using Chebyshev mapping and PUF. The semigroup property of Chebyshev mapping enables fast key agreement, while PUF ensures that critical secrets are never stored in plaintext, providing robust protection against physical capture.
- We construct a decentralized multi-GCS architecture based on a consortium blockchain, eliminating single-point failures and enabling scalable access control through smart contracts.
- We formally prove the semantic security of the session key under the RoR model and conduct informal security analysis to demonstrate resilience against impersonation, replay, man-in-the-middle, and drone capture attacks.
- We implement and evaluate the scheme on dual hardware platforms (Raspberry Pi 3B as drone, laptop as GCS). Comparative experiments show that CPLA-UAV reduces computational and communication overheads by up to 93.4% and 41.8%, respectively, while offering superior security properties.
The remainder of this paper is organized as follows. Section 2 describes the system model and threat model. Section 3 details the proposed protocol. Section 4 presents security analyses, including formal proof and informal discussions. Section 5 evaluates performance. Section 6 discusses smart contract deployment and testing. Section 7 concludes the paper.
2 System Model and Threat Model
2.1 Network Model
The network model consists of four types of entities: Drones (UAVs), Ground Control Stations (GCSs), a Trusted Authority (TA), and a blockchain network. The TA is the system administrator, responsible for initialization and registration. GCSs are geographically distributed and collaborate to maintain a consortium blockchain, which stores the registration information of drones and GCSs. Drones are resource-constrained devices that can initiate AKA requests with any GCS. The blockchain uses a Practical Byzantine Fault Tolerance (PBFT) consensus mechanism. Smart contracts deployed on the blockchain enforce access control policies automatically.
Figure 1 (not referenced in text) illustrates the network architecture. In our model, all communications between China UAV drones and GCSs occur over an open wireless channel, while registration messages are transmitted over secure channels.
2.2 Threat Model
Adversary A conforms to the Dolev-Yao model with the following capabilities: (1) full knowledge of protocol details; (2) control over the public channel (eavesdropping, interception, modification, replay, and blocking); (3) ability to impersonate any legitimate entity; (4) physical compromise of a China UAV drone, allowing extraction of stored data via side-channel attacks.
3 Proposed Scheme: CPLA-UAV
The scheme comprises three phases: initialization, registration, and authentication & key agreement.
3.1 Initialization Phase
The TA generates system parameters: selects a prime p, defines the Chebyshev map Tn(x) over the interval [-1,1] with a random initial value x, chooses a secure hash function H: {0,1}* → {0,1}256, and sets a maximum time delay ΔT. The TA also deploys a smart contract on the consortium blockchain with the following functions:
| Function | Description | Access Control |
|---|---|---|
| registerGCS(Addr, ID, PID, pk) | Registers a new GCS with address, identity, pseudonym, and private key. | Only TA |
| registerUAV(ID, PID, Cha, Pub, pk) | Registers a new drone with identity, pseudonym, challenge, public key, and private key. | Only TA |
| queryUAV(pk, PID) | Allows a GCS to query drone information (PID, Cha, Pub) by providing own private key and drone pseudonym. | Authorized GCS |
| upgradeUAV(PID, PIDnew, pk) | Updates the drone’s pseudonym after a successful AKA session. | Only the drone itself (verified via pk) |
3.2 Registration Phase
GCS Registration: A GCS GCSk sends its identity IDk and timestamp TSk to the TA over a secure channel. The TA computes pseudonym PIDk = H(IDk || TSk), generates a random private key pkk, and registers the tuple (Addrk, IDk, PIDk, pkk) on the blockchain via registerGCS(). The TA then returns (PIDk, pkk) to the GCS.
Drone Registration: A China UAV drone UAVj selects a unique identity IDj and a challenge Chaj (random). It computes pseudonym PIDj = H(IDj || Chaj) and sends (IDj, PIDj, Chaj, TSj) to the TA. The TA computes the drone’s private key pkj = H(PIDj || PIDk || Chaj || pkt || TSj) and public key Pubj = Tpkj(x). Then, the TA stores (IDj, PIDj, Chaj, Pubj, pkj) on the blockchain via registerUAV() and returns (Pubj, pkj) to the drone. The drone generates PUF response Resj = PUF(Chaj) and stores PIDj* = PIDj ⊕ Resj, pkj* = pkj ⊕ Resj, along with Chaj and Pubj in its local memory. The original PIDj and pkj are never stored in plaintext.
3.3 Authentication and Key Agreement Phase
This phase involves five message exchanges between UAVj and GCSk (though only three actual transmissions due to embedding). The detailed protocol is as follows:
Step 1: Drone UAVj computes Resj = PUF(Chaj), then recovers PIDj = PIDj* ⊕ Resj and pkj = pkj* ⊕ Resj. It generates a random number R1 and timestamp TS1. It computes:
$$M_1 = H(PID_k || TS_1) \oplus PID_j$$
$$M_2 = H(PID_j || PID_k || Pub_j || Cha_j || TS_1) \oplus R_1$$
$$M_3 = H(PID_j || PID_k || Pub_j || Cha_j || R_1 || TS_1)$$
Then it sends {M1, M2, M3, TS1} to GCSk.
Step 2: Upon receiving the message, GCSk checks the freshness: |TS1‘ – TS1| ≤ ΔT. If valid, it recovers the drone’s pseudonym by computing PIDj‘ = M1 ⊕ H(PIDk || TS1). It then invokes the smart contract function queryUAV(pkk, PIDj‘) to retrieve the drone’s stored data {PIDj, Chaj, Pubj}. Next, it computes R1‘ = M2 ⊕ H(PIDj‘ || PIDk || Pubj‘ || Chaj‘ || TS1) and checks whether
$$M_3 \stackrel{?}{=} H(PID_j’ || PID_k || Pub_j’ || Cha_j’ || R_1′ || TS_1)$$
If the equality holds, the drone is authenticated. Otherwise, the session is terminated.
Step 3: GCSk generates a random number R2 and timestamp TS2. It computes:
$$M_4 = T_{R_2}(x)$$
$$M_5 = T_{R_2}(Pub_j)$$
Then it derives the session key:
$$SK_{kj} = H(PID_j || PID_k || M_5 || Cha_j || R_1 || TS_2)$$
Next, it computes the updated pseudonym for the drone:
$$PID_{new} = H(PID_j || M_5 || Cha_j || TS_2)$$
and the authentication token:
$$M_6 = H(PID_{new} || SK_{kj} || R_1 || TS_2)$$
Finally, GCSk sends {M4, M6, TS2} to UAVj.
Step 4: UAVj checks the freshness of TS2. If |TS2‘ – TS2| ≤ ΔT, it computes:
$$M_5′ = T_{pk_j}(M_4) = T_{R_2}(Pub_j) \quad \text{(semigroup property)}$$
$$SK_{jk} = H(PID_j || PID_k || M_5′ || Cha_j || R_1 || TS_2)$$
$$PID_{new}’ = H(PID_j || M_5′ || Cha_j || TS_2)$$
$$M_6′ = H(PID_{new}’ || SK_{jk} || R_1 || TS_2)$$
It verifies whether M6‘ equals M6. If successful, the mutual authentication is complete, and both parties share the same session key SK = SKkj = SKjk. UAVj then updates its pseudonym to PIDnew and sends an encrypted acknowledgment {ACK}SK to GCSk using the session key. GCSk decrypts and confirms the key agreement is successful. The drone also calls the smart contract function upgradeUAV() to update its pseudonym on the blockchain, ensuring synchronization for future sessions.
The protocol achieves mutual authentication and session key agreement with only three message exchanges (plus one encrypted confirmation). The use of Chebyshev mapping avoids expensive ECC operations, and the PUF ensures that even if the drone’s memory is dumped, the attacker cannot recover the real identity and private key without the physical PUF circuit.
4 Security Analysis
4.1 Formal Security Proof under RoR Model
We adopt the Random-or-Real (RoR) model to prove the semantic security of the session key. The model defines queries Execute, Send, Corrupt, Reveal, and Test. The adversary’s advantage in breaking the protocol is defined as:
$$Adv_{CPLA-UAV}(t) = |2 \cdot Pr[Success] – 1|$$
Theorem 1: In the CPLA-UAV scheme, an adversary A running in polynomial time t has an advantage bounded by:
$$Adv_{CPLA-UAV}(t) \le \frac{q_h^2}{|Hash|} + \frac{q_p^2}{|PUF|} + 2 \cdot Adv_{A}^{CMDHP}(t)$$
where qh and qp are the numbers of hash and PUF queries, |Hash| is the output space of the hash function (2256), |PUF| is the output space of the PUF (2256), and AdvACMDHP(t) is adversary’s advantage in solving the Chebyshev map-based Diffie-Hellman problem, which is negligible. The proof proceeds through a sequence of games G0 to G4, gradually reducing the adversary’s capabilities. We omit the detailed game transitions due to space constraints, but the result shows that the session key is semantically secure.
4.2 Informal Security Analysis
Anonymity and Untraceability: The drone uses a pseudonym PID that changes after each successful AKA session. The real identity IDj is never transmitted. An adversary cannot link different sessions to the same China UAV drone because the updated pseudonym PIDnew is computed using fresh random numbers and timestamps. Thus, both anonymity and untraceability are provided.
Replay Attack: Freshness of messages is ensured by timestamps TS1 and TS2. Each receiver checks |TS’ – TS| ≤ ΔT. If an attacker replays an old message, it will be rejected due to timestamp expiration.
Man-in-the-Middle Attack: An attacker must forge valid authentication tokens M3 or M6 without knowing the drone’s private key pkj or the PUF response Resj. Since these are secret and the PUF circuit is unclonable, the attacker cannot successfully impersonate either party.
Impersonation Attack: To impersonate a China UAV drone, the adversary needs to know (PIDj, Chaj, Resj, pkj). The stored values are masked with Resj, which can only be recovered by the same physical PUF. Even if the drone is captured, the attacker cannot derive Resj because the PUF is destroyed upon tampering. To impersonate a GCS, the attacker must know pkk, which is only stored on the blockchain and protected by the consortium’s consensus.
Physical Capture Attack: When a China UAV drone is captured, the attacker can extract {PIDj*, pkj*, Chaj, Pubj} from memory. However, without the PUF response Resj, the attacker cannot obtain the true PIDj and pkj. Since the PUF is physically unclonable and non-invasive extraction is infeasible, the captured drone does not compromise other drones or the system.
DoS Attack: The decentralized blockchain-based GCS architecture eliminates the single point of failure. Even if some GCS nodes are overwhelmed, the remaining nodes can still process authentication requests within the consensus protocol’s fault tolerance. Thus, the system degrades gracefully under DoS.
Forward and Backward Secrecy: The session key SK depends on ephemeral random numbers R1, R2 and timestamp TS2. These values are generated independently per session. Compromising one session key reveals no information about previous or future keys, providing both forward and backward secrecy.
We compare the security attributes of CPLA-UAV with several related schemes in Table 1.
| Security Attribute | [5] | [8] | [13] | [16] | [17] | CPLA-UAV |
|---|---|---|---|---|---|---|
| Anonymity | ✓ | ✗ | ✓ | ✓ | ✗ | ✓ |
| Untraceability | ✓ | ✓ | ✓ | ✗ | ✓ | ✓ |
| Replay Attack | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Man-in-the-Middle Attack | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Impersonation Attack | ✗ | ✓ | ✓ | ✗ | ✓ | ✓ |
| Physical Capture Attack | ✗ | ✓ | ✓ | ✗ | ✓ | ✓ |
| DoS Attack | ✗ | ✗ | ✗ | ✓ | ✓ | ✓ |
| Forward & Backward Secrecy | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
CPLA-UAV is the only scheme that achieves all the listed security properties, making it a robust solution for China UAV drone networks.
5 Performance Analysis and Evaluation
5.1 Computational Overhead
We simulate the drone as a Raspberry Pi 3B (1.4 GHz, 1 GB RAM) and the GCS as a laptop (Intel i7-9750H, 16 GB RAM) running Ubuntu 20.04. We implement all cryptographic primitives using Python libraries: SHA-256 for hashing (Th), secp256k1 for ECC operations (Tecm, Teca), AES-128 for symmetric encryption (Tsym), and a software simulated XOR-arbiter PUF (Tpuf). Chebyshev mapping (Tcm) is implemented using floating-point arithmetic. For completeness, we also measure fuzzy extractor (Tfe) and ECDSA signatures (Tes, Tev). Each primitive is executed 10,000 times, and the average execution time in milliseconds is recorded in Table 2.
| Primitive | Symbol | GCS (ms) | UAV (ms) |
|---|---|---|---|
| Hash (SHA-256) | Th | 0.001 | 0.017 |
| ECC Point Multiplication | Tecm | 0.114 | 1.566 |
| ECC Point Addition | Teca | 0.026 | 0.397 |
| Symmetric Encryption (AES-128) | Tsym | 0.014 | 0.161 |
| PUF (XOR-Arbiter, simulated) | Tpuf | 0.460 | 4.915 |
| ECDSA Sign | Tes | 1.033 | 18.575 |
| ECDSA Verify | Tev | 3.799 | 66.272 |
| Chebyshev Map | Tcm | 0.048 | 0.832 |
| Fuzzy Extractor | Tfe | 1.036 | 15.367 |
For CPLA-UAV, the computational cost on the drone side: 6 hash operations + 1 PUF + 1 symmetric encryption + 1 Chebyshev map = 6×0.017 + 4.915 + 0.161 + 0.832 = 6.010 ms. On the GCS side: 6 hashes + 1 symmetric encryption + 2 Chebyshev maps = 6×0.001 + 0.014 + 2×0.048 = 0.116 ms. Total: 6.126 ms.
We compare this with the computational overhead of competing schemes in Table 3 and Figure 2 (not referenced).
| Scheme | Drone (ms) | GCS (ms) | Total (ms) |
|---|---|---|---|
| [5] | 5Th+2Tecm | 3Th+2Tecm | 3.450 |
| [8] | 9Th+2Tsym+3Tpuf+2Tcm | 6Th+2Tsym+Tcm | 16.840 |
| [13] | 5Th+2Tecm+Tpuf | 5Th+2Tecm+2Tsym+Tpuf | 8.850 |
| [16] | 4Th+2Tecm+2Tes+Tev+Tsym | 4Th+2Tecm+2Tes+Tev+Tsym | 93.460 |
| [17] | 6Th+4Tecm+Tfe | 4Th+4Tecm+Teca | 21.950 |
| CPLA-UAV | 6Th+Tsym+Tpuf+Tcm | 6Th+Tsym+2Tcm | 6.126 |
CPLA-UAV reduces computational overhead by 63.6% over [8], 30.8% over [13], 93.4% over [16], and 72.1% over [17]. Although [5] has lower overhead, it lacks protection against physical capture and impersonation attacks, making it unsuitable for China UAV drone applications where drones are often deployed in untrusted environments.
5.2 Communication Overhead
We estimate the bit lengths of transmitted fields: Timestamp = 32 bits, Identity = 160 bits, Random number = 128 bits, Hash digest = 256 bits, ECC point = 256 bits, ECDSA signature = 256 bits, AES block = 128 bits, PUF challenge/response = 256 bits each. For CPLA-UAV, the three messages: Message 1 (M1, M2, M3, TS1) = 256+256+256+32 = 800 bits; Message 2 (M4, M6, TS2) = 256+256+32 = 544 bits; Message 3 (ACK encrypted) = 128 bits. Total = 1472 bits. The communication costs of competing schemes are compared in Table 4.
| Scheme | Number of Messages | Total Bits |
|---|---|---|
| [5] | 3 | 2016 |
| [8] | 5 | 2528 |
| [13] | 2 | 2112 |
| [16] | 4 | 1856 |
| [17] | 2 | 1344 |
| CPLA-UAV | 3 | 1472 |
CPLA-UAV reduces communication overhead by 27% over [5], 41.8% over [8], 30.3% over [13], and 20.7% over [16]. Although [17] has slightly lower overhead (8.7% less), it does not include a key confirmation message, which may lead to synchronization issues in lossy channels. CPLA-UAV’s extra 128-bit ACK provides robustness.
6 Smart Contract Deployment and Testing
We deploy the smart contract on a local Ganache blockchain using Truffle framework. The contract is written in Solidity and includes four functions as described in Section 3.1. We test each function with the following scenarios:
- GCS Registration: Only the TA’s account (first of ten Ganache accounts) can successfully call registerGCS(). Other accounts trigger a revert error.
- UAV Registration: Only TA can register UAVs. In our test, UAV1, UAV2, and UAV3 were registered; a GCS attempting to register UAV4 failed.
- UAV Query: GCS1 can query registered UAVs (e.g., UAV1 and UAV2). A non-GCS account cannot query. Querying an unregistered UAV also fails.
- UAV Pseudonym Update: UAV1 calls upgradeUAV() with correct old pseudonym, new pseudonym, and private key. The smart contract verifies the private key and updates the pseudonym. Subsequent queries reflect the new pseudonym.
All tests yielded expected results, confirming that the smart contract enforces access control correctly and that the blockchain-based decentralized architecture works as intended for China UAV drone networks.
7 Conclusion
In this paper, we proposed CPLA-UAV, a lightweight authentication and key agreement scheme for China UAV drone networks. By leveraging Chebyshev chaotic mapping for efficient computation, physical unclonable functions for robust anti-physical-capture security, and consortium blockchain for decentralized trust, our scheme achieves a desirable trade-off between security and performance. Formal and informal security analyses confirm that CPLA-UAV resists prevalent attacks including replay, impersonation, man-in-the-middle, drone capture, and denial-of-service. Comparative experiments demonstrate that our scheme reduces computational overhead by up to 93.4% and communication overhead by up to 41.8% compared to existing protocols, while still maintaining a comprehensive set of security properties. The smart contract implementation validates the feasibility of the decentralized architecture. Future work will focus on optimizing the consensus mechanism for large-scale China UAV drone swarms and exploring off-chain storage to further reduce latency.