13600950642

Committed 01 Mar 2025 04:10AM UTC coverage: 74.211% (+3.2%) from 71.055%

Build # 13600950642

Build Type

Pull #2546

github

Committed by

web-flow

Commit Message

Merge 77df40314 into 60cff2437

Pull Request Pull Request #2546: ssh: Allow passing `disabled_algorithms` keyword argument from `ssh` to paramiko

Run Details

3812 of 6380 branches covered (59.75%)

0 of 1 new or added line in 1 file covered. (0.0%)

1243 existing lines in 37 files now uncovered.

13352 of 17992 relevant lines covered (74.21%)

0.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

29.41

/pwnlib/adb/bootloader.py

from __future__ import unicode_literals
from __future__ import division

import ctypes
import io
import os
import sys

from pwnlib.log import getLogger

log = getLogger(__name__)

class img_info(ctypes.Structure):
    _fields_ = [
        ('name', ctypes.c_char * 64),
        ('size', ctypes.c_uint32)
    ]

class bootloader_images_header(ctypes.Structure):
    _fields_ = [
        ('magic', ctypes.c_char * 8),
        ('num_images', ctypes.c_uint32),
        ('start_offset', ctypes.c_uint32),
        ('bootldr_size', ctypes.c_uint32),
    ]

BOOTLDR_MAGIC = b'BOOTLDR!'

class BootloaderImage(object):
    def __init__(self, data):
        """Android Bootloader image

        Arguments:
            data(str): Binary data from the image file.
        """
        self.data = data
        self.header = bootloader_images_header.from_buffer_copy(data)

        if self.magic != BOOTLDR_MAGIC:
            log.error("Incorrect magic (%r, expected %r)" % (self.magic, BOOTLDR_MAGIC))

        if(self.bootldr_size > len(data)):
            log.warn_once("Bootloader is supposed to be %#x bytes, only have %#x",
                          self.bootldr_size,
                          len(data))

        if(self.num_images >= 0x100):
            old = self.num_images
            self.num_images = 1
            log.warn_once("Bootloader num_images (%#x) appears corrupted, truncating to 1",
                          old)

        imgarray = ctypes.ARRAY(img_info, self.num_images)
        self.img_info = imgarray.from_buffer_copy(data, ctypes.sizeof(self.header))

    def extract(self, index_or_name):
        """extract(index_or_name) -> bytes

        Extract the contents of an image.

        Arguments:
            index_or_name(str,int): Either an image index or name.

        Returns:
            Contents of the image.
        """
        if isinstance(index_or_name, int):
            index = index_or_name
        else:
            for i in range(len(self.img_info)):
                if self.img_info[i].name == index_or_name:
                    index = i
                    break
            else:
                raise ValueError("Invalid img name: %r" % index_or_name)

        if index >= len(self.img_info):
            raise ValueError("index out of range (%s, max %s)" % (index, len(self.img_info)))

        offset = self.start_offset

        for i in range(index):
            offset += self.img_info[i].size

        return self.data[offset:offset + self.img_info[index].size]

    def extract_all(self, path):
        """extract_all(path)

        Extracts all images to the provided path.  The filenames are taken
        from the image name, with '.img' appended.
        """
        if not os.path.isdir(path):
            raise ValueError("%r does not exist or is not a directory" % path)

        for img in self.img_info:
            imgpath = os.path.join(path, img.name + '.img')
            with open(imgpath, 'wb+') as f:
                data = self.extract(img.name)
                f.write(data)

    def __str__(self):
        rv = []
        rv.append("Bootloader")
        rv.append("  Magic:  %r" % self.magic)
        rv.append("  Offset: %#x" % self.start_offset)
        rv.append("  Size:   %#x" % self.bootldr_size)
        rv.append("  Images: %s" % self.num_images)
        for img in self.img_info:
            rv.append("    Name: %s" % img.name)
            rv.append("    Size: %#x" % img.size)
            rv.append("    Data: %r..." % self.extract(img.name)[:32])
        return '\n'.join(rv)

    def __getattr__(self, name):
        if name.startswith('_'):
            raise AttributeError(name)

        return getattr(self.header, name)


if __name__ == '__main__':
    # Easy sanity checking
    b = BootloaderImage(open(sys.argv[1], 'rb').read())
    print(b)

1	from __future__ import unicode_literals	1✔
2	from __future__ import division	1✔
3
4	import ctypes	1✔
5	import io	1✔
6	import os	1✔
7	import sys	1✔
8
9	from pwnlib.log import getLogger	1✔
10
11	log = getLogger(__name__)	1✔
12
13	class img_info(ctypes.Structure):	1✔
14	_fields_ = [	1✔
15	('name', ctypes.c_char * 64),
16	('size', ctypes.c_uint32)
17	]
18
19	class bootloader_images_header(ctypes.Structure):	1✔
20	_fields_ = [	1✔
21	('magic', ctypes.c_char * 8),
22	('num_images', ctypes.c_uint32),
23	('start_offset', ctypes.c_uint32),
24	('bootldr_size', ctypes.c_uint32),
25	]
26
27	BOOTLDR_MAGIC = b'BOOTLDR!'	1✔
28
29	class BootloaderImage(object):	1✔
30	def __init__(self, data):	1✔
31	"""Android Bootloader image
32
33	Arguments:
34	data(str): Binary data from the image file.
35	"""
UNCOV 36	self.data = data	×
37	self.header = bootloader_images_header.from_buffer_copy(data)	×
38
UNCOV 39	if self.magic != BOOTLDR_MAGIC:	×
40	log.error("Incorrect magic (%r, expected %r)" % (self.magic, BOOTLDR_MAGIC))	×
41
UNCOV 42	if(self.bootldr_size > len(data)):	×
43	log.warn_once("Bootloader is supposed to be %#x bytes, only have %#x",	×
44	self.bootldr_size,
45	len(data))
46
UNCOV 47	if(self.num_images >= 0x100):	×
48	old = self.num_images	×
49	self.num_images = 1	×
50	log.warn_once("Bootloader num_images (%#x) appears corrupted, truncating to 1",	×
51	old)
52
UNCOV 53	imgarray = ctypes.ARRAY(img_info, self.num_images)	×
54	self.img_info = imgarray.from_buffer_copy(data, ctypes.sizeof(self.header))	×
55
56	def extract(self, index_or_name):	1✔
57	"""extract(index_or_name) -> bytes
58
59	Extract the contents of an image.
60
61	Arguments:
62	index_or_name(str,int): Either an image index or name.
63
64	Returns:
65	Contents of the image.
66	"""
UNCOV 67	if isinstance(index_or_name, int):	×
68	index = index_or_name	×
69	else:
UNCOV 70	for i in range(len(self.img_info)):	×
71	if self.img_info[i].name == index_or_name:	×
72	index = i	×
73	break	×
74	else:
UNCOV 75	raise ValueError("Invalid img name: %r" % index_or_name)	×
76
UNCOV 77	if index >= len(self.img_info):	×
78	raise ValueError("index out of range (%s, max %s)" % (index, len(self.img_info)))	×
79
UNCOV 80	offset = self.start_offset	×
81
UNCOV 82	for i in range(index):	×
83	offset += self.img_info[i].size	×
84
UNCOV 85	return self.data[offset:offset + self.img_info[index].size]	×
86
87	def extract_all(self, path):	1✔
88	"""extract_all(path)
89
90	Extracts all images to the provided path. The filenames are taken
91	from the image name, with '.img' appended.
92	"""
UNCOV 93	if not os.path.isdir(path):	×
94	raise ValueError("%r does not exist or is not a directory" % path)	×
95
UNCOV 96	for img in self.img_info:	×
97	imgpath = os.path.join(path, img.name + '.img')	×
98	with open(imgpath, 'wb+') as f:	×
99	data = self.extract(img.name)	×
100	f.write(data)	×
101
102	def __str__(self):	1✔
UNCOV 103	rv = []	×
104	rv.append("Bootloader")	×
105	rv.append(" Magic: %r" % self.magic)	×
106	rv.append(" Offset: %#x" % self.start_offset)	×
107	rv.append(" Size: %#x" % self.bootldr_size)	×
108	rv.append(" Images: %s" % self.num_images)	×
109	for img in self.img_info:	×
110	rv.append(" Name: %s" % img.name)	×
111	rv.append(" Size: %#x" % img.size)	×
112	rv.append(" Data: %r..." % self.extract(img.name)[:32])	×
113	return '\n'.join(rv)	×
114
115	def __getattr__(self, name):	1✔
UNCOV 116	if name.startswith('_'):	×
117	raise AttributeError(name)	×
118
UNCOV 119	return getattr(self.header, name)	×
120
121
122	if __name__ == '__main__':	1!
123	# Easy sanity checking
UNCOV 124	b = BootloaderImage(open(sys.argv[1], 'rb').read())	×
125	print(b)	×

Gallopsled / pwntools / 13600950642

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous