Abstract
This paper provides a critical security analysis of the PSLP protocol, a scheme intended to protect sensitive medical data during outsourced machine learning. The authors demonstrate that the protocol fails to provide the promised privacy, allowing an honest-but-curious cloud provider to fully recover private patient records and the final trained model.
Introduction
As healthcare providers increasingly leverage "Big Data," they often outsource computationally intensive machine learning tasks to cloud servers. Given the high sensitivity of medical records, privacy-preserving protocols are essential. The PSLP (Privacy-Preserving Single-Layer Perceptron) scheme was previously proposed to address this need, utilizing the Paillier cryptosystem—an additive homomorphic encryption scheme—to allow training on encrypted data. This analysis investigates whether PSLP truly delivers on its security promises against an "honest-but-curious" cloud provider (one that follows the protocol but attempts to extract sensitive information).
The PSLP Protocol and Its Flaws
The PSLP protocol involves a five-step interaction between a hospital (the data owner) and a cloud server (the computation provider). The core of the learning process relies on the standard perceptron weight update rule: $$\vec{w}_{new} = \vec{w}_{old} + \eta y_i \vec{x}_i$$ where $\vec{w}$ represents model weights, $\eta$ is the learning rate, $y_i$ is the label, and $\vec{x}_i$ is the private medical data.
The fundamental security flaw identified is the "Decryption Oracle" problem. Because the cloud cannot perform certain non-linear operations on encrypted data, the protocol requires the hospital to decrypt the updated weights and return them to the cloud in plaintext at the end of each iteration to facilitate further calculations.
Security Vulnerability Analysis
The most significant insight is that if an adversary knows the state of a model before and after a training step, they can calculate the "delta" or change in weights. In a single-layer perceptron, this delta is directly proportional to the input data. By observing the plaintext weights $\vec{w}^{(t)}$ and $\vec{w}^{(t+1)}$, the cloud server can easily reverse-engineer the private input $\vec{x}_i$.
Furthermore, this leakage extends to the hospital's intellectual property. Since the cloud receives the final weights in plaintext, the hospital loses control over the trained model, which may have significant commercial value. The protocol inadvertently exposes the very assets it was designed to protect.
Data Recovery Attack and Results
The authors prove that the cloud server can obtain private medical information $\vec{x}_i$ by solving a simple linear equation derived from the weight update rule: $$\vec{x}_i = \frac{\vec{w}^{(t+1)} - \vec{w}^{(t)}}{\eta y_i}$$
Since the cloud knows the weights at iterations $t$ and $t+1$, the learning rate $\eta$, and the labels $y_i$, the private medical record $\vec{x}_i$ is revealed through basic arithmetic. The analysis concludes that as the algorithm iterates through the dataset, every medical case used for training is eventually leaked to the cloud provider.
Conclusion
This research exposes a critical vulnerability in the PSLP protocol, showing that it fails to protect both patient privacy and model confidentiality. While the analysis is specific to single-layer perceptrons, it highlights the broader risks of "gradient leakage" in outsourced learning. Future work by the authors aims to develop a truly secure privacy-preserving learning scheme that avoids treating the data owner as a decryption oracle.
Summary updated