Cryptoshredding is a well-known technique to 'erase' encrypted data by throwing away the key necessary for decryption. Two out of numerous advantages are

• You do not have to actually remove (or update) data, so that it can be immutable
• You don't have to keep track of where it is used, as long as it stays encrypted

see https://en.wikipedia.org/wiki/Crypto-shredding

In order to make use of that technique, you need to encrypt data before writing in the first place and maintain keys for the subjects. This is what cryptoshred can do for you.

• Pluggable Metrics interface
  • optional Micrometer impl.
• Pluggable CryptoEngine
  • JDK-based impl.
• Pluggable Key Repository
  • optional Amazon DynamoDB impl.
• optional Spring-Boot autoconfiguration module
• Jackson based deserialization to Java Objects
• Evolutionary approach to key definition creation and migration

In order to encrypt a particular piece of data, you wrap it in a CryptoContainer before persisting (serializing).

@Data
public class Person { // might be an Enitity, a POJO you serialize or anything you want to persist
  int age;
  CryptoContainer<String> name;
}

In order to wrap the data you'll also need to provide a 'CryptoSubjectId', that references the actual key, that you'd want to throw away in order to do the 'deletion' afterwards)

CryptoSubjectId id = CryptoSubjectId.of(UUID.randomUUID()); // simple value object

Person p = new Person();
p.name = new CryptoContainer<>("Peter", id);
p.age = 30;

// go persist the Person

A CryptoContainer consists of the following data:

• SubjectId (which is associated to the actual key used for en/de-cryption)
• Algorithm used
• KeySize used
• Type of Object // String in this example
• Encoded byte array of the serialized form of the Object wrapped.

You can wrap any Jackson-serializable object like for instance

CryptoKeyRepository repo = new InMemCryptoKeyRepository(engine); // don't do this at home
ObjectMapper om = new ObjectMapper();
om.registerModule(new CryptoModule(engine,repo)); // not needed when using Spring Boot autoconfiguration

CryptoSubjectId id = CryptoSubjectId.of(UUID.randomUUID()); // simple value object, you would want to use a userId for that, and not a silly random.

Person p = new Person();
p.name = new CryptoContainer<>("Peter", id);
p.age = 30;
p.creditcard = new CryptoContainer<>(new CreditCardInfo("12341234",CrediCardTypes.VISA),id);
// go persist the Person

When using ObjectMapper to deserialize a 'CryptoContainer', all necessary dependencies are injected into the Container automatically, so you can use the 'CryptoContainer' just like an Optional (it copied all the methods from 'java.util.Optional').

String json = om.writeValueAsString(p);

Person p2 = om.readValue(json, Person.class);
assertTrue(p2.name.isPresent());
assertEquals("Peter",p2.name.get());

// if you deleted the key in between, name.isPresent() would be false.
// of course you should rather use p2.name.orElse("unknown") or something rather than get, but you know all that from using Optional...