def main(argv): # Get sparse image input_image = sparse_img.SparseImage(INPUT_IMAGE, tempfile.mkstemp()[1], '0') # Generate output files b = blockimgdiff.BlockImageDiff(input_image, None) b.Compute('system') print('Done! Output files: %s' % os.path.dirname(__file__)) return
def GetCareMap(which, imgname): """Generate care_map of system (or vendor) partition""" assert which in ("system", "vendor") _, blk_device = common.GetTypeAndDevice("/" + which, OPTIONS.info_dict) simg = sparse_img.SparseImage(imgname) care_map_list = [] care_map_list.append(blk_device) care_map_list.append(simg.care_map.to_string_raw()) return care_map_list
def _GetImage(which, tmpdir): assert which in ('system', 'vendor') path = os.path.join(tmpdir, 'IMAGES', which + '.img') mappath = os.path.join(tmpdir, 'IMAGES', which + '.map') # Map file must exist (allowed to be empty). assert os.path.exists(path) and os.path.exists(mappath) clobbered_blocks = '0' return sparse_img.SparseImage(path, mappath, clobbered_blocks)
def test_Generate(self): image_file = sparse_img.SparseImage(self._generate_image()) generator = CreateHashtreeInfoGenerator('system', 4096, self.prop_dict) info = generator.Generate(image_file) self.assertEqual(RangeSet(data=[0, 991232 / 4096]), info.filesystem_range) self.assertEqual(RangeSet(data=[991232 / 4096, (991232 + 12288) / 4096]), info.hashtree_range) self.assertEqual(self.hash_algorithm, info.hash_algorithm) self.assertEqual(self.fixed_salt, info.salt) self.assertEqual(self.expected_root_hash, info.root_hash)
def test_ParseHashtreeMetadata(self): image_file = sparse_img.SparseImage(self._generate_image()) generator = VerifiedBootVersion1HashtreeInfoGenerator( self.partition_size, 4096, True) generator.DecomposeSparseImage(image_file) # pylint: disable=protected-access generator._ParseHashtreeMetadata() self.assertEqual( self.hash_algorithm, generator.hashtree_info.hash_algorithm) self.assertEqual(self.fixed_salt, generator.hashtree_info.salt) self.assertEqual(self.expected_root_hash, generator.hashtree_info.root_hash)
def test_ValidateHashtree_failure(self): generator = VerifiedBootVersion1HashtreeInfoGenerator( self.partition_size, 4096, True) generator.image = sparse_img.SparseImage(self._GenerateImage()) generator.hashtree_info = info = HashtreeInfo() info.filesystem_range = RangeSet(data=[0, 991232 // 4096]) info.hashtree_range = RangeSet( data=[991232 // 4096, (991232 + 12288) // 4096]) info.hash_algorithm = self.hash_algorithm info.salt = self.fixed_salt info.root_hash = "a" + self.expected_root_hash[1:] self.assertFalse(generator.ValidateHashtree())
def GetCareMap(which, imgname): """Generates the care_map for the given partition.""" assert which in PARTITIONS_WITH_CARE_MAP simg = sparse_img.SparseImage(imgname) care_map_ranges = simg.care_map key = which + "_adjusted_partition_size" adjusted_blocks = OPTIONS.info_dict.get(key) if adjusted_blocks: assert adjusted_blocks > 0, "blocks should be positive for " + which care_map_ranges = care_map_ranges.intersect(rangelib.RangeSet( "0-%d" % (adjusted_blocks,))) return [which, care_map_ranges.to_string_raw()]
def main(argv): global input if len(sys.argv) < 3: outdir = './system' else: outdir = sys.argv[2] + '/system' if len(sys.argv) < 4: version = 4 item = True while item: print(''' 1. Android Lollipop 5.0 2. Android Lollipop 5.1 3. Android Marshmallow 6.0 4. Android Nougat 7.0/7.1/8.0 ''') try: input = raw_input except NameError: pass item = input('Choose system version: ') if item == '1': version = 1 break elif item == '2': version = 2 break elif item == '3': version = 3 break elif item == '4': version = 4 break else: return else: version = int(sys.argv[3]) # Get sparse image image = sparse_img.SparseImage(INPUT_IMAGE, tempfile.mkstemp()[1], '0') # Generate output files b = blockimgdiff.BlockImageDiff(image, None, version) b.Compute(outdir) print('Done! Output files: %s' % os.path.dirname(outdir)) return
def GetCareMap(which, imgname): """Generate care_map of system (or vendor) partition""" assert which in ("system", "vendor") simg = sparse_img.SparseImage(imgname) care_map_list = [which] care_map_ranges = simg.care_map key = which + "_adjusted_partition_size" adjusted_blocks = OPTIONS.info_dict.get(key) if adjusted_blocks: assert adjusted_blocks > 0, "blocks should be positive for " + which care_map_ranges = care_map_ranges.intersect( rangelib.RangeSet("0-%d" % (adjusted_blocks, ))) care_map_list.append(care_map_ranges.to_string_raw()) return care_map_list
def GetImage(which, tmpdir, info_dict): # Return an image object (suitable for passing to BlockImageDiff) # for the 'which' partition (most be "system" or "vendor"). If a # prebuilt image and file map are found in tmpdir they are used, # otherwise they are reconstructed from the individual files. path = os.path.join(tmpdir, "IMAGES", which + ".img") mappath = os.path.join(tmpdir, "IMAGES", which + ".map") if os.path.exists(path) and os.path.exists(mappath): print "using %s.img from target-files" % (which, ) # This is a 'new' target-files, which already has the image in it. else: print "building %s.img from target-files" % (which, ) # This is an 'old' target-files, which does not contain images # already built. Build them. mappath = tempfile.mkstemp()[1] common.OPTIONS.tempfiles.append(mappath) path = BuildExt4(which, tmpdir, info_dict, block_list=mappath) return sparse_img.SparseImage(path, mappath)
def GetSystemImage(info, tmpdir): path = os.path.join(tmpdir, "IMAGES", "system.img") mappath = os.path.join(tmpdir, "IMAGES", "system.map") if os.path.exists(path) and os.path.exists(mappath): print "using system.img from target-files" # This is a 'new' target-files, which already has the image in it. else: print "building system.img from target-files" # This is an 'old' target-files, which does not contain images # already built. Build them. mappath = tempfile.mkstemp()[1] OPTIONS.tempfiles.append(mappath) import add_img_to_target_files path = add_img_to_target_files.BuildSystem(tmpdir, info, block_list=mappath) return sparse_img.SparseImage(path, mappath)
def GetCareMap(which, imgname): """Returns the care_map string for the given partition. Args: which: The partition name, must be listed in PARTITIONS_WITH_CARE_MAP. imgname: The filename of the image. Returns: (which, care_map_ranges): care_map_ranges is the raw string of the care_map RangeSet. """ assert which in PARTITIONS_WITH_CARE_MAP simg = sparse_img.SparseImage(imgname) care_map_ranges = simg.care_map key = which + "_image_blocks" image_blocks = OPTIONS.info_dict.get(key) if image_blocks: assert image_blocks > 0, "blocks for {} must be positive".format(which) care_map_ranges = care_map_ranges.intersect( rangelib.RangeSet("0-{}".format(image_blocks))) return [which, care_map_ranges.to_string_raw()]
def GetCareMap(which, imgname): """Returns the care_map string for the given partition. Args: which: The partition name, must be listed in PARTITIONS_WITH_CARE_MAP. imgname: The filename of the image. Returns: (which, care_map_ranges): care_map_ranges is the raw string of the care_map RangeSet. """ assert which in PARTITIONS_WITH_CARE_MAP simg = sparse_img.SparseImage(imgname) care_map_ranges = simg.care_map key = which + "_adjusted_partition_size" adjusted_blocks = OPTIONS.info_dict.get(key) if adjusted_blocks: assert adjusted_blocks > 0, "blocks should be positive for " + which care_map_ranges = care_map_ranges.intersect( rangelib.RangeSet("0-%d" % (adjusted_blocks, ))) return [which, care_map_ranges.to_string_raw()]
def main(argv): if len(sys.argv) < 3: version = 4 item = True while item: print(''' 1. Android Lollipop 5.0 2. Android Lollipop 5.1 3. Android Marshmallow 6.0 4. Android Nougat 7.0 ''') item = raw_input('Choose system version: ') if item == '1': version = 1 break elif item == '2': version = 2 break elif item == '3': version = 3 break elif item == '4': version = 4 break else: return else: version = int(sys.argv[2]) # Get sparse image image = sparse_img.SparseImage(INPUT_IMAGE, tempfile.mkstemp()[1], '0') # Generate output files b = blockimgdiff.BlockImageDiff(image, None, version) b.Compute('system') print('Done! Output files: %s' % os.path.dirname(__file__)) return
def GetCareMap(which, imgname): """Returns the care_map string for the given partition. Args: which: The partition name, must be listed in PARTITIONS_WITH_CARE_MAP. imgname: The filename of the image. Returns: (which, care_map_ranges): care_map_ranges is the raw string of the care_map RangeSet; or None. """ assert which in common.PARTITIONS_WITH_CARE_MAP # which + "_image_size" contains the size that the actual filesystem image # resides in, which is all that needs to be verified. The additional blocks in # the image file contain verity metadata, by reading which would trigger # invalid reads. image_size = OPTIONS.info_dict.get(which + "_image_size") if not image_size: return None image_blocks = int(image_size) // 4096 - 1 assert image_blocks > 0, "blocks for {} must be positive".format(which) # For sparse images, we will only check the blocks that are listed in the care # map, i.e. the ones with meaningful data. if "extfs_sparse_flag" in OPTIONS.info_dict: simg = sparse_img.SparseImage(imgname) care_map_ranges = simg.care_map.intersect( rangelib.RangeSet("0-{}".format(image_blocks))) # Otherwise for non-sparse images, we read all the blocks in the filesystem # image. else: care_map_ranges = rangelib.RangeSet("0-{}".format(image_blocks)) return [which, care_map_ranges.to_string_raw()]
def ZeroPadSimg(image_file, pad_size): blocks = pad_size // BLOCK_SIZE logger.info("Padding %d blocks (%d bytes)", blocks, pad_size) simg = sparse_img.SparseImage(image_file, mode="r+b", build_map=False) simg.AppendFillChunk(0, blocks)
def GetSimgSize(image_file): simg = sparse_img.SparseImage(image_file, build_map=False) return simg.blocksize * simg.total_blocks
def GetPartitionSizeFromImage(img): try: simg = sparse_img.SparseImage(img) return simg.blocksize * simg.total_blocks except ValueError: return os.path.getsize(img)
def main(sysimg, outdir): tgt = sparse_img.SparseImage(sysimg) bif = blockimgdiff.BlockImageDiff(tgt, None) bif.Compute(outdir) return