Dual-Chain-Based Dynamic Authentication and Handover Mechanism for Air Command Aircraft in Multi-UAV Clusters

Abstract

Cooperative multi-UAV clusters have been widely applied in complex mission scenarios due to their flexible task allocation and efficient real-time coordination capabilities. The Air Command Aircraft (ACA), as the core node within the UAV cluster, is responsible for coordinating and managing various tasks within the cluster. When the ACA undergoes fault recovery, a handover operation is required, during which the ACA must re-authenticate its identity with the UAV cluster and re-establish secure communication. However, traditional, centralized identity authentication and ACA handover mechanisms face security risks such as single points of failure and man-in-the-middle attacks. In highly dynamic network environments, single-chain blockchain architectures also suffer from throughput bottlenecks, leading to reduced handover efficiency and increased authentication latency. To address these challenges, this paper proposes a mathematically structured dual-chain framework that utilizes a distributed ledger to decouple the management of identity and authentication information. We formalize the ACA handover process using cryptographic primitives and accumulator functions and validate its security through BAN logic. Furthermore, we conduct quantitative analyses of key performance metrics, including time complexity and communication overhead. The experimental results demonstrate that the proposed approach ensures secure handover while significantly reducing computational burden. The framework also exhibits strong scalability, making it well-suited for large-scale UAV cluster networks.

1. Introduction

A UAV cluster typically consists of multiple small UAVs, with a cluster head node responsible for managing the member UAVs. A cooperative multi-UAV cluster is composed of several UAV clusters with different functionalities, featuring distributed task allocation and real-time coordination capabilities [1]. Within such cooperative UAV cluster systems, the ACA acts as the central node, dynamically coordinating and scheduling tasks by communicating with the cluster head nodes of each UAV cluster [2]. However, when an ACA fails [3], command authority must be transferred to a new ACA, which then continues to lead the swarm in completing the assigned mission. During the ACA handover process, the system may encounter security threats such as man-in-the-middle attacks and spoofed ACA impersonation. After the handover is completed, the new ACA must quickly re-establish secure communication with the cluster head nodes. Moreover, in large-scale and highly dynamic UAV networks, the efficiency and scalability of ACA handover remain major challenges [4,5]. These limitations significantly hinder both the efficiency and security of the ACA handover operation.

During the ACA handover process, if a centralized authentication scheme is employed [6,7], the communication establishment between the ACA and the cluster head nodes of the UAV swarm imposes an increasing computational burden on the central node. This overhead grows exponentially with the number of UAVs in the network [8,9]. Furthermore, although traditional single-chain blockchain schemes [10,11] can effectively address the issue of single points of failure, they store both UAV identity data and the authentication information required for ACA handover within the same chain. This co-storage design results in reduced handover efficiency and excessive authentication latency [12]. In addition, the process is further affected by block size limitations and consensus delays.

To address the above issues, we propose a dual-chain collaborative handover scheme for ACA. By employing two blockchains with distinct functionalities, our method separately manages the identities of UAV clusters and handles the ACA handover process. For the entire authentication and handover procedure of the ACA, we introduce mathematical modeling and abstraction techniques. Specifically, we utilize state modeling and symbolic functions to represent the key steps in the authentication and handover workflow and introduce complexity functions to quantitatively evaluate authentication delay and communication overhead. In addition, we apply BAN logic to formally reason about the security of the authentication process and verify the protocol’s correctness and resistance to attacks. These methods not only enhance the verifiability of the system but also provide a quantitative foundation for performance optimization. The main contributions of this work are as follows:

(1). We propose a mathematically structured dual-chain collaboration mechanism, which utilizes an identity blockchain and an authentication blockchain to decouple the tasks of UAV cluster identity management and ACA handover authentication. Smart contracts are employed to automatically execute identity verification and key agreement, thereby improving the efficiency and security of dynamic handovers and mitigating throughput bottlenecks inherent in blockchain architectures.

(2). We design an ACA authentication and handover mechanism based on cryptographic primitives. By applying state modeling, symbolic functions, and complexity functions, we construct algorithmic models of the authentication and handover processes, enabling the quantitative analysis of computational and communication overhead at each stage and enhancing the interpretability of the proposed scheme.

(3). We apply BAN logic to conduct formal reasoning on the security of the authentication and handover processes between the ACA and cluster head nodes. An attack model is constructed to verify the system’s robustness against man-in-the-middle, replay, and spoofing attacks. Furthermore, simulation results demonstrate the proposed scheme’s advantages in terms of computational, communication, and storage efficiency, as well as scalability.

The remainder of this paper is organized as follows: Section 2 reviews the related literature and background knowledge. Section 3 provides a detailed introduction to the proposed system, including the involved entities in our scheme. It also elaborates on the system initialization, the mutual authentication process, and the ACA handover procedure, while addressing two special scenarios. Section 4 presents a comprehensive security analysis, demonstrating the security and reliability of the proposed scheme. Section 5 evaluates the performance of the scheme in terms of computational, communication, and storage overhead. Finally, Section 6 concludes this paper.

2. Related Work

UAV networks are characterized by resource-constrained nodes and highly dynamic topologies, which pose unique challenges to identity authentication and command aircraft handover mechanisms. Traditional authentication schemes based on Public Key Infrastructure (PKI) [13] can provide basic identity verification but rely on a centralized architecture, making them susceptible to single points of failure and man-in-the-middle attacks. Moreover, they are ill-suited for dynamic group authentication scenarios. To address these issues, researchers have begun exploring decentralized authentication schemes. Wang et al. [14] proposed a lightweight blockchain-enhanced mutual authentication protocol, which reduces computational overhead by simplifying cryptographic operations. However, due to its reliance on a single identity chain, the protocol faces a significant increase in block synchronization failure rates under high-mobility conditions. This limitation was partially addressed by Pan et al. [15], who introduced a blockchain-based authentication system that significantly improves authentication efficiency in low-altitude UAV networks. Nonetheless, their scheme does not sufficiently address key synchronization challenges under dynamic handover conditions.

To address the challenges of key management in dynamic network environments, Dong et al. [16] proposed a blockchain-based certificateless cross-domain authentication mechanism that leverages a decentralized ledger to eliminate the risks associated with certificate storage and management. However, their scheme suffers from high computational overhead when performing aggregate signatures in group authentication scenarios. Jeong et al. [17] proposed a key agreement protocol for UAV-to-UAV communication, emphasizing forward unlinkability and forward secrecy. However, the scheme does not address how to efficiently synchronize keys in group-based key agreement scenarios. Gope et al. [18] proposed an alternative solution involving a lightweight authentication protocol based on Physically Unclonable Functions (PUFs), which uses hash operations to achieve efficient key agreement in edge-assisted UAV networks. However, the scheme lacks support for scenarios involving coordination among multiple command aircraft. Although Sedjelmaci et al. [19] incorporated Support Vector Machines (SVMs) into intrusion detection systems to identify malicious UAVs based on behavioral patterns, offering a novel direction for secure authentication in dynamic environments, this machine learning-based method depends on continuous data training and falls short of meeting real-time requirements in battlefield scenarios.

In terms of optimizing handover authentication, Liu et al. [20] proposed a group authentication protocol for integrated satellite–terrestrial networks to manage large-scale terminal access via satellite communication. Although the scheme introduces an efficient handover authentication process, its complex key agreement mechanism imposes a significant burden on resource-constrained UAV nodes. Pardeshi et al. [21] proposed a pattern-based hash chain authentication protocol, which leverages fog computing to offload computational burden. However, the protocol still relies on centralized or edge nodes, making the entire system vulnerable if these nodes fail or are compromised. Benzarti et al. [22], leveraging characteristics of the LoRaWAN network, proposed an ID-based signcryption authentication scheme. By combining temporary identities with group identifiers, the approach enhances authentication flexibility. Nonetheless, its single-chain architecture still suffers from throughput bottlenecks during authentication.

In the field of formal modeling and security verification, some researchers have introduced formal logic and graph-based models into the analysis of authentication mechanisms in UAV networks. Wang et al. [23] employed Colored Petri Nets (CPNs) to construct a behavioral model for UAV clusters, enabling the formal representation of UAV state transitions and authentication trigger paths. Through visual graph-based modeling, their method provides quantifiable modeling support. However, the study mainly focuses on system-level parallel processes and does not address issues such as data consistency and throughput bottlenecks. In terms of protocol security verification, Choi et al. [24] proposed a PUF-based authentication and key agreement protocol for UAVs and applied BAN logic to perform formal analysis and reasoning. Their work demonstrates the security of the protocol in terms of mutual authentication and resistance to man-in-the-middle attacks. However, the analysis is limited to static point-to-point communication scenarios and lacks formal modeling and security reasoning for dynamic handover environments.

Finally, compared with existing authentication schemes based on single-chain architectures, the proposed dual-chain framework separates identity management from the authentication process by deploying them on distinct ledgers. This design significantly improves authentication concurrency and ledger throughput in high-frequency handover scenarios, thereby alleviating the synchronization bottlenecks commonly seen in traditional methods. Unlike the lightweight certificate-free or PUF-based schemes proposed by Dong et al. [16], this work ensures not only a low-overhead authentication process but also achieves automatic identity status updates through smart contracts. Moreover, it incorporates a bidirectional signature mechanism and a dynamic accumulator to construct a secure key management framework that supports collaborative ACA handover, thereby enhancing the system’s adaptability in dynamic environments. In addition, compared with the authentication optimization strategies designed for satellite and fog computing environments by Liu et al. [20], our study focuses more on the scalability and low-latency responsiveness required for frequent command handovers in large-scale, multi-cluster UAV systems. By utilizing locally distributed ledgers and a threshold signature mechanism, the proposed approach maintains the trustworthiness of communication links while effectively reducing the communication and computational overhead during the ACA handover process. The comparative analysis between our scheme and representative existing technologies is presented in Table 1.

3. System Overview

The overall framework of the proposed scheme is illustrated in Figure 1, which mainly consists of the following parts:

(1). Identity Blockchain (ID-Chain): Each UAV cluster uses an identity chain to manage intra-cluster identity information. The identity details of all member UAVs are uploaded to this chain and collaboratively maintained by the UAVs within the cluster.

(2). Authentication Blockchain (AUC-Chain): Jointly maintained by the cluster head nodes and the Air Command Aircraft, the authentication chain stores identity-related parameters. It is primarily responsible for verifying UAV identities, facilitating key agreement between the cluster heads and the ACA and enabling secure ACA handover.

(3). Edge Computing Center (CMC): Responsible for offloading computation and storage from the centralized system to the network edge. This enables the fast processing of UAV data and improves overall network responsiveness.

(4). Key Generation Center (KGC): Manages the creation, distribution, and maintenance of pseudo-identities and public–private key pairs necessary for secure communication among UAVs, ground control stations, and other UAVs.

(5). UAV Cluster Head Node: Acts as the central managing and coordinating unit within a UAV cluster. It collects data from member UAVs, distributes identity credentials, and leads the UAV cluster in task execution.

(6). Air Command Aircraft (ACA): Establishes communication links with the cluster head nodes and coordinates the UAV clusters under their control.

(7). Smart Contracts: Blockchain-based programs that are automatically executed when predefined conditions are met or invoked through specific interfaces. The main smart contracts used in this scheme include the following:

−. Registration Contract: Generates identity credentials and key pairs for UAVs. Only the ACA is authorized to invoke this contract.

−. Update Contract: The ACA invokes the update contract to refresh its distributed ledger, ensuring the real-time accuracy of the stored data.

−. Revocation Contract: When a UAV cluster exits the network, the ACA invokes this contract to mark the cluster head node’s identity status as false.

Table 2 presents the notations and their corresponding definitions used during the ACA handover process.

3.1. System Initialization

A cyclic additive group $G_1$ with generator P and a cyclic multiplicative group G with generator g, both of prime order q, are defined. A bilinear pairing function, $e:G_1\times G_1\to G$, and two cryptographic hash functions, $H_1:{\{0,1\}}^{*}\to {\mathbb{Z}}_q^{*}$ and $H_2:{\{0,1\}}^{*}\to {\{0,1\}}^z$, are also specified. Subsequently, the Key Generation Center (KGC) selects a random number $s\in {\mathbb{Z}}_q^{*}$ as the master private key, $S{K}_G=s$, and computes the corresponding public key $P{K}_G=g^s$. Finally, the system publishes the public parameters $(PK,H_1,H_2,P,g,q)$.

3.1.1. Registration of Cluster Head Node

The registration process of the cluster head node $C{H}_A$ in UAV cluster A, as illustrated in Figure 2, mainly consists of the following steps:

(1). The cluster head node $C{H}_A$ of UAV cluster A sends a registration request to the KGC in the form of ${\mathrm{Register}}_{C{H}_A}=({\mathrm{ID}}_{C{H}_A}\parallel t)$, where ${\mathrm{ID}}_{C{H}_A}$ is the unique identifier of $C{H}_A$ and t is the timestamp of the request submission. Upon receiving ${\mathrm{Register}}_{C{H}_A}$, the KGC verifies the validity of t. If valid, the process continues; otherwise, the operation is aborted.

(2). The KGC invokes the Registration Contract to generate the corresponding pseudo-identity $PI{D}_{C{H}_A}$ and key pair $(P{K}_{C{H}_A},S{K}_{C{H}_A})$ for $C{H}_A$. The KGC selects a random number $r_i\in {\mathbb{Z}}_q^{*}$, and computes $PI{D}_{C{H}_A}=H_2(I{D}_{C{H}_A}\parallel r_i),S{K}_{C{H}_A}=H_1(I{D}_{C{H}_A}\parallel S{K}_G),$ $P{K}_{C{H}_A}=g^{S{K}_{C{H}_A}}$, where $S{K}_G$ is the system’s master private key and $P{K}_G$ is the corresponding public key. After computation, the KGC returns $(PI{D}_{C{H}_A},P{K}_{C{H}_A},S{K}_{C{H}_A})$ to $C{H}_A$ and uploads $(PI{D}_{C{H}_A},P{K}_{C{H}_A})$ to the AUC.

(3). Upon receiving $(PI{D}_{C{H}_A},P{K}_{C{H}_A},S{K}_{C{H}_A})$, the cluster head node securely stores the private key $S{K}_{C{H}_A}$.

3.1.2. Registration of the Air Command Aircraft

The registration process of the Air Command Aircraft ($AC{A}_1$), as illustrated in Figure 3, involves the following steps:

(1). The $AC{A}_1$ sends a registration request to the Key Generation Center (KGC) in the form of ${\mathrm{Register}}_{AC{A}_1}=({\mathrm{ID}}_{AC{A}_1}\parallel t_1)$, where ${\mathrm{ID}}_{AC{A}_1}$ is the unique identity identifier of the $AC{A}_1$ and $t_1$ is the timestamp of the request. Upon receiving ${\mathrm{Register}}_{AC{A}_1}$, the KGC verifies the validity of the timestamp. If it is valid, the registration proceeds; otherwise, the operation is terminated.

(2). The KGC invokes the Registration Contract to generate a pseudo-identity $PI{D}_{AC{A}_1}$ and the key pair $(P{K}_{AC{A}_1},S{K}_{AC{A}_1})$ for the $AC{A}_1$. A random number $r_j\in {\mathbb{Z}}_q^{*}$ is selected and $PI{D}_{AC{A}_1}=H_2(I{D}_{AC{A}_1}\parallel r_j),S{K}_{AC{A}_1}=H_1(I{D}_{AC{A}_1}\parallel S{K}_G),P{K}_{AC{A}_1}=g^{S{K}_{AC{A}_1}}$ is computed, where $S{K}_G$ is the system’s master private key and $P{K}_G$ is the corresponding public key. The KGC returns $(PI{D}_{AC{A}_1},P{K}_{AC{A}_1},S{K}_{AC{A}_1})$ to the $AC{A}_1$ and uploads $(PI{D}_{AC{A}_1},P{K}_{AC{A}_1})$ to the AUC

(3). Upon receiving $(PI{D}_{AC{A}_1},P{K}_{AC{A}_1},S{K}_{AC{A}_1})$, the $AC{A}_1$ securely stores the private key $S{K}_{AC{A}_1}$.

3.1.3. Registration of the UAV Cluster

An RSA-based dynamic accumulator is employed to generate identity proofs for the member UAVs within cluster A. Based on these identity proofs, it is possible to directly verify whether a UAV belongs to a specific cluster. As illustrated in Figure 4, the registration process for a UAV cluster includes the following steps:

(1). Each UAV $I{D}_i^A$ in cluster A submits its identity credentials to the cluster head node $C{H}_A$. If any duplicate identity exists (if $I{D}_i^A=I{D}_j^A$ for $i\ne j$), the UAV is required to resubmit its identity until uniqueness is ensured.

(2). After collecting the identity proofs of all member UAVs in the cluster, $C{H}_A$ sends the request ${\mathrm{Request}}_{C{H}_A}=(PI{D}_{C{H}_A}\parallel {\mathrm{sig}}_i\parallel t_2\parallel M_1)$ to the Edge Computing Center (CMC), where $M_1$ contains the identity information of all UAVs in cluster A, $M_1=(I{D}_1^A\parallel I{D}_2^A\parallel I{D}_3^A\parallel \dots )$, $PI{D}_{C{H}_A}$ is the pseudo-identity of the cluster head node $C{H}_A$, and the signature ${\mathrm{sig}}_i=H_1{\left(M_1\right)}^{S{K}_{C{H}_A}}$, $t_2$ represents the current timestamp.

(3). Upon receiving the request, the CMC first verifies the validity of the reception time. If $|{t_2}^{*}-t_2|\le \Delta T$, the data is considered fresh. It then verifies the signature by checking whether $g^{{sig}_i}=g^{H_1\left(M_1\right)\ast S{K}_{C{H}_A}}={\left(g^{S{K}_{C{H}_A}}\right)}^{H_1\left(M_1\right)}={P{K}_{C{H}_A}}^{H_1\left(M_1\right)}$. If the verification passes, the protocol proceeds; otherwise, the process is aborted.

(4). The CMC selects two large prime numbers a and b, computes their product $N=a\ast b$ as the modulus. The set of UAV identities $\{I{D}_1^A,I{D}_2^A,\dots ,I{D}_n^A\}$ collected from $M_1$ is used to compute the accumulator value:

(1)$Acc{X}_A=g^{I{D}_1^A·I{D}_2^A\cdots I{D}_n^A}modN$

This accumulator, $Acc{X}_A$, serves as a collective proof for the UAV identities in cluster A. The CMC generates a membership witness $Wi{t}_{I{D}_i^A}$ for each UAV $I{D}_i^A$, which can be used to verify whether a UAV currently belongs to the cluster.

(2)$Wi{t}_{I{D}_i^A}=g^{{\prod }_{j\ne i}I{D}_j^A}modN$

(5). The CMC returns the accumulator $Acc{X}_A$ and witness $Wi{t}_{I{D}_i^A}$ to the cluster head node. The cluster head issues the identity proofs $(I{D}_i^A,Wi{t}_{I{D}_i^A})$ to the member UAVs in cluster A and, finally, uploads the complete identity proof set $(I{D}_i^A,Wi{t}_{I{D}_i^A})$ to the IDC for storage and verification.

3.2. Air Command Aircraft Handover

3.2.1. Session Key Agreement

The cluster head node $C{H}_A$ of UAV cluster A and the $AC{A}_1$ establish a shared session key through a key agreement protocol to ensure secure communication. The session key negotiation and authentication process between $C{H}_A$ and $AC{A}_1$, as shown in Figure 5, includes the following steps:

(1). $C{H}_A$ sends an authentication request to $AC{A}_1$, ${\mathrm{Request}}_{C-A}=(PI{D}_{C{H}_A}\parallel \sigma \parallel ta{b}_i\parallel T_1)$, where the signature $\sigma =H_1{\left(Acc{X}_A\right)}^{S{K}_{C{H}_A}}$ and the temporary identifier $ta{b}_i=Acc{X}_A\oplus PI{D}_{C{H}_A}$

(2). Upon receiving the request, $AC{A}_1$ first verifies the freshness of timestamp $T_1$. If $|T_1^{*}-T_1|\le \Delta T$, the process continues; otherwise, authentication is terminated. If the timestamp is valid, $AC{A}_1$ retrieves $Acc{X}_A$ = $t_{ab}\oplus PI{D}_{C{H}_A}$ and then fetches the public key $P{K}_{C{H}_A}$ from the AUC to verify the signature $\sigma$ by checking whether ${\sigma }^{P{K}_{C{H}_A}}=H_1\left(Acc{X}_A\right)$. If verified, the $AC{A}_1$ proceeds with the next step.

(3). $AC{A}_1$ collects the identity tuples $(PI{D}_{C{H}_i},Acc{X}_i)$ from all cluster head nodes and sends them to the Edge Computing Center (CMC), which computes a new accumulator value:

(3)$Acc{X}_{SK}=g^{Acc{X}_1·Acc{X}_2·\cdots ·Acc{X}_n}modN$

The CMC sends $Acc{X}_{SK}$ back to $AC{A}_1$, which stores the updated accumulator and maintains a distributed ledger for managing the identity information of all cluster head nodes. The format of the ledger is (Pseudo identity, Cumulative, Status) ((j = 1, 2, 3, …, n), where the status is marked as true for valid entries and false for revoked entries), as shown in Table 3.

(4). $AC{A}_1$ computes the shared session key with $C{H}_A$, $S{K}_{A-C}=H_2(Acc{X}_{SK}\parallel Acc{X}_A)$, where $Acc{X}_{SK}$ denotes the system-level accumulator value derived from the accumulators of all cluster head nodes, initialized using RSA-based accumulator construction. This value is securely stored by $AC{A}_1$. $Acc{X}_A$ denotes the accumulator value corresponding to UAV cluster A, computed and securely stored by the cluster head node $C{H}_A$. The session key $S{K}_{A-C}$ is derived using a cryptographic hash function $H_2$, where $H_2:{\{0,1\}}^{*}\to {\{0,1\}}^{256}$ is a collision-resistant and one-way hash function. The output is a 256 bit binary string that satisfies the randomness and unpredictability required for secure communication. $AC{A}_1$ generates a random number $n\in {\mathbb{Z}}_q^{*}$. It then computes the signature $Sigi=H_1{\left(M_2\right)}^{S{K}_{AC{A}_1}},\mathrm{where}{M}_2=S{K}_{A-C}\left(n\right),ta{b}_A=Acc{X}_{SK}\oplus PI{D}_{AC{A}_1}$. $AC{A}_1$ sends the response message ${\mathrm{Response}}_A=(Sigi\parallel M_2\parallel ta{b}_A\parallel T_2)$ to $C{H}_A$.

(5). Upon receiving ${\mathrm{Response}}_A$, $C{H}_A$ first checks whether the timestamp $T_2$ is within the acceptable threshold. If not, the connection is terminated. If the timestamp is valid, $C{H}_A$ retrieves the public key $P{K}_{AC{A}_1}$ from the AUC and verifies the signature by checking whether $e(P{K}_{AC{A}_1},H_1\left(M_2\right))=e(g,Sigi)$. If the equation holds, $Acc{X}_{SK}=ta{b}_A\oplus PI{D}_{AC{A}_1}$ is calculated and the session key $S{K}_{A-C}^{\prime }=H_2(Acc{X}_{SK}\parallel Acc{X}_A)$ is derived. $M_2$ is decrypted to obtain the random number n.

(6). $C{H}_A$ sends ${\mathrm{Response}}_C=(sigi\parallel M_3\parallel T_3)$ to $AC{A}_1$, where $sigi={\left(H_1\left(M_3\right)\right)}^{S{K}_{C{H}_A}}$ and $M_3=Acc{X}_{SK}(n+1)$.

(7). Upon receiving ${\mathrm{Response}}_C$, $AC{A}_1$ first verifies whether the timestamp $T_3$ meets the requirement. If not, the session is terminated. If valid, it verifies the signature’s correctness. Finally, it uses $S{K}_{A-C}$ to decrypt the message $M_3$ to obtain the updated random number. If the change in the random number is verified to be valid, the secure session is considered to be successfully established; otherwise, the communication is aborted.

The session key agreement algorithm between the ACA and the cluster head node is described as follows (Algorithm 1).

Algorithm 1: Air Command Aircraft Session Key Agreement

3.2.2. Air Command Aircraft Handover

When the $AC{A}_1$ needs to perform a handover operation, $AC{A}_2$ takes over from $AC{A}_1$ to continue leading the UAV cluster in executing its mission. The ACA handover process, as illustrated in Figure 6, mainly includes the following steps:

(1). Prior to executing the handover task, $AC{A}_1$ broadcasts the message to all UAV clusters: $\mathrm{ExRequest}=(\mathrm{sigi}\parallel PI{D}_{AC{A}_2}\parallel M_4\parallel T_4)$, where $\mathrm{sigi}=H_1{\left(M_4\right)}^{S{K}_{AC{A}_1}}$, and $M_4=\left(\mathrm{signal}\right)$ indicates that a handover operation is to be performed. $PI{D}_{AC{A}_2}$ represents the pseudo-identity of the target ACA.

(2). Upon receiving the message, $C{H}_A$ first checks the validity of the timestamp $T_4$. If $|T_4^{*}-T_4|<\Delta T$, the process continues. $C{H}_A$ obtains the public key of $AC{A}_1$ from the AUC and verifies the message by checking whether $e(P{K}_{AC{A}_1},H_1\left(M_4\right))=e(g,\mathrm{sigi})$. If the equation holds, the handover signal is considered valid, and $C{H}_A$ sends $(PI{D}_{C{H}_A},Acc{X}_A,r_A)$ to the CMC.

(3). The CMC generates a secret $k\in {\mathbb{Z}}_q^{*}$ as the core signing key of the system and computes the public key $PK=g^k$. It then selects a polynomial $p\left(x\right)$ of degree $t-1$ and $t-1$ integers such that $p\left(0\right)=k$, with the polynomial defined as the system’s threshold:

(4)$p\left(x\right)=k+a_{1}x+a_2{x}^2+\dots +a_{t-1}{x}^{t-1}.$

The CMC computes the sub secret for $C{H}_A$ as $d_A=p\left(Acc{X}_A\right)$ and the public value of the partial secret as $D_A=d_A\oplus Acc{X}_A$. Finally, it returns the tuple $(PI{D}_{C{H}_A},D_A)$ to $C{H}_A$.

(4). Upon receiving the message, $C{H}_A$ computes $d_A=Acc{X}_A\oplus D_A$ and uses the resulting value $d_A$ to sign the handover signal $si{g}_A=H_1{\left(signal\right)}^{d_A}$. $C{H}_A$ sends the tuple $(PI{D}_{C{H}_A},si{g}_A)$ to $AC{A}_1$.

(5). After receiving the message from $C{H}_A$, $AC{A}_1$ performs a single signature verification. It initializes the counter count to 0 and verifies the following equation $e(si{g}_A,g)=e(H_1\left(signal\right),D_A)$. If the equation holds, verification passes, and count is incremented by 1. When count reaches or exceeds the threshold t, $AC{A}_1$ performs the aggregate signature operation to generate the final signature S:

(5)$R=\prod _{i=1}^t{R}_i=\prod _{i=1}^t{g}^{r_i}$

(6)$S_i=r_i+H_1(signal\parallel R)·d_i$

(7)$S=\sum _{i=1}^t{S}_i=\sum _{i=1}^t\left(r_i+H_1(signal\parallel R)·d_i\right)$

After generating the aggregate signature, $AC{A}_1$ sends the signature message to ${CH}_A$$Si{g}_{AP}=H_1{\left(signal\right)}^S$.

(6). After receiving the signature, ${\mathit{CH}}_A$ verifies whether the equation $g^S=R·{\prod }_{i=1}^t{\left(g^{d_i}\right)}^{H_1(signal\parallel R)}$ holds. If the equation is satisfied, the signature S is considered valid and the ACA handover is deemed to be successful.

(7). $AC{A}_1$ transmits the secure message $M_{ex}=(M_5\parallel M_4\parallel ta{b}_{ex}\parallel T_5)$ to $AC{A}_2$ via a secure channel, where $ta{b}_{ex}=Acc{X}_{SK}\oplus PI{D}_{AC{A}_1}$ and $M_5$ contains the distributed ledger information of the UAV cluster head nodes $(PI{D}_{C{H}_i},Acc{X}_i,\mathrm{True})$.

(8). Upon receiving the message, $AC{A}_2$ first checks the timestamp $T_5$ for validity. If the check passes, it computes $Acc{X}_{SK}=ta{b}_{ex}\oplus PI{D}_{AC{A}_1}$ and re-computes the shared session key with the cluster head node as ${S{K}_{A-C}}^{\prime }=H_2(Acc{X}_{SK}\parallel Acc{X}_A)$; based on $M_5$, it updates its own distributed ledger by adding the cluster head node’s information. Through this process, the new ACA successfully completes the handover and re-establishes a secure communication link.

The ACA handover algorithm is described as follows (Algorithm 2).

Algorithm 2: ACA Handover Mechanism

The abstract expression of the function is defined as follows:

(8)$S{K}_{A-C}^{\prime }=\mathcal{F}(signal,{\left\{Acc{X}_i\right\}}_{i=1}^t,{\left\{r_i\right\}}_{i=1}^t,Acc{X}_{ACA})$

$\mathcal{F}$ is a composite function that includes operations such as threshold signature aggregation, polynomial reconstruction, pairing verification, and hash derivation. The function outputs the new session key $S{K}_{A-C}^{\prime }$ shared between the ACA and the cluster head node, serving as the foundation for subsequent secure communication.

The time complexity analysis is presented as follows.

The time complexity of generating the polynomial $p\left(x\right)$ is $\mathcal{O}\left(t\right)$, the time complexity of exponentiation and pairing operations is $\mathcal{O}(tlogq)+\mathcal{O}\left(e\right)$, the time complexity of threshold signature aggregation is $\mathcal{O}\left(t\right)$, and the time complexity of hash-based shared key generation is $\mathcal{O}\left(1\right)$. In summary, the overall computational complexity of the handover algorithm can be expressed as

(9)$C_{switch}=\mathcal{O}(tlogq)+\mathcal{O}\left(e\right)$

where e denotes the cost of bilinear pairing operations and q is the group order. This complexity applies to medium-scale clusters, and when the number of cluster head nodes $t\le 10$, the algorithm supports low-latency handover in practice.

3.2.3. Cluster Joining and Departure

(1). When UAV cluster Z joins the network, it collaborates with other UAV clusters under the leadership of the ACA to complete tasks.

The cluster head node $C{H}_Z$ of UAV cluster Z first registers with the KGC to obtain its pseudo-identity $PI{D}_{C{H}_Z}$ and key pair $(P{K}_{C{H}_Z},S{K}_{C{H}_Z})$. Through the CMC, identity proofs for the member UAVs in the cluster are generated, while $C{H}_Z$ stores its own accumulator value $Acc{X}_Z$. When cluster Z joins the network, the shared session key must be updated as follows:

(10)${Acc{X}_{SK}}^{\prime }=Acc{X}_{SK}^{Acc{X}_Z}$

(11)${S{K}_{A-C}}^{\prime \prime }=H_2({Acc{X}_{SK}}^{\prime }\parallel Acc{X}_Z)$

Subsequent communication between the ACA and $C{H}_Z$ uses ${S{K}_{A-C}}^{\prime }$ as the session key. The ACA invokes the update contract to add the information of cluster Z to the distributed ledger.

(2). When UAV cluster Z leaves the current network, the system must recompute the shared session key:

(12)${Acc{X}_{SK}}^{\prime }={Acc{X}_{SK}}^{Acc{X}_Z^{-1}}$

(13)${\displaystyle {\mathit{SK}}_{A-C}^{\prime \prime }}=H_2({Acc{X}_{SK}}^{\prime }\parallel Acc{X}_i).$

Subsequent communication between the ACA and other cluster head nodes will use ${S{K}_{A-C}}^{\prime \prime }$ as the session key. The ACA invokes the revocation contract to update the status of $PI{D}_{C{H}_Z}$ to false.

4. Security Analysis

In this section, we conduct a security analysis of the overall system framework, focusing on the security requirements that must be satisfied in the design of the authentication scheme. Finally, we discuss potential attacks that may arise during the implementation of the handover mechanism and propose corresponding countermeasures.

4.1. Proof of Logical Correctness

This section adopts BAN logic [17] (Burrows–Abadi–Needham, BAN) to prove the logical correctness of the proposed scheme. Table 4 presents the fundamental notations used in BAN logic.

Reasoning rules:

Message meaning rules:

Rule 1: ${\displaystyle \frac{P\mid \equiv \stackrel{K}{Q\leftrightarrow P},P◃{\left\{X\right\}}_K}{P\mid \equiv Q\sim X}}$

Rule 2: ${\displaystyle \frac{P\mid \equiv \#\left(X\right),P\mid \equiv Q\mid \sim X}{P\mid \equiv Q\mid \equiv X}}$

Rule 3: ${\displaystyle \frac{P\mid \equiv X,P\mid \equiv Y}{P\mid \equiv (X,Y)}}$${\displaystyle \frac{P\mid \equiv (X,Y)}{P\mid \equiv X}}$${\displaystyle \frac{P\mid \equiv Q\mid \equiv (X,Y)}{P\mid \equiv Q\mid \equiv X}}$

Rule 4: ${\displaystyle \frac{P\mid \equiv \#\left(X\right)}{P\mid \equiv \#(X,Y)}}$

4.1.1. The Mutual Authentication Inference Process Between UAV Cluster C and Air Command Aircraft A

Idealized Protocol:

Message 1.1: C → A: $\{T_C,\stackrel{K_{CA}}{C\leftrightarrow A}\}$ from C

Message 1.2: A → C: $\{T_A,\stackrel{K_{CA}}{A\leftrightarrow C}\}$ from A

Authentication Goals:

Purpose 1.1: $A\mid \equiv C\mid \equiv \stackrel{K_{CA}}{C\leftrightarrow A}$

Purpose 1.2: $C\mid \equiv A\mid \equiv \stackrel{K_{CA}}{(C\leftrightarrow A)}$

Initial Assumptions:

Assumption 1.1: $A\mid \equiv C\mid \sim \{T_C,K_{CA},C\leftrightarrow A\}$

Assumption 1.2: $C\mid \equiv A\mid \sim \{T_A,K_{CA},A\leftrightarrow C\}$

Assumption 1.3: $C\mid \equiv \#\left(T_A\right)$

Assumption 1.4: $A\mid \equiv \#\left(T_C\right)$

Step 1: We deduce from Message 1.1. The Air Command Aircraft A receives the message and confirms the source.

Based on Assumption 1.1 and Rule 1, $(B\mid \equiv A\stackrel{K}{\leftrightarrow }B\mathrm{and}B▹X,B\mid \equiv A\sim X)$, we can infer that

$R1:A\mid \equiv C\sim \{T_C,\stackrel{K_{CA}}{C\leftrightarrow A}\}$

Based on Assumption 1.4, Rules 4 and R1, $(B\mid \equiv \#(X)\mathrm{and}B\mid \equiv A\sim X,B\mid \equiv A\mid \equiv X)$ we can deduce that

$R2:A\mid \equiv C\mid \equiv \stackrel{K_{CA}}{(C\leftrightarrow A)}$

Based on Rule 3 and R2 $(B\mid \equiv A\mid \equiv X,B\mid \equiv X)$, we can deduce:

$A\mid \equiv \stackrel{K_{CA}}{C\leftrightarrow A}$

The Air Command Aircraft A will eventually confirm that $K_{CA}$ is trusted by the cluster node C.

Step 2: We deduce From Message 1.2. The cluster node C receives the message and confirms the source.

Based on Assumption 1.2 and Rule 1, $(B\mid \equiv A\stackrel{K}{\leftrightarrow }B\mathrm{and}B▹X,B\mid \equiv A\sim X)$, we can deduce that

$R3:C\mid \equiv A\sim \{T_A,\stackrel{K_{CA}}{C\leftrightarrow A}\}$

Based on Assumption 1.3, Rule 4, and R3, $(B\mid \equiv \#(X)\mathrm{and}B\mid \equiv A\sim X,B\mid \equiv A\mid \equiv X)$, we can deduce that

$R4:C\mid \equiv A\mid \equiv \stackrel{K_{CA}}{(A\leftrightarrow C)}$

This shows that the cluster node C and the Air Command Aircraft A share the trusted $K_{CA}$.

Based on Rule 3 and R4, $(B\mid \equiv A\mid \equiv X,B\mid \equiv X)$, we can deduce that

$C\mid \equiv \stackrel{K_{CA}}{A\leftrightarrow C}$

The cluster node C confirms that $K_{CA}$, trusted by Air Command Aircraft A, is shared and trusted.

4.1.2. Authentication Reasoning for Handover of the Air Command Aircraft in the UAV Cluster (New Air Command Aircraft N, Handover Signal $signal$)

Idealized Protocol:

Message 2.1: A → C: $\{N,T_A,signal\}$ from A

Message 2.2: C → N: $\{T_C,\stackrel{K_{CN}}{C\leftrightarrow N}\}$ from C

Message 2.3: N → C: $\{T_N,\stackrel{K_{CN}}{N\leftrightarrow C}\}$ from N

Authentication Goals:

Purpose 2.1: $N\mid \equiv C\mid \equiv \stackrel{K_{CN}}{C\leftrightarrow N}$

Purpose 2.2: $C\mid \equiv N\mid \equiv \stackrel{K_{CN}}{(N\leftrightarrow C)}$

Initial Assumptions:

Assumption 2.1: $N\mid \equiv C\mid \sim \{T_C,K_{CN},C\leftrightarrow N\}$

Assumption 2.2: $C\mid \equiv N\mid \sim \{T_N,K_{CN},N\leftrightarrow C\}$

Assumption 2.3: $C\mid \equiv \#\left(T_N\right)$

Assumption 2.4: $N\mid \equiv \#\left(T_C\right)$

Step 1: We deduce From Message 2.2. New Air Command Aircraft N receives messages and verifies sources.

Based on Assumption 2.1 and Rule 1, $(B\mid \equiv A\stackrel{K}{\leftrightarrow }B\mathrm{and}B▹X,B\mid \equiv A\sim X)$, we can deduce that

$R5:N\mid \equiv C\sim \{T_C,\stackrel{K_{CN}}{C\leftrightarrow N}\}$

Based on Assumption 2.4, Rule 4, and R5, $(B\mid \equiv \#(X)\mathrm{and}B\mid \equiv A\sim X,B\mid \equiv A\mid \equiv X)$, we can deduce that

$R6:N\mid \equiv C\mid \equiv \stackrel{K_{CN}}{(C\leftrightarrow N)}$

This indicates that the new Air Command Aircraft N and the cluster head node C confirm that the encryption key $K_{CN}$ is shared between them.

Based on Rule 3 and R6, $(B\mid \equiv A\mid \equiv X,B\mid \equiv X)$, we can deduce that

$N\mid \equiv \stackrel{K_{CN}}{C\leftrightarrow N}$

This shows that the new Air Command Aircraft N ultimately confirms that the encryption key $K_{CN}$ is shared between the new Air Command Aircraft and the cluster head node C.

Step 2: We deduce From Message 2.3. Cluster head node C receives the message and verifies the source.

Based on Assumption 2.2 and Rule 1, $(B\mid \equiv A\stackrel{K}{\leftrightarrow }B\mathrm{and}B▹X,B\mid \equiv A\sim X)$, we can deduce that

$R7:C\mid \equiv N\sim \{T_N,\stackrel{K_{CN}}{(N\leftrightarrow C)}\}$

Based on Assumption 2.3, Rule 4, and R7, $(B\mid \equiv \#(X)\mathrm{and}B\mid \equiv A\sim X,B\mid \equiv A\mid \equiv X)$, we can deduce that

$R8:C\mid \equiv N\mid \equiv \stackrel{K_{CN}}{(N\leftrightarrow N)}$

This shows that cluster head node C, trusting the new Air Command Aircraft N, confirms that the encryption key $K_{CN}$ is shared between them.

Based on Rule 3 and R8, $(B\mid \equiv A\mid \equiv X,B\mid \equiv X)$, we can deduce that

$C\mid \equiv \stackrel{K_{CN}}{C\leftrightarrow N}$

This shows that cluster head node C ultimately confirms that the encryption key $K_{CN}$ is shared between the new Air Command Aircraft N.

Through the application of BAN logic, the logical correctness of the mutual authentication between the cluster head node and the Air Command Aircraft (ACA), as well as the ACA handover process, is verified. The derivation not only prevents unauthorized access and replay attacks but also confirms the legitimacy of the shared session key. After a successful handover to the new ACA, secure communication with the cluster head node can be rapidly re-established.

4.2. Security Analysis

(1). Mutual Authentication [25]: In this scheme, mutual authentication is achieved through digital signatures, timestamp verification, and bilinearity-based techniques to ensure secure communication between UAV clusters and the Air Command Aircraft (ACA). The digital signature is based on the RSA algorithm. If an attacker attempts to impersonate the ACA, they must satisfy the following conditions:

(i). The attacker must recover the private key used for signature generation. However, RSA security is grounded in the hardness of integer factorization, which has exponential complexity and cannot be solved within a reasonable timeframe. Timestamp verification effectively limits replay attacks, preventing the reuse of captured signatures outside their validity period.

(ii). Given a signature $S=H{\left(m\right)}^{d}modN$, the attacker must recover d (the private key) in order to forge S. This requires factoring the modulus N into its prime components p and q. The most efficient known classical algorithm for this is the Number Field Sieve (NFS) [26], whose time complexity is $\mathcal{O}\left(e^{{(c·\log N)}^{1/3}{\left(\log \log N\right)}^{2/3}}\right)$, where c is a constant. For a 2048 bit RSA key, even with a supercomputer, factoring requires approximately ${10}^{19}$ operations, making it infeasible with current technology. Therefore, attackers cannot practically recover the RSA private key, rendering signature forgery nearly impossible.

(2). Confidentiality [27]: Confidentiality includes both forward and backward secrecy. In the proposed system, each authentication and communication session between the ACA and the cluster head node dynamically generates a session key based on their respective secret information. These session keys do not rely on long-term keys. Even if a session key is compromised in the future, the confidentiality of previous communications remains unaffected.

(3). Anonymity [28]: By employing pseudo-identities (PIDs) and RSA-based dynamic accumulator techniques, the ACA does not reveal its real identity during the authentication and handover processes.

(4). Attack Resistance: To effectively defend against spoofing attacks and man-in-the-middle (MITM) attacks, the proposed scheme integrates multiple protection mechanisms, including digital signature verification, timestamp validation, and randomness in session key negotiation. During each authentication process between the ACA and the cluster head node, the cluster head node signs the authentication message with its private key, and the ACA retrieves the corresponding public key from the AUC to verify the source legitimacy. Meanwhile, the authentication message includes a current timestamp, and a predefined time window ΔT is used to determine message freshness, thereby mitigating replay attacks. Furthermore, both parties incorporate XOR operations and hash functions to obfuscate the input parameters during session key negotiation, ensuring that the derived shared key is secure and resistant to reconstruction even if intercepted. By combining multi-source authentication, signature-based verification, and dynamic key negotiation, the proposed scheme significantly enhances the security and robustness of the authentication process. This ensures that the system can maintain stable identity verification capabilities even under dynamic and high-frequency communication conditions.

4.3. Attack Model

(1). Spoofing Attack [29]: The system ensures secure communication between the ACA and UAVs by employing digital signatures and timestamp verification. Digital signatures are generated using the RSA algorithm. To impersonate the ACA, an attacker would need to recover the private key, which is computationally infeasible due to the hardness of the integer factorization problem underlying RSA. Furthermore, timestamps are embedded in each communication to ensure message validity within a limited time window, making it impossible for attackers to reuse outdated messages for forgery.

(2). Man-in-the-Middle (MITM) Attack [30]: The system utilizes a session key agreement mechanism to dynamically generate shared keys, ensuring the confidentiality and integrity of transmitted data and preventing interception or tampering. The CMC promptly verifies signatures during the authentication process to validate both parties, reduce latency, and enhance the system’s resistance to MITM attacks.

(3). Denial-of-Service (DoS) Attack [31]: The proposed system adopts a dual-chain collaborative architecture comprising an identity blockchain and an authentication blockchain. By distributing authentication tasks across different ledger nodes, the system effectively reduces the risk of single-point control failures. In addition, the CMC acts as a buffer and filtering module in the authentication and message forwarding processes. When excessive request traffic targeting the main control node is detected, rate-limiting and frequency filtering mechanisms can be activated to prevent malicious request floods from congesting the communication channel. Furthermore, a request validation interface is embedded in the smart contracts, allowing only entities with a verified status of true to initiate authentication requests, thereby strengthening the system’s resistance to distributed denial-of-service (DDoS) attacks. Since identity information is stored on a decentralized blockchain, nodes that have already completed authentication can directly retrieve cluster head information from the distributed ledger. This reduces the communication burden on the main control node and simultaneously mitigates the impact of DDoS attacks.

5. Experimental Design

In this section, we evaluate the performance of the proposed scheme through simulation experiments, focusing on three key aspects: computational overhead, communication overhead, and storage overhead.

5.1. Experimental Setup

In our experiments, the system was configured with an Intel® Core™ i7-10870H CPU @ 2.20GHz and 32GB RAM, running Ubuntu 20.04 (64 bit). The blockchain network was deployed using FISCO BCOS version 2.9.0. This experimental environment supported detailed data analysis to evaluate the performance and feasibility of the proposed scheme. Furthermore, the effectiveness of ledger recording and management capabilities validated the practicality and reliability of the solution.

5.2. Performance Analysis

5.2.1. Computational Overhead

We divided the analysis into two phases, Phase 1 and Phase 2, representing the authentication process between the UAV cluster’s cluster head node and the ACA and the ACA handover process, respectively.

Phase 1 focused on establishing reliable communication between the cluster head node and the ACA. During this phase, mutual authentication was performed and session keys were negotiated to ensure confidentiality. The main computational tasks in this phase included key generation, encryption/decryption, and signature verification.

Phase 2 centered on the rapid handover of the ACA. During handover, the system verified the identity of the newly designated ACA and updated the communication keys of the cluster head nodes to maintain the integrity and security of the communication links. The main computational operations in this phase involved signature verification and session key updates.

Throughout mutual authentication and ACA handover, computational overhead mainly included pairing-based encryption, decryption, hash computation, and elliptic curve scalar multiplication. Table 5 provides a breakdown of the core computational operations involved in the system.

The computational overhead of each operation, ranked from lowest to highest in terms of time consumption, was as follows: $T_V<T_{XOR}<T_{HS}<T_{SE}<T_{HK}<T_{AE}<T_{SM}<T_M$.

Under the same experimental settings, we selected Blockchain-based Cross-domain Authentication (BCA) [13], Anonymous Biometrics-based Authentication (ABA) [32], and Secure Authentication and Key Agreement (SAKA) [33] as baseline schemes for comparison, primarily due to their representativeness and technical relevance in the current field of authentication research. BCA is a blockchain-based authentication mechanism that adopts centralized control and identity chain architecture. It is highly representative in terms of identity isolation and trusted access but suffers from high authentication latency in high-frequency dynamic handover scenarios. The ABA scheme integrates biometric recognition and anonymity mechanisms, emphasizing lightweight design and privacy protection, and serves as a typical example of low-cost identity authentication. SAKA is based on the traditional UMTS architecture and focuses on ensuring the reliability of the authentication process and the consistency of key agreement, representing classical key negotiation models. However, these three schemes exhibit varying degrees of adaptability to the ACA handover scenario. BCA mainly targets blockchain-based access authentication and does not address the dynamic handover of command nodes. ABA and SAKA, though not specifically designed for UAV systems, support key agreement and fast re-authentication processes, thereby demonstrating a certain degree of adaptability to handover scenarios. In contrast, the proposed scheme is designed to support ACA handover authentication with enhanced dynamic adaptability, scalability, and mission coordination capability, effectively addressing the limitations of existing solutions in this domain. The key computational overhead for each scheme is summarized in Table 6.

As shown in Table 6, compared with other schemes, our proposed method improved both the mutual authentication efficiency between the cluster head node and the ACA and the performance of ACA handover. This was because our scheme completed the identity verification of each UAV node during the initialization phase and offloaded complex computations to the Edge Computing Center during cluster management and ACA handover, thereby reducing the computational burden on the UAV nodes. For instance, in Phase 2, the computational cost was represented as $T_{HK}+2T_{HS}+3T_{XOR}+2T_V$, which corresponded to one key agreement operation, two hash computations, three XOR operations, and two verification operations executed during the ACA handover process.

Figure 7a illustrates the cost of mutual authentication between UAV cluster head nodes under our scheme and the BCA, ABA, and SAKA schemes when the number of clusters increased from 2 to 10 under the same experimental conditions. As shown in the figure, the authentication time in all schemes increased approximately linearly with the number of clusters. However, our scheme achieved significantly lower authentication time compared to BCA, ABA, and SAKA. In our scheme, each UAV cluster completed identity registration in advance, and the cluster head node distributed and uploaded identity credentials before the mutual authentication phase. Therefore, this step did not add computational overhead to the subsequent authentication process. Figure 7b illustrates the trend of computational overhead during the ACA handover process as the number of UAV clusters increased. In comparison with ABA and SAKA, the experimental results show that our proposed scheme maintained a relatively low level of computational cost as the cluster size grew, indicating good scalability of the scheme.

5.2.2. Communication Overhead

To better evaluate the communication cost differences between our scheme and other approaches, we adopted SHA256 as the hash function. The computation lengths of communication-related elements are summarized in Table 7.

Table 8 presents the communication overhead of our scheme in comparison with BCA, ABA, and SAKA during the communication phase.

Since messages of different tasks vary in length, we focused solely on calculating the communication overhead associated with identity authentication and handover processes between the cluster head node and the ACA.

In Figure 8a, we present the total signaling overhead generated in the network when each scheme performed the same number of access authentications. The figure shows that compared to BCA, ABA, and SAKA, our scheme significantly reduced the number of authentication signaling messages. This was because our scheme allowed the cluster head node to manage the identity of its member UAVs in advance, thereby reducing the number of identity verifications required by the network. Since signaling overhead was primarily determined by the number of clusters rather than the internal size of each cluster, our approach effectively alleviated the load during access bursts.

During the ACA handover process, as the number of handovers increased, the corresponding communication overhead also rose. By managing the cluster head nodes and updating the ACA’s distributed ledger, our scheme effectively reduced the amount of communication signaling required in the network, thereby alleviating the communication burden during handover. We conducted a simulation-based comparison with ABA and SAKA, where each scheme performed the same number of handover operations using its respective protocol, and the total communication signaling generated was recorded. As shown in Figure 8b, the experimental results demonstrate that under the same number of handovers, our scheme significantly reduced the number of interactions required during ACA handover, thus decreasing overall communication signaling and lowering communication overhead.

5.2.3. Storage Overhead

During the system initialization phase, identity information of UAVs within the cluster was sent to the cluster head node, which collected and forwarded it to the CMC. The CMC generated the corresponding identity credentials for each member UAV. The cluster head node only stored the cluster’s accumulated value $AccX$, eliminating the need to store additional parameters during subsequent authentication and handover processes.

In Phase 2, during ACA handover, each ACA maintained a local distributed ledger that stored the identity information of cluster head nodes for session key computation. Figure 9 shows the storage overhead per entity during mutual authentication and handover when the number of UAV clusters was 5. Compared to ABA and SAKA, our scheme achieved the lowest storage overhead per entity. The figure also shows that in our scheme, UAVs had the smallest storage burden across all tested cluster sizes. The storage overhead on the ACA side was slightly higher than in ABA due to the fact that the ACA maintained a categorized ledger of the identities of all cluster head nodes, which facilitated more efficient ACA handover.

6. Conclusions

This paper addressed the problem of identity authentication and secure communication during dynamic ACA handover in cooperative multi-UAV clusters. To this end, we proposed a dynamic authentication and handover mechanism based on a dual-chain architecture. By coordinating an identity chain and an authentication chain, the mechanism achieves a functional separation between UAV identity management and ACA handover authentication tasks, thereby enhancing the system’s scalability and responsiveness. The proposed design is supported by smart contract-driven authentication workflows, the formal modeling of algorithmic processes, computational complexity analysis, and security verification using BAN logic, providing a solid foundation for both logical correctness and engineering feasibility. This work emphasizes the following mathematical techniques:

(1). The formal modeling of the authentication process using symbolic functions and BAN logic to derive the system’s logical security properties.

(2). The construction of algorithmic models for key agreement and handover procedures, along with abstract function representation and time complexity analysis to evaluate computational resource consumption.

(3). The integration of cryptographic primitives, including cryptographic accumulators and bilinear pairings, to provide mathematically grounded security assurances.

The experimental results demonstrate that the proposed mechanism maintains strong security guarantees while achieving significant reductions in computation, communication, and storage overhead compared to existing solutions. It is especially effective in large-scale UAV networks with frequent node mobility. Future research will explore the following directions: extending formal verification to encompass the mathematical modeling of multi-chain synchronization and state consistency; incorporating adaptive game theory or reinforcement learning to optimize ACA handover strategies; and applying robust control theory to evaluate system self-recovery under ACA failure scenarios.

Author Contributions

Methodology, Y.C.; Formal analysis, Y.C.; Investigation, J.M., X.Y. and G.Y.; Resources, Y.F.; Writing—original draft, Y.C.; Writing—review and editing, Y.C., J.M., Y.F., and Z.D.; Visualization, Y.F.; Supervision, J.M.; Funding acquisition, Y.F. All authors have read and agreed to the published version of the manuscript.

Data Availability Statement

All information is included in the article.

Conflicts of Interest

The authors declare no conflicts of interest.

Footnotes

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Figures and Tables

Figure 1 System architecture.

Figure 2 The registration flowchart of the cluster head node.

Figure 3 The registration flowchart of the air command aircraft.

Figure 4 The registration flowchart of the UAV cluster.

Figure 5 The authentication flowchart between the cluster head node and the ACA.

Figure 6 The flowchart of the ACA handover process.

Figure 7 (a) Computational overhead of mutual authentication operations as the number of UAV clusters increased. (b) Computational overhead of handover operations as the number of UAV clusters increased.

Figure 8 (a) Communication signaling generated during mutual authentication as the number of UAV clusters increased. (b) Communication signaling generated during the same number of handover operations using different handover protocols.

Figure 9 Entity storage overhead.

Table 1

Comparative analysis between our scheme and representative existing technologies.

Dimension	Scheme [14]	Scheme [16]	Scheme [20]	Our Scheme
Architecture	Single-chain	Single-chain	Centralized control	Dual-chain collaborative
Key Management	Identity chain key exchange	Certificate-free key negotiation	Centralized key negotiation	Accumulator + distributed ledger
Handover Capability	Weak	Support but high latency	Support but high latency	Strong
Security	Replay attack resistance	Anti-forgery	Fault tolerance	Anti-spoofing, anti-forgery, anonymity
Application Scenario	Small scale networks	Multi-domain modeled networks	Hybrid networks	High dynamic networks

Table 2

Symbol Meanings.

Notation	Definition
P	Generator of the cyclic addition group $G_1$
$C{H}_i$	Cluster head node of UAV i
$AC{A}_i$	Air command aircraft i
$I{D}_i^A$	UAV i within UAV cluster A
$PI{D}_{C{H}_A}$	Pseudo-identity of cluster head node A
$PI{D}_{AC{A}_i}$	Pseudo-identity of Air Command Aircraft i
$P{K}_{C{H}_A}$	Public key of the cluster head node A
$S{K}_{C{H}_A}$	Private key of the cluster head ndoe A
T	Timestamp used to record and synchronize event occurrences
$D_A$	Public value used by the cluster head node A to sign handover messages
$Acc{X}_A$	Accumulated value of UAV cluster A
$S{K}_{A-C}$	Shared secret key between the ACA and the cluster head node
$IDC$	Identity chain
$AUC$	Authentication chain
$Wi{t}_{I{D}_i^A}$	Identity credential of UAV i in UAV cluster A
$signal$	ACA handover signal

Table 3

Ledger format.

Pseudo Identity	Cumulative	Status
$PI{D}_{C{H}_j}$	$Acc{X}_j$	True
$PI{D}_{C{H}_k}$	$Acc{X}_k$	True
…	…	…
$PI{D}_{C{H}_n}$	$Acc{X}_n$	True

Table 4

Basic terms of BAN logic.

Term	Meaning
$P\mid \equiv X$	P believes X is trustworthy
$P\mid \sim X$	P has sent a message containing X at some point in time
$P\mid \Rightarrow X$	P has arbitration rights over X
#(X)	X is fresh
${\left\{X\right\}}_k$	Encrypt X using key k
$\stackrel{K}{P\leftrightarrow Q}$	P and Q share K

Table 5

Computational cost of major operations.

Pseudo Identity	Cumulative
$T_{SE}$	Symmetric encryption/decryption
$T_{AE}$	Asymmetric encryption/decryption
$T_{HS}$	Hash-based signature computation
$T_{HK}$	Hash-based key agreement computation
$T_M$	Modular multiplication
$T_{SM}$	Scalar multiplication on elliptic curves
$T_{XOR}$	XOR operation
$T_V$	Verification operation

Table 6

Computational overhead for completing access authentication.

Scheme	Time
BCA	$2T_{SE}+4T_{AE}+3T_{SM}+1T_{HK}+5T_V$
ABA	$4T_{SM}+2T_{HK}+6T_{AE}+6T_{HS}+1T_{SE}+1T_V$
SAKA	$3T_{SM}+2T_{SE}+1T_{HK}+5T_{HS}+3T_V$
Ours (Stage 1)	$2T_M+T_{HK}+2T_{SE}+3T_{XOR}+2T_V$
Ours (Stage 2)	$T_{HK}+2T_{HS}+3T_{XOR}+2T_V$

Table 7

Lengths of relevant cryptographic elements.

Element	Length
TimeStamps	32 bytes
Randoms	64 bytes
Hash	256 bytes
G_Element	256 bytes
PID	64 bytes

Table 8

Communication overhead.

Scheme	Communication Overhead
BCA	2056 bytes
ABA	1952 bytes
SAKA	2656 bytes
Ours (Stage 1)	1312 bytes
Ours (Stage 2)	1088 bytes