Questions with answers regarding to our proposed paper
1. What makes this proposed Proof of Ownership (PoW) scheme more secure and efficient
compared to previous approaches like Merkle Tree-based methods?
Answer- The proposed scheme improves on earlier approaches both in terms of security and
efficiency, overcoming major shortcomings in existing Proof of Ownership (PoW) techniques.
Previous schemes, particularly those based on Merkle Trees required either:
Access to the entire file or storage of extensive metadata, such as sibling paths and tree nodes.
While secure, these methods imposed high computation and communication overhead,
especially as the file size increased. Additionally, some variants only used a subset of file blocks,
weakening security, as malicious users might succeed using only partial data.
The proposed scheme solves these issues through a lightweight and full-file approach:
Instead of using trees or complex cryptographic structures, it relies on a simple but effective
hash chain, built using a pseudorandom generator (PRG) and standard cryptographic hash
functions.
During each iteration, it processes just two file blocks, minimizing I/O cost.
The final result is a single compact hash, reducing communication to just one value—unlike
Merkle-based methods which transmit full sibling paths or large hashes.
Security is also stronger:
Since every block in the file contributes to the final proof, a malicious user must have all file
blocks, not just a subset.
Each challenge uses a new random seed, ensuring that the proof is unique each time, protecting
against replay attacks.
The use of collision-resistant hashing ensures that no two different file inputs can produce the
same proof.
In short, this scheme achieves strong security guarantees while being computationally
lightweight, scalable, and practical for real cloud environments.
2. How does the proposed scheme prevent replay attacks or the reuse of old proofs by malicious
users?
Answer- Replay attacks occur when an attacker captures a previous valid challenge-response
pair and tries to reuse it later to impersonate a legitimate user. This is a significant threat in
traditional PoW schemes if the challenge remains static or predictable.
The proposed scheme effectively neutralizes replay attacks through the use of a fresh, random
seed for every ownership verification challenge. Here's how it works in detail:
The cloud server generates a new random seed value for each ownership verification request.
The user uses this seed, along with the full content of the file, to compute a unique proof hash.
This hash is based on every block of the file, and the hash chain incorporates PRG(seed || i)
values, making it highly sensitive to both the seed and the file content.
What this means is:
Even if an attacker has access to a previous valid response, that response is useless for a new
challenge because the seed will be different, leading to a completely different hash output.
Since the PRG output depends on the seed, and the hash is a chain of PRG outputs and file
blocks, there's no way to reuse or adjust an old proof to match a new challenge.
This mechanism ensures freshness of every verification interaction, which is a standard
requirement in secure challenge-response protocols. The security proof in the paper formally
shows that the probability of an adversary succeeding with a replay or guess is negligibly small,
assuming a secure hash functions and PRG.
3. How scalable is this scheme for real-world cloud environments, especially with large files and
multiple users?
Answer- The proposed scheme is designed from the ground up to be practical and scalable, even
for large-scale cloud deployments involving millions of users and large file sizes.
Here's why it scales well:
1. Low I/O Overhead-
The scheme requires accessing only two file blocks at a time during each iteration of the proof
generation.
This means that it doesn’t load the full file into memory, making it highly efficient for devices
with limited RAM, such as mobile devices or edge nodes.
2. Minimal Communication-
Only a single final hash value is transmitted from the user to the server during the proof-of-
ownership protocol.
This significantly reduces bandwidth usage compared to other schemes, which may require
transmitting multiple hashes, full Merkle tree paths, or cryptographic tokens.
3. No Metadata Overhead-
Unlike Merkle Tree or Bloom Filter-based schemes, the server does not need to store any
ownership metadata.
This eliminates the need for large-scale metadata management, a common bottleneck in cloud
storage systems with deduplication.
4. Real Cloud Implementation-
The scheme was implemented using Google Firebase, a widely used real-world cloud service.
Experiments were conducted on files ranging from 64 MB to 1 GB, and the performance metrics
—including computation time, memory usage, and communication cost—were found to be
significantly better than traditional approaches.
5. Multi-user Friendly-
Each user’s challenge is independently generated and verified using a random seed, which
avoids collision or interference between users.
Even if multiple users try to access the same deduplicated file, ownership verification remains
secure and efficient.
In summary, the scheme is lightweight enough for client-side devices, efficient enough for large
files, and robust enough to handle multi-user environments, making it suitable for scalable cloud
deployments with high-security needs.
