Return U-Boot-related information

Author: AT0myks

README.md

@@ -54,7 +54,7 @@ provided on PyPI.
 
 ### Command line
 
-#### List
+#### Info
 
 ```
 $ reolinkfw info file_or_url
@@ -74,6 +74,10 @@ $ reolinkfw info RLC-410-5MP_20_20052300.zip -i 2
     "detail_machine_type": "IPC_51516M5M",
     "type": "IPC",
     "version_file": "20_20052300",
+    "os": "Linux",
+    "architecture": "MIPS",
+    "kernel_image_name": "Linux-4.1.0",
+    "uboot_version": "U-Boot 2014.07 (Feb 26 2019 - 18:20:07)",
     "filesystems": [
       {
         "name": "fs",

reolinkfw/__init__.py

@@ -2,7 +2,6 @@
 import io
 import posixpath
 import re
-from enum import Enum
 from pathlib import Path
 from typing import Optional
 from urllib.parse import parse_qsl, urlparse
@@ -13,16 +12,14 @@
 from lxml.html import document_fromstring
 from pakler import PAK, Section, is_pak_file
 from pycramfs import Cramfs
-from pycramfs.const import MAGIC_BYTES as CRAMFS_MAGIC
 from PySquashfsImage import SquashFsImage
-from PySquashfsImage.const import SQUASHFS_MAGIC
-from ubireader.ubi.defines import UBI_EC_HDR_MAGIC as UBI_MAGIC
 from ubireader.ubifs import ubifs, walk
-from ubireader.ubifs.defines import UBIFS_NODE_MAGIC as UBIFS_MAGIC
 from ubireader.ubifs.output import _process_reg_file
 
+from reolinkfw.uboot import get_arch_name, get_uboot_version, get_uimage_header
 from reolinkfw.util import (
     DummyLEB,
+    FileType,
     get_cache_file,
     get_fs_from_ubi,
     has_cache,
@@ -39,20 +36,6 @@
 FS_SECTIONS = ROOTFS_SECTIONS + ["app"]
 
 
-class FileSystem(Enum):
-    CRAMFS = CRAMFS_MAGIC
-    SQUASHFS = SQUASHFS_MAGIC.to_bytes(4, "little")
-    UBI = UBI_MAGIC  # Not a file system
-    UBIFS = UBIFS_MAGIC
-
-    @classmethod
-    def from_magic(cls, key, default=None):
-        try:
-            return cls(key)
-        except ValueError:
-            return default
-
-
 async def download(url):
     """Return resource as bytes.
 
@@ -118,10 +101,10 @@ def get_files_from_ubifs(binbytes):
 
 def get_files_from_ubi(fd, size, offset=0):
     fsbytes = get_fs_from_ubi(fd, size, offset)
-    fs = FileSystem.from_magic(fsbytes[:4])
-    if fs == FileSystem.UBIFS:
+    fs = FileType.from_magic(fsbytes[:4])
+    if fs == FileType.UBIFS:
         return get_files_from_ubifs(fsbytes)
-    elif fs == FileSystem.SQUASHFS:
+    elif fs == FileType.SQUASHFS:
         return get_files_from_squashfs(io.BytesIO(fsbytes))
     raise Exception("Unknown file system in UBI")
 
@@ -150,7 +133,7 @@ def get_fs_info(pak: PAK, fs_sections: list[Section]) -> list[dict[str, str]]:
     result = []
     for section in fs_sections:
         pak._fd.seek(section.start)
-        fs = FileSystem.from_magic(pak._fd.read(4))
+        fs = FileType.from_magic(pak._fd.read(4))
         result.append({
             "name": section.name,
             "type": fs.name.lower() if fs is not None else "unknown"
@@ -163,17 +146,25 @@ async def get_info_from_pak(pak: PAK):
     fs_sections = [s for s in pak.sections if s.name in FS_SECTIONS]
     app = fs_sections[-1]
     pak._fd.seek(app.start)
-    fs = FileSystem.from_magic(pak._fd.read(4))
-    if fs == FileSystem.CRAMFS:
+    fs = FileType.from_magic(pak._fd.read(4))
+    if fs == FileType.CRAMFS:
         files = await asyncio.to_thread(get_files_from_cramfs, pak._fd, app.start, False)
-    elif fs == FileSystem.UBI:
+    elif fs == FileType.UBI:
         files = await asyncio.to_thread(get_files_from_ubi, pak._fd, app.len, app.start)
-    elif fs == FileSystem.SQUASHFS:
+    elif fs == FileType.SQUASHFS:
         files = await asyncio.to_thread(get_files_from_squashfs, pak._fd, app.start, False)
     else:
         return {"error": "Unrecognized image type", "sha256": ha}
-    info = get_info_from_files(files)
-    return {**info, "filesystems": get_fs_info(pak, fs_sections), "sha256": ha}
+    uimage = get_uimage_header(pak)
+    return {
+        **get_info_from_files(files),
+        "os": "Linux" if uimage.os == 5 else "Unknown",
+        "architecture": get_arch_name(uimage.arch),
+        "kernel_image_name": uimage.name,
+        "uboot_version": get_uboot_version(pak),
+        "filesystems": get_fs_info(pak, fs_sections),
+        "sha256": ha
+    }
 
 
 async def direct_download_url(url):

reolinkfw/extract.py

@@ -10,32 +10,32 @@
 from ubireader.ubifs import ubifs
 from ubireader.ubifs.output import extract_files as extract_ubifs
 
-from reolinkfw import FS_SECTIONS, ROOTFS_SECTIONS, FileSystem
-from reolinkfw.util import DummyLEB, get_fs_from_ubi
+from reolinkfw import FS_SECTIONS, ROOTFS_SECTIONS
+from reolinkfw.util import DummyLEB, FileType, get_fs_from_ubi
 
 
 def extract_file_system(pak: PAK, section: Section, dest: Path = None):
     dest = (Path.cwd() / "reolink_fs") if dest is None else dest
     dest.mkdir(parents=True, exist_ok=True)
     pak._fd.seek(section.start)
-    fs = FileSystem.from_magic(pak._fd.read(4))
-    if fs == FileSystem.UBI:
+    fs = FileType.from_magic(pak._fd.read(4))
+    if fs == FileType.UBI:
         fs_bytes = get_fs_from_ubi(pak._fd, section.len, section.start)
-        fs = FileSystem.from_magic(fs_bytes[:4])
-        if fs == FileSystem.UBIFS:
+        fs = FileType.from_magic(fs_bytes[:4])
+        if fs == FileType.UBIFS:
             with DummyLEB.from_bytes(fs_bytes) as leb:
                 with redirect_stdout(StringIO()):
                     # If files already exist they are not written again.
                     extract_ubifs(ubifs(leb), dest)
-        elif fs == FileSystem.SQUASHFS:
+        elif fs == FileType.SQUASHFS:
             with SquashFsImage.from_bytes(fs_bytes) as image:
                 extract_squashfs(image.root, dest, True)
         else:
             raise Exception("Unknown file system in UBI")
-    elif fs == FileSystem.SQUASHFS:
+    elif fs == FileType.SQUASHFS:
         with SquashFsImage(pak._fd, section.start, False) as image:
             extract_squashfs(image.root, dest, True)
-    elif fs == FileSystem.CRAMFS:
+    elif fs == FileType.CRAMFS:
         with Cramfs.from_fd(pak._fd, section.start, False) as image:
             extract_cramfs(image.rootdir, dest, True)
     else:

reolinkfw/uboot.py

@@ -0,0 +1,114 @@
+import re
+from ctypes import BigEndianStructure, c_char, c_uint32, c_uint8, sizeof
+from enum import IntEnum
+
+from pakler import PAK
+
+from reolinkfw.util import FileType
+
+UBOOT_MAGIC = 0x27051956
+
+
+class Arch(IntEnum):
+    ARM = 2
+    MIPS = 5
+    ARM64 = 22
+
+
+class LegacyImageHeader(BigEndianStructure):
+    _fields_ = [
+        ("_magic", c_uint32),
+        ("_hcrc", c_uint32),
+        ("_time", c_uint32),
+        ("_size", c_uint32),
+        ("_load", c_uint32),
+        ("_ep", c_uint32),
+        ("_dcrc", c_uint32),
+        ("_os", c_uint8),
+        ("_arch", c_uint8),
+        ("_type", c_uint8),
+        ("_comp", c_uint8),
+        ("_name", c_char * 32),
+    ]
+
+    @property
+    def magic(self) -> int:
+        return self._magic
+
+    @property
+    def hcrc(self) -> int:
+        return self._hcrc
+
+    @property
+    def time(self) -> int:
+        return self._time
+
+    @property
+    def size(self) -> int:
+        return self._size
+
+    @property
+    def load(self) -> int:
+        return self._load
+
+    @property
+    def ep(self) -> int:
+        return self._ep
+
+    @property
+    def dcrc(self) -> int:
+        return self._dcrc
+
+    @property
+    def os(self) -> int:
+        return self._os
+
+    @property
+    def arch(self) -> Arch:
+        return Arch(self._arch)
+
+    @property
+    def type(self) -> int:
+        return self._type
+
+    @property
+    def comp(self) -> int:
+        return self._comp
+
+    @property
+    def name(self) -> str:
+        return self._name.decode()
+
+    @classmethod
+    def from_fd(cls, fd):
+        return cls.from_buffer_copy(fd.read(sizeof(cls)))
+
+
+def get_uboot_version(pak: PAK):
+    for section in pak.sections:
+        if section.len and "uboot" in section.name.lower():
+            # This section is always named 'uboot' or 'uboot1'.
+            pak._fd.seek(section.start)
+            match = re.search(b"U-Boot [0-9]{4}\.[0-9]{2}.*? \(.*?\)", pak._fd.read(section.len))
+            return match.group().decode() if match is not None else None
+    return None
+
+
+def get_uimage_header(pak: PAK) -> LegacyImageHeader:
+    for section in pak.sections:
+        pak._fd.seek(section.start)
+        if section.len and FileType.from_magic(pak._fd.read(4)) == FileType.UIMAGE:
+            # This section is always named 'KERNEL' or 'kernel'.
+            pak._fd.seek(section.start)
+            return LegacyImageHeader.from_fd(pak._fd)
+    raise Exception("No kernel section found")
+
+
+def get_arch_name(arch: Arch) -> str:
+    if arch == Arch.ARM:
+        return "ARM"
+    elif arch == Arch.MIPS:
+        return "MIPS"
+    elif arch == Arch.ARM64:
+        return "AArch64"
+    raise Exception("Unknown architecture")

reolinkfw/util.py

@@ -1,6 +1,7 @@
 import hashlib
 import io
 from contextlib import contextmanager
+from enum import Enum
 from functools import partial
 from os import scandir
 from pathlib import Path
@@ -9,8 +10,12 @@
 from zipfile import is_zipfile
 
 from pakler import PAK, is_pak_file
+from pycramfs.const import MAGIC_BYTES as CRAMFS_MAGIC
+from PySquashfsImage.const import SQUASHFS_MAGIC
 from ubireader.ubi import ubi
+from ubireader.ubi.defines import UBI_EC_HDR_MAGIC as UBI_MAGIC
 from ubireader.ubi_io import ubi_file, leb_virtual_file
+from ubireader.ubifs.defines import UBIFS_NODE_MAGIC as UBIFS_MAGIC
 from ubireader.utils import guess_peb_size
 
 from reolinkfw.tmpfile import TempFile
@@ -19,6 +24,21 @@
 ONEGIB = 1024**3
 
 
+class FileType(Enum):
+    CRAMFS = CRAMFS_MAGIC
+    SQUASHFS = SQUASHFS_MAGIC.to_bytes(4, "little")
+    UBI = UBI_MAGIC
+    UBIFS = UBIFS_MAGIC
+    UIMAGE = 0x27051956.to_bytes(4, "big")
+
+    @classmethod
+    def from_magic(cls, key, default=None):
+        try:
+            return cls(key)
+        except ValueError:
+            return default
+
+
 class DummyLEB:
     """A class that emulates ubireader's `leb_virtual_file`."""