Merge branch 'espressif:master' into pioarduino

Author: Jason2866

CHANGELOG.md

@@ -20,6 +20,15 @@
 </div>
 <hr>
 
+## v5.0.1 (2025-07-15)
+
+### 🐛 Bug Fixes
+
+- **elf2image**: validate ELF section types and addresses before processing *(Jaroslav Burian - 97a1546)*
+- **elf2image**: handle PREINIT_ARRAY section type in ESP32-P4 elf file properly *(Jaroslav Burian - ec84a75)*
+- **elf2image**: Fix incorrect logger call *(Marek Matej - 637f0e6)*
+
+
 ## v5.0.0 (2025-07-02)
 
 ### 🚨 Breaking changes

docs/en/esptool/scripting.rst

@@ -354,4 +354,4 @@ To ensure compatibility with esptool, the custom logger should re-implement (or
    :members: print, note, warning, error, stage, progress_bar, set_verbosity
    :member-order: bysource
 
-These methods are essential for maintaining proper integration and behavior with esptool. Additionally, all output printing should be made using ``log.print()`` (or the respective method, such as ``log.info()`` or ``log.warning()``) instead of the standard ``print()`` function to ensure the output is routed through the custom logger. This ensures consistency and allows the custom logger to handle all output appropriately. You can further customize this logger to fit your application's needs, such as integrating with GUI components or advanced logging frameworks.
+These methods are essential for maintaining proper integration and behavior with esptool. Additionally, all output printing should be made using ``log.print()`` (or the respective method, such as ``log.note()`` or ``log.warning()``) instead of the standard ``print()`` function to ensure the output is routed through the custom logger. This ensures consistency and allows the custom logger to handle all output appropriately. You can further customize this logger to fit your application's needs, such as integrating with GUI components or advanced logging frameworks.

docs/en/migration-guide.rst

@@ -77,7 +77,7 @@ The esptool ``v5`` release introduces a centralized logging mechanism to improve
 
 **Migration Steps:**
 
-1. If your scripts rely on direct ``print()`` statements, update them to use the centralized logger for consistent output. Calls to the logger should be made using ``log.print()`` (or the respective method, such as ``log.info()``, ``log.warning()``, or ``log.error()``).
+1. If your scripts rely on direct ``print()`` statements, update them to use the centralized logger for consistent output. Calls to the logger should be made using ``log.print()`` (or the respective method, such as ``log.note()``, ``log.warning()``, or ``log.error()``).
 2. Refer to the provided documentation to implement custom loggers as needed.
 3. Update GUIs or tools to leverage the progress tracking API for better user feedback during lengthy operations.
 

esptool/__init__.py

@@ -31,7 +31,7 @@
     "write_mem",
 ]
 
-__version__ = "5.0.0"
+__version__ = "5.0.1"
 
 import os
 import shlex

esptool/bin_image.py

@@ -443,7 +443,7 @@ def merge_adjacent_segments(self):
                     elem_pad_addr != elem.addr + len(elem.data)
                     and elem_pad_addr == next_elem.addr
                 ):
-                    log.info(
+                    log.note(
                         "Inserting {} bytes padding between {} and {}".format(
                             next_elem.addr - (elem.addr + len(elem.data)),
                             elem.name,
@@ -1281,14 +1281,6 @@ class ESP32H21FirmwareImage(ESP32C6FirmwareImage):
 
 
 class ELFFile(object):
-    SEC_TYPE_PROGBITS = 0x01
-    SEC_TYPE_STRTAB = 0x03
-    SEC_TYPE_NOBITS = 0x08  # e.g. .bss section
-    SEC_TYPE_INITARRAY = 0x0E
-    SEC_TYPE_FINIARRAY = 0x0F
-
-    PROG_SEC_TYPES = (SEC_TYPE_PROGBITS, SEC_TYPE_INITARRAY, SEC_TYPE_FINIARRAY)
-
     LEN_SEC_HEADER = 0x28
 
     SEG_TYPE_LOAD = 0x01
@@ -1347,6 +1339,22 @@ def _read_elf_file(self, f):
         self._read_segments(f, _phoff, _phnum, shstrndx)
 
     def _read_sections(self, f, section_header_offs, section_header_count, shstrndx):
+        SEC_TYPE_PROGBITS = 0x01
+        SEC_TYPE_STRTAB = 0x03
+        SEC_TYPE_NOBITS = 0x08  # e.g. .bss section
+        SEC_TYPE_INITARRAY = 0x0E
+        SEC_TYPE_FINIARRAY = 0x0F
+        SEC_TYPE_PREINITARRAY = 0x10
+
+        PROG_SEC_TYPES = (
+            SEC_TYPE_PROGBITS,
+            SEC_TYPE_INITARRAY,
+            SEC_TYPE_FINIARRAY,
+            SEC_TYPE_PREINITARRAY,
+        )
+
+        KNOWN_SEC_TYPES = PROG_SEC_TYPES + (SEC_TYPE_NOBITS, SEC_TYPE_STRTAB)
+
         f.seek(section_header_offs)
         len_bytes = section_header_count * self.LEN_SEC_HEADER
         section_header = f.read(len_bytes)
@@ -1378,17 +1386,13 @@ def read_section_header(offs):
             ) = struct.unpack_from("<LLLLLLLLL", section_header[offs:])
             return (name_offs, sec_type, lma, size, sec_offs, _flags, align)
 
-        all_sections = [read_section_header(offs) for offs in section_header_offsets]
-        prog_sections = [s for s in all_sections if s[1] in ELFFile.PROG_SEC_TYPES]
-        nobits_secitons = [s for s in all_sections if s[1] == ELFFile.SEC_TYPE_NOBITS]
-
         # search for the string table section
         if (shstrndx * self.LEN_SEC_HEADER) not in section_header_offsets:
             raise FatalError(f"ELF file has no STRTAB section at shstrndx {shstrndx}")
         _, sec_type, _, sec_size, sec_offs, _flags, align = read_section_header(
             shstrndx * self.LEN_SEC_HEADER
         )
-        if sec_type != ELFFile.SEC_TYPE_STRTAB:
+        if sec_type != SEC_TYPE_STRTAB:
             log.warning(f"ELF file has incorrect STRTAB section type {sec_type:#04x}")
         f.seek(sec_offs)
         string_table = f.read(sec_size)
@@ -1404,23 +1408,42 @@ def read_data(offs, size):
             f.seek(offs)
             return f.read(size)
 
-        prog_sections = [
-            ELFSection(
-                lookup_string(n_offs),
-                lma,
-                read_data(offs, size),
-                flags=_flags,
-                align=align,
-            )
-            for (n_offs, _type, lma, size, offs, _flags, align) in prog_sections
-            if lma != 0 and size > 0
-        ]
-        self.sections = prog_sections
-        self.nobits_sections = [
-            ELFSection(lookup_string(n_offs), lma, b"", flags=_flags, align=align)
-            for (n_offs, _type, lma, size, offs, _flags, align) in nobits_secitons
-            if lma != 0 and size > 0
-        ]
+        all_sections = [read_section_header(offs) for offs in section_header_offsets]
+
+        self.sections = []
+        self.nobits_sections = []
+        # Process all sections and raise an error if an unknown section type is found
+        for section in all_sections:
+            n_offs, sec_type, lma, size, offs, _flags, align = section
+
+            # Skip sections with lma == 0 or size == 0
+            if lma == 0 or size == 0:
+                continue
+
+            if sec_type not in KNOWN_SEC_TYPES:
+                log.warning(f"Unknown section type {sec_type:#04x} in ELF file")
+                continue
+
+            if sec_type in PROG_SEC_TYPES:
+                self.sections.append(
+                    ELFSection(
+                        lookup_string(n_offs),
+                        lma,
+                        read_data(offs, size),
+                        flags=_flags,
+                        align=align,
+                    )
+                )
+            elif sec_type == SEC_TYPE_NOBITS:
+                self.nobits_sections.append(
+                    ELFSection(
+                        lookup_string(n_offs),
+                        lma,
+                        b"",
+                        flags=_flags,
+                        align=align,
+                    )
+                )
 
     def _read_segments(self, f, segment_header_offs, segment_header_count, shstrndx):
         f.seek(segment_header_offs)

pyproject.toml

@@ -78,7 +78,7 @@
 
 [tool.commitizen]
     name = "czespressif"
-    version = "5.0.0"
+    version = "5.0.1"
     update_changelog_on_bump = true
     tag_format = "v$version"
     changelog_start_rev = "v4.2.1"

test/test_esptool_sdm.py

@@ -5,8 +5,9 @@
 #
 # How to use:
 #
-# Run with a physical connection to a chip:
-#  - `pytest test_esptool_sdm.py --chip esp32 --port /dev/ttyUSB0 --baud 115200`
+# Run with a physical connection to a chip (ESP8266 and ESP32 do not support
+# secure download mode):
+#  - `pytest test_esptool_sdm.py --chip esp32s2 --port /dev/ttyUSB0 --baud 115200`
 #
 # where  - --port       - a serial port for esptool operation
 #        - --chip       - ESP chip name
@@ -17,27 +18,20 @@
 
 
 @pytest.mark.skipif(
-    arg_chip == "esp8266", reason="ESP8266 does not support Secure Download Mode"
+    arg_chip in ("esp8266", "esp32"),
+    reason="ESP8266 and ESP32 do not support secure download mode",
 )
 class TestSecureDownloadMode(EsptoolTestCase):
     expected_chip_name = esptool.util.expand_chip_name(arg_chip)
 
-    @pytest.mark.skipif(
-        arg_chip in ("esp8266", "esp32"),
-        reason="No get-security-info on ESP8266 and ESP32",
-    )
     def test_auto_detect(self):
         output = self.run_esptool("get-security-info", chip="auto")
 
-        if arg_chip == "esp32s2":  # no autodetection from security info, only magic no.
-            assert "Secure Download Mode is enabled" in output
-            assert "autodetection will not work" in output
-        else:
-            assert f"Detecting chip type... {self.expected_chip_name}" in output
-            assert (
-                f"{'Chip type:':<20}{self.expected_chip_name} "
-                "in Secure Download Mode" in output
-            )
+        assert f"Detecting chip type... {self.expected_chip_name}" in output
+        assert (
+            f"{'Chip type:':<20}{self.expected_chip_name} "
+            "in Secure Download Mode" in output
+        )
 
     # Commands not supported in SDM
     def test_sdm_incompatible_commands(self):
@@ -65,6 +59,5 @@ def test_sdm_compatible_commands(self):
         assert "Stub flasher is not supported in Secure Download Mode" in output
         assert "Flash memory region erased successfully" in output
 
-        if arg_chip != "esp32":  # esp32 does not support get-security-info
-            output = self.run_esptool("get-security-info")
-            assert "Security Information:" in output
+        output = self.run_esptool("get-security-info")
+        assert "Security Information:" in output

test/test_imagegen.py

@@ -539,6 +539,68 @@ def test_hash_append(self):
         assert bytes(expected_bin_without_hash) == bin_without_hash
 
 
+class TestELFSectionHandling(BaseTestCase):
+    """Test ELF section type handling and related functionality."""
+
+    @staticmethod
+    def _modify_section_type(elf_path, section_name, new_type):
+        """
+        Modify the type of a specific section in the ELF file.
+        """
+        with open(elf_path, "rb+") as f:
+            elf = ELFFile(f)
+            section = elf.get_section_by_name(section_name)
+
+            index = elf.get_section_index(section_name)
+            # Calculate the section header's position in the file (using section index,
+            # the section header table's offset and section header entry size)
+            sh_entry_offset = elf.header["e_shoff"] + index * elf.header["e_shentsize"]
+
+            # Modify the section type in the header
+            section.header.sh_type = new_type
+
+            f.seek(sh_entry_offset)
+            f.write(elf.structs.Elf_Shdr.build(section.header))
+
+    @staticmethod
+    def _get_section_type(elf_path, section_name):
+        """
+        Get the current type of a specific section in the ELF file.
+        """
+        with open(elf_path, "rb") as f:
+            elf = ELFFile(f)
+            section = elf.get_section_by_name(section_name)
+            return section.header.sh_type
+
+    def test_unknown_section_type_warning(self, capsys):
+        """Test that unknown section types generate the expected warning message."""
+        ELF = "esp32c6-appdesc.elf"
+        BIN = "esp32c6-appdesc.bin"
+        SECTION_NAME = ".flash.appdesc"
+        UNKNOWN_TYPE = 0x99
+
+        original_sec_type = self._get_section_type(ELF, SECTION_NAME)
+
+        # Modify the section to have an unknown type
+        self._modify_section_type(ELF, SECTION_NAME, UNKNOWN_TYPE)
+
+        # Verify the section was actually modified
+        modified_type = self._get_section_type(ELF, SECTION_NAME)
+        assert modified_type == UNKNOWN_TYPE
+
+        try:
+            self.run_elf2image("esp32c6", ELF, allow_warnings=True)
+            output = capsys.readouterr().out
+            print(output)
+
+            expected_warning = f"Unknown section type {UNKNOWN_TYPE:#04x} in ELF file"
+            assert expected_warning in output
+
+        finally:
+            self._modify_section_type(ELF, SECTION_NAME, original_sec_type)
+            try_delete(BIN)
+
+
 class TestMMUPageSize(BaseTestCase):
     def test_appdesc_aligned(self, capsys):
         ELF = "esp32c6-appdesc.elf"