Add Diffie-Hellman key exchange for encryption to Account

bindings/stronghold-nodejs/examples/src/tests/key_exchange.ts

@@ -0,0 +1,9 @@
+import { keyExchange } from "../../../../wasm/examples-account/src/key_exchange";
+import { stronghold } from '../stronghold';
+
+// Only verifies that no uncaught exceptions are thrown, including syntax errors etc.
+describe("Test Stronghold Node.js examples", function () {
+    it("Key Exchange", async () => {
+        await keyExchange(await stronghold());
+    });
+})

bindings/stronghold-nodejs/js/stronghold.ts

@@ -1,5 +1,5 @@
-import { NapiStronghold, NapiDID, NapiKeyLocation, NapiChainState, NapiDocument, NapiKeyType, NapiDidLocation } from '../napi-dist/napi';
-import { DID, KeyLocation, Signature, ChainState, Storage, KeyType, Document } from "@iota/identity-wasm/node";
+import { NapiStronghold, NapiDID, NapiKeyLocation, NapiChainState, NapiDocument, NapiKeyType, NapiDidLocation, NapiEncryptedData, NapiEncryptionAlgorithm } from '../napi-dist/napi';
+import { DID, KeyLocation, Signature, ChainState, Storage, KeyType, Document, EncryptedData, EncryptionAlgorithm } from "@iota/identity-wasm/node";
 
 export class Stronghold implements Storage {
     private napiStronghold: NapiStronghold;
@@ -97,6 +97,31 @@ export class Stronghold implements Storage {
         return Signature.fromJSON(napiSignature.toJSON());
     }
 
+    public async encryptData(did: DID, data: Uint8Array, associatedData: Uint8Array, algorithm: EncryptionAlgorithm, privateKey: KeyLocation, publicKey?: Uint8Array): Promise<EncryptedData> {
+        const napiDID: NapiDID = NapiDID.fromJSON(did.toJSON());
+        const napiPrivateKeyLocation = NapiKeyLocation.fromJSON(privateKey.toJSON());
+        const napiAlgorithm = NapiEncryptionAlgorithm.fromJSON(algorithm.toJSON());
+        let optPublicKey = undefined;
+        if (publicKey) {
+            optPublicKey = Array.from(publicKey)
+        }
+        const napiEncryptedData = await this.napiStronghold.encryptData(napiDID, Array.from(data), Array.from(associatedData),  napiAlgorithm, napiPrivateKeyLocation, Array.from(optPublicKey));
+        return EncryptedData.fromJSON(napiEncryptedData.toJSON());
+    }
+
+    public async decryptData(did: DID, data: EncryptedData, algorithm: EncryptionAlgorithm, privateKey: KeyLocation, publicKey?: Uint8Array): Promise<Uint8Array> {
+        const napiDID: NapiDID = NapiDID.fromJSON(did.toJSON());
+        const napiPrivateKeyLocation = NapiKeyLocation.fromJSON(privateKey.toJSON());
+        const napiAlgorithm = NapiEncryptionAlgorithm.fromJSON(algorithm.toJSON());
+        const napiEncryptedData = NapiEncryptedData.fromJSON(data.toJSON());
+        let optPublicKey = undefined;
+        if (publicKey) {
+            optPublicKey = Array.from(publicKey)
+        }
+        const decryptedData = await this.napiStronghold.decryptData(napiDID, napiEncryptedData, napiAlgorithm, napiPrivateKeyLocation, optPublicKey);
+        return Uint8Array.from(decryptedData);
+    }
+
     public async chainStateGet(did: DID): Promise<ChainState | undefined> {
         const napiDID: NapiDID = NapiDID.fromJSON(did.toJSON());
         const napiChainState: NapiChainState | undefined = await this.napiStronghold.chainStateGet(napiDID);

bindings/stronghold-nodejs/src/account/storage/stronghold.rs

@@ -3,6 +3,7 @@
 
 use identity_account_storage::storage::Storage;
 use identity_account_storage::storage::Stronghold;
+use identity_account_storage::types::EncryptedData;
 use identity_account_storage::types::KeyLocation;
 use identity_core::crypto::PrivateKey;
 use identity_core::crypto::PublicKey;
@@ -13,6 +14,8 @@ use napi::Result;
 use napi_derive::napi;
 
 use crate::account::identity::NapiDidLocation;
+use crate::account::types::NapiEncryptedData;
+use crate::account::types::NapiEncryptionAlgorithm;
 use crate::account::types::NapiKeyType;
 use crate::account::NapiChainState;
 use crate::account::NapiDocument;
@@ -175,6 +178,64 @@ impl NapiStronghold {
     self.0.key_exists(&did.0, &location.0).await.napi_result()
   }
 
+  /// Encrypts the given `data` with the specified `algorithm`
+  ///
+  /// Diffie-Helman key exchange will be performed in case an [`KeyType::X25519`] is given.
+  #[napi]
+  pub async fn encrypt_data(
+    &self,
+    did: &NapiDID,
+    data: Vec<u32>,
+    associated_data: Vec<u32>,
+    algorithm: &NapiEncryptionAlgorithm,
+    private_key: &NapiKeyLocation,
+    public_key: Option<Vec<u32>>,
+  ) -> Result<NapiEncryptedData> {
+    let public_key: Option<Vec<u8>> = public_key.map(|key| key.try_into_bytes()).transpose()?;
+    let data: Vec<u8> = data.try_into_bytes()?;
+    let associated_data: Vec<u8> = associated_data.try_into_bytes()?;
+    let encrypted_data: EncryptedData = self
+      .0
+      .encrypt_data(
+        &did.0,
+        data,
+        associated_data,
+        &algorithm.0,
+        &private_key.0,
+        public_key.map(|key| key.into()),
+      )
+      .await
+      .napi_result()?;
+    Ok(NapiEncryptedData(encrypted_data))
+  }
+
+  /// Decrypts the given `data` with the specified `algorithm`
+  ///
+  /// Diffie-Helman key exchange will be performed in case an [`KeyType::X25519`] is given.
+  #[napi]
+  pub async fn decrypt_data(
+    &self,
+    did: &NapiDID,
+    data: &NapiEncryptedData,
+    algorithm: &NapiEncryptionAlgorithm,
+    private_key: &NapiKeyLocation,
+    public_key: Option<Vec<u32>>,
+  ) -> Result<Vec<u32>> {
+    let public_key: Option<Vec<u8>> = public_key.map(|key| key.try_into_bytes()).transpose()?;
+    let data: Vec<u8> = self
+      .0
+      .decrypt_data(
+        &did.0,
+        data.0.clone(),
+        &algorithm.0,
+        &private_key.0,
+        public_key.map(|key| key.into()),
+      )
+      .await
+      .napi_result()?;
+    Ok(data.into_iter().map(u32::from).collect())
+  }
+
   /// Returns the chain state of the identity specified by `did`.
   #[napi]
   pub async fn chain_state_get(&self, did: &NapiDID) -> Result<Option<NapiChainState>> {

bindings/stronghold-nodejs/src/account/types/encrypted_data.rs

@@ -0,0 +1,24 @@
+// Copyright 2020-2022 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use identity_account_storage::types::EncryptedData;
+use napi::Result;
+use napi_derive::napi;
+
+use crate::error::NapiResult;
+
+#[napi]
+pub struct NapiEncryptedData(pub(crate) EncryptedData);
+
+#[napi]
+impl NapiEncryptedData {
+  #[napi(js_name = fromJSON)]
+  pub fn from_json(json_value: serde_json::Value) -> Result<NapiEncryptedData> {
+    serde_json::from_value(json_value).map(Self).napi_result()
+  }
+
+  #[napi(js_name = toJSON)]
+  pub fn to_json(&self) -> Result<serde_json::Value> {
+    serde_json::to_value(&self.0).napi_result()
+  }
+}

bindings/stronghold-nodejs/src/account/types/encryption_algorithm.rs

@@ -0,0 +1,24 @@
+// Copyright 2020-2022 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use identity_account_storage::types::EncryptionAlgorithm;
+use napi::Result;
+use napi_derive::napi;
+
+use crate::error::NapiResult;
+
+#[napi]
+pub struct NapiEncryptionAlgorithm(pub(crate) EncryptionAlgorithm);
+
+#[napi]
+impl NapiEncryptionAlgorithm {
+  #[napi(js_name = fromJSON)]
+  pub fn from_json(json_value: serde_json::Value) -> Result<NapiEncryptionAlgorithm> {
+    serde_json::from_value(json_value).map(Self).napi_result()
+  }
+
+  #[napi(js_name = toJSON)]
+  pub fn to_json(&self) -> Result<serde_json::Value> {
+    serde_json::to_value(&self.0).napi_result()
+  }
+}

bindings/stronghold-nodejs/src/account/types/mod.rs

@@ -1,10 +1,14 @@
 // Copyright 2020-2022 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
+pub use encrypted_data::NapiEncryptedData;
+pub use encryption_algorithm::NapiEncryptionAlgorithm;
 pub use key_location::NapiKeyLocation;
 pub use key_type::NapiKeyType;
 pub use signature::NapiSignature;
 
+mod encrypted_data;
+mod encryption_algorithm;
 mod key_location;
 mod key_type;
 mod signature;