The Paradox of Provenance and Privacy: Can Private Cloud Compute (PCC) Prove That Apple Reference Images Are Not Used for Learning?
The Provenance-Privacy Paradox: Can Private Cloud Compute (PCC) Prove That Apple Reference Images Are Not Used for Learning?
The authors state that ARI's PCC cloud processing has a provenance–privacy paradox: in the testbed, two workloads pass the same verification and return byte-identical JPEGs, but one secretly retains gradients from which the input can be reconstructed.
- Apple Reference Image hands signed raw photos to Private Cloud Compute to be processed into a reference JPEG, and the authorized workload must touch plaintext pixels in the protected environment. The authors question whether attestation and the transparency log can prove that the workload will not learn from or retain information from the photos.
- The authors formally distinguish identity verification from behavior verification and construct a counterexample: the baseline workload B0 and the learning workload B1 have different measurements but are both authorized. In the Python/Docker testbed, B1 uses a background thread to compute and store first-layer gradients, then directly reconstructs the input using the analytical relationship of the fully connected layer's gradients.
- On 27 CC0 photos, B0 and B1 pass the same verification and return byte-identical JPEGs; B1 retains about 48 KB of gradients and reconstructs the 64×64 input with a maximum per-pixel error of 6 × 10−8. In the size-scaling experiment, B1 takes an additional 3–57 ms.
- The authors state: the testbed does not touch production PCC or VRE, and they do not claim that Apple is training with ARI; the reconstruction holds only under the narrow conditions of a single sample, a fully connected first layer, and 64×64 downsampled input; log growth and consistency proofs are not modeled; timing side channels are left for future evaluation.
- Threat model
- The victim systems are Apple Reference Image (ARI) and Private Cloud Compute (PCC). The attacker is an Apple-authorized PCC workload itself: it passes attestation and transparency-log verification, legitimately obtains plaintext raw pixels, and while returning a normal JPEG, secretly computes and retains image-derived state (gradients). The cryptographic mechanisms all work as designed; the failure is at the semantic level rather than the cryptographic level.
- Benchmarks
- 27 张 public-domain CC0 照片放大的 CC0 照片(约 1–100 MB,6 个尺寸)
- Metrics
- attestation 与 transparency-log 检查通过率JPEG 逐字节一致性重建最大绝对逐像素误差响应时间中位数(ms)梯度存储大小(KB/MB)
Two researchers implemented a counterexample in a Python and Docker experimental environment simulating the Apple Reference Image (ARI) and Private Cloud Compute (PCC) pipeline: a workload with a learning capability and a baseline workload pass the same verification checks and return byte-identical JPEGs for 27 public-domain photos. Because authorized PCC workloads must process raw pixels in plaintext, cloud processing, while strengthening provenance guarantees, also gives machine learning workloads access to hardware-attested raw images. The learning workload retained about 48 KB of first-layer gradients, from which the reconstructed 64×64 input had a maximum absolute per-pixel error of 6×10^-8. The authors argue on this basis that workload attestation and transparency logs can only verify software identity and authorization, not that an authorized workload does not learn or retain; the results do not indicate that Apple currently trains on ARI photos or reproduces production PCC, but rather list not learning and not retaining as independently verifiable assurance requirements.
Paper analysis
What problem does this paper attempt to solve?
The authors state that ARI relies on PCC to process plaintext raw pixels, creating a paradox between provenance guarantees and privacy, and that existing verification cannot prove that the workload does not learn.
Core question: ARI hands hardware-attested raw photos to an authorized PCC workload for plaintext processing—can workload attestation and transparency-log verification prove that the workload will not learn from, retain, or export information from the photos?
- Problem setting: ARI uses sensor signatures, the SEP, timestamps, and PCC to develop raw data captured by an iPhone into a verifiable reference JPEG. The authors point out that PCC must decrypt and process raw pixels in plaintext, and that PCC itself has foundation-model inference, embedding generation, and GPU acceleration capabilities; the same compute can calculate embeddings, gradients, or model updates.
- Shortcomings of existing mechanisms: The authors argue that attestation and transparency logs verify only software identity and release authorization, not semantic non-learning or non-retention properties; transport encryption protects only the communication path and does not prevent an authorized workload from using plaintext pixels.
- Core observation: The authors formalize that if the client policy is merely "valid attestation and in the approved log," then a baseline workload B0 and a learning workload B1 with different measurements will both be accepted, and when they return the same output the client cannot infer the hidden learning behavior from the verification result.
- What the paper proposes: The authors propose a characterization of the provenance–privacy paradox, a formal counterexample, a Python/Docker testbed implementation, and recommendations including a non-learning policy, restricting persistent storage and outbound communication, disclosing retained data, and independently verifying workload behavior.
- Threat model:
- Attacker goal: An authorized PCC workload secretly computes and retains derived state (such as gradients) that can recover image information while processing ARI raw photos.
- Attacker knowledge: The workload is authorized by Apple, its measurement is in the transparency log, and it legitimately passes all verification.
- Attacker capability: Legitimate access to plaintext raw pixels within the protected execution environment, ability to perform arbitrary computation and write to local storage; no need to forge signatures or break the TEE.
- Victim system: The ARI/PCC architecture and its client acceptance policy; the paper explicitly does not claim that Apple currently trains on ARI photos, nor does it reproduce production PCC.
What related research exists?
Related work falls into three categories: independent analyses of PCC, ML privacy leakage, and remote attestation; the authors state that no study has examined whether an attested workload can hide learning under output equivalence.
Independent analyses of PCC
- Dittmar et al. (2026): Reverse-engineered the PCC client binary and non-public interfaces, reported that the published source code cannot be matched to the released binaries via reproducible builds, and released a framework supporting custom PCC queries and model benchmarking. The paper notes that this work improves empirical access to PCC but does not test whether an attested image-processing workload can hide learning while functioning normally.
- Apple VRE (2026): A Virtual Research Environment provided by Apple that can boot a minimally modified PCC software stack on Apple silicon, allowing custom cryptexes, arbitrary entitlements, and debugging. The authors state that the VRE is a more suitable starting point for their server-side counterexample, but the VRE is not a production cluster.
Machine learning privacy leakage
- Shokri et al. (2017) and Fredrikson et al. (2015): Proposed membership inference attacks and model inversion attacks, respectively, inferring training-data membership or reconstructing sensitive attributes from black-box outputs or confidence information.
- Zhu et al. (2019), Phong et al. (2018), Geiping et al. (2020): Zhu et al. showed that shared gradients can reconstruct training samples at pixel-level accuracy under favorable conditions; Phong et al. and Geiping et al. showed that the input to a fully connected layer can be analytically recovered from its gradients. This paper uses this analytical recovery as the measurement tool for Phase 2, and the authors explicitly state that it is not a new attack.
Semantic limitations of remote attestation
- Haldar et al. (2004): Distinguished the identity of an executable from its behavior, pointing out that traditional remote attestation can prove only which binary is running remotely, and that guarantees about behavior rest on trust rather than verification. The paper cites this work in support of the argument that identity verification is not behavior verification.
- Birkholz et al. (RFC 9334, 2023): The RATS remote attestation architecture, cited as background for measurement-based attestation.
Baselines and benchmarks: This is not a work that proposes a new method and compares it against baselines; the control in the experiments is the authors' own baseline workload B0 (which only processes images and retains no state), and the data are 27 public-domain CC0 photos.
Authors' positioning: The authors state that prior work has separately studied PCC implementation transparency, model benchmarking, remote attestation, or ML leakage, and that they found no published study examining the paper's core combined question: whether a cloud workload can, while remaining attestation-acceptable and application-output-equivalent, silently extract useful training signal from authenticated raw photos.
How does the paper address this problem?
The authors formally distinguish identity verification from behavior verification, construct B0/B1 counterexamples, and validate hidden retention in a Python/Docker testbed using gradient-based analytical reconstruction.
Overall approach: first formally distinguish "verifying workload identity" from "verifying workload behavior," construct an attestation-compatible hidden-learning counterexample, then demonstrate that the counterexample holds with an executable testbed simulating ARI/PCC functionality, and measure the information content of the retained state using analytical gradient reconstruction.
Problem setting and formalization
- Capture and development: The sensor signature σS = Sign_SKS(R ∥ h) and the SEP signature σE = Sign_SKE(H(σS) ∥ M) authenticate the raw pixels R but do not encrypt them; PCC must execute J = Develop(R; C) to obtain the reference JPEG.
- Upload package: The device uploads the complete secure digital negative D = (R, σS, σSEP, MD, MB, TL, TU, µ), encrypted in transit as C = Enc_KPCC(D), but PCC must decrypt it and process it in plaintext.
- Acceptance predicate: A(B) = VerifyAttestation(m(B)) ∧ m(B) ∈ L, i.e., verify the measurement and confirm it is in the authorization log L; the authors point out that this does not directly establish semantic properties such as "B does not train on the input image" Φ(B).
Counterexample construction
- Two workloads: B0(R) = Develop(R) returns only the JPEG; B1 additionally computes gradients gR ← ∇θ ℓ(fθ(R), yR), updates θ′ ← θ − ηgR, and persists them, while still returning the same J.
- Equivalence condition: If both measurements are authorized (m(B0), m(B1) ∈ L) and the externally observable outputs are equal, then A(B0) = A(B1) = 1, and the client cannot infer hidden learning from the acceptance result and return value alone; the authors emphasize that all cryptographic mechanisms work as designed here, and the privacy failure is semantic rather than cryptographic.
Testbed implementation
- Deployment: Python implementation, Docker deployment; two server containers each limited to 4-core CPU and 8 GB memory, with a third container running the client, communicating over an isolated Docker network; uniform Debian 12, Python 3.12.3, CPU-only PyTorch 2.11.0, Pillow 12.1.1, NumPy 2.3.4, cryptography 49.0.0, no GPU.
- Simulated PCC functionality: Ed25519 keys represent the hardware root of trust signing code measurements; the transparency service is modeled as a signed Merkle tree containing published measurements; the client accepts a response only when the attestation signature and signed log root verify and the measurement is in the log. The log is built once before execution; log growth, consistency proofs, and equivocation are not modeled.
- Two servers: B0 processes and returns the photo without retaining state; B1 returns the same photo but uses a background thread to compute and store first-layer gradients (which the authors describe as the minimal retained representation permitting exact reconstruction under their conditions).
Reconstruction method (measurement tool for Phase 2)
- Network and retained quantity: B1 performs one training step on the 64×64 version of each photo, with a network consisting of a width-8 fully connected layer + ReLU + linear output head; only the weight gradient and bias gradient of one neuron in the first layer are retained, and the neuron with the largest absolute bias gradient is chosen to reduce numerical instability.
- Analytical reconstruction: For a single sample, the fully connected layer satisfies ∇Wiℓ = (∇biℓ) x, so when the bias gradient is nonzero the input can be recovered directly as x = ∇Wiℓ / ∇biℓ, without a GPU or iterative optimization; the authors state that this is the analytical reconstruction of Phong et al. and Geiping et al., not a new attack.
Suggested directions for protection
- The authors recommend that PCC enforce an explicit non-learning policy prohibiting ARI workloads from computing or retaining unnecessary image-derived state such as gradients, embeddings, and model updates; restrict persistent storage and outbound communication; fully disclose data entering, leaving, and being retained; and have independent reviewers verify workloads and their storage and communication permissions.
What experiments did the paper conduct?
On 27 CC0 photos, B0 and B1 pass the same verification and return byte-identical JPEGs; the 48 KB gradient retained by B1 reconstructs the input with an error of 6 × 10−8.
Experimental setup
- Subjects under test: Two server-side workloads implemented by the authors—baseline B0 (retains no state) and learning workload B1 (retains first-layer gradients); no real Apple system or model was tested.
- Data: Phase 1/2 used 27 public-domain CC0 photos; the size-scaling experiment used CC0 photos upscaled and noised to approximately 1–100 MB, for 6 sizes in total (Table 2).
- Metrics: Whether attestation and transparency-log checks pass, whether the returned JPEGs are byte-identical, the maximum absolute per-pixel reconstruction error, median response time, and gradient storage size.
- Decision method: The client programmatically verifies the attestation signature, the signed log root, and whether the measurement is in the log; no LLM review.
- Repetitions: The 27-image experiment was repeated 5 times; the size-scaling experiment was run 9 times per size, taking the median.
- Environment: Docker containers (4-core CPU, 8 GB memory), CPU-only, no GPU.
Main results
Phase 1 and Phase 2 results (per Sections 7.2 and 7.3 and Figure 3):
Swipe horizontally to read the table
Workload Passes verification (27 images) Returned JPEG Retained state Maximum per-pixel reconstruction error B0 (baseline) 27/27 Byte-identical to B1 None Not applicable B1 (learning) 27/27 Byte-identical to B0 About 48 KB per photo (64×64 gradient) 6 × 10−8 - Negative control: After removing B1's measurement from the transparency log, the client rejects B1; the authors state this confirms the acceptance check is working rather than being bypassed.
- Authors' interpretation: The client can see that the two measurements differ, but from the measurements alone cannot determine which workload retains gradients; under a policy of "accept any correctly attested and logged release," both are valid and produce the same output.
- Authors' emphasis: The results do not indicate that Apple currently trains on ARI photos, nor do they reproduce production PCC; they show only that identity-based attestation, transparency, and output equivalence are compatible with hidden retention of recoverable image information.
Response time comparison (Phase 1, 5 repetitions)
- Median response time: Including container network round trips, B0 was 9.4–12.2 ms and B1 was 11.5–12.4 ms; depending on the run batch, B1 was 0–2.1 ms slower.
- Authors' interpretation: One possible but untested explanation is contention between the background gradient computation and the response thread; sufficiently precise timing analysis might detect this difference, but timing is not within the modeled PCC acceptance policy, and decoupling computation with a work queue could reduce observable differences; the authors leave this for future evaluation.
Size-scaling experiment (Table 2)
- Setup: B0 and B1 return the same SHA-256, with the only intentional difference being the gradient computation; B0 is timed until the response is returned, and B1 until the 64×64 gradient is written to disk; the median of 9 requests per size is taken.
- Results: JPEGs ranged from 1.0 MB to 94.4 MB; B0's median time increased from 21 ms to 1650 ms, and B1's from 25 ms to 1707 ms; B1 took 3–57 ms more than B0, and except for the 1 MB case (4 ms more, about 19% of the 21 ms baseline), overhead was below 7% at all sizes.
- Gradient size: The 64×64 gradient is about 48 KB and the 512×512 about 3 MB, independent of the original JPEG size; the full-resolution gradient is about 16 times the compressed JPEG, with a 94.4 MB photo corresponding to about 1.5 GB (1510 MB in Table 2). Gradients at all three resolutions reconstructed their respective inputs with a maximum per-pixel error of 6 × 10−8.
- Authors' interpretation: Ordinary training typically uses a fixed input resolution, so even if the uploaded JPEG is large, retaining a training-resolution representation may require only tens of KB or a few MB; the testbed does not prove that such retention is undetectable in production PCC, only that storage and time overhead can be small relative to image decoding and processing.
Other ablations and analyses
- Perceptual hash difference: In the initial implementation, B1 replaced the SHA-256 in the simulated service record with a perceptual hash; this field does not affect the client's acceptance decision; in the size-scaling experiment both returned the same SHA-256, eliminating this incidental difference.
- Per-request waiting: The size-scaling experiment waited for B1's background computation to complete before sending the next request in each trial, so the measurements include full gradient generation and storage, but overlap between consecutive requests was not evaluated.
- Negative results: The paper reports no reconstruction failures; all 27 photos were reconstructed successfully with an error of 6 × 10−8, which the authors attribute to floating-point rounding.
What are some points that can be further explored?
The authors state that the testbed does not touch production PCC, that the reconstruction conditions are deliberately narrowed, and that timing side channels are left for the future; the experiments cover only a self-built simulated environment.
Limitations and future directions noted by the authors
- No claim that Apple is training, no reproduction of production PCC (Section 1, introduction to Section 7): Researchers cannot deploy arbitrary workloads on production PCC nodes, so this claim cannot be directly tested through public interfaces; the experiments evaluate only whether the published guarantee mechanisms are sufficient to rule out hidden learning and retention.
- Reconstruction conditions deliberately narrowed (Section 7.3): The gradients correspond to a single photo, the network contains a vulnerable fully connected first layer, and what is reconstructed is the downsampled 64×64 model input rather than the original full-resolution JPEG; the authors state that the results are a sufficiency demonstration, not evidence that every architecture or training configuration permits exact gradient inversion.
- Timing side channel not evaluated (Section 7.2): The authors suggest that fully decoupling computation with a work queue might reduce observable timing differences, and leave this possibility for future evaluation.
- Log mechanism not modeled (Section 7.1): The log is built once before execution; the testbed does not model log growth, consistency proofs, or equivocation.
- Detectability in production not established (Section 7.4): The testbed does not prove that such retention is undetectable in production PCC, only that the overhead can be small relative to image decoding and processing.
- Design alternatives all involve trade-offs (Section 9): The authors discuss directions such as fully on-device development, open deterministic development, an independent development quorum, zero-knowledge proofs, split/secure multi-party computation, and user-selected confidential cloud, noting that each requires trade-offs among provenance guarantees, privacy, computational cost, operational complexity, and trust distribution.
Experimental coverage
- The subjects under test are the authors' own two workloads, B0 and B1, 2 in total; they were not run on any real PCC node or VRE (introduction to Section 7).
- The data are 27 public-domain CC0 photos (Phase 1/2) and 6 size tiers generated from 1 upscaled and noised CC0 photo (Section 7.4).
- Repetitions: the 27-image experiment 5 times; size scaling 9 times per size (Sections 7.2, 7.4).
- The reconstruction network is a width-8 fully connected layer + ReLU + linear head with 64×64 input; no other architectures were tested (Section 7.3).
- The paper does not report gradient reconstruction performance on batched samples, convolutional architectures, or full-resolution inputs; the size-scaling experiment did not evaluate computation overlap between consecutive requests (Section 7.4).
Summarize the main content of the paper
The authors state that ARI's PCC design creates a provenance–privacy paradox: in the testbed, an authorized workload passes all verification and returns the same JPEG, yet secretly retains gradients from which the input can be exactly reconstructed.
An analytical and empirical paper on the privacy guarantees of Apple Reference Image (ARI) and Private Cloud Compute (PCC).
- Problem addressed: To prove photo provenance, ARI hands hardware-signed raw photos to PCC, which decrypts and processes them in plaintext into a reference JPEG. The authors question whether workload attestation and transparency-log verification, which can prove only software identity and authorization, can prove that an authorized workload will not learn from or retain information from the photos.
- Method highlights: Formally distinguish identity verification from behavior verification and construct a counterexample—baseline workload B0 and learning workload B1 have different measurements but are both authorized and return the same output; in a Python/Docker testbed (simulating image processing, attestation, transparency-log verification, and client acceptance), B1 uses a background thread to retain first-layer gradients and directly reconstructs the input using the analytical relationship of the fully connected layer's gradients.
- Main results: On 27 CC0 photos, B0 and B1 pass the same attestation and log checks and return byte-identical JPEGs; B1 retains about 48 KB of 64×64 gradients per photo and reconstructs its network input with a maximum absolute per-pixel error of 6 × 10−8; in the size-scaling experiment, B1 took 3–57 ms more than B0, with overhead below 7% at all sizes except the 1 MB case at about 19% (Table 2).
- Authors' conclusion: The authors state that identity-based attestation, transparency, and output equivalence are compatible with hidden retention of recoverable image information, and that non-learning and non-retention should become independently verifiable guarantee requirements; they recommend an explicit non-learning policy, restricting persistent storage and outbound communication, disclosing retained data, and independently verifying workload behavior and permissions.
- Boundaries: The authors explicitly do not claim that Apple currently trains on ARI photos, and the testbed does not reproduce production PCC; the reconstruction results hold only under the narrow conditions of a single sample, a fully connected first layer, and a downsampled input.