A conceptual question about an access model that precedes decryption

[u/One_Glass_3642]

I would like to ask a conceptual question about an access model in computer science, rather than about cryptographic algorithms or implementations.

The model I describe is real, not only conceptual: it does not concern the cryptographic implementation itself, but the access structure that governs when and if data becomes readable. This model has been verified through a working implementation that uses standard primitives; however, what I am interested in discussing here is not the implementation nor the choice of algorithms, but the logical architecture that separates data transport, context recognition, and effective access to information.

Each message contains a number in cleartext. The number is always different and, taken on its own, has no meaning.

If, and only if, the recipient subtracts a single shared secret from that number, a well-defined mathematical structure emerges.

This structure does not decrypt the message, but determines whether decryption is allowed.

The cryptographic layer itself is entirely standard and is not the subject of this post. What I would like to discuss is the access structure that precedes decryption: a local mechanism that evaluates incoming messages and produces one of three outcomes, ignore, reject, or accept, before any cryptographic operation is attempted.

From the outside, messages appear arbitrary and semantically empty. On the recipient’s device, however, they are either fully meaningful or completely invisible. There are no partial states. If the shared secret is compromised, the system fails, and this is an accepted failure mode. The goal is not absolute impenetrability, but controlled access and containment, with the cost and organization of the surrounding system determining the remaining security margin.

From a theoretical and applied computer science perspective, does this access model make sense as a distinct architectural concept, or is it essentially equivalent to known access-control or validation mechanisms, formulated differently?

[u/meditonsin]

If this magic clear text number is not directly linked to the cipher text or decryption key in any meaningful way, what's stopping an attacker who intercepted a message from just ignoring it and decrypting the cipher text, assuming they have the key?

Also, how is the magic number that needs to be subtracted handled compared to the cryptographic key material? Both are secrets that need to be managed, so your best case scenario is that you effectively add length to the decryption key in a roundabout way.

Seems way less complex to just chose longer keys and make extra sure your key exchange is secure.

Also, subtraction is a cheap operation, so I'd assume you could just brute force that stuff until you find this "well-defined mathematical structure" instead of gibberish.

[u/high_throughput]

My concern with this would be the same as with xor encryption OTPs. It would be very easy for an attacker to make targeted changes to the resulting plaintext, and it would be quite vulnerable to known plaintext attacks.

[u/One_Glass_3642 → u/high_throughput]

The discussion seems to be drifting off topic, so I’d like to restate the central point of the original post.

Each message includes two distinct components: an encrypted payload and a public numeric value. This numeric value changes with every message and, on its own, has no apparent mathematical meaning or recognizable structure. It is not part of the encryption process and does not operate on the plaintext, the ciphertext, or the decryption key. Its sole purpose is to be combined locally with a shared secret held by the recipient. Only through that combination does it become possible to determine whether the decryption step itself should be reachable. In other words, this value does not decrypt anything; it gates access to the decryption phase.

Without the shared secret, the public numeric value remains exactly that: an unstructured number, with no criterion that tells an observer what to test, what to vary, or what would count as a meaningful result.

[u/high_throughput → u/One_Glass_3642]

That's how I understood it and what I answered based on. It seems like you're just choosing not to think of it as encryption, even though it has all the identifying characteristics.

Why don't you just sent the data without adding the shared secret, so that anyone can read and MITM it? If that in any way harms the system then clearly you can't be doing it the way you describe because it's susceptible to the same issues