Dishonest Approximate Computing: A Coming Crisis for Cloud Clients

Ye Wang, Jian Dong, Ming Han, Jin Wu, Gang QuarXiv 2024 · DOI · arXiv

Abstract

Approximate Computing (AC) offers significant energy savings by sacrificing minor numerical precision, making it ideal for error-resilient applications like AI. However, this creates a vulnerability where untrusted Cloud Service Providers (CSPs) may secretly employ low-power AC hardware while charging clients for high-precision execution—a phenomenon termed DisHonest Approximate Computing (DHAC). This paper introduces DHAC as a new security threat and proposes two "golden-model-free" detection methods: Residual Class Check (RCC) for integer operations and Forward-Backward Check (FBC) for floating-point tasks. Experimental results demonstrate detection rates exceeding 99% with zero false positives and minimal overhead.

Introduction: The Rise of Dishonest Approximate Computing

As cloud computing becomes the backbone of modern AI and data processing, efficiency is paramount. Approximate Computing (AC) has emerged as a key strategy to reduce energy consumption by trading off precision. While beneficial when transparent, AC introduces a significant incentive for "commercial fraud" by Cloud Service Providers (CSPs).

In a DHAC attack, a CSP advertises high-precision computing services but executes the client's workload on cheaper, approximate hardware. Because the cloud is a "black box," clients typically cannot verify the hardware's integrity. Traditional verification methods, such as re-running tasks locally or using pre-computed "golden models," are often computationally prohibitive or practically impossible for dynamic real-world inputs.

The workflow of a DisHonest Approximate Computing (DHAC) attack scenario.

Detection Frameworks

To address this threat, the authors propose two low-cost detection mechanisms that do not require prior knowledge of the correct output.

1. Residual Class Check (RCC)

RCC is optimized for integer-heavy applications. It leverages the properties of Residue Class Rings (modular arithmetic). The client selects a small prime number $m$ and performs a simplified version of the program's operations in the modular space (e.g., $A \times B \pmod m$). Since these operations involve very small bit-widths, the client can execute them locally with negligible cost. Upon receiving the result $R$ from the server, the client verifies if $R \pmod m$ matches their local modular result. A mismatch indicates a DHAC attack.

2. Forward-Backward Check (FBC)

FBC is designed for floating-point intensive workloads, such as Deep Neural Networks. The client "instruments" the source code with sentinel branches—small, mathematically reversible operations (e.g., $y = f(x)$ followed by $x' = f^{-1}(y)$). In an accurate computing environment, $x$ should remain identical to $x'$. However, the precision loss inherent in approximate hardware prevents perfect cancellation during the "backward" pass, triggering a detection alert.

Experimental Evaluation

The effectiveness of RCC and FBC was tested across various benchmarks, including Euler and Runge-Kutta methods, FIR filters, and VGG-11/19 models trained on the CIFAR-10 dataset. The authors utilized EvoApproxLib to simulate approximate adders and multipliers, creating a realistic "dishonest" environment.

Key Results

  • High Sensitivity: RCC achieved a detection rate of over 98% in a single pass, rising to 99.9% after three rounds with different prime modules.
  • Robustness in AI: FBC successfully detected DHAC in VGG models with 96% to 99% accuracy, even when the accuracy loss was less than 1%—a level virtually invisible to standard user monitoring.
  • Zero False Positives: Neither method misidentified legitimate accurate computations as attacks during testing.
  • Economic Incentive: The study found that CSPs can save up to 24% energy on integer tasks and a staggering 77% on floating-point tasks, highlighting the strong financial motivation for DHAC.

Discussion and Future Work

The proposed methods shift the burden of proof. RCC is particularly robust because it is performed locally, making it invisible to the server and preventing "adaptive" attackers from temporarily switching to accurate mode. FBC, while visible in the code, shifts the execution cost to the server, providing a low-overhead solution for the client.

Future research aims to extend these protections to Software-as-a-Service (SaaS) environments and "local black-box" hardware devices where users have even less visibility into the execution pipeline.

Summary updated

BibTeX
@misc{wang2024dishonest,
  author = {Ye Wang and Jian Dong and Ming Han and Jin Wu and Gang Qu},
  title = {{Dishonest Approximate Computing: A Coming Crisis for Cloud Clients}},
  year = {2024},
  eprint = {2405.15322},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2405.15322},
}
Figure