Abstract
This paper introduces a novel "server-users-servers" framework for anonymous data aggregation in the Internet of Things (IoT). By combining a modified peer-shuffle technique with robust accountability checks, the proposed scheme enables secure data collection across multiple untrusted IoT providers. The approach significantly reduces computational and communication overhead compared to existing protocols like Dissent by decoupling identity anonymization from large data payloads.
The Challenge of IoT Data Silos
In the current IoT ecosystem, data is often siloed within proprietary networks. For instance, smart thermostat data may be sent to one company while smart meter data goes to another. For researchers attempting to aggregate this data to study broader patterns, such as neighborhood energy usage, privacy becomes a significant hurdle.
Traditional anonymous aggregation schemes typically rely on a simple server-client model. However, IoT devices are often tethered to a "provider server" (the manufacturer), and users may not have total control over the data sent to these home bases. This creates a unique challenge: how to aggregate data from multiple companies without any single entity—collector, provider, or user—knowing exactly whose data is whose, while ensuring that malicious actors can be held accountable.
The Server-Users-Servers Framework
The authors propose an Accountable Anonymous Data Aggregation Scheme that operates across six phases. The core innovation is the Server-Users-Servers architecture, which separates the identity of the user from the data submission process.
Modified Peer-Shuffle
Instead of shuffling actual (and potentially large) data payloads, users perform a peer-shuffle on small "index messages" or pseudonyms. This involves serial encryption—encrypting a message with every user's public key in sequence—followed by a reverse-order "shuffle-and-decrypt" process. This ensures that the final list of indices is anonymized before any data is linked to them.
Decoupled Submission
Once the index messages are anonymized and broadcast, users instruct their respective provider servers to submit the actual data to the collector, tagged with the now-anonymous index. This decoupling ensures that the heavy cryptographic lifting is independent of the data volume.
Accountability via Proactive Verification
Unlike many "Mix-Net" schemes that require a trusted third party, this protocol assumes no entity is fully trustworthy. Accountability is achieved through five proactive verification steps:
- Replication/Replacement Attack Checking: Ensures no messages were duplicated or swapped.
- Broadcast Consistence Checking: Confirms all participants received the same anonymized list.
- Uniqueness Checking: Prevents the collector from using unique data values to "fingerprint" a user.
- Data Submission Checking: Allows users to verify that their provider server submitted the correct data.
If a discrepancy is found, the system can "replay" the anonymization steps using logged random numbers to identify the cheater without compromising private keys.
Key Results and Performance
The authors evaluated the scheme using extensive Java simulations, testing variables such as user group sizes (up to 24), data sizes (up to 256KB), and provider counts (up to 25).
- Scalability: As the number of providers increases, the per-user communication overhead remains relatively flat, whereas traditional protocols like Dissent see overhead grow approximately $T$ times larger (where $T$ is the number of providers).
- Computation Speed: In multi-provider scenarios, the proposed scheme is significantly faster. For a setup with 10 users, the total execution time stayed nearly constant as providers were added, while Dissent's execution time spiked due to redundant serial encryptions.
- Communication Efficiency: Total message length is significantly lower because serial encryption is only applied to small index messages, not the full data tuples.
Limitations and Future Work
While the scheme shows significant improvements, the authors noted that the Java implementation introduced some overhead compared to C++ alternatives. Practical hurdles include RSA modulus limits during serial encryption, which can require data splitting. Future research will explore different encryption primitives to handle these limits more gracefully and improve recovery sub-protocols for when users drop out mid-session.
Summary updated