fastboot-oem-extractor 1.0.0__py3-none-any.whl

fastboot_oem_extractor/__init__.py

@@ -0,0 +1,18 @@
+"""Python library to extract hidden 'fastboot oem' commands from firmware blobs"""
+
+# Extract hidden "fastboot oem" commands from firmware blobs
+# Copyright (C) 2026 chkndrp
+#
+# This library is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+
+from .extract import extract_commands
+
+__all__ = ["extract_commands"]

fastboot_oem_extractor/__main__.py

@@ -0,0 +1,17 @@
+# Extract hidden "fastboot oem" commands from firmware blobs
+# Copyright (C) 2026 chkndrp
+#
+# This library is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fastboot_oem_extractor/cli.py

@@ -0,0 +1,72 @@
+"""CLI interface."""
+
+# Extract hidden "fastboot oem" commands from firmware blobs
+# Copyright (C) 2026 chkndrp
+#
+# This library is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+
+import argparse
+import logging
+
+from collections.abc import Sequence
+from pathlib import Path
+from .extract import _scan_firmware
+
+logger = logging.getLogger("fastboot-oem-extractor")
+
+
+class _PrefixFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        return f"(x) {super().format(record)}"
+
+
+def _configure_logging() -> None:
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(_PrefixFormatter("%(message)s"))
+        logger.addHandler(handler)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """CLI main entry"""
+
+    _configure_logging()
+
+    parser = argparse.ArgumentParser(
+        description='Extract hidden "fastboot oem" commands from firmware blobs'
+    )
+    parser.add_argument(
+        "file",
+        help="Firmware file to analyze"
+    )
+    parser.add_argument(
+        "-fsl", "--force-string-lookup",
+        help="Force string lookup on unsupported files",
+        action="store_true",
+        dest="fsl",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        commands, recognized = _scan_firmware(Path(args.file), args.fsl)
+    except OSError as error:
+        logger.error("Cannot read file (%s): %s", args.file, error)
+        return 1
+
+    if commands:
+        print("\n" + "\n".join(commands))
+
+    if recognized == 0:
+        return 1
+    return 0

fastboot_oem_extractor/extract.py

@@ -0,0 +1,209 @@
+"""Main entry"""
+
+# Extract hidden "fastboot oem" commands from firmware blobs
+# Copyright (C) 2026 chkndrp
+#
+# This library is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+
+import contextlib
+import logging
+import re
+import tempfile
+
+from pathlib import Path
+from uefi_firmware import AutoParser
+
+BL_MAGIC_PATTERNS = [
+    bytes.fromhex("4D 5A"),        # Portable Executable (PE)
+    bytes.fromhex("88 16 88 58"),  # Little Kernel (LK)
+    bytes.fromhex("46 42 50 4B"),  # FBPK container
+    bytes.fromhex("44 48 54 42"),  # DHTB signed binary
+    bytes.fromhex("7F 45 4C 46"),  # ELF binary
+    bytes.fromhex("41 4E 44 52 4F 49 44 21"),  # Second bootloaders
+]
+
+logger = logging.getLogger("fastboot-oem-extractor")
+
+
+def _find_oem_commands(data: bytes, quiet: bool = False) -> list[str]:
+    """Find and return OEM command strings in firmware data"""
+
+    strings = re.findall(rb"oem\s+([^\x00\n]+)", data, re.IGNORECASE)
+    commands: set[str] = set()
+
+    for raw_value in strings:
+        value = raw_value.decode("ascii", "ignore").strip()
+        command = f"fastboot oem {value}"
+
+        if not 2 <= len(f"oem {value}".split()) <= 5:
+            continue
+        if any(character in value for character in "<>/%"):
+            continue
+
+        commands.add(command)
+    if commands:
+        logger.info("Matching 'oem *' ascii strings")
+    elif not quiet:
+        logger.info("No fastboot oem commands found")
+
+    return sorted(commands)
+
+
+def _extract_pe_files(parser: AutoParser) -> list[str]:
+    """Extract firmware file and search for portable executables"""
+
+    commands: set[str] = set()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        logger.info("Extracting firmware...")
+
+        with contextlib.redirect_stdout(None), contextlib.redirect_stderr(None):
+            parsed = parser.parse()
+
+            if parsed is not None:
+                parsed.dump(tmpdir)
+
+        pe_files = list(Path(tmpdir).rglob("*.pe"))
+        if not pe_files:
+            logger.info("No UEFI portable executables found")
+            return []
+
+        logger.info("Found %s UEFI portable executable(s)", len(pe_files))
+        for pe_file in pe_files:
+            commands.update(
+                _find_oem_commands(
+                    pe_file.read_bytes(),
+                    quiet=True
+                )
+            )
+
+    return sorted(commands)
+
+
+def _check_uefi_structure(data: bytes) -> list[str] | None:
+    """Search for UEFI firmware structure (first 10MB)"""
+
+    max_offsets = min(len(data) // 2048, 100)
+
+    for offset_index in range(max_offsets):
+        offset = offset_index * 2048
+
+        with contextlib.redirect_stdout(None), contextlib.redirect_stderr(None):
+            parser = AutoParser(
+                data[offset:],
+                search=False
+            )
+
+        if parser.type() != "unknown":
+            logger.info("Found valid UEFI firmware structure at offset: 0x%x", offset)
+            return _extract_pe_files(parser)
+
+    return None
+
+
+def _extract_bootloader_pe_files(firmware_file: Path) -> list[str] | None:
+    """Extract PE files from bootloader (first 10MB)"""
+
+    with firmware_file.open("rb") as firmware:
+        bootloader_data = firmware.read(10 * 1024 * 1024)
+
+    pe_offsets = [
+        offset
+        for offset in range(len(bootloader_data) - 1)
+        if bootloader_data[offset:offset + 2] == b"MZ"
+    ]
+
+    if not pe_offsets:
+        return None
+
+    logger.info("Found %s embedded PE file(s)", len(pe_offsets))
+    commands: set[str] = set()
+
+    for index, offset in enumerate(pe_offsets):
+        end_offset = (
+            pe_offsets[index + 1]
+            if index + 1 < len(pe_offsets)
+            else len(bootloader_data)
+        )
+
+        commands.update(
+            _find_oem_commands(
+                bootloader_data[offset:end_offset],
+                quiet=True
+            )
+        )
+
+    return sorted(commands)
+
+
+def _scan_firmware(firmware_file: Path, force_string_lookup: bool) -> tuple[list[str], bool]:
+    """Scan a firmware file for fastboot OEM commands"""
+
+    if force_string_lookup:
+        return _find_oem_commands(firmware_file.read_bytes()), True
+
+    with firmware_file.open("rb") as firmware:
+        header = firmware.read(0x50)
+
+    if header.startswith(BL_MAGIC_PATTERNS[0]):
+        logger.info("File contains portable executable magic bytes")
+
+        commands = _extract_bootloader_pe_files(firmware_file)
+        if commands is not None:
+            return commands, True
+    elif any(header.startswith(pattern) for pattern in BL_MAGIC_PATTERNS[1:]):
+        logger.info("File contains common bootloader magic bytes")
+
+        commands = _find_oem_commands(
+            firmware_file.read_bytes(),
+            quiet=True
+        )
+
+        if commands:
+            return commands, True
+
+    logger.info("Reading firmware file (first 10MB): %s", firmware_file)
+    with firmware_file.open("rb") as firmware:
+        input_data = firmware.read(10 * 1024 * 1024)
+
+    commands = _check_uefi_structure(input_data)
+    if commands is not None:
+        return commands, True
+
+    logger.error("Could not recognize the provided firmware file")
+    return [], False
+
+
+def extract_commands(firmware_file: str | Path, force_string_lookup: bool = False) -> list[str] | None:
+    """
+    Extract unique 'fastboot oem' commands from a firmware file
+
+    :param firmware_file: Path to the firmware image.
+    :type firmware_file: str | pathlib.Path
+
+    :param force_string_lookup: Force the oem command string lookup on raw images.
+    :type force_string_lookup: bool
+
+    :returns: A sorted list of command strings when the format is
+        recognized; an empty list if no commands are found; or `None` if the format
+        is unrecognized and `force_string_lookup` is `False`.
+    :rtype: list[str] | None
+    :raises OSError: If the firmware file cannot be read.
+    """
+
+    commands, recognized = _scan_firmware(
+        Path(firmware_file),
+        force_string_lookup
+    )
+
+    if recognized:
+        return commands
+    return None

fastboot_oem_extractor-1.0.0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: fastboot-oem-extractor
+Version: 1.0.0
+Summary: Extract hidden "fastboot oem" commands from firmware blobs
+Author-email: chkndrp <chkndrp@gmail.com>
+License-Expression: LGPL-3.0-only
+Project-URL: Repository, https://github.com/chkndrp/fastboot-oem-extractor
+Project-URL: Issues, https://github.com/chkndrp/fastboot-oem-extractor/issues
+Project-URL: Changelog, https://github.com/chkndrp/fastboot-oem-extractor/blob/master/CHANGELOG.md
+Project-URL: Homepage, https://github.com/chkndrp/fastboot-oem-extractor/blob/master/README.md
+Keywords: android,fastboot,oem,extractor,research,uefi,lk,abl,bootloader,cli,library
+Classifier: Programming Language :: Python :: 3
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Environment :: Console
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: uefi_firmware==1.16
+Provides-Extra: dev
+Requires-Dist: pylint>=4.1.3; extra == "dev"
+Dynamic: license-file
+
+# fastboot-oem-extractor
+![PyPI - Version](https://img.shields.io/pypi/v/fastboot_oem_extractor?logo=python&logoColor=white) ![PyPI - Downloads](https://img.shields.io/pypi/dm/fastboot_oem_extractor?logo=python&logoColor=white) ![PyPI - Typing](https://img.shields.io/pypi/types/fastboot_oem_extractor?logo=python&logoColor=white)
+
+Extract hidden "fastboot oem" commands from firmware blobs
+
+## Supported firmware
+These firmware blobs will be accepted by this tool 
+- `ABL` (Qualcomm)
+- `LK1st, LK2nd` (Qualcomm, Second BLs)
+- `LK` (MediaTek)
+- `FBPK` Containers (Google)
+- `DHTB` Signed binaries (U-Boot)
+- `ELF` Linux binaries
+- Anything else containing UEFI PEs
+
+This is an artificial barrier for when this tool is ran in a loop against firmware images
+
+## Using as a CLI tool:
+1. Installing:
+```shell
+# With PyPi (recommended)
+pip install fasboot_oem_extractor
+```
+
+```shell
+# From source/clone
+pip install -r requirements.txt
+```
+
+2. Prepare your firmware images from the internet, or by pulling them off the device with `adb`
+3. Run the installed CLI against the image
+```shell
+# PyPi
+python -m fastboot_oem_extractor ./abl.elf
+```
+
+```shell
+# Source/clone
+python ./extractor.py ./abl.elf
+```
+
+4. Fetch the output
+```shell
+# Example output for Redmi Note 14 Pro+ 5G (amethyst)
+            
+(x) File contains common bootloader magic bytes
+(x) Reading firmware file (first 10MB): abl.elf
+(x) Found valid UEFI firmware structure at offset: 0x1000
+(x) Extracting firmware...
+(x) Found 1 UEFI portable executable(s)
+(x) Matching 'oem *' ascii strings
+
+fastboot oem allow-wipe-userdata
+fastboot oem audio-framework
+fastboot oem device-info
+fastboot oem disable-charger-screen
+fastboot oem dm-verity-enforcing
+fastboot oem edl
+fastboot oem enable-charger-screen
+fastboot oem fbreason
+fastboot oem getguid
+fastboot oem hwid
+fastboot oem lkmsg
+fastboot oem lock
+fastboot oem lpmsg
+fastboot oem off-mode-charge
+fastboot oem poweroff
+fastboot oem ramdump fat
+fastboot oem select-display-panel
+fastboot oem set-gpu-preemption
+fastboot oem set-hw-fence-value
+fastboot oem uart-enable
+fastboot oem uefilog
+fastboot oem unlock
+```
+
+If your file is some sparse image that does not contain any UEFI PEs or common binary magic bytes,
+you can force the string lookup via this command line option:
+```shell
+--force-string-lookup
+```
+
+### Using as a Python library
+This project can also be used as a library for other tools that want to integrate this.
+There is one public function:
+
+```python
+extract_commands(firmware_file, force_string_lookup=False) -> list[str] | None
+```
+
+- `firmware_file` (`str | pathlib.Path`): Path to the firmware image.
+- `force_string_lookup` (`bool`): Force the oem command string lookup on raw images. Defaults to `False`.
+- **Returns:** 
+    - A sorted list of unique command strings when the format is recognized.
+    - An empty list if no commands are found.
+    - `None` if the format is unrecognized and `force_string_lookup` is `False`.
+- **Raises:** `OSError` if the file cannot be read.
+
+**Quick example:**
+```python
+# from pathlib import Path
+from fastboot_oem_extractor import extract_commands
+
+# commands = extract_commands(Path("./abl.elf"))
+commands = extract_commands("./abl.elf")
+
+if commands is None:
+    print("Unrecognized firmware format.")
+elif commands:
+    print(commands)
+    # Example output: ['fastboot oem allow-wipe-userdata', ...]
+else:
+    print("No OEM commands found.")
+```
+
+## Disclaimer:
+Due to the nature of simply matching "oem" strings, the output may contain some invalid commands,
+or commands that don't work after the device is sent out of factory. Keep this in mind
+
+Also, some FBPK containers (e.g. `barbret` bootloader) are very difficult to extract
+`oem` commands from, and may not work. Most work just fine though.
+
+## Similar project
+If you want to extract bootloader/charging pictures from a `imagefv` partition on your Qualcomm device,
+use my other tool:
+
+[chkndrp/imagefv-extractor](https://github.com/chkndrp/imagefv-extractor)
+
+## Requirements
+- Python 3.10 or newer
+- Installed `uefi_firmware` pip package

fastboot_oem_extractor-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+fastboot_oem_extractor/__init__.py,sha256=og6ZbI5ixYw_P8vG3beXLwgjA7EpNW7NqqZvi4SINvA,753
+fastboot_oem_extractor/__main__.py,sha256=vwjCDH70IOf7uc-ZCo_3KimD4hKJaocvUWPz_wIHxow,678
+fastboot_oem_extractor/cli.py,sha256=NHln8uYsgbOR8nfjq6MQ-0TYDF0PDFh_eKNzxpKWv1s,2063
+fastboot_oem_extractor/extract.py,sha256=s1Y6Gy68eHmTG9OoEUIcw66kAAa731pSMkxoQiOiSl0,6495
+fastboot_oem_extractor-1.0.0.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+fastboot_oem_extractor-1.0.0.dist-info/METADATA,sha256=h684iWafoACbkwe5AfqukT-exC0JDbdRp4TxaF5SnBQ,5337
+fastboot_oem_extractor-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+fastboot_oem_extractor-1.0.0.dist-info/entry_points.txt,sha256=tumKFsfxuhO9rXgF8tVmY4SB7U2y4Q-lTVaEZ89TVTE,75
+fastboot_oem_extractor-1.0.0.dist-info/top_level.txt,sha256=fWOPTxHh8rUzz0t5BUiRSF4Al63KQMzVz-MICS7HZ9E,23
+fastboot_oem_extractor-1.0.0.dist-info/RECORD,,

fastboot_oem_extractor-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fastboot_oem_extractor-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fastboot-oem-extractor = fastboot_oem_extractor.cli:main

fastboot_oem_extractor-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

fastboot_oem_extractor-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastboot_oem_extractor