ledger_device_sdk 1.35.0

Ledger device Rust SDK
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

use ledger_secure_sdk_sys::seph as sys_seph;
use ledger_secure_sdk_sys::*;

#[cfg(not(feature = "io_new"))]
use crate::io::Reply;

#[cfg(not(feature = "io_new"))]
use crate::io::{ApduHeader, Comm, Event};

pub use ledger_secure_sdk_sys::BOLOS_UX_CANCEL;
pub use ledger_secure_sdk_sys::BOLOS_UX_CONTINUE;
pub use ledger_secure_sdk_sys::BOLOS_UX_ERROR;
pub use ledger_secure_sdk_sys::BOLOS_UX_IGNORE;
pub use ledger_secure_sdk_sys::BOLOS_UX_OK;
pub use ledger_secure_sdk_sys::BOLOS_UX_REDRAW;

unsafe extern "C" {
    pub unsafe static mut G_ux_params: bolos_ux_params_t;
}

#[repr(u8)]
pub enum UxEvent {
    Event = BOLOS_UX_EVENT,
    Keyboard = BOLOS_UX_KEYBOARD,
    WakeUp = BOLOS_UX_WAKE_UP,
    ValidatePIN = BOLOS_UX_VALIDATE_PIN,
    DelayLock = BOLOS_UX_DELAY_LOCK,
    LastID = BOLOS_UX_DELAY_LOCK + 1,
}

impl UxEvent {
    #[allow(unused)]
    pub fn request(&self) -> u32 {
        unsafe {
            //let mut params = bolos_ux_params_t::default();
            G_ux_params.ux_id = match self {
                Self::Event => Self::Event as u8,
                Self::Keyboard => Self::Keyboard as u8,
                Self::WakeUp => Self::WakeUp as u8,
                Self::ValidatePIN => {
                    // Perform pre-wake up
                    G_ux_params.ux_id = Self::WakeUp as u8;
                    os_ux(&raw mut G_ux_params as *mut bolos_ux_params_t);

                    Self::ValidatePIN as u8
                }
                Self::DelayLock => {
                    #[cfg(any(
                        target_os = "apex_p",
                        target_os = "stax",
                        target_os = "flex",
                        feature = "nano_nbgl"
                    ))]
                    {
                        G_ux_params.u.lock_delay.delay_ms = 10000;
                    }

                    Self::DelayLock as u8
                }
                Self::LastID => panic!("Unknown UX Event"),
            };

            os_ux(&raw mut G_ux_params as *mut bolos_ux_params_t);

            match self {
                Self::ValidatePIN => Self::block(),
                _ => os_sched_last_status(TASK_BOLOS_UX as u32) as u32,
            }
        }
    }

    pub fn block() -> u32 {
        let mut ret = unsafe { os_sched_last_status(TASK_BOLOS_UX as u32) } as u32;
        while ret == BOLOS_UX_IGNORE || ret == BOLOS_UX_CONTINUE {
            let mut spi_buffer = [0u8; 256];
            sys_seph::io_rx(&mut spi_buffer, true);
            UxEvent::Event.request();
            ret = unsafe { os_sched_last_status(TASK_BOLOS_UX as u32) } as u32;
        }
        ret
    }

    #[cfg(not(feature = "io_new"))]
    pub fn block_and_get_event<T>(comm: &mut Comm) -> (u32, Option<Event<T>>)
    where
        T: TryFrom<ApduHeader>,
        Reply: From<<T as TryFrom<ApduHeader>>::Error>,
    {
        let mut ret = unsafe { os_sched_last_status(TASK_BOLOS_UX as u32) } as u32;
        let mut event = None;
        while ret == BOLOS_UX_IGNORE || ret == BOLOS_UX_CONTINUE {
            let status = sys_seph::io_rx(&mut comm.io_buffer, true);
            if status > 0 {
                event = comm.decode_event(status)
            }

            UxEvent::Event.request();

            if let Option::Some(Event::Command(_)) = event {
                return (ret, event);
            }
            ret = unsafe { os_sched_last_status(TASK_BOLOS_UX as u32) } as u32;
        }
        (ret, event)
    }
}