Lines Matching refs:self
61 def __init__(self, message):
62 Exception.__init__(self, message)
82 def __init__(self, algorithm_type, hash_name, hash_num_bytes,
84 self.algorithm_type = algorithm_type
85 self.hash_name = hash_name
86 self.hash_num_bytes = hash_num_bytes
87 self.signature_num_bytes = signature_num_bytes
88 self.public_key_num_bytes = public_key_num_bytes
89 self.padding = padding
347 def __init__(self, key_path):
380 if not pout.lower().startswith(self.MODULUS_PREFIX):
383 modulus_hexstr = pout[len(self.MODULUS_PREFIX):]
388 self.modulus = int(modulus_hexstr, 16)
389 self.num_bits = round_to_pow2(int(math.ceil(math.log(self.modulus, 2))))
390 self.exponent = 65537
576 def __init__(self, chunk_type, chunk_offset, output_offset, output_size,
591 self.chunk_type = chunk_type
592 self.chunk_offset = chunk_offset
593 self.output_offset = output_offset
594 self.output_size = output_size
595 self.input_offset = input_offset
596 self.fill_data = fill_data
598 if self.chunk_type == self.TYPE_RAW:
599 if self.fill_data is not None:
601 if not self.input_offset:
603 elif self.chunk_type == self.TYPE_FILL:
604 if self.fill_data is None:
606 if self.input_offset:
608 elif self.chunk_type == self.TYPE_DONT_CARE:
609 if self.fill_data is not None:
611 if self.input_offset:
648 def __init__(self, image_filename):
657 self.filename = image_filename
658 self._read_header()
660 def _read_header(self):
669 self.is_sparse = False
670 self.block_size = 4096
671 self._file_pos = 0
672 self._image = open(self.filename, 'r+b')
673 self._image.seek(0, os.SEEK_END)
674 self.image_size = self._image.tell()
676 self._image.seek(0, os.SEEK_SET)
677 header_bin = self._image.read(struct.calcsize(self.HEADER_FORMAT))
679 block_size, self._num_total_blocks, self._num_total_chunks,
680 _) = struct.unpack(self.HEADER_FORMAT, header_bin)
681 if magic != self.MAGIC:
688 if file_hdr_sz != struct.calcsize(self.HEADER_FORMAT):
695 self.block_size = block_size
698 self._chunks = []
705 for _ in xrange(1, self._num_total_chunks + 1):
706 chunk_offset = self._image.tell()
708 header_bin = self._image.read(struct.calcsize(ImageChunk.FORMAT))
714 if data_sz != (chunk_sz * self.block_size):
717 format(data_sz, chunk_sz*self.block_size))
718 self._chunks.append(ImageChunk(ImageChunk.TYPE_RAW,
721 chunk_sz*self.block_size,
722 self._image.tell(),
724 self._image.seek(data_sz, os.SEEK_CUR)
730 fill_data = self._image.read(4)
731 self._chunks.append(ImageChunk(ImageChunk.TYPE_FILL,
734 chunk_sz*self.block_size,
741 self._chunks.append(ImageChunk(ImageChunk.TYPE_DONT_CARE,
744 chunk_sz*self.block_size,
751 self._image.read(4)
756 output_offset += chunk_sz*self.block_size
759 self._sparse_end = self._image.tell()
762 if self._num_total_blocks != offset:
764 'but we saw {}'.format(self._num_total_blocks, offset))
765 junk_len = len(self._image.read())
771 self.image_size = output_offset
774 self._chunk_output_offsets = [i.output_offset for i in self._chunks]
776 self.is_sparse = True
778 def _update_chunks_and_blocks(self):
786 self._image.seek(self.NUM_CHUNKS_AND_BLOCKS_OFFSET, os.SEEK_SET)
787 self._image.write(struct.pack(self.NUM_CHUNKS_AND_BLOCKS_FORMAT,
788 self._num_total_blocks,
789 self._num_total_chunks))
791 def append_dont_care(self, num_bytes):
799 assert num_bytes % self.block_size == 0
801 if not self.is_sparse:
802 self._image.seek(0, os.SEEK_END)
806 self._image.truncate(self._image.tell() + num_bytes)
807 self._read_header()
810 self._num_total_chunks += 1
811 self._num_total_blocks += num_bytes / self.block_size
812 self._update_chunks_and_blocks()
814 self._image.seek(self._sparse_end, os.SEEK_SET)
815 self._image.write(struct.pack(ImageChunk.FORMAT,
818 num_bytes / self.block_size,
820 self._read_header()
822 def append_raw(self, data):
830 assert len(data) % self.block_size == 0
832 if not self.is_sparse:
833 self._image.seek(0, os.SEEK_END)
834 self._image.write(data)
835 self._read_header()
838 self._num_total_chunks += 1
839 self._num_total_blocks += len(data) / self.block_size
840 self._update_chunks_and_blocks()
842 self._image.seek(self._sparse_end, os.SEEK_SET)
843 self._image.write(struct.pack(ImageChunk.FORMAT,
846 len(data) / self.block_size,
849 self._image.write(data)
850 self._read_header()
852 def append_fill(self, fill_data, size):
863 assert size % self.block_size == 0
865 if not self.is_sparse:
866 self._image.seek(0, os.SEEK_END)
867 self._image.write(fill_data * (size/4))
868 self._read_header()
871 self._num_total_chunks += 1
872 self._num_total_blocks += size / self.block_size
873 self._update_chunks_and_blocks()
875 self._image.seek(self._sparse_end, os.SEEK_SET)
876 self._image.write(struct.pack(ImageChunk.FORMAT,
879 size / self.block_size,
881 self._image.write(fill_data)
882 self._read_header()
884 def seek(self, offset):
892 self._file_pos = offset
894 def read(self, size):
910 if not self.is_sparse:
911 self._image.seek(self._file_pos)
912 data = self._image.read(size)
913 self._file_pos += len(data)
917 chunk_idx = bisect.bisect_right(self._chunk_output_offsets,
918 self._file_pos) - 1
922 chunk = self._chunks[chunk_idx]
923 chunk_pos_offset = self._file_pos - chunk.output_offset
927 self._image.seek(chunk.input_offset + chunk_pos_offset)
928 data.extend(self._image.read(chunk_pos_to_go))
938 self._file_pos += chunk_pos_to_go
941 if chunk_idx >= len(self._chunks):
946 def tell(self):
952 return self._file_pos
954 def truncate(self, size):
963 if not self.is_sparse:
964 self._image.truncate(size)
965 self._read_header()
968 if size % self.block_size != 0:
972 if size == self.image_size:
975 elif size < self.image_size:
976 chunk_idx = bisect.bisect_right(self._chunk_output_offsets, size) - 1
977 chunk = self._chunks[chunk_idx]
983 assert num_to_keep % self.block_size == 0
996 chunk_sz = num_to_keep/self.block_size
998 self._image.seek(chunk.chunk_offset)
999 self._image.write(struct.pack(ImageChunk.FORMAT,
1010 self._num_total_chunks = chunk_idx_for_update
1011 self._num_total_blocks = 0
1013 self._num_total_blocks += self._chunks[i].output_size / self.block_size
1014 self._update_chunks_and_blocks()
1015 self._image.truncate(truncate_at)
1018 self._read_header()
1021 self.append_dont_care(size - self.image_size)
1037 def __init__(self, data):
1046 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1049 (self.tag, num_bytes_following) = (
1050 struct.unpack(self.FORMAT_STRING, data[0:self.SIZE]))
1051 self.data = data[self.SIZE:self.SIZE + num_bytes_following]
1053 self.tag = None
1054 self.data = None
1056 def print_desc(self, o):
1063 o.write(' Tag: {}\n'.format(self.tag))
1064 if len(self.data) < 256:
1066 repr(str(self.data)), len(self.data)))
1068 o.write(' Data: {} bytes\n'.format(len(self.data)))
1070 def encode(self):
1076 num_bytes_following = len(self.data)
1079 desc = struct.pack(self.FORMAT_STRING, self.tag, nbf_with_padding)
1081 ret = desc + self.data + padding
1084 def verify(self, image_dir, image_ext, expected_chain_partitions_map,
1117 def __init__(self, data=None):
1126 AvbDescriptor.__init__(self, None)
1127 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1131 value_size) = struct.unpack(self.FORMAT_STRING, data[0:self.SIZE])
1133 self.SIZE - 16 + key_size + 1 + value_size + 1, 8)
1134 if tag != self.TAG or num_bytes_following != expected_size:
1137 self.key = data[self.SIZE:(self.SIZE + key_size)]
1138 self.value = data[(self.SIZE + key_size + 1):(self.SIZE + key_size + 1 +
1141 self.key = ''
1142 self.value = ''
1144 def print_desc(self, o):
1150 if len(self.value) < 256:
1151 o.write(' Prop: {} -> {}\n'.format(self.key, repr(str(self.value))))
1153 o.write(' Prop: {} -> ({} bytes)\n'.format(self.key, len(self.value)))
1155 def encode(self):
1161 num_bytes_following = self.SIZE + len(self.key) + len(self.value) + 2 - 16
1164 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1165 len(self.key), len(self.value))
1167 ret = desc + self.key + '\0' + self.value + '\0' + padding
1170 def verify(self, image_dir, image_ext, expected_chain_partitions_map,
1229 def __init__(self, data=None):
1238 AvbDescriptor.__init__(self, None)
1239 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1242 (tag, num_bytes_following, self.dm_verity_version, self.image_size,
1243 self.tree_offset, self.tree_size, self.data_block_size,
1244 self.hash_block_size, self.fec_num_roots, self.fec_offset, self.fec_size,
1245 self.hash_algorithm, partition_name_len, salt_len,
1246 root_digest_len, self.flags, _) = struct.unpack(self.FORMAT_STRING,
1247 data[0:self.SIZE])
1249 self.SIZE - 16 + partition_name_len + salt_len + root_digest_len, 8)
1250 if tag != self.TAG or num_bytes_following != expected_size:
1254 self.hash_algorithm = self.hash_algorithm.split('\0', 1)[0]
1256 self.partition_name = str(data[(self.SIZE + o):(self.SIZE + o +
1259 self.partition_name.decode('utf-8')
1261 self.salt = data[(self.SIZE + o):(self.SIZE + o + salt_len)]
1263 self.root_digest = data[(self.SIZE + o):(self.SIZE + o + root_digest_len)]
1264 if root_digest_len != len(hashlib.new(name=self.hash_algorithm).digest()):
1269 self.dm_verity_version = 0
1270 self.image_size = 0
1271 self.tree_offset = 0
1272 self.tree_size = 0
1273 self.data_block_size = 0
1274 self.hash_block_size = 0
1275 self.fec_num_roots = 0
1276 self.fec_offset = 0
1277 self.fec_size = 0
1278 self.hash_algorithm = ''
1279 self.partition_name = ''
1280 self.salt = bytearray()
1281 self.root_digest = bytearray()
1282 self.flags = 0
1284 def print_desc(self, o):
1291 o.write(' Version of dm-verity: {}\n'.format(self.dm_verity_version))
1292 o.write(' Image Size: {} bytes\n'.format(self.image_size))
1293 o.write(' Tree Offset: {}\n'.format(self.tree_offset))
1294 o.write(' Tree Size: {} bytes\n'.format(self.tree_size))
1296 self.data_block_size))
1298 self.hash_block_size))
1299 o.write(' FEC num roots: {}\n'.format(self.fec_num_roots))
1300 o.write(' FEC offset: {}\n'.format(self.fec_offset))
1301 o.write(' FEC size: {} bytes\n'.format(self.fec_size))
1302 o.write(' Hash Algorithm: {}\n'.format(self.hash_algorithm))
1303 o.write(' Partition Name: {}\n'.format(self.partition_name))
1304 o.write(' Salt: {}\n'.format(str(self.salt).encode(
1307 self.root_digest).encode('hex')))
1308 o.write(' Flags: {}\n'.format(self.flags))
1310 def encode(self):
1316 encoded_name = self.partition_name.encode('utf-8')
1317 num_bytes_following = (self.SIZE + len(encoded_name) + len(self.salt) +
1318 len(self.root_digest) - 16)
1321 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1322 self.dm_verity_version, self.image_size,
1323 self.tree_offset, self.tree_size, self.data_block_size,
1324 self.hash_block_size, self.fec_num_roots,
1325 self.fec_offset, self.fec_size, self.hash_algorithm,
1326 len(encoded_name), len(self.salt), len(self.root_digest),
1327 self.flags, self.RESERVED*'\0')
1329 ret = desc + encoded_name + self.salt + self.root_digest + padding
1332 def verify(self, image_dir, image_ext, expected_chain_partitions_map,
1346 if self.partition_name == '':
1349 image_filename = os.path.join(image_dir, self.partition_name + image_ext)
1352 digest_size = len(hashlib.new(name=self.hash_algorithm).digest())
1355 self.image_size, self.data_block_size, digest_size + digest_padding)
1356 root_digest, hash_tree = generate_hash_tree(image, self.image_size,
1357 self.data_block_size,
1358 self.hash_algorithm, self.salt,
1363 if len(self.root_digest) != 0 and root_digest != self.root_digest:
1368 image.seek(self.tree_offset)
1369 hash_tree_ondisk = image.read(self.tree_size)
1379 .format(self.partition_name, self.hash_algorithm, image.filename,
1380 self.image_size))
1410 def __init__(self, data=None):
1419 AvbDescriptor.__init__(self, None)
1420 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1423 (tag, num_bytes_following, self.image_size, self.hash_algorithm,
1425 digest_len, self.flags, _) = struct.unpack(self.FORMAT_STRING,
1426 data[0:self.SIZE])
1428 self.SIZE - 16 + partition_name_len + salt_len + digest_len, 8)
1429 if tag != self.TAG or num_bytes_following != expected_size:
1432 self.hash_algorithm = self.hash_algorithm.split('\0', 1)[0]
1434 self.partition_name = str(data[(self.SIZE + o):(self.SIZE + o +
1437 self.partition_name.decode('utf-8')
1439 self.salt = data[(self.SIZE + o):(self.SIZE + o + salt_len)]
1441 self.digest = data[(self.SIZE + o):(self.SIZE + o + digest_len)]
1442 if digest_len != len(hashlib.new(name=self.hash_algorithm).digest()):
1447 self.image_size = 0
1448 self.hash_algorithm = ''
1449 self.partition_name = ''
1450 self.salt = bytearray()
1451 self.digest = bytearray()
1452 self.flags = 0
1454 def print_desc(self, o):
1461 o.write(' Image Size: {} bytes\n'.format(self.image_size))
1462 o.write(' Hash Algorithm: {}\n'.format(self.hash_algorithm))
1463 o.write(' Partition Name: {}\n'.format(self.partition_name))
1464 o.write(' Salt: {}\n'.format(str(self.salt).encode(
1466 o.write(' Digest: {}\n'.format(str(self.digest).encode(
1468 o.write(' Flags: {}\n'.format(self.flags))
1470 def encode(self):
1476 encoded_name = self.partition_name.encode('utf-8')
1478 self.SIZE + len(encoded_name) + len(self.salt) + len(self.digest) - 16)
1481 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1482 self.image_size, self.hash_algorithm, len(encoded_name),
1483 len(self.salt), len(self.digest), self.flags,
1484 self.RESERVED*'\0')
1486 ret = desc + encoded_name + self.salt + self.digest + padding
1489 def verify(self, image_dir, image_ext, expected_chain_partitions_map,
1503 if self.partition_name == '':
1506 image_filename = os.path.join(image_dir, self.partition_name + image_ext)
1508 data = image.read(self.image_size)
1509 ha = hashlib.new(self.hash_algorithm)
1510 ha.update(self.salt)
1514 if len(self.digest) != 0 and digest != self.digest:
1516 format(self.hash_algorithm, image_filename))
1519 .format(self.partition_name, self.hash_algorithm, image.filename,
1520 self.image_size))
1543 def __init__(self, data=None):
1552 AvbDescriptor.__init__(self, None)
1553 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1556 (tag, num_bytes_following, self.flags, kernel_cmdline_length) = (
1557 struct.unpack(self.FORMAT_STRING, data[0:self.SIZE]))
1558 expected_size = round_to_multiple(self.SIZE - 16 + kernel_cmdline_length,
1560 if tag != self.TAG or num_bytes_following != expected_size:
1564 self.kernel_cmdline = str(data[self.SIZE:(self.SIZE +
1567 self.kernel_cmdline.decode('utf-8')
1569 self.flags = 0
1570 self.kernel_cmdline = ''
1572 def print_desc(self, o):
1579 o.write(' Flags: {}\n'.format(self.flags))
1581 self.kernel_cmdline)))
1583 def encode(self):
1589 encoded_str = self.kernel_cmdline.encode('utf-8')
1590 num_bytes_following = (self.SIZE + len(encoded_str) - 16)
1593 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1594 self.flags, len(encoded_str))
1599 def verify(self, image_dir, image_ext, expected_chain_partitions_map,
1636 def __init__(self, data=None):
1645 AvbDescriptor.__init__(self, None)
1646 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1649 (tag, num_bytes_following, self.rollback_index_location,
1651 public_key_len, _) = struct.unpack(self.FORMAT_STRING, data[0:self.SIZE])
1653 self.SIZE - 16 + partition_name_len + public_key_len, 8)
1654 if tag != self.TAG or num_bytes_following != expected_size:
1658 self.partition_name = str(data[(self.SIZE + o):(self.SIZE + o +
1661 self.partition_name.decode('utf-8')
1663 self.public_key = data[(self.SIZE + o):(self.SIZE + o + public_key_len)]
1666 self.rollback_index_location = 0
1667 self.partition_name = ''
1668 self.public_key = bytearray()
1670 def print_desc(self, o):
1677 o.write(' Partition Name: {}\n'.format(self.partition_name))
1679 self.rollback_index_location))
1681 hexdig = hashlib.sha1(self.public_key).hexdigest()
1684 def encode(self):
1690 encoded_name = self.partition_name.encode('utf-8')
1692 self.SIZE + len(encoded_name) + len(self.public_key) - 16)
1695 desc = struct.pack(self.FORMAT_STRING, self.TAG, nbf_with_padding,
1696 self.rollback_index_location, len(encoded_name),
1697 len(self.public_key), self.RESERVED*'\0')
1699 ret = desc + encoded_name + self.public_key + padding
1702 def verify(self, image_dir, image_ext, expected_chain_partitions_map,
1716 value = expected_chain_partitions_map.get(self.partition_name)
1721 format(self.partition_name))
1725 if self.rollback_index_location != rollback_index_location:
1729 self.rollback_index_location,
1730 self.partition_name))
1733 if self.public_key != pk_blob:
1736 format(self.partition_name))
1740 'expected data'.format(self.partition_name))
1800 def __init__(self, data=None):
1810 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1813 (self.magic, self.version_major, self.version_minor,
1814 self.original_image_size, self.vbmeta_offset,
1815 self.vbmeta_size) = struct.unpack(self.FORMAT_STRING, data)
1816 if self.magic != self.MAGIC:
1819 self.magic = self.MAGIC
1820 self.version_major = self.FOOTER_VERSION_MAJOR
1821 self.version_minor = self.FOOTER_VERSION_MINOR
1822 self.original_image_size = 0
1823 self.vbmeta_offset = 0
1824 self.vbmeta_size = 0
1826 def encode(self):
1832 return struct.pack(self.FORMAT_STRING, self.magic, self.version_major,
1833 self.version_minor, self.original_image_size,
1834 self.vbmeta_offset, self.vbmeta_size)
1867 def __init__(self, data=None):
1876 assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
1879 (self.magic, self.required_libavb_version_major,
1880 self.required_libavb_version_minor,
1881 self.authentication_data_block_size, self.auxiliary_data_block_size,
1882 self.algorithm_type, self.hash_offset, self.hash_size,
1883 self.signature_offset, self.signature_size, self.public_key_offset,
1884 self.public_key_size, self.public_key_metadata_offset,
1885 self.public_key_metadata_size, self.descriptors_offset,
1886 self.descriptors_size,
1887 self.rollback_index,
1888 self.flags,
1889 self.release_string) = struct.unpack(self.FORMAT_STRING, data)
1891 if self.magic != 'AVB0':
1894 self.magic = 'AVB0'
1898 self.required_libavb_version_major = AVB_VERSION_MAJOR
1899 self.required_libavb_version_minor = 0
1900 self.authentication_data_block_size = 0
1901 self.auxiliary_data_block_size = 0
1902 self.algorithm_type = 0
1903 self.hash_offset = 0
1904 self.hash_size = 0
1905 self.signature_offset = 0
1906 self.signature_size = 0
1907 self.public_key_offset = 0
1908 self.public_key_size = 0
1909 self.public_key_metadata_offset = 0
1910 self.public_key_metadata_size = 0
1911 self.descriptors_offset = 0
1912 self.descriptors_size = 0
1913 self.rollback_index = 0
1914 self.flags = 0
1915 self.release_string = get_release_string()
1917 def bump_required_libavb_version_minor(self, minor):
1926 self.required_libavb_version_minor = (
1927 max(self.required_libavb_version_minor, minor))
1929 def save(self, output):
1936 self.FORMAT_STRING, self.magic, self.required_libavb_version_major,
1937 self.required_libavb_version_minor, self.authentication_data_block_size,
1938 self.auxiliary_data_block_size, self.algorithm_type, self.hash_offset,
1939 self.hash_size, self.signature_offset, self.signature_size,
1940 self.public_key_offset, self.public_key_size,
1941 self.public_key_metadata_offset, self.public_key_metadata_size,
1942 self.descriptors_offset, self.descriptors_size, self.rollback_index,
1943 self.flags, self.release_string))
1945 def encode(self):
1951 return struct.pack(self.FORMAT_STRING, self.magic,
1952 self.required_libavb_version_major,
1953 self.required_libavb_version_minor,
1954 self.authentication_data_block_size,
1955 self.auxiliary_data_block_size, self.algorithm_type,
1956 self.hash_offset, self.hash_size, self.signature_offset,
1957 self.signature_size, self.public_key_offset,
1958 self.public_key_size, self.public_key_metadata_offset,
1959 self.public_key_metadata_size, self.descriptors_offset,
1960 self.descriptors_size, self.rollback_index, self.flags,
1961 self.release_string)
1981 def extract_vbmeta_image(self, output, image_filename, padding_size):
1994 (footer, _, _, _) = self._parse_image(image)
2008 def erase_footer(self, image_filename, keep_hashtree):
2021 (footer, _, descriptors, _) = self._parse_image(image)
2050 def resize_image(self, image_filename, partition_size):
2068 (footer, vbmeta_header, descriptors, _) = self._parse_image(image)
2100 def set_ab_metadata(self, misc_image, slot_data):
2123 ab_data_no_crc = struct.pack(self.AB_FORMAT_NO_CRC,
2124 self.AB_MAGIC,
2125 self.AB_MAJOR_VERSION, self.AB_MINOR_VERSION,
2131 misc_image.seek(self.AB_MISC_METADATA_OFFSET)
2134 def info_image(self, image_filename, output):
2146 (footer, header, descriptors, image_size) = self._parse_image(image)
2184 def verify_image(self, image_filename, key_path, expected_chain_partitions):
2217 (footer, header, descriptors, image_size) = self._parse_image(image)
2270 def calculate_vbmeta_digest(self, image_filename, hash_algorithm, output):
2283 (footer, header, descriptors, image_size) = self._parse_image(image)
2299 (ch_footer, ch_header, ch_descriptors, ch_image_size) = self._parse_image(ch_image)
2313 def calculate_kernel_cmdline(self, image_filename, hashtree_disabled, output):
2323 _, _, descriptors, _ = self._parse_image(image)
2333 _, _, ch_descriptors, _ = self._parse_image(ch_image)
2354 def _parse_image(self, image):
2393 def _load_vbmeta_blob(self, image):
2426 def _get_cmdline_descriptors_for_hashtree_descriptor(self, ht):
2484 def _get_cmdline_descriptors_for_dm_verity(self, image):
2500 (_, _, descriptors, _) = self._parse_image(image)
2511 return self._get_cmdline_descriptors_for_hashtree_descriptor(ht)
2513 def make_vbmeta_image(self, output, chain_partitions, algorithm_name,
2557 (_, image_header, _, _) = self._parse_image(ImageHandler(image.name))
2571 vbmeta_blob = self._generate_vbmeta_blob(
2588 def _generate_vbmeta_blob(self, algorithm_name, key_path,
2707 cmdline_desc = self._get_cmdline_descriptors_for_dm_verity(image_handler)
2713 cmdline_desc = self._get_cmdline_descriptors_for_hashtree_descriptor(
2730 (_, image_vbmeta_header, image_descriptors, _) = self._parse_image(
2837 def extract_public_key(self, key_path, output):
2846 def append_vbmeta_image(self, image_filename, vbmeta_image_filename,
2884 vbmeta_blob = self._load_vbmeta_blob(vbmeta_image_handler)
2928 def add_hash_footer(self, image_filename, partition_size, partition_name,
2990 max_metadata_size = self.MAX_VBMETA_SIZE + self.MAX_FOOTER_SIZE
3068 vbmeta_blob = self._generate_vbmeta_blob(
3125 def add_hashtree_footer(self, image_filename, partition_size, partition_name,
3209 self.MAX_VBMETA_SIZE +
3210 self.MAX_FOOTER_SIZE)
3341 vbmeta_blob = self._generate_vbmeta_blob(
3383 def make_atx_certificate(self, output, authority_key_path, subject_key_path,
3443 def make_atx_permanent_attributes(self, output, root_authority_key_path,
3467 def make_atx_metadata(self, output, intermediate_key_certificate,
3496 def make_atx_unlock_credential(self, output, intermediate_key_certificate,
3718 def __init__(self):
3720 self.avb = Avb()
3722 def _add_common_args(self, sub_parser):
3803 def _add_common_footer_args(self, sub_parser):
3822 def _fixup_common_args(self, args):
3835 def run(self, argv):
3846 sub_parser.set_defaults(func=self.version)
3857 sub_parser.set_defaults(func=self.extract_public_key)
3870 self._add_common_args(sub_parser)
3871 sub_parser.set_defaults(func=self.make_vbmeta_image)
3902 self._add_common_args(sub_parser)
3903 self._add_common_footer_args(sub_parser)
3904 sub_parser.set_defaults(func=self.add_hash_footer)
3918 sub_parser.set_defaults(func=self.append_vbmeta_image)
3976 self._add_common_args(sub_parser)
3977 self._add_common_footer_args(sub_parser)
3978 sub_parser.set_defaults(func=self.add_hashtree_footer)
3989 sub_parser.set_defaults(func=self.erase_footer)
4006 sub_parser.set_defaults(func=self.extract_vbmeta_image)
4017 sub_parser.set_defaults(func=self.resize_image)
4030 sub_parser.set_defaults(func=self.info_image)
4047 sub_parser.set_defaults(func=self.verify_image)
4063 sub_parser.set_defaults(func=self.calculate_vbmeta_digest)
4079 sub_parser.set_defaults(func=self.calculate_kernel_cmdline)
4095 sub_parser.set_defaults(func=self.set_ab_metadata)
4137 sub_parser.set_defaults(func=self.make_atx_certificate)
4154 sub_parser.set_defaults(func=self.make_atx_permanent_attributes)
4171 sub_parser.set_defaults(func=self.make_atx_metadata)
4208 sub_parser.set_defaults(func=self.make_atx_unlock_credential)
4217 def version(self, _):
4221 def extract_public_key(self, args):
4223 self.avb.extract_public_key(args.key, args.output)
4225 def make_vbmeta_image(self, args):
4227 args = self._fixup_common_args(args)
4228 self.avb.make_vbmeta_image(args.output, args.chain_partition,
4242 def append_vbmeta_image(self, args):
4244 self.avb.append_vbmeta_image(args.image.name, args.vbmeta_image.name,
4247 def add_hash_footer(self, args):
4249 args = self._fixup_common_args(args)
4250 self.avb.add_hash_footer(args.image.name if args.image else None,
4271 def add_hashtree_footer(self, args):
4273 args = self._fixup_common_args(args)
4280 self.avb.add_hashtree_footer(args.image.name if args.image else None,
4304 def erase_footer(self, args):
4306 self.avb.erase_footer(args.image.name, args.keep_hashtree)
4308 def extract_vbmeta_image(self, args):
4310 self.avb.extract_vbmeta_image(args.output, args.image.name,
4313 def resize_image(self, args):
4315 self.avb.resize_image(args.image.name, args.partition_size)
4317 def set_ab_metadata(self, args):
4319 self.avb.set_ab_metadata(args.misc_image, args.slot_data)
4321 def info_image(self, args):
4323 self.avb.info_image(args.image.name, args.output)
4325 def verify_image(self, args):
4327 self.avb.verify_image(args.image.name, args.key,
4330 def calculate_vbmeta_digest(self, args):
4332 self.avb.calculate_vbmeta_digest(args.image.name, args.hash_algorithm,
4335 def calculate_kernel_cmdline(self, args):
4337 self.avb.calculate_kernel_cmdline(args.image.name, args.hashtree_disabled, args.output)
4339 def make_atx_certificate(self, args):
4341 self.avb.make_atx_certificate(args.output, args.authority_key,
4350 def make_atx_permanent_attributes(self, args):
4352 self.avb.make_atx_permanent_attributes(args.output,
4356 def make_atx_metadata(self, args):
4358 self.avb.make_atx_metadata(args.output,
4362 def make_atx_unlock_credential(self, args):
4364 self.avb.make_atx_unlock_credential(