Seed password protected (#114)

rllola · web-flow · commit d1037bb7fad2 · 2020-04-14T13:03:31.000+02:00
* Support password for key_derive;
* Fix serde default
* FFI build fix
* Fix json rpc test
* Update documentation
* Added wasm tests and native tests;
* Fix FFI examples
diff --git a/docs/jsonrpc/api.md b/docs/jsonrpc/api.md
@@ -40,6 +40,7 @@ Derive a child key from a mnemonic following a [BIP44 path](https://github.com/b
 Arguments :
 * **mnemonic**: a string containing the words;
 * **path**: a BIP44 path;
+* **password (optional)**: for encrypted seed;
 
 ```javascript
 const axios = require("axios");
diff --git a/docs/native/api.md b/docs/native/api.md
@@ -20,6 +20,7 @@ Derive a child key from a mnemonic following a [BIP44 path](https://github.com/b
 Arguments :
 * **mnemonic**: a string containing the words;
 * **path**: a BIP44 path;
+* **password**: for encrypted seed if none use an empty string (e.g "")
 
 ```rust
 use signer::key_derive;
@@ -28,7 +29,7 @@ use bip39::{Mnemonic, MnemonicType, Language};
 let mnemonic = Mnemonic::new(MnemonicType::Words12, Language::English);
 let path = "m/44'/461'/0/0/1";
 
-let extended_key = key_derive(mnemonic.phrase(), path).unwrap();
+let extended_key = key_derive(mnemonic.phrase(), path, "").unwrap();
 
 println!("{:?}", extended_key);
 ```
diff --git a/docs/wasm/api.md b/docs/wasm/api.md
@@ -25,6 +25,7 @@ Derive a child key from a mnemonic following a [BIP44 path](https://github.com/b
 Arguments :
 * **mnemonic**: a string containing the words;
 * **path**: a BIP44 path;
+* **password**: for encrypted seed if none use an empty string (e.g "")
 
 ```javascript
 const signer_wasm = require('@zondax/filecoin-signer-wasm');
@@ -35,7 +36,7 @@ const mnemonic = "equip will roof matter pink blind book anxiety banner elbow su
 
 const path = "m/44'/461'/0/0/1";
 
-const keypair = signer_wasm.key_derive(mnemonic, path);
+const keypair = signer_wasm.key_derive(mnemonic, path, "");
 
 console.log(keypair);
 ```
diff --git a/examples/ffi/c++/main.cpp b/examples/ffi/c++/main.cpp
@@ -9,6 +9,7 @@ int main(int argc, char *argv[]) {
     ExtendedKey *extended_key = filecoin_signer_key_derive(
         "equip will roof matter pink blind book anxiety banner elbow sun young",
         "m/44'/461'/0/0/0",
+        "",
         error
     );
 
@@ -23,4 +24,4 @@ int main(int argc, char *argv[]) {
 
     filecoin_signer_extended_key_free(extended_key);
     filecoin_signer_error_free(error);
-}
+}
diff --git a/examples/ffi/c/main.c b/examples/ffi/c/main.c
@@ -9,6 +9,7 @@ int main(int argc, char *argv[]) {
     ExtendedKey *extended_key = filecoin_signer_key_derive(
         "equip will roof matter pink blind book anxiety banner elbow sun young",
         "m/44'/461'/0/0/0",
+        "",
         error
     );
 
@@ -23,4 +24,4 @@ int main(int argc, char *argv[]) {
 
     filecoin_signer_extended_key_free(extended_key);
     filecoin_signer_error_free(error);
-}
+}
diff --git a/examples/ffi/go/main.go b/examples/ffi/go/main.go
@@ -13,6 +13,7 @@ func main() {
 	extended_key := C.filecoin_signer_key_derive(
 		C.CString("equip will roof matter pink blind book anxiety banner elbow sun young"),
 		C.CString("m/44'/461'/0/0/0"),
+		C.CString(""),
 		error,
 	);
 
@@ -29,4 +30,4 @@ func main() {
 
 	C.filecoin_signer_extended_key_free(extended_key);
 	C.filecoin_signer_error_free(error);
-}
+}
diff --git a/examples/ffi/java/Main.java b/examples/ffi/java/Main.java
@@ -6,6 +6,7 @@ public static void main(String[] args) {
         long extendedKey = FilecoinSigner.keyDerive(
             "equip will roof matter pink blind book anxiety banner elbow sun young",
             "m/44'/461'/0/0/0",
+            "",
             error
         );
 
@@ -20,4 +21,4 @@ public static void main(String[] args) {
         FilecoinSigner.extendedKeyFree(extendedKey);
         FilecoinSigner.errorFree(error);
     }
-}
+}
diff --git a/examples/ffi/kotlin/Main.kt b/examples/ffi/kotlin/Main.kt
@@ -5,6 +5,7 @@ fun main() {
     var extendedKey = FilecoinSigner.keyDerive(
         "equip will roof matter pink blind book anxiety banner elbow sun young",
         "m/44'/461'/0/0/0",
+        "",
         error
     )
 
@@ -18,4 +19,4 @@ fun main() {
 
     FilecoinSigner.extendedKeyFree(extendedKey)
     FilecoinSigner.errorFree(error)
-}
+}
diff --git a/examples/ffi/objective-c/main.m b/examples/ffi/objective-c/main.m
@@ -9,6 +9,7 @@ int main(int argc, char *argv[]) {
     ExtendedKey *extended_key = filecoin_signer_key_derive(
         "equip will roof matter pink blind book anxiety banner elbow sun young",
         "m/44'/461'/0/0/0",
+        "",
         error
     );
 
@@ -26,4 +27,4 @@ int main(int argc, char *argv[]) {
 
     [pool drain];
     return 0;
-}
+}
diff --git a/examples/ffi/swift/main.swift b/examples/ffi/swift/main.swift
@@ -2,6 +2,7 @@ let error = filecoin_signer_error_new();
 let extended_key = filecoin_signer_key_derive(
     "equip will roof matter pink blind book anxiety banner elbow sun young",
     "m/44'/461'/0/0/0",
+    "",
     error
 );
 
@@ -16,4 +17,4 @@ else {
 }
 
 filecoin_signer_extended_key_free(extended_key);
-filecoin_signer_error_free(error);
+filecoin_signer_error_free(error);
diff --git a/examples/service_jsonrpc/tests/basic.ispec.js b/examples/service_jsonrpc/tests/basic.ispec.js
@@ -41,7 +41,7 @@ test("key_generate_mnemonic", async () => {
 
 test("key_derive", async () => {
   const path = "m/44'/461'/0/0/0";
-  const response = await callMethod(URL, "key_derive", [EXPECTED_MNEMONIC, path], 1);
+  const response = await callMethod(URL, "key_derive", [EXPECTED_MNEMONIC, path, ""], 1);
   const child = EXPECTED_ROOT_NODE.derivePath(path);
   console.log(response);
 
@@ -60,14 +60,34 @@ test("key_derive missing all parameters", async () => {
   expect(response.error.message).toMatch(/Invalid params/);
 });
 
-test("key_derive missing 1 parameters", async () => {
+test("key_derive missing path parameters", async () => {
   const response = await callMethod(URL, "key_derive", [EXPECTED_MNEMONIC], 1);
   console.log(response);
 
   expect(response).toHaveProperty("error");
   expect(response.error.message).toMatch(/Invalid params/);
 });
 
+test("key_derive invalid path parameter", async () => {
+  const response = await callMethod(URL, "key_derive", [EXPECTED_MNEMONIC, ""], 1);
+  console.log(response);
+
+  expect(response).toHaveProperty("error");
+  expect(response.error.message).toMatch(/Path should start with `m`/);
+});
+
+test("key_derive missing password parameter (verify default)", async () => {
+  const path = "m/44'/461'/0/0/0";
+  const response = await callMethod(URL, "key_derive", [EXPECTED_MNEMONIC, path], 1);
+  const child = EXPECTED_ROOT_NODE.derivePath(path);
+  console.log(response);
+
+  expect(response).toHaveProperty("result");
+  expect(response.result.private_hexstring).toEqual(child.privateKey.toString("hex"));
+  expect(response.result.public_compressed_hexstring).toEqual(child.publicKey.toString("hex"));
+  expect(response.result.address).toEqual("t1d2xrzcslx7xlbbylc5c3d5lvandqw4iwl6epxba");
+});
+
 test("key_derive_from_seed", async () => {
   const path = "m/44'/461'/0/0/0";
   const seed = bip39.mnemonicToSeedSync(EXPECTED_MNEMONIC).toString('hex');
diff --git a/examples/wasm_browser/index.js b/examples/wasm_browser/index.js
@@ -14,7 +14,7 @@ log("mnemonic");
 /////////////////////////////////
 // Derive key
 
-let key = wasm.key_derive(mnemonic, "m/44'/461'/0/0/0");
+let key = wasm.key_derive(mnemonic, "m/44'/461'/0/0/0", "");
 
 log("<h2>[wasm.key_derive]</h2>");
 log(`<b>address      </b> ${key.address}`);
diff --git a/examples/wasm_node/test/test.js b/examples/wasm_node/test/test.js
@@ -83,7 +83,7 @@ describe('Key generation / derivation', function () {
     });
 
     it('Key Derive', () => {
-        const keypair = signer_wasm.key_derive(EXAMPLE_MNEMONIC, "m/44'/461'/0/0/1");
+        const keypair = signer_wasm.key_derive(EXAMPLE_MNEMONIC, "m/44'/461'/0/0/1", "");
 
         console.log("Public Key Raw         :", keypair.public_raw);
         console.log("Public Key             :", keypair.public_hexstring);
@@ -96,6 +96,45 @@ describe('Key generation / derivation', function () {
         assert.strictEqual(keypair.address, "t1rovwtiuo5ncslpmpjftzu5akswbgsgighjazxoi");
     });
 
+    it('Key Derive with password', () => {
+        const keypair = signer_wasm.key_derive(EXAMPLE_MNEMONIC, "m/44'/461'/0/0/1", "password");
+
+        console.log("Public Key Raw         :", keypair.public_raw);
+        console.log("Public Key             :", keypair.public_hexstring);
+        console.log("Public Key Compressed  :", keypair.public_compressed_hexstring);
+        console.log("Private                :", keypair.private_hexstring);
+        console.log("Address                :", keypair.address);
+
+        const seed = bip39.mnemonicToSeedSync(EXAMPLE_MNEMONIC, "password");
+        const node = bip32.fromSeed(seed);
+
+        const expected_keys = node.derivePath("m/44'/461'/0/0/1");
+        assert.strictEqual(keypair.private_hexstring, expected_keys.privateKey.toString("hex"));
+    });
+
+    it('Key Derive with different password', () => {
+        const keypair = signer_wasm.key_derive(EXAMPLE_MNEMONIC, "m/44'/461'/0/0/1", "password");
+
+        console.log("Public Key Raw         :", keypair.public_raw);
+        console.log("Public Key             :", keypair.public_hexstring);
+        console.log("Public Key Compressed  :", keypair.public_compressed_hexstring);
+        console.log("Private                :", keypair.private_hexstring);
+        console.log("Address                :", keypair.address);
+
+        const seed = bip39.mnemonicToSeedSync(EXAMPLE_MNEMONIC, "lol");
+        const node = bip32.fromSeed(seed);
+
+        const expected_keys = node.derivePath("m/44'/461'/0/0/1");
+        assert.notEqual(keypair.private_hexstring, expected_keys.privateKey.toString("hex"));
+    });
+
+    it('Key Derive invalid paswword type (throw)', () => {
+      assert.throws(
+          () => signer_wasm.key_derive(EXAMPLE_MNEMONIC, "m/44'/461'/0/0/1", 123),
+          /Error/
+      );
+    });
+
     it('Key Derive From Seed', () => {
         const seed = bip39.mnemonicToSeedSync(EXAMPLE_MNEMONIC).toString('hex');
 
@@ -114,7 +153,7 @@ describe('Key generation / derivation', function () {
 
     it('Key Derive Invalid Path', () => {
         assert.throws(
-            () => signer_wasm.key_derive(EXAMPLE_MNEMONIC, "m/44'/461'/a/0/1"),
+            () => signer_wasm.key_derive(EXAMPLE_MNEMONIC, "m/44'/461'/a/0/1", ""),
             /Cannot parse integer/
         );
     });
diff --git a/service/src/service/methods.rs b/service/src/service/methods.rs
@@ -32,6 +32,8 @@ pub struct GetNonceParamsAPI {
 pub struct KeyDeriveParamsAPI {
     pub mnemonic: String,
     pub path: String,
+    #[serde(default)]
+    pub password: String,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -83,7 +85,8 @@ pub async fn key_generate_mnemonic(
 pub async fn key_derive(c: MethodCall, _: RemoteNodeSection) -> Result<Success, ServiceError> {
     let params = c.params.parse::<KeyDeriveParamsAPI>()?;
 
-    let key_address = filecoin_signer::key_derive(&params.mnemonic, &params.path)?;
+    let key_address =
+        filecoin_signer::key_derive(&params.mnemonic, &params.path, &params.password)?;
 
     let result = KeyDeriveResultAPI {
         public_hexstring: to_hex_string(&key_address.public_key.0),
diff --git a/signer-ffi/java/src/main/java/ch/zondax/FilecoinSigner.java b/signer-ffi/java/src/main/java/ch/zondax/FilecoinSigner.java
@@ -11,9 +11,9 @@ public class FilecoinSigner {
     public static native String extendedKeyPublicKeyCompressed(long ptr);
     public static native void extendedKeyFree(long ptr);
 
-    public static native long keyDerive(String mnemonic, String path, long ptr);
+    public static native long keyDerive(String mnemonic, String path, String password, long ptr);
 
     static {
         System.loadLibrary("filecoin_signer_ffi");
     }
-}
+}
diff --git a/signer-ffi/src/lib.rs b/signer-ffi/src/lib.rs
@@ -10,10 +10,11 @@ use filecoin_signer::{key_derive, ExtendedKey};
 create_fn!(filecoin_signer_key_derive|Java_ch_zondax_FilecoinSigner_keyDerive: (
     mnemonic: str_arg_ty!(),
     path: str_arg_ty!(),
+    password: str_arg_ty!(),
     error: &mut ExternError
 ) -> ptr!(ExtendedKey), |etc| {
     call_with_result(error, || -> Result<ExtendedKey, ExternError> {
-        Ok(key_derive(get_str!(etc, mnemonic), get_str!(etc, path))?)
+        Ok(key_derive(get_str!(etc, mnemonic), get_str!(etc, path), get_str!(etc, password))?)
     })
 });
 
diff --git a/signer-wasm/src/lib.rs b/signer-wasm/src/lib.rs
@@ -75,10 +75,14 @@ pub fn mnemonic_generate() -> Result<String, JsValue> {
 }
 
 #[wasm_bindgen]
-pub fn key_derive(mnemonic: String, path: String) -> Result<ExtendedKey, JsValue> {
+pub fn key_derive(
+    mnemonic: String,
+    path: String,
+    password: String,
+) -> Result<ExtendedKey, JsValue> {
     set_panic_hook();
 
-    let key_address = filecoin_signer::key_derive(&mnemonic, &path)
+    let key_address = filecoin_signer::key_derive(&mnemonic, &path, &password)
         .map_err(|e| JsValue::from(format!("Error deriving key: {}", e)))?;
 
     Ok(ExtendedKey { 0: key_address })
diff --git a/signer-wasm/tests/browser.rs b/signer-wasm/tests/browser.rs
@@ -26,7 +26,8 @@ fn key_derive() {
 
     let path = "m/44'/461'/0/0/1".to_string();
 
-    let answer = filecoin_signer_wasm::key_derive(mnemonic, path).expect("unexpected error");
+    let answer =
+        filecoin_signer_wasm::key_derive(mnemonic, path, "".to_string()).expect("unexpected error");
 
     assert_eq!(
         answer.public_compressed_hexstring(),
diff --git a/signer/src/lib.rs b/signer/src/lib.rs
@@ -108,17 +108,18 @@ pub fn key_generate_mnemonic() -> Result<Mnemonic, SignerError> {
     Ok(Mnemonic(mnemonic.to_string()))
 }
 
-/// Returns a public key, private key and address given a mnemonic and derivation path
+/// Returns a public key, private key and address given a mnemonic, derivation path and a password
 ///
 /// # Arguments
 ///
 /// * `mnemonic` - A string containing a 24-words English mnemonic
 /// * `path` - A string containing a derivation path
-pub fn key_derive(mnemonic: &str, path: &str) -> Result<ExtendedKey, SignerError> {
+/// * `password` - Password to decrypt seed, if none use and empty string (e.g "")
+pub fn key_derive(mnemonic: &str, path: &str, password: &str) -> Result<ExtendedKey, SignerError> {
     let mnemonic = bip39::Mnemonic::from_phrase(&mnemonic, Language::English)
         .map_err(|err| SignerError::GenericString(err.to_string()))?;
 
-    let seed = Seed::new(&mnemonic, "");
+    let seed = Seed::new(&mnemonic, password);
 
     let master = ExtendedSecretKey::try_from(seed.as_bytes())?;
 
@@ -388,14 +389,33 @@ mod tests {
     fn derive_key() {
         let mnemonic = "equip will roof matter pink blind book anxiety banner elbow sun young";
 
-        let extended_key = key_derive(mnemonic, "m/44'/461'/0/0/0").unwrap();
+        let extended_key = key_derive(mnemonic, "m/44'/461'/0/0/0", "").unwrap();
 
         assert_eq!(
             to_hex_string(&extended_key.private_key.0),
             EXAMPLE_PRIVATE_KEY
         );
     }
 
+    #[test]
+    fn derive_key_password() {
+        let mnemonic = "equip will roof matter pink blind book anxiety banner elbow sun young";
+
+        let m = bip39::Mnemonic::from_phrase(&mnemonic.to_string(), Language::English).unwrap();
+
+        let seed = Seed::new(&m, "password");
+
+        let extended_key_expected =
+            key_derive_from_seed(seed.as_bytes(), "m/44'/461'/0/0/0").unwrap();
+
+        let extended_key = key_derive(mnemonic, "m/44'/461'/0/0/0", "password").unwrap();
+
+        assert_eq!(
+            to_hex_string(&extended_key.private_key.0),
+            to_hex_string(&extended_key_expected.private_key.0)
+        );
+    }
+
     #[test]
     fn derive_key_from_seed() {
         let mnemonic = Mnemonic(
