Fix BAGL applications calling NBGL libraries case

Author: nroggeman-ledger

CHANGELOG.md

@@ -5,12 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.17.0] 2025-03-13
+
+## [0.17.0] 2025-03-14
 
 ### Added
 
 - `--save-nvram` and `--load-nvram` parameters that allow NVRAM testing
 - destination boundaries verification for `nvm_write()`
+- Make BAGL-based applications able to call NBGL-based libraries, or NBGL-based applications able to call BAGL-based libraries
 
 ## [0.16.0] 2025-03-05
 

speculos/main.py

@@ -148,7 +148,7 @@ def get_cx_infos(app_path):
     return ei
 
 
-def run_qemu(s1: socket.socket, s2: socket.socket, args: argparse.Namespace, use_bagl: bool) -> int:
+def run_qemu(s1: socket.socket, s2: socket.socket, args: argparse.Namespace) -> int:
     argv = ['qemu-arm-static']
 
     if args.debug:
@@ -183,20 +183,20 @@ def run_qemu(s1: socket.socket, s2: socket.socket, args: argparse.Namespace, use
     else:
         logger.warning(f"Cx lib {cxlib_filepath} not found")
 
-    # for NBGL apps, fonts binary file is mandatory
-    if not use_bagl:
-        fonts_filepath = f"fonts/{args.model}-fonts-{args.apiLevel}.bin"
-        fonts = str(resources.files(__package__) / fonts_filepath)
-        if os.path.exists(fonts):
-            argv += ['-f', fonts]
-        else:
-            logger.error(f"Fonts {fonts_filepath} not found")
-            sys.exit(1)
+    only_bagl = True
+    # 'bagl' is the default value of the binary.sections.sdk_graphics. We need to
+    # manage the cases where it is NOT 'bagl' but the section does not exists yet
+    if args.model in ["stax", "flex"]:
+        only_bagl = False
 
     extra_ram = ''
     app_path = getattr(args, 'app.elf')
     for lib in [f'main:{app_path}'] + args.library:
         name, lib_path = lib.split(':')
+        binary = LedgerBinaryApp(lib_path)
+        use_bagl = binary.sections.sdk_graphics == "bagl"
+        if not use_bagl:
+            only_bagl = False
         ei = get_elf_infos(lib_path, use_bagl)
 
         # Since binaries loaded as libs could also declare extra RAM page(s), collect them all
@@ -215,6 +215,16 @@ def run_qemu(s1: socket.socket, s2: socket.socket, args: argparse.Namespace, use
         lib_arg += f':{1 if args.save_nvram else 0}'
         argv.append(lib_arg)
 
+    # for NBGL apps, fonts binary file is mandatory
+    if not only_bagl:
+        fonts_filepath = f"fonts/{args.model}-fonts-{args.apiLevel}.bin"
+        fonts = str(resources.files(__package__) / fonts_filepath)
+        if os.path.exists(fonts):
+            argv += ['-f', fonts]
+        else:
+            logger.error(f"Fonts {fonts_filepath} not found")
+            sys.exit(1)
+
     if args.model == 'blue':
         if args.rampage:
             extra_ram = args.rampage
@@ -357,13 +367,6 @@ def main(prog=None) -> int:
         args.model = "nanosp" if binary.sections.target == "nanos2" else binary.sections.target
         logger.warning(f"Device model detected from metadata: {args.model}")
 
-    # 'bagl' is the default value of the binary.sections.sdk_graphics. We need to
-    # manage the cases where it is NOT 'bagl' but the section does not exists yet
-    if args.model in ["stax", "flex"]:
-        use_bagl = False
-    else:
-        use_bagl = binary.sections.sdk_graphics == "bagl"
-
     if not args.apiLevel:
         if binary.sections.api_level is not None:
             args.apiLevel = binary.sections.api_level
@@ -508,7 +511,7 @@ def main(prog=None) -> int:
 
     s1, s2 = socket.socketpair()
 
-    qemu_pid = run_qemu(s1, s2, args, use_bagl)
+    qemu_pid = run_qemu(s1, s2, args)
     s1.close()
 
     # The `--transport` argument takes precedence over `--usb`
@@ -521,7 +524,6 @@ def main(prog=None) -> int:
     seph = seproxyhal.SeProxyHal(
         s2,
         args.model,
-        use_bagl,
         automation_path,
         automation_server,
         transport_type,
@@ -563,7 +565,7 @@ def main(prog=None) -> int:
         apirun = ApiRunner(args.api_port)
 
     display_args = DisplayArgs(args.color, args.model, args.ontop, rendering,
-                               args.keymap, zoom, x, y, use_bagl)
+                               args.keymap, zoom, x, y)
     server_args = ServerArgs(apdu, apirun, button, finger, seph, vnc)
     screen_notifier = ScreenNotifier(display_args, server_args)
 

speculos/mcu/display.py

@@ -259,12 +259,13 @@ def rendering(self):
         return self._display_args.rendering
 
     @property
-    def use_bagl(self) -> bool:
-        return self._display_args.use_bagl
+    @abstractmethod
+    def nbgl_gl(self) -> GraphicLibrary:
+        pass
 
     @property
     @abstractmethod
-    def gl(self) -> GraphicLibrary:
+    def bagl_gl(self) -> GraphicLibrary:
         pass
 
     @abstractmethod

speculos/mcu/headless.py

@@ -15,32 +15,32 @@ def __init__(self, display: DisplayArgs, server: ServerArgs) -> None:
         super().__init__(display, server)
 
         self.m = HeadlessPaintWidget(self.model, server.vnc)
-        self._gl: GraphicLibrary
-        if display.use_bagl:
-            self._gl = bagl.Bagl(self.m, MODELS[self.model].screen_size, self.model)
-        else:
-            self._gl = nbgl.NBGL(self.m, MODELS[self.model].screen_size, self.model)
+        self._bagl_gl: GraphicLibrary
+        self._nbgl_gl: GraphicLibrary
+        self._bagl_gl = bagl.Bagl(self.m, MODELS[self.model].screen_size, self.model)
+        self._nbgl_gl = nbgl.NBGL(self.m, MODELS[self.model].screen_size, self.model)
 
     @property
-    def gl(self) -> GraphicLibrary:
-        return self._gl
+    def bagl_gl(self):
+        return self._bagl_gl
+
+    @property
+    def nbgl_gl(self):
+        return self._nbgl_gl
 
     def display_status(self, data: bytes) -> List[TextEvent]:
-        assert isinstance(self.gl, bagl.Bagl)
-        ret = self.gl.display_status(data)
+        ret = self.bagl_gl.display_status(data)
         if MODELS[self.model].name == 'blue':
             self.screen_update()    # Actually, this method doesn't work
         return ret
 
     def display_raw_status(self, data: bytes) -> None:
-        assert isinstance(self.gl, bagl.Bagl)
-        self.gl.display_raw_status(data)
+        self.bagl_gl.display_raw_status(data)
         if MODELS[self.model].name == 'blue':
             self.screen_update()    # Actually, this method doesn't work
 
     def screen_update(self) -> bool:
-        assert isinstance(self.gl, bagl.Bagl)
-        return self.gl.refresh()
+        return self.bagl_gl.refresh()
 
 
 class HeadlessPaintWidget(FrameBuffer):

speculos/mcu/ocr.py

@@ -122,11 +122,10 @@ class OCR:
     MAX_BLANK_SPACE_STAX = 24
     MAX_BLANK_SPACE_FLEX = 26
 
-    def __init__(self, model: str, use_bagl: bool):
+    def __init__(self, model: str):
         self.events: List[TextEvent] = []
         # Store the model of the device
         self.model = model
-        self.use_bagl = use_bagl
         # Maximum space for a letter to be considered part of the same word
         if model == "stax":
             self.max_blank_space = OCR.MAX_BLANK_SPACE_STAX
@@ -212,14 +211,14 @@ def add_character(self, x: int, y: int, w: int, h: int, char: str) -> None:
         # create a new TextEvent if there are no events yet or if there is a new line
         self.events.append(TextEvent(char, x, y, w, h, False))
 
-    def analyze_bitmap(self, data: bytes) -> None:
+    def analyze_bitmap(self, data: bytes, use_bagl: bool) -> None:
         """
         data contain information about the latest displayed bitmap.
         Since unified SDK, speculos added the displayed character to data.
         For older SKD versions, legacy behaviour is used: parsing internal
         fonts to find a matching bitmap.
         """
-        if not self.use_bagl:
+        if not use_bagl:
             # Can be called via SephTag.NBGL_DRAW_IMAGE or SephTag.NBGL_DRAW_IMAGE_RLE
             # In both cases, data contains:
             # - area (sizeof(nbgl_area_t))

speculos/mcu/screen.py

@@ -191,24 +191,27 @@ class Screen(Display):
     def __init__(self, display: DisplayArgs, server: ServerArgs) -> None:
         super().__init__(display, server)
         self.app: App
-        self._gl: GraphicLibrary
+        self._bagl_gl: GraphicLibrary
+        self._nbgl_gl: GraphicLibrary
 
     def set_app(self, app: App) -> None:
         self.app = app
         self.app.set_screen(self)
         model = self._display_args.model
-        if self.use_bagl:
-            self._gl = bagl.Bagl(app.widget, MODELS[model].screen_size, model)
-        else:
-            self._gl = nbgl.NBGL(app.widget, MODELS[model].screen_size, model)
+        self._bagl_gl = bagl.Bagl(app.widget, MODELS[model].screen_size, model)
+        self._nbgl_gl = nbgl.NBGL(app.widget, MODELS[model].screen_size, model)
 
     @property
     def m(self) -> QWidget:
         return self.app.widget
 
     @property
-    def gl(self):
-        return self._gl
+    def bagl_gl(self):
+        return self._bagl_gl
+
+    @property
+    def nbgl_gl(self):
+        return self._nbgl_gl
 
     def _key_event(self, event: QKeyEvent, pressed) -> None:
         key = Qt.Key(event.key())
@@ -223,20 +226,18 @@ def _key_event(self, event: QKeyEvent, pressed) -> None:
             self.app.close()
 
     def display_status(self, data: bytes) -> List[TextEvent]:
-        assert isinstance(self.gl, bagl.Bagl)
-        ret = self.gl.display_status(data)
+        ret = self.bagl_gl.display_status(data)
         if MODELS[self.model].name == 'blue':
             self.screen_update()    # Actually, this method doesn't work
         return ret
 
     def display_raw_status(self, data: bytes) -> None:
-        assert isinstance(self.gl, bagl.Bagl)
-        self.gl.display_raw_status(data)
+        self.bagl_gl.display_raw_status(data)
         if MODELS[self.model].name == 'blue':
             self.screen_update()    # Actually, this method doesn't work
 
     def screen_update(self) -> bool:
-        return self.gl.refresh()
+        return self.bagl_gl.refresh()
 
 
 class QtScreenNotifier(DisplayNotifier):

speculos/mcu/screen_text.py

@@ -105,10 +105,7 @@ def __init__(self, display_args: DisplayArgs, server_args: ServerArgs) -> None:
 
         self.width, self.height = MODELS[display_args.model].screen_size
         self.m = TextWidget(self, display_args.model)
-        if self.use_bagl:
-            self._gl = bagl.Bagl(self.m, MODELS[display_args.model].screen_size, display_args.model)
-        else:
-            raise NotImplementedError("This display can not emulate NBGL OS yet")
+        self._gl = bagl.Bagl(self.m, MODELS[display_args.model].screen_size, display_args.model)
 
         if display_args.keymap is not None:
             self.ARROW_KEYS = list(map(ord, display_args.keymap))

speculos/mcu/seproxyhal.py

@@ -253,7 +253,6 @@ class SeProxyHal(IODevice):
     def __init__(self,
                  sock: socket,
                  model: str,
-                 use_bagl: bool,
                  automation: Optional[Automation] = None,
                  automation_server: Optional[BroadcastInterface] = None,
                  transport: TransportType = TransportType.HID,
@@ -264,7 +263,8 @@ def __init__(self,
         self.automation = automation
         self.automation_server = automation_server
         self.events: List[TextEvent] = []
-        self.refreshed = False
+        self.need_nbgl_refresh = False
+        self.is_last_draw_nbgl = False
         self.verbose = verbose
 
         self.status_event = threading.Event()
@@ -277,9 +277,7 @@ def __init__(self,
 
         self.transport = build_transport(self.socket_helper.queue_packet, transport)
 
-        self.ocr = OCR(model, use_bagl)
-
-        self.use_bagl = use_bagl
+        self.ocr = OCR(model)
 
         # A list of callback methods when an APDU response is received
         self.apdu_callbacks: List[Callable[[bytes], None]] = []
@@ -333,17 +331,17 @@ def can_read(self, screen: DisplayNotifier):
 
         if tag == SephTag.GENERAL_STATUS:
             if int.from_bytes(data[:2], 'big') == SephTag.GENERAL_STATUS_LAST_COMMAND:
-                if self.refreshed:
-                    self.refreshed = False
+                if self.need_nbgl_refresh:
+                    self.need_nbgl_refresh = False
 
                     # Update the screenshot, we'll upload its associated events shortly
-                    screen.display.gl.update_screenshot()
-                    screen.display.gl.update_public_screenshot()
+                    screen.display.nbgl_gl.update_screenshot()
+                    screen.display.nbgl_gl.update_public_screenshot()
 
-                if self.use_bagl and screen.display.screen_update():
+                if self.is_last_draw_nbgl is False and screen.display.screen_update():
                     if screen.display.model in ["nanox", "nanosp"]:
                         self.events += self.ocr.get_events()
-                elif not self.use_bagl:
+                elif self.is_last_draw_nbgl:
                     self.events += self.ocr.get_events()
 
                 # Apply automation rules after having received a GENERAL_STATUS_LAST_COMMAND tag. It allows the
@@ -362,6 +360,7 @@ def can_read(self, screen: DisplayNotifier):
                      SephTag.DBG_SCREEN_DISPLAY_STATUS,
                      SephTag.BAGL_DRAW_RECT]:
             self.logger.debug(f"DISPLAY_STATUS {data!r}")
+            self.is_last_draw_nbgl = False
             if screen.display.model not in ["nanox", "nanosp"] or tag == SephTag.BAGL_DRAW_RECT:
                 events = screen.display.display_status(data)
                 self.events += events
@@ -371,8 +370,9 @@ def can_read(self, screen: DisplayNotifier):
         elif tag in [SephTag.SCREEN_DISPLAY_RAW_STATUS, SephTag.BAGL_DRAW_BITMAP]:
             self.logger.debug("SephTag.SCREEN_DISPLAY_RAW_STATUS")
             screen.display.display_raw_status(data)
+            self.is_last_draw_nbgl = False
             if screen.display.model in ["nanox", "nanosp"]:
-                self.ocr.analyze_bitmap(data)
+                self.ocr.analyze_bitmap(data, True)
             if tag != SephTag.BAGL_DRAW_BITMAP:
                 self.socket_helper.send_packet(SephTag.DISPLAY_PROCESSED_EVENT)
             if screen.display.rendering == RENDER_METHOD.PROGRESSIVE:
@@ -425,34 +425,34 @@ def can_read(self, screen: DisplayNotifier):
             pass
 
         elif tag == SephTag.NBGL_DRAW_RECT:
-            assert isinstance(screen.display.gl, NBGL)
-            self.events += screen.display.gl.hal_draw_rect(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            self.events += screen.display.nbgl_gl.hal_draw_rect(data)
 
         elif tag == SephTag.NBGL_REFRESH:
-            assert isinstance(screen.display.gl, NBGL)
-            screen.display.gl.refresh(data)
+            screen.display.nbgl_gl.refresh(data)
             # Stax/Flex only
-            # We have refreshed the screen, remember it for the next time we have SephTag.GENERAL_STATUS
+            # We have need_nbgl_refresh the screen, remember it for the next time we have SephTag.GENERAL_STATUS
             # then we'll perform a screen update and make public the resulting screenshot
-            self.refreshed = True
+            self.need_nbgl_refresh = True
+            self.is_last_draw_nbgl = True
 
         elif tag == SephTag.NBGL_DRAW_LINE:
-            assert isinstance(screen.display.gl, NBGL)
-            screen.display.gl.hal_draw_line(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            screen.display.nbgl_gl.hal_draw_line(data)
 
         elif tag == SephTag.NBGL_DRAW_IMAGE:
-            assert isinstance(screen.display.gl, NBGL)
-            self.ocr.analyze_bitmap(data)
-            screen.display.gl.hal_draw_image(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            self.ocr.analyze_bitmap(data, False)
+            screen.display.nbgl_gl.hal_draw_image(data)
 
         elif tag == SephTag.NBGL_DRAW_IMAGE_RLE:
-            assert isinstance(screen.display.gl, NBGL)
-            self.ocr.analyze_bitmap(data)
-            screen.display.gl.hal_draw_image_rle(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            self.ocr.analyze_bitmap(data, False)
+            screen.display.nbgl_gl.hal_draw_image_rle(data)
 
         elif tag == SephTag.NBGL_DRAW_IMAGE_FILE:
-            assert isinstance(screen.display.gl, NBGL)
-            screen.display.gl.hal_draw_image_file(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            screen.display.nbgl_gl.hal_draw_image_file(data)
 
         elif tag == SephTag.NFC_RAPDU:
             data = self.transport.handle_rapdu(data)