hsms | JavaScript driver for HSMS protocol | Networking library

a) This is incorrect, it can be configured to use 128/256 bit keys. Docs should be updated soon to reflect this.

b) In general when the rotate_universe_key_in_memory yb-admin command is run, only newly-written data files utilize the universe key that was rotated to (whether on enabling encryption at rest for the first time, or any subsequent key rotations). All previously existing data files still have a reference to the universe key that had been the current key when the files had been written, and the files continue to use their respective universe keys until they are flushed or compacted at which point the newly-written files will use the current universe key. So no, there is no tablet-wide decryption happening every time a key rotation occurs, and the time it takes for all data files to be using the current universe key is dependent on the write workload on the given universe.

c) Right now the Yugabyte yb-admin commands only support reading in a universe key from the contents of a file on disk for encryption at rest. Important to note that the key only needs to be persisted on disk up to the point of it being loaded into memory with add_universe_key_to_all_masters. After this, the key file can be moved from the master node and stored remotely elsewhere. Only other time this key file will be required to re-upload the key into memory is if all masters simultaneously go down. The Yugabyte Platform (https://www.yugabyte.com/platform/) offers integration support for AWS KMS that uses a CMK to generate universe keys (and you can use an AWS CloudHSM as a HSM custom key store for your AWS KMS CMK) as well as integration support for Equinix SmartKey; so this might fit your use case?

If all you need is to re-encrypt the same secret under a different key, you can use C_Unwrap to create a temporal HSM object with value of the translated secret and then use C_Wrap to encrypt the value of this temporal HSM object for all the recipients.

This way the secret will never leave HSM.

Something like this (verified to be working on SafeNet Luna 7 with RSA-OAEP):

CloudHSM is currently not supported by CloudFormation.
You can find a list of supported services and ressource types here.

I would like to know whether the code written using Pkcs11Interop should check which HSM is active then send requests to active HSM OR the secure world software installed on the server should check the active HSM before opening active connection

IMO you should first ask Thales support whether their PKCS#11 library can perform automatic failover. If their answer is yes then you don't need to add any failover related code into your application.

It's just about nesting. An HSM is basically an FSM, but where each state in turn can be a separate FSM.

For an example in a game, consider an NPC. It has multiple states:

1. Walk to point A
2. Wait a minute
3. Walk to point B
4. Wait a minute
5. Continue from 1
6. Fighting with PC

This FSM is simple, but all states needs to have a transition to state 6 (Fighting with PC) for when the NPC is attacked by a PC. This makes the FSM kind of ugly. So instead lets have this much more simple FSM:

1. Walking about
2. Fighting with PC

This FSM is very simple, there's only two transitions, and it's easy to understand. The major parts of state 1 is then a secondary FSM:

1. Walk to point A
2. Wait a minute
3. Walk to point B
4. Wait a minute

If there's an event which doesn't match the secondary FSM transitions, like a PC attacking, you go up a level to the top-level FSM to match the event and find a suitable transition.

You could in a way think about it as a stack, each state in a higher level could push a new lower-level FSM. If there's an even that doesn't match any possible transitions, pop the stack and go back up a level. Continue until there's a matching transition.

In short, it's a way to simplify an FSM.

Access to a HSM is timebound. If you lose your keys, anybody that has them can encrypt/decrypt data, produce signatures or perform any other cryptography as long as they want. Of course you can revoke a certificate, but that does not affect a key in many cases (for example it is still good for decryption after certificate revocation).

If you use a HSM, when you discover access compromise, you can disable the attacker's access to the HSM very quickly, and no further data is compromised. Of course the attacker can fully use your keys as long as they have access to the HSM, but not afterwards.

Also securing and equally importantly, auditing access to a HSM is much easier than to a key stored somewhere else. As a key never leaves a HSM, you don't have to care about auditing things like copied key usage (practically impossible) - you have information on exactly who accessed what key, for what purpose. You can grant and revoke such access at will.

A HSM usually provides other aspects of key management as well, for example key distribution may become much easier.

So yes, of course you still need to guard access to the HSM and contained keys. But for the reasons above, it still makes key management much more secure if used properly.

You are most likely not using PKCS#11 library and PKCS#11 sessions in multi-threaded environment correctly. See my older answer to similar question for more details.