I’m exploring a data security concept where files do not exist as conventional static entities but instead “float” as encrypted fragments, retrievable only through specific contextual parameters.
The Idea Floating Storage: The file is split into multiple small fragments, all given uniform filenames (e.g., datafile.dfv).
Contextual Binding: Access to these fragments is only possible when verified against behavioral or environmental parameters (e.g., device signature, time-bound tokens).
Dynamic Mapping: A mapping system continuously changes the internal references between the fragments and the file structure, making stolen fragments useless without the correct context.
This idea was inspired by how map pins on Google Maps are meaningless until the system overlays them with contextual data. Similarly, stolen fragments would be useless without the AI or mapping layer.
My Questions Is there any known implementation in production systems where data exists only as context-bound fragments?
Would traditional key-chunk mapping (used in filesystems) break this concept by making fragments predictable or clonable?
Could HSM/TPM-backed keys help maintain the floating nature by constantly regenerating internal references?
Example Pseudocode:
# Simplified representation of fragment hashing logic
import hashlib, time
def generate_fragment_key(fragment_data, device_id, time_slot):
raw = fragment_data + device_id + str(time_slot)
return hashlib.sha256(raw.encode()).hexdigest()
# Time-slot ensures key changes dynamically
key = generate_fragment_key("fragment_1", "DEVICE_ABC123", int(time.time() // 3600))
print(key)
This pseudocode only shows the dynamic key regeneration idea for each fragment.