Lines Matching refs:self
65 def __init__(self, message): argument
66 Exception.__init__(self, message)
86 def __init__(self, algorithm_type, hash_name, hash_num_bytes, argument
88 self.algorithm_type = algorithm_type
89 self.hash_name = hash_name
90 self.hash_num_bytes = hash_num_bytes
91 self.signature_num_bytes = signature_num_bytes
92 self.public_key_num_bytes = public_key_num_bytes
93 self.padding = padding
350 def __init__(self, key_path): argument
386 if not pout.lower().startswith(self.MODULUS_PREFIX):
389 modulus_hexstr = pout[len(self.MODULUS_PREFIX):]
394 self.key_path = key_path
395 self.modulus = int(modulus_hexstr, 16)
396 self.num_bits = round_to_pow2(int(math.ceil(math.log(self.modulus, 2))))
397 self.exponent = 65537
399 def encode(self): argument
411 if self.exponent != 65537:
416 n0inv = b - modinv(self.modulus, b)
418 r = 2 ** self.modulus.bit_length()
419 rrmodn = r * r % self.modulus
420 ret.extend(struct.pack('!II', self.num_bits, n0inv))
421 ret.extend(encode_long(self.num_bits, self.modulus))
422 ret.extend(encode_long(self.num_bits, rrmodn))
425 def sign(self, algorithm_name, data_to_sign, signing_helper=None, argument
450 if self.num_bits != (algorithm.signature_num_bytes * 8):
453 .format(self.num_bits, algorithm.signature_num_bytes * 8,
469 self.key_path, signing_file.name])
478 [signing_helper, algorithm_name, self.key_path],
484 ['openssl', 'rsautl', '-sign', '-inkey', self.key_path, '-raw'],
673 def __init__(self, chunk_type, chunk_offset, output_offset, output_size, argument
688 self.chunk_type = chunk_type
689 self.chunk_offset = chunk_offset
690 self.output_offset = output_offset
691 self.output_size = output_size
692 self.input_offset = input_offset
693 self.fill_data = fill_data
695 if self.chunk_type == self.TYPE_RAW:
696 if self.fill_data is not None:
698 if not self.input_offset:
700 elif self.chunk_type == self.TYPE_FILL:
701 if self.fill_data is None:
703 if self.input_offset:
705 elif self.chunk_type == self.TYPE_DONT_CARE:
706 if self.fill_data is not None:
708 if self.input_offset:
745 def __init__(self, image_filename, read_only=False): argument
755 self.filename = image_filename
756 self._num_total_blocks = 0
757 self._num_total_chunks = 0
758 self._file_pos = 0
759 self._read_only = read_only
760 self._read_header()
762 def _read_header(self): argument
771 self.is_sparse = False
772 self.block_size = 4096
773 self._file_pos = 0
774 if self._read_only:
775 self._image = open(self.filename, 'rb')
777 self._image = open(self.filename, 'r+b')
778 self._image.seek(0, os.SEEK_END)
779 self.image_size = self._image.tell()
781 self._image.seek(0, os.SEEK_SET)
782 header_bin = self._image.read(struct.calcsize(self.HEADER_FORMAT))
784 block_size, self._num_total_blocks, self._num_total_chunks,
785 _) = struct.unpack(self.HEADER_FORMAT, header_bin)
786 if magic != self.MAGIC:
793 if file_hdr_sz != struct.calcsize(self.HEADER_FORMAT):
800 self.block_size = block_size
803 self._chunks = []
810 for _ in range(1, self._num_total_chunks + 1):
811 chunk_offset = self._image.tell()
813 header_bin = self._image.read(struct.calcsize(ImageChunk.FORMAT))
819 if data_sz != (chunk_sz * self.block_size):
822 format(data_sz, chunk_sz*self.block_size))
823 self._chunks.append(ImageChunk(ImageChunk.TYPE_RAW,
826 chunk_sz*self.block_size,
827 self._image.tell(),
829 self._image.seek(data_sz, os.SEEK_CUR)
835 fill_data = self._image.read(4)
836 self._chunks.append(ImageChunk(ImageChunk.TYPE_FILL,
839 chunk_sz*self.block_size,
846 self._chunks.append(ImageChunk(ImageChunk.TYPE_DONT_CARE,
849 chunk_sz*self.block_size,
856 self._image.read(4)
861 output_offset += chunk_sz*self.block_size
864 self._sparse_end = self._image.tell()
867 if self._num_total_blocks != offset:
869 'but we saw {}'.format(self._num_total_blocks, offset))
870 junk_len = len(self._image.read())
876 self.image_size = output_offset
879 self._chunk_output_offsets = [i.output_offset for i in self._chunks]
881 self.is_sparse = True
883 def _update_chunks_and_blocks(self): argument
891 self._image.seek(self.NUM_CHUNKS_AND_BLOCKS_OFFSET, os.SEEK_SET)
892 self._image.write(struct.pack(self.NUM_CHUNKS_AND_BLOCKS_FORMAT,
893 self._num_total_blocks,
894 self._num_total_chunks))
896 def append_dont_care(self, num_bytes): argument
907 assert num_bytes % self.block_size == 0
909 if self._read_only:
912 if not self.is_sparse:
913 self._image.seek(0, os.SEEK_END)
917 self._image.truncate(self._image.tell() + num_bytes)
918 self._read_header()
921 self._num_total_chunks += 1
922 self._num_total_blocks += num_bytes // self.block_size
923 self._update_chunks_and_blocks()
925 self._image.seek(self._sparse_end, os.SEEK_SET)
926 self._image.write(struct.pack(ImageChunk.FORMAT,
929 num_bytes // self.block_size,
931 self._read_header()
933 def append_raw(self, data): argument
944 assert len(data) % self.block_size == 0
946 if self._read_only:
949 if not self.is_sparse:
950 self._image.seek(0, os.SEEK_END)
951 self._image.write(data)
952 self._read_header()
955 self._num_total_chunks += 1
956 self._num_total_blocks += len(data) // self.block_size
957 self._update_chunks_and_blocks()
959 self._image.seek(self._sparse_end, os.SEEK_SET)
960 self._image.write(struct.pack(ImageChunk.FORMAT,
963 len(data) // self.block_size,
966 self._image.write(data)
967 self._read_header()
969 def append_fill(self, fill_data, size): argument
983 assert size % self.block_size == 0
985 if self._read_only:
988 if not self.is_sparse:
989 self._image.seek(0, os.SEEK_END)
990 self._image.write(fill_data * (size//4))
991 self._read_header()
994 self._num_total_chunks += 1
995 self._num_total_blocks += size // self.block_size
996 self._update_chunks_and_blocks()
998 self._image.seek(self._sparse_end, os.SEEK_SET)
999 self._image.write(struct.pack(ImageChunk.FORMAT,
1002 size // self.block_size,
1004 self._image.write(fill_data)
1005 self._read_header()
1007 def seek(self, offset): argument
1018 self._file_pos = offset
1020 def read(self, size): argument
1035 if not self.is_sparse:
1036 self._image.seek(self._file_pos)
1037 data = self._image.read(size)
1038 self._file_pos += len(data)
1042 chunk_idx = bisect.bisect_right(self._chunk_output_offsets,
1043 self._file_pos) - 1
1047 chunk = self._chunks[chunk_idx]
1048 chunk_pos_offset = self._file_pos - chunk.output_offset
1052 self._image.seek(chunk.input_offset + chunk_pos_offset)
1053 data.extend(self._image.read(chunk_pos_to_go))
1063 self._file_pos += chunk_pos_to_go
1066 if chunk_idx >= len(self._chunks):
1071 def tell(self): argument
1077 return self._file_pos
1079 def truncate(self, size): argument
1089 if self._read_only:
1092 if not self.is_sparse:
1093 self._image.truncate(size)
1094 self._read_header()
1097 if size % self.block_size != 0:
1101 if size == self.image_size:
1105 if size < self.image_size:
1106 chunk_idx = bisect.bisect_right(self._chunk_output_offsets, size) - 1
1107 chunk = self._chunks[chunk_idx]
1113 assert num_to_keep % self.block_size == 0
1126 chunk_sz = num_to_keep // self.block_size
1128 self._image.seek(chunk.chunk_offset)
1129 self._image.write(struct.pack(ImageChunk.FORMAT,
1140 self._num_total_chunks = chunk_idx_for_update
1141 self._num_total_blocks = 0
1143 self._num_total_blocks += self._chunks[i].output_size // self.block_size
1144 self._update_chunks_and_blocks()
1145 self._image.truncate(truncate_at)
1148 self._read_header()
1151 self.append_dont_care(size - self.image_size)
1167 def __init__(self, data): argument
1176 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1179 (self.tag, num_bytes_following) = (
1180 struct.unpack(self.FORMAT_STRING, data[0:self.SIZE]))
1181 self.data = data[self.SIZE:self.SIZE + num_bytes_following]
1183 self.tag = None
1184 self.data = None
1186 def print_desc(self, o): argument
1193 o.write(' Tag: {}\n'.format(self.tag))
1194 if len(self.data) < 256:
1196 repr(str(self.data)), len(self.data)))
1198 o.write(' Data: {} bytes\n'.format(len(self.data)))
1200 def encode(self): argument
1206 num_bytes_following = len(self.data)
1209 desc = struct.pack(self.FORMAT_STRING, self.tag, nbf_with_padding)
1211 ret = desc + self.data + padding
1214 def verify(self, image_dir, image_ext, expected_chain_partitions_map, argument
1254 def __init__(self, data=None): argument
1264 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1268 value_size) = struct.unpack(self.FORMAT_STRING, data[0:self.SIZE])
1270 self.SIZE - 16 + key_size + 1 + value_size + 1, 8)
1271 if tag != self.TAG or num_bytes_following != expected_size:
1275 self.key = data[self.SIZE:(self.SIZE + key_size)].decode('utf-8')
1279 self.value = data[(self.SIZE + key_size + 1):(self.SIZE + key_size + 1 +
1282 self.key = ''
1283 self.value = b''
1285 def print_desc(self, o): argument
1294 printable_value = repr(self.value)
1298 if len(self.value) < 256:
1299 o.write(' Prop: {} -> {}\n'.format(self.key, printable_value))
1301 o.write(' Prop: {} -> ({} bytes)\n'.format(self.key, len(self.value)))
1303 def encode(self): argument
1309 key_encoded = self.key.encode('utf-8')
1311 self.SIZE + len(key_encoded) + len(self.value) + 2 - 16)
1314 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1315 len(key_encoded), len(self.value))
1316 ret = (desc + key_encoded + b'\0' + self.value + b'\0' +
1320 def verify(self, image_dir, image_ext, expected_chain_partitions_map, argument
1385 def __init__(self, data=None): argument
1395 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1398 (tag, num_bytes_following, self.dm_verity_version, self.image_size,
1399 self.tree_offset, self.tree_size, self.data_block_size,
1400 self.hash_block_size, self.fec_num_roots, self.fec_offset, self.fec_size,
1401 self.hash_algorithm, partition_name_len, salt_len,
1402 root_digest_len, self.flags, _) = struct.unpack(self.FORMAT_STRING,
1403 data[0:self.SIZE])
1405 self.SIZE - 16 + partition_name_len + salt_len + root_digest_len, 8)
1406 if tag != self.TAG or num_bytes_following != expected_size:
1410 self.hash_algorithm = self.hash_algorithm.rstrip(b'\0').decode('ascii')
1413 self.partition_name = data[
1414 (self.SIZE + o):(self.SIZE + o + partition_name_len)
1420 self.salt = data[(self.SIZE + o):(self.SIZE + o + salt_len)]
1422 self.root_digest = data[(self.SIZE + o):(self.SIZE + o + root_digest_len)]
1424 if root_digest_len != self._hashtree_digest_size():
1429 self.dm_verity_version = 0
1430 self.image_size = 0
1431 self.tree_offset = 0
1432 self.tree_size = 0
1433 self.data_block_size = 0
1434 self.hash_block_size = 0
1435 self.fec_num_roots = 0
1436 self.fec_offset = 0
1437 self.fec_size = 0
1438 self.hash_algorithm = ''
1439 self.partition_name = ''
1440 self.salt = b''
1441 self.root_digest = b''
1442 self.flags = 0
1444 def _hashtree_digest_size(self): argument
1445 return len(create_avb_hashtree_hasher(self.hash_algorithm, b'').digest())
1447 def print_desc(self, o): argument
1454 o.write(' Version of dm-verity: {}\n'.format(self.dm_verity_version))
1455 o.write(' Image Size: {} bytes\n'.format(self.image_size))
1456 o.write(' Tree Offset: {}\n'.format(self.tree_offset))
1457 o.write(' Tree Size: {} bytes\n'.format(self.tree_size))
1459 self.data_block_size))
1461 self.hash_block_size))
1462 o.write(' FEC num roots: {}\n'.format(self.fec_num_roots))
1463 o.write(' FEC offset: {}\n'.format(self.fec_offset))
1464 o.write(' FEC size: {} bytes\n'.format(self.fec_size))
1465 o.write(' Hash Algorithm: {}\n'.format(self.hash_algorithm))
1466 o.write(' Partition Name: {}\n'.format(self.partition_name))
1467 o.write(' Salt: {}\n'.format(self.salt.hex()))
1468 o.write(' Root Digest: {}\n'.format(self.root_digest.hex()))
1469 o.write(' Flags: {}\n'.format(self.flags))
1471 def encode(self): argument
1477 hash_algorithm_encoded = self.hash_algorithm.encode('ascii')
1478 partition_name_encoded = self.partition_name.encode('utf-8')
1479 num_bytes_following = (self.SIZE + len(partition_name_encoded)
1480 + len(self.salt) + len(self.root_digest) - 16)
1483 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1484 self.dm_verity_version, self.image_size,
1485 self.tree_offset, self.tree_size, self.data_block_size,
1486 self.hash_block_size, self.fec_num_roots,
1487 self.fec_offset, self.fec_size, hash_algorithm_encoded,
1488 len(partition_name_encoded), len(self.salt),
1489 len(self.root_digest), self.flags, self.RESERVED * b'\0')
1490 ret = (desc + partition_name_encoded + self.salt + self.root_digest +
1494 def verify(self, image_dir, image_ext, expected_chain_partitions_map, argument
1510 if not self.partition_name:
1514 image_filename = os.path.join(image_dir, self.partition_name + image_ext)
1517 digest_size = self._hashtree_digest_size()
1520 self.image_size, self.data_block_size, digest_size + digest_padding)
1521 root_digest, hash_tree = generate_hash_tree(image, self.image_size,
1522 self.data_block_size,
1523 self.hash_algorithm, self.salt,
1528 if self.root_digest and root_digest != self.root_digest:
1533 image.seek(self.tree_offset)
1534 hash_tree_ondisk = image.read(self.tree_size)
1535 is_zeroed = (self.tree_size == 0) or (hash_tree_ondisk[0:8] == b'ZeRoHaSH')
1539 .format(self.partition_name))
1546 .format(self.partition_name, self.hash_algorithm, image.filename,
1547 self.image_size))
1581 def __init__(self, data=None): argument
1591 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1594 (tag, num_bytes_following, self.image_size, self.hash_algorithm,
1596 digest_len, self.flags, _) = struct.unpack(self.FORMAT_STRING,
1597 data[0:self.SIZE])
1599 self.SIZE - 16 + partition_name_len + salt_len + digest_len, 8)
1600 if tag != self.TAG or num_bytes_following != expected_size:
1603 self.hash_algorithm = self.hash_algorithm.rstrip(b'\0').decode('ascii')
1606 self.partition_name = data[
1607 (self.SIZE + o):(self.SIZE + o + partition_name_len)
1613 self.salt = data[(self.SIZE + o):(self.SIZE + o + salt_len)]
1615 self.digest = data[(self.SIZE + o):(self.SIZE + o + digest_len)]
1616 if digest_len != len(hashlib.new(self.hash_algorithm).digest()):
1621 self.image_size = 0
1622 self.hash_algorithm = ''
1623 self.partition_name = ''
1624 self.salt = b''
1625 self.digest = b''
1626 self.flags = 0
1628 def print_desc(self, o): argument
1635 o.write(' Image Size: {} bytes\n'.format(self.image_size))
1636 o.write(' Hash Algorithm: {}\n'.format(self.hash_algorithm))
1637 o.write(' Partition Name: {}\n'.format(self.partition_name))
1638 o.write(' Salt: {}\n'.format(self.salt.hex()))
1639 o.write(' Digest: {}\n'.format(self.digest.hex()))
1640 o.write(' Flags: {}\n'.format(self.flags))
1642 def encode(self): argument
1648 hash_algorithm_encoded = self.hash_algorithm.encode('ascii')
1649 partition_name_encoded = self.partition_name.encode('utf-8')
1650 num_bytes_following = (self.SIZE + len(partition_name_encoded) +
1651 len(self.salt) + len(self.digest) - 16)
1654 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1655 self.image_size, hash_algorithm_encoded,
1656 len(partition_name_encoded), len(self.salt),
1657 len(self.digest), self.flags, self.RESERVED * b'\0')
1658 ret = (desc + partition_name_encoded + self.salt + self.digest +
1662 def verify(self, image_dir, image_ext, expected_chain_partitions_map, argument
1678 if not self.partition_name:
1682 image_filename = os.path.join(image_dir, self.partition_name + image_ext)
1684 data = image.read(self.image_size)
1685 ha = hashlib.new(self.hash_algorithm)
1686 ha.update(self.salt)
1690 if self.digest and digest != self.digest:
1692 format(self.hash_algorithm, image_filename))
1695 .format(self.partition_name, self.hash_algorithm, image.filename,
1696 self.image_size))
1719 def __init__(self, data=None): argument
1729 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1732 (tag, num_bytes_following, self.flags, kernel_cmdline_length) = (
1733 struct.unpack(self.FORMAT_STRING, data[0:self.SIZE]))
1734 expected_size = round_to_multiple(self.SIZE - 16 + kernel_cmdline_length,
1736 if tag != self.TAG or num_bytes_following != expected_size:
1741 self.kernel_cmdline = data[
1742 self.SIZE:(self.SIZE + kernel_cmdline_length)].decode('utf-8')
1747 self.flags = 0
1748 self.kernel_cmdline = ''
1750 def print_desc(self, o): argument
1757 o.write(' Flags: {}\n'.format(self.flags))
1758 o.write(' Kernel Cmdline: \'{}\'\n'.format(self.kernel_cmdline))
1760 def encode(self): argument
1766 kernel_cmd_encoded = self.kernel_cmdline.encode('utf-8')
1767 num_bytes_following = (self.SIZE + len(kernel_cmd_encoded) - 16)
1770 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1771 self.flags, len(kernel_cmd_encoded))
1775 def verify(self, image_dir, image_ext, expected_chain_partitions_map, argument
1815 def __init__(self, data=None): argument
1824 AvbDescriptor.__init__(self, None)
1825 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1828 (tag, num_bytes_following, self.rollback_index_location,
1830 public_key_len, _) = struct.unpack(self.FORMAT_STRING, data[0:self.SIZE])
1832 self.SIZE - 16 + partition_name_len + public_key_len, 8)
1833 if tag != self.TAG or num_bytes_following != expected_size:
1838 self.partition_name = data[
1839 (self.SIZE + o):(self.SIZE + o + partition_name_len)
1845 self.public_key = data[(self.SIZE + o):(self.SIZE + o + public_key_len)]
1848 self.rollback_index_location = 0
1849 self.partition_name = ''
1850 self.public_key = b''
1852 def print_desc(self, o): argument
1859 o.write(' Partition Name: {}\n'.format(self.partition_name))
1861 self.rollback_index_location))
1863 pubkey_digest = hashlib.sha1(self.public_key).hexdigest()
1866 def encode(self): argument
1872 partition_name_encoded = self.partition_name.encode('utf-8')
1874 self.SIZE + len(partition_name_encoded) + len(self.public_key) - 16)
1877 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1878 self.rollback_index_location,
1879 len(partition_name_encoded), len(self.public_key),
1880 self.RESERVED * b'\0')
1881 ret = desc + partition_name_encoded + self.public_key + padding_size * b'\0'
1884 def verify(self, image_dir, image_ext, expected_chain_partitions_map, argument
1900 value = expected_chain_partitions_map.get(self.partition_name)
1905 format(self.partition_name))
1909 if self.rollback_index_location != rollback_index_location:
1913 self.rollback_index_location,
1914 self.partition_name))
1917 if self.public_key != pk_blob:
1920 format(self.partition_name))
1924 'expected data'.format(self.partition_name))
1984 def __init__(self, data=None): argument
1994 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1997 (self.magic, self.version_major, self.version_minor,
1998 self.original_image_size, self.vbmeta_offset,
1999 self.vbmeta_size) = struct.unpack(self.FORMAT_STRING, data)
2000 if self.magic != self.MAGIC:
2003 self.magic = self.MAGIC
2004 self.version_major = self.FOOTER_VERSION_MAJOR
2005 self.version_minor = self.FOOTER_VERSION_MINOR
2006 self.original_image_size = 0
2007 self.vbmeta_offset = 0
2008 self.vbmeta_size = 0
2010 def encode(self): argument
2016 return struct.pack(self.FORMAT_STRING, self.magic, self.version_major,
2017 self.version_minor, self.original_image_size,
2018 self.vbmeta_offset, self.vbmeta_size)
2086 def __init__(self, data=None): argument
2095 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
2098 (self.magic, self.required_libavb_version_major,
2099 self.required_libavb_version_minor,
2100 self.authentication_data_block_size, self.auxiliary_data_block_size,
2101 self.algorithm_type, self.hash_offset, self.hash_size,
2102 self.signature_offset, self.signature_size, self.public_key_offset,
2103 self.public_key_size, self.public_key_metadata_offset,
2104 self.public_key_metadata_size, self.descriptors_offset,
2105 self.descriptors_size,
2106 self.rollback_index,
2107 self.flags,
2108 self.rollback_index_location,
2109 release_string) = struct.unpack(self.FORMAT_STRING, data)
2111 if self.magic != self.MAGIC:
2113 self.release_string = release_string.rstrip(b'\0').decode('utf-8')
2115 self.magic = self.MAGIC
2119 self.required_libavb_version_major = AVB_VERSION_MAJOR
2120 self.required_libavb_version_minor = 0
2121 self.authentication_data_block_size = 0
2122 self.auxiliary_data_block_size = 0
2123 self.algorithm_type = 0
2124 self.hash_offset = 0
2125 self.hash_size = 0
2126 self.signature_offset = 0
2127 self.signature_size = 0
2128 self.public_key_offset = 0
2129 self.public_key_size = 0
2130 self.public_key_metadata_offset = 0
2131 self.public_key_metadata_size = 0
2132 self.descriptors_offset = 0
2133 self.descriptors_size = 0
2134 self.rollback_index = 0
2135 self.flags = 0
2136 self.rollback_index_location = 0
2137 self.release_string = get_release_string()
2139 def bump_required_libavb_version_minor(self, minor): argument
2148 self.required_libavb_version_minor = (
2149 max(self.required_libavb_version_minor, minor))
2151 def encode(self): argument
2157 release_string_encoded = self.release_string.encode('utf-8')
2158 return struct.pack(self.FORMAT_STRING, self.magic,
2159 self.required_libavb_version_major,
2160 self.required_libavb_version_minor,
2161 self.authentication_data_block_size,
2162 self.auxiliary_data_block_size, self.algorithm_type,
2163 self.hash_offset, self.hash_size, self.signature_offset,
2164 self.signature_size, self.public_key_offset,
2165 self.public_key_size, self.public_key_metadata_offset,
2166 self.public_key_metadata_size, self.descriptors_offset,
2167 self.descriptors_size, self.rollback_index, self.flags,
2168 self.rollback_index_location, release_string_encoded)
2188 def generate_test_image(self, output, image_size, start_byte): argument
2206 def extract_vbmeta_image(self, output, image_filename, padding_size): argument
2218 (footer, _, _, _) = self._parse_image(image)
2231 def erase_footer(self, image_filename, keep_hashtree): argument
2242 (footer, _, descriptors, _) = self._parse_image(image)
2270 def zero_hashtree(self, image_filename): argument
2280 (footer, _, descriptors, _) = self._parse_image(image)
2325 def resize_image(self, image_filename, partition_size): argument
2341 (footer, _, _, _) = self._parse_image(image)
2372 def set_ab_metadata(self, misc_image, slot_data): argument
2395 ab_data_no_crc = struct.pack(self.AB_FORMAT_NO_CRC,
2396 self.AB_MAGIC,
2397 self.AB_MAJOR_VERSION, self.AB_MINOR_VERSION,
2403 misc_image.seek(self.AB_MISC_METADATA_OFFSET)
2406 def info_image(self, image_filename, output, atx): argument
2416 (footer, header, descriptors, image_size) = self._parse_image(image)
2419 vbmeta_blob = self._load_vbmeta_blob(image)
2490 def verify_image(self, image_filename, key_path, expected_chain_partitions, argument
2535 (footer, header, descriptors, _) = self._parse_image(image)
2588 self.verify_image(chained_image_filename, key_path, None, False,
2591 def print_partition_digests(self, image_filename, output, as_json): argument
2607 self._print_partition_digests(
2612 def _print_partition_digests(self, image_filename, output, json_partitions, argument
2628 (_, _, descriptors, _) = self._parse_image(image)
2648 self._print_partition_digests(
2652 def calculate_vbmeta_digest(self, image_filename, hash_algorithm, output): argument
2665 (footer, header, descriptors, _) = self._parse_image(image)
2682 (ch_footer, ch_header, _, _) = self._parse_image(ch_image)
2695 def calculate_kernel_cmdline(self, image_filename, hashtree_disabled, output): argument
2705 _, _, descriptors, _ = self._parse_image(image)
2716 _, _, ch_descriptors, _ = self._parse_image(ch_image)
2739 def _parse_image(self, image): argument
2781 def _load_vbmeta_blob(self, image): argument
2814 def _get_cmdline_descriptors_for_hashtree_descriptor(self, ht): argument
2879 def _get_cmdline_descriptors_for_dm_verity(self, image): argument
2894 (_, _, descriptors, _) = self._parse_image(image)
2905 return self._get_cmdline_descriptors_for_hashtree_descriptor(ht)
2907 def make_vbmeta_image(self, output, chain_partitions, algorithm_name, argument
2953 (_, image_header, _, _) = self._parse_image(ImageHandler(
2967 vbmeta_blob = self._generate_vbmeta_blob(
2985 def _generate_vbmeta_blob(self, algorithm_name, key_path, argument
3109 cmdline_desc = self._get_cmdline_descriptors_for_dm_verity(image_handler)
3115 cmdline_desc = self._get_cmdline_descriptors_for_hashtree_descriptor(
3132 (_, image_vbmeta_header, image_descriptors, _) = self._parse_image(
3238 def extract_public_key(self, key_path, output): argument
3250 def append_vbmeta_image(self, image_filename, vbmeta_image_filename, argument
3288 vbmeta_blob = self._load_vbmeta_blob(vbmeta_image_handler)
3332 def add_hash_footer(self, image_filename, partition_size, argument
3407 max_metadata_size = self.MAX_VBMETA_SIZE + self.MAX_FOOTER_SIZE
3490 vbmeta_blob = self._generate_vbmeta_blob(
3547 def add_hashtree_footer(self, image_filename, partition_size, partition_name, argument
3642 self.MAX_VBMETA_SIZE +
3643 self.MAX_FOOTER_SIZE)
3782 vbmeta_blob = self._generate_vbmeta_blob(
3825 def make_atx_certificate(self, output, authority_key_path, subject_key_path, argument
3881 def make_atx_permanent_attributes(self, output, root_authority_key_path, argument
3905 def make_atx_metadata(self, output, intermediate_key_certificate, argument
3934 def make_atx_unlock_credential(self, output, intermediate_key_certificate, argument
4162 def __init__(self): argument
4164 self.avb = Avb()
4166 def _add_common_args(self, sub_parser): argument
4251 def _add_common_footer_args(self, sub_parser): argument
4270 def _fixup_common_args(self, args): argument
4283 def run(self, argv): argument
4308 sub_parser.set_defaults(func=self.generate_test_image)
4312 sub_parser.set_defaults(func=self.version)
4323 sub_parser.set_defaults(func=self.extract_public_key)
4337 self._add_common_args(sub_parser)
4338 sub_parser.set_defaults(func=self.make_vbmeta_image)
4372 self._add_common_args(sub_parser)
4373 self._add_common_footer_args(sub_parser)
4374 sub_parser.set_defaults(func=self.add_hash_footer)
4388 sub_parser.set_defaults(func=self.append_vbmeta_image)
4454 self._add_common_args(sub_parser)
4455 self._add_common_footer_args(sub_parser)
4456 sub_parser.set_defaults(func=self.add_hashtree_footer)
4467 sub_parser.set_defaults(func=self.erase_footer)
4475 sub_parser.set_defaults(func=self.zero_hashtree)
4494 sub_parser.set_defaults(func=self.extract_vbmeta_image)
4505 sub_parser.set_defaults(func=self.resize_image)
4522 sub_parser.set_defaults(func=self.info_image)
4548 sub_parser.set_defaults(func=self.verify_image)
4564 sub_parser.set_defaults(func=self.print_partition_digests)
4580 sub_parser.set_defaults(func=self.calculate_vbmeta_digest)
4596 sub_parser.set_defaults(func=self.calculate_kernel_cmdline)
4612 sub_parser.set_defaults(func=self.set_ab_metadata)
4654 sub_parser.set_defaults(func=self.make_atx_certificate)
4671 sub_parser.set_defaults(func=self.make_atx_permanent_attributes)
4688 sub_parser.set_defaults(func=self.make_atx_metadata)
4725 sub_parser.set_defaults(func=self.make_atx_unlock_credential)
4740 def version(self, _): argument
4744 def generate_test_image(self, args): argument
4746 self.avb.generate_test_image(args.output, args.image_size, args.start_byte)
4748 def extract_public_key(self, args): argument
4750 self.avb.extract_public_key(args.key, args.output)
4752 def make_vbmeta_image(self, args): argument
4754 args = self._fixup_common_args(args)
4755 self.avb.make_vbmeta_image(args.output, args.chain_partition,
4770 def append_vbmeta_image(self, args): argument
4772 self.avb.append_vbmeta_image(args.image.name, args.vbmeta_image.name,
4775 def add_hash_footer(self, args): argument
4777 args = self._fixup_common_args(args)
4778 self.avb.add_hash_footer(args.image.name if args.image else None,
4800 def add_hashtree_footer(self, args): argument
4802 args = self._fixup_common_args(args)
4809 self.avb.add_hashtree_footer(
4837 def erase_footer(self, args): argument
4839 self.avb.erase_footer(args.image.name, args.keep_hashtree)
4841 def zero_hashtree(self, args): argument
4843 self.avb.zero_hashtree(args.image.name)
4845 def extract_vbmeta_image(self, args): argument
4847 self.avb.extract_vbmeta_image(args.output, args.image.name,
4850 def resize_image(self, args): argument
4852 self.avb.resize_image(args.image.name, args.partition_size)
4854 def set_ab_metadata(self, args): argument
4856 self.avb.set_ab_metadata(args.misc_image, args.slot_data)
4858 def info_image(self, args): argument
4860 self.avb.info_image(args.image.name, args.output, args.atx)
4862 def verify_image(self, args): argument
4864 self.avb.verify_image(args.image.name, args.key,
4869 def print_partition_digests(self, args): argument
4871 self.avb.print_partition_digests(args.image.name, args.output, args.json)
4873 def calculate_vbmeta_digest(self, args): argument
4875 self.avb.calculate_vbmeta_digest(args.image.name, args.hash_algorithm,
4878 def calculate_kernel_cmdline(self, args): argument
4880 self.avb.calculate_kernel_cmdline(args.image.name, args.hashtree_disabled,
4883 def make_atx_certificate(self, args): argument
4885 self.avb.make_atx_certificate(args.output, args.authority_key,
4894 def make_atx_permanent_attributes(self, args): argument
4896 self.avb.make_atx_permanent_attributes(args.output,
4900 def make_atx_metadata(self, args): argument
4902 self.avb.make_atx_metadata(args.output,
4906 def make_atx_unlock_credential(self, args): argument
4908 self.avb.make_atx_unlock_credential(