7709478874

Committed 30 Jan 2024 10:08AM UTC coverage: 74.314%. Remained the same

Build # 7709478874

Build Type

push

github

Committed by

web-flow

Commit Message

Make sure TERM_PROGRAM points to a valid program (#2329)

Visual Studio Code sets the $TERM_PROGRAM environment variable to `"vscode"` in its terminal pane,
but doesn't support opening new panes from the command line and there is no "vscode" binary.

Make sure the target binary exists before trying to launch it.

Run Details

4563 of 7273 branches covered (0.0%)

12840 of 17278 relevant lines covered (74.31%)

0.74 hits per line

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

30.43

/pwnlib/adb/bootloader.py

from __future__ import unicode_literals
from __future__ import division

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

Gallopsled / pwntools / 7709478874

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