Merge branch 'signmsg-testnet'

Author: benma

CHANGELOG.md

@@ -9,6 +9,7 @@ customers cannot upgrade their bootloader, its changes are recorded separately.
 ### [Unreleased]
 - Ethereum: add confirmation screen for known networks, change base unit to ETH for Arbitrum and Optimism
 - Ethereum: add Base and Gnosis Chain to known networks
+- Bitcoin: enable message signing on testnet and regtest
 
 ### 9.22.0
 - Update manufacturer HID descriptor to bitbox.swiss

CMakeLists.txt

@@ -91,8 +91,8 @@ endif()
 #
 # Versions MUST contain three parts and start with lowercase 'v'.
 # Example 'v1.0.0'. They MUST not contain a pre-release label such as '-beta'.
-set(FIRMWARE_VERSION "v9.22.0")
-set(FIRMWARE_BTC_ONLY_VERSION "v9.22.0")
+set(FIRMWARE_VERSION "v9.23.0")
+set(FIRMWARE_BTC_ONLY_VERSION "v9.23.0")
 set(BOOTLOADER_VERSION "v1.1.0")
 
 find_package(PythonInterp 3.6 REQUIRED)

py/bitbox02/bitbox02/bitbox02/bitbox02.py

@@ -613,6 +613,8 @@ def btc_sign_msg(
         # pylint: disable=no-member
 
         self._require_atleast(semver.VersionInfo(9, 2, 0))
+        if coin in (btc.TBTC, btc.RBTC):
+            self._require_atleast(semver.VersionInfo(9, 23, 0))
 
         request = btc.BTCRequest()
         request.sign_message.CopyFrom(

py/send_message.py

@@ -896,33 +896,59 @@ def _sign_btc_tx(self) -> None:
     def _sign_btc_message(self) -> None:
         # pylint: disable=no-member
 
-        keypath = [49 + HARDENED, 0 + HARDENED, 0 + HARDENED, 0, 0]
-        script_config = bitbox02.btc.BTCScriptConfig(
-            simple_type=bitbox02.btc.BTCScriptConfig.P2WPKH_P2SH
-        )
-        address = self._device.btc_address(
-            keypath=keypath, script_config=script_config, display=False
-        )
+        def sign(
+            coin: "bitbox02.btc.BTCCoin.V",
+            keypath: Sequence[int],
+            script_config: bitbox02.btc.BTCScriptConfig,
+        ) -> None:
+            address = self._device.btc_address(
+                coin=coin, keypath=keypath, script_config=script_config, display=False
+            )
 
-        print("Address:", address)
+            print("Address:", address)
 
-        msg = input(r"Message to sign (\n = newline): ")
-        if msg.startswith("0x"):
-            msg_bytes = binascii.unhexlify(msg[2:])
-        else:
-            msg_bytes = msg.replace(r"\n", "\n").encode("utf-8")
+            msg = input(r"Message to sign (\n = newline): ")
+            if msg.startswith("0x"):
+                msg_bytes = binascii.unhexlify(msg[2:])
+            else:
+                msg_bytes = msg.replace(r"\n", "\n").encode("utf-8")
 
-        try:
-            _, _, sig65 = self._device.btc_sign_msg(
-                bitbox02.btc.BTC,
-                bitbox02.btc.BTCScriptConfigWithKeypath(
-                    script_config=script_config, keypath=keypath
-                ),
-                msg_bytes,
+            try:
+                _, _, sig65 = self._device.btc_sign_msg(
+                    coin,
+                    bitbox02.btc.BTCScriptConfigWithKeypath(
+                        script_config=script_config, keypath=keypath
+                    ),
+                    msg_bytes,
+                )
+                print("Signature:", base64.b64encode(sig65).decode("ascii"))
+            except UserAbortException:
+                print("Aborted by user")
+
+        def sign_mainnet() -> None:
+            keypath = [49 + HARDENED, 0 + HARDENED, 0 + HARDENED, 0, 0]
+            script_config = bitbox02.btc.BTCScriptConfig(
+                simple_type=bitbox02.btc.BTCScriptConfig.P2WPKH_P2SH
             )
-            print("Signature:", base64.b64encode(sig65).decode("ascii"))
-        except UserAbortException:
-            print("Aborted by user")
+            sign(bitbox02.btc.BTC, keypath, script_config)
+
+        def sign_testnet() -> None:
+            keypath = [49 + HARDENED, 1 + HARDENED, 0 + HARDENED, 0, 0]
+            script_config = bitbox02.btc.BTCScriptConfig(
+                simple_type=bitbox02.btc.BTCScriptConfig.P2WPKH_P2SH
+            )
+            sign(bitbox02.btc.TBTC, keypath, script_config)
+
+        choices = (
+            ("Mainnet", sign_mainnet),
+            ("Testnet", sign_testnet),
+        )
+        choice = ask_user(choices)
+        if callable(choice):
+            try:
+                choice()
+            except UserAbortException:
+                eprint("Aborted by user")
 
     def _check_backup(self) -> None:
         print("Your BitBox02 will now perform a backup check")

src/rust/bitbox02-rust/src/hww/api/bitcoin/signmsg.rs

@@ -36,7 +36,7 @@ const MAX_MESSAGE_SIZE: usize = 1024;
 /// compact format (R and S values), and the last byte is the recoverable id (recid).
 pub async fn process(request: &pb::BtcSignMessageRequest) -> Result<Response, Error> {
     let coin = BtcCoin::try_from(request.coin)?;
-    if coin != BtcCoin::Btc {
+    if !matches!(coin, BtcCoin::Btc | BtcCoin::Tbtc | BtcCoin::Rbtc) {
         return Err(Error::InvalidInput);
     }
     let (keypath, simple_type) = match &request.script_config {
@@ -182,6 +182,52 @@ mod tests {
         );
     }
 
+    #[test]
+    pub fn test_p2wpkh_testnet() {
+        let request = pb::BtcSignMessageRequest {
+            coin: BtcCoin::Tbtc as _,
+            script_config: Some(pb::BtcScriptConfigWithKeypath {
+                script_config: Some(pb::BtcScriptConfig {
+                    config: Some(Config::SimpleType(SimpleType::P2wpkh as _)),
+                }),
+                keypath: vec![84 + HARDENED, 1 + HARDENED, 0 + HARDENED, 0, 0],
+            }),
+            msg: MESSAGE.to_vec(),
+            host_nonce_commitment: None,
+        };
+
+        static mut CONFIRM_COUNTER: u32 = 0;
+
+        mock(Data {
+            ui_confirm_create: Some(Box::new(|params| {
+                match unsafe {
+                    CONFIRM_COUNTER += 1;
+                    CONFIRM_COUNTER
+                } {
+                    1 => {
+                        assert_eq!(params.title, "Sign message");
+                        assert_eq!(params.body, "Coin: BTC Testnet");
+                        true
+                    }
+                    2 => {
+                        assert_eq!(params.title, "Address");
+                        assert_eq!(params.body, "tb1qnlyrq9pshg0v0lsuudjgga4nvmjxhcvketqwdg");
+                        true
+                    }
+                    3 => {
+                        assert_eq!(params.title, "Sign message");
+                        assert_eq!(params.body.as_bytes(), MESSAGE);
+                        true
+                    }
+                    _ => panic!("too many user confirmations"),
+                }
+            })),
+            ..Default::default()
+        });
+        mock_unlocked();
+        assert!(block_on(process(&request)).is_ok());
+    }
+
     #[test]
     pub fn test_p2wpkh_p2sh() {
         let request = pb::BtcSignMessageRequest {
@@ -419,5 +465,24 @@ mod tests {
             })),
             Err(Error::InvalidInput)
         );
+        // Invalid keypath (mainnet keypath on testnet)
+        mock(Data {
+            ..Default::default()
+        });
+        mock_unlocked();
+        assert_eq!(
+            block_on(process(&pb::BtcSignMessageRequest {
+                coin: BtcCoin::Tbtc as _,
+                script_config: Some(pb::BtcScriptConfigWithKeypath {
+                    script_config: Some(pb::BtcScriptConfig {
+                        config: Some(Config::SimpleType(SimpleType::P2wpkh as _))
+                    }),
+                    keypath: vec![84 + HARDENED, 0 + HARDENED, 0 + HARDENED, 0, 0],
+                }),
+                msg: MESSAGE.to_vec(),
+                host_nonce_commitment: None,
+            })),
+            Err(Error::InvalidInput)
+        );
     }
 }