I read your requirements. So, there's an analog loophole: in order to "write", the filesystem has to receive the data to be written - otherwise, it's untestabl

I read your requirements. So, there's an analog loophole: in order to "write", the filesystem has to receive the data to be written - otherwise, it's untestable (if it doesn't get the data to be written it could write whatever it wants and pass all tests) which is a roundabout way of saying that if it doesn't get the data it can't possibly work. So it has to get the data. At that point it could be saved if the filesystem is modified (patched) to exfiltrate it. So we have to assume that you kind-of trust the filesystem not to be patched. But if the filesystem is not modified, though, that means you're fine with the path that that data takes all the way until your filesystem writes it -- however, in this case your requirements are 100% met by encrypting to the public key and writing that out. #jakobdabo's requirements #include <pgp stuff> #include <filesystem stuff> public key = arg0 private key = arg1 read_file(filename){ if (have_private_key) try decrypt(private_key, read(filenename)) return result except "didn't work" else "I wasn't called with a private key." } write_file(filename, data) towrite = encrypt(filename, data) //encrypted metada inside try write towrite except "didn't work" so this should meet all of your requirements. If you wanted the filesystem to do stuff like hide whether a file is even modified, hide timestamps, etc etc, those are almost impossible. Consider: I want to determine whether anyone is accessing a server at the moment. Server is idling, with sockets listening to answer web queries. Suddenly 5,000 Reddit users show up and look through the site, generating lots of logs which nginx dutifully saves - only you're saving it in your encrypted filesystem. Now. How would you make it so that the fact that all of this traffic is being saved is hidden? The updates to the drive image would have to happen like clockwork regardless of what was happening. But this isn't a reasonable requirement, as the amount of entropy entering the drive is bigger while Reddit is hugging it than normal. You couldn't make it so that you are saving as much information as at top load. so what do you do? Reduce the top average to some level that you can continuously fabricate? It doesn't make sense. So you wouldn't hide whether any data was being saved by the dash-cam at all. but it's easy to save an encrypted version. the dash cam doesn't even need the private key. but you do have to trust the software running on it. (for example to correctly do the encryption and not also write the underlying data somehow.)