I am looking for a "partial" encryption/decryption algorithm.
Let's say I am encrypting the following List of IDs (long values) $[1,2,3,4]$ (with a secret key) to an encrypted string $e$, I would like to produce several keys $k_1,k_2,...,k_n$, which can decrypt just a subset (some IDs).
val rawIds = [1,2,3,4,8] # Array of Long val e = encrypt(rawIds, secretKey) # An encrypted String decrypt(k1, e) =  # Decryption of e with key k1 decrypt(k2, e) = [2,3] # Decryption of e with key k2
Both the encryption and decryption must be very fast in terms of computation time (<1ms). We want to produce keys, which can decrypt the value $e$ in way that only a subset of IDs can be decrypted.
$k_1$ for example is able to decrypt $e$ (but only retrieves $ID_1$) where $k_2$ can decrypt the same encrypted value but retrieves $ID_2$ and $ID_3$. He might even get $ID_5$, but this was not in the raw string.
When creating the keys, we could add the IDs which can be extracted somehow to the decryption key.
The possible values of the IDs are known, there is a predefined set (let's call them $ID_1,ID_2,...,ID_n$).
The business purpose is the following:
- I have 2 customers, where I know that customer1 is only allowed to see $ID_1$, therefore I create a key $k_1$ (and add the meta information $ID_1$).
- The second customer is allowed to see $ID_2$, $ID_3$ and $ID_5$ (therefore I create a special key $k_2$ for him).
- Both customers will get the same encrypted value e, and both can decrypt it but will get back a list of IDs, where every element is allowed to be extracted by that customer).
This was meant by: I add the IDs to the decryption key.
Some additional information:
- It's only one entity which is encrypting, don't need to decrypt with the secret key
- No need to check authenticity of the encrypted value (always trust)
- When creating keys, the actual IDs (Long values) which can be extracted can be added to the actual key.
Where to start? Has anybody an idea of a similar existing approach?