Merge pull request #114 from Zondax/support_f4_addresses

Support f4 addresses

.github/workflows/main.yml

@@ -25,8 +25,6 @@ jobs:
         run: |
           sudo update-alternatives --install /usr/bin/python python /usr/bin/python3 10
           make deps
-          brew install conan
-          conan config install https://github.com/conan-io/conanclientcert.git
       - run: cmake -DCMAKE_BUILD_TYPE=Debug . && make
       - run: GTEST_COLOR=1 ASAN_OPTIONS=detect_leaks=0 ctest -VV
 

app/Makefile

@@ -50,9 +50,7 @@ ifndef COIN
 COIN=FIL
 endif
 
-APPVERSION_M=0
-APPVERSION_N=22
-APPVERSION_P=5
+include $(CURDIR)/Makefile.version
 
 $(info COIN  = [$(COIN)])
 ifeq ($(COIN),FIL)

app/Makefile.version

@@ -0,0 +1,6 @@
+# This is the major version of this release
+APPVERSION_M=0
+# This is the minor version of this release
+APPVERSION_N=22
+# This is the patch version of this release
+APPVERSION_P=6

app/src/crypto.c

@@ -246,8 +246,8 @@ zxerr_t crypto_sign(uint8_t *signature, uint16_t signatureMaxlen,
 
 #endif
 
-uint8_t decompressLEB128(const uint8_t *input, uint16_t inputSize, uint64_t *v) {
-    unsigned int i = 0;
+uint16_t decompressLEB128(const uint8_t *input, uint16_t inputSize, uint64_t *v) {
+    uint16_t  i = 0;
 
     *v = 0;
     uint16_t shift = 0;
@@ -262,7 +262,7 @@ uint8_t decompressLEB128(const uint8_t *input, uint16_t inputSize, uint64_t *v)
         *v |= b << shift;
 
         if (!(input[i] & 0x80u)) {
-            return 1;
+            return i + 1;
         }
 
         shift += 7;
@@ -285,6 +285,9 @@ uint16_t formatProtocol(const uint8_t *addressBytes,
         return 0;
     }
 
+    // Clean output buffer
+    MEMZERO(formattedAddress, formattedAddressSize);
+
     const uint8_t protocol = addressBytes[0];
 
     formattedAddress[0] = isTestnet() ? 't' : 'f';
@@ -322,27 +325,43 @@ uint16_t formatProtocol(const uint8_t *addressBytes,
             payloadSize = ADDRESS_PROTOCOL_BLS_PAYLOAD_LEN;
             break;
         }
+        case ADDRESS_PROTOCOL_DELEGATED: {
+            uint64_t actorId = 0;
+            const uint16_t actorIdSize = decompressLEB128(addressBytes + 1, addressSize - 1, &actorId);
+
+            // Check missing actor id or missing sub-address
+            if (actorIdSize == 0 || (addressSize <= actorIdSize + 1)) {
+                return 0;
+            }
+
+            // Copy Actor ID
+            snprintf(formattedAddress + 2, formattedAddressSize - 2, "%df", actorId);
+
+            payloadSize = addressSize - 1 - actorIdSize;
+            break;
+        }
         default:
             return 0;
     }
 
-    // Remove first byte which is the protocol byte
-    if (addressSize != payloadSize + 1) {
+    // Keep only one crc buffer using the biggest size
+    uint8_t payload_crc[ADDRESS_PROTOCOL_DELEGATED_MAX_SUBADDRESS_LEN + CHECKSUM_LENGTH] = {0};
+
+    // f4 addresses contain actorID
+    const uint16_t actorIdSize = (protocol == ADDRESS_PROTOCOL_DELEGATED) ? (addressSize - payloadSize - 1) : 0;
+    if (addressSize != payloadSize + 1 + actorIdSize) {
         return 0;
     }
+    MEMCPY(payload_crc, addressBytes + 1 + actorIdSize, payloadSize);
 
-    uint8_t payload_crc[ADDRESS_PROTOCOL_BLS_PAYLOAD_LEN + CHECKSUM_LENGTH]; // Max size 52 bytes
-
-    //We don't want the first byte which is the protocol byte
-    MEMCPY(payload_crc, addressBytes + 1, addressSize - 1);
-    // append 4 bytes checksum to payload_crc
     blake_hash(addressBytes, addressSize, payload_crc + payloadSize, CHECKSUM_LENGTH);
 
+    const uint16_t offset = strnlen((char *) formattedAddress, formattedAddressSize);
     // Now prepare the address output
     if (base32_encode(payload_crc,
                       (uint32_t) (payloadSize + CHECKSUM_LENGTH),
-                      (char *)(formattedAddress + 2),
-                      (uint32_t) (formattedAddressSize - 2)) < 0) {
+                      (char *)(formattedAddress + offset),
+                      (uint32_t) (formattedAddressSize - offset)) < 0) {
         return 0;
     }
 

app/src/crypto.h

@@ -40,13 +40,15 @@ extern uint32_t hdPath[HDPATH_LEN_DEFAULT];
 #define ADDRESS_PROTOCOL_SECP256K1  0x01
 #define ADDRESS_PROTOCOL_ACTOR      0x02
 #define ADDRESS_PROTOCOL_BLS        0x03
+#define ADDRESS_PROTOCOL_DELEGATED  0x04
 
 #define ADDRESS_PROTOCOL_ID_PAYLOAD_LEN         0x00
 #define ADDRESS_PROTOCOL_SECP256K1_PAYLOAD_LEN  20
 #define ADDRESS_PROTOCOL_ACTOR_PAYLOAD_LEN      20
 #define ADDRESS_PROTOCOL_BLS_PAYLOAD_LEN        48
+#define ADDRESS_PROTOCOL_DELEGATED_MAX_SUBADDRESS_LEN  54
 
-uint8_t decompressLEB128(const uint8_t *input, uint16_t inputSize, uint64_t *v);
+uint16_t decompressLEB128(const uint8_t *input, uint16_t inputSize, uint64_t *v);
 
 uint16_t formatProtocol(const uint8_t *addressBytes, uint16_t addressSize,
                         uint8_t *formattedAddress,

app/src/parser_impl.c

@@ -163,6 +163,15 @@ __Z_INLINE parser_error_t readAddress(address_t *address, CborValue *value) {
             // protocol 3
             PARSER_ASSERT_OR_ERROR(address->len - 1 == ADDRESS_PROTOCOL_BLS_PAYLOAD_LEN, parser_invalid_address)
             break;
+        case ADDRESS_PROTOCOL_DELEGATED: {
+            // protocol 4
+            uint64_t actorId = 0;
+            const uint16_t actorIdSize = decompressLEB128(address->buffer + 1, address->len - 1, &actorId);
+            PARSER_ASSERT_OR_ERROR(actorIdSize > 0, parser_invalid_address)
+            // At least 1 byte in subaddress
+            PARSER_ASSERT_OR_ERROR(address->len > actorIdSize + 1, parser_invalid_address)
+            break;
+        }
         default:
             return parser_invalid_address;
     }

tests/crypto.cpp

@@ -104,7 +104,7 @@ TEST(CRYPTO, extractBitsFromLEB128_small) {
 
     auto ret = decompressLEB128(input, sizeof(input), &output);
 
-    EXPECT_THAT(ret, ::testing::Eq(1));
+    EXPECT_THAT(ret, ::testing::Gt(0));
     EXPECT_THAT(output, ::testing::Eq(0x81));
 
     char bufferUI[300];
@@ -120,7 +120,7 @@ TEST(CRYPTO, extractBitsFromLEB128_1byte) {
 
     auto ret = decompressLEB128(input, sizeof(input), &output);
 
-    EXPECT_THAT(ret, ::testing::Eq(1));
+    EXPECT_THAT(ret, ::testing::Gt(0));
     EXPECT_THAT(output, ::testing::Eq(1729));
 
     char bufferUI[300];
@@ -136,7 +136,7 @@ TEST(CRYPTO, extractBitsFromLEB128_big) {
 
     auto ret = decompressLEB128(input, sizeof(input), &output);
 
-    EXPECT_THAT(ret, ::testing::Eq(1));
+    EXPECT_THAT(ret, ::testing::Gt(0));
     EXPECT_THAT(output, ::testing::Eq(18446744073709551615u));
 
     char bufferUI[300];

tests/testvectors/manual.json

@@ -436,25 +436,6 @@
         },
         "encoded_tx_hex": "8a0058320300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000583203000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000144000186a01961a8420000430009c40040"
     },
-    {
-        "description": "Address with unknown protocol",
-        "encoded_tx": "igBVBAAAAAAAAAAAAAAAAAAAAAAAAAAAVQQAAAAAAAAAAAAAAAAAAAAAAAAAAAFEAAGGoBlhqEIAAEMACcQAQA==",
-        "valid": false,
-        "error": "Invalid address format",
-        "testnet": false,
-        "message": {
-            "version": 0,
-            "to": "faaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaryyc34i",
-            "from": "faaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaryyc34i",
-            "nonce": 1,
-            "value": "100000",
-            "gaslimit": "25000",
-            "gasfeecap": "0",
-            "gaspremium": "2500",
-            "method": 0
-        },
-        "encoded_tx_hex": "8a0055040000000000000000000000000000000000000000550400000000000000000000000000000000000000000144000186a01961a8420000430009c40040"
-    },
     {
         "description": "Negative sign byte",
         "encoded_tx": "igBVAdFQBQTk0aw+iayJGkUCWG+r2bQXVQG4gmGdRlWPPZ4xbRG0jc8hEycCagFBARlhqEIAAEMACcQAQA==",
@@ -595,5 +576,42 @@
             "params": [1234]
         },
         "encoded_tx_hex": "8a0044008bcb534400f59c5300400040400044811904d2"
+    },
+    {
+        "description": "Using Protocol 4 addresses",
+        "encoded_tx": "notAvailable",
+        "valid": true,
+        "error": "",
+        "testnet": false,
+        "message": {
+            "version": 0,
+            "to": "f410f2qreez6evnfbqs6rvidgwm3b44hpxpvpeuoddga",
+            "from": "f410f2qreez6evnfbqs6rvidgwm3b44hpxpvpeuoddga",
+            "nonce": 1,
+            "value": "100000",
+            "gaslimit": "25000",
+            "gasfeecap": "1",
+            "gaspremium": "1",
+            "method": 0
+        },
+        "encoded_tx_hex": "8a0056040ad4224267c4ab4a184bd1aa066b3361e70efbbeaf56040ad4224267c4ab4a184bd1aa066b3361e70efbbeaf0144000186a01961a84200014200010040"
+    },
+    {
+        "description": "Address with unknown protocol",
+        "valid": false,
+        "error": "Invalid address format",
+        "testnet": false,
+        "message": {
+            "version": 0,
+            "to": "faaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazuwnlsi",
+            "from": "faaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazuwnlsi",
+            "nonce": 1,
+            "value": "100000",
+            "gaslimit": 25000,
+            "gasfeecap": "1",
+            "gaspremium": "1",
+            "method": 0
+        },
+        "encoded_tx_hex": "8A0055050000000000000000000000000000000000000000550400000000000000000000000000000000000000000144000186A01961A84200014200010040"
     }
 ]

tests_zemu/package.json

@@ -14,14 +14,14 @@
     "Ledger"
   ],
   "scripts": {
-    "test": "jest --detectOpenHandles -t 'Standard'"
+    "test": "ts-node tests/pullImageKillOld.ts && jest"
   },
   "dependencies": {
     "@zondax/ledger-filecoin": "^0.11.2",
-    "@zondax/zemu": "^0.27.4"
+    "@zondax/zemu": "^0.34.0"
   },
   "devDependencies": {
-    "@types/jest": "^27.4.1",
+    "@types/jest": "^29.2.3",
     "@types/ledgerhq__hw-transport": "^4.21.3",
     "@types/secp256k1": "^4.0.2",
     "@typescript-eslint/eslint-plugin": "^5.19.0",
@@ -31,13 +31,14 @@
     "eslint": "^8.13.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jest": "^26.1.4",
+    "eslint-plugin-jest": "^27.1.5",
     "eslint-plugin-prettier": "^4.0.0",
-    "jest": "27.5.1",
+    "jest": "29.2.2",
     "jest-serial-runner": "^1.1.0",
-    "prettier": "^2.6.2",
     "secp256k1": "^4.0.2",
-    "ts-jest": "^27.1.4",
-    "typescript": "^4.6.3"
+    "ts-jest": "^29.0.3",
+    "prettier": "^2.5.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.5.3"
   }
 }

tests_zemu/tests/pullImageKillOld.ts

@@ -0,0 +1,4 @@
+import Zemu from '@zondax/zemu'
+
+Zemu.checkAndPullImage()
+Zemu.stopAllEmuContainers()

tests_zemu/tests/test.ts

@@ -61,7 +61,6 @@ describe('Standard', function () {
     const sim = new Zemu(m.path);
     try {
       await sim.start({...defaultOptions, model: m.name,});
-      // await sim.navigateAndCompareSnapshots('.', `${m.prefix.toLowerCase()}-mainmenu`, [1, 1, 1, 1])
       await sim.navigateAndCompareSnapshots('.', `${m.prefix.toLowerCase()}-mainmenu`, [1, 0, 0, 4, -5])
     } finally {
       await sim.close();
@@ -392,4 +391,44 @@ describe('Standard', function () {
     }
   });
 
+  test.each(models)('transfer using protocol 4 addresses', async function (m) {
+    const sim = new Zemu(m.path);
+    try {
+      await sim.start({...defaultOptions, model: m.name,});
+      const app = new FilecoinApp(sim.getTransport());
+
+      const path = "m/44'/461'/0'/0/1";
+      const txBlob = Buffer.from(
+        "8a0056040ad4224267c4ab4a184bd1aa066b3361e70efbbeaf56040ad4224267c4ab4a184bd1aa066b3361e70efbbeaf0144000186a01961a84200014200010040",
+        "hex",
+      );
+
+      const pkResponse = await app.getAddressAndPubKey(path);
+      console.log(pkResponse);
+      expect(pkResponse.return_code).toEqual(0x9000);
+      expect(pkResponse.error_message).toEqual("No errors");
+
+      // do not wait here..
+      const signatureRequest = app.sign(path, txBlob);
+
+      await sim.waitUntilScreenIsNot(sim.getMainMenuSnapshot());
+      await sim.compareSnapshotsAndApprove(".", `${m.prefix.toLowerCase()}-sign_transfer_protocol4`)
+
+      let resp = await signatureRequest;
+      console.log(resp);
+
+      expect(resp.return_code).toEqual(0x9000);
+      expect(resp.error_message).toEqual("No errors");
+
+      // Verify signature
+      const pk = Uint8Array.from(pkResponse.compressed_pk)
+      const digest = getDigest(txBlob);
+      const signature = secp256k1.signatureImport(Uint8Array.from(resp.signature_der));
+      const signatureOk = secp256k1.ecdsaVerify(signature, digest, pk);
+      expect(signatureOk).toEqual(true);
+    } finally {
+      await sim.close();
+    }
+  });
+
 })