A Hierarchical Benchmarking Framework for Homomorphic Encryption-Based Aggregation and Validation Using Real Smart Meter Data

1. Introduction

The rapid growth of distributed cyber-physical systems, Internet of Things (IoT) networks, smart grids, healthcare monitoring platforms, industrial control systems, and edge intelligence has led to unprecedented volumes of sensitive data being generated at geographically dispersed locations. While centralized data aggregation enables efficient analytics, forecasting, optimization, and decision-making, it simultaneously raises significant privacy, security, and regulatory concerns. Data collected from sensors, smart meters, wearable devices, and critical infrastructures often contain sensitive information that can reveal behavioral patterns, operational characteristics, or confidential organizational activities. Consequently, secure data aggregation mechanisms have become an important research topic in modern distributed systems [1,2,3].

Homomorphic Encryption (HE) has emerged as one of the most promising cryptographic technologies for enabling privacy-preserving computation. Unlike conventional encryption techniques that require decryption prior to processing, HE allows arithmetic operations to be performed directly on encrypted data while preserving confidentiality throughout the computation lifecycle. Since Gentry introduced the first Fully Homomorphic Encryption (FHE) scheme in 2009 [1], substantial advances have been achieved in algorithm design, noise management, bootstrapping techniques, hardware acceleration, and practical software libraries.

Among contemporary HE schemes, the Brakerski-Fan-Vercauteren (BFV) and Cheon-Kim-Kim-Song (CKKS) schemes have gained widespread adoption [4]. BFV supports exact integer arithmetic and is particularly suitable for applications requiring strict correctness guarantees, such as accounting, billing, and secure voting systems [5]. In contrast, CKKS enables approximate arithmetic over real-valued data and is therefore well suited for machine learning, signal processing, statistical analytics, and scientific computing [2,6]. Recent advances in software frameworks such as Microsoft SEAL, OpenFHE, PALISADE, and TenSEAL have further improved the accessibility and deployment of these schemes in real-world applications [6,7,8].

The application of HE has expanded significantly in recent years. Privacy-preserving federated learning has become one of the most active research areas, where encrypted model updates are aggregated without revealing local training data [9]. Similarly, encrypted data analytics, cloud computing, healthcare systems, smart infrastructure monitoring, and secure multi-party computation have increasingly adopted HE-based approaches to protect sensitive information while enabling collaborative computation [3,10]. Despite these advances, practical deployment remains challenging due to the substantial computational overhead associated with encryption, ciphertext manipulation, key switching, and bootstrapping operations.

Consequently, benchmarking and performance characterization have become critical research directions. Several recent studies have investigated acceleration techniques using GPUs, FPGAs, processing-in-memory architectures, and specialized hardware accelerators to improve the practicality of HE systems [11,12,13,14]. Comprehensive profiling and evaluation frameworks have also been proposed to quantify runtime, memory utilization, energy consumption, and scalability characteristics of modern HE libraries [15,16]. These studies collectively demonstrate that although substantial progress has been achieved, the performance of HE-based systems remains highly dependent on parameter selection, hierarchy depth, ciphertext size, and workload characteristics.

A major limitation of existing benchmarking efforts is that they often focus on isolated cryptographic primitives, machine learning workloads, or hardware-level optimizations. Comparatively little attention has been devoted to evaluating hierarchical encrypted aggregation workflows commonly encountered in smart grids, IoT infrastructures, distributed sensing systems, and multi-level operational networks. Such systems involve repeated aggregation of encrypted data across multiple organizational or geographical layers, introducing unique computational and communication challenges.

To address this gap, this paper presents a generic hierarchical homomorphic encryption benchmarking framework capable of evaluating encrypted aggregation workflows across configurable multi-level architectures. The framework supports multiple HE backends, including CKKS and BFV, while providing detailed measurements of encryption latency, decryption latency, homomorphic operation cost, memory utilization, ciphertext growth, communication overhead, and numerical accuracy. The framework further enables direct comparison of exact and approximate HE schemes under identical workloads, allowing researchers to quantify the trade-offs between computational efficiency and numerical precision.

Major Contributions

The primary contributions of this work are summarized as follows:

• C1: Development of a generic hierarchical HE benchmarking framework supporting configurable aggregation topologies and multiple encryption backends.
• C2: Comprehensive performance characterization of encrypted aggregation operations across multiple hierarchy levels.
• C3: Quantitative comparison of CKKS and BFV schemes with respect to computational overhead, scalability, ciphertext size, and aggregation accuracy.
• C4: Detailed logging and profiling of cryptographic operations, resource utilization, and communication costs.
• C5: Provision of an extensible experimental platform for future evaluation of emerging HE schemes, libraries, and privacy-preserving analytics applications.

The proposed framework provides researchers and practitioners with a reproducible environment for evaluating the practicality of homomorphic encryption in large-scale distributed cyber-physical systems and contributes toward the broader adoption of privacy-preserving computation technologies.

Outline of the Paper

The remainder of this paper is organized as follows. Section 2 provides the background on homomorphic encryption and more specifically on CKKS homomorphic encryption method. Section 3 reviews the related work, highlighting research gaps and the motivation for this study. Section 4 describes the design of the proposed SafeDER framework. Section 5 discusses the design of experiments conducted in this study and the experimental results and finally, Section 6 concludes the paper and outlines directions for future research.

2. Background

This section provides a high level background on homomorphic encryption followed by a discussion of CKKS homomorphic encryption scheme.

2.1. Homomorphic Encryption: An Overview

Homomorphic Encryption (HE) is a class of public-key cryptographic techniques that enables computations to be performed directly on encrypted data, without first decrypting it. The output of such a computation, when decrypted by the authorised key holder, yields a result identical (or approximately identical) to what would have been obtained by performing the same computation on the plaintext. This remarkable property makes homomorphic encryption a natural fit for privacy-preserving aggregation: an aggregation server can sum a collection of encrypted meter readings to produce an encrypted total, which only the authorised decryption key holder can reveal , the server itself never sees any plaintext value at any point.

Formally, a homomorphic encryption scheme $\mathcal{HE}=(\mathsf{KeyGen},\mathsf{Enc},\mathsf{Dec},\mathsf{Eval})$ satisfies the homomorphic property with respect to a plaintext operation $\circ \in \{+,\times \}$ if

$$\mathsf{Dec}\left({\mathsf{Eval}}_{\circ }\left(\mathsf{Enc}\left(m_1\right),\mathsf{Enc}\left(m_2\right)\right)\right)=m_1\circ m_2,$$

(1)

where $m_1$ and $m_2$ are plaintext messages, $\mathsf{Enc}(·)$ and $\mathsf{Dec}(·)$ denote encryption and decryption, respectively, and ${\mathsf{Eval}}_{\circ }(·)$ denotes the ciphertext-domain evaluation algorithm corresponding to the plaintext operation ∘. Thus, the operation is performed on encrypted data, but after decryption, the result is equivalent to applying ∘ directly to the plaintext messages.

2.1.1. Partially Homomorphic Encryption (PHE)

Partially Homomorphic Encryption supports unlimited evaluations of exactly one operation , either addition or multiplication, but not both simultaneously. The most widely used PHE scheme in the smart grid literature is the Paillier cryptosystem, which is additively homomorphic [17]. For ciphertexts $c_1=\mathsf{Enc}\left(m_1\right)$ and $c_2=\mathsf{Enc}\left(m_2\right)$, here, dot (·) is a multiplication operator, Paillier satisfies:

$$\mathsf{Enc}\left(m_1\right)·\mathsf{Enc}\left(m_2\right)\equiv \mathsf{Enc}(m_1+m_2)(mod{N}^2)$$

(2)

where $N=p·q$ is the RSA-style public modulus. Encryption of a message m is:

$$c=\mathsf{Enc}\left(m\right)=g^m·r^N(mod{N}^2)$$

(3)

for a public generator g and a random value r. Decryption uses the private key $(\lambda ,\mu )$ and the function $L\left(x\right)=(x-1)/N$:

$$m=L\left(c^{\lambda }mod{N}^2\right)·\mu modN$$

(4)

Paillier’s additive homomorphism is ideal for energy data aggregation, since summing meter readings requires only addition. Several other additively homomorphic schemes also appear in the reviewed literature:

• Boneh-Goh-Nissim (BGN): An additively homomorphic scheme based on bilinear groups that additionally supports one ciphertext multiplication, making it somewhat more expressive than pure-additive schemes [18].
• Additively Homomorphic ElGamal (AH-ElGamal): A variant of ElGamal encryption adapted to support additive homomorphism over elliptic curve groups [19].
• Ring-LWE-based linear schemes: Lattice-based constructions operating over polynomial rings $R_q={\mathbb{Z}}_q\left[x\right]/(x^n+1)$, which support linear (additive) operations at very high efficiency and are additionally post-quantum secure [20].

2.1.2. Fully Homomorphic Encryption (FHE)

Fully Homomorphic Encryption supports arbitrary sequences of both additions and multiplications on encrypted data, enabling general-purpose computation without requiring intermediate decryption. This is achieved through a technique called bootstrapping, which “refreshes” a ciphertext whose noise level has grown too large for reliable decryption. FHE is substantially more computationally expensive than PHE, but it is the only option when the computation of interest requires multiplication of encrypted values, for example, evaluating a polynomial on encrypted inputs or performing encrypted comparisons [1].

2.2. The CKKS Scheme

The Cheon-Kim-Kim-Song (CKKS) scheme is a levelled fully homomorphic encryption scheme specifically designed for real-number and floating-point arithmetic [2]. Unlike the exact-arithmetic HE schemes BFV and BGV, which operate on integers with exact results, CKKS operates on approximate arithmetic: computations produce results that are correct to within a small, controllable rounding error. This approximation is an intentional design feature, exploiting the fact that many practical computations (including energy data aggregation) do not require exact integer arithmetic and can tolerate small floating-point errors. The approximation trade-off makes CKKS significantly more efficient than exact FHE for numerical computations.

2.2.1. Mathematical Foundation

CKKS operates over the polynomial quotient ring:

$${\mathcal{R}}_q={\mathbb{Z}}_q\left[x\right]/\langle x^n+1\rangle ,$$

(5)

where $n\in \mathbb{N}$ is a power-of-two polynomial degree, ${\mathbb{Z}}_q$ denotes the ring of integers modulo the ciphertext modulus q, and $q\in \mathbb{N}$ is a large positive integer.

A plaintext message is represented as a vector:

$$\mathbf{m}=(m_1,\dots ,m_{n/2})\in {\mathbb{C}}^{n/2},$$

which is embedded into a polynomial $\mathsf{pt}\left(x\right)\in {\mathcal{R}}_q$ via the canonical embedding and scaling procedure.

This vectorized representation of m reflects the packing i.e. Single Instruction Multiple Data (SIMD) capability of CKKS, where multiple real-valued slots are encoded and encrypted simultaneously within a single ciphertext. Each ciphertext therefore operates on a packed vector of values, enabling parallel homomorphic operations over all slots.

Formally, CKKS defines an encoding map

$$\mathsf{Encode}:{\mathbb{C}}^{n/2}\to {\mathcal{R}}_q,\mathsf{Decode}:{\mathcal{R}}_q\to {\mathbb{C}}^{n/2}.$$

The scheme is defined as a tuple

$$\mathsf{HE}=(\mathsf{KeyGen},\mathsf{Enc},\mathsf{Dec},\mathsf{Eval}),$$

where each algorithm is probabilistic unless otherwise specified.

A plaintext polynomial $\mathsf{pt}\left(x\right)$ is first scaled by a factor $\Delta \in {\mathbb{R}}^{+}$ (typically $\Delta =2^k$, $k\in \mathbb{N}$), which controls the precision-noise trade-off.

Encryption is performed using a secret key:

$$s\in {\mathcal{R}}_q,$$

sampled from a small-norm distribution over ${\mathcal{R}}_q$.

The ciphertext is a pair:

$$\mathbf{c}=(c_0,c_1)\in {\mathcal{R}}_q^2,$$

(6)

where encryption is defined as

$$c_0=-a·s+\mathsf{pt}+e,c_1=a,$$

with $a\stackrel{\$}{\leftarrow }{\mathcal{R}}_q$ uniformly random and $e\in {\mathcal{R}}_q$ sampled from a discrete Gaussian error distribution $\chi$ with standard deviation $\sigma \in {\mathbb{R}}^{+}$.

Decryption is defined as:

$$\mathsf{Dec}\left(\mathbf{c}\right)=c_0+c_1·s\in {\mathcal{R}}_q,$$

(7)

followed by scaling down and rounding:

$$\mathsf{Decode}\left(\mathsf{Dec}\right(\mathbf{c})/\Delta )=\mathbf{m}+\epsilon ,$$

where $\epsilon \in {\mathbb{C}}^{n/2}$ is the approximation error induced by noise and scaling. Here, $\mathsf{Decode}(·)$ converts the decrypted polynomial representation back into the corresponding vector of approximate plaintext values.

2.2.2. Homomorphic Addition in CKKS

For ciphertexts:

$${\mathbf{c}}_1=(c_{1,0},c_{1,1}),{\mathbf{c}}_2=(c_{2,0},c_{2,1})\in {\mathcal{R}}_q^2,$$

encrypting $\Delta {\mathbf{m}}_1$ and $\Delta {\mathbf{m}}_2$, where ${\mathbf{m}}_1$ and ${\mathbf{m}}_2$ are the plaintext vectors and $\Delta$ is the CKKS scaling factor used during encoding; thus, $\Delta {\mathbf{m}}_1$ and $\Delta {\mathbf{m}}_2$ denote scaled encoded plaintexts rather than a homomorphic multiplication operation, homomorphic addition is defined as:

$${\mathbf{c}}_{\mathrm{add}}={\mathbf{c}}_1+{\mathbf{c}}_2=(c_{1,0}+c_{2,0},c_{1,1}+c_{2,1}),$$

(8)

where addition is performed component-wise in ${\mathcal{R}}_q$.

Decryption yields:

$$\mathsf{Dec}\left({\mathbf{c}}_{\mathrm{add}}\right)=\Delta ({\mathbf{m}}_1+{\mathbf{m}}_2)+e_1+e_2,$$

with $e_1,e_2\in {\mathcal{R}}_q$ independent ciphertext noise terms. After decryption and rescaling by $\Delta$, the decoded plaintext is

$${\mathbf{m}}_1+{\mathbf{m}}_2+{\epsilon }_{\mathrm{add}},$$

where ${\epsilon }_{\mathrm{add}}\in {\mathbb{C}}^{n/2}$ denotes the resulting approximation error induced by the accumulated ciphertext noise and the finite-precision scaling of the CKKS scheme. Throughout this work, $\parallel ·\parallel$ denotes the Euclidean (${\ell }_2$) norm applied to coefficient vectors in ${\mathbb{C}}^{n/2}$.

For $N_{\mathrm{add}}$ sequential additions, the deterministic worst-case bound is

$${∥{\displaystyle \sum _{i=1}^{N_{\mathrm{add}}}}{e}_i∥}_2\le N_{\mathrm{add}}\underset{i}{max}{\parallel e_i\parallel }_2,$$

(9)

Under zero-mean independence assumptions, root-mean-square error growth is proportional to $\sqrt{N_{\mathrm{add}}}$ rather than $N_{\mathrm{add}}$.

This yields the homomorphic property:

$$\mathsf{Dec}\left(\mathsf{Enc}\left(a\right)+\mathsf{Enc}\left(b\right)+\mathsf{Enc}\left(c\right)\right)\approx a+b+c.$$

(10)

Importantly, homomorphic addition does not consume the modulus-switching depth, although addition still accumulates error and practical circuit size remains constrained by the selected parameters and implementation limits.

2.2.3. CKKS Parameters and Security

The security of CKKS rests on the hardness of the Ring Learning With Errors (Ring-LWE) problem [20]. The three primary parameters are:

• Polynomial Modulus Degree (n): Determines both the security level and the number of slots ($n/2$ independent real values can be packed into one ciphertext via SIMD-style batching). Larger n provides stronger security but increases ciphertext size and computation time. For 128-bit classical security, $n=8192$ is a standard choice.
• Coefficient Modulus (q): A product of prime numbers whose total bit-width determines the available noise budget and the number of supported multiplication levels. Each prime represents one level in the modulus-switching chain; addition operations do not consume levels.
• Scale ($\Delta$): Controls the precision of floating-point representation. Setting $\Delta =2^{40}$ provides approximately twelve decimal digits of precision, far exceeding the precision required for energy consumption data.

In this project, CKKS is instantiated via the node-seal library (a Node.js binding for Microsoft SEAL) with the parameters shown in Table 1.

The coefficient modulus configuration [60, 40, 40, 60] consists of one 60-bit special prime (used internally by SEAL for key switching) and an arithmetic chain of three primes providing two multiplication levels. Since this system uses CKKS exclusively for addition and not multiplication, the noise budget was never fully consumed during the aggregation process, regardless of how many ciphertexts are summed together.

3. Related Work

Homomorphic Encryption (HE) has evolved from a largely theoretical cryptographic concept into a practical technology capable of supporting privacy-preserving analytics, secure data aggregation, machine learning, and cloud computing. Since the introduction of the first Fully Homomorphic Encryption (FHE) scheme by Gentry [1], significant research efforts have focused on improving computational efficiency, reducing ciphertext expansion, minimizing noise growth, and enabling practical deployment in real-world applications.

3.1. Foundations of Homomorphic Encryption

The theoretical foundations of modern HE can be traced to Gentry’s pioneering work on fully homomorphic encryption [1]. Subsequent research significantly improved efficiency through lattice-based cryptographic constructions and leveled homomorphic encryption schemes. The Brakerski-Gentry-Vaikuntanathan (BGV) scheme [21] and the Brakerski/Fan-Vercauteren (BFV) scheme [22] became important milestones in the development of practical HE systems.

More recently, Cheon et al. introduced the CKKS scheme [2], which supports approximate arithmetic over real-valued data and has become the preferred choice for privacy-preserving machine learning, signal processing, and scientific computing applications. These advances have enabled encrypted computation on increasingly complex workloads while maintaining acceptable performance characteristics.

3.2. HE Software Frameworks and Libraries

Several software libraries have emerged to facilitate the practical adoption of homomorphic encryption. Microsoft SEAL [7] is among the most widely used open-source HE frameworks and provides implementations of BFV and CKKS schemes. PALISADE [23] introduced a modular architecture for lattice-based cryptography and served as a foundation for subsequent developments.

OpenFHE [6] represents the next generation of open-source HE libraries, providing improved performance, broader algorithm support, and enhanced interoperability. Similarly, TenSEAL [8] extends HE functionality to tensor operations and machine learning applications, enabling encrypted inference and privacy-preserving analytics. These frameworks have significantly lowered the barrier to entry for researchers and practitioners seeking to integrate HE into distributed systems.

3.3. Homomorphic Encryption for Secure Data Aggregation

Secure aggregation represents one of the most important application domains for homomorphic encryption. Numerous studies have explored HE-based aggregation techniques in smart grids, wireless sensor networks, IoT environments, and cyber-physical systems.

Lu et al. [24] proposed one of the earliest privacy-preserving aggregation schemes for smart grid infrastructures using homomorphic encryption. Li et al. [25] further demonstrated secure smart-meter aggregation architectures capable of preserving user privacy while enabling utility-level analytics.

In IoT environments, encrypted aggregation techniques have been investigated to support privacy-preserving monitoring and distributed sensing applications [26,27]. These approaches generally rely on additive homomorphic properties to compute aggregate statistics without revealing individual sensor readings.

More recently, hierarchical aggregation architectures have attracted increasing attention due to their ability to reduce communication overhead and improve scalability in large-scale deployments. However, relatively few studies have systematically benchmarked the performance impact of multiple aggregation levels under realistic workloads.

3.4. Homomorphic Encryption for Machine Learning and Federated Learning

The convergence of HE and machine learning has become a major research direction. Secure machine learning frameworks leverage homomorphic encryption to protect training data, model parameters, and inference requests while preserving analytical capabilities.

Several studies have investigated encrypted neural network inference using CKKS-based implementations [28,29]. Privacy-preserving federated learning has emerged as another important application area, where local model updates are encrypted before aggregation [9,30].

Recent surveys have demonstrated the growing adoption of HE within federated learning systems and highlighted the trade-offs between privacy guarantees and computational overhead [3]. Despite substantial progress, encryption latency and communication costs remain significant challenges for large-scale deployments.

3.5. Performance Optimization and Hardware Acceleration

One of the primary barriers to widespread adoption of HE is its computational complexity. Consequently, significant research efforts have focused on performance optimization and hardware acceleration.

GPU-based acceleration has demonstrated substantial reductions in execution time for homomorphic operations [11]. Specialized architectures such as Taiyi [12] have been proposed to accelerate CKKS computations through customized hardware pipelines. Processing-in-memory approaches have also been investigated to reduce data movement overhead associated with ciphertext operations [14].

Additional studies have explored FPGA acceleration, ASIC-based architectures, and optimized bootstrapping implementations to further improve performance [31,32]. These advances suggest that hardware-software co-design will play a critical role in enabling future large-scale HE deployments.

3.6. HE Benchmarking and Profiling Frameworks

As HE systems become increasingly complex, systematic benchmarking has emerged as an important research area. Existing studies have evaluated the performance of different HE libraries, parameter configurations, and hardware platforms.

HEProfiler [15] introduced a detailed profiling framework capable of characterizing the runtime behavior of approximate HE schemes. Similarly, CryptOracle [16] proposed a modular benchmarking environment for evaluating multiple FHE implementations across diverse workloads.

Several comparative studies have analyzed BFV, BGV, and CKKS schemes under different security parameters and application scenarios [33,34]. These investigations have highlighted the significant impact of parameter selection on encryption latency, memory consumption, ciphertext growth, and computational accuracy.

Despite these advances, existing benchmarking frameworks typically focus on cryptographic primitives, encrypted machine learning workloads, or hardware accelerators. Comparatively little attention has been devoted to hierarchical encrypted aggregation systems involving multiple aggregation levels, distributed devices, and realistic telemetry workloads.

3.7. Homomorphic Encryption for Advanced Metering Infrastructure Data Integration

Advanced Metering Infrastructure (AMI) has emerged as a critical component of modern smart grid systems, enabling bidirectional communication between utilities and consumers while providing fine-grained electricity consumption measurements. The large volume of AMI data facilitates numerous applications including load forecasting, demand response, outage management, energy theft detection, and distribution network optimization. However, high-resolution smart meter readings can reveal sensitive information about consumer behavior, occupancy patterns, appliance usage, and lifestyle characteristics, creating significant privacy concerns [24,25].

To address these concerns, researchers have investigated the use of homomorphic encryption for privacy-preserving AMI data collection and aggregation. Early studies focused on additive homomorphic encryption techniques that enable utilities to compute aggregated energy consumption without accessing individual customer measurements [24]. Subsequent research extended these approaches to support dynamic pricing, demand response programs, and privacy-preserving billing mechanisms while maintaining regulatory compliance and consumer confidentiality [35,36].

Recent advances in homomorphic encryption have enabled more sophisticated AMI analytics. CKKS-based approaches support encrypted processing of real-valued meter measurements, making them suitable for forecasting, load analysis, and distributed energy resource management [2,8]. Similarly, BFV-based approaches provide exact arithmetic guarantees that are desirable for billing and accounting applications where numerical correctness is paramount [7,22].

Several studies have further explored privacy-preserving smart grid data integration architectures in which encrypted measurements collected from distributed smart meters are aggregated at neighborhood, feeder, or utility levels before centralized analysis [25,27]. These hierarchical aggregation models closely resemble practical AMI deployments and demonstrate the feasibility of performing large-scale encrypted computations while preserving consumer privacy.

Despite these advances, relatively few studies have systematically evaluated the performance implications of multi-level encrypted aggregation using realistic AMI datasets. Most existing work focuses on protocol design, privacy guarantees, or communication efficiency, whereas comprehensive benchmarking of encryption latency, aggregation overhead, memory utilization, ciphertext growth, and numerical accuracy across hierarchical infrastructures remains limited. Consequently, AMI datasets provide an important real-world validation environment for evaluating the scalability and practicality of homomorphic encryption frameworks.

In this work, AMI consumption measurements are employed as a representative distributed telemetry workload to validate the proposed benchmarking framework. The hierarchical structure of AMI deployments naturally aligns with the framework’s multi-level aggregation architecture, enabling quantitative evaluation of encrypted aggregation performance under realistic operational conditions while facilitating direct comparison between CKKS and BFV schemes.

3.8. Research Gap

The literature demonstrates substantial progress in homomorphic encryption algorithms, software libraries, secure aggregation techniques, machine learning applications, and hardware acceleration. However, several important limitations remain.

First, most existing studies evaluate isolated cryptographic operations rather than end-to-end hierarchical aggregation workflows. Second, direct comparisons between CKKS and BFV under identical multi-level aggregation workloads remain limited. Third, few benchmarking frameworks simultaneously capture computational performance, communication overhead, memory utilization, ciphertext growth, and numerical accuracy across large-scale distributed architectures.

To address these gaps, this work proposes a generic hierarchical homomorphic encryption benchmarking framework capable of evaluating encrypted aggregation across configurable multi-level infrastructures while supporting detailed comparison of CKKS and BFV schemes. The framework provides comprehensive performance characterization and offers a reproducible environment for future HE benchmarking research.

4. Framework Design and Implementation

4.1. Hierarchical Homomorphic Encryption Benchmarking Framework

To evaluate the practicality, scalability, and performance of privacy-preserving data aggregation in distributed cyber-physical systems, a generic hierarchical homomorphic encryption (HE) benchmarking framework was developed. The framework is application-independent and can model a wide range of systems including smart grids, Internet of Things (IoT) networks, industrial monitoring systems, healthcare infrastructures, defense sensing environments, and large-scale distributed telemetry systems.

The proposed framework consists of three logical layers:

• Data Acquisition Layer: End devices generate measurements from real-world datasets or synthetic data sources.
• Hierarchical Aggregation Layer: Intermediate aggregation nodes perform encrypted computations on ciphertexts without accessing plaintext values.
• Global Coordination Layer: The root node receives encrypted aggregates from lower levels and performs final aggregation before authorized decryption and validation.

Figure 1 illustrates the generic hierarchical HE benchmarking framework used in this work. At the device level, distributed end devices (e.g., smart meters) generate local measurements and encrypt them before transmission, ensuring that plaintext data never leaves the source node. At the cluster/intermediate level, aggregation nodes receive encrypted readings from multiple devices and perform homomorphic aggregation directly on ciphertexts to produce cluster-level encrypted summaries. These encrypted cluster aggregates are then forwarded to the global level, where the global aggregator performs the final encrypted aggregation across all clusters to obtain a single global ciphertext. The final result is then passed to an authorized key holder for decryption, after which validation is performed by comparing the decrypted aggregate with the corresponding plaintext reference. This hierarchical workflow reflects the practical operation of privacy-preserving distributed cyber-physical systems. Unlike conventional centralized architectures, the proposed framework supports arbitrary hierarchy depth and configurable fan-out factors, allowing realistic modeling of large-scale deployments consisting of thousands of distributed devices.

4.2. Homomorphic Encryption Abstraction Layer

To ensure extensibility and interoperability, the framework adopts a modular HE abstraction layer. All cryptographic backends implement a common interface consisting of:

• Encryption
• Decryption
• Homomorphic Addition
• Homomorphic Multiplication

This abstraction enables multiple HE schemes to be evaluated under identical experimental conditions without modifying application-level logic.

The current implementation supports:

• Mock HE backend for large-scale simulation studies
• BFV and CKKS implementation using TenSEAL
• Future integration of BGV, OpenFHE, Microsoft SEAL, HElib, and PALISADE

Consequently, the framework can serve as a generic benchmarking platform for evaluating emerging privacy-preserving computing technologies.

4.3. Hierarchical Encrypted Aggregation Process

For each aggregation cycle, the framework executes the following workflow.

4.3.1. Data Acquisition

Each device acquires a measurement represented as $x_i$, where $x_i$ denotes the observation generated by device i during a specific sampling interval.

The measurements may originate from energy consumption records, environmental sensors, industrial telemetry streams, healthcare monitoring systems, or synthetic benchmark datasets.

In our framework, for validation and evaluation, we utilize the Low Carbon London (LCL) smart meter dataset, which comprises half-hourly electricity consumption measurements from 5,567 London households, with half-hourly readings collected between November 2011 and February 2014 under the UK Power Networks Low Carbon London project [37].

4.3.2. Local Encryption

Each device encrypts its measurement using the selected HE scheme:

$$c_i=Enc\left(x_i\right)$$

where $Enc(·)$ denotes the encryption function and $c_i$ represents the corresponding ciphertext.

The plaintext values remain local to the originating device and are never transmitted in unencrypted form.

4.3.3. Cluster-Level Aggregation

At the cluster level, ciphertexts are aggregated directly through homomorphic addition:

$$C_{\mathrm{cluster}}={\displaystyle \underset{i=1}{\overset{n}{⨁}}}Enc\left(x_i\right)=Enc\left({\displaystyle \sum _{i=1}^n}{x}_i\right)$$

without revealing any individual measurement.

4.3.4. Multi-Level Aggregation

The framework recursively aggregates encrypted cluster outputs through higher levels of the hierarchy.

For $n_c$ child clusters, the aggregation process can be represented as

$$C_{\mathrm{global}}={\displaystyle \underset{j=1}{\overset{n_c}{⨁}}}{C}_j$$

which results in

$$C_{\mathrm{global}}=Enc\left({\displaystyle \sum _{j=1}^{n_c}}{\displaystyle \sum _{i=1}^{n_j}}{x}_{i,j}\right)$$

This process can be repeated across an arbitrary number of hierarchical levels.

4.3.5. Decryption and Validation

At the root node, the aggregated ciphertext is decrypted by an authorized entity:

$$D\left(C_{\mathrm{global}}\right)={\displaystyle \sum _{j=1}^{n_c}}{D}_j={\displaystyle \sum _{j=1}^{n_c}}{\left\{x_{j,i}\right\}}_{i=1}^{n_j}$$

where $D(·)$ denotes the decryption function.

The decrypted result is subsequently compared with the plaintext ground truth to quantify computational accuracy and precision loss.

4.4. Performance Benchmarking Methodology

The framework automatically records detailed operational metrics during every cryptographic operation.

4.4.1. Computational Metrics

The following latency measurements are collected:

• Encryption time
• Decryption time
• Homomorphic addition time
• Homomorphic multiplication time
• End-to-end aggregation time

The total execution time can be expressed as

$$T_{\mathrm{total}}=T_{\mathrm{enc}}+T_{\mathrm{agg}}+T_{\mathrm{dec}}$$

where $T_{\mathrm{enc}}$, $T_{\mathrm{agg}}$, and $T_{\mathrm{dec}}$ denote the cumulative encryption time, hierarchical aggregation time, and decryption and validation time, respectively.

4.4.2. Resource Utilization Metrics

To evaluate deployment feasibility, the framework records memory consumption and computation time over different operations such as encryption, addition, aggregation, decryption, in processing one batch of data.

These measurements facilitate quantitative analysis of computational efficiency and infrastructure requirements.

4.4.3. Accuracy Metrics

Numerical accuracy is also evaluated using absolute error:

$$E_{\mathrm{abs}}=\left|S_{\mathrm{plain}}-S_{\mathrm{dec}}\right|$$

where $S_{\mathrm{plain}}$ is the plaintext aggregate and $S_{\mathrm{dec}}$ is the decrypted aggregate.

Relative error may additionally be computed as:

$$E_{\mathrm{rel}}={\displaystyle \frac{\left|S_{\mathrm{plain}}-S_{\mathrm{dec}}\right|}{\left|S_{\mathrm{plain}}\right|}}\times 100.$$

4.5. Benchmarking Homomorphic Aggregation Performance

The proposed framework enables systematic benchmarking of encrypted aggregation using the BFV and CKKS homomorphic encryption schemes under a controlled and identical workload at both cluster and global levels. In this context, aggregation refers to the homomorphic combination of ciphertexts corresponding to device-level measurements within a given sampling interval, such that the decrypted result is equivalent to the sum of plaintext values.

At the cluster level, aggregation is performed over ciphertexts generated by a fixed set of five devices within each cluster. Specifically, for a given sampling instant, each device encrypts its local measurement, and the cluster node performs homomorphic addition over the received ciphertexts to produce a single aggregated ciphertext representing the total contribution of that cluster. This process is repeated independently across three clusters, ensuring uniform workload distribution.

At the global level, a higher-tier aggregator collects the three cluster-level ciphertexts corresponding to the same sampling interval. Once all cluster nodes have produced their aggregated outputs, the global node performs a final homomorphic aggregation step over these ciphertexts to compute a single ciphertext representing the system-wide total across all fifteen devices.

This hierarchical evaluation setting comprising five devices per cluster, three clusters, and a single global aggregation layer, ensures a consistent and reproducible workload for comparing the performance, accuracy, and scalability of BFV and CKKS schemes under identical operational conditions.

4.6. Comparative Evaluation of CKKS and BFV

A key capability of the framework is the direct comparison of multiple homomorphic encryption schemes under identical workloads.

4.6.1. CKKS Scheme

CKKS is an approximate homomorphic encryption scheme designed for real-valued arithmetic and vectorized computations.

Given a vector

$$\mathbf{x}=[x_1,x_2,\dots ,x_n],$$

CKKS supports approximate arithmetic over encrypted data, enabling efficient homomorphic computations on real- or complex-valued vectors while preserving computational efficiency.

Its primary advantages include:

• Native support for floating-point values
• Efficient vectorized processing
• Reduced computational overhead
• Suitability for machine learning and data analytics

However, CKKS introduces approximation errors that may accumulate after multiple homomorphic operations.

4.6.2. BFV Scheme

BFV is an exact homomorphic encryption scheme operating over integer arithmetic.

Floating-point measurements must first be transformed into integers using a scaling factor $\alpha$:

In BFV, real-valued inputs are first converted into integers using a scaling factor $\alpha$. For each element $x_i$, the encoded integer representation is given by

$$x_i^{\prime }=\lfloor \alpha x_i\rfloor .$$

Homomorphic computation is then performed on the encrypted integer values,

$$C_i=Enc\left(x_i^{\prime }\right).$$

After decryption, the approximate original value is recovered by rescaling,

$$x_i\approx {\displaystyle \frac{x_i^{\prime }}{\alpha }}.$$

The scaling factor $\alpha$ determines the precision of the fixed-point representation, with larger values providing higher numerical accuracy at the cost of increased ciphertext size and computational overhead.

BFV offers several advantages:

• Exact arithmetic in the encoded integer domain
• No scheme-induced approximation before fixed-point decoding
• Strong correctness guarantees
• Suitability for accounting and billing applications

The trade-off is increased computational complexity and larger ciphertext sizes.

4.6.3. CKKS Versus BFV Benchmarking

The framework enables side-by-side comparison of CKKS and BFV using identical datasets, aggregation workloads, and hierarchy configurations.

Performance is evaluated according to: encryption latency, decryption latency, aggregation latency, memory utilization and numerical accuracy.

The comparison allows researchers to quantify the trade-off between computational efficiency and numerical exactness. CKKS is generally expected to provide superior performance for real-valued analytics and machine learning workloads, whereas BFV provides exact arithmetic in the encoded integer domain; its accuracy for real-valued inputs depends on the selected scaling and rounding procedure.

4.7. Experimental Outcomes

The proposed benchmarking framework provides a reproducible and extensible environment for evaluating privacy-preserving hierarchical aggregation systems. By collecting fine-grained performance, resource utilization, communication, and accuracy metrics, the framework enables objective assessment of homomorphic encryption schemes and facilitates the selection of appropriate cryptographic technologies for large-scale distributed cyber-physical infrastructures.

5. Results and Discussion

The proposed hierarchical privacy-preserving aggregation framework was evaluated first using the BFV homomorphic encryption scheme across three hierarchy levels consisting of device, cluster, and global nodes. The objective of the experiments was to quantify the computational overhead, memory requirements, and numerical correctness of encrypted aggregation operations. Performance metrics including encryption time, aggregation time, decryption time, memory consumption, and decryption accuracy were recorded during execution.

The results presented in this section correspond to the benchmark configuration described in Section 4.4. Equivalent experiments will subsequently be conducted using the CKKS scheme to facilitate a comparative evaluation between exact and approximate homomorphic encryption approaches.

5.1. Encryption Performance Analysis

Figure 2 illustrates the average encryption latency observed at different hierarchy levels. The mean node-level encryption time is approximately 7.18 ms.

The node-level results show encryption latency ranging from approximately 6.721 ms to 8.075 ms.

5.2. Aggregation Performance Analysis

Aggregation is the fundamental operation of the proposed framework because encrypted values are recursively combined across the hierarchy in our implementation simulating the aggregation time for each batch of edge node’s data. This includes the encrytion and step by step addition of plain text numeric values as well as the ciphers in each cluster nodes and global nodes.

Figure 3 presents the average aggregation latency at each hierarchy level.

As expected, aggregation overhead increases when moving upward in the hierarchy because higher-level nodes combine a larger number of ciphertexts. The global node exhibited an average end-to-end aggregation latency of approximately 187.916 ms, whereas the cluster level required approximately 54.763 ms.

The detailed node-wise aggregation performance is shown in Figure 4.

There is very little variations observed among custer nodes as expected since each cluster are aggregating five device data connected. The aggregation complexity depends primarily on the number of child ciphertexts processed at each node. The global node is responsible for the entire aggregation tree experienced higher execution times including lower layer’s homomorphic addition operations.

5.3. Decryption Performance Analysis

Decryption was performed for validation purposes to verify the correctness of encrypted aggregation.

Figure 5 presents the average decryption latency across hierarchy levels.

The results indicate that decryption overhead remained relatively stable across hierarchy levels: approximately 2.447 ms at the device level, 2.549 ms at the cluster level, and 2.633 ms at the global level.

Node-level decryption performance is illustrated in Figure 6.

Minor variations between nodes can be attributed to runtime scheduling effects, memory allocation overhead, and operating-system level resource management.

5.4. Memory Consumption Analysis

Memory utilization is a critical factor for practical deployment of homomorphic encryption in resource-constrained environments.

Figure 7 shows the average memory usage across hierarchy levels.

The results demonstrate that process-level memory consumption remains nearly constant across the hierarchy, ranging from approximately 981.4 MB to 982.3 MB.

5.5. Operation-Level Performance Characteristics

To better understand system behavior, operation-level heatmaps were generated. Figure 8 presents operation performance aggregated by hierarchy level. The heatmap shows that end-to-end aggregation is the dominant latency at the cluster and global levels, while encryption is the principal measured cost at the device level. The node-level analysis highlights potential computational hotspots within the hierarchy and identifies nodes that may benefit from load balancing or parallelization strategies.

5.6. Decryption Accuracy Analysis

One of the most important requirements of privacy-preserving aggregation is preserving computational correctness after homomorphic processing.

Figure 9 presents the decryption accuracy observed across all nodes.

The results demonstrate that the BFV scheme preserved a high degree of arithmetic correctness, achieving an average accuracy of approximately (98.96%). Since the device data consists of floating-point values, a scaling factor was applied prior to conversion to integers for encryption. Consequently, a small quantization error was introduced, limiting the retained precision to approximately two decimal places. Based on the values displayed in Figure 9, the mean absolute error across the four reported nodes is approximately $7.95\times {10}^{-3}$.

The global aggregation node achieved an absolute error of approximately $1.33\times {10}^{-2}$, demonstrating that recursive aggregation remained close to the plaintext result across multiple hierarchy levels.

5.7. Overall Discussion

The experimental results demonstrate that the proposed hierarchical aggregation architecture successfully supports privacy-preserving data aggregation using homomorphic encryption. The framework maintained high computational correctness while enabling recursive aggregation across device, cluster, and global levels.

The primary computational overhead originated from end-to-end hierarchical aggregation, while process-level memory consumption remained nearly constant across the three reported hierarchy levels. Despite these costs, the framework produced accurate aggregate results across the evaluated hierarchy.

The findings suggest that hierarchical aggregation can significantly reduce communication and processing bottlenecks by distributing aggregation workloads among cluster nodes before forwarding encrypted summaries to higher levels.

5.8. Comparison Between BFV and CKKS

To compare the performance of BFV and CKKS, we repeat the same experimental setup using CKKS within the proposed framework, ensuring identical workloads and evaluation conditions. For brevity, we omit the full set of CKKS intermediate results and instead present the key aggregated findings in Table 2.

Across all evaluated metrics, CKKS consistently demonstrates improved performance compared to BFV under the same experimental workload. In terms of computation efficiency, CKKS shows lower encryption latency (6.65 ms vs. 7.77 ms), decryption latency (1.90 ms vs. 2.52 ms), and primitive homomorphic-addition latency (0.22 ms vs. 0.39 ms), indicating lower measured latency across the reported cryptographic operations. This suggests that CKKS is more suitable for scenarios where real-time or near-real-time encrypted computation is required.

From a system resource perspective, CKKS also exhibits reduced memory utilization (975.99 MB compared to 1030.93 MB for BFV), highlighting its improved efficiency in handling computational overhead. This reduction becomes particularly relevant in large-scale or distributed deployments where memory constraints can significantly impact scalability.

In terms of numerical accuracy, BFV maintains a small but non-zero absolute error (0.00321), while CKKS achieves near machine-level precision (5.91e-10) for the evaluated workload. Because BFV is exact over encoded integers, this observed difference primarily reflects the fixed-point encoding and parameter choices used in the experiment. Overall, CKKS provides lower measured latency, memory use, and error for this specific workload.

5.9. Scalability Testing

Scalability testing was conducted to evaluate how the hierarchical homomorphic encryption framework performs as the system size increases in terms of both the number of hierarchy levels and the number of devices per cluster. The benchmark datasets included configurations such as 3 levels with 5, 10, and 15 devices, 5 levels with 10 devices, and 7 levels with 10 devices. Four critical operations were analyzed: encryption, homomorphic addition, aggregation, and decryption.

The objective of this experiment was to determine whether the computational overhead grows linearly, sublinearly, or exponentially as the hierarchical structure becomes deeper and wider.

5.9.1. Encryption Scalability

Figure 10 shows the average encryption time across different system configurations.

The results indicate that encryption time remains relatively stable across most configurations, ranging approximately from 5.6 ms to 7.0 ms. Since encryption occurs independently at each leaf device, the number of hierarchy levels has limited direct impact on encryption latency. The primary contributor to encryption cost is the underlying BFV/CKKS cryptographic operation rather than the network topology.

Across the nine plotted configurations, encryption latency ranged from approximately 5.60 ms to 6.96 ms. The highest value occurred for the 7-level/5-device configuration, not the 7-level/15-device configuration; the plotted points do not show a monotonic increase with either hierarchy depth or device count.

Overall, encryption latency remained within a narrow range in these experiments, although repeated trials and confidence intervals are required before assigning a formal scaling complexity.

5.9.2. Homomorphic Addition Scalability

Figure 11 presents the average execution time for homomorphic ciphertext addition.

The results show that homomorphic addition latency remained between approximately 0.30 ms and 0.61 ms across all tested configurations. Since homomorphic addition is computationally cheaper than multiplication in lattice-based cryptosystems, the observed latency remained significantly lower than encryption and decryption.

The plotted addition times fluctuate rather than increasing monotonically with device count. The highest cluster-level addition latency, approximately 0.61 ms, occurred for the 7-level/5-device configuration.

These results show that primitive ciphertext addition remained below 0.61 ms in the tested cases; however, the plots alone do not establish a linear or sublinear scaling law.

5.9.3. Aggregation Scalability

Figure 12 illustrates the total aggregation time, including recursive ciphertext collection from devices to cluster nodes and from cluster nodes to the global node.

Aggregation exhibited the strongest dependency on hierarchy depth because it involves repeated communication and ciphertext accumulation across multiple levels. Across all plotted cluster- and global-level results, aggregation time ranged from approximately 94 ms to 699 ms.

Cluster-level aggregation ranged from approximately 94 ms to 147 ms, while global aggregation ranged from approximately 291 ms to 699 ms. The maximum global value occurred for the 3-level/10-device configuration, so the current plots do not demonstrate a monotonic increase with hierarchy depth.

The measurements show manageable execution times for the tested configurations, but a scaling claim requires operation-normalized repeated measurements and statistical uncertainty estimates.

5.9.4. Decryption Scalability

Figure 13 presents the decryption latency measured at cluster and global nodes.

Decryption time remained relatively stable across different configurations, varying from approximately 1.96 ms to 3.06 ms. Similar to encryption, decryption complexity primarily depends on the cryptographic scheme parameters rather than hierarchy size. The plotted values do not increase monotonically with configuration size. The maximum decryption latency, approximately 3.06 ms at the global node, occurred for the 7-level/5-device configuration. The limited variation suggests stable decryption latency within the tested range.

5.9.5. Overall Scalability Analysis

Across all experiments, the framework demonstrated strong scalability characteristics:

• Encryption and decryption remained largely stable across configurations.
• Homomorphic addition remained below approximately 0.61 ms, with no monotonic device-count trend in the plotted data.
• End-to-end aggregation showed the largest latency and the greatest variability across configurations.

Overall, the results indicate practical computational overhead for the evaluated configurations. This makes the architecture suitable for applications such as smart grids, IoT networks, federated analytics, and privacy-preserving edge intelligence, where secure aggregation of distributed data is essential.

5.10. Key Takeaways in Relation to the Major Contributions

The combined experimental findings demonstrate how the major contributions identified in Section 1 were achieved:

• Generic hierarchical benchmarking framework (C1): The implemented device-cluster-global workflow realizes a configurable encrypted aggregation topology, while the additional 3, 5, and 7-level configurations demonstrate that the same framework can be exercised under different hierarchy depths and fan-out settings.
• Multi-level performance characterization (C2): Encryption, primitive homomorphic addition, end-to-end aggregation, decryption, memory consumption, and numerical accuracy were measured at device, cluster, and global levels. These measurements show that end-to-end aggregation is the dominant cost, whereas encryption, decryption, and process-level memory remain comparatively stable within the evaluated configurations.
• Quantitative BFV and CKKS comparison (C3): Under the identical workload, CKKS reduced encryption latency from 7.77 ms to 6.65 ms, primitive homomorphic-addition latency from 0.39 ms to 0.22 ms, decryption latency from 2.52 ms to 1.90 ms, and memory utilization from 1030.93 MB to 975.99 MB. For the evaluated encoding and parameter choices, the mean absolute error decreased from $3.21\times {10}^{-3}$ for BFV to $5.91\times {10}^{-10}$ for CKKS.
• Detailed logging and profiling (C4): Node-wise and hierarchy-level measurements, together with the operation-level heatmap and scalability plots, provide fine-grained visibility into cryptographic and aggregation costs. The end-to-end aggregation metric includes recursive ciphertext collection and accumulation, enabling the framework to identify the principal processing and communication-aware bottleneck in the implemented hierarchy.
• Extensible experimental platform (C5) : The common HE abstraction layer, configurable topology, and validation with real Low Carbon London smart-meter data establish a reusable test environment in which additional HE schemes, libraries, parameter sets, and privacy-preserving analytics workloads can be evaluated without redesigning the application workflow.

Overall, the results confirm that the proposed contribution is both a working hierarchical privacy-preserving aggregation system and a reproducible benchmarking platform. Within the evaluated real-valued aggregation workload, CKKS provides the more efficient and accurate backend. At the same time, the framework exposes the operation and hierarchy-specific trade-offs required for future HE deployment studies.

6. Conclusion and Future Work

This paper presented a generic hierarchical benchmarking framework for evaluating homomorphic encryption (HE)-based aggregation in distributed multi-level architectures. The framework supports configurable aggregation topologies, detailed operation-level profiling, and comparative evaluation of multiple HE schemes under identical workloads. Through comprehensive experimentation, the framework enabled systematic characterization of computational overhead, memory consumption, communication requirements, and aggregation accuracy across node-, cluster-, and global-level aggregation stages.

The experimental results demonstrate that both BFV and CKKS are capable of supporting privacy-preserving aggregation; however, CKKS consistently outperformed BFV across all evaluated metrics. Specifically, CKKS reduced average encryption latency from 7.77 ms to 6.65 ms, representing an improvement of approximately 14.4%. Similarly, decryption latency decreased from 2.52 ms to 1.90 ms, yielding a 24.6% reduction. The most significant gain was observed during primitive homomorphic addition, where CKKS achieved an average latency of 0.218 ms compared with 0.391 ms for BFV, corresponding to a 44.3% improvement. Memory utilization was also reduced from approximately 1030.9 MB to 976.0 MB, resulting in a 5.3% reduction in memory requirements.

In addition to computational efficiency, CKKS demonstrated substantially higher numerical accuracy in the evaluated aggregation workload. While BFV achieved a mean absolute error of $3.21\times {10}^{-3}$, CKKS reduced the error to $5.91\times {10}^{-10}$, representing an improvement of more than six orders of magnitude. For the evaluated encoding and parameter choices, these results indicate that CKKS provided both lower computational overhead and lower numerical error for the real-valued aggregation workload.

Beyond the quantitative comparison of BFV and CKKS, the proposed framework contributes a reusable and extensible platform for benchmarking emerging HE schemes under realistic hierarchical aggregation scenarios. The detailed logging and profiling capabilities facilitate identification of performance bottlenecks and support rigorous evaluation of scalability, resource utilization, and communication overhead. Consequently, the framework provides a valuable tool for researchers and practitioners seeking to assess the practical feasibility of privacy-preserving analytics in distributed systems.

Future work will extend the framework to incorporate additional homomorphic encryption schemes, hardware-accelerated implementations, larger-scale deployments, and application-specific workloads in domains such as smart grids, industrial IoT, cyber-physical systems, and federated analytics. The presented results identify CKKS as the more efficient and accurate option within the evaluated configuration, while demonstrating the usefulness of the proposed framework for further privacy-preserving computation studies.