@ledgerhq/hw-app-str 6.24.1 → 6.25.1-alpha.3

package/lib-es/Str.js.flow

@@ -0,0 +1,316 @@
+/********************************************************************************
+ *   Ledger Node JS API
+ *   (c) 2017-2018 Ledger
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ ********************************************************************************/
+//@flow
+
+import type Transport from "@ledgerhq/hw-transport";
+import {
+  splitPath,
+  foreach,
+  encodeEd25519PublicKey,
+  verifyEd25519Signature,
+  checkStellarBip32Path,
+  hash,
+} from "./utils";
+
+const CLA = 0xe0;
+const INS_GET_PK = 0x02;
+const INS_SIGN_TX = 0x04;
+const INS_GET_CONF = 0x06;
+const INS_SIGN_TX_HASH = 0x08;
+const INS_KEEP_ALIVE = 0x10;
+
+const APDU_MAX_SIZE = 150;
+const P1_FIRST_APDU = 0x00;
+const P1_MORE_APDU = 0x80;
+const P2_LAST_APDU = 0x00;
+const P2_MORE_APDU = 0x80;
+
+const SW_OK = 0x9000;
+const SW_CANCEL = 0x6985;
+const SW_UNKNOWN_OP = 0x6c24;
+const SW_MULTI_OP = 0x6c25;
+const SW_NOT_ALLOWED = 0x6c66;
+const SW_UNSUPPORTED = 0x6d00;
+const SW_KEEP_ALIVE = 0x6e02;
+
+const TX_MAX_SIZE = 1540;
+
+/**
+ * Stellar API
+ *
+ * @example
+ * import Str from "@ledgerhq/hw-app-str";
+ * const str = new Str(transport)
+ */
+export default class Str {
+  transport: Transport<*>;
+
+  constructor(transport: Transport<*>, scrambleKey: string = "l0v") {
+    this.transport = transport;
+    transport.decorateAppAPIMethods(
+      this,
+      ["getAppConfiguration", "getPublicKey", "signTransaction", "signHash"],
+      scrambleKey
+    );
+  }
+
+  getAppConfiguration(): Promise<{
+    version: string,
+  }> {
+    return this.transport
+      .send(CLA, INS_GET_CONF, 0x00, 0x00)
+      .then((response) => {
+        let multiOpsEnabled = response[0] === 0x01 || response[1] < 0x02;
+        let version = "" + response[1] + "." + response[2] + "." + response[3];
+        return {
+          version: version,
+          multiOpsEnabled: multiOpsEnabled,
+        };
+      });
+  }
+
+  /**
+   * get Stellar public key for a given BIP 32 path.
+   * @param path a path in BIP 32 format
+   * @option boolValidate optionally enable key pair validation
+   * @option boolDisplay optionally enable or not the display
+   * @return an object with the publicKey (using XLM public key format) and
+   * the raw ed25519 public key.
+   * @example
+   * str.getPublicKey("44'/148'/0'").then(o => o.publicKey)
+   */
+  getPublicKey(
+    path: string,
+    boolValidate?: boolean,
+    boolDisplay?: boolean
+  ): Promise<{ publicKey: string, raw: Buffer }> {
+    checkStellarBip32Path(path);
+
+    let apdus = [];
+    let response;
+
+    let pathElts = splitPath(path);
+    let buffer = Buffer.alloc(1 + pathElts.length * 4);
+    buffer[0] = pathElts.length;
+    pathElts.forEach((element, index) => {
+      buffer.writeUInt32BE(element, 1 + 4 * index);
+    });
+    let verifyMsg = Buffer.from("via lumina", "ascii");
+    apdus.push(Buffer.concat([buffer, verifyMsg]));
+    let keepAlive = false;
+    return foreach(apdus, (data) =>
+      this.transport
+        .send(
+          CLA,
+          keepAlive ? INS_KEEP_ALIVE : INS_GET_PK,
+          boolValidate ? 0x01 : 0x00,
+          boolDisplay ? 0x01 : 0x00,
+          data,
+          [SW_OK, SW_KEEP_ALIVE]
+        )
+        .then((apduResponse) => {
+          let status = Buffer.from(
+            apduResponse.slice(apduResponse.length - 2)
+          ).readUInt16BE(0);
+          if (status === SW_KEEP_ALIVE) {
+            keepAlive = true;
+            apdus.push(Buffer.alloc(0));
+          }
+          response = apduResponse;
+        })
+    ).then(() => {
+      // response = Buffer.from(response, 'hex');
+      let offset = 0;
+      let rawPublicKey = response.slice(offset, offset + 32);
+      offset += 32;
+      let publicKey = encodeEd25519PublicKey(rawPublicKey);
+      if (boolValidate) {
+        let signature = response.slice(offset, offset + 64);
+        if (!verifyEd25519Signature(verifyMsg, signature, rawPublicKey)) {
+          throw new Error(
+            "Bad signature. Keypair is invalid. Please report this."
+          );
+        }
+      }
+      return {
+        publicKey: publicKey,
+        raw: rawPublicKey,
+      };
+    });
+  }
+
+  /**
+   * sign a Stellar transaction.
+   * @param path a path in BIP 32 format
+   * @param transaction signature base of the transaction to sign
+   * @return an object with the signature and the status
+   * @example
+   * str.signTransaction("44'/148'/0'", signatureBase).then(o => o.signature)
+   */
+  signTransaction(
+    path: string,
+    transaction: Buffer
+  ): Promise<{ signature: Buffer }> {
+    checkStellarBip32Path(path);
+
+    if (transaction.length > TX_MAX_SIZE) {
+      throw new Error(
+        "Transaction too large: max = " +
+          TX_MAX_SIZE +
+          "; actual = " +
+          transaction.length
+      );
+    }
+
+    let apdus = [];
+    let response;
+
+    let pathElts = splitPath(path);
+    let bufferSize = 1 + pathElts.length * 4;
+    let buffer = Buffer.alloc(bufferSize);
+    buffer[0] = pathElts.length;
+    pathElts.forEach(function (element, index) {
+      buffer.writeUInt32BE(element, 1 + 4 * index);
+    });
+    let chunkSize = APDU_MAX_SIZE - bufferSize;
+    if (transaction.length <= chunkSize) {
+      // it fits in a single apdu
+      apdus.push(Buffer.concat([buffer, transaction]));
+    } else {
+      // we need to send multiple apdus to transmit the entire transaction
+      let chunk = Buffer.alloc(chunkSize);
+      let offset = 0;
+      transaction.copy(chunk, 0, offset, chunkSize);
+      apdus.push(Buffer.concat([buffer, chunk]));
+      offset += chunkSize;
+      while (offset < transaction.length) {
+        let remaining = transaction.length - offset;
+        chunkSize = remaining < APDU_MAX_SIZE ? remaining : APDU_MAX_SIZE;
+        chunk = Buffer.alloc(chunkSize);
+        transaction.copy(chunk, 0, offset, offset + chunkSize);
+        offset += chunkSize;
+        apdus.push(chunk);
+      }
+    }
+    let keepAlive = false;
+    return foreach(apdus, (data, i) =>
+      this.transport
+        .send(
+          CLA,
+          keepAlive ? INS_KEEP_ALIVE : INS_SIGN_TX,
+          i === 0 ? P1_FIRST_APDU : P1_MORE_APDU,
+          i === apdus.length - 1 ? P2_LAST_APDU : P2_MORE_APDU,
+          data,
+          [SW_OK, SW_CANCEL, SW_UNKNOWN_OP, SW_MULTI_OP, SW_KEEP_ALIVE]
+        )
+        .then((apduResponse) => {
+          let status = Buffer.from(
+            apduResponse.slice(apduResponse.length - 2)
+          ).readUInt16BE(0);
+          if (status === SW_KEEP_ALIVE) {
+            keepAlive = true;
+            apdus.push(Buffer.alloc(0));
+          }
+          response = apduResponse;
+        })
+    ).then(() => {
+      let status = Buffer.from(
+        response.slice(response.length - 2)
+      ).readUInt16BE(0);
+      if (status === SW_OK) {
+        let signature = Buffer.from(response.slice(0, response.length - 2));
+        return {
+          signature: signature,
+        };
+      } else if (status === SW_UNKNOWN_OP) {
+        // pre-v2 app version: fall back on hash signing
+        return this.signHash_private(path, hash(transaction));
+      } else if (status === SW_MULTI_OP) {
+        // multi-operation transaction: attempt hash signing
+        return this.signHash_private(path, hash(transaction));
+      } else {
+        throw new Error("Transaction approval request was rejected");
+      }
+    });
+  }
+
+  /**
+   * sign a Stellar transaction hash.
+   * @param path a path in BIP 32 format
+   * @param hash hash of the transaction to sign
+   * @return an object with the signature
+   * @example
+   * str.signHash("44'/148'/0'", hash).then(o => o.signature)
+   */
+  signHash(path: string, hash: Buffer): Promise<{ signature: Buffer }> {
+    checkStellarBip32Path(path);
+    return this.signHash_private(path, hash);
+  }
+
+  signHash_private(path: string, hash: Buffer): Promise<{ signature: Buffer }> {
+    let apdus = [];
+    let response;
+
+    let pathElts = splitPath(path);
+    let buffer = Buffer.alloc(1 + pathElts.length * 4);
+    buffer[0] = pathElts.length;
+    pathElts.forEach(function (element, index) {
+      buffer.writeUInt32BE(element, 1 + 4 * index);
+    });
+    apdus.push(Buffer.concat([buffer, hash]));
+    let keepAlive = false;
+    return foreach(apdus, (data) =>
+      this.transport
+        .send(
+          CLA,
+          keepAlive ? INS_KEEP_ALIVE : INS_SIGN_TX_HASH,
+          0x00,
+          0x00,
+          data,
+          [SW_OK, SW_CANCEL, SW_NOT_ALLOWED, SW_UNSUPPORTED, SW_KEEP_ALIVE]
+        )
+        .then((apduResponse) => {
+          let status = Buffer.from(
+            apduResponse.slice(apduResponse.length - 2)
+          ).readUInt16BE(0);
+          if (status === SW_KEEP_ALIVE) {
+            keepAlive = true;
+            apdus.push(Buffer.alloc(0));
+          }
+          response = apduResponse;
+        })
+    ).then(() => {
+      let status = Buffer.from(
+        response.slice(response.length - 2)
+      ).readUInt16BE(0);
+      if (status === SW_OK) {
+        let signature = Buffer.from(response.slice(0, response.length - 2));
+        return {
+          signature: signature,
+        };
+      } else if (status === SW_CANCEL) {
+        throw new Error("Transaction approval request was rejected");
+      } else if (status === SW_UNSUPPORTED) {
+        throw new Error("Hash signing is not supported");
+      } else {
+        throw new Error(
+          "Hash signing not allowed. Have you enabled it in the app settings?"
+        );
+      }
+    });
+  }
+}

package/lib-es/utils.js.flow

@@ -0,0 +1,116 @@
+/********************************************************************************
+ *   Ledger Node JS API
+ *   (c) 2017-2018 Ledger
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ ********************************************************************************/
+//@flow
+
+import base32 from "base32.js";
+import nacl from "tweetnacl";
+import { sha256 } from "sha.js";
+
+// TODO use bip32-path library
+export function splitPath(path: string): number[] {
+  let result = [];
+  let components = path.split("/");
+  components.forEach((element) => {
+    let number = parseInt(element, 10);
+    if (isNaN(number)) {
+      return; // FIXME shouldn't it throws instead?
+    }
+    if (element.length > 1 && element[element.length - 1] === "'") {
+      number += 0x80000000;
+    }
+    result.push(number);
+  });
+  return result;
+}
+
+export function foreach<T, A>(
+  arr: T[],
+  callback: (T, number) => Promise<A>
+): Promise<A[]> {
+  function iterate(index, array, result) {
+    if (index >= array.length) {
+      return result;
+    } else {
+      return callback(array[index], index).then(function (res) {
+        result.push(res);
+        return iterate(index + 1, array, result);
+      });
+    }
+  }
+  return Promise.resolve().then(() => iterate(0, arr, []));
+}
+
+export function crc16xmodem(buf: Buffer, previous?: number): number {
+  let crc = typeof previous !== "undefined" ? ~~previous : 0x0;
+
+  for (var index = 0; index < buf.length; index++) {
+    const byte = buf[index];
+    let code = (crc >>> 8) & 0xff;
+
+    code ^= byte & 0xff;
+    code ^= code >>> 4;
+    crc = (crc << 8) & 0xffff;
+    crc ^= code;
+    code = (code << 5) & 0xffff;
+    crc ^= code;
+    code = (code << 7) & 0xffff;
+    crc ^= code;
+  }
+
+  return crc;
+}
+
+export function encodeEd25519PublicKey(rawPublicKey: Buffer): string {
+  let versionByte = 6 << 3; // 'G'
+  let data = Buffer.from(rawPublicKey);
+  let versionBuffer = Buffer.from([versionByte]);
+  let payload = Buffer.concat([versionBuffer, data]);
+  let checksum = Buffer.alloc(2);
+  checksum.writeUInt16LE(crc16xmodem(payload), 0);
+  let unencoded = Buffer.concat([payload, checksum]);
+  return base32.encode(unencoded);
+}
+
+export function verifyEd25519Signature(
+  data: Buffer,
+  signature: Buffer,
+  publicKey: Buffer
+): boolean {
+  return nacl.sign.detached.verify(
+    new Uint8Array(data.toJSON().data),
+    new Uint8Array(signature.toJSON().data),
+    new Uint8Array(publicKey.toJSON().data)
+  );
+}
+
+export function hash(data: Buffer) {
+  let hasher = new sha256();
+  hasher.update(data, "utf8");
+  return hasher.digest();
+}
+
+export function checkStellarBip32Path(path: string): void {
+  path.split("/").forEach(function (element) {
+    if (!element.toString().endsWith("'")) {
+      throw new Error(
+        "Detected a non-hardened path element in requested BIP32 path." +
+          " Non-hardended paths are not supported at this time. Please use an all-hardened path." +
+          " Example: 44'/148'/0'"
+      );
+    }
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/hw-app-str",
-  "version": "6.24.1",
+  "version": "6.25.1-alpha.3+eb669e17",
   "description": "Ledger Hardware Wallet Stellar Application API",
   "keywords": [
     "Ledger",
@@ -27,7 +27,7 @@
   "types": "lib/Str.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@ledgerhq/hw-transport": "^6.24.1",
+    "@ledgerhq/hw-transport": "^6.25.1-alpha.3+eb669e17",
     "base32.js": "^0.1.0",
     "sha.js": "^2.3.6",
     "tweetnacl": "^1.0.3"
@@ -37,5 +37,5 @@
     "build": "bash ../../script/build.sh",
     "watch": "bash ../../script/watch.sh"
   },
-  "gitHead": "159269dafc5f177c7af5b20761ab0ef3550e3faf"
+  "gitHead": "eb669e17dd87d3ab568beab1f9a5ddb1a2536e83"
 }