maintenance: make BBApp able to talk to simulator.

This allows devs to use the app without a real device and without
relying on the software keystore.

Author: bznein

backend/backend.go

@@ -662,6 +662,16 @@ func (backend *Backend) OnDeviceUninit(f func(string)) {
 	backend.onDeviceUninit = f
 }
 
+// SetTestDevice sets a test device to be used by the USB manager instead of real USB devices.
+func (backend *Backend) SetTestDevice(device *bitbox02.Device) {
+	backend.usbManager.TestDevice = device
+}
+
+// HasTestDevice returns whether a test device is set.
+func (backend *Backend) HasTestDevice() bool {
+	return backend.usbManager.TestDevice != nil
+}
+
 // Start starts the background services. It returns a channel of events to handle by the library
 // client.
 func (backend *Backend) Start() <-chan interface{} {

backend/devices/bitbox02/simulator/simulator.go

@@ -0,0 +1,106 @@
+package simulator
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"os/exec"
+	"time"
+
+	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox02"
+	"github.com/BitBoxSwiss/bitbox02-api-go/api/common"
+	bitbox02common "github.com/BitBoxSwiss/bitbox02-api-go/api/common"
+	"github.com/BitBoxSwiss/bitbox02-api-go/api/firmware/mocks"
+	"github.com/BitBoxSwiss/bitbox02-api-go/communication/u2fhid"
+	"github.com/BitBoxSwiss/bitbox02-api-go/util/semver"
+)
+
+// SimulatorID is the identifier used for the BitBox02 simulator.
+const SimulatorID = "Bitbox02-Simulator"
+
+// NewDevice connects to a BitBox02 simulator running on localhost:simulatorPort and returns
+// the bitbox02.Device instance. simulatorVersion is the version string of the simulator, e.g. "9.99.0".
+func NewDevice(simulatorPort int, simulatorVersion string) (*bitbox02.Device, error) {
+	var err error
+	var conn net.Conn
+	for range 200 {
+		conn, err = net.Dial("tcp", fmt.Sprintf("localhost:%d", simulatorPort))
+		if err == nil {
+			break
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	if err != nil {
+		return nil, err
+	}
+	const bitboxCMD = 0x80 + 0x40 + 0x01
+
+	communication := u2fhid.NewCommunication(conn, bitboxCMD)
+	version, err := semver.NewSemVerFromString(simulatorVersion)
+	if err != nil {
+		return nil, err
+	}
+	device := bitbox02.NewDevice(SimulatorID, version, common.ProductBitBox02Multi,
+		&mocks.Config{}, communication,
+	)
+	return device, nil
+}
+
+// IsRunning checks if a BitBox02 simulator with the given version is running.
+func IsRunning(version string) bool {
+	cmd := exec.Command("pgrep", "-f", fmt.Sprintf("%s-simulator", version))
+	if err := cmd.Run(); err != nil {
+		return false // no matching process
+	}
+	return true
+}
+
+// DeviceInfo implements usb.DeviceInfo for the simulator.
+// All methods return hardcoded values.
+type DeviceInfo struct {
+}
+
+// IsBluetooth implements usb.DeviceInfo.
+func (d DeviceInfo) IsBluetooth() bool {
+	return false
+}
+
+// VendorID implements usb.DeviceInfo.
+func (d DeviceInfo) VendorID() int {
+	return 0x03eb
+}
+
+// ProductID implements usb.DeviceInfo.
+func (d DeviceInfo) ProductID() int {
+	return 0x2403
+}
+
+// UsagePage implements usb.DeviceInfo.
+func (d DeviceInfo) UsagePage() int {
+	return 0xfffff
+}
+
+// Interface implements usb.DeviceInfo.
+func (d DeviceInfo) Interface() int {
+	return 0
+}
+
+// Serial implements usb.DeviceInfo.
+func (d DeviceInfo) Serial() string {
+	return "simulator"
+}
+
+// Product implements usb.DeviceInfo.
+func (d DeviceInfo) Product() string {
+	return bitbox02common.FirmwareDeviceProductStringBitBox02Multi
+}
+
+// Identifier implements usb.DeviceInfo.
+func (d DeviceInfo) Identifier() string {
+	return SimulatorID
+}
+
+// Open implements usb.DeviceInfo.
+func (d DeviceInfo) Open() (io.ReadWriteCloser, error) {
+	return nil, nil
+}

backend/devices/usb/manager.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox02"
+	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox02/simulator"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox02bootloader"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/device"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/errp"
@@ -63,6 +64,10 @@ func isBitBox(deviceInfo DeviceInfo) bool {
 	return deviceInfo.VendorID() == bitboxVendorID && deviceInfo.ProductID() == bitboxProductID && (deviceInfo.UsagePage() == 0xffff || deviceInfo.Interface() == 0)
 }
 
+func isSimulator(deviceInfo DeviceInfo) bool {
+	return deviceInfo.Identifier() == simulator.SimulatorID
+}
+
 func isBitBox02(deviceInfo DeviceInfo) bool {
 	return (deviceInfo.Product() == bitbox02common.FirmwareDeviceProductStringBitBox02Multi ||
 		deviceInfo.Product() == bitbox02common.FirmwareDeviceProductStringBitBox02BTCOnly ||
@@ -99,6 +104,9 @@ type Manager struct {
 	socksProxy socksproxy.SocksProxy
 
 	log *logrus.Entry
+
+	// TestDevice is used to inject a device for testing purposes.
+	TestDevice *bitbox02.Device
 }
 
 // NewManager creates a new Manager. onRegister is called when a device has been
@@ -320,6 +328,8 @@ func (manager *Manager) listen() {
 					manager.log.WithError(err).Error("Failed to register bitbox")
 					continue
 				}
+			case isSimulator(deviceInfo):
+				device = manager.TestDevice
 			case isBitBox02(deviceInfo):
 				var err error
 				device, err = manager.makeBitBox02(deviceInfo)

cmd/servewallet/main.go

@@ -22,10 +22,12 @@ import (
 	"os/exec"
 	"runtime"
 	"strings"
+	"time"
 
 	backendPkg "github.com/BitBoxSwiss/bitbox-wallet-app/backend"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/arguments"
 	btctypes "github.com/BitBoxSwiss/bitbox-wallet-app/backend/coins/btc/types"
+	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox02/simulator"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/usb"
 	backendHandlers "github.com/BitBoxSwiss/bitbox-wallet-app/backend/handlers"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/config"
@@ -69,6 +71,10 @@ func (webdevEnvironment) NotifyUser(text string) {
 
 // DeviceInfos implements backend.Environment.
 func (webdevEnvironment) DeviceInfos() []usb.DeviceInfo {
+	if backend.HasTestDevice() {
+		// We are in "test device" mode.
+		return []usb.DeviceInfo{simulator.DeviceInfo{}}
+	}
 	return usb.DeviceInfos()
 }
 
@@ -130,6 +136,41 @@ func (webdevEnvironment) DetectDarkTheme() bool {
 	return false
 }
 
+func handleBitboxSimulator(log *logrus.Entry, simulatorPort int, simulatorVersion string) error {
+	portIsSet := simulatorPort != -1
+	versionIsSet := simulatorVersion != ""
+
+	if portIsSet != versionIsSet {
+		return fmt.Errorf("flags -simulatorPort and -simulatorVersion must be set together or not at all")
+	}
+
+	if !portIsSet {
+		return nil
+	}
+	go func() {
+		for {
+			if !simulator.IsRunning(simulatorVersion) {
+				// Simulator not running. Unset test device.
+				backend.SetTestDevice(nil)
+				continue
+			}
+			// If the testdevice is already set, do nothing.
+			if backend.HasTestDevice() {
+				continue
+			}
+
+			// Otherwise, connect to the simulator.
+			device, err := simulator.NewDevice(simulatorPort, simulatorVersion)
+			if err != nil {
+				log.WithError(err).Fatal("Could not create new device from running simulator")
+			}
+			backend.SetTestDevice(device)
+			time.Sleep(time.Millisecond * 50)
+		}
+	}()
+	return nil
+}
+
 func main() {
 	config.SetAppDir("appfolder.dev")
 
@@ -138,6 +179,8 @@ func main() {
 	devservers := flag.Bool("devservers", true, "switch to dev servers")
 	gapLimitsReceive := flag.Uint("gapLimitReceive", 0, "gap limit for receive addresses")
 	gapLimitsChange := flag.Uint("gapLimitChange", 0, "gap limit for change addresses")
+	simulatorPort := flag.Int("simulatorPort", -1, "port for the BitBox02 simulator")
+	simulatorVersion := flag.String("simulatorVersion", "", "version of the BitBox02 simulator")
 	flag.Parse()
 
 	var gapLimits *btctypes.GapLimits
@@ -161,6 +204,7 @@ func main() {
 	log.Info("--------------- Started application --------------")
 	// since we are in dev-mode, we can drop the authorization token
 	connectionData := backendHandlers.NewConnectionData(-1, "")
+
 	newBackend, err := backendPkg.NewBackend(
 		arguments.NewArguments(
 			config.AppDir(),
@@ -177,6 +221,11 @@ func main() {
 	handlers := backendHandlers.NewHandlers(backend, connectionData)
 	log.WithFields(logrus.Fields{"address": address, "port": port}).Info("Listening for HTTP")
 	fmt.Printf("Listening on: http://localhost:%d\n", port)
+
+	if err := handleBitboxSimulator(log, *simulatorPort, *simulatorVersion); err != nil {
+		log.WithError(err).Fatal("Invalid simulator flags")
+	}
+
 	if err := http.ListenAndServe(fmt.Sprintf("%s:%d", address, port), handlers.Router); err != nil {
 		log.WithFields(logrus.Fields{"address": address, "port": port, "error": err.Error()}).Fatal("Failed to listen for HTTP")
 	}