Version 3.3.0

Signed-off-by: Andrew Gunnerson <accounts+github@chiller3.com>

.github/actions/preload-img-cache/action.yml

@@ -1,48 +0,0 @@
-name: Preload img cache
-inputs:
-  cache-key-prefix:
-    description: 'Device cache-key prefix'
-    required: true
-  device:
-    description: 'Device name'
-    required: true
-
-runs:
-  using: "composite"
-  steps:
-    - uses: actions/cache@v3
-      id: cache-img
-      with:
-        key: ${{ inputs.cache-key-prefix }}${{ inputs.device }}
-        # Make sure any changes to path are also reflected in ci.yml setup
-        path: e2e/files/${{ inputs.device }}-sparse.tar
-
-    - if: ${{ steps.cache-img.outputs.cache-hit }}
-      name: Extracting image from sparse archive
-      shell: sh
-      working-directory: e2e/files
-      run: tar -xf ${{ inputs.device }}-sparse.tar
-
-    - name: Restore e2e executable
-      if: ${{ ! steps.cache-img.outputs.cache-hit }}
-      uses: actions/cache/restore@v3
-      with:
-        key: e2e-${{ github.sha }}-${{ runner.os }}
-        fail-on-cache-miss: true
-        path: |
-          target/release/e2e
-          target/release/e2e.exe
-
-    - name: Downloading device image for ${{ inputs.device }}
-      if: ${{ ! steps.cache-img.outputs.cache-hit }}
-      shell: sh
-      working-directory: e2e
-      run: ../target/release/e2e download --stripped -d ${{ inputs.device }}
-
-    - if: ${{ ! steps.cache-img.outputs.cache-hit }}
-      name: Creating sparse archive from image
-      shell: sh
-      working-directory: e2e/files
-      run: |
-        tar --sparse -cf ${{ inputs.device }}-sparse.tar \
-          ${{ inputs.device }}/*.stripped

.github/actions/preload-magisk-cache/action.yml

@@ -1,31 +0,0 @@
-name: Preload Magisk
-inputs:
-  cache-key:
-    description: 'Magisk cache-key'
-    required: true
-
-runs:
-  using: "composite"
-  steps:
-    - uses: actions/cache@v3
-      id: cache-magisk
-      with:
-        key: ${{ inputs.cache-key }}
-        # Make sure any changes to path are also reflected in ci.yml setup
-        path: e2e/files/magisk
-
-    - name: Restore e2e executable
-      if: ${{ ! steps.cache-magisk.outputs.cache-hit }}
-      uses: actions/cache/restore@v3
-      with:
-        key: e2e-${{ github.sha }}-${{ runner.os }}
-        fail-on-cache-miss: true
-        path: |
-          target/release/e2e
-          target/release/e2e.exe
-
-    - name: Downloading Magisk
-      if: ${{ ! steps.cache-magisk.outputs.cache-hit }}
-      shell: sh
-      working-directory: e2e
-      run: ../target/release/e2e download --magisk

.github/workflows/ci.yml

@@ -5,31 +5,68 @@ on:
       - master
   pull_request:
 
-# This allows a subsequently queued workflow run to interrupt previous runs
+# This allows a subsequently queued workflow run to interrupt previous runs, but
+# only in pull requests.
 concurrency:
-  group: '${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}'
+  group: '${{ github.workflow }} @ ${{ github.head_ref || github.sha }}'
   cancel-in-progress: true
 
 jobs:
   build:
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{ matrix.artifact.os }}
     env:
       CARGO_TERM_COLOR: always
-      RUSTFLAGS: -C strip=symbols
+      # https://github.com/rust-lang/rust/issues/78210
+      RUSTFLAGS: -C strip=symbols -C target-feature=+crt-static
+      TARGETS: ${{ join(matrix.artifact.targets, ' ') || matrix.artifact.name }}
+      ANDROID_API: ${{ matrix.artifact.android_api }}
     strategy:
       fail-fast: false
       matrix:
-        os:
-          - ubuntu-latest
-          - windows-latest
-          - macos-latest
+        artifact:
+          - os: ubuntu-latest
+            name: x86_64-unknown-linux-gnu
+          - os: windows-latest
+            name: x86_64-pc-windows-msvc
+          - os: macos-latest
+            name: universal-apple-darwin
+            targets:
+              - aarch64-apple-darwin
+              - x86_64-apple-darwin
+            combine: lipo
+          # ubuntu-latest is not 24.04 yet and 22.04's qemu-user-static segfaults.
+          - os: ubuntu-24.04
+            name: aarch64-linux-android31
+            targets:
+              - aarch64-linux-android
+            android_api: '31'
     steps:
       - name: Check out repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           # For git describe
           fetch-depth: 0
 
+      - name: Install qemu-user-static
+        if: ${{ contains(matrix.artifact.name, 'android') }}
+        shell: bash
+        run: |
+          sudo apt-get -y update
+          sudo apt-get -y install qemu-user-static
+
+      - name: Set Android temporary directory
+        if: ${{ contains(matrix.artifact.name, 'android') }}
+        shell: bash
+        run: |
+          echo "TMPDIR=/tmp" >> "${GITHUB_ENV}"
+
+      - name: Install cargo-android
+        shell: bash
+        run: |
+          cargo install \
+              --git https://github.com/chenxiaolong/cargo-android \
+              --tag v0.1.1
+
       - name: Get version
         id: get_version
         shell: bash
@@ -39,179 +76,88 @@ jobs:
               | sed -E "s/^v//g;s/([^-]*-g)/r\1/;s/-/./g" \
               >> "${GITHUB_OUTPUT}"
 
-      - name: Get Rust LLVM target triple
-        id: get_target
+      - name: Install toolchains
         shell: bash
-        env:
-          RUSTC_BOOTSTRAP: '1'
         run: |
-          echo -n 'name=' >> "${GITHUB_OUTPUT}"
-          rustc -Z unstable-options --print target-spec-json \
-              | jq -r '."llvm-target"' \
-              >> "${GITHUB_OUTPUT}"
+          for target in ${TARGETS}; do
+              rustup target add "${target}"
+          done
 
       - name: Cache Rust dependencies
         uses: Swatinem/rust-cache@v2
 
       - name: Clippy
-        run: cargo clippy --release --workspace --features static
+        shell: bash
+        run: |
+          for target in ${TARGETS}; do
+              cargo android \
+                  clippy --release --workspace --features static \
+                  --target "${target}"
+          done
 
       - name: Build
-        run: cargo build --release --workspace --features static
+        shell: bash
+        run: |
+          for target in ${TARGETS}; do
+              cargo android \
+                  build --release --workspace --features static \
+                  --target "${target}"
+          done
 
       - name: Tests
-        run: cargo test --release --workspace --features static
+        shell: bash
+        run: |
+          for target in ${TARGETS}; do
+              cargo android \
+                  test --release --workspace --features static \
+                  --target "${target}"
+          done
 
-      - name: Archive documentation
-        uses: actions/upload-artifact@v3
-        with:
-          name: avbroot-${{ steps.get_version.outputs.version }}-${{ steps.get_target.outputs.name }}
-          path: |
-            LICENSE
-            README.md
+      - name: End to end tests
+        shell: bash
+        run: |
+          for target in ${TARGETS}; do
+              cargo android \
+                  run --release -p e2e --features static \
+                  --target "${target}" \
+                  -- test -a -c e2e/e2e.toml
+          done
+
+      - name: Create output directory
+        shell: bash
+        run: |
+          rm -rf target/output
+
+          case "${{ matrix.artifact.combine }}" in
+          lipo)
+              mkdir target/output
+              cmd=(lipo -output target/output/avbroot -create)
+              for target in ${TARGETS}; do
+                  cmd+=("target/${target}/release/avbroot")
+              done
+              "${cmd[@]}"
+              ;;
+          '')
+              ln -s "${TARGETS}/release" target/output
+              ;;
+          *)
+              echo >&2 "Unsupported combine argument"
+              exit 1
+              ;;
+          esac
+
+      # This is done to ensure a flat directory structure. The upload-artifact
+      # action no longer allows multiple uploads to the same destination.
+      - name: Copy documentation to target directory
+        shell: bash
+        run: cp LICENSE README.md target/output/
 
-      # This is separate so we can have a flat directory structure.
       - name: Archive executable
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: avbroot-${{ steps.get_version.outputs.version }}-${{ steps.get_target.outputs.name }}
+          name: avbroot-${{ steps.get_version.outputs.version }}-${{ matrix.artifact.name }}
           path: |
-            target/release/avbroot
-            target/release/avbroot.exe
-
-      - name: Cache e2e executable
-        uses: actions/cache@v3
-        with:
-          key: e2e-${{ github.sha }}-${{ runner.os }}
-          path: |
-            target/release/e2e
-            target/release/e2e.exe
-
-  setup:
-    name: Prepare workflow data
-    runs-on: ubuntu-latest
-    needs: build
-    timeout-minutes: 2
-    outputs:
-      config-path: ${{ steps.load-config.outputs.config-path }}
-      device-list: ${{ steps.load-config.outputs.device-list }}
-      magisk-key: ${{ steps.cache-keys.outputs.magisk-key }}
-      img-key-prefix: ${{ steps.cache-keys.outputs.img-key-prefix }}
-      img-hit: ${{ steps.get-img-cache.outputs.cache-matched-key }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Restore e2e executable
-        uses: actions/cache/restore@v3
-        with:
-          key: e2e-${{ github.sha }}-${{ runner.os }}
-          fail-on-cache-miss: true
-          path: |
-            target/release/e2e
-            target/release/e2e.exe
-
-      - name: Loading test config
-        id: load-config
-        working-directory: e2e
-        run: |
-          echo 'config-path=e2e/e2e.toml' >> "${GITHUB_OUTPUT}"
-          echo -n 'device-list=' >> "${GITHUB_OUTPUT}"
-          ../target/release/e2e list \
-            | jq -cnR '[inputs | select(length > 0)]' \
-            >> "${GITHUB_OUTPUT}"
-
-      - name: Generating cache keys
-        id: cache-keys
-        run: |
-          {
-            echo "img-key-prefix=img-${{ hashFiles(steps.load-config.outputs.config-path) }}-"; \
-            echo "magisk-key=magisk-${{ hashFiles(steps.load-config.outputs.config-path) }}";
-          } >> $GITHUB_OUTPUT
-
-      - name: Checking for cached device images
-        id: get-img-cache
-        uses: actions/cache/restore@v3
-        with:
-          key: ${{ steps.cache-keys.outputs.img-key-prefix }}
-          lookup-only: true
-          path: |
-            e2e/files/${{ fromJSON(steps.load-config.outputs.device-list)[0] }}-sparse.tar
-
-      - name: Checking for cached magisk apk
-        id: get-magisk-cache
-        uses: actions/cache/restore@v3
-        with:
-          key: ${{ steps.cache-keys.outputs.magisk-key }}
-          lookup-only: true
-          path: e2e/files/magisk
-
-      - name: Preloading Magisk cache
-        if: ${{ ! steps.get-magisk-cache.outputs.cache-hit }}
-        uses: ./.github/actions/preload-magisk-cache
-        with:
-          cache-key: ${{ steps.cache-keys.outputs.magisk-key }}
-
-  preload-img:
-    name: Preload device images
-    runs-on: ubuntu-latest
-    needs: setup
-    timeout-minutes: 5
-    # Assume that preloading always succesfully cached all images before.
-    # If for some reason only some got cached, on the first run, the cache will not be preloaded
-    # which will result in some being downloaded multiple times when running the tests.
-    if: ${{ ! needs.setup.outputs.img-hit }}
-    strategy:
-      matrix:
-        device: ${{ fromJSON(needs.setup.outputs.device-list) }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Preloading image cache
-        uses: ./.github/actions/preload-img-cache
-        with:
-          cache-key-prefix: ${{ needs.setup.outputs.img-key-prefix }}
-          device: ${{ matrix.device }}
-
-  tests:
-    name: Run test for ${{ matrix.device }} on ${{ matrix.os }}
-    runs-on: ubuntu-latest
-    needs:
-      - setup
-      - preload-img
-    timeout-minutes: 10
-    # Continue on skipped but not on failures or cancels
-    if: ${{ always() && ! failure() && ! cancelled() }}
-    strategy:
-      matrix:
-        device: ${{ fromJSON(needs.setup.outputs.device-list) }}
-        os:
-          - ubuntu-latest
-          - windows-latest
-          - macos-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Restoring Magisk cache
-        uses: ./.github/actions/preload-magisk-cache
-        with:
-          cache-key: ${{ needs.setup.outputs.magisk-key }}
-
-      - name: Restoring image cache
-        uses: ./.github/actions/preload-img-cache
-        with:
-          cache-key-prefix: ${{ needs.setup.outputs.img-key-prefix }}
-          device: ${{ matrix.device }}
-
-      - name: Restore e2e executable
-        uses: actions/cache/restore@v3
-        with:
-          key: e2e-${{ github.sha }}-${{ runner.os }}
-          fail-on-cache-miss: true
-          path: |
-            target/release/e2e
-            target/release/e2e.exe
-
-      # Finally run tests
-      - name: Run test for ${{ matrix.device }}
-        working-directory: e2e
-        run: ../target/release/e2e test --stripped -d ${{ matrix.device }}
+            target/output/LICENSE
+            target/output/README.md
+            target/output/avbroot
+            target/output/avbroot.exe

.github/workflows/deny.yml

@@ -1,4 +1,5 @@
 ---
+name: cargo-deny
 on:
   push:
     branches:
@@ -10,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Run cargo-deny
         uses: EmbarkStudios/cargo-deny-action@v1

.github/workflows/modules.yml

@@ -1,34 +0,0 @@
----
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-jobs:
-  build:
-    name: Build modules
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v3
-        with:
-          # For git describe
-          fetch-depth: 0
-
-      - name: Get version
-        id: get_version
-        shell: bash
-        run: |
-          echo -n 'version=' >> "${GITHUB_OUTPUT}"
-          git describe --always \
-              | sed -E "s/^v//g;s/([^-]*-g)/r\1/;s/-/./g" \
-              >> "${GITHUB_OUTPUT}"
-
-      - name: Build modules
-        run: cargo xtask modules -a
-
-      - name: Archive artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: avbroot-modules-${{ steps.get_version.outputs.version }}
-          path: modules/dist/

.github/workflows/release.yml

@@ -1,4 +1,5 @@
 ---
+name: Github Release
 on:
   push:
     # Uncomment to test against a branch
@@ -24,14 +25,12 @@ jobs:
           echo "version=${version}" >> "${GITHUB_OUTPUT}"
 
       - name: Check out repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Create release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
           tag_name: v${{ steps.get_version.outputs.version }}
           name: Version ${{ steps.get_version.outputs.version }}
           body_path: RELEASE.md
           draft: true
-          prerelease: false

CHANGELOG.md

@@ -7,6 +7,154 @@
     to update the actual links at the bottom of the file.
 -->
 
+### Version 3.3.0
+
+* Recompute CoW size estimate when replacing dynamic partitions ([Issue #306], [PR #307])
+  * Fixes out of space error when flashing a patched OTA that uses `--replace` to replace a dynamic partition (eg. `system`) with a larger or more incompressible image
+* Add `avbroot payload info` subcommand for inspecting `payload.bin` headers ([PR #309])
+
+### Version 3.2.3
+
+* Add prebuilt binary for Android (aarch64) ([PR #304])
+
+### Version 3.2.2
+
+* Add new `--recompute-size` option to `avbroot avb pack` to automatically recompute the image size for resizable images ([Discussion #294], [PR #296])
+* Add new `--output-info` option to `avbroot avb pack` to write a new `avb.toml` file containing computed values ([PR #297])
+* Add support for upcoming Magisk Canary 27003 ([Issue #301], [PR #268])
+
+### Version 3.2.1
+
+* Increase hash tree and FEC size limits to accommodate partition images up to 8 GiB ([Issue #291], [PR #293])
+
+### Version 3.2.0
+
+* Fix potential infinite loop when interrupting avbroot at the right moment to a bug in the bzip2-rs library ([Issue #285], [PR #287])
+* Update all dependencies and fix new clippy lints ([PR #288])
+* Add support for adding the custom AVB public key to the list of trusted keys for DSU (booting signed GSIs) ([Discussion #286], [PR #289])
+
+### Version 3.1.3
+
+* Build universal binary for macOS ([Issue #278], [PR #279])
+
+### Version 3.1.2
+
+* Use `fastboot flashall` for initial setup to avoid needing to manually flash every partition ([PR #253])
+* Remove binary test files in the git repo and generate them at runtime ([Issue #265], [PR #276])
+* Fix portions of a couple error messages being incorrectly quoted ([PR #277])
+
+### Version 3.1.1
+
+* Cache salted SHA-256 contexts for a small performance improvement ([PR #257])
+* Fix loading certificates that have extra text outside of the marker lines ([PR #261])
+
+### Version 3.1.0
+
+* The `OEMUnlockOnBoot` module has been split out to a separate repo ([Discussion #235], [PR #246])
+    * https://github.com/chenxiaolong/OEMUnlockOnBoot
+    * The new module supports the automatic update mechanism within Magisk/KernelSU
+* Add support for Magisk v27.0 ([PR #255])
+* Switch to using a proper logging library ([PR #251])
+    * Folks who want to see the juicy details during patching can use `--log-level debug` or `--log-level trace`
+
+Behind-the-scenes changes:
+
+* Switch from xz2 to liblzma (maintained fork of xz2) ([PR #247])
+* Update all dependencies ([PR #256])
+
+### Version 3.0.0
+
+Happy New Year! This release brings two major changes:
+
+1. The OTA certificates (`otacerts.zip`) in the system partition are now patched. The `clearotacerts` module from avbroot (or the `customotacerts` module from Custota) are no longer needed and can be safely uninstalled.
+
+    This makes it possible to use Pixel's new Repair Mode safely. To do so, follow the instructions in the [documentation here](./README.md#repair-mode).
+
+2. Autodetection for boot partitions is now significantly more reliable. For KernelSU users or folks who have more obscure devices, the `--boot-partition` option is no longer required (and is now ignored).
+
+Full list of changes:
+
+* Add support for AVB 2.0 format 1.3.0 (for Android 15) ([PR #210])
+* Add new `avbroot key decode-avb` command for converting AVB-encoded public keys to the standard PKCS8-encoded format ([PR #219])
+* Improve autodetection of boot images ([Issue #218], [PR #221], [PR #237])
+* Build precompiled executables as statically linked executables ([Issue #222], [PR #224], [PR #227])
+* Limit critical partition check to bootloader-verified partitions ([Issue #223], [PR #226])
+* Improve patching performance by spliiting new partition images into chunks and compressing them in parallel ([PR #228])
+* Also verify whole-partition hashes when running `avbroot ota verify` ([PR #229])
+* Add support for patching `otacerts.zip` on the system partition ([Issue #225], [PR #240], [PR #244])
+* Document how to use Repair Mode safely ([Issue #216], [PR #243])
+
+Behind-the-scenes changes:
+
+* Fix lint warnings introduced in Rust 1.74.0 ([PR #211])
+* Temporarily silence [RUSTSEC-2023-0071](https://rustsec.org/advisories/RUSTSEC-2023-0071) warning in cargo-deny ([PR #214])
+* Add support for partially updating FEC data ([PR #230], [PR #231], [PR #234])
+* Fix hash tree calculation for images smaller than one block ([PR #232])
+* Refactor hash tree code and add tests, CLI commands, and support for partial updates ([PR #233])
+* Generate mock OTAs to use for end-to-end tests ([PR #241])
+* Update all dependencies ([PR #245])
+
+### Version 2.3.3
+
+* Add support for XZ-compressed ramdisks ([Issue #203], [PR #207])
+* Merge property and kernel command line AVB descriptors when replacing partitions ([Issue #203], [PR #208])
+
+### Version 2.3.2
+
+* Improve error messages when using `--replace` with an image that has the wrong AVB descriptor type ([Issue #201], [PR #202])
+* Automatically update legacy `dm=` kernel command line descriptor when packing AVB images ([Issue #203], [PR #205])
+* Automatically promote insecure hash algorithms (eg. sha1) to sha256 when packing AVB images ([Issue #203], [PR #206])
+
+### Version 2.3.1
+
+* Mark Magisk 264xx as supported ([PR #199])
+
+### Version 2.3.0
+
+* Fix missing `--help` text for `avbroot avb unpack`'s `--ignore-invalid` option ([PR #183])
+* Group `avbroot ota patch --help` output into more readable sections ([PR #184])
+* Add more checks to ensure that the OTA has a secure AVB setup ([PR #188])
+    * OTAs with blatantly insecure or missing AVB configuration are now more likely to be rejected by avbroot to avoid providing a false sense of security.
+* Allow `avbroot avb verify` and `avbroot ota verify` to work for dm-verity partitions that use insecure SHA1 hashes ([PR #190])
+* Add support for legacy Android 11 OTAs ([Discussion #195], [PR #196])
+
+Behind-the-scenes changes:
+
+* Bump maximum payload manifest size to 4 MiB ([PR #182])
+* Rework file handle reopen functionality to use traits instead of callbacks ([PR #189])
+* Don't set signature algorithm field for indirectly signed boot images ([PR #191])
+* Update dependencies ([PR #197])
+
+### Version 2.2.0
+
+It's Android 14 release day! All versions of avbroot, including the old Python version, are compatible with Android 14 OTAs.
+
+Changes:
+
+* Add new unpack and pack commands for cpio archives (ramdisks) ([PR #173], [PR #178])
+* Rename `header.toml` to `boot.toml` for the boot image unpack and pack commands ([PR #175])
+    * Also changes the file format a bit to make it more readable.
+
+Behind-the-scenes changes:
+
+* Add streaming CPIO reader and writer ([PR #172])
+* Update dependencies ([PR #174], [PR #181])
+* Switch to prost for protobuf encoding/decoding ([PR #176])
+
+### Version 2.1.1
+
+This release is all about hardening avbroot against untrusted (or corrupted) inputs. While all of avbroot's parsers are memory-safe, it's still possible for crashes to occur due to logic issues like allocating too much memory or dividing by zero. With this release, most of these potential issues have been fixed and fuzz tests have been added to help find more of these situations.
+
+On the filesystem side of things, it is no longer possible for a nefarious program to cause avbroot to write to unintended locations by eg. swapping out an output directory or temp directory with a symlink while it is running.
+
+Behind-the-scenes changes:
+
+* Consolidate logic for handling `--pass-file` and `--pass-env-var` ([PR #156])
+* cargo-deny: Block executables in dependencies ([PR #133])
+* Implement size limits for parsers to prevent allocating too much memory ([Issue #157], [PR #158], [PR #159], [PR #164], [PR #168], [PR #169], [PR #170])
+* Add fuzzers to help catch panics/crashes ([Issue #160], [PR #161], [PR #162], [PR #163], [PR #165], [PR #167])
+* Use handle-based directory operations instead of path-based directory operations ([Issue #166], [PR #171])
+
 ### Version 2.1.0
 
 * Add support for dm-verify FEC (forward error correction) ([Issue #145], [PR #146])
@@ -46,12 +194,33 @@ Behind-the-scenes changes:
 * Initial Rust release. The old Python implementation can be found in the `python` branch. ([PR #130])
 
 <!-- Do not manually edit the lines below. Use `cargo xtask update-changelog` to regenerate. -->
+[Discussion #195]: https://github.com/chenxiaolong/avbroot/discussions/195
+[Discussion #235]: https://github.com/chenxiaolong/avbroot/discussions/235
+[Discussion #286]: https://github.com/chenxiaolong/avbroot/discussions/286
+[Discussion #294]: https://github.com/chenxiaolong/avbroot/discussions/294
 [Issue #138]: https://github.com/chenxiaolong/avbroot/issues/138
 [Issue #144]: https://github.com/chenxiaolong/avbroot/issues/144
 [Issue #145]: https://github.com/chenxiaolong/avbroot/issues/145
 [Issue #148]: https://github.com/chenxiaolong/avbroot/issues/148
+[Issue #157]: https://github.com/chenxiaolong/avbroot/issues/157
+[Issue #160]: https://github.com/chenxiaolong/avbroot/issues/160
+[Issue #166]: https://github.com/chenxiaolong/avbroot/issues/166
+[Issue #201]: https://github.com/chenxiaolong/avbroot/issues/201
+[Issue #203]: https://github.com/chenxiaolong/avbroot/issues/203
+[Issue #216]: https://github.com/chenxiaolong/avbroot/issues/216
+[Issue #218]: https://github.com/chenxiaolong/avbroot/issues/218
+[Issue #222]: https://github.com/chenxiaolong/avbroot/issues/222
+[Issue #223]: https://github.com/chenxiaolong/avbroot/issues/223
+[Issue #225]: https://github.com/chenxiaolong/avbroot/issues/225
+[Issue #265]: https://github.com/chenxiaolong/avbroot/issues/265
+[Issue #278]: https://github.com/chenxiaolong/avbroot/issues/278
+[Issue #285]: https://github.com/chenxiaolong/avbroot/issues/285
+[Issue #291]: https://github.com/chenxiaolong/avbroot/issues/291
+[Issue #301]: https://github.com/chenxiaolong/avbroot/issues/301
+[Issue #306]: https://github.com/chenxiaolong/avbroot/issues/306
 [PR #130]: https://github.com/chenxiaolong/avbroot/pull/130
 [PR #132]: https://github.com/chenxiaolong/avbroot/pull/132
+[PR #133]: https://github.com/chenxiaolong/avbroot/pull/133
 [PR #135]: https://github.com/chenxiaolong/avbroot/pull/135
 [PR #136]: https://github.com/chenxiaolong/avbroot/pull/136
 [PR #137]: https://github.com/chenxiaolong/avbroot/pull/137
@@ -63,3 +232,80 @@ Behind-the-scenes changes:
 [PR #150]: https://github.com/chenxiaolong/avbroot/pull/150
 [PR #152]: https://github.com/chenxiaolong/avbroot/pull/152
 [PR #153]: https://github.com/chenxiaolong/avbroot/pull/153
+[PR #156]: https://github.com/chenxiaolong/avbroot/pull/156
+[PR #158]: https://github.com/chenxiaolong/avbroot/pull/158
+[PR #159]: https://github.com/chenxiaolong/avbroot/pull/159
+[PR #161]: https://github.com/chenxiaolong/avbroot/pull/161
+[PR #162]: https://github.com/chenxiaolong/avbroot/pull/162
+[PR #163]: https://github.com/chenxiaolong/avbroot/pull/163
+[PR #164]: https://github.com/chenxiaolong/avbroot/pull/164
+[PR #165]: https://github.com/chenxiaolong/avbroot/pull/165
+[PR #167]: https://github.com/chenxiaolong/avbroot/pull/167
+[PR #168]: https://github.com/chenxiaolong/avbroot/pull/168
+[PR #169]: https://github.com/chenxiaolong/avbroot/pull/169
+[PR #170]: https://github.com/chenxiaolong/avbroot/pull/170
+[PR #171]: https://github.com/chenxiaolong/avbroot/pull/171
+[PR #172]: https://github.com/chenxiaolong/avbroot/pull/172
+[PR #173]: https://github.com/chenxiaolong/avbroot/pull/173
+[PR #174]: https://github.com/chenxiaolong/avbroot/pull/174
+[PR #175]: https://github.com/chenxiaolong/avbroot/pull/175
+[PR #176]: https://github.com/chenxiaolong/avbroot/pull/176
+[PR #178]: https://github.com/chenxiaolong/avbroot/pull/178
+[PR #181]: https://github.com/chenxiaolong/avbroot/pull/181
+[PR #182]: https://github.com/chenxiaolong/avbroot/pull/182
+[PR #183]: https://github.com/chenxiaolong/avbroot/pull/183
+[PR #184]: https://github.com/chenxiaolong/avbroot/pull/184
+[PR #188]: https://github.com/chenxiaolong/avbroot/pull/188
+[PR #189]: https://github.com/chenxiaolong/avbroot/pull/189
+[PR #190]: https://github.com/chenxiaolong/avbroot/pull/190
+[PR #191]: https://github.com/chenxiaolong/avbroot/pull/191
+[PR #196]: https://github.com/chenxiaolong/avbroot/pull/196
+[PR #197]: https://github.com/chenxiaolong/avbroot/pull/197
+[PR #199]: https://github.com/chenxiaolong/avbroot/pull/199
+[PR #202]: https://github.com/chenxiaolong/avbroot/pull/202
+[PR #205]: https://github.com/chenxiaolong/avbroot/pull/205
+[PR #206]: https://github.com/chenxiaolong/avbroot/pull/206
+[PR #207]: https://github.com/chenxiaolong/avbroot/pull/207
+[PR #208]: https://github.com/chenxiaolong/avbroot/pull/208
+[PR #210]: https://github.com/chenxiaolong/avbroot/pull/210
+[PR #211]: https://github.com/chenxiaolong/avbroot/pull/211
+[PR #214]: https://github.com/chenxiaolong/avbroot/pull/214
+[PR #219]: https://github.com/chenxiaolong/avbroot/pull/219
+[PR #221]: https://github.com/chenxiaolong/avbroot/pull/221
+[PR #224]: https://github.com/chenxiaolong/avbroot/pull/224
+[PR #226]: https://github.com/chenxiaolong/avbroot/pull/226
+[PR #227]: https://github.com/chenxiaolong/avbroot/pull/227
+[PR #228]: https://github.com/chenxiaolong/avbroot/pull/228
+[PR #229]: https://github.com/chenxiaolong/avbroot/pull/229
+[PR #230]: https://github.com/chenxiaolong/avbroot/pull/230
+[PR #231]: https://github.com/chenxiaolong/avbroot/pull/231
+[PR #232]: https://github.com/chenxiaolong/avbroot/pull/232
+[PR #233]: https://github.com/chenxiaolong/avbroot/pull/233
+[PR #234]: https://github.com/chenxiaolong/avbroot/pull/234
+[PR #237]: https://github.com/chenxiaolong/avbroot/pull/237
+[PR #240]: https://github.com/chenxiaolong/avbroot/pull/240
+[PR #241]: https://github.com/chenxiaolong/avbroot/pull/241
+[PR #243]: https://github.com/chenxiaolong/avbroot/pull/243
+[PR #244]: https://github.com/chenxiaolong/avbroot/pull/244
+[PR #245]: https://github.com/chenxiaolong/avbroot/pull/245
+[PR #246]: https://github.com/chenxiaolong/avbroot/pull/246
+[PR #247]: https://github.com/chenxiaolong/avbroot/pull/247
+[PR #251]: https://github.com/chenxiaolong/avbroot/pull/251
+[PR #253]: https://github.com/chenxiaolong/avbroot/pull/253
+[PR #255]: https://github.com/chenxiaolong/avbroot/pull/255
+[PR #256]: https://github.com/chenxiaolong/avbroot/pull/256
+[PR #257]: https://github.com/chenxiaolong/avbroot/pull/257
+[PR #261]: https://github.com/chenxiaolong/avbroot/pull/261
+[PR #268]: https://github.com/chenxiaolong/avbroot/pull/268
+[PR #276]: https://github.com/chenxiaolong/avbroot/pull/276
+[PR #277]: https://github.com/chenxiaolong/avbroot/pull/277
+[PR #279]: https://github.com/chenxiaolong/avbroot/pull/279
+[PR #287]: https://github.com/chenxiaolong/avbroot/pull/287
+[PR #288]: https://github.com/chenxiaolong/avbroot/pull/288
+[PR #289]: https://github.com/chenxiaolong/avbroot/pull/289
+[PR #293]: https://github.com/chenxiaolong/avbroot/pull/293
+[PR #296]: https://github.com/chenxiaolong/avbroot/pull/296
+[PR #297]: https://github.com/chenxiaolong/avbroot/pull/297
+[PR #304]: https://github.com/chenxiaolong/avbroot/pull/304
+[PR #307]: https://github.com/chenxiaolong/avbroot/pull/307
+[PR #309]: https://github.com/chenxiaolong/avbroot/pull/309

Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
 default-members = ["avbroot"]
-members = ["avbroot", "e2e", "xtask"]
+members = ["avbroot", "e2e", "fuzz", "xtask"]
 resolver = "2"
 
 [workspace.package]
-version = "2.1.0"
+version = "3.3.0"
 license = "GPL-3.0-only"
 edition = "2021"
 repository = "https://github.com/chenxiaolong/avbroot"

README.extra.md

@@ -30,6 +30,12 @@ This subcommand packs a new AVB image from the `avb.toml` file and, for appended
 * To force an image to be signed, use `--key <path> --force`.
 * To force an image to be unsigned, use `--force` without specifying `--key`.
 
+Note that if the image is an appended image and its hash or hash tree descriptor uses an insecure algorithm, like `sha1`, then it will automatically be promoted to `sha256`.
+
+By default, for appended vbmeta images, the output image size will match the size of the original image that was unpacked. This size is specified by the `image_size` field in `avb.toml`. If the image is resizable (eg. `system`), then passing in `--recompute-size` will cause the `image_size` field to be ignored and the smallest possible output file that fits the raw image and AVB metadata will be built. This avoids wasting space if `raw.img` shrunk or allows the packing to work at all if `raw.img` grew. **Do not use this option for non-resizable images** (eg. `boot`) or else the device won't be able to boot.
+
+When packing an image, several of the fields in `avb.toml` may potentially be recomputed. To write a TOML file containing the new values, use `--output-info <output TOML>`. It is safe to overwrite the existing `avb.toml` if desired.
+
 ### Repacking an AVB image
 
 ```bash
@@ -68,7 +74,7 @@ By default, this command will not write to any file and fails if an image is cor
 avbroot boot unpack -i <input boot image>
 ```
 
-This subcommand unpacks all of the components of the boot image into the current directory by default (see `--help`). The header fields are saved to `header.toml` and each blob section is saved to a separate file. Each blob is written to disk as-is, without decompression.
+This subcommand unpacks all of the components of the boot image into the current directory by default (see `--help`). The header fields are saved to `boot.toml` and each blob section is saved to a separate file. Each blob is written to disk as-is, without decompression.
 
 ### Packing a boot image
 
@@ -94,6 +100,48 @@ avbroot boot info -i <input boot image>
 
 All of the `boot` subcommands show the boot image information. This specific subcommand just does it without performing any other operation. To show avbroot's internal representation of the information, pass in `-d`.
 
+## `avbroot cpio`
+
+### Unpacking a cpio archive
+
+```bash
+avbroot cpio unpack -i <input cpio archive>
+```
+
+This subcommand unpacks the cpio archive. The list of file entries and their metadata, like permissions, are written to `cpio.toml`. The contents of regular files are extracted to `cpio_tree/`. Other file types, like symlinks and block devices, are not extracted at all. Their information only exists in the TOML file.
+
+The files inside the tree will have default permissions, ownership, and modification timestamps. This metadata exists only inside the TOML file in order to ensure that the behavior is the same across all platforms.
+
+Both uncompressed archives and compressed archives (gzip or legacy lz4) are supported.
+
+### Packing a cpio archive
+
+```bash
+avbroot cpio pack -o <output cpio archive>
+```
+
+This subcommand packs a new cpio archive from the file entries listed in `cpio.toml` and the file contents in `cpio_tree/`. Note that **only entries listed in the TOML file are packed**. Extra files inside the tree are silently ignored.
+
+The files are packed in the order listed in the TOML file. When packing ramdisks specifically, it's important to ensure that files are listed after their parent directories (which also **must** exist). Otherwise, the kernel will ignore them. As long as the file paths don't contain anything weird (eg. `a//b` or `a/./b`), sorting the entires with `--sort` should do the trick.
+
+The new archive will be written in the same format (compressed or uncompressed) as the original archive.
+
+### Repacking a cpio archive
+
+```bash
+avbroot cpio repack -i <input cpio archive> -o <output cpio archive>
+```
+
+This is almost equivalent to running `avbroot cpio unpack` followed by `avbroot cpio pack`, except inode numbers will not be reassigned.
+
+### Showing information about a cpio archive
+
+```bash
+avbroot cpio info -i <input cpio archive>
+```
+
+All of the `cpio` subcommands show details about all the entries in the archive. This specific subcommand just does it without performing any other operation.
+
 ## `avbroot fec`
 
 This set of commands is for working with dm-verity FEC (forward error correction) data. The FEC data allows small errors in partition data to be corrected. This increases reliability of the system because when dm-verity encounters data that doesn't match the expected checksum, it will either trigger a kernel panic or reboot the system.
@@ -131,6 +179,14 @@ The default behavior is to use 2 bytes of parity information per 253 bytes of in
 
 The number of parity bytes (between 2 and 24, inclusive) can be configured using `--parity`.
 
+### Updating FEC data
+
+```bash
+avbroot fec update -i <input data file> -f <FEC file> [-r <start> <end>]...
+```
+
+This will update the FEC data corresponding to the specified regions. This can be significantly faster than generating new FEC data from scratch for large files if the regions where data was modified are known.
+
 ### Verifying a file
 
 ```bash
@@ -151,26 +207,58 @@ This will repair the file in place. As described above, in each column, up to `p
 
 Note that FEC is **not** a replacement for checksums, like SHA-256. When there are too many errors, the file can potentially be "successfully repaired" to some incorrect data.
 
-## `avbroot ramdisk`
+## `avbroot hash-tree`
 
-### Dumping a cpio archive
+This set of commands is for working with dm-verity hash tree data. They are not especially useful outside of debugging avbroot itself because the output format is custom. There is a custom header that sits in front of the standard dm-verity hash tree data.
+
+| Offsets    | Type   | Description                    |
+|------------|--------|--------------------------------|
+| 0..16      | ASCII  | `avbroot!hashtree` magic bytes |
+| 16..18     | U16LE  | Version (currently 1)          |
+| 18..26     | U64LE  | Image size                     |
+| 26..30     | U32LE  | Block size                     |
+| 30..46     | ASCII  | Hash algorithm                 |
+| 46..48     | U16LE  | Salt size                      |
+| 48..50     | U16LE  | Root digest size               |
+| 50..54     | U32LE  | Hash tree size                 |
+| (Variable) | BINARY | Salt                           |
+| (Variable) | BINARY | Root digest                    |
+| (Variable) | BINARY | Hash tree                      |
+
+For more information on the hash tree data, see the [Linux kernel documentation](https://docs.kernel.org/admin-guide/device-mapper/verity.html#hash-tree) or avbroot's implementation in [`hashtree.rs`](./avbroot/src/format/hashtree.rs).
+
+### Generating hash tree
 
 ```bash
-avbroot ramdisk dump -i <cpio archive>
+avbroot hash-tree generate -i <input data file> -H <output hash tree file>
 ```
 
-This subcommand dumps all information about a cpio archive to stdout. This includes the compression format, all header fields (including the trailer entry), and all data. If an entry's data can be decoded as UTF-8, then it is printed out as text. Otherwise, the binary data is printed out `\x##`-encoded for non-ASCII bytes. The escape-encoded data is truncated to 512 bytes by default to avoid outputting too much data, but this behavior can be disabled with `--no-truncate`.
+The default behavior is to use a block size of 4096, the `sha256` algorithm, and an empty salt. These can be changed with the `-b`, `-a`, and `-s` options, respectively.
 
-### Repacking a cpio archive
+All parameters needed for verification are included in the hash tree file's header.
+
+### Updating hash tree
 
 ```bash
-avbroot ramdisk repack -i <input cpio archive> -o <output cpio archive>
+avbroot hash-tree update -i <input data file> -H <hash tree file> [-r <start> <end>]...
 ```
 
-This subcommand repacks a cpio archive, including recompression if needed. This is useful for roundtrip testing of avbroot's cpio parser and compression handling. The uncompressed output should be identical to the uncompressed input, except:
+This will update the hash tree data corresponding to the specified regions. This can be significantly faster than generating new hash tree data from scratch for large files if the regions where data was modified are known.
 
-* files are sorted by name
-* inodes are reassigned, starting from 300000
-* there is no excess padding at the end of the file
+### Verifying a file
 
-The compressed output may differ from what other tools produce due to differences in compression levels and header metadata. avbroot avoids specifying header information where possible (eg. gzip timestamp) for reproducibility.
+```bash
+avbroot hash-tree verify -i <input data file> -H <input hash tree file>
+```
+
+This will check if the input file has any corrupted blocks. Currently, the command cannot report which specific blocks are corrupted, only whether the file is valid.
+
+## `avbroot payload`
+
+### Showing payload header information
+
+```bash
+avbroot payload info -i <payload>
+```
+
+This subcommand shows all of the payload header fields (which will likely be extremely long).

README.md

@@ -1,49 +1,113 @@
 # avbroot
 
-avbroot is a program for patching Android A/B-style OTA images for root access while preserving AVB (Android Verified Boot) using custom signing keys. It is compatible with both Magisk and KernelSU.
+(This page is also available in: [Russian (Русский)](./README.ru.md).)
+
+avbroot is a program for patching Android A/B-style OTA images for root access while preserving AVB (Android Verified Boot) using custom signing keys. It is compatible with both Magisk and KernelSU. If desired, it can also just re-sign an OTA without enabling root access.
 
 Having a good understanding of how AVB and A/B OTAs work is recommended prior to using avbroot. At the very least, please make sure the [warnings and caveats](#warnings-and-caveats) are well-understood to avoid the risk of hard bricking.
 
 **NOTE:** avbroot 2.0 has been rewritten in Rust and no longer relies on any AOSP code. The CLI is fully backwards compatible, but the old Python implementation can be found in the `python` branch if needed.
 
+## Requirements
+
+* Only devices that use modern A/B partitioning are supported. This is the case for most non-Samsung devices launched with Android 10 or newer. To check if a device uses this partitioning scheme, open the OTA zip file and check that:
+
+  * `payload.bin` exists
+  * `META-INF/com/android/metadata` (Android 10-11) or `META-INF/com/android/metadata.pb` (Android 12+) exists
+
+* The device must support using a custom public key for the bootloader's root of trust. This is normally done via the `fastboot flash avb_custom_key` command.
+
+  A list of devices known to work can be found in the issue tracker at [#299](https://github.com/chenxiaolong/avbroot/issues/299).
+
 ## Patches
 
-avbroot applies two patches to the boot images:
+avbroot applies the following patches to the partition images:
 
-* Magisk is applied to the `boot` or `init_boot` image, depending on device, as if it were done from the Magisk app.
+* The `boot` or `init_boot` image, depending on device, is patched to enable root access. For Magisk, the patch is equivalent to what would be normally done by the Magisk app.
 
-* The `boot`, `recovery`, or `vendor_boot` image, depending on device, is patched to replace the OTA signature verification certificates with the custom OTA signing certificate. This allows future patched OTAs to be sideloaded after the bootloader has been locked. It also prevents accidental flashing of the original OTA package while booted into recovery.
+* The `boot`, `recovery`, or `vendor_boot` image, depending on device, is patched to replace the OTA signature verification certificates with the custom OTA signing certificate. This allows future patched OTAs to be sideloaded from recovery mode after the bootloader has been locked. It also prevents accidental flashing of the original unpatched OTA.
+
+* The `system` image is also patched to replace the OTA signature verification certificates. This prevents the OS' system updater app from installing an unpatched OTA and also allows the use of custom OTA updater apps.
 
 ## Warnings and Caveats
 
-* The device must use (non-legacy-SAR) A/B partitioning. This is the case on newer Pixel and OnePlus devices. To check if a device uses this partitioning sceme, open the OTA zip file and check that:
+* **Always leave the `OEM unlocking` checkbox enabled when using a locked bootloader with root.** This is critically important. Root access allows the boot partition to potentially be overwritten, either accidentally or intentionally, with an image that is not properly signed. In this scenario, if the checkbox is turned off, both the OS and recovery mode will be made unbootable and `fastboot flashing unlock` will not be allowed. This effectively renders the device **_hard bricked_**.
 
-  * `payload.bin` exists
-  * `META-INF/com/android/metadata.pb` exists
-  * `META-INF/com/android/metadata` contains the line: `ota-type=AB`
+    Repeat: **_ALWAYS leave `OEM unlocking` enabled if rooted._**
 
-* The device must support using a custom public key for the bootloader's root of trust. This is normally done via the `fastboot flash avb_custom_key` command. All Pixel devices with unlockable bootloaders support this, as well as most OnePlus devices. Other devices may support it as well, but there's no easy way to check without just trying it.
+* Any operation that causes an improperly-signed boot image to be flashed will result in the device being unbootable and unrecoverable without unlocking the bootloader again (and thus, triggering a data wipe). This includes the `Direct install` method for updating Magisk. Magisk updates **must** be done by repatching the OTA, not via the app.
 
-* **Do not ever disable the `OEM unlocking` checkbox when using a locked bootloader with root.** This is critically important. With root access, it is possible to corrupt the running system, for example by zeroing out the boot partition. In this scenario, if the checkbox is turned off, both the OS and recovery mode will be made unbootable and `fastboot flashing unlock` will not be allowed. This effectively renders the device **_hard bricked_**.
+    If the boot image is ever modified, **do not reboot**. [Open an issue](https://github.com/chenxiaolong/avbroot/issues/new) for support and be very clear about what steps were done that lead to the situation. If Android is still running and root access works, it might be possible to recover without wiping and starting over.
 
-* Any operation that causes an unsigned or differently-signed boot image to be flashed will result in the device being unbootable and unrecoverable without unlocking the bootloader again (and thus, triggering a data wipe). This includes:
+## Usage
 
-    * Performing a regular (unpatched) A/B OTA update. This can be blocked via a Magisk module (see: [Blocking A/B OTA Updates](#blocking-ab-ota-updates)).
+1. Make sure the [caveats listed above](#warnings-and-caveats) are understood. It is possible to hard brick by doing the wrong thing!
 
-    * The `Direct install` method for updating Magisk. Magisk updates must be done by repatching as well.
+2. Download the latest version from the [releases page](https://github.com/chenxiaolong/avbroot/releases). To verify the digital signature, see the [verifying digital signatures](#verifying-digital-signatures) section.
+
+    avbroot is a standalone executable. It does not need to be installed and can be run from anywhere.
+
+3. Follow the steps to [generate signing keys](#generating-keys).
+
+4. Patch the OTA zip. The base command is:
+
+    ```bash
+    avbroot ota patch \
+        --input /path/to/ota.zip \
+        --key-avb /path/to/avb.key \
+        --key-ota /path/to/ota.key \
+        --cert-ota /path/to/ota.crt \
+    ```
+
+    Add the following additional arguments to the end of the command depending on how you want to configure root access.
+
+    * To enable root access with Magisk:
+
+        ```bash
+        --magisk /path/to/magisk.apk \
+        --magisk-preinit-device <name>
+        ```
+
+        If you don't know the Magisk preinit partition name, see the [Magisk preinit device section](#magisk-preinit-device) for steps on how to find it.
+
+        If you prefer to manually patch the boot image via the Magisk app instead of letting avbroot handle it, use the following arguments instead:
+
+        ```bash
+        --prepatched /path/to/magisk_patched-xxxxx_yyyyy.img
+        ```
+
+    * To enable root access with KernelSU:
+
+        ```bash
+        --prepatched /path/to/kernelsu/boot.img
+        ```
+
+    * To leave the OS unrooted:
+
+        ```bash
+        --rootless
+        ```
+
+    For more details on the options above, see the [advanced usage section](#advanced-usage).
+
+    If `--output` is not specified, then the output file is written to `<input>.patched`.
+
+5. The patched OTA is ready to go! To flash it for the first time, follow the steps in the [initial setup section](#initial-setup). For updates, follow the steps in the [updates section](#updates).
 
 ## Generating Keys
 
-avbroot signs a few components while patching an OTA zip:
+avbroot signs several components while patching an OTA zip:
 
-* the root `vbmeta` image
-* the boot image `vbmeta` footers (if the original ones were signed)
+* the boot images
+* the vbmeta images
 * the OTA payload
 * the OTA zip itself
 
-The boot-related components are signed with an AVB key and OTA-related components are signed with an OTA key. They can be the same RSA keypair, though the following steps show how to generate two separate keys.
+The first two components are signed with an AVB key and latter two components are signed with an OTA key. They can be the same key, though the following steps show how to generate two separate keys.
 
-1. Generate the AVB and OTA signing keys:
+When patching OTAs for multiple devices, generating unique keys for each device is strongly recommended because it prevents an OTA for the wrong device being accidentally flashed.
+
+1. Generate the AVB and OTA signing keys.
 
     ```bash
     avbroot key generate-key -o avb.key
@@ -56,118 +120,147 @@ The boot-related components are signed with an AVB key and OTA-related component
     avbroot key extract-avb -k avb.key -o avb_pkmd.bin
     ```
 
-3. Generate a self-signed certificate for the OTA signing key. This is used by recovery for verifying OTA updates.
+3. Generate a self-signed certificate for the OTA signing key. This is used by recovery to verify OTA updates when sideloading.
 
     ```bash
     avbroot key generate-cert -k ota.key -o ota.crt
     ```
 
-The commands above are provided for convenience. avbroot is compatible with any standard PKCS8-encoded 4096-bit RSA private key and X509 certificate (eg. like those generated by openssl).
+The commands above are provided for convenience. avbroot is compatible with any standard PKCS8-encoded 4096-bit RSA private key and PEM-encoded X509 certificate, like those generated by openssl.
 
-If you lose your AVB or OTA signing key you will no longer be able to sign new OTA zips. You will have to generate new signing keys and unlock your bootloader again (including a data wipe). Follow the [Usage section](#usage) as if doing an initial setup.
+If you lose your AVB or OTA signing key, you will no longer be able to sign new OTA zips. You will have to generate new signing keys and unlock your bootloader again (triggering a data wipe). Follow the [Usage section](#usage) as if doing an initial setup.
 
-## Usage
+## Initial setup
 
-1. Make sure the caveats listed above are understood. It is possible to hard brick by doing the wrong thing!
-
-2. Download the latest version from the [releases page](https://github.com/chenxiaolong/avbroot/releases). To verify the digital signature, see the [verifying digital signatures](#verifying-digital-signatures) section.
-
-3. Follow the steps to [generate signing keys](#generating-keys).
-
-4. Patch the full OTA ZIP.
+1. Reboot into fastboot mode and unlock the bootloader if it isn't already unlocked. This will trigger a data wipe.
 
     ```bash
-    avbroot ota patch \
-        --input /path/to/ota.zip \
-        --privkey-avb /path/to/avb.key \
-        --privkey-ota /path/to/ota.key \
-        --cert-ota /path/to/ota.crt \
-        --magisk /path/to/magisk.apk
+    fastboot flashing unlock
     ```
 
-    If `--output` is not specified, then the output file is written to `<input>.patched`.
+2. When setting things up for the first time, the device must already be running the correct OS. Flash the original unpatched OTA if needed.
 
-    **NOTE:** If you are using Magisk version >=25211, you need to know the preinit partition name (`--magisk-preinit-device <name>`). For details, see the [Magisk preinit device section](#magisk-preinit-device).
-
-    If you prefer to use an existing boot image patched by the Magisk app or you want to use KernelSU, see the [advanced usage section](#advanced-usage).
-
-5. **[Initial setup only]** Unlock the bootloader. This will trigger a data wipe.
-
-6. **[Initial setup only]** Extract the patched images from the patched OTA.
+3. Extract the partition images from the patched OTA that are different from the original.
 
     ```bash
     avbroot ota extract \
         --input /path/to/ota.zip.patched \
-        --directory extracted
+        --directory extracted \
+        --fastboot
     ```
 
-7. **[Initial setup only]** Flash the patched images and the AVB public key metadata. This sets up the custom root of trust. Future updates are done by simply sideloading patched OTA zips.
+    If you prefer to extract and flash all OS partitions just to be safe, pass in `--all`.
+
+4. Flash the partition images that were extracted.
 
     ```bash
-    # Flash the boot images that were extracted
-    for image in extracted/*.img; do
-        partition=$(basename "${image}")
-        partition=${partition%.img}
+    ANDROID_PRODUCT_OUT=extracted fastboot flashall --skip-reboot
+    ```
 
-        fastboot flash "${partition}" "${image}"
-    done
+    Note that this only flashes the OS partitions. The bootloader and modem/radio partitions are left untouched due to fastboot limitations. If they are not already up to date or if unsure, after fastboot completes, follow the steps in the [updates section](#updates) to sideload the patched OTA once. Sideloading OTAs always ensures that all partitions are up to date.
 
-    # Flash the AVB signing public key
+    Alternatively, for Pixel devices, running `flash-base.sh` from the factory image will also update the bootloader and modem.
+
+5. Set up the custom AVB public key in the bootloader after rebooting from fastbootd to bootloader.
+
+    ```bash
+    fastboot reboot-bootloader
     fastboot erase avb_custom_key
     fastboot flash avb_custom_key /path/to/avb_pkmd.bin
     ```
 
-8. **[Initial setup only]** Run `dmesg | grep libfs_avb` as root to verify that AVB is working properly. A message similar to the following is expected:
+6. **[Optional]** Before locking the bootloader, reboot into Android once to confirm that everything is properly signed.
+
+    Install the Magisk or KernelSU app and run the following command:
+
+    ```bash
+    adb shell su -c 'dmesg | grep libfs_avb'
+    ```
+
+    If AVB is working properly, the following message should be printed out:
 
     ```bash
     init: [libfs_avb]Returning avb_handle with status: Success
     ```
 
-9. **[Initial setup only]** Lock the bootloader. This will trigger a data wipe again. **Do not uncheck `OEM unlocking`!**
+7. Reboot back into fastboot and lock the bootloader. This will trigger a data wipe again.
 
-    **WARNING**: If you are flashing CalyxOS, the setup wizard will [automatically turn off the `OEM unlocking` switch](https://github.com/CalyxOS/platform_packages_apps_SetupWizard/blob/7d2df25cedcbff83ddb608e628f9d97b38259c26/src/org/lineageos/setupwizard/SetupWizardApp.java#L135-L140). Make sure to manually reenable it again from Android's developer settings. Consider using [avbroot's `oemunlockonboot` Magisk module](#oemunlockonboot-enable-oem-unlocking-on-every-boot) to automatically ensure OEM unlocking is enabled on every boot.
+    ```bash
+    fastboot flashing lock
+    ```
+
+    Confirm by pressing volume down and then power. Then reboot.
+
+    Remember: **Do not uncheck `OEM unlocking`!**
+
+    **WARNING**: If you are flashing CalyxOS, the setup wizard will [automatically turn off the `OEM unlocking` switch](https://github.com/CalyxOS/platform_packages_apps_SetupWizard/blob/7d2df25cedcbff83ddb608e628f9d97b38259c26/src/org/lineageos/setupwizard/SetupWizardApp.java#L135-L140). Make sure to manually reenable it again from Android's developer settings. Consider using the [`OEMUnlockOnBoot` module](https://github.com/chenxiaolong/OEMUnlockOnBoot) to automatically ensure OEM unlocking is enabled on every boot.
+
+8. That's it! To install future OS, Magisk, or KernelSU updates, see the [next section](#updates).
 
 ## Updates
 
-To update Android or Magisk:
+Updates to Android, Magisk, and KernelSU are all done the same way by patching (or repatching) the OTA.
 
-1. Follow step 4 in [the previous section](#usage) to patch the new OTA (or an existing OTA with a newer Magisk APK).
+1. If Magisk or KernelSU is being updated, first install their new `.apk`. If you happen to open the app, make sure it **does not** flash the boot image. Cancel the boot image update prompts if needed.
 
-2. Reboot to recovery mode. If stuck at a `No command` screen, press the volume up button once while holding down the power button.
+2. Follow the step in the [usage section](#usage) to patch the new OTA.
 
-3. Sideload the patched OTA.
+3. Reboot to recovery mode. If the screen is stuck at a `No command` message, press the volume up button once while holding down the power button.
 
-4. Reboot.
+4. Sideload the patched OTA with `adb sideload`.
 
-## avbroot Magisk modules
+5. That's it!
 
-avbroot's Magisk modules can be found on the [releases page](https://github.com/chenxiaolong/avbroot/releases) or they can be built locally by running:
+## Reverting to stock firmware
 
-```bash
-cargo xtask modules -a
-```
+To stop using avbroot and revert to the stock firmware:
 
-This requires Java and the Android SDK to be installed. The `ANDROID_HOME` environment variable should be set to the Android SDK path.
+1. Reboot into fastboot mode and unlock the bootloader. This will trigger a data wipe.
 
-### `clearotacerts`: Blocking A/B OTA Updates
+2. Erase the custom AVB public key.
 
-Unpatched OTA updates are already blocked in recovery because the original OTA certificate has been replaced with the custom certificate. To disable automatic OTAs while booted into Android, turn off `Automatic system updates` in Android's Developer Options.
+    ```bash
+    fastboot erase avb_custom_key
+    ```
 
-The `clearotacerts` module additionally makes A/B OTAs fail while booted into Android to prevent accidental manual updates. The module simply overrides `/system/etc/security/otacerts.zip` at runtime with an empty zip so that even if an OTA is downloaded, signature verification will fail.
+3. Flash the stock firmware.
 
-At least in CalyxOS the Updater app does not respect the `Automatic system updates` setting and may enter an infinite loop downloading the OTA update and restarting the download when signature verification fails. If this happens on your ROM, you can try to either remove network access from the Updater app or disable the Updater app altogether (if your ROM allows you to do so). In CalyxOS it is possible to go to `Settings > Apps > See all apps`, open the three-dot menu, `Show system`, then find the `System updater` app and disable it.
+4. That's it! There are no other remnants to clean up.
 
-Alternatively, see [Custota](https://github.com/chenxiaolong/Custota) for a custom OTA updater app that pulls from a self-hosted OTA server.
+## OTA updates
 
-### `oemunlockonboot`: Enable OEM unlocking on every boot
+avbroot replaces `/system/etc/security/otacerts.zip` in both the system and recovery partitions with a new zip that contains the custom OTA signing certificate. This prevents an unpatched OTA from inadvertently being installed both when booted into Android and when sideloading from recovery.
 
-To help reduce the risk of OEM unlocking being accidentally disabled (or intentionally disabled as part of some OS's initial setup wizard), this module will attempt to enable the OEM unlocking option on every boot.
+Disabling the system updater app is recommended to prevent it from even attempting to install an unpatched OTA. To do so:
 
-The logs for this module can be found at `/data/local/tmp/avbroot_oem_unlock.log`.
+* Stock OS: Turn off `Automatic system updates` in Android's Developer Options.
+* Custom OS: Disable the system updater app (or block its network access) from Settings -> Apps -> See all apps -> (three-dot menu) -> Show system -> (find updater app).
+
+This is especially important for some custom OS's because their system updater app may get stuck in an infinite loop downloading an OTA update and then retrying when signature verification fails.
+
+To self-host a custom OTA server, see [Custota](https://github.com/chenxiaolong/Custota).
+
+## Repair mode
+
+Some devices now ship with a Repair Mode feature that boots the system with a fresh `userdata` image so that repair technicians are able to run on-device diagnostics without needing the user's credentials to unlock the device.
+
+When the device is rooted, it is unsafe to use Repair Mode. Unless you are using release builds of Magisk/KernelSU signed with your own keys, it's trivial for someone to just install the Magisk/KernelSU app while in repair mode to gain root access with no authentication.
+
+To safely use Repair Mode:
+
+1. Unroot the device by repatching the OTA with the `--rootless` option (instead of `--magisk` or `--prepatched`) and flashing it.
+
+2. Turn on Repair Mode.
+
+3. After receiving the repaired device, exit Repair Mode.
+
+4. Flash the (rooted) patched OTA as normal.
+
+Because the unrooting and rooting are done by flashing OTAs, the device's data will not be wiped.
 
 ## Magisk preinit device
 
-Magisk versions 25211 and newer require a writable partition for storing custom SELinux rules that need to be accessed during early boot stages. This can only be determined on a real device, so avbroot requires the partition's block device name to be specified via `--magisk-preinit-device <name>`. To find the partition name:
+Magisk versions 25211 and newer require a writable partition for storing custom SELinux rules that need to be accessed during early boot stages. This can only be determined on a real device, so avbroot requires the partition to be explicitly specified via `--magisk-preinit-device <name>`. To find the partition name:
 
 1. Extract the boot image from the original/unpatched OTA:
 
@@ -178,9 +271,9 @@ Magisk versions 25211 and newer require a writable partition for storing custom
         --boot-only
     ```
 
-2. Patch the boot image via the Magisk app. This **MUST** be done on the target device! The partition name will be incorrect if patched from Magisk on a different device.
+2. Patch the boot image via the Magisk app. This **MUST** be done on the target device or a device of the same model! The partition name will be incorrect if patched from Magisk on a different device model.
 
-    The Magisk app will include a line like the following in the output:
+    The Magisk app will print out a line like the following in the output:
 
     ```
     - Pre-init storage partition device ID: <name>
@@ -189,7 +282,7 @@ Magisk versions 25211 and newer require a writable partition for storing custom
     Alternatively, avbroot can print out what Magisk detected by running:
 
     ```bash
-    avbroot ota magisk-info \
+    avbroot boot magisk-info \
         --image magisk_patched-*.img
     ```
 
@@ -210,6 +303,8 @@ avbroot ota verify \
     --public-key-avb /path/to/avb_pkmd.bin
 ```
 
+This command works for any OTA, regardless if it's patched or unpatched.
+
 If the `--cert-ota` and `--public-key-avb` options are omitted, then the signatures are only checked for validity, not that they are trusted.
 
 ## Tab completion
@@ -252,15 +347,13 @@ Invoke-Expression (& avbroot completion -s powershell)
 
 ### Using a prepatched boot image
 
-avbroot can replace the boot image with a prepatched image instead of applying the Magisk root patch itself. This is useful for using a boot image patched by the Magisk app or for KernelSU. To use a prepatched boot image, pass in `--prepatched <boot image>` instead of `--magisk <apk>`. When using `--prepatched`, avbroot will skip applying the Magisk root patch, but will still apply the OTA certificate patch.
-
-For KernelSU, also pass in `--boot-partition @gki_kernel` for both the `patch` and `extract` commands. avbroot defaults to Magisk's semantics where the boot image containing the GKI ramdisk is needed, whereas KernelSU requires the boot image containing the GKI kernel. This only affects devices launching with Android 13, where the GKI kernel and ramdisk are in different partitions (`boot` vs. `init_boot`), but it is safe and recommended to always use this option for KernelSU.
+avbroot can replace the boot image with a prepatched image instead of applying the root patch itself. This is useful for using a boot image patched by the Magisk app or for KernelSU. To use a prepatched Magisk boot image or a KernelSU boot image, pass in `--prepatched <boot image>` instead of `--magisk <apk>`. When using `--prepatched`, avbroot will skip applying the Magisk root patch, but will still apply the OTA certificate patch.
 
 Note that avbroot will validate that the prepatched image is compatible with the original. If, for example, the header fields do not match or a boot image section is missing, then the patching process will abort. The checks are not foolproof, but should help protect against accidental use of the wrong boot image. To bypass a somewhat "safe" subset of the checks, use `--ignore-prepatched-compat`. To ignore all checks (strongly discouraged!), pass it in twice.
 
 ### Skipping root patches
 
-avbroot can be used for just resigning an OTA by specifying `--rootless` instead of `--magisk`/`--prepatched`. With this option, the patched OTA will not be rooted. The only modification applied is the replacement of the OTA verification certificate so that the OS can be upgraded with future (patched) OTAs.
+avbroot can be used for just re-signing an OTA by specifying `--rootless` instead of `--magisk`/`--prepatched`. With this option, the patched OTA will not be rooted. The only modification applied is the replacement of the OTA verification certificate so that the OS can be upgraded with future (patched) OTAs.
 
 ### Replacing partitions
 
@@ -270,12 +363,18 @@ The only behavior this changes is where the partition is read from. When using `
 
 This has no impact on what patches are applied. For example, when using Magisk, the root patch is applied to the boot partition, no matter if the partition came from the original `payload.bin` or from `--replace`.
 
+### Booting signed GSIs
+
+Android's [Dynamic System Updates (DSU)](https://developer.android.com/topic/dsu) feature uses a different root of trust than the regular system. Instead of using the bootloader's `avb_custom_key`, it obtains the trusted keys from the `first_stage_ramdisk/avb/*.avbpubkey` files inside the `init_boot` or `vendor_boot` ramdisk. These files are encoded in the same binary format as `avb_pkmd.bin`.
+
+avbroot can add the custom AVB public key to this directory by passing in `--dsu` when patching an OTA. This allows booting [Generic System Images (GSI)](https://developer.android.com/topic/generic-system-image) signed by the custom AVB key.
+
 ### Clearing vbmeta flags
 
 Some Android builds may ship with a root `vbmeta` image with the flags set such that AVB is effectively disabled. When avbroot encounters these images, the patching process will fail with a message like:
 
 ```
-ValueError: vbmeta flags disable AVB: 0x3
+Verified boot is disabled by vbmeta's header flags: 0x3
 ```
 
 To forcibly enable AVB (by clearing the flags), pass in `--clear-vbmeta-flags`.
@@ -284,7 +383,7 @@ To forcibly enable AVB (by clearing the flags), pass in `--clear-vbmeta-flags`.
 
 avbroot prompts for the private key passphrases interactively by default. To run avbroot non-interactively, either:
 
-* Supply the passphrases via files:
+* Supply the passphrases via files.
 
     ```bash
     avbroot ota patch \
@@ -339,11 +438,21 @@ The output binary is written to `target/release/avbroot`.
 
 Debug builds work too, but they will run significantly slower (in the sha256 computations) due to compiler optimizations being turned off.
 
-By default, the build links to the system's bzip2 and liblzma libraries, which are the only external libraries avbroot depends on. To compile and statically link these two libraries, pass in `--features static`.
+By default, the executable links to the system's bzip2 and liblzma libraries, which are the only external libraries avbroot depends on. To compile and statically link these two libraries, pass in `--features static`.
+
+### Android cross-compilation
+
+To cross-compile for Android, install [cargo-android](https://github.com/chenxiaolong/cargo-android) and use the `cargo android` wrapper. To make a release build for aarch64, run:
+
+```bash
+cargo android build --release --target aarch64-linux-android
+```
+
+It is possible to run the tests if the host is running Linux, qemu-user-static is installed, and the executable is built with `RUSTFLAGS=-C target-feature=+crt-static` and `--features static`.
 
 ## Verifying digital signatures
 
-First, save the public key to a file listing the keys to be trusted.
+First, save the public key to a file listing the keys to be trusted. This is the same key listed in [the author's profile](https://github.com/chenxiaolong/).
 
 ```bash
 echo 'avbroot ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDOe6/tBnO7xZhAWXRj3ApUYgn+XZ0wnQiXM8B7tPgv4' > avbroot_trusted_keys

README.ru.md

@@ -0,0 +1,460 @@
+# avbroot
+
+avbroot – это программа для модификации OTA-образов Android A/B-формата с целью получения root-прав при сохранении прохождения AVB (Android Verified Boot) с использованием кастомных (пользовательских) ключей подписи. Она совместима как с Magisk, так и с KernelSU. При необходимости можно просто переподписать OTA, без получения root-доступа.
+
+Прежде чем использовать avbroot, рекомендуется иметь хорошее понимание того, как работают AVB и OTA в формате A/B. Как минимум, следует ознакомиться с [разделом предостережений,](#предостережения) чтобы избежать хардбрика устройства.
+
+**ПРИМЕЧАНИЕ:** avbroot 2.0 была переписана на Rust и больше не имеет в основе никакого кода AOSP, а CLI полностью обратно совместим. Тем не менее, старую реализацию на Python можно найти в одноименной ветке `python`.
+
+## Требования
+
+* Поддерживаются только устройства, использующие современную A/B-разметку. Это большинство девайсов, выпускаемых с Android 10 и новее (за исключением устройств от Samsung). Чтобы проверить, использует ли ваш телефон необходимую схему разметки, откройте zip-архив OTA и проверьте:
+
+  * наличие файла `payload.bin` (обычно находится в корне архива)
+  * наличие файла `META-INF/com/android/metadata` (Android 10-11) или `META-INF/com/android/metadata.pb` (Android 12+)
+
+* Устройство должно поддерживать установку пользовательского публичного ключа для подтверждения статуса доверия загрузчика. Обычно это производится с помощью команды `fastboot flash avb_custom_key`.
+
+  Список девайсов, на которых проверялась совместимость с указанным выше функционалом, находится здесь: [#299.](https://github.com/chenxiaolong/avbroot/issues/299)
+
+## Патчи
+
+avbroot модифицирует следующие образы:
+
+* `boot` или `init_boot`, в зависимости от устройства, модифицируется для получения root-доступа. В случае с Magisk, патч будет эквивалентен тому, что производится в самом приложении Magisk.
+
+* `boot`, `recovery` или `vendor_boot`, в зависимости от устройства, модифицируется для замены сертификата проверки подписи OTA на пользовательский. Это позволяет устанавливать будущие пропатченные OTA через режим Recovery уже после блокировки загрузчика, то есть в качестве обновления. Также это предотвращает случайную установку оригинального непропатченного OTA.
+
+* `system` тоже модифицируется для замены сертификата проверки подписи OTA. Это не позволит системному приложению обновлений ОС установить оригинальный непропатченный OTA и дает возможность использовать сторонние приложения для установки пропатченных OTA.
+
+## Предостережения
+
+* **Всегда оставляйте опцию `Заводской разблокировки`** (или OEM unlocking в англ.) **включенной при наличии root-прав с заблокированным загрузчиком.** Это очень важно. Доступ к root-правам потенциально позволяет перезаписать загрузочный раздел из-под системы, будь то сделано случайно или намеренно, файлом, который не был подписан должным образом. В таком случае, система и режим Recovery больше не смогут загрузиться, а команда `fastboot flashing unlock` будет недоступна, потому что параметр Заводской разблокировки отключен. То есть, это приведет к **_хардбрику устройства_**.
+
+    Повторюсь: **_ВСЕГДА оставляйте `Заводскую разблокировку` включенной при наличии root-прав._**
+
+* Любая операция, приводящая к прошивке некорректно подписанного загрузочного образа, приведет к тому, что устройство больше не сможет загрузиться в систему/режим Recovery, а для его восстановления потребуется повторная разблокировка загрузчика (и, следовательно, стирание всех пользовательских данных). Это же относится и к методу `Прямой установки` для обновления Magisk. Обновление Magisk **должно выполняться только путем обновления OTA,** а не через Magisk Manager.
+
+    Если в загрузочный раздел были внесены какие-либо изменения, **не перезагружайтесь**. Обратитесь за помощью, [открыв Issue,](https://github.com/chenxiaolong/avbroot/issues/new) и четко разъясните, какие конкретные действия привели к возникновению такой ситуации. Если Android всё еще работает и доступ к root-правам сохранился – вероятно, получится откатить изменения до исходного состояния, не стирая ваши данные.
+
+## Использование
+
+1. Убедитесь, что вы ознакомились и поняли указанные выше [предостережения.](#предостережения) 
+
+2. Скачайте последнюю версию со страницы [релизов.](https://github.com/chenxiaolong/avbroot/releases) Чтобы сверить цифровую подпись, см. раздел [проверки цифровых подписей.](#проверка-цифровых-подписей)
+
+    avbroot – это отдельный исполняемый файл. Он не требует установки и может быть запущен из любого места на диске.
+
+3. [Сгенерируйте ключи подписи.](#генерация-ключей)
+
+4. Пропатчите ОТА-архив с помощью команды:
+
+    ```bash
+    avbroot ota patch \
+        --input /путь/к/ota.zip \
+        --key-avb /путь/к/avb.key \
+        --key-ota /путь/к/ota.key \
+        --cert-ota /путь/к/ota.crt \
+    ```
+
+    Добавьте следующие аргументы в конец команды в зависимости от того, как вы хотите получить root-доступ.
+
+    * Для получения root-доступа с использованием Magisk:
+
+        ```bash
+        --magisk /путь/к/magisk.apk \
+        --magisk-preinit-device <имя>
+        ```
+
+        Если вы не знаете имени раздела предварительной инициализации Magisk, следуйте инструкции [в соответствующем разделе.](#предварительная-инициализация-устройства-для-magisk)
+
+        Если вы пропатчили загрузочный образ вручную через приложение Magisk (вместо автоматического идентичного патчинга через avbroot), используйте следующий аргумент:
+
+        ```bash
+        --prepatched /путь/к/magisk_patched-xxxxx_yyyyy.img
+        ```
+
+    * Для получения root-доступа с использованием KernelSU:
+
+        ```bash
+        --prepatched /путь/к/kernelsu_boot.img
+        ```
+
+    * Без root-доступа:
+
+        ```bash
+        --rootless
+        ```
+
+    Больше информации про существующие аргументы можно найти в разделе [расширенного использования.](#расширенное-использование)
+
+    Если название для `--output` не указывается, то готовый файл будет записан как `<название-ota-zip-в-input>.patched`.
+
+5. Готово! Для прошивки пропатченного OTA следуйте инструкции в разделе [первоначальной настройки.](#первоначальная-настройка) Для последующих обновлений тоже есть соответствующий [раздел обновлений.](#обновления)
+
+## Генерация ключей
+
+Во время патчинга OTA, avbroot подписывает несколько компонентов:
+
+* загрузочный образ (boot)
+* образ vbmeta
+* payload из OTA
+* сам архив OTA
+
+Первые два компонента подписываются ключом AVB, а последние два – ключом OTA. Можно использовать один и тот же ключ, однако в следующих шагах описано, как сгенерировать два отдельных.
+
+Если вы патчите OTA сразу для нескольких устройств, настоятельно рекомендуется генерировать уникальные ключи для каждого девайса – так вы защитите себя от случайной прошивки неподходящего OTA для другого телефона. 
+
+1. Сгенерируйте ключи подписи для AVB и OTA.
+
+    ```bash
+    avbroot key generate-key -o avb.key
+    avbroot key generate-key -o ota.key
+    ```
+
+2. Преобразуйте публичную часть ключа подписи AVB в формат метаданных публичного ключа AVB. Именно этот формат используется в загрузчике устройства для установки пользовательского ключа.
+
+    ```bash
+    avbroot key extract-avb -k avb.key -o avb_pkmd.bin
+    ```
+
+3. Сгенерируйте самоподписанный сертификат для ключа подписи OTA. Он используется режимом Recovery для проверки подписи OTA при сайдлоадинге обновления.
+
+    ```bash
+    avbroot key generate-cert -k ota.key -o ota.crt
+    ```
+
+avbroot совместим с любым стандартным 4096-битным приватным ключом RSA в кодировке PKCS8 и сертификатом X509 в кодировке PEM, например с теми, которые генерируются openssl.
+
+Если вы потеряете ключ(-и) подписи AVB или OTA, вы больше не сможете подписывать новые OTA-архивы. Придется генерировать новые ключи подписи и разблокировать загрузчик (что приведет к стиранию всех данных). В таком случае возвращайтесь к инструкции в разделе [использования.](#использование)
+
+## Первоначальная настройка
+
+1. Перезагрузитесь в режим fastboot и разблокируйте загрузчик, если не сделали этого ранее. Это приведет к стиранию всех пользовательских данных.
+
+    ```bash
+    fastboot flashing unlock
+    ```
+
+2. Перед первой установкой, на устройстве уже должна быть установлена в оригинальном виде та прошивка, пропатченную версию которой вы собираетесь ставить. Если это не так, сначала установите оригинальную непропатченную OTA.
+
+3. Извлекаем из пропатченного OTA модифицированные образы:
+
+    ```bash
+    avbroot ota extract \
+        --input /путь/к/ota.zip.patched \
+        --directory extracted \
+        --fastboot
+    ```
+
+    Если вы на всякий случай хотите прошить вообще все разделы из ОТА, извлечь их можно, указав аргумент `--all`.
+
+4. Прошейте извлеченные образы разделов.
+
+    ```bash
+    ANDROID_PRODUCT_OUT=extracted fastboot flashall --skip-reboot
+    ```
+
+    Обратите внимание, что так прошиваются лишь те образы, что относятся к системе. Разделы загрузчика и модема же остаются нетронутыми из-за ограничений fastboot. Если они не обновлены до необходимой версии, или вы не уверены в этом, после прошивки перейдите к пункту [обновлений](#обновления) и установите пропатченный OTA-архив сайдлоадом в режиме Recovery. Прошивка полного OTA гарантирует, что абсолютно все разделы будут обновлены.
+
+    Для устройств Pixel есть ещё один вариант: запуск скрипта `flash-base.sh` из папки заводских образов (factory images) обновит загрузчик и модем.
+
+5. После перезагрузки из fastbootd в загрузчик (bootloader), установите пользовательский публичный ключ AVB в загрузчик:
+
+    ```bash
+    fastboot reboot-bootloader
+    fastboot erase avb_custom_key
+    fastboot flash avb_custom_key /путь/к/avb_pkmd.bin
+    ```
+
+6. **[Опционально]** Перед блокировкой загрузчика загрузитесь в систему, дабы убедиться, что все подписано правильно.
+
+    Установите приложение Magisk или KernelSU и выполните следующую команду:
+
+    ```bash
+    adb shell su -c 'dmesg | grep libfs_avb'
+    ```
+
+    Если AVB работает корректно, будет выведено следующее сообщение:
+
+    ```bash
+    init: [libfs_avb]Returning avb_handle with status: Success
+    ```
+
+7. Перезагрузитесь в fastboot и заблокируйте загрузчик. Это снова приведет к стиранию данных.
+
+    ```bash
+    fastboot flashing lock
+    ```
+
+    Подтвердите нажатием клавиш уменьшения громкости и включения, а после перезагрузитесь в систему.
+
+    Напоминаю: **не отключайте `Заводскую разблокировку`!**
+
+    **ПРЕДУПРЕЖДЕНИЕ**: Если вы прошили CalyxOS, мастер настройки [автоматически отключит опцию `Заводской разблокировки`.](https://github.com/CalyxOS/platform_packages_apps_SetupWizard/blob/7d2df25cedcbff83ddb608e628f9d97b38259c26/src/org/lineageos/setupwizard/SetupWizardApp.java#L135-L140) Не забудьте снова включить её вручную в настройках для разработчиков. Для перестраховки можете использовать [модуль `OEMUnlockOnBoot`,](https://github.com/chenxiaolong/OEMUnlockOnBoot) который автоматически включает пункт Заводской разблокировки при каждом запуске системы.
+
+8. Готово. Установка последующих обновлений системы, Magisk или KernelSU, описывается в [следующем разделе.](#обновления)
+
+## Обновления
+
+Обновления Android, Magisk и KernelSU выполняются одинаково – исключительно путем обновления или репатчинга того же самого OTA.
+
+1. Если Magisk или KernelSU обновились, сначала установите их новый `.apk`. Если вы случайно открыли приложение после обновления, убедитесь, что оно не начало прошивать загрузочный образ. Если появится предложение обновить сам загрузочный образ – отклоните его.
+
+2. Следуйте инструкции в разделе [использования,](#использование) чтобы пропатчить OTA уже с новым .apk Magisk'а/предварительно пропатченным образом с Magisk или KernelSU.
+
+3. Перезагрузитесь в режим Recovery. Если устройство повисло на сплеше с сообщением "No command", удерживайте кнопку питания, а затем нажмите кнопку увеличения громкости один раз.
+
+4. Обновитесь (Apply update from adb → `adb sideload <ota.zip.patched>`).
+
+5. Готово!
+
+## Возврат на заводскую прошивку
+
+Если вы хотите отказаться от использования avbroot и вернуться на стоковую прошивку:
+
+1. Перезагрузитесь в режим fastboot и разблокируйте загрузчик. Это приведет к стиранию всех пользовательских данных.
+
+2. Удалите пользовательский публичный ключ AVB.
+
+    ```bash
+    fastboot erase avb_custom_key
+    ```
+
+3. Прошейте стоковую прошивку. Готово.
+
+## OTA-обновления
+
+avbroot заменяет `/system/etc/security/otacerts.zip` в разделах системы и Recovery на новый архив, содержащий пользовательский сертификат подписи OTA. Это предотвращает случайную установку непропатченных OTA как при загрузке в Android, так и при сайдлоадинге через Recovery.
+
+Рекомендуется отключить приложение обновлений системы, чтобы оно не пыталось установить непропатченные OTA:
+
+* Стоковая прошивка: Отключите `Автоматические обновления системы` (Automatic system updates в англ.) в настройках для разработчиков.
+* Кастомная прошивка: Отключите приложение обновлений системы (или запретите ему доступ к Интернету) через Настройки -> Приложения -> Все приложения -> (меню/три точки) -> Показать системные -> (найдите приложение обновлений, например Обновления системы/Updater).
+
+Это особенно важно для некоторых кастомных прошивок, поскольку их фирменное приложение для обновления системы может уйти в бесконечный цикл, загружая OTA-обновление, а затем повторяя попытку загрузки и установки при неудачной проверке подписи.
+
+Если вы хотите поднять собственный сервер для ОТА-обновлений, вам может быть интересно приложение [Custota.](https://github.com/chenxiaolong/Custota)
+
+## Режим обслуживания
+
+Некоторые устройства поставляются с режимом обслуживания, который загружает систему с чистым образом `userdata`, благодаря чему специалист по ремонту может проводить диагностику устройства, не имея доступа к пользовательским данным владельца.
+
+Если на устройстве есть root-права, использовать этот режим небезопасно. Если у вас обычная сборка Magisk/KernelSU, не подписанная вашим собственным ключом, кто угодно может установить официальное приложение Magisk/KernelSU в режиме обслуживания и запросто получить root-права без какой-либо аутентификации.
+
+Потому, чтобы безопасно использовать режим обслуживания:
+
+1. Отключите root-доступ на устройстве, пропатчив OTA с аргументом `--rootless` (вместо `--magisk` или `--prepatched`) и прошив его.
+
+2. Включите режим обслуживания.
+
+3. Получив отремонтированное устройство обратно, выйдите из режима обслуживания.
+
+4. Прошейте рутированный OTA в обычном режиме.
+
+Поскольку удаление root-прав и повторное их получение выполняются путем перепрошивки OTA, данные устройства стёрты не будут.
+
+## Предварительная инициализация устройства для Magisk
+
+Magisk версии 25211 и новее требует наличие раздела, доступного для записи пользовательских правил SELinux, к которым необходимо обращаться на ранних этапах загрузки. Его можно определить только на реальном устройстве, поэтому avbroot требует указания точного названия с помощью аргумента `--magisk-preinit-device <имя>`. Чтобы получить имя раздела:
+
+1. Извлеките загрузочный образ из оригинального, непропатченного OTA:
+
+    ```bash
+    avbroot ota extract \
+        --input /path/to/ota.zip \
+        --directory . \
+        --boot-only
+    ```
+
+2. Теперь нужно пропатчить загрузочный образ с помощью приложения Magisk. Это **ДОЛЖНО** быть сделано именно на целевом устройстве или устройстве той же модели! Имя раздела будет неверным и не подойдет, если пропатчить образ на устройстве иной модели.
+
+    Приложение Magisk выведет в лог строку, подобную следующей:
+
+    ```
+    - Pre-init storage partition device ID: <имя>
+    ```
+
+    Также и avbroot может вывести информацию о разделе, обнаруженном Magisk, для этого выполните команду:
+
+    ```bash
+    avbroot boot magisk-info \
+        --image magisk_patched-*.img
+    ```
+
+    Имя раздела будет выведено как: `PREINITDEVICE=<имя>`.
+
+    Теперь, когда имя раздела известно, его нужно указать avbroot с помощью команды `--magisk-preinit-device <имя>`. Имя раздела стоит запомнить или сохранить где-нибудь на будущее, оно вряд ли изменится при обновлении Magisk.
+
+Если запустить приложение Magisk на целевом устройстве невозможно (например, телефон не загружается), пропатчите OTA с аргументом `--ignore-magisk-warnings` и прошейте его. Затем выполните указанные выше шаги и повторно пропатчите OTA, но уже с указанием аргумента `--magisk-preinit-device <имя>`.
+
+## Проверка OTA
+
+Чтобы проверить все подписи и хэши, связанные с установкой OTA и процессом загрузки AVB, выполните команду:
+
+```bash
+avbroot ota verify \
+    --input /путь/к/ota.zip \
+    --cert-ota /путь/к/ota.crt \
+    --public-key-avb /путь/к/avb_pkmd.bin
+```
+
+Эта команда работает для любого OTA, независимо от того, пропатчено оно или нет.
+
+Если опции `--cert-ota` и `--public-key-avb` не указаны, то подписи проверяются только на корректность, не проверяя, совпадают ли они внутри всех файлов.
+
+## Подсказки через Tab
+
+Поскольку avbroot имеет множество опций, будет удобно настроить подсказки с автозаполнением для используемой оболочки. Конфигурации генерируются в самом avbroot.
+
+#### bash
+
+Добавьте в `~/.bashrc`:
+
+```bash
+eval "$(avbroot completion -s bash)"
+```
+
+#### zsh
+
+Добавьте в `~/.zshrc`:
+
+```bash
+eval "$(avbroot completion -s zsh)"
+```
+
+#### fish
+
+Добавьте в `~/.config/fish/config.fish`:
+
+```bash
+avbroot completion -s fish | source
+```
+
+#### PowerShell
+
+Добавьте в загрузочный скрипт PowerShell (`profile.ps1`):
+
+```powershell
+Invoke-Expression (& avbroot completion -s powershell)
+```
+
+## Расширенное использование
+
+### Использование заранее пропатченного boot.img
+
+avbroot может подменить используемый загрузочный образ на заранее пропатченный (вместо того, чтобы самостоятельно применять патч). Это пригодится в случае, если у вас уже имеется пропатченный через приложение Magisk образ ядра или образ с поддержкой KernelSU. Для этого используйте аргумент `--prepatched <загрузочный образ>` вместо `--magisk <apk>`. То есть, указав `--prepatched`, avbroot пропустит применение патчинга Magisk'ом, но по-прежнему применит патч OTA-сертификата.
+
+Обратите внимание, что avbroot проверяет совместимость предварительно пропатченного образа с оригинальным. Например, если поля заголовка образа не совпадают, или вовсе указан иной, незагрузочный образ, то процесс патча будет прерван. Эти проверки, конечно, ничего не гарантируют, но должны предостеречь от случайного использования некорректного образа. Чтобы обойти базовые проверки безопасности, укажите аргумент `--ignore-prepatched-compat`. Если вы хотите убрать вообще все проверки (чего делать крайне не рекомендуется), укажите его дважды.
+
+### Пропуск патчей для root-доступа
+
+avbroot можно использовать для простого переподписания OTA, указав аргумент `--rootless` вместо `--magisk`/`--prepatched`. В таком случае пропатченный OTA не будет рутирован. Единственная модификация, которая будет применена – это замена сертификата проверки OTA, чтобы систему можно было обновлять с помощью будущих пропатченных OTA.
+
+### Подмена разделов
+
+avbroot поддерживает подмену целых образов в OTA, даже тех, что не являются загрузочными (например, `vendor_dlkm`). Образ можно заменить, указав аргумент `--replace <имя раздела> /путь/к/образу.img`.
+
+Единственное, что меняется – это то, откуда считывается раздел. При использовании `--replace` вместо использования образа раздела из оригинального `payload.bin` в OTA, он берется напрямую по указанному вами пути. Таким образом, заменяющие образы разделов должны иметь правильные колонтитулы vbmeta, соответствующие оригинальным.
+
+Это не влияет на ход применения пачтей. Например, при использовании Magisk, патч получения root-прав применяется к загрузочному образу одинаково, независимо от того, был ли он получен из оригинального `payload.bin` или это файл, указанный через `--replace`.
+
+### Очистка флагов vbmeta
+
+Некоторые сборки Android-прошивок могут поставляться с образом `vbmeta`, в котором флаги установлены таким образом, что AVB фактически отключен. Если avbroot сталкивается с такими образом, процесс патчинга завершается ошибкой с сообщением следующего типа:
+
+```
+Verified boot is disabled by vbmeta's header flags: 0x3
+```
+
+Чтобы принудительно включить AVB (очистив флаги), укажите аргумент `--clear-vbmeta-flags`.
+
+### Использование в неинтерактивном режиме
+
+По умолчанию avbroot интерактивно запрашивает пароли к приватным ключам. Чтобы запустить avbroot в неинтерактивном режиме, можно:
+
+* Предоставить пароли через файлы:
+
+    ```bash
+    avbroot ota patch \
+        --pass-avb-file /путь/к/avb.passphrase \
+        --pass-ota-file /путь/к/ota.passphrase \
+        <...>
+    ```
+
+    На Unix-подобных системах "файлы" могут быть каналами ("pipes"). В оболочках, поддерживающих подстановку процесса (bash, zsh и т. д.), пароль можно запросить с помощью команды (например, запрашивая у менеджера паролей).
+
+    ```bash
+    avbroot ota patch \
+        --pass-avb-file <(команда для запроса пароля AVB) \
+        --pass-ota-file <(команда для запроса пароля OTA) \
+        <...>
+    ```
+
+* Предоставить пароли через переменные среды. Это менее безопасно, поскольку любой процесс, запущенный от имени того же пользователя, может видеть значения переменных среды.
+
+    ```bash
+    export PASSPHRASE_AVB="пароль AVB"
+    export PASSPHRASE_OTA="пароль OTA"
+
+    avbroot ota patch \
+        --pass-avb-env-var PASSPHRASE_AVB \
+        --pass-ota-env-var PASSPHRASE_OTA \
+        <...>
+    ```
+
+* Использовать незашифрованные приватные ключи. Крайне не рекомендуется.
+
+### Извлечение всей OTA
+
+Чтобы извлечь все образы, содержащиеся в `payload.bin`, используйте команду:
+
+```bash
+avbroot ota extract \
+    --input /путь/к/ota.zip \
+    --directory extracted \
+    --all
+```
+
+## Сборка из исходного кода
+
+Убедитесь, что у вас установлен [набор инструментов Rust.](https://www.rust-lang.org/ru/) Затем выполните:
+
+```bash
+cargo build --release
+```
+
+Исполняемый файл будет записан в `target/release/avbroot`.
+
+Дебаг-сборки тоже работают, но они будут работать значительно медленнее (в вычислениях sha256), потому что оптимизации компилятора отключены.
+
+По умолчанию исполняемый файл ссылается на системные библиотеки bzip2 и liblzma, от которых зависит avbroot. Чтобы скомпилировать и статически связать эти две библиотеки, укажите аргумент `--features static`.
+
+## Проверка цифровых подписей
+
+Сначала сохраните открытый ключ в файл, перечисляющий ключи, которым можно доверять. Это тот же ключ, который указан [в профиле автора.](https://github.com/chenxiaolong/)
+
+```bash
+echo 'avbroot ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDOe6/tBnO7xZhAWXRj3ApUYgn+XZ0wnQiXM8B7tPgv4' > avbroot_trusted_keys
+```
+
+Затем проверьте подпись zip-файла, используя список доверенных ключей.
+
+```bash
+ssh-keygen -Y verify -f avbroot_trusted_keys -I avbroot -n file -s <file>.zip.sig < <file>.zip
+```
+
+Если файл успешно проверен, вывод будет следующим:
+
+```
+Good "file" signature for avbroot with ED25519 key SHA256:Ct0HoRyrFLrnF9W+A/BKEiJmwx7yWkgaW/JvghKrboA
+```
+
+## Вклад
+
+Буду рад вашему вкладу в разработку! Однако я вряд ли приму изменения для поддержки устройств, которые ведут себя значительно иначе, чем устройства Pixel.
+
+## Лицензия
+
+avbroot распространяется по лицензии GPLv3. Полный текст лицензии см. в [`LICENSE`.](./LICENSE)
+

avbroot/Cargo.toml

@@ -10,9 +10,12 @@ publish = false
 
 [dependencies]
 anyhow = "1.0.75"
-base64 = "0.21.3"
+base64 = "0.22.1"
+bitflags = "2.4.1"
 bstr = "1.6.2"
 byteorder = "1.4.3"
+cap-std = "3.0.0"
+cap-tempfile = "3.0.0"
 clap = { version = "4.4.1", features = ["derive"] }
 clap_complete = "4.4.0"
 cms = { version = "0.2.2", features = ["std"] }
@@ -21,13 +24,14 @@ ctrlc = "3.4.0"
 flate2 = "1.0.27"
 gf256 = { version = "0.3.0", features = ["rs"] }
 hex = { version = "0.4.3", features = ["serde"] }
+liblzma = "0.3.0"
 lz4_flex = "0.11.1"
 memchr = "2.6.0"
 num-bigint-dig = "0.8.4"
 num-traits = "0.2.16"
 phf = { version = "0.11.2", features = ["macros"] }
 pkcs8 = { version = "0.10.2", features = ["encryption", "pem"] }
-quick-protobuf = "0.8.1"
+prost = "0.12.1"
 rand = "0.8.5"
 rayon = "1.7.0"
 regex = { version = "1.9.4", default-features = false, features = ["perf", "std"] }
@@ -35,7 +39,7 @@ regex = { version = "1.9.4", default-features = false, features = ["perf", "std"
 # because sha2 is significantly slower on older x86_64 CPUs without the SHA-NI
 # instructions. sha2 is still used for signing purposes.
 # https://github.com/RustCrypto/hashes/issues/327
-ring = "0.16.20"
+ring = "0.17.0"
 rpassword = "7.2.0"
 rsa = { version = "0.9.2", features = ["sha1", "sha2"] }
 serde = { version = "1.0.188", features = ["derive"] }
@@ -43,26 +47,18 @@ sha1 = "0.10.5"
 sha2 = "0.10.7"
 tempfile = "3.8.0"
 thiserror = "1.0.47"
-toml_edit = { version = "0.19.14", features = ["serde"] }
+toml_edit = { version = "0.22.9", features = ["serde"] }
 topological-sort = "0.2.2"
+tracing = "0.1.40"
+tracing-subscriber = "0.3.18"
 x509-cert = { version = "0.2.4", features = ["builder"] }
 
-# There's an upstream bug that causes an infinite loop in the write::BzDecoder
-# destructor if the decoder is fed invalid data. While this never happens during
-# normal operation, it is possible to run into this by running `ota extract`
-# against a `--stripped` OTA file.
-# https://github.com/alexcrichton/bzip2-rs/pull/99
+# There are multiple upstream bugs that cause infinite loops in the Drop
+# implementation of write::BzDecoder. Unfortunately, the project is no longer
+# maintained, so we have to maintain our own fork with the necessary fixes.
 [dependencies.bzip2]
-git = "https://github.com/jongiddy/bzip2-rs"
-rev = "2aefcb4d3634de1df226c73d93f758d65228bb8c"
-
-# The upstream xz2 crate uses an old version of liblzma when compiling with the
-# `static` feature and doesn't enable all of the encoders and decoders. This
-# causes certain payload data to fail to decompress.
-# https://github.com/chenxiaolong/avbroot/issues/138
-[dependencies.xz2]
-git = "https://github.com/chenxiaolong/xz2-rs"
-rev = "fe2050b9c3395db15d8610f1dabb505440c1a556"
+git = "https://github.com/chenxiaolong/bzip2-rs"
+rev = "6e0f9836ec87b19261461b6cc1772e14aff8e851"
 
 # https://github.com/zip-rs/zip/pull/383
 [dependencies.zip]
@@ -75,11 +71,11 @@ features = ["deflate"]
 rustix = { version = "0.38.9", default-features = false, features = ["process"] }
 
 [build-dependencies]
-# Disable the clap feature since it pulls in an ancient version of clap.
-pb-rs = { version = "0.10.0", default-features = false }
+prost-build = "0.12.1"
+protox = "0.6.0"
 
 [dev-dependencies]
 assert_matches = "1.5.0"
 
 [features]
-static = ["bzip2/static", "xz2/static"]
+static = ["bzip2/static", "liblzma/static"]

avbroot/build.rs

@@ -5,8 +5,6 @@
 
 use std::{env, ffi::OsStr, fs, io, path::Path};
 
-use pb_rs::{types::FileDescriptor, ConfigBuilder};
-
 fn main() {
     let out_dir = Path::new(&env::var("OUT_DIR").unwrap()).join("protobuf");
     let in_dir = Path::new(&env::var("CARGO_MANIFEST_DIR").unwrap()).join("protobuf");
@@ -30,14 +28,10 @@ fn main() {
 
     fs::create_dir_all(&out_dir).unwrap();
 
-    let config = ConfigBuilder::new(&protos, None, Some(&out_dir), &[in_dir])
-        .unwrap()
-        .dont_use_cow(true)
-        // We're using this as a means to force quick-protobuf to use BTreeMap
-        // instead of HashMap so that the serialized messages are reproducible.
-        // https://github.com/tafia/quick-protobuf/issues/251
-        .nostd(true)
-        .build();
+    let file_descriptors = protox::compile(&protos, [&in_dir]).unwrap();
 
-    FileDescriptor::run(&config).unwrap();
+    prost_build::Config::new()
+        .btree_map(["."])
+        .compile_fds(file_descriptors)
+        .unwrap();
 }

avbroot/src/boot.rs

@@ -1,792 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2022-2023 Andrew Gunnerson
- * SPDX-License-Identifier: GPL-3.0-only
- */
-
-use std::{
-    cmp::Ordering,
-    collections::HashMap,
-    fs::File,
-    io::{self, BufRead, BufReader, Cursor, Read, Seek, Write},
-    num::ParseIntError,
-    ops::Range,
-    path::{Path, PathBuf},
-    sync::atomic::AtomicBool,
-};
-
-use bstr::ByteSlice;
-use regex::bytes::Regex;
-use ring::digest::Context;
-use rsa::RsaPrivateKey;
-use thiserror::Error;
-use x509_cert::Certificate;
-use xz2::{
-    stream::{Check, Stream},
-    write::XzEncoder,
-};
-use zip::{result::ZipError, write::FileOptions, CompressionMethod, ZipArchive, ZipWriter};
-
-use crate::{
-    crypto,
-    format::{
-        avb::{self, Descriptor},
-        bootimage::{self, BootImage, BootImageExt, RamdiskMeta},
-        compression::{self, CompressedFormat, CompressedReader, CompressedWriter},
-        cpio::{self, CpioEntryNew},
-    },
-    stream::{self, FromReader, HashingWriter, SectionReader, ToWriter},
-};
-
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("Boot image has no vbmeta footer")]
-    NoFooter,
-    #[error("No hash descriptor found in vbmeta header")]
-    NoHashDescriptor,
-    #[error("Found multiple hash descriptors in vbmeta header")]
-    MultipleHashDescriptors,
-    #[error("Validation error: {0}")]
-    Validation(String),
-    #[error("Failed to parse Magisk version from line: {0:?}")]
-    ParseMagiskVersion(String, #[source] ParseIntError),
-    #[error("Failed to determine Magisk version from: {0:?}")]
-    FindMagiskVersion(PathBuf),
-    #[error("AVB error")]
-    Avb(#[from] avb::Error),
-    #[error("Boot image error")]
-    BootImage(#[from] bootimage::Error),
-    #[error("Compression error")]
-    Compression(#[from] compression::Error),
-    #[error("Crypto error")]
-    Crypto(#[from] crypto::Error),
-    #[error("CPIO error")]
-    Cpio(#[from] cpio::Error),
-    #[error("XZ stream error")]
-    XzStream(#[from] xz2::stream::Error),
-    #[error("Zip error")]
-    Zip(#[from] ZipError),
-    #[error("I/O error")]
-    Io(#[from] io::Error),
-    #[error("File I/O error")]
-    File(PathBuf, #[source] io::Error),
-}
-
-type Result<T> = std::result::Result<T, Error>;
-
-fn load_ramdisk(data: &[u8]) -> Result<(Vec<CpioEntryNew>, CompressedFormat)> {
-    let raw_reader = Cursor::new(data);
-    let mut reader = CompressedReader::new(raw_reader, false)?;
-    let entries = cpio::load(&mut reader, false)?;
-
-    Ok((entries, reader.format()))
-}
-
-fn save_ramdisk(entries: &[CpioEntryNew], format: CompressedFormat) -> Result<Vec<u8>> {
-    let raw_writer = Cursor::new(vec![]);
-    let mut writer = CompressedWriter::new(raw_writer, format)?;
-    cpio::save(&mut writer, entries, false)?;
-
-    let raw_writer = writer.finish()?;
-    Ok(raw_writer.into_inner())
-}
-
-pub trait BootImagePatcher {
-    fn patch(&self, boot_image: &mut BootImage, cancel_signal: &AtomicBool) -> Result<()>;
-}
-
-/// Root a boot image with Magisk.
-pub struct MagiskRootPatcher {
-    apk_path: PathBuf,
-    version: u32,
-    preinit_device: Option<String>,
-    random_seed: u64,
-}
-
-impl MagiskRootPatcher {
-    // - Versions <25102 are not supported because they're missing commit
-    //   1f8c063dc64806c4f7320ed66c785ff7bc116383, which would leave devices
-    //   that use Android 13 GKIs unable to boot into recovery
-    // - Versions 25207 through 25210 are not supported because they used the
-    //   RULESDEVICE config option, which stored the writable block device as an
-    //   rdev major/minor pair, which was not consistent across reboots and was
-    //   replaced by PREINITDEVICE
-    const VERS_SUPPORTED: &[Range<u32>] = &[25102..25207, 25211..26400];
-    const VER_PREINIT_DEVICE: Range<u32> =
-        25211..Self::VERS_SUPPORTED[Self::VERS_SUPPORTED.len() - 1].end;
-    const VER_RANDOM_SEED: Range<u32> = 25211..26103;
-
-    pub fn new(
-        path: &Path,
-        preinit_device: Option<&str>,
-        random_seed: Option<u64>,
-        ignore_compatibility: bool,
-        warning_fn: impl Fn(&str) + Send + 'static,
-    ) -> Result<Self> {
-        let version = Self::get_version(path)?;
-
-        if !Self::VERS_SUPPORTED.iter().any(|v| v.contains(&version)) {
-            let msg = format!(
-                "Unsupported Magisk version {} (supported: {:?})",
-                version,
-                Self::VERS_SUPPORTED,
-            );
-
-            if ignore_compatibility {
-                warning_fn(&msg);
-            } else {
-                return Err(Error::Validation(msg));
-            }
-        }
-
-        if preinit_device.is_none() && Self::VER_PREINIT_DEVICE.contains(&version) {
-            let msg = format!(
-                "Magisk version {} ({:?}) requires a preinit device to be specified",
-                version,
-                Self::VER_PREINIT_DEVICE,
-            );
-
-            if ignore_compatibility {
-                warning_fn(&msg);
-            } else {
-                return Err(Error::Validation(msg));
-            }
-        }
-
-        Ok(Self {
-            apk_path: path.to_owned(),
-            version,
-            preinit_device: preinit_device.map(|d| d.to_owned()),
-            // Use a hardcoded random seed by default to ensure byte-for-byte
-            // reproducibility.
-            random_seed: random_seed.unwrap_or(0xfedcba9876543210),
-        })
-    }
-
-    fn get_version(path: &Path) -> Result<u32> {
-        let reader = File::open(path).map_err(|e| Error::File(path.to_owned(), e))?;
-        let reader = BufReader::new(reader);
-        let mut zip = ZipArchive::new(reader)?;
-        let entry = zip.by_name("assets/util_functions.sh")?;
-        let mut entry = BufReader::new(entry);
-        let mut line = String::new();
-
-        loop {
-            line.clear();
-            let n = entry.read_line(&mut line)?;
-            if n == 0 {
-                return Err(Error::FindMagiskVersion(path.to_owned()));
-            }
-
-            if let Some(suffix) = line.trim_end().strip_prefix("MAGISK_VER_CODE=") {
-                let version = suffix
-                    .parse()
-                    .map_err(|e| Error::ParseMagiskVersion(suffix.to_owned(), e))?;
-                return Ok(version);
-            }
-        }
-    }
-
-    /// Compare old and new ramdisk entry lists, creating the Magisk `.backup/`
-    /// directory structure. `.backup/.rmlist` will contain a sorted list of
-    /// NULL-terminated strings, listing which files were newly added or
-    /// changed. The old entries for changed files will be added to the new
-    /// entries as `.backup/<path>`.
-    ///
-    /// Both lists and entries within the lists may be mutated.
-    fn apply_magisk_backup(old_entries: &mut [CpioEntryNew], new_entries: &mut Vec<CpioEntryNew>) {
-        cpio::sort(old_entries);
-        cpio::sort(new_entries);
-
-        let mut rm_list = vec![];
-        let mut to_back_up = vec![];
-
-        let mut old_iter = old_entries.iter().peekable();
-        let mut new_iter = new_entries.iter().peekable();
-
-        loop {
-            match (old_iter.peek(), new_iter.peek()) {
-                (Some(&old), Some(&new)) => match old.name.cmp(&new.name) {
-                    Ordering::Less => {
-                        to_back_up.push(old);
-                        old_iter.next();
-                    }
-                    Ordering::Equal => {
-                        if old.content != new.content {
-                            to_back_up.push(old);
-                        }
-                        old_iter.next();
-                        new_iter.next();
-                    }
-                    Ordering::Greater => {
-                        rm_list.extend(&new.name);
-                        rm_list.push(b'\0');
-                        new_iter.next();
-                    }
-                },
-                (Some(old), None) => {
-                    to_back_up.push(old);
-                    old_iter.next();
-                }
-                (None, Some(new)) => {
-                    rm_list.extend(&new.name);
-                    rm_list.push(b'\0');
-                    new_iter.next();
-                }
-                (None, None) => break,
-            }
-        }
-
-        // Intentially using 000 permissions to match Magisk.
-        new_entries.push(CpioEntryNew::new_directory(b".backup"));
-
-        for old_entry in to_back_up {
-            let mut new_entry = old_entry.clone();
-            new_entry.name = b".backup/".to_vec();
-            new_entry.name.extend(&old_entry.name);
-            new_entries.push(new_entry);
-        }
-
-        {
-            // Intentially using 000 permissions to match Magisk.
-            let mut entry = CpioEntryNew::new_file(b".backup/.rmlist");
-            entry.content = rm_list;
-            new_entries.push(entry);
-        }
-    }
-}
-
-impl BootImagePatcher for MagiskRootPatcher {
-    fn patch(&self, boot_image: &mut BootImage, cancel_signal: &AtomicBool) -> Result<()> {
-        let zip_reader =
-            File::open(&self.apk_path).map_err(|e| Error::File(self.apk_path.clone(), e))?;
-        let mut zip = ZipArchive::new(BufReader::new(zip_reader))?;
-
-        // Load the first ramdisk. If it doesn't exist, we have to generate one
-        // from scratch.
-        let ramdisk = match boot_image {
-            BootImage::V0Through2(b) => Some(&b.ramdisk),
-            BootImage::V3Through4(b) => Some(&b.ramdisk),
-            BootImage::VendorV3Through4(b) => b.ramdisks.first(),
-        };
-        let (mut entries, ramdisk_format) = match ramdisk {
-            Some(r) if !r.is_empty() => load_ramdisk(r)?,
-            _ => (vec![], CompressedFormat::Lz4Legacy),
-        };
-
-        let mut old_entries = entries.clone();
-
-        // Create the Magisk directory structure.
-        for (path, perms) in [
-            (b"overlay.d".as_slice(), 0o750),
-            (b"overlay.d/sbin".as_slice(), 0o750),
-        ] {
-            let mut entry = CpioEntryNew::new_directory(path);
-            entry.mode |= perms;
-            entries.push(entry);
-        }
-
-        // Delete the original init.
-        entries.retain(|e| e.name != b"init");
-
-        // Add magiskinit.
-        {
-            let mut zip_entry = zip.by_name("lib/arm64-v8a/libmagiskinit.so")?;
-            let mut data = vec![];
-            zip_entry.read_to_end(&mut data)?;
-
-            let mut entry = CpioEntryNew::new_file(b"init");
-            entry.mode |= 0o750;
-            entry.content = data;
-            entries.push(entry);
-        }
-
-        // Add xz-compressed magisk32 and magisk64.
-        let mut xz_files = HashMap::<&str, &[u8]>::new();
-        xz_files.insert(
-            "lib/armeabi-v7a/libmagisk32.so",
-            b"overlay.d/sbin/magisk32.xz",
-        );
-        xz_files.insert(
-            "lib/arm64-v8a/libmagisk64.so",
-            b"overlay.d/sbin/magisk64.xz",
-        );
-
-        // Add stub apk, which only exists after Magisk commit
-        // ad0e6511e11ebec65aa9b5b916e1397342850319.
-        if zip.file_names().any(|n| n == "assets/stub.apk") {
-            xz_files.insert("assets/stub.apk", b"overlay.d/sbin/stub.xz");
-        }
-
-        for (source, target) in xz_files {
-            let reader = zip.by_name(source)?;
-            let raw_writer = Cursor::new(vec![]);
-            let stream = Stream::new_easy_encoder(9, Check::Crc32)?;
-            let mut writer = XzEncoder::new_stream(raw_writer, stream);
-
-            stream::copy(reader, &mut writer, cancel_signal)?;
-
-            let raw_writer = writer.finish()?;
-            let mut entry = CpioEntryNew::new_file(target);
-            entry.mode |= 0o644;
-            entry.content = raw_writer.into_inner();
-            entries.push(entry);
-        }
-
-        // Create Magisk .backup directory structure.
-        Self::apply_magisk_backup(&mut old_entries, &mut entries);
-
-        // Create Magisk config.
-        let mut magisk_config = String::new();
-        magisk_config.push_str("KEEPVERITY=true\n");
-        magisk_config.push_str("KEEPFORCEENCRYPT=true\n");
-        magisk_config.push_str("PATCHVBMETAFLAG=false\n");
-        magisk_config.push_str("RECOVERYMODE=false\n");
-
-        if Self::VER_PREINIT_DEVICE.contains(&self.version) {
-            magisk_config.push_str(&format!(
-                "PREINITDEVICE={}\n",
-                self.preinit_device.as_ref().unwrap(),
-            ));
-        }
-
-        // Magisk normally saves the original SHA1 digest in its config file. It
-        // uses this to find the original image in /data/magisk_backup_<sha1> to
-        // restore the stock boot image for uninstallation purposes. This is a
-        // feature we cannot ever use, so just use a dummy value.
-        magisk_config.push_str("SHA1=0000000000000000000000000000000000000000\n");
-
-        if Self::VER_RANDOM_SEED.contains(&self.version) {
-            magisk_config.push_str(&format!("RANDOMSEED={:#x}\n", self.random_seed));
-        }
-
-        {
-            // Intentially using 000 permissions to match Magisk.
-            let mut entry = CpioEntryNew::new_file(b".backup/.magisk");
-            entry.content = magisk_config.into_bytes();
-            entries.push(entry);
-        }
-
-        // Repack ramdisk.
-        cpio::sort(&mut entries);
-        cpio::reassign_inodes(&mut entries);
-        let new_ramdisk = save_ramdisk(&entries, ramdisk_format)?;
-
-        match boot_image {
-            BootImage::V0Through2(b) => b.ramdisk = new_ramdisk,
-            BootImage::V3Through4(b) => b.ramdisk = new_ramdisk,
-            BootImage::VendorV3Through4(b) => {
-                if b.ramdisks.is_empty() {
-                    b.ramdisks.push(new_ramdisk);
-
-                    if let Some(v4) = &mut b.v4_extra {
-                        v4.ramdisk_metas.push(RamdiskMeta {
-                            ramdisk_type: bootimage::VENDOR_RAMDISK_TYPE_NONE,
-                            ramdisk_name: String::new(),
-                            board_id: Default::default(),
-                        });
-                    }
-                } else {
-                    b.ramdisks[0] = new_ramdisk;
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-/// Replace the OTA certificates in the vendor_boot/recovery image with the
-/// custom OTA signing certificate.
-pub struct OtaCertPatcher {
-    cert: Certificate,
-}
-
-impl OtaCertPatcher {
-    const OTACERTS_PATH: &[u8] = b"system/etc/security/otacerts.zip";
-
-    pub fn new(cert: Certificate) -> Self {
-        Self { cert }
-    }
-
-    pub fn get_certificates(boot_image: &BootImage) -> Result<Vec<Certificate>> {
-        let mut ramdisks = vec![];
-
-        match boot_image {
-            BootImage::V0Through2(b) => ramdisks.push(&b.ramdisk),
-            BootImage::V3Through4(b) => ramdisks.push(&b.ramdisk),
-            BootImage::VendorV3Through4(b) => ramdisks.extend(b.ramdisks.iter()),
-        }
-
-        let mut certificates = vec![];
-
-        for ramdisk in ramdisks {
-            let (entries, _) = load_ramdisk(ramdisk)?;
-            let Some(entry) = entries.iter().find(|e| e.name == Self::OTACERTS_PATH) else {
-                continue;
-            };
-
-            let mut zip = ZipArchive::new(Cursor::new(&entry.content))?;
-
-            for index in 0..zip.len() {
-                let zip_entry = zip.by_index(index)?;
-                if !zip_entry.name().ends_with(".x509.pem") {
-                    continue;
-                }
-
-                let certificate = crypto::read_pem_cert(zip_entry)?;
-                certificates.push(certificate);
-            }
-        }
-
-        Ok(certificates)
-    }
-
-    fn patch_ramdisk(&self, data: &mut Vec<u8>) -> Result<bool> {
-        let (mut entries, ramdisk_format) = load_ramdisk(data)?;
-        let Some(entry) = entries.iter_mut().find(|e| e.name == Self::OTACERTS_PATH) else {
-            return Ok(false);
-        };
-
-        // Create a new otacerts archive. The old certs are ignored since
-        // flashing a stock OTA will render the device unbootable.
-        {
-            let raw_writer = Cursor::new(vec![]);
-            let mut writer = ZipWriter::new(raw_writer);
-            let options = FileOptions::default().compression_method(CompressionMethod::Stored);
-            writer.start_file("ota.x509.pem", options)?;
-
-            crypto::write_pem_cert(&mut writer, &self.cert)?;
-
-            let raw_writer = writer.finish()?;
-            entry.content = raw_writer.into_inner();
-        }
-
-        // Repack ramdisk.
-        *data = save_ramdisk(&entries, ramdisk_format)?;
-
-        Ok(true)
-    }
-}
-
-impl BootImagePatcher for OtaCertPatcher {
-    fn patch(&self, boot_image: &mut BootImage, _cancel_signal: &AtomicBool) -> Result<()> {
-        let patched_any = match boot_image {
-            BootImage::V0Through2(b) => self.patch_ramdisk(&mut b.ramdisk)?,
-            BootImage::V3Through4(b) => self.patch_ramdisk(&mut b.ramdisk)?,
-            BootImage::VendorV3Through4(b) => {
-                let mut patched = false;
-
-                for ramdisk in &mut b.ramdisks {
-                    if self.patch_ramdisk(ramdisk)? {
-                        patched = true;
-                        break;
-                    }
-                }
-
-                patched
-            }
-        };
-
-        // Fail hard if otacerts does not exist. We don't want to lock the user
-        // out of future updates if the OTA certificate mechanism has changed.
-        if !patched_any {
-            return Err(Error::Validation(format!(
-                "No ramdisk contains {:?}",
-                Self::OTACERTS_PATH.as_bstr(),
-            )));
-        }
-
-        Ok(())
-    }
-}
-
-/// Replace the boot image with a prepatched boot image if it is compatible.
-///
-/// An image is compatible if all the non-size-related header fields are
-/// identical and the set of included sections (eg. kernel, dtb) are the same.
-/// The only exception is the number of ramdisk sections, which is allowed to be
-/// higher than the original image.
-pub struct PrepatchedImagePatcher {
-    prepatched: PathBuf,
-    fatal_level: u8,
-    warning_fn: Box<dyn Fn(&str) + Send>,
-}
-
-impl PrepatchedImagePatcher {
-    const MIN_LEVEL: u8 = 0;
-    const MAX_LEVEL: u8 = 2;
-
-    // We compile without Unicode support so we have to use [0-9] instead of \d.
-    const VERSION_REGEX: &str = r"Linux version ([0-9]+\.[0-9]+).[0-9]+-(android[0-9]+)-([0-9]+)-";
-
-    pub fn new(
-        prepatched: &Path,
-        fatal_level: u8,
-        warning_fn: impl Fn(&str) + Send + 'static,
-    ) -> Self {
-        Self {
-            prepatched: prepatched.to_owned(),
-            fatal_level,
-            warning_fn: Box::new(warning_fn),
-        }
-    }
-
-    fn get_kmi_version(kernel: &[u8]) -> Result<Option<String>> {
-        let mut decompressed = vec![];
-        {
-            let raw_reader = Cursor::new(kernel);
-            let mut reader = CompressedReader::new(raw_reader, true)?;
-            reader.read_to_end(&mut decompressed)?;
-        }
-
-        let regex = Regex::new(Self::VERSION_REGEX).unwrap();
-        let Some(captures) = regex.captures(&decompressed) else {
-            return Ok(None);
-        };
-
-        let kmi_version = captures
-            .iter()
-            // Capture #0 is the entire match.
-            .skip(1)
-            .flatten()
-            .map(|c| c.as_bytes())
-            // Our regex only matches ASCII bytes.
-            .map(|c| std::str::from_utf8(c).unwrap())
-            .collect::<Vec<_>>()
-            .join("-");
-
-        Ok(Some(kmi_version))
-    }
-}
-
-impl BootImagePatcher for PrepatchedImagePatcher {
-    fn patch(&self, boot_image: &mut BootImage, _cancel_signal: &AtomicBool) -> Result<()> {
-        let prepatched_image = {
-            let raw_reader = File::open(&self.prepatched)
-                .map_err(|e| Error::File(self.prepatched.clone(), e))?;
-            BootImage::from_reader(BufReader::new(raw_reader))?
-        };
-
-        // Level 0: Warnings that don't affect booting
-        // Level 1: Warnings that may affect booting
-        // Level 2: Warnings that are very likely to affect booting
-        let mut issues = [vec![], vec![], vec![]];
-
-        macro_rules! check {
-            ($level:literal, $old:expr, $new:expr $(,)?) => {
-                let old_val = $old;
-                let new_val = $new;
-
-                if old_val != new_val {
-                    issues[$level].push(format!(
-                        "Field differs: {} ({:?}) -> {} ({:?})",
-                        stringify!($old),
-                        old_val,
-                        stringify!($new),
-                        new_val,
-                    ));
-                }
-            };
-        }
-
-        let old_kernel;
-        let new_kernel;
-
-        match (&boot_image, &prepatched_image) {
-            (BootImage::V0Through2(old), BootImage::V0Through2(new)) => {
-                check!(2, old.header_version(), new.header_version());
-                check!(2, old.kernel_addr, new.kernel_addr);
-                check!(2, old.ramdisk_addr, new.ramdisk_addr);
-                check!(2, old.second_addr, new.second_addr);
-                check!(2, old.tags_addr, new.tags_addr);
-                check!(2, old.page_size, new.page_size);
-                check!(0, old.os_version, new.os_version);
-                check!(0, &old.name, &new.name);
-                check!(1, &old.cmdline, &new.cmdline);
-                check!(0, &old.id, &new.id);
-                check!(1, &old.extra_cmdline, &new.extra_cmdline);
-                check!(2, old.kernel.is_empty(), new.kernel.is_empty());
-                check!(2, old.second.is_empty(), new.second.is_empty());
-
-                if let (Some(old_v1), Some(new_v1)) = (&old.v1_extra, &new.v1_extra) {
-                    check!(2, old_v1.recovery_dtbo_offset, new_v1.recovery_dtbo_offset);
-                    check!(
-                        2,
-                        old_v1.recovery_dtbo.is_empty(),
-                        new_v1.recovery_dtbo.is_empty(),
-                    );
-                }
-
-                if let (Some(old_v2), Some(new_v2)) = (&old.v2_extra, &new.v2_extra) {
-                    check!(2, old_v2.dtb_addr, new_v2.dtb_addr);
-                    check!(2, old_v2.dtb.is_empty(), new_v2.dtb.is_empty());
-                }
-
-                // We allow adding a ramdisk.
-                if !old.ramdisk.is_empty() || new.ramdisk.is_empty() {
-                    check!(2, old.ramdisk.is_empty(), new.ramdisk.is_empty());
-                }
-
-                old_kernel = if old.kernel.is_empty() {
-                    None
-                } else {
-                    Some(&old.kernel)
-                };
-                new_kernel = if new.kernel.is_empty() {
-                    None
-                } else {
-                    Some(&new.kernel)
-                };
-            }
-            (BootImage::V3Through4(old), BootImage::V3Through4(new)) => {
-                check!(2, old.header_version(), new.header_version());
-                check!(0, old.os_version, new.os_version);
-                check!(0, old.reserved, new.reserved);
-                check!(1, &old.cmdline, &new.cmdline);
-                check!(2, old.kernel.is_empty(), new.kernel.is_empty());
-
-                // We allow adding a ramdisk.
-                if !old.ramdisk.is_empty() || new.ramdisk.is_empty() {
-                    check!(2, old.ramdisk.is_empty(), new.ramdisk.is_empty());
-                }
-
-                old_kernel = if old.kernel.is_empty() {
-                    None
-                } else {
-                    Some(&old.kernel)
-                };
-                new_kernel = if new.kernel.is_empty() {
-                    None
-                } else {
-                    Some(&new.kernel)
-                };
-            }
-            (BootImage::VendorV3Through4(old), BootImage::VendorV3Through4(new)) => {
-                check!(2, old.page_size, new.page_size);
-                check!(2, old.kernel_addr, new.kernel_addr);
-                check!(2, old.ramdisk_addr, new.ramdisk_addr);
-                check!(1, &old.cmdline, &new.cmdline);
-                check!(2, old.tags_addr, new.tags_addr);
-                check!(0, &old.name, &new.name);
-                check!(2, old.dtb.is_empty(), new.dtb.is_empty());
-                check!(2, old.dtb_addr, new.dtb_addr);
-                check!(2, old.ramdisks.len(), new.ramdisks.len());
-
-                if let (Some(old_v4), Some(new_v4)) = (&old.v4_extra, &new.v4_extra) {
-                    check!(2, &old_v4.ramdisk_metas, &new_v4.ramdisk_metas);
-                    check!(2, &old_v4.bootconfig, &new_v4.bootconfig);
-                }
-
-                old_kernel = None;
-                new_kernel = None;
-            }
-            _ => {
-                return Err(Error::Validation(
-                    "Boot image and prepatched image are different boot image types".to_owned(),
-                ));
-            }
-        }
-
-        if let (Some(old), Some(new)) = (old_kernel, new_kernel) {
-            let old_kmi_version = Self::get_kmi_version(old)?;
-            let new_kmi_version = Self::get_kmi_version(new)?;
-
-            check!(2, old_kmi_version, new_kmi_version);
-        }
-
-        let mut warnings = vec![];
-        let mut errors = vec![];
-
-        for level in Self::MIN_LEVEL..self.fatal_level {
-            warnings.extend(&issues[level as usize]);
-        }
-        for level in self.fatal_level..=Self::MAX_LEVEL {
-            errors.extend(&issues[level as usize]);
-        }
-
-        if !warnings.is_empty() {
-            let mut msg =
-                "The prepatched boot image may not be compatible with the original:".to_owned();
-            for warning in warnings {
-                msg.push_str("\n- ");
-                msg.push_str(warning);
-            }
-
-            (self.warning_fn)(&msg);
-        }
-
-        if !errors.is_empty() {
-            let mut msg =
-                "The prepatched boot image is not compatible with the original:".to_owned();
-            for error in errors {
-                msg.push_str("\n- ");
-                msg.push_str(error);
-            }
-
-            return Err(Error::Validation(msg));
-        }
-
-        *boot_image = prepatched_image;
-
-        Ok(())
-    }
-}
-
-/// Run each patcher against the boot image with the vbmeta footer stripped off
-/// and then re-sign the image.
-pub fn patch_boot(
-    mut reader: impl Read + Seek,
-    writer: impl Write + Seek,
-    key: &RsaPrivateKey,
-    patchers: &[Box<dyn BootImagePatcher + Send>],
-    cancel_signal: &AtomicBool,
-) -> Result<()> {
-    let (mut header, footer, image_size) = avb::load_image(&mut reader)?;
-    let Some(mut footer) = footer else {
-        return Err(Error::NoFooter);
-    };
-
-    let section_reader = SectionReader::new(reader, 0, footer.original_image_size)?;
-    let mut boot_image = BootImage::from_reader(section_reader)?;
-
-    for patcher in patchers {
-        patcher.patch(&mut boot_image, cancel_signal)?;
-    }
-
-    header.set_algo_for_key(key)?;
-
-    let mut descriptor_iter = header.descriptors.iter_mut().filter_map(|d| {
-        if let Descriptor::Hash(h) = d {
-            Some(h)
-        } else {
-            None
-        }
-    });
-
-    let Some(descriptor) = descriptor_iter.next() else {
-        return Err(Error::NoHashDescriptor);
-    };
-
-    // Write new boot image. We reuse the existing salt for the digest.
-    let mut context = Context::new(&ring::digest::SHA256);
-    context.update(&descriptor.salt);
-    let mut hashing_writer = HashingWriter::new(writer, context);
-    boot_image.to_writer(&mut hashing_writer)?;
-    let (mut writer, context) = hashing_writer.finish();
-
-    descriptor.image_size = writer.stream_position()?;
-    descriptor.hash_algorithm = "sha256".to_owned();
-    descriptor.root_digest = context.finish().as_ref().to_vec();
-
-    if descriptor_iter.next().is_some() {
-        return Err(Error::MultipleHashDescriptors);
-    }
-
-    if !header.public_key.is_empty() {
-        header.sign(key)?;
-    }
-
-    avb::write_appended_image(writer, &header, &mut footer, image_size)?;
-
-    Ok(())
-}

avbroot/src/cli/args.rs

@@ -1,14 +1,21 @@
 /*
- * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
  * SPDX-License-Identifier: GPL-3.0-only
  */
 
-use std::sync::atomic::AtomicBool;
+use std::{
+    fmt,
+    io::{self, IsTerminal},
+    sync::atomic::{AtomicBool, Ordering},
+    time::Instant,
+};
 
 use anyhow::Result;
-use clap::{Parser, Subcommand};
+use clap::{Parser, Subcommand, ValueEnum};
+use tracing::{debug, Level};
+use tracing_subscriber::fmt::{format::Writer, time::FormatTime};
 
-use crate::cli::{avb, boot, completion, fec, key, ota, ramdisk};
+use crate::cli::{avb, boot, completion, cpio, fec, hashtree, key, ota, payload};
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Debug, Subcommand)]
@@ -16,10 +23,12 @@ pub enum Command {
     Avb(avb::AvbCli),
     Boot(boot::BootCli),
     Completion(completion::CompletionCli),
+    Cpio(cpio::CpioCli),
     Fec(fec::FecCli),
+    HashTree(hashtree::HashTreeCli),
     Key(key::KeyCli),
     Ota(ota::OtaCli),
-    Ramdisk(ramdisk::RamdiskCli),
+    Payload(payload::PayloadCli),
     /// (Deprecated: Use `avbroot ota patch` instead.)
     Patch(ota::PatchCli),
     /// (Deprecated: Use `avbroot ota extract` instead.)
@@ -28,24 +37,134 @@ pub enum Command {
     MagiskInfo(boot::MagiskInfoCli),
 }
 
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub enum LogLevel {
+    Trace,
+    Debug,
+    Info,
+    Warn,
+    Error,
+}
+
+impl LogLevel {
+    fn as_level(self) -> Level {
+        match self {
+            Self::Trace => Level::TRACE,
+            Self::Debug => Level::DEBUG,
+            Self::Info => Level::INFO,
+            Self::Warn => Level::WARN,
+            Self::Error => Level::ERROR,
+        }
+    }
+}
+
+impl Default for LogLevel {
+    fn default() -> Self {
+        Self::Info
+    }
+}
+
+impl fmt::Display for LogLevel {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.to_possible_value().ok_or(fmt::Error)?.get_name())
+    }
+}
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub enum LogFormat {
+    Short,
+    Medium,
+    Long,
+}
+
+impl Default for LogFormat {
+    fn default() -> Self {
+        Self::Short
+    }
+}
+
+impl fmt::Display for LogFormat {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.to_possible_value().ok_or(fmt::Error)?.get_name())
+    }
+}
+
 #[derive(Debug, Parser)]
 #[command(version)]
 pub struct Cli {
     #[command(subcommand)]
     pub command: Command,
+
+    /// Lowest log message severity to output.
+    #[arg(long, global = true, value_name = "LEVEL", default_value_t)]
+    pub log_level: LogLevel,
+
+    /// Output format for log messages.
+    #[arg(long, global = true, value_name = "FORMAT", default_value_t)]
+    pub log_format: LogFormat,
 }
 
-pub fn main(cancel_signal: &AtomicBool) -> Result<()> {
+#[derive(Debug, Clone, Copy)]
+pub struct ShortUptime {
+    epoch: Instant,
+}
+
+impl Default for ShortUptime {
+    fn default() -> Self {
+        Self {
+            epoch: Instant::now(),
+        }
+    }
+}
+
+impl FormatTime for ShortUptime {
+    fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
+        let e = self.epoch.elapsed();
+        write!(w, "{:3}.{:03}s", e.as_secs(), e.subsec_millis())
+    }
+}
+
+pub fn init_logging(log_level: LogLevel, log_format: LogFormat) {
+    let builder = tracing_subscriber::fmt()
+        .with_writer(io::stderr)
+        .with_ansi(io::stderr().is_terminal())
+        .with_max_level(log_level.as_level());
+
+    match log_format {
+        LogFormat::Short => {
+            let format = tracing_subscriber::fmt::format()
+                .with_timer(ShortUptime::default())
+                .with_target(false);
+
+            builder.event_format(format).init();
+        }
+        LogFormat::Medium => {
+            builder.with_timer(ShortUptime::default()).init();
+        }
+        LogFormat::Long => {
+            builder.pretty().init();
+        }
+    }
+}
+
+pub fn main(logging_initialized: &AtomicBool, cancel_signal: &AtomicBool) -> Result<()> {
     let cli = Cli::parse();
 
+    init_logging(cli.log_level, cli.log_format);
+    logging_initialized.store(true, Ordering::SeqCst);
+
+    debug!(?cli);
+
     match cli.command {
         Command::Avb(c) => avb::avb_main(&c, cancel_signal),
         Command::Boot(c) => boot::boot_main(&c),
         Command::Completion(c) => completion::completion_main(&c),
+        Command::Cpio(c) => cpio::cpio_main(&c, cancel_signal),
         Command::Fec(c) => fec::fec_main(&c, cancel_signal),
+        Command::HashTree(c) => hashtree::hash_tree_main(&c, cancel_signal),
         Command::Key(c) => key::key_main(&c),
         Command::Ota(c) => ota::ota_main(&c, cancel_signal),
-        Command::Ramdisk(c) => ramdisk::ramdisk_main(&c),
+        Command::Payload(c) => payload::payload_main(&c),
         // Deprecated aliases.
         Command::Patch(c) => ota::patch_subcommand(&c, cancel_signal),
         Command::Extract(c) => ota::extract_subcommand(&c, cancel_signal),

avbroot/src/cli/avb.rs

@@ -1,12 +1,12 @@
 /*
- * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
  * SPDX-License-Identifier: GPL-3.0-only
  */
 
 use std::{
     collections::{HashMap, HashSet},
     ffi::{OsStr, OsString},
-    fs::{self, File, OpenOptions},
+    fs::{self, File},
     io::{self, BufReader, BufWriter, Seek, SeekFrom, Write},
     path::{Path, PathBuf},
     str,
@@ -14,22 +14,27 @@ use std::{
 };
 
 use anyhow::{anyhow, bail, Context, Result};
+use cap_std::{
+    ambient_authority,
+    fs::{Dir, OpenOptions},
+};
 use clap::{Args, Parser, Subcommand};
 use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
 use rsa::RsaPublicKey;
 use serde::{Deserialize, Serialize};
+use tracing::{debug_span, info, warn, Span};
 
 use crate::{
-    cli::{status, warning},
     crypto::{self, PassphraseSource},
     format::avb::{
         self, AlgorithmType, AppendedDescriptorMut, AppendedDescriptorRef, Descriptor, Footer,
-        Header,
+        HashTreeDescriptor, Header, KernelCmdlineDescriptor,
     },
-    stream::{self, PSeekFile},
+    stream::{self, PSeekFile, Reopen},
+    util,
 };
 
-#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 struct AvbInfo {
     header: Header,
     footer: Option<Footer>,
@@ -52,16 +57,22 @@ fn read_avb_image(path: &Path) -> Result<(AvbInfo, BufReader<File>)> {
     Ok((info, reader))
 }
 
-fn write_avb_image(file: PSeekFile, info: &mut AvbInfo) -> Result<()> {
+fn write_avb_image(file: PSeekFile, info: &mut AvbInfo, recompute_size: bool) -> Result<()> {
     let mut writer = BufWriter::new(file);
 
-    if let Some(f) = &mut info.footer {
-        avb::write_appended_image(&mut writer, &info.header, f, info.image_size)
-            .context("Failed to write appended AVB image")?;
+    info.image_size = if let Some(f) = &mut info.footer {
+        let image_size = if recompute_size {
+            None
+        } else {
+            Some(info.image_size)
+        };
+
+        avb::write_appended_image(&mut writer, &info.header, f, image_size)
+            .context("Failed to write appended AVB image")?
     } else {
         avb::write_root_image(&mut writer, &info.header, 4096)
-            .context("Failed to write root AVB image")?;
-    }
+            .context("Failed to write root AVB image")?
+    };
 
     writer.flush().context("Failed to flush writes")?;
 
@@ -87,6 +98,18 @@ fn write_info(path: &Path, info: &AvbInfo) -> Result<()> {
     Ok(())
 }
 
+/// Packing with insecure algorithms is intentionally not supported, so promote
+/// to a secure algorithm if needed.
+fn promote_insecure_hash_algorithm(algorithm: &mut String) {
+    const INSECURE_ALGORITHMS: &[&str] = &["sha1"];
+    const NEW_ALGORITHM: &str = "sha256";
+
+    if INSECURE_ALGORITHMS.contains(&algorithm.as_str()) {
+        warn!("Changing insecure hash algorithm {algorithm} to {NEW_ALGORITHM}");
+        NEW_ALGORITHM.clone_into(algorithm);
+    }
+}
+
 /// Copy `size` bytes from `reader` into a new file `path` that's opened as
 /// both readable and writable.
 fn write_raw(
@@ -95,7 +118,7 @@ fn write_raw(
     size: u64,
     cancel_signal: &AtomicBool,
 ) -> Result<PSeekFile> {
-    let file = OpenOptions::new()
+    let file = fs::OpenOptions::new()
         .read(true)
         .write(true)
         .create(true)
@@ -140,14 +163,14 @@ fn write_raw_and_verify(
 
     let raw_file = write_raw(path, reader, copy_size, cancel_signal)?;
 
-    let result = verify_and_repair(None, raw_file.reopen(), descriptor, true, cancel_signal);
+    let result = verify_and_repair(None, raw_file.reopen()?, descriptor, true, cancel_signal);
 
     // Chop off the old hash tree and FEC data.
     raw_file.set_len(f.original_image_size)?;
 
     if let Err(e) = result {
         if ignore_invalid {
-            warning!("{e:?}");
+            warn!("{e:?}");
         } else {
             return Err(e);
         }
@@ -174,15 +197,13 @@ fn write_raw_and_update(
 
     match info.header.appended_descriptor_mut()? {
         AppendedDescriptorMut::HashTree(d) => {
+            promote_insecure_hash_algorithm(&mut d.hash_algorithm);
             d.image_size = image_size;
-            d.update(
-                || Ok(Box::new(raw_file.reopen())),
-                || Ok(Box::new(raw_file.reopen())),
-                cancel_signal,
-            )
-            .context("Failed to update hash tree descriptor")?;
+            d.update(&raw_file, &raw_file, None, cancel_signal)
+                .context("Failed to update hash tree descriptor")?;
         }
         AppendedDescriptorMut::Hash(d) => {
+            promote_insecure_hash_algorithm(&mut d.hash_algorithm);
             d.image_size = image_size;
             raw_file.rewind()?;
             d.update(&mut raw_file, cancel_signal)
@@ -193,6 +214,121 @@ fn write_raw_and_update(
     Ok(raw_file)
 }
 
+/// Compute the kernel command line arguments to allow the kernel to set up the
+/// dm-verity block device without dm-init or userspace helpers. This is handled
+/// by init/do_mounts_dm.c in older Pixel devices (and ChromiumOS).
+fn compute_dm_verity_cmdline(descriptor: &HashTreeDescriptor) -> String {
+    use std::fmt::Write;
+
+    let mut result = String::new();
+
+    // Number of device mapper devices.
+    result.push_str("dm=\"1");
+    // Block device name.
+    result.push_str(" vroot");
+    // Block device UUID.
+    result.push_str(" none");
+    // Block device write mode.
+    result.push_str(" ro");
+    // Number of device mapper targets.
+    result.push_str(" 1,");
+    // Starting sector.
+    result.push('0');
+    // Sector count.
+    write!(&mut result, " {}", descriptor.image_size / 512).unwrap();
+    // dm-verity version.
+    write!(&mut result, " verity {}", descriptor.dm_verity_version).unwrap();
+    // Data block device (replaced by bootloader at runtime).
+    result.push_str(" PARTUUID=$(ANDROID_SYSTEM_PARTUUID)");
+    // Hash block device (replaced by bootloader at runtime).
+    result.push_str(" PARTUUID=$(ANDROID_SYSTEM_PARTUUID)");
+    // Data block size.
+    write!(&mut result, " {}", descriptor.data_block_size).unwrap();
+    // Hash block size.
+    write!(&mut result, " {}", descriptor.hash_block_size).unwrap();
+    // Number of data blocks.
+    write!(
+        &mut result,
+        " {}",
+        descriptor.image_size / u64::from(descriptor.data_block_size),
+    )
+    .unwrap();
+    // Hash starting block (in units of the hash block size).
+    write!(
+        &mut result,
+        " {}",
+        descriptor.image_size / u64::from(descriptor.hash_block_size),
+    )
+    .unwrap();
+    // Hash algorithm.
+    write!(&mut result, " {}", descriptor.hash_algorithm).unwrap();
+    // Root digest.
+    write!(&mut result, " {}", &hex::encode(&descriptor.root_digest)).unwrap();
+    // Salt.
+    write!(&mut result, " {}", &hex::encode(&descriptor.salt)).unwrap();
+
+    // Number of optional arguments.
+    let num_optional_args = if descriptor.fec_num_roots != 0 { 10 } else { 2 }
+        + u8::from(descriptor.flags & HashTreeDescriptor::FLAG_CHECK_AT_MOST_ONCE != 0);
+    write!(&mut result, " {num_optional_args}").unwrap();
+
+    if descriptor.flags & HashTreeDescriptor::FLAG_CHECK_AT_MOST_ONCE != 0 {
+        // [n + 1] Only check blocks once instead of on each access.
+        result.push_str(" check_at_most_once");
+    }
+
+    // [0] Corruption handling mode (replaced by bootloader at runtime).
+    result.push_str(" $(ANDROID_VERITY_MODE)");
+    // [1] Force return zeros and skip validation for blocks expected to contain
+    // only zeros.
+    result.push_str(" ignore_zero_blocks");
+
+    if descriptor.fec_num_roots != 0 {
+        // [2-3] Enable FEC (replaced by bootloader at runtime).
+        result.push_str(" use_fec_from_device PARTUUID=$(ANDROID_SYSTEM_PARTUUID)");
+        // [4-5] Number of parity bytes per FEC codeword.
+        write!(&mut result, " fec_roots {}", descriptor.fec_num_roots).unwrap();
+
+        let fec_block_offset = descriptor.fec_offset / u64::from(descriptor.data_block_size);
+
+        // [6-7] Number of data blocks covered by FEC.
+        write!(&mut result, " fec_blocks {fec_block_offset}").unwrap();
+        // [8-9] Starting block (in data block size units) of FEC.
+        write!(&mut result, " fec_start {fec_block_offset}").unwrap();
+    }
+
+    // Root filesystem block device.
+    result.push_str("\" root=/dev/dm-0");
+
+    result
+}
+
+/// Update the dm-verity kernel command line descriptor to match the hash tree
+/// descriptor. This is a no-op if there's no matching existing kernel command
+/// line descriptor to update. Returns whether the descriptor was updated.
+fn update_dm_verity_cmdline(info: &mut AvbInfo) -> Result<bool> {
+    assert!(info.footer.is_some(), "Not an appended image");
+
+    let new_cmdline = match info.header.appended_descriptor()? {
+        AppendedDescriptorRef::HashTree(d) => compute_dm_verity_cmdline(d),
+        AppendedDescriptorRef::Hash(_) => return Ok(false),
+    };
+
+    for d in &mut info.header.descriptors {
+        if let Descriptor::KernelCmdline(d) = d {
+            if d.flags & KernelCmdlineDescriptor::FLAG_USE_ONLY_IF_HASHTREE_NOT_DISABLED != 0
+                && d.cmdline.starts_with("dm=")
+                && d.cmdline != new_cmdline
+            {
+                d.cmdline = new_cmdline;
+                return Ok(true);
+            }
+        }
+    }
+
+    Ok(false)
+}
+
 /// Sign or clear header signatures based on whether the original header was
 /// signed. If the original header was signed and is unchanged, then the
 /// original signature is used as-is. If the force option is specified, then
@@ -226,30 +362,28 @@ fn sign_or_clear(info: &mut AvbInfo, orig_header: &Header, key_group: &KeyGroup)
     match sign_action {
         SignAction::None => {
             if originally_signed {
-                status!("Preserving original AVB header signature");
+                info!("Preserving original AVB header signature");
             } else {
-                status!("Leaving AVB header unsigned");
+                info!("Leaving AVB header unsigned");
             }
         }
         SignAction::Sign => {
             if originally_signed {
-                status!("Replacing AVB header signature");
+                info!("Replacing AVB header signature");
             } else {
-                status!("Signing AVB header");
+                info!("Signing AVB header");
             }
 
             let Some(key_path) = &key_group.key else {
                 bail!("Need to sign new AVB header, but no private key was specified");
             };
 
-            let passphrase = if let Some(v) = &key_group.pass_env_var {
-                PassphraseSource::EnvVar(v.clone())
-            } else if let Some(p) = &key_group.pass_file {
-                PassphraseSource::File(p.clone())
-            } else {
-                PassphraseSource::Prompt(format!("Enter passphrase for {key_path:?}: "))
-            };
-            let private_key = crypto::read_pem_key_file(key_path, &passphrase)
+            let source = PassphraseSource::new(
+                key_path,
+                key_group.pass_file.as_deref(),
+                key_group.pass_env_var.as_deref(),
+            );
+            let private_key = crypto::read_pem_key_file(key_path, &source)
                 .with_context(|| format!("Failed to load key: {key_path:?}"))?;
 
             info.header.set_algo_for_key(&private_key)?;
@@ -259,9 +393,9 @@ fn sign_or_clear(info: &mut AvbInfo, orig_header: &Header, key_group: &KeyGroup)
         }
         SignAction::Clear => {
             if originally_signed {
-                status!("Clearing AVB header signature");
+                info!("Clearing AVB header signature");
             } else {
-                status!("Leaving AVB header unsigned");
+                info!("Leaving AVB header unsigned");
             }
 
             info.header.algorithm_type = AlgorithmType::None;
@@ -292,7 +426,7 @@ fn ensure_name_is_safe(name: &str) -> Result<()> {
 /// `seen` is used to prevent cycles. `descriptors` will contain all of the hash
 /// and hash tree descriptors that need to be verified.
 pub fn verify_headers(
-    directory: &Path,
+    directory: &Dir,
     name: &str,
     expected_key: Option<&RsaPublicKey>,
     seen: &mut HashSet<String>,
@@ -304,9 +438,10 @@ pub fn verify_headers(
 
     ensure_name_is_safe(name)?;
 
-    let path = directory.join(format!("{name}.img"));
-    let raw_reader =
-        File::open(&path).with_context(|| format!("Failed to open for reading: {path:?}"))?;
+    let path = format!("{name}.img");
+    let raw_reader = directory
+        .open(&path)
+        .with_context(|| format!("Failed to open for reading: {path:?}"))?;
     let (header, _, _) = avb::load_image(BufReader::new(raw_reader))
         .with_context(|| format!("Failed to load vbmeta structures: {path:?}"))?;
 
@@ -320,15 +455,15 @@ pub fn verify_headers(
 
         if let Some(e) = expected_key {
             if k == e {
-                status!("{prefix}");
+                info!("{prefix}");
             } else {
                 bail!("{prefix}, but is signed by an untrusted key");
             }
         } else {
-            warning!("{prefix}, but parent does not list a trusted key");
+            warn!("{prefix}, but parent does not list a trusted key");
         }
     } else {
-        status!("{name} has an unsigned vbmeta header");
+        info!("{name} has an unsigned vbmeta header");
     }
 
     for descriptor in &header.descriptors {
@@ -371,6 +506,7 @@ fn verify_and_repair(
     repair: bool,
     cancel_signal: &AtomicBool,
 ) -> Result<()> {
+    let _span = debug_span!("image", name = name.unwrap_or_default()).entered();
     let suffix = match name {
         Some(n) => format!(" for: {n}"),
         None => String::new(),
@@ -378,34 +514,26 @@ fn verify_and_repair(
 
     match descriptor {
         AppendedDescriptorRef::HashTree(d) => {
-            status!("Verifying hash tree descriptor{suffix}");
+            info!("Verifying hash tree descriptor{suffix}");
 
-            match d.verify(|| Ok(Box::new(file.reopen())), cancel_signal) {
-                Err(
-                    e @ avb::Error::InvalidRootDigest { .. }
-                    | e @ avb::Error::InvalidHashTree { .. },
-                ) if repair => {
-                    warning!("Failed to verify hash tree descriptor{suffix}: {e}");
-                    warning!("Attempting to repair using FEC data{suffix}");
+            match d.verify(&file, cancel_signal) {
+                Err(e @ avb::Error::HashTree(_)) if repair => {
+                    warn!("Failed to verify hash tree descriptor{suffix}: {e}");
+                    warn!("Attempting to repair using FEC data{suffix}");
 
-                    d.repair(
-                        || Ok(Box::new(file.reopen())),
-                        || Ok(Box::new(file.reopen())),
-                        cancel_signal,
-                    )
-                    .with_context(|| format!("Failed to repair data{suffix}"))?;
+                    d.repair(&file, &file, cancel_signal)
+                        .with_context(|| format!("Failed to repair data{suffix}"))?;
 
-                    d.verify(|| Ok(Box::new(file.reopen())), cancel_signal)
-                        .map(|_| {
-                            status!("Successfully repaired data{suffix}");
-                        })
+                    d.verify(&file, cancel_signal).map(|_| {
+                        info!("Successfully repaired data{suffix}");
+                    })
                 }
                 ret => ret,
             }
             .with_context(|| format!("Failed to verify hash tree descriptor{suffix}"))?;
         }
         AppendedDescriptorRef::Hash(d) => {
-            status!("Verifying hash descriptor{suffix}");
+            info!("Verifying hash descriptor{suffix}");
 
             file.rewind()?;
             d.verify(file, cancel_signal)
@@ -419,27 +547,29 @@ fn verify_and_repair(
 /// Verify hash and hash tree descriptor digests and FEC data against their
 /// corresponding input files.
 pub fn verify_descriptors(
-    directory: &Path,
+    directory: &Dir,
     descriptors: &HashMap<String, Descriptor>,
     repair: bool,
     cancel_signal: &AtomicBool,
 ) -> Result<()> {
+    let parent_span = Span::current();
+
     descriptors
         .par_iter()
         .map(|(name, descriptor)| {
-            let path = directory.join(format!("{name}.img"));
-            let file = match OpenOptions::new()
-                .read(true)
-                .write(repair)
-                .open(&path)
-                .map(PSeekFile::new)
+            let _span = parent_span.enter();
+
+            let path = format!("{name}.img");
+            let file = match directory
+                .open_with(&path, OpenOptions::new().read(true).write(repair))
+                .map(|f| PSeekFile::new(f.into_std()))
             {
                 Ok(f) => f,
                 // Some devices, like bluejay, have vbmeta descriptors that
                 // refer to partitions that exist on the device, but not in the
                 // OTA.
                 Err(e) if e.kind() == io::ErrorKind::NotFound => {
-                    warning!("Partition image does not exist: {path:?}");
+                    warn!("Partition image does not exist: {path:?}");
                     return Ok(());
                 }
                 Err(e) => {
@@ -488,7 +618,11 @@ fn pack_subcommand(cli: &PackCli, cancel_signal: &AtomicBool) -> Result<()> {
                 format!("Failed to open raw image for reading: {:?}", cli.input_raw)
             })?;
 
-        write_raw_and_update(&cli.output, &mut reader, &mut info, cancel_signal)?
+        let file = write_raw_and_update(&cli.output, &mut reader, &mut info, cancel_signal)?;
+
+        update_dm_verity_cmdline(&mut info)?;
+
+        file
     } else {
         File::create(&cli.output)
             .map(PSeekFile::new)
@@ -497,12 +631,16 @@ fn pack_subcommand(cli: &PackCli, cancel_signal: &AtomicBool) -> Result<()> {
 
     sign_or_clear(&mut info, &orig_header, &cli.key)?;
 
-    write_avb_image(file, &mut info)?;
+    write_avb_image(file, &mut info, cli.recompute_size)?;
 
     // We display the info at the very end after both the header and footer are
     // updated so that incorrect/incomplete information isn't shown.
     display_info(&cli.display, &info);
 
+    if let Some(path) = &cli.output_info {
+        write_info(path, &info)?;
+    }
+
     Ok(())
 }
 
@@ -514,15 +652,14 @@ fn repack_subcommand(cli: &RepackCli, cancel_signal: &AtomicBool) -> Result<()>
         let file = write_raw_and_verify(&cli.output, &mut reader, &info, false, cancel_signal)?;
 
         // Write new hash tree and FEC data instead of copying the original.
-        // THere could have been errors in the original FEC data itself.
+        // There could have been errors in the original FEC data itself.
         if let AppendedDescriptorMut::HashTree(d) = info.header.appended_descriptor_mut()? {
-            d.update(
-                || Ok(Box::new(file.reopen())),
-                || Ok(Box::new(file.reopen())),
-                cancel_signal,
-            )?;
+            promote_insecure_hash_algorithm(&mut d.hash_algorithm);
+            d.update(&file, &file, None, cancel_signal)?;
         }
 
+        update_dm_verity_cmdline(&mut info)?;
+
         file
     } else {
         File::create(&cli.output)
@@ -532,7 +669,7 @@ fn repack_subcommand(cli: &RepackCli, cancel_signal: &AtomicBool) -> Result<()>
 
     sign_or_clear(&mut info, &orig_header, &cli.key)?;
 
-    write_avb_image(file, &mut info)?;
+    write_avb_image(file, &mut info, false)?;
 
     // We display the info at the very end after both the header and footer are
     // updated so that incorrect/incomplete information isn't shown.
@@ -559,7 +696,10 @@ fn verify_subcommand(cli: &VerifyCli, cancel_signal: &AtomicBool) -> Result<()>
         None
     };
 
-    let directory = cli.input.parent().unwrap_or_else(|| Path::new("."));
+    let authority = ambient_authority();
+    let parent_path = util::parent_path(&cli.input);
+    let directory = Dir::open_ambient_dir(parent_path, authority)
+        .with_context(|| format!("Failed to open directory: {parent_path:?}"))?;
     let name = cli
         .input
         .file_stem()
@@ -571,15 +711,15 @@ fn verify_subcommand(cli: &VerifyCli, cancel_signal: &AtomicBool) -> Result<()>
     let mut descriptors = HashMap::<String, Descriptor>::new();
 
     verify_headers(
-        directory,
+        &directory,
         name,
         public_key.as_ref(),
         &mut seen,
         &mut descriptors,
     )?;
-    verify_descriptors(directory, &descriptors, cli.repair, cancel_signal)?;
+    verify_descriptors(&directory, &descriptors, cli.repair, cancel_signal)?;
 
-    status!("Successfully verified all vbmeta signatures and hashes");
+    info!("Successfully verified all vbmeta signatures and hashes");
 
     Ok(())
 }
@@ -659,7 +799,7 @@ struct UnpackCli {
     #[arg(long, value_name = "FILE", value_parser, default_value = "raw.img")]
     output_raw: PathBuf,
 
-    // Ignore invalid digests or FEC data.
+    /// Ignore invalid digests or FEC data.
     #[arg(long)]
     ignore_invalid: bool,
 
@@ -697,12 +837,28 @@ struct PackCli {
     #[arg(long, value_name = "FILE", value_parser, default_value = "avb.toml")]
     input_info: PathBuf,
 
+    /// Path to output AVB info TOML.
+    ///
+    /// If specified, the AVB info containing all recomputed fields will be
+    /// written to this file. This can point to the same file as --input-info.
+    #[arg(long, value_name = "FILE", value_parser)]
+    output_info: Option<PathBuf>,
+
     /// Path to input raw image.
     ///
     /// Appended AVB images require a raw image.
     #[arg(long, value_name = "FILE", value_parser, default_value = "raw.img")]
     input_raw: PathBuf,
 
+    /// Recompute image size.
+    ///
+    /// By default, it is assumed that the image has a fixed size specified by
+    /// the image_size top-level field in the AVB info TOML. If flag is passed,
+    /// then that field is ignored and the smallest possible output image will
+    /// be created.
+    #[arg(long)]
+    recompute_size: bool,
+
     #[command(flatten)]
     key: KeyGroup,
 
@@ -777,7 +933,7 @@ enum AvbCommand {
     Verify(VerifyCli),
 }
 
-/// Show information about AVB-protected images.
+/// Pack, unpack, and inspect AVB-protected images.
 #[derive(Debug, Parser)]
 pub struct AvbCli {
     #[command(subcommand)]

avbroot/src/cli/boot.rs

@@ -13,7 +13,7 @@ use anyhow::{bail, Context, Result};
 use clap::{Parser, Subcommand};
 
 use crate::{
-    format::{avb::Header, bootimage::BootImage, compression::CompressedReader, cpio},
+    format::{avb::Header, bootimage::BootImage, compression::CompressedReader, cpio::CpioReader},
     stream::{FromReader, ToWriter},
 };
 
@@ -300,12 +300,16 @@ pub fn magisk_info_subcommand(cli: &MagiskInfoCli) -> Result<()> {
         let reader = Cursor::new(ramdisk);
         let reader = CompressedReader::new(reader, true)
             .with_context(|| format!("Failed to load ramdisk #{i}"))?;
-        let entries = cpio::load(reader, false)
-            .with_context(|| format!("Failed to load ramdisk #{i} cpio"))?;
+        let mut cpio_reader = CpioReader::new(reader, false);
 
-        if let Some(e) = entries.iter().find(|e| e.name == b".backup/.magisk") {
-            io::stdout().write_all(&e.content)?;
-            return Ok(());
+        while let Some(entry) = cpio_reader
+            .next_entry()
+            .with_context(|| format!("Failed to read ramdisk #{i} cpio entry"))?
+        {
+            if entry.path == b".backup/.magisk" {
+                io::copy(&mut cpio_reader, &mut io::stdout())?;
+                return Ok(());
+            }
         }
     }
 
@@ -330,7 +334,7 @@ struct UnpackCli {
     input: PathBuf,
 
     /// Path to output header TOML.
-    #[arg(long, value_name = "FILE", value_parser, default_value = "header.toml")]
+    #[arg(long, value_name = "FILE", value_parser, default_value = "boot.toml")]
     output_header: PathBuf,
 
     /// Path to output kernel image.
@@ -390,7 +394,7 @@ struct PackCli {
     output: PathBuf,
 
     /// Path to input header TOML.
-    #[arg(long, value_name = "FILE", value_parser, default_value = "header.toml")]
+    #[arg(long, value_name = "FILE", value_parser, default_value = "boot.toml")]
     input_header: PathBuf,
 
     /// Path to input kernel image.
@@ -479,7 +483,7 @@ enum BootCommand {
     MagiskInfo(MagiskInfoCli),
 }
 
-/// Pack or unpack boot images.
+/// Pack, unpack, and inspect boot images.
 #[derive(Debug, Parser)]
 pub struct BootCli {
     #[command(subcommand)]

avbroot/src/cli/cpio.rs

@@ -0,0 +1,385 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+use std::{
+    fs::{self, File},
+    io::{BufReader, BufWriter, Seek},
+    path::{Path, PathBuf},
+    str,
+    sync::atomic::AtomicBool,
+};
+
+use anyhow::{anyhow, Context, Result};
+use bstr::ByteSlice;
+use cap_std::{ambient_authority, fs::Dir};
+use clap::{Parser, Subcommand};
+use num_traits::ToPrimitive;
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    format::{
+        compression::{CompressedFormat, CompressedReader, CompressedWriter},
+        cpio::{self, CpioEntry, CpioEntryData, CpioEntryType, CpioReader, CpioWriter},
+    },
+    stream, util,
+};
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+struct CpioInfo {
+    format: CompressedFormat,
+    entries: Vec<CpioEntry>,
+}
+
+fn open_reader(
+    path: &Path,
+    include_trailer: bool,
+) -> Result<(
+    CpioReader<CompressedReader<BufReader<File>>>,
+    CompressedFormat,
+)> {
+    let file =
+        File::open(path).with_context(|| format!("Failed to open cpio for reading: {path:?}"))?;
+    let reader = CompressedReader::new(BufReader::new(file), true)
+        .with_context(|| format!("Failed to open decompressor: {path:?}"))?;
+    let format = reader.format();
+    let cpio_reader = CpioReader::new(reader, include_trailer);
+
+    Ok((cpio_reader, format))
+}
+
+fn open_writer(
+    path: &Path,
+    format: CompressedFormat,
+) -> Result<CpioWriter<CompressedWriter<BufWriter<File>>>> {
+    let file =
+        File::create(path).with_context(|| format!("Failed to open cpio for writing: {path:?}"))?;
+    let writer = CompressedWriter::new(BufWriter::new(file), format)
+        .with_context(|| format!("Failed to open compressor: {path:?}"))?;
+    let cpio_writer = CpioWriter::new(writer, false);
+
+    Ok(cpio_writer)
+}
+
+fn flush_writer(writer: CpioWriter<CompressedWriter<BufWriter<File>>>) -> Result<()> {
+    let compressed_writer = writer.finish().context("Failed to flush cpio writer")?;
+    let buf_writer = compressed_writer
+        .finish()
+        .context("Failed to flush compressor")?;
+    buf_writer.into_inner().context("Failed to flush file")?;
+
+    Ok(())
+}
+
+/// Read cpio information from TOML file.
+fn read_info(path: &Path) -> Result<CpioInfo> {
+    let data = fs::read_to_string(path)
+        .with_context(|| format!("Failed to read cpio info TOML: {path:?}"))?;
+    let info = toml_edit::de::from_str(&data)
+        .with_context(|| format!("Failed to parse cpio info TOML: {path:?}"))?;
+
+    Ok(info)
+}
+
+/// Write cpio information to TOML file.
+fn write_info(path: &Path, info: &CpioInfo) -> Result<()> {
+    let data = toml_edit::ser::to_string_pretty(info)
+        .with_context(|| format!("Failed to serialize cpio info TOML: {path:?}"))?;
+    fs::write(path, data).with_context(|| format!("Failed to write cpio info TOML: {path:?}"))?;
+
+    Ok(())
+}
+
+/// Open reader to the corresponding file inside the tree if the entry is a
+/// regular file. Unsafe paths will result in an error.
+fn open_tree_file(tree: &Dir, entry: &CpioEntry) -> Result<Option<(BufReader<File>, u32)>> {
+    if entry.file_type == CpioEntryType::Regular {
+        let path = entry
+            .path
+            .as_bstr()
+            .to_path()
+            .with_context(|| format!("Invalid entry path: {:?}", entry.path.as_bstr()))?;
+
+        let mut reader = tree
+            .open(path)
+            .map(|f| BufReader::new(f.into_std()))
+            .with_context(|| format!("Failed to open for reading: {path:?}"))?;
+
+        let file_size = reader
+            .seek(std::io::SeekFrom::End(0))
+            .with_context(|| format!("Failed to get file size: {path:?}"))?
+            .to_u32()
+            .ok_or_else(|| anyhow!("File is too large: {path:?}"))?;
+        reader
+            .rewind()
+            .with_context(|| format!("Failed to seek file: {path:?}"))?;
+
+        Ok(Some((reader, file_size)))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Open writer to the corresponding file inside the tree if the entry is a
+/// regular file. Intermediate directories are automatically created as needed.
+/// Unsafe paths will result in an error.
+fn create_tree_file(tree: &Dir, entry: &CpioEntry) -> Result<Option<BufWriter<File>>> {
+    if entry.file_type == CpioEntryType::Regular {
+        let path = entry
+            .path
+            .as_bstr()
+            .to_path()
+            .with_context(|| format!("Invalid entry path: {:?}", entry.path.as_bstr()))?;
+        let parent = util::parent_path(path);
+
+        tree.create_dir_all(parent)
+            .with_context(|| format!("Failed to create directory: {parent:?}"))?;
+
+        let writer = tree
+            .create(path)
+            .map(|f| BufWriter::new(f.into_std()))
+            .with_context(|| format!("Failed to open for writing: {path:?}"))?;
+
+        Ok(Some(writer))
+    } else {
+        Ok(None)
+    }
+}
+
+fn display_format(cli: &CpioCli, format: CompressedFormat) {
+    if !cli.quiet {
+        println!("Compression format: {format:?}");
+    }
+}
+
+fn display_entry(cli: &CpioCli, entry: &CpioEntry) {
+    if !cli.quiet {
+        println!();
+        println!("{entry}");
+    }
+}
+
+fn unpack_subcommand(
+    cpio_cli: &CpioCli,
+    cli: &UnpackCli,
+    cancel_signal: &AtomicBool,
+) -> Result<()> {
+    let (mut reader, format) = open_reader(&cli.input, false)?;
+    let mut info = CpioInfo {
+        format,
+        entries: vec![],
+    };
+
+    display_format(cpio_cli, format);
+
+    let authority = ambient_authority();
+    Dir::create_ambient_dir_all(&cli.output_tree, authority)
+        .with_context(|| format!("Failed to create directory: {:?}", cli.output_tree))?;
+    let tree = Dir::open_ambient_dir(&cli.output_tree, authority)
+        .with_context(|| format!("Failed to open directory: {:?}", cli.output_tree))?;
+
+    while let Some(entry) = reader.next_entry().context("Failed to read cpio entry")? {
+        display_entry(cpio_cli, &entry);
+
+        if let Some(mut writer) = create_tree_file(&tree, &entry)? {
+            let file_size = entry.data.size()?;
+
+            stream::copy_n(&mut reader, &mut writer, file_size.into(), cancel_signal)
+                .context("Failed to copy data")?;
+
+            writer.into_inner().context("Failed to flush data")?;
+        }
+
+        info.entries.push(entry);
+    }
+
+    write_info(&cli.output_info, &info)?;
+
+    Ok(())
+}
+
+fn pack_subcommand(cpio_cli: &CpioCli, cli: &PackCli, cancel_signal: &AtomicBool) -> Result<()> {
+    let mut info = read_info(&cli.input_info)?;
+    let mut writer = open_writer(&cli.output, info.format)?;
+
+    display_format(cpio_cli, info.format);
+
+    if cli.sort {
+        cpio::sort(&mut info.entries);
+    }
+
+    cpio::assign_inodes(&mut info.entries, true)?;
+
+    let authority = ambient_authority();
+    let tree = Dir::open_ambient_dir(&cli.input_tree, authority)
+        .with_context(|| format!("Failed to open directory: {:?}", cli.input_tree))?;
+
+    for entry in &mut info.entries {
+        let out = open_tree_file(&tree, entry)?;
+
+        if let Some((_, file_size)) = &out {
+            entry.data = CpioEntryData::Size(*file_size);
+        }
+
+        display_entry(cpio_cli, entry);
+
+        writer
+            .start_entry(entry)
+            .context("Failed to write cpio entry")?;
+
+        if let Some((mut reader, file_size)) = out {
+            stream::copy_n(&mut reader, &mut writer, file_size.into(), cancel_signal)
+                .context("Failed to copy data")?;
+        }
+    }
+
+    flush_writer(writer)?;
+
+    Ok(())
+}
+
+fn repack_subcommand(
+    cpio_cli: &CpioCli,
+    cli: &RepackCli,
+    cancel_signal: &AtomicBool,
+) -> Result<()> {
+    let (mut reader, format) = open_reader(&cli.input, false)?;
+    let mut writer = open_writer(&cli.output, format)?;
+
+    display_format(cpio_cli, format);
+
+    while let Some(entry) = reader.next_entry().context("Failed to read cpio entry")? {
+        display_entry(cpio_cli, &entry);
+
+        writer
+            .start_entry(&entry)
+            .context("Failed to write cpio entry")?;
+
+        if let CpioEntryData::Size(s) = &entry.data {
+            stream::copy_n(&mut reader, &mut writer, u64::from(*s), cancel_signal)
+                .context("Failed to copy cpio entry data")?;
+        }
+    }
+
+    flush_writer(writer)?;
+
+    Ok(())
+}
+
+fn info_subcommand(cpio_cli: &CpioCli, cli: &InfoCli) -> Result<()> {
+    let (mut reader, format) = open_reader(&cli.input, cli.trailer)?;
+
+    display_format(cpio_cli, format);
+
+    while let Some(entry) = reader.next_entry().context("Failed to read cpio entry")? {
+        display_entry(cpio_cli, &entry);
+    }
+
+    Ok(())
+}
+
+pub fn cpio_main(cli: &CpioCli, cancel_signal: &AtomicBool) -> Result<()> {
+    match &cli.command {
+        CpioCommand::Unpack(c) => unpack_subcommand(cli, c, cancel_signal),
+        CpioCommand::Pack(c) => pack_subcommand(cli, c, cancel_signal),
+        CpioCommand::Repack(c) => repack_subcommand(cli, c, cancel_signal),
+        CpioCommand::Info(c) => info_subcommand(cli, c),
+    }
+}
+
+/// Unpack a cpio archive.
+///
+/// Regular files will be extracted to the output tree directory, but not any
+/// other type of file (eg. symlinks). All file metadata is written to the info
+/// TOML file, like the UID/GID, permissions, and symlink targets.
+///
+/// If any paths inside the cpio archive are unsafe, the extraction process will
+/// fail and exit. Extracted files are never written outside of the tree
+/// directory, even if an external process tries to interfere.
+#[derive(Debug, Parser)]
+struct UnpackCli {
+    /// Path to input cpio file.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    input: PathBuf,
+
+    /// Path to output cpio info TOML.
+    #[arg(long, value_name = "FILE", value_parser, default_value = "cpio.toml")]
+    output_info: PathBuf,
+
+    /// Path to output files directory.
+    #[arg(long, value_name = "DIR", value_parser, default_value = "cpio_tree")]
+    output_tree: PathBuf,
+}
+
+/// Pack a cpio archive.
+///
+/// The new cpio archive will *only* contain files listed in the info TOML file.
+/// Extra files inside the input tree directory that aren't listed will be
+/// silently ignored. Entries are added to the archive in the order that they
+/// are listed unless --sort is specified.
+///
+/// All fields inside the info TOML are used as-is. Missing fields in entries
+/// are set to 0, aside from the inode number, which will be assigned a unique
+/// value.
+#[derive(Debug, Parser)]
+struct PackCli {
+    /// Path to output cpio file.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    output: PathBuf,
+
+    /// Path to input info TOML.
+    #[arg(long, value_name = "FILE", value_parser, default_value = "cpio.toml")]
+    input_info: PathBuf,
+
+    /// Path to input files directory.
+    #[arg(long, value_name = "DIR", value_parser, default_value = "cpio_tree")]
+    input_tree: PathBuf,
+
+    /// Sort entries before packing.
+    #[arg(long)]
+    sort: bool,
+}
+
+/// Repack a cpio archive.
+#[derive(Debug, Parser)]
+struct RepackCli {
+    /// Path to input cpio file.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    input: PathBuf,
+
+    /// Path to output cpio file.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    output: PathBuf,
+}
+
+/// Display cpio entry information.
+#[derive(Debug, Parser)]
+struct InfoCli {
+    /// Path to input cpio file.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    input: PathBuf,
+
+    /// Show cpio trailer entry.
+    #[arg(long, global = true)]
+    trailer: bool,
+}
+
+#[derive(Debug, Subcommand)]
+enum CpioCommand {
+    Unpack(UnpackCli),
+    Pack(PackCli),
+    Repack(RepackCli),
+    Info(InfoCli),
+}
+
+/// Pack, unpack, and inspect cpio archives.
+#[derive(Debug, Parser)]
+pub struct CpioCli {
+    #[command(subcommand)]
+    command: CpioCommand,
+
+    /// Don't print cpio entry information.
+    #[arg(short, long, global = true)]
+    quiet: bool,
+}

avbroot/src/cli/fec.rs

@@ -53,7 +53,7 @@ fn write_fec(path: &Path, fec: &FecImage) -> Result<()> {
 fn generate_subcommand(cli: &GenerateCli, cancel_signal: &AtomicBool) -> Result<()> {
     let input = open_input(&cli.input, false)?;
 
-    let fec = FecImage::generate(|| Ok(Box::new(input.reopen())), cli.parity, cancel_signal)
+    let fec = FecImage::generate(&input, cli.parity, cancel_signal)
         .context("Failed to generate FEC data")?;
 
     write_fec(&cli.fec, &fec)?;
@@ -61,11 +61,29 @@ fn generate_subcommand(cli: &GenerateCli, cancel_signal: &AtomicBool) -> Result<
     Ok(())
 }
 
+fn update_subcommand(cli: &UpdateCli, cancel_signal: &AtomicBool) -> Result<()> {
+    let ranges = cli
+        .range
+        .chunks_exact(2)
+        .map(|w| w[0]..w[1])
+        .collect::<Vec<_>>();
+
+    let input = open_input(&cli.input, false)?;
+    let mut fec = read_fec(&cli.fec)?;
+
+    fec.update(&input, &ranges, cancel_signal)
+        .context("Failed to update FEC data")?;
+
+    write_fec(&cli.fec, &fec)?;
+
+    Ok(())
+}
+
 fn verify_subcommand(cli: &VerifyCli, cancel_signal: &AtomicBool) -> Result<()> {
     let input = open_input(&cli.input, false)?;
     let fec = read_fec(&cli.fec)?;
 
-    fec.verify(|| Ok(Box::new(input.reopen())), cancel_signal)
+    fec.verify(&input, cancel_signal)
         .context("Failed to verify data")?;
 
     Ok(())
@@ -78,12 +96,8 @@ fn repair_subcommand(cli: &RepairCli, cancel_signal: &AtomicBool) -> Result<()>
     // The separate buffered readers and writers are safe because the function
     // guarantees that every thread touches disjoint offsets and every offset is
     // read and written at most once.
-    fec.repair(
-        || Ok(Box::new(input.reopen())),
-        || Ok(Box::new(input.reopen())),
-        cancel_signal,
-    )
-    .context("Failed to repair file")?;
+    fec.repair(&input, &input, cancel_signal)
+        .context("Failed to repair file")?;
 
     Ok(())
 }
@@ -91,6 +105,7 @@ fn repair_subcommand(cli: &RepairCli, cancel_signal: &AtomicBool) -> Result<()>
 pub fn fec_main(cli: &FecCli, cancel_signal: &AtomicBool) -> Result<()> {
     match &cli.command {
         FecCommand::Generate(c) => generate_subcommand(c, cancel_signal),
+        FecCommand::Update(c) => update_subcommand(c, cancel_signal),
         FecCommand::Verify(c) => verify_subcommand(c, cancel_signal),
         FecCommand::Repair(c) => repair_subcommand(c, cancel_signal),
     }
@@ -112,6 +127,26 @@ struct GenerateCli {
     parity: u8,
 }
 
+/// Update FEC data after a file is modified.
+#[derive(Debug, Parser)]
+struct UpdateCli {
+    /// Path to input data.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    input: PathBuf,
+
+    /// Path to FEC data.
+    ///
+    /// The file will be modified in place.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    fec: PathBuf,
+
+    /// Input file ranges that were updated.
+    ///
+    /// This is a half-open range and can be specified multiple times.
+    #[arg(short, long, value_names = ["START", "END"], num_args = 2)]
+    range: Vec<u64>,
+}
+
 /// Verify that a file contains no errors.
 #[derive(Debug, Parser)]
 struct VerifyCli {
@@ -141,6 +176,7 @@ struct RepairCli {
 #[derive(Debug, Subcommand)]
 enum FecCommand {
     Generate(GenerateCli),
+    Update(UpdateCli),
     Verify(VerifyCli),
     Repair(RepairCli),
 }

avbroot/src/cli/hashtree.rs

@@ -0,0 +1,176 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+use std::{
+    fs::{File, OpenOptions},
+    io::{BufReader, BufWriter, Write},
+    path::{Path, PathBuf},
+    sync::atomic::AtomicBool,
+};
+
+use anyhow::{Context, Result};
+use clap::{Parser, Subcommand};
+
+use crate::{
+    format::hashtree::HashTreeImage,
+    stream::{FromReader, PSeekFile, ToWriter},
+};
+
+fn open_input(path: &Path, rw: bool) -> Result<PSeekFile> {
+    OpenOptions::new()
+        .read(true)
+        .write(rw)
+        .open(path)
+        .map(PSeekFile::new)
+        .with_context(|| format!("Failed to open file: {path:?}"))
+}
+
+fn read_hash_tree(path: &Path) -> Result<HashTreeImage> {
+    let reader = File::open(path)
+        .map(BufReader::new)
+        .with_context(|| format!("Failed to open for reading: {path:?}"))?;
+    let hash_tree = HashTreeImage::from_reader(reader)
+        .with_context(|| format!("Failed to read hash tree data: {path:?}"))?;
+
+    Ok(hash_tree)
+}
+
+fn write_hash_tree(path: &Path, hash_tree: &HashTreeImage) -> Result<()> {
+    let mut writer = File::create(path)
+        .map(BufWriter::new)
+        .with_context(|| format!("Failed to open for writing: {path:?}"))?;
+    hash_tree
+        .to_writer(&mut writer)
+        .with_context(|| format!("Failed to write hash tree data: {path:?}"))?;
+    writer
+        .flush()
+        .with_context(|| format!("Failed to flush hash tree data: {path:?}"))?;
+
+    Ok(())
+}
+
+fn generate_subcommand(cli: &GenerateCli, cancel_signal: &AtomicBool) -> Result<()> {
+    let salt = hex::decode(&cli.salt).context("Invalid salt")?;
+    let input = open_input(&cli.input, false)?;
+
+    let hash_tree =
+        HashTreeImage::generate(&input, cli.block_size, &cli.algorithm, &salt, cancel_signal)
+            .context("Failed to generate hash tree data")?;
+
+    write_hash_tree(&cli.hash_tree, &hash_tree)?;
+
+    Ok(())
+}
+
+fn update_subcommand(cli: &UpdateCli, cancel_signal: &AtomicBool) -> Result<()> {
+    let ranges = cli
+        .range
+        .chunks_exact(2)
+        .map(|w| w[0]..w[1])
+        .collect::<Vec<_>>();
+
+    let input = open_input(&cli.input, false)?;
+    let mut hash_tree = read_hash_tree(&cli.hash_tree)?;
+
+    hash_tree
+        .update(&input, &ranges, cancel_signal)
+        .context("Failed to update hash tree data")?;
+
+    write_hash_tree(&cli.hash_tree, &hash_tree)?;
+
+    Ok(())
+}
+
+fn verify_subcommand(cli: &VerifyCli, cancel_signal: &AtomicBool) -> Result<()> {
+    let input = open_input(&cli.input, false)?;
+    let hash_tree = read_hash_tree(&cli.hash_tree)?;
+
+    hash_tree
+        .verify(&input, cancel_signal)
+        .context("Failed to verify data")?;
+
+    Ok(())
+}
+
+pub fn hash_tree_main(cli: &HashTreeCli, cancel_signal: &AtomicBool) -> Result<()> {
+    match &cli.command {
+        HashTreeCommand::Generate(c) => generate_subcommand(c, cancel_signal),
+        HashTreeCommand::Update(c) => update_subcommand(c, cancel_signal),
+        HashTreeCommand::Verify(c) => verify_subcommand(c, cancel_signal),
+    }
+}
+
+/// Generate hash tree data for a file.
+#[derive(Debug, Parser)]
+struct GenerateCli {
+    /// Path to input data.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    input: PathBuf,
+
+    /// Path to output hash tree data.
+    #[arg(short = 'H', long, value_name = "FILE", value_parser)]
+    hash_tree: PathBuf,
+
+    /// Block size.
+    #[arg(short, long, value_name = "BYTES", default_value = "4096")]
+    block_size: u32,
+
+    /// Hash algorithm.
+    #[arg(short, long, value_name = "NAME", default_value = "sha256")]
+    algorithm: String,
+
+    /// Salt (in hex).
+    #[arg(short, long, value_name = "HEX", default_value = "")]
+    salt: String,
+}
+
+/// Update hash tree data after a file is modified.
+#[derive(Debug, Parser)]
+struct UpdateCli {
+    /// Path to input data.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    input: PathBuf,
+
+    /// Path to hash tree data.
+    ///
+    /// The file will be modified in place.
+    #[arg(short = 'H', long, value_name = "FILE", value_parser)]
+    hash_tree: PathBuf,
+
+    /// Input file ranges that were updated.
+    ///
+    /// This is a half-open range and can be specified multiple times.
+    #[arg(short, long, value_names = ["START", "END"], num_args = 2)]
+    range: Vec<u64>,
+}
+
+/// Verify that a file contains no errors.
+#[derive(Debug, Parser)]
+struct VerifyCli {
+    /// Path to input data.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    input: PathBuf,
+
+    /// Path to input hash tree data.
+    #[arg(short = 'H', long, value_name = "FILE", value_parser)]
+    hash_tree: PathBuf,
+}
+
+#[derive(Debug, Subcommand)]
+enum HashTreeCommand {
+    Generate(GenerateCli),
+    Update(UpdateCli),
+    Verify(VerifyCli),
+}
+
+/// Generate dm-verity hash tree data and verify files.
+///
+/// These commands operate on a standard hash tree data prepended by a custom
+/// header.
+#[derive(Debug, Parser)]
+pub struct HashTreeCli {
+    #[command(subcommand)]
+    command: HashTreeCommand,
+}

avbroot/src/cli/key.rs

@@ -18,29 +18,27 @@ use crate::{
     format::avb,
 };
 
-fn get_passphrase(group: &PassphraseGroup, key_path: &Path) -> PassphraseSource {
-    if let Some(v) = &group.pass_env_var {
-        PassphraseSource::EnvVar(v.clone())
-    } else if let Some(p) = &group.pass_file {
-        PassphraseSource::File(p.clone())
-    } else {
-        PassphraseSource::Prompt(format!("Enter passphrase for {key_path:?}: "))
-    }
+fn get_passphrase_source(group: &PassphraseGroup, key_path: &Path) -> PassphraseSource {
+    PassphraseSource::new(
+        key_path,
+        group.pass_file.as_deref(),
+        group.pass_env_var.as_deref(),
+    )
 }
 
 pub fn key_main(cli: &KeyCli) -> Result<()> {
     match &cli.command {
         KeyCommand::GenerateKey(c) => {
-            let passphrase = get_passphrase(&c.passphrase, &c.output);
+            let source = get_passphrase_source(&c.passphrase, &c.output);
             let private_key =
                 crypto::generate_rsa_key_pair().context("Failed to generate RSA keypair")?;
 
-            crypto::write_pem_key_file(&c.output, &private_key, &passphrase)
+            crypto::write_pem_key_file(&c.output, &private_key, &source)
                 .with_context(|| format!("Failed to write private key: {:?}", c.output))?;
         }
         KeyCommand::GenerateCert(c) => {
-            let passphrase = get_passphrase(&c.passphrase, &c.key);
-            let private_key = crypto::read_pem_key_file(&c.key, &passphrase)
+            let source = get_passphrase_source(&c.passphrase, &c.key);
+            let private_key = crypto::read_pem_key_file(&c.key, &source)
                 .with_context(|| format!("Failed to load key: {:?}", c.key))?;
 
             let validity = Duration::from_secs(c.validity * 24 * 60 * 60);
@@ -52,7 +50,7 @@ pub fn key_main(cli: &KeyCli) -> Result<()> {
         }
         KeyCommand::ExtractAvb(c) => {
             let public_key = if let Some(p) = &c.input.key {
-                let passphrase = get_passphrase(&c.passphrase, p);
+                let passphrase = get_passphrase_source(&c.passphrase, p);
                 let private_key = crypto::read_pem_key_file(p, &passphrase)
                     .with_context(|| format!("Failed to load key: {p:?}"))?;
 
@@ -73,6 +71,16 @@ pub fn key_main(cli: &KeyCli) -> Result<()> {
             fs::write(&c.output, encoded)
                 .with_context(|| format!("Failed to write public key: {:?}", c.output))?;
         }
+        KeyCommand::DecodeAvb(c) => {
+            let encoded = fs::read(&c.key)
+                .with_context(|| format!("Failed to load AVB public key: {:?}", c.key))?;
+
+            let public_key = avb::decode_public_key(&encoded)
+                .context("Failed to decode public key as AVB format")?;
+
+            crypto::write_pem_public_key_file(&c.output, &public_key)
+                .with_context(|| format!("Failed to write public key: {:?}", c.output))?;
+        }
     }
 
     Ok(())
@@ -154,11 +162,24 @@ struct ExtractAvbCli {
     passphrase: PassphraseGroup,
 }
 
+/// Convert an AVB-encoded public key to a PKCS8-encoded public key.
+#[derive(Debug, Parser)]
+struct DecodeAvbCli {
+    /// Path to output PKCS8-encoded public key.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    output: PathBuf,
+
+    /// Path to AVB-encoded public key.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    key: PathBuf,
+}
+
 #[derive(Debug, Subcommand)]
 enum KeyCommand {
     GenerateKey(GenerateKeyCli),
     GenerateCert(GenerateCertCli),
     ExtractAvb(ExtractAvbCli),
+    DecodeAvb(DecodeAvbCli),
 }
 
 /// Generate and convert keys.

avbroot/src/cli/mod.rs

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
  * SPDX-License-Identifier: GPL-3.0-only
  */
 
@@ -7,22 +7,9 @@ pub mod args;
 pub mod avb;
 pub mod boot;
 pub mod completion;
+pub mod cpio;
 pub mod fec;
+pub mod hashtree;
 pub mod key;
 pub mod ota;
-pub mod ramdisk;
-
-macro_rules! status {
-    ($($arg:tt)*) => {
-        eprintln!("\x1b[1m[*] {}\x1b[0m", format!($($arg)*))
-    }
-}
-
-macro_rules! warning {
-    ($($arg:tt)*) => {
-        eprintln!("\x1b[1;31m[WARNING] {}\x1b[0m", format!($($arg)*))
-    }
-}
-
-pub(crate) use status;
-pub(crate) use warning;
+pub mod payload;

avbroot/src/cli/payload.rs

@@ -0,0 +1,49 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Andrew Gunnerson
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+use std::{fs::File, io::BufReader, path::PathBuf};
+
+use anyhow::{Context, Result};
+use clap::{Parser, Subcommand};
+
+use crate::{format::payload::PayloadHeader, stream::FromReader};
+
+fn info_subcommand(cli: &InfoCli) -> Result<()> {
+    let mut reader = File::open(&cli.input)
+        .map(BufReader::new)
+        .with_context(|| format!("Failed to open payload: {:?}", cli.input))?;
+    let header = PayloadHeader::from_reader(&mut reader)
+        .with_context(|| format!("Failed to read payload: {:?}", cli.input))?;
+
+    println!("{header:#?}");
+
+    Ok(())
+}
+
+pub fn payload_main(cli: &PayloadCli) -> Result<()> {
+    match &cli.command {
+        PayloadCommand::Info(c) => info_subcommand(c),
+    }
+}
+
+/// Display payload information.
+#[derive(Debug, Parser)]
+struct InfoCli {
+    /// Path to input payload file.
+    #[arg(short, long, value_name = "FILE", value_parser)]
+    input: PathBuf,
+}
+
+#[derive(Debug, Subcommand)]
+enum PayloadCommand {
+    Info(InfoCli),
+}
+
+/// Inspect OTA payloads.
+#[derive(Debug, Parser)]
+pub struct PayloadCli {
+    #[command(subcommand)]
+    command: PayloadCommand,
+}

avbroot/src/cli/ramdisk.rs

@@ -1,150 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
- * SPDX-License-Identifier: GPL-3.0-only
- */
-
-use std::{
-    fs::File,
-    path::{Path, PathBuf},
-    str,
-};
-
-use anyhow::{Context, Result};
-use clap::{Parser, Subcommand};
-
-use crate::format::{
-    compression::{CompressedFormat, CompressedReader, CompressedWriter},
-    cpio::{self, CpioEntryNew},
-};
-
-static CONTENT_BEGIN: &str = "----- BEGIN UTF-8 CONTENT -----";
-static CONTENT_END: &str = "----- END UTF-8 CONTENT -----";
-static CONTENT_END_NO_NEWLINE: &str = "----- END UTF-8 CONTENT (NO NEWLINE) -----";
-
-static BINARY_BEGIN: &str = "----- BEGIN BINARY CONTENT -----";
-static BINARY_END: &str = "----- END BINARY CONTENT -----";
-static BINARY_END_TRUNCATED: &str = "----- END BINARY CONTENT (TRUNCATED) -----";
-
-static NO_DATA: &str = "----- NO DATA -----";
-
-fn print_content(data: &[u8], truncate: bool) {
-    if data.is_empty() {
-        println!("{NO_DATA}");
-        return;
-    }
-
-    if !data.contains(&b'\0') {
-        if let Ok(s) = str::from_utf8(data) {
-            if !s.contains(CONTENT_BEGIN)
-                && !s.contains(CONTENT_END)
-                && !s.contains(CONTENT_END_NO_NEWLINE)
-            {
-                println!("{CONTENT_BEGIN}");
-                print!("{s}");
-                if data.last() == Some(&b'\n') {
-                    println!("{CONTENT_END}");
-                } else {
-                    println!();
-                    println!("{CONTENT_END_NO_NEWLINE}");
-                }
-
-                return;
-            }
-        }
-    }
-
-    println!("{BINARY_BEGIN}");
-
-    if data.len() > 512 && truncate {
-        println!("{}", data[..512].escape_ascii());
-        println!("{BINARY_END_TRUNCATED}");
-    } else {
-        println!("{}", data.escape_ascii());
-        println!("{BINARY_END}");
-    }
-}
-
-fn load_archive(
-    path: &Path,
-    include_trailer: bool,
-) -> Result<(Vec<CpioEntryNew>, CompressedFormat)> {
-    let file = File::open(path)?;
-    let reader = CompressedReader::new(file, true)?;
-    let format = reader.format();
-    let entries = cpio::load(reader, include_trailer)?;
-
-    Ok((entries, format))
-}
-
-fn save_archive(path: &Path, entries: &[CpioEntryNew], format: CompressedFormat) -> Result<()> {
-    let file = File::create(path)?;
-    let mut writer = CompressedWriter::new(file, format)?;
-    cpio::save(&mut writer, entries, false)?;
-    writer.finish()?;
-
-    Ok(())
-}
-
-pub fn ramdisk_main(cli: &RamdiskCli) -> Result<()> {
-    match &cli.command {
-        RamdiskCommand::Dump(c) => {
-            let (entries, format) = load_archive(&c.input, true)
-                .with_context(|| format!("Failed to read cpio: {:?}", c.input))?;
-
-            println!("Compression format: {format:?}");
-            println!();
-
-            for entry in entries {
-                println!("{entry}");
-                print_content(&entry.content, !c.no_truncate);
-                println!();
-            }
-        }
-        RamdiskCommand::Repack(c) => {
-            let (entries, format) = load_archive(&c.input, false)
-                .with_context(|| format!("Failed to read cpio: {:?}", c.input))?;
-
-            save_archive(&c.output, &entries, format)
-                .with_context(|| format!("Failed to write cpio: {:?}", c.output))?;
-        }
-    }
-
-    Ok(())
-}
-
-/// Dump cpio headers and data.
-#[derive(Debug, Parser)]
-struct DumpCli {
-    /// Path to input cpio file.
-    #[arg(short, long, value_name = "FILE", value_parser)]
-    input: PathBuf,
-
-    /// Do not truncate binary file contents.
-    #[arg(long)]
-    no_truncate: bool,
-}
-
-/// Repack cpio archive.
-#[derive(Debug, Parser)]
-struct RepackCli {
-    /// Path to input cpio file.
-    #[arg(short, long, value_name = "FILE", value_parser)]
-    input: PathBuf,
-
-    /// Path to output cpio file.
-    #[arg(short, long, value_name = "FILE", value_parser)]
-    output: PathBuf,
-}
-
-#[derive(Debug, Subcommand)]
-enum RamdiskCommand {
-    Dump(DumpCli),
-    Repack(RepackCli),
-}
-
-/// Show information about ramdisk cpio archives.
-#[derive(Debug, Parser)]
-pub struct RamdiskCli {
-    #[command(subcommand)]
-    command: RamdiskCommand,
-}

avbroot/src/crypto.rs

@@ -5,7 +5,7 @@
 
 use std::{
     env::{self, VarError},
-    ffi::OsString,
+    ffi::{OsStr, OsString},
     fs::{self, File, OpenOptions},
     io::{self, BufReader, BufWriter, Read, Write},
     path::{Path, PathBuf},
@@ -75,6 +75,16 @@ pub enum PassphraseSource {
 }
 
 impl PassphraseSource {
+    pub fn new(key_file: &Path, pass_file: Option<&Path>, env_var: Option<&OsStr>) -> Self {
+        if let Some(v) = env_var {
+            Self::EnvVar(v.to_owned())
+        } else if let Some(p) = pass_file {
+            Self::File(p.to_owned())
+        } else {
+            Self::Prompt(format!("Enter passphrase for {key_file:?}: "))
+        }
+    }
+
     pub fn acquire(&self, confirm: bool) -> Result<String> {
         let passphrase = match self {
             Self::Prompt(p) => {
@@ -154,6 +164,9 @@ fn reformat_pem(data: &[u8]) -> Result<Vec<u8>> {
             continue;
         } else if line.starts_with(b"-----BEGIN CERTIFICATE-----") {
             inside_base64 = true;
+
+            result.extend_from_slice(line);
+            result.push(b'\n');
         } else if line.starts_with(b"-----END CERTIFICATE-----") {
             inside_base64 = false;
 
@@ -163,13 +176,13 @@ fn reformat_pem(data: &[u8]) -> Result<Vec<u8>> {
             }
 
             base64.clear();
+
+            result.extend_from_slice(line);
+            result.push(b'\n');
         } else if inside_base64 {
             base64.extend_from_slice(line);
             continue;
         }
-
-        result.extend_from_slice(line);
-        result.push(b'\n');
     }
 
     if inside_base64 {
@@ -215,6 +228,23 @@ pub fn write_pem_cert_file(path: &Path, cert: &Certificate) -> Result<()> {
     write_pem_cert(writer, cert)
 }
 
+/// Write PEM-encoded PKCS8 public key to a writer.
+pub fn write_pem_public_key(mut writer: impl Write, key: &RsaPublicKey) -> Result<()> {
+    let data = key.to_public_key_pem(LineEnding::LF)?;
+
+    writer.write_all(data.as_bytes())?;
+
+    Ok(())
+}
+
+/// Write PEM-encoded PKCS8 public key to a file.
+pub fn write_pem_public_key_file(path: &Path, key: &RsaPublicKey) -> Result<()> {
+    let file = File::create(path)?;
+    let writer = BufWriter::new(file);
+
+    write_pem_public_key(writer, key)
+}
+
 /// Read PEM-encoded PKCS8 private key from a reader.
 pub fn read_pem_key(mut reader: impl Read, source: &PassphraseSource) -> Result<RsaPrivateKey> {
     let mut data = String::new();

avbroot/src/format/bootimage.rs

@@ -57,6 +57,15 @@ const VENDOR_HDR_V3_SIZE: u32 = 2112;
 const VENDOR_HDR_V4_EXTRA_SIZE: u32 = 16;
 const VENDOR_RAMDISK_TABLE_ENTRY_V4_SIZE: u32 = 108;
 
+/// Maximum size of any individual boot image component, like the kernel. This
+/// limit is currently 64 MiB, which should be sufficient since there is no
+/// known device where the entire boot image exceeds this size.
+const COMPONENT_MAX_SIZE: u32 = 64 * 1024 * 1024;
+/// Maximum size of the bootconfig component in vendor v4 images. This limit is
+/// currently 1 KiB, which is ~25x the size of the Pixel 7 Pro stock image's
+/// bootconfig.
+const BOOTCONFIG_MAX_SIZE: u32 = 1024;
+
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("Unknown boot image format")]
@@ -71,8 +80,8 @@ pub enum Error {
     WriteFieldError(&'static str, #[source] io::Error),
     #[error("{0:?} field: invalid value: {1}")]
     InvalidFieldValue(&'static str, u32),
-    #[error("{0:?} field exceeds integer bounds")]
-    IntegerTooLarge(&'static str),
+    #[error("{0:?} field is out of bounds")]
+    FieldOutOfBounds(&'static str),
     #[error("Invalid data: {0}")]
     InvalidData(&'static str),
     #[error("VTS signature is missing hash descriptor")]
@@ -257,6 +266,16 @@ impl<R: Read> FromReader<R> for BootImageV0Through2 {
             return Err(Error::UnknownHeaderVersion(header_version));
         }
 
+        if kernel_size > COMPONENT_MAX_SIZE {
+            return Err(Error::FieldOutOfBounds("kernel_size"));
+        } else if ramdisk_size > COMPONENT_MAX_SIZE {
+            return Err(Error::FieldOutOfBounds("ramdisk_size"));
+        } else if second_size > COMPONENT_MAX_SIZE {
+            return Err(Error::FieldOutOfBounds("second_size"));
+        } else if page_size == 0 {
+            return Err(Error::InvalidFieldValue("page_size", 0));
+        }
+
         let os_version = reader.read_u32::<LittleEndian>()?;
 
         let name = reader
@@ -281,6 +300,10 @@ impl<R: Read> FromReader<R> for BootImageV0Through2 {
 
         let mut v1_data = if header_version >= 1 {
             let recovery_dtbo_size = reader.read_u32::<LittleEndian>()?;
+            if recovery_dtbo_size > COMPONENT_MAX_SIZE {
+                return Err(Error::FieldOutOfBounds("recovery_dtbo_size"));
+            }
+
             let recovery_dtbo_offset = reader.read_u64::<LittleEndian>()?;
             let header_size = reader.read_u32::<LittleEndian>()?;
 
@@ -305,6 +328,10 @@ impl<R: Read> FromReader<R> for BootImageV0Through2 {
 
         let mut v2_data = if header_version == 2 {
             let dtb_size = reader.read_u32::<LittleEndian>()?;
+            if dtb_size > COMPONENT_MAX_SIZE {
+                return Err(Error::FieldOutOfBounds("dtb_size"));
+            }
+
             let dtb_addr = reader.read_u64::<LittleEndian>()?;
 
             let v2_extra = V2Extra {
@@ -329,29 +356,39 @@ impl<R: Read> FromReader<R> for BootImageV0Through2 {
         let mut ramdisk = vec![];
         let mut second = vec![];
 
-        kernel.resize(kernel_size.to_usize().unwrap(), 0);
-        reader.read_exact(&mut kernel)?;
+        kernel.resize(kernel_size as usize, 0);
+        reader
+            .read_exact(&mut kernel)
+            .map_err(|e| Error::ReadFieldError("kernel", e))?;
         padding::read_discard(&mut reader, page_size.into())?;
 
-        ramdisk.resize(ramdisk_size.to_usize().unwrap(), 0);
-        reader.read_exact(&mut ramdisk)?;
+        ramdisk.resize(ramdisk_size as usize, 0);
+        reader
+            .read_exact(&mut ramdisk)
+            .map_err(|e| Error::ReadFieldError("ramdisk", e))?;
         padding::read_discard(&mut reader, page_size.into())?;
 
-        second.resize(second_size.to_usize().unwrap(), 0);
-        reader.read_exact(&mut second)?;
+        second.resize(second_size as usize, 0);
+        reader
+            .read_exact(&mut second)
+            .map_err(|e| Error::ReadFieldError("second", e))?;
         padding::read_discard(&mut reader, page_size.into())?;
 
         if let Some(v1) = &mut v1_data {
             v1.v1_extra
                 .recovery_dtbo
-                .resize(v1.recovery_dtbo_size.to_usize().unwrap(), 0);
-            reader.read_exact(&mut v1.v1_extra.recovery_dtbo)?;
+                .resize(v1.recovery_dtbo_size as usize, 0);
+            reader
+                .read_exact(&mut v1.v1_extra.recovery_dtbo)
+                .map_err(|e| Error::ReadFieldError("recovery_dtbo", e))?;
             padding::read_discard(&mut reader, page_size.into())?;
         }
 
         if let Some(v2) = &mut v2_data {
-            v2.v2_extra.dtb.resize(v2.dtb_size.to_usize().unwrap(), 0);
-            reader.read_exact(&mut v2.v2_extra.dtb)?;
+            v2.v2_extra.dtb.resize(v2.dtb_size as usize, 0);
+            reader
+                .read_exact(&mut v2.v2_extra.dtb)
+                .map_err(|e| Error::ReadFieldError("dtb", e))?;
             padding::read_discard(&mut reader, page_size.into())?;
         }
 
@@ -381,30 +418,35 @@ impl<W: Write> ToWriter<W> for BootImageV0Through2 {
     type Error = Error;
 
     fn to_writer(&self, writer: W) -> Result<()> {
+        if self.kernel.len() > COMPONENT_MAX_SIZE as usize {
+            return Err(Error::FieldOutOfBounds("kernel_size"));
+        } else if self.ramdisk.len() > COMPONENT_MAX_SIZE as usize {
+            return Err(Error::FieldOutOfBounds("ramdisk_size"));
+        } else if self.second.len() > COMPONENT_MAX_SIZE as usize {
+            return Err(Error::FieldOutOfBounds("second_size"));
+        } else if self.page_size == 0 {
+            return Err(Error::InvalidFieldValue("page_size", 0));
+        }
+
+        if let Some(v1) = &self.v1_extra {
+            if v1.recovery_dtbo.len() > COMPONENT_MAX_SIZE as usize {
+                return Err(Error::FieldOutOfBounds("recovery_dtbo_size"));
+            }
+        }
+        if let Some(v2) = &self.v2_extra {
+            if v2.dtb.len() > COMPONENT_MAX_SIZE as usize {
+                return Err(Error::FieldOutOfBounds("dtb_size"));
+            }
+        }
+
         let mut writer = CountingWriter::new(writer);
 
-        let kernel_size = self
-            .kernel
-            .len()
-            .to_u32()
-            .ok_or_else(|| Error::IntegerTooLarge("kernel_size"))?;
-        let ramdisk_size = self
-            .ramdisk
-            .len()
-            .to_u32()
-            .ok_or_else(|| Error::IntegerTooLarge("ramdisk_size"))?;
-        let second_size = self
-            .second
-            .len()
-            .to_u32()
-            .ok_or_else(|| Error::IntegerTooLarge("second_size"))?;
-
         writer.write_all(&BOOT_MAGIC)?;
-        writer.write_u32::<LittleEndian>(kernel_size)?;
+        writer.write_u32::<LittleEndian>(self.kernel.len() as u32)?;
         writer.write_u32::<LittleEndian>(self.kernel_addr)?;
-        writer.write_u32::<LittleEndian>(ramdisk_size)?;
+        writer.write_u32::<LittleEndian>(self.ramdisk.len() as u32)?;
         writer.write_u32::<LittleEndian>(self.ramdisk_addr)?;
-        writer.write_u32::<LittleEndian>(second_size)?;
+        writer.write_u32::<LittleEndian>(self.second.len() as u32)?;
         writer.write_u32::<LittleEndian>(self.second_addr)?;
         writer.write_u32::<LittleEndian>(self.tags_addr)?;
         writer.write_u32::<LittleEndian>(self.page_size)?;
@@ -427,46 +469,44 @@ impl<W: Write> ToWriter<W> for BootImageV0Through2 {
             .map_err(|e| Error::WriteFieldError("extra_cmdline", e))?;
 
         if let Some(v1) = &self.v1_extra {
-            let recovery_dtbo_size = v1
-                .recovery_dtbo
-                .len()
-                .to_u32()
-                .ok_or_else(|| Error::IntegerTooLarge("recovery_dtbo_size"))?;
-
-            writer.write_u32::<LittleEndian>(recovery_dtbo_size)?;
+            writer.write_u32::<LittleEndian>(v1.recovery_dtbo.len() as u32)?;
             writer.write_u64::<LittleEndian>(v1.recovery_dtbo_offset)?;
             writer.write_u32::<LittleEndian>(self.header_size())?;
         }
 
         if let Some(v2) = &self.v2_extra {
-            let dtb_size = v2
-                .dtb
-                .len()
-                .to_u32()
-                .ok_or_else(|| Error::IntegerTooLarge("dtb_size"))?;
-
-            writer.write_u32::<LittleEndian>(dtb_size)?;
+            writer.write_u32::<LittleEndian>(v2.dtb.len() as u32)?;
             writer.write_u64::<LittleEndian>(v2.dtb_addr)?;
         }
 
         padding::write_zeros(&mut writer, self.page_size.into())?;
 
-        writer.write_all(&self.kernel)?;
+        writer
+            .write_all(&self.kernel)
+            .map_err(|e| Error::WriteFieldError("kernel", e))?;
         padding::write_zeros(&mut writer, self.page_size.into())?;
 
-        writer.write_all(&self.ramdisk)?;
+        writer
+            .write_all(&self.ramdisk)
+            .map_err(|e| Error::WriteFieldError("ramdisk", e))?;
         padding::write_zeros(&mut writer, self.page_size.into())?;
 
-        writer.write_all(&self.second)?;
+        writer
+            .write_all(&self.second)
+            .map_err(|e| Error::WriteFieldError("second", e))?;
         padding::write_zeros(&mut writer, self.page_size.into())?;
 
         if let Some(v1) = &self.v1_extra {
-            writer.write_all(&v1.recovery_dtbo)?;
+            writer
+                .write_all(&v1.recovery_dtbo)
+                .map_err(|e| Error::WriteFieldError("recovery_dtbo", e))?;
             padding::write_zeros(&mut writer, self.page_size.into())?;
         }
 
         if let Some(v2) = &self.v2_extra {
-            writer.write_all(&v2.dtb)?;
+            writer
+                .write_all(&v2.dtb)
+                .map_err(|e| Error::WriteFieldError("dtb", e))?;
             padding::write_zeros(&mut writer, self.page_size.into())?;
         }
 
@@ -572,12 +612,23 @@ impl<R: Read> FromReader<R> for BootImageV3Through4 {
             return Err(Error::UnknownHeaderVersion(header_version));
         }
 
+        if kernel_size > COMPONENT_MAX_SIZE {
+            return Err(Error::FieldOutOfBounds("kernel_size"));
+        } else if ramdisk_size > COMPONENT_MAX_SIZE {
+            return Err(Error::FieldOutOfBounds("ramdisk_size"));
+        }
+
         let cmdline = reader
             .read_string_padded(BOOT_ARGS_SIZE + BOOT_EXTRA_ARGS_SIZE)
             .map_err(|e| Error::ReadFieldError("cmdline", e))?;
 
         let signature_size = if header_version == 4 {
-            Some(reader.read_u32::<LittleEndian>()?)
+            let signature_size = reader.read_u32::<LittleEndian>()?;
+            if signature_size > HDR_V4_SIGNATURE_SIZE as u32 {
+                return Err(Error::FieldOutOfBounds("signature_size"));
+            }
+
+            Some(signature_size)
         } else {
             None
         };
@@ -591,20 +642,26 @@ impl<R: Read> FromReader<R> for BootImageV3Through4 {
         let mut kernel = vec![];
         let mut ramdisk = vec![];
 
-        kernel.resize(kernel_size.to_usize().unwrap(), 0);
-        reader.read_exact(&mut kernel)?;
+        kernel.resize(kernel_size as usize, 0);
+        reader
+            .read_exact(&mut kernel)
+            .map_err(|e| Error::ReadFieldError("kernel", e))?;
         padding::read_discard(&mut reader, PAGE_SIZE.into())?;
 
-        ramdisk.resize(ramdisk_size.to_usize().unwrap(), 0);
-        reader.read_exact(&mut ramdisk)?;
+        ramdisk.resize(ramdisk_size as usize, 0);
+        reader
+            .read_exact(&mut ramdisk)
+            .map_err(|e| Error::ReadFieldError("ramdisk", e))?;
         padding::read_discard(&mut reader, PAGE_SIZE.into())?;
 
         // Don't preserve the signature. It is only used for VTS tests and is
         // not relevant for booting.
         let v4_extra = if let Some(s) = signature_size {
             // OnePlus images have an invalid signature consisting of all zeros.
-            let mut data = vec![0u8; s.to_usize().unwrap()];
-            reader.read_exact(&mut data)?;
+            let mut data = vec![0u8; s as usize];
+            reader
+                .read_exact(&mut data)
+                .map_err(|e| Error::ReadFieldError("signature", e))?;
 
             let signature = if s > 0 && !util::is_zero(&data) {
                 Some(Header::from_reader(Cursor::new(data))?)
@@ -634,22 +691,17 @@ impl<R: Read> FromReader<R> for BootImageV3Through4 {
 
 impl BootImageV3Through4 {
     fn to_writer_internal(&self, writer: impl Write, skip_v4_sig: bool) -> Result<()> {
+        if self.kernel.len() > COMPONENT_MAX_SIZE as usize {
+            return Err(Error::FieldOutOfBounds("kernel_size"));
+        } else if self.ramdisk.len() > COMPONENT_MAX_SIZE as usize {
+            return Err(Error::FieldOutOfBounds("ramdisk_size"));
+        }
+
         let mut writer = CountingWriter::new(writer);
 
-        let kernel_size = self
-            .kernel
-            .len()
-            .to_u32()
-            .ok_or_else(|| Error::IntegerTooLarge("kernel_size"))?;
-        let ramdisk_size = self
-            .ramdisk
-            .len()
-            .to_u32()
-            .ok_or_else(|| Error::IntegerTooLarge("ramdisk_size"))?;
-
         writer.write_all(&BOOT_MAGIC)?;
-        writer.write_u32::<LittleEndian>(kernel_size)?;
-        writer.write_u32::<LittleEndian>(ramdisk_size)?;
+        writer.write_u32::<LittleEndian>(self.kernel.len() as u32)?;
+        writer.write_u32::<LittleEndian>(self.ramdisk.len() as u32)?;
         writer.write_u32::<LittleEndian>(self.os_version)?;
         writer.write_u32::<LittleEndian>(self.header_size())?;
 
@@ -673,7 +725,7 @@ impl BootImageV3Through4 {
 
                 // The VTS signature is always a fixed size.
                 if size > HDR_V4_SIGNATURE_SIZE {
-                    return Err(Error::IntegerTooLarge("signature_size"));
+                    return Err(Error::FieldOutOfBounds("signature_size"));
                 }
 
                 padding::write_zeros(&mut sig_writer, HDR_V4_SIGNATURE_SIZE)?;
@@ -688,15 +740,21 @@ impl BootImageV3Through4 {
 
         padding::write_zeros(&mut writer, PAGE_SIZE.into())?;
 
-        writer.write_all(&self.kernel)?;
+        writer
+            .write_all(&self.kernel)
+            .map_err(|e| Error::WriteFieldError("kernel", e))?;
         padding::write_zeros(&mut writer, PAGE_SIZE.into())?;
 
-        writer.write_all(&self.ramdisk)?;
+        writer
+            .write_all(&self.ramdisk)
+            .map_err(|e| Error::WriteFieldError("ramdisk", e))?;
         padding::write_zeros(&mut writer, PAGE_SIZE.into())?;
 
         if !skip_v4_sig {
             if let Some(sig) = v4_signature {
-                writer.write_all(&sig)?;
+                writer
+                    .write_all(&sig)
+                    .map_err(|e| Error::WriteFieldError("signature", e))?;
                 padding::write_zeros(&mut writer, PAGE_SIZE.into())?;
             }
         }
@@ -910,9 +968,17 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
         }
 
         let page_size = reader.read_u32::<LittleEndian>()?;
+        if page_size == 0 {
+            return Err(Error::InvalidFieldValue("page_size", 0));
+        }
+
         let kernel_addr = reader.read_u32::<LittleEndian>()?;
         let ramdisk_addr = reader.read_u32::<LittleEndian>()?;
+
         let vendor_ramdisk_size = reader.read_u32::<LittleEndian>()?;
+        if vendor_ramdisk_size > COMPONENT_MAX_SIZE {
+            return Err(Error::FieldOutOfBounds("vendor_ramdisk_size"));
+        }
 
         let cmdline = reader
             .read_string_padded(VENDOR_BOOT_ARGS_SIZE)
@@ -925,7 +991,12 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
             .map_err(|e| Error::ReadFieldError("name", e))?;
 
         let header_size = reader.read_u32::<LittleEndian>()?;
+
         let dtb_size = reader.read_u32::<LittleEndian>()?;
+        if dtb_size > COMPONENT_MAX_SIZE {
+            return Err(Error::FieldOutOfBounds("dtb_size"));
+        }
+
         let dtb_addr = reader.read_u64::<LittleEndian>()?;
 
         struct V4Data {
@@ -938,14 +1009,18 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
             let table_size = reader.read_u32::<LittleEndian>()?;
             let table_entry_num = reader.read_u32::<LittleEndian>()?;
             let table_entry_size = reader.read_u32::<LittleEndian>()?;
+
             let bootconfig_size = reader.read_u32::<LittleEndian>()?;
+            if bootconfig_size > BOOTCONFIG_MAX_SIZE {
+                return Err(Error::FieldOutOfBounds("bootconfig_size"));
+            }
 
             if table_entry_size != VENDOR_RAMDISK_TABLE_ENTRY_V4_SIZE {
                 return Err(Error::InvalidFieldValue(
                     "vendor_ramdisk_table_entry_size",
                     table_entry_size,
                 ));
-            } else if table_size != table_entry_num * table_entry_size {
+            } else if table_entry_num.checked_mul(table_entry_size) != Some(table_size) {
                 return Err(Error::InvalidFieldValue(
                     "vendor_ramdisk_table_size",
                     table_size,
@@ -972,8 +1047,10 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
 
         let mut ramdisks = vec![];
 
-        let mut vendor_ramdisk_data = vec![0u8; vendor_ramdisk_size.to_usize().unwrap()];
-        reader.read_exact(&mut vendor_ramdisk_data)?;
+        let mut vendor_ramdisk_data = vec![0u8; vendor_ramdisk_size as usize];
+        reader
+            .read_exact(&mut vendor_ramdisk_data)
+            .map_err(|e| Error::ReadFieldError("vendor_ramdisk_data", e))?;
         padding::read_discard(&mut reader, page_size.into())?;
 
         // For v3, this is just one big ramdisk. For v4, we have to wait until
@@ -984,8 +1061,10 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
             vendor_ramdisk_data = vec![];
         }
 
-        let mut dtb = vec![0u8; dtb_size.to_usize().unwrap()];
-        reader.read_exact(&mut dtb)?;
+        let mut dtb = vec![0u8; dtb_size as usize];
+        reader
+            .read_exact(&mut dtb)
+            .map_err(|e| Error::ReadFieldError("dtb", e))?;
         padding::read_discard(&mut reader, page_size.into())?;
 
         if let Some(v4) = &mut v4_data {
@@ -994,6 +1073,10 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
 
             for _ in 0..v4.vendor_ramdisk_table_entry_num {
                 let ramdisk_size = reader.read_u32::<LittleEndian>()?;
+                if ramdisk_size > vendor_ramdisk_size {
+                    return Err(Error::FieldOutOfBounds("ramdisk_size"));
+                }
+
                 let ramdisk_offset = reader.read_u32::<LittleEndian>()?;
                 let ramdisk_type = reader.read_u32::<LittleEndian>()?;
 
@@ -1010,7 +1093,7 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
                     return Err(Error::InvalidFieldValue("ramdisk_offset", ramdisk_offset));
                 }
 
-                let mut ramdisk = vec![0u8; ramdisk_size.to_usize().unwrap()];
+                let mut ramdisk = vec![0u8; ramdisk_size as usize];
                 ramdisk_reader.read_exact(&mut ramdisk)?;
                 ramdisks.push(ramdisk);
 
@@ -1033,7 +1116,7 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
             padding::read_discard(&mut reader, page_size.into())?;
 
             v4.v4_extra.bootconfig = reader
-                .read_string_padded(v4.bootconfig_size.to_usize().unwrap())
+                .read_string_padded(v4.bootconfig_size as usize)
                 .map_err(|e| Error::ReadFieldError("bootconfig", e))?;
         }
 
@@ -1070,27 +1153,29 @@ impl<W: Write> ToWriter<W> for VendorBootImageV3Through4 {
             return Err(Error::InvalidData("v3 only supports one ramdisk"));
         }
 
-        let mut writer = CountingWriter::new(writer);
+        let vendor_ramdisk_size = self.ramdisks.iter().map(|r| r.len()).sum::<usize>();
+        if vendor_ramdisk_size > COMPONENT_MAX_SIZE as usize {
+            return Err(Error::FieldOutOfBounds("vendor_ramdisk_size"));
+        } else if self.dtb.len() > COMPONENT_MAX_SIZE as usize {
+            return Err(Error::FieldOutOfBounds("dtb_size"));
+        } else if self.page_size == 0 {
+            return Err(Error::InvalidFieldValue("page_size", 0));
+        }
 
-        let vendor_ramdisk_size = self
-            .ramdisks
-            .iter()
-            .map(|r| r.len())
-            .sum::<usize>()
-            .to_u32()
-            .ok_or_else(|| Error::IntegerTooLarge("vendor_ramdisk_size"))?;
-        let dtb_size = self
-            .dtb
-            .len()
-            .to_u32()
-            .ok_or_else(|| Error::IntegerTooLarge("dtb_size"))?;
+        if let Some(v4) = &self.v4_extra {
+            if v4.bootconfig.len() > BOOTCONFIG_MAX_SIZE as usize {
+                return Err(Error::FieldOutOfBounds("bootconfig_size"));
+            }
+        }
+
+        let mut writer = CountingWriter::new(writer);
 
         writer.write_all(&VENDOR_BOOT_MAGIC)?;
         writer.write_u32::<LittleEndian>(self.header_version())?;
         writer.write_u32::<LittleEndian>(self.page_size)?;
         writer.write_u32::<LittleEndian>(self.kernel_addr)?;
         writer.write_u32::<LittleEndian>(self.ramdisk_addr)?;
-        writer.write_u32::<LittleEndian>(vendor_ramdisk_size)?;
+        writer.write_u32::<LittleEndian>(vendor_ramdisk_size as u32)?;
 
         writer
             .write_string_padded(&self.cmdline, VENDOR_BOOT_ARGS_SIZE)
@@ -1103,7 +1188,7 @@ impl<W: Write> ToWriter<W> for VendorBootImageV3Through4 {
             .map_err(|e| Error::WriteFieldError("name", e))?;
 
         writer.write_u32::<LittleEndian>(self.header_size())?;
-        writer.write_u32::<LittleEndian>(dtb_size)?;
+        writer.write_u32::<LittleEndian>(self.dtb.len() as u32)?;
         writer.write_u64::<LittleEndian>(self.dtb_addr)?;
 
         if let Some(v4) = &self.v4_extra {
@@ -1111,38 +1196,37 @@ impl<W: Write> ToWriter<W> for VendorBootImageV3Through4 {
                 .ramdisks
                 .len()
                 .to_u32()
-                .ok_or_else(|| Error::IntegerTooLarge("vendor_ramdisk_table_entry_num"))?;
+                .ok_or_else(|| Error::FieldOutOfBounds("vendor_ramdisk_table_entry_num"))?;
             let vendor_ramdisk_table_size = vendor_ramdisk_table_entry_num
                 .checked_mul(VENDOR_RAMDISK_TABLE_ENTRY_V4_SIZE)
                 .and_then(|v| v.to_u32())
-                .ok_or_else(|| Error::IntegerTooLarge("vendor_ramdisk_table_size"))?;
-            let bootconfig_size = v4
-                .bootconfig
-                .len()
-                .to_u32()
-                .ok_or_else(|| Error::IntegerTooLarge("bootconfig"))?;
+                .ok_or_else(|| Error::FieldOutOfBounds("vendor_ramdisk_table_size"))?;
 
             writer.write_u32::<LittleEndian>(vendor_ramdisk_table_size)?;
             writer.write_u32::<LittleEndian>(vendor_ramdisk_table_entry_num)?;
             writer.write_u32::<LittleEndian>(VENDOR_RAMDISK_TABLE_ENTRY_V4_SIZE)?;
-            writer.write_u32::<LittleEndian>(bootconfig_size)?;
+            writer.write_u32::<LittleEndian>(v4.bootconfig.len() as u32)?;
         }
 
         padding::write_zeros(&mut writer, self.page_size.into())?;
 
         for ramdisk in &self.ramdisks {
-            writer.write_all(ramdisk)?;
+            writer
+                .write_all(ramdisk)
+                .map_err(|e| Error::WriteFieldError("vendor_ramdisk_data", e))?;
         }
         padding::write_zeros(&mut writer, self.page_size.into())?;
 
-        writer.write_all(&self.dtb)?;
+        writer
+            .write_all(&self.dtb)
+            .map_err(|e| Error::WriteFieldError("dtb", e))?;
         padding::write_zeros(&mut writer, self.page_size.into())?;
 
         if let Some(v4) = &self.v4_extra {
             let mut ramdisk_offset = 0;
 
             for (ramdisk, meta) in self.ramdisks.iter().zip(&v4.ramdisk_metas) {
-                let ramdisk_size = ramdisk.len().to_u32().unwrap();
+                let ramdisk_size = ramdisk.len() as u32;
 
                 writer.write_u32::<LittleEndian>(ramdisk_size)?;
                 writer.write_u32::<LittleEndian>(ramdisk_offset)?;
@@ -1160,7 +1244,9 @@ impl<W: Write> ToWriter<W> for VendorBootImageV3Through4 {
             }
             padding::write_zeros(&mut writer, self.page_size.into())?;
 
-            writer.write_all(v4.bootconfig.as_bytes())?;
+            writer
+                .write_all(v4.bootconfig.as_bytes())
+                .map_err(|e| Error::WriteFieldError("bootconfig", e))?;
             padding::write_zeros(&mut writer, self.page_size.into())?;
         }
 
@@ -1169,6 +1255,7 @@ impl<W: Write> ToWriter<W> for VendorBootImageV3Through4 {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(tag = "type")]
 pub enum BootImage {
     V0Through2(BootImageV0Through2),
     V3Through4(BootImageV3Through4),

avbroot/src/format/compression.rs

@@ -7,16 +7,25 @@ use std::io::{self, Read, Seek, Write};
 
 use byteorder::{LittleEndian, WriteBytesExt};
 use flate2::{read::GzDecoder, write::GzEncoder, Compression};
+use liblzma::{
+    read::XzDecoder,
+    stream::{Check, Stream},
+    write::XzEncoder,
+};
 use lz4_flex::frame::FrameDecoder;
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 static GZIP_MAGIC: &[u8; 2] = b"\x1f\x8b";
 static LZ4_LEGACY_MAGIC: &[u8; 4] = b"\x02\x21\x4c\x18";
+static XZ_MAGIC: &[u8; 6] = b"\xfd\x37\x7a\x58\x5a\x00";
 
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("Unknown compression format")]
     UnknownFormat,
+    #[error("XZ stream error")]
+    XzStream(#[from] liblzma::stream::Error),
     #[error("I/O error")]
     Io(#[from] io::Error),
 }
@@ -96,30 +105,34 @@ impl<W: Write> Write for Lz4LegacyEncoder<W> {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
 pub enum CompressedFormat {
     None,
     Gzip,
     Lz4Legacy,
+    Xz,
 }
 
 pub enum CompressedReader<R: Read> {
     None(R),
     Gzip(GzDecoder<R>),
     Lz4(FrameDecoder<R>),
+    Xz(XzDecoder<R>),
 }
 
 impl<R: Read + Seek> CompressedReader<R> {
     pub fn new(mut reader: R, raw_if_unknown: bool) -> Result<Self> {
-        let mut magic = [0u8; 4];
+        let mut magic = [0u8; 6];
         reader.read_exact(&mut magic)?;
 
         reader.rewind()?;
 
         if &magic[0..2] == GZIP_MAGIC {
             Ok(Self::Gzip(GzDecoder::new(reader)))
-        } else if &magic == LZ4_LEGACY_MAGIC {
+        } else if &magic[0..4] == LZ4_LEGACY_MAGIC {
             Ok(Self::Lz4(FrameDecoder::new(reader)))
+        } else if &magic == XZ_MAGIC {
+            Ok(Self::Xz(XzDecoder::new(reader)))
         } else if raw_if_unknown {
             Ok(Self::None(reader))
         } else {
@@ -132,6 +145,7 @@ impl<R: Read + Seek> CompressedReader<R> {
             Self::None(_) => CompressedFormat::None,
             Self::Gzip(_) => CompressedFormat::Gzip,
             Self::Lz4(_) => CompressedFormat::Lz4Legacy,
+            Self::Xz(_) => CompressedFormat::Xz,
         }
     }
 
@@ -140,6 +154,7 @@ impl<R: Read + Seek> CompressedReader<R> {
             Self::None(r) => r,
             Self::Gzip(r) => r.into_inner(),
             Self::Lz4(r) => r.into_inner(),
+            Self::Xz(r) => r.into_inner(),
         }
     }
 }
@@ -150,6 +165,7 @@ impl<R: Read> Read for CompressedReader<R> {
             Self::None(r) => r.read(buf),
             Self::Gzip(r) => r.read(buf),
             Self::Lz4(r) => r.read(buf),
+            Self::Xz(r) => r.read(buf),
         }
     }
 }
@@ -158,6 +174,7 @@ pub enum CompressedWriter<W: Write> {
     None(W),
     Gzip(GzEncoder<W>),
     Lz4Legacy(Lz4LegacyEncoder<W>),
+    Xz(XzEncoder<W>),
 }
 
 impl<W: Write> CompressedWriter<W> {
@@ -168,6 +185,11 @@ impl<W: Write> CompressedWriter<W> {
                 Ok(Self::Gzip(GzEncoder::new(writer, Compression::default())))
             }
             CompressedFormat::Lz4Legacy => Ok(Self::Lz4Legacy(Lz4LegacyEncoder::new(writer)?)),
+            CompressedFormat::Xz => {
+                // Some kernels are compiled without support for the default CRC64.
+                let stream = Stream::new_easy_encoder(6, Check::Crc32)?;
+                Ok(Self::Xz(XzEncoder::new_stream(writer, stream)))
+            }
         }
     }
 
@@ -176,6 +198,7 @@ impl<W: Write> CompressedWriter<W> {
             Self::None(_) => CompressedFormat::None,
             Self::Gzip(_) => CompressedFormat::Gzip,
             Self::Lz4Legacy(_) => CompressedFormat::Lz4Legacy,
+            Self::Xz(_) => CompressedFormat::Xz,
         }
     }
 
@@ -184,6 +207,7 @@ impl<W: Write> CompressedWriter<W> {
             Self::None(w) => Ok(w),
             Self::Gzip(w) => w.finish(),
             Self::Lz4Legacy(w) => w.finish(),
+            Self::Xz(w) => w.finish(),
         }
     }
 }
@@ -194,6 +218,7 @@ impl<W: Write> Write for CompressedWriter<W> {
             Self::None(w) => w.write(buf),
             Self::Gzip(w) => w.write(buf),
             Self::Lz4Legacy(w) => w.write(buf),
+            Self::Xz(w) => w.write(buf),
         }
     }
 
@@ -202,6 +227,7 @@ impl<W: Write> Write for CompressedWriter<W> {
             Self::None(w) => w.flush(),
             Self::Gzip(w) => w.flush(),
             Self::Lz4Legacy(w) => w.flush(),
+            Self::Xz(w) => w.flush(),
         }
     }
 }

avbroot/src/format/cpio.rs

@@ -4,18 +4,25 @@
  */
 
 use std::{
-    borrow::Cow,
+    collections::{HashMap, HashSet},
     fmt,
-    io::{self, Read, Write},
+    io::{self, Cursor, Read, Write},
+    ops::Range,
+    sync::atomic::AtomicBool,
 };
 
 use bstr::ByteSlice;
-use num_traits::ToPrimitive;
+use num_traits::{ToPrimitive, Zero};
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 use crate::{
+    escape,
     format::padding,
-    stream::{CountingReader, CountingWriter, FromReader, ToWriter, WriteZerosExt},
+    octal,
+    stream::{
+        self, CountingReader, CountingWriter, FromReader, ReadDiscardExt, ToWriter, WriteZerosExt,
+    },
     util::NumBytes,
 };
 
@@ -35,12 +42,20 @@ const C_ISCTG: u32 = 0o110000;
 
 const IO_BLOCK_SIZE: u64 = 512;
 
+/// The threshold when reading data where memory allocation switches from
+/// allocating the exact size to resizing as necessary.
+const VEC_CAP_THRESHOLD: usize = 16384;
+
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("Unknown magic: {0:?}")]
     UnknownMagic([u8; 6]),
     #[error("Hard links are not supported: {:?}", .0.as_bstr())]
     HardLinksNotSupported(Vec<u8>),
+    #[error("Entry of type {0} should not have data: {:?}", .1.as_bstr())]
+    EntryHasData(CpioEntryType, Vec<u8>),
+    #[error("No inodes available for device {0:x},{1:x}")]
+    DeviceFull(u32, u32),
     #[error("{0:?} field exceeds integer bounds")]
     IntegerTooLarge(&'static str),
     #[error("I/O error")]
@@ -86,32 +101,200 @@ fn write_int(mut writer: impl Write, mut value: u32) -> io::Result<()> {
     writer.write_all(&buf)
 }
 
-fn file_type(mode: u32) -> u32 {
-    mode & 0o170000
+/// Read a chunk of bytes from the reader. If `size` is less than
+/// [`VEC_CAP_THRESHOLD`], then the buffer is allocated with the exact size.
+/// Otherwise, the buffer starts with a capacity of [`VEC_CAP_THRESHOLD`] and
+/// grows as necessary. This avoids allocating excessive memory when the entry
+/// specifies an excessively large value that's not backed by actual data.
+fn read_data(reader: impl Read, size: usize, cancel_signal: &AtomicBool) -> io::Result<Vec<u8>> {
+    let buf = Vec::with_capacity(size.min(VEC_CAP_THRESHOLD));
+    let mut cursor = Cursor::new(buf);
+
+    stream::copy_n(reader, &mut cursor, size as u64, cancel_signal)?;
+
+    Ok(cursor.into_inner())
 }
 
-#[derive(Clone, Default, PartialEq, Eq)]
-pub struct CpioEntryNew {
-    pub ino: u32,
-    pub mode: u32,
-    pub uid: u32,
-    pub gid: u32,
-    pub nlink: u32,
-    pub mtime: u32,
-    pub dev_maj: u32,
-    pub dev_min: u32,
-    pub rdev_maj: u32,
-    pub rdev_min: u32,
-    pub chksum: u32,
-    pub name: Vec<u8>,
-    pub content: Vec<u8>,
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)]
+pub enum CpioEntryType {
+    Pipe,
+    Char,
+    Directory,
+    Block,
+    Regular,
+    Symlink,
+    Socket,
+    Reserved,
+    Unknown(u16),
 }
 
-impl fmt::Debug for CpioEntryNew {
+impl CpioEntryType {
+    pub fn from_mode(mode: u32) -> Self {
+        match mode & 0o170000 {
+            S_IFIFO => Self::Pipe,
+            S_IFCHR => Self::Char,
+            S_IFDIR => Self::Directory,
+            S_IFBLK => Self::Block,
+            S_IFREG => Self::Regular,
+            S_IFLNK => Self::Symlink,
+            S_IFSOCK => Self::Socket,
+            C_ISCTG => Self::Reserved,
+            m => Self::Unknown(m as u16),
+        }
+    }
+
+    pub fn to_mode(self) -> u32 {
+        match self {
+            Self::Pipe => S_IFIFO,
+            Self::Char => S_IFCHR,
+            Self::Directory => S_IFDIR,
+            Self::Block => S_IFBLK,
+            Self::Regular => S_IFREG,
+            Self::Symlink => S_IFLNK,
+            Self::Socket => S_IFSOCK,
+            Self::Reserved => C_ISCTG,
+            Self::Unknown(m) => m.into(),
+        }
+    }
+}
+
+impl fmt::Display for CpioEntryType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("CpioEntryNew")
-            .field("ino", &self.ino)
-            .field("mode", &self.mode)
+        match self {
+            Self::Pipe => write!(f, "pipe"),
+            Self::Char => write!(f, "character device"),
+            Self::Directory => write!(f, "directory"),
+            Self::Block => write!(f, "block device"),
+            Self::Regular => write!(f, "regular file"),
+            Self::Symlink => write!(f, "symbolic link"),
+            Self::Socket => write!(f, "socket"),
+            Self::Reserved => write!(f, "reserved"),
+            Self::Unknown(m) => write!(f, "unknown ({m:o})"),
+        }
+    }
+}
+
+impl Default for CpioEntryType {
+    fn default() -> Self {
+        Self::Unknown(0)
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum CpioEntryData {
+    /// Size of entry's data. [`CpioReader`] and [`CpioWriter`] use this for
+    /// [`CpioEntryType::Regular`] entries to allow for lazy reads and writes.
+    Size(u32),
+    /// Entry's data. For [`CpioEntryType::Symlink`] entries, this is the
+    /// link target. For [`CpioEntryType::Regular`] entries, this is the file
+    /// content. [`CpioReader`] will never use this when reading regular files.
+    /// [`CpioWriter`] will write this immediately and lazy writes will not be
+    /// allowed.
+    Data(#[serde(with = "escape")] Vec<u8>),
+}
+
+impl fmt::Debug for CpioEntryData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Size(s) => f.debug_tuple("Size").field(s).finish(),
+            Self::Data(d) => f.debug_tuple("Data").field(&NumBytes(d.len())).finish(),
+        }
+    }
+}
+
+impl Default for CpioEntryData {
+    fn default() -> Self {
+        Self::Size(0)
+    }
+}
+
+impl CpioEntryData {
+    pub fn size(&self) -> Result<u32> {
+        let size = match self {
+            Self::Size(s) => *s,
+            Self::Data(d) => d
+                .len()
+                .to_u32()
+                .ok_or_else(|| Error::IntegerTooLarge("data_size"))?,
+        };
+
+        Ok(size)
+    }
+
+    fn is_size(&self) -> bool {
+        matches!(self, CpioEntryData::Size(_))
+    }
+}
+
+#[derive(Clone, Default, PartialEq, Eq, Deserialize, Serialize)]
+pub struct CpioEntry {
+    /// File path.
+    #[serde(with = "escape")]
+    pub path: Vec<u8>,
+
+    /// File data.
+    #[serde(default, skip_serializing_if = "CpioEntryData::is_size")]
+    pub data: CpioEntryData,
+
+    /// Inode number.
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub inode: u32,
+
+    /// File type portion of the `st_mode`-style mode.
+    pub file_type: CpioEntryType,
+
+    /// Permissions portion of the `st_mode`-style mode.
+    #[serde(default, skip_serializing_if = "Zero::is_zero", with = "octal")]
+    pub file_mode: u16,
+
+    /// Owner user ID.
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub uid: u32,
+
+    /// Owner group ID.
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub gid: u32,
+
+    /// Number of paths referencing the inode.
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub nlink: u32,
+
+    /// Modification timestamp in Unix time.
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub mtime: u32,
+
+    /// Major ID (class of device) for the device containing the inode.
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub dev_maj: u32,
+
+    /// Minor ID (specific device instance) for the device containing the inode.
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub dev_min: u32,
+
+    /// Major ID (class of device) represented by this entry. This is only
+    /// relevant for [`CpioEntryType::Char`] and [`CpioEntryType::Block`].
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub rdev_maj: u32,
+
+    /// Minor ID (specific device instance) represented by this entry. This is
+    /// only relevant for [`CpioEntryType::Char`] and [`CpioEntryType::Block`].
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub rdev_min: u32,
+
+    /// CRC32 checksum.
+    #[serde(default, skip_serializing_if = "Zero::is_zero")]
+    pub crc32: u32,
+}
+
+impl fmt::Debug for CpioEntry {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("CpioEntry")
+            .field("path", &self.path.as_bstr())
+            .field("data", &self.data)
+            .field("inode", &self.inode)
+            .field("file_type", &self.file_type)
+            .field("file_mode", &self.file_mode)
             .field("uid", &self.uid)
             .field("gid", &self.gid)
             .field("nlink", &self.nlink)
@@ -120,84 +303,89 @@ impl fmt::Debug for CpioEntryNew {
             .field("dev_min", &self.dev_min)
             .field("rdev_maj", &self.rdev_maj)
             .field("rdev_min", &self.rdev_min)
-            .field("chksum", &self.chksum)
-            .field("name", &self.name.as_bstr())
-            .field("content", &NumBytes(self.content.len()))
+            .field("crc32", &self.crc32)
             .finish()
     }
 }
 
-impl fmt::Display for CpioEntryNew {
+impl fmt::Display for CpioEntry {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let file_type_str = match file_type(self.mode) {
-            S_IFIFO => Cow::Borrowed("pipe"),
-            S_IFCHR => Cow::Borrowed("character device"),
-            S_IFDIR => Cow::Borrowed("directory"),
-            S_IFBLK => Cow::Borrowed("block device"),
-            S_IFREG => Cow::Borrowed("regular file"),
-            S_IFLNK => Cow::Borrowed("symbolic link"),
-            S_IFSOCK => Cow::Borrowed("socket"),
-            C_ISCTG => Cow::Borrowed("reserved"),
-            m => Cow::Owned(format!("unknown ({m:o})")),
-        };
-
-        writeln!(f, "Filename:  {:?}", self.name.as_bstr())?;
-        writeln!(f, "Filetype:  {file_type_str}")?;
-        writeln!(f, "Inode:     {}", self.ino)?;
-        writeln!(f, "Mode:      {:o}", self.mode)?;
-        writeln!(f, "UID:       {}", self.uid)?;
-        writeln!(f, "GID:       {}", self.gid)?;
-        writeln!(f, "Links:     {}", self.nlink)?;
-        writeln!(f, "Modified:  {}", self.mtime)?;
-        writeln!(f, "Device:    {:x},{:x}", self.dev_maj, self.dev_min)?;
-        writeln!(f, "Device ID: {:x},{:x}", self.rdev_maj, self.rdev_min)?;
-        writeln!(f, "Checksum:  {:x}", self.chksum)?;
-        writeln!(f, "Content:   {:?}", NumBytes(self.content.len()))?;
+        writeln!(f, "Path:    {:?}", self.path.as_bstr())?;
+        match &self.data {
+            CpioEntryData::Size(s) => {
+                writeln!(f, "Data:    {:?}", &NumBytes(*s))?;
+            }
+            CpioEntryData::Data(d) => {
+                if self.file_type == CpioEntryType::Symlink {
+                    writeln!(f, "Data:    {:?}", d.as_bstr())?;
+                } else {
+                    writeln!(f, "Data:    {:?}", &NumBytes(d.len()))?;
+                }
+            }
+        }
+        writeln!(f, "Inode:   {}", self.inode)?;
+        writeln!(f, "Type:    {}", self.file_type)?;
+        writeln!(f, "Mode:    {:o}", self.file_mode)?;
+        writeln!(f, "UID:     {}", self.uid)?;
+        writeln!(f, "GID:     {}", self.gid)?;
+        writeln!(f, "Links:   {}", self.nlink)?;
+        writeln!(f, "Modtime: {}", self.mtime)?;
+        writeln!(f, "Idevice: {:x},{:x}", self.dev_maj, self.dev_min)?;
+        writeln!(f, "Rdevice: {:x},{:x}", self.rdev_maj, self.rdev_min)?;
+        write!(f, "CRC32:   {:x}", self.crc32)?;
 
         Ok(())
     }
 }
 
-impl CpioEntryNew {
+impl CpioEntry {
     pub fn new_trailer() -> Self {
         Self {
+            path: CPIO_TRAILER.to_vec(),
             // Must be 1 for CRC format.
             nlink: 1,
-            name: CPIO_TRAILER.to_vec(),
             ..Default::default()
         }
     }
 
-    pub fn new_symlink(link_target: &[u8], name: &[u8]) -> Self {
+    pub fn new_symlink(path: &[u8], link_target: &[u8]) -> Self {
         Self {
-            mode: S_IFLNK | 0o777,
+            path: path.to_owned(),
+            data: CpioEntryData::Data(link_target.to_owned()),
+            file_type: CpioEntryType::Symlink,
+            file_mode: 0o777,
             nlink: 1,
-            name: name.to_owned(),
-            content: link_target.to_owned(),
             ..Default::default()
         }
     }
 
-    pub fn new_directory(name: &[u8]) -> Self {
+    pub fn new_directory(path: &[u8], mode: u16) -> Self {
         Self {
-            mode: S_IFDIR,
+            path: path.to_owned(),
+            file_type: CpioEntryType::Directory,
+            file_mode: mode,
             nlink: 1,
-            name: name.to_owned(),
             ..Default::default()
         }
     }
 
-    pub fn new_file(name: &[u8]) -> Self {
+    pub fn new_file(path: &[u8], mode: u16, data: CpioEntryData) -> Self {
         Self {
-            mode: S_IFREG,
+            path: path.to_owned(),
+            data,
+            file_type: CpioEntryType::Regular,
+            file_mode: mode,
             nlink: 1,
-            name: name.to_owned(),
             ..Default::default()
         }
     }
+
+    pub fn is_trailer(&self) -> bool {
+        self.path == CPIO_TRAILER
+    }
 }
 
-impl<R: Read> FromReader<R> for CpioEntryNew {
+impl<R: Read> FromReader<R> for CpioEntry {
     type Error = Error;
 
     fn from_reader(reader: R) -> Result<Self> {
@@ -210,39 +398,61 @@ impl<R: Read> FromReader<R> for CpioEntryNew {
             return Err(Error::UnknownMagic(magic));
         }
 
-        let ino = read_int(&mut reader)?;
+        let inode = read_int(&mut reader)?;
         let mode = read_int(&mut reader)?;
         let uid = read_int(&mut reader)?;
         let gid = read_int(&mut reader)?;
         let nlink = read_int(&mut reader)?;
         let mtime = read_int(&mut reader)?;
-        let filesize = read_int(&mut reader)?;
+        let file_size = read_int(&mut reader)?;
         let dev_maj = read_int(&mut reader)?;
         let dev_min = read_int(&mut reader)?;
         let rdev_maj = read_int(&mut reader)?;
         let rdev_min = read_int(&mut reader)?;
-        let namesize = read_int(&mut reader)?;
-        let chksum = read_int(&mut reader)?;
+        let path_size = read_int(&mut reader)?;
+        let crc32 = read_int(&mut reader)?;
 
-        let mut name = vec![0u8; namesize.to_usize().unwrap()];
-        reader.read_exact(&mut name)?;
-        if name.last() != Some(&b'\0') {
+        let mut path = read_data(
+            &mut reader,
+            path_size.to_usize().unwrap(),
+            &AtomicBool::new(false),
+        )?;
+        if path.last() != Some(&b'\0') {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 "Filename is not NULL-terminated",
             )
             .into());
         }
-        name.pop();
+        path.pop();
         padding::read_discard(&mut reader, 4)?;
 
-        let mut content = vec![0u8; filesize.to_usize().unwrap()];
-        reader.read_exact(&mut content)?;
-        padding::read_discard(&mut reader, 4)?;
+        let file_type = CpioEntryType::from_mode(mode);
+        let data = match file_type {
+            // Handled by CpioReader for streaming reads.
+            CpioEntryType::Regular => CpioEntryData::Size(file_size),
+            // Symlinks store the target in the file data.
+            CpioEntryType::Symlink => {
+                let content = read_data(
+                    &mut reader,
+                    file_size.to_usize().unwrap(),
+                    &AtomicBool::new(false),
+                )?;
+                padding::read_discard(&mut reader, 4)?;
+
+                CpioEntryData::Data(content)
+            }
+            // No other entry type should have data.
+            t if file_size != 0 => return Err(Error::EntryHasData(t, path)),
+            _ => CpioEntryData::Size(0),
+        };
 
         Ok(Self {
-            ino,
-            mode,
+            path,
+            data,
+            inode,
+            file_type,
+            file_mode: (mode & 0o7777) as u16,
             uid,
             gid,
             nlink,
@@ -251,76 +461,236 @@ impl<R: Read> FromReader<R> for CpioEntryNew {
             dev_min,
             rdev_maj,
             rdev_min,
-            chksum,
-            name,
-            content,
+            crc32,
         })
     }
 }
 
-impl<W: Write> ToWriter<W> for CpioEntryNew {
+impl<W: Write> ToWriter<W> for CpioEntry {
     type Error = Error;
 
     fn to_writer(&self, writer: W) -> Result<()> {
         let mut writer = CountingWriter::new(writer);
 
-        let filesize = self
-            .content
-            .len()
-            .to_u32()
-            .ok_or_else(|| Error::IntegerTooLarge("filesize"))?;
-        let namesize = self
-            .name
+        let path_size = self
+            .path
             .len()
             .checked_add(1)
             .and_then(|s| s.to_u32())
-            .ok_or_else(|| Error::IntegerTooLarge("filesize"))?;
+            .ok_or_else(|| Error::IntegerTooLarge("path_size"))?;
 
-        if self.chksum == 0 {
+        let file_size = self.data.size()?;
+        if file_size != 0
+            && self.file_type != CpioEntryType::Regular
+            && self.file_type != CpioEntryType::Symlink
+        {
+            return Err(Error::EntryHasData(self.file_type, self.path.clone()));
+        }
+
+        if self.crc32 == 0 {
             writer.write_all(MAGIC_NEW)?;
         } else {
             writer.write_all(MAGIC_NEW_CRC)?;
         }
 
-        write_int(&mut writer, self.ino)?;
-        write_int(&mut writer, self.mode)?;
+        let mode = self.file_type.to_mode() | u32::from(self.file_mode & 0o7777);
+
+        write_int(&mut writer, self.inode)?;
+        write_int(&mut writer, mode)?;
         write_int(&mut writer, self.uid)?;
         write_int(&mut writer, self.gid)?;
         write_int(&mut writer, self.nlink)?;
         write_int(&mut writer, self.mtime)?;
-        write_int(&mut writer, filesize)?;
+        write_int(&mut writer, file_size)?;
         write_int(&mut writer, self.dev_maj)?;
         write_int(&mut writer, self.dev_min)?;
         write_int(&mut writer, self.rdev_maj)?;
         write_int(&mut writer, self.rdev_min)?;
-        write_int(&mut writer, namesize)?;
-        write_int(&mut writer, self.chksum)?;
+        write_int(&mut writer, path_size)?;
+        write_int(&mut writer, self.crc32)?;
 
-        writer.write_all(&self.name)?;
+        writer.write_all(&self.path)?;
         writer.write_zeros_exact(1)?;
         padding::write_zeros(&mut writer, 4)?;
 
-        writer.write_all(&self.content)?;
-        padding::write_zeros(&mut writer, 4)?;
+        if let CpioEntryData::Data(d) = &self.data {
+            writer.write_all(d)?;
+            padding::write_zeros(&mut writer, 4)?;
+        }
 
         Ok(())
     }
 }
 
-pub fn load(mut reader: impl Read, include_trailer: bool) -> Result<Vec<CpioEntryNew>> {
-    let mut entries = vec![];
+pub struct CpioReader<R: Read> {
+    reader: R,
+    include_trailer: bool,
+    range: Option<Range<u64>>,
+    done: bool,
+}
 
-    loop {
-        let entry = CpioEntryNew::from_reader(&mut reader)?;
-        if file_type(entry.mode) != S_IFDIR && entry.nlink > 1 {
-            return Err(Error::HardLinksNotSupported(entry.name));
+impl<R: Read> CpioReader<R> {
+    pub fn new(reader: R, include_trailer: bool) -> Self {
+        Self {
+            reader,
+            include_trailer,
+            range: None,
+            done: false,
+        }
+    }
+
+    pub fn into_inner(self) -> R {
+        self.reader
+    }
+
+    fn skip_data(&mut self) -> io::Result<()> {
+        if let Some(range) = &mut self.range {
+            // This cannot overflow because cpio file sizes are 32 bit.
+            let n = range.end - range.start + padding::calc(range.end, 4);
+            self.reader.read_discard_exact(n)?;
+            self.range = None;
         }
 
-        if entry.name == CPIO_TRAILER {
-            if include_trailer {
-                entries.push(entry);
+        Ok(())
+    }
+
+    pub fn next_entry(&mut self) -> Result<Option<CpioEntry>> {
+        if self.done {
+            return Ok(None);
+        }
+
+        self.skip_data()?;
+
+        let entry = CpioEntry::from_reader(&mut self.reader)?;
+
+        if entry.is_trailer() {
+            self.done = true;
+
+            if !self.include_trailer {
+                return Ok(None);
             }
-            break;
+        } else if let CpioEntryData::Size(s) = entry.data {
+            self.range = Some(0..u64::from(s));
+        }
+
+        Ok(Some(entry))
+    }
+}
+
+impl<R: Read> Read for CpioReader<R> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let Some(range) = &mut self.range else {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "No entry opened",
+            ));
+        };
+
+        let to_read = (range.end - range.start).min(buf.len() as u64) as usize;
+        let n = self.reader.read(&mut buf[..to_read])?;
+
+        range.start += n as u64;
+
+        Ok(n)
+    }
+}
+
+pub struct CpioWriter<W: Write> {
+    writer: CountingWriter<W>,
+    pad_to_block_size: bool,
+    range: Option<Range<u64>>,
+    max_inode: u32,
+}
+
+impl<W: Write> CpioWriter<W> {
+    pub fn new(writer: W, pad_to_block_size: bool) -> Self {
+        Self {
+            writer: CountingWriter::new(writer),
+            pad_to_block_size,
+            range: None,
+            max_inode: 0,
+        }
+    }
+
+    fn finish_entry(&mut self) -> io::Result<()> {
+        if let Some(range) = &mut self.range {
+            // This cannot overflow because cpio file sizes are 32 bit.
+            let n = range.end - range.start + padding::calc(range.end, 4);
+            self.writer.write_zeros_exact(n)?;
+            self.range = None;
+        }
+
+        Ok(())
+    }
+
+    pub fn start_entry(&mut self, entry: &CpioEntry) -> Result<()> {
+        self.finish_entry()?;
+
+        entry.to_writer(&mut self.writer)?;
+
+        if let CpioEntryData::Size(s) = entry.data {
+            self.range = Some(0..u64::from(s));
+        }
+
+        self.max_inode = self.max_inode.max(entry.inode);
+
+        Ok(())
+    }
+
+    pub fn finish(mut self) -> Result<W> {
+        self.finish_entry()?;
+
+        self.start_entry(&CpioEntry::new_trailer())?;
+
+        // Pad until the end of the block.
+        if self.pad_to_block_size {
+            padding::write_zeros(&mut self.writer, IO_BLOCK_SIZE)?;
+        }
+
+        Ok(self.writer.finish().0)
+    }
+}
+
+impl<W: Write> Write for CpioWriter<W> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let Some(range) = &mut self.range else {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "No entry started",
+            ));
+        };
+
+        let to_write = (range.end - range.start).min(buf.len() as u64) as usize;
+        let n = self.writer.write(&buf[..to_write])?;
+
+        range.start += n as u64;
+
+        Ok(n)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.writer.flush()
+    }
+}
+
+pub fn load(
+    reader: impl Read,
+    include_trailer: bool,
+    cancel_signal: &AtomicBool,
+) -> Result<Vec<CpioEntry>> {
+    let mut cpio_reader = CpioReader::new(reader, include_trailer);
+    let mut entries = vec![];
+
+    while let Some(mut entry) = cpio_reader.next_entry()? {
+        stream::check_cancel(cancel_signal)?;
+
+        if entry.file_type != CpioEntryType::Directory && entry.nlink > 1 {
+            return Err(Error::HardLinksNotSupported(entry.path.clone()));
+        }
+
+        if let CpioEntryData::Size(s) = entry.data {
+            let data = read_data(&mut cpio_reader, s.to_usize().unwrap(), cancel_signal)?;
+            entry.data = CpioEntryData::Data(data);
         }
 
         entries.push(entry);
@@ -329,35 +699,83 @@ pub fn load(mut reader: impl Read, include_trailer: bool) -> Result<Vec<CpioEntr
     Ok(entries)
 }
 
-pub fn sort(entries: &mut [CpioEntryNew]) {
-    entries.sort_by(|a, b| a.name.cmp(&b.name));
+pub fn sort(entries: &mut [CpioEntry]) {
+    entries.sort_by(|a, b| a.path.cmp(&b.path));
 }
 
-pub fn reassign_inodes(entries: &mut [CpioEntryNew]) {
-    let mut inode = 300000;
-
-    for entry in entries {
-        entry.ino = inode;
-        inode += 1;
-    }
-}
-
-pub fn save(writer: impl Write, entries: &[CpioEntryNew], pad_to_block_size: bool) -> Result<()> {
-    let mut writer = CountingWriter::new(writer);
-
-    for entry in entries {
-        entry.to_writer(&mut writer)?;
+/// Assign inodes to entries. If `missing_only` is true, then inodes are only
+/// assigned if the inode field in an entry is set to 0.
+///
+/// New inodes are assigned starting immediately after the highest inode number
+/// for a given ([`CpioEntry::dev_maj`], [`CpioEntry::dev_min`]) pair. If there
+/// are no existing inodes assigned for a device, then the numbers begin at
+/// 300000.
+pub fn assign_inodes(entries: &mut [CpioEntry], missing_only: bool) -> Result<()> {
+    fn next_non_zero(i: u32) -> u32 {
+        if i == u32::MAX {
+            1
+        } else {
+            i.wrapping_add(1)
+        }
     }
 
-    let mut trailer = CpioEntryNew::new_trailer();
-    // 1 higher than the highest inode if possible.
-    trailer.ino = entries.iter().map(|e| e.ino).max().map_or(0, |i| i + 1);
-    trailer.to_writer(&mut writer)?;
+    // (dev maj, dev min) -> (inode set, last assigned inode)
+    let mut inodes: HashMap<(u32, u32), (HashSet<u32>, u32)> = HashMap::new();
 
-    // Pad until the end of the block.
-    if pad_to_block_size {
-        padding::write_zeros(&mut writer, IO_BLOCK_SIZE)?;
+    if missing_only {
+        for entry in &mut *entries {
+            if entry.inode != 0 {
+                let key = (entry.dev_maj, entry.dev_min);
+                let (set, last) = inodes.entry(key).or_default();
+
+                set.insert(entry.inode);
+                *last = (*last).max(entry.inode);
+            }
+        }
+    }
+
+    for entry in entries {
+        if entry.inode == 0 {
+            let key = (entry.dev_maj, entry.dev_min);
+            let (set, last) = inodes
+                .entry(key)
+                .or_insert_with(|| (HashSet::new(), 299999));
+
+            let mut unused = next_non_zero(*last);
+
+            while set.contains(&unused) {
+                if unused == *last {
+                    return Err(Error::DeviceFull(entry.dev_maj, entry.dev_min));
+                }
+
+                unused = next_non_zero(unused);
+            }
+
+            entry.inode = unused;
+            set.insert(unused);
+            *last = unused;
+        }
     }
 
     Ok(())
 }
+
+pub fn save(
+    writer: impl Write,
+    entries: &[CpioEntry],
+    pad_to_block_size: bool,
+    cancel_signal: &AtomicBool,
+) -> Result<()> {
+    let mut cpio_writer = CpioWriter::new(writer, pad_to_block_size);
+
+    for entry in entries {
+        stream::check_cancel(cancel_signal)?;
+
+        cpio_writer.start_entry(entry)?;
+        // CpioEntryData::Data will have already been written.
+    }
+
+    cpio_writer.finish()?;
+
+    Ok(())
+}

avbroot/src/format/fec.rs

@@ -4,8 +4,10 @@
  */
 
 use std::{
+    collections::HashSet,
     fmt,
     io::{self, Cursor, Read, Seek, SeekFrom, Write},
+    ops::Range,
     sync::atomic::AtomicBool,
 };
 
@@ -19,8 +21,8 @@ use thiserror::Error;
 
 use crate::{
     format::verityrs,
-    stream::{self, FromReader, ReadSeek, ToWriter, WriteSeek, WriteZerosExt},
-    util::NumBytes,
+    stream::{self, FromReader, ReadSeekReopen, ToWriter, WriteSeekReopen, WriteZerosExt},
+    util::{self, NumBytes},
 };
 
 // Not to be confused with the 255-byte RS block size.
@@ -29,6 +31,8 @@ const FEC_HEADER_SIZE: usize = 60;
 const FEC_MAGIC: u32 = 0xFECFECFE;
 const FEC_VERSION: u32 = 0;
 
+const FEC_MAX_BLOCK_SIZE: u32 = 16384;
+
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("FEC with parity byte count of {0} is not supported")]
@@ -61,8 +65,8 @@ pub enum Error {
     InvalidHeaderFecSize { value: usize, available: usize },
     #[error("Expected FEC digest {expected}, but have {actual}")]
     InvalidFecDigest { expected: String, actual: String },
-    #[error("{0:?} field exceeds integer bounds")]
-    IntegerTooLarge(&'static str),
+    #[error("{0:?} field is out of bounds")]
+    FieldOutOfBounds(&'static str),
     #[error("I/O error")]
     Io(#[from] io::Error),
 }
@@ -109,11 +113,6 @@ impl Codeword {
     }
 }
 
-/// Since Rust's built-in .div_ceil() is still nightly-only.
-fn div_ceil(dividend: u64, divisor: u64) -> u64 {
-    dividend / divisor + u64::from(dividend % divisor != 0)
-}
-
 /// A type for performing FEC generation, verification, and error correction for
 /// a specific file size and Reed Solomon configuration. The implementation uses
 /// dm-verity's interleaving access pattern.
@@ -158,6 +157,8 @@ impl Fec {
                 input: file_size,
                 block: block_size,
             });
+        } else if block_size > FEC_MAX_BLOCK_SIZE {
+            return Err(Error::FieldOutOfBounds("block_size"));
         }
 
         let rs_k = 255 - parity;
@@ -165,8 +166,19 @@ impl Fec {
             return Err(Error::UnsupportedParity(parity));
         }
 
-        let blocks = div_ceil(file_size, u64::from(block_size));
-        let rounds = div_ceil(blocks, u64::from(rs_k));
+        let blocks = file_size.div_ceil(u64::from(block_size));
+        let rounds = blocks.div_ceil(u64::from(rs_k));
+
+        // Check upfront so we don't need to do checked multiplication later.
+        rounds
+            .checked_mul(u64::from(parity))
+            .and_then(|s| s.checked_mul(u64::from(block_size)))
+            .and_then(|s| s.to_usize())
+            .ok_or_else(|| Error::FieldOutOfBounds("fec_data_size"))?;
+        rounds
+            .checked_mul(u64::from(rs_k))
+            .and_then(|s| s.checked_mul(u64::from(block_size)))
+            .ok_or_else(|| Error::FieldOutOfBounds("fec_grid_size"))?;
 
         Ok(Self {
             file_size,
@@ -184,7 +196,7 @@ impl Fec {
 
     /// Get the size of the FEC data needed to cover the entire file.
     #[inline]
-    fn fec_size(&self) -> usize {
+    pub fn fec_size(&self) -> usize {
         usize::from(self.parity()) * self.rounds as usize * self.block_size as usize
     }
 
@@ -196,6 +208,34 @@ impl Fec {
         offset / rs_k + offset % rs_k * self.rounds * u64::from(self.block_size)
     }
 
+    /// Get the rounds that correspond to the specified ranges.
+    fn rounds_for_ranges(&self, ranges: &[Range<u64>]) -> Result<HashSet<u64>> {
+        let ranges = util::merge_overlapping(ranges);
+        if let Some(last) = ranges.last() {
+            if last.end > self.file_size {
+                return Err(Error::FieldOutOfBounds("ranges"));
+            }
+        }
+
+        let block_size = u64::from(self.block_size);
+        let mut result = HashSet::new();
+
+        for range in ranges {
+            let start_block = range.start / block_size;
+            let end_block = if range.end % block_size == 0 {
+                range.end / block_size
+            } else {
+                range.end.div_ceil(block_size)
+            };
+
+            for block in start_block..end_block {
+                result.insert(block % self.rounds);
+            }
+        }
+
+        Ok(result)
+    }
+
     /// Read a raw sequential block from the backing file, starting at offset
     /// `offset` in the interleaved view. This reads a horizontal block-aligned
     /// slice in the file offset grid.
@@ -404,7 +444,7 @@ impl Fec {
     /// This function is multithreaded and uses rayon's global thread pool.
     pub fn generate(
         &self,
-        open_input: impl Fn() -> io::Result<Box<dyn ReadSeek>> + Sync,
+        input: &(dyn ReadSeekReopen + Sync),
         cancel_signal: &AtomicBool,
     ) -> Result<Vec<u8>> {
         let fec_size = self.fec_size();
@@ -415,7 +455,7 @@ impl Fec {
             .map(|(round, buf)| -> Result<()> {
                 stream::check_cancel(cancel_signal)?;
 
-                let reader = open_input()?;
+                let reader = input.reopen_boxed()?;
                 self.generate_one_round(reader, round as u64, buf)
             })
             .collect::<Result<()>>()?;
@@ -423,6 +463,41 @@ impl Fec {
         Ok(fec)
     }
 
+    /// Update FEC data coreesponding to the specified file ranges.
+    ///
+    /// This function is multithreaded and uses rayon's global thread pool.
+    pub fn update(
+        &self,
+        input: &(dyn ReadSeekReopen + Sync),
+        ranges: &[Range<u64>],
+        fec: &mut [u8],
+        cancel_signal: &AtomicBool,
+    ) -> Result<()> {
+        let fec_size = self.fec_size();
+        if fec.len() != fec_size {
+            return Err(Error::InvalidFecSize {
+                input: self.file_size,
+                expected: fec_size,
+                actual: fec.len(),
+            });
+        }
+
+        let rounds_to_update = self.rounds_for_ranges(ranges)?;
+
+        fec.par_chunks_exact_mut(fec_size / self.rounds as usize)
+            .enumerate()
+            .filter(|(round, _)| rounds_to_update.contains(&(*round as u64)))
+            .map(|(round, buf)| -> Result<()> {
+                stream::check_cancel(cancel_signal)?;
+
+                let reader = input.reopen_boxed()?;
+                self.generate_one_round(reader, round as u64, buf)
+            })
+            .collect::<Result<()>>()?;
+
+        Ok(())
+    }
+
     /// Verify that the file contains no errors. This is significantly faster
     /// than [`Self::repair()`] if only error detection, not correction, is
     /// needed.
@@ -430,7 +505,7 @@ impl Fec {
     /// This function is multithreaded and uses rayon's global thread pool.
     pub fn verify(
         &self,
-        open_input: impl Fn() -> io::Result<Box<dyn ReadSeek>> + Sync,
+        input: &(dyn ReadSeekReopen + Sync),
         fec: &[u8],
         cancel_signal: &AtomicBool,
     ) -> Result<()> {
@@ -448,7 +523,7 @@ impl Fec {
             .map(|(round, buf)| -> Result<()> {
                 stream::check_cancel(cancel_signal)?;
 
-                let reader = open_input()?;
+                let reader = input.reopen_boxed()?;
                 self.verify_one_round(reader, round as u64, buf)
             })
             .collect::<Result<()>>()?;
@@ -469,8 +544,8 @@ impl Fec {
     /// This function is multithreaded and uses rayon's global thread pool.
     pub fn repair(
         &self,
-        open_input: impl Fn() -> io::Result<Box<dyn ReadSeek>> + Sync,
-        open_output: impl Fn() -> io::Result<Box<dyn WriteSeek>> + Sync,
+        input: &(dyn ReadSeekReopen + Sync),
+        output: &(dyn WriteSeekReopen + Sync),
         fec: &[u8],
         cancel_signal: &AtomicBool,
     ) -> Result<u64> {
@@ -489,8 +564,8 @@ impl Fec {
             .map(|(round, buf)| -> Result<u64> {
                 stream::check_cancel(cancel_signal)?;
 
-                let reader = open_input()?;
-                let writer = open_output()?;
+                let reader = input.reopen_boxed()?;
+                let writer = output.reopen_boxed()?;
                 self.repair_one_round(reader, writer, round as u64, buf)
             })
             .collect::<Result<Vec<u64>>>()?
@@ -515,7 +590,7 @@ pub struct FecImage {
 
 impl fmt::Debug for FecImage {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Fec")
+        f.debug_struct("FecImage")
             .field("fec", &NumBytes(self.fec.len()))
             .field("data_size", &self.data_size)
             .field("parity", &self.parity)
@@ -527,16 +602,16 @@ impl FecImage {
     /// Generate FEC data for a file. `parity` is the number of parity bytes per
     /// 255-byte Reed-Solomon codeword.
     pub fn generate(
-        open_input: impl Fn() -> io::Result<Box<dyn ReadSeek>> + Sync,
+        input: &(dyn ReadSeekReopen + Sync),
         parity: u8,
         cancel_signal: &AtomicBool,
     ) -> Result<Self> {
         let data_size = {
-            let mut file = open_input()?;
+            let mut file = input.reopen_boxed()?;
             file.seek(SeekFrom::End(0))?
         };
         let fec = Fec::new(data_size, FEC_BLOCK_SIZE as u32, parity)?;
-        let fec_data = fec.generate(open_input, cancel_signal)?;
+        let fec_data = fec.generate(input, cancel_signal)?;
 
         Ok(Self {
             fec: fec_data,
@@ -545,15 +620,26 @@ impl FecImage {
         })
     }
 
+    /// Update FEC data coreesponding to the specified file ranges.
+    pub fn update(
+        &mut self,
+        input: &(dyn ReadSeekReopen + Sync),
+        ranges: &[Range<u64>],
+        cancel_signal: &AtomicBool,
+    ) -> Result<()> {
+        let fec = Fec::new(self.data_size, FEC_BLOCK_SIZE as u32, self.parity)?;
+        fec.update(input, ranges, &mut self.fec, cancel_signal)
+    }
+
     /// Check that a file contains no errors. This is significantly faster than
     /// [`Self::repair()`] if performing a repair is not necessary.
     pub fn verify(
         &self,
-        open_input: impl Fn() -> io::Result<Box<dyn ReadSeek>> + Sync,
+        input: &(dyn ReadSeekReopen + Sync),
         cancel_signal: &AtomicBool,
     ) -> Result<()> {
         let fec = Fec::new(self.data_size, FEC_BLOCK_SIZE as u32, self.parity)?;
-        fec.verify(open_input, &self.fec, cancel_signal)
+        fec.verify(input, &self.fec, cancel_signal)
     }
 
     /// Repair a file using this instance's FEC data. The maximum correctable
@@ -573,12 +659,12 @@ impl FecImage {
     /// that multiple threads will always read and write disjoint file offsets.
     pub fn repair(
         &self,
-        open_input: impl Fn() -> io::Result<Box<dyn ReadSeek>> + Sync,
-        open_output: impl Fn() -> io::Result<Box<dyn WriteSeek>> + Sync,
+        input: &(dyn ReadSeekReopen + Sync),
+        output: &(dyn WriteSeekReopen + Sync),
         cancel_signal: &AtomicBool,
     ) -> Result<u64> {
         let fec = Fec::new(self.data_size, FEC_BLOCK_SIZE as u32, self.parity)?;
-        fec.repair(open_input, open_output, &self.fec, cancel_signal)
+        fec.repair(input, output, &self.fec, cancel_signal)
     }
 
     /// Build one instance of the FEC header. The caller is responsible for
@@ -588,7 +674,7 @@ impl FecImage {
             .fec
             .len()
             .to_u32()
-            .ok_or_else(|| Error::IntegerTooLarge("fec_size"))?;
+            .ok_or_else(|| Error::FieldOutOfBounds("fec_size"))?;
 
         let mut writer = Cursor::new([0u8; FEC_HEADER_SIZE]);
 
@@ -649,12 +735,12 @@ impl<R: Read> FromReader<R> for FecImage {
         let parity = header_reader
             .read_u32::<LittleEndian>()?
             .to_u8()
-            .ok_or_else(|| Error::IntegerTooLarge("parity"))?;
+            .ok_or_else(|| Error::FieldOutOfBounds("parity"))?;
 
         let fec_size = header_reader
             .read_u32::<LittleEndian>()?
             .to_usize()
-            .ok_or_else(|| Error::IntegerTooLarge("fec_size"))?;
+            .ok_or_else(|| Error::FieldOutOfBounds("fec_size"))?;
         let actual_fec_size = fec.len() - FEC_BLOCK_SIZE;
         if fec_size != actual_fec_size {
             return Err(Error::InvalidHeaderFecSize {
@@ -716,6 +802,31 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn rounds_for_ranges() {
+        let size = 2 * 253 * 4096;
+        let fec = Fec::new(size, 4096, 2).unwrap();
+
+        assert_eq!(fec.rounds_for_ranges(&[0..0]).unwrap(), HashSet::new());
+        assert_eq!(
+            fec.rounds_for_ranges(&[0..size]).unwrap(),
+            HashSet::from([0, 1]),
+        );
+        assert_eq!(fec.rounds_for_ranges(&[0..1]).unwrap(), HashSet::from([0]));
+        assert_eq!(
+            fec.rounds_for_ranges(&[4095..4096]).unwrap(),
+            HashSet::from([0]),
+        );
+        assert_eq!(
+            fec.rounds_for_ranges(&[4095..4097]).unwrap(),
+            HashSet::from([0, 1]),
+        );
+        assert_eq!(
+            fec.rounds_for_ranges(&[size - 1..size]).unwrap(),
+            HashSet::from([1]),
+        );
+    }
+
     fn corrupt_byte(file: &mut SharedCursor, offset: u64) {
         let mut buf = [0u8; 1];
 
@@ -749,18 +860,15 @@ mod tests {
         let num_codewords = fec.rounds as usize * block_size as usize;
 
         // Generate FEC data.
-        let fec_data = fec
-            .generate(|| Ok(Box::new(file.reopen())), &cancel_signal)
-            .unwrap();
+        let fec_data = fec.generate(&file, &cancel_signal).unwrap();
 
         // Verify that there are no errors.
-        fec.verify(|| Ok(Box::new(file.reopen())), &fec_data, &cancel_signal)
-            .unwrap();
+        fec.verify(&file, &fec_data, &cancel_signal).unwrap();
 
         // Verify that errors are detected.
         corrupt_byte(&mut file, 0);
         assert_matches!(
-            fec.verify(|| Ok(Box::new(file.reopen())), &fec_data, &cancel_signal,),
+            fec.verify(&file, &fec_data, &cancel_signal),
             Err(Error::HasErrors)
         );
 
@@ -769,14 +877,10 @@ mod tests {
             corrupt_byte(&mut file, offset as u64);
         }
 
-        // Verify that all the single-byte errors can be fixed.
-        fec.repair(
-            || Ok(Box::new(file.reopen())),
-            || Ok(Box::new(file.reopen())),
-            &fec_data,
-            &cancel_signal,
-        )
-        .unwrap();
+        // Verify that all the single-byte errors can be fixed. We don't test
+        // for Error::TooManyErrors because of the chance of false positives due
+        // to the nature of RS.
+        fec.repair(&file, &file, &fec_data, &cancel_signal).unwrap();
 
         let repaired_digest = {
             let mut buf = Vec::new();
@@ -786,12 +890,17 @@ mod tests {
         };
         assert_eq!(repaired_digest.as_ref(), orig_digest.as_ref());
 
-        // We don't test for Error::TooManyErrors because of the chance of false
-        // positives due to the nature of RS.
+        // Intentionally update some data.
+        corrupt_byte(&mut file, 0);
+        let mut fec_data_updated = fec_data.clone();
+        let fec_data = fec.generate(&file, &cancel_signal).unwrap();
+        fec.update(&file, &[0..1], &mut fec_data_updated, &cancel_signal)
+            .unwrap();
+        assert_eq!(fec_data_updated, fec_data);
     }
 
     #[test]
-    fn generate_verify_repair() {
+    fn generate_update_verify_repair() {
         for block_size in [1, 2, 4, 8, 16, 32, 64] {
             for rs_k in verityrs::FN_ENCODE.keys() {
                 println!("Testing block_size={block_size}, rs_k={rs_k}");
@@ -811,7 +920,7 @@ mod tests {
             file.write_all(&buf).unwrap();
         }
 
-        let image = FecImage::generate(|| Ok(Box::new(file.reopen())), 2, &cancel_signal).unwrap();
+        let image = FecImage::generate(&file, 2, &cancel_signal).unwrap();
 
         let mut fec_file = Cursor::new(Vec::new());
         image.to_writer(&mut fec_file).unwrap();

avbroot/src/format/hashtree.rs

@@ -0,0 +1,744 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+use std::{
+    fmt,
+    io::{self, Cursor, Read, SeekFrom, Write},
+    ops::Range,
+    sync::atomic::AtomicBool,
+};
+
+use bstr::ByteSlice;
+use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+use num_traits::ToPrimitive;
+use rayon::{
+    iter::{IndexedParallelIterator, ParallelIterator},
+    slice::ParallelSliceMut,
+};
+use ring::digest::{Algorithm, Context};
+use thiserror::Error;
+
+use crate::{
+    format::{avb, padding},
+    stream::{self, FromReader, ReadSeekReopen, ReadStringExt, ToWriter, WriteStringExt},
+    util::{self, NumBytes},
+};
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Hash tree should have size {expected} for input size {input}, but has size {actual}")]
+    InvalidHashTreeSize {
+        input: u64,
+        expected: usize,
+        actual: usize,
+    },
+    #[error("Expected root digest {expected}, but have {actual}")]
+    InvalidRootDigest { expected: String, actual: String },
+    #[error("Expected hash tree {expected}, but have {actual}")]
+    InvalidHashTree { expected: String, actual: String },
+    #[error("Invalid hash tree header magic: {:?}", .0.as_bstr())]
+    InvalidHeaderMagic([u8; 16]),
+    #[error("Invalid hash tree header version: {0}")]
+    InvalidHeaderVersion(u16),
+    #[error("Hashing algorithm not supported: {0:?}")]
+    UnsupportedHashAlgorithm(String),
+    #[error("{0:?} field is out of bounds")]
+    FieldOutOfBounds(&'static str),
+    #[error("I/O error")]
+    Io(#[from] io::Error),
+}
+
+type Result<T> = std::result::Result<T, Error>;
+
+pub struct HashTree {
+    block_size: u32,
+    salted_context: Context,
+}
+
+impl HashTree {
+    pub fn new(block_size: u32, algorithm: &'static Algorithm, salt: &[u8]) -> Self {
+        let mut salted_context = Context::new(algorithm);
+        salted_context.update(salt);
+
+        Self {
+            block_size,
+            salted_context,
+        }
+    }
+
+    /// Compute the list of offset ranges that each level occupies in the hash
+    /// tree data. The items are returned with the bottom level's offsets first
+    /// in the list. Note that the bottom level is stored at the end of the hash
+    /// tree data.
+    pub fn compute_level_offsets(&self, image_size: u64) -> Result<Vec<Range<usize>>> {
+        let algorithm = self.salted_context.algorithm();
+        let digest_size = algorithm.output_len().next_power_of_two();
+        let mut ranges = vec![];
+        let mut level_size = image_size;
+
+        while level_size > u64::from(self.block_size) {
+            let blocks = level_size.div_ceil(u64::from(self.block_size));
+            level_size = blocks
+                .checked_mul(digest_size as u64)
+                .and_then(|s| padding::round(s, u64::from(self.block_size)))
+                .ok_or_else(|| Error::FieldOutOfBounds("level_size"))?;
+
+            // Depending on the chosen block size, the original file size could
+            // overflow a usize without the first level's size doing the same.
+            let level_size_usize = level_size
+                .to_usize()
+                .ok_or_else(|| Error::FieldOutOfBounds("level_size"))?;
+
+            ranges.push(0..level_size_usize);
+        }
+
+        // The hash tree puts the leaves at the end.
+        let mut offset = 0;
+        for range in ranges.iter_mut().rev() {
+            let level_size = range.end - range.start;
+            range.start += offset;
+            range.end += offset;
+            offset += level_size;
+        }
+
+        Ok(ranges)
+    }
+
+    /// Convert a list of ranges of byte offsets to a sorted, non-overlapping
+    /// list of block ranges.
+    fn blocks_for_ranges(&self, image_size: u64, ranges: &[Range<u64>]) -> Result<Vec<Range<u64>>> {
+        let ranges = util::merge_overlapping(ranges);
+        if let Some(last) = ranges.last() {
+            if last.end > image_size {
+                return Err(Error::FieldOutOfBounds("ranges"));
+            }
+        }
+
+        let block_size = u64::from(self.block_size);
+        let mut result = Vec::new();
+
+        for range in ranges {
+            let start_block = range.start / block_size;
+            let end_block = if range.end % block_size == 0 {
+                range.end / block_size
+            } else {
+                range.end.div_ceil(block_size)
+            };
+
+            result.push(start_block..end_block);
+        }
+
+        Ok(util::merge_overlapping(&result))
+    }
+
+    /// Calculate the hash tree digests for a single level of the tree. If the
+    /// reader's position is block-aligned and `image_size` is a multiple of the
+    /// block size, then this function can also be used to calculate the digests
+    /// for a portion of a level.
+    fn hash_partial_level(
+        &self,
+        mut reader: impl Read,
+        mut size: u64,
+        mut level_data: &mut [u8],
+        cancel_signal: &AtomicBool,
+    ) -> io::Result<()> {
+        // Each digest must be a power of 2.
+        let algorithm = self.salted_context.algorithm();
+        let digest_padding = algorithm.output_len().next_power_of_two() - algorithm.output_len();
+        let mut buf = vec![0u8; self.block_size as usize];
+
+        while size > 0 {
+            stream::check_cancel(cancel_signal)?;
+
+            let n = size.min(buf.len() as u64) as usize;
+            reader.read_exact(&mut buf[..n])?;
+
+            // For undersized blocks, we still hash the whole buffer, except
+            // with padding.
+            buf[n..].fill(0);
+
+            let mut context = self.salted_context.clone();
+            context.update(&buf);
+
+            // Add the digest to the tree level. Each tree node must be a power
+            // of two.
+            let digest = context.finish();
+
+            level_data[..digest.as_ref().len()].copy_from_slice(digest.as_ref());
+            level_data = &mut level_data[digest.as_ref().len()..];
+
+            level_data[..digest_padding].fill(0);
+            level_data = &mut level_data[digest_padding..];
+
+            size -= n as u64;
+        }
+
+        Ok(())
+    }
+
+    /// Hash one full level in parallel.
+    fn hash_one_level_parallel(
+        &self,
+        input: &(dyn ReadSeekReopen + Sync),
+        size: u64,
+        level_data: &mut [u8],
+        cancel_signal: &AtomicBool,
+    ) -> io::Result<()> {
+        assert!(
+            size > self.block_size as u64,
+            "Images smaller than block size must use a normal hash",
+        );
+
+        // Parallelize in larger chunks to avoid too much seek thrashing.
+        let algorithm = self.salted_context.algorithm();
+        let digest_size = algorithm.output_len().next_power_of_two();
+        let multiplier = 1024u64;
+
+        level_data
+            .par_chunks_mut(digest_size * multiplier as usize)
+            .enumerate()
+            .map(|(chunk, out_data)| -> io::Result<()> {
+                let digests = out_data.len() / digest_size;
+                let in_start = (chunk as u64) * multiplier * u64::from(self.block_size);
+                let in_size = ((digests as u64) * u64::from(self.block_size)).min(size - in_start);
+
+                let mut reader = input.reopen_boxed()?;
+                reader.seek(SeekFrom::Start(in_start))?;
+
+                self.hash_partial_level(reader, in_size, out_data, cancel_signal)
+            })
+            .collect::<io::Result<()>>()?;
+
+        Ok(())
+    }
+
+    /// Update parts of the hash tree level corresponding to the specified
+    /// blocks.
+    fn hash_partial_level_parallel(
+        &self,
+        input: &(dyn ReadSeekReopen + Sync),
+        size: u64,
+        block_ranges: &[Range<u64>],
+        level_data: &mut [u8],
+        cancel_signal: &AtomicBool,
+    ) -> io::Result<()> {
+        let algorithm = self.salted_context.algorithm();
+        let digest_size = algorithm.output_len().next_power_of_two();
+
+        level_data
+            .par_chunks_exact_mut(digest_size)
+            .enumerate()
+            .filter(|(chunk, _)| util::ranges_contains(block_ranges, &(*chunk as u64)))
+            .map(|(chunk, out_data)| -> io::Result<()> {
+                let in_start = (chunk as u64) * u64::from(self.block_size);
+                let in_size = u64::from(self.block_size).min(size - in_start);
+
+                let mut reader = input.reopen_boxed()?;
+                reader.seek(SeekFrom::Start(in_start))?;
+
+                self.hash_partial_level(reader, in_size, out_data, cancel_signal)
+            })
+            .collect::<io::Result<()>>()?;
+
+        Ok(())
+    }
+
+    /// Compute the hash tree and return the root digest. If `ranges` is
+    /// specified, then only the input file blocks containing those ranges are
+    /// recomputed.
+    ///
+    /// `hash_tree_data` must match `level_offsets`. In other words, the ending
+    /// offset of the leaf layer of the tree must equal `hash_tree_data`'s size.
+    fn calculate(
+        &self,
+        input: &(dyn ReadSeekReopen + Sync),
+        image_size: u64,
+        ranges: Option<&[Range<u64>]>,
+        level_offsets: &[Range<usize>],
+        hash_tree_data: &mut [u8],
+        cancel_signal: &AtomicBool,
+    ) -> Result<Vec<u8>> {
+        // Small files are hashed directly.
+        if image_size <= u64::from(self.block_size) {
+            let mut reader = input.reopen_boxed()?;
+            let mut buf = vec![0u8; image_size as usize];
+            reader.read_exact(&mut buf)?;
+
+            let mut context = self.salted_context.clone();
+            context.update(&buf);
+            let digest = context.finish();
+
+            return Ok(digest.as_ref().to_vec());
+        }
+
+        // Large files use the hash tree.
+        for (i, level_range) in level_offsets.iter().enumerate() {
+            let (front, back) = hash_tree_data.split_at_mut(level_range.end);
+            let level_data = &mut front[level_range.clone()];
+
+            if i > 0 {
+                // Hash the previous level.
+                let prev_range = level_offsets[i - 1].clone();
+                let prev_size = prev_range.end - prev_range.start;
+                let prev_data = &back[..prev_size];
+
+                self.hash_partial_level(
+                    Cursor::new(prev_data),
+                    prev_size as u64,
+                    level_data,
+                    cancel_signal,
+                )?;
+            } else if let Some(r) = ranges {
+                // Read partial blocks from file.
+                let block_ranges = self.blocks_for_ranges(image_size, r)?;
+
+                self.hash_partial_level_parallel(
+                    input,
+                    image_size,
+                    &block_ranges,
+                    level_data,
+                    cancel_signal,
+                )?;
+            } else {
+                // Read entire file.
+                self.hash_one_level_parallel(input, image_size, level_data, cancel_signal)?;
+            }
+
+            // No need to explicitly ensure the level is padded to the block
+            // size since the tree is initialized with zeros.
+        }
+
+        // Calculate the root hash.
+        let mut context = self.salted_context.clone();
+        context.update(&hash_tree_data[level_offsets.last().unwrap().clone()]);
+        let root_hash = context.finish().as_ref().to_vec();
+
+        Ok(root_hash)
+    }
+
+    /// Generate hash tree data for the file. Returns the root digest and the
+    /// hash tree data.
+    pub fn generate(
+        &self,
+        input: &(dyn ReadSeekReopen + Sync),
+        image_size: u64,
+        cancel_signal: &AtomicBool,
+    ) -> Result<(Vec<u8>, Vec<u8>)> {
+        let offsets = self.compute_level_offsets(image_size)?;
+        let hash_tree_size = offsets.first().map(|r| r.end).unwrap_or(0);
+        let mut hash_tree_data = vec![0u8; hash_tree_size];
+
+        let root_digest = self.calculate(
+            input,
+            image_size,
+            None,
+            &offsets,
+            &mut hash_tree_data,
+            cancel_signal,
+        )?;
+
+        Ok((root_digest, hash_tree_data))
+    }
+
+    /// Update hash tree data corresponding to the specified file ranges.
+    /// Returns the new root digest.
+    pub fn update(
+        &self,
+        input: &(dyn ReadSeekReopen + Sync),
+        image_size: u64,
+        ranges: &[Range<u64>],
+        hash_tree_data: &mut [u8],
+        cancel_signal: &AtomicBool,
+    ) -> Result<Vec<u8>> {
+        let offsets = self.compute_level_offsets(image_size)?;
+        let hash_tree_size = offsets.first().map(|r| r.end).unwrap_or(0);
+        if hash_tree_data.len() != hash_tree_size {
+            return Err(Error::InvalidHashTreeSize {
+                input: image_size,
+                expected: hash_tree_size,
+                actual: hash_tree_data.len(),
+            });
+        }
+
+        self.calculate(
+            input,
+            image_size,
+            Some(ranges),
+            &offsets,
+            hash_tree_data,
+            cancel_signal,
+        )
+    }
+
+    /// Verify that the file contains no errors.
+    pub fn verify(
+        &self,
+        input: &(dyn ReadSeekReopen + Sync),
+        image_size: u64,
+        root_digest: &[u8],
+        hash_tree_data: &[u8],
+        cancel_signal: &AtomicBool,
+    ) -> Result<()> {
+        let offsets = self.compute_level_offsets(image_size)?;
+        let hash_tree_size = offsets.first().map(|r| r.end).unwrap_or(0);
+        if hash_tree_data.len() != hash_tree_size {
+            return Err(Error::InvalidHashTreeSize {
+                input: image_size,
+                expected: hash_tree_size,
+                actual: hash_tree_data.len(),
+            });
+        }
+
+        let (actual_root_digest, actual_hash_tree_data) =
+            self.generate(input, image_size, cancel_signal)?;
+
+        if root_digest != actual_root_digest {
+            return Err(Error::InvalidRootDigest {
+                expected: hex::encode(root_digest),
+                actual: hex::encode(&actual_root_digest),
+            });
+        }
+
+        if hash_tree_data != actual_hash_tree_data {
+            // These are multiple megabytes, so only report the hashes.
+            let algorithm = self.salted_context.algorithm();
+            let expected = ring::digest::digest(algorithm, hash_tree_data);
+            let actual = ring::digest::digest(algorithm, &actual_hash_tree_data);
+
+            return Err(Error::InvalidHashTree {
+                expected: hex::encode(expected),
+                actual: hex::encode(actual),
+            });
+        }
+
+        Ok(())
+    }
+}
+
+/// A type for reading and writing a custom hash tree image format.
+///
+/// File format:
+/// - [0  .. 16]   - ASCII  - "avbroot!hashtree"
+/// - [16 .. 18]   - U16LE  - Version
+/// - [18 .. 26]   - U64LE  - Image size
+/// - [26 .. 30]   - U32LE  - Block size
+/// - [30 .. 46]   - ASCII  - Hash algorithm
+/// - [46 .. 48]   - U16LE  - Salt size
+/// - [48 .. 50]   - U16LE  - Root digest size
+/// - [50 .. 54]   - U32LE  - Hash tree size
+/// - [<variable>] - BINARY - Salt
+/// - [<variable>] - BINARY - Root digest
+/// - [<variable>] - BINARY - Hash tree
+#[derive(Clone, PartialEq, Eq)]
+pub struct HashTreeImage {
+    pub image_size: u64,
+    pub block_size: u32,
+    pub algorithm: String,
+    pub salt: Vec<u8>,
+    pub root_digest: Vec<u8>,
+    pub hash_tree: Vec<u8>,
+}
+
+impl fmt::Debug for HashTreeImage {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("HashTreeImage")
+            .field("block_size", &self.block_size)
+            .field("algorithm", &self.algorithm)
+            .field("salt", &hex::encode(&self.salt))
+            .field("root_digest", &hex::encode(&self.root_digest))
+            .field("hash_tree", &NumBytes(self.hash_tree.len()))
+            .finish()
+    }
+}
+
+impl HashTreeImage {
+    const MAGIC: &'static [u8; 16] = b"avbroot!hashtree";
+    const VERSION: u16 = 1;
+
+    pub fn ring_algorithm(name: &str) -> Result<&'static Algorithm> {
+        avb::ring_algorithm(name, false)
+            .map_err(|_| Error::UnsupportedHashAlgorithm(name.to_owned()))
+    }
+
+    /// Generate hash tree data for a file.
+    pub fn generate(
+        input: &(dyn ReadSeekReopen + Sync),
+        block_size: u32,
+        algorithm: &str,
+        salt: &[u8],
+        cancel_signal: &AtomicBool,
+    ) -> Result<Self> {
+        let image_size = {
+            let mut file = input.reopen_boxed()?;
+            file.seek(SeekFrom::End(0))?
+        };
+        let ring_algorithm = Self::ring_algorithm(algorithm)?;
+        let hash_tree = HashTree::new(block_size, ring_algorithm, salt);
+        let (root_digest, hash_tree_data) = hash_tree.generate(input, image_size, cancel_signal)?;
+
+        Ok(Self {
+            image_size,
+            block_size,
+            algorithm: algorithm.to_owned(),
+            salt: salt.to_vec(),
+            root_digest,
+            hash_tree: hash_tree_data,
+        })
+    }
+
+    /// Update hash tree data coreesponding to the specified file ranges.
+    pub fn update(
+        &mut self,
+        input: &(dyn ReadSeekReopen + Sync),
+        ranges: &[Range<u64>],
+        cancel_signal: &AtomicBool,
+    ) -> Result<()> {
+        let ring_algorithm = Self::ring_algorithm(&self.algorithm)?;
+        let hash_tree = HashTree::new(self.block_size, ring_algorithm, &self.salt);
+
+        self.root_digest = hash_tree.update(
+            input,
+            self.image_size,
+            ranges,
+            &mut self.hash_tree,
+            cancel_signal,
+        )?;
+
+        Ok(())
+    }
+
+    /// Check that a file contains no errors.
+    pub fn verify(
+        &self,
+        input: &(dyn ReadSeekReopen + Sync),
+        cancel_signal: &AtomicBool,
+    ) -> Result<()> {
+        let ring_algorithm = Self::ring_algorithm(&self.algorithm)?;
+        let hash_tree = HashTree::new(self.block_size, ring_algorithm, &self.salt);
+
+        hash_tree.verify(
+            input,
+            self.image_size,
+            &self.root_digest,
+            &self.hash_tree,
+            cancel_signal,
+        )
+    }
+}
+
+impl<R: Read> FromReader<R> for HashTreeImage {
+    type Error = Error;
+
+    fn from_reader(mut reader: R) -> Result<Self> {
+        let mut magic = [0u8; 16];
+        reader.read_exact(&mut magic)?;
+        if magic != *Self::MAGIC {
+            return Err(Error::InvalidHeaderMagic(magic));
+        }
+
+        let version = reader.read_u16::<LittleEndian>()?;
+        if version != Self::VERSION {
+            return Err(Error::InvalidHeaderVersion(version));
+        }
+
+        let image_size = reader.read_u64::<LittleEndian>()?;
+        let block_size = reader.read_u32::<LittleEndian>()?;
+        let algorithm = reader.read_string_padded(16)?;
+        let salt_size = reader.read_u16::<LittleEndian>()?;
+        let root_digest_size = reader.read_u16::<LittleEndian>()?;
+        let hash_tree_size = reader
+            .read_u32::<LittleEndian>()?
+            .to_usize()
+            .ok_or_else(|| Error::FieldOutOfBounds("hash_tree_size"))?;
+
+        let mut salt = vec![0u8; usize::from(salt_size)];
+        reader.read_exact(&mut salt)?;
+
+        let mut root_digest = vec![0u8; usize::from(root_digest_size)];
+        reader.read_exact(&mut root_digest)?;
+
+        let mut hash_tree = vec![0u8; hash_tree_size];
+        reader.read_exact(&mut hash_tree)?;
+
+        Ok(Self {
+            image_size,
+            block_size,
+            algorithm,
+            salt,
+            root_digest,
+            hash_tree,
+        })
+    }
+}
+
+impl<W: Write> ToWriter<W> for HashTreeImage {
+    type Error = Error;
+
+    fn to_writer(&self, mut writer: W) -> Result<()> {
+        let salt_size = self
+            .salt
+            .len()
+            .to_u16()
+            .ok_or_else(|| Error::FieldOutOfBounds("salt_size"))?;
+        let root_digest_size = self
+            .root_digest
+            .len()
+            .to_u16()
+            .ok_or_else(|| Error::FieldOutOfBounds("root_digest_size"))?;
+        let hash_tree_size = self
+            .hash_tree
+            .len()
+            .to_u32()
+            .ok_or_else(|| Error::FieldOutOfBounds("hash_tree_size"))?;
+
+        writer.write_all(Self::MAGIC)?;
+        writer.write_u16::<LittleEndian>(Self::VERSION)?;
+        writer.write_u64::<LittleEndian>(self.image_size)?;
+        writer.write_u32::<LittleEndian>(self.block_size)?;
+        writer.write_string_padded(&self.algorithm, 16)?;
+        writer.write_u16::<LittleEndian>(salt_size)?;
+        writer.write_u16::<LittleEndian>(root_digest_size)?;
+        writer.write_u32::<LittleEndian>(hash_tree_size)?;
+        writer.write_all(&self.salt)?;
+        writer.write_all(&self.root_digest)?;
+        writer.write_all(&self.hash_tree)?;
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::{Seek, Write};
+
+    use assert_matches::assert_matches;
+
+    use crate::stream::SharedCursor;
+
+    use super::*;
+
+    #[test]
+    fn calculate_level_ranges() {
+        let hash_tree = HashTree::new(4096, &ring::digest::SHA256, &[]);
+        assert_eq!(
+            hash_tree.compute_level_offsets(0).unwrap(),
+            &[] as &[Range<usize>],
+        );
+        assert_eq!(
+            hash_tree.compute_level_offsets(1024 * 1024 * 1024).unwrap(),
+            &[69632..8458240, 4096..69632, 0..4096],
+        )
+    }
+
+    #[test]
+    fn blocks_for_ranges() {
+        let hash_tree = HashTree::new(4096, &ring::digest::SHA256, b"Salt");
+        assert_eq!(
+            hash_tree.blocks_for_ranges(16384, &[0..16384]).unwrap(),
+            &[0..4],
+        );
+        assert_eq!(hash_tree.blocks_for_ranges(16384, &[0..0]).unwrap(), &[]);
+        assert_eq!(
+            hash_tree
+                .blocks_for_ranges(16384, &[12287..12289, 0..1, 5000..5001])
+                .unwrap(),
+            &[0..4],
+        );
+        assert_matches!(
+            hash_tree.blocks_for_ranges(16384, &[0..16385]),
+            Err(Error::FieldOutOfBounds(_))
+        );
+    }
+
+    #[test]
+    fn generate_update_verify() {
+        let cancel_signal = AtomicBool::new(false);
+        let hash_tree = HashTree::new(64, &ring::digest::SHA256, b"Salt");
+        let mut input = SharedCursor::new();
+
+        // Try input smaller than one block.
+        let (root_digest, hash_tree_data) = hash_tree.generate(&input, 0, &cancel_signal).unwrap();
+
+        assert_eq!(
+            root_digest,
+            &[
+                0x15, 0x0f, 0xe5, 0x51, 0x40, 0x30, 0xb1, 0x43, 0x4a, 0x5d, 0xea, 0xf4, 0x91, 0xec,
+                0xe9, 0x2c, 0x0e, 0x64, 0x97, 0x44, 0x7d, 0x6d, 0xe7, 0xbd, 0x6b, 0xa8, 0x5e, 0x8c,
+                0xae, 0x1e, 0x00, 0xa3
+            ],
+        );
+        assert_eq!(hash_tree_data, &[]);
+
+        // Try larger input that spans multiple blocks are results in an actual
+        // hash tree being created.
+        input.write_all(&b"Data".repeat(25)).unwrap();
+
+        let (root_digest, mut hash_tree_data) =
+            hash_tree.generate(&input, 100, &cancel_signal).unwrap();
+        assert_eq!(
+            root_digest,
+            &[
+                0x92, 0xc3, 0xd7, 0x4a, 0x64, 0x03, 0x4b, 0xcc, 0xa9, 0x9a, 0x44, 0xf6, 0x81, 0xa2,
+                0x4d, 0xdd, 0x97, 0xd3, 0xda, 0x84, 0xdc, 0xe2, 0x1b, 0x83, 0xd1, 0x7b, 0xab, 0x60,
+                0x59, 0xe8, 0x45, 0x59
+            ],
+        );
+        assert_eq!(
+            hash_tree_data,
+            &[
+                0x7e, 0x33, 0x47, 0xb6, 0xf3, 0x7c, 0xde, 0x0e, 0xe2, 0x8d, 0x9e, 0x49, 0x8e, 0xd4,
+                0xbd, 0x53, 0x3a, 0xa1, 0xff, 0xeb, 0x4f, 0x6d, 0x5a, 0x5f, 0x55, 0x28, 0x37, 0x79,
+                0xd0, 0x25, 0x07, 0xd5, 0xb7, 0x7f, 0x1a, 0x48, 0x92, 0x12, 0x91, 0xdb, 0x92, 0x04,
+                0x74, 0xf6, 0x86, 0x31, 0xfc, 0x64, 0xb6, 0xc8, 0x72, 0xb0, 0xf7, 0x7d, 0x24, 0xa4,
+                0x3c, 0x87, 0x1f, 0xc9, 0xd8, 0x17, 0x8a, 0xd9
+            ],
+        );
+
+        // Change some data and update the hash tree.
+        input.rewind().unwrap();
+        input.write_all(b"Changed").unwrap();
+
+        let root_digest = hash_tree
+            .update(&input, 100, &[0..7], &mut hash_tree_data, &cancel_signal)
+            .unwrap();
+        assert_eq!(
+            root_digest,
+            &[
+                0x8d, 0x03, 0xad, 0x18, 0xf2, 0x53, 0x13, 0x59, 0xf5, 0xbf, 0x68, 0x0e, 0x0c, 0x4a,
+                0x86, 0xe2, 0x6e, 0xaa, 0x3d, 0x4b, 0x0f, 0x1b, 0x57, 0xad, 0x92, 0xe7, 0xbf, 0x3e,
+                0xa6, 0xb1, 0x2e, 0xcc
+            ],
+        );
+        assert_eq!(
+            hash_tree_data,
+            &[
+                0xfe, 0x46, 0xf7, 0x8c, 0xa1, 0xd9, 0xc8, 0xdd, 0x47, 0x9e, 0x6c, 0x32, 0x7c, 0x38,
+                0x7f, 0x09, 0xe1, 0x58, 0x92, 0xa3, 0xb6, 0xbd, 0x96, 0xef, 0x10, 0xe8, 0x30, 0xb0,
+                0x37, 0x8d, 0xef, 0x9a, 0xb7, 0x7f, 0x1a, 0x48, 0x92, 0x12, 0x91, 0xdb, 0x92, 0x04,
+                0x74, 0xf6, 0x86, 0x31, 0xfc, 0x64, 0xb6, 0xc8, 0x72, 0xb0, 0xf7, 0x7d, 0x24, 0xa4,
+                0x3c, 0x87, 0x1f, 0xc9, 0xd8, 0x17, 0x8a, 0xd9
+            ],
+        );
+
+        // Updated hash tree should match newly generated tree.
+        let (new_root_digest, new_hash_tree_data) =
+            hash_tree.generate(&input, 100, &cancel_signal).unwrap();
+        assert_eq!(new_root_digest, root_digest);
+        assert_eq!(new_hash_tree_data, hash_tree_data);
+
+        // Data should validate successfully.
+        hash_tree
+            .verify(&input, 100, &root_digest, &hash_tree_data, &cancel_signal)
+            .unwrap();
+
+        // But not if the data is corrupted.
+        input.rewind().unwrap();
+        input.write_all(b"Bad").unwrap();
+
+        hash_tree
+            .verify(&input, 100, &root_digest, &hash_tree_data, &cancel_signal)
+            .unwrap_err();
+    }
+}

avbroot/src/format/mod.rs

@@ -8,6 +8,7 @@ pub mod bootimage;
 pub mod compression;
 pub mod cpio;
 pub mod fec;
+pub mod hashtree;
 pub mod ota;
 pub mod padding;
 pub mod payload;

avbroot/src/format/ota.rs

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2023 Andrew Gunnerson
+ * SPDX-FileCopyrightText: 2022-2024 Andrew Gunnerson
  * SPDX-License-Identifier: GPL-3.0-only
  */
 
@@ -13,6 +13,7 @@ use std::{
 use cms::signed_data::SignedData;
 use const_oid::{db::rfc5912, ObjectIdentifier};
 use memchr::memmem;
+use prost::Message;
 use ring::digest::Context;
 use rsa::{Pkcs1v15Sign, RsaPrivateKey};
 use sha1::Sha1;
@@ -24,9 +25,8 @@ use zip::{result::ZipError, write::FileOptions, CompressionMethod, ZipArchive, Z
 use crate::{
     crypto,
     format::payload::{self, PayloadHeader},
-    protobuf::build::tools::releasetools::{mod_OtaMetadata::OtaType, OtaMetadata},
+    protobuf::build::tools::releasetools::{ota_metadata::OtaType, OtaMetadata},
     stream::{self, FromReader, HashingReader, HashingWriter},
-    util,
 };
 
 pub const PATH_METADATA: &str = "META-INF/com/android/metadata";
@@ -40,10 +40,12 @@ const NAME_PAYLOAD_METADATA: &str = "payload_metadata.bin";
 pub const PF_NAME: &str = "ota-property-files";
 pub const PF_STREAMING_NAME: &str = "ota-streaming-property-files";
 
-const ZIP_EOCD_MAGIC: &[u8; 4] = b"PK\x05\x06";
+pub const ZIP_EOCD_MAGIC: &[u8; 4] = b"PK\x05\x06";
 
 const COMMENT_MESSAGE: &[u8] = b"signed by avbroot\0";
 
+const LEGACY_SEP: &str = "|";
+
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("Cannot find OTA signature footer magic")]
@@ -64,6 +66,10 @@ pub enum Error {
     UnsupportedDigestAlgorithm(ObjectIdentifier),
     #[error("Unsupported signature algorithm: {0}")]
     UnsupportedSignatureAlgorithm(ObjectIdentifier),
+    #[error("Invalid legacy metadata line: {0:?}")]
+    InvalidLegacyMetadataLine(String),
+    #[error("Unsupported legacy metadata field: {key:?} = {value:?}")]
+    UnsupportedLegacyMetadataField { key: String, value: String },
     #[error("Expected entry offsets {expected:?}, but have {actual:?}")]
     MismatchedPropertyFiles { expected: String, actual: String },
     #[error("Property files {0:?} exceed {1} byte reserved space")]
@@ -76,8 +82,8 @@ pub enum Error {
     CmsSign(#[from] crypto::Error),
     #[error("Payload error")]
     Payload(#[from] payload::Error),
-    #[error("Protobuf error")]
-    Protobuf(#[from] quick_protobuf::Error),
+    #[error("Failed to decode protobuf message")]
+    ProtobufDecode(#[from] prost::DecodeError),
     #[error("SPKI error")]
     Spki(#[from] pkcs8::spki::Error),
     #[error("x509 DER error")]
@@ -92,21 +98,111 @@ pub enum Error {
 
 type Result<T> = std::result::Result<T, Error>;
 
+pub fn parse_protobuf_metadata(data: &[u8]) -> Result<OtaMetadata> {
+    Ok(OtaMetadata::decode(data)?)
+}
+
+/// Synthesize protobuf structure from legacy plain-text metadata.
+pub fn parse_legacy_metadata(data: &str) -> Result<OtaMetadata> {
+    let mut metadata = OtaMetadata::default();
+
+    for line in data.split('\n') {
+        if line.is_empty() {
+            continue;
+        }
+
+        let (key, value) = line
+            .split_once('=')
+            .ok_or_else(|| Error::InvalidLegacyMetadataLine(line.to_owned()))?;
+        let unsupported = || Error::UnsupportedLegacyMetadataField {
+            key: key.to_owned(),
+            value: value.to_owned(),
+        };
+        // Booleans are represented by the presence or absence of `<key>=yes`.
+        let parse_yes = || match value {
+            "yes" => Ok(true),
+            _ => Err(unsupported()),
+        };
+        let parse_list = || {
+            value
+                .split(LEGACY_SEP)
+                .map(|s| s.to_owned())
+                .collect::<Vec<_>>()
+        };
+
+        match key {
+            "ota-type" => {
+                match OtaType::from_str_name(value).ok_or_else(unsupported)? {
+                    t @ (OtaType::Ab | OtaType::Block) => metadata.set_type(t),
+                    // Not allowed by AOSP in the legacy format.
+                    _ => return Err(unsupported()),
+                }
+            }
+            "ota-wipe" => metadata.wipe = parse_yes()?,
+            "ota-retrofit-dynamic-partitions" => {
+                metadata.retrofit_dynamic_partitions = parse_yes()?
+            }
+            "ota-downgrade" => metadata.downgrade = parse_yes()?,
+            "ota-required-cache" => {
+                metadata.required_cache = value.parse().map_err(|_| unsupported())?;
+            }
+            "post-build" => {
+                let p = metadata.postcondition.get_or_insert_with(Default::default);
+                p.build = parse_list();
+            }
+            "post-build-incremental" => {
+                let p = metadata.postcondition.get_or_insert_with(Default::default);
+                value.clone_into(&mut p.build_incremental);
+            }
+            "post-sdk-level" => {
+                let p = metadata.postcondition.get_or_insert_with(Default::default);
+                value.clone_into(&mut p.sdk_level);
+            }
+            "post-security-patch-level" => {
+                let p = metadata.postcondition.get_or_insert_with(Default::default);
+                value.clone_into(&mut p.security_patch_level);
+            }
+            "post-timestamp" => {
+                let p = metadata.postcondition.get_or_insert_with(Default::default);
+                p.timestamp = value.parse().map_err(|_| unsupported())?;
+            }
+            "pre-device" => {
+                let p = metadata.precondition.get_or_insert_with(Default::default);
+                p.device = parse_list();
+            }
+            "pre-build" => {
+                let p = metadata.precondition.get_or_insert_with(Default::default);
+                p.build = parse_list();
+            }
+            "pre-build-incremental" => {
+                let p = metadata.precondition.get_or_insert_with(Default::default);
+                value.clone_into(&mut p.build_incremental);
+            }
+            "spl-downgrade" => metadata.spl_downgrade = parse_yes()?,
+            k if k.ends_with("-property-files") => {
+                metadata
+                    .property_files
+                    .insert(key.to_owned(), value.to_owned());
+            }
+            _ => {
+                // Ignore. Some OEMs insert values that aren't defined in AOSP.
+            }
+        }
+    }
+
+    Ok(metadata)
+}
+
 /// Generate the legacy plain-text and modern protobuf serializations of the
 /// given metadata instance.
 fn serialize_metadata(metadata: &OtaMetadata) -> Result<(String, Vec<u8>)> {
-    const SEP: &str = "|";
+    use std::fmt::Write;
 
     let mut pairs = BTreeMap::<String, String>::new();
 
-    match metadata.type_pb {
-        OtaType::AB => {
-            pairs.insert("ota-type".to_owned(), "AB".to_owned());
-        }
-        OtaType::BLOCK => {
-            pairs.insert("ota-type".to_owned(), "BLOCK".to_owned());
-        }
-        _ => {}
+    // Other types are not allowed by AOSP in the legacy format.
+    if let t @ (OtaType::Ab | OtaType::Block) = metadata.r#type() {
+        pairs.insert("ota-type".to_owned(), t.as_str_name().to_owned());
     }
     if metadata.wipe {
         pairs.insert("ota-wipe".to_owned(), "yes".to_owned());
@@ -127,7 +223,7 @@ fn serialize_metadata(metadata: &OtaMetadata) -> Result<(String, Vec<u8>)> {
     );
 
     if let Some(p) = &metadata.postcondition {
-        pairs.insert("post-build".to_owned(), p.build.join(SEP));
+        pairs.insert("post-build".to_owned(), p.build.join(LEGACY_SEP));
         pairs.insert(
             "post-build-incremental".to_owned(),
             p.build_incremental.clone(),
@@ -141,9 +237,9 @@ fn serialize_metadata(metadata: &OtaMetadata) -> Result<(String, Vec<u8>)> {
     }
 
     if let Some(p) = &metadata.precondition {
-        pairs.insert("pre-device".to_owned(), p.device.join(SEP));
+        pairs.insert("pre-device".to_owned(), p.device.join(LEGACY_SEP));
         if !p.build.is_empty() {
-            pairs.insert("pre-build".to_owned(), p.build.join(SEP));
+            pairs.insert("pre-build".to_owned(), p.build.join(LEGACY_SEP));
             pairs.insert(
                 "pre-build-incremental".to_owned(),
                 p.build_incremental.clone(),
@@ -157,11 +253,11 @@ fn serialize_metadata(metadata: &OtaMetadata) -> Result<(String, Vec<u8>)> {
 
     pairs.extend(metadata.property_files.clone());
 
-    let legacy_metadata = pairs
-        .into_iter()
-        .map(|(k, v)| format!("{k}={v}\n"))
-        .collect::<String>();
-    let modern_metadata = util::write_protobuf(metadata)?;
+    let legacy_metadata = pairs.into_iter().fold(String::new(), |mut output, (k, v)| {
+        let _ = writeln!(output, "{k}={v}");
+        output
+    });
+    let modern_metadata = metadata.encode_to_vec();
 
     Ok((legacy_metadata, modern_metadata))
 }
@@ -286,9 +382,9 @@ fn add_payload_metadata_entry(
 /// Add metadata files to the output OTA zip. `zip_entries` is the list of
 /// [`ZipEntry`] already written to `zip_writer`. `next_offset` is the current
 /// file offset (where the next zip entry's local header begins).
-/// `metadata_pb_raw` is the serialized OTA metadata protobuf message from the
-/// original OTA. `payload_metadata_size` is the size of the new payload's
-/// metadata and metadata signature regions.
+/// `metadata` is the OTA metadata protobuf message from the original OTA.
+/// `payload_metadata_size` is the size of the new payload's metadata and
+/// metadata signature regions.
 ///
 /// The zip file's backing file position MUST BE set to where the central
 /// directory would start.
@@ -296,10 +392,10 @@ pub fn add_metadata(
     zip_entries: &[ZipEntry],
     zip_writer: &mut ZipWriter<impl Write>,
     next_offset: u64,
-    metadata_pb_raw: &[u8],
+    metadata: &OtaMetadata,
     payload_metadata_size: u64,
 ) -> Result<OtaMetadata> {
-    let mut metadata: OtaMetadata = util::read_protobuf(metadata_pb_raw)?;
+    let mut metadata = metadata.clone();
     let options = FileOptions::default().compression_method(CompressionMethod::Stored);
 
     let mut zip_entries = zip_entries.to_owned();
@@ -521,9 +617,9 @@ pub fn parse_zip_ota_info(
 
     let metadata = {
         let mut entry = zip.by_name(PATH_METADATA_PB)?;
-        let mut buf = vec![0u8; entry.size() as usize];
-        entry.read_exact(&mut buf)?;
-        util::read_protobuf::<OtaMetadata>(&buf)?
+        let mut buf = Vec::new();
+        entry.read_to_end(&mut buf)?;
+        OtaMetadata::decode(buf.as_slice())?
     };
 
     let certificate = {

avbroot/src/format/payload.rs

@@ -6,6 +6,7 @@
 use std::{
     collections::{HashMap, HashSet},
     io::{self, Cursor, Read, Seek, SeekFrom, Write},
+    ops::Range,
     sync::atomic::AtomicBool,
 };
 
@@ -13,29 +14,32 @@ use base64::engine::general_purpose::STANDARD;
 use base64::Engine;
 use byteorder::{BigEndian, ReadBytesExt};
 use bzip2::write::BzDecoder;
+use liblzma::{
+    stream::{Check, Stream},
+    write::XzDecoder,
+    write::XzEncoder,
+};
 use num_traits::ToPrimitive;
-use quick_protobuf::MessageWrite;
-use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
+use prost::Message;
+use rayon::{
+    iter::{IndexedParallelIterator, IntoParallelRefMutIterator},
+    prelude::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator},
+};
 use ring::digest::{Context, Digest};
 use rsa::{traits::PublicKeyParts, Pkcs1v15Sign, RsaPrivateKey};
 use sha2::Sha256;
 use thiserror::Error;
 use x509_cert::Certificate;
-use xz2::{
-    stream::{Check, Stream},
-    write::XzDecoder,
-    write::XzEncoder,
-};
 
 use crate::{
     crypto,
     protobuf::chromeos_update_engine::{
-        mod_InstallOperation, mod_Signatures::Signature, DeltaArchiveManifest, Extent,
+        install_operation::Type, signatures::Signature, DeltaArchiveManifest, Extent,
         InstallOperation, PartitionInfo, PartitionUpdate, Signatures,
     },
     stream::{
-        self, CountingReader, CountingWriter, FromReader, HashingWriter, ReadDiscardExt, ReadSeek,
-        SharedCursor, WriteSeek,
+        self, CountingReader, FromReader, HashingWriter, ReadDiscardExt, ReadSeekReopen, WriteSeek,
+        WriteSeekReopen,
     },
     util,
 };
@@ -43,6 +47,8 @@ use crate::{
 const OTA_MAGIC: &[u8; 4] = b"CrAU";
 const OTA_HEADER_SIZE: usize = OTA_MAGIC.len() + 8 + 8 + 4;
 
+const MANIFEST_MAX_SIZE: usize = 4 * 1024 * 1024;
+
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("Unknown magic: {0:?}")]
@@ -66,7 +72,7 @@ pub enum Error {
         actual: String,
     },
     #[error("Unsupported partition operation: {0:?}")]
-    UnsupportedOperation(mod_InstallOperation::Type),
+    UnsupportedOperation(Type),
     #[error("Expected sha256 {expected:?}, but have {actual:?}")]
     MismatchedDigest {
         expected: Option<String>,
@@ -78,20 +84,22 @@ pub enum Error {
         size: u64,
         block_size: u32,
     },
+    #[error("Destination extents are not in order")]
+    ExtentsNotInOrder,
     #[error("Partition not found in payload: {0}")]
     MissingPartition(String),
     #[error("Partitions not found in payload: {0:?}")]
     MissingPartitions(HashSet<String>),
     #[error("{0:?} field is missing")]
     MissingField(&'static str),
-    #[error("{0:?} field exceeds integer bounds")]
-    IntegerTooLarge(&'static str),
+    #[error("{0:?} field is out of bounds")]
+    FieldOutOfBounds(&'static str),
     #[error("Crypto error")]
     Crypto(#[from] crypto::Error),
-    #[error("Protobuf error")]
-    Protobuf(#[from] quick_protobuf::Error),
+    #[error("Failed to decode protobuf message")]
+    ProtobufDecode(#[from] prost::DecodeError),
     #[error("XZ stream error")]
-    XzStream(#[from] xz2::stream::Error),
+    XzStream(#[from] liblzma::stream::Error),
     #[error("RSA error")]
     Rsa(#[from] rsa::Error),
     #[error("I/O error")]
@@ -139,12 +147,19 @@ impl<R: Read> FromReader<R> for PayloadHeader {
         let manifest_size = reader
             .read_u64::<BigEndian>()?
             .to_usize()
-            .ok_or_else(|| Error::IntegerTooLarge("manifest_size"))?;
+            .and_then(|s| {
+                if s <= MANIFEST_MAX_SIZE {
+                    Some(s)
+                } else {
+                    None
+                }
+            })
+            .ok_or_else(|| Error::FieldOutOfBounds("manifest_size"))?;
         let metadata_signature_size = reader.read_u32::<BigEndian>()?;
 
         let mut manifest_raw = vec![0u8; manifest_size];
         reader.read_exact(&mut manifest_raw)?;
-        let manifest: DeltaArchiveManifest = util::read_protobuf(&manifest_raw)?;
+        let manifest = DeltaArchiveManifest::decode(manifest_raw.as_slice())?;
 
         // Skip manifest signatures.
         reader.read_discard_exact(metadata_signature_size.into())?;
@@ -175,6 +190,7 @@ fn sign_digest(digest: &[u8], key: &RsaPrivateKey) -> Result<Signatures> {
         data: Some(digest_signed),
         // Always fits in even a u16.
         unpadded_signature_size: Some(unpadded_size as u32),
+        ..Default::default()
     };
 
     let signatures = Signatures {
@@ -320,14 +336,14 @@ impl<W: Write> PayloadWriter<W> {
             ring::digest::digest(&ring::digest::SHA256, b"").as_ref(),
             &key,
         )?;
-        let dummy_sig_size = dummy_sig.get_size();
+        let dummy_sig_size = dummy_sig.encoded_len();
 
         // Fill out the new payload signature information.
         header.manifest.signatures_offset = Some(blob_size);
         header.manifest.signatures_size = Some(dummy_sig_size as u64);
 
         // Build new manifest.
-        let manifest_raw_new = util::write_protobuf(&header.manifest)?;
+        let manifest_raw_new = header.manifest.encode_to_vec();
 
         // Excludes signatures (hashes are for signing).
         let mut h_partial = Context::new(&ring::digest::SHA256);
@@ -355,7 +371,7 @@ impl<W: Write> PayloadWriter<W> {
         // in the payload hash.
         let metadata_hash = h_partial.clone().finish();
         let metadata_sig = sign_digest(metadata_hash.as_ref(), &key)?;
-        let metadata_sig_raw = util::write_protobuf(&metadata_sig)?;
+        let metadata_sig_raw = metadata_sig.encode_to_vec();
         write_hash!(inner, [h_full], &metadata_sig_raw)?;
 
         Ok(Self {
@@ -383,7 +399,7 @@ impl<W: Write> PayloadWriter<W> {
         // Append payload signature.
         let payload_partial_hash = self.h_partial.clone().finish();
         let payload_sig = sign_digest(payload_partial_hash.as_ref(), &self.key)?;
-        let payload_sig_raw = util::write_protobuf(&payload_sig)?;
+        let payload_sig_raw = payload_sig.encode_to_vec();
         write_hash!(self.inner, [self.h_full], &payload_sig_raw)?;
 
         // Everything before the blob.
@@ -526,104 +542,6 @@ impl<W: Write> Write for PayloadWriter<W> {
     }
 }
 
-/// A writer to produce a compressed partition image suitable for directly
-/// inserting into a `payload.bin`'s blob section. The data is XZ-compressed at
-/// a low compression level, primarily to collapse zeros, and the
-/// [`PartitionUpdate`] instance is updated with the final size and hash. The
-/// entire data will be represented as a single [`InstallOperation`] and
-/// [`InstallOperation::data_offset`] will be set to `None`.
-pub struct CompressedPartitionWriter<W: Write> {
-    inner: XzEncoder<HashingWriter<CountingWriter<W>>>,
-    block_size: u32,
-    h_uncompressed: Context,
-    written: u64,
-}
-
-impl<W: Write> CompressedPartitionWriter<W> {
-    pub fn new(writer: W, block_size: u32) -> Result<Self> {
-        let counting_writer = CountingWriter::new(writer);
-        let hashing_writer =
-            HashingWriter::new(counting_writer, Context::new(&ring::digest::SHA256));
-
-        // AOSP's payload_consumer does not support CRC during decompression.
-        // Also, we intentionally pick the lowest compression level since we
-        // primarily care about squishing zeros. The non-zero portions of boot
-        // images are usually already-compressed kernels and ramdisks.
-        let stream = Stream::new_easy_encoder(0, Check::None)?;
-        let xz_writer = XzEncoder::new_stream(hashing_writer, stream);
-
-        Ok(Self {
-            inner: xz_writer,
-            block_size,
-            h_uncompressed: Context::new(&ring::digest::SHA256),
-            written: 0,
-        })
-    }
-
-    /// Finish writing and update the [`PartitionUpdate`] instance with the new
-    /// size, hash, and install operation metadata.
-    pub fn finish(mut self, partition: &mut PartitionUpdate) -> Result<W> {
-        if self.written % u64::from(self.block_size) != 0 {
-            return Err(Error::InvalidPartitionSize {
-                name: partition.partition_name.clone(),
-                size: self.written,
-                block_size: self.block_size,
-            });
-        }
-
-        self.inner.flush()?;
-
-        let hashing_writer = self.inner.finish()?;
-        let digest_uncompressed = self.h_uncompressed.finish();
-        let (counting_writer, context_compressed) = hashing_writer.finish();
-        let digest_compressed = context_compressed.finish();
-        // XzEncoder::total_out() cannot be used for an exact byte count because
-        // XzEncoder::finish() writes data.
-        let (writer, size_compressed) = counting_writer.finish();
-
-        partition.new_partition_info = Some(PartitionInfo {
-            size: Some(self.written),
-            hash: Some(digest_uncompressed.as_ref().to_vec()),
-        });
-
-        let extent = Extent {
-            start_block: Some(0),
-            num_blocks: Some(self.written / u64::from(self.block_size)),
-        };
-
-        let operation = InstallOperation {
-            type_pb: mod_InstallOperation::Type::REPLACE_XZ,
-            // Must be manually updated by the caller.
-            data_offset: None,
-            data_length: Some(size_compressed),
-            src_extents: vec![],
-            src_length: None,
-            dst_extents: vec![extent],
-            dst_length: None,
-            data_sha256_hash: Some(digest_compressed.as_ref().to_vec()),
-            src_sha256_hash: None,
-        };
-
-        partition.operations.clear();
-        partition.operations.push(operation);
-
-        Ok(writer)
-    }
-}
-
-impl<W: Write> Write for CompressedPartitionWriter<W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let n = self.inner.write(buf)?;
-        self.h_uncompressed.update(&buf[..n]);
-        self.written += n as u64;
-        Ok(n)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.inner.flush()
-    }
-}
-
 /// Verify the payload signatures using the specified certificate and check that
 /// the digests in `payload_properties.txt` are correct.
 pub fn verify_payload(
@@ -676,7 +594,7 @@ pub fn verify_payload(
         )?;
 
         let buf = writer.into_inner();
-        util::read_protobuf::<Signatures>(&buf)?
+        Signatures::decode(buf.as_slice())?
     };
 
     // Check the metadata signatures.
@@ -728,7 +646,7 @@ pub fn verify_payload(
         )?;
 
         let buf = writer.into_inner();
-        util::read_protobuf::<Signatures>(&buf)?
+        Signatures::decode(buf.as_slice())?
     };
 
     // Check the payload signatures.
@@ -779,19 +697,19 @@ pub fn apply_operation(
 
         let out_offset = start_block
             .checked_mul(block_size.into())
-            .ok_or_else(|| Error::IntegerTooLarge("out_offset"))?;
+            .ok_or_else(|| Error::FieldOutOfBounds("out_offset"))?;
         let out_data_length = num_blocks
             .checked_mul(block_size.into())
-            .ok_or_else(|| Error::IntegerTooLarge("out_data_length"))?;
+            .ok_or_else(|| Error::FieldOutOfBounds("out_data_length"))?;
 
         writer.seek(SeekFrom::Start(out_offset))?;
 
         let mut hasher = Context::new(&ring::digest::SHA256);
 
-        match op.type_pb {
+        match op.r#type() {
             // Handle ZERO/DISCARD specially since they don't require access to
             // the payload blob.
-            mod_InstallOperation::Type::ZERO | mod_InstallOperation::Type::DISCARD => {
+            Type::Zero | Type::Discard => {
                 stream::copy_n_inspect(
                     io::repeat(0),
                     &mut writer,
@@ -809,12 +727,12 @@ pub fn apply_operation(
                     .ok_or_else(|| Error::MissingField("data_length"))?;
                 let in_offset = blob_offset
                     .checked_add(data_offset)
-                    .ok_or_else(|| Error::IntegerTooLarge("in_offset"))?;
+                    .ok_or_else(|| Error::FieldOutOfBounds("in_offset"))?;
 
                 reader.seek(SeekFrom::Start(in_offset))?;
 
                 match other {
-                    mod_InstallOperation::Type::REPLACE => {
+                    Type::Replace => {
                         stream::copy_n_inspect(
                             &mut reader,
                             &mut writer,
@@ -823,7 +741,7 @@ pub fn apply_operation(
                             cancel_signal,
                         )?;
                     }
-                    mod_InstallOperation::Type::REPLACE_BZ => {
+                    Type::ReplaceBz => {
                         let mut decoder = BzDecoder::new(&mut writer);
                         stream::copy_n_inspect(
                             &mut reader,
@@ -834,7 +752,7 @@ pub fn apply_operation(
                         )?;
                         decoder.finish()?;
                     }
-                    mod_InstallOperation::Type::REPLACE_XZ => {
+                    Type::ReplaceXz => {
                         let mut decoder = XzDecoder::new(&mut writer);
                         stream::copy_n_inspect(
                             &mut reader,
@@ -845,7 +763,7 @@ pub fn apply_operation(
                         )?;
                         decoder.finish()?;
                     }
-                    _ => return Err(Error::UnsupportedOperation(op.type_pb)),
+                    _ => return Err(Error::UnsupportedOperation(op.r#type())),
                 }
             }
         }
@@ -853,9 +771,7 @@ pub fn apply_operation(
         let expected_digest = op.data_sha256_hash.as_deref();
         let digest = hasher.finish();
 
-        if expected_digest != Some(digest.as_ref())
-            && op.type_pb != mod_InstallOperation::Type::ZERO
-        {
+        if expected_digest != Some(digest.as_ref()) && op.r#type() != Type::Zero {
             return Err(Error::MismatchedDigest {
                 expected: expected_digest.map(hex::encode),
                 actual: hex::encode(digest.as_ref()),
@@ -866,34 +782,34 @@ pub fn apply_operation(
     Ok(())
 }
 
-/// Extract the specified image from the payload into memory. This is done
-/// multithreaded and uses rayon's global thread pool. `open_payload` will be
-/// called from multiple threads.
-pub fn extract_image_to_memory(
-    open_payload: impl Fn() -> io::Result<Box<dyn ReadSeek>> + Sync,
+/// Extract the specified image from the payload. This is done multithreaded and
+/// uses rayon's global thread pool. Both the `payload` and `output` streams
+/// will be reopened from multiple threads.
+pub fn extract_image(
+    payload: &(dyn ReadSeekReopen + Sync),
+    output: &(dyn WriteSeekReopen + Sync),
     header: &PayloadHeader,
     partition_name: &str,
     cancel_signal: &AtomicBool,
-) -> Result<SharedCursor> {
+) -> Result<()> {
     let partition = header
         .manifest
         .partitions
         .iter()
         .find(|p| p.partition_name == partition_name)
         .ok_or_else(|| Error::MissingPartition(partition_name.to_owned()))?;
-    let stream = SharedCursor::default();
 
     partition
         .operations
         .par_iter()
         .map(|op| -> Result<()> {
-            let reader = open_payload()?;
-            let writer = stream.reopen();
+            let reader = payload.reopen_boxed()?;
+            let writer = output.reopen_boxed()?;
 
             apply_operation(
                 reader,
                 writer,
-                header.manifest.block_size,
+                header.manifest.block_size(),
                 header.blob_offset,
                 op,
                 cancel_signal,
@@ -901,16 +817,14 @@ pub fn extract_image_to_memory(
 
             Ok(())
         })
-        .collect::<Result<_>>()?;
-
-    Ok(stream)
+        .collect::<Result<_>>()
 }
 
 /// Extract the specified partition images from the payload into writers. This
 /// is done multithreaded and uses rayon's global thread pool. `open_payload`
 /// and `open_output` will be called from multiple threads.
 pub fn extract_images<'a>(
-    open_payload: impl Fn() -> io::Result<Box<dyn ReadSeek>> + Sync,
+    payload: &(dyn ReadSeekReopen + Sync),
     open_output: impl Fn(&str) -> io::Result<Box<dyn WriteSeek>> + Sync,
     header: &PayloadHeader,
     partition_names: impl IntoIterator<Item = &'a str>,
@@ -937,13 +851,13 @@ pub fn extract_images<'a>(
     operations
         .into_par_iter()
         .map(|(name, op)| -> Result<()> {
-            let reader = open_payload()?;
+            let reader = payload.reopen_boxed()?;
             let writer = open_output(name)?;
 
             apply_operation(
                 reader,
                 writer,
-                header.manifest.block_size,
+                header.manifest.block_size(),
                 header.blob_offset,
                 op,
                 cancel_signal,
@@ -953,3 +867,329 @@ pub fn extract_images<'a>(
         })
         .collect()
 }
+
+fn compress_chunk(raw_data: &[u8], cancel_signal: &AtomicBool) -> Result<(Vec<u8>, Digest)> {
+    let reader = Cursor::new(raw_data);
+    let writer = Cursor::new(Vec::new());
+    let hashing_writer = HashingWriter::new(writer, Context::new(&ring::digest::SHA256));
+
+    // AOSP's payload_consumer does not support checking CRC during
+    // decompression. Also, we intentionally pick the lowest compression level
+    // since we primarily care about squishing zeros. The non-zero portions of
+    // boot images are usually already-compressed kernels and ramdisks.
+    let stream = Stream::new_easy_encoder(0, Check::None)?;
+    let mut xz_writer = XzEncoder::new_stream(hashing_writer, stream);
+
+    stream::copy_n(reader, &mut xz_writer, raw_data.len() as u64, cancel_signal)?;
+
+    let hashing_writer = xz_writer.finish()?;
+    let (writer, context_compressed) = hashing_writer.finish();
+    let digest_compressed = context_compressed.finish();
+    let data = writer.into_inner();
+
+    Ok((data, digest_compressed))
+}
+
+fn compress_cow_size(mut raw_data: &[u8], block_size: u32) -> u64 {
+    let mut total = 0;
+
+    while !raw_data.is_empty() {
+        let n = raw_data.len().min(block_size as usize);
+        let compressed = lz4_flex::block::compress(&raw_data[..n]);
+
+        total += compressed.len().min(n) as u64;
+
+        raw_data = &raw_data[n..];
+    }
+
+    total
+}
+
+/// Compress the image and return the corresponding information to insert into
+/// the payload manifest's [`PartitionUpdate`] instance. The uncompressed data
+/// is split into 2 MiB chunks, which are read and compressed in parallel, and
+/// then written in parallel (but in order) to the output. Each chunk will have
+/// a corresponding [`InstallOperation`] in the return value. The caller must
+/// update [`InstallOperation::data_offset`] in each operation manually because
+/// the initial values are relative to 0.
+///
+/// If `need_cow_estimate` is true, the VABC CoW v2 + lz4 size estimate will be
+/// computed. The caller must update [`PartitionUpdate::estimate_cow_size`] with
+/// this value or else update_engine may fail to flash the partition due to
+/// running out of space on the CoW block device. CoW v2 + other algorithms and
+/// also CoW v3 are currently unsupported because there currently are no known
+/// OTAs that use those configurations.
+pub fn compress_image(
+    input: &(dyn ReadSeekReopen + Sync),
+    output: &(dyn WriteSeekReopen + Sync),
+    partition_name: &str,
+    block_size: u32,
+    need_cow_estimate: bool,
+    cancel_signal: &AtomicBool,
+) -> Result<(PartitionInfo, Vec<InstallOperation>, Option<u64>)> {
+    const CHUNK_SIZE: u64 = 2 * 1024 * 1024;
+    const CHUNK_GROUP: u64 = 32;
+
+    let file_size = input.reopen_boxed()?.seek(SeekFrom::End(0))?;
+    let final_chunk_different = file_size % CHUNK_SIZE != 0;
+
+    if file_size % u64::from(block_size) != 0 || CHUNK_SIZE % u64::from(block_size) != 0 {
+        return Err(Error::InvalidPartitionSize {
+            name: partition_name.to_owned(),
+            size: file_size,
+            block_size,
+        });
+    }
+
+    let chunks_total = file_size.div_ceil(CHUNK_SIZE);
+    let mut bytes_compressed = 0;
+    let mut context_uncompressed = Context::new(&ring::digest::SHA256);
+    let mut cow_estimate = 0;
+    let mut operations = vec![];
+
+    // Read the file one group at a time. This allows for some parallelization
+    // without reading the entire file into memory. This is necessary because we
+    // need to compute the checksum of the entire file.
+    while (operations.len() as u64) < chunks_total {
+        let chunks_done = operations.len() as u64;
+        let chunks_group = (chunks_total - chunks_done).min(CHUNK_GROUP);
+
+        let uncompressed_data_group = (chunks_done..chunks_done + chunks_group)
+            .into_par_iter()
+            .map(|chunk| -> Result<(u64, Vec<u8>)> {
+                let mut reader = input.reopen_boxed()?;
+                let offset = reader.seek(SeekFrom::Start(chunk * CHUNK_SIZE))?;
+
+                let chunk_size = if final_chunk_different && chunk == chunks_total - 1 {
+                    file_size % CHUNK_SIZE
+                } else {
+                    CHUNK_SIZE
+                };
+                let mut data = vec![0u8; chunk_size as usize];
+
+                stream::check_cancel(cancel_signal)?;
+                reader.read_exact(&mut data)?;
+
+                Ok((offset, data))
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        for (_, data) in &uncompressed_data_group {
+            context_uncompressed.update(data);
+        }
+
+        let mut compressed_data_group = uncompressed_data_group
+            .into_par_iter()
+            .map(
+                |(raw_offset, raw_data)| -> Result<(Vec<u8>, InstallOperation, u64)> {
+                    let (data, digest_compressed) = compress_chunk(&raw_data, cancel_signal)?;
+                    let cow_size = if need_cow_estimate {
+                        compress_cow_size(&raw_data, block_size)
+                    } else {
+                        0
+                    };
+
+                    let extent = Extent {
+                        start_block: Some(raw_offset / u64::from(block_size)),
+                        num_blocks: Some(raw_data.len() as u64 / u64::from(block_size)),
+                    };
+
+                    let mut operation = InstallOperation::default();
+                    operation.set_type(Type::ReplaceXz);
+                    operation.data_length = Some(data.len() as u64);
+                    operation.dst_extents.push(extent);
+                    operation.data_sha256_hash = Some(digest_compressed.as_ref().to_vec());
+
+                    Ok((data, operation, cow_size))
+                },
+            )
+            .collect::<Result<Vec<_>>>()?;
+
+        for (data, operation, cow_size) in &mut compressed_data_group {
+            operation.data_offset = Some(bytes_compressed);
+            bytes_compressed += data.len() as u64;
+            cow_estimate += *cow_size;
+        }
+
+        let group_operations = compressed_data_group
+            .into_par_iter()
+            .map(|(data, operation, _)| -> Result<InstallOperation> {
+                let mut writer = output.reopen_boxed()?;
+                writer.seek(SeekFrom::Start(operation.data_offset.unwrap()))?;
+                writer.write_all(&data)?;
+
+                Ok(operation)
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        operations.extend(group_operations.into_iter());
+    }
+
+    let digest_uncompressed = context_uncompressed.finish();
+    let partition_info = PartitionInfo {
+        size: Some(file_size),
+        hash: Some(digest_uncompressed.as_ref().to_vec()),
+    };
+
+    let cow_estimate = if need_cow_estimate {
+        // Because lz4_flex compresses better than official lz4.
+        let fudge = cow_estimate / 100;
+
+        Some(cow_estimate + fudge)
+    } else {
+        None
+    };
+
+    Ok((partition_info, operations, cow_estimate))
+}
+
+fn extents_sorted(operations: &[InstallOperation]) -> bool {
+    let mut offset = 0;
+
+    for operation in operations {
+        if operation.dst_extents.is_empty() {
+            return false;
+        }
+
+        for extent in &operation.dst_extents {
+            let Some(start) = extent.start_block else {
+                return false;
+            };
+            let Some(size) = extent.num_blocks else {
+                return false;
+            };
+
+            if start != offset {
+                return false;
+            }
+
+            let Some(next) = start.checked_add(size) else {
+                return false;
+            };
+            offset = next;
+        }
+    }
+
+    true
+}
+
+/// Compress the modified image and update the specified [`PartitionInfo`] and
+/// list of [`InstallOperation`]s. [`InstallOperation`]s that do not match any
+/// byte range in `ranges` will not be compressed. The caller must update
+/// [`InstallOperation::data_offset`] in each operation manually because the
+/// initial values are relative to 0.
+///
+/// Returns the ranges of indices of `operations` that were updated.
+pub fn compress_modified_image(
+    input: &(dyn ReadSeekReopen + Sync),
+    output: &(dyn WriteSeekReopen + Sync),
+    block_size: u32,
+    partition_info: &mut PartitionInfo,
+    operations: &mut [InstallOperation],
+    ranges: &[Range<u64>],
+    cancel_signal: &AtomicBool,
+) -> Result<Vec<Range<usize>>> {
+    const OPERATION_GROUP: usize = 32;
+
+    // Full OTAs created by payload_generator have one extent per operation and
+    // they're all in order with no gaps. Verify this so we can take advantage
+    // of this layout.
+    if !extents_sorted(operations) {
+        return Err(Error::ExtentsNotInOrder);
+    }
+
+    let groups_total = operations.len().div_ceil(OPERATION_GROUP);
+    let mut bytes_compressed = 0;
+    let mut context_uncompressed = Context::new(&ring::digest::SHA256);
+    let mut modified_operations = vec![];
+
+    // Read the file one group at a time. This allows for some parallelization
+    // without reading the entire file into memory. This is necessary because we
+    // need to compute the checksum of the entire file.
+    for group in 0..groups_total {
+        let operation_start = group * OPERATION_GROUP;
+        let operation_size = (operations.len() - operation_start).min(OPERATION_GROUP);
+        let operation_end = operation_start + operation_size;
+
+        let uncompressed_data_group = operations[operation_start..operation_end]
+            .par_iter()
+            .map(|operation| -> Result<(Vec<u8>, bool)> {
+                let extents_start = operation.dst_extents[0]
+                    .start_block()
+                    .checked_mul(u64::from(block_size))
+                    .ok_or_else(|| Error::FieldOutOfBounds("extents_start"))?;
+                let extents_size = operation
+                    .dst_extents
+                    .iter()
+                    .map(|e| e.num_blocks())
+                    .try_fold(0u64, |acc, n| acc.checked_add(n))
+                    .and_then(|n| n.checked_mul(u64::from(block_size)))
+                    .ok_or_else(|| Error::FieldOutOfBounds("extents_size"))?;
+                let extents_end = extents_start
+                    .checked_add(extents_size)
+                    .ok_or_else(|| Error::FieldOutOfBounds("extents_end"))?;
+                let extents_size = extents_size
+                    .to_usize()
+                    .ok_or_else(|| Error::FieldOutOfBounds("extents_size"))?;
+
+                let mut reader = input.reopen_boxed()?;
+                reader.seek(SeekFrom::Start(extents_start))?;
+
+                let mut data = vec![0u8; extents_size];
+
+                stream::check_cancel(cancel_signal)?;
+                reader.read_exact(&mut data)?;
+
+                let was_modified = util::ranges_overlaps(ranges, &(extents_start..extents_end));
+
+                Ok((data, was_modified))
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        for (data, _) in &uncompressed_data_group {
+            context_uncompressed.update(data);
+        }
+
+        // Only compress the modified chunks.
+        let mut compressed_data_group = operations[operation_start..operation_end]
+            .par_iter_mut()
+            .enumerate()
+            .zip(uncompressed_data_group)
+            .filter(|(_, (_, was_modified))| *was_modified)
+            .map(
+                |((i_rel, operation), (raw_data, _))| -> Result<(Vec<u8>, usize, &mut InstallOperation)> {
+                    let (data, digest_compressed) = compress_chunk(&raw_data, cancel_signal)?;
+
+                    operation.set_type(Type::ReplaceXz);
+                    operation.data_length = Some(data.len() as u64);
+                    operation.data_sha256_hash = Some(digest_compressed.as_ref().to_vec());
+
+                    Ok((data, i_rel + operation_start, operation))
+                },
+            )
+            .collect::<Result<Vec<_>>>()?;
+
+        for (data, _, operation) in &mut compressed_data_group {
+            operation.data_offset = Some(bytes_compressed);
+            bytes_compressed += data.len() as u64;
+        }
+
+        let modified_group_operations = compressed_data_group
+            .into_par_iter()
+            .map(|(data, i, operation)| {
+                let mut writer = output.reopen_boxed()?;
+                writer.seek(SeekFrom::Start(operation.data_offset.unwrap()))?;
+                writer.write_all(&data)?;
+
+                Ok(i..i + 1)
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        modified_operations.extend(modified_group_operations);
+    }
+
+    let digest_uncompressed = context_uncompressed.finish();
+    partition_info.hash = Some(digest_uncompressed.as_ref().to_vec());
+
+    Ok(util::merge_overlapping(&modified_operations))
+}

avbroot/src/lib.rs

@@ -13,11 +13,12 @@
 // We use pb-rs' nostd mode. See build.rs.
 extern crate alloc;
 
-pub mod boot;
 pub mod cli;
 pub mod crypto;
 pub mod escape;
 pub mod format;
+pub mod octal;
+pub mod patch;
 pub mod protobuf;
 pub mod stream;
 pub mod util;

avbroot/src/main.rs

@@ -8,9 +8,11 @@ use std::sync::{
     Arc,
 };
 
-use anyhow::Result;
+use tracing::error;
 
-fn main() -> Result<()> {
+static LOGGING_INITIALIZED: AtomicBool = AtomicBool::new(false);
+
+fn main() {
     // Set up a cancel signal so we can properly clean up any temporary files.
     let cancel_signal = Arc::new(AtomicBool::new(false));
     {
@@ -22,5 +24,15 @@ fn main() -> Result<()> {
         .expect("Failed to set signal handler");
     }
 
-    avbroot::cli::args::main(&cancel_signal)
+    match avbroot::cli::args::main(&LOGGING_INITIALIZED, &cancel_signal) {
+        Ok(_) => {}
+        Err(e) => {
+            if LOGGING_INITIALIZED.load(Ordering::SeqCst) {
+                error!("{e:?}");
+            } else {
+                eprintln!("{e:?}");
+            }
+            std::process::exit(1);
+        }
+    }
 }

avbroot/src/octal.rs

@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+//! Hack to format an integer as an octal string because toml_edit can't output
+//! octal-formatted integers and many other toml parsers can't parse it either.
+
+use std::{
+    fmt::{self, Octal},
+    marker::PhantomData,
+};
+
+use num_traits::{Num, PrimInt};
+use serde::{de::Visitor, Deserializer, Serializer};
+
+pub fn serialize<S, T>(data: &T, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: PrimInt + Octal,
+{
+    serializer.serialize_str(&format!("{data:o}"))
+}
+
+pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+where
+    D: Deserializer<'de>,
+    T: PrimInt,
+    <T as Num>::FromStrRadixErr: fmt::Display,
+{
+    struct OctalStrVisitor<T>(PhantomData<T>);
+
+    impl<'de, T> Visitor<'de> for OctalStrVisitor<T>
+    where
+        T: PrimInt,
+        <T as Num>::FromStrRadixErr: fmt::Display,
+    {
+        type Value = T;
+
+        fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            write!(f, "a string containing an octal number")
+        }
+
+        fn visit_str<E>(self, data: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            T::from_str_radix(data, 8).map_err(serde::de::Error::custom)
+        }
+    }
+
+    deserializer.deserialize_str(OctalStrVisitor(PhantomData))
+}

avbroot/src/patch/mod.rs

@@ -0,0 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+pub mod boot;
+pub mod otacert;
+pub mod system;

avbroot/src/patch/otacert.rs

@@ -0,0 +1,150 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+use std::{borrow::Cow, cmp::Ordering, io::Cursor};
+
+use bitflags::bitflags;
+use thiserror::Error;
+use tracing::trace;
+use x509_cert::{der::asn1::BitString, Certificate};
+use zip::{result::ZipError, write::FileOptions, CompressionMethod, ZipWriter};
+
+use crate::{crypto, format::ota};
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("New otacerts.zip is too small to pad to {0} bytes")]
+    ZipTooSmall(usize),
+    #[error("New otacerts.zip is too large to fit in {0} bytes")]
+    ZipTooLarge(usize),
+    #[error("Crypto error")]
+    Crypto(#[from] crypto::Error),
+    #[error("x509 DER error")]
+    Der(#[from] x509_cert::der::Error),
+    #[error("Zip error")]
+    Zip(#[from] ZipError),
+}
+
+type Result<T> = std::result::Result<T, Error>;
+
+/// Pad a non-zip64 zip file to the specified size by adding null bytes to the
+/// archive comment field.
+pub fn pad_zip(data: &mut Vec<u8>, size: usize) -> Result<()> {
+    match size.cmp(&data.len()) {
+        Ordering::Equal => Ok(()),
+        Ordering::Less => Err(Error::ZipTooLarge(size)),
+        Ordering::Greater => {
+            let padding = size - data.len();
+
+            if data.len() < 22
+                || &data[data.len() - 22..][..4] != ota::ZIP_EOCD_MAGIC
+                || padding > usize::from(u16::MAX)
+            {
+                return Err(Error::ZipTooSmall(size));
+            }
+
+            // Rewrite the comment size and pad with null bytes.
+            data.pop();
+            data.pop();
+            data.extend((padding as u16).to_le_bytes());
+            data.resize(size, 0);
+
+            Ok(())
+        }
+    }
+}
+
+bitflags! {
+    /// Android uses X.509 as nothing more than a file format to transport RSA
+    /// public keys. This is true for both the framework's RecoverySystem and
+    /// recovery's otautil/verifier.cpp. The only fields that must exist are
+    /// the public key and the signature algorithm. The rest can be removed with
+    /// no side effects whatsoever.
+    #[derive(Debug, Clone, Copy)]
+    pub struct OtaCertBuildFlags: u8 {
+        const COMPRESS_DEFLATE = 1 << 0;
+        const REMOVE_SIGNATURE = 1 << 1;
+        const REMOVE_EXTENSIONS = 1 << 2;
+        const REMOVE_ISSUER = 1 << 3;
+        const REMOVE_SUBJECT = 1 << 4;
+    }
+}
+
+/// Create an `otacerts.zip` file containing the specified certificate.
+pub fn create_zip(cert: &Certificate, flags: OtaCertBuildFlags) -> Result<Vec<u8>> {
+    let raw_writer = Cursor::new(Vec::new());
+    let mut writer = ZipWriter::new(raw_writer);
+
+    let compression_method = if flags.contains(OtaCertBuildFlags::COMPRESS_DEFLATE) {
+        CompressionMethod::Deflated
+    } else {
+        CompressionMethod::Stored
+    };
+
+    let options = FileOptions::default().compression_method(compression_method);
+    writer.start_file("ota.x509.pem", options)?;
+
+    let cert = if flags.is_empty() {
+        Cow::Borrowed(cert)
+    } else {
+        let mut modified = cert.clone();
+
+        if flags.contains(OtaCertBuildFlags::REMOVE_SIGNATURE) {
+            modified.signature = BitString::from_bytes(&[])?;
+        }
+        if flags.contains(OtaCertBuildFlags::REMOVE_EXTENSIONS) {
+            if let Some(extensions) = &mut modified.tbs_certificate.extensions {
+                extensions.clear();
+            }
+        }
+        if flags.contains(OtaCertBuildFlags::REMOVE_ISSUER) {
+            modified.tbs_certificate.issuer.0.clear();
+            modified.tbs_certificate.issuer_unique_id = None;
+        }
+        if flags.contains(OtaCertBuildFlags::REMOVE_SUBJECT) {
+            modified.tbs_certificate.subject.0.clear();
+            modified.tbs_certificate.subject_unique_id = None;
+        }
+
+        Cow::Owned(modified)
+    };
+
+    crypto::write_pem_cert(&mut writer, &cert)?;
+
+    let raw_writer = writer.finish()?;
+
+    Ok(raw_writer.into_inner())
+}
+
+/// Create an `otacerts.zip` file padded to the specified size.
+///
+/// This will incrementally remove unneeded components from the certificate to
+/// meet the size limit if needed.
+pub fn create_zip_with_size(cert: &Certificate, size: usize) -> Result<Vec<u8>> {
+    let mut flags = OtaCertBuildFlags::empty();
+
+    for additional_flag in [
+        OtaCertBuildFlags::empty(),
+        OtaCertBuildFlags::COMPRESS_DEFLATE,
+        OtaCertBuildFlags::REMOVE_SIGNATURE,
+        OtaCertBuildFlags::REMOVE_EXTENSIONS,
+        OtaCertBuildFlags::REMOVE_ISSUER,
+        OtaCertBuildFlags::REMOVE_SUBJECT,
+    ] {
+        flags |= additional_flag;
+
+        trace!("Attempting to create {size} byte otacerts.zip: {flags:?}");
+
+        let mut data = create_zip(cert, flags)?;
+        if data.len() <= size {
+            trace!("Padding {} byte otacerts.zip to {size}", data.len());
+
+            pad_zip(&mut data, size)?;
+            return Ok(data);
+        }
+    }
+
+    Err(Error::ZipTooLarge(size))
+}

avbroot/src/patch/system.rs

@@ -0,0 +1,239 @@
+/*
+ * SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+use std::{
+    io::{self, Cursor, SeekFrom},
+    ops::Range,
+    sync::atomic::AtomicBool,
+};
+
+use memchr::memmem;
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use rsa::RsaPrivateKey;
+use thiserror::Error;
+use tracing::{debug, debug_span, trace, Span};
+use x509_cert::Certificate;
+use zip::ZipArchive;
+
+use crate::{
+    format::{
+        avb::{self, AppendedDescriptorMut, Footer},
+        ota,
+    },
+    patch::otacert,
+    stream::{self, ReadSeekReopen, SectionReader, WriteSeekReopen},
+    util,
+};
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Old otacerts.zip not found in image")]
+    OldZipNotFound,
+    #[error("Image has no vbmeta footer")]
+    NoFooter,
+    #[error("No hash tree descriptor found in vbmeta header")]
+    NoHashTreeDescriptor,
+    #[error("{0:?} field is out of bounds")]
+    FieldOutOfBounds(&'static str),
+    #[error("AVB error")]
+    Avb(#[from] avb::Error),
+    #[error("OTA certificate error")]
+    OtaCert(#[from] otacert::Error),
+    #[error("I/O error")]
+    Io(#[from] io::Error),
+}
+
+type Result<T> = std::result::Result<T, Error>;
+
+/// Find the bounds of a non-zip64 zip starting from the EOCD magic offset.
+fn find_zip_bounds(data: &[u8], eocd_offset: usize) -> Option<Range<usize>> {
+    let eocd = &data[eocd_offset..];
+    if eocd.len() < 22 {
+        trace!("Buffer is too small to contain EOCD");
+        return None;
+    }
+
+    let cd_size = u32::from_le_bytes(eocd[12..16].try_into().unwrap()) as usize;
+    let cd_offset = u32::from_le_bytes(eocd[16..20].try_into().unwrap()) as usize;
+    let comment_size = usize::from(u16::from_le_bytes(eocd[20..22].try_into().unwrap()));
+
+    let start = eocd_offset.checked_sub(cd_size)?.checked_sub(cd_offset)?;
+    let end = eocd_offset.checked_add(22)?.checked_add(comment_size)?;
+    if end > data.len() {
+        trace!("End of zip is out of bounds");
+        return None;
+    }
+
+    trace!("Found zip bounds: {:?}", start..end);
+
+    let reader = SectionReader::new(Cursor::new(data), start as u64, (end - start) as u64).ok()?;
+    let mut zip_reader = ZipArchive::new(reader).ok()?;
+
+    if zip_reader.is_empty() {
+        // otacerts.zip files contain at least one cert.
+        trace!("Zip is empty");
+        return None;
+    }
+
+    for index in 0..zip_reader.len() {
+        let entry = zip_reader.by_index_raw(index).ok()?;
+
+        if !entry.name().ends_with(".x509.pem") {
+            // otacerts.zip files only contain files named this way.
+            trace!("Excluded due to invalid name: {:?}", entry.name());
+            return None;
+        }
+    }
+
+    debug!("Found otacerts.zip candidate");
+
+    // There's one or more entries and every one is named *.x509.pem.
+    Some(start..end)
+}
+
+/// Replace `otacerts.zip` with a new one containing the new certificate, but
+/// padded to the same size. If the new zip is too large, the certificate will
+/// be modified to remove unnecessary components until it fits. All operations
+/// run in parallel where possible. The input and output must refer to the same
+/// file and will be reopened from multiple threads.
+///
+/// Returns two sorted and non-overlapping lists of byte ranges that were
+/// modified. The first list are the byte regions within the filesystem data
+/// that contained otacerts.zip. The second list is the list of byte regions
+/// outside of the filesyste, like the hash tree, FEC data, and AVB metadata.
+///
+/// If [`Error::OldZipNotFound`] is returned, the output will not have been
+/// modified.
+#[allow(clippy::type_complexity)]
+pub fn patch_system_image(
+    input: &(dyn ReadSeekReopen + Sync),
+    output: &(dyn WriteSeekReopen + Sync),
+    certificate: &Certificate,
+    key: &RsaPrivateKey,
+    cancel_signal: &AtomicBool,
+) -> Result<(Vec<Range<u64>>, Vec<Range<u64>>)> {
+    // This must be a multiple of normal filesystem block sizes (eg. 4 KiB).
+    // This ensures that the block containing otacerts.zip's data won't cross
+    // chunk boundaries.
+    const CHUNK_SIZE: u64 = 2 * 1024 * 1024;
+
+    let parent_span = Span::current();
+
+    let (mut header, footer, image_size) = avb::load_image(input.reopen_boxed()?)?;
+    let Some(mut footer) = footer else {
+        return Err(Error::NoFooter);
+    };
+    let AppendedDescriptorMut::HashTree(descriptor) = header.appended_descriptor_mut()? else {
+        return Err(Error::NoHashTreeDescriptor);
+    };
+
+    let num_chunks = footer.original_image_size.div_ceil(CHUNK_SIZE);
+    trace!("Parallel heuristics search for otacerts.zip with {num_chunks} chunks");
+
+    let modified_ranges = (0..num_chunks)
+        .into_par_iter()
+        .map(|chunk| -> Result<Vec<Range<u64>>> {
+            stream::check_cancel(cancel_signal)?;
+
+            let offset = chunk * CHUNK_SIZE;
+            let size = CHUNK_SIZE.min(footer.original_image_size - offset);
+            let mut buf = vec![0u8; size as usize];
+
+            let mut reader = input.reopen_boxed()?;
+            reader.seek(SeekFrom::Start(offset))?;
+            reader.read_exact(&mut buf)?;
+
+            let mut writer = output.reopen_boxed()?;
+            let mut ranges = Vec::<Range<u64>>::new();
+
+            for eocd_offset_rel in memmem::find_iter(&buf, ota::ZIP_EOCD_MAGIC) {
+                let _span = debug_span!(parent: &parent_span, "otacerts", offset, eocd_offset_rel)
+                    .entered();
+
+                let Some(bounds_rel) = find_zip_bounds(&buf, eocd_offset_rel) else {
+                    continue;
+                };
+
+                let zip_size = bounds_rel.end - bounds_rel.start;
+                let new_zip = otacert::create_zip_with_size(certificate, zip_size)?;
+
+                let bounds = offset + bounds_rel.start as u64..offset + bounds_rel.end as u64;
+
+                stream::check_cancel(cancel_signal)?;
+
+                writer.seek(SeekFrom::Start(bounds.start))?;
+                writer.write_all(&new_zip)?;
+
+                ranges.push(bounds);
+            }
+
+            Ok(ranges)
+        })
+        .try_reduce(Vec::new, |mut result, item| {
+            result.extend(item);
+            Ok(result)
+        })?;
+
+    if modified_ranges.is_empty() {
+        return Err(Error::OldZipNotFound);
+    }
+
+    let update_ranges = if descriptor.hash_algorithm == "sha1" {
+        // Promote to a secure algorithm. SHA1 is allowed for verification only.
+        // The entire hash tree and FEC data will need to be recomputed.
+        let new_algorithm = "sha256".to_owned();
+
+        debug!(
+            "Changing insecure hash algorithm {} to {new_algorithm}",
+            descriptor.hash_algorithm,
+        );
+
+        descriptor.hash_algorithm = new_algorithm;
+        None
+    } else {
+        // Only need to update the hash tree and FEC data corresponding to the
+        // modified regions.
+        Some(modified_ranges.as_slice())
+    };
+
+    descriptor.update(input, output, update_ranges, cancel_signal)?;
+
+    if !header.public_key.is_empty() {
+        debug!("Signing system image");
+        header.set_algo_for_key(key)?;
+        header.sign(key)?;
+    }
+
+    let writer = output.reopen_boxed()?;
+    avb::write_appended_image(writer, &header, &mut footer, Some(image_size))?;
+
+    let AppendedDescriptorMut::HashTree(descriptor) = header.appended_descriptor_mut()? else {
+        return Err(Error::NoHashTreeDescriptor);
+    };
+
+    // The hash tree, FEC data, and AVB regions will have been modified.
+    let hash_tree_end = descriptor
+        .tree_offset
+        .checked_add(descriptor.tree_size)
+        .ok_or_else(|| Error::FieldOutOfBounds("hash_tree_end"))?;
+    let fec_data_end = descriptor
+        .fec_offset
+        .checked_add(descriptor.fec_size)
+        .ok_or_else(|| Error::FieldOutOfBounds("fec_data_end"))?;
+    let header_end = footer
+        .vbmeta_offset
+        .checked_add(footer.vbmeta_size)
+        .ok_or_else(|| Error::FieldOutOfBounds("avb_end"))?;
+    let footer_start = image_size - Footer::SIZE as u64;
+
+    let other_ranges = util::merge_overlapping(&[
+        descriptor.tree_offset..hash_tree_end,
+        descriptor.fec_offset..fec_data_end,
+        footer.vbmeta_offset..header_end,
+        footer_start..image_size,
+    ]);
+
+    Ok((modified_ranges, other_ranges))
+}

avbroot/src/protobuf.rs

@@ -1 +1,11 @@
-include!(concat!(env!("OUT_DIR"), "/protobuf/mod.rs"));
+pub mod build {
+    pub mod tools {
+        pub mod releasetools {
+            include!(concat!(env!("OUT_DIR"), "/build.tools.releasetools.rs"));
+        }
+    }
+}
+
+pub mod chromeos_update_engine {
+    include!(concat!(env!("OUT_DIR"), "/chromeos_update_engine.rs"));
+}

avbroot/src/stream.rs

@@ -5,7 +5,7 @@
 
 use std::{
     fs::File,
-    io::{self, Cursor, Read, Seek, SeekFrom, Write},
+    io::{self, BufReader, BufWriter, Cursor, Read, Seek, SeekFrom, Write},
     sync::{
         atomic::{AtomicBool, Ordering},
         Arc, Mutex, RwLock,
@@ -30,6 +30,28 @@ pub trait WriteSeek: Write + Seek {}
 
 impl<W: Write + Seek> WriteSeek for W {}
 
+/// A trait for seekable and reopenable readers.
+pub trait ReadSeekReopen: ReadSeek {
+    fn reopen_boxed(&self) -> io::Result<Box<dyn ReadSeek>>;
+}
+
+impl<R: ReadSeek + Reopen + 'static> ReadSeekReopen for R {
+    fn reopen_boxed(&self) -> io::Result<Box<dyn ReadSeek>> {
+        Ok(Box::new(self.reopen()?))
+    }
+}
+
+/// A trait for seekable and reopenable writers.
+pub trait WriteSeekReopen: WriteSeek {
+    fn reopen_boxed(&self) -> io::Result<Box<dyn WriteSeek>>;
+}
+
+impl<W: WriteSeek + Reopen + 'static> WriteSeekReopen for W {
+    fn reopen_boxed(&self) -> io::Result<Box<dyn WriteSeek>> {
+        Ok(Box::new(self.reopen()?))
+    }
+}
+
 /// Common function for reading a structure from a reader.
 pub trait FromReader<R: Read>: Sized {
     type Error;
@@ -168,6 +190,25 @@ impl<W: Write> WriteStringExt for W {
     }
 }
 
+/// Extensions for file-like types to reopen themselves.
+pub trait Reopen: Sized {
+    /// Open a new handle to the same file. The new handle is independently
+    /// seekable and the file offset is initially set to 0.
+    fn reopen(&self) -> io::Result<Self>;
+}
+
+impl<R: Read + Reopen> Reopen for BufReader<R> {
+    fn reopen(&self) -> io::Result<Self> {
+        Ok(BufReader::new(self.get_ref().reopen()?))
+    }
+}
+
+impl<W: Write + Reopen> Reopen for BufWriter<W> {
+    fn reopen(&self) -> io::Result<Self> {
+        Ok(BufWriter::new(self.get_ref().reopen()?))
+    }
+}
+
 /// A reader wrapper that implements [`Seek`], but only for reporting the
 /// current file position.
 pub struct CountingReader<R: Read> {
@@ -325,6 +366,14 @@ impl<R: Read + Seek> SectionReader<R> {
     }
 }
 
+impl<R: Read + Seek + Reopen> Reopen for SectionReader<R> {
+    fn reopen(&self) -> io::Result<Self> {
+        let inner = self.inner.reopen()?;
+
+        Self::new(inner, self.start, self.size)
+    }
+}
+
 impl<R: Read + Seek> Read for SectionReader<R> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let to_read = self.size.saturating_sub(self.pos).min(buf.len() as u64) as usize;
@@ -417,13 +466,6 @@ impl PSeekFile {
         }
     }
 
-    pub fn reopen(&self) -> Self {
-        Self {
-            file: self.file.clone(),
-            offset: 0,
-        }
-    }
-
     pub fn set_len(&self, size: u64) -> io::Result<()> {
         let file_locked = self.file.read().unwrap();
         file_locked.set_len(size)
@@ -458,6 +500,15 @@ impl PSeekFile {
     }
 }
 
+impl Reopen for PSeekFile {
+    fn reopen(&self) -> io::Result<Self> {
+        Ok(Self {
+            file: self.file.clone(),
+            offset: 0,
+        })
+    }
+}
+
 impl Read for PSeekFile {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let n = self.read_at(buf)?;
@@ -530,12 +581,14 @@ impl SharedCursor {
             ..Default::default()
         }
     }
+}
 
-    pub fn reopen(&self) -> Self {
-        Self {
+impl Reopen for SharedCursor {
+    fn reopen(&self) -> io::Result<Self> {
+        Ok(Self {
             inner: self.inner.clone(),
             offset: 0,
-        }
+        })
     }
 }
 
@@ -668,8 +721,8 @@ mod tests {
 
     use super::{
         CountingReader, CountingWriter, HashingReader, HashingWriter, HolePunchingWriter,
-        PSeekFile, ReadDiscardExt, ReadStringExt, SectionReader, SharedCursor, WriteStringExt,
-        WriteZerosExt,
+        PSeekFile, ReadDiscardExt, ReadStringExt, Reopen, SectionReader, SharedCursor,
+        WriteStringExt, WriteZerosExt,
     };
 
     const FOOBAR_SHA256: [u8; 32] = [
@@ -848,8 +901,8 @@ mod tests {
     fn pseek_file() {
         let raw_file = tempfile::tempfile().unwrap();
         let mut a = PSeekFile::new(raw_file);
-        let mut b = a.reopen();
-        let mut c = b.reopen();
+        let mut b = a.reopen().unwrap();
+        let mut c = b.reopen().unwrap();
 
         b.write_all(b"foobar").unwrap();
         c.write_all(b"hello").unwrap();
@@ -868,8 +921,8 @@ mod tests {
     #[test]
     fn shared_cursor() {
         let mut a = SharedCursor::default();
-        let mut b = a.reopen();
-        let mut c = b.reopen();
+        let mut b = a.reopen().unwrap();
+        let mut c = b.reopen().unwrap();
 
         b.write_all(b"foobar").unwrap();
         c.write_all(b"hello").unwrap();

avbroot/src/util.rs

@@ -3,19 +3,19 @@
  * SPDX-License-Identifier: GPL-3.0-only
  */
 
-use std::fmt;
+use std::{cmp::Ordering, fmt, ops::Range, path::Path};
 
-use quick_protobuf::{BytesReader, MessageRead, MessageWrite, Writer};
+use num_traits::PrimInt;
 
 pub const ZEROS: [u8; 16384] = [0u8; 16384];
 
 /// A small wrapper to format a number as a size in bytes.
 #[derive(Clone, Copy)]
-pub struct NumBytes(pub usize);
+pub struct NumBytes<T: PrimInt>(pub T);
 
-impl fmt::Debug for NumBytes {
+impl<T: PrimInt + fmt::Debug> fmt::Debug for NumBytes<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.0 == 1 {
+        if self.0 == T::one() {
             write!(f, "<{:?} byte>", self.0)
         } else {
             write!(f, "<{:?} bytes>", self.0)
@@ -37,16 +37,107 @@ pub fn is_zero(mut buf: &[u8]) -> bool {
     true
 }
 
-/// Read a protobuf message with no leading size field.
-pub fn read_protobuf<'a, M: MessageRead<'a>>(data: &'a [u8]) -> quick_protobuf::Result<M> {
-    let mut reader = BytesReader::from_bytes(data);
-    M::from_reader(&mut reader, data)
+/// Get the non-empty parent of a path. If the path has no parent in the string,
+/// then `.` is returned. This does not perform any filesystem operations.
+pub fn parent_path(path: &Path) -> &Path {
+    if let Some(parent) = path.parent() {
+        if !parent.as_os_str().is_empty() {
+            return parent;
+        }
+    }
+
+    Path::new(".")
 }
 
-/// Write a protobuf message with no leading size field.
-pub fn write_protobuf<M: MessageWrite>(message: &M) -> quick_protobuf::Result<Vec<u8>> {
-    let mut buf = Vec::with_capacity(message.get_size());
-    let mut writer = Writer::new(&mut buf);
-    message.write_message(&mut writer)?;
-    Ok(buf)
+/// Sort and merge overlapping intervals.
+pub fn merge_overlapping<T>(sections: &[Range<T>]) -> Vec<Range<T>>
+where
+    T: Ord + Clone + Copy,
+{
+    let mut sections = sections.to_vec();
+    sections.sort_by_key(|r| (r.start, r.end));
+
+    let mut result = Vec::<Range<T>>::new();
+
+    for section in sections {
+        if section.start >= section.end {
+            continue;
+        } else if let Some(last) = result.last_mut() {
+            if section.start <= last.end {
+                last.end = last.end.max(section.end);
+                continue;
+            }
+        }
+
+        result.push(section);
+    }
+
+    result
+}
+
+/// Binary search to determine if the needle overlaps any of the ranges.
+pub fn ranges_overlaps<T>(ranges: &[Range<T>], needle: &Range<T>) -> bool
+where
+    T: Ord,
+{
+    if needle.start < needle.end {
+        ranges
+            .binary_search_by(|range| {
+                if range.start > needle.end {
+                    Ordering::Greater
+                } else if range.end <= needle.start {
+                    Ordering::Less
+                } else {
+                    Ordering::Equal
+                }
+            })
+            .is_ok()
+    } else {
+        false
+    }
+}
+
+/// Binary search to determine if any of the ranges contain the needle.
+pub fn ranges_contains<T>(ranges: &[Range<T>], needle: &T) -> bool
+where
+    T: Ord,
+{
+    ranges
+        .binary_search_by(|range| {
+            if range.start > *needle {
+                Ordering::Greater
+            } else if range.end <= *needle {
+                Ordering::Less
+            } else {
+                Ordering::Equal
+            }
+        })
+        .is_ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_ranges_overlaps() {
+        assert_eq!(ranges_overlaps(&[0..4], &(0..0)), false);
+        assert_eq!(ranges_overlaps(&[0..4], &(0..4)), true);
+        assert_eq!(ranges_overlaps(&[0..4], &(1..4)), true);
+        assert_eq!(ranges_overlaps(&[0..4], &(0..3)), true);
+        assert_eq!(ranges_overlaps(&[0..4], &(4..5)), false);
+        assert_eq!(ranges_overlaps(&[5..8], &(5..9)), true);
+        assert_eq!(ranges_overlaps(&[5..8], &(4..8)), true);
+        assert_eq!(ranges_overlaps(&[5..8], &(4..9)), true);
+        assert_eq!(ranges_overlaps(&[0..4, 5..8], &(4..5)), true);
+        assert_eq!(ranges_overlaps(&[0..4, 5..8], &(0..9)), true);
+    }
+
+    #[test]
+    fn test_ranges_contains() {
+        assert_eq!(ranges_contains(&[0..4], &0), true);
+        assert_eq!(ranges_contains(&[0..4], &4), false);
+        assert_eq!(ranges_contains(&[0..4, 5..8], &4), false);
+        assert_eq!(ranges_contains(&[0..4, 5..8], &6), true);
+    }
 }

avbroot/tests/avb.rs

@@ -1,10 +1,10 @@
 /*
- * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
  * SPDX-License-Identifier: GPL-3.0-only
  */
 
 use std::{
-    io::{Cursor, Read, Seek, SeekFrom, Write},
+    io::{Cursor, Read, Seek, Write},
     sync::atomic::AtomicBool,
 };
 
@@ -14,8 +14,12 @@ use rsa::RsaPrivateKey;
 
 use avbroot::{
     self,
-    format::avb::{self, AppendedDescriptorMut, AppendedDescriptorRef},
-    stream::{self, SharedCursor},
+    format::avb::{
+        self, AlgorithmType, AppendedDescriptorMut, AppendedDescriptorRef,
+        ChainPartitionDescriptor, Descriptor, Footer, HashDescriptor, HashTreeDescriptor, Header,
+        KernelCmdlineDescriptor, PropertyDescriptor,
+    },
+    stream::SharedCursor,
 };
 
 fn get_test_key() -> RsaPrivateKey {
@@ -31,162 +35,435 @@ fn get_test_key() -> RsaPrivateKey {
     RsaPrivateKey::from_pkcs8_encrypted_pem(data, passphrase.trim_end()).unwrap()
 }
 
+fn repeat_str(s: &str, max_len: usize) -> String {
+    assert!(!s.is_empty());
+
+    let mut result = s.repeat(max_len / s.len());
+    result.push_str(&s[..max_len % s.len()]);
+
+    result
+}
+
+fn repeat_array<const N: usize>(data: &[u8]) -> [u8; N] {
+    assert!(!data.is_empty());
+
+    let mut result = [0u8; N];
+
+    for i in 0..N / data.len() {
+        result[i * data.len()..][..data.len()].copy_from_slice(data);
+    }
+
+    let remain = N % data.len();
+    result[N - remain..].copy_from_slice(&data[..remain]);
+
+    result
+}
+
 #[test]
 fn round_trip_root_image() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/vbmeta_root.img",
-    ));
-    let reader = Cursor::new(data);
-
-    let (mut header, footer, _) = avb::load_image(reader).unwrap();
-    assert_matches!(footer, None);
+    let mut header = Header {
+        required_libavb_version_major: 1,
+        required_libavb_version_minor: 0,
+        algorithm_type: AlgorithmType::Sha256Rsa4096,
+        hash: vec![],       // autogenerated
+        signature: vec![],  // autogenerated
+        public_key: vec![], // autogenerated
+        public_key_metadata: vec![
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+            0x0e, 0x0f,
+        ],
+        descriptors: vec![
+            Descriptor::Property(PropertyDescriptor {
+                key: "foobar".to_owned(),
+                value: b"Invalid UTF-8: \xFF".to_vec(),
+            }),
+            Descriptor::HashTree(HashTreeDescriptor {
+                dm_verity_version: 1,
+                image_size: 4096,
+                tree_offset: 0,
+                tree_size: 2048,
+                data_block_size: 4096,
+                hash_block_size: 4096,
+                fec_num_roots: 1,
+                fec_offset: 2048,
+                fec_size: 2048,
+                hash_algorithm: "sha512".to_owned(),
+                partition_name: "hashtreed_partition".to_owned(),
+                salt: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef].repeat(8),
+                root_digest: [0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10].repeat(8),
+                flags: 0,
+                reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+            }),
+            Descriptor::Hash(HashDescriptor {
+                image_size: 6,
+                hash_algorithm: "sha256".to_owned(),
+                partition_name: "hashed_partition".to_owned(),
+                salt: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef].repeat(4),
+                root_digest: [0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10].repeat(4),
+                flags: 0,
+                reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+            }),
+            Descriptor::KernelCmdline(KernelCmdlineDescriptor {
+                flags: 1,
+                cmdline: "foobar".to_owned(),
+            }),
+            Descriptor::ChainPartition(ChainPartitionDescriptor {
+                rollback_index_location: 1,
+                partition_name: "chained_partition".to_owned(),
+                public_key: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef].repeat(129),
+                flags: 0xfedcba98,
+                reserved: repeat_array(&[0x76, 0x54, 0x32, 0x10, 0xfe, 0xdc, 0xba, 0x98]),
+            }),
+        ],
+        rollback_index: 1677974400,
+        flags: 0,
+        rollback_index_location: 0,
+        release_string: repeat_str("MaxLength", 48),
+        reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+    };
 
+    // Sign the header.
     let key = get_test_key();
-
+    header.sign(&key).unwrap();
     assert_eq!(header.verify().unwrap().unwrap(), key.to_public_key());
 
-    // Clear out the signature-related fields and re-sign.
-    header.hash.clear();
-    header.signature.clear();
-    header.public_key.clear();
-    header.sign(&key).unwrap();
-
+    // Write vbmeta structures.
     let mut writer = Cursor::new(Vec::new());
     avb::write_root_image(&mut writer, &header, 64).unwrap();
-    let new_data = writer.into_inner();
+    let data = writer.into_inner();
 
-    assert_eq!(data, new_data.as_slice());
+    // Verify checksum of the output.
+    assert_eq!(
+        ring::digest::digest(&ring::digest::SHA512, &data).as_ref(),
+        [
+            0xc4, 0xa5, 0xda, 0x3e, 0x09, 0xa2, 0xc8, 0x70, 0xcb, 0xf0, 0x96, 0x79, 0x0e, 0x1e,
+            0x80, 0xae, 0x5e, 0x37, 0x81, 0x27, 0x24, 0xc3, 0x6c, 0xa9, 0x42, 0x9e, 0x2c, 0xb1,
+            0x81, 0xad, 0xce, 0xee, 0x8d, 0x4f, 0x76, 0x45, 0x54, 0xc1, 0x31, 0x6a, 0xa7, 0x81,
+            0x5c, 0x59, 0xa8, 0xe8, 0x76, 0xab, 0xed, 0x5b, 0x07, 0x07, 0x38, 0xdd, 0x09, 0x86,
+            0x05, 0x39, 0x23, 0x2d, 0x7b, 0xcc, 0x57, 0x06,
+        ],
+    );
+
+    // Parse the generated image.
+    let mut reader = Cursor::new(&data);
+    let (new_header, new_footer, new_image_size) = avb::load_image(&mut reader).unwrap();
+    assert_matches!(new_footer, None);
+
+    assert_eq!(new_header, header);
+    assert_eq!(new_image_size, data.len() as u64);
 }
 
 #[test]
 fn round_trip_appended_hash_image() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/vbmeta_appended_hash.img",
-    ));
-    let mut reader = Cursor::new(data);
-    let cancel_signal = AtomicBool::new(false);
-
-    let (mut header, footer, image_size) = avb::load_image(&mut reader).unwrap();
-    let mut footer = footer.unwrap();
-
-    let key = get_test_key();
-
-    assert_eq!(header.verify().unwrap().unwrap(), key.to_public_key());
-
-    // Verify the digest.
-    match header.appended_descriptor().unwrap() {
-        AppendedDescriptorRef::HashTree(_) => panic!("Expected hash descriptor"),
-        AppendedDescriptorRef::Hash(d) => {
-            reader.rewind().unwrap();
-            d.verify(&mut reader, &cancel_signal).unwrap();
-        }
-    }
+    let image_size = 12288;
+    let raw_data = b"foobar";
+    let mut header = Header {
+        required_libavb_version_major: 1,
+        required_libavb_version_minor: 0,
+        algorithm_type: AlgorithmType::Sha256Rsa4096,
+        hash: vec![],       // autogenerated
+        signature: vec![],  // autogenerated
+        public_key: vec![], // autogenerated
+        public_key_metadata: vec![
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+            0x0e, 0x0f,
+        ],
+        descriptors: vec![
+            Descriptor::Property(PropertyDescriptor {
+                key: "foobar".to_owned(),
+                value: b"Invalid UTF-8: \xFF".to_vec(),
+            }),
+            Descriptor::Hash(HashDescriptor {
+                image_size: raw_data.len() as u64,
+                hash_algorithm: "sha256".to_owned(),
+                partition_name: "vbmeta_appended_hash".to_owned(),
+                salt: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef].repeat(4),
+                root_digest: vec![], // autogenerated
+                flags: 0,
+                reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+            }),
+        ],
+        rollback_index: 1677974400,
+        flags: 0,
+        rollback_index_location: 0,
+        release_string: repeat_str("MaxLength", 48),
+        reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+    };
+    let mut footer = Footer {
+        version_major: 1,
+        version_minor: 0,
+        original_image_size: 0, // autogenerated
+        vbmeta_offset: 0,       // autogenerated
+        vbmeta_size: 0,         // autogenerated
+        reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+    };
 
     let mut writer = Cursor::new(Vec::new());
+    let cancel_signal = AtomicBool::new(false);
 
-    // Copy the partition data.
-    reader.seek(SeekFrom::Start(0)).unwrap();
-    stream::copy_n(
-        &mut reader,
-        &mut writer,
-        footer.original_image_size,
-        &cancel_signal,
-    )
-    .unwrap();
+    // Write the raw partition data.
+    writer.write_all(raw_data).unwrap();
 
-    // Regenerate the digest.
+    // Regenerate the raw image digest.
     match header.appended_descriptor_mut().unwrap() {
         AppendedDescriptorMut::HashTree(_) => panic!("Expected hash descriptor"),
         AppendedDescriptorMut::Hash(d) => {
-            d.root_digest.clear();
             writer.rewind().unwrap();
             d.update(&mut writer, &cancel_signal).unwrap();
         }
     }
 
-    // Clear out the signature-related fields and re-sign.
-    header.hash.clear();
-    header.signature.clear();
-    header.public_key.clear();
+    // Verify the raw image digest.
+    match header.appended_descriptor().unwrap() {
+        AppendedDescriptorRef::HashTree(_) => panic!("Expected hash descriptor"),
+        AppendedDescriptorRef::Hash(d) => {
+            writer.rewind().unwrap();
+            d.verify(&mut writer, &cancel_signal).unwrap();
+        }
+    }
+
+    // Sign the header.
+    let key = get_test_key();
     header.sign(&key).unwrap();
+    assert_eq!(header.verify().unwrap().unwrap(), key.to_public_key());
 
-    // Write new vbmeta structures.
-    avb::write_appended_image(&mut writer, &header, &mut footer, image_size).unwrap();
-    let new_data = writer.into_inner();
+    // Write vbmeta structures.
+    avb::write_appended_image(&mut writer, &header, &mut footer, Some(image_size)).unwrap();
+    let data = writer.into_inner();
 
-    assert_eq!(data, new_data.as_slice());
+    // Verify checksum of the output.
+    assert_eq!(
+        ring::digest::digest(&ring::digest::SHA512, &data).as_ref(),
+        [
+            0x09, 0x98, 0x0c, 0x9d, 0x11, 0x50, 0xde, 0xb1, 0x55, 0x3b, 0x00, 0x76, 0xbe, 0x25,
+            0xfd, 0xe6, 0x46, 0x22, 0xbd, 0x9a, 0x05, 0x86, 0xea, 0x07, 0x4d, 0x8f, 0x7b, 0x15,
+            0x36, 0x20, 0x0d, 0xf0, 0x7e, 0x96, 0xd2, 0x58, 0xde, 0xf2, 0xa6, 0x91, 0x6d, 0x01,
+            0x7b, 0x03, 0x96, 0x70, 0xf8, 0x3b, 0x76, 0x74, 0xf0, 0xbf, 0x47, 0xe0, 0xd2, 0xd4,
+            0x5d, 0xbf, 0xb7, 0x9c, 0xf5, 0xf8, 0xaf, 0x3c,
+        ],
+    );
+
+    // Parse the generated image.
+    let mut reader = Cursor::new(&data);
+    let (new_header, new_footer, new_image_size) = avb::load_image(&mut reader).unwrap();
+    let new_footer = new_footer.unwrap();
+
+    assert_eq!(new_header, header);
+    assert_eq!(new_footer, footer);
+    assert_eq!(new_image_size, image_size);
 }
 
 #[test]
-fn round_trip_appended_hash_tree_image() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/vbmeta_appended_hash_tree.img",
-    ));
-    let mut reader = SharedCursor::default();
-    reader.write_all(data).unwrap();
-    let cancel_signal = AtomicBool::new(false);
-
-    let (mut header, footer, image_size) = avb::load_image(&mut reader).unwrap();
-    let mut footer = footer.unwrap();
-
-    let key = get_test_key();
-
-    assert_eq!(header.verify().unwrap().unwrap(), key.to_public_key());
-
-    // Verify the hash tree and FEC data.
-    match header.appended_descriptor().unwrap() {
-        AppendedDescriptorRef::HashTree(d) => {
-            d.verify(|| Ok(Box::new(reader.reopen())), &cancel_signal)
-                .unwrap();
-        }
-        AppendedDescriptorRef::Hash(_) => panic!("Expected hash tree descriptor"),
-    }
+fn round_trip_appended_hash_tree_image_fixed_size() {
+    let image_size = 32768;
+    let raw_data: [u8; 8192] = repeat_array(b"foobar");
+    let mut header = Header {
+        required_libavb_version_major: 1,
+        required_libavb_version_minor: 0,
+        algorithm_type: AlgorithmType::Sha256Rsa4096,
+        hash: vec![],       // autogenerated
+        signature: vec![],  // autogenerated
+        public_key: vec![], // autogenerated
+        public_key_metadata: vec![
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+            0x0e, 0x0f,
+        ],
+        descriptors: vec![
+            Descriptor::Property(PropertyDescriptor {
+                key: "foobar".to_owned(),
+                value: b"Invalid UTF-8: \xFF".to_vec(),
+            }),
+            Descriptor::HashTree(HashTreeDescriptor {
+                dm_verity_version: 1,
+                image_size: raw_data.len() as u64,
+                tree_offset: 0, // autogenerated
+                tree_size: 0,   // autogenerated
+                data_block_size: 4096,
+                hash_block_size: 4096,
+                fec_num_roots: 2,
+                fec_offset: 0, // autogenerated
+                fec_size: 0,   // autogenerated
+                hash_algorithm: "sha256".to_owned(),
+                partition_name: "vbmeta_appended_hash_tree".to_owned(),
+                salt: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef].repeat(4),
+                root_digest: vec![], // autogenerated
+                flags: 0,
+                reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+            }),
+        ],
+        rollback_index: 1677974400,
+        flags: 0,
+        rollback_index_location: 0,
+        release_string: repeat_str("MaxLength", 48),
+        reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+    };
+    let mut footer = Footer {
+        version_major: 1,
+        version_minor: 0,
+        original_image_size: 0, // autogenerated
+        vbmeta_offset: 0,       // autogenerated
+        vbmeta_size: 0,         // autogenerated
+        reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+    };
 
     let mut writer = SharedCursor::default();
+    let cancel_signal = AtomicBool::new(false);
 
-    // Copy the partition data, excluding the hash tree and FEC data.
-    reader.seek(SeekFrom::Start(0)).unwrap();
-    stream::copy_n(
-        &mut reader,
-        &mut writer,
-        footer.original_image_size,
-        &cancel_signal,
-    )
-    .unwrap();
+    // Write the raw partition data.
+    writer.write_all(&raw_data).unwrap();
 
-    // Regenerate the hash tree and FEC data.
+    // Generate and write the hash tree and FEC data.
     match header.appended_descriptor_mut().unwrap() {
         AppendedDescriptorMut::HashTree(d) => {
-            d.root_digest.clear();
-            d.tree_offset = 0;
-            d.tree_size = 0;
-            d.fec_offset = 0;
-            d.fec_size = 0;
-
-            d.update(
-                || Ok(Box::new(writer.reopen())),
-                || Ok(Box::new(writer.reopen())),
-                &cancel_signal,
-            )
-            .unwrap();
+            d.update(&writer, &writer, None, &cancel_signal).unwrap();
         }
         AppendedDescriptorMut::Hash(_) => panic!("Expected hash tree descriptor"),
     }
 
-    // Clear out the signature-related fields and re-sign.
-    header.hash.clear();
-    header.signature.clear();
-    header.public_key.clear();
+    // Verify the hash tree and FEC data.
+    match header.appended_descriptor_mut().unwrap() {
+        AppendedDescriptorMut::HashTree(d) => {
+            d.verify(&writer, &cancel_signal).unwrap();
+        }
+        AppendedDescriptorMut::Hash(_) => panic!("Expected hash tree descriptor"),
+    }
+
+    // Sign the header.
+    let key = get_test_key();
     header.sign(&key).unwrap();
+    assert_eq!(header.verify().unwrap().unwrap(), key.to_public_key());
 
-    // Write new vbmeta structures.
-    avb::write_appended_image(&mut writer, &header, &mut footer, image_size).unwrap();
-    let mut new_data = Vec::new();
+    // Write vbmeta structures.
+    avb::write_appended_image(&mut writer, &header, &mut footer, Some(image_size)).unwrap();
+    let mut data = Vec::new();
     writer.rewind().unwrap();
-    writer.read_to_end(&mut new_data).unwrap();
+    writer.read_to_end(&mut data).unwrap();
 
-    assert_eq!(data, new_data.as_slice());
+    // Verify checksum of the output.
+    assert_eq!(
+        ring::digest::digest(&ring::digest::SHA512, &data).as_ref(),
+        [
+            0xb5, 0x56, 0x65, 0x81, 0x5a, 0x16, 0x65, 0xa9, 0xa6, 0xc6, 0x9e, 0x41, 0x89, 0x9f,
+            0xe9, 0xbc, 0xea, 0x59, 0x4d, 0x14, 0x8a, 0x9e, 0x2b, 0x13, 0xa0, 0x3a, 0x8e, 0xd4,
+            0x59, 0xcd, 0x74, 0xe7, 0x99, 0xbd, 0xa3, 0x58, 0x4b, 0x84, 0xf2, 0x04, 0xe2, 0x12,
+            0x48, 0xfe, 0x4f, 0x67, 0x1f, 0x2a, 0xaa, 0x22, 0x51, 0x19, 0x83, 0x95, 0xa8, 0x03,
+            0xf5, 0x87, 0x12, 0x05, 0x8e, 0x14, 0xd9, 0xbd
+        ],
+    );
+
+    // Parse the generated image.
+    let mut reader = Cursor::new(&data);
+    let (new_header, new_footer, new_image_size) = avb::load_image(&mut reader).unwrap();
+    let new_footer = new_footer.unwrap();
+
+    assert_eq!(new_header, header);
+    assert_eq!(new_footer, footer);
+    assert_eq!(new_image_size, image_size);
+}
+
+#[test]
+fn round_trip_appended_hash_tree_image_minimum_size() {
+    let raw_data: [u8; 8192] = repeat_array(b"foobar");
+    let mut header = Header {
+        required_libavb_version_major: 1,
+        required_libavb_version_minor: 0,
+        algorithm_type: AlgorithmType::Sha256Rsa4096,
+        hash: vec![],       // autogenerated
+        signature: vec![],  // autogenerated
+        public_key: vec![], // autogenerated
+        public_key_metadata: vec![
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+            0x0e, 0x0f,
+        ],
+        descriptors: vec![
+            Descriptor::Property(PropertyDescriptor {
+                key: "foobar".to_owned(),
+                value: b"Invalid UTF-8: \xFF".to_vec(),
+            }),
+            Descriptor::HashTree(HashTreeDescriptor {
+                dm_verity_version: 1,
+                image_size: raw_data.len() as u64,
+                tree_offset: 0, // autogenerated
+                tree_size: 0,   // autogenerated
+                data_block_size: 4096,
+                hash_block_size: 4096,
+                fec_num_roots: 2,
+                fec_offset: 0, // autogenerated
+                fec_size: 0,   // autogenerated
+                hash_algorithm: "sha256".to_owned(),
+                partition_name: "vbmeta_appended_hash_tree".to_owned(),
+                salt: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef].repeat(4),
+                root_digest: vec![], // autogenerated
+                flags: 0,
+                reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+            }),
+        ],
+        rollback_index: 1677974400,
+        flags: 0,
+        rollback_index_location: 0,
+        release_string: repeat_str("MaxLength", 48),
+        reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+    };
+    let mut footer = Footer {
+        version_major: 1,
+        version_minor: 0,
+        original_image_size: 0, // autogenerated
+        vbmeta_offset: 0,       // autogenerated
+        vbmeta_size: 0,         // autogenerated
+        reserved: repeat_array(&[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]),
+    };
+
+    let mut writer = SharedCursor::default();
+    let cancel_signal = AtomicBool::new(false);
+
+    // Write the raw partition data.
+    writer.write_all(&raw_data).unwrap();
+
+    // Generate and write the hash tree and FEC data.
+    match header.appended_descriptor_mut().unwrap() {
+        AppendedDescriptorMut::HashTree(d) => {
+            d.update(&writer, &writer, None, &cancel_signal).unwrap();
+        }
+        AppendedDescriptorMut::Hash(_) => panic!("Expected hash tree descriptor"),
+    }
+
+    // Verify the hash tree and FEC data.
+    match header.appended_descriptor_mut().unwrap() {
+        AppendedDescriptorMut::HashTree(d) => {
+            d.verify(&writer, &cancel_signal).unwrap();
+        }
+        AppendedDescriptorMut::Hash(_) => panic!("Expected hash tree descriptor"),
+    }
+
+    // Sign the header.
+    let key = get_test_key();
+    header.sign(&key).unwrap();
+    assert_eq!(header.verify().unwrap().unwrap(), key.to_public_key());
+
+    // Write vbmeta structures.
+    avb::write_appended_image(&mut writer, &header, &mut footer, None).unwrap();
+    let mut data = Vec::new();
+    writer.rewind().unwrap();
+    writer.read_to_end(&mut data).unwrap();
+
+    // Verify checksum of the output.
+    assert_eq!(
+        ring::digest::digest(&ring::digest::SHA512, &data).as_ref(),
+        [
+            0xd6, 0x69, 0x19, 0x6a, 0x36, 0xc8, 0x1c, 0xe9, 0xc4, 0x85, 0xbe, 0xff, 0x43, 0xb1,
+            0x9f, 0xd4, 0x1d, 0x6c, 0xf9, 0xd2, 0xf3, 0xa6, 0x5f, 0x66, 0x41, 0xd5, 0xf3, 0xfd,
+            0x28, 0xdb, 0x14, 0x67, 0xc6, 0xa8, 0xef, 0xc4, 0xd4, 0x67, 0x6c, 0xb8, 0x66, 0xbb,
+            0x56, 0x5a, 0x4a, 0xf5, 0xd8, 0x92, 0x7c, 0x42, 0xbc, 0x47, 0xdb, 0x94, 0x38, 0x15,
+            0x4b, 0x2d, 0xd0, 0x28, 0x1f, 0xd1, 0x45, 0xa9,
+        ],
+    );
+
+    // Parse the generated image.
+    let mut reader = Cursor::new(&data);
+    let (new_header, new_footer, new_image_size) = avb::load_image(&mut reader).unwrap();
+    let new_footer = new_footer.unwrap();
+
+    assert_eq!(new_header, header);
+    assert_eq!(new_footer, footer);
+    assert_eq!(new_image_size, 28672);
 }

avbroot/tests/bootimage.rs

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
  * SPDX-License-Identifier: GPL-3.0-only
  */
 
@@ -7,7 +7,13 @@ use std::io::Cursor;
 
 use avbroot::{
     self,
-    format::bootimage::{BootImage, BootImageExt},
+    format::{
+        avb::{AlgorithmType, Descriptor, HashDescriptor, Header},
+        bootimage::{
+            self, BootImage, BootImageExt, BootImageV0Through2, BootImageV3Through4, RamdiskMeta,
+            V1Extra, V2Extra, V4Extra, VendorBootImageV3Through4, VendorV4Extra,
+        },
+    },
     stream::{FromReader, ToWriter},
 };
 use pkcs8::DecodePrivateKey;
@@ -26,100 +32,318 @@ fn get_test_key() -> RsaPrivateKey {
     RsaPrivateKey::from_pkcs8_encrypted_pem(data, passphrase.trim_end()).unwrap()
 }
 
-fn round_trip(data: &[u8], expected_version: u32) {
-    let reader = Cursor::new(data);
-    let mut image = BootImage::from_reader(reader).unwrap();
+fn repeat(s: &str, max_len: usize) -> String {
+    assert!(!s.is_empty());
 
+    let mut result = s.repeat(max_len / s.len());
+    result.push_str(&s[..max_len % s.len()]);
+
+    result
+}
+
+fn round_trip(image: &BootImage, sha512: &[u8; 64], expected_version: u32) {
     assert_eq!(image.header_version(), expected_version);
 
-    match &mut image {
-        BootImage::V3Through4(b) => {
-            let should_sign = b
-                .v4_extra
-                .as_ref()
-                .map_or(false, |v4| v4.signature.is_some());
-            let key = get_test_key();
-            let signed = b.sign(&key).unwrap();
-            assert_eq!(signed, should_sign);
-        }
-        _ => {}
-    }
-
     let mut writer = Cursor::new(Vec::new());
     image.to_writer(&mut writer).unwrap();
-    let new_data = writer.into_inner();
+    let data = writer.into_inner();
 
-    assert_eq!(data, new_data);
+    assert_eq!(
+        ring::digest::digest(&ring::digest::SHA512, &data).as_ref(),
+        sha512,
+    );
+
+    let reader = Cursor::new(data);
+    let new_image = BootImage::from_reader(reader).unwrap();
+
+    assert_eq!(&new_image, image);
 }
 
 #[test]
 fn round_trip_v0() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/boot_v0.img",
-    ));
-    round_trip(data, 0);
+    let image = BootImage::V0Through2(BootImageV0Through2 {
+        kernel_addr: 0x01234567,
+        ramdisk_addr: 0x89abcdef,
+        second_addr: 0x02468ace,
+        tags_addr: 0x13579bdf,
+        page_size: 4096,
+        os_version: 0x76543210,
+        name: repeat("Name", 16),
+        cmdline: repeat("Cmdline", 512),
+        id: [
+            0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff, 0xffeeddcc, 0xbbaa9988, 0x77665544,
+            0x33221100,
+        ],
+        extra_cmdline: repeat("ExtraCmdline", 1024),
+        kernel: b"kernel data".to_vec(),
+        ramdisk: b"ramdisk data".to_vec(),
+        second: b"second data".to_vec(),
+        v1_extra: None,
+        v2_extra: None,
+    });
+    let sha512 = [
+        0x23, 0x65, 0x0b, 0xfa, 0x7a, 0x09, 0x0a, 0xdf, 0xdd, 0x9a, 0x6c, 0x03, 0xfa, 0xc5, 0xe1,
+        0xfa, 0x27, 0x65, 0xa0, 0x94, 0xef, 0xa2, 0x0c, 0xc5, 0x3e, 0xd9, 0x67, 0x7d, 0x88, 0x7b,
+        0xb3, 0x48, 0x39, 0xab, 0x28, 0x77, 0x7b, 0x18, 0xec, 0x60, 0xe0, 0xb7, 0x0d, 0x15, 0x26,
+        0xb2, 0xd4, 0x27, 0x25, 0x92, 0x5c, 0x7b, 0x0b, 0x5c, 0xf7, 0xed, 0x27, 0x6c, 0x39, 0xb5,
+        0xb7, 0x44, 0xbb, 0xec,
+    ];
+
+    round_trip(&image, &sha512, 0);
 }
 
 #[test]
 fn round_trip_v1() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/boot_v1.img",
-    ));
-    round_trip(data, 1);
+    let image = BootImage::V0Through2(BootImageV0Through2 {
+        kernel_addr: 0x01234567,
+        ramdisk_addr: 0x89abcdef,
+        second_addr: 0x02468ace,
+        tags_addr: 0x13579bdf,
+        page_size: 4096,
+        os_version: 0x76543210,
+        name: repeat("Name", 16),
+        cmdline: repeat("Cmdline", 512),
+        id: [
+            0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff, 0xffeeddcc, 0xbbaa9988, 0x77665544,
+            0x33221100,
+        ],
+        extra_cmdline: repeat("ExtraCmdline", 1024),
+        kernel: b"kernel data".to_vec(),
+        ramdisk: b"ramdisk data".to_vec(),
+        second: b"second data".to_vec(),
+        v1_extra: Some(V1Extra {
+            recovery_dtbo_offset: 0x0123456789abcdef,
+            recovery_dtbo: b"recovery_dtbo data".to_vec(),
+        }),
+        v2_extra: None,
+    });
+    let sha512 = [
+        0x37, 0x8e, 0xf1, 0xf0, 0xb8, 0x44, 0x0f, 0x9e, 0x16, 0xc0, 0x15, 0x98, 0xa2, 0xb5, 0x06,
+        0x63, 0x59, 0xf4, 0x91, 0xb6, 0x28, 0x03, 0xe6, 0xdc, 0xd2, 0x0d, 0xd7, 0x49, 0x33, 0x63,
+        0x91, 0xd4, 0xa8, 0x24, 0xff, 0xb0, 0x5f, 0x99, 0x2a, 0x9a, 0xb3, 0x66, 0x81, 0x41, 0x69,
+        0xb0, 0xbc, 0xe2, 0x5b, 0x33, 0x3f, 0x39, 0x6a, 0xa8, 0xbd, 0xe1, 0x15, 0x3e, 0x51, 0x5a,
+        0x2a, 0x9d, 0x23, 0x90,
+    ];
+
+    round_trip(&image, &sha512, 1);
 }
 
 #[test]
 fn round_trip_v2() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/boot_v2.img",
-    ));
-    round_trip(data, 2);
+    let image = BootImage::V0Through2(BootImageV0Through2 {
+        kernel_addr: 0x01234567,
+        ramdisk_addr: 0x89abcdef,
+        second_addr: 0x02468ace,
+        tags_addr: 0x13579bdf,
+        page_size: 4096,
+        os_version: 0x76543210,
+        name: repeat("Name", 16),
+        cmdline: repeat("Cmdline", 512),
+        id: [
+            0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff, 0xffeeddcc, 0xbbaa9988, 0x77665544,
+            0x33221100,
+        ],
+        extra_cmdline: repeat("ExtraCmdline", 1024),
+        kernel: b"kernel data".to_vec(),
+        ramdisk: b"ramdisk data".to_vec(),
+        second: b"second data".to_vec(),
+        v1_extra: Some(V1Extra {
+            recovery_dtbo_offset: 0x0123456789abcdef,
+            recovery_dtbo: b"recovery_dtbo data".to_vec(),
+        }),
+        v2_extra: Some(V2Extra {
+            dtb_addr: 0xfedcba9876543210,
+            dtb: b"dtb data".to_vec(),
+        }),
+    });
+    let sha512 = [
+        0x04, 0x24, 0x5b, 0xb7, 0x07, 0x82, 0xa9, 0x08, 0x68, 0xb9, 0xc9, 0x65, 0x1f, 0x53, 0xd7,
+        0x6c, 0xcf, 0xf3, 0x48, 0x58, 0x9a, 0xd4, 0xb1, 0xf3, 0xd8, 0x6f, 0x95, 0x10, 0x70, 0x2f,
+        0x53, 0x30, 0x60, 0x60, 0xe4, 0x68, 0xd9, 0x84, 0xe8, 0x0a, 0xf3, 0x12, 0xb3, 0xa3, 0x1b,
+        0x06, 0x88, 0x2f, 0x5d, 0x34, 0x5a, 0xea, 0x8f, 0xbb, 0x54, 0x49, 0x3c, 0xc1, 0x9c, 0xc6,
+        0x24, 0x80, 0x03, 0xde,
+    ];
+
+    round_trip(&image, &sha512, 2);
 }
 
 #[test]
 fn round_trip_v3() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/boot_v3.img",
-    ));
-    round_trip(data, 3);
+    let image = BootImage::V3Through4(BootImageV3Through4 {
+        os_version: 0x01234567,
+        reserved: [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff],
+        cmdline: repeat("Cmdline", 1536),
+        v4_extra: None,
+        kernel: b"kernel data".to_vec(),
+        ramdisk: b"ramdisk data".to_vec(),
+    });
+    let sha512 = [
+        0x30, 0xea, 0x77, 0x0a, 0xd3, 0x24, 0x6a, 0x3f, 0xf8, 0xdf, 0xe6, 0xd9, 0x5a, 0xa1, 0xd3,
+        0xa4, 0x3b, 0x8a, 0x13, 0x39, 0x5e, 0x58, 0x24, 0x3e, 0x71, 0x31, 0x78, 0xa1, 0x2c, 0xad,
+        0x1d, 0xca, 0x24, 0x12, 0xf5, 0xfb, 0x2c, 0x48, 0xa5, 0x3d, 0xc0, 0x38, 0x55, 0xb6, 0xfd,
+        0xd3, 0x30, 0xe0, 0x69, 0x11, 0x28, 0xd7, 0x29, 0xda, 0x2e, 0x5a, 0x49, 0x5c, 0x39, 0x1d,
+        0xb9, 0xdb, 0x53, 0xe1,
+    ];
+
+    round_trip(&image, &sha512, 3);
 }
 
 #[test]
 fn round_trip_v4() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/boot_v4.img",
-    ));
-    round_trip(data, 4);
+    let image = BootImage::V3Through4(BootImageV3Through4 {
+        os_version: 0x01234567,
+        reserved: [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff],
+        cmdline: repeat("Cmdline", 1536),
+        v4_extra: Some(V4Extra { signature: None }),
+        kernel: b"kernel data".to_vec(),
+        ramdisk: b"ramdisk data".to_vec(),
+    });
+    let sha512 = [
+        0xa8, 0x1d, 0x2b, 0x78, 0x22, 0x45, 0x0b, 0xe7, 0xc2, 0x3a, 0xd8, 0xda, 0x95, 0x49, 0x77,
+        0x18, 0xd0, 0x7b, 0x9b, 0x7f, 0xc7, 0xf6, 0x48, 0xb4, 0x2d, 0x85, 0x6d, 0xe3, 0x5a, 0xa3,
+        0x24, 0xb6, 0x94, 0x56, 0xb9, 0x07, 0x84, 0xdb, 0x50, 0x01, 0xca, 0x6c, 0x86, 0x26, 0x32,
+        0x79, 0x0c, 0xc5, 0x70, 0xcf, 0xcc, 0x7f, 0xc3, 0x5b, 0x96, 0x56, 0x23, 0x5c, 0xd0, 0x50,
+        0xb0, 0x98, 0xdb, 0x4a,
+    ];
+
+    round_trip(&image, &sha512, 4);
 }
 
 #[test]
 fn round_trip_v4_vts() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/boot_v4_vts.img",
-    ));
-    round_trip(data, 4);
+    let mut header = Header {
+        required_libavb_version_major: 1,
+        required_libavb_version_minor: 0,
+        algorithm_type: AlgorithmType::Sha256Rsa4096,
+        hash: vec![],       // autogenerated
+        signature: vec![],  // autogenerated
+        public_key: vec![], // autogenerated
+        public_key_metadata: vec![],
+        descriptors: vec![Descriptor::Hash(HashDescriptor {
+            image_size: 12288,
+            hash_algorithm: "sha256".to_owned(),
+            partition_name: "boot".to_owned(),
+            salt: vec![0x64, 0x30, 0x30, 0x64, 0x66, 0x30, 0x30, 0x64],
+            root_digest: vec![
+                0xab, 0xd5, 0x48, 0x3e, 0x11, 0xe7, 0x94, 0x0c, 0xb9, 0xbf, 0x38, 0x75, 0x87, 0xa4,
+                0xa1, 0x65, 0x99, 0x81, 0xa1, 0xb8, 0x39, 0x62, 0xb7, 0xc1, 0xfa, 0xf1, 0xb0, 0xcd,
+                0x63, 0x07, 0xd4, 0x49,
+            ],
+            flags: 0,
+            reserved: [0; 60],
+        })],
+        rollback_index: 0,
+        flags: 0,
+        rollback_index_location: 0,
+        release_string: "avbtool 1.2.0".to_owned(),
+        reserved: [0; 80],
+    };
+
+    let key = get_test_key();
+    header.sign(&key).unwrap();
+    assert_eq!(header.verify().unwrap().unwrap(), key.to_public_key());
+
+    let image = BootImage::V3Through4(BootImageV3Through4 {
+        os_version: 0x01234567,
+        reserved: [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff],
+        cmdline: repeat("Cmdline", 1536),
+        v4_extra: Some(V4Extra {
+            signature: Some(header),
+        }),
+        kernel: b"kernel data".to_vec(),
+        ramdisk: b"ramdisk data".to_vec(),
+    });
+    let sha512 = [
+        0x19, 0x47, 0x15, 0x3c, 0x1f, 0x62, 0x84, 0xee, 0xbc, 0x16, 0x9e, 0x5a, 0xf2, 0x45, 0x2a,
+        0xf7, 0x40, 0xc2, 0x18, 0x7f, 0x23, 0xb2, 0xa4, 0x20, 0x10, 0xdf, 0xb1, 0x5c, 0xf2, 0x7f,
+        0x6f, 0x79, 0x22, 0x1d, 0x29, 0x27, 0x78, 0xea, 0xb3, 0x9e, 0x1f, 0xfe, 0xeb, 0xc8, 0x9f,
+        0xe6, 0xef, 0xce, 0xa2, 0x28, 0x0b, 0x05, 0x1d, 0x52, 0xff, 0xab, 0xd4, 0x6f, 0x87, 0x11,
+        0xd9, 0xb6, 0x5f, 0x2e,
+    ];
+
+    round_trip(&image, &sha512, 4);
 }
 
 #[test]
 fn round_trip_vendor_v3() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/vendor_v3.img",
-    ));
-    round_trip(data, 3);
+    let image = BootImage::VendorV3Through4(VendorBootImageV3Through4 {
+        page_size: 4096,
+        kernel_addr: 0x01234567,
+        ramdisk_addr: 0x89abcdef,
+        cmdline: repeat("Cmdline", 2048),
+        tags_addr: 0xfedcba98,
+        name: repeat("Name", 16),
+        dtb: b"dtb data".to_vec(),
+        dtb_addr: 0x76543210,
+        ramdisks: vec![b"ramdisk data".to_vec()],
+        v4_extra: None,
+    });
+    let sha512 = [
+        0x17, 0x18, 0xb9, 0x67, 0x4c, 0x82, 0x71, 0x98, 0x6a, 0x8a, 0xb8, 0x85, 0x3c, 0x77, 0x9e,
+        0x27, 0xeb, 0xce, 0x2a, 0x23, 0x04, 0x63, 0x7c, 0x94, 0xd4, 0xad, 0x1f, 0x3c, 0xee, 0x7e,
+        0x41, 0x8b, 0xa8, 0xd9, 0x35, 0xec, 0xf2, 0xc1, 0x52, 0x3a, 0xd9, 0x5b, 0xbe, 0x63, 0xe8,
+        0x00, 0xd2, 0x23, 0x4e, 0x37, 0x76, 0x31, 0x5a, 0xfc, 0x63, 0x43, 0x32, 0x34, 0x30, 0xf6,
+        0x3e, 0x2e, 0x3e, 0x66,
+    ];
+
+    round_trip(&image, &sha512, 3);
 }
 
 #[test]
 fn round_trip_vendor_v4() {
-    let data = include_bytes!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/data/vendor_v4.img",
-    ));
-    round_trip(data, 4);
+    let board_id = [
+        0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff, 0xffeeddcc, 0xbbaa9988, 0x77665544,
+        0x33221100, 0x004488cc, 0x115599dd, 0x2266aaee, 0x3377bbff, 0xffbb7733, 0xeeaa6622,
+        0xdd995511, 0xcc884400,
+    ];
+    let image = BootImage::VendorV3Through4(VendorBootImageV3Through4 {
+        page_size: 2048,
+        kernel_addr: 0x01234567,
+        ramdisk_addr: 0x89abcdef,
+        cmdline: repeat("Cmdline", 2048),
+        tags_addr: 0xfedcba98,
+        name: repeat("Name", 16),
+        dtb: b"dtb data".to_vec(),
+        dtb_addr: 0x76543210,
+        ramdisks: vec![
+            b"ramdisk 0 data".to_vec(),
+            b"ramdisk 1 data".to_vec(),
+            b"ramdisk 2 data".to_vec(),
+            b"ramdisk 3 data".to_vec(),
+        ],
+        v4_extra: Some(VendorV4Extra {
+            ramdisk_metas: vec![
+                RamdiskMeta {
+                    ramdisk_type: bootimage::VENDOR_RAMDISK_TYPE_NONE,
+                    ramdisk_name: repeat("None", 32),
+                    board_id,
+                },
+                RamdiskMeta {
+                    ramdisk_type: bootimage::VENDOR_RAMDISK_TYPE_PLATFORM,
+                    ramdisk_name: repeat("Platform", 32),
+                    board_id,
+                },
+                RamdiskMeta {
+                    ramdisk_type: bootimage::VENDOR_RAMDISK_TYPE_RECOVERY,
+                    ramdisk_name: repeat("Recovery", 32),
+                    board_id,
+                },
+                RamdiskMeta {
+                    ramdisk_type: bootimage::VENDOR_RAMDISK_TYPE_DLKM,
+                    ramdisk_name: repeat("Dlkm", 32),
+                    board_id,
+                },
+            ],
+            bootconfig: "bootconfig data".to_owned(),
+        }),
+    });
+    let sha512 = [
+        0x0e, 0x3f, 0x86, 0x9e, 0xad, 0x98, 0xbb, 0x53, 0xc7, 0xc4, 0x3f, 0xb8, 0xc6, 0x06, 0xdc,
+        0xb2, 0xe5, 0x47, 0x66, 0xe3, 0xaf, 0x2c, 0xa4, 0x91, 0x8d, 0x4b, 0xc5, 0x70, 0x1e, 0x51,
+        0x19, 0x23, 0x7c, 0xab, 0x40, 0x24, 0x95, 0xef, 0xc8, 0x65, 0xdb, 0x5f, 0x0a, 0x41, 0x93,
+        0xff, 0x6c, 0x22, 0xb4, 0x9a, 0xe2, 0x20, 0xc1, 0x95, 0xa0, 0x3c, 0xc2, 0x13, 0xdb, 0xc8,
+        0x24, 0x33, 0x77, 0x75,
+    ];
+
+    round_trip(&image, &sha512, 4);
 }

avbroot/tests/cpio.rs

@@ -0,0 +1,92 @@
+/*
+ * SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+use std::io::{self, Cursor};
+
+use avbroot::{
+    self,
+    format::cpio::{CpioEntry, CpioEntryData, CpioEntryType, CpioReader, CpioWriter},
+    util,
+};
+
+fn generate_archive() -> Vec<u8> {
+    let writer = Cursor::new(Vec::new());
+    let mut cpio_writer = CpioWriter::new(writer, false);
+
+    for entry in [
+        CpioEntry::new_symlink(b"symlink", b"target"),
+        CpioEntry::new_directory(b"directory", 0o755),
+        CpioEntry::new_file(b"file", 0o644, CpioEntryData::Data(b"foobar".to_vec())),
+        CpioEntry {
+            path: b"reserved".to_vec(),
+            data: CpioEntryData::Size(0),
+            inode: 12345,
+            file_type: CpioEntryType::Reserved,
+            file_mode: 0o4777,
+            uid: 12345678,
+            gid: 87654321,
+            nlink: 2,
+            mtime: 1700000000,
+            dev_maj: 2222,
+            dev_min: 3333,
+            rdev_maj: 4444,
+            rdev_min: 5555,
+            crc32: 0xfedcba09,
+        },
+    ] {
+        cpio_writer.start_entry(&entry).unwrap();
+    }
+
+    let writer = cpio_writer.finish().unwrap();
+    let data = writer.into_inner();
+
+    assert_eq!(
+        ring::digest::digest(&ring::digest::SHA512, &data).as_ref(),
+        [
+            0xb0, 0x51, 0xac, 0x28, 0x6f, 0x78, 0xe2, 0xe7, 0x45, 0xa0, 0x52, 0x7c, 0xff, 0x42,
+            0x30, 0x55, 0xbd, 0x64, 0x7d, 0x4e, 0xb8, 0xe6, 0x95, 0xe5, 0x9b, 0xd1, 0x13, 0xd6,
+            0x43, 0x0e, 0x32, 0xb2, 0x4e, 0x62, 0xa4, 0x55, 0x64, 0x48, 0xb7, 0x32, 0x26, 0x57,
+            0x75, 0x07, 0xf5, 0xa6, 0x0f, 0x18, 0xc3, 0x9e, 0x9f, 0x06, 0xdb, 0xa4, 0xf7, 0xeb,
+            0x5e, 0x8f, 0xce, 0xd0, 0x2b, 0x54, 0x39, 0x57
+        ],
+    );
+
+    data
+}
+
+#[test]
+fn round_trip_archive() {
+    let data = generate_archive();
+    assert_ne!(data.len() % 512, 0);
+
+    for pad_to_block_size in [false, true] {
+        println!("Pad to block size: {pad_to_block_size}");
+
+        let reader = Cursor::new(&data);
+        let mut cpio_reader = CpioReader::new(reader, false);
+
+        let writer = Cursor::new(Vec::new());
+        let mut cpio_writer = CpioWriter::new(writer, pad_to_block_size);
+
+        while let Some(entry) = cpio_reader.next_entry().unwrap() {
+            cpio_writer.start_entry(&entry).unwrap();
+
+            if entry.file_type == CpioEntryType::Regular {
+                io::copy(&mut cpio_reader, &mut cpio_writer).unwrap();
+            }
+        }
+
+        let writer = cpio_writer.finish().unwrap();
+        let new_data = writer.get_ref().as_slice();
+
+        if pad_to_block_size {
+            assert!(new_data.starts_with(&data));
+            assert!(util::is_zero(&new_data[data.len()..]));
+            assert_eq!(new_data.len() % 512, 0);
+        } else {
+            assert_eq!(new_data, data);
+        }
+    }
+}

deny.toml

@@ -1,21 +1,44 @@
 [advisories]
-vulnerability = "deny"
-unmaintained = "deny"
+version = 2
 yanked = "deny"
-notice = "deny"
+ignore = [
+    # https://rustsec.org/advisories/RUSTSEC-2023-0071
+    #
+    # This is a side-channel vulnerability where secrets can be leaked to an
+    # attacker that is able to measure the timing of a large number of RSA
+    # operations. As of 2023-12-03, there is no released version of the rsa
+    # crate that contains a fix.
+    #
+    # For avbroot specifically, this vulnerability is not too critical for a
+    # couple reasons:
+    #
+    # 1. avbroot performs RSA signing only at the end of lengthy processes
+    #    that involve a lot of disk I/O. It's very expensive to run avbroot
+    #    the millions of times needed to capture a sufficient amount of timing
+    #    data.
+    # 2. During a single run of avbroot, it will only perform RSA signing a
+    #    handful of times. To get sufficient measurements, the attacker would
+    #    need to rerun avbroot. If they are able to rerun avbroot, then they
+    #    are also able to just read and steal the private key directly.
+    #
+    # avbroot has no network capabilities, so this is not inherently remotely
+    # exploitable.
+    "RUSTSEC-2023-0071",
+]
 
 [licenses]
-unlicensed = "deny"
+version = 2
+include-dev = true
 allow = [
     "Apache-2.0",
+    "Apache-2.0 WITH LLVM-exception",
     "BSD-3-Clause",
+    "GPL-3.0",
     "ISC",
     "MIT",
     "OpenSSL",
     "Unicode-DFS-2016",
 ]
-copyleft = "allow"
-default = "deny"
 
 [[licenses.clarify]]
 name = "ring"
@@ -26,16 +49,27 @@ license-files = [
 
 [bans]
 multiple-versions = "warn"
+multiple-versions-include-dev = true
 deny = [
     # https://github.com/serde-rs/serde/issues/2538
     { name = "serde_derive", version = ">=1.0.172,<1.0.184" },
 ]
 
+[bans.build]
+executables = "deny"
+include-dependencies = true
+include-workspace = true
+bypass = [
+    # Copies of unmodified crashwrangler objects for old macOS versions.
+    { name = "honggfuzz", allow-globs = ["honggfuzz/third_party/mac/CrashReport_*.o"] },
+    # Test files for liblzma's test suite
+    { name = "liblzma-sys", allow-globs = ["xz/tests/compress_prepared_bcj_*"] },
+]
+
 [sources]
 unknown-registry = "deny"
 unknown-git = "deny"
 allow-git = [
-    "https://github.com/chenxiaolong/xz2-rs",
+    "https://github.com/chenxiaolong/bzip2-rs",
     "https://github.com/chenxiaolong/zip",
-    "https://github.com/jongiddy/bzip2-rs",
 ]

e2e/.gitignore

@@ -1 +0,0 @@
-/files/

e2e/Cargo.toml

@@ -10,18 +10,25 @@ publish = false
 
 [dependencies]
 anyhow = "1.0.75"
-attohttpc = "0.26.1"
 avbroot = { path = "../avbroot" }
 clap = { version = "4.4.1", features = ["derive"] }
 ctrlc = "3.4.0"
 hex = { version = "0.4.3", features = ["serde"] }
-ring = "0.16.20"
+ring = "0.17.0"
+rsa = "0.9.6"
 serde = { version = "1.0.188", features = ["derive"] }
 tempfile = "3.8.0"
-toml_edit = { version = "0.19.14", features = ["serde"] }
+toml_edit = { version = "0.22.9", features = ["serde"] }
+topological-sort = "0.2.2"
+tracing = "0.1.40"
+tracing-subscriber = "0.3.18"
+x509-cert = "0.2.5"
 
 # https://github.com/zip-rs/zip/pull/383
 [dependencies.zip]
 git = "https://github.com/chenxiaolong/zip"
 rev = "989101f9384b9e94e36e6e9e0f51908fdf98bde6"
 default-features = false
+
+[features]
+static = ["avbroot/static"]

e2e/README.md

@@ -1,64 +1,26 @@
 # End-to-end tests
 
-avbroot's output file is reproducible for a given input file. [`e2e.toml`](./e2e.toml) lists some OTA images with unique properties and the expected checksums before and after patching. These tests use pregenerated, hardcoded test keys for signing. **These keys should NEVER be used for any other purpose.**
+avbroot's output file is reproducible for a given input file. [`e2e.toml`](./e2e.toml) lists some profiles for generating mock OTA images with unique properties and the expected checksums before and after patching. These tests use pregenerated, hardcoded test keys for signing. **These keys should NEVER be used for any other purpose.**
 
-For each image listed in the config, the test process will:
+For each profile listed in the config, the test process will:
 
-1. Download the OTA if it doesn't already exist in `./files/<device>/` (or the workdir specified by `-w`)
-2. Verify the OTA checksum
-3. Run avbroot against the OTA using `--magisk`
-4. Extract the AVB-related partitions from the patched OTA and verify their checksums
-5. Verify the patched OTA checksum
+1. Generate a mock OTA based on the specification
+2. Verify tha original OTA checksum
+3. Run avbroot against the OTA using `--magisk` (with a mock Magisk APK)
+4. Verify the patched OTA checksum
+5. Extract the AVB-related partitions from the patched OTA
 6. Run avbroot against the OTA again using `--prepatched`
 7. Verify the patched OTA checksum again
 
-For more efficient CI testing, the tests can operate on "stripped" OTAs. A stripped OTA is identical to the full OTA, except that partitions in `payload.bin` unrelated to AVB are zeroed out. This reduces the download size and disk space requirements by a couple orders of magnitude. **A stripped OTA is NOT bootable and should never be flashed on a real device.**
+The default profiles shipped with the project mimic how various stock OTAs for Pixel devices are built. The generated mock OTAs have valid signatures and data structures for all components, but without any actual data where possible. For example, most files in the ramdisks are empty files. To ensure the mock OTAs cannot be mistakenly installed on a real device, the OTA metadata lists a fake device name in the preconditions section.
 
 ## Running the tests
 
-To test against the device OTA images listed in [`e2e.toml`](./e2e.toml), run:
+To test against the profiles listed in [`e2e.toml`](./e2e.toml), run:
 
 ```bash
-# To test all device OTAs
+# To test all profiles
 cargo run --release -- test -a
-# Or to test against specific device OTAs
-cargo run --release -- test -d cheetah -d bluejay
+# Or to test against specific profiles
+cargo run --release -- test -p pixel_v4_gki -p pixel_v4_non_gki
 ```
-
-To test against stripped OTAs (smaller download, but not bootable), pass in `--stripped`.
-
-## Downloading a device image
-
-To download a full OTA image, run:
-
-```bash
-cargo run --release -- download -d <device>
-```
-
-This normally happens automatically when running the `test` subcommand. To download the stripped OTA image instead, pass in `--stripped`.
-
-If the image file does not already exist, then it will be downloaded and the checksums will be validated. If the download is interrupted, it will automatically resume when the command is rerun. If the file is already downloaded, the command is effectively a no-op unless `--revalidate` is passed in to revalidate the image checksums.
-
-## Adding a new device image
-
-To add a new device image to the testing configuration, run:
-
-```bash
-cargo run --release -- add -d <device> -u <full OTA URL> -H <expected checksum>
-```
-
-If the OS vendor does not provide a SHA-256 checksum, omit `-H` and the program will compute the checksum from the downloaded data.
-
-This process will download the full OTA, strip it, patch the full OTA, patch the stripped OTA, extract the AVB partitions, and write all of the checksums to [`e2e.toml`](./e2e.toml).
-
-The process for updating an existing device config is exactly the same as adding a new one.
-
-## Stripping a full OTA
-
-To convert a full OTA to the stripped form, run:
-
-```bash
-cargo run --release -- strip -i <input zip> -o <output zip>
-```
-
-This normally happens automatically as a part of adding a new device image.

e2e/e2e.toml

@@ -1,116 +1,148 @@
-[magisk]
-"url" = "https://github.com/topjohnwu/Magisk/releases/download/v26.0/Magisk-v26.0.apk"
-"hash" = "9e14d3d3ca1f1a2765f8ca215ebbf35ea5fd2896fb147eea581fcaa3b4e77d25"
+# Metadata used when generating OTAs. These values don't affect behavior at all.
+[ota_info]
+# Make sure generated OTAs aren't flashable on real devices.
+device = "avbroot_fake_device"
+fingerprint = "avbroot/avbroot_fake_device:14/UQ1A.240101.000/12345678:user/release-keys"
+build_number = "UQ1A.240101.000"
+incremental_version = "12345678"
+android_version = "14"
+sdk_version = "34"
+security_patch_level = "2024-01-01"
 
 # Google Pixel 7 Pro
 # What's unique: init_boot (boot v4) + vendor_boot (vendor v4)
-[device.cheetah]
-url = "https://dl.google.com/dl/android/aosp/cheetah-ota-tq2a.230305.008.c1-6ac5ff2e.zip"
-sections = [
-    { start = 0, end = 151715 },
-    { start = 21683150, end = 23179365 },
-    { start = 2043499985, end = 2043508325 },
-    { start = 2315331822, end = 2333060126 },
-    { start = 2344084950, end = 2344090066 },
-]
-hash.original.full = "6ac5ff2e14dc16755ea4ea30e6dbe25103b889a36a465194ef943bd0d665b91c"
-hash.original.stripped = "549522015f0369a3b89385f532ab62235b47c2c39540bd0adaaf6acc81fdda94"
-hash.patched.full = "b380720852e2a1e994bcf38064f577bac68b18e799cf8166cb6a7edb8a661cb4"
-hash.patched.stripped = "560cdf4d7b25fb5bc650f96ae5a3c7593ac229a364bb39887287cfb734f6b377"
-hash.avb_images."init_boot.img" = "fac9305ce22b897fbfb193968d5346f4c70f6c18c3060bb106226f134ce5f433"
-hash.avb_images."vbmeta.img" = "0b3d719b751dd43bbec95d02b1bf57b5dae62e42a52502895892a207b773e77d"
-hash.avb_images."vbmeta_system.img" = "cf8c77dcf0a4474d49b5bdc2a44bdb3646464d5212fbe12aa5d3c5f531742f4f"
-hash.avb_images."vbmeta_vendor.img" = "660d8f61acd95a4f8ad416b4cbe126e9c039706462b4236ad723953c72ac49a8"
-hash.avb_images."vendor_boot.img" = "c788d4d8eb7926ad1bfa2a9c000343c3c73cedc580449f5270a711feb620f033"
+
+[profile.pixel_v4_gki.partitions.boot]
+avb.signed = true
+data.type = "boot"
+data.version = "v4"
+data.kernel = true
+
+[profile.pixel_v4_gki.partitions.init_boot]
+avb.signed = true
+data.type = "boot"
+data.version = "v4"
+data.ramdisks = [["init", "first_stage"]]
+
+[profile.pixel_v4_gki.partitions.system]
+avb.signed = false
+data.type = "dm_verity"
+data.content = "system_otacerts"
+
+[profile.pixel_v4_gki.partitions.vbmeta]
+avb.signed = true
+data.type = "vbmeta"
+data.deps = ["boot", "init_boot", "vendor_boot", "vbmeta_system"]
+
+[profile.pixel_v4_gki.partitions.vbmeta_system]
+avb.signed = true
+data.type = "vbmeta"
+data.deps = ["system"]
+
+[profile.pixel_v4_gki.partitions.vendor_boot]
+avb.signed = false
+data.type = "boot"
+data.version = "vendor_v4"
+data.ramdisks = [["otacerts", "first_stage", "dsu_key_dir"]]
+
+[profile.pixel_v4_gki.hashes]
+original = "6b140c378d21eae2fa4fc581bce13a689b21bd32f5fba865698d1fd322f2f8c6"
+patched = "f00e9745f90754be28ce8355501d876759cd8336451e4c3633908fbb4217b422"
 
 # Google Pixel 6a
 # What's unique: boot (boot v4, no ramdisk) + vendor_boot (vendor v4, 2 ramdisks)
-[device.bluejay]
-url = "https://dl.google.com/dl/android/aosp/bluejay-ota-tq2a.230305.008.e1-915f9087.zip"
-sections = [
-    { start = 0, end = 140787 },
-    { start = 1060207, end = 21612852 },
-    { start = 1886150700, end = 1886158844 },
-    { start = 2069112987, end = 2092260102 },
-    { start = 2098778558, end = 2098783674 },
-]
-hash.original.full = "915f9087b627b6961be9bb447dc63a7a1083b536753a78715e98641eaeb9c9d1"
-hash.original.stripped = "a3ee5b6e39e687665c31790118ab9f47715b0b8285ae9847dbf81307f963db14"
-hash.patched.full = "bfa7b26d90bdc889a7a199439e1564b219e5e2dbfddc1657bc1c6b73229be67e"
-hash.patched.stripped = "4e56ee4a8554f2b08ffc2f1470ad60b9b63d2b6fb469ed1f7c4b1204bbf8ad7d"
-hash.avb_images."boot.img" = "a1a705092e7034d20b83c94d78291418e13c343b1573c1b11e0fc884fc00ae62"
-hash.avb_images."vbmeta.img" = "3c123705be57ab142d2b43beef9b123eaad129df17a523b59b1d63b9122d28b0"
-hash.avb_images."vbmeta_system.img" = "285b83e4290f3257dc3678f0c3191794830bb2d72fb0969b69fc8f09d7ddff12"
-hash.avb_images."vbmeta_vendor.img" = "981f736586b91a9f4c93c4208a0d191a35ff15118c6fa505d755ee7fda8b2477"
-hash.avb_images."vendor_boot.img" = "ceffcb4fdb33aa3bb2c70621060acd5af612206b21cc413d5c2d39fee25144ab"
+
+[profile.pixel_v4_non_gki.partitions.boot]
+avb.signed = true
+data.type = "boot"
+data.version = "v4"
+data.kernel = true
+
+[profile.pixel_v4_non_gki.partitions.system]
+avb.signed = false
+data.type = "dm_verity"
+data.content = "system_otacerts"
+
+[profile.pixel_v4_non_gki.partitions.vbmeta]
+avb.signed = true
+data.type = "vbmeta"
+data.deps = ["boot", "vendor_boot", "vbmeta_system"]
+
+[profile.pixel_v4_non_gki.partitions.vbmeta_system]
+avb.signed = true
+data.type = "vbmeta"
+data.deps = ["system"]
+
+[profile.pixel_v4_non_gki.partitions.vendor_boot]
+avb.signed = false
+data.type = "boot"
+data.version = "vendor_v4"
+data.ramdisks = [["init", "otacerts", "first_stage", "dsu_key_dir"], ["dlkm"]]
+
+[profile.pixel_v4_non_gki.hashes]
+original = "31963e6f81986c6686111f50e36b89e4d85ee5c02bc8e5ecd560528bc98d6fe7"
+patched = "43959409034dbb9aa0a605d7c5c0e7885012bbcd63510ec87d8e97015b37a746"
 
 # Google Pixel 4a 5G
 # What's unique: boot (boot v3) + vendor_boot (vendor v3)
-[device.bramble]
-url = "https://dl.google.com/dl/android/aosp/bramble-ota-tq2a.230305.008.c1-a925dd09.zip"
-sections = [
-    { start = 0, end = 140531 },
-    { start = 496187, end = 11655082 },
-    { start = 1650283561, end = 1650287993 },
-    { start = 1884739919, end = 1908081011 },
-    { start = 1910894027, end = 1910899144 },
-]
-hash.original.full = "a925dd09c8d613d46cf72677c16f4fadee18bc21734d57047c6ccf31f672507b"
-hash.original.stripped = "79322b0b417359e8f072032de676d7e5bd2715a3b3554c48ed5cc9e9a25c6866"
-hash.patched.full = "cf79cd60acd3635f5085d8bb411d4a8dc4d7e62440f62a14e7ea12f5a9b7cd8a"
-hash.patched.stripped = "b684a78fe08014f1633e74d1f380e137823ba77a47ddf428bc649364f5548b75"
-hash.avb_images."boot.img" = "2bbf2c6d2f82d454426b26ac3b4887b26ca0591b458e6cf137207ecbb8f7649d"
-hash.avb_images."vbmeta.img" = "ab3b2487671b3fc28e163898621d6c068164d335b6ddd9b94e4fde9471c95d66"
-hash.avb_images."vbmeta_system.img" = "2fcd52d7462916a8510bbb07f2f5a14200afe2de97568396fe75e04c5c283152"
-hash.avb_images."vendor_boot.img" = "e27f157c4ebf4e958165997a4b87d4de1cfc34f4dea423a153327a27b053cac7"
+
+[profile.pixel_v3.partitions.boot]
+avb.signed = true
+data.type = "boot"
+data.version = "v3"
+data.kernel = true
+data.ramdisks = [["init"]]
+
+[profile.pixel_v3.partitions.system]
+avb.signed = false
+data.type = "dm_verity"
+data.content = "system_otacerts"
+
+[profile.pixel_v3.partitions.vbmeta]
+avb.signed = true
+data.type = "vbmeta"
+data.deps = ["boot", "vendor_boot", "vbmeta_system"]
+
+[profile.pixel_v3.partitions.vbmeta_system]
+avb.signed = true
+data.type = "vbmeta"
+data.deps = ["system"]
+
+[profile.pixel_v3.partitions.vendor_boot]
+avb.signed = false
+data.type = "boot"
+data.version = "vendor_v3"
+data.ramdisks = [["otacerts", "first_stage", "dsu_key_dir"]]
+
+[profile.pixel_v3.hashes]
+original = "e684aacb54464098c1b8e3f499efe35dff10ea792e89d71a83404620d0108b3e"
+patched = "08e03ec327bf5bd841b91ad8d53028c3439a1722b423aaaac6cc0ceee4ef66b1"
 
 # Google Pixel 4a
 # What's unique: boot (boot v2)
-[device.sunfish]
-url = "https://dl.google.com/dl/android/aosp/sunfish-ota-tq2a.230305.008.c1-174fd16b.zip"
-sections = [
-    { start = 0, end = 129700 },
-    { start = 476996, end = 34035261 },
-    { start = 1624751947, end = 1624756371 },
-    { start = 1823132563, end = 1823137581 },
-]
-hash.original.full = "174fd16b47ef994ea8f3cb0f3fb456df2654b0aa1f9ea6fb8e54e5c6319f2601"
-hash.original.stripped = "943ce3ae2aac8a0ccd4a7e9d4e38a9c495c39639f2621c6853be4c7a3fa0fc26"
-hash.patched.full = "cdfffa731f0aca0ab9eff1e7d7bfee8c4716054d64cf0a47e50f50da6cbdb849"
-hash.patched.stripped = "35b720058c460dd28b00f40bed4bcd1d133522d42d00ba048172b3092a7444ee"
-hash.avb_images."boot.img" = "22182f2efc7043f35d79e71abb400ce919c6b3b8419405e16469644932367ee6"
-hash.avb_images."vbmeta.img" = "4cbe171bb37515f59cd4082cc2d982ca1edfeba9db09dd62c8959dd318423888"
-hash.avb_images."vbmeta_system.img" = "7cdb590bfc1056a5a8c7606ff05e99eb344efe108296682698b5cfe83905e0cd"
 
-# OnePlus 10 Pro
-# Build NE2215_11_C.26
-# What's unique:
-# - boot (boot v4) + recovery (boot v4)
-# - boot images have VTS signature block filled with all 0s
-# - payload.bin uses ZERO blocks
-# Build info:
-# - Unofficial list of full OTAs: https://forum.xda-developers.com/t/oneplus-10-pro-rom-ota-oxygen-os-repo-of-oxygen-os-builds.4572593/
-# - The North American builds are used because they're the only ones hosted on
-#   a well known domain
-# - The build number can be found in <my_manifest>/build.prop since it's not
-#   obvious from the filename
-[device.ossi]
-url = "https://android.googleapis.com/packages/ota-api/package/4cacbe5e6a3ab6a6fade68cc40f44d0fa6a2928a.zip"
-sections = [
-    { start = 0, end = 204048 },
-    { start = 19105432, end = 34966775 },
-    { start = 2657405750, end = 2657407254 },
-    { start = 4984045446, end = 5006377281 },
-    { start = 5114504441, end = 5114507197 },
-    { start = 5138158449, end = 5138159817 },
-    { start = 5140101511, end = 5140105324 },
-]
-hash.original.full = "929f892fbd70699cf7f118a119aac1ae1b86351e1ada17715666fa4401e63472"
-hash.original.stripped = "4eabaf79b6c2b5df305e3ecdc2b9570c0dd27350b4e8d6434584000c4989ff3d"
-hash.patched.full = "3453b2eda97ca1ba7367fa9d0dd37b21a5065e2e57cc3bbe9a6f135349d42d0b"
-hash.patched.stripped = "1a41e435bdbf4302761e719e218e8682145644c0fe276739c3265f392adbd74d"
-hash.avb_images."boot.img" = "f5dc3b147c54589be8db00ca15257a3688424a9eb88bd9c2cec82ebf4f6bf859"
-hash.avb_images."recovery.img" = "a42c0bf4f023cd24394184a33ee113783a9c89a7cc4c0c582a5f72cc23b72309"
-hash.avb_images."vbmeta.img" = "c022cf79da301a8430af5c49704944c490707fa0306031fe3ea22c39ce4734f6"
-hash.avb_images."vbmeta_system.img" = "749616b7f04487c05e9e363ad2071a0ab3bae29d497daf1f1a7695f7c8cfa82a"
-hash.avb_images."vbmeta_vendor.img" = "a6037fce745384425fb12745b8568386b84fb57ca6f94f6e47bcf754de341ae4"
+[profile.pixel_v2.partitions.boot]
+avb.signed = false
+data.type = "boot"
+data.version = "v2"
+data.kernel = true
+data.ramdisks = [["init", "otacerts", "first_stage", "dsu_key_dir"]]
+
+[profile.pixel_v2.partitions.system]
+avb.signed = false
+data.type = "dm_verity"
+data.content = "system_otacerts"
+
+[profile.pixel_v2.partitions.vbmeta]
+avb.signed = true
+data.type = "vbmeta"
+data.deps = ["boot", "vbmeta_system"]
+
+[profile.pixel_v2.partitions.vbmeta_system]
+avb.signed = true
+data.type = "vbmeta"
+data.deps = ["system"]
+
+[profile.pixel_v2.hashes]
+original = "ee9568797d9195985f14753b89949d8ebb08c8863a32eceeeec6e8d94661b1cf"
+patched = "5e265094d4164cedde8f483911c58860f6008b314dc8e5ed3b44deb53fbb2f96"

e2e/keys/ORIG_KEY_DO_NOT_USE_avb.key

@@ -0,0 +1,54 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----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+-----END ENCRYPTED PRIVATE KEY-----

e2e/keys/ORIG_KEY_DO_NOT_USE_avb.passphrase

@@ -0,0 +1 @@
+CWokJ23olHitbyjqw6aZoIFhAo3mwzwdEEkv7sjh600hPwR0YNUDxSkNA7ztK5Ii

e2e/keys/ORIG_KEY_DO_NOT_USE_ota.crt

@@ -0,0 +1,29 @@
+-----BEGIN CERTIFICATE-----
+MIIE6jCCAtKgAwIBAgIIG/hHrySZ878wDQYJKoZIhvcNAQELBQAwEjEQMA4GA1UE
+AwwHYXZicm9vdDAgFw0yMzEyMjYwMzQwNDBaGA8yMDUxMDUxMzAzNDA0MFowEjEQ
+MA4GA1UEAwwHYXZicm9vdDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
+AK9VVEeI2UnjQr3IrVlZddq2lTHOlV8qFBVzMguVJUr128HqIXQRgXbEzHfCOOzC
+Nuh2x+cBXO7gztpwjSJFi2P+q4OdEujmgCf8SdwxS1NqWo5TRsB9szPALeQ+FQi8
+yir+urv6uJUuDpwwPgjhCDwn1tL426c4HgGsQpO0IWjCzc2SWL+KP4zirk7GIf2R
+Fy0TsFeJi5ucHWiMuXCGyiPZ2xV7AZ3AakZnf6rqWEIkOOsBf6UVNxFKuppMBcY6
+Lb6YcXB7nn2xFwZ+S5gGdZjkZIlLAoZjRynVRBz2BwlJB6ignH8+MbWkYS6ls9C8
+C10SmiGXI/S/DhRR11JCNAC5AD8FO+A6i9Vp19PiVmUv6nTx01+FhRqTeiW5bPhk
+PTn9gUAU5FKL4ouhr3ojJd6BczdJ2lWB9lQYmWnwzdYnSAnvXwc3WaSX+ryi7LoJ
+sZtlc91ZT2yNiqmPQpH6fcPKfi/BJZhe61hZ7Xv3+OVupbmU+IuUK9iKEw5+aqNt
+DiT15PKoyKuAfm0A/TJ1UV/P4FbSavEOrMse2SZvhRL/EvwpRXwaiwPFQL/vZ5GZ
+mGCXdmVt0FEH9z3UyYq9+UIhZoQh3V9eSrOgjOh3dnFZN5E/UQzqndykGy+pYjG4
+e4ZZQjQR5G3pmAiCIngqnqRUNWpG5DQcZYuXLdor19o5AgMBAAGjQjBAMB0GA1Ud
+DgQWBBQgy5IQsP4+QnQRWlMJiFsqwyXAzTAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud
+DwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAn8pexl/crAWBPJ/nPu9rhRo0
+dowLhbamhx/i5RRNxIJl8Lpf78Boj4t9ICuTU4yeLFHfA+IcnthS/wrFADbhSgF5
+m4gLBSfRjtiOPJSJqkIqCIV6RIcbfdCJa/V3p1nvu3vuGYEp9eSYACEtv6kLaMFu
+61RsEWgR6tNmb1Hssl9XzGdM2yf2vy/Gip+Ugztz9gfTF3Vhdos9VToPOzLNQh6C
+dr+uLKnnPHOb9PfAonYs23MAfpBaP8m4sEMkyMgACCUP+qld0S8xpptEA/9Wblxy
+zWJIZTNWhyfo7cH030lVbdgMBYtZN/WxYVtD3fp+BZPk5fD3QwM712Ja288anDic
+HRwtc0wFwJ9EOOwXT1kYT1GgKrmLTnmAGDktnjKtsHMvl7Rn2Wf+5XTQ3FC99DJU
+q/Jhe3BGUvOXS7uPfUSMQrH4q+cwUdPSLGu2TSPyXVUEv5/Z4mH4JD+HQbJrKjdO
+NvUlnNJgtL3nIW8iSR1BRkIQn9HAnHtfYELHFBr1XHdn8LCjeWmYStdI3s9jucWb
+5uIfij1/50hc6A5zl20/y1h9OGFKdRttjk9XzRR6HPt22zyStjab5Y5SzHOwMCaP
+wk/uDc+Aestyqm7BoIqU8XptC+VV92OoNiEouI0UI5zPw9EWLRmTjFAc4NzOc1I7
+2AKjtz3xnKC3R3oqtsA=
+-----END CERTIFICATE-----

e2e/keys/ORIG_KEY_DO_NOT_USE_ota.key

@@ -0,0 +1,54 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----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+-----END ENCRYPTED PRIVATE KEY-----

e2e/keys/ORIG_KEY_DO_NOT_USE_ota.passphrase

@@ -0,0 +1 @@
+R9iItBaS278KvqlLyil1yUlizNGvWI93SERQ6uAitbzXm4fOc9t3c8dG8r2ThuZz

e2e/src/cli.rs

@@ -3,44 +3,22 @@
  * SPDX-License-Identifier: GPL-3.0-only
  */
 
-use std::{ffi::OsString, path::PathBuf, str::FromStr};
+use std::path::PathBuf;
 
-use anyhow::Result;
+use avbroot::cli::args::{LogFormat, LogLevel};
 use clap::{Args, Parser, Subcommand};
 
 #[derive(Debug, Args)]
-pub struct DeviceGroup {
-    /// Device config name.
+pub struct ProfileGroup {
+    /// OTA profile name.
     #[arg(short, long, value_name = "NAME")]
-    pub device: Vec<String>,
+    pub profile: Vec<String>,
 
-    /// All device configs.
-    #[arg(short, long, conflicts_with = "device")]
+    /// All profiles.
+    #[arg(short, long, conflicts_with = "profile")]
     pub all: bool,
 }
 
-#[derive(Debug, Args)]
-pub struct DownloadGroup {
-    /// Revalidate hash of existing download.
-    #[arg(long)]
-    pub revalidate: bool,
-
-    /// Download the stripped OTA instead of the full OTA.
-    #[arg(long)]
-    pub stripped: bool,
-}
-
-#[derive(Debug, Args)]
-pub struct PatchGroup {
-    /// Delete patched output files on success.
-    #[arg(long)]
-    pub delete_on_success: bool,
-
-    /// Suffix for patched output files.
-    #[arg(long = "output-file-suffix", value_parser, default_value = ".patched")]
-    pub suffix: OsString,
-}
-
 #[derive(Debug, Args)]
 pub struct ConfigGroup {
     /// Path to config file.
@@ -53,112 +31,26 @@ pub struct ConfigGroup {
     )]
     pub config: PathBuf,
 
-    /// Working directory for storing images.
-    #[arg(
-        short,
-        long,
-        value_name = "DIRECTORY",
-        value_parser,
-        default_value = "files"
-    )]
-    pub work_dir: PathBuf,
-}
-
-/// Convert a full OTA to stripped form.
-///
-/// A stripped OTA omits byte regions of the OTA that aren't needed for testing
-/// avbroot's patching logic (eg. the system partition image). This reduces the
-/// size of the test files by about two orders of magnitude.
-#[derive(Debug, Parser)]
-pub struct StripCli {
-    /// Path to original OTA zip.
-    #[arg(short, long, value_name = "FILE", value_parser)]
-    pub input: PathBuf,
-
-    /// Path to new stripped OTA zip.
-    #[arg(short, long, value_name = "FILE", value_parser)]
-    pub output: PathBuf,
-}
-
-#[derive(Debug, Clone)]
-pub struct Sha256Arg(pub [u8; 32]);
-
-impl FromStr for Sha256Arg {
-    type Err = hex::FromHexError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut data = [0u8; 32];
-        hex::decode_to_slice(s, &mut data)?;
-        Ok(Self(data))
-    }
-}
-
-/// Add a new OTA image to the test config.
-///
-/// This will download the OTA image, strip it, patch both images, and add the
-/// resulting metadata (eg. checksums) to the specified test config file.
-#[derive(Debug, Parser)]
-pub struct AddCli {
-    /// URL to the full OTA zip.
-    #[arg(short, long)]
-    pub url: String,
-
-    /// Device config name.
-    #[arg(short, long, value_name = "NAME")]
-    pub device: String,
-
-    /// Expected sha256 hash of the full OTA zip.
-    #[arg(short = 'H', long, value_name = "SHA256_HEX", value_parser)]
-    pub hash: Option<Sha256Arg>,
-
-    #[command(flatten)]
-    pub patch: PatchGroup,
-
-    #[command(flatten)]
-    pub config: ConfigGroup,
-
-    /// Skip verifying OTA and AVB signatures.
+    /// Working directory.
     ///
-    /// OTAs for some devices (eg. ossi) ship with vbmeta partitions containing
-    /// invalid hashes. These will normally fail during validation.
-    #[arg(long)]
-    pub skip_verify: bool,
-}
-
-/// Download a device image.
-#[derive(Debug, Parser)]
-pub struct DownloadCli {
-    /// Download the Magisk APK.
-    #[arg(short, long)]
-    pub magisk: bool,
-
-    #[command(flatten)]
-    pub device: DeviceGroup,
-
-    #[command(flatten)]
-    pub download: DownloadGroup,
-
-    #[command(flatten)]
-    pub config: ConfigGroup,
+    /// If unset, a temporary directory is used, which will be automatically
+    /// cleaned up, even if a failure occurs. Custom working directories are
+    /// not deleted.
+    #[arg(short, long, value_name = "DIRECTORY", value_parser)]
+    pub work_dir: Option<PathBuf>,
 }
 
 /// Run tests.
 #[derive(Debug, Parser)]
 pub struct TestCli {
     #[command(flatten)]
-    pub device: DeviceGroup,
-
-    #[command(flatten)]
-    pub download: DownloadGroup,
-
-    #[command(flatten)]
-    pub patch: PatchGroup,
+    pub profile: ProfileGroup,
 
     #[command(flatten)]
     pub config: ConfigGroup,
 }
 
-/// List devices in config file.
+/// List profiles in config file.
 #[derive(Debug, Parser)]
 pub struct ListCli {
     #[command(flatten)]
@@ -167,9 +59,6 @@ pub struct ListCli {
 
 #[derive(Debug, Subcommand)]
 pub enum Command {
-    Strip(StripCli),
-    Add(AddCli),
-    Download(DownloadCli),
     Test(TestCli),
     List(ListCli),
 }
@@ -178,4 +67,12 @@ pub enum Command {
 pub struct Cli {
     #[command(subcommand)]
     pub command: Command,
+
+    /// Lowest log message severity to output.
+    #[arg(long, global = true, value_name = "LEVEL", default_value_t)]
+    pub log_level: LogLevel,
+
+    /// Output format for log messages.
+    #[arg(long, global = true, value_name = "FORMAT", default_value_t = LogFormat::Medium)]
+    pub log_format: LogFormat,
 }

e2e/src/config.rs

@@ -1,17 +1,13 @@
 /*
- * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+ * SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
  * SPDX-License-Identifier: GPL-3.0-only
  */
 
-use std::{collections::BTreeMap, fs, ops::Range, path::Path};
+use std::{collections::BTreeMap, fs, path::Path};
 
 use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
-use toml_edit::{
-    ser::ValueSerializer,
-    visit_mut::{self, VisitMut},
-    Array, Document, InlineTable, Item, KeyMut, Table, Value,
-};
+use toml_edit::DocumentMut;
 
 #[derive(Serialize, Deserialize)]
 pub struct Sha256Hash(
@@ -23,118 +19,114 @@ pub struct Sha256Hash(
 );
 
 #[derive(Serialize, Deserialize)]
-pub struct Magisk {
-    pub url: String,
-    pub hash: Sha256Hash,
+#[serde(deny_unknown_fields)]
+pub struct OtaInfo {
+    pub device: String,
+    pub fingerprint: String,
+    pub build_number: String,
+    pub incremental_version: String,
+    pub android_version: String,
+    pub sdk_version: String,
+    pub security_patch_level: String,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct OtaHashes {
-    pub full: Sha256Hash,
-    pub stripped: Sha256Hash,
+#[serde(deny_unknown_fields)]
+pub struct Avb {
+    pub signed: bool,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RamdiskContent {
+    Init,
+    Otacerts,
+    FirstStage,
+    DsuKeyDir,
+    Dlkm,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum BootVersion {
+    V2,
+    V3,
+    V4,
+    VendorV3,
+    VendorV4,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct ImageHashes {
-    pub original: OtaHashes,
-    pub patched: OtaHashes,
-    pub avb_images: BTreeMap<String, Sha256Hash>,
+#[serde(deny_unknown_fields)]
+pub struct BootData {
+    pub version: BootVersion,
+    #[serde(default)]
+    pub kernel: bool,
+    #[serde(default)]
+    pub ramdisks: Vec<Vec<RamdiskContent>>,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DmVerityContent {
+    SystemOtacerts,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct Device {
-    pub url: String,
-    pub sections: Vec<Range<u64>>,
-    pub hash: ImageHashes,
+#[serde(deny_unknown_fields)]
+pub struct DmVerityData {
+    pub content: DmVerityContent,
 }
 
 #[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct VbmetaData {
+    pub deps: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum Data {
+    Boot(BootData),
+    DmVerity(DmVerityData),
+    Vbmeta(VbmetaData),
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Hashes {
+    pub original: Sha256Hash,
+    pub patched: Sha256Hash,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Partition {
+    pub avb: Avb,
+    pub data: Data,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Profile {
+    pub partitions: BTreeMap<String, Partition>,
+    pub hashes: Hashes,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct Config {
-    pub magisk: Magisk,
-    pub device: BTreeMap<String, Device>,
+    pub ota_info: OtaInfo,
+    #[serde(default)]
+    pub profile: BTreeMap<String, Profile>,
 }
 
-struct ConfigFormatter;
-
-impl VisitMut for ConfigFormatter {
-    fn visit_table_like_kv_mut(&mut self, key: KeyMut<'_>, node: &mut Item) {
-        // Convert non-array-of-tables inline tables into regular tables.
-        if let Item::Value(Value::InlineTable(t)) = node {
-            let inline_table = std::mem::replace(t, InlineTable::new());
-            *node = Item::Table(inline_table.into_table());
-        }
-
-        // But for hashes, use dotted notation until TOML 1.1, which allows
-        // newlines in inline tables, is released.
-        if key == "hash" || key == "original" || key == "patched" || key == "avb_images" {
-            if let Some(t) = node.as_table_like_mut() {
-                t.set_dotted(true);
-            }
-        }
-
-        visit_mut::visit_table_like_kv_mut(self, key, node);
-    }
-
-    fn visit_table_mut(&mut self, node: &mut Table) {
-        // Make tables implicit unless they are empty, which may be meaningful.
-        if !node.is_empty() {
-            node.set_implicit(true);
-        }
-
-        visit_mut::visit_table_mut(self, node);
-    }
-
-    fn visit_array_mut(&mut self, node: &mut Array) {
-        visit_mut::visit_array_mut(self, node);
-
-        // Put array elements on their own indented lines.
-        if node.is_empty() {
-            node.set_trailing("");
-            node.set_trailing_comma(false);
-        } else {
-            for item in node.iter_mut() {
-                item.decor_mut().set_prefix("\n    ");
-            }
-            node.set_trailing("\n");
-            node.set_trailing_comma(true);
-        }
-    }
-}
-
-/// Add a device to the config file. This leaves all comments intact, except for
-/// those contained within the existing device section if it exists.
-pub fn add_device(document: &mut Document, name: &str, device: &Device) -> Result<()> {
-    let device_table = document.entry("device").or_insert_with(|| {
-        let mut t = toml_edit::Table::new();
-        t.set_implicit(true);
-        Item::Table(t)
-    });
-    let old_table = device_table.get(name).and_then(|i| i.as_table());
-
-    let value = device.serialize(ValueSerializer::new())?;
-    let Value::InlineTable(inline_table) = value else {
-        unreachable!("Device did not serialize as an inline table");
-    };
-    let mut table = inline_table.into_table();
-
-    ConfigFormatter.visit_table_mut(&mut table);
-
-    // Keep top-level comment on the table.
-    if let Some(t) = old_table {
-        *table.decor_mut() = t.decor().clone();
-    }
-
-    device_table[name] = Item::Table(table);
-
-    Ok(())
-}
-
-pub fn load_config(path: &Path) -> Result<(Config, Document)> {
+pub fn load_config(path: &Path) -> Result<(Config, DocumentMut)> {
     let contents =
         fs::read_to_string(path).with_context(|| format!("Failed to read config: {path:?}"))?;
     let config: Config = toml_edit::de::from_str(&contents)
         .with_context(|| format!("Failed to parse config: {path:?}"))?;
-    let document: Document = contents.parse().unwrap();
+    let document: DocumentMut = contents.parse().unwrap();
 
     Ok((config, document))
 }

e2e/src/download.rs

@@ -1,461 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 Andrew Gunnerson
- * SPDX-License-Identifier: GPL-3.0-only
- */
-
-use std::{
-    collections::{HashMap, VecDeque},
-    fs::{self, OpenOptions},
-    io::{self, Read, Seek, SeekFrom, Write},
-    ops::Range,
-    path::{Path, PathBuf},
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        mpsc::{self, Sender},
-    },
-    thread::{self, ThreadId},
-    time::{Duration, Instant},
-};
-
-use anyhow::{anyhow, bail, Context, Result};
-use avbroot::stream::PSeekFile;
-use serde::{Deserialize, Serialize};
-
-/// Minimum download chunk size per task.
-const MIN_CHUNK_SIZE: u64 = 1024 * 1024;
-
-const TIMEOUT: Duration = Duration::from_secs(5);
-
-pub trait ProgressDisplay {
-    fn progress(&mut self, current: u64, total: u64);
-
-    fn error(&mut self, msg: &str);
-
-    fn finish(&mut self);
-}
-
-pub struct BasicProgressDisplay {
-    current: u64,
-    total: u64,
-    interval: Duration,
-    last_render: Instant,
-    avg: VecDeque<(Instant, u64)>,
-}
-
-// Speed is a simple moving average over 5 seconds.
-static AVG_INTERVAL: Duration = Duration::from_millis(100);
-static AVG_WINDOW_SIZE: usize = 5000 / AVG_INTERVAL.as_millis() as usize;
-
-impl BasicProgressDisplay {
-    pub fn new(interval: Duration) -> Self {
-        Self {
-            current: 0,
-            total: 0,
-            interval,
-            last_render: Instant::now() - interval,
-            avg: VecDeque::new(),
-        }
-    }
-
-    fn clear_line(&self) {
-        eprint!("\x1b[2K\r");
-    }
-}
-
-impl ProgressDisplay for BasicProgressDisplay {
-    fn progress(&mut self, current: u64, total: u64) {
-        self.current = current;
-        self.total = total;
-
-        let now = Instant::now();
-
-        if self.avg.is_empty() || (now - self.avg.back().unwrap().0) > AVG_INTERVAL {
-            if self.avg.len() == AVG_WINDOW_SIZE {
-                self.avg.pop_front();
-            }
-
-            self.avg.push_back((now, current));
-        }
-
-        if now - self.last_render > self.interval {
-            let current_mib = current as f64 / 1024.0 / 1024.0;
-            let total_mib = total as f64 / 1024.0 / 1024.0;
-
-            let front = self.avg.front().unwrap();
-            let back = self.avg.back().unwrap();
-
-            let avg_window_mib = (back.1 - front.1) as f64 / 1024.0 / 1024.0;
-            let avg_window_duration = back.0 - front.0;
-
-            let speed_mib_s = if avg_window_duration.is_zero() {
-                0.0
-            } else {
-                avg_window_mib / avg_window_duration.as_secs_f64()
-            };
-
-            self.clear_line();
-            eprint!("{current_mib:.1} / {total_mib:.1} MiB ({speed_mib_s:.1} MiB/s)");
-
-            self.last_render = now;
-        }
-    }
-
-    fn error(&mut self, msg: &str) {
-        self.clear_line();
-        eprintln!("{msg}");
-    }
-
-    fn finish(&mut self) {
-        self.clear_line();
-    }
-}
-
-#[derive(Debug)]
-enum MessageData {
-    Progress {
-        bytes: u64,
-        // Controller replies with a new ending offset.
-        resp: Sender<u64>,
-    },
-    Completion {
-        result: Result<()>,
-    },
-}
-
-#[derive(Debug)]
-struct Message {
-    id: ThreadId,
-    data: MessageData,
-}
-
-/// Download a contiguous byte range. The number of bytes downloaded per loop
-/// iteration will be sent to the specified channel via a `ProgressMessage`. The
-/// receiver of the message must reply with the new ending offset for this
-/// download via the oneshot channel in the `resp` field. An appropriate error
-/// will be returned if the full range (subject to modification) cannot be fully
-/// downloaded (eg. premature EOF is an error).
-fn download_range(
-    url: &str,
-    mut file: PSeekFile,
-    initial_range: Range<u64>,
-    channel: Sender<Message>,
-    cancel_signal: &AtomicBool,
-) -> Result<()> {
-    assert!(initial_range.start < initial_range.end);
-
-    let mut response = attohttpc::get(url)
-        .connect_timeout(TIMEOUT)
-        .read_timeout(TIMEOUT)
-        .header(
-            "Range",
-            &format!("bytes={}-{}", initial_range.start, initial_range.end - 1),
-        )
-        .send()
-        .and_then(|r| r.error_for_status())
-        .with_context(|| format!("Failed to start download for range: {initial_range:?}"))?;
-
-    let mut range = initial_range.clone();
-    let mut buf = [0u8; 65536];
-
-    while range.start < range.end {
-        if cancel_signal.load(Ordering::SeqCst) {
-            bail!("Received cancel signal");
-        }
-
-        let to_read = (range.end - range.start).min(buf.len() as u64) as usize;
-        let n = response.read(&mut buf[..to_read]).with_context(|| {
-            format!(
-                "Failed to download {to_read} bytes at offset {}",
-                range.start,
-            )
-        })?;
-        if n == 0 {
-            bail!("Unexpected EOF from server");
-        }
-
-        // This may overlap with another task's write when a range split occurs,
-        // but the same data will be written anyway, so it's not a huge deal.
-        file.seek(SeekFrom::Start(range.start))?;
-        file.write_all(&buf[..n]).with_context(|| {
-            format!(
-                "Failed to write {n} bytes to output file at offset {}",
-                range.start,
-            )
-        })?;
-
-        range.start += n as u64;
-
-        // Report progress to the controller.
-        let (tx, rx) = mpsc::channel();
-        let msg = Message {
-            id: thread::current().id(),
-            data: MessageData::Progress {
-                bytes: n as u64,
-                resp: tx,
-            },
-        };
-        channel.send(msg)?;
-
-        // Get new ending offset from controller.
-        let new_end = rx.recv()?;
-        if new_end != range.end {
-            debug_assert!(new_end <= range.end);
-            range.end = new_end;
-        }
-    }
-
-    Ok(())
-}
-
-/// This just calls [`download_range()`] and sends a completion message to the
-/// channel with the result.
-fn download_thread(
-    url: &str,
-    file: PSeekFile,
-    initial_range: Range<u64>,
-    channel: mpsc::Sender<Message>,
-    cancel_signal: &AtomicBool,
-) {
-    let result = download_range(url, file, initial_range, channel.clone(), cancel_signal);
-
-    channel
-        .send(Message {
-            id: thread::current().id(),
-            data: MessageData::Completion { result },
-        })
-        .unwrap();
-}
-
-/// Send a HEAD request to get the value of the Content-Length header.
-fn get_content_length(url: &str) -> Result<u64> {
-    let response = attohttpc::head(url)
-        .connect_timeout(TIMEOUT)
-        .read_timeout(TIMEOUT)
-        .send()
-        .and_then(|r| r.error_for_status())
-        .context("Failed to send HEAD request to get Content-Length")?;
-
-    response
-        .headers()
-        .get("Content-Length")
-        .and_then(|h| h.to_str().ok())
-        .and_then(|h| h.parse().ok())
-        .ok_or_else(|| anyhow!("HEAD request did not return a valid Content-Length"))
-}
-
-/// Download a set of file chunks in parallel. Only unrecoverable errors are
-/// returned as an Err. Normal/expected errors and download progress info are
-/// reported via `display`. Returns the remaining ranges that need to be
-/// downloaded.
-fn download_ranges(
-    url: &str,
-    output: &Path,
-    initial_ranges: Option<&[Range<u64>]>,
-    display: &mut dyn ProgressDisplay,
-    max_threads: usize,
-    max_errors: u8,
-    cancel_signal: &AtomicBool,
-) -> Result<Vec<Range<u64>>> {
-    let file_size = get_content_length(url)?;
-
-    // Open for writing, but without truncation.
-    let file = OpenOptions::new()
-        .write(true)
-        .create(true)
-        .open(output)
-        .map(PSeekFile::new)
-        .with_context(|| format!("Failed to open for writing: {output:?}"))?;
-
-    file.set_len(file_size)
-        .with_context(|| format!("Failed to set file size: {output:?}"))?;
-
-    // Queue of ranges that need to be downloaded.
-    let mut remaining = VecDeque::from(match initial_ranges {
-        Some(r) => r.to_vec(),
-        #[allow(clippy::single_range_in_vec_init)]
-        None => vec![0..file_size],
-    });
-    // Ranges that have failed.
-    let mut failed = Vec::<Range<u64>>::new();
-    // Ranges for currently running threads.
-    let mut thread_ranges = HashMap::<ThreadId, Range<u64>>::new();
-
-    // Overall progress.
-    let mut progress = file_size - remaining.iter().map(|r| r.end - r.start).sum::<u64>();
-    display.progress(progress, file_size);
-
-    thread::scope(|scope| {
-        let mut threads = HashMap::new();
-        let mut error_count = 0u8;
-        // Progress messages from threads.
-        let (tx, rx) = mpsc::channel();
-
-        loop {
-            // Spawn new threads.
-            while !cancel_signal.load(Ordering::SeqCst) && threads.len() < max_threads {
-                if remaining.is_empty() && !threads.is_empty() {
-                    // No more ranges to download. Split another thread's range.
-                    let (_, old_range) = thread_ranges
-                        .iter_mut()
-                        .max_by_key(|(_, r)| r.end - r.start)
-                        .unwrap();
-                    let size = old_range.end - old_range.start;
-
-                    if size >= MIN_CHUNK_SIZE {
-                        let new_range = old_range.start + size / 2..old_range.end;
-                        old_range.end = new_range.start;
-                        remaining.push_back(new_range);
-                    }
-                }
-
-                if let Some(thread_range) = remaining.pop_front() {
-                    let file_cloned = file.reopen();
-                    let thread_range_cloned = thread_range.clone();
-                    let tx_cloned = tx.clone();
-
-                    let join_handle = scope.spawn(|| {
-                        download_thread(
-                            url,
-                            file_cloned,
-                            thread_range_cloned,
-                            tx_cloned,
-                            cancel_signal,
-                        )
-                    });
-
-                    thread_ranges.insert(join_handle.thread().id(), thread_range);
-                    threads.insert(join_handle.thread().id(), join_handle);
-                } else {
-                    // No pending ranges and no running threads can be split.
-                    break;
-                }
-            }
-
-            if threads.is_empty() {
-                // Nothing left to do.
-                break;
-            }
-
-            let Message { id, data } = rx.recv().unwrap();
-
-            match data {
-                MessageData::Progress { bytes, resp } => {
-                    progress += bytes;
-                    display.progress(progress, file_size);
-
-                    let thread_range = thread_ranges.get_mut(&id).unwrap();
-                    thread_range.start += bytes;
-
-                    resp.send(thread_range.end).unwrap();
-                }
-                MessageData::Completion { result } => {
-                    threads.remove(&id).unwrap().join().unwrap();
-
-                    let thread_range = thread_ranges.remove(&id).unwrap();
-
-                    if let Err(e) = result {
-                        display.error(&format!("[{id:?}] {e:?}"));
-                        error_count += 1;
-
-                        if error_count < max_errors {
-                            remaining.push_back(thread_range);
-                        } else {
-                            failed.push(thread_range);
-                        }
-                    }
-                }
-            }
-        }
-    });
-
-    display.finish();
-
-    failed.extend(remaining);
-    failed.extend(thread_ranges.into_values());
-
-    Ok(failed)
-}
-
-#[derive(Serialize, Deserialize)]
-struct State {
-    ranges: Vec<Range<u64>>,
-}
-
-fn read_state(path: &Path) -> Result<Option<State>> {
-    let data = match fs::read_to_string(path) {
-        Ok(f) => f,
-        Err(e) if e.kind() == io::ErrorKind::NotFound => return Ok(None),
-        Err(e) => Err(e).with_context(|| format!("Failed to read download state: {path:?}"))?,
-    };
-
-    let state = toml_edit::de::from_str(&data)
-        .with_context(|| format!("Failed to parse download state: {path:?}"))?;
-
-    Ok(Some(state))
-}
-
-fn write_state(path: &Path, state: &State) -> Result<()> {
-    let data = toml_edit::ser::to_string(state).unwrap();
-
-    fs::write(path, data).with_context(|| format!("Failed to write download state: {path:?}"))?;
-
-    Ok(())
-}
-
-fn delete_if_exists(path: &Path) -> Result<()> {
-    if let Err(e) = fs::remove_file(path) {
-        if e.kind() != io::ErrorKind::NotFound {
-            return Err(e).context(format!("Failed to delete file: {path:?}"));
-        }
-    }
-
-    Ok(())
-}
-
-pub fn state_path(path: &Path) -> PathBuf {
-    let mut s = path.as_os_str().to_owned();
-    s.push(".state");
-    PathBuf::from(s)
-}
-
-/// Download `url` to `output` with parallel threads.
-///
-/// If `initial_ranges` is specified, only those sections of the file will be
-/// downloaded. The empty regions are left untouched (i.e. filled with zeroes).
-/// A `.state` file is written if the download is interrupted. If the state
-/// file exists when this function is called, `initial_ranges` is ignored and
-/// the ranges from the state file are used to resume the download.
-pub fn download(
-    url: &str,
-    output: &Path,
-    initial_ranges: Option<&[Range<u64>]>,
-    display: &mut dyn ProgressDisplay,
-    max_tasks: usize,
-    max_errors: u8,
-    cancel_signal: &AtomicBool,
-) -> Result<()> {
-    let state_path = state_path(output);
-    let ranges = match read_state(&state_path)? {
-        Some(r) => Some(r.ranges),
-        None => initial_ranges.map(|r| r.to_vec()),
-    };
-
-    let remaining = download_ranges(
-        url,
-        output,
-        ranges.as_deref(),
-        display,
-        max_tasks,
-        max_errors,
-        cancel_signal,
-    )?;
-
-    if remaining.is_empty() {
-        delete_if_exists(&state_path)?;
-    } else {
-        write_state(&state_path, &State { ranges: remaining })?;
-        bail!("Download was interrupted");
-    }
-
-    Ok(())
-}

fuzz/.gitignore

@@ -0,0 +1,4 @@
+/hfuzz_target/
+HONGGFUZZ.REPORT.TXT
+*.honggfuzz.cov
+*.fuzz

fuzz/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "fuzz"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+# There's currently no good way to exclude a workspace member for a specific
+# platform, so we just compile empty stubs on Windows (which isn't supported by
+# honggfuzz).
+# https://github.com/rust-lang/cargo/issues/5220
+# https://github.com/rust-lang/cargo/issues/6179
+[target.'cfg(unix)'.dependencies]
+avbroot = { path = "../avbroot" }
+honggfuzz = "0.5.55"

fuzz/README.md

@@ -0,0 +1,53 @@
+# Fuzzing
+
+While avbroot's parsers are all memory-safe, it is still possible for panics or crashes to occur, for example due to excessive memory allocation, integer overflow, or division by zero. Fuzzing helps to identify these issues by randomizing inputs in a way that tries to increase code coverage.
+
+## Running the fuzzers
+
+1. Install the cargo honggfuzz commands.
+
+    ```bash
+    cargo install honggfuzz
+    ```
+
+2. Pick a fuzz target to run. A fuzz target is the name of the source file in [`src/bin/`](./src/bin) without the `.rs` extension.
+
+    The list of targets can be queried programmatically with:
+
+    ```bash
+    cargo read-manifest | jq -r '.targets[].name'
+    ```
+
+3. Run the fuzzer.
+
+    ```bash
+    cargo hfuzz run <fuzz target>
+    ```
+
+    This will run forever until it is manually killed. At the top of the screen, a summary section like the following is shown:
+
+    ```
+      Iterations : 31,243 [31.24k]
+      Mode [1/3] : Feedback Driven Dry Run [2486/4085]
+          Target : hfuzz_target/x86_64-unknown-linux-gnu/release/bootimage
+         Threads : 8, CPUs: 16, CPU%: 800% [50%/CPU]
+           Speed : 36,126/sec [avg: 31,243]
+         Crashes : 53 [unique: 1, blocklist: 0, verified: 0]
+        Timeouts : 0 [1 sec]
+     Corpus Size : 1,424, max: 24,576 bytes, init: 4,085 files
+      Cov Update : 0 days 00 hrs 00 mins 00 secs ago
+        Coverage : edge: 897/224,621 [0%] pc: 2 cmp: 34,736
+    ```
+
+    When a crash occurs, the `Crashes` counter will increment and the input data that triggered the crash will be written to `hfuzz_workspace/<fuzz target>/*.fuzz`. New files are only written for unique crashes.
+
+4. If a crash occurs, run the following command to trigger the crash in a debugger.
+
+    ```bash
+    cargo hfuzz run-debug <fuzz target> \
+        hfuzz_workspace/<fuzz_target>/<input file>.fuzz
+    ```
+
+    This defaults to using `rust-lldb`. To use `rust-gdb` instead, set the `HFUZZ_DEBUGGER` environment variable to `rust-gdb`.
+
+    Alternatively, just feed the input file to the appropriate avbroot command directly (eg. `avbroot boot info -i hfuzz_workspace/<fuzz_target>/<input file>.fuzz` for boot images).

fuzz/hfuzz_workspace/avb/input/vbmeta_appended_hash.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/vbmeta_appended_hash.img

fuzz/hfuzz_workspace/avb/input/vbmeta_appended_hash_tree.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/vbmeta_appended_hash_tree.img

fuzz/hfuzz_workspace/avb/input/vbmeta_root.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/vbmeta_root.img

fuzz/hfuzz_workspace/bootimage/input/boot_v0.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/boot_v0.img

fuzz/hfuzz_workspace/bootimage/input/boot_v1.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/boot_v1.img

fuzz/hfuzz_workspace/bootimage/input/boot_v2.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/boot_v2.img

fuzz/hfuzz_workspace/bootimage/input/boot_v3.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/boot_v3.img

fuzz/hfuzz_workspace/bootimage/input/boot_v4.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/boot_v4.img

fuzz/hfuzz_workspace/bootimage/input/boot_v4_vts.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/boot_v4_vts.img

fuzz/hfuzz_workspace/bootimage/input/vendor_v3.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/vendor_v3.img

fuzz/hfuzz_workspace/bootimage/input/vendor_v4.img

@@ -0,0 +1 @@
+../../../../avbroot/tests/data/vendor_v4.img

fuzz/src/bin/avb.rs

@@ -0,0 +1,21 @@
+#[cfg(not(windows))]
+mod fuzz {
+    use std::io::Cursor;
+
+    use avbroot::format::avb;
+    use honggfuzz::fuzz;
+
+    pub fn main() {
+        loop {
+            fuzz!(|data: &[u8]| {
+                let reader = Cursor::new(data);
+                let _ = avb::load_image(reader);
+            });
+        }
+    }
+}
+
+fn main() {
+    #[cfg(not(windows))]
+    fuzz::main();
+}

fuzz/src/bin/bootimage.rs

@@ -0,0 +1,21 @@
+#[cfg(not(windows))]
+mod fuzz {
+    use std::io::Cursor;
+
+    use avbroot::{format::bootimage::BootImage, stream::FromReader};
+    use honggfuzz::fuzz;
+
+    pub fn main() {
+        loop {
+            fuzz!(|data: &[u8]| {
+                let reader = Cursor::new(data);
+                let _ = BootImage::from_reader(reader);
+            });
+        }
+    }
+}
+
+fn main() {
+    #[cfg(not(windows))]
+    fuzz::main();
+}

fuzz/src/bin/cpio.rs

@@ -0,0 +1,22 @@
+#[cfg(not(windows))]
+mod fuzz {
+    use std::{io::Cursor, sync::atomic::AtomicBool};
+
+    use avbroot::format::cpio;
+    use honggfuzz::fuzz;
+
+    pub fn main() {
+        loop {
+            fuzz!(|data: &[u8]| {
+                let cancel_signal = AtomicBool::new(false);
+                let reader = Cursor::new(data);
+                let _ = cpio::load(reader, true, &cancel_signal);
+            });
+        }
+    }
+}
+
+fn main() {
+    #[cfg(not(windows))]
+    fuzz::main();
+}

fuzz/src/bin/fec.rs

@@ -0,0 +1,36 @@
+#[cfg(not(windows))]
+mod fuzz {
+    use std::{io::Cursor, sync::atomic::AtomicBool};
+
+    use avbroot::{
+        format::fec::FecImage,
+        stream::{FromReader, SharedCursor, WriteZerosExt},
+    };
+    use honggfuzz::fuzz;
+
+    pub fn main() {
+        loop {
+            fuzz!(|data: &[u8]| {
+                let cancel_signal = AtomicBool::new(false);
+
+                let reader = Cursor::new(data);
+                if let Ok(fec) = FecImage::from_reader(reader) {
+                    let mut input = SharedCursor::new();
+
+                    // Allow verify() to get further, but don't blow up the host
+                    // with excessive memory usage.
+                    if fec.data_size < 64 * 1024 * 1024 {
+                        input.write_zeros_exact(fec.data_size).unwrap();
+                    }
+
+                    let _ = fec.verify(&input, &cancel_signal);
+                }
+            });
+        }
+    }
+}
+
+fn main() {
+    #[cfg(not(windows))]
+    fuzz::main();
+}

modules/clearotacerts/module.prop

@@ -1,6 +0,0 @@
-id=com.chiller3.avbroot.clearotacerts
-name=clearotacerts
-version=v2.1.0
-versionCode=131328
-author=chenxiaolong
-description=Block A/B OTAs by clearing verification certificates

modules/common/update-binary

@@ -1,33 +0,0 @@
-#!/sbin/sh
-
-#################
-# Initialization
-#################
-
-umask 022
-
-# echo before loading util_functions
-ui_print() { echo "$1"; }
-
-require_new_magisk() {
-  ui_print "*******************************"
-  ui_print " Please install Magisk v20.4+! "
-  ui_print "*******************************"
-  exit 1
-}
-
-#########################
-# Load util_functions.sh
-#########################
-
-OUTFD=$2
-ZIPFILE=$3
-
-mount /data 2>/dev/null
-
-[ -f /data/adb/magisk/util_functions.sh ] || require_new_magisk
-. /data/adb/magisk/util_functions.sh
-[ $MAGISK_VER_CODE -lt 20400 ] && require_new_magisk
-
-install_module
-exit 0

modules/common/updater-script

@@ -1 +0,0 @@
-#MAGISK

modules/oemunlockonboot/Main.java

@@ -1,83 +0,0 @@
-import android.annotation.SuppressLint;
-import android.os.IBinder;
-import android.os.IInterface;
-import android.os.Process;
-import android.system.ErrnoException;
-
-import java.lang.reflect.Method;
-
-@SuppressLint({"DiscouragedPrivateApi", "PrivateApi", "SoonBlockedPrivateApi"})
-public class Main {
-    private static final int GET_SERVICE_ATTEMPTS = 30;
-
-    @SuppressWarnings("SameParameterValue")
-    private static IInterface getService(Class<?> interfaceClass, String serviceName) throws Exception {
-        Class<?> serviceManager = Class.forName("android.os.ServiceManager");
-        Method getService = serviceManager.getDeclaredMethod("getService", String.class);
-
-        Class<?> stub = Class.forName(interfaceClass.getCanonicalName() + "$Stub");
-        Method asInterface = stub.getDeclaredMethod("asInterface", IBinder.class);
-
-        // ServiceManager.waitForService() tries to start the service, which we want to avoid to be
-        // 100% sure we're not disrupting the boot flow.
-        for (int attempt = 1; attempt <= GET_SERVICE_ATTEMPTS; ++attempt) {
-            IBinder iBinder = (IBinder) getService.invoke(null, serviceName);
-            if (iBinder != null) {
-                return (IInterface) asInterface.invoke(null, iBinder);
-            }
-
-            if (attempt < GET_SERVICE_ATTEMPTS) {
-                Thread.sleep(1000);
-            }
-        }
-
-        throw new IllegalStateException(
-                "Service " + serviceName + " not found after " + GET_SERVICE_ATTEMPTS + " attempts");
-    }
-
-    @SuppressWarnings("ConstantConditions")
-    private static void unlock() throws Exception {
-        Class<?> iOemLockService = Class.forName("android.service.oemlock.IOemLockService");
-        IInterface iFace = getService(iOemLockService, "oem_lock");
-
-        Method setOemUnlockAllowedByUser = iOemLockService.getDeclaredMethod("setOemUnlockAllowedByUser", boolean.class);
-        Method isOemUnlockAllowedByUser = iOemLockService.getDeclaredMethod("isOemUnlockAllowedByUser");
-
-        Boolean unlockAllowed = (Boolean) isOemUnlockAllowedByUser.invoke(iFace);
-        if (unlockAllowed) {
-            System.out.println("OEM unlocking already enabled");
-            return;
-        }
-
-        System.out.println("Enabling OEM unlocking");
-        setOemUnlockAllowedByUser.invoke(iFace, true);
-    }
-
-    @SuppressWarnings({"ConstantConditions", "JavaReflectionMemberAccess"})
-    private static void switchToSystemUid() throws Exception {
-        if (Process.myUid() != Process.SYSTEM_UID) {
-            Method setUid = Process.class.getDeclaredMethod("setUid", int.class);
-            int errno = (int) setUid.invoke(null, Process.SYSTEM_UID);
-
-            if (errno != 0) {
-                throw new Exception("Failed to switch to SYSTEM (" + Process.SYSTEM_UID + ") user",
-                        new ErrnoException("setuid", errno));
-            }
-            if (Process.myUid() != Process.SYSTEM_UID) {
-                throw new IllegalStateException("UID didn't actually change: " +
-                        Process.myUid() + " != " + Process.SYSTEM_UID);
-            }
-        }
-    }
-
-    public static void main(String[] args) {
-        try {
-            switchToSystemUid();
-            unlock();
-        } catch (Exception e) {
-            System.err.println("Failed to enable OEM unlocking");
-            e.printStackTrace();
-            System.exit(1);
-        }
-    }
-}

modules/oemunlockonboot/module.prop

@@ -1,6 +0,0 @@
-id=com.chiller3.avbroot.oemunlockonboot
-name=oemunlockonboot
-version=v2.1.0
-versionCode=131328
-author=chenxiaolong
-description=Enable OEM unlocking on every boot