ECAE: An Efficient Certificateless Aggregate Signature Scheme Based on Elliptic Curves for NDN-IoT Environments

TL;DR

ECAE is a new secure signature scheme for IoT devices in NDN networks that reduces computation and communication costs.

Contribution

ECAE introduces a certificateless aggregate signature scheme using ECC to improve efficiency in NDN-IoT environments.

Findings

ECAE reduces total computation overhead by up to 46.18% compared to existing schemes.

Communication overhead is reduced by 55.56% in ECAE compared to state-of-the-art methods.

ECAE is secure against forgery, replay, and man-in-the-middle attacks.

Abstract

As a data-centric next-generation network architecture, Named Data Networking (NDN) exhibits inherent compatibility with the distributed nature of the Internet of Things (IoT) through its name-based routing mechanism. However, existing signature schemes for NDN-IoT face dual challenges: resource-constrained IoT terminals struggle with certificate management and computationally intensive bilinear pairings under traditional Public Key Infrastructure (PKI), while NDN routers require low-latency batch verification for high-speed data forwarding. To address these issues, this study proposes ECAE, an efficient certificateless aggregate signature scheme based on elliptic curve cryptography (ECC). ECAE introduces a partial private key distribution mechanism in key generation, enabling the authentication of identity by a Key Generation Center (KGC) for terminal devices. It leverages ECC and universal hash functions to construct an aggregate verification model that eliminates bilinear pairing operations and reduces communication overhead. Security analysis formally proves that ECAE resists forgery, replay, and man-in-the-middle attacks under the random oracle model. Experimental results demonstrate substantial efficiency gains: total computation overhead is reduced by up to 46.18%, and communication overhead is reduced by 55.56% compared to state-of-the-art schemes. This lightweight yet robust framework offers a trusted and scalable verification solution for NDN-IoT environments.

Figures

Full text

1. Introduction

The widespread adoption of Internet of Things (IoT) smart devices across various domains has profoundly transformed daily life [1,2,3]. However, the massive interconnection of devices and the exponential growth of data volumes have intensified critical challenges, such as data security threats and transmission efficiency bottlenecks, imposing new demands on communication security and performance [4]. To address these issues, Named Data Networking (NDN) has emerged as a promising content-centric communication paradigm due to its inherent advantages [5]. Unlike traditional address-based network architectures, NDN focuses on the data itself through a name-based routing mechanism, offering enhanced flexibility, scalability, and built-in security. Nevertheless, deploying NDN in IoT environments introduces complex security challenges arising from heterogeneous device capabilities, including identity authentication, message integrity assurance, and privacy protection [6,7,8].

In the NDN architecture, digital signatures serve as a fundamental mechanism for data packet verification. By embedding cryptographically generated unique identifiers into data packets, digital signatures ensure content authenticity and integrity, playing a pivotal role in preventing data source spoofing, tampering, and man-in-the-middle attacks [9]. However, this mechanism must satisfy the following two critical requirements: (1) IoT terminal devices, constrained in computational power and storage, struggle to handle the certificate chain validation and bilinear pairing operations required by traditional Public Key Infrastructure (PKI); (2) NDN routers must support low-latency and batch signature verification in high-speed data forwarding scenarios.

Traditional PKI relies on digital certificates to bind user identities to public keys. However, the communication overhead associated with certificate issuance, storage, and revocation imposes significant burdens on resource-constrained IoT terminals. Furthermore, the risks of single points of failure in certificate authorities (CAs) and the complexity of cross-domain authentication limit PKI’s applicability in distributed IoT environments. Certificateless Cryptography (CLC) provides a compelling alternative by integrating Identity-Based Cryptography (IBC) with partial private key distribution through a Key Generation Center (KGC). This approach eliminates the need for certificate management while avoiding the key escrow problem inherent in IBC. In this study, we propose a key generation mechanism that incorporates partial private key distribution, ensuring data packet security while reducing computational costs.

Moreover, the data-centric nature of NDN may result in concurrent responses from multiple producer nodes for a single request. When using conventional signature schemes, routers must verify each data packet independently, leading to computational overhead that scales linearly with the number of packets. Aggregate signature (AS) techniques address this limitation by compressing independent signatures into a fixed-length aggregate result, thereby reducing verification complexity to a constant level and significantly enhancing router processing efficiency. This study further innovates by combining elliptic curve cryptography (ECC) with universal hash functions to eliminate the need for bilinear pairings, achieving substantial improvements in verification performance.

1.1. Related Work

In recent years, research on security in Named Data Networking-Based Internet of Things (NDN-IoT) has primarily focused on achieving two key objectives: protecting data integrity and ensuring data source authentication. Existing solutions can be broadly classified into four main categories: (1) signature authentication schemes based on edge computing [10,11]; (2) blockchain-based signature authentication schemes [12,13,14,15]; (3) certificateless signature authentication schemes [16,17,18,19]; (4) batch signature authentication schemes [20,21,22,23].

By offloading computational tasks to edge nodes, these approaches reduce the core network load and enhance overall system performance. For instance, Wang et al. [10] proposed the NIoTE framework, which improves data retrieval efficiency from neighboring service nodes through requested aggregation and distributed caching. Huang et al. [11] introduced a certificateless group signature scheme; however, its reliance on computationally intensive bilinear pairing operations resulted in high computational costs, limiting its practicality in large-scale deployments. Moreover, the scheme’s centralized edge gateway architecture for identity management presents a security vulnerability—if the gateway is compromised, regional data verification could be undermined.

In blockchain-based authentication schemes, Lou et al. [12] proposed a distributed key management mechanism for NDN, leveraging blockchain to store hashed public keys in the NDN Testbed model, thus reducing the certificate chain verification time during user authentication. However, since blockchain stores data in transaction records, retrieving specific transactions requires traversing the entire block, which may lead to increased average retrieval delays as the number of transactions grows. Lei et al. [13] integrated cache poisoning protection and privacy-aware access control into a blockchain-based NDN network, but the approach’s computational overhead restricts its application to vehicular networks. Alsamhi et al. [14] combined federated learning with blockchain to protect model data and verify human–machine interactions, ensuring privacy and security. More recently, Yang et al. [15] proposed a blockchain-based encryption scheme that authenticates IoT devices and encrypts signals. However, its dependence on bilinear pairing operations leads to a significantly higher computational overhead than ECC-based alternatives.

Certificateless signature schemes eliminate certificate management, provide lightweight solutions for resource-constrained environments, and significantly reduce management costs. Karati et al. [16] proposed a lightweight pairing-based signature scheme for IoT, but its security still relies on computationally expensive operations. Rezaeibagha et al. [17] enhanced Karati’s model from a security perspective but failed to resolve the efficiency bottleneck caused by pairing. Thumbur et al. [18] utilized the Elliptic Curve Discrete Logarithm Problem (ECDLP) for security; however, their complex ECC-based algorithm remained unsuitable for constrained environments. Bisheh-Niasar et al. [19] presented an efficient FPGA-based implementation of Ed25519, utilizing Karatsuba multiplication and parallelism to accelerate signing. While this provides hardware-level optimization, it lacks sufficient algorithm-level resistance against attacks.

To alleviate the burden on resource-limited IoT devices, researchers have also explored batch signature authentication. Asami et al. [20] proposed an NDN aggregation signature scheme based on proof-of-concept identity verification to reduce communication overhead. This scheme enhances the efficiency of both signature generation and verification using aggregate signatures. Nonetheless, identity- and attribute-based schemes that rely on key escrows continue to pose critical security risks. Zhang et al. [21] introduced a multi-party authentication scheme based on a centralized certificate authority, drawing criticism due to its centralized trust model. Xue et al. [22] proposed a cooperative authentication framework using a name-prefix-based public key binding for distributed router verification, yet the model still depends on a vulnerable central authority. Zhu et al. [23] developed a reconfigurable certificateless signature scheme to prevent dishonest data modification and improve bandwidth efficiency. However, its trade-off between security and efficiency remains an issue.

Although existing research has advanced NDN-IoT authentication technologies across various dimensions, several core challenges remain—particularly in balancing security with efficiency, improving attack resilience, and building a secure and trustworthy communication environment. Current solutions face three major limitations: (1) performance degradation due to bilinear pairing or other complex cryptographic computations when scaling to large numbers of connected devices; (2) dependence on centralized certificate authorities in batch signature schemes, which introduces single points of failure; and (3) insufficient anonymity, exposing users to traceability and privacy risks.

These challenges underscore the urgent need for novel authentication mechanisms tailored to resource-constrained NDN-IoT environments—mechanisms that can simultaneously address security, efficiency, and privacy concerns. Developing a highly secure, lightweight communication framework capable of resisting diverse attacks is crucial for enabling practical deployment in such environments.

1.2. Motivation

To ensure the core security properties of data integrity, authentication, and access control are upheld and to establish a more secure and trustworthy communication environment, researchers have proposed a variety of communication security schemes aimed at defending against data tampering and unauthorized access. Despite these efforts, existing approaches still present significant limitations. For instance, in edge computing-based signature authentication schemes, such as the work by Huang et al. [11], edge computing enhances local performance but fails to guarantee the legitimacy of producer data packets in cases where the edge gateway is compromised. In blockchain-based signature authentication schemes, Lou et al. [12], Lei et al. [13], and Yang et al. [15] improved communication security through the use of blockchain. However, due to blockchain’s inherent efficiency bottlenecks and the computational overhead of bilinear pairing operations, these solutions remain unsuitable for large-scale deployment scenarios. In the domain of certificateless signature schemes, Karati et al.’s [16] scheme has been shown to be vulnerable to signature forgery attacks during security analysis. While Thumbur et al. [18] strengthened data security by leveraging the Elliptic Curve Discrete Logarithm Problem (ECDLP), the scheme’s computational complexity leads to reduced efficiency and increased communication overheads, particularly in resource-constrained environments. Regarding batch signature verification schemes, Xue et al. [22] proposed a cooperative content authentication framework that enables verification across multiple routers. However, their approach heavily depends on third-party trust centers, thereby introducing potential security threats to end consumers and IoT devices. Experimental data show that, under typical conditions, a single bilinear pairing operation on an elliptic curve incurs approximately 20 times the computational cost of a point multiplication operation. Moreover, hash function mappings to elliptic curve points are significantly more time-consuming than standard cryptographic hash functions. As the number of terminal devices increases, the size of aggregated signatures grows linearly, severely impacting communication efficiency and introducing considerable storage overheads. To address these challenges, this paper proposes a pairing-free and efficient signature authentication scheme, which demonstrates both strong security guarantees and high computational efficiency, making it well-suited for deployment in resource-constrained NDN-IoT environments.

1.3. Contribution

The main contributions of this paper are as follows:

• This paper proposes an efficient certificateless aggregate signature scheme based on elliptic curve cryptography (ECC) in the NDN-IoT environment, named ECAE. To accommodate resource-constrained devices, ECAE eliminates the need for computationally expensive map-to-point hash functions and bilinear pairing operations, thereby improving system computational efficiency. Furthermore, by implementing aggregate signatures, ECAE ensures that the signature length remains constant regardless of the number of terminal devices, effectively reducing communication overhead.
• ECAE adopts a key generation mechanism that integrates identity authentication with partial private key distribution, satisfying security functional requirements and ensuring secure communication.
• ECAE demonstrates strong security against various attacks in both theoretical analysis and simulations while also exhibiting high computational efficiency and low communication overheads.

2. Preliminaries

2.1. System Architecture

This paper proposes an efficient and conditionally confidential certificateless aggregate signature scheme for NDN-IoT, establishing a network model that consists of four main entities: the Key Generation Center (KGC) and NDN routers, consumers, and producers. The network model is illustrated in Figure 1.

Line 1 represents an example of the process in which a consumer requests data forwarding from an NDN router.Line 2 illustrates the process of a consumer requesting data packets from multiple producers.Line 3 demonstrates the interaction between terminal devices (producers in Figure 1) and the KGC for registration and the process of generating an aggregate signature and transmitting data packets via the NDN router.

When an Edge Device (ED) requests to join the network as a producer or consumer in the NDN-IoT system, it first transmits its real identity to the Key Generation Center (KGC) through a secure channel for registration. Subsequently, the KGC assigns a partial private key and public parameters to the ED. Each ED possesses a unique real identity along with a corresponding public–private key pair and must obtain a signature from the KGC before transmitting any message. Upon receiving a message–signature pair, the NDN router verifies the signature to ensure its validity and maintain message integrity. The roles of the key entities in the system are described as follows:

• KGC (Key Generation Center): The KGC acts as the public parameter distribution authority and key management center for the entire system. During the system’s initialization phase, it is responsible for generating and publishing system parameters. When a new entity requests to join the system, it must securely interact with the KGC to obtain public parameters, pseudonyms, and partial private keys.
• NDN Router: The NDN router verifies the authenticity and integrity of data packets during transmission. As a critical component ensuring secure data forwarding, it performs signature verification on the encapsulated producer information within the data packet. Additionally, it aggregates digital signatures from multiple terminal devices to enhance computational efficiency.
• Consumer: The consumer serves as the data requester in the proposed system, corresponding to the consumer entity in NDN. It requests the required data or services by sending Interest packets.
• Producer: The Producer is responsible for data generation in the NDN-IoT environment, corresponding to the producer entity in NDN. It utilizes sensor devices to collect information such as soil moisture, vehicle location, and indoor temperature.

2.2. Elliptic Curve Cryptography

Elliptic curve cryptography (ECC) is a public-key cryptographic algorithm based on the mathematical principles of elliptic curves. Compared to traditional cryptographic algorithms (e.g., RSA), ECC offers higher performance and smaller key sizes for the same level of security, making it particularly suitable for resource-constrained environments such as mobile and IoT devices.

The fundamental principle of ECC involves the addition and multiplication of points on an elliptic curve, enabling key generation, data encryption and decryption, and cryptographic operations such as digital signatures. Its security is based on the Elliptic Curve Discrete Logarithm Problem (ECDLP). Given a prime-order finite field $[eqn]$ , an elliptic curve $[eqn]$ is defined as follows: $[eqn]$ , where $[eqn]$ , $[eqn]$ represents the point at infinity, and $[eqn]$ is a prime number. The addition and multiplication of points on an elliptic curve are defined as follows:

• For any point, $[eqn]$ ; then, $[eqn]$ .
• For two points, $[eqn]$ ; if $[eqn]$ and $[eqn]$ , then $[eqn]$ .
• If $[eqn]$ and $[eqn]$ , then $[eqn]$ , where $[eqn]$ and $[eqn]$ , The definition of $[eqn]$ can be found in Equation (1).

$$[eqn]$$

• Scalar multiplication is defined as follows: $[eqn]$ , where $[eqn]$ and $[eqn]$ . $[eqn]$ : Given two points, $[eqn]$ , it is computationally unfeasible to find an integer $[eqn]$ such that $[eqn]$ holds.

2.3. Scheme Framework

The commonly used identifiers in the implementation of this scheme are shown in Table 1.

The implementation process of the proposed scheme mainly includes the following six steps:

• KGC System Initialization: The security parameters are input $[eqn]$ . The KGC initializes the system, generates the master key $[eqn]$ and system $[eqn]$ , and then keeps the master key, $[eqn]$ confidential while publishing the system $[eqn]$ .
• Interaction between KGC and $[eqn]$ to Generate Public and Private Keys: $[eqn]$ sends its real identity $[eqn]$ to the KGC. The KGC runs an algorithm offline to generate the pseudonym $[eqn]$ ; then, $[eqn]$ selects a random value $[eqn]$ as its key value and sends the pseudonym $[eqn]$ to the KGC. The KGC runs an algorithm to generate the partial private key for $[eqn]$ . Using the key value and the private key sent by the KGC as inputs, $[eqn]$ generates its secret key $[eqn]$ and public key $[eqn]$ .
• The terminal device $[eqn]$ signature generation: $[eqn]$ uses $[eqn]$ , $[eqn]$ and $[eqn]$ as inputs to generate a signature $[eqn]$
• Single signature verification: the $[eqn]$ or NDN router uses $[eqn]$ , $[eqn]$ , $[eqn]$ and $[eqn]$ as the inputs. If $[eqn]$ is valid, the output is accepted; otherwise, the output is rejected.
• The NDN router performs signature aggregation: The NDN router compresses the different signatures $[eqn]$ from $[eqn]$ data packets requested by the same consumer from $[eqn]$ different producers within the same time period into a single signature $[eqn]$ .
• Other NDN routers perform aggregate signature verification: They take $[eqn]$ as the input. If $[eqn]$ is valid, the output is accepted; otherwise, the output is rejection.

The system process framework of this scheme is shown in Figure 2.

2.4. Security Model

In the proposed scheme, we consider Type I and Type II attackers as defined in [24]. Due to the lack of certificate verification, an attacker may replace an entity’s public key with a public key of their choice. The two types of attackers are simulated as follows:

• Type I attacker: This attacker simulates an external adversary who can replace any entity’s public key with a specific value chosen by the attacker. However, a Type I attacker does not know the private key of the Key Generation Center (KGC).
• Type II attacker: This attacker simulates a malicious KGC that has access to the master key but cannot replace the public keys of other entities.

Furthermore, both Type I and Type II attackers can be classified into three attack levels [25,26]:

• An ordinary adversary can only learn valid verification messages.
• A strong adversary can replace public keys to forge valid verification messages, provided that the attacker possesses the corresponding private value.
• A super adversary can obtain valid verification messages for a public key that is replaced without submitting any content.

In general, a super adversary may issue the following queries:

• create-user ( $[eqn]$ ): This oracle model takes $[eqn]$ as the input, where $[eqn]$ represents the identity of the t-th terminal device. It then runs the relevant algorithm to obtain the partial private key, $[eqn]$ , the key value, $[eqn]$ , and the public key, $[eqn]$ .
• request-public-key ( $[eqn]$ ): This oracle model takes $[eqn]$ as the input. It searches the list $[eqn]$ and returns the public key $[eqn]$ of the t-th terminal device.
• replace-public-key ( $[eqn]$ ): This oracle model takes ( $[eqn]$ ) as the input. It replaces the public key of the t-th terminal device with $[eqn]$ and updates the corresponding information in list $[eqn]$ .
• extract-secret ( $[eqn]$ ): This oracle model takes $[eqn]$ as the input. It searches the list $[eqn]$ and returns the key value $[eqn]$ . However, if the t-th terminal device has been queried with a replace-public-key request, it returns null.
• extract-partial-secret ( $[eqn]$ ): This oracle model takes $[eqn]$ as the input. It then searches the list, $[eqn]$ and returns the partial private key, $[eqn]$ .
• super-sign ( $[eqn]$ ): This oracle model takes ( $[eqn]$ ) as the input, where $[eqn]$ represents the message to be signed. The oracle outputs a signature $[eqn]$ , such that $[eqn]$ If the public key has not been replaced, i.e., $[eqn]$ , $[eqn]$ is the public key returned by the oracle model request-public-key ( $[eqn]$ ). Otherwise, $[eqn]$ , where $[eqn]$ is the latest public key value submitted to the oracle model replace-public-key ( $[eqn]$ ).

The following two games, namely Game 1 and Game 2, are designed for Super Type I and Super Type II adversaries, respectively. Super Type I adversary simulates an external adversary who can replace any entity’s public key with a specific value of their choice. Super Type II adversary simulates a malicious KGC that holds the master key and may engage in adversarial activities such as eavesdropping on signatures and issuing signature queries.

Game 1. This game is played between the challenger, C, and the Super Type I adversary $[eqn]$ , where they interact within the proposed certificateless signature scheme. First, in the “Initialization” phase, challenger C runs the corresponding algorithm and generates the private key $[eqn]$ , along with the public system parameters $[eqn]$ . Then, C keeps $[eqn]$ , secret while providing $[eqn]$ to adversary $[eqn]$ Second, in the “Query” phase, SA1 can adaptively access the following oracle queries: create-user ( $[eqn]$ ), request-public-key ( $[eqn]$ ), replace-public-key ( $[eqn]$ ), extract-secret ( $[eqn]$ ), extract-partial-secret ( $[eqn]$ ), and super-sign ( $[eqn]$ ). After making all necessary queries, $[eqn]$ outputs a forged signature ( $[eqn]$ ). $[eqn]$ wins Game 1 if the following three conditions hold:

• $[eqn]$ has never queried the oracle extract-partial-secret ( $[eqn]$ ).
• $[eqn]$ has never queried the oracle super-sign ( $[eqn]$ ).
• $[eqn]$ , where $[eqn]$ is the current public key of the t-th terminal device, which can be replaced by $[eqn]$ .

Definition 1. *The proposed certificateless signature scheme is existentially unforgeable against a Super Type-I adversary $[eqn]$ if, within polynomial time, $[eqn]$ undertakes the following: $[eqn]$ queries to the hash oracle, $[eqn]$ queries to create-user ( $[eqn]$ ), $[eqn]$ queries to extract-partial-secret ( $[eqn]$ ), $[eqn]$ queries to extract-secret ( $[eqn]$ ), $[eqn]$ queries to request-public-key ( $[eqn]$ ), $[eqn]$ queries to replace-public-key ( $[eqn]$ ), and $[eqn]$ queries to super-sign ( $[eqn]$ * ). If $[eqn]$ , the probability of $[eqn]$ winning Game 1, is negligible, and the scheme is secure against a Super Type-I adversary.

Game 2. This game takes place between a challenger C and a Super Type-II adversary $[eqn]$ , interacting within the proposed certificateless signature scheme. First, in the “Initialization” phase, challenger C runs the corresponding algorithms and generates a private key $[eqn]$ , along with public system parameters $[eqn]$ . Then, C keeps $[eqn]$ secret while providing $[eqn]$ to the adversary. Second, in the “Query” phase, $[eqn]$ can adaptively access the following oracle queries: create-user ( $[eqn]$ ), request-public-key ( $[eqn]$ ), replace-public-key ( $[eqn]$ ), extract-secret ( $[eqn]$ ), extract-partial-secret ( $[eqn]$ ), and super-sign ( $[eqn]$ ). After making all necessary queries, $[eqn]$ outputs a forged signature ( $[eqn]$ ). $[eqn]$ wins Game 2 if the following three conditions hold:

• $[eqn]$ has never queried the oracle extract-secret ( $[eqn]$ ).
• $[eqn]$ has never queried the oracle super-sign ( $[eqn]$ ).
• $[eqn]$ , where $[eqn]$ is the current public key of the t-th terminal device, which can be replaced by $[eqn]$ .

Definition 2. The proposed certificateless signature scheme is existentially unforgeable against a Super Type-II adversary $[eqn]$ if, for any polynomial-time adversary $[eqn]$ , the success probability $[eqn]$ of winning Game 2 is negligible. $[eqn]$ is allowed to undertake the following: $[eqn]$ queries to the hash oracle, $[eqn]$ queries to create-user ( $[eqn]$ ), $[eqn]$ queries to extract-partial-secret ( $[eqn]$ ), $[eqn]$ queries to extract-secret ( $[eqn]$ ), $[eqn]$ queries to request-public-key ( $[eqn]$ ), $[eqn]$ queries to replace-public-key ( $[eqn]$ ), and $[eqn]$ queries to super-sign ( $[eqn]$ ). If $[eqn]$ is negligible, then the scheme is secure against a Super Type-II adversary.

2.5. Security Requirements

In the NDN-IoT environment, an efficient certificateless aggregate signature scheme based on elliptic curves should meet the following security requirements:

Data Integrity: Elliptic curve cryptography (ECC) should be used to protect data from unauthorized access during transmission. Encryption ensures that only legitimate entities possessing the corresponding decryption key can access and interpret the data, effectively maintaining the privacy and confidentiality of communications.Key Management: The secure generation, distribution, and updating of keys is essential to prevent key leakage or misuse. A robust key management system is crucial for maintaining overall system security and ensuring the safety and validity of cryptographic keys.User Privacy: In an NDN-IoT system, content names are used to request data, and these names are semantically related to user preferences, making them visible within the network. Additionally, since each node in an NDN-IoT system can cache content, malicious users may still obtain content even if content names are protected. Therefore, user privacy protection must be ensured by maintaining content anonymity and protecting user behavior privacy, preventing attackers from inferring the content of user requests.Resistance to Various Security Attacks: The NDN-IoT system is vulnerable to multiple security threats, such as impersonation and replay attacks. Thus, the proposed signature scheme must be capable of resisting various security attacks to ensure the safety and reliability of communications.

3. Proposed Scheme

This paper proposes an efficient certificateless aggregate signature scheme based on ECC, utilizing ECC and a general hash function while avoiding bilinear pairing operations and map-to-point hash functions.

Meanwhile, considering a resource-constrained environment, we introduce an unauthenticated aggregate signature method. The proposed scheme enables cryptographic signature aggregation for n concurrent message transmissions. A consumer sends requests to n producers over a period of time, with each producer generating a data packet. The original independent signatures from the n data packets are compressed into an aggregate signature within the NDN router, thereby reducing signature verification time and minimizing the storage overhead of the NDN router.

3.1. System Initialization

The KGC takes a security parameter, $[eqn]$ , as the input and selects a cyclic group $[eqn]$ of prime order $[eqn]$ , where $[eqn]$ is a generator of $[eqn]$ . Next, the KGC randomly selects a secret value $[eqn]$ and computes the public key: $[eqn]$ . Then, the KGC sets $[eqn]$ as the master secret key and $[eqn]$ as the public key. The KGC also selects three general one-way hash functions: $[eqn]$ , $[eqn]$ , $[eqn]$ , $[eqn]$ . Finally, the KGC keeps $[eqn]$ confidential and publishes the system parameters: $[eqn]$ .

3.2. Generation of Terminal Device Pseudonyms

To prevent malicious users from launching traffic analysis attacks or user location tracking attacks in the NDN network, each terminal device $[eqn]$ must register its real identity $[eqn]$ with the KGC to generate a pseudonym for anonymous communication. Additionally, since the KGC manages the real identities, $[eqn]$ , of all terminal devices, $[eqn]$ , in the system, it can effectively track malicious users. The terminal device $[eqn]$ randomly selects a value $[eqn]$ and computes the following: $[eqn]$ Then, $[eqn]$ submits $[eqn]$ to the KGC. Upon receiving $[eqn]$ , the KGC computes the following: $[eqn]$ Thus, the real identity of the terminal device is retrieved. If $[eqn]$ is invalid, the KGC discards the request. Otherwise, the KGC computes the following: $[eqn]$ and then sends $[eqn]$ to $[eqn]$ , where $[eqn]$ represents the validity period of the pseudonym $[eqn]$ . The implementation process is illustrated in Algorithm 1 and Figure 3.

Algorithm 1: Generation of ED_i_ Pseudonym Input: params, ID_i_Output: PID_i_1.         $[eqn]$         //Generate a random constant2.        M_i_ = l_i_ P;3.        N_i_ = l_i_ Ppub;4.         $[eqn]$ ;5.         $[eqn]$         //Generate a random constant6.         $[eqn]$ ;7.         $[eqn]$ ) then8.                 $[eqn]$ ; T_i_ is the validity period of the PID_i_9.                 $[eqn]$ ;10.       else return null;11.        $[eqn]$

To track the real identity of terminal devices, the KGC stores $[eqn]$ in its secure database. In the future, these terminal devices will communicate using pseudonyms, which can help protect their real identity information.

3.3. Generation of Terminal Device Keys

When $[eqn]$ obtains its pseudonym from the KGC, it selects a random number $[eqn]$ as its key value and computes $[eqn]$ . Then, $[eqn]$ sends its pseudonym $[eqn]$ to KGC. The KGC searches for $[eqn]$ in its database. If it exists, the KGC executes the following algorithm to generate the partial private key for $[eqn]$ .

Given the public parameters, $[eqn]$ and the terminal device pseudonym, $[eqn]$ , the KGC selects a random number $[eqn]$ and computes $[eqn]$ . The KGC then computes the following: $[eqn]$ The partial private key $[eqn]$ is then sent to $[eqn]$ . Upon receiving $[eqn]$ , the terminal device $[eqn]$ verifies whether the following equation holds: $[eqn]$ If the equation holds, $[eqn]$ accepts the partial private key. Otherwise, it rejects it.

Finally, $[eqn]$ computes $[eqn]$ Then, it sets $[eqn]$ as its private key and $[eqn]$ as its public key. The implementation process is illustrated in Algorithm 2 and Figure 4.

Algorithm 2: Generation of ED_i_ Key Input: params, PID_i_Output: SK_i_, PK_i_1.         $[eqn]$ ;        //Generate a random constant2.         $[eqn]$ ;3.         $[eqn]$ ;        //Generate a random constant4.         $[eqn]$ ;5.         $[eqn]$ ;6.         $[eqn]$ ;7.        if ( $[eqn]$ ) then8.               $[eqn]$ ;9.               $[eqn]$ ;10.             $[eqn]$ ;11.             $[eqn]$ ;12.      else return null;13.       $[eqn]$

3.4. Generation and Verification of a Single Digital Signature

To generate a digital signature, $[eqn]$ obtains a message: $[eqn]$ . It then selects a random number, $[eqn]$ , and computes the following: $[eqn]$ where $[eqn]$ is the current timestamp. $[eqn]$ then computes $[eqn]$ . Thus, the output signature is $[eqn]$ . Finally, $[eqn]$ sends the information $[eqn]$ to a nearby NDN router. The process is described in Algorithm 3.

Algorithm 3: Generation of a Single Digital Signature Input: params, PID_i_, SK_i_, PK_i_Output: σ_i_1.         $[eqn]$ ;2.         $[eqn]$ ;3.         $[eqn]$ ;4.         $[eqn]$ ;      //t_i_ is the current timestamp5.         $[eqn]$ ;6.         $[eqn]$ ;7.         $[eqn]$ ;

When performing digital signature verification, or when the NDN router receives the message $[eqn]$ , it first checks whether $[eqn]$ is within the valid period, $[eqn]$ , and whether $[eqn]$ is fresh. If it is invalid, the message is discarded; otherwise, the NDN router computes $[eqn]$ and verifies whether the equation $[eqn]$ holds. If the equation holds, the NDN router accepts the signature, and the single digital signature verification is successful; otherwise, the signature is rejected.

3.5. Generation and Verification of Aggregated Digital Signatures

When an NDN router receives a large number of messages $[eqn]$ from different $[eqn]$ , it computes $[eqn]$ and $[eqn]$ ; it then outputs the aggregated signature $[eqn]$ . Finally, the NDN router sends $[eqn]$ along with $[eqn]$ to other NDN routers. The algorithm process is shown in Algorithm 4.

Algorithm 4: Generation of Aggregated Digital Signature Input: σ_i_Output: ς1.         $[eqn]$ ;2.         $[eqn]$ ;3.         $[eqn]$ ;4.         $[eqn]$ ;

When other NDN routers receive $[eqn]$ and $[eqn]$ , the NDN routers check the validity of the aggregated signature $[eqn]$ by verifying whether $[eqn]$ holds, where $[eqn]$ and $[eqn]$ . If the equation holds, the aggregated signature is accepted, and the verification is successful; otherwise, the signature is rejected, and the verification fails.

4. Security Analysis

Correctness Analysis

The proof of the correctness of single signature verification is shown in Equation (2):

$$[eqn]$$

The proof of correctness of the aggregate signature verification is shown in Equation (3):

$$[eqn]$$

5. Formal Security Analysis

Under the condition that solving the $[eqn]$ is extremely difficult, we have proven that the ECAE scheme possesses existential unforgeability against both Super Type I and Super Type II adversaries.

Theorem 1. *In the random oracle model, assuming that solving the $[eqn]$ is difficult, the proposed certificateless signature scheme possesses existential unforgeability against a Super Type-I adversary. That is, if there exists a Super Type-I adversary *

• $[eqn]$ that can submit queries to the random oracle model and win Game 1 with probability $[eqn]$ , then there exists an algorithm $[eqn]$ that can solve a random instance of the $[eqn]$ in polynomial time, with a success probability of $[eqn]$

Proof. Assume there exists a Super Type-I adversary $[eqn]$ that can break our proposed certificateless signature scheme with a non-negligible probability $[eqn]$ . We can construct a polynomial-time algorithm $[eqn]$ that utilizes $[eqn]$ to solve the $[eqn]$ .Initialization Phase: Algorithm $[eqn]$ initializes two tables: a hash table, $[eqn]$ (initially empty), and a key table, $[eqn]$ (initially empty). In Game 1, $[eqn]$ selects an identity $[eqn]$ as the challenge identity, sets the public key of the KGC as $[eqn]$ , and sends the parameters $[eqn]$ to $[eqn]$ .Query Phase of the Super Adversary:

• Create-user ( $[eqn]$ ): The random oracle model takes $[eqn]$ as the input. If $[eqn]$ has already been created, nothing happens. Otherwise, $[eqn]$ runs the corresponding algorithm to generate the following: the partial private key $[eqn]$ , the secret key $[eqn]$ , and the public key $[eqn]$ . Then, $[eqn]$ returns these values to $[eqn]$ .
• Hash Queries: (1) When $[eqn]$ queries the hash function at $[eqn]$ , if the list $[eqn]$ contains $[eqn]$ , then $[eqn]$ returns $[eqn]$ to $[eqn]$ . Otherwise, $[eqn]$ randomly selects $[eqn]$ , returns it to $[eqn]$ , and adds $[eqn]$ to $[eqn]$ . (2) When $[eqn]$ queries the hash function at $[eqn]$ , if $[eqn]$ contains $[eqn]$ , then $[eqn]$ returns $[eqn]$ to $[eqn]$ . Otherwise, $[eqn]$ randomly selects $[eqn]$ , returns it to $[eqn]$ , and adds $[eqn]$ to $[eqn]$ .
• request-public-key ( $[eqn]$ ): Upon receiving a request-public-key query for identity $[eqn]$ , $[eqn]$ checks if $[eqn]$ . If true, $[eqn]$ selects three random values $[eqn]$ and computes the following: $[eqn]$ . $[eqn]$ updates the following: $[eqn]$ with $[eqn]$ , $[eqn]$ with $[eqn]$ and $[eqn]$ . Finally, $[eqn]$ returns $[eqn]$ to $[eqn]$ . Otherwise, $[eqn]$ selects three random values $[eqn]$ and sets $[eqn]$ , $[eqn]$ . $[eqn]$ updates the following: $[eqn]$ with $[eqn]$ , $[eqn]$ with $[eqn]$ and $[eqn]$ . Finally, $[eqn]$ returns $[eqn]$ to $[eqn]$ .
• extract-partial-secret ( $[eqn]$ ): Upon receiving an extract-partial-secret query for identity $[eqn]$ , if $[eqn]$ , $[eqn]$ terminates the session. Otherwise, $[eqn]$ checks $[eqn]$ for an entry $[eqn]$ . If such a record exists, $[eqn]$ returns $[eqn]$ to $[eqn]$ . Otherwise, $[eqn]$ first performs a request-public-key ( $[eqn]$ ) query and then returns $[eqn]$ to $[eqn]$ .
• extract-secret ( $[eqn]$ ): Upon receiving an extract-secret query for identity $[eqn]$ , $[eqn]$ searches $[eqn]$ for $[eqn]$ . If such a record exists, $[eqn]$ returns $[eqn]$ to $[eqn]$ . Otherwise, $[eqn]$ first performs an extract-partial-secret ( $[eqn]$ ) query and then returns $[eqn]$ to $[eqn]$ .
• replace-public-key ( $[eqn]$ ): Once $[eqn]$ receives the query ( $[eqn]$ ) from $[eqn]$ , it searches the list $[eqn]$ for an entry $[eqn]$ . If such a record exists, $[eqn]$ sets $[eqn]$ and $[eqn]$ . Otherwise, $[eqn]$ first performs a request-public-key ( $[eqn]$ ) query and then sets $[eqn]$ and $[eqn]$ .
• super-sign ( $[eqn]$ ): Upon receiving a super-sign query with ( $[eqn]$ ) from $[eqn]$ , $[eqn]$ searches for the following: $[eqn]$ in the list $[eqn]$ and $[eqn]$ in the list $[eqn]$ . Then, $[eqn]$ generates a random value $[eqn]$ and computes the following: $[eqn]$ . Then, $[eqn]$ returns the signature $[eqn]$ to $[eqn]$ .

Finally, $[eqn]$ outputs a forged but valid signature ( $[eqn]$ ). If $[eqn]$ , $[eqn]$ terminates the simulation. Otherwise, $[eqn]$ searches the tables $[eqn]$ and $[eqn]$ for the entries: $[eqn]$ . On the other hand, based on the Forking Lemma [27], through polynomial-time replay attacks under the same source of randomness but different hash oracle choices, it is possible to obtain two additional valid signatures. Eventually, three valid signatures are obtained: $[eqn]$ . These signatures satisfy the following equation: $[eqn]$ , for $[eqn]$ . Note that for $[eqn]$ to win the first game, it must have never queried the extract-partial-secret or the super-sign oracle. Using the above three equations, $[eqn]$ can solve for the three unknowns $[eqn]$ and $[eqn]$ as the solution to a random instance of $[eqn]$ , given by $[eqn]$ . So far, we have demonstrated that $[eqn]$ can solve a given $[eqn]$ instance. Next, we analyze the probability $[eqn]$ that $[eqn]$ wins in Game 1.

• E1: $[eqn]$ does not terminate in any extract-partial-secret queries.
• E2: $[eqn]$ successfully forges a valid signature ( $[eqn]$ ).
• E3: The forged signature ( $[eqn]$ ) satisfies $[eqn]$ .

The corresponding probabilities of the three events mentioned above are given as follows: $[eqn]$ , where $[eqn]$ represent the number of create-user queries, hash queries, and extract-partial-secret queries, respectively. In this case, the probability that $[eqn]$ solves the given instance of $[eqn]$ is as follows: $[eqn]$ . Clearly, since $[eqn]$ is non-negligible, $[eqn]$ can solve $[eqn]$ with a non-negligible probability $[eqn]$ . This contradicts the assumed difficulty of $[eqn]$ . □

Theorem **2.**In the random oracle model, assuming that solving  $[eqn]$  is hard, the proposed certificateless signature scheme is existentially unforgeable against a Super Type-II adversary. That is, if there exists a Super Type-II adversary  $[eqn]$ , which can query the random oracle model and win Game 2 with probability  $[eqn]$ , then there exists an algorithm  $[eqn]$  that can solve a random instance of  $[eqn]$  in polynomial time with a success probability:  $[eqn]$ .

Proof. Suppose there exists a Super Type-II adversary $[eqn]$ that can break our certificateless signature scheme with a non-negligible probability $[eqn]$ . Then, we can construct a polynomial-time algorithm $[eqn]$ that uses $[eqn]$ to solve $[eqn]$ . That is, $[eqn]$ is given a random instance of $[eqn]$   $[eqn]$ . The goal of $[eqn]$ is to compute the secret key $[eqn]$ . Initialization Phase: $[eqn]$ selects an identity $[eqn]$ as the challenge identity in Game 2. It sets the public key $[eqn]$ and sends the master key $[eqn]$ along with the parameters, $[eqn]$ to the adversary $[eqn]$ . $[eqn]$ also maintains two lists, $[eqn]$ and $[eqn]$ , to record oracle query responses. Next, during the query phase, $[eqn]$ interacts with $[eqn]$ and simulates the oracle model by responding to the adversary’s queries. Since the create-user, hash query, replace-public-key, and super-sign queries have already been defined in Theorem 1, we do not provide their descriptions here. In the following, we simulate the other oracle queries made by $[eqn]$ :

• request-public-key ( $[eqn]$ ): When $[eqn]$ queries the public key of identity $[eqn]$ , $[eqn]$ proceeds as follows. If $[eqn]$ , $[eqn]$ generates two random values $[eqn]$ and computes the following: $[eqn]$ . Then, $[eqn]$ adds the tuples $[eqn]$ and $[eqn]$ to the lists $[eqn]$ and $[eqn]$ . Finally, $[eqn]$ returns $[eqn]$ to $[eqn]$ . Otherwise, $[eqn]$ selects a random value $[eqn]$ and sets $[eqn]$ . Then, $[eqn]$ adds $[eqn]$ to $[eqn]$ and $[eqn]$ to $[eqn]$ . Finally, $[eqn]$ returns $[eqn]$ to $[eqn]$ .
• extract-partial-secret ( $[eqn]$ ): When $[eqn]$ queries the partial private key for identity $[eqn]$ , $[eqn]$ proceeds as follows: $[eqn]$ searches for $[eqn]$ in $[eqn]$ . If such a record exists, $[eqn]$ returns $[eqn]$ to $[eqn]$ . Otherwise, $[eqn]$ performs a request-public-key ( $[eqn]$ ) query and returns $[eqn]$ to $[eqn]$ .
• extract-secret ( $[eqn]$ ): When $[eqn]$ queries the full private key of identity $[eqn]$ , $[eqn]$ proceeds as follows: if $[eqn]$ , $[eqn]$ terminates the session. Otherwise, $[eqn]$ searches for $[eqn]$ in $[eqn]$ . If such a record exists, $[eqn]$ returns $[eqn]$ to $[eqn]$ . Otherwise, $[eqn]$ performs a request-public-key ( $[eqn]$ ) query and then returns $[eqn]$ to $[eqn]$ .

Finally, $[eqn]$ outputs a forged but valid signature ( $[eqn]$ ). If $[eqn]$ , the simulation stops. Otherwise, $[eqn]$ searches in list $[eqn]$ for $[eqn]$ and $[eqn]$ . Based on the Forking Lemma [27], if there is polynomial replay under the same randomness and different hash oracle model choices, $[eqn]$ can generate another valid signature. Eventually, we obtain two valid signatures: $[eqn]$ for $[eqn]$ , satisfying the following equation: $[eqn]$ for $[eqn]$ . It is important to note that winning Game 2 requires that the oracle queries extract-secret and super-sign are never made. Using the two independent linear equations above, $[eqn]$ can derive the two unknown values $[eqn]$ and $[eqn]$ and output them as the solution to the random $[eqn]$ instance $[eqn]$ . This, in turn, allows us to analyze the probability of $[eqn]$ winning in Game 2. We introduce the events leading to success as follows:

• E1: $[eqn]$ does not terminate in any extract-secret query.
• E2: $[eqn]$ successfully forges a valid signature ( $[eqn]$ ).
• E3: The forged signature ( $[eqn]$ ) satisfies $[eqn]$ .

The probabilities of these events are given as follows: $[eqn]$ , where $[eqn]$ denote the number of create-user queries, hash queries, and extract-secret queries, respectively. Thus, the probability that $[eqn]$ solves the given instance of $[eqn]$ is as follows: $[eqn]$ . Since $[eqn]$ is non-negligible, $[eqn]$ is able to solve $[eqn]$ with non-negligible probability, $[eqn]$ , contradicting the difficulty of solving $[eqn]$ . □

In summary, the proposed ECAE scheme achieves existential unforgeability under the random oracle model based on the difficulty assumption of the Elliptic Curve Discrete Logarithm Problem (ECDLP). Through the proof of formal security, it effectively resists two types of adversaries and defends against advanced attacks such as public key replacement and key escrow, thereby providing provable security guarantees for NDN-IoT environments.

Informal Security Analysis

Anonymity: During communication, the true identity of the terminal device is hidden behind a pseudonym, such as $[eqn]$ , where $[eqn]$ and $[eqn]$ . Here, $[eqn]$ represents the validity period of the pseudonym. Each terminal device uses a pseudonym $[eqn]$ generated by the KGC for communication. Apart from the KGC, no adversary can retrieve the real identity of the terminal device from the pseudonym.

Unlinkability: During communication, the terminal device uses different pseudonyms for each interaction. Each message is signed using a different pseudonym and its corresponding private key. There is no connection between the new and old pseudonyms. Therefore, an attacker cannot infer the terminal device from the new pseudonym, ensuring the unlinkability of the scheme.

Message Authentication: In our scheme, every message generated by a terminal device must be signed before being sent to a nearby NDN router. The NDN router can verify the signature to ensure that the message has not been tampered with or forged by an attacker or an unauthorized device. Additionally, the ECAE scheme provides existential unforgeability against both Type-I and Type-II adversaries. Therefore, the proposed scheme meets the security requirements for message authentication.

Conditional Traceability: When a terminal device malfunctions or causes an incident, the KGC can trace the real identity of the user. The KGC retrieves $[eqn]$ from its secure database and computes $[eqn]$ to obtain the real identity of the malicious user. Since $[eqn]$ is the master private key of the KGC, only the KGC has access to this information. Thus, only the KGC can trace the real identity of the terminal device, while no other entity can do so.

Non-repudiation: Based on the analysis above, if a terminal device denies certain information, the KGC can identify its real identity through the pseudonym of the malicious device. Therefore, no device can deny its signature on a message.

Resistance to Replay Attacks: A replay attack occurs when an attacker records or reuses communication messages to deceive the system. In the proposed scheme, the interactions between the ED, NDN router, and KGC incorporate random numbers and timestamps. The recipient can detect whether a message is a replayed one and effectively filter out any illegitimate replayed messages.

Perfect Forward Secrecy: Suppose an attacker obtains the private key $[eqn]$ of a terminal device, $[eqn]$ . Since the temporary random number $[eqn]$ used by $[eqn]$ during each signing session is independent of the private key and the signature $[eqn]$ includes $[eqn]$ , which depends on $[eqn]$ , the attacker cannot derive $[eqn]$ from any historical session, even if $[eqn]$ is exposed. This is because recovering $[eqn]$ from $[eqn]$ requires solving the ECDLP. Similarly, in the aggregate signature, $[eqn]$ , where $[eqn]$ , the value also depends on the temporary random numbers used in each session. This further ensures that even if a terminal device’s key is compromised, the confidentiality of previous sessions remains intact. Therefore, the ECAE scheme possesses the property of perfect forward secrecy.

6. Performance Analysis

In this section, the ECAE scheme will be compared with the schemes proposed by Huang et al. [11], Yang et al. [15], Karati et al. [16], Thumbur et al. [17], and Zhu et al. [23] in terms of security features, the number of cryptographic operations, computational delay, and communication overhead. Due to its high efficiency and robust security properties, the Curve25519 elliptic curve has been widely adopted in various fields [28,29]. Therefore, this experiment selected Curve25519 as the underlying elliptic curve, with a security parameter of $[eqn]$ = 256. The curve is defined over the prime field $[eqn]$ , and its equation is given by $[eqn]$ , where the $[eqn]$ -coordinate of the base point $[eqn]$ is 9.

6.1. Security Functionality Comparison

Table 2 presents a functional comparison between the ECAE scheme and other existing schemes. Notably, many current signature schemes do not ensure the anonymity of message sources, which may allow attackers to easily trace the origin of messages, thereby compromising user privacy. In addition, the group signature scheme proposed by Huang et al. [11] in recent years has improved authentication efficiency. However, its resistance to man-in-the-middle attacks is inadequate, giving attackers opportunities to insert themselves between communicating parties, enabling eavesdropping, message tampering, or impersonation. By comparison, the scheme proposed by Karati et al. [16] appears relatively outdated. It lacks non-repudiation and unlinkability, making it vulnerable to signature forgery attacks, which compromise the integrity and authenticity of information. The schemes proposed by Karati et al. [16], Thumbur et al. [17], and Zhu et al. [23] share several common shortcomings, such as the absence of a timely signature update mechanism, making them ineffective against replay attacks. Bisheh-Niasar et al. [19] adopted the Edwards curve signature algorithm and focused primarily on hardware architecture. However, their scheme remains vulnerable to man-in-the-middle and replay attacks. Unlike these schemes, the solution proposed in this paper comprehensively meets all the security requirements listed in the table, offering a more complete and efficient approach to overcoming the limitations of existing schemes.

6.2. Computation Delay

We simulated these methods on two Ubuntu 16.04 devices using the OpenSSL library [30], GMP library [31], and PBC library [32]. The terminal device hardware used was a RASPBERRY PI 3B+ with 1 GB of LPDDR2 SDRAM and a 1.4 GHz BCM2837B0 system-on-chip. The AG hardware used a computer with 4 GB of RAM and an INTEL(R) CELERON (R) J1900 CPU.

In the six schemes compared, the cryptographic operations used included hash operations, point multiplication, point addition, XOR operations, exponentiation, and bilinear pairing operations, which are denoted as follows: Has, Mul, Add, Xor, EXP, and BPA. The execution time for each cryptographic operation is shown in Table 3.

Table 4 provides a comparison of the number of cryptographic operations and their execution times across different schemes. It can be observed that the ECAE scheme exhibits the shortest overall execution time on the ED. Figure 5 shows a comparison of computational delays between the schemes. The total computation time of the ECAE scheme is 46.18% lower than Huang et al.’s [11] scheme, 26.82% lower than Yang et al.’s scheme [15], 12.27% lower than Karati et al.’s scheme [16], 19.07% lower than Thumbur et al.’s scheme [17], 20.35% lower than Bisheh-Niasar et al.’s scheme [19], and 7.50% lower than Zhu et al.’s scheme [23].

In Section 4, a comprehensive security analysis of the ECAE scheme is provided to validate its resistance against typical attacks. Through this security analysis, we define the attacks we can defend against as known attacks, while other potential attacks, due to their unpredictability, are categorized as unknown attacks. It is assumed that unknown attacks may interfere with the authentication process of these seven schemes, whereas known attacks do not. In the case of known attacks, each scheme exhibits fixed computational delays; however, in the case of unknown attacks, the computational delay may vary. To assess the impact of this uncertainty on performance, simulations were conducted using C++ experiments, evaluating the performance of the authentication schemes under unknown attack conditions. By adjusting the ratio of unknown attacks to known attacks, the computational delay for each scheme can be measured. The performance measurement parameter is defined as the average successful computational delay calculated by Equation (4). Additionally, delay_known_ represents the computational delay under known attacks, while delay_unknown_ represents the computational delay under unknown attacks, which is a random value.

$$[eqn]$$

Figure 6 shows the relationship between the average computational delay of each scheme and the proportion of unknown attacks. The vertical axis represents the average computational delay, and the horizontal axis represents the proportion of unknown attacks out of the total attacks. The seven schemes are represented by curves of different colors and shapes. As seen in Figure 6, with the increase in the proportion of unknown attacks, the average computational delay of each scheme gradually increases. Notably, the ECAE scheme exhibits the smallest computational delay as the proportion of unknown attacks increases. Through a comprehensive analysis of efficiency and security, it was concluded that the proposed scheme has significant advantages in both aspects.

6.3. Communication Overhead

In the NDN packet forwarding mechanism, the transmission of an Interest packet triggers the entire data transfer process. The Interest packet propagates through the network, and each router makes intelligent forwarding decisions based on the data name in the Interest packet. Once the Interest packet reaches the producer, the data packet is generated and accompanied by a digital signature to ensure data integrity and source authenticity. These data packets are transmitted along the reverse path of the Interest packet and are forwarded by routers until they reach the initiator of the Interest. Therefore, the length of the signature is an important factor in determining the communication costs. In this experiment, it was assumed that the communication usage for point multiplication in $[eqn]$ was 320 bits, and the communication usage for the numbers in $[eqn]$ was 160 bits. Table 5 presents the analysis of the signature length in the seven schemes. Figure 7 shows a comparison of the total communication overheads across the seven schemes.

By analyzing Table 5 and Figure 7, it can be concluded that the signature lengths in both the ECAE scheme and the scheme proposed by Bisheh-Niasar et al. are the shortest. This is because both schemes employ fewer point multiplication operations during the signature generation process and emphasize the inclusion of minimal data in the signature design. Therefore, from the perspective of memory and communication overheads, the ECAE scheme demonstrates a notable performance advantage.

7. Conclusions and Future Work

The research results show that the signature algorithms used in NDN to ensure packet security still have limitations in terms of security and compatibility with IoT devices. To effectively address these issues, this paper proposes an efficient certificateless aggregate signature scheme in the NDN-IoT environment. By utilizing low-cost elliptic curve cryptosystems and conventional hash functions, the signature verification process in the NDN architecture is optimized, thereby reducing the signature verification time overhead and the cache overhead of NDN routers, easing the burden of certificate management and achieving high compatibility with resource-constrained IoT devices. Experimental data show that the ECAE scheme reduces the total computation time by up to 46.18% compared to existing schemes. Furthermore, even in unknown attack scenarios, the ECAE scheme maintains stable performance, with a signature communication usage of only 640 bits, significantly reducing system resource requirements. To highlight the advantages of the ECAE scheme, a comprehensive security evaluation was also conducted. The security of this scheme is based on the ECDLP and has been verified under the random oracle model, proving that it can effectively resist Type I/II attacks while also providing multiple security properties such as anonymity and unforgeability. The simulation results show that, with relatively low computational delay and communication overhead, the ECAE scheme offers all the security functions provided by other schemes.

Our paper is based on the random oracle model (ROM). Although the ROM offers a concise and powerful framework for the security analysis of the ECAE scheme, it relies on several idealized assumptions that may not fully reflect real-world security scenarios. First, the ROM treats hash functions as perfect random functions, while real-world hash algorithms (e.g., SHA-3) are deterministic and may exhibit structural properties that attackers could exploit in targeted attacks, such as length extension or algebraic manipulation. Second, proof of security in the ROM does not directly provide concrete security guarantees in the standard model, especially in scenarios where hash functions are maliciously constructed or are subject to side-channel leakage. For example, if an adversary can extract the internal state of a hash function via physical side channels, the “unpredictability” assumption inherent to the ROM is broken. Moreover, transitioning from the ROM to the standard model typically necessitates stronger computational assumptions (e.g., DDH or LWE) or more complex cryptographic constructions, which may lead to significant performance degradation (e.g., increased group operations or larger key sizes). Although the ECAE scheme has been proven to be secure under the ROM, future work should explore the selection of hash functions that align with the abstract properties required by the ROM, develop provably secure alternatives in the standard model, and address potential threats such as the impact of quantum computing on the security of hash functions.

Furthermore, ECAE’s design—featuring constant-size aggregated signatures, pairing-free verification, and lightweight ECC operations—naturally supports high scalability under extreme network loads and massive packet volumes since routers can arbitrarily verify many signatures in constant time and end devices incur only minimal per-message overheads. However, actual performance under bursts of heterogeneous traffic still depends on factors such as aggregation window size, hardware parallelism, network topology, and the distribution of the Key Generation Center (KGC). Therefore, our future work will include large-scale simulations and testbed deployments to characterize latency–throughput trade-offs across diverse topologies, optimize dynamic aggregation intervals and parallel verification strategies, and explore distributed KGC architectures with adaptive parameter tuning so as to maintain millisecond-level verification latency even as the numbers of producers and data packets scale into the tens or hundreds of thousands.

In future research, we plan to explore the synergy of this scheme with other security mechanisms to build a more comprehensive NDN-IoT security architecture to meet the growing network threats. Additionally, we will investigate its practical performance under real-world hash functions and address performance bottlenecks in high-traffic NDN-IoT environments through systematic solutions. Beyond this, we aim to design extended functionalities such as group signatures and ring signatures to enhance adaptability in diverse application scenarios.