betaFeedback

WorksComputer Science

ML Models Are Not Ciphers: Power Analysis for Weight Extraction Is Harder Than You Think

Abstract

Can power-analysis techniques reveal secret weights of machine-learning models? Multiple recent works demonstrate proof-of-concept attacks that can partially recover such weights. To that end, these works build on techniques from cryptographic engineering, treating the model as a ``cipher'' and its secret weights as keys. We question the basic assumption behind such straightforward adaptations of cryptographic attacks and highlight the challenges arising when applying past techniques to fully recover all layers of deep neural networks. Unlike past works, which extract only a few weights, typically from shallow layers, we investigate the recovery of complete networks. Moreover, we target fully trained and functional models, rather than untrained, randomly initialized networks. To focus on fundamental challenges, we assume an unrealistically strong side-channel adversary that can directly observe the output of the leakage model without any added noise. With this adversary, we show that machine-learning models differ significantly from cryptographic implementations, giving rise to unique challenges that have not been observed in the prior art. We observe two main differences between machine-learning models and ciphers. First, in contrast to the high-diffusion nonlinear integer arithmetic prevalent in cryptographic schemes, machine-learning models tend to use limited-precision floating-point arithmetic and low-diffusion linear operations. We show that these operations introduce difficulties in weight recovery, often requiring an unexpectedly large number of traces, even under ideal channel conditions. Second, we observe that, unlike ciphers, which aim to increase the data entropy, machine-learning models aim to reduce it. This reduces data variability as the algorithm progresses, hampering weight recovery in deep layers of the model. (details can be found in the paper)

Introduction

Deep neural networks (DNNs) have rapidly become the dominant approach for solving complex tasks such as object detection [37], image classification [58], audio processing [49], forecasting [65], and natural language processing [47]. Training these models requires carefully curated datasets, significant computational resources, and substantial human expertise. As a result, trained models, and particularly their learned weights, represent valuable intellectual property. The resources required to develop modern DNNs make their learned parameters a valuable asset, and consequently an appealing target for adversaries seeking to replicate or misuse proprietary models [29, 72]. This motivates a deeper examination of how such parameters may unintentionally leak.

In recent years, the machine-learning ecosystem has been undergoing a shift toward edge deployment [67]. To reduce latency, improve availability, and avoid transmitting sensitive user data to the cloud, many companies deploy trained models directly onto edge devices such as smart cameras, drones, and autonomous vehicles. In this work, we use the term edge GPU to refer to platforms, such as NVIDIA Jetson-class devices, designed for on-device inference in embedded robotics and Internet-of-Things (IoT) systems [45]. This deployment strategy prevents direct access to model weights, because they are not exposed through any accessible interface. However, it still places valuable models on devices under the physical control of potentially untrusted users. This creates an opportunity for physical side-channel attacks that bypass software-level protections.

Side-channel attacks extract information by observing incidental interactions between computation and the environment in which it takes place. A common example is Correlation Power Analysis (CPA), which correlates observed power consumption with hypothesized leakage models to recover secret values from computation [3]. In the past, side-channel attacks such as CPA mostly targeted cryptographic primitives [32, 3, 36]. However, more recently, multiple works have used CPA to extract weights from DNN implementations, targeting partial sums or the results of individual multiplications stored in registers. For example, CSI-NN [1] shows how to recover the hidden architecture and weights of multilayer perceptrons [17] and convolutional neural networks (CNNs) [33]. Subsequent works target FPGAs [69, 38, 10, 70] and GPUs [19, 23] and use CPA-based techniques to extract model information such as architecture and weights. However, these works generally show the feasibility of CPA only on toy examples or, at most, on the first two layers of larger DNNs, and ignore error propagation. To the best of our knowledge, no prior attack has demonstrated parameter extraction of all the layers of a trained model, with realistic depth, parameter distributions, and architectural complexity, from edge devices.

In this work, we investigate the challenges of using side-channel attacks for such a full recovery of a DNN model. To facilitate the analysis, we focus only on intrinsic challenges that relate to the nature of leakage from DNN models, ignoring the challenges of physically measuring the leakage. To eliminate the effects of measurement limitations, such as interference, alignment, and device-specific behavior, we develop a simulation-based framework. Our framework uses the common Hamming weight (HW) and Hamming distance (HD) leakage models [3] and allows us to incorporate synthetic noise in the simulated measurements. Using this approach, we can systematically explore when, how, and to what extent correlation-based side-channel attacks can recover parameters from our target models.

Our main finding is that extraction of weights from DNNs presents new challenges that do not manifest in cryptographic attacks. We find that, in our setting, full key recovery of AES requires fewer than ten noise-free traces, whereas attacks on even simple DNNs may require more than 150,000 traces, often significantly more (Section 5.1). We analyze the causes of this stark difference and identify two fundamental differences between DNN models and cryptographic functions that contribute to it. The first difference is that, unlike cryptography, which aims to hide information and increase entropy, DNNs aim to extract information, i.e., reduce entropy. Consequently, as the computation progresses through the DNN model, the variability of the data tends to decrease [48]. However, CPA requires high data variability to distinguish between weight candidates. Hence, the decreased entropy hampers CPA attacks. We also find that we can increase the variability of the data in deeper layers by selecting data samples from the population that the model is designed to process, rather than selecting them uniformly at random, as is common in prior work [19] (see § 4).

The second difference we identify is the common use of floating-point numbers in DNN models. Floating-point computation behaves differently from the integer- or bit-vector-based computation typically used in cryptography. In particular, the loss of precision in floating-point addition [15], especially when summing long sequences of numbers, causes collisions between weight candidates, rendering it infeasible to identify a single correct weight guess. We further demonstrate that, due to properties of floating-point numbers, the Hamming distance model is inherently better suited than the Hamming weight model for CPA attacks on DNNs.

Balancing the negative outlook so far, we further note that, when targeting DNNs, the adversary’s goals diverge from those of attacks on cryptography. When attacking cryptography, the adversary aims to extract the exact secret. In contrast, when attacking DNN models, obtaining an approximate model is often sufficient. For example, an attacker might only need to reconstruct a model that achieves similar classification accuracy on benign samples, or one that is useful as a surrogate model for generating adversarial examples (§ 6). We find that acquiring such an approximate model requires orders of magnitude fewer traces than completely replicating the original model’s weights.

However, we show that this easier task of approximate model extraction can still be challenging, even in an ideal, noise-free setting. Our findings indicate that the complexity of extraction, measured by the number of traces required, grows exponentially with the depth of the target model. As Figure 1 shows, in our setting, a standard attack on a cryptographic primitive such as AES requires fewer than ten traces. In comparison, a simple CNN model with eight layers can be extracted using 5,000 traces, a VGG-11 [58] model with 11 layers requires 20,000 traces, and for a ResNet-18 [25] model with 21 layers, even 200,000 traces are not sufficient. Furthermore, adding even a small amount of noise to our simulation can increase the required number of traces by two orders of magnitude. When using a realistic signal-to-noise ratio (SNR), our experiments show that even extracting only the first layer of the model requires more than ten million traces.

Figure 1. The number of traces required for the extracted model to achieve baseline accuracy as a function of the number of layers, for different models. While the number of traces grows exponentially with the number of layers, the total number of weights in the model (in parentheses) seems to have little effect. For comparison, we add the AES cipher, modeling a CPA attack on the first-round S-box computation as one layer and 16 weights (one per key byte).

While our work proposes multiple techniques to overcome some of the challenges we encountered during the extraction process, the complexity of a full end-to-end extraction of a model such as ResNet-18, even in the ideal noise-free setting, suggests that we need to develop new approaches to allow for practical attacks on modern models, which are usually much larger.

In summary, we make the following contributions:

  • We present a comprehensive analysis of the inherent challenges in CPA attacks for DNN weight extraction (§ 3).

  • We identify and quantify challenges due to the non-random structure of DNN models (§ 4) and due to the use of floating-point numbers (§ 5), showing that these challenges nearly preclude accurate weight recovery from non-trivial models.

  • We show that, nonetheless, approximate models extracted using a limited number of samples are still functional and can be treated as equivalent to the original models (§ 6). We further connect this result to the constrained error propagation in DNN models (§ 6.4) and describe approximate extraction of the common models VGG-11 and ResNet-18 (§ 7).

  • Finally, we demonstrate that extraction of functional DNNs remains feasible in the presence of a small amount of noise (albeit requiring significantly more traces), but fails with realistic noise levels (§ 8).

Background

Floating-Point Arithmetic

Modern machine-learning systems compute almost entirely in IEEE 754 floating point. Understanding this arithmetic is essential for CPA on neural networks for two reasons: it determines how floating-point values leak during computation, and it shapes the CPA results we observe, including correlations and reconstruction accuracy. Both the leakage mechanism and the interpretation of our findings depend directly on the numerical structure of IEEE 754. A floating-point value is stored using a sign ss, an exponent ee, and a significand (1.f)(1.f), representing numbers of the form

(−1)s⋅2e⋅(1.f).(-1)^{s} \cdot2^{e} \cdot(1.f).

Because the exponent and significand have finite length, floating-point formats can represent only finitely many real numbers [15]. Many familiar decimals, such as 0.1, have no finite binary expansion and must be approximated; for example, in half precision (FP16), the closest representable value to 0.1 is 0.0999755859375.

Since not every real value is representable, IEEE 754 provides a systematic rule for choosing which representable number should replace the exact mathematical result. The standard uses a discrete grid of representable numbers, whose spacing grows with the exponent. The distance between two adjacent representable numbers at a given scale is called one ULP (unit in the last place). Notice that the ULP size grows as the exponent increases. This follows directly from the floating-point representation: for a fixed significand precision, increasing the exponent increases the spacing between adjacent representable numbers [15]. As a result, larger-magnitude values have wider spacing between representable numbers than smaller-magnitude values. For instance, in FP16 (which has a 10-bit significand) the numbers in [1,2)[1,2) are spaced by 2−102^{-10}, so the next representable value after 1.0 is 1.0009765625. In contrast, the numbers in [8,16)=[23,24)[8,16) = [2^{3},2^{4}) are spaced by 23−102^{3-10}, meaning the next representable value after 8.0 is 8.0078125.

IEEE 754 enforces normalized representation and correct rounding: each basic operation returns the representable value closest to the exact real result. Because adjacent values differ by exactly one ULP, rounding to nearest guarantees a bounded rounding error of at most 0.5 ULP. As the ULP becomes larger for larger exponents, this bound, which is fixed in units of ULP, translates into larger absolute rounding errors for larger-magnitude values, while the relative error remains roughly constant.

This property is important for CPA on neural networks, as it affects how the intermediate computation values we target are represented. When the spacing between representable numbers is large, adding a small term may not be sufficient to move the sum to the next representable value. In such cases, different real-valued sums are mapped to the same floating-point representation. In contrast, for smaller-magnitude sums, the finer spacing allows such small terms to change the represented value. In § 5.2, we explain how this affects CPA attacks.

Floating-Point Addition and Multiplication

When adding floating-point numbers, we first align exponents by right-shifting the significand of the operand with the smaller exponent until both operands share the same exponent. We then add (or subtract) the aligned significands and finally normalize and round—again retaining only the available significand bits while dropping the extra bits. When multiplying two operands, aa and bb, we start by computing the output sign (s=sa⊕sbs = s_a \oplus s_b) and exponent (e=ea+ebe = e_a + e_b with a bias adjustment). We then multiply the significand values (1.fa)⋅(1.fb)(1.f_a) \cdot(1.f_b); the significand product contains more fraction bits than the format can store, so it is normalized and rounded by keeping only the available significand bits and discarding the remaining low-order bits. § 5.2 includes toy examples of floating-point addition and multiplication.

Side-Channel Analysis

Side-Channel Analysis (SCA) exploits unintended physical leakages emitted by electronic devices to infer secret information processed during execution [32, 30]. Such leakage may arise through various channels, including power consumption, electromagnetic (EM) emanations, timing behavior, optical signals, or acoustic effects, and can reveal sensitive information about both data values and executed operations.

SCA was originally introduced in the 1990s in the context of cryptography, where it targeted implementations running on constrained devices such as smart cards, with the primary goal of recovering secret cryptographic keys [32, 30]. Since then, SCA has remained a persistent threat to a wide range of embedded and computing systems.

More recently, side-channel techniques have been extended beyond classical cryptography to complex computing platforms [1, 66, 13, 2]. The majority of prior work adopts the same CPA approach used for cryptographic implementations [3] and assumes that the adversary has (full) knowledge of the underlying software or hardware implementation details [21]. Model weights [1] and model inputs (e.g., input images) [66, 2] can be extracted from CPUs [JMP R23] and FPGAs [RBA+20, YMIH+21, YKO+20, ITQ20] via physical side channels. Recently, architectures have been extracted from GPUs [42, 18], and later the exact weight and bias bytes of neural networks running on GPUs could be extracted via the EM side channel [19, 23].

In addition, prior work has demonstrated that model designs and architectures can be extracted solely from physical side-channel leakage [21]. By analyzing physical side-channel leakages during model inference, an adversary can extract detailed information about the underlying neural network, including layer types [HLL+20, CW21, MXL+22, LZY+22, JMPR23, BBJP19a, RBA+20, GLXF24], activation functions [TSSL20, BBJP19a], hyperparameters [HLL+20, YMY+20, YMIH+21], and the high-level model architecture [XCC+20, WHCB21, SKT+23, HCW+24]. However, past results on weight extraction are much more limited: they recover only a small number of weights, either from shallow layers of small models [19, 1, 69, 38, 10, 70] or by assuming that the previous weights are known [23]. While prior work noted error propagation during extraction [21], it did not analyze its effect on deeper layers, modeling it as Gaussian noise on the weights instead.

DNN Computations

Deep Neural Networks (DNNs) are composed of multiple processing layers that learn representations of data with multiple levels of abstraction [34]. During deployment, DNNs perform inference through a sequence of computations, consisting of linear transformations (e.g., matrix multiplications and convolutions) followed by nonlinear activation functions; in classification models, the final linear layer outputs logits (class scores). Among these operations, matrix multiplication is dominant, accounting for the majority of arithmetic operations and execution time, and therefore largely determines the inference behavior and physical leakage characteristics of the implementation.

In a CNN, a convolutional layer applies a small learnable matrix called a kernel (filter) across local regions of the input, producing feature maps that capture patterns such as edges and textures while using shared weights (fewer parameters than dense connections). A fully connected (FC) layer (also called a dense layer) is different: every neuron is connected to every activation from the previous layer, so its computation is a matrix multiplication plus bias, followed by a nonlinearity. This gives the layer global access to all extracted features; FC layers are commonly used as the final layers for classification (e.g., mapping features to class scores).

Beyond linear transformations, DNNs also incorporate operations such as batch normalization (BatchNorm) [26] and max pooling as key architectural components. BatchNorm is a standard component in modern deep networks that stabilizes training by normalizing intermediate activations and then rescaling and shifting them with learnable parameters. Its main role in practice is to make deep optimization more reliable: models usually tolerate larger learning rates, become less sensitive to initialization, and train faster and more consistently. At inference time, normalization is performed using stored running statistics rather than current mini-batch statistics, giving deterministic behavior. Max pooling is a standard downsampling layer in DNNs (especially CNNs) used to progressively reduce the spatial size of feature maps while retaining salient information. It operates by replacing each local window (e.g., 2×22 \times2) with its maximum value, thereby preserving the strongest activation in that region. As a result, max pooling reduces memory and computational costs in deeper layers and provides limited robustness to small spatial shifts by emphasizing dominant responses rather than exact positions.

Depending on the exact platform, different DNN computations may be carried out sequentially or with varying degrees of parallelism. CPUs and FPGAs often execute them in a more structured, hardware-specific manner (e.g., the dataflow-style architecture of FPGAs [63]). In contrast, GPUs employ massively parallel execution models optimized for throughput.

Leakage Model

Leakage models in SCA describe the leakage of intermediate values in the side-channel traces. The Hamming-weight (HW) leakage model is widely used and assumes that the leakage is proportional to the number of set bits in the intermediate value. The Hamming-distance (HD) leakage model assumes that the leakage is proportional to the number of bit flips between consecutive states (e.g., register bits changing from one clock cycle to the next). Prior work [19] builds the leakage model on the weight-dependent partial sums in DNN computations:

zi+1=wi⋅xi+zi,z0=0,z_{i+1} = w_i \cdot x_i + z_i,\qquad z_0 = 0,

where wiw_i denotes the ii-th weight, xix_i its corresponding input activation, and ziz_i the running partial sum.

To reflect this behavior, we model the leakage at step ii as

Li={HW⁡(zi),(Hamming-weight model),HW⁡(zi−1⊕zi),(Hamming-distance model).L_i = \begin{cases} \operatorname{HW}(z_i), & \text{(Hamming-weight model)},\\ \operatorname{HW}(z_{i-1} \oplus z_i), & \text{(Hamming-distance model)}. \end{cases}

As the two leakage models have been used in previous works [1, 27, 69, 38, 10, 70, 14, 19, 23], we analyze both of them in our experiments.

Black-Box Cryptanalytic Extraction Attacks

Prior cryptanalytic extraction attacks show that ReLU networks can leak their parameters through oracle access [7 MCH+24, 5]. These attacks view model extraction as a cryptanalytic problem and recover weights by exploiting the piecewise-linear structure of ReLU networks, especially critical points where hidden neurons change activation state. However, these polynomial-time attacks rely on high-precision models (typically 64-bit floating-point arithmetic) and target only relatively small or simple contracting and ReLU-based network architectures. Thus, these attacks are not applicable to our larger non-contracting/expanding convolutional models that use 16-bit floating-point computations. More recently, Coqueret et al. [6] extend cryptanalytic extraction to non-fully-connected networks using a divide-and-conquer approach assisted by a physical side-channel oracle. Their EM oracle targets individual ReLU activation states instead of directly extracting weights using CPA.

Threat Model

In general, prior weight-extraction attacks using physical side-channel information assume unfettered physical access to the target. This allows the adversary to collect measurements with high resolution and is a realistic assumption for edge computing devices. Although power consumption can be measured using performance counters to reverse-engineer the architecture of neural networks [GQZ+24], the resolution might not be sufficient to extract weights. Furthermore, weight extraction requires the adversary to know the architecture (e.g., number and types of layers) of the target DNN. Therefore, we assume that the adversary already knows the exact architecture, and our focus is on evaluating the feasibility of weight extraction from deeper networks. This assumption reflects practical scenarios in which model architectures are often publicly known or easily inferred [HLL+20, CW21, MXL+22, HCW+24].

Methodology

Using a simulation-based approach, we investigate the fundamental limits of extracting DNN weights with power-analysis-based side-channel attacks. This approach allows us to uncover the main limitations and challenges of such attacks that are orthogonal to the engineering effort required to mount them (e.g., physical measurements and trace alignment). Our simulation-based approach allows us to efficiently run ablation tests comparing the effectiveness of attacks under various leakage models and noise levels.

For example, we can simulate our attack on “noise-free” traces that contain exactly the information leaked according to the leakage model (e.g., exact Hamming-weight values). Under such idealized perfect-channel conditions, standard CPA attacks on cryptographic primitives might seem trivial. For instance, a simulated noise-free attack on the S-box computation in AES [43] requires fewer than ten traces to recover the full key. However, we show that even in this idealized setting, 150,000 traces (four orders of magnitude more) are not sufficient for bitwise-accurate extraction of all DNN weights.

Figure 2 provides an overview of our simulated attack pipeline. At a high level, after we choose our target model and dataset, our simulated attack runs as follows:

Figure 2. End-to-end pipeline. We use the target model to generate simulated leakage traces from intermediate computation values. We then run a CPA attack on these traces to recover the network weights sequentially, weight-by-weight and layer-by-layer, updating the recovered model as extraction progresses. Finally, we evaluate the recovered model using test-set accuracy and weight-recovery metrics.

  1. We use our ground-truth knowledge of the model weights to generate a simulated trace for each data sample in the chosen dataset.

  2. We use the simulated traces for our CPA attack. Our attack is sequential, extracting the value of each weight in the order in which it is used to compute the model output. Each extracted value is then used to calculate the next partial sum value required to extract the following weight.

  3. Finally, we evaluate the success of the attack based on various metrics, such as bitwise weight accuracy and test-set accuracy.

We note that the sequential nature of the attack means that any error in the recovery of a weight may propagate to the extraction of subsequent weights.

Perfect-Channel Simulation

Our idealized perfect-channel simulation generates traces that include the information leaked as defined by the leakage model, without any added noise. For a specific dataset and target model, we generate the simulated traces in the following way:

  1. For each data sample in a dataset of size nn, we calculate all of the intermediate inputs and partial sum values generated during model inference. That is, for every weight in the model, we generate nn corresponding partial sum values and intermediate inputs.

  2. For each data sample, we generate a simulated trace by iterating over each weight in the model and applying the leakage model function (e.g., HW or HD) to its corresponding partial sum value.

These idealized “noise-free” simulated traces are then used to run a sequential CPA attack.

Following [19], for each data sample, our simulated traces include only a single fixed receptive-field position of each kernel. That is, while each kernel in a convolutional layer is applied multiple times, we only use the values of a single fixed kernel application in our simulated traces. In § 7.2, we show a limitation of this approach and how it can be improved. To simplify our analysis and explanation, we do not consider the extraction of the four floating-point parameters of each channel in each BatchNorm layer.

CPA Weight Recovery

We use our simulated traces in a CPA attack in an attempt to extract the model’s weights. To extract a model weight, our leakage models require us to compute its corresponding partial sum value. For this, we need the values of the intermediate inputs that are multiplied by the weight and of the previous partial sums to which the products are added. This means that our attack must be sequential in two dimensions:

  1. Sequential weight extraction — For each kernel in a layer, we recover weights one at a time, fixing each recovered weight before moving on to the next. We start by extracting the first weight w0w_0. Then, we use the previously extracted weights to calculate the next hypothetical partial sum value, which our leakage model requires to extract the following weight.

  2. Sequential layer extraction — We start by extracting the weights of the first layer, where our hypothetical partial sums are computed using the known inputs from each data sample (and the previously extracted weights). Then, for each data sample, we use the extracted weights to calculate the hypothetical intermediate inputs to the next layer. These hypothetical intermediate inputs are the input values used in the kernels of the next layer and are thus required for the attack.

For each weight we want to extract, we create a list of candidate weights (e.g., all possible float16 values within some range). Then, for each candidate, we use the corresponding inputs and partial sum values with our leakage model to generate a leakage hypothesis (the input values and previous partial sums are computed using the previously extracted weights). We then compute the correlation between each leakage hypothesis and the corresponding point of interest in the simulated traces. We pick the weight candidate whose leakage hypothesis has the highest correlation.

Experimental Setup

In this section, we describe our experimental setup, including the computational environment, numerical precision, target model, datasets, and weight-extraction implementation.

Hardware and Software Environment We generate our simulated traces and run the CPA attack code on a server with a single NVIDIA RTX 3090 GPU (24 GB), an Intel Xeon CPU, and 128 GB of RAM, running Ubuntu 22.04. We implement the attack in Python 3.9 with PyTorch 2.4 (CUDA 12.2). Unless stated otherwise, we enable deterministic execution for reproducibility.

Precision Setting We execute all experiments using float16 (half-precision) arithmetic to reflect common GPU inference practice [19] (e.g., the CHW2 data format in TensorRT [46]).

Target Model The main model we target in our experiments is a pretrained CNN for the CIFAR-10 [31] image-classification task. Simpler tasks such as MNIST [11] require shallow networks that might not exhibit some of the challenges of deep networks, while more advanced tasks such as ImageNet [56] require deep and complex networks, which, if used, would detract from the explanations. Following this logic, we target an open-source pretrained implementation by Holtz Hol20, which, while relatively shallow, still achieves a reasonable CIFAR-10 test accuracy of 84.45%. § 7 describes extending our attacks to VGG-11 [58] and ResNet-18 [25].

The model architecture consists of six convolutional layers arranged into three blocks, each with ReLU activations and BatchNorm, followed by max pooling. Two fully connected layers perform the final classification. Table 2 in Appendix § 11 summarizes the full architecture. We use the weights from the reference implementation of the target model [22] and use its mean and standard deviation values to normalize the inputs.

StageLayers / OpsOutput (C×H×WC \times H \times W)
Input–3×32×323 \times32 \times32
Block 1Conv(3×3×33 \times3 \times3, p=1p=1, 32 kernels) → ReLU → BN32×32×3232 \times32 \times32
Block 2Conv(32×3×332 \times3 \times3, p=1p=1, 32 kernels) → ReLU → BN → Pool(2×22 \times2)32×16×1632 \times16 \times16
Block 3Conv(32×3×332 \times3 \times3, p=1p=1, 64 kernels) → ReLU → BN64×16×1664 \times16 \times16
Block 4Conv(64×3×364 \times3 \times3, p=1p=1, 64 kernels) → ReLU → BN → Pool(2×22 \times2)64×8×864 \times8 \times8
Block 5Conv(64×3×364 \times3 \times3, p=1p=1, 128 kernels) → ReLU → BN128×8×8128 \times8 \times8
Block 6Conv(128×3×3128 \times3 \times3, p=1p=1, 128 kernels) → ReLU → BN → Pool(2×22 \times2)128×4×4128 \times4 \times4
Flatten–2048
FC1Linear(2048→1282048 \to128) → ReLU128
FC2Linear(128→10128 \to10)10

Table 2. CNN architecture. BN = BatchNorm, pp = padding, Pool = max pooling.

Datasets In our attack, we use data samples from the standard CIFAR-10 and CIFAR-5M [NNS21] datasets. CIFAR-5M aims to mirror the distribution of the standard CIFAR-10 but with significantly more samples (5,000,000 vs. 60,000).

Weight-Extraction Implementation We apply the CPA method of § 3.2 to recover weights in a sequential manner, weight-by-weight and layer-by-layer. For each weight, we select the candidate that maximizes the Pearson correlation between the simulated traces and its leakage hypothesis. In our simulation, we sometimes encounter multiple weight candidates with the same maximum correlation value. To keep extraction deterministic and reproducible, we break such ties by choosing the numerically largest candidate. We follow the approach of previous work [1, 19] and restrict the candidate search space to approximately [−5,5][-5, 5] for float16.

Models Are Not Random

Prior CPA attacks on DNNs adapt assumptions from similar attacks on implementations of cryptographic primitives. In particular, attacks on cryptography tend to assume that the keys are random and use randomly selected input vectors for the attack. Adapting these assumptions to DNNs, prior works target untrained models with randomly initialized weights [19] and use random inputs for the attack [19, 1]. In this section, we question the applicability of these assumptions to DNNs. We demonstrate that the behavior of randomly initialized models diverges significantly from that of trained models. Consequently, randomly initialized models should not be used as a representative attack target. Moreover, we show that CPA attacks on DNNs are sensitive to the input distribution and benefit significantly from choosing inputs from the input domain rather than uniformly random inputs.

Model Initialization

The main motivation for CPA attacks on DNNs is to retrieve the weights of trained models. Yet, published attacks tend to target models with randomly chosen weights. To test whether such models are representative of trained models, we analyze CPA attacks on two untrained models using the same architecture as our CNN model but with random weights. Our first model follows the example from BarraCUDA [19], selecting weights uniformly at random from the interval (−5,5)(-5, 5). The second model uses the default PyTorch initialization, which samples weights from a fan-in-scaled uniform distribution [52, 54, 53, 24], with the BatchNorm parameters kept at their defaults [51].

For each model, we generate 10,000 simulated traces using inputs sampled uniformly from the interval (−1,1)(-1, 1), and perform CPA for weight extraction on these traces. We Figure 4: Impact of input distribution and trace count on weight extraction errors.

Figure 4. (a) Layer-wise extraction errors with 10k traces under different input distributions. Natural datasets enable low error rates, while random inputs fail to provide sufficient variability, especially in deeper layers. (b) Probability of incorrect weight extraction across layers in the idealized noise-free setting, as a function of the number of traces used. While increasing the trace count reduces error rates, several deeper layers retain non-zero error probabilities even at 150,000 traces.

measure the probability that weight extraction returns the wrong weight, summarizing the results in Figure 3. We observe that as we progress deeper into the model, extraction errors start appearing, reaching 100% error from layer conv4 or conv5 onward. For comparison, we also repeat the process on the pretrained model of Holtz [22], showing that we can extract weights much further into the model.

Figure 3. Layer-wise extraction errors for different weight initializations (10,000 traces).

Analyzing the reason for these extraction errors, we find that when weights are chosen uniformly, layer outputs tend to diverge, overflowing the maximum value representable in float16 from layer conv4 onward. Conversely, when using the PyTorch initialization, layer outputs tend to converge toward zero. Consequently, in both models, the diversity of layer outputs drops in deeper layers, and because CPA relies on input diversity to distinguish weights, the attack fails.

Input Distribution

Focusing our attention on the pretrained model, we now check whether the attack is sensitive to the input distribution. We repeat the attack using five input sets: (1) Random Inputs, with pixel values sampled uniformly from the interval (−1,1)(-1, 1); (2) CIFAR-5M (low-acc), the subset of CIFAR-5M inputs on which the model achieves a low accuracy of 13% or below; (3) CIFAR-5M, drawn from the full CIFAR-5M dataset; (4) CIFAR-5M (high-acc), the subset of CIFAR-5M inputs on which the model achieves a very high classification accuracy of 99% or above; and (5) CIFAR-10, sampled from the combined pool of CIFAR-10 training and test images.

Figure 4a reports, for each layer, the probability that an extracted weight is not identical to the true stored weight. Uniformly random inputs yield the highest error probabilities in nearly all layers (with the exception of conv2), and the gap widens substantially in deeper layers. Among dataset-derived inputs, extraction accuracy is broadly similar in early layers, but differences emerge from conv5 onward. CIFAR-5M inputs on which the model attains low classification accuracy yield consistently higher error probabilities than the other natural-input distributions. Notably, this subset shows a sharp increase in error probability in the final layer, a behavior we analyze in Appendix § 12.§ 2.

Overall, these results indicate that inputs drawn from natural-image datasets consistently induce more informative leakage than uniformly random inputs, enabling substantially more reliable weight extraction across layers. We hypothesize that such inputs produce more diversity in the outputs of deeper layers, allowing for easier attacks.

Bit-Accurate Model Recovery Challenges

The standard goal of CPA attacks on cryptographic primitives is full and exact key recovery. However, we show that even in our ideal noise-free simulation, exact weight recovery is extremely challenging due to the low-diffusion linear computations and the limited precision of floating-point arithmetic.

Evaluation of Extraction Error Rate

Figure 4b shows the probability of incorrect weight extraction for each layer, using the HD leakage model, as a function of the number of traces used. As expected, increasing the trace count consistently reduces error rates across all layers. However, while a simulated CPA attack on AES requires fewer than 10 traces for error-free recovery, in our case, even with 150,000 traces, we are still unable to achieve 100% accurate extraction of the model’s weights. Unsurprisingly, the first layer is the easiest to recover, with full and accurate recovery even with a relatively low number of traces. However, a more complicated behavior emerges when examining the deeper layers.

While adding more traces reduces the error probability for all layers, the impact of the additional traces differs between layers. For example, while the second and fourth convolutional layers (conv2 and conv4) show a relatively slow drop in the error rate, the third and fifth layers (conv3 and conv5) show a quick drop. Among the two fully connected layers, which are the final two layers of the model, the last layer (fc2) quickly converges to zero error, while the error probability of the penultimate layer (fc1) decreases slowly.

The persistence of errors even under idealized conditions and the difference in the behavior of the various layers suggest the existence of some fundamental challenges in the extraction of some of the weights and a high level of non-uniformity in the input distribution between the layers. In fact, in our noise-free setting, an error can only occur if, at some point in the computation, the correct weight value results in a hypothetical leakage trace that is equal, for all data samples, to the hypothetical leakage trace of some wrong weight candidate. Such a “collision” can arise either from rounding effects due to limited-precision floating-point computation or from the limited information exposed by the leakage model.

Floating-Point Rounding Errors

We now explore the effect of rounding errors in floating-point computation, which are one of the main challenges to accurate extraction. When we compute the hypothetical partial sum values for the different weight candidates, rounding errors cause collisions in a significant percentage of the partial sum values of close weight candidates, e.g., ww and w±ULPw \pm\mathrm{ULP}. Recall that in each kernel, we compute the partial sums as:

zi+1=wi⋅xi+zi,z0=0.z_{i+1} = w_i \cdot x_i + z_i,\qquad z_0 = 0.
Collision rates for multiplication, partial sum, HD, and HW

(a) Collision rates for multiplication, partial sum, HD, and HW between the correct weight ww and the value with the highest collision rate (w±ULPw \pm\mathrm{ULP}), averaged over 10,000 inputs and all model weights.

Distribution of the exponent difference

(b) Distribution of the exponent difference Δ=exp⁡(s)−exp⁡(w⋅x)\Delta= \exp(s) - \exp(w \cdot x) between the previous partial sum ss and the product w⋅xw \cdot x, conditioned on whether a collision is caused by addition rounding errors (omitting collisions caused by multiplication rounding errors).

Figure 6. Analysis of collisions caused by finite-precision floating-point computations.

Floating-point multiplication

(a) Floating-point multiplication — The significands are multiplied, and the products are normalized and rounded. Comparing (ww) and (w+ULPw + \mathrm{ULP}), a larger significand (MSB = 1) requires an additional normalization shift, causing the difference between the two products to fall outside the retained significand bits and resulting in a collision, whereas a smaller significand (MSB = 0) keeps the difference within the retained significand bits.

(b) Floating-point addition — The exponents are aligned by right-shifting the significand of the smaller operand, with larger exponent gaps requiring larger shifts. The aligned significands are then added, and the result is normalized and rounded. Comparing (ww) and (w+ULPw + \mathrm{ULP}), a small exponent gap leaves their difference within the retained significand bits, whereas a large gap shifts it into the discarded low-order bits, causing a collision.

Figure 7. Floating-point multiplication and addition operations.

The rounding errors may result from either part of the computation, i.e., from the multiplication of the weights and inputs, or from the addition of the previous partial sum.

Floating-Point Multiplication Rounding Errors

Rounding errors in the multiplication can cause the values of wi⋅xiw_i \cdot x_i and (wi±ULP)⋅xi(w_i \pm\mathrm{ULP}) \cdot x_i to collide. Figure 6a shows the collision rate for the multiplication values before the addition of the previous sum. While, on average across all weights, we get a collision for ∼25%\sim25\% of the input values, there is a large variance between different weights. We define the collision rate as the fraction of traces for which the correct weight and an adjacent candidate (wi±ULPw_i \pm\mathrm{ULP}) yield identical values; the weight index is its position in the kernel.

It seems that there is a large variance in the collision rate (both low and high collision rates) for weights of different indices, especially at higher indices. This is because high indices occur only in the first connected layer, which are the last layers of the model. In these layers, the input distribution has low entropy due to a small number of unique input values, which affects the probability of collision.

However, the input distribution only explains part of the variance. Figure 5b shows the probability of collision in the multiplication as a function of the weight’s significand value, where the collision probability increases for higher significand values. Figure 7a illustrates a simplified toy example (with a 3-bit significand) that can provide intuition for this effect of the significand value. In the first case, where the most significant bit (MSB) of the significand is 0, we do not get a collision between the multiplication results for weight values ww and w+ULPw + \mathrm{ULP}, even after the rounding effect. However, when the MSB value is 1, the multiplication values collide. Intuitively, when the significand value is bigger, we need to discard more low-order bits (while increasing the value of the exponent), which are more affected by the small ULP difference between the weight candidates. Thus, higher significand values increase the probability of collision. Note that, for brevity in our simplified examples, bits are dropped when, in practice, the value is rounded.

Figure 5. (a) Absolute partial sums at different indices in fc1, over all kernels and 10,000 inputs. (b) Multiplication collision probability as a function of the weight significand value. Collision behavior during floating-point accumulation and multiplication.

Floating-Point Addition Rounding Errors

Even in cases where the multiplication values wi⋅xiw_i \cdot x_i and (wi±ULP)⋅xi(w_i \pm\mathrm{ULP}) \cdot x_i do not collide, the difference between the two values is small. Thus, rounding errors that occur when we add the previous sum might still result in a collision. Figure 6a shows the average collision rate after the addition of the previous partial sum value.

The average partial-sum collision rate is heavily dependent on the weight index in the kernel. For the weight at index 0, the previous partial sum is zero, so we do not get any rounding errors in the addition. Thus, all partial sum value collisions we see are due to collisions in the multiplication. For index 1, we already see a collision rate of ≈50%\approx50\%, about half of which is due to rounding errors in the addition. The collision rate continues to increase with the weight index, approaching 100% at later indices.

Note that even values that do not collide may still result in identical values of HW or HD. However, the HD leakage model has a lower collision probability, and, as we will see, this results in more efficient extraction compared to HW.

The increase in the collision rate for higher indices may be explained by the increase in magnitude of the partial sum values. Figure 5a shows that the magnitude of the partial sums increases for higher indices, as more and more multiplication values are added. This magnitude increase is similar to what we would expect from a random walk, although the multiplication values are not uniformly distributed.

When the magnitude of the partial sum grows, so does the value of the exponent in its floating-point representation. As shown in Figure 6b, collisions are more likely to occur when the exponent value of the partial sum ss is larger than the exponent value of the product w⋅xw \cdot x. Notably, when the exponent difference is larger than 10 (the number of significant bits), the value of w⋅xw \cdot x is below the ULP value of ss and does not affect its value, which always results in a collision. Figure 7b illustrates the effect of the exponent gap on the addition using a 3-bit significand toy example. It shows why an increase in the exponent gap results in discarding more low-order bits, which leads to a collision.

Our leakage model exposes only partial information about the partial sum values we target. While this is also the case for standard attacks against cryptographic primitives, the combination of this partial information and low-diffusion linear floating-point computations raises novel challenges for weight extraction that significantly weaken the discriminative power of correlation-based attacks.

Sign and Exponent Ambiguity

Further challenges posed by our leakage model are the difficulty of determining the exponent value of the weights at index 0 and the correct sign of the weights. These phenomena are explained in Appendix § 12.

Approximate Model Extraction

In this section, we shift the focus to the case where the adversary’s aim is not to recover the exact weights of the model, but rather to recover an approximation of the model. We now explore two potential aims an attacker might have: achieving equivalent benign performance and improving adversarial attacks.

Benign Performance

Training models is a costly operation that typically requires a significant investment of resources. To reduce this cost, an attacker may try to steal the weights of an already-trained model. Building on past results showing that models may be insensitive to some weight changes [59], we now investigate the option of using CPA attacks to recover an approximate model that performs similarly to the attacked model.

We perform a CPA attack in the noise-free scenario, using samples from the CIFAR-5M dataset, varying the number of samples from 2,000 to 20,000. We then test the accuracy of the extracted models on the CIFAR-10 test set.

Figure 8 shows the classification accuracy for models extracted using the HD and HW leakage models. We observe that, using only 5,000 samples, extraction with the HD leakage model achieves an accuracy similar to that of the attacked model (84.45%). However, the HW leakage model achieves worse results, requiring 20,000 samples to achieve a similar accuracy. Thus, with both leakage models, an attacker requires significantly fewer input samples to acquire an approximate model than to extract an exact replica of the model.

Figure 8. Extracted model accuracy on the CIFAR-10 test set versus trace count, showing that ≈\approx 5,000 traces are sufficient to reach baseline accuracy. Beyond this point, additional traces yield no further improvement.

Sign Inversions in the Final Layer

Figure 8 shows a significant accuracy drop for 6,000 and 7,000 input samples. We find that the cause of this drop is a sign inversion. As described in Appendix § 12.§ 2, under certain circumstances, CPA cannot distinguish between the correct weights and their inverse in the final layer’s kernels.

The last layer consists of ten independent kernels, each producing the logit for one of the classes. Hence, if the weight signs of one of these kernels are inverted, the corresponding class is consistently misclassified. Fortunately, we can easily detect and correct such errors using a small number of labeled samples for each class. Specifically, if a class exhibits consistently poor performance, we flip the weight signs in the corresponding kernel and re-evaluate the model against the CIFAR-10 dataset. As Figure 8 shows, fixing the sign improves the accuracy of the extracted model.

Performance for Adversarial Attacks

Appendix § 13 shows that approximately extracted models can be exploited to generate adversarial examples, where small perturbations in samples cause misclassifications.

Error Propagation

In contrast to cryptographic primitives, extracted models can function well even when they contain errors. To understand why, we investigate how errors propagate through the model. We distinguish between data errors, which affect data as it flows through incorrect models, and weight errors, which can propagate between model layers during the CPA attack. We show that the limited precision of floating-point operations and the model’s structure contribute to error suppression.

Error Propagation in Data

When an incorrect weight operates on a data value, the computation result may be wrong. However, operations downstream may correct such errors. For example, if both the correct and the erroneous values are negative, a ReLU operation will remove the error. Similarly, when the exponents of the two addends differ, rounding of the addition result may remove errors in the least significant bits of the significand. We now explore how these effects contribute to reducing error propagation in data as it flows through the model.

For each approximate model, Figure 9a shows the probability of data error at each of the components of the model. We observe that, irrespective of the approximate model, components of the same type tend to behave similarly. Specifically, convolutional layers and max pooling increase error probabilities, whereas ReLU and BatchNorm decrease them. The main difference between components that increase errors and those that suppress them is their structure. When each output of the component depends on a single input, limited precision and the ReLU operation successfully eliminate errors (e.g., by correctly mapping erroneous negative input to zero). Conversely, when an output depends on multiple inputs, errors tend to increase.

Impact of extraction errors and finite-precision collisions on intermediate computations

Figure 9. (a) Input-error probability at each model component for different numbers of traces. (b) Collision rate of partial sums under a +ϵ+\epsilon extraction error versus kernel offset. Impact of extraction errors and finite-precision collisions on intermediate computations.

Error Propagation in Weights

Errors in weights can also propagate between weights during the extraction process. For example, an error in a weight used in a partial sum will affect subsequent partial sums and can therefore introduce errors in subsequent weights. We now investigate how small weight errors propagate to subsequent partial sums in such a case. Specifically, for a single kernel (a 64×3×364 \times3 \times3 kernel in conv4), we introduce a small error in one of the weights, adding ϵ=1\epsilon= 1 ULP to the weight. We then check for collisions between subsequent partial sums in the same kernel. That is, we execute the original and the modified kernel on the same input, and mark a collision at a subsequent offset if the partial sums at that offset in the two kernels are identical.

(a) Bitwise accuracy of noise-free VGG-11 extraction using fixed vs. adaptive receptive fields (RFs) with 40,000 traces and the HD leakage model.

(b) Layer-wise bitwise accuracy of VGG-11 extraction (using adaptive RF) for different numbers of traces.

Figure 10. Bitwise accuracy of VGG-11 extraction under different receptive-field strategies and trace counts.

Figure 9b shows the collision rate as a function of the offset for several positions of the erroneous weight. We observe that errors tend to disappear as the offset grows, with the collision rate exceeding 80% within only a few subsequent sums. Consequently, errors in early weights have a limited effect on subsequent sums. We further observe that when the error occurs in a later weight, collisions are even more frequent. We suspect that the reason is that, as the computation progresses, the magnitude of the partial sum grows, increasing the likelihood that rounding removes errors.

This limitation on error propagation also implies that backtracking strategies are unlikely to be effective for correcting weight errors. Such strategies tend to work when early errors cause subsequent errors, which tends not to happen in our case.

Extension to Larger Architectures

To understand the effect of the depth and size of the model on the difficulty of extraction, we apply our noise-free attack to the larger, and more commonly used, model architectures of VGG-11 [58] and ResNet-18 [25]. Table 1 compares the different models. Both VGG-11 and ResNet-18 are substantially more complex (and more accurate), with more than 15×15 \times as many weights and 11 and 21 layers to extract, respectively, compared to only 8 for our CNN. Moreover, the kernels these models use are four times wider than those of our CNN. These larger architectures raise further challenges for full end-to-end extraction.

ModelAccuracyConv/FC layersWeightsMax kernel width
CNN84.45%8∼550K1152
VGG-1192.78%11∼9.7M4608
ResNet-1892.59%21∼11M4608

Table 1. Comparison of model architectures

Sign Ambiguity

Appendix § 12.§ 2 describes the challenge of sign inversion when all inputs are non-negative. In our CNN model, this occurs only for the final layer (see § 6.2). However, similar to the setting of Joud et al. [27], both VGG-11 and ResNet-18 apply BatchNorm layers before the ReLU layers, and thus all the inputs to the deeper layers are non-negative.

To address this, our implementation performs a per-kernel sign correction based on the next-layer extraction. The core idea is that if a kernel in layer ii is sign-flipped, it will corrupt the values of the corresponding input channel in layer i+1i+1, which results in a much lower CPA correlation for downstream weights that depend on this channel, compared to the correlation when using the correct sign.

Adaptive Receptive Field

As models get larger (i.e., have more layers), the variability of the data in the intermediate inputs to the deeper layers tends to reduce [48]. When attempting to extract larger models, such as VGG-11 and ResNet-18, we encounter cases where, even after increasing the number of traces significantly, the number of unique inputs for some weights in the deeper layers remains too small for our CPA to identify the correct weight value.

To overcome this challenge, we rely on weight reuse across multiple invocations of the same filter. We note that the attacker can observe many activations involving the same weight, each corresponding to a different receptive field (RF). For the same weight, some receptive fields might have a very small number of unique input values (usually due to a large number of zero inputs), while others might display a much larger diversity of values. In prior work, which targeted randomly initialized models [19], the choice of the receptive field did not have a significant effect on the results. However, we show that optimizing the choice of the receptive field can significantly improve the extraction of trained models.

To optimize the extraction, for each weight we recover, we choose the receptive field that is likely to give us the best separation between the correct weight value and the other guesses. Optimally ranking the receptive fields requires a complicated function that depends on the input values, the intermediate sums, and the correct weight value, which is unknown. We approximate this function by ranking the receptive fields based on the input values alone. During extraction, we use the partially reconstructed model to calculate all of the inputs to the current layer. For each convolutional weight, we choose the receptive field with the largest number of distinct input values that correspond to the target weight across all traces.

Figure 10a shows the advantage of the adaptive RF approach. Even when we increase the number of traces by almost an order of magnitude compared to the CNN case (from 5,000 to 40,000) and use our sign-correction technique, extraction of the VGG-11 model still fails with the fixed RF approach. However, when using the adaptive RF approach, we can extract an approximate model that reaches the baseline accuracy of 92.78%.

We note that extraction succeeds even though we achieve low bitwise accuracy in the penultimate fc2 layer. The drop occurs because, unlike convolutional layers, in a fully connected layer each weight is associated with just a single input value. If that input value is always zero, the weight never affects the running sum and cannot be recovered from the leakage, thus reducing the bitwise accuracy. However, as these weights are functionally inactive, they do not affect inference.

Figure 10b shows the effect of the depth of the layer on the difficulty of extraction, measured by the number of traces required for extraction. The number of required traces grows exponentially with the depth of the layer. While 500 traces are enough to approximately extract the second layer, we need 1,000 traces for the third layer, 2,000 for the fourth layer, 5,000 for the fifth, and so on.

Exploiting Partial Extraction

Appendix § 14 describes the attack targeting the ResNet-18 architecture, which has 21 layers compared to VGG-11’s 11. Even when using 200,000 traces (an order of magnitude more than the 20,000 required for VGG-11 extraction), we were not able to fully extract the model’s weights. Furthermore, increasing the number of traces raises the computational cost of the extraction, which already exceeds 5,000 US dollars for the ResNet-18 attack using 200,000 traces.

As full weight recovery becomes increasingly costly for larger models, we investigate whether partial extraction of the lower layers can be exploited. As Figure 10b shows, for a given trace budget, we can recover the first layers with high bitwise accuracy, until we reach a layer where extraction fails. We can identify this layer, as the gap between the correlation achieved by the best weight guess and that of the other guesses drops significantly. Our experiments show that this partial information can be exploited to reduce the cost of training an equivalent model and improve the transferability of adversarial examples compared to training a surrogate model from scratch. The main idea is that the recovered layers can be used as a basis for fine-tuning the full model. The recovered layers are retained, and the remaining layers are reinitialized and fine-tuned.

Figure 11a shows the amount of training data required to reach within 1.1 percentage points of the target model’s accuracy. Focusing on the HD leakage model, we fine-tune using CIFAR-10 with a maximum budget of 50,000 labeled images, maintaining class balance across the different training-set sizes. Across CNN, VGG-11, and ResNet-18, having more successfully extracted layers substantially reduces the required training data.

Figure 11. (a) Training data required to reach the target model’s accuracy (±1.1 percentage points). (b) Attack success rate against the target model. Utility of partial extraction. Extracting more layers reduces the required training data while increasing the transferability of adversarial examples.

As in Appendix § 13, we further evaluate whether this advantage extends to adversarial transferability. Using the CIFAR-10 fine-tuned models that reach within 1.1 percentage points of the target model’s accuracy, we generate adversarial examples and evaluate their success against the original target model. We use an L∞L_{\infty} PGD attack [41] with ϵ=5/255\epsilon= 5/255, α=2/255\alpha= 2/255, 75 iterations, and a random start. For each configuration, we report the median attack success rate (ASR) over three independently trained models. As shown in Figure 11b, having more successfully extracted layers results in higher transferability, which decreases toward that of a standard surrogate as more layers are fine-tuned.

Extraction with Noise

Having demonstrated the challenges in noise-free attacks, we now investigate the case of noisy channels. Using our CNN model as the target, we generate synthetic traces under the HW and HD leakage models and add Gaussian noise at varying levels (i.e., values sampled from a zero-mean Gaussian distribution with varying standard deviation σ\sigma). We perform CPA on the simulated traces to recover approximate models and test their accuracy on the CIFAR-10 test set.

(a) Extracted model accuracy across noise levels for different trace counts and leakage models, using fixed RF.

(b) Extracted model accuracy across noise levels for different trace counts and RF strategies, using HD leakage.

Figure 12. Extracted model accuracy across noise levels

Figure 12a presents the results using the fixed RF approach. While model extraction remains feasible for low noise levels, it requires around two orders of magnitude more traces than in the noise-free setting. Moreover, as the level of noise increases, the number of traces required to extract a functional model increases exponentially. For example, at σ=4\sigma= 4, ≈200,000\approx200{,}000 traces are sufficient; at σ=8\sigma= 8, ≈400,000\approx400{,}000 traces are required; and at σ=16\sigma= 16, even ≈800,000\approx800{,}000 traces are not enough. We further observe that, as in the noise-free scenario, the HD model consistently outperforms the HW model.

Figure 12b shows that using adaptive RF improves extraction compared to using fixed RF under added noise.

Extraction with Realistic Signal-to-Noise Ratio

To relate our synthetic Gaussian noise levels to prior physical measurements, we used the experimental setting of BarraCUDA [19] as a calibration target to recover the σ\sigma value that approximates the noise level in their physical measurements. As there is no direct approach to recover the SNR or noise level from their artifacts, we used the following method to estimate a suitable σ\sigma value for our simulation. We reproduced their setting in our simulation. We targeted a randomly initialized EfficientNet [61] model with weights sampled from [−5,5][-5, 5], random inputs from [−2,2][-2, 2], and 12.24 million traces. In contrast to our usual methodology, we followed their approach and suppressed error propagation in the weight extraction. That is, when extracting each weight, we used the ground-truth previous inputs and weights rather than the previously extracted values. Under this favorable oracle setting, we tested a range of Gaussian noise values and found that with σ=850\sigma= 850, the attack achieved 85.76% bitwise accuracy over the 864 weights of the first layer and 76.39% over the 288 weights of the second layer, which is consistent with their results.2

We further evaluated extraction on a pretrained (instead of randomly initialized) EfficientNet-B0 model with in-distribution inputs, taking error propagation into account. Figure 13 shows the results. For the estimated noise value σ=850\sigma= 850, even when using 12.24 million traces, the bitwise accuracy of first-layer recovery drops to 33.9%. Although accuracy increases at lower σ\sigma values, even for noise levels significantly lower than the one estimated from BarraCUDA, full end-to-end extraction will fail. Indeed, for σ=850\sigma= 850, we only get a negligible bitwise accuracy of 1.74% in the second layer. Another experiment targeting our CNN model achieves a similar bitwise accuracy of 38.3% in the first layer.

Figure 13. Bitwise recovery accuracy as a function of σ\sigma for the 864 weights in the first convolutional layer of a pretrained EfficientNet-B0, using 12.24 million in-distribution traces and adaptive RF.

Discussion and Future Work

In this work, we highlight the main differences between CPA attacks on cryptographic primitives and on machine-learning models. We explore the challenges that arise from the use of floating-point arithmetic and low-diffusion linear operations. While we propose various strategies for addressing these challenges and show that the much easier task of approximate extraction is usually sufficient for most attack goals, our findings indicate that full-model extraction under realistic conditions may be extremely challenging.

While our noise-free attack on our small CNN model is very efficient, targeting more common models such as VGG-11 and ResNet-18 is already costly, as the required number of traces seems to grow exponentially with the number of layers. Moreover, modern Transformer-based language models, such as GPT-3 [4] and PaLM [CND+23], are significantly larger and deeper than the models targeted in this work. For example, GPT-3 175B has 96 Transformer layers, and PaLM 540B has 118 layers, compared with ResNet-18, which was introduced more than 10 years ago and contains only 21 layers. Our current extraction techniques are unlikely to scale to such large modern models. In addition, our experiments show that adding even a small amount of noise to our traces can increase the required number of traces by two orders of magnitude, and when adding realistic noise based on previous work, our attack already fails at the first layer.

Beyond the challenges we highlight, real-world attacks also need to overcome the engineering problems associated with capturing a large number of traces and performing analysis on them. Thus, we believe that for practical full-model recovery, incrementally improving the measurement setup to obtain a higher SNR and increasing the number of traces are unlikely to suffice; novel attack techniques are required. Furthermore, future work developing such new techniques should follow our approach and evaluate full-model extraction, including the deeper layers, while taking error propagation into account. It is possible that models that use integer rather than floating-point arithmetic present fewer challenges for attacks. As mainstream models, such as those mentioned above, tend to use FP16, we leave this investigation to future work.

Acknowledgments

This work has been supported in part by a grant from the Blavatnik Interdisciplinary Cyber Research Center (ICRC); by grant No. 2023641 and grant No. 2024032 from the United States-Israel Binational Science Foundation (BSF); by grant No. 1807/23 from the Israel Science Foundation; by an Intel Rising Star Faculty Award; by Len Blavatnik and the Blavatnik Family foundation; by a Maof prize for outstanding young scientists; by the Stellar Development Foundation; by the Ministry of Innovation, Science & Technology, Israel (grant number 0603870071); by a grant from the Tel Aviv University Center for AI and Data Science (TAD); by the Australian Research Council (Discovery Project number DP210102670); by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Germany’s Excellence Strategy - EXC 2092 CASA - 390781972; and by the Deutsche Forschungsgemeinschaft (DFG) project number 560392681; by the Dutch Research Council (NWO) through the following projects: PROACT (NWA.1215.18.014), TTW PREDATOR 19782 and the CiCS project of the research programme Gravitation (024.006.037).

CNN Model Architecture

Table 2 summarizes the full details of our CNN architecture, based on the reference implementation of the model [22].

Sign and Exponent Ambiguity

Exponent Ambiguity at Index 0

When comparing two weight candidates that share the same significand but differ in the exponent (e.g., m⋅2em \cdot2^{e} vs. m⋅2e+1m \cdot2^{e+1}), the results of their multiplication with any input value also differ only in the exponent. The addition of the previous partial sum increases the diffusion of the difference and usually results in additional differences in the significand values after the addition.

However, for weights at index 0, the result depends only on the product x0w0x_0w_0, as the previous partial sum is 0 by definition. While the two resulting floating-point values are clearly distinct (different exponent), after we apply the HW leakage model (or HD, which is identical to HW for index 0), we get an interesting effect. In many cases, the entropy of the difference of the HW values is very low. Table 3 shows, for different layers, the probability of getting a specific difference between the HW of the multiplication results when using the correct weight at index 0 and the candidate with the highest correlation that differs only in the exponent. In at least 98% of the cases, the HW difference is either 0 or 1.

Layerconv1conv4conv6fc1
Δ\DeltaHW = 00.210.370.180.07
Δ\DeltaHW = 10.780.610.810.92
other0.010.020.010.01

Table 3. Distribution of the difference in the HW of the multiplication results at index 0 between the correct weight and the highest-correlation candidate differing only in the exponent.

In our noise-free setting, as the difference in HW between the two cases is not constant across all inputs, our CPA attack can still extract the correct weight. However, in a more realistic setting where the traces are noisy, extraction can become extremely challenging, as the CPA attack loses most of its discriminative power.

Sign Inversion for Non-negative Inputs

Another challenge posed by our leakage model is distinguishing between the correct weight ww and its inverse −w-w when all inputs are non-negative.

Recall that for a floating-point value, changing it from positive to negative means changing the sign bit to 1, thus increasing the HW of the value by 1. Thus, if all the inputs are positive, inverting the sign of the first weight will cause the HW of all non-zero multiplication results to either increase by 1 (positive to negative) or decrease by 1 (negative to positive). If we invert the signs of all weights in the kernel, this fixed difference in HW values due to sign inversions will occur for all partial-sum computations in the kernel. For the HD leakage model, distinguishing the sign is even harder, as the sign-bit difference cancels when both the previous and updated partial sums change sign.

In this case, for the HW model, the hypothetical leakage traces for ww and −w-w will be the same up to a constant offset of 1. As the correlation calculation subtracts the mean, it ignores such a fixed offset, making the two traces indistinguishable. However, when some of the input values are 0, sign inversion does not have an effect, and we get the same HW value before and after sign inversion. As a result, the difference between the two hypothetical leakage traces is not fully constant, which makes it theoretically possible to distinguish between the two cases. In practice, however, adding such zero inputs has a very small effect on the correlation between the two hypothetical leakage traces. Figure 14 shows the effect of padding both traces with the same HW values on the Pearson correlation. Without any padding, the normalized traces are identical and the correlation is 1. By adding zero inputs, we can slightly reduce the correlation, but it remains extremely high (above 0.998). While sufficient for noise-free simulation, this difference is too weak to create a reliable separation signal for CPA with any noise.

Figure 14. Correlation between the normalized HW traces generated by ww and −w-w with added zero padding. Even after injecting thousands of zeros, the traces remain almost perfectly correlated (>0.998> 0.998).

A similar effect appears in the HD model. When we compare the correct candidate with the sign-inverted candidate, both the previous partial sum and the updated partial sum change sign. Since the sign bit changes on both sides of the transition, its effect is canceled in the HD value. Therefore, as in the HW case, the two candidates remain very difficult to separate.

While all outputs of the ReLU activation function are non-negative, this issue is largely avoided in most layers of the CNN model, where BatchNorm yields both positive and negative activations. However, it does occur in the final layer of the CNN model, where BatchNorm is not applied to the inputs, and in the VGG-11 and ResNet-18 models, where BatchNorm is applied before the ReLU (this case is addressed in § 7.1).

Performance for Adversarial Attacks

Instead of stealing a model for its benign functionality, the attacker may want to replicate it for the purpose of generating adversarial examples, where small perturbations to inputs cause misclassifications. While such attacks are possible with a surrogate model [SZS+14, LCLS17], white-box attacks, where the attacker has an exact copy of the model, are more powerful, allowing higher success rates with smaller perturbations. In this section, we examine whether approximate models recovered using CPA give the attacker an advantage over surrogate models.

For the evaluation, we consider three attack scenarios. The first is a white-box scenario, where we employ an exact replica of the target model. The second is a traditional transferability attack, where we train a surrogate model on the CIFAR-10 dataset and use it for the attack. For the third scenario, we use the same approximate models extracted in § 6.1, after the sign correction described in § 6.2. To generate the adversarial examples, we use an L∞L_{\infty} PGD attack [41] with ϵ=5/255\epsilon= 5/255, α=2/255\alpha= 2/255, 75 iterations, and a random start.

Figure 15 summarizes the results. It shows that, as reported in the past [12, 50 SZS+14], transferability attacks underperform white-box attacks. Moreover, we observe that, using approximate models, the attacker can achieve success rates equivalent to those of a white-box attack with only 5,000 traces in the HD case and 20,000 traces in the HW case. Thus, even though the extracted models are not exact replicas of the target model, they are functionally equivalent with respect to both benign accuracy and the generation of adversarial examples.

Figure 15. Attack success rate of PGD adversarial examples against the target model, showing that transfer from extracted models improves with more traces and nearly matches white-box performance, while surpassing a standard surrogate trained on CIFAR-10.

ResNet-18

Despite having a similar number of weights and the same maximum kernel width, ResNet-18 is significantly deeper than VGG-11, with 21 layers compared to VGG-11’s 11. While 20,000 traces are sufficient to achieve baseline accuracy for VGG-11, even increasing the number of traces by an order of magnitude to 200,000 traces is not enough for a full extraction. Figure 16 shows the results of the model extraction. Although using adaptive RF improves the results, the extraction still fails in the penultimate layer.

Figure 16. Bitwise accuracy of noise-free ResNet-18 extraction using fixed vs. adaptive receptive fields (RFs) with 200,000 traces and the HD leakage model.

Further increasing the number of traces might lead to a successful extraction, but due to the size of the model, the computational cost becomes prohibitively high. The 200,000-trace run required ≈2,400\approx2{,}400 GPU-hours. For perspective, a server with 8 GPUs of similar computational capabilities costs 17.274 US dollars per hour, so the total cost of this single run would be more than 5,000 US dollars.

References

  1. [1]Lejla Batina, Shivam Bhasin, Dirmanto Jap, and Stjepan Picek. CSI NN: reverse engineering of neural network architectures through electromagnetic side channel. In USENIX Security, 2019.
  2. [2]Lejla Batina, Shivam Bhasin, Dirmanto Jap, and Stjepan Picek. Poster: Recovering the input of neural networks via single shot side-channel attacks. In CCS, 2019.
  3. [3]Eric Brier, Christophe Clavier, and Francis Olivier. Correlation power analysis with a leakage model. In CHES, 2004.DOI
  4. [4]Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. In NeurIPS, 2020.arxiv.org/abs/2005.14165
  5. [5]Nicholas Carlini, Jorge Chávez-Saab, Anna Hambitzer, Francisco Rodríguez-Henríquez, and Adi Shamir. Polynomial time cryptanalytic extraction of deep neural networks in the hard-label setting. In EUROCRYPT, 2025.
  6. [6]Benoît Coqueret, Mathieu Carbone, Olivier Sentieys, and Gabriel Zaid. A divide-and-conquer strategy for hard-label extraction of deep neural networks via side-channel attacks. IACR Transactions on Cryptographic Hardware and Embedded Systems, 2026(3):646–678, 2026.arxiv.org/abs/2411.10174
  7. [7]Nicholas Carlini, Matthew Jagielski, and Ilya Mironov. Cryptanalytic extraction of neural network models. In CRYPTO, 2020.arxiv.org/abs/2003.04884
  8. [10]Anuj Dubey, Rosario Cammarota, and Aydin Aysu. Maskednet: The first hardware inference engine aiming power side-channel protection. In HOST, 2020.arxiv.org/abs/1910.13063
  9. [11]Li Deng. The MNIST database of handwritten digit images for machine learning research [best of the web]. IEEE Signal Process. Mag., 29(6):141–142, 2012.DOI
  10. [12]Ambra Demontis, Marco Melis, Maura Pintor, Matthew Jagielski, Battista Biggio, Alina Oprea, Cristina Nita-Rotaru, and Fabio Roli. Why do adversarial attacks transfer? explaining transferability of evasion and poisoning attacks. In USENIX Security, 2019.arxiv.org/abs/1809.02861
  11. [13]Gaofeng Dong, Ping Wang, Ping Chen, Ruizhe Gu, and Honggang Hu. Floating-point multiplication timing attack on deep neural network. In SmartIoT, 2019.
  12. [14]Cheng Gongye, Yukui Luo, Xiaolin Xu, and Yunsi Fei. Side-channel-assisted reverse-engineering of encrypted DNN hardware accelerator IP and attack surface exploration. In SP, 2024.DOI
  13. [15]David Goldberg. What every computer scientist should know about floating-point arithmetic. ACM Comput. Surv., 23(1):5–48, 1991.DOI
  14. [17]Simon Haykin. Neural networks: a comprehensive foundation. Prentice hall PTR, 1994.
  15. [18]Péter Horváth, Lukasz Chmielewski, Leo Weissbart, Lejla Batina, and Yuval Yarom. CNN architecture extraction on edge GPU. In AIHWS, 2024.arxiv.org/abs/2401.13575
  16. [19]Péter Horváth, Lukasz Chmielewski, Léo Weissbart, Lejla Batina, and Yuval Yarom. BarraCUDA: Edge GPUs do leak DNN weights. In USENIX Security, 2025.
  17. [21]Péter Horváth, Dirk Lauret, Zhuoran Liu, and Lejla Batina. SoK: Neural network extraction through physical side channels. In USENIX Security, 2024.
  18. [22]David Holtz. cnn-cifar10-pytorch. https://github.com/dmholtz/cnn-cifar10-pytorch, 2020.
  19. [23]Péter Horváth, Ilia Shumailov, Lukasz Chmielewski, Lejla Batina, and Yuval Yarom. Kraken: Higher-order EM side-channel attacks on dnns in near and far field. In SaTML, 2026.arxiv.org/abs/2603.02891
  20. [24]Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification. In ICCV, 2015.arxiv.org/abs/1502.01852
  21. [25]Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.arxiv.org/abs/1512.03385
  22. [26]Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
  23. [27]Raphaël Joud, Pierre-Alain Moëllic, Simon Pontié, and Jean-Baptiste Rigaud. A practical introduction to side-channel extraction of deep neural network parameters. In CARDIS, 2022.arxiv.org/abs/2211.05590
  24. [29]Mika Juuti, Sebastian Szyller, Samuel Marchal, and N. Asokan. PRADA: protecting against DNN model stealing attacks. In EuroS&P, 2019.arxiv.org/abs/1805.02628
  25. [30]Paul C. Kocher, Joshua Jaffe, and Benjamin Jun. Differential power analysis. In CRYPTO, 1999.DOI
  26. [31]Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The CIFAR-10 dataset, 2009.
  27. [32]Paul C. Kocher. Timing attacks on implementations of Diffie-Hellman, RSA, DSS, and other systems. In CRYPTO, 1996.DOI
  28. [33]Yann LeCun, Bernhard Boser, John S Denker, Donnie Henderson, Richard E Howard, Wayne Hubbard, and Lawrence D Jackel. Backpropagation applied to handwritten zip code recognition. Neural computation, 1(4):541–551, 1989.DOI
  29. [34]Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.DOI
  30. [36]Zhenglin Liu, Xu Guo, Yi-Cheng Chen, Yu Han, and Xuecheng Zou. On the ability of AES S-boxes to secure against correlation power analysis. In ISPEC, 2007.DOI
  31. [37]Li Liu, Wanli Ouyang, Xiaogang Wang, Paul W. Fieguth, Jie Chen, Xinwang Liu, and Matti Pietikäinen. Deep learning for generic object detection: A survey. Int. J. Comput. Vis., 128(2):261–318, 2020.arxiv.org/abs/1809.02165
  32. [38]Ge Li, Mohit Tiwari, and Michael Orshansky. Power-based attacks on spatial DNN accelerators. ACM Journal on Emerging Technologies in Computing Systems, 18(3):1–18, 2022.arxiv.org/abs/2108.12579
  33. [41]Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.arxiv.org/abs/1706.06083
  34. [42]Henrique Teles Maia, Chang Xiao, Dingzeyu Li, Eitan Grinspun, and Changxi Zheng. Can one hear the shape of a neural network?: Snooping the GPU via magnetic side channel. In USENIX Security, 2022.arxiv.org/abs/2109.07395
  35. [43]National Institute of Standards and Technology. Advanced encryption standard (aes). Technical Report FIPS PUB 197, U.S. Department of Commerce, 2001. Updated May 9, 2023.
  36. [45]Get started with Jetson Nano developer kit. https://developer.nvidia.com/embedded/learn/get-started-jetson-nano-devkit. Accessed: 2025-11-27.
  37. [46]NVIDIA. Data Format Descriptions — NVIDIA TensorRT documentation. https://docs.nvidia.com/deeplearning/tensorrt/10.x.x/reference/data-format-desc.html, 2026. Accessed 2026-10-14.
  38. [47]Daniel W. Otter, Julian R. Medina, and Jugal K. Kalita. A survey of the usages of deep learning for natural language processing. IEEE Trans. Neural Networks Learn. Syst., 32(2):604–624, 2021.DOI
  39. [48]Vardan Papyan, X. Y. Han, and David L. Donoho. Prevalence of neural collapse during the terminal phase of deep learning training. Proceedings of the National Academy of Sciences, 117(40):24652–24663, 2020.DOI
  40. [49]Hendrik Purwins, Bo Li, Tuomas Virtanen, Jan Schlüter, Shuo-Yiin Chang, and Tara N. Sainath. Deep learning for audio signal processing. IEEE J. Sel. Top. Signal Process., 13(2):206–219, 2019.DOI
  41. [50]Nicolas Papernot, Patrick D. McDaniel, and Ian J. Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. CoRR, 2016.arxiv.org/abs/1605.07277
  42. [51]torch.nn.batchnorm2d. https://docs.pytorch.org/docs/stable/generated/torch.nn.BatchNorm2d.html. [Accessed 04-06-2026], Default parameters: γ = 1 and β = 0.
  43. [52]torch.nn.conv2d. https://docs.pytorch.org/docs/stable/generated/torch.nn.Conv2d.html#torch.nn.Conv2d. [Accessed 04-06-2026], Default parameter initialization (weights/bias sampled from a uniform distribution).
  44. [53]torch.nn.init.kaiming_uniform_. https://docs.pytorch.org/docs/stable/nn.init.html#torch.nn.init.kaiming_uniform_. [Accessed 04-06-2026], Kaiming (He) uniform initialization; references He et al. (2015).
  45. [54]torch.nn.linear. https://docs.pytorch.org/docs/stable/generated/torch.nn.Linear.html. [Accessed 04-06-2026], Default parameter initialization (weights/bias sampled from a uniform distribution).
  46. [56]Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet large scale visual recognition challenge. Int. J. Comput. Vis., 115(3):211–252, 2015.
  47. [58]Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
  48. [59]Xu Sun, Zhiyuan Zhang, Xuancheng Ren, Ruixuan Luo, and Liangyou Li. Exploring the vulnerability of deep neural networks: A study of parameter corruption. In AAAI, 2021.arxiv.org/abs/2006.05620
  49. [61]Mingxing Tan and Quoc V. Le. EfficientNet: Rethinking model scaling for convolutional neural networks. In ICML, 2019.
  50. [63]Yaman Umuroglu, Nicholas J Fraser, Giulio Gambardella, Michaela Blott, Philip Leong, Magnus Jahre, and Kees Vissers. Finn: A framework for fast, scalable binarized neural network inference. In ISFPGA, 2017.
  51. [65]Andreas Wunsch, Tanja Liesch, and Stefan Broda. Groundwater level forecasting with artificial neural networks: A comparison of LSTM, CNN and NARX. Hydrology and Earth System Sciences, 25:1671–1687, 2021.
  52. [66]Lingxiao Wei, Bo Luo, Yu Li, Yannan Liu, and Qiang Xu. I know what you see: Power side-channel attack on convolutional neural network accelerators. In ACSAC, 2018.DOI
  53. [67]Xubin Wang, Zhiqing Tang, Jianxiong Guo, Tianhui Meng, Chenhao Wang, Tian Wang, and Weijia Jia. Empowering edge intelligence: A comprehensive survey on on-device AI models. ACM Comput. Surv., 57(9):228:1–228:39, 2025.
  54. [69]Kota Yoshida, Takaya Kubota, Shunsuke Okura, Mitsuru Shiozaki, and Takeshi Fujino. Model reverse-engineering attack using correlation power analysis against systolic array based neural network accelerator. In ISCAS, pages 1–5, 2020.
  55. [70]Ville Yli-Mäyry, Akira Ito, Naofumi Homma, Shivam Bhasin, and Dirmanto Jap. Extraction of binarized neural network architecture and secret parameters using side-channel information. In ISCAS, 2021.
  56. [72]Honggang Yu, Kaichen Yang, Teng Zhang, Yun-Yun Tsai, Tsung-Yi Ho, and Yier Jin. CloudLeak: Large-scale deep learning models stealing through adversarial examples. In NDSS, 2020.DOI

Paper details

vlnc:W_xy2t2suj
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 10

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents