dumpbootimg

#!/usr/bin/env python3

import sys
from pkg_resources import parse_version
from kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO

if parse_version(ks_version) < parse_version('0.7'):
    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))

class AndroidImg(KaitaiStruct):
    """
    .. seealso::
       Source - https://source.android.com/devices/bootloader/boot-image-header
    """
    def __init__(self, _io, _parent=None, _root=None):
        self._io = _io
        self._parent = _parent
        self._root = _root if _root else self
        self._read()

    def _read(self):
        self.magic = self._io.ensure_fixed_contents(b"\x41\x4E\x44\x52\x4F\x49\x44\x21")
        self.kernel = self._root.Load(self._io, self, self._root)
        self.ramdisk = self._root.Load(self._io, self, self._root)
        self.second = self._root.Load(self._io, self, self._root)
        self.tags_load = self._io.read_u4le()
        self.page_size = self._io.read_u4le()
        self.header_version = self._io.read_u4le()
        self.os_version = self._root.OsVersion(self._io, self, self._root)
        self.name = (KaitaiStream.bytes_terminate(self._io.read_bytes(16), 0, False)).decode(u"ASCII")
        self.cmdline = (KaitaiStream.bytes_terminate(self._io.read_bytes(512), 0, False)).decode(u"ASCII")
        self.sha = self._io.read_bytes(32)
        self.extra_cmdline = (KaitaiStream.bytes_terminate(self._io.read_bytes(1024), 0, False)).decode(u"ASCII")
        if self.header_version > 0:
            self.recovery_dtbo = self._root.SizeOffset(self._io, self, self._root)

        if self.header_version > 0:
            self.boot_header_size = self._io.read_u4le()

        if self.header_version > 1:
            self.dtb = self._root.LoadLong(self._io, self, self._root)


    class Load(KaitaiStruct):
        def __init__(self, _io, _parent=None, _root=None):
            self._io = _io
            self._parent = _parent
            self._root = _root if _root else self
            self._read()

        def _read(self):
            self.size = self._io.read_u4le()
            self.addr = self._io.read_u4le()


    class LoadLong(KaitaiStruct):
        def __init__(self, _io, _parent=None, _root=None):
            self._io = _io
            self._parent = _parent
            self._root = _root if _root else self
            self._read()

        def _read(self):
            self.size = self._io.read_u4le()
            self.addr = self._io.read_u8le()


    class SizeOffset(KaitaiStruct):
        def __init__(self, _io, _parent=None, _root=None):
            self._io = _io
            self._parent = _parent
            self._root = _root if _root else self
            self._read()

        def _read(self):
            self.size = self._io.read_u4le()
            self.offset = self._io.read_u8le()


    class OsVersion(KaitaiStruct):
        def __init__(self, _io, _parent=None, _root=None):
            self._io = _io
            self._parent = _parent
            self._root = _root if _root else self
            self._read()

        def _read(self):
            self.version = self._io.read_u4le()

        @property
        def month(self):
            if hasattr(self, '_m_month'):
                return self._m_month if hasattr(self, '_m_month') else None

            self._m_month = (self.version & 15)
            return self._m_month if hasattr(self, '_m_month') else None

        @property
        def patch(self):
            if hasattr(self, '_m_patch'):
                return self._m_patch if hasattr(self, '_m_patch') else None

            self._m_patch = ((self.version >> 11) & 127)
            return self._m_patch if hasattr(self, '_m_patch') else None

        @property
        def year(self):
            if hasattr(self, '_m_year'):
                return self._m_year if hasattr(self, '_m_year') else None

            self._m_year = (((self.version >> 4) & 127) + 2000)
            return self._m_year if hasattr(self, '_m_year') else None

        @property
        def major(self):
            if hasattr(self, '_m_major'):
                return self._m_major if hasattr(self, '_m_major') else None

            self._m_major = ((self.version >> 25) & 127)
            return self._m_major if hasattr(self, '_m_major') else None

        @property
        def minor(self):
            if hasattr(self, '_m_minor'):
                return self._m_minor if hasattr(self, '_m_minor') else None

            self._m_minor = ((self.version >> 18) & 127)
            return self._m_minor if hasattr(self, '_m_minor') else None


    @property
    def kernel_img(self):
        if hasattr(self, '_m_kernel_img'):
            return self._m_kernel_img if hasattr(self, '_m_kernel_img') else None

        _pos = self._io.pos()
        self._io.seek(self.page_size)
        self._m_kernel_img = self._io.read_bytes(self.kernel.size)
        self._io.seek(_pos)
        return self._m_kernel_img if hasattr(self, '_m_kernel_img') else None

    @property
    def tags_offset(self):
        """tags offset from base."""
        if hasattr(self, '_m_tags_offset'):
            return self._m_tags_offset if hasattr(self, '_m_tags_offset') else None

        self._m_tags_offset = (self.tags_load - self.base)
        return self._m_tags_offset if hasattr(self, '_m_tags_offset') else None

    @property
    def ramdisk_offset(self):
        """ramdisk offset from base."""
        if hasattr(self, '_m_ramdisk_offset'):
            return self._m_ramdisk_offset if hasattr(self, '_m_ramdisk_offset') else None

        self._m_ramdisk_offset = ((self.ramdisk.addr - self.base) if self.ramdisk.addr > 0 else 0)
        return self._m_ramdisk_offset if hasattr(self, '_m_ramdisk_offset') else None

    @property
    def second_offset(self):
        """2nd bootloader offset from base."""
        if hasattr(self, '_m_second_offset'):
            return self._m_second_offset if hasattr(self, '_m_second_offset') else None

        self._m_second_offset = ((self.second.addr - self.base) if self.second.addr > 0 else 0)
        return self._m_second_offset if hasattr(self, '_m_second_offset') else None

    @property
    def kernel_offset(self):
        """kernel offset from base."""
        if hasattr(self, '_m_kernel_offset'):
            return self._m_kernel_offset if hasattr(self, '_m_kernel_offset') else None

        self._m_kernel_offset = (self.kernel.addr - self.base)
        return self._m_kernel_offset if hasattr(self, '_m_kernel_offset') else None

    @property
    def dtb_offset(self):
        """dtb offset from base."""
        if hasattr(self, '_m_dtb_offset'):
            return self._m_dtb_offset if hasattr(self, '_m_dtb_offset') else None

        if self.header_version > 1:
            self._m_dtb_offset = ((self.dtb.addr - self.base) if self.dtb.addr > 0 else 0)

        return self._m_dtb_offset if hasattr(self, '_m_dtb_offset') else None

    @property
    def dtb_img(self):
        if hasattr(self, '_m_dtb_img'):
            return self._m_dtb_img if hasattr(self, '_m_dtb_img') else None

        if  ((self.header_version > 1) and (self.dtb.size > 0)) :
            _pos = self._io.pos()
            self._io.seek((((((((self.page_size + self.kernel.size) + self.ramdisk.size) + self.second.size) + self.recovery_dtbo.size) + self.page_size) - 1) // self.page_size * self.page_size))
            self._m_dtb_img = self._io.read_bytes(self.dtb.size)
            self._io.seek(_pos)

        return self._m_dtb_img if hasattr(self, '_m_dtb_img') else None

    @property
    def ramdisk_img(self):
        if hasattr(self, '_m_ramdisk_img'):
            return self._m_ramdisk_img if hasattr(self, '_m_ramdisk_img') else None

        if self.ramdisk.size > 0:
            _pos = self._io.pos()
            self._io.seek(((((self.page_size + self.kernel.size) + self.page_size) - 1) // self.page_size * self.page_size))
            self._m_ramdisk_img = self._io.read_bytes(self.ramdisk.size)
            self._io.seek(_pos)

        return self._m_ramdisk_img if hasattr(self, '_m_ramdisk_img') else None

    @property
    def recovery_dtbo_img(self):
        if hasattr(self, '_m_recovery_dtbo_img'):
            return self._m_recovery_dtbo_img if hasattr(self, '_m_recovery_dtbo_img') else None

        if  ((self.header_version > 0) and (self.recovery_dtbo.size > 0)) :
            _pos = self._io.pos()
            self._io.seek(self.recovery_dtbo.offset)
            self._m_recovery_dtbo_img = self._io.read_bytes(self.recovery_dtbo.size)
            self._io.seek(_pos)

        return self._m_recovery_dtbo_img if hasattr(self, '_m_recovery_dtbo_img') else None

    @property
    def second_img(self):
        if hasattr(self, '_m_second_img'):
            return self._m_second_img if hasattr(self, '_m_second_img') else None

        if self.second.size > 0:
            _pos = self._io.pos()
            self._io.seek((((((self.page_size + self.kernel.size) + self.ramdisk.size) + self.page_size) - 1) // self.page_size * self.page_size))
            self._m_second_img = self._io.read_bytes(self.second.size)
            self._io.seek(_pos)

        return self._m_second_img if hasattr(self, '_m_second_img') else None

    @property
    def base(self):
        """base loading address."""
        if hasattr(self, '_m_base'):
            return self._m_base if hasattr(self, '_m_base') else None

        self._m_base = (self.kernel.addr - 32768)
        return self._m_base if hasattr(self, '_m_base') else None

if __name__ == '__main__':
    if (len(sys.argv) < 2):
        sys.stderr.write("Usage: {} <boot.img>\n".format(sys.argv[0]))
        sys.exit(1)
    try:
        with open(sys.argv[1], 'rb') as fh:
            img = AndroidImg(KaitaiStream(BytesIO(fh.read())))

            print("header_version={}".format(img.header_version))

            os_version = img.os_version
            print("os_version={}.{}.{}".format(os_version.major, os_version.minor, os_version.patch))
            print("os_patch_level={}-{:02d}".format(os_version.year, os_version.month))

            if img.name:
                print("board={:s}".format(img.name))
            print("pagesize={}".format(img.page_size))
            if img.cmdline:
                print("cmdline={}".format(img.cmdline))
            if img.extra_cmdline:
                print("extra_cmdline={}".format(img.extra_cmdline))
            print("base={:#010x}".format(img.base))
            print("kernel_offset={:#010x}".format(img.kernel_offset))
            print("ramdisk_offset={:#010x}".format(img.ramdisk_offset))
            print("second_offset={:#010x}".format(img.second_offset))
            print("tags_offset={:#010x}".format(img.tags_offset))
            if img.dtb_offset:
                print("dtb_offset={:#010x}".format(img.dtb_offset))
            try:
                if img.kernel_img:
                    with open('kernel', 'wb') as fh:
                        fh.write(img.kernel_img)
                if img.ramdisk_img:
                    with open('ramdisk', 'wb') as fh:
                        fh.write(img.ramdisk_img)
                if img.dtb_img:
                    with open('dtb', 'wb') as fh:
                        fh.write(img.dtb_img)
                if img.recovery_dtbo_img:
                    with open('recovery_dtbo', 'wb') as fh:
                        fh.write(img.recovery_dtbo_img)
                if img.second_img:
                    with open('second_img', 'wb') as fh:
                        fh.write(img.second_img)
            except IOError as e:
                sys.stderr.write("Can't open file: {}\n".format(str(e)))
    except IOError:
        sys.stderr.write("Can't open file {}\n".format(sys.argv[1]))