Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit be469cf9 authored by Hung-Wei Chen's avatar Hung-Wei Chen Committed by Gerrit Code Review
Browse files

Merge changes Icc298256,I9268cb11,I446a0b16,I347447eb,Iaae39e4c, ... 

* changes:
  Remove HashTreeInfo from verity_utils.py
  Remove verity keys from info_dict
  Remove replace verity key args
  Remove unused args from common.py
  Clean up unused code for VB in verity_utils.py
  Remove verity related props from build_image.py
parents 1eb2dc87 cc9c05d5

tools/releasetools/add_img_to_target_files.py

+5 −6
Original line number Diff line number Diff line
@@ -76,8 +76,6 @@ OPTIONS = common.OPTIONS 
OPTIONS.add_missing = False

OPTIONS.rebuild_recovery = False

OPTIONS.replace_updated_files_list = []

OPTIONS.replace_verity_public_key = False

OPTIONS.replace_verity_private_key = False

OPTIONS.is_signing = False



# Use a fixed timestamp (01/01/2009 00:00:00 UTC) for files when packaging
@@ -457,8 +455,7 @@ def CreateImage(input_dir, info_dict, what, output_file, block_list=None): 


  # Set the '_image_size' for given image size.

  is_verity_partition = "verity_block_device" in image_props

  verity_supported = (image_props.get("verity") == "true" or

                      image_props.get("avb_enable") == "true")

  verity_supported = (image_props.get("avb_enable") == "true")

  is_avb_enable = image_props.get("avb_hashtree_enable") == "true"

  if verity_supported and (is_verity_partition or is_avb_enable):

    image_size = image_props.get("image_size")
@@ -1064,9 +1061,11 @@ def main(argv): 
    elif o in ("-r", "--rebuild_recovery",):

      OPTIONS.rebuild_recovery = True

    elif o == "--replace_verity_private_key":

      OPTIONS.replace_verity_private_key = (True, a)

      raise ValueError("--replace_verity_private_key is no longer supported,"

                       " please switch to AVB")

    elif o == "--replace_verity_public_key":

      OPTIONS.replace_verity_public_key = (True, a)

      raise ValueError("--replace_verity_public_key is no longer supported,"

                       " please switch to AVB")

    elif o == "--is_signing":

      OPTIONS.is_signing = True

    else:

tools/releasetools/blockimgdiff.py

+0 −14
Original line number Diff line number Diff line
@@ -537,14 +537,6 @@ class BlockImageDiff(object): 


    self.touched_src_sha1 = self.src.RangeSha1(self.touched_src_ranges)



    if self.tgt.hashtree_info:

      out.append("compute_hash_tree {} {} {} {} {}\n".format(

          self.tgt.hashtree_info.hashtree_range.to_string_raw(),

          self.tgt.hashtree_info.filesystem_range.to_string_raw(),

          self.tgt.hashtree_info.hash_algorithm,

          self.tgt.hashtree_info.salt,

          self.tgt.hashtree_info.root_hash))



    # Zero out extended blocks as a workaround for bug 20881595.

    if self.tgt.extended:

      assert (WriteSplitTransfers(out, "zero", self.tgt.extended) ==
@@ -830,12 +822,6 @@ class BlockImageDiff(object): 
          assert touched[i] == 0

          touched[i] = 1



    if self.tgt.hashtree_info:

      for s, e in self.tgt.hashtree_info.hashtree_range:

        for i in range(s, e):

          assert touched[i] == 0

          touched[i] = 1



    # Check that we've written every target block.

    for s, e in self.tgt.care_map:

      for i in range(s, e):

tools/releasetools/build_image.py

+0 −5
Original line number Diff line number Diff line
@@ -671,11 +671,6 @@ def ImagePropFromGlobalDict(glob_dict, mount_point): 
      "f2fs_sparse_flag",

      "skip_fsck",

      "ext_mkuserimg",

      "verity",

      "verity_key",

      "verity_signer_cmd",

      "verity_fec",

      "verity_disable",

      "avb_enable",

      "avb_avbtool",

      "use_dynamic_partition_size",

tools/releasetools/common.py

+11 −37
Original line number Diff line number Diff line
@@ -82,10 +82,6 @@ class Options(object): 
    self.public_key_suffix = ".x509.pem"

    self.private_key_suffix = ".pk8"

    # use otatools built boot_signer by default

    self.boot_signer_path = "boot_signer"

    self.boot_signer_args = []

    self.verity_signer_path = None

    self.verity_signer_args = []

    self.verbose = False

    self.tempfiles = []

    self.device_specific = None
@@ -1686,23 +1682,9 @@ def _BuildBootableImage(image_name, sourcedir, fs_config_file, info_dict=None, 
    with open(img.name, 'ab') as f:

      f.write(boot_signature_bytes)



  if (info_dict.get("boot_signer") == "true" and

          info_dict.get("verity_key")):

    # Hard-code the path as "/boot" for two-step special recovery image (which

    # will be loaded into /boot during the two-step OTA).

    if two_step_image:

      path = "/boot"

    else:

      path = "/" + partition_name

    cmd = [OPTIONS.boot_signer_path]

    cmd.extend(OPTIONS.boot_signer_args)

    cmd.extend([path, img.name,

                info_dict["verity_key"] + ".pk8",

                info_dict["verity_key"] + ".x509.pem", img.name])

    RunAndCheckOutput(cmd)



  # Sign the image if vboot is non-empty.

  elif info_dict.get("vboot"):

  if info_dict.get("vboot"):

    path = "/" + partition_name

    img_keyblock = tempfile.NamedTemporaryFile()

    # We have switched from the prebuilt futility binary to using the tool
@@ -2077,7 +2059,6 @@ def UnzipTemp(filename, patterns=None): 
def GetUserImage(which, tmpdir, input_zip,

                 info_dict=None,

                 allow_shared_blocks=None,

                 hashtree_info_generator=None,

                 reset_file_map=False):

  """Returns an Image object suitable for passing to BlockImageDiff.
@@ -2094,8 +2075,6 @@ def GetUserImage(which, tmpdir, input_zip, 
    info_dict: The dict to be looked up for relevant info.

    allow_shared_blocks: If image is sparse, whether having shared blocks is

        allowed. If none, it is looked up from info_dict.

    hashtree_info_generator: If present and image is sparse, generates the

        hashtree_info for this sparse image.

    reset_file_map: If true and image is sparse, reset file map before returning

        the image.

  Returns:
@@ -2117,15 +2096,14 @@ def GetUserImage(which, tmpdir, input_zip, 
    allow_shared_blocks = info_dict.get("ext4_share_dup_blocks") == "true"



  if is_sparse:

    img = GetSparseImage(which, tmpdir, input_zip, allow_shared_blocks,

                         hashtree_info_generator)

    img = GetSparseImage(which, tmpdir, input_zip, allow_shared_blocks)

    if reset_file_map:

      img.ResetFileMap()

    return img

  return GetNonSparseImage(which, tmpdir, hashtree_info_generator)

  return GetNonSparseImage(which, tmpdir)





def GetNonSparseImage(which, tmpdir, hashtree_info_generator=None):

def GetNonSparseImage(which, tmpdir):

  """Returns a Image object suitable for passing to BlockImageDiff.



  This function loads the specified non-sparse image from the given path.
@@ -2143,11 +2121,10 @@ def GetNonSparseImage(which, tmpdir, hashtree_info_generator=None): 
  # ota_from_target_files.py (since LMP).

  assert os.path.exists(path) and os.path.exists(mappath)



  return images.FileImage(path, hashtree_info_generator=hashtree_info_generator)

  return images.FileImage(path)





def GetSparseImage(which, tmpdir, input_zip, allow_shared_blocks,

                   hashtree_info_generator=None):

def GetSparseImage(which, tmpdir, input_zip, allow_shared_blocks):

  """Returns a SparseImage object suitable for passing to BlockImageDiff.



  This function loads the specified sparse image from the given path, and
@@ -2160,8 +2137,6 @@ def GetSparseImage(which, tmpdir, input_zip, allow_shared_blocks, 
    tmpdir: The directory that contains the prebuilt image and block map file.

    input_zip: The target-files ZIP archive.

    allow_shared_blocks: Whether having shared blocks is allowed.

    hashtree_info_generator: If present, generates the hashtree_info for this

        sparse image.

  Returns:

    A SparseImage object, with file_map info loaded.

  """
@@ -2178,8 +2153,7 @@ def GetSparseImage(which, tmpdir, input_zip, allow_shared_blocks, 
  clobbered_blocks = "0"



  image = sparse_img.SparseImage(

      path, mappath, clobbered_blocks, allow_shared_blocks=allow_shared_blocks,

      hashtree_info_generator=hashtree_info_generator)

      path, mappath, clobbered_blocks, allow_shared_blocks=allow_shared_blocks)



  # block.map may contain less blocks, because mke2fs may skip allocating blocks

  # if they contain all zeros. We can't reconstruct such a file from its block
@@ -2634,13 +2608,13 @@ def ParseOptions(argv, 
    elif o in ("--private_key_suffix",):

      OPTIONS.private_key_suffix = a

    elif o in ("--boot_signer_path",):

      OPTIONS.boot_signer_path = a

      raise ValueError("--boot_signer_path is no longer supported, please switch to AVB")

    elif o in ("--boot_signer_args",):

      OPTIONS.boot_signer_args = shlex.split(a)

      raise ValueError("--boot_signer_args is no longer supported, please switch to AVB")

    elif o in ("--verity_signer_path",):

      OPTIONS.verity_signer_path = a

      raise ValueError("--verity_signer_path is no longer supported, please switch to AVB")

    elif o in ("--verity_signer_args",):

      OPTIONS.verity_signer_args = shlex.split(a)

      raise ValueError("--verity_signer_args is no longer supported, please switch to AVB")

    elif o in ("-s", "--device_specific"):

      OPTIONS.device_specific = a

    elif o in ("-x", "--extra"):

tools/releasetools/images.py

+1 −7
Original line number Diff line number Diff line
@@ -149,7 +149,7 @@ class DataImage(Image): 
class FileImage(Image):

  """An image wrapped around a raw image file."""



  def __init__(self, path, hashtree_info_generator=None):

  def __init__(self, path):

    self.path = path

    self.blocksize = 4096

    self._file_size = os.path.getsize(self.path)
@@ -166,10 +166,6 @@ class FileImage(Image): 


    self.generator_lock = threading.Lock()



    self.hashtree_info = None

    if hashtree_info_generator:

      self.hashtree_info = hashtree_info_generator.Generate(self)



    zero_blocks = []

    nonzero_blocks = []

    reference = '\0' * self.blocksize
@@ -190,8 +186,6 @@ class FileImage(Image): 
      self.file_map["__ZERO"] = RangeSet(data=zero_blocks)

    if nonzero_blocks:

      self.file_map["__NONZERO"] = RangeSet(data=nonzero_blocks)

    if self.hashtree_info:

      self.file_map["__HASHTREE"] = self.hashtree_info.hashtree_range



  def __del__(self):

    self._file.close()