Implement hybrid root of trust

[ghost]

To avoid any scalability issue and throughput improvements, we have to implement a new scheme for node cryptography where hardware keys are use for the node transaction chain but still using software keys to support fast signing and decryption.

So a node transaction will be build with:

previous_public_key: software key
previous_signature: software key
origin_signature: hardware key if possible
transaction's content: origin public key + certificate of the origin public key

Then we should:

• [x] Embed the origin public key and its certificate inside the transaction's content
• [x] Sign the transaction (origin signature) with the origin private key
• [x] The proof of work algorithm should verify the origin signature with public key from the content
• [x] Add a new field in the node struct and mem table to inject the origin public key as attestation key
• [x] For any other network transaction, the origin signature should be check among the list of attestation key of the nodes
• [x] Complete use of software key for signing and decryption messages
• [x] Avoid as much as possible the bottleneck (maybe remove GenServer and keep ETS table) for signing and decryption
• [x] Test with TPM implementation
• [x] Stress test

[internet-zero]

Hey team! Please add your planning poker estimate with ZenHub @apoorv-2204 @blackode @imnik11 @roychowdhuryrohit-dev @samuel-uniris

[ghost]

example of stress test done with benchee:

Archethic.Crypto.NodeKeystore.Origin.TPMImpl.start_link()
Archethic.Crypto.NodeKeystore.SoftwareImpl.start_link()

# Benchmarks with sequential calls for both software and hardware keys
Benchee.run(%{
  "sign with origin key" => fn data ->
    Archethic.Crypto.NodeKeystore.Origin.TPMImpl.sign_with_origin_key(data)
  end,
  "sign with software key" => fn data ->
    Archethic.Crypto.NodeKeystore.SoftwareImpl.sign_with_last_key(data)
  end
}, inputs: %{
  "with hash of 256bits" => :crypto.strong_rand_bytes(32)
})

# Benchmarks with parallel calls for both software and hardware keys
Benchee.run(%{
  "sign with origin key" => fn data ->
    Archethic.Crypto.NodeKeystore.Origin.TPMImpl.sign_with_origin_key(data)
  end,
  "sign with software key" => fn data ->
    Archethic.Crypto.NodeKeystore.SoftwareImpl.sign_with_last_key(data)
  end
}, inputs: %{
  "with hash of 256bits" => :crypto.strong_rand_bytes(32)
}, parallel: System.schedulers_online())

# Benchmarks with high parallelism for software keys
Benchee.run(%{
  "sign with software key" => fn data ->
     Archethic.Crypto.NodeKeystore.SoftwareImpl.sign_with_last_key(data)
  end
}, inputs: %{
  "with hash of 256bits" => :crypto.strong_rand_bytes(32)
}, parallel: System.schedulers_online() * 4)