diff --git a/Android.bp b/Android.bp
index 60926e6..6e438d8 100644
--- a/Android.bp
+++ b/Android.bp
@@ -99,8 +99,6 @@
         "libavb/avb_kernel_cmdline_descriptor.c",
         "libavb/avb_property_descriptor.c",
         "libavb/avb_rsa.c",
-        "libavb/avb_sha256.c",
-        "libavb/avb_sha512.c",
         "libavb/avb_slot_verify.c",
         "libavb/avb_util.c",
         "libavb/avb_vbmeta_image.c",
@@ -108,6 +106,30 @@
     ],
 }
 
+cc_defaults {
+    name: "avb_crypto_ops_impl_boringssl",
+    srcs: [
+        "libavb/boringssl/sha.c",
+    ],
+    local_include_dirs: [
+        "libavb/boringssl",
+    ],
+    shared_libs: [
+        "libcrypto",
+    ],
+}
+
+cc_defaults {
+    name: "avb_crypto_ops_impl_sha",
+    srcs: [
+        "libavb/sha/sha256_impl.c",
+        "libavb/sha/sha512_impl.c",
+    ],
+    local_include_dirs: [
+        "libavb/sha",
+    ],
+}
+
 python_binary_host {
     name: "avbtool",
     srcs: ["avbtool.py"],
@@ -125,89 +147,16 @@
     compile_multilib: "first",
 }
 
-python_library_host {
-    name: "aftl_proto",
-    srcs: [
-        "proto/api.proto",
-        "proto/crypto/sigpb/sigpb.proto",
-        "proto/crypto/keyspb/keyspb.proto",
-        "proto/trillian.proto",
-    ],
-    proto: {
-        include_dirs: [
-            "external/protobuf/src",
-        ],
-        local_include_dirs: [
-            "proto",
-        ],
-        canonical_path_from_root: false,
-    },
-    version: {
-        py2: {
-            enabled: false,
-        },
-        py3: {
-            enabled: true,
-        },
-    },
-}
-
-python_binary_host {
-    name: "aftltool",
-    srcs: [
-        "aftltool.py",
-        "avbtool.py",
-    ],
-    libs: [
-        "aftl_proto",
-    ],
-    main: "aftltool.py",
-    version: {
-        py2: {
-            enabled: false,
-        },
-        py3: {
-            enabled: true,
-        },
-    },
-}
-
-python_test_host {
-    name: "aftltool_test",
-    main: "aftltool_test.py",
-    srcs: [
-        "aftltool.py",
-        "aftltool_test.py",
-        "avbtool.py",
-    ],
-    libs: [
-        "aftl_proto",
-    ],
-    data: [
-        "test/data/**/*.*",
-    ],
-    test_options: {
-        unit_test: true,
-    },
-    version: {
-        py2: {
-            enabled: false,
-        },
-        py3: {
-            enabled: true,
-        },
-    },
-}
-
-// Build libavb - this is a static library that depends
 // on only libc and doesn't drag in any other dependencies.
 cc_library_static {
     name: "libavb",
     defaults: [
         "avb_defaults",
         "avb_sources",
+        "avb_crypto_ops_impl_boringssl",
     ],
     host_supported: true,
+    ramdisk_available: true,
     recovery_available: true,
     header_libs: [
         "avb_headers",
@@ -231,6 +180,7 @@
     defaults: [
         "avb_defaults",
         "avb_sources",
+        "avb_crypto_ops_impl_boringssl",
     ],
     recovery_available: true,
     header_libs: [
@@ -258,7 +208,10 @@
         "libavb_user",
         "libfs_mgr",
     ],
-    shared_libs: ["libbase"],
+    shared_libs: [
+        "libbase",
+        "libcrypto",
+    ],
     srcs: ["tools/avbctl/avbctl.cc"],
 }
 
@@ -276,55 +229,12 @@
     srcs: ["libavb_ab/avb_ab_flow.c"],
 }
 
-cc_library_static {
-    name: "libavb_aftl",
-    defaults: [
-        "avb_defaults",
-        "avb_sources",
-    ],
-    host_supported: true,
-    recovery_available: true,
-    header_libs: ["avb_headers"],
-    export_header_lib_headers: ["avb_headers"],
-    cflags: [
-        "-fno-stack-protector",
-    ],
-    srcs: [
-        "libavb_aftl/avb_aftl_util.c",
-        "libavb_aftl/avb_aftl_validate.c",
-        "libavb_aftl/avb_aftl_verify.c",
-    ],
-}
-
-cc_fuzz {
-    name: "libavb_aftl_fuzzer",
-    defaults: ["avb_defaults"],
-    // The fuzzing entry point is declared and defined in the same file.
-    // Overwrite the behaviour introduced by avb_defaults.
-    cflags: [
-        "-Wno-missing-prototypes",
-    ],
-    srcs: [
-        "test/avb_aftl_fuzz.cc",
-    ],
-    static_libs: [
-        "libavb",
-        "libavb_aftl",
-    ],
-    host_supported: true,
-    corpus: ["test/corpus/*"],
-    fuzz_config: {
-        cc: [
-            "tweek@google.com",
-            "jpm@google.com",
-        ],
-        componentid: 685985,
-    },
-}
-
 cc_library_host_static {
     name: "libavb_atx_host",
-    defaults: ["avb_defaults"],
+    defaults: [
+        "avb_defaults",
+        "avb_crypto_ops_impl_boringssl",
+    ],
     header_libs: [
         "avb_headers",
     ],
@@ -347,7 +257,10 @@
 
 cc_library_host_static {
     name: "libavb_things_example",
-    defaults: ["avb_defaults"],
+    defaults: [
+        "avb_defaults",
+        "avb_crypto_ops_impl_boringssl",
+    ],
     header_libs: [
         "avb_headers",
     ],
@@ -355,8 +268,8 @@
     srcs: ["examples/things/avb_atx_slot_verify.c"],
 }
 
-cc_test_host {
-    name: "libavb_host_unittest",
+cc_defaults {
+    name: "libavb_host_unittest_core",
     defaults: ["avb_defaults"],
     required: [
         "simg2img",
@@ -368,10 +281,7 @@
     },
     compile_multilib: "first",
     data: [
-        ":img2simg",
-        ":simg2img",
         "avbtool",
-        ":fec",
         "test/avbtool_signing_helper_test.py",
         "test/avbtool_signing_helper_with_files_test.py",
         "test/data/*",
@@ -381,7 +291,6 @@
     static_libs: [
         "libavb",
         "libavb_ab_host",
-        "libavb_aftl",
         "libavb_atx_host",
         "libavb_things_example",
         "libgmock_host",
@@ -398,11 +307,9 @@
     ],
     srcs: [
         "test/avb_ab_flow_unittest.cc",
-        "test/avb_aftl_util_unittest.cc",
-        "test/avb_aftl_validate_unittest.cc",
-        "test/avb_aftl_verify_unittest.cc",
         "test/avb_atx_validate_unittest.cc",
         "test/avb_atx_slot_verify_unittest.cc",
+        "test/avb_crypto_ops_unittest.cc",
         "test/avb_slot_verify_unittest.cc",
         "test/avb_unittest_util.cc",
         "test/avb_util_unittest.cc",
@@ -413,6 +320,32 @@
     ],
 }
 
+cc_test_host {
+    name: "libavb_host_unittest",
+    defaults: [
+        "avb_crypto_ops_impl_boringssl",
+        "libavb_host_unittest_core",
+    ],
+    data: [
+        ":img2simg",
+        ":simg2img",
+        ":fec",
+    ],
+}
+
+cc_test_host {
+    name: "libavb_host_unittest_sha",
+    defaults: [
+        "avb_crypto_ops_impl_sha",
+        "libavb_host_unittest_core",
+    ],
+    data: [
+        ":img2simg",
+        ":simg2img",
+        ":fec",
+    ],
+}
+
 cc_library_host_static {
     name: "libavb_host_user_code_test",
     defaults: ["avb_defaults"],
@@ -432,6 +365,7 @@
     ],
     shared_libs: [
         "libbase",
+        "libcrypto",
         "libcutils",
     ],
     cflags: [
@@ -443,6 +377,7 @@
 cc_library_headers {
     name: "avb_headers",
     host_supported: true,
+    ramdisk_available: true,
     recovery_available: true,
     export_include_dirs: ["."],
     target: {
diff --git a/OWNERS b/OWNERS
index 114cf11..30abb1d 100644
--- a/OWNERS
+++ b/OWNERS
@@ -2,5 +2,4 @@
 samitolvanen@google.com
 zeuthen@google.com
 dkrahn@google.com
-jpm@google.com
 tweek@google.com
diff --git a/README.md b/README.md
index 4a2bb72..a293cb0 100644
--- a/README.md
+++ b/README.md
@@ -429,7 +429,8 @@
         [--calc_max_image_size]                                                    \
         [--do_not_use_ab]                                                          \
         [--no_hashtree]                                                            \
-        [--use_persistent_digest]
+        [--use_persistent_digest]                                                  \
+        [--check_at_most_once]
 
 Valid values for `HASH_ALG` above include `sha1`, `sha256`, and `blake2b-256`.
 
@@ -907,6 +908,13 @@
 }
 ```
 
+This logic should ideally be implemented outside of the HLOS. One
+possible implementation is to update rollback indices in the
+bootloader when booting into a successful slot. This means that
+when booting into a new OS not yet marked as successful, the
+rollback indices would not be updated. The first reboot after the
+slot succeeded would trigger an update of the rollback indices.
+
 For an HLOS where it's possible to roll back to a previous version,
 `stored_rollback_index[n]` should be set to the largest possible value
 allowing all bootable slots to boot. This approach is implemented in
@@ -1014,6 +1022,11 @@
    be used for **ONLY** diagnostics and debugging. It cannot be used
    unless verification errors are allowed.
 
+* `AVB_HASHTREE_ERROR_MODE_PANIC` means that the OS will **panic** without
+  the current slot being invalidated. Be careful using this mode as it may
+  introduce boot panic if the same hashtree verification error is hit on
+  every boot. This mode is available since: 1.7.0 (kernel 5.9)
+
 The value passed in `hashtree_error_mode` is essentially just passed on through
 to the HLOS through the the `androidboot.veritymode`,
 `androidboot.veritymode.managed`, and `androidboot.vbmeta.invalidate_on_error`
@@ -1026,6 +1039,7 @@
 | `AVB_HASHTREE_ERROR_MODE_EIO` | **eio** | (unset) | (unset) |
 | `AVB_HASHTREE_ERROR_MODE_MANAGED_RESTART_AND_EIO` | **eio** or **enforcing** | **yes** | (unset) |
 | `AVB_HASHTREE_ERROR_MODE_LOGGING` | **ignore_corruption** | (unset) | (unset) |
+| `AVB_HASHTREE_ERROR_MODE_PANIC` | **panicking** | (unset) | (unset) |
 
 The only exception to this table is that if the
 `AVB_VBMETA_IMAGE_FLAGS_HASHTREE_DISABLED` flag is set in the top-level vbmeta,
@@ -1033,6 +1047,26 @@
 `androidboot.veritymode.managed` and `androidboot.vbmeta.invalidate_on_error`
 are unset.
 
+The different values of `hashtree_error_mode` parameter in the `avb_slot_verify()`
+function can be categorized into three groups:
+
+* `AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE`, which needs `CONFIG_DM_VERITY_AVB`
+  in the kernel config for the kernel to invalidate the current slot and
+  restart. This is kept here for legacy Android Things devices and is not
+  recommended for other device form factors.
+
+* The bootloader handles the switch between `AVB_HASHTREE_ERROR_MODE_RESTART`
+  and `AVB_HASHTREE_ERROR_MODE_EIO`. This would need a persistent storage on the
+  device to store the vbmeta digest, so the bootloader can detect if a device
+  ever gets an update or not. Once the new OS is installed and if the device is
+  in **EIO** mode, the bootloader should switch back to **RESTART** mode.
+
+* `AVB_HASHTREE_ERROR_MODE_MANAGED_RESTART_AND_EIO`: `libavb` helps the
+  bootloader manage **EIO**/**RESTART** state transition. The bootloader needs
+  to implement the callbacks of `AvbOps->read_persistent_value()` and
+  `AvbOps->write_persistent_value()` for `libavb` to store the vbmeta digest to
+  detect whether a new OS is installed.
+
 ### Which mode should I use for my device?
 
 This depends entirely on the device, how the device is intended to be
@@ -1086,7 +1120,9 @@
 
 ### Version 1.2
 
-Version 1.2 adds support for the `rollback_index_location` field of the main vbmeta header.
+Version 1.2 adds support for the following:
+* `rollback_index_location` field of the main vbmeta header.
+* `check_at_most_once` parameter of dm-verity in a hashtree descriptor.
 
 ### Version 1.1
 
diff --git a/TEST_MAPPING b/TEST_MAPPING
new file mode 100644
index 0000000..b97c31b
--- /dev/null
+++ b/TEST_MAPPING
@@ -0,0 +1,10 @@
+{
+  "presubmit": [
+    {
+      "name": "libavb_host_unittest"
+    },
+    {
+      "name": "libavb_host_unittest_sha"
+    }
+  ]
+}
diff --git a/aftltool b/aftltool
deleted file mode 120000
index 11a8ff9..0000000
--- a/aftltool
+++ /dev/null
@@ -1 +0,0 @@
-aftltool.py
\ No newline at end of file
diff --git a/aftltool.py b/aftltool.py
deleted file mode 100755
index 613e83b..0000000
--- a/aftltool.py
+++ /dev/null
@@ -1,2254 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2020, The Android Open Source Project
-#
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation
-# files (the "Software"), to deal in the Software without
-# restriction, including without limitation the rights to use, copy,
-# modify, merge, publish, distribute, sublicense, and/or sell copies
-# of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-#
-"""Command-line tool for AFTL support for Android Verified Boot images."""
-
-import abc
-import argparse
-import enum
-import hashlib
-import io
-import multiprocessing
-import os
-import queue
-import struct
-import subprocess
-import sys
-import tempfile
-import time
-
-# This is to work around temporarily with the issue that python3 does not permit
-# relative imports anymore going forward. This adds the proto directory relative
-# to the location of aftltool to the sys.path.
-# TODO(b/154068467): Implement proper importing of generated *_pb2 modules.
-EXEC_PATH = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(os.path.join(EXEC_PATH, 'proto'))
-
-# pylint: disable=wrong-import-position,import-error
-import avbtool
-import api_pb2
-# pylint: enable=wrong-import-position,import-error
-
-
-class AftlError(Exception):
-  """Application-specific errors.
-
-  These errors represent issues for which a stack-trace should not be
-  presented.
-
-  Attributes:
-    message: Error message.
-  """
-
-  def __init__(self, message):
-    Exception.__init__(self, message)
-
-
-def rsa_key_read_pem_bytes(key_path):
-  """Reads the bytes out of the passed in PEM file.
-
-  Arguments:
-    key_path: A string containing the path to the PEM file.
-
-  Returns:
-    A bytearray containing the DER encoded bytes in the PEM file.
-
-  Raises:
-    AftlError: If openssl cannot decode the PEM file.
-  """
-  # Use openssl to decode the PEM file.
-  args = ['openssl', 'rsa', '-in', key_path, '-pubout', '-outform', 'DER']
-  p = subprocess.Popen(args,
-                       stdin=subprocess.PIPE,
-                       stdout=subprocess.PIPE,
-                       stderr=subprocess.PIPE)
-  (pout, perr) = p.communicate()
-  retcode = p.wait()
-  if retcode != 0:
-    raise AftlError('Error decoding: {}'.format(perr))
-  return pout
-
-
-def check_signature(log_root, log_root_sig,
-                    transparency_log_pub_key):
-  """Validates the signature provided by the transparency log.
-
-  Arguments:
-    log_root: The transparency log_root data structure.
-    log_root_sig: The signature of the transparency log_root data structure.
-    transparency_log_pub_key: The file path to the transparency log public key.
-
-  Returns:
-    True if the signature check passes, otherwise False.
-  """
-
-  logsig_tmp = tempfile.NamedTemporaryFile()
-  logsig_tmp.write(log_root_sig)
-  logsig_tmp.flush()
-  logroot_tmp = tempfile.NamedTemporaryFile()
-  logroot_tmp.write(log_root)
-  logroot_tmp.flush()
-
-  p = subprocess.Popen(['openssl', 'dgst', '-sha256', '-verify',
-                        transparency_log_pub_key,
-                        '-signature', logsig_tmp.name, logroot_tmp.name],
-                       stdin=subprocess.PIPE,
-                       stdout=subprocess.PIPE,
-                       stderr=subprocess.PIPE)
-
-  p.communicate()
-  retcode = p.wait()
-  if not retcode:
-    return True
-  return False
-
-
-# AFTL Merkle Tree Functionality
-def rfc6962_hash_leaf(leaf):
-  """RFC6962 hashing function for hashing leaves of a Merkle tree.
-
-  Arguments:
-    leaf: A bytearray containing the Merkle tree leaf to be hashed.
-
-  Returns:
-    A bytearray containing the RFC6962 SHA256 hash of the leaf.
-  """
-  hasher = hashlib.sha256()
-  # RFC6962 states a '0' byte should be prepended to the data.
-  # This is done in conjunction with the '1' byte for non-leaf
-  # nodes for 2nd preimage attack resistance.
-  hasher.update(b'\x00')
-  hasher.update(leaf)
-  return hasher.digest()
-
-
-def rfc6962_hash_children(l, r):
-  """Calculates the inner Merkle tree node hash of child nodes l and r.
-
-  Arguments:
-    l: A bytearray containing the left child node to be hashed.
-    r: A bytearray containing the right child node to be hashed.
-
-  Returns:
-    A bytearray containing the RFC6962 SHA256 hash of 1|l|r.
-  """
-  hasher = hashlib.sha256()
-  # RFC6962 states a '1' byte should be prepended to the concatenated data.
-  # This is done in conjunction with the '0' byte for leaf
-  # nodes for 2nd preimage attack resistance.
-  hasher.update(b'\x01')
-  hasher.update(l)
-  hasher.update(r)
-  return hasher.digest()
-
-
-def chain_border_right(seed, proof):
-  """Computes a subtree hash along the left-side tree border.
-
-  Arguments:
-    seed: A bytearray containing the starting hash.
-    proof: A list of bytearrays representing the hashes in the inclusion proof.
-
-  Returns:
-    A bytearray containing the left-side subtree hash.
-  """
-  for h in proof:
-    seed = rfc6962_hash_children(h, seed)
-  return seed
-
-
-def chain_inner(seed, proof, leaf_index):
-  """Computes a subtree hash on or below the tree's right border.
-
-  Arguments:
-    seed: A bytearray containing the starting hash.
-    proof: A list of bytearrays representing the hashes in the inclusion proof.
-    leaf_index: The current leaf index.
-
-  Returns:
-    A bytearray containing the subtree hash.
-  """
-  for i, h in enumerate(proof):
-    if leaf_index >> i & 1 == 0:
-      seed = rfc6962_hash_children(seed, h)
-    else:
-      seed = rfc6962_hash_children(h, seed)
-  return seed
-
-
-def root_from_icp(leaf_index, tree_size, proof, leaf_hash):
-  """Calculates the expected Merkle tree root hash.
-
-  Arguments:
-    leaf_index: The current leaf index.
-    tree_size: The number of nodes in the Merkle tree.
-    proof: A list of bytearrays containing the inclusion proof.
-    leaf_hash: A bytearray containing the initial leaf hash.
-
-  Returns:
-    A bytearray containing the calculated Merkle tree root hash.
-
-  Raises:
-    AftlError: If invalid parameters are passed in.
-  """
-  if leaf_index < 0:
-    raise AftlError('Invalid leaf_index value: {}'.format(leaf_index))
-  if tree_size < 0:
-    raise AftlError('Invalid tree_size value: {}'.format(tree_size))
-  if leaf_index >= tree_size:
-    err_str = 'leaf_index cannot be equal or larger than tree_size: {}, {}'
-    raise AftlError(err_str.format(leaf_index, tree_size))
-  if proof is None:
-    raise AftlError('Inclusion proof not provided.')
-  if leaf_hash is None:
-    raise AftlError('No leaf hash provided.')
-  # Calculate the point to split the proof into two parts.
-  # The split is where the paths to leaves diverge.
-  inner = (leaf_index ^ (tree_size - 1)).bit_length()
-  result = chain_inner(leaf_hash, proof[:inner], leaf_index)
-  result = chain_border_right(result, proof[inner:])
-  return result
-
-
-class AftlImageHeader(object):
-  """A class for representing the AFTL image header.
-
-  Attributes:
-    magic: Magic for identifying the AftlImage.
-    required_icp_version_major: The major version of AVB that wrote the entry.
-    required_icp_version_minor: The minor version of AVB that wrote the entry.
-    aftl_image_size: Total size of the AftlImage.
-    icp_count: Number of inclusion proofs represented in this structure.
-  """
-
-  SIZE = 18  # The size of the structure, in bytes
-  MAGIC = b'AFTL'
-  FORMAT_STRING = ('!4s2L'  # magic, major & minor version.
-                   'L'      # AFTL image size.
-                   'H')     # number of inclusion proof entries.
-
-  def __init__(self, data=None):
-    """Initializes a new AftlImageHeader object.
-
-    Arguments:
-      data: If not None, must be a bytearray of size |SIZE|.
-
-    Raises:
-      AftlError: If invalid structure for AftlImageHeader.
-    """
-    assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
-
-    if data:
-      (self.magic, self.required_icp_version_major,
-       self.required_icp_version_minor, self.aftl_image_size,
-       self.icp_count) = struct.unpack(self.FORMAT_STRING, data)
-    else:
-      self.magic = self.MAGIC
-      self.required_icp_version_major = avbtool.AVB_VERSION_MAJOR
-      self.required_icp_version_minor = avbtool.AVB_VERSION_MINOR
-      self.aftl_image_size = self.SIZE
-      self.icp_count = 0
-    if not self.is_valid():
-      raise AftlError('Invalid structure for AftlImageHeader.')
-
-  def encode(self):
-    """Serializes the AftlImageHeader |SIZE| to bytes.
-
-    Returns:
-      The encoded AftlImageHeader as bytes.
-
-    Raises:
-      AftlError: If invalid structure for AftlImageHeader.
-    """
-    if not self.is_valid():
-      raise AftlError('Invalid structure for AftlImageHeader')
-    return struct.pack(self.FORMAT_STRING, self.magic,
-                       self.required_icp_version_major,
-                       self.required_icp_version_minor,
-                       self.aftl_image_size,
-                       self.icp_count)
-
-  def is_valid(self):
-    """Ensures that values in the AftlImageHeader are sane.
-
-    Returns:
-      True if the values in the AftlImageHeader are sane, False otherwise.
-    """
-    if self.magic != AftlImageHeader.MAGIC:
-      sys.stderr.write(
-          'AftlImageHeader: magic value mismatch: {}\n'
-          .format(repr(self.magic)))
-      return False
-
-    if self.required_icp_version_major > avbtool.AVB_VERSION_MAJOR:
-      sys.stderr.write('AftlImageHeader: major version mismatch: {}\n'.format(
-          self.required_icp_version_major))
-      return False
-
-    if self.required_icp_version_minor > avbtool.AVB_VERSION_MINOR:
-      sys.stderr.write('AftlImageHeader: minor version mismatch: {}\n'.format(
-          self.required_icp_version_minor))
-      return False
-
-    if self.aftl_image_size < self.SIZE:
-      sys.stderr.write('AftlImageHeader: Invalid AFTL image size: {}\n'.format(
-          self.aftl_image_size))
-      return False
-
-    if self.icp_count < 0 or self.icp_count > 65535:
-      sys.stderr.write(
-          'AftlImageHeader: ICP entry count out of range: {}\n'.format(
-              self.icp_count))
-      return False
-    return True
-
-  def print_desc(self, o):
-    """Print the AftlImageHeader.
-
-    Arguments:
-      o: The object to write the output to.
-    """
-    o.write('  AFTL image header:\n')
-    i = ' ' * 4
-    fmt = '{}{:25}{}\n'
-    o.write(fmt.format(i, 'Major version:', self.required_icp_version_major))
-    o.write(fmt.format(i, 'Minor version:', self.required_icp_version_minor))
-    o.write(fmt.format(i, 'Image size:', self.aftl_image_size))
-    o.write(fmt.format(i, 'ICP entries count:', self.icp_count))
-
-
-class AftlIcpEntry(object):
-  """A class for the transparency log inclusion proof entries.
-
-  The data that represents each of the components of the ICP entry are stored
-  immediately following the ICP entry header. The format is log_url,
-  SignedLogRoot, and inclusion proof hashes.
-
-  Attributes:
-    log_url_size: Length of the string representing the transparency log URL.
-    leaf_index: Leaf index in the transparency log representing this entry.
-    log_root_descriptor_size: Size of the transparency log's SignedLogRoot.
-    annotation_leaf_size: Size of the SignedVBMetaPrimaryAnnotationLeaf passed
-        to the log.
-    log_root_sig_size: Size in bytes of the log_root_signature
-    proof_hash_count: Number of hashes comprising the inclusion proof.
-    inc_proof_size: The total size of the inclusion proof, in bytes.
-    log_url: The URL for the transparency log that generated this inclusion
-        proof.
-    log_root_descriptor: The data comprising the signed tree head structure.
-    annotation_leaf: The data comprising the SignedVBMetaPrimaryAnnotationLeaf
-        leaf.
-    log_root_signature: The data comprising the log root signature.
-    proofs: The hashes comprising the inclusion proof.
-
-  """
-  SIZE = 27  # The size of the structure, in bytes
-  FORMAT_STRING = ('!L'   # transparency log server url size
-                   'Q'    # leaf index
-                   'L'    # log root descriptor size
-                   'L'    # firmware info leaf size
-                   'H'    # log root signature size
-                   'B'    # number of hashes in the inclusion proof
-                   'L')   # size of the inclusion proof in bytes
-  # This header is followed by the log_url, log_root_descriptor,
-  # annotation leaf, log root signature, and the proofs elements.
-
-  def __init__(self, data=None):
-    """Initializes a new ICP entry object.
-
-    Arguments:
-      data: If not None, must be a bytearray of size >= |SIZE|.
-
-    Raises:
-      AftlError: If data does not represent a well-formed AftlIcpEntry.
-    """
-    # Assert the header structure is of a sane size.
-    assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
-
-    if data:
-      # Deserialize the header from the data.
-      (self._log_url_size_expected,
-       self.leaf_index,
-       self._log_root_descriptor_size_expected,
-       self._annotation_leaf_size_expected,
-       self._log_root_sig_size_expected,
-       self._proof_hash_count_expected,
-       self._inc_proof_size_expected) = struct.unpack(self.FORMAT_STRING,
-                                                      data[0:self.SIZE])
-
-      # Deserialize ICP entry components from the data.
-      expected_format_string = '{}s{}s{}s{}s{}s'.format(
-          self._log_url_size_expected,
-          self._log_root_descriptor_size_expected,
-          self._annotation_leaf_size_expected,
-          self._log_root_sig_size_expected,
-          self._inc_proof_size_expected)
-
-      (log_url, log_root_descriptor_bytes, annotation_leaf_bytes,
-       self.log_root_signature, proof_bytes) = struct.unpack(
-           expected_format_string, data[self.SIZE:self.get_expected_size()])
-
-      self.log_url = log_url.decode('ascii')
-      self.log_root_descriptor = TrillianLogRootDescriptor(
-          log_root_descriptor_bytes)
-
-      self.annotation_leaf = SignedVBMetaPrimaryAnnotationLeaf.parse(
-          annotation_leaf_bytes)
-
-      self.proofs = []
-      if self._proof_hash_count_expected > 0:
-        proof_idx = 0
-        hash_size = (self._inc_proof_size_expected
-                     // self._proof_hash_count_expected)
-        for _ in range(self._proof_hash_count_expected):
-          proof = proof_bytes[proof_idx:(proof_idx+hash_size)]
-          self.proofs.append(proof)
-          proof_idx += hash_size
-    else:
-      self.leaf_index = 0
-      self.log_url = ''
-      self.log_root_descriptor = TrillianLogRootDescriptor()
-      self.annotation_leaf = SignedVBMetaPrimaryAnnotationLeaf()
-      self.log_root_signature = b''
-      self.proofs = []
-    if not self.is_valid():
-      raise AftlError('Invalid structure for AftlIcpEntry')
-
-  @property
-  def log_url_size(self):
-    """Gets the size of the log_url attribute."""
-    if hasattr(self, 'log_url'):
-      return len(self.log_url)
-    return self._log_url_size_expected
-
-  @property
-  def log_root_descriptor_size(self):
-    """Gets the size of the log_root_descriptor attribute."""
-    if hasattr(self, 'log_root_descriptor'):
-      return self.log_root_descriptor.get_expected_size()
-    return self._log_root_descriptor_size_expected
-
-  @property
-  def annotation_leaf_size(self):
-    """Gets the size of the annotation_leaf attribute."""
-    if hasattr(self, 'annotation_leaf'):
-      return self.annotation_leaf.get_expected_size()
-    return self._annotation_leaf_size_expected
-
-  @property
-  def log_root_sig_size(self):
-    """Gets the size of the log_root signature."""
-    if hasattr(self, 'log_root_signature'):
-      return len(self.log_root_signature)
-    return self._log_root_sig_size_expected
-
-  @property
-  def proof_hash_count(self):
-    """Gets the number of proof hashes."""
-    if hasattr(self, 'proofs'):
-      return len(self.proofs)
-    return self._proof_hash_count_expected
-
-  @property
-  def inc_proof_size(self):
-    """Gets the total size of the proof hashes in bytes."""
-    if hasattr(self, 'proofs'):
-      result = 0
-      for proof in self.proofs:
-        result += len(proof)
-      return result
-    return self._inc_proof_size_expected
-
-  def verify_icp(self, transparency_log_pub_key):
-    """Verifies the contained inclusion proof given the public log key.
-
-    Arguments:
-      transparency_log_pub_key: The path to the trusted public key for the log.
-
-    Returns:
-      True if the calculated signature matches AftlIcpEntry's. False otherwise.
-    """
-    if not transparency_log_pub_key:
-      return False
-
-    leaf_hash = rfc6962_hash_leaf(self.annotation_leaf.encode())
-    calc_root = root_from_icp(self.leaf_index,
-                              self.log_root_descriptor.tree_size,
-                              self.proofs,
-                              leaf_hash)
-    if ((calc_root == self.log_root_descriptor.root_hash) and
-        check_signature(
-            self.log_root_descriptor.encode(),
-            self.log_root_signature,
-            transparency_log_pub_key)):
-      return True
-    return False
-
-  def verify_vbmeta_image(self, vbmeta_image, transparency_log_pub_key):
-    """Verify the inclusion proof for the given VBMeta image.
-
-    Arguments:
-      vbmeta_image: A bytearray with the VBMeta image.
-      transparency_log_pub_key: File path to the PEM file containing the trusted
-        transparency log public key.
-
-    Returns:
-      True if the inclusion proof validates and the vbmeta hash of the given
-      VBMeta image matches the one in the annotation leaf; otherwise False.
-    """
-    if not vbmeta_image:
-      return False
-
-    # Calculate the hash of the vbmeta image.
-    vbmeta_hash = hashlib.sha256(vbmeta_image).digest()
-
-    # Validates the inclusion proof and then compare the calculated vbmeta_hash
-    # against the one in the inclusion proof.
-    return (self.verify_icp(transparency_log_pub_key)
-            and self.annotation_leaf.annotation.vbmeta_hash == vbmeta_hash)
-
-  def encode(self):
-    """Serializes the header |SIZE| and data to bytes.
-
-    Returns:
-      bytes with the encoded header.
-
-    Raises:
-      AftlError: If invalid entry structure.
-    """
-    proof_bytes = bytearray()
-    if not self.is_valid():
-      raise AftlError('Invalid AftlIcpEntry structure')
-
-    expected_format_string = '{}{}s{}s{}s{}s{}s'.format(
-        self.FORMAT_STRING,
-        self.log_url_size,
-        self.log_root_descriptor_size,
-        self.annotation_leaf_size,
-        self.log_root_sig_size,
-        self.inc_proof_size)
-
-    for proof in self.proofs:
-      proof_bytes.extend(proof)
-
-    return struct.pack(expected_format_string,
-                       self.log_url_size, self.leaf_index,
-                       self.log_root_descriptor_size, self.annotation_leaf_size,
-                       self.log_root_sig_size, self.proof_hash_count,
-                       self.inc_proof_size, self.log_url.encode('ascii'),
-                       self.log_root_descriptor.encode(),
-                       self.annotation_leaf.encode(),
-                       self.log_root_signature,
-                       proof_bytes)
-
-  def translate_response(self, log_url, avbm_response):
-    """Translates an AddVBMetaResponse object to an AftlIcpEntry.
-
-    Arguments:
-      log_url: String representing the transparency log URL.
-      avbm_response: The AddVBMetaResponse object to translate.
-    """
-    self.log_url = log_url
-
-    # Deserializes from AddVBMetaResponse.
-    proof = avbm_response.annotation_proof
-    self.leaf_index = proof.proof.leaf_index
-    self.log_root_descriptor = TrillianLogRootDescriptor(proof.sth.log_root)
-    self.annotation_leaf = SignedVBMetaPrimaryAnnotationLeaf.parse(
-        avbm_response.annotation_leaf)
-    self.log_root_signature = proof.sth.log_root_signature
-    self.proofs = proof.proof.hashes
-
-  def get_expected_size(self):
-    """Gets the expected size of the full entry out of the header.
-
-    Returns:
-      The expected size of the AftlIcpEntry from the header.
-    """
-    return (self.SIZE + self.log_url_size + self.log_root_descriptor_size +
-            self.annotation_leaf_size + self.log_root_sig_size +
-            self.inc_proof_size)
-
-  def is_valid(self):
-    """Ensures that values in an AftlIcpEntry structure are sane.
-
-    Returns:
-      True if the values in the AftlIcpEntry are sane, False otherwise.
-    """
-    if self.leaf_index < 0:
-      sys.stderr.write('ICP entry: leaf index out of range: '
-                       '{}.\n'.format(self.leaf_index))
-      return False
-
-    if (not self.log_root_descriptor or
-        not isinstance(self.log_root_descriptor, TrillianLogRootDescriptor) or
-        not self.log_root_descriptor.is_valid()):
-      sys.stderr.write('ICP entry: invalid TrillianLogRootDescriptor.\n')
-      return False
-
-    if (not self.annotation_leaf or
-        not isinstance(self.annotation_leaf, Leaf)):
-      sys.stderr.write('ICP entry: invalid Leaf.\n')
-      return False
-    return True
-
-  def print_desc(self, o):
-    """Print the ICP entry.
-
-    Arguments:
-      o: The object to write the output to.
-    """
-    i = ' ' * 4
-    fmt = '{}{:25}{}\n'
-    o.write(fmt.format(i, 'Transparency Log:', self.log_url))
-    o.write(fmt.format(i, 'Leaf index:', self.leaf_index))
-    o.write('    ICP hashes:              ')
-    for i, proof_hash in enumerate(self.proofs):
-      if i != 0:
-        o.write(' ' * 29)
-      o.write('{}\n'.format(proof_hash.hex()))
-    self.log_root_descriptor.print_desc(o)
-    self.annotation_leaf.print_desc(o)
-
-
-class TrillianLogRootDescriptor(object):
-  """A class representing the Trillian log_root descriptor.
-
-  Taken from Trillian definitions:
-  https://github.com/google/trillian/blob/master/trillian.proto#L255
-
-  Attributes:
-    version: The version number of the descriptor. Currently only version=1 is
-        supported.
-    tree_size: The size of the tree.
-    root_hash_size: The size of the root hash in bytes. Valid values are between
-        0 and 128.
-    root_hash: The root hash as bytearray().
-    timestamp: The timestamp in nanoseconds.
-    revision: The revision number as long.
-    metadata_size: The size of the metadata in bytes. Valid values are between
-        0 and 65535.
-    metadata: The metadata as bytearray().
-  """
-  FORMAT_STRING_PART_1 = ('!H'  # version
-                          'Q'   # tree_size
-                          'B'   # root_hash_size
-                         )
-
-  FORMAT_STRING_PART_2 = ('!Q'  # timestamp
-                          'Q'   # revision
-                          'H'   # metadata_size
-                         )
-
-  def __init__(self, data=None):
-    """Initializes a new TrillianLogRoot descriptor."""
-    if data:
-      # Parses first part of the log_root descriptor.
-      data_length = struct.calcsize(self.FORMAT_STRING_PART_1)
-      (self.version, self.tree_size, self.root_hash_size) = struct.unpack(
-          self.FORMAT_STRING_PART_1, data[0:data_length])
-      data = data[data_length:]
-
-      # Parses the root_hash bytes if the size indicates existance.
-      if self.root_hash_size > 0:
-        self.root_hash = data[0:self.root_hash_size]
-        data = data[self.root_hash_size:]
-      else:
-        self.root_hash = b''
-
-      # Parses second part of the log_root descriptor.
-      data_length = struct.calcsize(self.FORMAT_STRING_PART_2)
-      (self.timestamp, self.revision, self.metadata_size) = struct.unpack(
-          self.FORMAT_STRING_PART_2, data[0:data_length])
-      data = data[data_length:]
-
-      # Parses the metadata if the size indicates existance.
-      if self.metadata_size > 0:
-        self.metadata = data[0:self.metadata_size]
-      else:
-        self.metadata = b''
-    else:
-      self.version = 1
-      self.tree_size = 0
-      self.root_hash_size = 0
-      self.root_hash = b''
-      self.timestamp = 0
-      self.revision = 0
-      self.metadata_size = 0
-      self.metadata = b''
-
-    if not self.is_valid():
-      raise AftlError('Invalid structure for TrillianLogRootDescriptor.')
-
-  def get_expected_size(self):
-    """Calculates the expected size of the TrillianLogRootDescriptor.
-
-    Returns:
-      The expected size of the TrillianLogRootDescriptor.
-    """
-    return (struct.calcsize(self.FORMAT_STRING_PART_1) + self.root_hash_size +
-            struct.calcsize(self.FORMAT_STRING_PART_2) + self.metadata_size)
-
-  def encode(self):
-    """Serializes the TrillianLogDescriptor to a bytearray().
-
-    Returns:
-      A bytearray() with the encoded header.
-
-    Raises:
-      AftlError: If invalid entry structure.
-    """
-    if not self.is_valid():
-      raise AftlError('Invalid structure for TrillianLogRootDescriptor.')
-
-    expected_format_string = '{}{}s{}{}s'.format(
-        self.FORMAT_STRING_PART_1,
-        self.root_hash_size,
-        self.FORMAT_STRING_PART_2[1:],
-        self.metadata_size)
-
-    return struct.pack(expected_format_string,
-                       self.version, self.tree_size, self.root_hash_size,
-                       self.root_hash, self.timestamp, self.revision,
-                       self.metadata_size, self.metadata)
-
-  def is_valid(self):
-    """Ensures that values in the descritor are sane.
-
-    Returns:
-      True if the values are sane; otherwise False.
-    """
-    cls = self.__class__.__name__
-    if self.version != 1:
-      sys.stderr.write('{}: Bad version value {}.\n'.format(cls, self.version))
-      return False
-    if self.tree_size < 0:
-      sys.stderr.write('{}: Bad tree_size value {}.\n'.format(cls,
-                                                              self.tree_size))
-      return False
-    if self.root_hash_size < 0 or self.root_hash_size > 128:
-      sys.stderr.write('{}: Bad root_hash_size value {}.\n'.format(
-          cls, self.root_hash_size))
-      return False
-    if len(self.root_hash) != self.root_hash_size:
-      sys.stderr.write('{}: root_hash_size {} does not match with length of '
-                       'root_hash {}.\n'.format(cls, self.root_hash_size,
-                                                len(self.root_hash)))
-      return False
-    if self.timestamp < 0:
-      sys.stderr.write('{}: Bad timestamp value {}.\n'.format(cls,
-                                                              self.timestamp))
-      return False
-    if self.revision < 0:
-      sys.stderr.write('{}: Bad revision value {}.\n'.format(cls,
-                                                             self.revision))
-      return False
-    if self.metadata_size < 0 or self.metadata_size > 65535:
-      sys.stderr.write('{}: Bad metadatasize value {}.\n'.format(
-          cls, self.metadata_size))
-      return False
-    if len(self.metadata) != self.metadata_size:
-      sys.stderr.write('{}: metadata_size {} does not match with length of'
-                       'metadata {}.\n'.format(cls, self.metadata_size,
-                                               len(self.metadata)))
-      return False
-    return True
-
-  def print_desc(self, o):
-    """Print the TrillianLogRootDescriptor.
-
-    Arguments:
-      o: The object to write the output to.
-    """
-    o.write('    Log Root Descriptor:\n')
-    i = ' ' * 6
-    fmt = '{}{:23}{}\n'
-    o.write(fmt.format(i, 'Version:', self.version))
-    o.write(fmt.format(i, 'Tree size:', self.tree_size))
-    o.write(fmt.format(i, 'Root hash size:', self.root_hash_size))
-    if self.root_hash_size > 0:
-      o.write(fmt.format(i, 'Root hash:', self.root_hash.hex()))
-      o.write(fmt.format(i, 'Timestamp (ns):', self.timestamp))
-    o.write(fmt.format(i, 'Revision:', self.revision))
-    o.write(fmt.format(i, 'Metadata size:', self.metadata_size))
-    if self.metadata_size > 0:
-      o.write(fmt.format(i, 'Metadata:', self.metadata.hex()))
-
-
-def tls_decode_bytes(byte_size, stream):
-  """Decodes a variable-length vector.
-
-  In the TLS presentation language, a variable-length vector is a pair
-  (size, value). |size| describes the size of the |value| to read
-  in bytes. All values are encoded in big-endian.
-  See https://tools.ietf.org/html/rfc8446#section-3 for more details.
-
-  Arguments:
-      byte_size: A format character as described in the struct module
-          which describes the expected length of the size. For
-          instance, "B", "H", "L" or "Q".
-      stream: a BytesIO which contains the value to decode.
-
-  Returns:
-    A bytes containing the value decoded.
-
-  Raises:
-    AftlError: If |byte_size| is not a known format character, or if not
-    enough data is available to decode the size or the value.
-  """
-  byte_size_format = "!" + byte_size
-  try:
-    byte_size_length = struct.calcsize(byte_size_format)
-  except struct.error:
-    raise AftlError("Invalid byte_size character: {}. It must be a "
-                    "format supported by struct.".format(byte_size))
-  try:
-    value_size = struct.unpack(byte_size_format,
-                               stream.read(byte_size_length))[0]
-  except struct.error:
-    raise AftlError("Not enough data to read size: {}".format(byte_size))
-  value = stream.read(value_size)
-  if value_size != len(value):
-    raise AftlError("Not enough data to read value: "
-                    "{} != {}".format(value_size, len(value)))
-  return value
-
-def tls_encode_bytes(byte_size, value, stream):
-  """Encodes a variable-length vector.
-
-  In the TLS presentation language, a variable-length vector is a pair
-  (size, value). |size| describes the size of the |value| to read
-  in bytes. All values are encoded in big-endian.
-  See https://tools.ietf.org/html/rfc8446#section-3 for more details.
-
-  Arguments:
-      byte_size: A format character as described in the struct module
-          which describes the expected length of the size. For
-          instance, "B", "H", "L" or "Q".
-      value: the value to encode. The length of |value| must be
-          representable with |byte_size|.
-      stream: a BytesIO to which the value is encoded to.
-
-  Raises:
-    AftlError: If |byte_size| is not a known format character, or if
-    |value|'s length cannot be represent with |byte_size|.
-  """
-  byte_size_format = "!" + byte_size
-  try:
-    stream.write(struct.pack(byte_size_format, len(value)))
-  except struct.error:
-    # Whether byte_size is invalid or not large enough to represent value,
-    # struct returns an struct.error exception. Instead of matching on the
-    # exception message, capture both cases in a generic message.
-    raise AftlError("Invalid byte_size to store {} bytes".format(len(value)))
-  stream.write(value)
-
-class HashAlgorithm(enum.Enum):
-  SHA256 = 0
-
-class SignatureAlgorithm(enum.Enum):
-  RSA = 0
-  ECDSA = 1
-
-class Signature(object):
-  """Represents a signature of some data.
-
-  It is usually made using a manufacturer key and used to sign part of a leaf
-  that belongs to the transparency log. The encoding of this structure must
-  match the server expectation.
-
-  Attributes:
-    hash_algorithm: the HashAlgorithm used for the signature.
-    signature_algorithm: the SignatureAlgorithm used.
-    signature: the raw signature in bytes.
-  """
-  FORMAT_STRING = ('!B'    # Hash algorithm
-                   'B'     # Signing algorithm
-                  )
-  # Followed by the raw signature, encoded as a TLS variable-length vector
-  # which size is represented using 2 bytes.
-
-  def __init__(self, hash_algorithm=HashAlgorithm.SHA256,
-               signature_algorithm=SignatureAlgorithm.RSA, signature=b''):
-    self.hash_algorithm = hash_algorithm
-    self.signature_algorithm = signature_algorithm
-    self.signature = signature
-
-  @classmethod
-  def parse(cls, stream):
-    """Parses a TLS-encoded structure and returns a new Signature.
-
-    Arguments:
-      stream: a BytesIO to read the signature from.
-
-    Returns:
-      A new Signature object.
-
-    Raises:
-      AftlError: If the hash algorithm or signature algorithm value is
-        unknown; or if the decoding failed.
-    """
-    data_length = struct.calcsize(cls.FORMAT_STRING)
-    (hash_algorithm, signature_algorithm) = struct.unpack(
-        cls.FORMAT_STRING, stream.read(data_length))
-    try:
-      hash_algorithm = HashAlgorithm(hash_algorithm)
-    except ValueError:
-      raise AftlError('unknown hash algorithm: {}'.format(hash_algorithm))
-    try:
-      signature_algorithm = SignatureAlgorithm(signature_algorithm)
-    except ValueError:
-      raise AftlError('unknown signature algorithm: {}'.format(
-          signature_algorithm))
-    signature = tls_decode_bytes('H', stream)
-    return Signature(hash_algorithm, signature_algorithm, signature)
-
-  def get_expected_size(self):
-    """Returns the size of the encoded Signature."""
-    return struct.calcsize(self.FORMAT_STRING) + \
-        struct.calcsize('H') + len(self.signature)
-
-  def encode(self, stream):
-    """Encodes the Signature.
-
-    Arguments:
-      stream: a BytesIO to which the signature is written.
-    """
-    stream.write(struct.pack(self.FORMAT_STRING, self.hash_algorithm.value,
-                             self.signature_algorithm.value))
-    tls_encode_bytes('H', self.signature, stream)
-
-class VBMetaPrimaryAnnotation(object):
-  """An annotation that contains metadata about a VBMeta image.
-
-  Attributes:
-    vbmeta_hash: the SHA256 of the VBMeta it references.
-    version_incremental: the version incremental of the build, as string.
-    manufacturer_key_hash: the hash of the manufacturer key that will
-        sign this annotation.
-    description: a free-form field.
-  """
-
-  def __init__(self, vbmeta_hash=b'', version_incremental='',
-               manufacturer_key_hash=b'', description=''):
-    """Default constructor."""
-    self.vbmeta_hash = vbmeta_hash
-    self.version_incremental = version_incremental
-    self.manufacturer_key_hash = manufacturer_key_hash
-    self.description = description
-
-  @classmethod
-  def parse(cls, stream):
-    """Parses a VBMetaPrimaryAnnotation from data.
-
-    Arguments:
-      stream: an io.BytesIO to decode the annotation from.
-
-    Returns:
-      A new VBMetaPrimaryAnnotation.
-
-    Raises:
-      AftlError: If an error occured while parsing the annotation.
-    """
-    vbmeta_hash = tls_decode_bytes("B", stream)
-    version_incremental = tls_decode_bytes("B", stream)
-    try:
-      version_incremental = version_incremental.decode("ascii")
-    except UnicodeError:
-      raise AftlError('Failed to convert version incremental to an ASCII'
-                      'string')
-    manufacturer_key_hash = tls_decode_bytes("B", stream)
-    description = tls_decode_bytes("H", stream)
-    try:
-      description = description.decode("utf-8")
-    except UnicodeError:
-      raise AftlError('Failed to convert description to an UTF-8 string')
-    return cls(vbmeta_hash, version_incremental, manufacturer_key_hash,
-               description)
-
-  def sign(self, manufacturer_key_path, signing_helper=None,
-           signing_helper_with_files=None):
-    """Signs the annotation.
-
-    Arguments:
-      manufacturer_key_path: Path to key used to sign messages sent to the
-        transparency log servers.
-      signing_helper: Program which signs a hash and returns a signature.
-      signing_helper_with_files: Same as signing_helper but uses files instead.
-
-    Returns:
-      A new SignedVBMetaPrimaryAnnotation.
-
-    Raises:
-      AftlError: If an error occured while signing the annotation.
-    """
-    # AFTL supports SHA256_RSA4096 for now, more will be available.
-    algorithm_name = 'SHA256_RSA4096'
-    encoded_leaf = io.BytesIO()
-    self.encode(encoded_leaf)
-    try:
-      rsa_key = avbtool.RSAPublicKey(manufacturer_key_path)
-      raw_signature = rsa_key.sign(algorithm_name, encoded_leaf.getvalue(),
-                                   signing_helper, signing_helper_with_files)
-    except avbtool.AvbError as e:
-      raise AftlError('Failed to sign VBMetaPrimaryAnnotation with '
-                      '--manufacturer_key: {}'.format(e))
-    signature = Signature(hash_algorithm=HashAlgorithm.SHA256,
-                          signature_algorithm=SignatureAlgorithm.RSA,
-                          signature=raw_signature)
-    return SignedVBMetaPrimaryAnnotation(signature=signature, annotation=self)
-
-  def encode(self, stream):
-    """Encodes the VBMetaPrimaryAnnotation.
-
-    Arguments:
-      stream: a BytesIO to which the signature is written.
-
-    Raises:
-      AftlError: If the encoding failed.
-    """
-    tls_encode_bytes("B", self.vbmeta_hash, stream)
-    try:
-      tls_encode_bytes("B", self.version_incremental.encode("ascii"), stream)
-    except UnicodeError:
-      raise AftlError('Unable to encode version incremental to ASCII')
-    tls_encode_bytes("B", self.manufacturer_key_hash, stream)
-    try:
-      tls_encode_bytes("H", self.description.encode("utf-8"), stream)
-    except UnicodeError:
-      raise AftlError('Unable to encode description to UTF-8')
-
-  def get_expected_size(self):
-    """Returns the size of the encoded annotation."""
-    b = io.BytesIO()
-    self.encode(b)
-    return len(b.getvalue())
-
-  def print_desc(self, o):
-    """Print the VBMetaPrimaryAnnotation.
-
-    Arguments:
-      o: The object to write the output to.
-    """
-    o.write('      VBMeta Primary Annotation:\n')
-    i = ' ' * 8
-    fmt = '{}{:23}{}\n'
-    if self.vbmeta_hash:
-      o.write(fmt.format(i, 'VBMeta hash:', self.vbmeta_hash.hex()))
-    if self.version_incremental:
-      o.write(fmt.format(i, 'Version incremental:', self.version_incremental))
-    if self.manufacturer_key_hash:
-      o.write(fmt.format(i, 'Manufacturer key hash:',
-                         self.manufacturer_key_hash.hex()))
-    if self.description:
-      o.write(fmt.format(i, 'Description:', self.description))
-
-
-class SignedVBMetaPrimaryAnnotation(object):
-  """A Signed VBMetaPrimaryAnnotation.
-
-  Attributes:
-    signature: a Signature.
-    annotation: a VBMetaPrimaryAnnotation.
-  """
-
-  def __init__(self, signature=None, annotation=None):
-    """Default constructor."""
-    if not signature:
-      signature = Signature()
-    self.signature = signature
-    if not annotation:
-      annotation = VBMetaPrimaryAnnotation()
-    self.annotation = annotation
-
-  @classmethod
-  def parse(cls, stream):
-    """Parses a signed annotation."""
-    signature = Signature.parse(stream)
-    annotation = VBMetaPrimaryAnnotation.parse(stream)
-    return cls(signature, annotation)
-
-  def get_expected_size(self):
-    """Returns the size of the encoded signed annotation."""
-    return self.signature.get_expected_size() + \
-             self.annotation.get_expected_size()
-
-  def encode(self, stream):
-    """Encodes the SignedVBMetaPrimaryAnnotation.
-
-    Arguments:
-      stream: a BytesIO to which the object is written.
-
-    Raises:
-      AftlError: If the encoding failed.
-    """
-    self.signature.encode(stream)
-    self.annotation.encode(stream)
-
-  def print_desc(self, o):
-    """Prints the annotation.
-
-    Arguments:
-      o: The object to write the output to.
-    """
-    self.annotation.print_desc(o)
-
-class Leaf(abc.ABC):
-  """An abstract class to represent the leaves in the transparency log."""
-  FORMAT_STRING = ('!B'   # Version
-                   'Q'    # Timestamp
-                   'B'    # LeafType
-                  )
-
-  class LeafType(enum.Enum):
-    VBMetaType = 0
-    SignedVBMetaPrimaryAnnotationType = 1
-
-  def __init__(self, version=1, timestamp=0, leaf_type=LeafType.VBMetaType):
-    """Build a new leaf."""
-    self.version = version
-    self.timestamp = timestamp
-    self.leaf_type = leaf_type
-
-  @classmethod
-  def _parse_header(cls, stream):
-    """Parses the header of a leaf.
-
-    This is called with the parse method of the subclasses.
-
-    Arguments:
-      stream: a BytesIO to read the header from.
-
-    Returns:
-      A tuple (version, timestamp, leaf_type).
-
-    Raises:
-      AftlError: If the header cannot be decoded; or if the leaf type is
-          unknown.
-    """
-    data_length = struct.calcsize(cls.FORMAT_STRING)
-    try:
-      (version, timestamp, leaf_type) = struct.unpack(
-          cls.FORMAT_STRING, stream.read(data_length))
-    except struct.error:
-      raise AftlError("Not enough data to parse leaf header")
-    try:
-      leaf_type = cls.LeafType(leaf_type)
-    except ValueError:
-      raise AftlError("Unknown leaf type: {}".format(leaf_type))
-    return version, timestamp, leaf_type
-
-  @classmethod
-  @abc.abstractmethod
-  def parse(cls, data):
-    """Parses a leaf and returned a new object.
-
-    This abstract method must be implemented by the subclass. It may use
-    _parse_header to parse the common fields.
-
-    Arguments:
-      data: a bytes-like object.
-
-    Returns:
-      An object of the type of the particular subclass.
-
-    Raises:
-      AftlError: If the leaf type is incorrect; or if the decoding failed.
-    """
-
-  @abc.abstractmethod
-  def encode(self):
-    """Encodes a leaf.
-
-    This abstract method must be implemented by the subclass. It may use
-    _encode_header to encode the common fields.
-
-    Returns:
-      A bytes with the encoded leaf.
-
-    Raises:
-      AftlError: If the encoding failed.
-    """
-
-  def _get_expected_header_size(self):
-    """Returns the size of the leaf header."""
-    return struct.calcsize(self.FORMAT_STRING)
-
-  def _encode_header(self, stream):
-    """Encodes the header of the leaf.
-
-    This method is called by the encode method in the subclass.
-
-    Arguments:
-      stream: a BytesIO to which the object is written.
-
-    Raises:
-      AftlError: If the encoding failed.
-    """
-    try:
-      stream.write(struct.pack(self.FORMAT_STRING, self.version, self.timestamp,
-                               self.leaf_type.value))
-    except struct.error:
-      raise AftlError('Unable to encode the leaf header')
-
-  def print_desc(self, o):
-    """Prints the leaf header.
-
-    Arguments:
-      o: The object to write the output to.
-    """
-    i = ' ' * 6
-    fmt = '{}{:23}{}\n'
-    o.write(fmt.format(i, 'Version:', self.version))
-    o.write(fmt.format(i, 'Timestamp:', self.timestamp))
-    o.write(fmt.format(i, 'Type:', self.leaf_type))
-
-
-class SignedVBMetaPrimaryAnnotationLeaf(Leaf):
-  """A Signed VBMetaPrimaryAnnotation leaf."""
-
-  def __init__(self, version=1, timestamp=0,
-               signed_vbmeta_primary_annotation=None):
-    """Builds a new Signed VBMeta Primary Annotation leaf."""
-    super(SignedVBMetaPrimaryAnnotationLeaf, self).__init__(
-        version=version, timestamp=timestamp,
-        leaf_type=self.LeafType.SignedVBMetaPrimaryAnnotationType)
-    if not signed_vbmeta_primary_annotation:
-      signed_vbmeta_primary_annotation = SignedVBMetaPrimaryAnnotation()
-    self.signed_vbmeta_primary_annotation = signed_vbmeta_primary_annotation
-
-  @property
-  def annotation(self):
-    """Returns the VBMetaPrimaryAnnotation contained in the leaf."""
-    return self.signed_vbmeta_primary_annotation.annotation
-
-  @property
-  def signature(self):
-    """Returns the Signature contained in the leaf."""
-    return self.signed_vbmeta_primary_annotation.signature
-
-  @classmethod
-  def parse(cls, data):
-    """Parses an encoded contained in data.
-
-    Arguments:
-      data: a bytes-like object.
-
-    Returns:
-      A SignedVBMetaPrimaryAnnotationLeaf.
-
-    Raises:
-      AftlError if the leaf type is incorrect; or if the decoding failed.
-    """
-    encoded_leaf = io.BytesIO(data)
-    version, timestamp, leaf_type = Leaf._parse_header(encoded_leaf)
-    if leaf_type != Leaf.LeafType.SignedVBMetaPrimaryAnnotationType:
-      raise AftlError("Incorrect leaf type")
-    signed_annotation = SignedVBMetaPrimaryAnnotation.parse(encoded_leaf)
-    return cls(version=version, timestamp=timestamp,
-               signed_vbmeta_primary_annotation=signed_annotation)
-
-  def get_expected_size(self):
-    """Returns the size of the leaf."""
-    size = self._get_expected_header_size()
-    if self.signed_vbmeta_primary_annotation:
-      size += self.signed_vbmeta_primary_annotation.get_expected_size()
-    return size
-
-  def encode(self):
-    """Encodes the leaf.
-
-    Returns:
-      bytes which contains the encoded leaf.
-
-    Raises:
-      AftlError: If the encoding failed.
-    """
-    stream = io.BytesIO()
-    self._encode_header(stream)
-    self.signed_vbmeta_primary_annotation.encode(stream)
-    return stream.getvalue()
-
-  def print_desc(self, o):
-    """Prints the leaf.
-
-    Arguments:
-      o: The object to write the output to.
-    """
-    i = ' ' * 4
-    fmt = '{}{:25}{}\n'
-    o.write(fmt.format(i, 'Leaf:', ''))
-    super(SignedVBMetaPrimaryAnnotationLeaf, self).print_desc(o)
-    self.signed_vbmeta_primary_annotation.print_desc(o)
-
-
-class AftlImage(object):
-  """A class for the AFTL image, which contains the transparency log ICPs.
-
-  This encapsulates an AFTL ICP section with all information required to
-  validate an inclusion proof.
-
-  Attributes:
-    image_header: A header for the section.
-    icp_entries: A list of AftlIcpEntry objects representing the inclusion
-        proofs.
-  """
-
-  def __init__(self, data=None):
-    """Initializes a new AftlImage section.
-
-    Arguments:
-      data: If not None, must be a bytearray representing an AftlImage.
-
-    Raises:
-      AftlError: If the data does not represent a well-formed AftlImage.
-    """
-    if data:
-      image_header_bytes = data[0:AftlImageHeader.SIZE]
-      self.image_header = AftlImageHeader(image_header_bytes)
-      if not self.image_header.is_valid():
-        raise AftlError('Invalid AftlImageHeader.')
-      icp_count = self.image_header.icp_count
-
-      # Jump past the header for entry deserialization.
-      icp_index = AftlImageHeader.SIZE
-      # Validate each entry.
-      self.icp_entries = []
-      # add_icp_entry() updates entries and header, so set header count to
-      # compensate.
-      self.image_header.icp_count = 0
-      for i in range(icp_count):
-        # Get the entry header from the AftlImage.
-        cur_icp_entry = AftlIcpEntry(data[icp_index:])
-        cur_icp_entry_size = cur_icp_entry.get_expected_size()
-        # Now validate the entry structure.
-        if not cur_icp_entry.is_valid():
-          raise AftlError('Validation of ICP entry {} failed.'.format(i))
-        self.add_icp_entry(cur_icp_entry)
-        icp_index += cur_icp_entry_size
-    else:
-      self.image_header = AftlImageHeader()
-      self.icp_entries = []
-    if not self.is_valid():
-      raise AftlError('Invalid AftlImage.')
-
-  def add_icp_entry(self, icp_entry):
-    """Adds a new AftlIcpEntry to the AftlImage, updating fields as needed.
-
-    Arguments:
-      icp_entry: An AftlIcpEntry structure.
-    """
-    self.icp_entries.append(icp_entry)
-    self.image_header.icp_count += 1
-    self.image_header.aftl_image_size += icp_entry.get_expected_size()
-
-  def verify_vbmeta_image(self, vbmeta_image, transparency_log_pub_keys):
-    """Verifies the contained inclusion proof given the public log key.
-
-    Arguments:
-      vbmeta_image: The vbmeta_image that should be verified against the
-        inclusion proof.
-      transparency_log_pub_keys: List of paths to PEM files containing trusted
-        public keys that correspond with the transparency_logs.
-
-    Returns:
-      True if all the inclusion proofs in the AfltDescriptor validate, are
-      signed by one of the give transparency log public keys; otherwise false.
-    """
-    if not transparency_log_pub_keys or not self.icp_entries:
-      return False
-
-    icp_verified = 0
-    for icp_entry in self.icp_entries:
-      verified = False
-      for pub_key in transparency_log_pub_keys:
-        if icp_entry.verify_vbmeta_image(vbmeta_image, pub_key):
-          verified = True
-          break
-      if verified:
-        icp_verified += 1
-    return icp_verified == len(self.icp_entries)
-
-  def encode(self):
-    """Serialize the AftlImage to a bytearray().
-
-    Returns:
-      A bytearray() with the encoded AFTL image.
-
-    Raises:
-      AftlError: If invalid AFTL image structure.
-    """
-    # The header and entries are guaranteed to be valid when encode is called.
-    # Check the entire structure as a whole.
-    if not self.is_valid():
-      raise AftlError('Invalid AftlImage structure.')
-
-    aftl_image = bytearray()
-    aftl_image.extend(self.image_header.encode())
-    for icp_entry in self.icp_entries:
-      aftl_image.extend(icp_entry.encode())
-    return aftl_image
-
-  def is_valid(self):
-    """Ensures that values in the AftlImage are sane.
-
-    Returns:
-      True if the values in the AftlImage are sane, False otherwise.
-    """
-    if not self.image_header.is_valid():
-      return False
-
-    if self.image_header.icp_count != len(self.icp_entries):
-      return False
-
-    for icp_entry in self.icp_entries:
-      if not icp_entry.is_valid():
-        return False
-    return True
-
-  def print_desc(self, o):
-    """Print the AFTL image.
-
-    Arguments:
-      o: The object to write the output to.
-    """
-    o.write('Android Firmware Transparency Image:\n')
-    self.image_header.print_desc(o)
-    for i, icp_entry in enumerate(self.icp_entries):
-      o.write('  Entry #{}:\n'.format(i + 1))
-      icp_entry.print_desc(o)
-
-
-class AftlCommunication(object):
-  """Class to abstract the communication layer with the transparency log."""
-
-  def __init__(self, transparency_log_config, timeout):
-    """Initializes the object.
-
-    Arguments:
-      transparency_log_config: A TransparencyLogConfig instance.
-      timeout: Duration in seconds before requests to the AFTL times out. A
-        value of 0 or None means there will be no timeout.
-    """
-    self.transparency_log_config = transparency_log_config
-    if timeout:
-      self.timeout = timeout
-    else:
-      self.timeout = None
-
-  def add_vbmeta(self, request):
-    """Calls the AddVBMeta RPC on the AFTL server.
-
-    Arguments:
-      request: An AddVBMetaRequest message.
-
-    Returns:
-      An AddVBMetaResponse message.
-
-    Raises:
-      AftlError: If grpc or the proto modules cannot be loaded, if there is an
-        error communicating with the log.
-    """
-    raise NotImplementedError(
-        'add_vbmeta() needs to be implemented by subclass.')
-
-
-class AftlGrpcCommunication(AftlCommunication):
-  """Class that implements GRPC communication to the AFTL server."""
-
-  def add_vbmeta(self, request):
-    """Calls the AddVBMeta RPC on the AFTL server.
-
-    Arguments:
-      request: An AddVBMetaRequest message.
-
-    Returns:
-      An AddVBMetaResponse message.
-
-    Raises:
-      AftlError: If grpc or the proto modules cannot be loaded, if there is an
-        error communicating with the log.
-    """
-    # Import grpc now to avoid global dependencies as it otherwise breaks
-    # running unittest with atest.
-    try:
-      import grpc  # pylint: disable=import-outside-toplevel
-      from proto import api_pb2_grpc # pylint: disable=import-outside-toplevel
-    except ImportError as e:
-      err_str = 'grpc can be installed with python pip install grpcio.\n'
-      raise AftlError('Failed to import module: ({}).\n{}'.format(e, err_str))
-
-    # Set up the gRPC channel with the transparency log.
-    sys.stdout.write('Preparing to request inclusion proof from {}. This could '
-                     'take ~30 seconds for the process to complete.\n'.format(
-                         self.transparency_log_config.target))
-    channel = grpc.insecure_channel(self.transparency_log_config.target)
-    stub = api_pb2_grpc.AFTLogStub(channel)
-
-    metadata = []
-    if self.transparency_log_config.api_key:
-      metadata.append(('x-api-key', self.transparency_log_config.api_key))
-
-    # Attempt to transmit to the transparency log.
-    sys.stdout.write('ICP is about to be requested from transparency log '
-                     'with domain {}.\n'.format(
-                         self.transparency_log_config.target))
-    try:
-      response = stub.AddVBMeta(request, timeout=self.timeout,
-                                metadata=metadata)
-    except grpc.RpcError as e:
-      raise AftlError('Error: grpc failure ({})'.format(e))
-    return response
-
-
-class Aftl(avbtool.Avb):
-  """Business logic for aftltool command-line tool."""
-
-  def get_vbmeta_image(self, image_filename):
-    """Gets the VBMeta struct bytes from image.
-
-    Arguments:
-      image_filename: Image file to get information from.
-
-    Returns:
-      A tuple with following elements:
-        1. A bytearray with the vbmeta structure or None if the file does not
-           contain a VBMeta structure.
-        2. The VBMeta image footer.
-    """
-    # Reads and parses the vbmeta image.
-    try:
-      image = avbtool.ImageHandler(image_filename, read_only=True)
-    except (IOError, ValueError) as e:
-      sys.stderr.write('The image does not contain a valid VBMeta structure: '
-                       '{}.\n'.format(e))
-      return None, None
-
-    try:
-      (footer, header, _, _) = self._parse_image(image)
-    except avbtool.AvbError as e:
-      sys.stderr.write('The image cannot be parsed: {}.\n'.format(e))
-      return None, None
-
-    # Seeks for the start of the vbmeta image and calculates its size.
-    offset = 0
-    if footer:
-      offset = footer.vbmeta_offset
-    vbmeta_image_size = (offset + header.SIZE
-                         + header.authentication_data_block_size
-                         + header.auxiliary_data_block_size)
-
-    # Reads the vbmeta image bytes.
-    try:
-      image.seek(offset)
-    except RuntimeError as e:
-      sys.stderr.write('Given vbmeta image offset is invalid: {}.\n'.format(e))
-      return None, None
-    return image.read(vbmeta_image_size), footer
-
-  def get_aftl_image(self, image_filename):
-    """Gets the AftlImage from image.
-
-    Arguments:
-      image_filename: Image file to get information from.
-
-    Returns:
-      An AftlImage or None if the file does not contain a AftlImage.
-    """
-    # Reads the vbmeta image bytes.
-    vbmeta_image, _ = self.get_vbmeta_image(image_filename)
-    if not vbmeta_image:
-      return None
-
-    try:
-      image = avbtool.ImageHandler(image_filename, read_only=True)
-    except ValueError as e:
-      sys.stderr.write('The image does not contain a valid VBMeta structure: '
-                       '{}.\n'.format(e))
-      return None
-
-    # Seeks for the start of the AftlImage.
-    try:
-      image.seek(len(vbmeta_image))
-    except RuntimeError as e:
-      sys.stderr.write('Given AftlImage image offset is invalid: {}.\n'
-                       .format(e))
-      return None
-
-    # Parses the header for the AftlImage size.
-    tmp_header_bytes = image.read(AftlImageHeader.SIZE)
-    if not tmp_header_bytes or len(tmp_header_bytes) != AftlImageHeader.SIZE:
-      sys.stderr.write('This image does not contain an AftlImage.\n')
-      return None
-
-    try:
-      tmp_header = AftlImageHeader(tmp_header_bytes)
-    except AftlError as e:
-      sys.stderr.write('This image does not contain a valid AftlImage: '
-                       '{}.\n'.format(e))
-      return None
-
-    # Resets to the beginning of the AftlImage.
-    try:
-      image.seek(len(vbmeta_image))
-    except RuntimeError as e:
-      sys.stderr.write('Given AftlImage image offset is invalid: {}.\n'
-                       .format(e))
-      return None
-
-    # Parses the full AftlImage.
-    aftl_image_bytes = image.read(tmp_header.aftl_image_size)
-    aftl_image = None
-    try:
-      aftl_image = AftlImage(aftl_image_bytes)
-    except AftlError as e:
-      sys.stderr.write('The image does not contain a valid AftlImage: '
-                       '{}.\n'.format(e))
-    return aftl_image
-
-  def info_image_icp(self, vbmeta_image_path, output):
-    """Implements the 'info_image_icp' command.
-
-    Arguments:
-      vbmeta_image_path: Image file to get information from.
-      output: Output file to write human-readable information to (file object).
-
-    Returns:
-      True if the given image has an AftlImage and could successfully
-      be processed; otherwise False.
-    """
-    aftl_image = self.get_aftl_image(vbmeta_image_path)
-    if not aftl_image:
-      return False
-    aftl_image.print_desc(output)
-    return True
-
-  def verify_image_icp(self, vbmeta_image_path, transparency_log_pub_keys,
-                       output):
-    """Implements the 'verify_image_icp' command.
-
-    Arguments:
-      vbmeta_image_path: Image file to get information from.
-      transparency_log_pub_keys: List of paths to PEM files containing trusted
-        public keys that correspond with the transparency_logs.
-      output: Output file to write human-readable information to (file object).
-
-    Returns:
-      True if for the given image the inclusion proof validates; otherwise
-      False.
-    """
-    vbmeta_image, _ = self.get_vbmeta_image(vbmeta_image_path)
-    aftl_image = self.get_aftl_image(vbmeta_image_path)
-    if not aftl_image or not vbmeta_image:
-      return False
-    verified = aftl_image.verify_vbmeta_image(vbmeta_image,
-                                              transparency_log_pub_keys)
-    if not verified:
-      output.write('The inclusion proofs for the image do not validate.\n')
-      return False
-    output.write('The inclusion proofs for the image successfully validate.\n')
-    return True
-
-  def request_inclusion_proof(self, transparency_log_config, vbmeta_image,
-                              version_inc, manufacturer_key_path,
-                              signing_helper, signing_helper_with_files,
-                              timeout, aftl_comms=None):
-    """Packages and sends a request to the specified transparency log.
-
-    Arguments:
-      transparency_log_config: A TransparencyLogConfig instance.
-      vbmeta_image: A bytearray with the VBMeta image.
-      version_inc: Subcomponent of the build fingerprint.
-      manufacturer_key_path: Path to key used to sign messages sent to the
-        transparency log servers.
-      signing_helper: Program which signs a hash and returns a signature.
-      signing_helper_with_files: Same as signing_helper but uses files instead.
-      timeout: Duration in seconds before requests to the transparency log
-        timeout.
-      aftl_comms: A subclass of the AftlCommunication class. The default is
-        to use AftlGrpcCommunication.
-
-    Returns:
-      An AftlIcpEntry with the inclusion proof for the log entry.
-
-    Raises:
-      AftlError: If grpc or the proto modules cannot be loaded, if there is an
-         error communicating with the log, if the manufacturer_key_path
-         cannot be decoded, or if the log submission cannot be signed.
-    """
-    # Calculate the hash of the vbmeta image.
-    vbmeta_hash = hashlib.sha256(vbmeta_image).digest()
-
-    # Extract the key data from the PEM file if of size 4096.
-    manufacturer_key = avbtool.RSAPublicKey(manufacturer_key_path)
-    if manufacturer_key.num_bits != 4096:
-      raise AftlError('Manufacturer keys not of size 4096: {}'.format(
-          manufacturer_key.num_bits))
-    manufacturer_key_data = rsa_key_read_pem_bytes(manufacturer_key_path)
-
-    # Calculate the hash of the manufacturer key data.
-    m_key_hash = hashlib.sha256(manufacturer_key_data).digest()
-
-    # Build VBMetaPrimaryAnnotation with that data.
-    annotation = VBMetaPrimaryAnnotation(
-        vbmeta_hash=vbmeta_hash, version_incremental=version_inc,
-        manufacturer_key_hash=m_key_hash)
-
-    # Sign annotation and add it to the request.
-    signed_annotation = annotation.sign(
-        manufacturer_key_path, signing_helper=signing_helper,
-        signing_helper_with_files=signing_helper_with_files)
-
-    encoded_signed_annotation = io.BytesIO()
-    signed_annotation.encode(encoded_signed_annotation)
-    request = api_pb2.AddVBMetaRequest(
-        vbmeta=vbmeta_image,
-        signed_vbmeta_primary_annotation=encoded_signed_annotation.getvalue())
-
-    # Submit signed VBMeta annotation to the server.
-    if not aftl_comms:
-      aftl_comms = AftlGrpcCommunication(transparency_log_config, timeout)
-    response = aftl_comms.add_vbmeta(request)
-
-    # Return an AftlIcpEntry representing this response.
-    icp_entry = AftlIcpEntry()
-    icp_entry.translate_response(transparency_log_config.target, response)
-    return icp_entry
-
-  def make_icp_from_vbmeta(self, vbmeta_image_path, output,
-                           signing_helper, signing_helper_with_files,
-                           version_incremental, transparency_log_configs,
-                           manufacturer_key, padding_size, timeout):
-    """Generates a vbmeta image with inclusion proof given a vbmeta image.
-
-    The AftlImage contains the information required to validate an inclusion
-    proof for a specific vbmeta image. It consists of a header (struct
-    AftlImageHeader) and zero or more entry structures (struct AftlIcpEntry)
-    that contain the vbmeta leaf hash, tree size, root hash, inclusion proof
-    hashes, and the signature for the root hash.
-
-    The vbmeta image, its hash, the version_incremental part of the build
-    fingerprint, and the hash of the manufacturer key are sent to the
-    transparency log, with the message signed by the manufacturer key.
-    An inclusion proof is calculated and returned. This inclusion proof is
-    then packaged in an AftlImage structure. The existing vbmeta data is
-    copied to a new file, appended with the AftlImage data, and written to
-    output. Validation of the inclusion proof does not require
-    communication with the transparency log.
-
-    Arguments:
-      vbmeta_image_path: Path to a vbmeta image file.
-      output: File to write the results to.
-      signing_helper: Program which signs a hash and returns a signature.
-      signing_helper_with_files: Same as signing_helper but uses files instead.
-      version_incremental: A string representing the subcomponent of the
-        build fingerprint used to identify the vbmeta in the transparency log.
-      transparency_log_configs: List of TransparencyLogConfig used to request
-        the inclusion proofs.
-      manufacturer_key: Path to PEM file containting the key file used to sign
-        messages sent to the transparency log servers.
-      padding_size: If not 0, pads output so size is a multiple of the number.
-      timeout: Duration in seconds before requests to the AFTL times out. A
-        value of 0 or None means there will be no timeout.
-
-    Returns:
-      True if the inclusion proofs could be fetched from the transparency log
-      servers and could be successfully validated; otherwise False.
-    """
-    # Retrieves vbmeta structure from given partition image.
-    vbmeta_image, footer = self.get_vbmeta_image(vbmeta_image_path)
-
-    # Fetches inclusion proofs for vbmeta structure from all transparency logs.
-    aftl_image = AftlImage()
-    for log_config in transparency_log_configs:
-      try:
-        icp_entry = self.request_inclusion_proof(log_config, vbmeta_image,
-                                                 version_incremental,
-                                                 manufacturer_key,
-                                                 signing_helper,
-                                                 signing_helper_with_files,
-                                                 timeout)
-        if not icp_entry.verify_vbmeta_image(vbmeta_image, log_config.pub_key):
-          sys.stderr.write('The inclusion proof from {} could not be verified.'
-                           '\n'.format(log_config.target))
-        aftl_image.add_icp_entry(icp_entry)
-      except AftlError as e:
-        # The inclusion proof request failed. Continue and see if others will.
-        sys.stderr.write('Requesting inclusion proof failed: {}.\n'.format(e))
-        continue
-
-    # Checks that the resulting AftlImage is sane.
-    if aftl_image.image_header.icp_count != len(transparency_log_configs):
-      sys.stderr.write('Valid inclusion proofs could only be retrieved from {} '
-                       'out of {} transparency logs.\n'
-                       .format(aftl_image.image_header.icp_count,
-                               len(transparency_log_configs)))
-      return False
-    if not aftl_image.is_valid():
-      sys.stderr.write('Resulting AftlImage structure is malformed.\n')
-      return False
-    keys = [log.pub_key for log in transparency_log_configs]
-    if not aftl_image.verify_vbmeta_image(vbmeta_image, keys):
-      sys.stderr.write('Resulting AftlImage inclusion proofs do not '
-                       'validate.\n')
-      return False
-
-    # Writes original VBMeta image, followed by the AftlImage into the output.
-    if footer:  # Checks if it is a chained partition.
-      # TODO(b/147217370): Determine the best way to handle chained partitions
-      # like the system.img. Currently, we only put the main vbmeta.img in the
-      # transparency log.
-      sys.stderr.write('Image has a footer and ICP for this format is not '
-                       'implemented.\n')
-      return False
-
-    output.seek(0)
-    output.write(vbmeta_image)
-    encoded_aftl_image = aftl_image.encode()
-    output.write(encoded_aftl_image)
-
-    if padding_size > 0:
-      total_image_size = len(vbmeta_image) + len(encoded_aftl_image)
-      padded_size = avbtool.round_to_multiple(total_image_size, padding_size)
-      padding_needed = padded_size - total_image_size
-      output.write('\0' * padding_needed)
-
-    sys.stdout.write('VBMeta image with AFTL image successfully created.\n')
-    return True
-
-  def _load_test_process_function(self, vbmeta_image_path,
-                                  transparency_log_config,
-                                  manufacturer_key,
-                                  process_number, submission_count,
-                                  preserve_icp_images, timeout, result_queue):
-    """Function to be used by multiprocessing.Process.
-
-    Arguments:
-      vbmeta_image_path: Path to a vbmeta image file.
-      transparency_log_config: A TransparencyLogConfig instance used to request
-        an inclusion proof.
-      manufacturer_key: Path to PEM file containting the key file used to sign
-        messages sent to the transparency log servers.
-      process_number: The number of the processes executing the function.
-      submission_count: Number of total submissions to perform per
-        process_count.
-      preserve_icp_images: Boolean to indicate if the generated vbmeta image
-        files with inclusion proofs should be preserved in the temporary
-        directory.
-      timeout: Duration in seconds before requests to the AFTL times out. A
-        value of 0 or None means there will be no timeout.
-      result_queue: Multiprocessing.Queue object for posting execution results.
-    """
-    for count in range(0, submission_count):
-      version_incremental = 'aftl_load_testing_{}_{}'.format(process_number,
-                                                             count)
-      output_file = os.path.join(tempfile.gettempdir(),
-                                 '{}_icp.img'.format(version_incremental))
-      output = open(output_file, 'wb')
-
-      # Instrumented section.
-      start_time = time.time()
-      result = self.make_icp_from_vbmeta(
-          vbmeta_image_path=vbmeta_image_path,
-          output=output,
-          signing_helper=None,
-          signing_helper_with_files=None,
-          version_incremental=version_incremental,
-          transparency_log_configs=[transparency_log_config],
-          manufacturer_key=manufacturer_key,
-          padding_size=0,
-          timeout=timeout)
-      end_time = time.time()
-
-      output.close()
-      if not preserve_icp_images:
-        os.unlink(output_file)
-
-      # Puts the result onto the result queue.
-      execution_time = end_time - start_time
-      result_queue.put((start_time, end_time, execution_time,
-                        version_incremental, result))
-
-  def load_test_aftl(self, vbmeta_image_path, output, transparency_log_config,
-                     manufacturer_key,
-                     process_count, submission_count, stats_filename,
-                     preserve_icp_images, timeout):
-    """Performs multi-threaded load test on a given AFTL and prints stats.
-
-    Arguments:
-      vbmeta_image_path: Path to a vbmeta image file.
-      output: File to write the report to.
-      transparency_log_config: A TransparencyLogConfig used to request an
-        inclusion proof.
-      manufacturer_key: Path to PEM file containting the key file used to sign
-        messages sent to the transparency log servers.
-      process_count: Number of processes used for parallel testing.
-      submission_count: Number of total submissions to perform per
-        process_count.
-      stats_filename: Path to the stats file to write the raw execution data to.
-        If None, it will be written to the temp directory.
-      preserve_icp_images: Boolean to indicate if the generated vbmeta
-        image files with inclusion proofs should preserved.
-      timeout: Duration in seconds before requests to the AFTL times out. A
-        value of 0 or None means there will be no timeout.
-
-    Returns:
-      True if the load tested succeeded without errors; otherwise False.
-    """
-    if process_count < 1 or submission_count < 1:
-      sys.stderr.write('Values for --processes/--submissions '
-                       'must be at least 1.\n')
-      return False
-
-    if not stats_filename:
-      stats_filename = os.path.join(
-          tempfile.gettempdir(),
-          'load_test_p{}_s{}.csv'.format(process_count, submission_count))
-
-    stats_file = None
-    try:
-      stats_file = open(stats_filename, 'wt')
-      stats_file.write('start_time,end_time,execution_time,version_incremental,'
-                       'result\n')
-    except IOError as e:
-      sys.stderr.write('Could not open stats file {}: {}.\n'
-                       .format(stats_file, e))
-      return False
-
-    # Launch all the processes with their workloads.
-    result_queue = multiprocessing.Queue()
-    processes = set()
-    execution_times = []
-    results = []
-    for i in range(0, process_count):
-      p = multiprocessing.Process(
-          target=self._load_test_process_function,
-          args=(vbmeta_image_path, transparency_log_config,
-                manufacturer_key, i, submission_count,
-                preserve_icp_images, timeout, result_queue))
-      p.start()
-      processes.add(p)
-
-    while processes:
-      # Processes the results queue and writes these to a stats file.
-      try:
-        (start_time, end_time, execution_time, version_incremental,
-         result) = result_queue.get(timeout=1)
-        stats_file.write('{},{},{},{},{}\n'.format(start_time, end_time,
-                                                   execution_time,
-                                                   version_incremental, result))
-        execution_times.append(execution_time)
-        results.append(result)
-      except queue.Empty:
-        pass
-
-      # Checks if processes are still alive; if not clean them up. join() would
-      # have been nicer but we want to continously stream out the stats to file.
-      for p in processes.copy():
-        if not p.is_alive():
-          processes.remove(p)
-
-    # Prepares stats.
-    executions = sorted(execution_times)
-    execution_count = len(execution_times)
-    median = 0
-
-    # pylint: disable=old-division
-    if execution_count % 2 == 0:
-      median = (executions[execution_count // 2 - 1]
-                + executions[execution_count // 2]) / 2
-    else:
-      median = executions[execution_count // 2]
-
-    # Outputs the stats report.
-    o = output
-    o.write('Load testing results:\n')
-    o.write('  Processes:               {}\n'.format(process_count))
-    o.write('  Submissions per process: {}\n'.format(submission_count))
-    o.write('\n')
-    o.write('  Submissions:\n')
-    o.write('    Total:                 {}\n'.format(len(executions)))
-    o.write('    Succeeded:             {}\n'.format(results.count(True)))
-    o.write('    Failed:                {}\n'.format(results.count(False)))
-    o.write('\n')
-    o.write('  Submission execution durations:\n')
-    o.write('    Average:               {:.2f} sec\n'.format(
-        sum(execution_times) / execution_count))
-    o.write('    Median:                {:.2f} sec\n'.format(median))
-    o.write('    Min:                   {:.2f} sec\n'.format(min(executions)))
-    o.write('    Max:                   {:.2f} sec\n'.format(max(executions)))
-
-    # Close the stats file.
-    stats_file.close()
-    if results.count(False):
-      return False
-    return True
-
-
-class TransparencyLogConfig(object):
-  """Class that gathers the fields representing a transparency log.
-
-  Attributes:
-    target: The hostname and port of the server in hostname:port format.
-    pub_key: A PEM file that contains the public key of the transparency
-      log server.
-    api_key: The API key to use to interact with the transparency log
-      server.
-  """
-
-  @staticmethod
-  def from_argument(arg):
-    """Build an object from a command line argument string.
-
-    Arguments:
-      arg: The transparency log as passed in the command line argument.
-        It must be in the format: host:port,key_file[,api_key].
-
-    Returns:
-      The TransparencyLogConfig instance.
-
-    Raises:
-      argparse.ArgumentTypeError: If the format of arg is invalid.
-    """
-    api_key = None
-    try:
-      target, pub_key, *rest = arg.split(",", maxsplit=2)
-    except ValueError:
-      raise argparse.ArgumentTypeError("incorrect format for transparency log "
-                                       "server, expected "
-                                       "host:port,publickey_file.")
-    if not target:
-      raise argparse.ArgumentTypeError("incorrect format for transparency log "
-                                       "server: host:port cannot be empty.")
-    if not pub_key:
-      raise argparse.ArgumentTypeError("incorrect format for transparency log "
-                                       "server: publickey_file cannot be "
-                                       "empty.")
-    if rest:
-      api_key = rest[0]
-    return TransparencyLogConfig(target, pub_key, api_key)
-
-  def __init__(self, target, pub_key, api_key=None):
-    """Initializes a new TransparencyLogConfig object."""
-    self.target = target
-    self.pub_key = pub_key
-    self.api_key = api_key
-
-
-class AftlTool(avbtool.AvbTool):
-  """Object for aftltool command-line tool."""
-
-  def __init__(self):
-    """Initializer method."""
-    self.aftl = Aftl()
-    super(AftlTool, self).__init__()
-
-  def make_icp_from_vbmeta(self, args):
-    """Implements the 'make_icp_from_vbmeta' sub-command."""
-    args = self._fixup_common_args(args)
-    return self.aftl.make_icp_from_vbmeta(args.vbmeta_image_path,
-                                          args.output,
-                                          args.signing_helper,
-                                          args.signing_helper_with_files,
-                                          args.version_incremental,
-                                          args.transparency_log_servers,
-                                          args.manufacturer_key,
-                                          args.padding_size,
-                                          args.timeout)
-
-  def info_image_icp(self, args):
-    """Implements the 'info_image_icp' sub-command."""
-    return self.aftl.info_image_icp(args.vbmeta_image_path.name, args.output)
-
-  def verify_image_icp(self, args):
-    """Implements the 'verify_image_icp' sub-command."""
-    return self.aftl.verify_image_icp(args.vbmeta_image_path.name,
-                                      args.transparency_log_pub_keys,
-                                      args.output)
-
-  def load_test_aftl(self, args):
-    """Implements the 'load_test_aftl' sub-command."""
-    return self.aftl.load_test_aftl(args.vbmeta_image_path,
-                                    args.output,
-                                    args.transparency_log_server,
-                                    args.manufacturer_key,
-                                    args.processes,
-                                    args.submissions,
-                                    args.stats_file,
-                                    args.preserve_icp_images,
-                                    args.timeout)
-
-  def run(self, argv):
-    """Command-line processor.
-
-    Arguments:
-      argv: Pass sys.argv from main.
-    """
-    parser = argparse.ArgumentParser()
-    subparsers = parser.add_subparsers(title='subcommands')
-
-    # Command: make_icp_from_vbmeta
-    sub_parser = subparsers.add_parser('make_icp_from_vbmeta',
-                                       help='Makes an ICP enhanced vbmeta image'
-                                       ' from an existing vbmeta image.')
-    sub_parser.add_argument('--output',
-                            help='Output file name.',
-                            type=argparse.FileType('wb'),
-                            default=sys.stdout)
-    sub_parser.add_argument('--vbmeta_image_path',
-                            help='Path to a generate vbmeta image file.',
-                            required=True)
-    sub_parser.add_argument('--version_incremental',
-                            help='Current build ID.',
-                            required=True)
-    sub_parser.add_argument('--manufacturer_key',
-                            help='Path to the PEM file containing the '
-                            'manufacturer key for use with the log.',
-                            required=True)
-    sub_parser.add_argument('--transparency_log_servers',
-                            help='List of transparency log servers in '
-                            'host:port,publickey_file[,api_key] format. The '
-                            'publickey_file must be in the PEM format.',
-                            nargs='+', type=TransparencyLogConfig.from_argument)
-    sub_parser.add_argument('--padding_size',
-                            metavar='NUMBER',
-                            help='If non-zero, pads output with NUL bytes so '
-                            'its size is a multiple of NUMBER (default: 0)',
-                            type=avbtool.parse_number,
-                            default=0)
-    sub_parser.add_argument('--timeout',
-                            metavar='SECONDS',
-                            help='Timeout in seconds for transparency log '
-                            'requests (default: 600 sec). A value of 0 means '
-                            'no timeout.',
-                            type=avbtool.parse_number,
-                            default=600)
-    self._add_common_args(sub_parser)
-    sub_parser.set_defaults(func=self.make_icp_from_vbmeta)
-
-    # Command: info_image_icp
-    sub_parser = subparsers.add_parser(
-        'info_image_icp',
-        help='Show information about AFTL ICPs in vbmeta or footer.')
-    sub_parser.add_argument('--vbmeta_image_path',
-                            help='Path to vbmeta image for AFTL information.',
-                            type=argparse.FileType('rb'),
-                            required=True)
-    sub_parser.add_argument('--output',
-                            help='Write info to file',
-                            type=argparse.FileType('wt'),
-                            default=sys.stdout)
-    sub_parser.set_defaults(func=self.info_image_icp)
-
-    # Arguments for verify_image_icp.
-    sub_parser = subparsers.add_parser(
-        'verify_image_icp',
-        help='Verify AFTL ICPs in vbmeta or footer.')
-
-    sub_parser.add_argument('--vbmeta_image_path',
-                            help='Image to verify the inclusion proofs.',
-                            type=argparse.FileType('rb'),
-                            required=True)
-    sub_parser.add_argument('--transparency_log_pub_keys',
-                            help='Paths to PEM files containing transparency '
-                            'log server key(s). This must not be None.',
-                            nargs='*',
-                            required=True)
-    sub_parser.add_argument('--output',
-                            help='Write info to file',
-                            type=argparse.FileType('wt'),
-                            default=sys.stdout)
-    sub_parser.set_defaults(func=self.verify_image_icp)
-
-    # Command: load_test_aftl
-    sub_parser = subparsers.add_parser(
-        'load_test_aftl',
-        help='Perform load testing against one AFTL log server. Note: This MUST'
-        ' not be performed against a production system.')
-    sub_parser.add_argument('--vbmeta_image_path',
-                            help='Path to a generate vbmeta image file.',
-                            required=True)
-    sub_parser.add_argument('--output',
-                            help='Write report to file.',
-                            type=argparse.FileType('wt'),
-                            default=sys.stdout)
-    sub_parser.add_argument('--manufacturer_key',
-                            help='Path to the PEM file containing the '
-                            'manufacturer key for use with the log.',
-                            required=True)
-    sub_parser.add_argument('--transparency_log_server',
-                            help='Transparency log server to test against in '
-                            'host:port,publickey_file[,api_key] format. The '
-                            'publickey_file must be in the PEM format.',
-                            required=True,
-                            type=TransparencyLogConfig.from_argument)
-    sub_parser.add_argument('--processes',
-                            help='Number of parallel processes to use for '
-                            'testing (default: 1).',
-                            type=avbtool.parse_number,
-                            default=1)
-    sub_parser.add_argument('--submissions',
-                            help='Number of submissions to perform against the '
-                            'log per process (default: 1).',
-                            type=avbtool.parse_number,
-                            default=1)
-    sub_parser.add_argument('--stats_file',
-                            help='Path to the stats file to write the raw '
-                            'execution data to (Default: '
-                            'load_test_p[processes]_s[submissions].csv.')
-    sub_parser.add_argument('--preserve_icp_images',
-                            help='Boolean flag to indicate if the generated '
-                            'vbmeta image files with inclusion proofs should '
-                            'preserved.',
-                            action='store_true')
-    sub_parser.add_argument('--timeout',
-                            metavar='SECONDS',
-                            help='Timeout in seconds for transparency log '
-                            'requests (default: 0). A value of 0 means '
-                            'no timeout.',
-                            type=avbtool.parse_number,
-                            default=0)
-    sub_parser.set_defaults(func=self.load_test_aftl)
-
-    args = parser.parse_args(argv[1:])
-    if not 'func' in args:
-      # This error gets raised when the command line tool is called without any
-      # arguments. It mimics the original Python 2 behavior.
-      parser.print_usage()
-      print('aftltool: error: too few arguments')
-      sys.exit(2)
-    try:
-      success = args.func(args)
-    except AftlError as e:
-      # Signals to calling tools that an unhandled exception occured.
-      sys.stderr.write('Unhandled AftlError occured: {}\n'.format(e))
-      sys.exit(2)
-
-    if not success:
-      # Signals to calling tools that the command has failed.
-      sys.exit(1)
-
-if __name__ == '__main__':
-  tool = AftlTool()
-  tool.run(sys.argv)
diff --git a/aftltool_integration_test.py b/aftltool_integration_test.py
deleted file mode 100755
index 814631b..0000000
--- a/aftltool_integration_test.py
+++ /dev/null
@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2019, The Android Open Source Project
-#
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation
-# files (the "Software"), to deal in the Software without
-# restriction, including without limitation the rights to use, copy,
-# modify, merge, publish, distribute, sublicense, and/or sell copies
-# of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-#
-"""Integration tests for the avbtool with an actual AFTL.
-
-The test cases directly interact with a transparency log. However,
-before using this script the following environment variables
-need to be set:
-
-  AFTL_HOST: host:port of the transparency log to test with.
-  AFTL_PUBKEY: Transparency log public key in PEM format.
-  AFTL_APIKEY: If the transparency log requires an API key to submit data,
-      this should be the complete key.
-  AFTL_VBMETA_IMAGE: VBMeta image that should be used for submission to AFTL.
-  AFTL_MANUFACTURER_KEY: Manufacturer signing key used to sign submissions
-      to the transparency log in PEM format.
-"""
-
-import os
-import unittest
-
-import aftltool
-import aftltool_test
-
-
-class AftlIntegrationTest(aftltool_test.AftlTest):
-  """Test suite for integration testing aftltool with an actual AFTL.
-
-  Note: The actual testcases are implemented are implemented as part of the
-  super class. This class only contains the configuration for running the unit
-  tests against as a live log as a means of integration testing.
-  """
-
-  def set_up_environment(self):
-    """Sets up the environment for integration testing with actual AFTL."""
-    self.aftl_host = os.environ.get('AFTL_HOST')
-    self.aftl_pubkey = os.environ.get('AFTL_PUBKEY')
-    self.aftl_apikey = os.environ.get('AFTL_APIKEY')
-    self.vbmeta_image = os.environ.get('AFTL_VBMETA_IMAGE')
-    self.manufacturer_key = os.environ.get('AFTL_MANUFACTURER_KEY')
-
-    if (not self.aftl_host or not self.aftl_pubkey or not self.vbmeta_image
-        or not self.manufacturer_key):
-      self.fail('Environment variables not correctly set up. See description of'
-                ' this test case for details')
-
-  def get_aftl_implementation(self, canned_response):
-    """Retrieves an instance if aftltool.Aftl for integration testing.
-
-    Arguments:
-      canned_response: Since we are using the actual implementation and not a
-      mock this gets ignored.
-
-    Returns:
-      An instance of aftltool.Aftl()
-    """
-    return aftltool.Aftl()
-
-
-if __name__ == '__main__':
-  unittest.main(verbosity=2)
diff --git a/aftltool_test.py b/aftltool_test.py
deleted file mode 100755
index 7c8c205..0000000
--- a/aftltool_test.py
+++ /dev/null
@@ -1,1609 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2019, The Android Open Source Project
-#
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation
-# files (the "Software"), to deal in the Software without
-# restriction, including without limitation the rights to use, copy,
-# modify, merge, publish, distribute, sublicense, and/or sell copies
-# of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-#
-"""Unit tests for aftltool."""
-
-import argparse
-import binascii
-import io
-import os
-import struct
-import sys
-import tempfile
-import unittest
-
-import aftltool
-import avbtool
-
-# pylint: disable=import-error
-import api_pb2
-# pylint: enable=import-error
-
-
-# Workaround for b/149307145 in order to pick up the test data from the right
-# location independent where the script is called from.
-# TODO(b/149307145): Remove workaround once the referenced bug is fixed.
-TEST_EXEC_PATH = os.path.dirname(os.path.realpath(__file__))
-
-class TlsDataTest(unittest.TestCase):
-
-  def test_decode(self):
-    data = io.BytesIO(b'\x01\x02')
-    value = aftltool.tls_decode_bytes('B', data)
-    self.assertEqual(value, b'\x02')
-    self.assertEqual(data.read(), b'')
-
-    data = io.BytesIO(b'\x00\x01\x03\xff')
-    value = aftltool.tls_decode_bytes('H', data)
-    self.assertEqual(value, b'\x03')
-    self.assertEqual(data.read(), b'\xff')
-
-    data = io.BytesIO(b'\x00\x00\x00\x02\x04\x05\xff\xff')
-    value = aftltool.tls_decode_bytes('L', data)
-    self.assertEqual(value, b'\x04\x05')
-    self.assertEqual(data.read(), b'\xff\xff')
-
-  def test_decode_invalid(self):
-    # Insufficient data for reading the size.
-    with self.assertRaises(aftltool.AftlError):
-      aftltool.tls_decode_bytes('B', io.BytesIO(b''))
-
-    # Invalid byte_size character.
-    with self.assertRaises(aftltool.AftlError):
-      aftltool.tls_decode_bytes('/o/', io.BytesIO(b'\x01\x02\xff'))
-
-    # Insufficient data for reading the value.
-    with self.assertRaises(aftltool.AftlError):
-      aftltool.tls_decode_bytes('B', io.BytesIO(b'\x01'))
-
-  def test_encode(self):
-    stream = io.BytesIO()
-    aftltool.tls_encode_bytes('B', b'\x01\x02\x03\x04', stream)
-    self.assertEqual(stream.getvalue(), b'\x04\x01\x02\x03\x04')
-
-    stream = io.BytesIO()
-    aftltool.tls_encode_bytes('H', b'\x01\x02\x03\x04', stream)
-    self.assertEqual(stream.getvalue(), b'\x00\x04\x01\x02\x03\x04')
-
-  def test_encode_invalid(self):
-    # Byte size is not large enough to encode the value.
-    stream = io.BytesIO()
-    with self.assertRaises(aftltool.AftlError):
-      aftltool.tls_encode_bytes('B', b'\x01'*256, stream)
-
-    # Invalid byte_size character.
-    stream = io.BytesIO()
-    with self.assertRaises(aftltool.AftlError):
-      aftltool.tls_encode_bytes('/o/', b'\x01\x02', stream)
-
-
-class VBMetaPrimaryAnnotationTest(unittest.TestCase):
-
-  def test_decode(self):
-    stream = io.BytesIO(b'\x00\x00\x00\x00\x00')
-    anno = aftltool.VBMetaPrimaryAnnotation.parse(stream)
-    self.assertEqual(anno.vbmeta_hash, b'')
-    self.assertEqual(anno.version_incremental, '')
-    self.assertEqual(anno.manufacturer_key_hash, b'')
-    self.assertEqual(anno.description, '')
-
-  def test_encode(self):
-    stream = io.BytesIO()
-    anno = aftltool.VBMetaPrimaryAnnotation()
-    anno.encode(stream)
-    self.assertEqual(stream.getvalue(), b'\x00\x00\x00\x00\x00')
-
-  def test_encode_invalid(self):
-    stream = io.BytesIO()
-    anno = aftltool.VBMetaPrimaryAnnotation()
-    # Version incremental should be ASCII only.
-    anno.version_incremental = '☃'
-    with self.assertRaises(aftltool.AftlError):
-      anno.encode(stream)
-
-
-class SignedVBMetaAnnotationLeafTest(unittest.TestCase):
-
-  def test_encode(self):
-    leaf = aftltool.SignedVBMetaPrimaryAnnotationLeaf()
-    self.assertEqual(leaf.encode(),
-                     b'\x01'   # Version
-                     b'\x00\x00\x00\x00\x00\x00\x00\x00'  # Timestamp
-                     b'\x01' + # Leaf Type
-                     b'\x00' * 4 + # Empty Signature
-                     b'\x00' * 5) # Empty Annotation
-
-  def test_encode_invalid_type(self):
-    # The version field must be a 1-byte integer.
-    leaf = aftltool.SignedVBMetaPrimaryAnnotationLeaf()
-    leaf.version = 'x'
-    with self.assertRaises(aftltool.AftlError):
-      leaf.encode()
-
-  def test_encode_invalid_size(self):
-    leaf = aftltool.SignedVBMetaPrimaryAnnotationLeaf()
-    leaf.version = 256
-    with self.assertRaises(aftltool.AftlError):
-      leaf.encode()
-
-
-class AftltoolTestCase(unittest.TestCase):
-
-  def setUp(self):
-    """Sets up the test bed for the unit tests."""
-    super(AftltoolTestCase, self).setUp()
-
-    # Redirects the stderr to /dev/null when running the unittests. The reason
-    # is that soong interprets any output on stderr as an error and marks the
-    # unit test as failed although the test itself succeeded.
-    self.stderr = sys.stderr
-    self.null = open(os.devnull, 'wt')
-    sys.stderr = self.null
-
-    # AFTL public key.
-    self.test_aftl_pub_key = (
-        '-----BEGIN PUBLIC KEY-----\n'
-        'MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA4ilqCNsenNA013iCdwgD\n'
-        'YPxZ853nbHG9lMBp9boXiwRcqT/8bUKHIL7YX5z7s+QoRYVY3rkMKppRabclXzyx\n'
-        'H59YnPMaU4uv7NqwWzjgaZo7E+vo7IF+KBjV3cJulId5Av0yIYUCsrwd7MpGtWdC\n'
-        'Q3S+7Vd4zwzCKEhcvliNIhnNlp1U3wNkPCxOyCAsMEn6k8O5ar12ke5TvxDv15db\n'
-        'rPDeHh8G2OYWoCkWL+lSN35L2kOJqKqVbLKWrrOd96RCYrrtbPCi580OADJRcUlG\n'
-        'lgcjwmNwmypBWvQMZ6ITj0P0ksHnl1zZz1DE2rXe1goLI1doghb5KxLaezlR8c2C\n'
-        'E3w/uo9KJgNmNgUVzzqZZ6FE0moyIDNOpP7KtZAL0DvEZj6jqLbB0ccPQElrg52m\n'
-        'Dv2/A3nYSr0mYBKeskT4+Bg7PGgoC8p7WyLSxMyzJEDYdtrj9OFx6eZaA23oqTQx\n'
-        'k3Qq5H8RfNBeeSUEeKF7pKH/7gyqZ2bNzBFMA2EBZgBozwRfaeN/HCv3qbaCnwvu\n'
-        '6caacmAsK+RxiYxSL1QsJqyhCWWGxVyenmxdc1KG/u5ypi7OIioztyzR3t2tAzD3\n'
-        'Nb+2t8lgHBRxbV24yiPlnvPmB1ZYEctXnlRR9Evpl1o9xA9NnybPHKr9rozN39CZ\n'
-        'V/USB8K6ao1y5xPZxa8CZksCAwEAAQ==\n'
-        '-----END PUBLIC KEY-----\n')
-
-    # Test AftlIcpEntry #1
-    self.test_tl_url_1 = 'aftl-test-server.google.com'
-
-    self.test_sth_1 = aftltool.TrillianLogRootDescriptor()
-    self.test_sth_1.tree_size = 2
-    self.test_sth_1.root_hash_size = 32
-    self.test_sth_1.root_hash = b'f' * 32
-    self.test_sth_1.timestamp = 0x1234567890ABCDEF
-    self.test_sth_1.revision = 0xFEDCBA0987654321
-
-    self.test_sth_1_bytes = (
-        b'\x00\x01'                          # version
-        b'\x00\x00\x00\x00\x00\x00\x00\x02'  # tree_size
-        b'\x20'                              # root_hash_size
-        + b'f' * 32 +                        # root_hash
-        b'\x12\x34\x56\x78\x90\xAB\xCD\xEF'  # timestamp
-        b'\xFE\xDC\xBA\x09\x87\x65\x43\x21'  # revision
-        b'\x00\x00'                          # metadata_size
-        b''                                  # metadata (empty)
-    )
-
-    # Test Annotation #1
-    anno_1 = aftltool.VBMetaPrimaryAnnotation(vbmeta_hash=b'w'*32,
-                                              version_incremental='x'*5,
-                                              manufacturer_key_hash=b'y'*32,
-                                              description='z'*51)
-    signed_anno_1 = aftltool.SignedVBMetaPrimaryAnnotation(annotation=anno_1)
-
-    self.test_anno_1 = aftltool.SignedVBMetaPrimaryAnnotationLeaf(
-        signed_vbmeta_primary_annotation=signed_anno_1)
-    self.test_anno_1_bytes = (
-        b'\x01'                              # version
-        b'\x00\x00\x00\x00\x00\x00\x00\x00'  # timestamp
-        b'\x01'                              # leaf_type
-        b'\x00'                              # hash_algorithm
-        b'\x00'                              # signature_algorithm
-        + b'\x00\x00'                        # signature
-        + b'\x20' + b'w' * 32                # vbmeta_hash
-        + b'\x05' + b'x' * 5                 # version_incremental
-        + b'\x20' + b'y' * 32                # manufacturer_key_hash
-        + b'\x00\x33' + b'z' * 51            # description
-    )
-
-    # Fill each structure with an easily observable pattern for easy validation.
-    self.test_proof_hashes_1 = []
-    self.test_proof_hashes_1.append(b'b' * 32)
-    self.test_proof_hashes_1.append(b'c' * 32)
-    self.test_proof_hashes_1.append(b'd' * 32)
-    self.test_proof_hashes_1.append(b'e' * 32)
-
-    # Valid test AftlIcpEntry #1.
-    self.test_entry_1 = aftltool.AftlIcpEntry()
-    self.test_entry_1.log_url = self.test_tl_url_1
-    self.test_entry_1.leaf_index = 1
-    self.test_entry_1.annotation_leaf = self.test_anno_1
-    self.test_entry_1.log_root_descriptor = self.test_sth_1
-    self.test_entry_1.proofs = self.test_proof_hashes_1
-    self.test_entry_1.log_root_signature = b'g' * 512
-
-    self.test_entry_1_bytes = (
-        b'\x00\x00\x00\x1b'                  # Transparency log url size.
-        b'\x00\x00\x00\x00\x00\x00\x00\x01'  # Leaf index.
-        b'\x00\x00\x00\x3d'                  # Log root descriptor size.
-        b'\x00\x00\x00\x8b'                  # Annotation leaf size.
-        b'\x02\x00'                          # Log root signature size.
-        b'\x04'                              # Number of hashes in ICP.
-        b'\x00\x00\x00\x80'                  # Size of ICP in bytes.
-        + self.test_tl_url_1.encode('ascii') # Transparency log url.
-        + self.test_sth_1_bytes
-        + self.test_anno_1_bytes
-        + b'g' * 512                         # Log root signature.
-        + b'b' * 32                          # Hashes...
-        + b'c' * 32
-        + b'd' * 32
-        + b'e' * 32)
-
-    # Valid test AftlIcpEntry #2.
-    self.test_tl_url_2 = 'aftl-test-server.google.ch'
-
-    self.test_sth_2 = aftltool.TrillianLogRootDescriptor()
-    self.test_sth_2.tree_size = 4
-    self.test_sth_2.root_hash_size = 32
-    self.test_sth_2.root_hash = b'e' * 32
-    self.test_sth_2.timestamp = 6
-    self.test_sth_2.revision = 7
-    self.test_sth_2.metadata_size = 2
-    self.test_sth_2.metadata = b'12'
-
-    self.test_sth_2_bytes = (
-        b'\x00\x01'                          # version
-        b'\x00\x00\x00\x00\x00\x00\x00\x04'  # tree_size
-        b'\x20'                              # root_hash_size
-        + b'e' * 32 +                        # root_hash
-        b'\x00\x00\x00\x00\x00\x00\x00\x06'  # timestamp
-        b'\x00\x00\x00\x00\x00\x00\x00\x07'  # revision
-        b'\x00\x02'                          # metadata_size
-        b'12'                                # metadata
-    )
-
-    # Fill each structure with an easily observable pattern for easy validation.
-    self.test_proof_hashes_2 = []
-    self.test_proof_hashes_2.append(b'g' * 32)
-    self.test_proof_hashes_2.append(b'h' * 32)
-
-    self.test_entry_2 = aftltool.AftlIcpEntry()
-    self.test_entry_2.log_url = self.test_tl_url_2
-    self.test_entry_2.leaf_index = 2
-    self.test_entry_2.annotation_leaf = self.test_anno_1
-    self.test_entry_2.log_root_descriptor = self.test_sth_2
-    self.test_entry_2.log_root_signature = b'd' * 512
-    self.test_entry_2.proofs = self.test_proof_hashes_2
-
-    self.test_entry_2_bytes = (
-        b'\x00\x00\x00\x1a'                   # Transparency log url size.
-        b'\x00\x00\x00\x00\x00\x00\x00\x02'   # Leaf index.
-        b'\x00\x00\x00\x3f'                   # Log root descriptor size.
-        b'\x00\x00\x00\x8b'                   # Annotation leaf size.
-        b'\x02\x00'                           # Log root signature size.
-        b'\x02'                               # Number of hashes in ICP.
-        b'\x00\x00\x00\x40'                   # Size of ICP in bytes.
-        + self.test_tl_url_2.encode('ascii')  # Transparency log url.
-        + self.test_sth_2_bytes               # Log root
-        + self.test_anno_1_bytes
-        + b'd' * 512                          # Log root signature.
-        + b'g' * 32                           # Hashes...
-        + b'h' * 32)
-
-    # Valid test AftlImage made out of AftlEntry #1 and #2.
-    self.test_aftl_desc = aftltool.AftlImage()
-    self.test_aftl_desc.add_icp_entry(self.test_entry_1)
-    self.test_aftl_desc.add_icp_entry(self.test_entry_2)
-
-    self.test_expected_aftl_image_bytes = (
-        b'AFTL'                                         # Magic.
-        + struct.pack('!L', avbtool.AVB_VERSION_MAJOR)  # Major version.
-        + struct.pack('!L', avbtool.AVB_VERSION_MINOR)  # Minor version.
-        + b'\x00\x00\x06\xcf'                           # Image size.
-        b'\x00\x02'                                     # Number of ICP entries.
-        + self.test_entry_1_bytes
-        + self.test_entry_2_bytes)
-
-    self.test_avbm_resp = api_pb2.AddVBMetaResponse()
-    self.test_avbm_resp.annotation_proof.proof.leaf_index = 9127
-    hashes = [
-        '61076ca285b4982669e67757f55682ddc43ab5c11ba671260f82a8efa8831f94',
-        '89c2fbcc58da25a65ce5e9b4fb22aaf208b20601f0bc023f73f05d35bc1f3bac',
-        '75d26b5f754b4bed332a3ce2a2bfea0334706a974b7e00ee663f0279fa8b446e',
-        'e1cd9c96feb893b5ef7771e424ac1c6c47509c2b98bc578d22ad07369c9641aa',
-        'e83e0e4dd352b1670a55f93f88781a73bb41efcadb9927399f59459dfa14bc40',
-        '8d5d25996117c88655d66f685baa3c94390867a040507b10587b17fbe92b496a',
-        '5de4c627e9ca712f207d6056f56f0d3286ed4a5381ed7f3cc1aa470217734138',
-        '19acfdb424d7fe28d1f850c76302f78f9a50146a5b9c65f9fdfbbc0173fd6993']
-    for h in hashes:
-      self.test_avbm_resp.annotation_proof.proof.hashes.append(
-          binascii.unhexlify(h))
-    self.test_avbm_resp.annotation_proof.sth.key_hint = binascii.unhexlify(
-        '5af859abce8fe1ea')
-    self.test_avbm_resp.annotation_proof.sth.log_root = binascii.unhexlify(
-        '0001'
-        '00000000000023a8'
-        '20'
-        '9a5f71340f8dc98bdc6320f976dda5f34db8554cb273ba5ab60f1697c519d6f6'
-        '1609ae15024774b1'
-        '0000000000001e5a'
-        '0000'
-    )
-    self.test_avbm_resp.annotation_proof.sth.log_root_signature = (
-        binascii.unhexlify(
-            '7c37903cc76e8689a6b31da9ad56c3daeb6194029510297cc7d147278390da33'
-            '09c4d9eb1f6be0cdcd1de5315b0b3b573cc9fcd8620d3fab956abbe3c597a572'
-            '46e5a5d277c4cc4b590872d0292fa64e1d3285626b1dedeb00b6aa0a7a0717c0'
-            '7d4c89b68fda9091be06180be1369675a7c4ce7f42cca133ef0daf8dcc5ba1ee'
-            '930cef6dcb71b0a7690446e19661c8e18c089a5d6f6fc9299a0592efb33a4db5'
-            '4c640027fa4f0ad0009f8bf75ec5fc17e0fa1091fabe74fe52738443745066ab'
-            '48f99b297809b863c01016abda17a2479fce91f9929c60bc2ce15e474204fc5a'
-            '8e79b2190aadb7c149671e8c76a4da506860f8d6020fb2eaabfee025cc267bad'
-            '3c8257186c8aaf1da9eefe50cae4b3e8deb66033ebc4bfcda2b317f9e7d2dd78'
-            'b47f2d86795815d82058ad4cba8fc7983a3bbf843e9b8c7ec7f1ae137be6848d'
-            '03c76eefdac40ce5e66cc23d9f3e79ad87acbe7ec0c0bb419a7d368ae1e73c85'
-            '742871f847bde69c871e8797638e0e270282fb058ef1cbcba52aded9dcc8249b'
-            '38fbed8424c33b8cfcde4f49797c64dda8d089d73b84062602fd41c66091543c'
-            'e13c18cfa7f8300530ad4b7adb8924bbb86d17bcc5f1d3d74c522a7dcc8c3c1f'
-            '28a999f2fe1bfe5520c66f93f7c90996dc7f52e62dd95ace9ceace90324c3040'
-            '669b7f5aeb5c5a53f217f1de46e32f80d0aaaf7d9cc9d0e8f8fd7026c612103a'
-        )
-    )
-
-    anno = aftltool.VBMetaPrimaryAnnotation(
-        vbmeta_hash=bytes.fromhex(
-            '5623731104bfa1cfdb275df2978d1f93f72f5f0f746f11d06f3091c601c32067'),
-        version_incremental='only_for_testing',
-        manufacturer_key_hash=bytes.fromhex(
-            '83ab3b109b73a1d32dce4153a2de57a1a0485052db8364f3180d98614749d7f7'))
-    raw_signature = bytes.fromhex(
-        '6a523021bc5b933bb58c38c8238be3a5fe1166002f5df8b77dee9dd22d353595'
-        'be7996656d3824ebf4e1411a05ee3652d64669d3d62b167d3290dbdf4f2741ba'
-        '4b6472e1bd71fc1860465fdcdca1ff08c4ab0420d7dcbf4ad144f64e211d8f92'
-        '081ba51192358e2478195e573d000282423b23e6dd945069907dcf11520ff11a'
-        '250e26643b820f8a5d80ccfe7d5d84f58e549cd05630f2254ade8edc88d9aa8a'
-        'ec2089f84643854e1f265a4f746598ce4cae529c4eaa637f6e35fa1d1da9254e'
-        'ec8dfede7a4313f7b151547dcdde98782ce6fb3149326ee5b8e750813d3fd37a'
-        '738fe92f6111bf0dff4091769e216b842980e05716f2e50268a7dcca430e175e'
-        '711f80e41a1a28f20635741ac11a56f97492d30db6d1955a827daf8e83faebe5'
-        'a96e18a13c558ae561a02c90982514c853db0296c2e791e68b77c30e6232a3b7'
-        'ed355441d4706277f33a01735f56cb8279336491731939691683f96f1c3e3183'
-        'a0b77510d6ff0199b7688902044829793106546fd6fd4a5294d63c31c91256ad'
-        'f7be6d053e77875698ad32ffaaeaac5d54b432e537f72549d2543072ae35578f'
-        '138d82afcadd668511ba276ce02b6f9c18ef3b6f2f6ae0d123e9f8cb930f21a9'
-        'c49a6d9e95de741c7860593a956735e1b77e9851ecb1f6572abf6e2c8ba15085'
-        'e37e0f7bab0a30d108b997ed5edd74cf7f89cf082590a6f0af7a3a1f68c0077a')
-    signature = aftltool.Signature(signature=raw_signature)
-    signed_anno = aftltool.SignedVBMetaPrimaryAnnotation(annotation=anno,
-                                                         signature=signature)
-    leaf = aftltool.SignedVBMetaPrimaryAnnotationLeaf(
-        timestamp=1587991742919072870,
-        signed_vbmeta_primary_annotation=signed_anno).encode()
-    self.test_avbm_resp.annotation_leaf = leaf
-
-
-  def tearDown(self):
-    """Tears down the test bed for the unit tests."""
-    # Reconnects stderr back to the normal stderr; see setUp() for details.
-    sys.stderr = self.stderr
-    self.null.close()
-
-    super(AftltoolTestCase, self).tearDown()
-
-  def get_testdata_path(self, relative_path):
-    """Retrieves the absolute path for testdata given the relative path.
-
-    Arguments:
-      relative_path: The relative path to the testdata in the testdata
-        directory.
-
-    Returns:
-      The absolute path to the testdata.
-    """
-    rel_path_parts = ['test', 'data']
-    rel_path_parts.extend(relative_path.split(os.path.sep))
-    return os.path.join(TEST_EXEC_PATH, *rel_path_parts)
-
-
-class AftltoolTest(AftltoolTestCase):
-
-  def test_merkle_root_hash(self):
-    """Tests validation of inclusion proof and the merkle tree calculations.
-
-    The test vectors have been taken from the Trillian tests:
-    https://github.com/google/trillian/blob/v1.3.3/merkle/log_verifier_test.go
-    """
-
-    inclusion_proofs = [
-        (1,
-         8,
-         [
-             binascii.unhexlify('96a296d224f285c67bee93c30f8a3091'
-                                '57f0daa35dc5b87e410b78630a09cfc7'),
-             binascii.unhexlify('5f083f0a1a33ca076a95279832580db3'
-                                'e0ef4584bdff1f54c8a360f50de3031e'),
-             binascii.unhexlify('6b47aaf29ee3c2af9af889bc1fb9254d'
-                                'abd31177f16232dd6aab035ca39bf6e4')
-         ]),
-        (6,
-         8,
-         [
-             binascii.unhexlify('bc1a0643b12e4d2d7c77918f44e0f4f7'
-                                '9a838b6cf9ec5b5c283e1f4d88599e6b'),
-             binascii.unhexlify('ca854ea128ed050b41b35ffc1b87b8eb'
-                                '2bde461e9e3b5596ece6b9d5975a0ae0'),
-             binascii.unhexlify('d37ee418976dd95753c1c73862b9398f'
-                                'a2a2cf9b4ff0fdfe8b30cd95209614b7')
-         ]),
-        (3,
-         3,
-         [
-             binascii.unhexlify('fac54203e7cc696cf0dfcb42c92a1d9d'
-                                'baf70ad9e621f4bd8d98662f00e3c125')
-         ]),
-        (2,
-         5,
-         [
-             binascii.unhexlify('6e340b9cffb37a989ca544e6bb780a2c'
-                                '78901d3fb33738768511a30617afa01d'),
-             binascii.unhexlify('5f083f0a1a33ca076a95279832580db3'
-                                'e0ef4584bdff1f54c8a360f50de3031e'),
-             binascii.unhexlify('bc1a0643b12e4d2d7c77918f44e0f4f7'
-                                '9a838b6cf9ec5b5c283e1f4d88599e6b')
-         ]
-        )
-    ]
-
-    leaves = [
-        binascii.unhexlify(''),
-        binascii.unhexlify('00'),
-        binascii.unhexlify('10'),
-        binascii.unhexlify('2021'),
-        binascii.unhexlify('3031'),
-        binascii.unhexlify('40414243'),
-        binascii.unhexlify('5051525354555657'),
-        binascii.unhexlify('606162636465666768696a6b6c6d6e6f'),
-    ]
-
-    roots = [
-        binascii.unhexlify('6e340b9cffb37a989ca544e6bb780a2c'
-                           '78901d3fb33738768511a30617afa01d'),
-        binascii.unhexlify('fac54203e7cc696cf0dfcb42c92a1d9d'
-                           'baf70ad9e621f4bd8d98662f00e3c125'),
-        binascii.unhexlify('aeb6bcfe274b70a14fb067a5e5578264'
-                           'db0fa9b51af5e0ba159158f329e06e77'),
-        binascii.unhexlify('d37ee418976dd95753c1c73862b9398f'
-                           'a2a2cf9b4ff0fdfe8b30cd95209614b7'),
-        binascii.unhexlify('4e3bbb1f7b478dcfe71fb631631519a3'
-                           'bca12c9aefca1612bfce4c13a86264d4'),
-        binascii.unhexlify('76e67dadbcdf1e10e1b74ddc608abd2f'
-                           '98dfb16fbce75277b5232a127f2087ef'),
-        binascii.unhexlify('ddb89be403809e325750d3d263cd7892'
-                           '9c2942b7942a34b77e122c9594a74c8c'),
-        binascii.unhexlify('5dc9da79a70659a9ad559cb701ded9a2'
-                           'ab9d823aad2f4960cfe370eff4604328'),
-    ]
-
-    for icp in inclusion_proofs:
-      leaf_id = icp[0] - 1
-      leaf_hash = aftltool.rfc6962_hash_leaf(leaves[leaf_id])
-      root_hash = aftltool.root_from_icp(leaf_id, icp[1], icp[2], leaf_hash)
-      self.assertEqual(root_hash, roots[icp[1] -1])
-
-
-class AftlImageTest(AftltoolTestCase):
-
-  def test__init__(self):
-    """Tests the constructor."""
-    # Calls constructor without data.
-    d = aftltool.AftlImage()
-    self.assertIsInstance(d.image_header, aftltool.AftlImageHeader)
-    self.assertEqual(d.image_header.icp_count, 0)
-    self.assertEqual(d.icp_entries, [])
-    self.assertTrue(d.is_valid())
-
-    # Calls constructor with data.
-    d = aftltool.AftlImage(self.test_expected_aftl_image_bytes)
-    self.assertIsInstance(d.image_header, aftltool.AftlImageHeader)
-    self.assertEqual(d.image_header.icp_count, 2)
-    self.assertEqual(len(d.icp_entries), 2)
-    for entry in d.icp_entries:
-      self.assertIsInstance(entry, aftltool.AftlIcpEntry)
-    self.assertTrue(d.is_valid())
-
-  def test_add_icp_entry(self):
-    """Tests the add_icp_entry method."""
-    d = aftltool.AftlImage()
-
-    # Adds 1st ICP.
-    d.add_icp_entry(self.test_entry_1)
-    self.assertEqual(d.image_header.icp_count, 1)
-    self.assertEqual(len(d.icp_entries), 1)
-    self.assertTrue(d.is_valid())
-
-    # Adds 2nd ICP.
-    d.add_icp_entry(self.test_entry_2)
-    self.assertEqual(d.image_header.icp_count, 2)
-    self.assertEqual(len(d.icp_entries), 2)
-    self.assertTrue(d.is_valid())
-
-  def test_verify_vbmeta_image_with_1_icp(self):
-    """Tests the verify_vbmeta_image method."""
-    # Valid vbmeta image without footer with 1 ICP.
-    tool = aftltool.Aftl()
-    image_path = self.get_testdata_path(
-        'aftl_output_vbmeta_with_1_icp.img')
-    vbmeta_image, _ = tool.get_vbmeta_image(image_path)
-    desc = tool.get_aftl_image(image_path)
-
-    # Valid image checked against correct log key.
-    self.assertTrue(desc.verify_vbmeta_image(
-        vbmeta_image, [self.get_testdata_path('aftl_pubkey_1.pem')]))
-
-    # Valid image checked with a key from another log.
-    self.assertFalse(desc.verify_vbmeta_image(
-        vbmeta_image, [self.get_testdata_path('testkey_rsa4096_pub.pem')]))
-
-    # Valid image checked with non existed key file path.
-    self.assertFalse(desc.verify_vbmeta_image(
-        vbmeta_image, [self.get_testdata_path('non_existent_blabli')]))
-
-    # Valid image checked with an invalid key.
-    self.assertFalse(desc.verify_vbmeta_image(
-        vbmeta_image, [self.get_testdata_path('large_blob.bin')]))
-
-    # Valid image checked with empty list of keys.
-    self.assertFalse(desc.verify_vbmeta_image(vbmeta_image, []))
-
-    # Valid image checked with empty list of keys.
-    self.assertFalse(desc.verify_vbmeta_image(vbmeta_image, None))
-
-  def test_verify_vbmeta_image_with_2_icp_from_same_log(self):
-    """Tests the verify_vbmeta_image method."""
-    # Valid vbmeta image without footer with 2 ICPs from same log.
-    tool = aftltool.Aftl()
-    image_path = self.get_testdata_path(
-        'aftl_output_vbmeta_with_2_icp_same_log.img')
-    vbmeta_image, _ = tool.get_vbmeta_image(image_path)
-    desc = tool.get_aftl_image(image_path)
-
-    # Valid image checked against correct log key.
-    self.assertTrue(desc.verify_vbmeta_image(
-        vbmeta_image, [self.get_testdata_path('aftl_pubkey_1.pem')]))
-
-    # Valid vbmeta image checked with key from another log.
-    self.assertFalse(desc.verify_vbmeta_image(
-        vbmeta_image, [self.get_testdata_path('testkey_rsa4096_pub.pem')]))
-
-    # Valid image checked with non existed key file path.
-    self.assertFalse(desc.verify_vbmeta_image(
-        vbmeta_image, [self.get_testdata_path('non_existent_blabli')]))
-
-    # Valid image checked with invalid key.
-    self.assertFalse(desc.verify_vbmeta_image(
-        vbmeta_image, [self.get_testdata_path('large_blob.bin')]))
-
-    # Valid image but checked with empty list of keys.
-    self.assertFalse(desc.verify_vbmeta_image(vbmeta_image, []))
-
-  def test_encode(self):
-    """Tests encode method."""
-    desc_bytes = self.test_aftl_desc.encode()
-    self.assertEqual(desc_bytes, self.test_expected_aftl_image_bytes)
-
-  def test_is_valid(self):
-    """Tests is_valid method."""
-    d = aftltool.AftlImage()
-    d.add_icp_entry(self.test_entry_1)
-    d.add_icp_entry(self.test_entry_2)
-
-    # Force invalid ICP header.
-    old_magic = d.image_header.magic
-    d.image_header.magic = b'YOLO'
-    self.assertFalse(d.is_valid())
-    d.image_header.magic = old_magic
-    self.assertTrue(d.is_valid())
-
-    # Force count mismatch between header and actual entries.
-    old_icp_count = d.image_header.icp_count
-    d.image_header.icp_count = 1
-    self.assertFalse(d.is_valid())
-    d.image_header.icp_count = old_icp_count
-    self.assertTrue(d.is_valid())
-
-    # Force invalid ICP entry.
-    old_leaf_index = d.icp_entries[0].leaf_index
-    d.icp_entries[0].leaf_index = -10
-    self.assertFalse(d.is_valid())
-    d.icp_entries[0].leaf_index = old_leaf_index
-    self.assertTrue(d.is_valid())
-
-  def test_print_desc(self):
-    """Tests print_desc method."""
-    buf = io.StringIO()
-    self.test_aftl_desc.print_desc(buf)
-    desc = buf.getvalue()
-
-    # Cursory check whether the printed description contains something useful.
-    self.assertGreater(len(desc), 0)
-    self.assertIn('Log Root Descriptor:', desc)
-
-
-class AftlImageHeaderTest(AftltoolTestCase):
-  """Test suite for testing the AftlImageHeader descriptor."""
-
-  def setUp(self):
-    """Sets up the test bed for the unit tests."""
-    super(AftlImageHeaderTest, self).setUp()
-
-    self.test_header_valid = aftltool.AftlImageHeader()
-    self.test_header_valid.icp_count = 1
-
-    self.test_header_invalid = aftltool.AftlImageHeader()
-    self.test_header_invalid.icp_count = -34
-
-    self.test_header_bytes = (
-        b'AFTL'                                         # Magic.
-        + struct.pack('!L', avbtool.AVB_VERSION_MAJOR)  # Major version.
-        + struct.pack('!L', avbtool.AVB_VERSION_MINOR)  # Minor version.
-        + b'\x00\x00\x00\x12'                           # Image size.
-        b'\x00\x01')                                    # Number of ICP entries.
-
-  def test__init__(self):
-    """Tests constructor."""
-
-    # Calls constructor without data.
-    header = aftltool.AftlImageHeader()
-    self.assertEqual(header.magic, b'AFTL')
-    self.assertEqual(header.required_icp_version_major,
-                     avbtool.AVB_VERSION_MAJOR)
-    self.assertEqual(header.required_icp_version_minor,
-                     avbtool.AVB_VERSION_MINOR)
-    self.assertEqual(header.aftl_image_size, aftltool.AftlImageHeader.SIZE)
-    self.assertEqual(header.icp_count, 0)
-    self.assertTrue(header.is_valid())
-
-    # Calls constructor with data.
-    header = aftltool.AftlImageHeader(self.test_header_bytes)
-    self.assertEqual(header.magic, b'AFTL')
-    self.assertEqual(header.required_icp_version_major,
-                     avbtool.AVB_VERSION_MAJOR)
-    self.assertEqual(header.required_icp_version_minor,
-                     avbtool.AVB_VERSION_MINOR)
-    self.assertEqual(header.aftl_image_size, aftltool.AftlImageHeader.SIZE)
-    self.assertTrue(header.icp_count, 1)
-    self.assertTrue(header.is_valid())
-
-  def test_encode(self):
-    """Tests encode method."""
-    # Valid header.
-    header_bytes = self.test_header_valid.encode()
-    self.assertEqual(header_bytes, self.test_header_bytes)
-
-    # Invalid header
-    with self.assertRaises(aftltool.AftlError):
-      header_bytes = self.test_header_invalid.encode()
-
-  def test_is_valid(self):
-    """Tests is_valid method."""
-    # Valid default record.
-    header = aftltool.AftlImageHeader()
-    self.assertTrue(header.is_valid())
-
-    # Invalid magic.
-    header = aftltool.AftlImageHeader()
-    header.magic = b'YOLO'
-    self.assertFalse(header.is_valid())
-
-    # Valid ICP count.
-    self.assertTrue(self.test_header_valid.is_valid())
-
-    # Invalid ICP count.
-    self.assertFalse(self.test_header_invalid.is_valid())
-
-    header = aftltool.AftlImageHeader()
-    header.icp_count = 10000000
-    self.assertFalse(header.is_valid())
-
-    # Invalid ICP major version.
-    header = aftltool.AftlImageHeader()
-    header.required_icp_version_major = avbtool.AVB_VERSION_MAJOR + 1
-    self.assertFalse(header.is_valid())
-
-    # Invalid ICP minor version.
-    header = aftltool.AftlImageHeader()
-    header.required_icp_version_minor = avbtool.AVB_VERSION_MINOR + 1
-    self.assertFalse(header.is_valid())
-
-  def test_print_desc(self):
-    """Tests print_desc method."""
-    buf = io.StringIO()
-    self.test_header_valid.print_desc(buf)
-    desc = buf.getvalue()
-
-    # Cursory check whether the printed description contains something useful.
-    self.assertGreater(len(desc), 0)
-    self.assertIn('Major version:', desc)
-
-
-class AftlIcpEntryTest(AftltoolTestCase):
-  """Test suite for testing the AftlIcpEntry descriptor."""
-
-  def test__init__and_properties(self):
-    """Tests constructor and properties methods."""
-
-    # Calls constructor without data.
-    entry = aftltool.AftlIcpEntry()
-    self.assertEqual(entry.log_url_size, 0)
-    self.assertEqual(entry.leaf_index, 0)
-    self.assertEqual(entry.log_root_descriptor_size, 29)
-    self.assertEqual(entry.annotation_leaf_size, 19)
-    self.assertEqual(entry.log_root_sig_size, 0)
-    self.assertEqual(entry.proof_hash_count, 0)
-    self.assertEqual(entry.inc_proof_size, 0)
-    self.assertEqual(entry.log_url, '')
-    self.assertIsInstance(entry.log_root_descriptor,
-                          aftltool.TrillianLogRootDescriptor)
-    self.assertEqual(entry.proofs, [])
-    self.assertTrue(entry.is_valid())
-
-    # Calls constructor with data.
-    entry = aftltool.AftlIcpEntry(self.test_entry_1_bytes)
-    self.assertEqual(entry.log_url_size, len(self.test_tl_url_1))
-    self.assertEqual(entry.leaf_index, 1)
-    self.assertEqual(entry.annotation_leaf_size, 139)
-    self.assertEqual(entry.log_root_sig_size, 512)
-    self.assertEqual(entry.proof_hash_count, len(self.test_proof_hashes_1))
-    self.assertEqual(entry.inc_proof_size, 128)
-    self.assertEqual(entry.log_url, self.test_tl_url_1)
-    self.assertEqual(entry.proofs, self.test_proof_hashes_1)
-    self.assertTrue(entry.is_valid())
-
-  def test_encode(self):
-    """Tests encode method."""
-    entry_bytes = self.test_entry_1.encode()
-    self.assertEqual(entry_bytes, self.test_entry_1_bytes)
-
-  def test_get_expected_size(self):
-    """Tests get_expected_size method."""
-    # Default record.
-    entry = aftltool.AftlIcpEntry()
-    self.assertEqual(entry.get_expected_size(), 75)
-    self.assertEqual(entry.get_expected_size(), len(entry.encode()))
-
-    # Test record.
-    self.assertEqual(self.test_entry_1.get_expected_size(), 894)
-    self.assertEqual(self.test_entry_1.get_expected_size(),
-                     len(self.test_entry_1.encode()))
-
-  def test_is_valid(self):
-    """Tests is_valid method."""
-    # Valid default record.
-    entry = aftltool.AftlIcpEntry()
-    entry.leaf_index = 2
-    entry.log_url = self.test_tl_url_1
-    entry.set_log_root_descriptor = self.test_sth_1
-    entry.proofs = self.test_proof_hashes_1
-    self.assertTrue(entry.is_valid())
-
-    # Invalid leaf index.
-    entry = aftltool.AftlIcpEntry()
-    entry.leaf_index = -1
-    self.assertFalse(entry.is_valid())
-
-    # Invalid log_root_descriptor
-    entry = aftltool.AftlIcpEntry()
-    entry.log_root_descriptor = None
-    self.assertFalse(entry.is_valid())
-
-    entry.log_root_descriptor = b''
-    self.assertFalse(entry.is_valid())
-
-    entry.log_root_descriptor = b'blabli'
-    self.assertFalse(entry.is_valid())
-
-  def test_translate_response(self):
-    """Tests translate_response method."""
-    entry = aftltool.AftlIcpEntry()
-    entry.translate_response('aftl-test.foo.bar:80', self.test_avbm_resp)
-    self.assertEqual(entry.log_url, 'aftl-test.foo.bar:80')
-    self.assertEqual(entry.leaf_index, 9127)
-    self.assertEqual(entry.log_root_descriptor.encode(),
-                     self.test_avbm_resp.annotation_proof.sth.log_root)
-    self.assertEqual(
-        entry.log_root_signature,
-        self.test_avbm_resp.annotation_proof.sth.log_root_signature)
-    self.assertEqual(
-        entry.proofs,
-        self.test_avbm_resp.annotation_proof.proof.hashes)
-
-  def test_verify_icp(self):
-    """Tests verify_icp method."""
-    with tempfile.NamedTemporaryFile('wt+') as key_file:
-      key_file.write(self.test_aftl_pub_key)
-      key_file.flush()
-
-      # Valid ICP.
-      entry = aftltool.AftlIcpEntry()
-      entry.translate_response(self.test_tl_url_1, self.test_avbm_resp)
-      self.assertTrue(entry.verify_icp(key_file.name))
-
-      # Invalid ICP where annotation_leaf is not matching up with proofs.
-      # pylint: disable=protected-access
-      entry = aftltool.AftlIcpEntry()
-      entry.translate_response(self.test_tl_url_1, self.test_avbm_resp)
-      vbmeta_hash = entry.annotation_leaf.annotation.vbmeta_hash
-      vbmeta_hash = vbmeta_hash.replace(b"\x56\x23\x73\x11",
-                                        b"\x00\x00\x00\x00")
-      entry.annotation_leaf.annotation.vbmeta_hash = vbmeta_hash
-      self.assertFalse(entry.verify_icp(key_file))
-
-  def test_verify_vbmeta_image(self):
-    """Tests the verify_vbmeta_image method."""
-    # Valid vbmeta image without footer with 1 ICP.
-    tool = aftltool.Aftl()
-    image_path = self.get_testdata_path(
-        'aftl_output_vbmeta_with_1_icp.img')
-    vbmeta_image, _ = tool.get_vbmeta_image(image_path)
-    desc = tool.get_aftl_image(image_path)
-
-    # Checks that there is 1 ICP.
-    self.assertEqual(desc.image_header.icp_count, 1)
-    entry = desc.icp_entries[0]
-
-    # Valid vbmeta image checked with correct log key.
-    self.assertTrue(entry.verify_vbmeta_image(
-        vbmeta_image, self.get_testdata_path('aftl_pubkey_1.pem')))
-
-    # Valid vbmeta image checked with public key of another log.
-    self.assertFalse(entry.verify_vbmeta_image(
-        vbmeta_image, self.get_testdata_path('testkey_rsa4096_pub.pem')))
-
-    # Valid vbmeta image checked with invalid key.
-    self.assertFalse(entry.verify_vbmeta_image(
-        vbmeta_image, self.get_testdata_path('large_blob.bin')))
-
-    # Valid vbmeta image checked with no key.
-    self.assertFalse(entry.verify_vbmeta_image(vbmeta_image, None))
-
-  def test_verify_invalid_vbmeta_image(self):
-    """Tests the verify_vbmeta_image method."""
-    # Valid vbmeta image without footer with 1 ICP.
-    tool = aftltool.Aftl()
-    image_path = self.get_testdata_path(
-        'aftl_output_vbmeta_with_1_icp.img')
-    vbmeta_image, _ = tool.get_vbmeta_image(image_path)
-    desc = tool.get_aftl_image(image_path)
-
-    self.assertEqual(desc.image_header.icp_count, 1)
-    entry = desc.icp_entries[0]
-
-    # Modify vbmeta image to become invalid
-    vbmeta_image = b'A' * len(vbmeta_image)
-
-    # Invalid vbmeta image checked with correct log key.
-    self.assertFalse(entry.verify_vbmeta_image(
-        vbmeta_image, self.get_testdata_path('aftl_pubkey_1.pem')))
-
-    # Invalid vbmeta image checked with invalid key.
-    self.assertFalse(entry.verify_vbmeta_image(
-        vbmeta_image, self.get_testdata_path('large_blob.bin')))
-
-    # Valid vbmeta image checked with no key.
-    self.assertFalse(entry.verify_vbmeta_image(vbmeta_image, None))
-
-    # None image checked with a key.
-    self.assertFalse(entry.verify_vbmeta_image(
-        None, self.get_testdata_path('aftl_pubkey_1.pem')))
-
-  def test_print_desc(self):
-    """Tests print_desc method."""
-    buf = io.StringIO()
-    self.test_entry_1.print_desc(buf)
-    desc = buf.getvalue()
-
-    # Cursory check whether the printed description contains something useful.
-    self.assertGreater(len(desc), 0)
-    self.assertIn('ICP hashes:', desc)
-
-
-class TrillianLogRootDescriptorTest(AftltoolTestCase):
-  """Test suite for testing the TrillianLogRootDescriptor descriptor."""
-
-  def setUp(self):
-    """Sets up the test bed for the unit tests."""
-    super(TrillianLogRootDescriptorTest, self).setUp()
-
-    # Creates basic log root without metadata fields.
-    base_log_root = (
-        '0001'                              # version
-        '00000000000002e5'                  # tree_size
-        '20'                                # root_hash_size
-        '2d614759ad408a111a3351c0cb33c099'  # root_hash
-        '422c30a5c5104788a343332bde2b387b'
-        '15e1c97e3b4bd239'                  # timestamp
-        '00000000000002e4'                  # revision
-    )
-
-    # Create valid log roots with metadata fields w/ and w/o metadata.
-    self.test_log_root_bytes_wo_metadata = binascii.unhexlify(
-        base_log_root + '0000')
-    self.test_log_root_bytes_with_metadata = binascii.unhexlify(
-        base_log_root + '00023132')
-
-  def test__init__(self):
-    """Tests constructor."""
-    # Calls constructor without data.
-    d = aftltool.TrillianLogRootDescriptor()
-    self.assertTrue(d.is_valid())
-    self.assertEqual(d.version, 1)
-    self.assertEqual(d.tree_size, 0)
-    self.assertEqual(d.root_hash_size, 0)
-    self.assertEqual(d.root_hash, b'')
-    self.assertEqual(d.timestamp, 0)
-    self.assertEqual(d.revision, 0)
-    self.assertEqual(d.metadata_size, 0)
-    self.assertEqual(d.metadata, b'')
-
-    # Calls constructor with log_root w/o metadata
-    d = aftltool.TrillianLogRootDescriptor(self.test_log_root_bytes_wo_metadata)
-    self.assertTrue(d.is_valid())
-    self.assertEqual(d.version, 1)
-    self.assertEqual(d.tree_size, 741)
-    self.assertEqual(d.root_hash_size, 32)
-    self.assertEqual(d.root_hash,
-                     binascii.unhexlify('2d614759ad408a111a3351c0cb33c099'
-                                        '422c30a5c5104788a343332bde2b387b'))
-    self.assertEqual(d.timestamp, 1576762888554271289)
-    self.assertEqual(d.revision, 740)
-    self.assertEqual(d.metadata_size, 0)
-    self.assertEqual(d.metadata, b'')
-
-    # Calls constructor with log_root with metadata
-    d = aftltool.TrillianLogRootDescriptor(
-        self.test_log_root_bytes_with_metadata)
-    self.assertEqual(d.metadata_size, 2)
-    self.assertEqual(d.metadata, b'12')
-
-  def test_get_expected_size(self):
-    """Tests get_expected_size method."""
-    # Default constructor.
-    d = aftltool.TrillianLogRootDescriptor()
-    self.assertEqual(d.get_expected_size(), 11 + 18)
-
-    # Log root without metadata.
-    d = aftltool.TrillianLogRootDescriptor(self.test_log_root_bytes_wo_metadata)
-    self.assertEqual(d.get_expected_size(), 11 + 18 + 32)
-
-    # Log root with metadata.
-    d = aftltool.TrillianLogRootDescriptor(
-        self.test_log_root_bytes_with_metadata)
-    self.assertEqual(d.get_expected_size(), 11 + 18 + 32 + 2)
-
-  def test_encode(self):
-    """Tests encode method."""
-    # Log root from default constructor.
-    d = aftltool.TrillianLogRootDescriptor()
-    expected_bytes = (
-        '0001'                              # version
-        '0000000000000000'                  # tree_size
-        '00'                                # root_hash_size
-        ''                                  # root_hash (empty)
-        '0000000000000000'                  # timestamp
-        '0000000000000000'                  # revision
-        '0000'                              # metadata size
-        ''                                  # metadata (empty)
-    )
-    self.assertEqual(d.encode(), binascii.unhexlify(expected_bytes))
-
-    # Log root without metadata.
-    d = aftltool.TrillianLogRootDescriptor(self.test_log_root_bytes_wo_metadata)
-    self.assertEqual(d.encode(), self.test_log_root_bytes_wo_metadata)
-
-    # Log root with metadata.
-    d = aftltool.TrillianLogRootDescriptor(
-        self.test_log_root_bytes_with_metadata)
-    self.assertEqual(d.encode(), self.test_log_root_bytes_with_metadata)
-
-  def test_is_valid(self):
-    """Tests is_valid method."""
-    d = aftltool.TrillianLogRootDescriptor()
-    self.assertTrue(d.is_valid())
-
-    # Invalid version.
-    d = aftltool.TrillianLogRootDescriptor()
-    d.version = 2
-    self.assertFalse(d.is_valid())
-
-    # Invalid tree_size.
-    d = aftltool.TrillianLogRootDescriptor()
-    d.tree_size = -1
-    self.assertFalse(d.is_valid())
-
-    # Invalid root_hash_size.
-    d = aftltool.TrillianLogRootDescriptor()
-    d.root_hash_size = -1
-    self.assertFalse(d.is_valid())
-    d.root_hash_size = 300
-    self.assertFalse(d.is_valid())
-
-    # Invalid/valid root_hash_size / root_hash combination.
-    d = aftltool.TrillianLogRootDescriptor()
-    d.root_hash_size = 4
-    d.root_hash = b'123'
-    self.assertFalse(d.is_valid())
-    d.root_hash = b'1234'
-    self.assertTrue(d.is_valid())
-
-    # Invalid timestamp.
-    d = aftltool.TrillianLogRootDescriptor()
-    d.timestamp = -1
-    self.assertFalse(d.is_valid())
-
-    # Invalid revision.
-    d = aftltool.TrillianLogRootDescriptor()
-    d.revision = -1
-    self.assertFalse(d.is_valid())
-
-    # Invalid metadata_size.
-    d = aftltool.TrillianLogRootDescriptor()
-    d.metadata_size = -1
-    self.assertFalse(d.is_valid())
-    d.metadata_size = 70000
-    self.assertFalse(d.is_valid())
-
-    # Invalid/valid metadata_size / metadata combination.
-    d = aftltool.TrillianLogRootDescriptor()
-    d.metadata_size = 4
-    d.metadata = b'123'
-    self.assertFalse(d.is_valid())
-    d.metadata = b'1234'
-    self.assertTrue(d.is_valid())
-
-  def test_print_desc(self):
-    """Tests print_desc method."""
-    # Log root without metadata
-    buf = io.StringIO()
-    d = aftltool.TrillianLogRootDescriptor(self.test_log_root_bytes_wo_metadata)
-    d.print_desc(buf)
-    desc = buf.getvalue()
-
-    # Cursory check whether the printed description contains something useful.
-    self.assertGreater(len(desc), 0)
-    self.assertIn('Version:', desc)
-    self.assertNotIn('Metadata:', desc)
-
-    # Log root with metadata
-    buf = io.StringIO()
-    d = aftltool.TrillianLogRootDescriptor(
-        self.test_log_root_bytes_with_metadata)
-    d.print_desc(buf)
-    desc = buf.getvalue()
-
-    # Cursory check whether the printed description contains something useful.
-    self.assertGreater(len(desc), 0)
-    self.assertIn('Version:', desc)
-    self.assertIn('Metadata:', desc)
-
-
-class SignedVBMetaPrimaryAnnotationLeafTest(AftltoolTestCase):
-  """Test suite for testing the Leaf."""
-
-  def test__init__(self):
-    """Tests constructor and properties methods."""
-    # Calls constructor without data.
-    leaf = aftltool.SignedVBMetaPrimaryAnnotationLeaf()
-    self.assertEqual(leaf.version, 1)
-    self.assertEqual(leaf.timestamp, 0)
-    self.assertEqual(leaf.signature.signature, b'')
-    self.assertEqual(leaf.annotation.vbmeta_hash, b'')
-    self.assertEqual(leaf.annotation.description, '')
-
-  def test_parse(self):
-    # Calls parse with valid data.
-    leaf = aftltool.SignedVBMetaPrimaryAnnotationLeaf.parse(
-        self.test_anno_1_bytes)
-    self.assertEqual(leaf.annotation.vbmeta_hash, b'w'*32)
-    self.assertEqual(leaf.annotation.version_incremental, 'x'*5)
-    self.assertEqual(leaf.annotation.manufacturer_key_hash, b'y'*32)
-    self.assertEqual(leaf.annotation.description, 'z'*51)
-
-    # Calls parse with invalid data.
-    with self.assertRaises(aftltool.AftlError):
-      leaf = aftltool.SignedVBMetaPrimaryAnnotationLeaf.parse(b'Invalid data')
-
-  def test_get_expected_size(self):
-    """Tests get_expected_size method."""
-    # Calls constructor without data.
-    leaf = aftltool.SignedVBMetaPrimaryAnnotationLeaf()
-    self.assertEqual(leaf.get_expected_size(), 19)
-
-    # Calls constructor with data.
-    leaf = aftltool.SignedVBMetaPrimaryAnnotationLeaf.parse(
-        self.test_anno_1_bytes)
-    self.assertEqual(leaf.get_expected_size(),
-                     len(self.test_anno_1_bytes))
-
-  def test_encode(self):
-    """Tests encode method."""
-    # Calls constructor with data.
-    self.assertEqual(self.test_anno_1.encode(),
-                     self.test_anno_1_bytes)
-
-  def test_print_desc(self):
-    """Tests print_desc method."""
-    buf = io.StringIO()
-    self.test_anno_1.print_desc(buf)
-    desc = buf.getvalue()
-
-    # Cursory check whether the printed description contains something useful.
-    self.assertGreater(len(desc), 0)
-    self.assertIn('VBMeta hash:', desc)
-
-
-class AftlMockCommunication(aftltool.AftlCommunication):
-  """Testing Mock implementation of AftlCommunication."""
-
-  def __init__(self, transparency_log_config, canned_response):
-    """Initializes the object.
-
-    Arguments:
-      transparency_log_config: An aftltool.TransparencyLogConfig instance.
-      canned_response: AddVBMetaResponse to return or the Exception to
-        raise.
-    """
-    super(AftlMockCommunication, self).__init__(transparency_log_config,
-                                                timeout=None)
-    self.request = None
-    self.canned_response = canned_response
-
-  def add_vbmeta(self, request):
-    """Records the request and returns the canned response."""
-    self.request = request
-
-    if isinstance(self.canned_response, aftltool.AftlError):
-      raise self.canned_response
-    return self.canned_response
-
-
-class AftlMock(aftltool.Aftl):
-  """Mock for aftltool.Aftl to mock the communication piece."""
-
-  def __init__(self, canned_response):
-    """Initializes the object.
-
-    Arguments:
-      canned_response: AddVBMetaResponse to return or the Exception to
-        raise.
-    """
-    self.mock_canned_response = canned_response
-
-  def request_inclusion_proof(self, transparency_log_config, vbmeta_image,
-                              version_inc, manufacturer_key_path,
-                              signing_helper, signing_helper_with_files,
-                              timeout, aftl_comms=None):
-    """Mocked request_inclusion_proof function."""
-    aftl_comms = AftlMockCommunication(transparency_log_config,
-                                       self.mock_canned_response)
-    return super(AftlMock, self).request_inclusion_proof(
-        transparency_log_config, vbmeta_image, version_inc,
-        manufacturer_key_path, signing_helper, signing_helper_with_files,
-        timeout, aftl_comms=aftl_comms)
-
-
-class AftlTestCase(AftltoolTestCase):
-
-  def setUp(self):
-    """Sets up the test bed for the unit tests."""
-    super(AftlTestCase, self).setUp()
-
-    # Sets up the member variables which are then configured by
-    # set_up_environment() in the subclasses.
-    self.aftl_host = None
-    self.aftl_pubkey = None
-    self.aftl_apikey = None
-    self.vbmeta_image = None
-    self.manufacturer_key = None
-    self.set_up_environment()
-
-    self.transparency_log_config = aftltool.TransparencyLogConfig(
-        self.aftl_host, self.aftl_pubkey, self.aftl_apikey)
-
-    self.make_icp_default_params = {
-        'vbmeta_image_path': self.vbmeta_image,
-        'output': None,
-        'signing_helper': None,
-        'signing_helper_with_files': None,
-        'version_incremental': '1',
-        'transparency_log_configs': [self.transparency_log_config],
-        'manufacturer_key': self.manufacturer_key,
-        'padding_size': 0,
-        'timeout': None
-    }
-
-    self.info_icp_default_params = {
-        'vbmeta_image_path': None,
-        'output': io.StringIO()
-    }
-
-    self.verify_icp_default_params = {
-        'vbmeta_image_path': None,
-        'transparency_log_pub_keys': [self.aftl_pubkey],
-        'output': io.StringIO()
-    }
-
-    self.load_test_aftl_default_params = {
-        'vbmeta_image_path': self.vbmeta_image,
-        'output': io.StringIO(),
-        'transparency_log_config': self.transparency_log_config,
-        'manufacturer_key': self.manufacturer_key,
-        'process_count': 1,
-        'submission_count': 1,
-        'stats_filename': None,
-        'preserve_icp_images': False,
-        'timeout': None
-    }
-
-  def set_up_environment(self):
-    """Sets up member variables for the particular test environment.
-
-    This allows to have different settings and mocking for unit tests and
-    integration tests.
-    """
-    raise NotImplementedError('set_up_environment() needs to be implemented '
-                              'by subclass.')
-
-  def get_aftl_implementation(self, canned_response):
-    """Gets the aftltool.Aftl implementation used for testing.
-
-    This allows to have different Aftl implementations for unit tests and
-    integration tests.
-
-    Arguments:
-      canned_response: Since we are using the actual implementation and not a
-      mock this gets ignored.
-
-    Raises:
-      NotImplementedError if subclass is not implementing the method.
-    """
-    raise NotImplementedError('get_aftl_implementation() needs to be'
-                              'implemented by subclass.')
-
-
-class AftlTest(AftlTestCase):
-
-  def set_up_environment(self):
-    """Sets up the environment for unit testing without networking."""
-    self.aftl_host = 'test.foo.bar:9000'
-    self.aftl_pubkey = self.get_testdata_path('aftl_pubkey_1.pem')
-    self.vbmeta_image = self.get_testdata_path('aftl_input_vbmeta.img')
-    self.manufacturer_key = self.get_testdata_path('testkey_rsa4096.pem')
-
-  def get_aftl_implementation(self, canned_response):
-    """Retrieves the AftlMock for unit testing without networking."""
-    return AftlMock(canned_response)
-
-  def test_get_vbmeta_image(self):
-    """Tests the get_vbmeta_image method."""
-    tool = aftltool.Aftl()
-
-    # Valid vbmeta image without footer and AftlImage.
-    image, footer = tool.get_vbmeta_image(
-        self.get_testdata_path('aftl_input_vbmeta.img'))
-    self.assertIsNotNone(image)
-    self.assertEqual(len(image), 4352)
-    self.assertIsNone(footer)
-
-    # Valid vbmeta image without footer but with AftlImage.
-    image, footer = tool.get_vbmeta_image(
-        self.get_testdata_path('aftl_output_vbmeta_with_1_icp.img'))
-    self.assertIsNotNone(image)
-    self.assertEqual(len(image), 4352)
-    self.assertIsNone(footer)
-
-    # Invalid vbmeta image.
-    image, footer = tool.get_vbmeta_image(
-        self.get_testdata_path('large_blob.bin'))
-    self.assertIsNone(image)
-    self.assertIsNone(footer)
-
-    # Invalid file path.
-    image, footer = tool.get_vbmeta_image(
-        self.get_testdata_path('blabli_not_existing_file'))
-    self.assertIsNone(image)
-    self.assertIsNone(footer)
-
-  def test_get_aftl_image(self):
-    """Tests the get_aftl_image method."""
-    tool = aftltool.Aftl()
-
-    # Valid vbmeta image without footer with AftlImage.
-    desc = tool.get_aftl_image(
-        self.get_testdata_path('aftl_output_vbmeta_with_1_icp.img'))
-    self.assertIsInstance(desc, aftltool.AftlImage)
-
-    # Valid vbmeta image without footer and AftlImage.
-    desc = tool.get_aftl_image(
-        self.get_testdata_path('aftl_input_vbmeta.img'))
-    self.assertIsNone(desc)
-
-    # Invalid vbmeta image.
-    desc = tool.get_aftl_image(self.get_testdata_path('large_blob.bin'))
-    self.assertIsNone(desc)
-
-  # pylint: disable=no-member
-  def test_request_inclusion_proof(self):
-    """Tests the request_inclusion_proof method."""
-    # Always work with a mock independent if run as unit or integration tests.
-    aftl = AftlMock(self.test_avbm_resp)
-
-    icp = aftl.request_inclusion_proof(
-        self.transparency_log_config, b'a' * 1024, '1',
-        self.get_testdata_path('testkey_rsa4096.pem'), None, None, None)
-    self.assertEqual(icp.leaf_index,
-                     self.test_avbm_resp.annotation_proof.proof.leaf_index)
-    self.assertEqual(icp.proof_hash_count,
-                     len(self.test_avbm_resp.annotation_proof.proof.hashes))
-    self.assertEqual(icp.log_url, self.aftl_host)
-    self.assertEqual(
-        icp.log_root_descriptor.root_hash, binascii.unhexlify(
-            '9a5f71340f8dc98bdc6320f976dda5f34db8554cb273ba5ab60f1697c519d6f6'))
-
-    self.assertEqual(icp.annotation_leaf.annotation.version_incremental,
-                     'only_for_testing')
-    # To calculate the hash of the a RSA key use the following command:
-    # openssl rsa -in test/data/testkey_rsa4096.pem -pubout \
-    #    -outform DER | sha256sum
-    self.assertEqual(
-        icp.annotation_leaf.annotation.manufacturer_key_hash,
-        bytes.fromhex(
-            "83ab3b109b73a1d32dce4153a2de57a1a0485052db8364f3180d98614749d7f7"))
-
-    self.assertEqual(
-        icp.log_root_signature,
-        self.test_avbm_resp.annotation_proof.sth.log_root_signature)
-    self.assertEqual(
-        icp.proofs,
-        self.test_avbm_resp.annotation_proof.proof.hashes)
-
-  # pylint: disable=no-member
-  def test_request_inclusion_proof_failure(self):
-    """Tests the request_inclusion_proof method in case of a comms problem."""
-    # Always work with a mock independent if run as unit or integration tests.
-    aftl = AftlMock(aftltool.AftlError('Comms error'))
-
-    with self.assertRaises(aftltool.AftlError):
-      aftl.request_inclusion_proof(
-          self.transparency_log_config, b'a' * 1024, 'version_inc',
-          self.get_testdata_path('testkey_rsa4096.pem'), None, None, None)
-
-  def test_request_inclusion_proof_manuf_key_not_4096(self):
-    """Tests request_inclusion_proof with manufacturing key not of size 4096."""
-    # Always work with a mock independent if run as unit or integration tests.
-    aftl = AftlMock(self.test_avbm_resp)
-    with self.assertRaises(aftltool.AftlError) as e:
-      aftl.request_inclusion_proof(
-          self.transparency_log_config, b'a' * 1024, 'version_inc',
-          self.get_testdata_path('testkey_rsa2048.pem'), None, None, None)
-    self.assertIn('not of size 4096: 2048', str(e.exception))
-
-  def test_make_and_verify_icp_with_1_log(self):
-    """Tests make_icp_from_vbmeta, verify_image_icp & info_image_icp."""
-    aftl = self.get_aftl_implementation(self.test_avbm_resp)
-
-    # Make a VBmeta image with ICP.
-    with tempfile.NamedTemporaryFile('wb+') as output_file:
-      self.make_icp_default_params['output'] = output_file
-      result = aftl.make_icp_from_vbmeta(**self.make_icp_default_params)
-      output_file.flush()
-      self.assertTrue(result)
-
-      # Checks that there is 1 ICP.
-      aftl_image = aftl.get_aftl_image(output_file.name)
-      self.assertEqual(aftl_image.image_header.icp_count, 1)
-
-      # Verifies the generated image.
-      self.verify_icp_default_params['vbmeta_image_path'] = output_file.name
-      result = aftl.verify_image_icp(**self.verify_icp_default_params)
-      self.assertTrue(result)
-
-      # Prints the image details.
-      self.info_icp_default_params['vbmeta_image_path'] = output_file.name
-      result = aftl.info_image_icp(**self.info_icp_default_params)
-      self.assertTrue(result)
-
-  def test_make_and_verify_icp_with_2_logs(self):
-    """Tests make_icp_from_vbmeta, verify_image_icp & info_image_icp."""
-    aftl = self.get_aftl_implementation(self.test_avbm_resp)
-
-    # Reconfigures default parameters with two transparency logs.
-    self.make_icp_default_params['transparency_log_configs'] = [
-        self.transparency_log_config, self.transparency_log_config]
-
-    # Make a VBmeta image with ICP.
-    with tempfile.NamedTemporaryFile('wb+') as output_file:
-      self.make_icp_default_params['output'] = output_file
-      result = aftl.make_icp_from_vbmeta(
-          **self.make_icp_default_params)
-      output_file.flush()
-      self.assertTrue(result)
-
-      # Checks that there are 2 ICPs.
-      aftl_image = aftl.get_aftl_image(output_file.name)
-      self.assertEqual(aftl_image.image_header.icp_count, 2)
-
-      # Verifies the generated image.
-      self.verify_icp_default_params['vbmeta_image_path'] = output_file.name
-      result = aftl.verify_image_icp(**self.verify_icp_default_params)
-      self.assertTrue(result)
-
-      # Prints the image details.
-      self.info_icp_default_params['vbmeta_image_path'] = output_file.name
-      result = aftl.info_image_icp(**self.info_icp_default_params)
-      self.assertTrue(result)
-
-  def test_info_image_icp(self):
-    """Tests info_image_icp with vbmeta image with 2 ICP."""
-    # Always work with a mock independent if run as unit or integration tests.
-    aftl = AftlMock(self.test_avbm_resp)
-
-    image_path = self.get_testdata_path(
-        'aftl_output_vbmeta_with_2_icp_same_log.img')
-    self.info_icp_default_params['vbmeta_image_path'] = image_path
-
-    # Verifies the generated image.
-    result = aftl.info_image_icp(**self.info_icp_default_params)
-    self.assertTrue(result)
-
-  def test_info_image_icp_fail(self):
-    """Tests info_image_icp with invalid vbmeta image."""
-    # Always work with a mock independent if run as unit or integration tests.
-    aftl = AftlMock(self.test_avbm_resp)
-
-    image_path = self.get_testdata_path('large_blob.bin')
-    self.info_icp_default_params['vbmeta_image_path'] = image_path
-
-    # Verifies the generated image.
-    result = aftl.info_image_icp(**self.info_icp_default_params)
-    self.assertFalse(result)
-
-  def test_verify_image_icp(self):
-    """Tets verify_image_icp with 2 ICP with all matching log keys."""
-    # Always work with a mock independent if run as unit or integration tests.
-    aftl = AftlMock(self.test_avbm_resp)
-
-    image_path = self.get_testdata_path(
-        'aftl_output_vbmeta_with_2_icp_same_log.img')
-    self.verify_icp_default_params['vbmeta_image_path'] = image_path
-    self.verify_icp_default_params['transparency_log_pub_keys'] = [
-        self.get_testdata_path('aftl_pubkey_1.pem'),
-    ]
-
-    result = aftl.verify_image_icp(**self.verify_icp_default_params)
-    self.assertTrue(result)
-
-  def test_make_icp_with_invalid_grpc_service(self):
-    """Tests make_icp_from_vbmeta command with a host not supporting GRPC."""
-    aftl = self.get_aftl_implementation(aftltool.AftlError('Comms error'))
-    self.make_icp_default_params[
-        'transparency_log_configs'][0].target = 'www.google.com:80'
-    with tempfile.NamedTemporaryFile('wb+') as output_file:
-      self.make_icp_default_params['output'] = output_file
-      result = aftl.make_icp_from_vbmeta(
-          **self.make_icp_default_params)
-      self.assertFalse(result)
-
-  def test_make_icp_grpc_timeout(self):
-    """Tests make_icp_from_vbmeta command when running into GRPC timeout."""
-    aftl = self.get_aftl_implementation(aftltool.AftlError('Comms error'))
-
-    # The timeout is set to 1 second which is way below the minimum processing
-    # time of the transparency log per load test results in b/139407814#2 where
-    # it was 3.43 seconds.
-    self.make_icp_default_params['timeout'] = 1
-    with tempfile.NamedTemporaryFile('wb+') as output_file:
-      self.make_icp_default_params['output'] = output_file
-      result = aftl.make_icp_from_vbmeta(
-          **self.make_icp_default_params)
-      self.assertFalse(result)
-
-  def test_load_test_single_process_single_submission(self):
-    """Tests load_test_aftl command with 1 process which does 1 submission."""
-    aftl = self.get_aftl_implementation(self.test_avbm_resp)
-
-    with tempfile.TemporaryDirectory() as tmp_dir:
-      self.load_test_aftl_default_params[
-          'stats_filename'] = os.path.join(tmp_dir, 'load_test.csv')
-      result = aftl.load_test_aftl(**self.load_test_aftl_default_params)
-      self.assertTrue(result)
-
-      output = self.load_test_aftl_default_params['output'].getvalue()
-      self.assertRegex(output, 'Succeeded:.+?1\n')
-      self.assertRegex(output, 'Failed:.+?0\n')
-
-      self.assertTrue(os.path.exists(
-          self.load_test_aftl_default_params['stats_filename']))
-
-  def test_load_test_multi_process_multi_submission(self):
-    """Tests load_test_aftl command with 2 processes and 2 submissions each."""
-    aftl = self.get_aftl_implementation(self.test_avbm_resp)
-
-    self.load_test_aftl_default_params['process_count'] = 2
-    self.load_test_aftl_default_params['submission_count'] = 2
-    with tempfile.TemporaryDirectory() as tmp_dir:
-      self.load_test_aftl_default_params[
-          'stats_filename'] = os.path.join(tmp_dir, 'load_test.csv')
-      result = aftl.load_test_aftl(**self.load_test_aftl_default_params)
-      self.assertTrue(result)
-
-      output = self.load_test_aftl_default_params['output'].getvalue()
-      self.assertRegex(output, 'Succeeded:.+?4\n')
-      self.assertRegex(output, 'Failed:.+?0\n')
-
-      self.assertTrue(os.path.exists(
-          self.load_test_aftl_default_params['stats_filename']))
-
-  def test_load_test_invalid_grpc_service(self):
-    """Tests load_test_aftl command with a host that does not support GRPC."""
-    aftl = self.get_aftl_implementation(aftltool.AftlError('Comms error'))
-
-    self.load_test_aftl_default_params[
-        'transparency_log_config'].target = 'www.google.com:80'
-    result = aftl.load_test_aftl(**self.load_test_aftl_default_params)
-    self.assertFalse(result)
-
-    output = self.load_test_aftl_default_params['output'].getvalue()
-    self.assertRegex(output, 'Succeeded:.+?0\n')
-    self.assertRegex(output, 'Failed:.+?1\n')
-
-  def test_load_test_grpc_timeout(self):
-    """Tests load_test_aftl command when running into timeout."""
-    aftl = self.get_aftl_implementation(aftltool.AftlError('Comms error'))
-
-    self.load_test_aftl_default_params['timeout'] = 1
-    result = aftl.load_test_aftl(**self.load_test_aftl_default_params)
-    self.assertFalse(result)
-
-    output = self.load_test_aftl_default_params['output'].getvalue()
-    self.assertRegex(output, 'Succeeded:.+?0\n')
-    self.assertRegex(output, 'Failed:.+?1\n')
-
-
-class TransparencyLogConfigTestCase(unittest.TestCase):
-
-  def test_from_argument(self):
-    log = aftltool.TransparencyLogConfig.from_argument(
-        "example.com:8080,mykey.pub")
-    self.assertEqual(log.target, "example.com:8080")
-    self.assertEqual(log.pub_key, "mykey.pub")
-
-    with self.assertRaises(argparse.ArgumentTypeError):
-      aftltool.TransparencyLogConfig.from_argument("example.com:8080,")
-
-    with self.assertRaises(argparse.ArgumentTypeError):
-      aftltool.TransparencyLogConfig.from_argument(",")
-
-  def test_from_argument_with_api_key(self):
-    log = aftltool.TransparencyLogConfig.from_argument(
-        "example.com:8080,mykey.pub,Aipl29gj3x9")
-    self.assertEqual(log.target, "example.com:8080")
-    self.assertEqual(log.pub_key, "mykey.pub")
-    self.assertEqual(log.api_key, "Aipl29gj3x9")
-
-if __name__ == '__main__':
-  unittest.main(verbosity=2)
diff --git a/avbtool.py b/avbtool.py
index 8647b29..3967651 100755
--- a/avbtool.py
+++ b/avbtool.py
@@ -342,6 +342,7 @@
     exponent: The key exponent.
     modulus: The key modulus.
     num_bits: The key size.
+    key_path: The path to a key file.
   """
 
   MODULUS_PREFIX = b'modulus='
@@ -900,7 +901,7 @@
     Arguments:
       num_bytes: Size in number of bytes of the DONT_CARE chunk.
 
-    Raises
+    Raises:
       OSError: If ImageHandler was initialized in read-only mode.
     """
     assert num_bytes % self.block_size == 0
@@ -937,7 +938,7 @@
     Arguments:
       data: Data to append as bytes.
 
-    Raises
+    Raises:
       OSError: If ImageHandler was initialized in read-only mode.
     """
     assert len(data) % self.block_size == 0
@@ -974,7 +975,7 @@
       fill_data: Fill data to append - must be four bytes.
       size: Number of chunk - must be a multiple of four and the block size.
 
-    Raises
+    Raises:
       OSError: If ImageHandler was initialized in read-only mode.
     """
     assert len(fill_data) == 4
@@ -1259,7 +1260,7 @@
     Raises:
       LookupError: If the given descriptor is malformed.
     """
-    super(AvbPropertyDescriptor, self).__init__(None)
+    super().__init__(None)
     assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
 
     if data:
@@ -1273,7 +1274,8 @@
       try:
         self.key = data[self.SIZE:(self.SIZE + key_size)].decode('utf-8')
       except UnicodeDecodeError as e:
-        raise LookupError('Key cannot be decoded as UTF-8: {}.'.format(e))
+        raise LookupError('Key cannot be decoded as UTF-8: {}.'
+                          .format(e)) from e
       self.value = data[(self.SIZE + key_size + 1):(self.SIZE + key_size + 1 +
                                                     value_size)]
     else:
@@ -1377,6 +1379,9 @@
                    'L' +  # flags
                    str(RESERVED) + 's')  # reserved
 
+  FLAGS_DO_NOT_USE_AB = (1 << 0)
+  FLAGS_CHECK_AT_MOST_ONCE = (1 << 1)
+
   def __init__(self, data=None):
     """Initializes a new hashtree descriptor.
 
@@ -1386,7 +1391,7 @@
     Raises:
       LookupError: If the given descriptor is malformed.
     """
-    super(AvbHashtreeDescriptor, self).__init__(None)
+    super().__init__(None)
     assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
 
     if data:
@@ -1410,7 +1415,7 @@
         ].decode('utf-8')
       except UnicodeDecodeError as e:
         raise LookupError('Partition name cannot be decoded as UTF-8: {}.'
-                          .format(e))
+                          .format(e)) from e
       o += partition_name_len
       self.salt = data[(self.SIZE + o):(self.SIZE + o + salt_len)]
       o += salt_len
@@ -1582,7 +1587,7 @@
     Raises:
       LookupError: If the given descriptor is malformed.
     """
-    super(AvbHashDescriptor, self).__init__(None)
+    super().__init__(None)
     assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
 
     if data:
@@ -1603,7 +1608,7 @@
         ].decode('utf-8')
       except UnicodeDecodeError as e:
         raise LookupError('Partition name cannot be decoded as UTF-8: {}.'
-                          .format(e))
+                          .format(e)) from e
       o += partition_name_len
       self.salt = data[(self.SIZE + o):(self.SIZE + o + salt_len)]
       o += salt_len
@@ -1720,7 +1725,7 @@
     Raises:
       LookupError: If the given descriptor is malformed.
     """
-    super(AvbKernelCmdlineDescriptor, self).__init__(None)
+    super().__init__(None)
     assert struct.calcsize(self.FORMAT_STRING) == self.SIZE
 
     if data:
@@ -1737,7 +1742,7 @@
             self.SIZE:(self.SIZE + kernel_cmdline_length)].decode('utf-8')
       except UnicodeDecodeError as e:
         raise LookupError('Kernel command-line cannot be decoded as UTF-8: {}.'
-                          .format(e))
+                          .format(e)) from e
     else:
       self.flags = 0
       self.kernel_cmdline = ''
@@ -1835,7 +1840,7 @@
         ].decode('utf-8')
       except UnicodeDecodeError as e:
         raise LookupError('Partition name cannot be decoded as UTF-8: {}.'
-                          .format(e))
+                          .format(e)) from e
       o += partition_name_len
       self.public_key = data[(self.SIZE + o):(self.SIZE + o + public_key_len)]
 
@@ -2468,8 +2473,8 @@
       o.write('    Metadata version:        {}\n'.format(version))
 
       def print_atx_certificate(cert):
-        version, public_key, subject, usage, key_version, _signature = \
-            struct.unpack('<I1032s32s32sQ512s', cert)
+        version, public_key, subject, usage, key_version, _ = (
+            struct.unpack('<I1032s32s32sQ512s', cert))
         o.write('      Version:               {}\n'.format(version))
         o.write('      Public key (sha1):     {}\n'.format(
             hashlib.sha1(public_key).hexdigest()))
@@ -2832,7 +2837,11 @@
     c += ' {}'.format(ht.root_digest.hex())                 # root_digest
     c += ' {}'.format(ht.salt.hex())                        # salt
     if ht.fec_num_roots > 0:
-      c += ' 10'  # number of optional args
+      if ht.flags & AvbHashtreeDescriptor.FLAGS_CHECK_AT_MOST_ONCE:
+        c += ' 11'  # number of optional args
+        c += ' check_at_most_once'
+      else:
+        c += ' 10'  # number of optional args
       c += ' $(ANDROID_VERITY_MODE)'
       c += ' ignore_zero_blocks'
       c += ' use_fec_from_device PARTUUID=$(ANDROID_SYSTEM_PARTUUID)'
@@ -2843,7 +2852,11 @@
       c += ' fec_blocks {}'.format(ht.fec_offset // ht.data_block_size)
       c += ' fec_start {}'.format(ht.fec_offset // ht.data_block_size)
     else:
-      c += ' 2'  # number of optional args
+      if ht.flags & AvbHashtreeDescriptor.FLAGS_CHECK_AT_MOST_ONCE:
+        c += ' 3'  # number of optional args
+        c += ' check_at_most_once'
+      else:
+        c += ' 2'  # number of optional args
       c += ' $(ANDROID_VERITY_MODE)'
       c += ' ignore_zero_blocks'
     c += '" root=/dev/dm-0'
@@ -3025,8 +3038,9 @@
     """
     try:
       alg = ALGORITHMS[algorithm_name]
-    except KeyError:
-      raise AvbError('Unknown algorithm with name {}'.format(algorithm_name))
+    except KeyError as e:
+      raise AvbError('Unknown algorithm with name {}'
+                     .format(algorithm_name)) from e
 
     if not descriptors:
       descriptors = []
@@ -3313,7 +3327,7 @@
     except Exception as e:
       # Truncate back to original size, then re-raise.
       image.truncate(original_image_size)
-      raise AvbError('Appending VBMeta image failed: {}.'.format(e))
+      raise AvbError('Appending VBMeta image failed: {}.'.format(e)) from e
 
   def add_hash_footer(self, image_filename, partition_size, partition_name,
                       hash_algorithm, salt, chain_partitions, algorithm_name,
@@ -3514,7 +3528,7 @@
     except Exception as e:
       # Truncate back to original size, then re-raise.
       image.truncate(original_image_size)
-      raise AvbError('Adding hash_footer failed: {}.'.format(e))
+      raise AvbError('Adding hash_footer failed: {}.'.format(e)) from e
 
   def add_hashtree_footer(self, image_filename, partition_size, partition_name,
                           generate_fec, fec_num_roots, hash_algorithm,
@@ -3532,7 +3546,7 @@
                           output_vbmeta_image, do_not_append_vbmeta_image,
                           print_required_libavb_version,
                           use_persistent_root_digest, do_not_use_ab,
-                          no_hashtree):
+                          no_hashtree, check_at_most_once):
     """Implements the 'add_hashtree_footer' command.
 
     See https://gitlab.com/cryptsetup/cryptsetup/wikis/DMVerity for
@@ -3576,13 +3590,15 @@
       use_persistent_root_digest: Use a persistent root digest on device.
       do_not_use_ab: The partition does not use A/B.
       no_hashtree: Do not append hashtree. Set size in descriptor as zero.
+      check_at_most_once: Set to verify data blocks only the first time they
+        are read from the data device.
 
     Raises:
       AvbError: If an argument is incorrect or adding the hashtree footer
           failed.
     """
     required_libavb_version_minor = 0
-    if use_persistent_root_digest or do_not_use_ab:
+    if use_persistent_root_digest or do_not_use_ab or check_at_most_once:
       required_libavb_version_minor = 1
     if rollback_index_location > 0:
       required_libavb_version_minor = 2
@@ -3713,9 +3729,11 @@
       ht_desc.partition_name = partition_name
       ht_desc.salt = salt
       if do_not_use_ab:
-        ht_desc.flags |= 1  # AVB_HASHTREE_DESCRIPTOR_FLAGS_DO_NOT_USE_AB
+        ht_desc.flags |= AvbHashtreeDescriptor.FLAGS_DO_NOT_USE_AB
       if not use_persistent_root_digest:
         ht_desc.root_digest = root_digest
+      if check_at_most_once:
+        ht_desc.flags |= AvbHashtreeDescriptor.FLAGS_CHECK_AT_MOST_ONCE
 
       # Write the hash tree
       padding_needed = (round_to_multiple(len(hash_tree), image.block_size) -
@@ -3788,7 +3806,7 @@
     except Exception as e:
       # Truncate back to original size, then re-raise.
       image.truncate(original_image_size)
-      raise AvbError('Adding hashtree_footer failed: {}.'.format(e))
+      raise AvbError('Adding hashtree_footer failed: {}.'.format(e)) from e
 
   def make_atx_certificate(self, output, authority_key_path, subject_key_path,
                            subject_key_version, subject,
@@ -4040,7 +4058,8 @@
            fec_tmpfile.name],
           stderr=open(os.devnull, 'wb'))
     except subprocess.CalledProcessError as e:
-      raise ValueError('Execution of \'fec\' tool failed: {}.'.format(e))
+      raise ValueError('Execution of \'fec\' tool failed: {}.'
+                       .format(e)) from e
     fec_data = fec_tmpfile.read()
 
   footer_size = struct.calcsize(FEC_FOOTER_FORMAT)
@@ -4404,6 +4423,9 @@
     sub_parser.add_argument('--no_hashtree',
                             action='store_true',
                             help='Do not append hashtree')
+    sub_parser.add_argument('--check_at_most_once',
+                            action='store_true',
+                            help='Set to verify data block only once')
     self._add_common_args(sub_parser)
     self._add_common_footer_args(sub_parser)
     sub_parser.set_defaults(func=self.add_hashtree_footer)
@@ -4784,7 +4806,8 @@
         args.print_required_libavb_version,
         args.use_persistent_digest,
         args.do_not_use_ab,
-        args.no_hashtree)
+        args.no_hashtree,
+        args.check_at_most_once)
 
   def erase_footer(self, args):
     """Implements the 'erase_footer' sub-command."""
diff --git a/docs/aftl-architecture.png b/docs/aftl-architecture.png
deleted file mode 100644
index 5526f92..0000000
--- a/docs/aftl-architecture.png
+++ /dev/null
Binary files differ
diff --git a/docs/aftl-boot-flow.png b/docs/aftl-boot-flow.png
deleted file mode 100644
index f724808..0000000
--- a/docs/aftl-boot-flow.png
+++ /dev/null
Binary files differ
diff --git a/docs/aftl-image-location.png b/docs/aftl-image-location.png
deleted file mode 100644
index 0e609d7..0000000
--- a/docs/aftl-image-location.png
+++ /dev/null
Binary files differ
diff --git a/docs/aftl-image-structure.png b/docs/aftl-image-structure.png
deleted file mode 100644
index 2487314..0000000
--- a/docs/aftl-image-structure.png
+++ /dev/null
Binary files differ
diff --git a/libavb/avb_cmdline.c b/libavb/avb_cmdline.c
index 5773a20..6613020 100644
--- a/libavb/avb_cmdline.c
+++ b/libavb/avb_cmdline.c
@@ -353,6 +353,10 @@
         // remapped by avb_manage_hashtree_error_mode().
         avb_assert_not_reached();
         break;
+      case AVB_HASHTREE_ERROR_MODE_PANIC:
+        verity_mode = "panicking";
+        dm_verity_mode = "panic_on_corruption";
+        break;
     }
     new_ret = avb_replace(
         slot_data->cmdline, "$(ANDROID_VERITY_MODE)", dm_verity_mode);
diff --git a/libavb/avb_hashtree_descriptor.h b/libavb/avb_hashtree_descriptor.h
index d0f7e2c..6595f46 100644
--- a/libavb/avb_hashtree_descriptor.h
+++ b/libavb/avb_hashtree_descriptor.h
@@ -40,9 +40,12 @@
  * AVB_HASHTREE_DESCRIPTOR_FLAGS_DO_NOT_USE_AB: Do not apply the default A/B
  *   partition logic to this partition. This is intentionally a negative boolean
  *   because A/B should be both the default and most used in practice.
+ * AVB_HASHTREE_DESCRIPTOR_FLAGS_CHECK_AT_MOST_ONCE: supports to validate hashes
+ *   at most once in DM-Verity.
  */
 typedef enum {
   AVB_HASHTREE_DESCRIPTOR_FLAGS_DO_NOT_USE_AB = (1 << 0),
+  AVB_HASHTREE_DESCRIPTOR_FLAGS_CHECK_AT_MOST_ONCE = (1 << 1),
 } AvbHashtreeDescriptorFlags;
 
 /* A descriptor containing information about a dm-verity hashtree.
diff --git a/libavb/avb_sha.h b/libavb/avb_sha.h
index 82ac9a5..f4c42ea 100644
--- a/libavb/avb_sha.h
+++ b/libavb/avb_sha.h
@@ -40,28 +40,28 @@
 #include "avb_crypto.h"
 #include "avb_sysdeps.h"
 
-/* Block size in bytes of a SHA-256 digest. */
-#define AVB_SHA256_BLOCK_SIZE 64
-
-
-/* Block size in bytes of a SHA-512 digest. */
-#define AVB_SHA512_BLOCK_SIZE 128
+/* The following defines must be set to something appropriate
+ *
+ *   AVB_SHA256_CONTEXT_SIZE - the size of AvbSHA256Ctx, excluding the buffer
+ *   AVB_SHA512_CONTEXT_SIZE - the size of AvbSHA512Ctx, exclusing the buffer
+ *
+ * For example, if AvbSHA512Ctx is implemented using BoringSSL this would be
+ * defined as sizeof(SHA256_CTX).
+ *
+ * We expect the implementation to provide a header file with the name
+ * avb_crypto_ops_impl.h to do all this.
+ */
+#include "avb_crypto_ops_impl.h"
 
 /* Data structure used for SHA-256. */
 typedef struct {
-  uint32_t h[8];
-  uint64_t tot_len;
-  size_t len;
-  uint8_t block[2 * AVB_SHA256_BLOCK_SIZE];
+  uint8_t reserved[AVB_SHA256_CONTEXT_SIZE];
   uint8_t buf[AVB_SHA256_DIGEST_SIZE]; /* Used for storing the final digest. */
 } AvbSHA256Ctx;
 
 /* Data structure used for SHA-512. */
 typedef struct {
-  uint64_t h[8];
-  uint64_t tot_len;
-  size_t len;
-  uint8_t block[2 * AVB_SHA512_BLOCK_SIZE];
+  uint8_t reserved[AVB_SHA512_CONTEXT_SIZE];
   uint8_t buf[AVB_SHA512_DIGEST_SIZE]; /* Used for storing the final digest. */
 } AvbSHA512Ctx;
 
diff --git a/libavb/avb_slot_verify.c b/libavb/avb_slot_verify.c
index 6a2745a..8e0721d 100644
--- a/libavb/avb_slot_verify.c
+++ b/libavb/avb_slot_verify.c
@@ -468,6 +468,7 @@
     loaded_partition->data_size = image_size;
     loaded_partition->data = image_buf;
     loaded_partition->preloaded = image_preloaded;
+    loaded_partition->verify_result = ret;
     image_buf = NULL;
   }
 
@@ -1706,7 +1707,7 @@
   return ret;
 }
 
-void avb_slot_verify_data_calculate_vbmeta_digest(AvbSlotVerifyData* data,
+void avb_slot_verify_data_calculate_vbmeta_digest(const AvbSlotVerifyData* data,
                                                   AvbDigestType digest_type,
                                                   uint8_t* out_digest) {
   bool ret = false;
diff --git a/libavb/avb_slot_verify.h b/libavb/avb_slot_verify.h
index a2c98f4..c7f3f45 100644
--- a/libavb/avb_slot_verify.h
+++ b/libavb/avb_slot_verify.h
@@ -88,7 +88,8 @@
   AVB_HASHTREE_ERROR_MODE_RESTART,
   AVB_HASHTREE_ERROR_MODE_EIO,
   AVB_HASHTREE_ERROR_MODE_LOGGING,
-  AVB_HASHTREE_ERROR_MODE_MANAGED_RESTART_AND_EIO
+  AVB_HASHTREE_ERROR_MODE_MANAGED_RESTART_AND_EIO,
+  AVB_HASHTREE_ERROR_MODE_PANIC
 } AvbHashtreeErrorMode;
 
 /* Flags that influence how avb_slot_verify() works.
@@ -157,6 +158,7 @@
   uint8_t* data;
   size_t data_size;
   bool preloaded;
+  AvbSlotVerifyResult verify_result;
 } AvbPartitionData;
 
 /* AvbVBMetaData contains a vbmeta struct loaded from a partition when
@@ -310,7 +312,7 @@
  * in |out_digest| which must be large enough to hold a digest
  * of the requested type.
  */
-void avb_slot_verify_data_calculate_vbmeta_digest(AvbSlotVerifyData* data,
+void avb_slot_verify_data_calculate_vbmeta_digest(const AvbSlotVerifyData* data,
                                                   AvbDigestType digest_type,
                                                   uint8_t* out_digest);
 
diff --git a/libavb_aftl/avb_ops_aftl.h b/libavb/boringssl/avb_crypto_ops_impl.h
similarity index 66%
rename from libavb_aftl/avb_ops_aftl.h
rename to libavb/boringssl/avb_crypto_ops_impl.h
index a2f5577..abfbcad 100644
--- a/libavb_aftl/avb_ops_aftl.h
+++ b/libavb/boringssl/avb_crypto_ops_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 The Android Open Source Project
+ * Copyright (C) 2021 The Android Open Source Project
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
@@ -22,31 +22,29 @@
  * SOFTWARE.
  */
 
-#if !defined(AVB_INSIDE_LIBAVB_AFTL_H) && !defined(AVB_COMPILATION)
-#error "Never include this file directly, include libavb_aftl/libavb_aftl.h."
+#ifdef AVB_INSIDE_LIBAVB_H
+#error "You can't include avb_crypto_ops_impl.h in the public header libavb.h."
 #endif
 
-#ifndef AVB_AFTL_OPS_H_
-#define AVB_AFTL_OPS_H_
+#ifndef AVB_COMPILATION
+#error "Never include this file, it may only be used from internal avb code."
+#endif
 
-#include <libavb/libavb.h>
+#ifndef AVB_CRYPTO_OPS_IMPL_H_
+#define AVB_CRYPTO_OPS_IMPL_H_
+
+#include <openssl/is_boringssl.h>
+#include <openssl/sha.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct AvbAftlOps;
-typedef struct AvbAftlOps AvbAftlOps;
-
-/* An extension to AvbOps required by the new AFTL validation flow.
-   TODO(danielaustin): update the AFTL readme link once it is submitted.  */
-struct AvbAftlOps {
-  /* Operations from libavb. */
-  AvbOps* ops;
-};
+#define AVB_SHA256_CONTEXT_SIZE sizeof(SHA256_CTX)
+#define AVB_SHA512_CONTEXT_SIZE sizeof(SHA512_CTX)
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* AVB_AFTL_OPS_H_ */
+#endif /* AVB_CRYPTO_OPS_IMPL_H_ */
diff --git a/libavb/boringssl/sha.c b/libavb/boringssl/sha.c
new file mode 100644
index 0000000..96973ec
--- /dev/null
+++ b/libavb/boringssl/sha.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <libavb/avb_sha.h>
+
+#include "avb_crypto_ops_impl.h"
+
+/* SHA-256 implementation */
+void avb_sha256_init(AvbSHA256Ctx* ctx) {
+  SHA256_CTX* realCtx = (SHA256_CTX*)ctx->reserved;
+  SHA256_Init(realCtx);
+}
+
+void avb_sha256_update(AvbSHA256Ctx* ctx, const uint8_t* data, size_t len) {
+  SHA256_CTX* realCtx = (SHA256_CTX*)ctx->reserved;
+  SHA256_Update(realCtx, data, len);
+}
+
+uint8_t* avb_sha256_final(AvbSHA256Ctx* ctx) {
+  SHA256_CTX* realCtx = (SHA256_CTX*)ctx->reserved;
+  SHA256_Final(ctx->buf, realCtx);
+  return ctx->buf;
+}
+
+/* SHA-512 implementation */
+void avb_sha512_init(AvbSHA512Ctx* ctx) {
+  SHA512_CTX* realCtx = (SHA512_CTX*)ctx->reserved;
+  SHA512_Init(realCtx);
+}
+
+void avb_sha512_update(AvbSHA512Ctx* ctx, const uint8_t* data, size_t len) {
+  SHA512_CTX* realCtx = (SHA512_CTX*)ctx->reserved;
+  SHA512_Update(realCtx, data, len);
+}
+
+uint8_t* avb_sha512_final(AvbSHA512Ctx* ctx) {
+  SHA512_CTX* realCtx = (SHA512_CTX*)ctx->reserved;
+  SHA512_Final(ctx->buf, realCtx);
+  return ctx->buf;
+}
diff --git a/libavb/sha/avb_crypto_ops_impl.h b/libavb/sha/avb_crypto_ops_impl.h
new file mode 100644
index 0000000..321e0fb
--- /dev/null
+++ b/libavb/sha/avb_crypto_ops_impl.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifdef AVB_INSIDE_LIBAVB_H
+#error "You can't include avb_crypto_ops_impl.h in the public header libavb.h."
+#endif
+
+#ifndef AVB_COMPILATION
+#error "Never include this file, it may only be used from internal avb code."
+#endif
+
+#ifndef AVB_CRYPTO_OPS_IMPL_H_
+#define AVB_CRYPTO_OPS_IMPL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libavb/avb_sysdeps.h>
+
+/* Block size in bytes of a SHA-256 digest. */
+#define AVB_SHA256_BLOCK_SIZE 64
+
+/* Block size in bytes of a SHA-512 digest. */
+#define AVB_SHA512_BLOCK_SIZE 128
+
+/* Data structure used for SHA-256. */
+typedef struct {
+  uint32_t h[8];
+  uint64_t tot_len;
+  size_t len;
+  uint8_t block[2 * AVB_SHA256_BLOCK_SIZE];
+} AvbSHA256ImplCtx;
+
+/* Data structure used for SHA-512. */
+typedef struct {
+  uint64_t h[8];
+  uint64_t tot_len;
+  size_t len;
+  uint8_t block[2 * AVB_SHA512_BLOCK_SIZE];
+} AvbSHA512ImplCtx;
+
+#define AVB_SHA256_CONTEXT_SIZE sizeof(AvbSHA256ImplCtx)
+#define AVB_SHA512_CONTEXT_SIZE sizeof(AvbSHA512ImplCtx)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AVB_CRYPTO_OPS_IMPL_H_ */
diff --git a/libavb/avb_sha256.c b/libavb/sha/sha256_impl.c
similarity index 92%
rename from libavb/avb_sha256.c
rename to libavb/sha/sha256_impl.c
index 8a1c3ae..7e99358 100644
--- a/libavb/avb_sha256.c
+++ b/libavb/sha/sha256_impl.c
@@ -35,7 +35,9 @@
  * SUCH DAMAGE.
  */
 
-#include "avb_sha.h"
+#include <libavb/avb_sha.h>
+
+#include "avb_crypto_ops_impl.h"
 
 #define SHFR(x, n) (x >> n)
 #define ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))
@@ -112,7 +114,8 @@
     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
 
 /* SHA-256 implementation */
-void avb_sha256_init(AvbSHA256Ctx* ctx) {
+void avb_sha256_init(AvbSHA256Ctx* avb_ctx) {
+  AvbSHA256ImplCtx* ctx = (AvbSHA256ImplCtx*)avb_ctx->reserved;
 #ifndef UNROLL_LOOPS
   int i;
   for (i = 0; i < 8; i++) {
@@ -133,7 +136,7 @@
   ctx->tot_len = 0;
 }
 
-static void SHA256_transform(AvbSHA256Ctx* ctx,
+static void SHA256_transform(AvbSHA256ImplCtx* ctx,
                              const uint8_t* message,
                              size_t block_nb) {
   uint32_t w[64];
@@ -332,7 +335,8 @@
   }
 }
 
-void avb_sha256_update(AvbSHA256Ctx* ctx, const uint8_t* data, size_t len) {
+void avb_sha256_update(AvbSHA256Ctx* avb_ctx, const uint8_t* data, size_t len) {
+  AvbSHA256ImplCtx* ctx = (AvbSHA256ImplCtx*)avb_ctx->reserved;
   size_t block_nb;
   size_t new_len, rem_len, tmp_len;
   const uint8_t* shifted_data;
@@ -363,7 +367,8 @@
   ctx->tot_len += (block_nb + 1) << 6;
 }
 
-uint8_t* avb_sha256_final(AvbSHA256Ctx* ctx) {
+uint8_t* avb_sha256_final(AvbSHA256Ctx* avb_ctx) {
+  AvbSHA256ImplCtx* ctx = (AvbSHA256ImplCtx*)avb_ctx->reserved;
   size_t block_nb;
   size_t pm_len;
   uint64_t len_b;
@@ -385,18 +390,18 @@
 
 #ifndef UNROLL_LOOPS
   for (i = 0; i < 8; i++) {
-    UNPACK32(ctx->h[i], &ctx->buf[i << 2]);
+    UNPACK32(ctx->h[i], &avb_ctx->buf[i << 2]);
   }
 #else
-  UNPACK32(ctx->h[0], &ctx->buf[0]);
-  UNPACK32(ctx->h[1], &ctx->buf[4]);
-  UNPACK32(ctx->h[2], &ctx->buf[8]);
-  UNPACK32(ctx->h[3], &ctx->buf[12]);
-  UNPACK32(ctx->h[4], &ctx->buf[16]);
-  UNPACK32(ctx->h[5], &ctx->buf[20]);
-  UNPACK32(ctx->h[6], &ctx->buf[24]);
-  UNPACK32(ctx->h[7], &ctx->buf[28]);
+  UNPACK32(ctx->h[0], &avb_ctx->buf[0]);
+  UNPACK32(ctx->h[1], &avb_ctx->buf[4]);
+  UNPACK32(ctx->h[2], &avb_ctx->buf[8]);
+  UNPACK32(ctx->h[3], &avb_ctx->buf[12]);
+  UNPACK32(ctx->h[4], &avb_ctx->buf[16]);
+  UNPACK32(ctx->h[5], &avb_ctx->buf[20]);
+  UNPACK32(ctx->h[6], &avb_ctx->buf[24]);
+  UNPACK32(ctx->h[7], &avb_ctx->buf[28]);
 #endif /* !UNROLL_LOOPS */
 
-  return ctx->buf;
+  return avb_ctx->buf;
 }
diff --git a/libavb/avb_sha512.c b/libavb/sha/sha512_impl.c
similarity index 92%
rename from libavb/avb_sha512.c
rename to libavb/sha/sha512_impl.c
index 6cdc494..1eb9ba4 100644
--- a/libavb/avb_sha512.c
+++ b/libavb/sha/sha512_impl.c
@@ -35,7 +35,9 @@
  * SUCH DAMAGE.
  */
 
-#include "avb_sha.h"
+#include <libavb/avb_sha.h>
+
+#include "avb_crypto_ops_impl.h"
 
 #define SHFR(x, n) (x >> n)
 #define ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))
@@ -131,7 +133,8 @@
 
 /* SHA-512 implementation */
 
-void avb_sha512_init(AvbSHA512Ctx* ctx) {
+void avb_sha512_init(AvbSHA512Ctx* avb_ctx) {
+  AvbSHA512ImplCtx* ctx = (AvbSHA512ImplCtx*)avb_ctx->reserved;
 #ifdef UNROLL_LOOPS_SHA512
   ctx->h[0] = sha512_h0[0];
   ctx->h[1] = sha512_h0[1];
@@ -152,7 +155,7 @@
   ctx->tot_len = 0;
 }
 
-static void SHA512_transform(AvbSHA512Ctx* ctx,
+static void SHA512_transform(AvbSHA512ImplCtx* ctx,
                              const uint8_t* message,
                              size_t block_nb) {
   uint64_t w[80];
@@ -318,7 +321,8 @@
   }
 }
 
-void avb_sha512_update(AvbSHA512Ctx* ctx, const uint8_t* data, size_t len) {
+void avb_sha512_update(AvbSHA512Ctx* avb_ctx, const uint8_t* data, size_t len) {
+  AvbSHA512ImplCtx* ctx = (AvbSHA512ImplCtx*)avb_ctx->reserved;
   size_t block_nb;
   size_t new_len, rem_len, tmp_len;
   const uint8_t* shifted_data;
@@ -349,7 +353,8 @@
   ctx->tot_len += (block_nb + 1) << 7;
 }
 
-uint8_t* avb_sha512_final(AvbSHA512Ctx* ctx) {
+uint8_t* avb_sha512_final(AvbSHA512Ctx* avb_ctx) {
+  AvbSHA512ImplCtx* ctx = (AvbSHA512ImplCtx*)avb_ctx->reserved;
   size_t block_nb;
   size_t pm_len;
   uint64_t len_b;
@@ -371,18 +376,18 @@
   SHA512_transform(ctx, ctx->block, block_nb);
 
 #ifdef UNROLL_LOOPS_SHA512
-  UNPACK64(ctx->h[0], &ctx->buf[0]);
-  UNPACK64(ctx->h[1], &ctx->buf[8]);
-  UNPACK64(ctx->h[2], &ctx->buf[16]);
-  UNPACK64(ctx->h[3], &ctx->buf[24]);
-  UNPACK64(ctx->h[4], &ctx->buf[32]);
-  UNPACK64(ctx->h[5], &ctx->buf[40]);
-  UNPACK64(ctx->h[6], &ctx->buf[48]);
-  UNPACK64(ctx->h[7], &ctx->buf[56]);
+  UNPACK64(ctx->h[0], &avb_ctx->buf[0]);
+  UNPACK64(ctx->h[1], &avb_ctx->buf[8]);
+  UNPACK64(ctx->h[2], &avb_ctx->buf[16]);
+  UNPACK64(ctx->h[3], &avb_ctx->buf[24]);
+  UNPACK64(ctx->h[4], &avb_ctx->buf[32]);
+  UNPACK64(ctx->h[5], &avb_ctx->buf[40]);
+  UNPACK64(ctx->h[6], &avb_ctx->buf[48]);
+  UNPACK64(ctx->h[7], &avb_ctx->buf[56]);
 #else
   for (i = 0; i < 8; i++)
-    UNPACK64(ctx->h[i], &ctx->buf[i << 3]);
+    UNPACK64(ctx->h[i], &avb_ctx->buf[i << 3]);
 #endif /* UNROLL_LOOPS_SHA512 */
 
-  return ctx->buf;
+  return avb_ctx->buf;
 }
diff --git a/libavb_aftl/README.md b/libavb_aftl/README.md
deleted file mode 100644
index abf2636..0000000
--- a/libavb_aftl/README.md
+++ /dev/null
@@ -1,305 +0,0 @@
-# Android Firmware Transparency Log 1.0
----
-
-This repository contains tools and libraries for working with the Android
-Firmware Transparency Log components of Android Verified Boot. AFTL will be
-used to refer to these components.
-
-[TOC]
-
-# What is it?
-
-The Android Firmware Transparency Log (AFTL) is an implementation of binary
-transparency that leverages cryptographic proofs of inclusion of build images
-using a public append-only ledger. The device manufacturer stores these
-cryptographic proofs, called inclusion proofs, on-device to allow for offline
-validation of the build during system update and device boot. This ensures that
-only a publicly known build is running on the device. Furthermore, it allows
-device manufacturers and other interested parties to audit the information in
-the log to detect unexpected or malicious uses of the publisher's signing keys.
-
-
-## System overview
-
-An AFTL can be implemented using a
-[Trillian](https://github.com/google/trillian) instance which manages a Merkle
-tree with build metadata (particularly the [VBMeta
-struct](https://android.googlesource.com/platform/external/avb/+/refs/heads/master#The-VBMeta-struct))
-and keeps a repository of other data that were made transparent.
-
-![Android Firmware Transparency Log system overview](../docs/aftl-architecture.png)
-
-As part of the finalizing step in the build process the `aftltool` reaches out
-to the **AFTL personality** to submit a manufacturer-signed message (containing
-VBMeta struct and other metadata) to the AFTL. Then the AFTL personality
-submits that data to Trillian to incorporate it into the Merkle tree. After
-integration into the log, the AFTL personality returns the inclusion proof back
-to the `aftltool`, which in turn incorporates the inclusion proof with the
-VBMeta image.
-
-The AFTL uses two sets of keys for authentication and validation, the
-transparency log key and the manufacturer key.
-
-* **Transparency log key:** Used by Trillian to sign inclusion proofs. The
-  public key is embedded with the device for on-device for validation.
-* **Manufacturer key:** Used by OEMs or other build providers to sign
-  submissions sent to the log. This ensures that malicious entries posing as a
-  valid OEM entry cannot be provided to the log. For the log to authenticate
-  messages, the manufacturer key must be shared out-of-band with the AFTL prior
-  to submission.
-
-## The AftlImage struct
-
-The central data structure used for AFTL validation is the `AftlImage` struct.
-The structure is saved on the vbmeta partition, right after the
-`AvbVBMetaImage` struct, as illustrated below.
-
-![Overview of the AftlImage structure](../docs/aftl-image-location.png)
-
-This structure contains the `AftlImageHeader` header that describes the number
-of inclusion proofs (`AftlIcpEntry`) represented by this structure. Each
-inclusion proof has associated metadata, such as the transparency log URL. A
-high-level description of the structures is given below. See
-[aftltool](https://android.googlesource.com/platform/external/avb/+/refs/heads/master/aftltool.py)
-and
-[libavb_aftl](https://android.googlesource.com/platform/external/avb/+/refs/heads/master/libavb_aftl/)
-for more details.
-
-
-![Overview of AftlIcpHeader and AftlIcpEntry](../docs/aftl-image-structure.png)
-
-Each `AftlIcpEntry` structure contains the information required to validate an
-inclusion proof from a specific transparency log server for a given [VBMeta
-structure](https://android.googlesource.com/platform/external/avb/+/master#the-vbmeta-struct)
-given the corresponding transparency log public key. The inclusion proof
-validation process is described in the [inclusion proofs](#inclusion-proofs)
-section of this document.
-
-*Note*: A single `AftlImage` can have multiple inclusion proofs from different
-transparency logs. This allows the device manufacturer to not rely on a single
-transparency log, and ensures that the builds represented by the VBMeta
-structure are deemed transparent in multiple disparate jurisdictions.
-
-## Inclusion proofs
-
-An inclusion proof allows a user to prove that a specific VBMeta structure is
-included in a transparency log. An inclusion proof consists of three parts:
-
-*  A `SignedVBMetaPrimaryAnnotation` structure containing the hash of the
-VBMeta structure (and other build meta information) that is signed with the
-manufacturer key.
-*  A set of sibling node hashes (`Proof`) in a Merkle tree on the path from the
-leaf node in question, which represents the logged annotation, to the root
-node.
-*  A `TrillianLogRootDescriptor` structure containing the log's root hash,
-along with related metadata, which is signed by the transparency log’s private
-key.
-
-Validation of an inclusion proof can be performed with the following steps,
-which are implemented in both `aftltool` and `libavb_aftl`.
-
-1.  Calculate the hash of the VBMeta structure stored on the device.
-1.  Determine if the hash matches the hash stored in the
-`SignedVBMetaPrimaryAnnotation` structure inside the `AftlImage` on device. If
-it does, continue validation.
-1.  Given the set of hashes provided from the transparency log as part of the
-inclusion proof, attempt to recalculate the root hash. Details of the process
-can be found [here](https://www.certificate-transparency.org/log-proofs-work)
-in the Merkle Audit Proofs section.
-1.  Check the calculated root hash against the log's root hash from the
-inclusion proof. If it matches, continue validation.
-1.  Finally, verify the log root signature given the calculated root hash and
-the public key of the transparency log that is stored on device. If the
-signature is valid, the inclusion proof is valid.
-
-# Tools and libraries
-
-This section contains information about the tools and libraries added to AVB
-repository or modified to include AFTL support.
-
-## aftltool and libavb\_aftl
-
-The main purpose of
-[aftltool](https://android.googlesource.com/platform/external/avb/+/refs/heads/master/aftltool.py)
-is to add an inclusion proof to an existing `vbmeta.img` to be used
-for transparency checks at boot or system update time. This enhanced image is
-stored in the `vbmeta` partition or in the `vbmeta_a` and
-`vbmeta_b` slots when using A/B  and will still be of minimal size
-(for out-of-band updates). Creation, query, and verification tasks can be
-performed with `aftltool`.
-
-In addition to the `aftltool`, the
-[libavb](https://android.googlesource.com/platform/external/avb/+/master/libavb/)
-library comes with an extension called
-[libavb\_aftl](https://android.googlesource.com/platform/external/avb/+/master/libavb_aftl/).
-This component performs all verification on the device side related to AFTL and
-inclusion proofs. That is, it loads the `vbmeta` partition, checks
-the VBMeta structure signature, walks through each inclusion proof stored in
-the `AftlImage`, and validates them against a trusted transparency
-log key stored on the device.
-
-This library is intended to be used in both the boot loader and inside Android
-as part of the OTA client. The main entry point for verification is
-`aftl_slot_verify()`, which is intended to be called after `vbmeta`
-verification is done via `avb_slot_verify()`.
-
-## Files and directories
-
-* `libavb_aftl/`
-  + An implementation of AFTL inclusion proof validation. This
-    code is designed to be highly portable so it can be used in as many contexts
-    as possible. This code requires a C99-compliant C compiler. Only the content
-    declared in `libavb_aftl.h` is considered public. The other files are
-    considered internal to the implementation and may change without notice.
-* `libavb_aftl/README.md`
-  + This document.
-* `test/`
-  + Unit tests for `libavb_aftl.`
-* `test/data/`
-  + Test data for the `aftltool` and `libavb_aftl` unit tests.
-* `aftltool`
-  + A symlink to `aftltool.py`.
-* `aftltool.py`
-  + A tool written in Python for working with images related to AFTL.
-* `Android.bp`
-  + Build rules for `aftltool`,  `libavb_aftl` (a static library
-    for use on the device), host-side libraries (for unit tests), and unit
-    tests.
-* `aftltool_test.py`
-  + Source-code for `aftltool` related unit tests.
-* `aftltool_integration_test.py`
-  + Source-code for `aftltool` related integration tests against
-    a live transparency log.
-
-## Portability
-
-The `libavb_aftl` code is intended to be used in bootloaders in devices that
-will load Android or other operating systems. The suggested approach is to copy
-the appropriate header and C files mentioned in the previous section into the
-boot loader and integrate as appropriate. The library is intended to be highly
-portable, working on both little and big endian architectures, as well as
-32-bit and 64-bit variants of each. It is also intended to work in environments
-without the standard C library and runtime.
-
-As in libavb, if the `AVB_ENABLE_DEBUG` preprocessor symbol is set, the code
-will include useful debug information and run-time checks.
-
-## Versioning and compatibility
-
-The `libavb_aftl` library follows the [versioning of
-libavb](https://android.googlesource.com/platform/external/avb/+/master#Versioning-and-Compatibility).
-
-## Using aftltool
-
-The content for the vbmeta partition is assumed to have been generated
-previously using `avbtool`. Instructions can be found in the
-[README.md](https://android.googlesource.com/platform/external/avb/+/master/README.md)
-for libavb. After the VBMeta partition is generated, it can be extended with
-inclusion proofs from transparency logs in the following manner:
-
-
-```
-aftltool make_icp_from_vbmeta \
-      --vbmeta_image_path /path/to/image.bin \
-      --output OUTPUT \
-      [--signing_helper /path/to/external/signer]  \
-      [--signing_helper_with_files /path/to/external/signer_with_files] \
-      --version_incremental STR \
-      --transparency_log_servers host:port,/path/to/log_key.pub \
-      --manufacturer_key /path/to/priv_key \
-      [--padding_size NUM]
-```
-
-The
-[version\_incremental](https://developer.android.com/reference/android/os/Build.VERSION#INCREMENTAL)
-is a part of the build fingerprint which allows for tagging the transparency
-log entry for easier tracking.
-
-An example of how to use the `make_icp_from_vbmeta` command is as follows:
-
-```
-aftltool make_icp_from_vbmeta \
-      --vbmeta_image_path ./vbmeta.img \
-      --output ./vbmeta_icp.img \
-      --version_incremental 99999999 \
-      --transparency_log_servers \
-        log.aftl-android.com:9000,/aftl-log-rsa-pub.pem \
-      --manufacturer_key ./manufacturer-rsa.pem \
-      --algorithm SHA256_RSA4096 \
-      --padding 4096
-```
-
-The AFTL information can be viewed in a human readable format in the following
-manner:
-
-```
-aftltool info_image_icp \
-      --vbmeta_image_path /path/to/image.bin \
-      [--output OUTPUT]
-```
-
-An example using `info_image_icp` is as follows:
-
-```
-aftltool info_image_icp --vbmeta_image_path ./vbmeta.img
-```
-
-Verification of an AFTL enhanced vbmeta image can be performed with the
-following command:
-
-```
-aftltool verify_image_icp \
-      --vbmeta_image_path /path/to/image.bin \
-      --transparency_log_pub_keys [TRANSPARENCY_LOG_PUB_KEYS [TRANSPARENCY_LOG_PUB_KEYS ...]] 
-[--output OUTPUT]
-```
-
-An example using `verify_image_icp` is as follows:
-
-```
-aftltool verify_image_icp --vbmeta_image_path ./vbmeta.img --transparency_log_pub_keys ./log_pub_key.pem
-```
-
-More information on the options can be found using `aftltool --help`.
-
-# Build system integration
-
-AFTL modifications only will work if AVB is enabled in the build. In Android,
-AVB is enabled in an `Android.mk` file by the `BOARD_AVB_ENABLE` variable as
-described in the AVB
-[README.md](https://android.googlesource.com/platform/external/avb/#Build-System-Integration).
-
-When calling the
-[sign\_target\_files\_apks.py](https://android.googlesource.com/platform/build/+/master/tools/releasetools/sign_target_files_apks.py)
-script, the following parameters must be set:
-
-*  `--aftl_tool_path`, the location of aftltool.py
-*  `--aftl_server`, the address of the transparency log
-*  `--aftl_key_path`, which gives the path to the DER encoded transparency log public key
-*  `--aftl_manufacturer_key_path`, which gives the path to the DER encoded OEM
-  private key. Note: This key is different to the signing key used to sign VBMeta
-  structure
-
-Remember that the public part of the transparency log keys need to be available
-to the bootloader of the device to validate the inclusion proofs.
-
-# Device integration
-
-This section discusses recommendations and best practices for integrating
-`libavb` AFTL support with a device boot loader. It's important to emphasize
-that these are just recommendations. Most of these recommendations are the same
-as those for AVB.
-
-## Recommended bootflow
-
-The boot flow should ensure checking of the inclusion proofs independent of the
-unlock state of the device. It is recommended to present the user with a
-warning in case transparency checks fail.
-
-AFTL modifies this flow in the following manner: as soon as a valid OS has been
-found, search for an `AftlImage` for each VBMeta image and validate their
-inclusion proofs (this is done by the `aftl_slot_verify` function). The result
-of the verification can be appended to the kernel command line for further
-processing by the OS.
-
-![Recommended boot flow for a device using AFTL](../docs/aftl-boot-flow.png)
diff --git a/libavb_aftl/avb_aftl_types.h b/libavb_aftl/avb_aftl_types.h
deleted file mode 100644
index 028ffda..0000000
--- a/libavb_aftl/avb_aftl_types.h
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#ifdef AVB_INSIDE_LIBAVB_AFTL_H
-#error "You can't include avb_aftl_types.h in the public header libavb_aftl.h."
-#endif
-
-#ifndef AVB_COMPILATION
-#error "Never include this file, it may only be used from internal avb code."
-#endif
-
-#ifndef AVB_AFTL_TYPES_H_
-#define AVB_AFTL_TYPES_H_
-
-#include <libavb/libavb.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define AVB_AFTL_UINT64_MAX 0xfffffffffffffffful
-#define AVB_AFTL_HASH_SIZE 32ul
-#define AVB_AFTL_SIGNATURE_SIZE 512ul
-/* Raw key size used for signature validation. */
-#define AVB_AFTL_PUB_KEY_SIZE 1032ul
-/* Limit AftlImage size to 64KB. */
-#define AVB_AFTL_MAX_AFTL_IMAGE_SIZE 65536ul
-/* Limit version.incremental size to 256 characters. */
-#define AVB_AFTL_MAX_VERSION_INCREMENTAL_SIZE 256ul
-/* AFTL trees require at most 64 hashes to reconstruct the root */
-#define AVB_AFTL_MAX_PROOF_SIZE 64 * AVB_AFTL_HASH_SIZE
-/* Max URL limit. */
-#define AVB_AFTL_MAX_URL_SIZE 2048ul
-/* Minimum valid size for an Annotation leaf. */
-#define AVB_AFTL_MIN_ANNOTATION_SIZE 18ul
-/* Minimum valid size for a TrillianLogRootDescriptor. See the
-   TrillianLogRootDescriptor struct for details. The values here cover:
-   version: sizeof(uint16_t)
-   tree_size: sizeof(uint64_t)
-   root_hash_size: sizeof(uint8_t)
-   root_hash: AVB_AFTL_HASH_SIZE
-   timestamp; sizeof(uint64_t)
-   revision; sizeof(uint64_t)
-   metadata_size: sizeof(uint16_t)
-   metadata is optional, so it's not required for the minimum size. */
-#define AVB_AFTL_MIN_TLRD_SIZE                                \
-  (sizeof(uint16_t) + sizeof(uint64_t) + sizeof(uint8_t) +    \
-   AVB_AFTL_HASH_SIZE + sizeof(uint64_t) + sizeof(uint64_t) + \
-   sizeof(uint16_t))
-/* Minimum valid size for an AftlIcpEntry structure. See the
-   AftlIcpEntry struct for details. The values here cover:
-   log_url_size: sizeof(uint32_t)
-   leaf_index: sizeof(uint64_t)
-   log_root_descriptor_size: sizeof(uint32_t)
-   annotation_leaf_size: sizeof(uint32_t)
-   log_root_sig_size: sizeof(uint32_t)
-   proof_hash_count: sizeof(uint8_t)
-   inc_proof_size: sizeof(uint32_t)
-   log_url: 4 (shortest practical URL)
-   log_root_descriptor: AVB_AFTL_MIN_TLRD_SIZE
-   annotation_leaf: AVB_AFTL_MIN_ANNOTATION_SIZE
-   log_root_signature: AVB_AFTL_SIGNATURE_SIZE
-   proofs: AVB_AFTL_HASH_SIZE as there must be at least one hash. */
-#define AVB_AFTL_MIN_AFTL_ICP_ENTRY_SIZE                                       \
-  (sizeof(uint32_t) + sizeof(uint64_t) + sizeof(uint32_t) + sizeof(uint32_t) + \
-   sizeof(uint32_t) + sizeof(uint8_t) + sizeof(uint32_t) + 4 +                 \
-   AVB_AFTL_MIN_TLRD_SIZE + AVB_AFTL_MIN_ANNOTATION_SIZE +                     \
-   AVB_AFTL_SIGNATURE_SIZE + AVB_AFTL_HASH_SIZE)
-/* The maximum AftlIcpEntrySize is the max AftlImage size minus the size
-   of the AftlImageHeader. */
-#define AVB_AFTL_MAX_AFTL_ICP_ENTRY_SIZE \
-  (AVB_AFTL_MAX_AFTL_IMAGE_SIZE - sizeof(AftlImageHeader))
-/* The maximum Annotation size is the max AftlImage size minus the
-   size of the smallest valid AftlIcpEntry. */
-#define AVB_AFTL_MAX_ANNOTATION_SIZE \
-  (AVB_AFTL_MAX_AFTL_IMAGE_SIZE - AVB_AFTL_MIN_AFTL_ICP_ENTRY_SIZE)
-/* The maximum metadata size in a TrillianLogRootDescriptor for AFTL is the
-   max AftlImage size minus the smallest valid AftlIcpEntry size. */
-#define AVB_AFTL_MAX_METADATA_SIZE \
-  (AVB_AFTL_MAX_AFTL_IMAGE_SIZE - AVB_AFTL_MIN_AFTL_ICP_ENTRY_SIZE)
-/* The maximum TrillianLogRootDescriptor is the size of the smallest valid
-TrillianLogRootDescriptor + the largest possible metadata size. */
-#define AVB_AFTL_MAX_TLRD_SIZE \
-  (AVB_AFTL_MIN_TLRD_SIZE + AVB_AFTL_MAX_METADATA_SIZE)
-
-/* Data structure containing a Trillian LogRootDescriptor, from
-   https://github.com/google/trillian/blob/master/trillian.proto#L255
-   The log_root_signature is calculated over this structure. */
-typedef struct TrillianLogRootDescriptor {
-  uint16_t version;
-  uint64_t tree_size;
-  uint8_t root_hash_size;
-  uint8_t* root_hash;
-  uint64_t timestamp;
-  uint64_t revision;
-  uint16_t metadata_size;
-  uint8_t* metadata;
-} TrillianLogRootDescriptor;
-
-typedef enum {
-  AVB_AFTL_HASH_SHA256,
-  _AVB_AFTL_HASH_ALGORITHM_NUM
-} HashAlgorithm;
-
-typedef enum {
-  AVB_AFTL_SIGNATURE_RSA,    // RSA with PKCS1v15
-  AVB_AFTL_SIGNATURE_ECDSA,  // ECDSA with P256 curve
-  _AVB_AFTL_SIGNATURE_ALGORITHM_NUM
-} SignatureAlgorithm;
-
-/* Data structure containing the signature within a leaf of the VBMeta
- * annotation. This signature is made using the manufacturer key which is
- * generally not available at boot time. Therefore, this structure is not
- * verified by the bootloader. */
-typedef struct {
-  uint8_t hash_algorithm;
-  uint8_t signature_algorithm;
-  uint16_t signature_size;
-  uint8_t* signature;
-} Signature;
-
-/* Data structure containing the VBMeta annotation. */
-typedef struct {
-  uint8_t vbmeta_hash_size;
-  uint8_t* vbmeta_hash;
-  uint8_t version_incremental_size;
-  uint8_t* version_incremental;
-  uint8_t manufacturer_key_hash_size;
-  uint8_t* manufacturer_key_hash;
-  uint16_t description_size;
-  uint8_t* description;
-} VBMetaPrimaryAnnotation;
-
-#define AVB_AFTL_VBMETA_LEAF 0
-#define AVB_AFTL_SIGNED_VBMETA_PRIMARY_ANNOTATION_LEAF 1
-
-/* Data structure containing the leaf that is stored in the
-   transparency log. */
-typedef struct {
-  uint8_t version;
-  uint64_t timestamp;
-  uint8_t leaf_type;
-  Signature* signature;
-  VBMetaPrimaryAnnotation* annotation;
-} SignedVBMetaPrimaryAnnotationLeaf;
-
-/* Data structure containing AFTL inclusion proof data from a single
-   transparency log. */
-typedef struct AftlIcpEntry {
-  uint32_t log_url_size;
-  uint64_t leaf_index;
-  uint32_t log_root_descriptor_size;
-  uint32_t annotation_leaf_size;
-  uint16_t log_root_sig_size;
-  uint8_t proof_hash_count;
-  uint32_t inc_proof_size;
-  uint8_t* log_url;
-  TrillianLogRootDescriptor log_root_descriptor;
-  uint8_t* log_root_descriptor_raw;
-  SignedVBMetaPrimaryAnnotationLeaf* annotation_leaf;
-  uint8_t* annotation_leaf_raw;
-  uint8_t* log_root_signature;
-  uint8_t (*proofs)[AVB_AFTL_HASH_SIZE];
-} AftlIcpEntry;
-
-/* Data structure containing AFTL header information. */
-typedef struct AftlImageHeader {
-  uint32_t magic;
-  uint32_t required_icp_version_major;
-  uint32_t required_icp_version_minor;
-  uint32_t image_size; /* Total size of the AftlImage, including this header */
-  uint16_t icp_count;
-} AVB_ATTR_PACKED AftlImageHeader;
-
-/* Main data structure for an AFTL image. */
-typedef struct AftlImage {
-  AftlImageHeader header;
-  AftlIcpEntry** entries;
-} AftlImage;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* AVB_AFTL_TYPES_H_ */
diff --git a/libavb_aftl/avb_aftl_util.c b/libavb_aftl/avb_aftl_util.c
deleted file mode 100644
index f780e82..0000000
--- a/libavb_aftl/avb_aftl_util.c
+++ /dev/null
@@ -1,932 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include <libavb/avb_crypto.h>
-#include <libavb/avb_rsa.h>
-#include <libavb/avb_sha.h>
-#include <libavb/avb_util.h>
-
-#include "avb_aftl_types.h"
-#include "avb_aftl_util.h"
-#include "avb_aftl_validate.h"
-
-/* Performs a SHA256 hash operation on data. */
-bool avb_aftl_sha256(uint8_t* data,
-                     uint64_t length,
-                     uint8_t hash[AVB_AFTL_HASH_SIZE]) {
-  AvbSHA256Ctx context;
-  uint8_t* tmp;
-
-  if ((data == NULL) && (length != 0)) return false;
-
-  avb_sha256_init(&context);
-  avb_sha256_update(&context, data, length);
-  tmp = avb_sha256_final(&context);
-  avb_memcpy(hash, tmp, AVB_AFTL_HASH_SIZE);
-  return true;
-}
-
-/* Computes a leaf hash as detailed by https://tools.ietf.org/html/rfc6962. */
-bool avb_aftl_rfc6962_hash_leaf(uint8_t* leaf,
-                                uint64_t leaf_size,
-                                uint8_t* hash) {
-  uint8_t* buffer;
-  bool retval;
-
-  avb_assert(leaf != NULL && hash != NULL);
-  avb_assert(leaf_size != AVB_AFTL_UINT64_MAX);
-
-  buffer = (uint8_t*)avb_malloc(leaf_size + 1);
-
-  if (buffer == NULL) {
-    avb_error("Allocation failure in avb_aftl_rfc6962_hash_leaf.\n");
-    return false;
-  }
-  /* Prefix the data with a '0' for 2nd preimage attack resistance. */
-  buffer[0] = 0;
-
-  if (leaf_size > 0) avb_memcpy(buffer + 1, leaf, leaf_size);
-
-  retval = avb_aftl_sha256(buffer, leaf_size + 1, hash);
-  avb_free(buffer);
-  return retval;
-}
-
-/* Computes an inner hash as detailed by https://tools.ietf.org/html/rfc6962. */
-bool avb_aftl_rfc6962_hash_children(uint8_t* left_child,
-                                    uint64_t left_child_size,
-                                    uint8_t* right_child,
-                                    uint64_t right_child_size,
-                                    uint8_t* hash) {
-  uint8_t* buffer;
-  uint64_t data_size;
-  bool retval;
-
-  avb_assert(left_child != NULL && right_child != NULL && hash != NULL);
-
-  /* Check for integer overflow. */
-  avb_assert(left_child_size < AVB_AFTL_UINT64_MAX - right_child_size);
-
-  data_size = left_child_size + right_child_size + 1;
-  buffer = (uint8_t*)avb_malloc(data_size);
-  if (buffer == NULL) {
-    avb_error("Allocation failure in avb_aftl_rfc6962_hash_children.\n");
-    return false;
-  }
-
-  /* Prefix the data with '1' for 2nd preimage attack resistance. */
-  buffer[0] = 1;
-
-  /* Copy the left child data, if it exists. */
-  if (left_child_size > 0) avb_memcpy(buffer + 1, left_child, left_child_size);
-  /* Copy the right child data, if it exists. */
-  if (right_child_size > 0)
-    avb_memcpy(buffer + 1 + left_child_size, right_child, right_child_size);
-
-  /* Hash the concatenated data and clean up. */
-  retval = avb_aftl_sha256(buffer, data_size, hash);
-  avb_free(buffer);
-  return retval;
-}
-
-/* Computes a subtree hash along tree's right border. */
-bool avb_aftl_chain_border_right(uint8_t* seed,
-                                 uint64_t seed_size,
-                                 uint8_t* proof,
-                                 uint32_t proof_entry_count,
-                                 uint8_t* hash) {
-  size_t i;
-  uint8_t* tmp_hash;
-  uint8_t* tmp = seed;
-  bool retval = true;
-
-  avb_assert(seed_size == AVB_AFTL_HASH_SIZE);
-  avb_assert(seed != NULL && proof != NULL && hash != NULL);
-
-  tmp_hash = (uint8_t*)avb_malloc(AVB_AFTL_HASH_SIZE);
-  if (tmp_hash == NULL) {
-    avb_error("Allocation failure in avb_aftl_chain_border_right.\n");
-    return false;
-  }
-  for (i = 0; i < proof_entry_count; i++) {
-    retval = avb_aftl_rfc6962_hash_children(proof + (i * AVB_AFTL_HASH_SIZE),
-                                            AVB_AFTL_HASH_SIZE,
-                                            tmp,
-                                            AVB_AFTL_HASH_SIZE,
-                                            tmp_hash);
-    if (!retval) {
-      avb_error("Failed to hash Merkle tree children.\n");
-      break;
-    }
-    tmp = tmp_hash;
-  }
-
-  if (retval) avb_memcpy(hash, tmp, AVB_AFTL_HASH_SIZE);
-
-  avb_free(tmp_hash);
-  return retval;
-}
-
-/* Computes a subtree hash on or below the tree's right border. */
-bool avb_aftl_chain_inner(uint8_t* seed,
-                          uint64_t seed_size,
-                          uint8_t* proof,
-                          uint32_t proof_entry_count,
-                          uint64_t leaf_index,
-                          uint8_t* hash) {
-  size_t i;
-  uint8_t* tmp_hash;
-  uint8_t* tmp = seed;
-  bool retval = true;
-
-  avb_assert(seed_size == AVB_AFTL_HASH_SIZE);
-  avb_assert(seed != NULL && proof != NULL && hash != NULL);
-
-  tmp_hash = (uint8_t*)avb_malloc(AVB_AFTL_HASH_SIZE);
-  if (tmp_hash == NULL) {
-    avb_error("Allocation failure in avb_aftl_chain_inner.\n");
-    return false;
-  }
-  for (i = 0; i < proof_entry_count; i++) {
-    if ((leaf_index >> i & 1) == 0) {
-      retval = avb_aftl_rfc6962_hash_children(tmp,
-                                              seed_size,
-                                              proof + (i * AVB_AFTL_HASH_SIZE),
-                                              AVB_AFTL_HASH_SIZE,
-                                              tmp_hash);
-    } else {
-      retval = avb_aftl_rfc6962_hash_children(proof + (i * AVB_AFTL_HASH_SIZE),
-                                              AVB_AFTL_HASH_SIZE,
-                                              tmp,
-                                              seed_size,
-                                              tmp_hash);
-    }
-    if (!retval) {
-      avb_error("Failed to hash Merkle tree children.\n");
-      break;
-    }
-    tmp = tmp_hash;
-  }
-  if (retval) avb_memcpy(hash, tmp, AVB_AFTL_HASH_SIZE);
-  avb_free(tmp_hash);
-  return retval;
-}
-
-/* Counts leading zeros. Used in Merkle tree hash validation .*/
-unsigned int avb_aftl_count_leading_zeros(uint64_t val) {
-  int r = 0;
-  if (val == 0) return 64;
-  if (!(val & 0xffffffff00000000u)) {
-    val <<= 32;
-    r += 32;
-  }
-  if (!(val & 0xffff000000000000u)) {
-    val <<= 16;
-    r += 16;
-  }
-  if (!(val & 0xff00000000000000u)) {
-    val <<= 8;
-    r += 8;
-  }
-  if (!(val & 0xf000000000000000u)) {
-    val <<= 4;
-    r += 4;
-  }
-  if (!(val & 0xc000000000000000u)) {
-    val <<= 2;
-    r += 2;
-  }
-  if (!(val & 0x8000000000000000u)) {
-    val <<= 1;
-    r += 1;
-  }
-
-  return r;
-}
-
-/* Calculates the expected Merkle tree hash. */
-bool avb_aftl_root_from_icp(uint64_t leaf_index,
-                            uint64_t tree_size,
-                            uint8_t proof[][AVB_AFTL_HASH_SIZE],
-                            uint32_t proof_entry_count,
-                            uint8_t* leaf_hash,
-                            uint64_t leaf_hash_size,
-                            uint8_t* root_hash) {
-  uint64_t inner_proof_size;
-  uint64_t border_proof_size;
-  size_t i;
-  uint8_t hash[AVB_AFTL_HASH_SIZE];
-  uint8_t* inner_proof;
-  uint8_t* border_proof;
-  bool retval;
-
-  avb_assert(proof_entry_count != 0);
-  avb_assert(leaf_hash_size != 0);
-  avb_assert(proof != NULL && leaf_hash != NULL && root_hash != NULL);
-
-  /* This cannot overflow. */
-  inner_proof_size =
-      64 - avb_aftl_count_leading_zeros(leaf_index ^ (tree_size - 1));
-
-  /* Check for integer underflow.*/
-  if ((proof_entry_count - inner_proof_size) > proof_entry_count) {
-    avb_error("Invalid proof entry count value.\n");
-    return false;
-  }
-  border_proof_size = proof_entry_count - inner_proof_size;
-  /* Split the proof into two parts based on the calculated pivot point. */
-  inner_proof = (uint8_t*)avb_malloc(inner_proof_size * AVB_AFTL_HASH_SIZE);
-  if (inner_proof == NULL) {
-    avb_error("Allocation failure in avb_aftl_root_from_icp.\n");
-    return false;
-  }
-  border_proof = (uint8_t*)avb_malloc(border_proof_size * AVB_AFTL_HASH_SIZE);
-  if (border_proof == NULL) {
-    avb_free(inner_proof);
-    avb_error("Allocation failure in avb_aftl_root_from_icp.\n");
-    return false;
-  }
-
-  for (i = 0; i < inner_proof_size; i++) {
-    avb_memcpy(
-        inner_proof + (AVB_AFTL_HASH_SIZE * i), proof[i], AVB_AFTL_HASH_SIZE);
-  }
-  for (i = 0; i < border_proof_size; i++) {
-    avb_memcpy(border_proof + (AVB_AFTL_HASH_SIZE * i),
-               proof[inner_proof_size + i],
-               AVB_AFTL_HASH_SIZE);
-  }
-
-  /* Calculate the root hash and store it in root_hash. */
-  retval = avb_aftl_chain_inner(leaf_hash,
-                                leaf_hash_size,
-                                inner_proof,
-                                inner_proof_size,
-                                leaf_index,
-                                hash);
-  if (retval)
-    retval = avb_aftl_chain_border_right(
-        hash, AVB_AFTL_HASH_SIZE, border_proof, border_proof_size, root_hash);
-
-  if (inner_proof != NULL) avb_free(inner_proof);
-  if (border_proof != NULL) avb_free(border_proof);
-  return retval;
-}
-
-/* Defines helper functions read_u8, read_u16, read_u32 and read_u64. These
- * functions can be used to read from a |data| stream a |value| of a specific
- * size. The value endianness is converted from big-endian to host.  We ensure
- * that the read do not overflow beyond |data_end|. If successful, |data| is
- * brought forward by the size of the value read.
- */
-#define _read_u(fct)                                   \
-  {                                                    \
-    size_t value_size = sizeof(*value);                \
-    if ((*data + value_size) < *data) return false;    \
-    if ((*data + value_size) > data_end) return false; \
-    avb_memcpy(value, *data, value_size);              \
-    *value = fct(*value);                              \
-    *data += value_size;                               \
-    return true;                                       \
-  }
-static bool read_u8(uint8_t* value, uint8_t** data, uint8_t* data_end) {
-  _read_u();
-}
-AVB_ATTR_WARN_UNUSED_RESULT
-static bool read_u16(uint16_t* value, uint8_t** data, uint8_t* data_end) {
-  _read_u(avb_be16toh);
-}
-AVB_ATTR_WARN_UNUSED_RESULT
-static bool read_u32(uint32_t* value, uint8_t** data, uint8_t* data_end) {
-  _read_u(avb_be32toh);
-}
-AVB_ATTR_WARN_UNUSED_RESULT
-static bool read_u64(uint64_t* value, uint8_t** data, uint8_t* data_end) {
-  _read_u(avb_be64toh);
-}
-AVB_ATTR_WARN_UNUSED_RESULT
-
-/* Allocates |value_size| bytes into |value| and copy |value_size| bytes from
- * |data|.  Ensure that we don't overflow beyond |data_end|. It is the caller
- * responsibility to avb_free |value|. Advances the |data| pointer pass the
- * value that has been read. Returns false if an overflow would have occurred or
- * if the allocation failed.
- */
-static bool read_mem(uint8_t** value,
-                     size_t value_size,
-                     uint8_t** data,
-                     uint8_t* data_end) {
-  if (*data + value_size < *data || *data + value_size > data_end) {
-    return false;
-  }
-  *value = (uint8_t*)avb_calloc(value_size);
-  if (!value) {
-    return false;
-  }
-  avb_memcpy(*value, *data, value_size);
-  *data += value_size;
-  return true;
-}
-
-/* Allocates and populates a TrillianLogRootDescriptor element in an
-   AftlIcpEntry from a binary blob.
-   The blob is expected to be pointing to the beginning of a
-   serialized TrillianLogRootDescriptor element of an AftlIcpEntry.
-   The aftl_blob argument is updated to point to the area after the
-   TrillianLogRootDescriptor. aftl_blob_remaining gives the amount of the
-   aftl_blob that is left to parse. */
-static bool parse_trillian_log_root_descriptor(AftlIcpEntry* icp_entry,
-                                               uint8_t** aftl_blob,
-                                               size_t aftl_blob_remaining) {
-  avb_assert(icp_entry);
-  avb_assert(aftl_blob);
-  uint8_t* blob_end = *aftl_blob + aftl_blob_remaining;
-  if (*aftl_blob > blob_end) {
-    return false;
-  }
-
-  /* Copy in the version field from the blob. */
-  if (!read_u16(
-          &(icp_entry->log_root_descriptor.version), aftl_blob, blob_end)) {
-    avb_error("Unable to parse version.\n");
-    return false;
-  }
-
-  /* Copy in the tree size field from the blob. */
-  if (!read_u64(
-          &(icp_entry->log_root_descriptor.tree_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse tree size.\n");
-    return false;
-  }
-
-  /* Copy in the root hash size field from the blob. */
-  if (!read_u8(&(icp_entry->log_root_descriptor.root_hash_size),
-               aftl_blob,
-               blob_end)) {
-    avb_error("Unable to parse root hash size.\n");
-    return false;
-  }
-  if (icp_entry->log_root_descriptor.root_hash_size != AVB_AFTL_HASH_SIZE) {
-    avb_error("Invalid root hash size.\n");
-    return false;
-  }
-
-  /* Copy in the root hash from the blob. */
-  if (!read_mem(&(icp_entry->log_root_descriptor.root_hash),
-                icp_entry->log_root_descriptor.root_hash_size,
-                aftl_blob,
-                blob_end)) {
-    avb_error("Unable to parse root hash.\n");
-    return false;
-  }
-
-  /* Copy in the timestamp field from the blob. */
-  if (!read_u64(
-          &(icp_entry->log_root_descriptor.timestamp), aftl_blob, blob_end)) {
-    avb_error("Unable to parse timestamp.\n");
-    return false;
-  }
-
-  /* Copy in the revision field from the blob. */
-  if (!read_u64(
-          &(icp_entry->log_root_descriptor.revision), aftl_blob, blob_end)) {
-    avb_error("Unable to parse revision.\n");
-    return false;
-  }
-
-  /* Copy in the metadata size field from the blob. */
-  if (!read_u16(&(icp_entry->log_root_descriptor.metadata_size),
-                aftl_blob,
-                blob_end)) {
-    avb_error("Unable to parse metadata size.\n");
-    return false;
-  }
-
-  if (icp_entry->log_root_descriptor.metadata_size >
-      AVB_AFTL_MAX_METADATA_SIZE) {
-    avb_error("Invalid metadata size.\n");
-    return false;
-  }
-
-  /* If it exists, copy in the metadata field from the blob. */
-  if (icp_entry->log_root_descriptor.metadata_size > 0) {
-    if (!read_mem(&(icp_entry->log_root_descriptor.metadata),
-                  icp_entry->log_root_descriptor.metadata_size,
-                  aftl_blob,
-                  blob_end)) {
-      avb_error("Unable to parse metadata.\n");
-      return false;
-    }
-  } else {
-    icp_entry->log_root_descriptor.metadata = NULL;
-  }
-  return true;
-}
-
-/* Parses a Signature from |aftl_blob| into leaf->signature.
- * Returns false if an error occurred during the parsing */
-static bool parse_signature(SignedVBMetaPrimaryAnnotationLeaf* leaf,
-                            uint8_t** aftl_blob,
-                            uint8_t* blob_end) {
-  Signature* signature = (Signature*)avb_calloc(sizeof(Signature));
-  if (!signature) {
-    avb_error("Failed to allocate signature.\n");
-    return false;
-  }
-  leaf->signature = signature;
-
-  if (!read_u8(&(signature->hash_algorithm), aftl_blob, blob_end)) {
-    avb_error("Unable to parse the hash algorithm.\n");
-    return false;
-  }
-  if (signature->hash_algorithm >= _AVB_AFTL_HASH_ALGORITHM_NUM) {
-    avb_error("Unexpect hash algorithm in leaf signature.\n");
-    return false;
-  }
-
-  if (!read_u8(&(signature->signature_algorithm), aftl_blob, blob_end)) {
-    avb_error("Unable to parse the signature algorithm.\n");
-    return false;
-  }
-  if (signature->signature_algorithm >= _AVB_AFTL_SIGNATURE_ALGORITHM_NUM) {
-    avb_error("Unexpect signature algorithm in leaf signature.\n");
-    return false;
-  }
-
-  if (!read_u16(&(signature->signature_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse the signature size.\n");
-    return false;
-  }
-  if (!read_mem(&(signature->signature),
-                signature->signature_size,
-                aftl_blob,
-                blob_end)) {
-    avb_error("Unable to parse signature.\n");
-    return false;
-  }
-  return true;
-}
-
-/* Parses an VBMetaPrimaryAnnotation from |aftl_blob| into leaf->annotation.
- * Returns false if an error occurred during the parsing */
-static bool parse_annotation(SignedVBMetaPrimaryAnnotationLeaf* leaf,
-                             uint8_t** aftl_blob,
-                             uint8_t* blob_end) {
-  VBMetaPrimaryAnnotation* annotation =
-      (VBMetaPrimaryAnnotation*)avb_calloc(sizeof(VBMetaPrimaryAnnotation));
-  if (!annotation) {
-    avb_error("Failed to allocate annotation.\n");
-    return false;
-  }
-  leaf->annotation = annotation;
-
-  if (!read_u8(&(annotation->vbmeta_hash_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse VBMeta hash size.\n");
-    return false;
-  }
-  if (annotation->vbmeta_hash_size != AVB_AFTL_HASH_SIZE) {
-    avb_error("Unexpected VBMeta hash size.\n");
-    return false;
-  }
-  if (!read_mem(&(annotation->vbmeta_hash),
-                annotation->vbmeta_hash_size,
-                aftl_blob,
-                blob_end)) {
-    avb_error("Unable to parse VBMeta hash.\n");
-    return false;
-  }
-
-  if (!read_u8(&(annotation->version_incremental_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse version incremental size.\n");
-    return false;
-  }
-  if (!read_mem(&(annotation->version_incremental),
-                annotation->version_incremental_size,
-                aftl_blob,
-                blob_end)) {
-    avb_error("Unable to parse version incremental.\n");
-    return false;
-  }
-
-  if (!read_u8(
-          &(annotation->manufacturer_key_hash_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse manufacturer key hash size.\n");
-    return false;
-  }
-  if (!read_mem(&(annotation->manufacturer_key_hash),
-                annotation->manufacturer_key_hash_size,
-                aftl_blob,
-                blob_end)) {
-    avb_error("Unable to parse manufacturer key hash.\n");
-    return false;
-  }
-
-  if (!read_u16(&(annotation->description_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse description size.\n");
-    return false;
-  }
-  if (!read_mem(&(annotation->description),
-                annotation->description_size,
-                aftl_blob,
-                blob_end)) {
-    avb_error("Unable to parse description.\n");
-    return false;
-  }
-  return true;
-}
-
-/* Allocates and populates a SignedVBMetaPrimaryAnnotationLeaf element in an
-   AftlIcpEntry from a binary blob.
-   The blob is expected to be pointing to the beginning of a
-   serialized SignedVBMetaPrimaryAnnotationLeaf element of an AftlIcpEntry.
-   The aftl_blob argument is updated to point to the area after the leaf. */
-static bool parse_annotation_leaf(AftlIcpEntry* icp_entry,
-                                  uint8_t** aftl_blob) {
-  SignedVBMetaPrimaryAnnotationLeaf* leaf;
-  uint8_t* blob_end = *aftl_blob + icp_entry->annotation_leaf_size;
-  if (*aftl_blob > blob_end) {
-    return false;
-  }
-
-  leaf = (SignedVBMetaPrimaryAnnotationLeaf*)avb_calloc(
-      sizeof(SignedVBMetaPrimaryAnnotationLeaf));
-  if (!leaf) {
-    avb_error("Failed to allocate for annotation leaf.\n");
-    return false;
-  }
-  /* The leaf will be free'd within the free_aftl_icp_entry() */
-  icp_entry->annotation_leaf = leaf;
-  if (!read_u8(&(leaf->version), aftl_blob, blob_end)) {
-    avb_error("Unable to parse version.\n");
-    return false;
-  }
-  if (leaf->version != 1) {
-    avb_error("Unexpected leaf version.\n");
-    return false;
-  }
-  if (!read_u64(&(leaf->timestamp), aftl_blob, blob_end)) {
-    avb_error("Unable to parse timestamp.\n");
-    return false;
-  }
-  if (!read_u8(&(leaf->leaf_type), aftl_blob, blob_end)) {
-    avb_error("Unable to parse version.\n");
-    return false;
-  }
-  if (leaf->leaf_type != AVB_AFTL_SIGNED_VBMETA_PRIMARY_ANNOTATION_LEAF) {
-    avb_error("Unexpected leaf type.\n");
-    return false;
-  }
-  if (!parse_signature(leaf, aftl_blob, blob_end)) {
-    avb_error("Unable to parse signature.\n");
-    return false;
-  }
-  if (!parse_annotation(leaf, aftl_blob, blob_end)) {
-    avb_error("Unable to parse annotation.\n");
-    return false;
-  }
-  return true;
-}
-
-/* Allocates and populates an AftlIcpEntry from a binary blob.
-   The blob is expected to be pointing to the beginning of a
-   serialized AftlIcpEntry structure. */
-AftlIcpEntry* parse_icp_entry(uint8_t** aftl_blob, size_t* remaining_size) {
-  AftlIcpEntry* icp_entry;
-  uint8_t* blob_start = *aftl_blob;
-  uint8_t* blob_end = *aftl_blob + *remaining_size;
-  if (*aftl_blob > blob_end) {
-    return NULL;
-  }
-
-  if (*remaining_size < AVB_AFTL_MIN_AFTL_ICP_ENTRY_SIZE) {
-    avb_error("Invalid AftlImage\n");
-    return NULL;
-  }
-
-  icp_entry = (AftlIcpEntry*)avb_calloc(sizeof(AftlIcpEntry));
-  if (!icp_entry) {
-    avb_error("Failure allocating AftlIcpEntry\n");
-    return NULL;
-  }
-
-  /* Copy in the log server URL size field. */
-  if (!read_u32(&(icp_entry->log_url_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse log url size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  if (icp_entry->log_url_size > AVB_AFTL_MAX_URL_SIZE) {
-    avb_error("Invalid log URL size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  /* Copy in the leaf index field. */
-  if (!read_u64(&(icp_entry->leaf_index), aftl_blob, blob_end)) {
-    avb_error("Unable to parse leaf_index.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  /* Copy in the TrillianLogRootDescriptor size field. */
-  if (!read_u32(&(icp_entry->log_root_descriptor_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse log root descriptor size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  if (icp_entry->log_root_descriptor_size < AVB_AFTL_MIN_TLRD_SIZE ||
-      icp_entry->log_root_descriptor_size > AVB_AFTL_MAX_TLRD_SIZE) {
-    avb_error("Invalid TrillianLogRootDescriptor size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-
-  /* Copy in the annotation leaf size field. */
-  if (!read_u32(&(icp_entry->annotation_leaf_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse annotation leaf size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  if (icp_entry->annotation_leaf_size == 0 ||
-      icp_entry->annotation_leaf_size > AVB_AFTL_MAX_ANNOTATION_SIZE) {
-    avb_error("Invalid annotation leaf size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-
-  /* Copy the log root signature size field. */
-  if (!read_u16(&(icp_entry->log_root_sig_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse log root signature size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  if (icp_entry->log_root_sig_size != AVB_AFTL_SIGNATURE_SIZE) {
-    avb_error("Invalid log root signature size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  /* Copy the inclusion proof hash count field. */
-  if (!read_u8(&(icp_entry->proof_hash_count), aftl_blob, blob_end)) {
-    avb_error("Unable to parse proof hash count.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  /* Copy the inclusion proof size field. */
-  if (!read_u32(&(icp_entry->inc_proof_size), aftl_blob, blob_end)) {
-    avb_error("Unable to parse inclusion proof size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  if ((icp_entry->inc_proof_size !=
-       icp_entry->proof_hash_count * AVB_AFTL_HASH_SIZE) ||
-      (icp_entry->inc_proof_size > AVB_AFTL_MAX_PROOF_SIZE)) {
-    avb_error("Invalid inclusion proof size.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  /* Copy in the log server URL from the blob. */
-  if (*aftl_blob + icp_entry->log_url_size < *aftl_blob ||
-      *aftl_blob + icp_entry->log_url_size > blob_end) {
-    avb_error("Invalid AftlImage.\n");
-    avb_free(icp_entry);
-    return NULL;
-  }
-  icp_entry->log_url = (uint8_t*)avb_calloc(icp_entry->log_url_size);
-  if (!icp_entry->log_url) {
-    avb_error("Failure to allocate URL.\n");
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-  avb_memcpy(icp_entry->log_url, *aftl_blob, icp_entry->log_url_size);
-  *aftl_blob += icp_entry->log_url_size;
-
-  /* Populate the TrillianLogRootDescriptor elements. */
-  if (*aftl_blob + icp_entry->log_root_descriptor_size < *aftl_blob ||
-      *aftl_blob + icp_entry->log_root_descriptor_size > blob_end) {
-    avb_error("Invalid AftlImage.\n");
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-  icp_entry->log_root_descriptor_raw =
-      (uint8_t*)avb_calloc(icp_entry->log_root_descriptor_size);
-  if (!icp_entry->log_root_descriptor_raw) {
-    avb_error("Failure to allocate log root descriptor.\n");
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-  avb_memcpy(icp_entry->log_root_descriptor_raw,
-             *aftl_blob,
-             icp_entry->log_root_descriptor_size);
-  if (!parse_trillian_log_root_descriptor(
-          icp_entry, aftl_blob, icp_entry->log_root_descriptor_size)) {
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-
-  /* Populate the annotation leaf. */
-  if (*aftl_blob + icp_entry->annotation_leaf_size < *aftl_blob ||
-      *aftl_blob + icp_entry->annotation_leaf_size > blob_end) {
-    avb_error("Invalid AftlImage.\n");
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-  icp_entry->annotation_leaf_raw =
-      (uint8_t*)avb_calloc(icp_entry->annotation_leaf_size);
-  if (!icp_entry->annotation_leaf_raw) {
-    avb_error("Failure to allocate annotation leaf.\n");
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-  avb_memcpy(icp_entry->annotation_leaf_raw,
-             *aftl_blob,
-             icp_entry->annotation_leaf_size);
-  if (!parse_annotation_leaf(icp_entry, aftl_blob)) {
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-
-  /* Allocate and copy the log root signature from the blob. */
-  if (*aftl_blob + icp_entry->log_root_sig_size < *aftl_blob ||
-      *aftl_blob + icp_entry->log_root_sig_size > blob_end) {
-    avb_error("Invalid AftlImage.\n");
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-  icp_entry->log_root_signature =
-      (uint8_t*)avb_calloc(icp_entry->log_root_sig_size);
-  if (!icp_entry->log_root_signature) {
-    avb_error("Failure to allocate log root signature.\n");
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-  avb_memcpy(
-      icp_entry->log_root_signature, *aftl_blob, icp_entry->log_root_sig_size);
-  *aftl_blob += icp_entry->log_root_sig_size;
-
-  /* Finally, copy the proof hash data from the blob to the AftlImage. */
-  if (*aftl_blob + icp_entry->inc_proof_size < *aftl_blob ||
-      *aftl_blob + icp_entry->inc_proof_size > blob_end) {
-    avb_error("Invalid AftlImage.\n");
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-  icp_entry->proofs = avb_calloc(icp_entry->inc_proof_size);
-  if (!icp_entry->proofs) {
-    free_aftl_icp_entry(icp_entry);
-    return NULL;
-  }
-  avb_memcpy(icp_entry->proofs, *aftl_blob, icp_entry->inc_proof_size);
-  *aftl_blob += icp_entry->inc_proof_size;
-
-  *remaining_size -= *aftl_blob - blob_start;
-  return icp_entry;
-}
-
-/* Allocate and parse an AftlImage object out of binary data. */
-AftlImage* parse_aftl_image(uint8_t* aftl_blob, size_t aftl_blob_size) {
-  AftlImage* image;
-  AftlImageHeader* image_header;
-  AftlIcpEntry* entry;
-  size_t image_size;
-  size_t i;
-  size_t remaining_size;
-
-  /* Ensure the blob is at least large enough for an AftlImageHeader */
-  if (aftl_blob_size < sizeof(AftlImageHeader)) {
-    avb_error("Invalid image header.\n");
-    return NULL;
-  }
-  image_header = (AftlImageHeader*)aftl_blob;
-  /* Check for the magic value for an AftlImageHeader. */
-  if (image_header->magic != AVB_AFTL_MAGIC) {
-    avb_error("Invalid magic number\n");
-    return NULL;
-  }
-  /* Extract the size out of the header. */
-  image_size = avb_be32toh(image_header->image_size);
-  if (image_size < sizeof(AftlImageHeader) ||
-      image_size > AVB_AFTL_MAX_AFTL_IMAGE_SIZE) {
-    avb_error("Invalid image size.\n");
-    return NULL;
-  }
-  image = (AftlImage*)avb_calloc(sizeof(AftlImage));
-  if (!image) {
-    avb_error("Failed allocation for AftlImage.\n");
-    return NULL;
-  }
-  /* Copy the header bytes directly from the aftl_blob. */
-  avb_memcpy(&(image->header), aftl_blob, sizeof(AftlImageHeader));
-  /* Fix endianness. */
-  image->header.required_icp_version_major =
-      avb_be32toh(image->header.required_icp_version_major);
-  image->header.required_icp_version_minor =
-      avb_be32toh(image->header.required_icp_version_minor);
-  image->header.image_size = avb_be32toh(image->header.image_size);
-  image->header.icp_count = avb_be16toh(image->header.icp_count);
-  /* Allocate memory for the entry array */
-  image->entries = (AftlIcpEntry**)avb_calloc(sizeof(AftlIcpEntry*) *
-                                              image->header.icp_count);
-  if (!image->entries) {
-    avb_error("Failed allocation for AftlIcpEntry array.\n");
-    avb_free(image);
-    return NULL;
-  }
-
-  /* Jump past the header and parse out each AftlIcpEntry. */
-  aftl_blob += sizeof(AftlImageHeader);
-  remaining_size = aftl_blob_size - sizeof(AftlImageHeader);
-  for (i = 0; i < image->header.icp_count && remaining_size > 0; i++) {
-    entry = parse_icp_entry(&aftl_blob, &remaining_size);
-    if (!entry) {
-      free_aftl_image(image);
-      return NULL;
-    }
-    image->entries[i] = entry;
-  }
-
-  return image;
-}
-
-/* Free an AftlIcpEntry and each allocated sub-element. */
-void free_aftl_icp_entry(AftlIcpEntry* icp_entry) {
-  /* Ensure the AftlIcpEntry exists before attempting to free it. */
-  if (icp_entry) {
-    /* Free the log_url and log_root_signature elements if they exist. */
-    if (icp_entry->log_url) avb_free(icp_entry->log_url);
-    if (icp_entry->log_root_signature) avb_free(icp_entry->log_root_signature);
-    /* Free the annotation elements if they exist. */
-    if (icp_entry->annotation_leaf) {
-      if (icp_entry->annotation_leaf->signature) {
-        if (icp_entry->annotation_leaf->signature->signature) {
-          avb_free(icp_entry->annotation_leaf->signature->signature);
-        }
-        avb_free(icp_entry->annotation_leaf->signature);
-      }
-      if (icp_entry->annotation_leaf->annotation) {
-        if (icp_entry->annotation_leaf->annotation->vbmeta_hash)
-          avb_free(icp_entry->annotation_leaf->annotation->vbmeta_hash);
-        if (icp_entry->annotation_leaf->annotation->version_incremental)
-          avb_free(icp_entry->annotation_leaf->annotation->version_incremental);
-        if (icp_entry->annotation_leaf->annotation->manufacturer_key_hash)
-          avb_free(
-              icp_entry->annotation_leaf->annotation->manufacturer_key_hash);
-        if (icp_entry->annotation_leaf->annotation->description)
-          avb_free(icp_entry->annotation_leaf->annotation->description);
-        avb_free(icp_entry->annotation_leaf->annotation);
-      }
-      avb_free(icp_entry->annotation_leaf);
-    }
-    if (icp_entry->annotation_leaf_raw)
-      avb_free(icp_entry->annotation_leaf_raw);
-    /* Free the TrillianLogRoot elements if they exist. */
-    if (icp_entry->log_root_descriptor.metadata)
-      avb_free(icp_entry->log_root_descriptor.metadata);
-    if (icp_entry->log_root_descriptor.root_hash)
-      avb_free(icp_entry->log_root_descriptor.root_hash);
-    if (icp_entry->log_root_descriptor_raw)
-      avb_free(icp_entry->log_root_descriptor_raw);
-    if (icp_entry->proofs) avb_free(icp_entry->proofs);
-    /* Finally, free the AftlIcpEntry. */
-    avb_free(icp_entry);
-  }
-}
-
-/* Free the AftlImage and each allocated sub-element. */
-void free_aftl_image(AftlImage* image) {
-  size_t i;
-
-  /* Ensure the descriptor exists before attempting to free it. */
-  if (!image) {
-    return;
-  }
-  /* Free the entry array. */
-  if (image->entries) {
-    /* Walk through each entry, freeing each one. */
-    for (i = 0; i < image->header.icp_count; i++) {
-      if (image->entries[i]) {
-        free_aftl_icp_entry(image->entries[i]);
-      }
-    }
-    avb_free(image->entries);
-  }
-  avb_free(image);
-}
diff --git a/libavb_aftl/avb_aftl_util.h b/libavb_aftl/avb_aftl_util.h
deleted file mode 100644
index db222c3..0000000
--- a/libavb_aftl/avb_aftl_util.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#ifdef AVB_INSIDE_LIBAVB_AFTL_H
-#error "You can't include avb_aftl_util.h in the public header libavb_aftl.h."
-#endif
-
-#ifndef AVB_COMPILATION
-#error "Never include this file, it may only be used from internal avb code."
-#endif
-
-#ifndef AVB_AFTL_UTIL_H_
-#define AVB_AFTL_UTIL_H_
-
-#include "avb_aftl_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define AVB_AFTL_MAGIC 0x4c544641
-#define avb_aftl_member_size(type, member) sizeof(((type*)0)->member)
-
-/* Performs a SHA256 hash operation on data. */
-bool avb_aftl_sha256(
-    uint8_t* data,                     /* Data to be hashed. */
-    uint64_t length,                   /* Size of data. */
-    uint8_t hash[AVB_AFTL_HASH_SIZE]); /* Resulting SHA256 hash. */
-
-/* Calculates a SHA256 hash of the TrillianLogRootDescriptor in icp_entry. */
-bool avb_aftl_hash_log_root_descriptor(
-    AftlIcpEntry* icp_entry, /* The icp_entry containing the descriptor. */
-    uint8_t* hash);          /* The resulting hash of the descriptor data. */
-
-/* RFC 6962 Hashing function for leaves of a Merkle tree. */
-bool avb_aftl_rfc6962_hash_leaf(
-    uint8_t* leaf,      /* The Merkle tree leaf data to be hashed. */
-    uint64_t leaf_size, /* Size of the leaf data. */
-    uint8_t* hash);     /* Resulting RFC 6962 hash of the leaf data. */
-
-/* Computes an inner hash as detailed by https://tools.ietf.org/html/rfc6962. */
-bool avb_aftl_rfc6962_hash_children(
-    uint8_t* left_child,       /* The left child node data. */
-    uint64_t left_child_size,  /* Size of the left child node data. */
-    uint8_t* right_child,      /* The right child node data. */
-    uint64_t right_child_size, /* Size of the right child node data. */
-    uint8_t
-        hash[AVB_AFTL_HASH_SIZE]); /* Resulting RFC 6962 hash of the children.*/
-
-/* Computes a subtree hash along the left-side tree border. */
-bool avb_aftl_chain_border_right(
-    uint8_t* seed,              /* Data containing the starting hash. */
-    uint64_t seed_size,         /* Size of the starting hash data. */
-    uint8_t* proof,             /* The hashes in the inclusion proof. */
-    uint32_t proof_entry_count, /* Number of inclusion proof entries. */
-    uint8_t* hash);             /* Resulting subtree hash. */
-
-/* Computes a subtree hash on or below the tree's right border. */
-bool avb_aftl_chain_inner(
-    uint8_t* seed,              /* Data containing the starting hash. */
-    uint64_t seed_size,         /* Size of the starting hash data. */
-    uint8_t* proof,             /* The hashes in the inclusion proof. */
-    uint32_t proof_entry_count, /* Number of inclusion proof entries. */
-    uint64_t leaf_index,        /* The current Merkle tree leaf index. */
-    uint8_t* hash);             /* Resulting subtree hash. */
-
-/* Counts leading zeros. Used in Merkle tree hash validation .*/
-unsigned int avb_aftl_count_leading_zeros(
-    uint64_t val); /* Value to count leading zeros of. */
-
-/* Calculates the expected Merkle tree hash. */
-bool avb_aftl_root_from_icp(
-    uint64_t leaf_index,                 /* The leaf index in the Merkle tree.*/
-    uint64_t tree_size,                  /* The size of the Merkle tree. */
-    uint8_t proof[][AVB_AFTL_HASH_SIZE], /* Inclusion proof hash data. */
-    uint32_t proof_entry_count,          /* Number of inclusion proof hashes. */
-    uint8_t* leaf_hash,      /* The leaf hash to prove inclusion of. */
-    uint64_t leaf_hash_size, /* Size of the leaf hash. */
-    uint8_t* root_hash);     /* The resulting tree root hash. */
-
-/* Allocates and populates an AftlImage from a binary blob. */
-AftlImage* parse_aftl_image(uint8_t* aftl_blob, size_t aftl_blob_size);
-
-/* Allocates and populates an AftlIcpEntry and all sub-fields from
-   a binary blob. It is assumed that the blob points to an AftlIcpEntry. */
-AftlIcpEntry* parse_icp_entry(uint8_t** aftl_blob, size_t* remaining_size);
-
-/* Frees an AftlIcpEntry and all sub-fields that were previously
-   allocated by a call to parse_icp_entry. */
-void free_aftl_icp_entry(AftlIcpEntry* aftl_icp_entry);
-
-/* Frees an AftlImage and all sub-fields that were previously
-   allocated by a call to parse_aftl_image. */
-void free_aftl_image(AftlImage* image);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* AVB_AFTL_UTIL_H_ */
diff --git a/libavb_aftl/avb_aftl_validate.c b/libavb_aftl/avb_aftl_validate.c
deleted file mode 100644
index 2d76b2f..0000000
--- a/libavb_aftl/avb_aftl_validate.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include <libavb/avb_crypto.h>
-#include <libavb/avb_rsa.h>
-#include <libavb/avb_sha.h>
-#include <libavb/avb_util.h>
-
-#include "avb_aftl_types.h"
-#include "avb_aftl_util.h"
-#include "avb_aftl_validate.h"
-
-/* Verifies that the logged VBMeta hash matches the one on device. */
-bool avb_aftl_verify_vbmeta_hash(uint8_t* vbmeta,
-                                 size_t vbmeta_size,
-                                 AftlIcpEntry* icp_entry) {
-  uint8_t vbmeta_hash[AVB_AFTL_HASH_SIZE];
-
-  avb_assert(vbmeta != NULL && icp_entry != NULL);
-  if (!avb_aftl_sha256(vbmeta, vbmeta_size, vbmeta_hash)) return false;
-
-  /* Only SHA256 hashes are currently supported. If the vbmeta hash
-     size is not AVB_AFTL_HASH_SIZE, return false. */
-  if (icp_entry->annotation_leaf->annotation->vbmeta_hash_size !=
-      AVB_AFTL_HASH_SIZE) {
-    avb_error("Invalid VBMeta hash size.\n");
-    return false;
-  }
-
-  /* Return whether the calculated VBMeta hash matches the stored one. */
-  return avb_safe_memcmp(vbmeta_hash,
-                         icp_entry->annotation_leaf->annotation->vbmeta_hash,
-                         AVB_AFTL_HASH_SIZE) == 0;
-}
-
-/* Verifies the Merkle tree root hash. */
-bool avb_aftl_verify_icp_root_hash(AftlIcpEntry* icp_entry) {
-  uint8_t leaf_hash[AVB_AFTL_HASH_SIZE];
-  uint8_t result_hash[AVB_AFTL_HASH_SIZE];
-
-  avb_assert(icp_entry != NULL);
-  /* Calculate the RFC 6962 hash of the seed entry. */
-  if (!avb_aftl_rfc6962_hash_leaf(icp_entry->annotation_leaf_raw,
-                                  icp_entry->annotation_leaf_size,
-                                  leaf_hash)) {
-    return false;
-  }
-  /* Calculate the Merkle tree's root hash. */
-  if (!avb_aftl_root_from_icp(icp_entry->leaf_index,
-                              icp_entry->log_root_descriptor.tree_size,
-                              icp_entry->proofs,
-                              icp_entry->proof_hash_count,
-                              leaf_hash,
-                              AVB_AFTL_HASH_SIZE,
-                              result_hash))
-    return false;
-
-  /* Return whether the calculated root hash matches the stored one. */
-  return (avb_safe_memcmp(result_hash,
-                          icp_entry->log_root_descriptor.root_hash,
-                          AVB_AFTL_HASH_SIZE) == 0);
-}
-
-/* Verifies the log root signature for the transparency log submission. */
-bool avb_aftl_verify_entry_signature(const uint8_t* key,
-                                     size_t key_num_bytes,
-                                     AftlIcpEntry* icp_entry) {
-  uint8_t* sig;
-  size_t sig_num_bytes;
-  uint8_t log_root_hash[AVB_AFTL_HASH_SIZE];
-  size_t log_root_hash_num_bytes;
-  const AvbAlgorithmData* algorithm_data;
-
-  avb_assert(key != NULL && icp_entry != NULL);
-
-  /* Extract the log root signature from the AftlIcpEntry. */
-  sig = icp_entry->log_root_signature;
-  if (sig == NULL) {
-    avb_error("Invalid log root signature.\n");
-    return false;
-  }
-  sig_num_bytes = icp_entry->log_root_sig_size;
-  log_root_hash_num_bytes = AVB_AFTL_HASH_SIZE;
-
-  /* Calculate the SHA256 of the TrillianLogRootDescriptor. */
-  if (!avb_aftl_sha256(icp_entry->log_root_descriptor_raw,
-                       icp_entry->log_root_descriptor_size,
-                       log_root_hash))
-    return false;
-
-  /* algorithm_data is used to calculate the padding for signature verification.
-   */
-  algorithm_data = avb_get_algorithm_data(AVB_ALGORITHM_TYPE_SHA256_RSA4096);
-  if (algorithm_data == NULL) {
-    avb_error("Failed to get algorithm data.\n");
-    return false;
-  }
-
-  return avb_rsa_verify(key,
-                        key_num_bytes,
-                        sig,
-                        sig_num_bytes,
-                        log_root_hash,
-                        log_root_hash_num_bytes,
-                        algorithm_data->padding,
-                        algorithm_data->padding_len);
-}
diff --git a/libavb_aftl/avb_aftl_validate.h b/libavb_aftl/avb_aftl_validate.h
deleted file mode 100644
index 4a1ecc8..0000000
--- a/libavb_aftl/avb_aftl_validate.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#if !defined(AVB_INSIDE_LIBAVB_AFTL_H) && !defined(AVB_COMPILATION)
-#error "Never include this file directly, include libavb_aftl/libavb_aftl.h."
-#endif
-
-#ifndef AVB_AFTL_VALIDATE_H_
-#define AVB_AFTL_VALIDATE_H_
-
-#include <libavb/libavb.h>
-#include "avb_aftl_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Verifies that the logged vbmeta hash matches the one on device. */
-bool avb_aftl_verify_vbmeta_hash(
-    uint8_t* vbmeta,          /* Buffer containing the vbmeta data. */
-    size_t vbmeta_size,       /* Size of the vbmeta buffer. */
-    AftlIcpEntry* icp_entry); /* Pointer to the AftlIcpEntry to verify. */
-
-/* Verifies the Merkle tree root hash. */
-bool avb_aftl_verify_icp_root_hash(
-    AftlIcpEntry* icp_entry); /* Pointer to the AftlIcpEntry to verify. */
-
-/* Verifies the log root signature for the transparency log submission. */
-bool avb_aftl_verify_entry_signature(
-    const uint8_t* key,       /* Transparency log public key data. */
-    size_t key_num_bytes,     /* Size of the key data. */
-    AftlIcpEntry* icp_entry); /* Pointer to the AftlIcpEntry to verify. */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* AVB_AFTL_VALIDATE_H_ */
diff --git a/libavb_aftl/avb_aftl_verify.c b/libavb_aftl/avb_aftl_verify.c
deleted file mode 100644
index b35e417..0000000
--- a/libavb_aftl/avb_aftl_verify.c
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "libavb_aftl/avb_aftl_verify.h"
-
-#include <libavb/avb_cmdline.h>
-#include <libavb/avb_slot_verify.h>
-#include <libavb/avb_util.h>
-
-#include "libavb_aftl/avb_aftl_types.h"
-#include "libavb_aftl/avb_aftl_util.h"
-#include "libavb_aftl/avb_aftl_validate.h"
-
-/* Read the vbmeta partition, after the AvbVBMetaImageHeader structure, to find
- * the AftlImage.
- */
-static AftlSlotVerifyResult avb_aftl_find_aftl_image(AvbOps* ops,
-                                                     const char* part_name,
-                                                     size_t vbmeta_size,
-                                                     uint8_t* out_image_buf,
-                                                     size_t* out_image_size) {
-  AvbIOResult io_ret;
-
-  avb_assert(vbmeta_size <= AVB_AFTL_MAX_AFTL_IMAGE_SIZE);
-  io_ret = ops->read_from_partition(ops,
-                                    part_name,
-                                    vbmeta_size /* offset */,
-                                    AVB_AFTL_MAX_AFTL_IMAGE_SIZE - vbmeta_size,
-                                    out_image_buf,
-                                    out_image_size);
-  switch (io_ret) {
-    case AVB_IO_RESULT_OK:
-      break;
-    case AVB_IO_RESULT_ERROR_OOM:
-      return AFTL_SLOT_VERIFY_RESULT_ERROR_OOM;
-    case AVB_IO_RESULT_ERROR_RANGE_OUTSIDE_PARTITION:
-    case AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION:
-      return AFTL_SLOT_VERIFY_RESULT_ERROR_IMAGE_NOT_FOUND;
-    default:
-      avb_errorv(
-          part_name, ": Error loading AftlImage from partition.\n", NULL);
-      return AFTL_SLOT_VERIFY_RESULT_ERROR_IO;
-  }
-
-  if (*out_image_size < 4 || (out_image_buf[0] != 'A') ||
-      (out_image_buf[1] != 'F') || (out_image_buf[2] != 'T') ||
-      (out_image_buf[3] != 'L')) {
-    avb_errorv(part_name, ": Unexpected AftlImage magic.\n", NULL);
-    return AFTL_SLOT_VERIFY_RESULT_ERROR_IMAGE_NOT_FOUND;
-  }
-
-  return AFTL_SLOT_VERIFY_RESULT_OK;
-}
-
-/* Performs the three validation steps for an AFTL image:
-   1. Ensure the vbmeta image hash matches that in the image.
-   2. Ensure the root hash of the Merkle tree matches that in the image.
-   3. Verify the signature using the transparency log public key.
-*/
-static AftlSlotVerifyResult avb_aftl_verify_image(uint8_t* cur_vbmeta_data,
-                                                  size_t cur_vbmeta_size,
-                                                  uint8_t* aftl_blob,
-                                                  size_t aftl_size,
-                                                  uint8_t* key_bytes,
-                                                  size_t key_num_bytes) {
-  size_t i;
-  AftlImage* image;
-  AftlSlotVerifyResult result = AFTL_SLOT_VERIFY_RESULT_ERROR_VERIFICATION;
-
-  /* Attempt to parse the AftlImage pointed to by aftl_blob. */
-  image = parse_aftl_image(aftl_blob, aftl_size);
-  if (!image) {
-    return AFTL_SLOT_VERIFY_RESULT_ERROR_INVALID_IMAGE;
-  }
-
-  /* Now that a valid AftlImage has been parsed, attempt to verify
-     the inclusion proof(s) in three steps. */
-  for (i = 0; i < image->header.icp_count; i++) {
-    /* 1. Ensure that the vbmeta hash stored in the AftlIcpEntry matches
-       the one that represents the partition. */
-    if (!avb_aftl_verify_vbmeta_hash(
-            cur_vbmeta_data, cur_vbmeta_size, image->entries[i])) {
-      avb_error("AFTL vbmeta hash verification failed.\n");
-      result = AFTL_SLOT_VERIFY_RESULT_ERROR_VBMETA_HASH_MISMATCH;
-      break;
-    }
-    /* 2. Ensure that the root hash of the Merkle tree representing
-       the transparency log entry matches the one stored in the
-       AftlIcpEntry. */
-    if (!avb_aftl_verify_icp_root_hash(image->entries[i])) {
-      avb_error("AFTL root hash verification failed.\n");
-      result = AFTL_SLOT_VERIFY_RESULT_ERROR_TREE_HASH_MISMATCH;
-      break;
-    }
-    /* 3. Verify the signature using the transparency log public
-       key stored on device. */
-    if (!avb_aftl_verify_entry_signature(
-            key_bytes, key_num_bytes, image->entries[i])) {
-      avb_error("AFTL signature verification failed on entry.\n");
-      result = AFTL_SLOT_VERIFY_RESULT_ERROR_INVALID_PROOF_SIGNATURE;
-      break;
-    }
-    result = AFTL_SLOT_VERIFY_RESULT_OK;
-  }
-  free_aftl_image(image);
-  return result;
-}
-
-AftlSlotVerifyResult aftl_slot_verify(AvbOps* ops,
-                                      AvbSlotVerifyData* slot_verify_data,
-                                      uint8_t* key_bytes,
-                                      size_t key_size) {
-  size_t i;
-  size_t aftl_image_size;
-  size_t vbmeta_size;
-  uint8_t* current_aftl_blob;
-  char part_name[AVB_PART_NAME_MAX_SIZE];
-  char* pname;
-  AftlSlotVerifyResult ret = AFTL_SLOT_VERIFY_RESULT_ERROR_VERIFICATION;
-
-  avb_assert(slot_verify_data != NULL);
-  avb_assert(key_bytes != NULL);
-  avb_assert(key_size == AVB_AFTL_PUB_KEY_SIZE);
-  if (slot_verify_data->vbmeta_images == NULL) {
-    return AFTL_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT;
-  }
-
-  current_aftl_blob = avb_malloc(AVB_AFTL_MAX_AFTL_IMAGE_SIZE);
-  if (current_aftl_blob == NULL) {
-    return AFTL_SLOT_VERIFY_RESULT_ERROR_OOM;
-  }
-
-  /* Walk through each vbmeta blob in the AvbSlotVerifyData struct. */
-  for (i = 0; i < slot_verify_data->num_vbmeta_images; i++) {
-    /* Rebuild partition name, appending the suffix */
-    pname = slot_verify_data->vbmeta_images[i].partition_name;
-    if (!avb_str_concat(part_name,
-                        sizeof part_name,
-                        (const char*)pname,
-                        avb_strlen(pname),
-                        slot_verify_data->ab_suffix,
-                        avb_strlen(slot_verify_data->ab_suffix))) {
-      avb_error("Partition name and suffix does not fit.\n");
-      ret = AFTL_SLOT_VERIFY_RESULT_ERROR_VERIFICATION;
-      break;
-    }
-
-    /* Use the partition info to find the AftlImage */
-    vbmeta_size = slot_verify_data->vbmeta_images[i].vbmeta_size;
-    ret = avb_aftl_find_aftl_image(
-        ops, part_name, vbmeta_size, current_aftl_blob, &aftl_image_size);
-    if (ret != AFTL_SLOT_VERIFY_RESULT_OK) {
-      avb_errorv(part_name, ": Unable to find the AftlImage.\n", NULL);
-      break;
-    }
-
-    /* Validate the AFTL image in the vbmeta image. */
-    ret = avb_aftl_verify_image(slot_verify_data->vbmeta_images[i].vbmeta_data,
-                                vbmeta_size,
-                                current_aftl_blob,
-                                aftl_image_size,
-                                key_bytes,
-                                key_size);
-    if (ret != AVB_SLOT_VERIFY_RESULT_OK) break;
-  }
-
-  avb_free(current_aftl_blob);
-  return ret;
-}
diff --git a/libavb_aftl/avb_aftl_verify.h b/libavb_aftl/avb_aftl_verify.h
deleted file mode 100644
index 7c6799f..0000000
--- a/libavb_aftl/avb_aftl_verify.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#if !defined(AVB_INSIDE_LIBAVB_AFTL_H) && !defined(AVB_COMPILATION)
-#error "Never include this file directly, include libavb_aftl.h instead."
-#endif
-
-#ifndef AVB_AFTL_VERIFY_H_
-#define AVB_AFTL_VERIFY_H_
-
-#include <libavb/libavb.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-  // When the verification succeeded.
-  AFTL_SLOT_VERIFY_RESULT_OK,
-
-  // If at some point during the verification, a memory allocation failed. This
-  // could be the case when handling a large number of log keys or inclusion
-  // proofs.
-  AFTL_SLOT_VERIFY_RESULT_ERROR_OOM,
-
-  // If at some point during the verification, we were not able to access some
-  // devices. This can be the case when reading the AftlImage from the
-  // partition.
-  AFTL_SLOT_VERIFY_RESULT_ERROR_IO,
-
-  // The VBMeta hash in the inclusion proof is not matching the VBMeta image
-  // hash.
-  AFTL_SLOT_VERIFY_RESULT_ERROR_VBMETA_HASH_MISMATCH,
-
-  // The root hash of the reconstructed tree do not match the value contained in
-  // the inclusion proof.
-  AFTL_SLOT_VERIFY_RESULT_ERROR_TREE_HASH_MISMATCH,
-
-  // The inclusion proof signature cannot be verified by the given key.
-  AFTL_SLOT_VERIFY_RESULT_ERROR_INVALID_PROOF_SIGNATURE,
-
-  // A generic error occurred during the verification.
-  AFTL_SLOT_VERIFY_RESULT_ERROR_VERIFICATION,
-
-  // At least one of the VBMetas did not have an AftlImage attached.
-  AFTL_SLOT_VERIFY_RESULT_ERROR_IMAGE_NOT_FOUND,
-
-  // Some content of one of the AFTLImages was found corrupted.
-  AFTL_SLOT_VERIFY_RESULT_ERROR_INVALID_IMAGE,
-
-  // Returned if the caller passed invalid parameters, for example if the prior
-  // call to avb_slot_verify failed.
-  AFTL_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT
-
-} AftlSlotVerifyResult;
-
-/* The entry point of AFTL validation. It uses the AvbSlotVerifyData structure,
- * |slot_verify_data|, generated by a prior call to the avb_slot_verify
- * function, and a transparency log key to validate the inclusion proof(s)
- * attached to each VBMeta images.
- *
- * The caller is responsible for ensuring that the previous call to
- * avb_slot_verify succeeded. If |slot_verify_data| is incomplete or NULL,
- * AFTL_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT will be returned.
- *
- * The AftlImage structure is located after the VBMetaImage structure. Uses
- * |ops| to read the partition where the VBMeta was loaded from.
- *
- * For each inclusion proof found, the following three validation steps are
- * performed:
- *   1. Match the VBMeta image hash with the hash in the tree leaf.
- *   2. Match the root hash of the Merkle tree with the hash in the proof.
- *   3. Verify the signature of the proof using the transparency log public key.
- * See the definition of AftlSlotVerifyResult for all the possible return
- * values.
- */
-
-AftlSlotVerifyResult aftl_slot_verify(AvbOps* ops,
-                                      AvbSlotVerifyData* slot_verify_data,
-                                      uint8_t* key_bytes,
-                                      size_t key_size);
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* AVB_AFTL_VERIFY_H_ */
diff --git a/libavb_aftl/libavb_aftl.h b/libavb_aftl/libavb_aftl.h
deleted file mode 100644
index dbf0146..0000000
--- a/libavb_aftl/libavb_aftl.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#ifndef LIBAVB_AFTL_H_
-#define LIBAVB_AFTL_H_
-
-
-/* The AVB_INSIDE_LIBAVB_AFTL_H preprocessor symbol is used to enforce
- * library users to include only this file. All public interfaces, and
- * only public interfaces, must be included here.
- */
-
-#define AVB_INSIDE_LIBAVB_AFTL_H
-#include "avb_aftl_verify.h"
-#undef AVB_INSIDE_LIBAVB_AFTL_H
-
-#endif /* LIBAVB_AFTL_H_ */
diff --git a/proto/README.md b/proto/README.md
deleted file mode 100644
index ee64b01..0000000
--- a/proto/README.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# Android Firmware Transparency Log Proto Definitions
----
-
-This directory contains the proto definitions required to communicate with an
-AFTL server. The original repos and purpose for each proto file are as
-follows:
-
-* api.proto
-   Contains the messages to communicate with the AFTL personality.
-* crypto/keyspb/keyspb.proto
-   From https://github.com/google/trillian
-   Dependency of trillian.proto
-   Contains the PublicKey message definition used by Tree.
-* crypto/sigpb/sigpb.proto
-   From https://github.com/google/trillian
-   Dependency of trillian.proto
-   For trillian.proto, contains the DigitallySigned message used by Tree and
-   SignedEntryTimestamp.
-* trillian.proto
-   From https://github.com/google/trillian
-   Dependency of aftl.proto
-   For aftl.proto, contains message definitions for SignedLogRoot.
diff --git a/proto/__init__.py b/proto/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/proto/__init__.py
+++ /dev/null
diff --git a/proto/api.proto b/proto/api.proto
deleted file mode 100644
index e22ae47..0000000
--- a/proto/api.proto
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2019-2020 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-
-package aftl;
-option go_package = "proto";
-
-import "trillian.proto";
-
-message InclusionProof {
-  trillian.Proof proof = 1;
-  trillian.SignedLogRoot sth = 2;
-}
-
-message AddVBMetaRequest {
-  // VBMeta structure as described in
-  // https://android.googlesource.com/platform/external/avb/+/master/README.md.
-  // In case of chained partitions, each VBMeta is added via a separate call.
-  // The default size for gRPC payload is about 4MB. We expect vbmeta to be
-  // in the order of 64kB.
-  bytes vbmeta = 1;
-
-  // Serialized SignedVBMetaPrimaryAnnotation. This annotation contains the hash
-  // of the vbmeta structure. It is signed using the manufacturer key.
-  // See types/types.go.
-  bytes signed_vbmeta_primary_annotation = 2;
-}
-
-message AddVBMetaResponse {
-  // Inclusion proof and the leaf that was added to the log, which contains
-  // the annotation on VBMeta.
-  // It is required to have the complete leaf to validate the inclusion proof.
-  // For on-device verification, only these first 2 fields are required to
-  // validate the inclusion.
-  InclusionProof annotation_proof = 1;
-  bytes          annotation_leaf = 2;
-
-  // Inclusion proof and leaf that was added to the log, which contains the full
-  // vbmeta partition.
-  // These fields are NOT required for validation but can still be recorded by a
-  // vendor to prove that the complete VBMeta was submitted.
-  InclusionProof vbmeta_proof = 3;
-  bytes          vbmeta_leaf = 4;
-}
-
-message AnnotateVBMetaWithBuildRequest {
-  // Serialized SignedVBMetaBuildAnnotation.  This annotation contains the hash
-  // of the full build image. See types/types.go.
-  bytes signed_vbmeta_build_annotation = 1;
-
-  // Bytes of the binary images. The hash value of the concatenation of these
-  // chunk is contained in SignedVBMetaBuildAnnotation.
-  // This is ignored if any of the requests origin_url is set.
-  bytes image_chunk = 2;
-
-  // Origin location of image. It is used to get a copy of the binary image
-  // from another server (e.g., Google Cloud Storage).
-  string origin_url = 3;
-}
-
-message AnnotateVBMetaWithBuildResponse {
-  // Inclusion proof and leaf for the firmware image. The leaf contains the URL
-  // where the image was stored.
-  // It is not required for vendors to keep this information. However, this can
-  // be used for their records to ensure the correctness of the log.
-  InclusionProof  annotation_proof = 1;
-  bytes           annotation_leaf = 2;
-}
-
-service AFTLog {
-
-  // Insert a new VBMeta structure into the log.
-  // This request will effectively create 2 log entries:
-  //  - VBMeta itself
-  //  - Vendor annotations, which includes a reference to the VBMeta.
-  rpc AddVBMeta(AddVBMetaRequest) returns (AddVBMetaResponse) {}
-
-  // Upload (or copy) the complete firmware image.
-  rpc AnnotateVBMetaWithBuild(stream AnnotateVBMetaWithBuildResponse) returns (AnnotateVBMetaWithBuildResponse) {}
-
-  // TODO(tweek): GetProofByHash, GetSthConsistency, GetEntries, GetRootKeys
-}
diff --git a/proto/api_pb2.py b/proto/api_pb2.py
deleted file mode 100644
index fbe3bab..0000000
--- a/proto/api_pb2.py
+++ /dev/null
@@ -1,323 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: api.proto
-
-import sys
-_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import message as _message
-from google.protobuf import reflection as _reflection
-from google.protobuf import symbol_database as _symbol_database
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-import trillian_pb2 as trillian__pb2
-
-
-DESCRIPTOR = _descriptor.FileDescriptor(
-  name='api.proto',
-  package='aftl',
-  syntax='proto3',
-  serialized_options=_b('Z\005proto'),
-  serialized_pb=_b('\n\tapi.proto\x12\x04\x61\x66tl\x1a\x0etrillian.proto\"V\n\x0eInclusionProof\x12\x1e\n\x05proof\x18\x01 \x01(\x0b\x32\x0f.trillian.Proof\x12$\n\x03sth\x18\x02 \x01(\x0b\x32\x17.trillian.SignedLogRoot\"L\n\x10\x41\x64\x64VBMetaRequest\x12\x0e\n\x06vbmeta\x18\x01 \x01(\x0c\x12(\n signed_vbmeta_primary_annotation\x18\x02 \x01(\x0c\"\x9d\x01\n\x11\x41\x64\x64VBMetaResponse\x12.\n\x10\x61nnotation_proof\x18\x01 \x01(\x0b\x32\x14.aftl.InclusionProof\x12\x17\n\x0f\x61nnotation_leaf\x18\x02 \x01(\x0c\x12*\n\x0cvbmeta_proof\x18\x03 \x01(\x0b\x32\x14.aftl.InclusionProof\x12\x13\n\x0bvbmeta_leaf\x18\x04 \x01(\x0c\"q\n\x1e\x41nnotateVBMetaWithBuildRequest\x12&\n\x1esigned_vbmeta_build_annotation\x18\x01 \x01(\x0c\x12\x13\n\x0bimage_chunk\x18\x02 \x01(\x0c\x12\x12\n\norigin_url\x18\x03 \x01(\t\"j\n\x1f\x41nnotateVBMetaWithBuildResponse\x12.\n\x10\x61nnotation_proof\x18\x01 \x01(\x0b\x32\x14.aftl.InclusionProof\x12\x17\n\x0f\x61nnotation_leaf\x18\x02 \x01(\x0c\x32\xb5\x01\n\x06\x41\x46TLog\x12>\n\tAddVBMeta\x12\x16.aftl.AddVBMetaRequest\x1a\x17.aftl.AddVBMetaResponse\"\x00\x12k\n\x17\x41nnotateVBMetaWithBuild\x12%.aftl.AnnotateVBMetaWithBuildResponse\x1a%.aftl.AnnotateVBMetaWithBuildResponse\"\x00(\x01\x42\x07Z\x05protob\x06proto3')
-  ,
-  dependencies=[trillian__pb2.DESCRIPTOR,])
-
-
-
-
-_INCLUSIONPROOF = _descriptor.Descriptor(
-  name='InclusionProof',
-  full_name='aftl.InclusionProof',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='proof', full_name='aftl.InclusionProof.proof', index=0,
-      number=1, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='sth', full_name='aftl.InclusionProof.sth', index=1,
-      number=2, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=35,
-  serialized_end=121,
-)
-
-
-_ADDVBMETAREQUEST = _descriptor.Descriptor(
-  name='AddVBMetaRequest',
-  full_name='aftl.AddVBMetaRequest',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='vbmeta', full_name='aftl.AddVBMetaRequest.vbmeta', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='signed_vbmeta_primary_annotation', full_name='aftl.AddVBMetaRequest.signed_vbmeta_primary_annotation', index=1,
-      number=2, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=123,
-  serialized_end=199,
-)
-
-
-_ADDVBMETARESPONSE = _descriptor.Descriptor(
-  name='AddVBMetaResponse',
-  full_name='aftl.AddVBMetaResponse',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='annotation_proof', full_name='aftl.AddVBMetaResponse.annotation_proof', index=0,
-      number=1, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='annotation_leaf', full_name='aftl.AddVBMetaResponse.annotation_leaf', index=1,
-      number=2, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='vbmeta_proof', full_name='aftl.AddVBMetaResponse.vbmeta_proof', index=2,
-      number=3, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='vbmeta_leaf', full_name='aftl.AddVBMetaResponse.vbmeta_leaf', index=3,
-      number=4, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=202,
-  serialized_end=359,
-)
-
-
-_ANNOTATEVBMETAWITHBUILDREQUEST = _descriptor.Descriptor(
-  name='AnnotateVBMetaWithBuildRequest',
-  full_name='aftl.AnnotateVBMetaWithBuildRequest',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='signed_vbmeta_build_annotation', full_name='aftl.AnnotateVBMetaWithBuildRequest.signed_vbmeta_build_annotation', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='image_chunk', full_name='aftl.AnnotateVBMetaWithBuildRequest.image_chunk', index=1,
-      number=2, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='origin_url', full_name='aftl.AnnotateVBMetaWithBuildRequest.origin_url', index=2,
-      number=3, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=361,
-  serialized_end=474,
-)
-
-
-_ANNOTATEVBMETAWITHBUILDRESPONSE = _descriptor.Descriptor(
-  name='AnnotateVBMetaWithBuildResponse',
-  full_name='aftl.AnnotateVBMetaWithBuildResponse',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='annotation_proof', full_name='aftl.AnnotateVBMetaWithBuildResponse.annotation_proof', index=0,
-      number=1, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='annotation_leaf', full_name='aftl.AnnotateVBMetaWithBuildResponse.annotation_leaf', index=1,
-      number=2, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=476,
-  serialized_end=582,
-)
-
-_INCLUSIONPROOF.fields_by_name['proof'].message_type = trillian__pb2._PROOF
-_INCLUSIONPROOF.fields_by_name['sth'].message_type = trillian__pb2._SIGNEDLOGROOT
-_ADDVBMETARESPONSE.fields_by_name['annotation_proof'].message_type = _INCLUSIONPROOF
-_ADDVBMETARESPONSE.fields_by_name['vbmeta_proof'].message_type = _INCLUSIONPROOF
-_ANNOTATEVBMETAWITHBUILDRESPONSE.fields_by_name['annotation_proof'].message_type = _INCLUSIONPROOF
-DESCRIPTOR.message_types_by_name['InclusionProof'] = _INCLUSIONPROOF
-DESCRIPTOR.message_types_by_name['AddVBMetaRequest'] = _ADDVBMETAREQUEST
-DESCRIPTOR.message_types_by_name['AddVBMetaResponse'] = _ADDVBMETARESPONSE
-DESCRIPTOR.message_types_by_name['AnnotateVBMetaWithBuildRequest'] = _ANNOTATEVBMETAWITHBUILDREQUEST
-DESCRIPTOR.message_types_by_name['AnnotateVBMetaWithBuildResponse'] = _ANNOTATEVBMETAWITHBUILDRESPONSE
-_sym_db.RegisterFileDescriptor(DESCRIPTOR)
-
-InclusionProof = _reflection.GeneratedProtocolMessageType('InclusionProof', (_message.Message,), {
-  'DESCRIPTOR' : _INCLUSIONPROOF,
-  '__module__' : 'api_pb2'
-  # @@protoc_insertion_point(class_scope:aftl.InclusionProof)
-  })
-_sym_db.RegisterMessage(InclusionProof)
-
-AddVBMetaRequest = _reflection.GeneratedProtocolMessageType('AddVBMetaRequest', (_message.Message,), {
-  'DESCRIPTOR' : _ADDVBMETAREQUEST,
-  '__module__' : 'api_pb2'
-  # @@protoc_insertion_point(class_scope:aftl.AddVBMetaRequest)
-  })
-_sym_db.RegisterMessage(AddVBMetaRequest)
-
-AddVBMetaResponse = _reflection.GeneratedProtocolMessageType('AddVBMetaResponse', (_message.Message,), {
-  'DESCRIPTOR' : _ADDVBMETARESPONSE,
-  '__module__' : 'api_pb2'
-  # @@protoc_insertion_point(class_scope:aftl.AddVBMetaResponse)
-  })
-_sym_db.RegisterMessage(AddVBMetaResponse)
-
-AnnotateVBMetaWithBuildRequest = _reflection.GeneratedProtocolMessageType('AnnotateVBMetaWithBuildRequest', (_message.Message,), {
-  'DESCRIPTOR' : _ANNOTATEVBMETAWITHBUILDREQUEST,
-  '__module__' : 'api_pb2'
-  # @@protoc_insertion_point(class_scope:aftl.AnnotateVBMetaWithBuildRequest)
-  })
-_sym_db.RegisterMessage(AnnotateVBMetaWithBuildRequest)
-
-AnnotateVBMetaWithBuildResponse = _reflection.GeneratedProtocolMessageType('AnnotateVBMetaWithBuildResponse', (_message.Message,), {
-  'DESCRIPTOR' : _ANNOTATEVBMETAWITHBUILDRESPONSE,
-  '__module__' : 'api_pb2'
-  # @@protoc_insertion_point(class_scope:aftl.AnnotateVBMetaWithBuildResponse)
-  })
-_sym_db.RegisterMessage(AnnotateVBMetaWithBuildResponse)
-
-
-DESCRIPTOR._options = None
-
-_AFTLOG = _descriptor.ServiceDescriptor(
-  name='AFTLog',
-  full_name='aftl.AFTLog',
-  file=DESCRIPTOR,
-  index=0,
-  serialized_options=None,
-  serialized_start=585,
-  serialized_end=766,
-  methods=[
-  _descriptor.MethodDescriptor(
-    name='AddVBMeta',
-    full_name='aftl.AFTLog.AddVBMeta',
-    index=0,
-    containing_service=None,
-    input_type=_ADDVBMETAREQUEST,
-    output_type=_ADDVBMETARESPONSE,
-    serialized_options=None,
-  ),
-  _descriptor.MethodDescriptor(
-    name='AnnotateVBMetaWithBuild',
-    full_name='aftl.AFTLog.AnnotateVBMetaWithBuild',
-    index=1,
-    containing_service=None,
-    input_type=_ANNOTATEVBMETAWITHBUILDRESPONSE,
-    output_type=_ANNOTATEVBMETAWITHBUILDRESPONSE,
-    serialized_options=None,
-  ),
-])
-_sym_db.RegisterServiceDescriptor(_AFTLOG)
-
-DESCRIPTOR.services_by_name['AFTLog'] = _AFTLOG
-
-# @@protoc_insertion_point(module_scope)
diff --git a/proto/api_pb2_grpc.py b/proto/api_pb2_grpc.py
deleted file mode 100644
index d487856..0000000
--- a/proto/api_pb2_grpc.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
-import grpc
-
-import api_pb2 as api__pb2
-
-
-class AFTLogStub(object):
-  # missing associated documentation comment in .proto file
-  pass
-
-  def __init__(self, channel):
-    """Constructor.
-
-    Args:
-      channel: A grpc.Channel.
-    """
-    self.AddVBMeta = channel.unary_unary(
-        '/aftl.AFTLog/AddVBMeta',
-        request_serializer=api__pb2.AddVBMetaRequest.SerializeToString,
-        response_deserializer=api__pb2.AddVBMetaResponse.FromString,
-        )
-    self.AnnotateVBMetaWithBuild = channel.stream_unary(
-        '/aftl.AFTLog/AnnotateVBMetaWithBuild',
-        request_serializer=api__pb2.AnnotateVBMetaWithBuildResponse.SerializeToString,
-        response_deserializer=api__pb2.AnnotateVBMetaWithBuildResponse.FromString,
-        )
-
-
-class AFTLogServicer(object):
-  # missing associated documentation comment in .proto file
-  pass
-
-  def AddVBMeta(self, request, context):
-    """Insert a new VBMeta structure into the log.
-    This request will effectively create 2 log entries:
-    - VBMeta itself
-    - Vendor annotations, which includes a reference to the VBMeta.
-    """
-    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-    context.set_details('Method not implemented!')
-    raise NotImplementedError('Method not implemented!')
-
-  def AnnotateVBMetaWithBuild(self, request_iterator, context):
-    """Upload (or copy) the complete firmware image.
-    """
-    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-    context.set_details('Method not implemented!')
-    raise NotImplementedError('Method not implemented!')
-
-
-def add_AFTLogServicer_to_server(servicer, server):
-  rpc_method_handlers = {
-      'AddVBMeta': grpc.unary_unary_rpc_method_handler(
-          servicer.AddVBMeta,
-          request_deserializer=api__pb2.AddVBMetaRequest.FromString,
-          response_serializer=api__pb2.AddVBMetaResponse.SerializeToString,
-      ),
-      'AnnotateVBMetaWithBuild': grpc.stream_unary_rpc_method_handler(
-          servicer.AnnotateVBMetaWithBuild,
-          request_deserializer=api__pb2.AnnotateVBMetaWithBuildResponse.FromString,
-          response_serializer=api__pb2.AnnotateVBMetaWithBuildResponse.SerializeToString,
-      ),
-  }
-  generic_handler = grpc.method_handlers_generic_handler(
-      'aftl.AFTLog', rpc_method_handlers)
-  server.add_generic_rpc_handlers((generic_handler,))
diff --git a/proto/crypto/__init__.py b/proto/crypto/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/proto/crypto/__init__.py
+++ /dev/null
diff --git a/proto/crypto/keyspb/__init__.py b/proto/crypto/keyspb/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/proto/crypto/keyspb/__init__.py
+++ /dev/null
diff --git a/proto/crypto/keyspb/keyspb.proto b/proto/crypto/keyspb/keyspb.proto
deleted file mode 100644
index 03a8313..0000000
--- a/proto/crypto/keyspb/keyspb.proto
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-
-option go_package = "github.com/google/trillian/crypto/keyspb";
-
-package keyspb;
-
-// Specification for a private key.
-message Specification {
-  /// ECDSA defines parameters for an ECDSA key.
-  message ECDSA {
-    // The supported elliptic curves.
-    enum Curve {
-      DEFAULT_CURVE = 0;  // Curve will be chosen by Trillian.
-      P256 = 1;
-      P384 = 2;
-      P521 = 3;
-    }
-
-    // The elliptic curve to use.
-    // Optional. If not set, the default curve will be used.
-    Curve curve = 1;
-  }
-
-  // RSA defines parameters for an RSA key.
-  message RSA {
-    // Size of the keys in bits. Must be sufficiently large to allow two primes
-    // to be generated.
-    // Optional. If not set, the key size will be chosen by Trillian.
-    int32 bits = 1;
-  }
-
-  // Ed25519 defines (empty) parameters for an Ed25519 private key.
-  message Ed25519 {
-  }
-
-  // The type of parameters provided determines the algorithm used for the key.
-  oneof params {
-    // The parameters for an ECDSA key.
-    ECDSA ecdsa_params = 1;
-
-    // The parameters for an RSA key.
-    RSA rsa_params = 2;
-
-    // The parameters for an Ed25519 key.
-    Ed25519 ed25519_params = 3;
-  }
-}
-
-// PEMKeyFile identifies a private key stored in a PEM-encoded file.
-message PEMKeyFile {
-  // File path of the private key.
-  string path = 1;
-
-  // Password for decrypting the private key.
-  // If empty, indicates that the private key is not encrypted.
-  string password = 2;
-}
-
-// PrivateKey is a private key, used for generating signatures.
-message PrivateKey {
-  // The key in DER-encoded form.
-  // The specific format (e.g. PKCS8) is not specified.
-  bytes der = 1;
-}
-
-// PublicKey is a public key, used for verifying signatures.
-message PublicKey {
-  // The key in DER-encoded PKIX form.
-  bytes der = 1;
-}
-
-// PKCS11Config identifies a private key accessed using PKCS #11.
-message PKCS11Config {
-  // The label of the PKCS#11 token.
-  string token_label = 1;
-  // The PIN for the specific token.
-  string pin = 2;
-  // The PEM public key assosciated with the private key to be used.
-  string public_key = 3;
-}
diff --git a/proto/crypto/keyspb/keyspb_pb2.py b/proto/crypto/keyspb/keyspb_pb2.py
deleted file mode 100644
index eba4099..0000000
--- a/proto/crypto/keyspb/keyspb_pb2.py
+++ /dev/null
@@ -1,421 +0,0 @@
-# pylint: skip-file
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: crypto/keyspb/keyspb.proto
-
-import sys
-_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import message as _message
-from google.protobuf import reflection as _reflection
-from google.protobuf import symbol_database as _symbol_database
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-
-
-DESCRIPTOR = _descriptor.FileDescriptor(
-  name='crypto/keyspb/keyspb.proto',
-  package='keyspb',
-  syntax='proto3',
-  serialized_options=_b('Z(github.com/google/trillian/crypto/keyspb'),
-  serialized_pb=_b('\n\x1a\x63rypto/keyspb/keyspb.proto\x12\x06keyspb\"\xcd\x02\n\rSpecification\x12\x33\n\x0c\x65\x63\x64sa_params\x18\x01 \x01(\x0b\x32\x1b.keyspb.Specification.ECDSAH\x00\x12/\n\nrsa_params\x18\x02 \x01(\x0b\x32\x19.keyspb.Specification.RSAH\x00\x12\x37\n\x0e\x65\x64\x32\x35\x35\x31\x39_params\x18\x03 \x01(\x0b\x32\x1d.keyspb.Specification.Ed25519H\x00\x1as\n\x05\x45\x43\x44SA\x12\x30\n\x05\x63urve\x18\x01 \x01(\x0e\x32!.keyspb.Specification.ECDSA.Curve\"8\n\x05\x43urve\x12\x11\n\rDEFAULT_CURVE\x10\x00\x12\x08\n\x04P256\x10\x01\x12\x08\n\x04P384\x10\x02\x12\x08\n\x04P521\x10\x03\x1a\x13\n\x03RSA\x12\x0c\n\x04\x62its\x18\x01 \x01(\x05\x1a\t\n\x07\x45\x64\x32\x35\x35\x31\x39\x42\x08\n\x06params\",\n\nPEMKeyFile\x12\x0c\n\x04path\x18\x01 \x01(\t\x12\x10\n\x08password\x18\x02 \x01(\t\"\x19\n\nPrivateKey\x12\x0b\n\x03\x64\x65r\x18\x01 \x01(\x0c\"\x18\n\tPublicKey\x12\x0b\n\x03\x64\x65r\x18\x01 \x01(\x0c\"D\n\x0cPKCS11Config\x12\x13\n\x0btoken_label\x18\x01 \x01(\t\x12\x0b\n\x03pin\x18\x02 \x01(\t\x12\x12\n\npublic_key\x18\x03 \x01(\tB*Z(github.com/google/trillian/crypto/keyspbb\x06proto3')
-)
-
-
-
-_SPECIFICATION_ECDSA_CURVE = _descriptor.EnumDescriptor(
-  name='Curve',
-  full_name='keyspb.Specification.ECDSA.Curve',
-  filename=None,
-  file=DESCRIPTOR,
-  values=[
-    _descriptor.EnumValueDescriptor(
-      name='DEFAULT_CURVE', index=0, number=0,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='P256', index=1, number=1,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='P384', index=2, number=2,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='P521', index=3, number=3,
-      serialized_options=None,
-      type=None),
-  ],
-  containing_type=None,
-  serialized_options=None,
-  serialized_start=274,
-  serialized_end=330,
-)
-_sym_db.RegisterEnumDescriptor(_SPECIFICATION_ECDSA_CURVE)
-
-
-_SPECIFICATION_ECDSA = _descriptor.Descriptor(
-  name='ECDSA',
-  full_name='keyspb.Specification.ECDSA',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='curve', full_name='keyspb.Specification.ECDSA.curve', index=0,
-      number=1, type=14, cpp_type=8, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-    _SPECIFICATION_ECDSA_CURVE,
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=215,
-  serialized_end=330,
-)
-
-_SPECIFICATION_RSA = _descriptor.Descriptor(
-  name='RSA',
-  full_name='keyspb.Specification.RSA',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='bits', full_name='keyspb.Specification.RSA.bits', index=0,
-      number=1, type=5, cpp_type=1, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=332,
-  serialized_end=351,
-)
-
-_SPECIFICATION_ED25519 = _descriptor.Descriptor(
-  name='Ed25519',
-  full_name='keyspb.Specification.Ed25519',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=353,
-  serialized_end=362,
-)
-
-_SPECIFICATION = _descriptor.Descriptor(
-  name='Specification',
-  full_name='keyspb.Specification',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='ecdsa_params', full_name='keyspb.Specification.ecdsa_params', index=0,
-      number=1, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='rsa_params', full_name='keyspb.Specification.rsa_params', index=1,
-      number=2, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='ed25519_params', full_name='keyspb.Specification.ed25519_params', index=2,
-      number=3, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[_SPECIFICATION_ECDSA, _SPECIFICATION_RSA, _SPECIFICATION_ED25519, ],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-    _descriptor.OneofDescriptor(
-      name='params', full_name='keyspb.Specification.params',
-      index=0, containing_type=None, fields=[]),
-  ],
-  serialized_start=39,
-  serialized_end=372,
-)
-
-
-_PEMKEYFILE = _descriptor.Descriptor(
-  name='PEMKeyFile',
-  full_name='keyspb.PEMKeyFile',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='path', full_name='keyspb.PEMKeyFile.path', index=0,
-      number=1, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='password', full_name='keyspb.PEMKeyFile.password', index=1,
-      number=2, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=374,
-  serialized_end=418,
-)
-
-
-_PRIVATEKEY = _descriptor.Descriptor(
-  name='PrivateKey',
-  full_name='keyspb.PrivateKey',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='der', full_name='keyspb.PrivateKey.der', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=420,
-  serialized_end=445,
-)
-
-
-_PUBLICKEY = _descriptor.Descriptor(
-  name='PublicKey',
-  full_name='keyspb.PublicKey',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='der', full_name='keyspb.PublicKey.der', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=447,
-  serialized_end=471,
-)
-
-
-_PKCS11CONFIG = _descriptor.Descriptor(
-  name='PKCS11Config',
-  full_name='keyspb.PKCS11Config',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='token_label', full_name='keyspb.PKCS11Config.token_label', index=0,
-      number=1, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='pin', full_name='keyspb.PKCS11Config.pin', index=1,
-      number=2, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='public_key', full_name='keyspb.PKCS11Config.public_key', index=2,
-      number=3, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=473,
-  serialized_end=541,
-)
-
-_SPECIFICATION_ECDSA.fields_by_name['curve'].enum_type = _SPECIFICATION_ECDSA_CURVE
-_SPECIFICATION_ECDSA.containing_type = _SPECIFICATION
-_SPECIFICATION_ECDSA_CURVE.containing_type = _SPECIFICATION_ECDSA
-_SPECIFICATION_RSA.containing_type = _SPECIFICATION
-_SPECIFICATION_ED25519.containing_type = _SPECIFICATION
-_SPECIFICATION.fields_by_name['ecdsa_params'].message_type = _SPECIFICATION_ECDSA
-_SPECIFICATION.fields_by_name['rsa_params'].message_type = _SPECIFICATION_RSA
-_SPECIFICATION.fields_by_name['ed25519_params'].message_type = _SPECIFICATION_ED25519
-_SPECIFICATION.oneofs_by_name['params'].fields.append(
-  _SPECIFICATION.fields_by_name['ecdsa_params'])
-_SPECIFICATION.fields_by_name['ecdsa_params'].containing_oneof = _SPECIFICATION.oneofs_by_name['params']
-_SPECIFICATION.oneofs_by_name['params'].fields.append(
-  _SPECIFICATION.fields_by_name['rsa_params'])
-_SPECIFICATION.fields_by_name['rsa_params'].containing_oneof = _SPECIFICATION.oneofs_by_name['params']
-_SPECIFICATION.oneofs_by_name['params'].fields.append(
-  _SPECIFICATION.fields_by_name['ed25519_params'])
-_SPECIFICATION.fields_by_name['ed25519_params'].containing_oneof = _SPECIFICATION.oneofs_by_name['params']
-DESCRIPTOR.message_types_by_name['Specification'] = _SPECIFICATION
-DESCRIPTOR.message_types_by_name['PEMKeyFile'] = _PEMKEYFILE
-DESCRIPTOR.message_types_by_name['PrivateKey'] = _PRIVATEKEY
-DESCRIPTOR.message_types_by_name['PublicKey'] = _PUBLICKEY
-DESCRIPTOR.message_types_by_name['PKCS11Config'] = _PKCS11CONFIG
-_sym_db.RegisterFileDescriptor(DESCRIPTOR)
-
-Specification = _reflection.GeneratedProtocolMessageType('Specification', (_message.Message,), {
-
-  'ECDSA' : _reflection.GeneratedProtocolMessageType('ECDSA', (_message.Message,), {
-    'DESCRIPTOR' : _SPECIFICATION_ECDSA,
-    '__module__' : 'crypto.keyspb.keyspb_pb2'
-    # @@protoc_insertion_point(class_scope:keyspb.Specification.ECDSA)
-    })
-  ,
-
-  'RSA' : _reflection.GeneratedProtocolMessageType('RSA', (_message.Message,), {
-    'DESCRIPTOR' : _SPECIFICATION_RSA,
-    '__module__' : 'crypto.keyspb.keyspb_pb2'
-    # @@protoc_insertion_point(class_scope:keyspb.Specification.RSA)
-    })
-  ,
-
-  'Ed25519' : _reflection.GeneratedProtocolMessageType('Ed25519', (_message.Message,), {
-    'DESCRIPTOR' : _SPECIFICATION_ED25519,
-    '__module__' : 'crypto.keyspb.keyspb_pb2'
-    # @@protoc_insertion_point(class_scope:keyspb.Specification.Ed25519)
-    })
-  ,
-  'DESCRIPTOR' : _SPECIFICATION,
-  '__module__' : 'crypto.keyspb.keyspb_pb2'
-  # @@protoc_insertion_point(class_scope:keyspb.Specification)
-  })
-_sym_db.RegisterMessage(Specification)
-_sym_db.RegisterMessage(Specification.ECDSA)
-_sym_db.RegisterMessage(Specification.RSA)
-_sym_db.RegisterMessage(Specification.Ed25519)
-
-PEMKeyFile = _reflection.GeneratedProtocolMessageType('PEMKeyFile', (_message.Message,), {
-  'DESCRIPTOR' : _PEMKEYFILE,
-  '__module__' : 'crypto.keyspb.keyspb_pb2'
-  # @@protoc_insertion_point(class_scope:keyspb.PEMKeyFile)
-  })
-_sym_db.RegisterMessage(PEMKeyFile)
-
-PrivateKey = _reflection.GeneratedProtocolMessageType('PrivateKey', (_message.Message,), {
-  'DESCRIPTOR' : _PRIVATEKEY,
-  '__module__' : 'crypto.keyspb.keyspb_pb2'
-  # @@protoc_insertion_point(class_scope:keyspb.PrivateKey)
-  })
-_sym_db.RegisterMessage(PrivateKey)
-
-PublicKey = _reflection.GeneratedProtocolMessageType('PublicKey', (_message.Message,), {
-  'DESCRIPTOR' : _PUBLICKEY,
-  '__module__' : 'crypto.keyspb.keyspb_pb2'
-  # @@protoc_insertion_point(class_scope:keyspb.PublicKey)
-  })
-_sym_db.RegisterMessage(PublicKey)
-
-PKCS11Config = _reflection.GeneratedProtocolMessageType('PKCS11Config', (_message.Message,), {
-  'DESCRIPTOR' : _PKCS11CONFIG,
-  '__module__' : 'crypto.keyspb.keyspb_pb2'
-  # @@protoc_insertion_point(class_scope:keyspb.PKCS11Config)
-  })
-_sym_db.RegisterMessage(PKCS11Config)
-
-
-DESCRIPTOR._options = None
-# @@protoc_insertion_point(module_scope)
diff --git a/proto/crypto/keyspb/keyspb_pb2_grpc.py b/proto/crypto/keyspb/keyspb_pb2_grpc.py
deleted file mode 100644
index 73636b2..0000000
--- a/proto/crypto/keyspb/keyspb_pb2_grpc.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# pylint: skip-file
-# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
-import grpc
-
diff --git a/proto/crypto/sigpb/__init__.py b/proto/crypto/sigpb/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/proto/crypto/sigpb/__init__.py
+++ /dev/null
diff --git a/proto/crypto/sigpb/sigpb.proto b/proto/crypto/sigpb/sigpb.proto
deleted file mode 100644
index 3e333d3..0000000
--- a/proto/crypto/sigpb/sigpb.proto
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-
-option go_package = "github.com/google/trillian/crypto/sigpb";
-
-package sigpb;
-
-// Protocol buffer encoding of the TLS DigitallySigned type, from RFC 5246 §4.7.
-message DigitallySigned {
-  // HashAlgorithm defines the approved methods for object hashing.
-  //
-  // Supported hash algorithms. The numbering space is the same as for TLS,
-  // given in RFC 5246 s7.4.1.4.1 and at:
-  // http://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-18
-  enum HashAlgorithm {
-    // No hash algorithm is used.
-    NONE = 0;
-    // SHA256 is used.
-    SHA256 = 4;
-  }
-
-  // SignatureAlgorithm defines the algorithm used to sign the object.
-  //
-  // Supported signature algorithms. The numbering space is the same as for TLS,
-  // given in RFC 5246 s7.4.1.4.1 and at:
-  // http://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-16
-  enum SignatureAlgorithm {
-    // Anonymous signature scheme.
-    ANONYMOUS = 0;
-    // RSA signature scheme.
-    RSA = 1;
-    // ECDSA signature scheme.
-    ECDSA = 3;
-    // Ed25519 signature scheme.
-    ED25519 = 7;
-  }
-
-  // hash_algorithm contains the hash algorithm used.
-  HashAlgorithm hash_algorithm = 1;
-  // sig_algorithm contains the signing algorithm used.
-  SignatureAlgorithm signature_algorithm = 2;
-  // signature contains the object signature.
-  bytes signature = 3;
-}
diff --git a/proto/crypto/sigpb/sigpb_pb2.py b/proto/crypto/sigpb/sigpb_pb2.py
deleted file mode 100644
index b00d42a..0000000
--- a/proto/crypto/sigpb/sigpb_pb2.py
+++ /dev/null
@@ -1,144 +0,0 @@
-# pylint: skip-file
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: crypto/sigpb/sigpb.proto
-
-import sys
-_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import message as _message
-from google.protobuf import reflection as _reflection
-from google.protobuf import symbol_database as _symbol_database
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-
-
-DESCRIPTOR = _descriptor.FileDescriptor(
-  name='crypto/sigpb/sigpb.proto',
-  package='sigpb',
-  syntax='proto3',
-  serialized_options=_b('Z\'github.com/google/trillian/crypto/sigpb'),
-  serialized_pb=_b('\n\x18\x63rypto/sigpb/sigpb.proto\x12\x05sigpb\"\x97\x02\n\x0f\x44igitallySigned\x12<\n\x0ehash_algorithm\x18\x01 \x01(\x0e\x32$.sigpb.DigitallySigned.HashAlgorithm\x12\x46\n\x13signature_algorithm\x18\x02 \x01(\x0e\x32).sigpb.DigitallySigned.SignatureAlgorithm\x12\x11\n\tsignature\x18\x03 \x01(\x0c\"%\n\rHashAlgorithm\x12\x08\n\x04NONE\x10\x00\x12\n\n\x06SHA256\x10\x04\"D\n\x12SignatureAlgorithm\x12\r\n\tANONYMOUS\x10\x00\x12\x07\n\x03RSA\x10\x01\x12\t\n\x05\x45\x43\x44SA\x10\x03\x12\x0b\n\x07\x45\x44\x32\x35\x35\x31\x39\x10\x07\x42)Z\'github.com/google/trillian/crypto/sigpbb\x06proto3')
-)
-
-
-
-_DIGITALLYSIGNED_HASHALGORITHM = _descriptor.EnumDescriptor(
-  name='HashAlgorithm',
-  full_name='sigpb.DigitallySigned.HashAlgorithm',
-  filename=None,
-  file=DESCRIPTOR,
-  values=[
-    _descriptor.EnumValueDescriptor(
-      name='NONE', index=0, number=0,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='SHA256', index=1, number=4,
-      serialized_options=None,
-      type=None),
-  ],
-  containing_type=None,
-  serialized_options=None,
-  serialized_start=208,
-  serialized_end=245,
-)
-_sym_db.RegisterEnumDescriptor(_DIGITALLYSIGNED_HASHALGORITHM)
-
-_DIGITALLYSIGNED_SIGNATUREALGORITHM = _descriptor.EnumDescriptor(
-  name='SignatureAlgorithm',
-  full_name='sigpb.DigitallySigned.SignatureAlgorithm',
-  filename=None,
-  file=DESCRIPTOR,
-  values=[
-    _descriptor.EnumValueDescriptor(
-      name='ANONYMOUS', index=0, number=0,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='RSA', index=1, number=1,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='ECDSA', index=2, number=3,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='ED25519', index=3, number=7,
-      serialized_options=None,
-      type=None),
-  ],
-  containing_type=None,
-  serialized_options=None,
-  serialized_start=247,
-  serialized_end=315,
-)
-_sym_db.RegisterEnumDescriptor(_DIGITALLYSIGNED_SIGNATUREALGORITHM)
-
-
-_DIGITALLYSIGNED = _descriptor.Descriptor(
-  name='DigitallySigned',
-  full_name='sigpb.DigitallySigned',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='hash_algorithm', full_name='sigpb.DigitallySigned.hash_algorithm', index=0,
-      number=1, type=14, cpp_type=8, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='signature_algorithm', full_name='sigpb.DigitallySigned.signature_algorithm', index=1,
-      number=2, type=14, cpp_type=8, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='signature', full_name='sigpb.DigitallySigned.signature', index=2,
-      number=3, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-    _DIGITALLYSIGNED_HASHALGORITHM,
-    _DIGITALLYSIGNED_SIGNATUREALGORITHM,
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=36,
-  serialized_end=315,
-)
-
-_DIGITALLYSIGNED.fields_by_name['hash_algorithm'].enum_type = _DIGITALLYSIGNED_HASHALGORITHM
-_DIGITALLYSIGNED.fields_by_name['signature_algorithm'].enum_type = _DIGITALLYSIGNED_SIGNATUREALGORITHM
-_DIGITALLYSIGNED_HASHALGORITHM.containing_type = _DIGITALLYSIGNED
-_DIGITALLYSIGNED_SIGNATUREALGORITHM.containing_type = _DIGITALLYSIGNED
-DESCRIPTOR.message_types_by_name['DigitallySigned'] = _DIGITALLYSIGNED
-_sym_db.RegisterFileDescriptor(DESCRIPTOR)
-
-DigitallySigned = _reflection.GeneratedProtocolMessageType('DigitallySigned', (_message.Message,), {
-  'DESCRIPTOR' : _DIGITALLYSIGNED,
-  '__module__' : 'crypto.sigpb.sigpb_pb2'
-  # @@protoc_insertion_point(class_scope:sigpb.DigitallySigned)
-  })
-_sym_db.RegisterMessage(DigitallySigned)
-
-
-DESCRIPTOR._options = None
-# @@protoc_insertion_point(module_scope)
diff --git a/proto/crypto/sigpb/sigpb_pb2_grpc.py b/proto/crypto/sigpb/sigpb_pb2_grpc.py
deleted file mode 100644
index 73636b2..0000000
--- a/proto/crypto/sigpb/sigpb_pb2_grpc.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# pylint: skip-file
-# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
-import grpc
-
diff --git a/proto/trillian.proto b/proto/trillian.proto
deleted file mode 100644
index e14522f..0000000
--- a/proto/trillian.proto
+++ /dev/null
@@ -1,316 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-
-option java_multiple_files = true;
-option java_package = "com.google.trillian.proto";
-option java_outer_classname = "TrillianProto";
-option go_package = "github.com/google/trillian";
-
-package trillian;
-
-import "crypto/keyspb/keyspb.proto";
-import "crypto/sigpb/sigpb.proto";
-import "google/protobuf/any.proto";
-import "google/protobuf/duration.proto";
-import "google/protobuf/timestamp.proto";
-
-// LogRootFormat specifies the fields that are covered by the
-// SignedLogRoot signature, as well as their ordering and formats.
-enum LogRootFormat {
-  LOG_ROOT_FORMAT_UNKNOWN = 0;
-  LOG_ROOT_FORMAT_V1 = 1;
-}
-
-// MapRootFormat specifies the fields that are covered by the
-// SignedMapRoot signature, as well as their ordering and formats.
-enum MapRootFormat {
-  MAP_ROOT_FORMAT_UNKNOWN = 0;
-  MAP_ROOT_FORMAT_V1 = 1;
-}
-
-// What goes in here?
-// Things which are exposed through the public trillian APIs.
-
-// Defines the way empty / node / leaf hashes are constructed incorporating
-// preimage protection, which can be application specific.
-enum HashStrategy {
-  // Hash strategy cannot be determined. Included to enable detection of
-  // mismatched proto versions being used. Represents an invalid value.
-  UNKNOWN_HASH_STRATEGY = 0;
-
-  // Certificate Transparency strategy: leaf hash prefix = 0x00, node prefix =
-  // 0x01, empty hash is digest([]byte{}), as defined in the specification.
-  RFC6962_SHA256 = 1;
-
-  // Sparse Merkle Tree strategy:  leaf hash prefix = 0x00, node prefix = 0x01,
-  // empty branch is recursively computed from empty leaf nodes.
-  // NOT secure in a multi tree environment. For testing only.
-  TEST_MAP_HASHER = 2;
-
-  // Append-only log strategy where leaf nodes are defined as the ObjectHash.
-  // All other properties are equal to RFC6962_SHA256.
-  OBJECT_RFC6962_SHA256 = 3;
-
-  // The CONIKS sparse tree hasher with SHA512_256 as the hash algorithm.
-  CONIKS_SHA512_256 = 4;
-
-  // The CONIKS sparse tree hasher with SHA256 as the hash algorithm.
-  CONIKS_SHA256 = 5;
-}
-
-// State of the tree.
-enum TreeState {
-  // Tree state cannot be determined. Included to enable detection of
-  // mismatched proto versions being used. Represents an invalid value.
-  UNKNOWN_TREE_STATE = 0;
-
-  // Active trees are able to respond to both read and write requests.
-  ACTIVE = 1;
-
-  // Frozen trees are only able to respond to read requests, writing to a frozen
-  // tree is forbidden. Trees should not be frozen when there are entries
-  // in the queue that have not yet been integrated. See the DRAINING
-  // state for this case.
-  FROZEN = 2;
-
-  // Deprecated: now tracked in Tree.deleted.
-  DEPRECATED_SOFT_DELETED = 3 [deprecated = true];
-
-  // Deprecated: now tracked in Tree.deleted.
-  DEPRECATED_HARD_DELETED = 4 [deprecated = true];
-
-  // A tree that is draining will continue to integrate queued entries.
-  // No new entries should be accepted.
-  DRAINING = 5;
-}
-
-// Type of the tree.
-enum TreeType {
-  // Tree type cannot be determined. Included to enable detection of mismatched
-  // proto versions being used. Represents an invalid value.
-  UNKNOWN_TREE_TYPE = 0;
-
-  // Tree represents a verifiable log.
-  LOG = 1;
-
-  // Tree represents a verifiable map.
-  MAP = 2;
-
-  // Tree represents a verifiable pre-ordered log, i.e., a log whose entries are
-  // placed according to sequence numbers assigned outside of Trillian.
-  PREORDERED_LOG = 3;
-}
-
-// Represents a tree, which may be either a verifiable log or map.
-// Readonly attributes are assigned at tree creation, after which they may not
-// be modified.
-//
-// Note: Many APIs within the rest of the code require these objects to
-// be provided. For safety they should be obtained via Admin API calls and
-// not created dynamically.
-message Tree {
-  // ID of the tree.
-  // Readonly.
-  int64 tree_id = 1;
-
-  // State of the tree.
-  // Trees are ACTIVE after creation. At any point the tree may transition
-  // between ACTIVE, DRAINING and FROZEN states.
-  TreeState tree_state = 2;
-
-  // Type of the tree.
-  // Readonly after Tree creation. Exception: Can be switched from
-  // PREORDERED_LOG to LOG if the Tree is and remains in the FROZEN state.
-  TreeType tree_type = 3;
-
-  // Hash strategy to be used by the tree.
-  // Readonly.
-  HashStrategy hash_strategy = 4;
-
-  // Hash algorithm to be used by the tree.
-  // Readonly.
-  sigpb.DigitallySigned.HashAlgorithm hash_algorithm = 5;
-
-  // Signature algorithm to be used by the tree.
-  // Readonly.
-  sigpb.DigitallySigned.SignatureAlgorithm signature_algorithm = 6;
-
-  reserved 18;  // Signature cipher suite (removed)
-  reserved 7;   // DuplicatePolicy (removed)
-
-  // Display name of the tree.
-  // Optional.
-  string display_name = 8;
-
-  // Description of the tree,
-  // Optional.
-  string description = 9;
-
-  reserved 10;  // create_time_millis_since_epoch (removed)
-  reserved 11;  // update_time_millis_since_epoch (removed)
-
-  // Identifies the private key used for signing tree heads and entry
-  // timestamps.
-  // This can be any type of message to accommodate different key management
-  // systems, e.g. PEM files, HSMs, etc.
-  // Private keys are write-only: they're never returned by RPCs.
-  // The private_key message can be changed after a tree is created, but the
-  // underlying key must remain the same - this is to enable migrating a key
-  // from one provider to another.
-  google.protobuf.Any private_key = 12;
-
-  // Storage-specific settings.
-  // Varies according to the storage implementation backing Trillian.
-  google.protobuf.Any storage_settings = 13;
-
-  // The public key used for verifying tree heads and entry timestamps.
-  // Readonly.
-  keyspb.PublicKey public_key = 14;
-
-  // Interval after which a new signed root is produced even if there have been
-  // no submission.  If zero, this behavior is disabled.
-  google.protobuf.Duration max_root_duration = 15;
-
-  // Time of tree creation.
-  // Readonly.
-  google.protobuf.Timestamp create_time = 16;
-
-  // Time of last tree update.
-  // Readonly (automatically assigned on updates).
-  google.protobuf.Timestamp update_time = 17;
-
-  // If true, the tree has been deleted.
-  // Deleted trees may be undeleted during a certain time window, after which
-  // they're permanently deleted (and unrecoverable).
-  // Readonly.
-  bool deleted = 19;
-
-  // Time of tree deletion, if any.
-  // Readonly.
-  google.protobuf.Timestamp delete_time = 20;
-}
-
-message SignedEntryTimestamp {
-  int64 timestamp_nanos = 1;
-  int64 log_id = 2;
-  sigpb.DigitallySigned signature = 3;
-}
-
-// SignedLogRoot represents a commitment by a Log to a particular tree.
-message SignedLogRoot {
-  // Deleted: TimestampNanos moved to LogRoot.
-  reserved 1;
-  // Deleted: RootHash moved to LogRoot.
-  reserved 2;
-  // Deleted: TreeSize moved to LogRoot.
-  reserved 3;
-  // Deleted: Signature replaced by LogRootSignature.
-  reserved 4;
-  // Deleted: LogID is associated with the public key that validates signature.
-  reserved 5;
-  // Deleted: TreeRevision moved to LogRoot.
-  reserved 6;
-
-  // key_hint is a hint to identify the public key for signature verification.
-  // key_hint is not authenticated and may be incorrect or missing, in which
-  // case all known public keys may be used to verify the signature.
-  // When directly communicating with a Trillian gRPC server, the key_hint will
-  // typically contain the LogID encoded as a big-endian 64-bit integer;
-  // however, in other contexts the key_hint is likely to have different
-  // contents (e.g. it could be a GUID, a URL + TreeID, or it could be
-  // derived from the public key itself).
-  bytes key_hint = 7;
-
-  // log_root holds the TLS-serialization of the following structure (described
-  // in RFC5246 notation): Clients should validate log_root_signature with
-  // VerifySignedLogRoot before deserializing log_root.
-  // enum { v1(1), (65535)} Version;
-  // struct {
-  //   uint64 tree_size;
-  //   opaque root_hash<0..128>;
-  //   uint64 timestamp_nanos;
-  //   uint64 revision;
-  //   opaque metadata<0..65535>;
-  // } LogRootV1;
-  // struct {
-  //   Version version;
-  //   select(version) {
-  //     case v1: LogRootV1;
-  //   }
-  // } LogRoot;
-  //
-  // A serialized v1 log root will therefore be laid out as:
-  //
-  // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+-....--+
-  // | ver=1 |          tree_size            |len|    root_hashlen   |
-  // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+-....--+
-  //
-  // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-  // |        timestamp_nanos        |      revision                 |
-  // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-  //
-  // +---+---+---+---+---+-....---+
-  // |  len  |    metadata        |
-  // +---+---+---+---+---+-....---+
-  //
-  // (with all integers encoded big-endian).
-  bytes log_root = 8;
-
-  // log_root_signature is the raw signature over log_root.
-  bytes log_root_signature = 9;
-}
-
-// SignedMapRoot represents a commitment by a Map to a particular tree.
-message SignedMapRoot {
-  reserved 1;  // Deprecated: Was timestamp_nanos. Use map_root.
-  reserved 2;  // Deprecated: Was root_hash. Use map_root.
-  reserved 3;  // Deprecated: Was MapperMetadata. Use map_root.
-  reserved 5;  // Deprecated: Was map_id. Use signature.
-  reserved 6;  // Deprecated: Was map_revision. Use map_root.
-  reserved 7;  // Deprecated: Was metadata Any. Use map_root.
-  reserved 8;  // Deprecated: Was metadata bytes. Use map_root.
-
-  // map_root holds the TLS-serialization of the following structure (described
-  // in RFC5246 notation): Clients should validate signature with
-  // VerifySignedMapRoot before deserializing map_root.
-  // enum { v1(1), (65535)} Version;
-  // struct {
-  //   opaque root_hash<0..128>;
-  //   uint64 timestamp_nanos;
-  //   uint64 revision;
-  //   opaque metadata<0..65535>;
-  // } MapRootV1;
-  // struct {
-  //   Version version;
-  //   select(version) {
-  //     case v1: MapRootV1;
-  //   }
-  // } MapRoot;
-  bytes map_root = 9;
-  // Signature is the raw signature over MapRoot.
-  bytes signature = 4;
-}
-
-// Proof holds a consistency or inclusion proof for a Merkle tree, as returned
-// by the API.
-message Proof {
-  // leaf_index indicates the requested leaf index when this message is used for
-  // a leaf inclusion proof.  This field is set to zero when this message is
-  // used for a consistency proof.
-  int64 leaf_index = 1;
-  reserved 2; // Contained internal node details (removed)
-  repeated bytes hashes = 3;
-}
diff --git a/proto/trillian_pb2.py b/proto/trillian_pb2.py
deleted file mode 100644
index 4c7ddd6..0000000
--- a/proto/trillian_pb2.py
+++ /dev/null
@@ -1,576 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: trillian.proto
-
-import sys
-_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
-from google.protobuf.internal import enum_type_wrapper
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import message as _message
-from google.protobuf import reflection as _reflection
-from google.protobuf import symbol_database as _symbol_database
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-from crypto.keyspb import keyspb_pb2 as crypto_dot_keyspb_dot_keyspb__pb2
-from crypto.sigpb import sigpb_pb2 as crypto_dot_sigpb_dot_sigpb__pb2
-from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2
-from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2
-from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
-
-
-DESCRIPTOR = _descriptor.FileDescriptor(
-  name='trillian.proto',
-  package='trillian',
-  syntax='proto3',
-  serialized_options=_b('\n\031com.google.trillian.protoB\rTrillianProtoP\001Z\032github.com/google/trillian'),
-  serialized_pb=_b('\n\x0etrillian.proto\x12\x08trillian\x1a\x1a\x63rypto/keyspb/keyspb.proto\x1a\x18\x63rypto/sigpb/sigpb.proto\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xbb\x05\n\x04Tree\x12\x0f\n\x07tree_id\x18\x01 \x01(\x03\x12\'\n\ntree_state\x18\x02 \x01(\x0e\x32\x13.trillian.TreeState\x12%\n\ttree_type\x18\x03 \x01(\x0e\x32\x12.trillian.TreeType\x12-\n\rhash_strategy\x18\x04 \x01(\x0e\x32\x16.trillian.HashStrategy\x12<\n\x0ehash_algorithm\x18\x05 \x01(\x0e\x32$.sigpb.DigitallySigned.HashAlgorithm\x12\x46\n\x13signature_algorithm\x18\x06 \x01(\x0e\x32).sigpb.DigitallySigned.SignatureAlgorithm\x12\x14\n\x0c\x64isplay_name\x18\x08 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\t \x01(\t\x12)\n\x0bprivate_key\x18\x0c \x01(\x0b\x32\x14.google.protobuf.Any\x12.\n\x10storage_settings\x18\r \x01(\x0b\x32\x14.google.protobuf.Any\x12%\n\npublic_key\x18\x0e \x01(\x0b\x32\x11.keyspb.PublicKey\x12\x34\n\x11max_root_duration\x18\x0f \x01(\x0b\x32\x19.google.protobuf.Duration\x12/\n\x0b\x63reate_time\x18\x10 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12/\n\x0bupdate_time\x18\x11 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07\x64\x65leted\x18\x13 \x01(\x08\x12/\n\x0b\x64\x65lete_time\x18\x14 \x01(\x0b\x32\x1a.google.protobuf.TimestampJ\x04\x08\x12\x10\x13J\x04\x08\x07\x10\x08J\x04\x08\n\x10\x0bJ\x04\x08\x0b\x10\x0c\"j\n\x14SignedEntryTimestamp\x12\x17\n\x0ftimestamp_nanos\x18\x01 \x01(\x03\x12\x0e\n\x06log_id\x18\x02 \x01(\x03\x12)\n\tsignature\x18\x03 \x01(\x0b\x32\x16.sigpb.DigitallySigned\"s\n\rSignedLogRoot\x12\x10\n\x08key_hint\x18\x07 \x01(\x0c\x12\x10\n\x08log_root\x18\x08 \x01(\x0c\x12\x1a\n\x12log_root_signature\x18\t \x01(\x0cJ\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03J\x04\x08\x03\x10\x04J\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07\"^\n\rSignedMapRoot\x12\x10\n\x08map_root\x18\t \x01(\x0c\x12\x11\n\tsignature\x18\x04 \x01(\x0cJ\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03J\x04\x08\x03\x10\x04J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07J\x04\x08\x07\x10\x08J\x04\x08\x08\x10\t\"1\n\x05Proof\x12\x12\n\nleaf_index\x18\x01 \x01(\x03\x12\x0e\n\x06hashes\x18\x03 \x03(\x0cJ\x04\x08\x02\x10\x03*D\n\rLogRootFormat\x12\x1b\n\x17LOG_ROOT_FORMAT_UNKNOWN\x10\x00\x12\x16\n\x12LOG_ROOT_FORMAT_V1\x10\x01*D\n\rMapRootFormat\x12\x1b\n\x17MAP_ROOT_FORMAT_UNKNOWN\x10\x00\x12\x16\n\x12MAP_ROOT_FORMAT_V1\x10\x01*\x97\x01\n\x0cHashStrategy\x12\x19\n\x15UNKNOWN_HASH_STRATEGY\x10\x00\x12\x12\n\x0eRFC6962_SHA256\x10\x01\x12\x13\n\x0fTEST_MAP_HASHER\x10\x02\x12\x19\n\x15OBJECT_RFC6962_SHA256\x10\x03\x12\x15\n\x11\x43ONIKS_SHA512_256\x10\x04\x12\x11\n\rCONIKS_SHA256\x10\x05*\x8b\x01\n\tTreeState\x12\x16\n\x12UNKNOWN_TREE_STATE\x10\x00\x12\n\n\x06\x41\x43TIVE\x10\x01\x12\n\n\x06\x46ROZEN\x10\x02\x12\x1f\n\x17\x44\x45PRECATED_SOFT_DELETED\x10\x03\x1a\x02\x08\x01\x12\x1f\n\x17\x44\x45PRECATED_HARD_DELETED\x10\x04\x1a\x02\x08\x01\x12\x0c\n\x08\x44RAINING\x10\x05*G\n\x08TreeType\x12\x15\n\x11UNKNOWN_TREE_TYPE\x10\x00\x12\x07\n\x03LOG\x10\x01\x12\x07\n\x03MAP\x10\x02\x12\x12\n\x0ePREORDERED_LOG\x10\x03\x42H\n\x19\x63om.google.trillian.protoB\rTrillianProtoP\x01Z\x1agithub.com/google/trillianb\x06proto3')
-  ,
-  dependencies=[crypto_dot_keyspb_dot_keyspb__pb2.DESCRIPTOR,crypto_dot_sigpb_dot_sigpb__pb2.DESCRIPTOR,google_dot_protobuf_dot_any__pb2.DESCRIPTOR,google_dot_protobuf_dot_duration__pb2.DESCRIPTOR,google_dot_protobuf_dot_timestamp__pb2.DESCRIPTOR,])
-
-_LOGROOTFORMAT = _descriptor.EnumDescriptor(
-  name='LogRootFormat',
-  full_name='trillian.LogRootFormat',
-  filename=None,
-  file=DESCRIPTOR,
-  values=[
-    _descriptor.EnumValueDescriptor(
-      name='LOG_ROOT_FORMAT_UNKNOWN', index=0, number=0,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='LOG_ROOT_FORMAT_V1', index=1, number=1,
-      serialized_options=None,
-      type=None),
-  ],
-  containing_type=None,
-  serialized_options=None,
-  serialized_start=1248,
-  serialized_end=1316,
-)
-_sym_db.RegisterEnumDescriptor(_LOGROOTFORMAT)
-
-LogRootFormat = enum_type_wrapper.EnumTypeWrapper(_LOGROOTFORMAT)
-_MAPROOTFORMAT = _descriptor.EnumDescriptor(
-  name='MapRootFormat',
-  full_name='trillian.MapRootFormat',
-  filename=None,
-  file=DESCRIPTOR,
-  values=[
-    _descriptor.EnumValueDescriptor(
-      name='MAP_ROOT_FORMAT_UNKNOWN', index=0, number=0,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='MAP_ROOT_FORMAT_V1', index=1, number=1,
-      serialized_options=None,
-      type=None),
-  ],
-  containing_type=None,
-  serialized_options=None,
-  serialized_start=1318,
-  serialized_end=1386,
-)
-_sym_db.RegisterEnumDescriptor(_MAPROOTFORMAT)
-
-MapRootFormat = enum_type_wrapper.EnumTypeWrapper(_MAPROOTFORMAT)
-_HASHSTRATEGY = _descriptor.EnumDescriptor(
-  name='HashStrategy',
-  full_name='trillian.HashStrategy',
-  filename=None,
-  file=DESCRIPTOR,
-  values=[
-    _descriptor.EnumValueDescriptor(
-      name='UNKNOWN_HASH_STRATEGY', index=0, number=0,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='RFC6962_SHA256', index=1, number=1,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='TEST_MAP_HASHER', index=2, number=2,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='OBJECT_RFC6962_SHA256', index=3, number=3,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='CONIKS_SHA512_256', index=4, number=4,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='CONIKS_SHA256', index=5, number=5,
-      serialized_options=None,
-      type=None),
-  ],
-  containing_type=None,
-  serialized_options=None,
-  serialized_start=1389,
-  serialized_end=1540,
-)
-_sym_db.RegisterEnumDescriptor(_HASHSTRATEGY)
-
-HashStrategy = enum_type_wrapper.EnumTypeWrapper(_HASHSTRATEGY)
-_TREESTATE = _descriptor.EnumDescriptor(
-  name='TreeState',
-  full_name='trillian.TreeState',
-  filename=None,
-  file=DESCRIPTOR,
-  values=[
-    _descriptor.EnumValueDescriptor(
-      name='UNKNOWN_TREE_STATE', index=0, number=0,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='ACTIVE', index=1, number=1,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='FROZEN', index=2, number=2,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='DEPRECATED_SOFT_DELETED', index=3, number=3,
-      serialized_options=_b('\010\001'),
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='DEPRECATED_HARD_DELETED', index=4, number=4,
-      serialized_options=_b('\010\001'),
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='DRAINING', index=5, number=5,
-      serialized_options=None,
-      type=None),
-  ],
-  containing_type=None,
-  serialized_options=None,
-  serialized_start=1543,
-  serialized_end=1682,
-)
-_sym_db.RegisterEnumDescriptor(_TREESTATE)
-
-TreeState = enum_type_wrapper.EnumTypeWrapper(_TREESTATE)
-_TREETYPE = _descriptor.EnumDescriptor(
-  name='TreeType',
-  full_name='trillian.TreeType',
-  filename=None,
-  file=DESCRIPTOR,
-  values=[
-    _descriptor.EnumValueDescriptor(
-      name='UNKNOWN_TREE_TYPE', index=0, number=0,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='LOG', index=1, number=1,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='MAP', index=2, number=2,
-      serialized_options=None,
-      type=None),
-    _descriptor.EnumValueDescriptor(
-      name='PREORDERED_LOG', index=3, number=3,
-      serialized_options=None,
-      type=None),
-  ],
-  containing_type=None,
-  serialized_options=None,
-  serialized_start=1684,
-  serialized_end=1755,
-)
-_sym_db.RegisterEnumDescriptor(_TREETYPE)
-
-TreeType = enum_type_wrapper.EnumTypeWrapper(_TREETYPE)
-LOG_ROOT_FORMAT_UNKNOWN = 0
-LOG_ROOT_FORMAT_V1 = 1
-MAP_ROOT_FORMAT_UNKNOWN = 0
-MAP_ROOT_FORMAT_V1 = 1
-UNKNOWN_HASH_STRATEGY = 0
-RFC6962_SHA256 = 1
-TEST_MAP_HASHER = 2
-OBJECT_RFC6962_SHA256 = 3
-CONIKS_SHA512_256 = 4
-CONIKS_SHA256 = 5
-UNKNOWN_TREE_STATE = 0
-ACTIVE = 1
-FROZEN = 2
-DEPRECATED_SOFT_DELETED = 3
-DEPRECATED_HARD_DELETED = 4
-DRAINING = 5
-UNKNOWN_TREE_TYPE = 0
-LOG = 1
-MAP = 2
-PREORDERED_LOG = 3
-
-
-
-_TREE = _descriptor.Descriptor(
-  name='Tree',
-  full_name='trillian.Tree',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='tree_id', full_name='trillian.Tree.tree_id', index=0,
-      number=1, type=3, cpp_type=2, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='tree_state', full_name='trillian.Tree.tree_state', index=1,
-      number=2, type=14, cpp_type=8, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='tree_type', full_name='trillian.Tree.tree_type', index=2,
-      number=3, type=14, cpp_type=8, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='hash_strategy', full_name='trillian.Tree.hash_strategy', index=3,
-      number=4, type=14, cpp_type=8, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='hash_algorithm', full_name='trillian.Tree.hash_algorithm', index=4,
-      number=5, type=14, cpp_type=8, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='signature_algorithm', full_name='trillian.Tree.signature_algorithm', index=5,
-      number=6, type=14, cpp_type=8, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='display_name', full_name='trillian.Tree.display_name', index=6,
-      number=8, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='description', full_name='trillian.Tree.description', index=7,
-      number=9, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='private_key', full_name='trillian.Tree.private_key', index=8,
-      number=12, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='storage_settings', full_name='trillian.Tree.storage_settings', index=9,
-      number=13, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='public_key', full_name='trillian.Tree.public_key', index=10,
-      number=14, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='max_root_duration', full_name='trillian.Tree.max_root_duration', index=11,
-      number=15, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='create_time', full_name='trillian.Tree.create_time', index=12,
-      number=16, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='update_time', full_name='trillian.Tree.update_time', index=13,
-      number=17, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='deleted', full_name='trillian.Tree.deleted', index=14,
-      number=19, type=8, cpp_type=7, label=1,
-      has_default_value=False, default_value=False,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='delete_time', full_name='trillian.Tree.delete_time', index=15,
-      number=20, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=175,
-  serialized_end=874,
-)
-
-
-_SIGNEDENTRYTIMESTAMP = _descriptor.Descriptor(
-  name='SignedEntryTimestamp',
-  full_name='trillian.SignedEntryTimestamp',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='timestamp_nanos', full_name='trillian.SignedEntryTimestamp.timestamp_nanos', index=0,
-      number=1, type=3, cpp_type=2, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='log_id', full_name='trillian.SignedEntryTimestamp.log_id', index=1,
-      number=2, type=3, cpp_type=2, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='signature', full_name='trillian.SignedEntryTimestamp.signature', index=2,
-      number=3, type=11, cpp_type=10, label=1,
-      has_default_value=False, default_value=None,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=876,
-  serialized_end=982,
-)
-
-
-_SIGNEDLOGROOT = _descriptor.Descriptor(
-  name='SignedLogRoot',
-  full_name='trillian.SignedLogRoot',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='key_hint', full_name='trillian.SignedLogRoot.key_hint', index=0,
-      number=7, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='log_root', full_name='trillian.SignedLogRoot.log_root', index=1,
-      number=8, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='log_root_signature', full_name='trillian.SignedLogRoot.log_root_signature', index=2,
-      number=9, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=984,
-  serialized_end=1099,
-)
-
-
-_SIGNEDMAPROOT = _descriptor.Descriptor(
-  name='SignedMapRoot',
-  full_name='trillian.SignedMapRoot',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='map_root', full_name='trillian.SignedMapRoot.map_root', index=0,
-      number=9, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='signature', full_name='trillian.SignedMapRoot.signature', index=1,
-      number=4, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b(""),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=1101,
-  serialized_end=1195,
-)
-
-
-_PROOF = _descriptor.Descriptor(
-  name='Proof',
-  full_name='trillian.Proof',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='leaf_index', full_name='trillian.Proof.leaf_index', index=0,
-      number=1, type=3, cpp_type=2, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='hashes', full_name='trillian.Proof.hashes', index=1,
-      number=3, type=12, cpp_type=9, label=3,
-      has_default_value=False, default_value=[],
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=1197,
-  serialized_end=1246,
-)
-
-_TREE.fields_by_name['tree_state'].enum_type = _TREESTATE
-_TREE.fields_by_name['tree_type'].enum_type = _TREETYPE
-_TREE.fields_by_name['hash_strategy'].enum_type = _HASHSTRATEGY
-_TREE.fields_by_name['hash_algorithm'].enum_type = crypto_dot_sigpb_dot_sigpb__pb2._DIGITALLYSIGNED_HASHALGORITHM
-_TREE.fields_by_name['signature_algorithm'].enum_type = crypto_dot_sigpb_dot_sigpb__pb2._DIGITALLYSIGNED_SIGNATUREALGORITHM
-_TREE.fields_by_name['private_key'].message_type = google_dot_protobuf_dot_any__pb2._ANY
-_TREE.fields_by_name['storage_settings'].message_type = google_dot_protobuf_dot_any__pb2._ANY
-_TREE.fields_by_name['public_key'].message_type = crypto_dot_keyspb_dot_keyspb__pb2._PUBLICKEY
-_TREE.fields_by_name['max_root_duration'].message_type = google_dot_protobuf_dot_duration__pb2._DURATION
-_TREE.fields_by_name['create_time'].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
-_TREE.fields_by_name['update_time'].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
-_TREE.fields_by_name['delete_time'].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP
-_SIGNEDENTRYTIMESTAMP.fields_by_name['signature'].message_type = crypto_dot_sigpb_dot_sigpb__pb2._DIGITALLYSIGNED
-DESCRIPTOR.message_types_by_name['Tree'] = _TREE
-DESCRIPTOR.message_types_by_name['SignedEntryTimestamp'] = _SIGNEDENTRYTIMESTAMP
-DESCRIPTOR.message_types_by_name['SignedLogRoot'] = _SIGNEDLOGROOT
-DESCRIPTOR.message_types_by_name['SignedMapRoot'] = _SIGNEDMAPROOT
-DESCRIPTOR.message_types_by_name['Proof'] = _PROOF
-DESCRIPTOR.enum_types_by_name['LogRootFormat'] = _LOGROOTFORMAT
-DESCRIPTOR.enum_types_by_name['MapRootFormat'] = _MAPROOTFORMAT
-DESCRIPTOR.enum_types_by_name['HashStrategy'] = _HASHSTRATEGY
-DESCRIPTOR.enum_types_by_name['TreeState'] = _TREESTATE
-DESCRIPTOR.enum_types_by_name['TreeType'] = _TREETYPE
-_sym_db.RegisterFileDescriptor(DESCRIPTOR)
-
-Tree = _reflection.GeneratedProtocolMessageType('Tree', (_message.Message,), {
-  'DESCRIPTOR' : _TREE,
-  '__module__' : 'trillian_pb2'
-  # @@protoc_insertion_point(class_scope:trillian.Tree)
-  })
-_sym_db.RegisterMessage(Tree)
-
-SignedEntryTimestamp = _reflection.GeneratedProtocolMessageType('SignedEntryTimestamp', (_message.Message,), {
-  'DESCRIPTOR' : _SIGNEDENTRYTIMESTAMP,
-  '__module__' : 'trillian_pb2'
-  # @@protoc_insertion_point(class_scope:trillian.SignedEntryTimestamp)
-  })
-_sym_db.RegisterMessage(SignedEntryTimestamp)
-
-SignedLogRoot = _reflection.GeneratedProtocolMessageType('SignedLogRoot', (_message.Message,), {
-  'DESCRIPTOR' : _SIGNEDLOGROOT,
-  '__module__' : 'trillian_pb2'
-  # @@protoc_insertion_point(class_scope:trillian.SignedLogRoot)
-  })
-_sym_db.RegisterMessage(SignedLogRoot)
-
-SignedMapRoot = _reflection.GeneratedProtocolMessageType('SignedMapRoot', (_message.Message,), {
-  'DESCRIPTOR' : _SIGNEDMAPROOT,
-  '__module__' : 'trillian_pb2'
-  # @@protoc_insertion_point(class_scope:trillian.SignedMapRoot)
-  })
-_sym_db.RegisterMessage(SignedMapRoot)
-
-Proof = _reflection.GeneratedProtocolMessageType('Proof', (_message.Message,), {
-  'DESCRIPTOR' : _PROOF,
-  '__module__' : 'trillian_pb2'
-  # @@protoc_insertion_point(class_scope:trillian.Proof)
-  })
-_sym_db.RegisterMessage(Proof)
-
-
-DESCRIPTOR._options = None
-_TREESTATE.values_by_name["DEPRECATED_SOFT_DELETED"]._options = None
-_TREESTATE.values_by_name["DEPRECATED_HARD_DELETED"]._options = None
-# @@protoc_insertion_point(module_scope)
diff --git a/proto/trillian_pb2_grpc.py b/proto/trillian_pb2_grpc.py
deleted file mode 100644
index a894352..0000000
--- a/proto/trillian_pb2_grpc.py
+++ /dev/null
@@ -1,3 +0,0 @@
-# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
-import grpc
-
diff --git a/test/avb_aftl_fuzz.cc b/test/avb_aftl_fuzz.cc
deleted file mode 100644
index 89b59d8..0000000
--- a/test/avb_aftl_fuzz.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "libavb_aftl/avb_aftl_types.h"
-#include "libavb_aftl/avb_aftl_util.h"
-
-extern "C" int LLVMFuzzerTestOneInput(const char* data, size_t size) {
-  AftlImage* image = parse_aftl_image((uint8_t*)data, size);
-  free_aftl_image(image);
-  return 0;
-}
diff --git a/test/avb_aftl_util_unittest.cc b/test/avb_aftl_util_unittest.cc
deleted file mode 100644
index 33a598c..0000000
--- a/test/avb_aftl_util_unittest.cc
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "libavb_aftl/avb_aftl_util.h"
-#include <libavb_aftl/libavb_aftl.h>
-#include "avb_unittest_util.h"
-#include "libavb_aftl/avb_aftl_types.h"
-
-namespace {
-
-/* TODO(b/154115873): These VBMetas are manually generated. We need to implement
- * a mock in aftltool that generates an inclusion proof and call that mock from
- * the unit tests, similarly to what is done with GenerateVBMetaImage. */
-const char kAftlImagePath[] = "test/data/aftl_output_vbmeta_with_1_icp.img";
-const uint64_t kAftlImageOffset = 0x1100;
-const char kAftlImageMultiPath[] =
-    "test/data/aftl_output_vbmeta_with_2_icp_same_log.img";
-
-}  // namespace
-
-namespace avb {
-/* Extend BaseAvbToolTest to take advantage of common checks and tooling. */
-class AvbAftlUtilTest : public BaseAvbToolTest {
- public:
-  AvbAftlUtilTest() {}
-  ~AvbAftlUtilTest() {}
-  void SetUp() override {
-    std::string content;
-
-    BaseAvbToolTest::SetUp();
-    /* Read in test data from the aftl_image binaries. */
-    ASSERT_TRUE(
-        base::ReadFileToString(base::FilePath(kAftlImagePath), &content));
-    content = content.substr(kAftlImageOffset);
-    /* Allocate and populate an AftlImage for testing. */
-    aftl_image_ = parse_aftl_image((uint8_t*)content.data(), content.size());
-
-    /* Read in test data from the aftl_image file with multiple ICPs. */
-    ASSERT_TRUE(
-        base::ReadFileToString(base::FilePath(kAftlImageMultiPath), &content));
-    content = content.substr(kAftlImageOffset);
-    /* Allocate and populate an AftlImage for testing. */
-    aftl_image_multi_ =
-        parse_aftl_image((uint8_t*)content.data(), content.size());
-  }
-
-  void TearDown() override {
-    free_aftl_image(aftl_image_);
-    free_aftl_image(aftl_image_multi_);
-    BaseAvbToolTest::TearDown();
-  }
-
-  void TestAftlImageHeader(AftlImageHeader* aftl_header, uint16_t icp_count) {
-    EXPECT_EQ(aftl_header->magic, 0x4c544641ul);
-    EXPECT_EQ(aftl_header->required_icp_version_major, 1ul);
-    EXPECT_EQ(aftl_header->required_icp_version_minor, 2ul);
-    EXPECT_EQ(aftl_header->icp_count, icp_count);
-  }
-
-  void TestAftlIcpEntry(AftlIcpEntry* icp_entry) {
-    /* Test each field in the AftlIcpEntry. */
-    EXPECT_GT(icp_entry->log_url_size, 0ul);
-    EXPECT_GT(icp_entry->leaf_index, 1ul);
-    EXPECT_GT(icp_entry->log_root_descriptor_size, 0ul);
-    EXPECT_GT(icp_entry->annotation_leaf_size, 0ul);
-    EXPECT_EQ(icp_entry->log_root_sig_size, AVB_AFTL_SIGNATURE_SIZE);
-    EXPECT_GT(icp_entry->proof_hash_count, 0ul);
-    EXPECT_LT(icp_entry->proof_hash_count, 64ul);
-    EXPECT_GT(icp_entry->inc_proof_size, 0ul);
-    EXPECT_EQ(mem_to_hexstring(icp_entry->log_url, 8), "6c6f672e656e6470");
-    /* Test the TrillianLogRootDescriptor fields. */
-    EXPECT_EQ(icp_entry->log_root_descriptor.version, 1ul);
-    EXPECT_GT(icp_entry->log_root_descriptor.tree_size, 0ull);
-    EXPECT_EQ(icp_entry->log_root_descriptor.root_hash_size,
-              AVB_AFTL_HASH_SIZE);
-    EXPECT_GT(icp_entry->log_root_descriptor.timestamp, 0ull);
-    EXPECT_GT(icp_entry->log_root_descriptor.revision, 0ull);
-    EXPECT_EQ(icp_entry->log_root_descriptor.metadata_size, 0);
-    /* Test the FirmwareInfo fields. */
-    EXPECT_EQ(icp_entry->annotation_leaf->annotation->vbmeta_hash_size,
-              AVB_AFTL_HASH_SIZE);
-    EXPECT_EQ(icp_entry->proof_hash_count * 32ul, icp_entry->inc_proof_size);
-  }
-
- protected:
-  AftlImage* aftl_image_;
-  AftlImage* aftl_image_multi_;
-};
-
-TEST_F(AvbAftlUtilTest, AftlImageHeaderStructure) {
-  AftlImageHeader* header;
-  ASSERT_NE(aftl_image_, nullptr);
-  header = &(aftl_image_->header);
-  ASSERT_NE(header, nullptr);
-  TestAftlImageHeader(header, 1);
-}
-
-TEST_F(AvbAftlUtilTest, AftlImageMultipleIcps) {
-  AftlImageHeader* header;
-  size_t i;
-
-  ASSERT_NE(aftl_image_multi_, nullptr);
-  header = &(aftl_image_multi_->header);
-  ASSERT_NE(header, nullptr);
-  TestAftlImageHeader(header, 2);
-
-  for (i = 0; i < header->icp_count; i++) {
-    ASSERT_NE(aftl_image_multi_->entries[i], nullptr)
-        << " Failed at entry " << i;
-    TestAftlIcpEntry(aftl_image_multi_->entries[i]);
-  }
-}
-
-TEST_F(AvbAftlUtilTest, AftlIcpEntryStructure) {
-  AftlIcpEntry* icp_entry;
-
-  icp_entry = aftl_image_->entries[0];
-  ASSERT_NE(icp_entry, nullptr);
-  TestAftlIcpEntry(icp_entry);
-}
-
-} /* namespace avb */
diff --git a/test/avb_aftl_validate_unittest.cc b/test/avb_aftl_validate_unittest.cc
deleted file mode 100644
index 2a78e6a..0000000
--- a/test/avb_aftl_validate_unittest.cc
+++ /dev/null
@@ -1,539 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include <gtest/gtest.h>
-
-#include <libavb_aftl/libavb_aftl.h>
-
-#include "avb_unittest_util.h"
-#include "libavb_aftl/avb_aftl_types.h"
-#include "libavb_aftl/avb_aftl_util.h"
-#include "libavb_aftl/avb_aftl_validate.h"
-
-namespace {
-
-/* Public part of testkey_rsa4096.pem, in the AvbRsaPublicKey format. Generated
- * using:
- *   $ openssl rsa -in testkey_rsa4096.pem -pubout -out testkey_rsa4096_pub.pem
- *   $ avbtool extract_public_key --key testkey_rsa4096_pub.pem --output \
- *     testkey_rsa4096_pub.bin.
- */
-const char kKeyBytesPath[] = "test/data/testkey_rsa4096_pub.bin";
-/* Example VBMeta. Its hash should match the value kVBMetaHash defined below. */
-const char kVBMetaPath[] = "test/data/aftl_input_vbmeta.img";
-
-} /* namespace */
-
-namespace avb {
-
-/* Extend BaseAvbToolTest to take advantage of common checks and tooling. */
-class AvbAftlValidateTest : public BaseAvbToolTest {
- public:
-  AvbAftlValidateTest() {}
-  ~AvbAftlValidateTest() {}
-  void SetUp() override {
-    /* Generate an artificial inclusion proof with its own annotation. The
-     * annotation matches the kVBMetaPath file. It is signed using the
-     * testkey_rsa4096.pem key. */
-    /* We define the constants below as string literals (to be able to annotate
-     * the bytes). We keep their sizes in a separate variable as sizeof will
-     * include the final null byte that is automatically appended. */
-    const uint8_t kAnnotationLeafHeader[] =
-        "\x01"                              // Version
-        "\x00\x00\x00\x00\x00\x00\x00\x00"  // Timestamp
-        "\x01";                             // Leaf Type
-    const size_t kAnnotationLeafHeaderSize = sizeof(kAnnotationLeafHeader) - 1;
-    const uint8_t kSignature[] =
-        "\x00"   // Hash Type
-        "\x00"   // Signature Type
-        "\x00";  // Signature size
-    const size_t kSignatureSize = sizeof(kSignature) - 1;
-    const uint8_t kAnnotationHeader[] = "\x20";  // VBMeta hash size
-    const size_t kAnnotationHeaderSize = sizeof(kAnnotationHeader) - 1;
-    /* This is the SHA256 hash of the image at kVBMetaPath */
-    const uint8_t kVBMetaHash[] =
-        "\x34\x1c\x6c\xf2\x4b\xc1\xe6\x4a\xb1\x03\xa0\xee\xe1\x9d\xee\x9c"
-        "\x35\x34\xdb\x07\x17\x29\xb4\xad\xd0\xce\xa0\xbd\x52\x92\x54\xec";
-    const uint8_t kAnnotationFooter[] =
-        "\x03"      // Version incremental size
-        "123"       // Version incremental
-        "\x00"      // Manufacturer key hash size
-        "\x00\x05"  // Description size
-        "abcde";    // Description
-    const size_t kAnnotationFooterSize = sizeof(kAnnotationFooter) - 1;
-    const uint8_t kLogRootDescriptorHeader[] =
-        "\x00\x01"                          // Version
-        "\x00\x00\x00\x00\x00\x00\x00\x03"  // Tree size
-        "\x20";                             // Root hash size
-    const size_t kLogRootDescriptorHeaderSize =
-        sizeof(kLogRootDescriptorHeader) - 1;
-    const uint8_t kLogRootDescriptorRootHash[] =
-        "\x40\x79\x2f\xf1\xcb\xfc\xd1\x8a\x13\x70\x90\xaf\x6a\x16\x4d\xa9"
-        "\x36\x80\x99\xb3\xf9\x7f\x99\x13\x3e\x07\xff\xbc\x73\x42\xfc\xc7";
-    const uint8_t kLogRootDescriptorFooter[] =
-        "\x00\x00\x00\x00\x13\x36\x4b\xff"  // Timestamp
-        "\x00\x00\x00\x00\x00\x00\x00\x00"  // Revision
-        "\x00\x00";                         // Metadata size
-    const size_t kLogRootDescriptorFooterSize =
-        sizeof(kLogRootDescriptorFooter) - 1;
-    /* Signature of the log root descriptor.
-     *   $ openssl dgst -sha256 -sign testkey_rsa4096.pem \
-     *   -out kLogRootHashSignature log_root_descriptor_raw
-     * log_root_descriptor_raw is defined as the concatenation:
-     * kLogRootDescriptorHeader || kLogRootDescriptorRootHash ||
-     * kLogRootDescriptorFooter */
-    const uint8_t kLogRootHashSignature[] = {
-        0x55, 0x1d, 0xd3, 0x13, 0x3c, 0x41, 0xde, 0x67, 0x79, 0xf1, 0xc6, 0xad,
-        0x72, 0x10, 0xff, 0xfb, 0x6d, 0xac, 0xc1, 0x1c, 0x06, 0x2a, 0x3e, 0xa8,
-        0xd9, 0xf3, 0x8c, 0x9c, 0x67, 0xbe, 0x1e, 0x8e, 0xe1, 0x02, 0xf6, 0xdb,
-        0xd2, 0x5c, 0x31, 0x4b, 0x26, 0xad, 0x9a, 0xd1, 0xf5, 0x7d, 0xb9, 0x6b,
-        0x4b, 0xf1, 0x7a, 0x89, 0x9d, 0xf0, 0x17, 0xb4, 0xee, 0xb2, 0x08, 0x0d,
-        0xd8, 0x99, 0xac, 0x7b, 0x34, 0x1f, 0xd1, 0x9c, 0x2e, 0x0c, 0xd1, 0xb1,
-        0x42, 0x34, 0xf2, 0x65, 0xbb, 0x79, 0x7a, 0xac, 0x23, 0x37, 0xec, 0xfc,
-        0xff, 0xbf, 0x66, 0x51, 0xed, 0x3e, 0xa7, 0x45, 0x3a, 0xf9, 0x72, 0xaa,
-        0x01, 0x3c, 0xfd, 0x59, 0x01, 0x67, 0x67, 0xb4, 0x57, 0x23, 0xb6, 0x7e,
-        0x59, 0x82, 0xb3, 0x98, 0xa2, 0x57, 0xd4, 0x64, 0x83, 0xaa, 0x02, 0x17,
-        0x87, 0xfd, 0xa2, 0xe2, 0x3b, 0xa8, 0xf5, 0xc2, 0xfb, 0xce, 0x7f, 0x59,
-        0x72, 0x10, 0xc5, 0x11, 0x81, 0x80, 0x20, 0x4a, 0x3e, 0xf9, 0x85, 0x2e,
-        0x44, 0x94, 0x87, 0xec, 0xfa, 0x2e, 0x8f, 0x75, 0x00, 0x6f, 0x52, 0x1b,
-        0x4d, 0x5c, 0xfc, 0xe4, 0x1f, 0xe2, 0x94, 0xbc, 0x8c, 0xe8, 0x7f, 0x74,
-        0x14, 0x2f, 0x66, 0x8e, 0xfb, 0x11, 0x34, 0xde, 0x80, 0x21, 0x92, 0xc3,
-        0x52, 0xa7, 0xf7, 0x5e, 0x49, 0x53, 0x21, 0x7d, 0x8b, 0xa2, 0xcb, 0x84,
-        0x80, 0x64, 0x0d, 0xd7, 0xd0, 0x6d, 0x6f, 0x2a, 0x98, 0x57, 0x3b, 0x95,
-        0xa1, 0x63, 0x39, 0x00, 0x22, 0x9e, 0x5a, 0x75, 0x07, 0x10, 0x1f, 0x7e,
-        0xdb, 0x05, 0x5d, 0x3d, 0x76, 0x75, 0x3c, 0x1a, 0xd4, 0x1e, 0x8d, 0x6e,
-        0xce, 0x57, 0xd6, 0xce, 0x23, 0xc0, 0x23, 0x4c, 0xcb, 0x10, 0xec, 0x59,
-        0x22, 0x64, 0x57, 0x33, 0x1c, 0x3f, 0xa9, 0x43, 0x97, 0xc1, 0xc0, 0x93,
-        0x5a, 0x16, 0x80, 0x51, 0x56, 0x28, 0x98, 0x33, 0xee, 0x1a, 0xf8, 0x38,
-        0x7a, 0xaa, 0xdb, 0x43, 0x39, 0x90, 0x9e, 0x74, 0xb7, 0x9f, 0xfe, 0xa5,
-        0x84, 0x69, 0xf5, 0x77, 0x80, 0x92, 0xec, 0x06, 0x06, 0xe0, 0xd2, 0x98,
-        0x34, 0x66, 0x25, 0xc3, 0x7c, 0x89, 0x78, 0x3a, 0x0b, 0x48, 0x49, 0x37,
-        0x46, 0x07, 0xc4, 0xc8, 0x04, 0x72, 0x45, 0x60, 0x36, 0x98, 0x2d, 0x47,
-        0xfe, 0xba, 0x74, 0xb9, 0xb0, 0xe4, 0xf5, 0x45, 0xa0, 0xfb, 0x4a, 0x53,
-        0xe0, 0x16, 0x6a, 0x6b, 0x82, 0xcc, 0x33, 0x1c, 0x3c, 0x64, 0xe0, 0x90,
-        0x3c, 0x59, 0xfa, 0x04, 0x51, 0xe0, 0xe8, 0xaa, 0xe9, 0x92, 0x43, 0x04,
-        0x2a, 0x49, 0xd4, 0xdf, 0xac, 0x1d, 0x46, 0x44, 0xad, 0x65, 0x62, 0xaf,
-        0x44, 0x16, 0xb0, 0x05, 0x56, 0x2b, 0xa4, 0xad, 0x4c, 0x7e, 0xbd, 0x04,
-        0x95, 0xcb, 0xce, 0x0e, 0xf6, 0xd5, 0x4b, 0x3a, 0xc0, 0xde, 0x1e, 0xf8,
-        0xfa, 0xf5, 0x73, 0x4a, 0x6d, 0xc2, 0x4a, 0xe1, 0xaf, 0xae, 0xd8, 0x31,
-        0x23, 0x16, 0x5d, 0x15, 0x41, 0xe6, 0xbf, 0x4a, 0xe0, 0xf3, 0xdd, 0x74,
-        0x32, 0x96, 0x64, 0x4c, 0x16, 0x7d, 0xd3, 0xad, 0x21, 0x47, 0x2b, 0x17,
-        0xb9, 0xf3, 0x84, 0x38, 0x80, 0x60, 0xb6, 0xcb, 0x24, 0x45, 0x24, 0x90,
-        0x74, 0xe9, 0x50, 0xea, 0x2e, 0x1f, 0xc2, 0x74, 0x36, 0xa2, 0xf5, 0xd7,
-        0x24, 0xb3, 0xa1, 0x1f, 0xd3, 0x39, 0x61, 0x67, 0x37, 0xe4, 0x2a, 0x20,
-        0x67, 0x95, 0x53, 0x9d, 0xd4, 0xdb, 0x4f, 0xa6, 0xb8, 0x7f, 0x91, 0xb2,
-        0xc5, 0x6f, 0x71, 0x3c, 0x86, 0xc8, 0x36, 0x8d, 0xa4, 0x4d, 0x53, 0x6b,
-        0x3f, 0xe6, 0xce, 0xf1, 0x7a, 0xa2, 0x2e, 0x53, 0x80, 0x4c, 0x52, 0x9d,
-        0x3e, 0xd7, 0xec, 0x47, 0x4a, 0xfa, 0x84, 0xa5, 0x9a, 0x2f, 0x7b, 0xfc,
-        0xfc, 0xe8, 0xa4, 0x09, 0xfb, 0xb5, 0xb7, 0xf2};
-    BaseAvbToolTest::SetUp();
-
-    /* Read in test data from the key and log_sig binaries. */
-    ASSERT_TRUE(
-        base::ReadFileToString(base::FilePath(kKeyBytesPath), &key_bytes_));
-
-    /* Allocate and populate the inclusion proof */
-    icp_entry_ = (AftlIcpEntry*)avb_malloc(sizeof(AftlIcpEntry));
-    if (!icp_entry_) return;
-    icp_entry_->log_root_descriptor.version = 1;
-    icp_entry_->log_root_descriptor.tree_size = 3;
-    icp_entry_->log_root_descriptor.root_hash_size = AVB_AFTL_HASH_SIZE;
-    icp_entry_->log_root_descriptor.timestamp = 322325503;
-    icp_entry_->log_root_descriptor.revision = 0;
-    icp_entry_->log_root_descriptor.metadata_size = 0;
-    icp_entry_->log_root_descriptor.metadata = NULL;
-    icp_entry_->log_root_descriptor_size = kLogRootDescriptorHeaderSize +
-                                           AVB_AFTL_HASH_SIZE +
-                                           kLogRootDescriptorFooterSize;
-    icp_entry_->log_root_descriptor_raw =
-        (uint8_t*)avb_malloc(icp_entry_->log_root_descriptor_size);
-    if (!icp_entry_->log_root_descriptor_raw) {
-      return;
-    }
-    memcpy(icp_entry_->log_root_descriptor_raw,
-           kLogRootDescriptorHeader,
-           kLogRootDescriptorHeaderSize);
-    memcpy(icp_entry_->log_root_descriptor_raw + kLogRootDescriptorHeaderSize,
-           kLogRootDescriptorRootHash,
-           AVB_AFTL_HASH_SIZE);
-    memcpy(icp_entry_->log_root_descriptor_raw + kLogRootDescriptorHeaderSize +
-               AVB_AFTL_HASH_SIZE,
-           kLogRootDescriptorFooter,
-           kLogRootDescriptorFooterSize);
-    icp_entry_->log_root_descriptor.root_hash =
-        (uint8_t*)avb_malloc(AVB_AFTL_HASH_SIZE);
-    if (!icp_entry_->log_root_descriptor.root_hash) return;
-    /* Copy the hash from within the raw version */
-    memcpy(icp_entry_->log_root_descriptor.root_hash,
-           kLogRootDescriptorRootHash,
-           AVB_AFTL_HASH_SIZE);
-    icp_entry_->log_root_sig_size = AVB_AFTL_SIGNATURE_SIZE;
-    icp_entry_->log_root_signature =
-        (uint8_t*)avb_malloc(AVB_AFTL_SIGNATURE_SIZE);
-    memcpy(icp_entry_->log_root_signature,
-           kLogRootHashSignature,
-           AVB_AFTL_SIGNATURE_SIZE);
-
-    /* Allocate the annotation leaf */
-    icp_entry_->annotation_leaf_size =
-        kAnnotationLeafHeaderSize + kSignatureSize + kAnnotationHeaderSize +
-        AVB_AFTL_HASH_SIZE + kAnnotationFooterSize;
-    icp_entry_->annotation_leaf =
-        (SignedVBMetaPrimaryAnnotationLeaf*)avb_calloc(
-            sizeof(SignedVBMetaPrimaryAnnotationLeaf));
-    if (!icp_entry_->annotation_leaf) return;
-    icp_entry_->annotation_leaf->version = 1;
-    icp_entry_->annotation_leaf->timestamp = 0;
-    icp_entry_->annotation_leaf->leaf_type =
-        AVB_AFTL_SIGNED_VBMETA_PRIMARY_ANNOTATION_LEAF;
-    icp_entry_->annotation_leaf->annotation =
-        (VBMetaPrimaryAnnotation*)avb_calloc(sizeof(VBMetaPrimaryAnnotation));
-    if (!icp_entry_->annotation_leaf->annotation) return;
-    icp_entry_->annotation_leaf->annotation->vbmeta_hash_size =
-        AVB_AFTL_HASH_SIZE;
-    icp_entry_->annotation_leaf->annotation->vbmeta_hash =
-        (uint8_t*)avb_calloc(AVB_AFTL_HASH_SIZE);
-    if (!icp_entry_->annotation_leaf->annotation->vbmeta_hash) return;
-    memcpy(icp_entry_->annotation_leaf->annotation->vbmeta_hash,
-           kVBMetaHash,
-           AVB_AFTL_HASH_SIZE);
-    icp_entry_->annotation_leaf_raw =
-        (uint8_t*)avb_calloc(icp_entry_->annotation_leaf_size);
-    if (!icp_entry_->annotation_leaf_raw) return;
-    memcpy(icp_entry_->annotation_leaf_raw,
-           kAnnotationLeafHeader,
-           kAnnotationLeafHeaderSize);
-    memcpy(icp_entry_->annotation_leaf_raw + kAnnotationLeafHeaderSize,
-           kSignature,
-           kSignatureSize);
-    memcpy(icp_entry_->annotation_leaf_raw + kAnnotationLeafHeaderSize +
-               kSignatureSize,
-           kAnnotationHeader,
-           kAnnotationHeaderSize);
-    memcpy(icp_entry_->annotation_leaf_raw + kAnnotationLeafHeaderSize +
-               kSignatureSize + kAnnotationHeaderSize,
-           kVBMetaHash,
-           AVB_AFTL_HASH_SIZE);
-    memcpy(icp_entry_->annotation_leaf_raw + kAnnotationLeafHeaderSize +
-               kSignatureSize + kAnnotationHeaderSize + AVB_AFTL_HASH_SIZE,
-           kAnnotationFooter,
-           kAnnotationFooterSize);
-
-    icp_entry_->leaf_index = 2;
-    icp_entry_->proofs =
-        (uint8_t(*)[AVB_AFTL_HASH_SIZE])avb_calloc(AVB_AFTL_HASH_SIZE);
-    memcpy(icp_entry_->proofs[0],
-           "\xfa\xc5\x42\x03\xe7\xcc\x69\x6c\xf0\xdf\xcb\x42\xc9\x2a\x1d\x9d"
-           "\xba\xf7\x0a\xd9\xe6\x21\xf4\xbd\x8d\x98\x66\x2f\x00\xe3\xc1\x25",
-           AVB_AFTL_HASH_SIZE);
-    icp_entry_->proof_hash_count = 1;
-  }
-
-  void TearDown() override {
-    if (icp_entry_) {
-      if (icp_entry_->annotation_leaf_raw)
-        avb_free(icp_entry_->annotation_leaf_raw);
-      if (icp_entry_->annotation_leaf) {
-        if (icp_entry_->annotation_leaf->annotation) {
-          if (icp_entry_->annotation_leaf->annotation->vbmeta_hash)
-            avb_free(icp_entry_->annotation_leaf->annotation->vbmeta_hash);
-          avb_free(icp_entry_->annotation_leaf->annotation);
-        }
-        avb_free(icp_entry_->annotation_leaf);
-      }
-      if (icp_entry_->log_root_descriptor.root_hash)
-        avb_free(icp_entry_->log_root_descriptor.root_hash);
-      if (icp_entry_->log_root_descriptor_raw)
-        avb_free(icp_entry_->log_root_descriptor_raw);
-      if (icp_entry_->log_root_signature)
-        avb_free(icp_entry_->log_root_signature);
-      if (icp_entry_->proofs) avb_free(icp_entry_->proofs);
-      avb_free(icp_entry_);
-    }
-    BaseAvbToolTest::TearDown();
-  }
-
- protected:
-  AftlIcpEntry* icp_entry_;
-  std::string key_bytes_;
-};
-
-TEST_F(AvbAftlValidateTest, VerifyEntrySignature) {
-  EXPECT_EQ(true,
-            avb_aftl_verify_entry_signature(
-                (uint8_t*)key_bytes_.data(), key_bytes_.size(), icp_entry_));
-}
-
-TEST_F(AvbAftlValidateTest, VerifyIcpRootHash) {
-  EXPECT_EQ(true, avb_aftl_verify_icp_root_hash(icp_entry_));
-}
-
-TEST_F(AvbAftlValidateTest, VerifyVbmetaHash) {
-  std::string vbmeta;
-  ASSERT_TRUE(base::ReadFileToString(base::FilePath(kVBMetaPath), &vbmeta));
-  EXPECT_EQ(true,
-            avb_aftl_verify_vbmeta_hash(
-                (uint8_t*)vbmeta.data(), vbmeta.size(), icp_entry_));
-}
-
-TEST_F(AvbAftlValidateTest, RootFromIcp) {
-  /* Tests from trillian root_from_icp functionality:
-     https://github.com/google/trillian/blob/master/merkle/log_verifier_test.go
-  */
-  uint64_t leaf_index;
-  uint64_t tree_size;
-  uint8_t proof[3][AVB_AFTL_HASH_SIZE];
-  uint8_t leaf_hash[AVB_AFTL_HASH_SIZE];
-  uint8_t hash[AVB_AFTL_HASH_SIZE];
-
-  leaf_index = 0;
-  tree_size = 8;
-  avb_aftl_rfc6962_hash_leaf((uint8_t*)"", 0, leaf_hash);
-  memcpy(proof[0],
-         "\x96\xa2\x96\xd2\x24\xf2\x85\xc6\x7b\xee\x93\xc3\x0f\x8a\x30\x91"
-         "\x57\xf0\xda\xa3\x5d\xc5\xb8\x7e\x41\x0b\x78\x63\x0a\x09\xcf\xc7",
-         AVB_AFTL_HASH_SIZE);
-  memcpy(proof[1],
-         "\x5f\x08\x3f\x0a\x1a\x33\xca\x07\x6a\x95\x27\x98\x32\x58\x0d\xb3"
-         "\xe0\xef\x45\x84\xbd\xff\x1f\x54\xc8\xa3\x60\xf5\x0d\xe3\x03\x1e",
-         AVB_AFTL_HASH_SIZE);
-  memcpy(proof[2],
-         "\x6b\x47\xaa\xf2\x9e\xe3\xc2\xaf\x9a\xf8\x89\xbc\x1f\xb9\x25\x4d"
-         "\xab\xd3\x11\x77\xf1\x62\x32\xdd\x6a\xab\x03\x5c\xa3\x9b\xf6\xe4",
-         AVB_AFTL_HASH_SIZE);
-  avb_aftl_root_from_icp(
-      leaf_index, tree_size, proof, 3, leaf_hash, AVB_AFTL_HASH_SIZE, hash);
-  EXPECT_EQ("5dc9da79a70659a9ad559cb701ded9a2ab9d823aad2f4960cfe370eff4604328",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on test #1";
-
-  leaf_index = 5;
-  tree_size = 8;
-  avb_aftl_rfc6962_hash_leaf((uint8_t*)"@ABC", 4, leaf_hash);
-  memcpy(proof[0],
-         "\xbc\x1a\x06\x43\xb1\x2e\x4d\x2d\x7c\x77\x91\x8f\x44\xe0\xf4\xf7"
-         "\x9a\x83\x8b\x6c\xf9\xec\x5b\x5c\x28\x3e\x1f\x4d\x88\x59\x9e\x6b",
-         AVB_AFTL_HASH_SIZE);
-  memcpy(proof[1],
-         "\xca\x85\x4e\xa1\x28\xed\x05\x0b\x41\xb3\x5f\xfc\x1b\x87\xb8\xeb"
-         "\x2b\xde\x46\x1e\x9e\x3b\x55\x96\xec\xe6\xb9\xd5\x97\x5a\x0a\xe0",
-         AVB_AFTL_HASH_SIZE);
-  memcpy(proof[2],
-         "\xd3\x7e\xe4\x18\x97\x6d\xd9\x57\x53\xc1\xc7\x38\x62\xb9\x39\x8f"
-         "\xa2\xa2\xcf\x9b\x4f\xf0\xfd\xfe\x8b\x30\xcd\x95\x20\x96\x14\xb7",
-         AVB_AFTL_HASH_SIZE);
-  avb_aftl_root_from_icp(
-      leaf_index, tree_size, proof, 3, leaf_hash, AVB_AFTL_HASH_SIZE, hash);
-  EXPECT_EQ("5dc9da79a70659a9ad559cb701ded9a2ab9d823aad2f4960cfe370eff4604328",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on test #2";
-
-  leaf_index = 2;
-  tree_size = 3;
-  avb_aftl_rfc6962_hash_leaf((uint8_t*)"\x10", 1, leaf_hash);
-  memcpy(proof[0],
-         "\xfa\xc5\x42\x03\xe7\xcc\x69\x6c\xf0\xdf\xcb\x42\xc9\x2a\x1d\x9d"
-         "\xba\xf7\x0a\xd9\xe6\x21\xf4\xbd\x8d\x98\x66\x2f\x00\xe3\xc1\x25",
-         AVB_AFTL_HASH_SIZE);
-  avb_aftl_root_from_icp(
-      leaf_index, tree_size, proof, 1, leaf_hash, AVB_AFTL_HASH_SIZE, hash);
-  EXPECT_EQ("aeb6bcfe274b70a14fb067a5e5578264db0fa9b51af5e0ba159158f329e06e77",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on test #3";
-
-  leaf_index = 1;
-  tree_size = 5;
-  avb_aftl_rfc6962_hash_leaf((uint8_t*)"\x00", 1, leaf_hash);
-  memcpy(proof[0],
-         "\x6e\x34\x0b\x9c\xff\xb3\x7a\x98\x9c\xa5\x44\xe6\xbb\x78\x0a\x2c"
-         "\x78\x90\x1d\x3f\xb3\x37\x38\x76\x85\x11\xa3\x06\x17\xaf\xa0\x1d",
-         AVB_AFTL_HASH_SIZE);
-  memcpy(proof[1],
-         "\x5f\x08\x3f\x0a\x1a\x33\xca\x07\x6a\x95\x27\x98\x32\x58\x0d\xb3"
-         "\xe0\xef\x45\x84\xbd\xff\x1f\x54\xc8\xa3\x60\xf5\x0d\xe3\x03\x1e",
-         AVB_AFTL_HASH_SIZE);
-  memcpy(proof[2],
-         "\xbc\x1a\x06\x43\xb1\x2e\x4d\x2d\x7c\x77\x91\x8f\x44\xe0\xf4\xf7"
-         "\x9a\x83\x8b\x6c\xf9\xec\x5b\x5c\x28\x3e\x1f\x4d\x88\x59\x9e\x6b",
-         AVB_AFTL_HASH_SIZE);
-  avb_aftl_root_from_icp(
-      leaf_index, tree_size, proof, 3, leaf_hash, AVB_AFTL_HASH_SIZE, hash);
-  EXPECT_EQ("4e3bbb1f7b478dcfe71fb631631519a3bca12c9aefca1612bfce4c13a86264d4",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on test #4";
-}
-
-TEST_F(AvbAftlValidateTest, ChainInner) {
-  uint8_t hash[AVB_AFTL_HASH_SIZE];
-  uint8_t seed[AVB_AFTL_HASH_SIZE];
-  uint8_t proof[4][AVB_AFTL_HASH_SIZE];
-  uint64_t i;
-
-  for (i = 0; i < AVB_AFTL_HASH_SIZE; i++) {
-    hash[i] = 0;
-  }
-
-  memcpy(seed, "1234567890abcdefghijklmnopqrstuv", AVB_AFTL_HASH_SIZE);
-  memcpy(proof[0], "abcdefghijklmnopqrstuvwxyz123456", AVB_AFTL_HASH_SIZE);
-  avb_aftl_chain_inner(seed, AVB_AFTL_HASH_SIZE, (uint8_t*)proof, 1, 0, hash);
-  EXPECT_EQ("9cb6af81b146b6a81d911d26f4c0d467265a3385d6caf926d5515e58efd161a3",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed with seed: "
-      << "\"1234567890abcdefghijklmnopqrstuv\", proof ["
-      << "\"abcdefghijklmnopqrstuvwxyz123456\"], and leaf_index 0";
-  memcpy(proof[1], "7890abcdefghijklmnopqrstuvwxyz12", AVB_AFTL_HASH_SIZE);
-  avb_aftl_chain_inner(seed, AVB_AFTL_HASH_SIZE, (uint8_t*)proof, 2, 0, hash);
-  EXPECT_EQ("368d8213cd7d62335a84b3a3d75c8a0302c0d63c93cbbd22c5396dc4c75ba019",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed with seed: "
-      << "\"1234567890abcdefghijklmnopqrstuv\", proof ["
-      << "\"abcdefghijklmnopqrstuvwxyz123456\", "
-         "\"7890abcdefghijklmnopqrstuvwxyz12\"],"
-      << " and leaf_index 0";
-  avb_aftl_chain_inner(seed, AVB_AFTL_HASH_SIZE, (uint8_t*)proof, 2, 1, hash);
-  EXPECT_EQ("78418158eb5943c50ec581b41f105ba9aecc1b9e7aba3ea2e93021cbd5bd166e",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed with seed: "
-      << "\"1234567890abcdefghijklmnopqrstuv\", proof ["
-      << "\"abcdefghijklmnopqrstuvwxyz123456\", "
-         "\"7890abcdefghijklmnopqrstuvwxyz12\"],"
-      << " and leaf_index 1";
-  memcpy(proof[2], "abcdefghijklmn0pqrstuvwxyz123456", AVB_AFTL_HASH_SIZE);
-  memcpy(proof[3], "7890abcdefgh1jklmnopqrstuvwxyz12", AVB_AFTL_HASH_SIZE);
-  avb_aftl_chain_inner(seed, AVB_AFTL_HASH_SIZE, (uint8_t*)proof, 4, 1, hash);
-  EXPECT_EQ("83309c48fb92707f5788b6dd4c9a89042dff20856ad9529b7fb8e5cdf47c04f8",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed with seed: "
-      << "\"1234567890abcdefghijklmnopqrstuv\", proof ["
-      << "\"abcdefghijklmnopqrstuvwxyz123456\", "
-         "\"7890abcdefghijklmnopqrstuvwxyz12\","
-      << "\"abcdefghijklmnopqrstuvwxyz123456\", "
-         "\"7890abcdefghijklmnopqrstuvwxyz12\"]"
-      << " and leaf_index 1";
-  avb_aftl_chain_inner(seed, AVB_AFTL_HASH_SIZE, (uint8_t*)proof, 4, 3, hash);
-  EXPECT_EQ("13e5f7e441dc4dbea659acbc989ac33222f4447546e3dac36b0e0c9977d52b97",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed with seed: "
-      << "\"1234567890abcdefghijklmnopqrstuv\", proof ["
-      << "\"abcdefghijklmnopqrstuvwxyz123456\", "
-         "\"7890abcdefghijklmnopqrstuvwxyz12\","
-      << "\"abcdefghijklmnopqrstuvwxyz123456\", "
-         "\"7890abcdefghijklmnopqrstuvwxyz12\"]"
-      << " and leaf_index 3";
-}
-
-TEST_F(AvbAftlValidateTest, ChainBorderRight) {
-  uint8_t hash[AVB_AFTL_HASH_SIZE];
-  uint8_t seed[AVB_AFTL_HASH_SIZE];
-  uint8_t proof[2][AVB_AFTL_HASH_SIZE];
-  uint64_t i;
-
-  for (i = 0; i < AVB_AFTL_HASH_SIZE; i++) {
-    hash[i] = 0;
-  }
-
-  memcpy(seed, "1234567890abcdefghijklmnopqrstuv", AVB_AFTL_HASH_SIZE);
-  memcpy(proof[0], "abcdefghijklmnopqrstuvwxyz123456", AVB_AFTL_HASH_SIZE);
-  avb_aftl_chain_border_right(
-      seed, AVB_AFTL_HASH_SIZE, (uint8_t*)proof, 1, hash);
-  EXPECT_EQ("363aa8a62b784be38392ab69ade1aac2562f8989ce8986bec685d2957d657310",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed with seed: "
-      << "\"1234567890abcdefghijklmnopqrstuv\" and proof "
-         "[\"abcdefghijklmnopqrstuvwxyz123456\"]";
-  memcpy(proof[1], "7890abcdefghijklmnopqrstuvwxyz12", AVB_AFTL_HASH_SIZE);
-  avb_aftl_chain_border_right(
-      seed, AVB_AFTL_HASH_SIZE, (uint8_t*)proof, 2, hash);
-  EXPECT_EQ("618fc58c45faea808e0bbe0f82afbe7687f4db2608824120e8ade507cbce221f",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed with seed: "
-      << "\"1234567890abcdefghijklmnopqrstuv\" and proof ["
-      << "\"abcdefghijklmnopqrstuvwxyz123456\", "
-         "\"7890abcdefghijklmnopqrstuvwxyz12\"]";
-}
-
-TEST_F(AvbAftlValidateTest, RFC6962HashChildren) {
-  uint8_t hash[AVB_AFTL_HASH_SIZE];
-
-  avb_aftl_rfc6962_hash_children((uint8_t*)"", 0, (uint8_t*)"", 0, hash);
-  EXPECT_EQ("4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on inputs \"\" and \"\"";
-
-  avb_aftl_rfc6962_hash_children((uint8_t*)"abcd", 4, (uint8_t*)"", 0, hash);
-  EXPECT_EQ("b75eb7b06e69c1c49597fba37398e0f5ba319c7164ed67bb19b41e9d576313b9",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on inputs \"abcd\" and \"\"";
-
-  avb_aftl_rfc6962_hash_children((uint8_t*)"", 0, (uint8_t*)"efgh", 4, hash);
-  EXPECT_EQ("8d65f3e92e3853cee633345caca3e035f01c2e44815371985baed2c45c10ca40",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on inputs \"\" and \"efgh\"";
-
-  avb_aftl_rfc6962_hash_children(
-      (uint8_t*)"abcd", 4, (uint8_t*)"efgh", 4, hash);
-  EXPECT_EQ("41561b1297f692dad705e28ece8bf47060fba1abeeebda0aa67c43570a36bf79",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on inputs \"abcd\" and \"efgh\"";
-}
-
-TEST_F(AvbAftlValidateTest, RFC6962HashLeaf) {
-  uint8_t hash[AVB_AFTL_HASH_SIZE];
-  avb_aftl_rfc6962_hash_leaf((uint8_t*)"", 0, hash);
-  EXPECT_EQ("6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on input \"\"";
-  avb_aftl_rfc6962_hash_leaf((uint8_t*)"abcdefg", 7, hash);
-  EXPECT_EQ("6b43f785b72386e132b275bc918c25dbc687ab8427836bef6ce4509b64f4f54d",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE))
-      << "Failed on input \"abcdefg\"";
-}
-
-TEST_F(AvbAftlValidateTest, Sha256) {
-  /* Computed with:
-   *
-   * $ echo -n foobar |sha256sum
-   * c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2
-   */
-  uint8_t hash[AVB_AFTL_HASH_SIZE];
-  avb_aftl_sha256(NULL, 0, hash);
-  EXPECT_EQ("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE));
-  avb_aftl_sha256((uint8_t*)"foobar", 6, hash);
-  EXPECT_EQ("c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2",
-            mem_to_hexstring(hash, AVB_AFTL_HASH_SIZE));
-}
-
-TEST_F(AvbAftlValidateTest, AvbAftlCountLeadingZeros) {
-  /* Spot checks to ensure aftl_count_leading_zeros is correct. */
-  EXPECT_EQ(52ull, avb_aftl_count_leading_zeros(4095))
-      << "Failed on input 4095";
-  EXPECT_EQ(12ull, avb_aftl_count_leading_zeros(0xfffffffffffff))
-      << "Failed on input 0xfffffffffffff";
-  EXPECT_EQ(64ull, avb_aftl_count_leading_zeros(0)) << "Failed on input 0";
-  EXPECT_EQ(0ull, avb_aftl_count_leading_zeros(0xffffffffffffffff))
-      << "Failed on input 0xffffffffffffffff";
-}
-
-} /* namespace avb */
diff --git a/test/avb_aftl_verify_unittest.cc b/test/avb_aftl_verify_unittest.cc
deleted file mode 100644
index 1e44a4a..0000000
--- a/test/avb_aftl_verify_unittest.cc
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include <gtest/gtest.h>
-
-#include <libavb_aftl/libavb_aftl.h>
-
-#include "avb_unittest_util.h"
-#include "fake_avb_ops.h"
-#include "libavb_aftl/avb_aftl_types.h"
-#include "libavb_aftl/avb_aftl_util.h"
-#include "libavb_aftl/avb_aftl_validate.h"
-#include "libavb_aftl/avb_aftl_verify.h"
-
-namespace {
-
-/* Log transparency key */
-const char kAftlTestKey[] = "test/data/aftl_pubkey_1.bin";
-/* Full VBMeta partition which contains an AftlImage */
-/* TODO(b/154115873): These VBMetas are manually generated. We need to implement
- * a mock in aftltool that generates an inclusion proof and call that mock from
- * the unit tests, similarly to what is done with GenerateVBMetaImage. */
-const char kVbmetaWithAftlDescBin[] =
-    "test/data/aftl_output_vbmeta_with_1_icp.img";
-/* Size of the VBMetaImage in the partition */
-const uint64_t kVbmetaSize = 0x1100;
-
-} /* namespace */
-
-namespace avb {
-
-/* Extend BaseAvbToolTest to take advantage of common checks and tooling. */
-class AvbAftlVerifyTest : public BaseAvbToolTest,
-                          public FakeAvbOpsDelegateWithDefaults {
- public:
-  AvbAftlVerifyTest() {}
-  ~AvbAftlVerifyTest() {}
-  void SetUp() override {
-    BaseAvbToolTest::SetUp();
-    ops_.set_delegate(this);
-    ops_.set_partition_dir(base::FilePath("test/data"));
-    asv_test_data_ = NULL;
-
-    /* Read in the test data. */
-    ASSERT_TRUE(base::ReadFileToString(base::FilePath(kAftlTestKey), &key_));
-    ASSERT_TRUE(base::ReadFileToString(base::FilePath(kVbmetaWithAftlDescBin),
-                                       &vbmeta_icp_));
-    /* Keep a truncated version of the image without the ICP */
-    vbmeta_ = vbmeta_icp_.substr(0, kVbmetaSize);
-
-    /* Set up required parts of asv_test_data */
-    asv_test_data_ = (AvbSlotVerifyData*)avb_calloc(sizeof(AvbSlotVerifyData));
-    ASSERT_TRUE(asv_test_data_ != NULL);
-    asv_test_data_->ab_suffix = (char*)"";
-    asv_test_data_->num_vbmeta_images = 1;
-    asv_test_data_->vbmeta_images =
-        (AvbVBMetaData*)avb_calloc(sizeof(AvbVBMetaData));
-    ASSERT_TRUE(asv_test_data_->vbmeta_images != NULL);
-    asv_test_data_->vbmeta_images[0].vbmeta_size = vbmeta_.size();
-    asv_test_data_->vbmeta_images[0].vbmeta_data =
-        (uint8_t*)avb_calloc(vbmeta_.size());
-    ASSERT_TRUE(asv_test_data_->vbmeta_images[0].vbmeta_data != NULL);
-    memcpy(asv_test_data_->vbmeta_images[0].vbmeta_data,
-           vbmeta_.data(),
-           vbmeta_.size());
-    asv_test_data_->vbmeta_images[0].partition_name =
-        (char*)"aftl_output_vbmeta_with_1_icp";
-  }
-
-  void TearDown() override {
-    if (asv_test_data_ != NULL) {
-      if (asv_test_data_->vbmeta_images != NULL) {
-        if (asv_test_data_->vbmeta_images[0].vbmeta_data != NULL) {
-          avb_free(asv_test_data_->vbmeta_images[0].vbmeta_data);
-        }
-        avb_free(asv_test_data_->vbmeta_images);
-      }
-      avb_free(asv_test_data_);
-    }
-    BaseAvbToolTest::TearDown();
-  }
-
- protected:
-  AvbSlotVerifyData* asv_test_data_;
-  std::string key_;
-  std::string vbmeta_;
-  std::string vbmeta_icp_;
-};
-
-TEST_F(AvbAftlVerifyTest, Basic) {
-  AftlSlotVerifyResult result = aftl_slot_verify(
-      ops_.avb_ops(), asv_test_data_, (uint8_t*)key_.data(), key_.size());
-  EXPECT_EQ(result, AFTL_SLOT_VERIFY_RESULT_OK);
-}
-
-TEST_F(AvbAftlVerifyTest, PartitionError) {
-  asv_test_data_->vbmeta_images[0].partition_name = (char*)"do-no-exist";
-  AftlSlotVerifyResult result = aftl_slot_verify(
-      ops_.avb_ops(), asv_test_data_, (uint8_t*)key_.data(), key_.size());
-  EXPECT_EQ(result, AFTL_SLOT_VERIFY_RESULT_ERROR_IMAGE_NOT_FOUND);
-}
-
-TEST_F(AvbAftlVerifyTest, MismatchingVBMeta) {
-  asv_test_data_->vbmeta_images[0].vbmeta_data[0] = 'X';
-  AftlSlotVerifyResult result = aftl_slot_verify(
-      ops_.avb_ops(), asv_test_data_, (uint8_t*)key_.data(), key_.size());
-  EXPECT_EQ(result, AFTL_SLOT_VERIFY_RESULT_ERROR_VBMETA_HASH_MISMATCH);
-}
-
-TEST_F(AvbAftlVerifyTest, InvalidKey) {
-  // Corrupt the key in order to fail the verification: complement the last
-  // byte, we keep the key header valid.
-  key_[key_.size() - 1] = ~key_[key_.size() - 1];
-  AftlSlotVerifyResult result = aftl_slot_verify(
-      ops_.avb_ops(), asv_test_data_, (uint8_t*)key_.data(), key_.size());
-  EXPECT_EQ(result, AFTL_SLOT_VERIFY_RESULT_ERROR_INVALID_PROOF_SIGNATURE);
-}
-
-} /* namespace avb */
diff --git a/test/avb_crypto_ops_unittest.cc b/test/avb_crypto_ops_unittest.cc
new file mode 100644
index 0000000..94141c7
--- /dev/null
+++ b/test/avb_crypto_ops_unittest.cc
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <string.h>
+
+#include <gtest/gtest.h>
+
+#include <libavb/avb_sha.h>
+
+#include "avb_unittest_util.h"
+
+namespace avb {
+
+/* These smoke tests are intended to check that the cryptographic operations
+ * conform to the AVB interface and not to check the correctness of the
+ * cryptograhpy.
+ */
+
+TEST(CryptoOpsTest, Sha256) {
+  AvbSHA256Ctx ctx;
+
+  /* Compare with
+   *
+   * $ echo -n foobar |sha256sum
+   * c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2 -
+   */
+  avb_sha256_init(&ctx);
+  avb_sha256_update(&ctx, (const uint8_t*)"foobar", 6);
+  EXPECT_EQ("c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2",
+            mem_to_hexstring(avb_sha256_final(&ctx), AVB_SHA256_DIGEST_SIZE));
+}
+
+// Disabled for now because it takes ~30 seconds to run.
+TEST(CryptoOpsTest, DISABLED_Sha256Large) {
+  AvbSHA256Ctx ctx;
+
+  /* Also check we this works with greater than 4GiB input. Compare with
+   *
+   * $ dd if=/dev/zero bs=1048576 count=4097 |sha256sum
+   * 829816e339ff597ec3ada4c30fc840d3f2298444169d242952a54bcf3fcd7747 -
+   */
+  const size_t kMebibyte = 1048576;
+  uint8_t* megabuf;
+  megabuf = new uint8_t[kMebibyte];
+  memset((char*)megabuf, '\0', kMebibyte);
+  avb_sha256_init(&ctx);
+  for (size_t n = 0; n < 4097; n++) {
+    avb_sha256_update(&ctx, megabuf, kMebibyte);
+  }
+  EXPECT_EQ("829816e339ff597ec3ada4c30fc840d3f2298444169d242952a54bcf3fcd7747",
+            mem_to_hexstring(avb_sha256_final(&ctx), AVB_SHA256_DIGEST_SIZE));
+  delete[] megabuf;
+}
+
+TEST(CryptoOpsTest, Sha512) {
+  AvbSHA512Ctx ctx;
+
+  /* Compare with
+   *
+   * $ echo -n foobar |sha512sum
+   * 0a50261ebd1a390fed2bf326f2673c145582a6342d523204973d0219337f81616a8069b012587cf5635f6925f1b56c360230c19b273500ee013e030601bf2425
+   * -
+   */
+  avb_sha512_init(&ctx);
+  avb_sha512_update(&ctx, (const uint8_t*)"foobar", 6);
+  EXPECT_EQ(
+      "0a50261ebd1a390fed2bf326f2673c145582a6342d523204973d0219337f81616a8069b0"
+      "12587cf5635f6925f1b56c360230c19b273500ee013e030601bf2425",
+      mem_to_hexstring(avb_sha512_final(&ctx), AVB_SHA512_DIGEST_SIZE));
+}
+
+// Disabled for now because it takes ~30 seconds to run.
+TEST(CryptoOpsTest, DISABLED_Sha512Large) {
+  AvbSHA512Ctx ctx;
+
+  /* Also check we this works with greater than 4GiB input. Compare with
+   *
+   * $ dd if=/dev/zero bs=1048576 count=4097 |sha512sum
+   * eac1685671cc2060315888746de072398116c0c83b7ee9463f0576e11bfdea9cdd5ddbf291fb3ffc4ee8a1b459c798d9fb9b50b7845e2871c4b1402470aaf4c0
+   * -
+   */
+  const size_t kMebibyte = 1048576;
+  uint8_t* megabuf;
+  megabuf = new uint8_t[kMebibyte];
+  memset((char*)megabuf, '\0', kMebibyte);
+  avb_sha512_init(&ctx);
+  for (size_t n = 0; n < 4097; n++) {
+    avb_sha512_update(&ctx, megabuf, kMebibyte);
+  }
+  EXPECT_EQ(
+      "eac1685671cc2060315888746de072398116c0c83b7ee9463f0576e11bfdea9cdd5ddbf2"
+      "91fb3ffc4ee8a1b459c798d9fb9b50b7845e2871c4b1402470aaf4c0",
+      mem_to_hexstring(avb_sha512_final(&ctx), AVB_SHA512_DIGEST_SIZE));
+  delete[] megabuf;
+}
+
+}  // namespace avb
diff --git a/test/avb_util_unittest.cc b/test/avb_util_unittest.cc
index defdfab..5670f85 100644
--- a/test/avb_util_unittest.cc
+++ b/test/avb_util_unittest.cc
@@ -27,7 +27,6 @@
 
 #include <gtest/gtest.h>
 
-#include <libavb/avb_sha.h>
 #include <libavb/libavb.h>
 
 #include "avb_unittest_util.h"
@@ -543,82 +542,4 @@
   EXPECT_EQ("/", std::string(avb_basename("/")));
 }
 
-TEST_F(UtilTest, Sha256) {
-  AvbSHA256Ctx ctx;
-
-  /* Compare with
-   *
-   * $ echo -n foobar |sha256sum
-   * c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2 -
-   */
-  avb_sha256_init(&ctx);
-  avb_sha256_update(&ctx, (const uint8_t*)"foobar", 6);
-  EXPECT_EQ("c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2",
-            mem_to_hexstring(avb_sha256_final(&ctx), AVB_SHA256_DIGEST_SIZE));
-}
-
-// Disabled for now because it takes ~30 seconds to run.
-TEST_F(UtilTest, DISABLED_Sha256Large) {
-  AvbSHA256Ctx ctx;
-
-  /* Also check we this works with greater than 4GiB input. Compare with
-   *
-   * $ dd if=/dev/zero bs=1048576 count=4097 |sha256sum
-   * 829816e339ff597ec3ada4c30fc840d3f2298444169d242952a54bcf3fcd7747 -
-   */
-  const size_t kMebibyte = 1048576;
-  uint8_t* megabuf;
-  megabuf = new uint8_t[kMebibyte];
-  memset((char*)megabuf, '\0', kMebibyte);
-  avb_sha256_init(&ctx);
-  for (size_t n = 0; n < 4097; n++) {
-    avb_sha256_update(&ctx, megabuf, kMebibyte);
-  }
-  EXPECT_EQ("829816e339ff597ec3ada4c30fc840d3f2298444169d242952a54bcf3fcd7747",
-            mem_to_hexstring(avb_sha256_final(&ctx), AVB_SHA256_DIGEST_SIZE));
-  delete[] megabuf;
-}
-
-TEST_F(UtilTest, Sha512) {
-  AvbSHA512Ctx ctx;
-
-  /* Compare with
-   *
-   * $ echo -n foobar |sha512sum
-   * 0a50261ebd1a390fed2bf326f2673c145582a6342d523204973d0219337f81616a8069b012587cf5635f6925f1b56c360230c19b273500ee013e030601bf2425
-   * -
-   */
-  avb_sha512_init(&ctx);
-  avb_sha512_update(&ctx, (const uint8_t*)"foobar", 6);
-  EXPECT_EQ(
-      "0a50261ebd1a390fed2bf326f2673c145582a6342d523204973d0219337f81616a8069b0"
-      "12587cf5635f6925f1b56c360230c19b273500ee013e030601bf2425",
-      mem_to_hexstring(avb_sha512_final(&ctx), AVB_SHA512_DIGEST_SIZE));
-}
-
-// Disabled for now because it takes ~30 seconds to run.
-TEST_F(UtilTest, DISABLED_Sha512Large) {
-  AvbSHA512Ctx ctx;
-
-  /* Also check we this works with greater than 4GiB input. Compare with
-   *
-   * $ dd if=/dev/zero bs=1048576 count=4097 |sha512sum
-   * eac1685671cc2060315888746de072398116c0c83b7ee9463f0576e11bfdea9cdd5ddbf291fb3ffc4ee8a1b459c798d9fb9b50b7845e2871c4b1402470aaf4c0
-   * -
-   */
-  const size_t kMebibyte = 1048576;
-  uint8_t* megabuf;
-  megabuf = new uint8_t[kMebibyte];
-  memset((char*)megabuf, '\0', kMebibyte);
-  avb_sha512_init(&ctx);
-  for (size_t n = 0; n < 4097; n++) {
-    avb_sha512_update(&ctx, megabuf, kMebibyte);
-  }
-  EXPECT_EQ(
-      "eac1685671cc2060315888746de072398116c0c83b7ee9463f0576e11bfdea9cdd5ddbf2"
-      "91fb3ffc4ee8a1b459c798d9fb9b50b7845e2871c4b1402470aaf4c0",
-      mem_to_hexstring(avb_sha512_final(&ctx), AVB_SHA512_DIGEST_SIZE));
-  delete[] megabuf;
-}
-
 }  // namespace avb
diff --git a/test/avbtool_unittest.cc b/test/avbtool_unittest.cc
index 7fb89c4..908aa71 100644
--- a/test/avbtool_unittest.cc
+++ b/test/avbtool_unittest.cc
@@ -1950,6 +1950,59 @@
                  path.value().c_str());
 }
 
+TEST_F(AvbToolTest, AddHashtreeFooterWithCheckAtMostOnce) {
+  size_t partition_size = 10 * 1024 * 1024;
+  base::FilePath path = GenerateImage("digest_location", partition_size / 2);
+  EXPECT_COMMAND(0,
+                 "./avbtool add_hashtree_footer --salt d00df00d "
+                 "--hash_algorithm sha256 --image %s "
+                 "--partition_size %d --partition_name foobar "
+                 "--algorithm SHA256_RSA2048 "
+                 "--key test/data/testkey_rsa2048.pem "
+                 "--internal_release_string \"\" "
+                 "--check_at_most_once",
+                 path.value().c_str(),
+                 (int)partition_size);
+  // There are two important bits here we're expecting with --check_at_most_once:
+  //   Minimum libavb version = 1.1
+  //   Hashtree descriptor -> Flags = 2
+  ASSERT_EQ(
+      "Footer version:           1.0\n"
+      "Image size:               10485760 bytes\n"
+      "Original image size:      5242880 bytes\n"
+      "VBMeta offset:            5337088\n"
+      "VBMeta size:              1344 bytes\n"
+      "--\n"
+      "Minimum libavb version:   1.1\n"
+      "Header Block:             256 bytes\n"
+      "Authentication Block:     320 bytes\n"
+      "Auxiliary Block:          768 bytes\n"
+      "Public key (sha1):        cdbb77177f731920bbe0a0f94f84d9038ae0617d\n"
+      "Algorithm:                SHA256_RSA2048\n"
+      "Rollback Index:           0\n"
+      "Flags:                    0\n"
+      "Rollback Index Location:  0\n"
+      "Release String:           ''\n"
+      "Descriptors:\n"
+      "    Hashtree descriptor:\n"
+      "      Version of dm-verity:  1\n"
+      "      Image Size:            5242880 bytes\n"
+      "      Tree Offset:           5242880\n"
+      "      Tree Size:             45056 bytes\n"
+      "      Data Block Size:       4096 bytes\n"
+      "      Hash Block Size:       4096 bytes\n"
+      "      FEC num roots:         2\n"
+      "      FEC offset:            5287936\n"
+      "      FEC size:              49152 bytes\n"
+      "      Hash Algorithm:        sha256\n"
+      "      Partition Name:        foobar\n"
+      "      Salt:                  d00df00d\n"
+      "      Root Digest:           "
+      "d0e31526f5a3f8e3f59acf726bd31ae7861ee78f9baa9195356bf479c6f9119d\n"
+      "      Flags:                 2\n",
+      InfoImage(path));
+}
+
 TEST_F(AvbToolTest, KernelCmdlineDescriptor) {
   base::FilePath vbmeta_path =
       testdir_.Append("vbmeta_kernel_cmdline_desc.bin");
@@ -3118,7 +3171,7 @@
     std::string extra_args;
     if (target_required_minor_version == 1) {
       // The --do_not_use_ab option will require 1.1.
-      extra_args = "--do_not_use_ab";
+      extra_args = "--do_not_use_ab --check_at_most_once";
     } else if (target_required_minor_version == 2) {
       extra_args = "--rollback_index_location 2";
     }
diff --git a/test/corpus/icp.bin b/test/corpus/icp.bin
deleted file mode 100644
index 19125fe..0000000
--- a/test/corpus/icp.bin
+++ /dev/null
Binary files differ
diff --git a/test/data/aftl_input_vbmeta.img b/test/data/aftl_input_vbmeta.img
deleted file mode 100644
index 4660701..0000000
--- a/test/data/aftl_input_vbmeta.img
+++ /dev/null
Binary files differ
diff --git a/test/data/aftl_output_vbmeta_with_1_icp.img b/test/data/aftl_output_vbmeta_with_1_icp.img
deleted file mode 100644
index 74b67bb..0000000
--- a/test/data/aftl_output_vbmeta_with_1_icp.img
+++ /dev/null
Binary files differ
diff --git a/test/data/aftl_output_vbmeta_with_2_icp_same_log.img b/test/data/aftl_output_vbmeta_with_2_icp_same_log.img
deleted file mode 100644
index 2a6368e..0000000
--- a/test/data/aftl_output_vbmeta_with_2_icp_same_log.img
+++ /dev/null
Binary files differ
diff --git a/test/data/aftl_pubkey_1.bin b/test/data/aftl_pubkey_1.bin
deleted file mode 100644
index 5bad4be..0000000
--- a/test/data/aftl_pubkey_1.bin
+++ /dev/null
Binary files differ
diff --git a/test/data/aftl_pubkey_1.pem b/test/data/aftl_pubkey_1.pem
deleted file mode 100644
index 8bfd816..0000000
--- a/test/data/aftl_pubkey_1.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA4ilqCNsenNA013iCdwgD
-YPxZ853nbHG9lMBp9boXiwRcqT/8bUKHIL7YX5z7s+QoRYVY3rkMKppRabclXzyx
-H59YnPMaU4uv7NqwWzjgaZo7E+vo7IF+KBjV3cJulId5Av0yIYUCsrwd7MpGtWdC
-Q3S+7Vd4zwzCKEhcvliNIhnNlp1U3wNkPCxOyCAsMEn6k8O5ar12ke5TvxDv15db
-rPDeHh8G2OYWoCkWL+lSN35L2kOJqKqVbLKWrrOd96RCYrrtbPCi580OADJRcUlG
-lgcjwmNwmypBWvQMZ6ITj0P0ksHnl1zZz1DE2rXe1goLI1doghb5KxLaezlR8c2C
-E3w/uo9KJgNmNgUVzzqZZ6FE0moyIDNOpP7KtZAL0DvEZj6jqLbB0ccPQElrg52m
-Dv2/A3nYSr0mYBKeskT4+Bg7PGgoC8p7WyLSxMyzJEDYdtrj9OFx6eZaA23oqTQx
-k3Qq5H8RfNBeeSUEeKF7pKH/7gyqZ2bNzBFMA2EBZgBozwRfaeN/HCv3qbaCnwvu
-6caacmAsK+RxiYxSL1QsJqyhCWWGxVyenmxdc1KG/u5ypi7OIioztyzR3t2tAzD3
-Nb+2t8lgHBRxbV24yiPlnvPmB1ZYEctXnlRR9Evpl1o9xA9NnybPHKr9rozN39CZ
-V/USB8K6ao1y5xPZxa8CZksCAwEAAQ==
------END PUBLIC KEY-----
-
diff --git a/test/data/find_aftl_descriptor.bin b/test/data/find_aftl_descriptor.bin
deleted file mode 100644
index 5044ab3..0000000
--- a/test/data/find_aftl_descriptor.bin
+++ /dev/null
Binary files differ