bitbox-api 0.12.0

A library to interact with BitBox hardware wallets
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

// SPDX-License-Identifier: Apache-2.0

use super::constants::{PRODUCT_ID, VENDOR_ID};
use async_trait::async_trait;
use thiserror::Error;

#[cfg(feature = "multithreaded")]
use std::sync::Mutex;

use super::communication::{Error as CommunicationError, ReadWrite};

/// The hid product string of the BitBox02 multi edition firmware.
const FIRMWARE_PRODUCT_STRING_BITBOX02_MULTI: &str = "BitBox02";
/// The hid product string of the BitBox02 btc-only edition firmware.
const FIRMWARE_PRODUCT_STRING_BITBOX02_BTCONLY: &str = "BitBox02BTC";

/// The hid product string of the BitBox02 Nova multi edition firmware.
const FIRMWARE_PRODUCT_STRING_BITBOX02_NOVA_MULTI: &str = "BitBox02 Nova Multi";
/// The hid product string of the BitBox02 Nova btc-only edition firmware.
const FIRMWARE_PRODUCT_STRING_BITBOX02_NOVA_BTCONLY: &str = "BitBox02 Nova BTC-only";

#[cfg(feature = "multithreaded")]
pub(crate) struct HidDevice(Mutex<hidapi::HidDevice>);

#[cfg(not(feature = "multithreaded"))]
pub(crate) struct HidDevice(hidapi::HidDevice);

impl crate::util::Threading for HidDevice {}

impl HidDevice {
    #[cfg(feature = "multithreaded")]
    pub(crate) fn new(device: hidapi::HidDevice) -> Self {
        HidDevice(Mutex::new(device))
    }

    #[cfg(not(feature = "multithreaded"))]
    pub(crate) fn new(device: hidapi::HidDevice) -> Self {
        HidDevice(device)
    }

    #[cfg(feature = "multithreaded")]
    fn get(&self) -> std::sync::MutexGuard<'_, hidapi::HidDevice> {
        self.0.lock().unwrap()
    }

    #[cfg(not(feature = "multithreaded"))]
    fn get(&self) -> &hidapi::HidDevice {
        &self.0
    }
}

#[cfg_attr(feature = "multithreaded", async_trait)]
#[cfg_attr(not(feature="multithreaded"), async_trait(?Send))]
impl ReadWrite for HidDevice {
    fn write(&self, msg: &[u8]) -> Result<usize, CommunicationError> {
        let device = self.get();
        let mut v = vec![0x00];
        v.extend_from_slice(msg);
        #[allow(clippy::needless_borrow)]
        hidapi::HidDevice::write(&device, &v).or(Err(CommunicationError::Write))
    }

    async fn read(&self) -> Result<Vec<u8>, CommunicationError> {
        let device = self.get();
        let mut buf = [0u8; 64];
        #[allow(clippy::needless_borrow)]
        let res = hidapi::HidDevice::read(&device, &mut buf).or(Err(CommunicationError::Read))?;
        Ok(buf[..res].to_vec())
    }
}

#[derive(Error, Debug)]
pub enum UsbError {
    #[error("hid error: {0}")]
    Hid(#[from] hidapi::HidError),
    #[error("could not find device or device is busy")]
    NotFound,
}

/// Returns true if this device is a BitBox02 device (any edition). This does not identify BitBox02
/// bootloaders.
pub fn is_bitbox02(device_info: &hidapi::DeviceInfo) -> bool {
    (matches!(
        device_info.product_string(),
        Some(
            FIRMWARE_PRODUCT_STRING_BITBOX02_MULTI
                | FIRMWARE_PRODUCT_STRING_BITBOX02_BTCONLY
                | FIRMWARE_PRODUCT_STRING_BITBOX02_NOVA_MULTI
                | FIRMWARE_PRODUCT_STRING_BITBOX02_NOVA_BTCONLY
        )
    )) && device_info.vendor_id() == VENDOR_ID
        && device_info.product_id() == PRODUCT_ID
        && (device_info.usage_page() == 0xffff || device_info.interface_number() == 0)
}

/// Returns the first BitBox02 HID device info that is found, or `Err(UsbError::NotFound)` if none
/// is available.
pub fn get_any_bitbox02() -> Result<hidapi::HidDevice, UsbError> {
    let api = hidapi::HidApi::new().unwrap();
    for device_info in api.device_list() {
        if is_bitbox02(device_info) {
            return Ok(device_info.open_device(&api)?);
        }
    }
    Err(UsbError::NotFound)
}