Version 3.19.0

Signed-off-by: Andrew Gunnerson <accounts+github@chiller3.com>
CHANGELOG.md: Add entry for PR #479
2026-07-03 14:05:11 +02:00 · 2025-08-07 23:23:18 -04:00 · 2025-08-07 23:20:12 -04:00 · 2025-08-07 23:14:06 -04:00 · 2025-08-07 23:13:47 -04:00 · 2025-08-07 23:10:24 -04:00
49 changed files with 4604 additions and 2247 deletions
@@ -34,8 +34,7 @@ jobs:
              - 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
+          - os: ubuntu-latest
            name: aarch64-linux-android31
            targets:
              - aarch64-linux-android
@@ -65,7 +64,7 @@ jobs:
        run: |
          cargo install \
              --git https://github.com/chenxiaolong/cargo-android \
-              --tag v0.1.1
+              --tag v0.1.3

      - name: Get version
        id: get_version
@@ -84,7 +83,7 @@ jobs:
          done

      - name: Cache Rust dependencies
-        uses: Swatinem/rust-cache@82a92a6e8fbeee089604da2575dc567ae9ddeaab # v2.7.5
+        uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
        with:
          key: ${{ matrix.artifact.name }}

@@ -155,7 +154,7 @@ jobs:
        run: cp LICENSE README.md target/output/

      - name: Archive executable
-        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4.4.3
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
        with:
          name: avbroot-${{ steps.get_version.outputs.version }}-${{ matrix.artifact.name }}
          path: |
@@ -13,4 +13,4 @@ jobs:
        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Run cargo-deny
-        uses: EmbarkStudios/cargo-deny-action@e2f4ede4a4e60ea15ff31bc0647485d80c66cfba # v2.0.4
+        uses: EmbarkStudios/cargo-deny-action@30f817c6f72275c6d54dc744fbca09ebc958599f # v2.0.12
@@ -27,7 +27,7 @@ jobs:
        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Create release
-        uses: softprops/action-gh-release@01570a1f39cb168c169c802c3bceb9e93fb10974 # v2.1.0
+        uses: softprops/action-gh-release@72f2c25fcb47643c292f7107632f7a47c1df5cd8 # v2.3.2
        with:
          tag_name: v${{ steps.get_version.outputs.version }}
          name: Version ${{ steps.get_version.outputs.version }}
@@ -7,6 +7,106 @@
    to update the actual links at the bottom of the file.
 -->

+### Version 3.19.0
+
+* Allow verifying hashes of unsigned images with `avbroot avb verify` ([PR #477])
+* Warn when verifying image containing insecure flags field with `avbroot avb verify` ([PR #478])
+* Force re-signing of signed images in `avbroot avb pack` when fields were changed externally ([PR #479])
+
+### Version 3.18.1
+
+* Fix output file corruption in `avbroot sparse unpack` when unpacking a sparse file with holes larger than 2^32 ([Issue #472], [PR #476])
+
+### Version 3.18.0
+
+* Make OTA metadata property file field validation more lenient ([Issue #469], [PR #470])
+  * Fixes `avbroot ota verify` for stock OTAs that include extra zip file entries in the metadata
+* Remove automatic promotion of insecure SHA-1 AVB hash algorithm to SHA-256 ([Issue #366], [Issue #469], [PR #473])
+  * There are insecure devices that don't support SHA-256 and won't boot with it.
+  * The original feature was a bandaid for OnePlus devices to make them a tiny bit more secure. They used SHA-256 for every partition except `system`. However, OnePlus no longer supports custom AVB keys anyway, so this feature is going away.
+* Add support for Magisk 30200 ([PR #474])
+* Update dependencies ([PR #475])
+
+### Version 3.17.2
+
+* Add support for Magisk 30100 ([PR #468])
+
+### Version 3.17.1
+
+* Update end-to-end tests to place streaming and seekable OTAs in separate directories for easier troubleshooting ([PR #463])
+* Update dependencies ([PR #464])
+* Add support for Magisk 30000 ([PR #467])
+
+### Version 3.17.0
+
+* Fix reserved space error when patching OTA zips larger than ~10 GB ([Issue #451], [PR #452])
+* Update dependencies ([PR #453])
+
+### Version 3.16.1
+
+* Add support for Magisk 29000 ([PR #448])
+* Update dependencies ([PR #449])
+
+### Version 3.16.0
+
+* Add support for CoW version 3 for virtual A/B ([Issue #441], [PR #442], [PR #445])
+  * This was recently introduced with the Pixel 9a. Previous devices all used CoW version 2.
+* Add support for uncompressed CoW for virtual A/B ([PR #443])
+  * This is not used on actual devices, but is very useful for testing the CoW estimation logic.
+  * All differences between avbroot's and AOSP delta_generator's estimation logic are now fixed.
+* Add support for custom CoW compression levels for virtual A/B ([PR #444])
+  * This is also not used on actual devices, but is supported by AOSP, so avbroot should support it too.
+* Update dependencies ([PR #446])
+
+### Version 3.15.0
+
+* Add support for changing the virtual A/B compression algorithm ([PR #437])
+    * For devices that launched with Android <14, `--vabc-algo lz4` can significantly increase OTA installation speed when using a custom OTA updater app (with caveats). There is no difference when sideloading from recovery mode.
+    * See [the documentation](./README.md#changing-virtual-ab-cow-compression-algorithm) for more details.
+* Switch back to the ring library now that it is maintained again ([PR #438])
+* Update dependencies ([PR #439])
+
+### Version 3.14.0
+
+* Report as many errors as possible before failing in `avbroot ota verify` and improve error messages ([Discussion #426], [PR #428], [PR #430])
+* Fix new clippy warnings introduced in Rust 1.85 ([PR #429])
+* Fix massive performance regression introduced in 3.13.0 for OTAs that use gzip for virtual A/B CoW compression ([Issue #433], [PR #434])
+* Update dependencies ([PR #435])
+
+### Version 3.13.0
+
+* Fix parsing Samsung `super.img` files in `avbroot lp` due to Samsung putting their own data structures in a region that's supposed to be filled with zeros ([PR #415])
+* Add advanced option to skip replacing the OTA certificate in the system image ([Discussion #417], [PR #418])
+* Switch to stable bzip2-rs release and use zlib-rs as the backend for flate2 ([PR #421])
+* Switch to the aws-lc cryptography library for SHA1 and SHA2 hashing ([PR #422])
+    * The ring library is no longer maintained
+* Fix incorrect `Partitions aren't protected by AVB: system` warning when using `--skip-system-ota-cert` ([PR #423])
+* Discard unneeded temp file sooner when using `--skip-system-ota-cert` ([PR #424])
+* Make `avbroot lp`'s parser less strict so that it can load on-device `super` partitions ([PR #425])
+    * The on-disk layout on virtual A/B devices violates some requirements stated in AOSP's documentation
+* Update dependencies ([PR #427])
+
+### Version 3.12.0
+
+* Add new `-p <name>` option to `avbroot ota extract` for extracting specific partitions ([PR #408])
+* Deprecate the `--boot-only` option in `avbroot ota extract` ([PR #408])
+    * The option will remain indefinitely for backwards compatibility, but is hidden from `--help`
+* Add support for extracting the embedded OTA certificate and AVB public key in `avbroot ota extract` ([PR #409])
+* Rename `avbroot key extract-avb` to `avbroot key encode-avb` for consistency with `avbroot key decode-avb` ([PR #410])
+    * The old syntax will remain supported indefinitely for backwards compatibility, but is hidden from `--help`
+* Update dependencies ([PR #411])
+
+### Version 3.11.0
+
+* Fix crash when ignoring warning about `--magisk-preinit-device` not being specified ([PR #394])
+* When using `--ignore-magisk-warnings`, assume that unsupported Magisk versions newer than the latest supported version are capable of all features ([Issue #393], [PR #395])
+* Update bzip2-rs and switch to the Rust backend ([PR #397], [PR #402])
+* Minor code cleanup for custom integer range type ([PR #398])
+* Improve errors to make them less ambiguous about what went wrong ([PR #401])
+* Fix bug where a vendor v4 boot image that was truncated in the bootconfig padding section would be accepted as valid ([PR #401])
+* Avoid performing many small I/O operations when reading and writing cpio archives ([PR #403])
+* Update dependencies ([PR #404])
+
 ### Version 3.10.0

 * Switch to using zerocopy library for all binary file format parsers ([PR #384])
@@ -259,6 +359,8 @@ Behind-the-scenes changes:
 [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
+[Discussion #417]: https://github.com/chenxiaolong/avbroot/discussions/417
+[Discussion #426]: https://github.com/chenxiaolong/avbroot/discussions/426
 [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
@@ -284,6 +386,12 @@ Behind-the-scenes changes:
 [Issue #332]: https://github.com/chenxiaolong/avbroot/issues/332
 [Issue #356]: https://github.com/chenxiaolong/avbroot/issues/356
 [Issue #366]: https://github.com/chenxiaolong/avbroot/issues/366
+[Issue #393]: https://github.com/chenxiaolong/avbroot/issues/393
+[Issue #433]: https://github.com/chenxiaolong/avbroot/issues/433
+[Issue #441]: https://github.com/chenxiaolong/avbroot/issues/441
+[Issue #451]: https://github.com/chenxiaolong/avbroot/issues/451
+[Issue #469]: https://github.com/chenxiaolong/avbroot/issues/469
+[Issue #472]: https://github.com/chenxiaolong/avbroot/issues/472
 [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
@@ -410,3 +518,52 @@ Behind-the-scenes changes:
 [PR #390]: https://github.com/chenxiaolong/avbroot/pull/390
 [PR #391]: https://github.com/chenxiaolong/avbroot/pull/391
 [PR #392]: https://github.com/chenxiaolong/avbroot/pull/392
+[PR #394]: https://github.com/chenxiaolong/avbroot/pull/394
+[PR #395]: https://github.com/chenxiaolong/avbroot/pull/395
+[PR #397]: https://github.com/chenxiaolong/avbroot/pull/397
+[PR #398]: https://github.com/chenxiaolong/avbroot/pull/398
+[PR #401]: https://github.com/chenxiaolong/avbroot/pull/401
+[PR #402]: https://github.com/chenxiaolong/avbroot/pull/402
+[PR #403]: https://github.com/chenxiaolong/avbroot/pull/403
+[PR #404]: https://github.com/chenxiaolong/avbroot/pull/404
+[PR #408]: https://github.com/chenxiaolong/avbroot/pull/408
+[PR #409]: https://github.com/chenxiaolong/avbroot/pull/409
+[PR #410]: https://github.com/chenxiaolong/avbroot/pull/410
+[PR #411]: https://github.com/chenxiaolong/avbroot/pull/411
+[PR #415]: https://github.com/chenxiaolong/avbroot/pull/415
+[PR #418]: https://github.com/chenxiaolong/avbroot/pull/418
+[PR #421]: https://github.com/chenxiaolong/avbroot/pull/421
+[PR #422]: https://github.com/chenxiaolong/avbroot/pull/422
+[PR #423]: https://github.com/chenxiaolong/avbroot/pull/423
+[PR #424]: https://github.com/chenxiaolong/avbroot/pull/424
+[PR #425]: https://github.com/chenxiaolong/avbroot/pull/425
+[PR #427]: https://github.com/chenxiaolong/avbroot/pull/427
+[PR #428]: https://github.com/chenxiaolong/avbroot/pull/428
+[PR #429]: https://github.com/chenxiaolong/avbroot/pull/429
+[PR #430]: https://github.com/chenxiaolong/avbroot/pull/430
+[PR #434]: https://github.com/chenxiaolong/avbroot/pull/434
+[PR #435]: https://github.com/chenxiaolong/avbroot/pull/435
+[PR #437]: https://github.com/chenxiaolong/avbroot/pull/437
+[PR #438]: https://github.com/chenxiaolong/avbroot/pull/438
+[PR #439]: https://github.com/chenxiaolong/avbroot/pull/439
+[PR #442]: https://github.com/chenxiaolong/avbroot/pull/442
+[PR #443]: https://github.com/chenxiaolong/avbroot/pull/443
+[PR #444]: https://github.com/chenxiaolong/avbroot/pull/444
+[PR #445]: https://github.com/chenxiaolong/avbroot/pull/445
+[PR #446]: https://github.com/chenxiaolong/avbroot/pull/446
+[PR #448]: https://github.com/chenxiaolong/avbroot/pull/448
+[PR #449]: https://github.com/chenxiaolong/avbroot/pull/449
+[PR #452]: https://github.com/chenxiaolong/avbroot/pull/452
+[PR #453]: https://github.com/chenxiaolong/avbroot/pull/453
+[PR #463]: https://github.com/chenxiaolong/avbroot/pull/463
+[PR #464]: https://github.com/chenxiaolong/avbroot/pull/464
+[PR #467]: https://github.com/chenxiaolong/avbroot/pull/467
+[PR #468]: https://github.com/chenxiaolong/avbroot/pull/468
+[PR #470]: https://github.com/chenxiaolong/avbroot/pull/470
+[PR #473]: https://github.com/chenxiaolong/avbroot/pull/473
+[PR #474]: https://github.com/chenxiaolong/avbroot/pull/474
+[PR #475]: https://github.com/chenxiaolong/avbroot/pull/475
+[PR #476]: https://github.com/chenxiaolong/avbroot/pull/476
+[PR #477]: https://github.com/chenxiaolong/avbroot/pull/477
+[PR #478]: https://github.com/chenxiaolong/avbroot/pull/478
+[PR #479]: https://github.com/chenxiaolong/avbroot/pull/479
@@ -4,9 +4,9 @@ members = ["avbroot", "e2e", "fuzz", "xtask"]
 resolver = "2"

 [workspace.package]
-version = "3.10.0"
+version = "3.19.0"
 license = "GPL-3.0-only"
-edition = "2021"
+edition = "2024"
 repository = "https://github.com/chenxiaolong/avbroot"

 [workspace.lints.clippy]
@@ -30,8 +30,6 @@ 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.
@@ -2,12 +2,10 @@

 (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.
+avbroot is a tool for modifying Android A/B OTA images reproducibly and re-signing them with custom keys. It also includes a [collection of subcommands](./README.extra.md) for packing and unpacking numerous Android image formats.

 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:
@@ -23,7 +21,7 @@ Having a good understanding of how AVB and A/B OTAs work is recommended prior to

 avbroot applies the following patches to the partition images:

-* 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` or `init_boot` image, depending on device, is patched to enable root access if requested.

 * 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.

@@ -31,7 +29,7 @@ avbroot applies the following patches to the partition images:

 ## Warnings and Caveats

-* **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_**.
+* **Always leave the `OEM unlocking` checkbox enabled when using a locked bootloader while rooted.** 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_**.

    Repeat: **_ALWAYS leave `OEM unlocking` enabled if rooted._**

@@ -53,6 +51,8 @@ avbroot applies the following patches to the partition images:

 3. Follow the steps to [generate signing keys](#generating-keys).

+    Skip this step if you're updating Android, Magisk, or KernelSU after you've performed an [initial setup](#initial-setup). [Updates](#updates) do not require signing keys since you have already generated them in the initial setup.
+
 4. Patch the OTA zip. The base command is:

    ```bash
@@ -121,7 +121,7 @@ When patching OTAs for multiple devices, generating unique keys for each device
 2. Convert the public key portion of the AVB signing key to the AVB public key metadata format. This is the format that the bootloader requires when setting the custom root of trust.

    ```bash
-    avbroot key extract-avb -k avb.key -o avb_pkmd.bin
+    avbroot key encode-avb -k avb.key -o avb_pkmd.bin
    ```

 3. Generate a self-signed certificate for the OTA signing key. This is used by recovery to verify OTA updates when sideloading.
@@ -225,21 +225,25 @@ If you lose your AVB or OTA signing key, you will no longer be able to sign new

    **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.

-10. That's it! To install future OS, Magisk, or KernelSU updates, see the [next section](#updates).
+10. That's it! To update the OS, Magisk, or KernelSU see the [next section](#updates).

 ## Updates

-Updates to Android, Magisk, and KernelSU are all done the same way by patching (or repatching) the OTA.
+Updates to Android, Magisk, and KernelSU are all done the same way: by patching (or repatching) the OTA.

-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.
+1. Generate a new patched OTA by following the steps in the [usage section](#usage).

-2. Follow the step in the [usage section](#usage) to patch the new OTA.
+2. 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.

 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. Sideload the patched OTA with `adb sideload`.

-5. That's it!
+5. Restart your phone. Note: the phone will likely take a long time to startup after an OS update (a few minutes in some cases).
+
+**Warning**: Due to how virtual A/B works, there is a snapshot merge operation that Android runs invisibly in the background after installing an OTA and rebooting. During the snapshot merge process, it's not possible to sideload another OTA from recovery mode. Avoid doing anything that could result in a boot loop (eg. installing modules) until this process is complete because there is no way to recover, aside from unlocking the bootloader (and wiping) again.
+
+The status can be found by running `adb logcat -v color -s update_engine`. Alternatively, if [Custota](https://github.com/chenxiaolong/Custota) is installed (even if it's not configured to point to a custom OTA server), it will show a notification until the snapshot merge operation completes.

 ## Reverting to stock firmware

@@ -297,8 +301,7 @@ Magisk versions 25211 and newer require a writable partition for storing custom
    ```bash
    avbroot ota extract \
        --input /path/to/ota.zip \
-        --directory . \
-        --boot-only
+        --partition <name> # init_boot or boot, depending on 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.
@@ -385,11 +388,28 @@ Note that avbroot will validate that the prepatched image is compatible with the

 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.

-### Skipping recovery OTA certificate patches
+### Skipping OTA certificate patches

-avbroot can skip modifying `otacerts.zip` in the recovery image with the `--skip-recovery-ota-cert` option. **Do not do this unless you have a good reason to do so.** (For example, if you've already manually inserted the OTA certificate into a boot image specified with `--prepatched` or `--replace`.) When this option is used with `--rootless` (and `--dsu` is not specified), then no modifications are performed on any boot image besides ensuring they are properly signed.
+avbroot can skip modifying `otacerts.zip` with the `--skip-system-ota-cert` and `--skip-recovery-ota-cert` options. **Do not use these unless you have a good reason to do so.**

-When manually adding the OTA certificate to a boot image, [verifying the patched OTA](#verifying-otas) afterwards is recommended to ensure that it was properly done.
+When `--skip-system-ota-cert` is used, the OTA certificates in the `system` partition will not be modified. This prevents custom OTA updater apps from installing further patched OTAs while booted into Android.
+
+When `--skip-recovery-ota-cert` is used, the OTA certificates in the `vendor_boot` or `recovery` partition will not be modified. **This prevents sideloading further patched OTAs from recovery mode.**
+
+If `--skip-recovery-ota-cert` is used because the OTA certificate was already manually added to the boot image, then [verifying the patched OTA](#verifying-otas) afterwards is recommended to ensure that it was properly done. The verification process is only capable of checking the boot image's copy of the OTA certificates, not the system image's copy of them.
+
+### Skipping all patches
+
+To have avbroot make the absolute minimal changes:
+
+* Specify `--skip-system-ota-cert`
+* Specify `--skip-recovery-ota-cert`
+* Specify `--rootless`
+* Omit `--dsu`
+
+This will re-sign the `vbmeta` partition and the OTA with the custom keys, but leave all other partitions untouched.
+
+**This should only be used for advanced troubleshooting.** Without the OTA certificate patches, the resulting OTA will not be able to install further updates.

 ### Replacing partitions

@@ -415,6 +435,18 @@ Verified boot is disabled by vbmeta's header flags: 0x3

 To forcibly enable AVB (by clearing the flags), pass in `--clear-vbmeta-flags`.

+### Changing virtual A/B CoW compression algorithm
+
+The virtual A/B CoW compression algorithm can be changed by passing in `--vabc-algo <algo>` with `gz` or `lz4`. OTAs normally use an algorithm that is compatible with the initial version of Android shipped on the device.
+
+* Devices launching with Android 12 support `gz` and `brotli` (unsupported by avbroot)
+* Devices launching with Android 14 support `lz4`
+* Devices launching with Android 15 support `zstd` (unsupported by avbroot)
+
+Picking a fast algorithm, like lz4, can speed up OTA installation significantly when installing via a custom OTA updater app. However, there is no performance difference when sideloading an OTA from recovery mode.
+
+Note that the currently running version of Android must support the specified compression algorithm or else the OTA will fail to install. For example, trying to install an Android 14 OTA that uses lz4 CoW compression will fail if the running system is Android 13.
+
 ### Non-interactive use

 avbroot prompts for the private key passphrases interactively by default. To run avbroot non-interactively, either:
@@ -451,17 +483,20 @@ avbroot prompts for the private key passphrases interactively by default. To run

 * Use unencrypted private keys. This is strongly discouraged.

-### Extracting the entire OTA
+### Extracting an OTA

-To extract all images contained within the OTA's `payload.bin`, run:
+To extract the partition images contained within an OTA's `payload.bin`, run:

 ```bash
 avbroot ota extract \
    --input /path/to/ota.zip \
-    --directory extracted \
-    --all
+    --directory extracted
 ```

+By default, this only extracts the images that could potentially be patched by avbroot. To extract all images, use the `--all` option. To extract specific images, use the `--partition <name>` option, which can be specified multiple times.
+
+This command also supports extracting the embedded OTA certificate and AVB public key using the `--cert-ota` and `--public-key-avb` options. To extract only these components, pass in `--none` to skip extracting partition images.
+
 ### Zip write mode

 By default, avbroot uses streaming writes for the output OTA during patching. This means it computes the sha256 digest for the digital signature as the file is being written. This mode causes the zip file to contain data descriptors, which is part of the zip standard and works on the vast majority of devices. However, some devices may have broken zip file parsers and fail to properly read OTA zip files containing data descriptors. If this is the case, pass in `--zip-mode seekable` when patching.
@@ -1,11 +1,9 @@
 # avbroot

-avbroot – это программа для модификации OTA-образов Android A/B-формата с целью получения root-прав при сохранении прохождения AVB (Android Verified Boot) с использованием кастомных (пользовательских) ключей подписи. Она совместима как с Magisk, так и с KernelSU. При необходимости можно просто переподписать OTA, без получения root-доступа.
+avbroot – это утилита для воспроизводимой модификации OTA-образов Android A/B-формата и их переподписания пользовательскими ключами. Она также включает в себя [набор подкоманд](./README.extra.md) для упаковки и распаковки образов Android различных форматов.

 Прежде чем использовать avbroot, рекомендуется иметь хорошее понимание того, как работают AVB и OTA в формате A/B. Как минимум, следует ознакомиться с [разделом предостережений,](#предостережения) чтобы избежать хардбрика устройства.

-**ПРИМЕЧАНИЕ:** avbroot 2.0 была переписана на Rust и больше не имеет в основе никакого кода AOSP, а CLI полностью обратно совместим. Тем не менее, старую реализацию на Python можно найти в одноименной ветке `python`.
-
 ## Требования

 * Поддерживаются только устройства, использующие современную A/B-разметку. Это большинство девайсов, выпускаемых с Android 10 и новее (за исключением устройств от Samsung). Чтобы проверить, использует ли ваш телефон необходимую схему разметки, откройте zip-архив OTA и проверьте:
@@ -21,7 +19,7 @@ avbroot – это программа для модификации OTA-обра

 avbroot модифицирует следующие образы:

-* `boot` или `init_boot`, в зависимости от устройства, модифицируется для получения root-доступа. В случае с Magisk, патч будет эквивалентен тому, что производится в самом приложении Magisk.
+* `boot` или `init_boot`, в зависимости от устройства, модифицируется для получения root-доступа, если это запрашивается.

 * `boot`, `recovery` или `vendor_boot`, в зависимости от устройства, модифицируется для замены сертификата проверки подписи OTA на пользовательский. Это позволяет устанавливать будущие пропатченные OTA через режим Recovery уже после блокировки загрузчика, то есть в качестве обновления. Также это предотвращает случайную установку оригинального непропатченного OTA.

@@ -43,7 +41,7 @@ avbroot модифицирует следующие образы:

 ## Использование

-1. Убедитесь, что вы ознакомились и поняли указанные выше [предостережения.](#предостережения) 
+1. Убедитесь, что вы ознакомились и поняли указанные выше [предостережения.](#предостережения)

 2. Скачайте последнюю версию со страницы [релизов.](https://github.com/chenxiaolong/avbroot/releases) Чтобы сверить цифровую подпись, см. раздел [проверки цифровых подписей.](#проверка-цифровых-подписей)

@@ -107,7 +105,7 @@ avbroot модифицирует следующие образы:

 Первые два компонента подписываются ключом AVB, а последние два – ключом OTA. Можно использовать один и тот же ключ, однако в следующих шагах описано, как сгенерировать два отдельных.

-Если вы патчите OTA сразу для нескольких устройств, настоятельно рекомендуется генерировать уникальные ключи для каждого девайса – так вы защитите себя от случайной прошивки неподходящего OTA для другого телефона. 
+Если вы патчите OTA сразу для нескольких устройств, настоятельно рекомендуется генерировать уникальные ключи для каждого девайса – так вы защитите себя от случайной прошивки неподходящего OTA для другого телефона.

 1. Сгенерируйте ключи подписи для AVB и OTA.

@@ -119,10 +117,10 @@ avbroot модифицирует следующие образы:
 2. Преобразуйте публичную часть ключа подписи AVB в формат метаданных публичного ключа AVB. Именно этот формат используется в загрузчике устройства для установки пользовательского ключа.

    ```bash
-    avbroot key extract-avb -k avb.key -o avb_pkmd.bin
+    avbroot key encode-avb -k avb.key -o avb_pkmd.bin
    ```

-3. Сгенерируйте самоподписанный сертификат для ключа подписи OTA. Он используется режимом Recovery для проверки подписи OTA при сайдлоадинге обновления.
+3. Сгенерируйте самоподписанный сертификат для ключа подписи OTA. Он используется режимом Recovery для проверки подписи OTA при установке обновления.

    ```bash
    avbroot key generate-cert -k ota.key -o ota.crt
@@ -185,7 +183,7 @@ avbroot совместим с любым стандартным 4096-битны
    fastboot flashall --skip-reboot
    ```

-    Обратите внимание, что так прошиваются лишь те образы, что относятся к системе. Разделы загрузчика и модема же остаются нетронутыми из-за ограничений fastboot. Если они не обновлены до необходимой версии, или вы не уверены в этом, после прошивки перейдите к пункту [обновлений](#обновления) и установите пропатченный OTA-архив сайдлоадом в режиме Recovery. Прошивка полного OTA гарантирует, что абсолютно все разделы будут обновлены.
+    Обратите внимание, что так прошиваются лишь те образы, что относятся к системе. Разделы загрузчика и модема же остаются нетронутыми из-за ограничений fastboot. Если они не обновлены до необходимой версии, или вы не уверены в этом, после прошивки перейдите к пункту [обновлений](#обновления) и установите пропатченный OTA в режиме Recovery. Прошивка полного OTA гарантирует, что абсолютно все разделы будут обновлены.

    Для устройств Pixel есть ещё один вариант: запуск скрипта `flash-base.sh` из папки заводских образов (factory images) обновит загрузчик и модем.

@@ -255,11 +253,11 @@ avbroot совместим с любым стандартным 4096-битны

 ## OTA-обновления

-avbroot заменяет `/system/etc/security/otacerts.zip` в разделах системы и Recovery на новый архив, содержащий пользовательский сертификат подписи OTA. Это предотвращает случайную установку непропатченных OTA как при загрузке в Android, так и при сайдлоадинге через Recovery.
+avbroot заменяет `/system/etc/security/otacerts.zip` в разделах системы и Recovery на новый архив, содержащий пользовательский сертификат подписи OTA. Это предотвращает случайную установку непропатченных OTA как из-под загруженной системы, так и при прошивке через Recovery.

-Рекомендуется отключить приложение обновлений системы, чтобы оно не пыталось установить непропатченные OTA:
+Рекомендуется отключить системное приложение для обновлений, чтобы оно не пыталось установить непропатченные OTA:

-* Стоковая прошивка: Отключите `Автоматические обновления системы` (Automatic system updates в англ.) в настройках для разработчиков.
+* Стоковая (заводская) прошивка: Отключите `Автоматические обновления системы` (Automatic system updates в англ.) в настройках для разработчиков.
 * Кастомная прошивка: Отключите приложение обновлений системы (или запретите ему доступ к Интернету) через Настройки -> Приложения -> Все приложения -> (меню/три точки) -> Показать системные -> (найдите приложение обновлений, например Обновления системы/Updater).

 Это особенно важно для некоторых кастомных прошивок, поскольку их фирменное приложение для обновления системы может уйти в бесконечный цикл, загружая OTA-обновление, а затем повторяя попытку загрузки и установки при неудачной проверке подписи.
@@ -295,6 +293,7 @@ Magisk версии 25211 и новее требует наличие разде
        --input /path/to/ota.zip \
        --directory . \
        --boot-only
+        --partition <название раздела> # init_boot или boot, в зависимости от устройства
    ```

 2. Теперь нужно пропатчить загрузочный образ с помощью приложения Magisk. Это **ДОЛЖНО** быть сделано именно на целевом устройстве или устройстве той же модели! Имя раздела будет неверным и не подойдет, если пропатчить образ на устройстве иной модели.
@@ -381,17 +380,34 @@ avbroot может подменить используемый загрузоч

 avbroot можно использовать для простого переподписания OTA, указав аргумент `--rootless` вместо `--magisk`/`--prepatched`. В таком случае пропатченный OTA не будет рутирован. Единственная модификация, которая будет применена – это замена сертификата проверки OTA, чтобы систему можно было обновлять с помощью будущих пропатченных OTA.

-### Пропуск патчинга сертификата OTA в разделе Recovery
+### Пропуск патчинга сертификата OTA

-avbroot может пропустить изменение файла `otacerts.zip` в разделе Recovery с помощью опции `--skip-recovery-ota-cert`. **Не используйте эту функцию, если на то нет веской причины.** (Например, если вы уже самостоятельно встроили сертификат OTA в загрузочный образ (`boot.img`) и передаете его программе через опции `--prepatched` или `--replace`.) Если эта опция применяется совместно с `--rootless` (и без указания параметра `--dsu`), то в загрузочный образ не будут внесены никакие изменения, кроме обеспечения его корректной подписи.
+Вы можете пропустить изменение otacerts.zip, используя аргументы  `--skip-system-ota-cert` и `--skip-recovery-ota-cert`. **Не используйте их без веской причины.**

-Если вы вручную добавили сертификат OTA в загрузочный образ, рекомендуем [предварительно проверить пропатченный OTA.](#проверка-ota)
+При использовании `--skip-system-ota-cert`, сертификаты OTA в образе `system` изменены не будут. Это не позволит сторонним приложениям для OTA-обновлений устанавливать будущие пропатченные OTA из-под загруженной системы.

-### Подмена разделов
+При использовании `--skip-recovery-ota-cert`, сертификаты OTA в образах `vendor_boot` или `recovery` изменены не будут. **Это не позволит устанавливать будущие пропатченные OTA в режиме Recovery.**

-avbroot поддерживает подмену целых образов в OTA, даже тех, что не являются загрузочными (например, `vendor_dlkm`). Образ можно заменить, указав аргумент `--replace <имя раздела> /путь/к/образу.img`.
+Если вы используете аргумент `--skip-recovery-ota-cert`, потому что уже добавили сертификат OTA в загрузочный образ вручную, рекомендуетcя [проверить пропатченный OTA](#проверка-ota), дабы удостовериться, что замена произведена корректно. Процесс верификации проверяет только копию сертификатов OTA в загрузочном образе, не проверяя копию в образе системы.

-Единственное, что меняется – это то, откуда считывается раздел. При использовании `--replace` вместо использования образа раздела из оригинального `payload.bin` в OTA, он берется напрямую по указанному вами пути. Таким образом, заменяющие образы разделов должны иметь правильные колонтитулы vbmeta, соответствующие оригинальным.
+### Пропуск всех патчей
+ 
+Чтобы внести самый минимум изменений, укажите аргументы:
+ 
+* `--skip-system-ota-cert`
+* `--skip-recovery-ota-cert`
+* `--rootless`
+* не используйте аргумент `--dsu`.
+ 
+Так, пользовательскими ключами будут переподписаны лишь образ `vbmeta` и OTA, остальные разделы останутся нетронутыми.
+ 
+**Это следует использовать только для устранения неполадок.** Без патчей сертификатов, поверх полученного OTA не получится установить никакие обновления.	
+
+### Подмена образов
+
+avbroot поддерживает подмену целых образов в OTA, даже тех, что не являются загрузочными (например, `vendor_dlkm`). Образ можно заменить, используя аргумент `--replace <имя раздела> /путь/к/образу.img`.
+
+Единственное, что меняется – это то, откуда считывается файл. При использовании `--replace` вместо образа раздела из оригинального `payload.bin` в OTA, он берется напрямую по указанному вами пути. Заменяющие образы разделов должны иметь правильные колонтитулы vbmeta, соответствующие оригинальным.

 Это не влияет на ход применения пачтей. Например, при использовании Magisk, патч получения root-прав применяется к загрузочному образу одинаково, независимо от того, был ли он получен из оригинального `payload.bin` или это файл, указанный через `--replace`.

@@ -405,6 +421,18 @@ Verified boot is disabled by vbmeta's header flags: 0x3

 Чтобы принудительно включить AVB (очистив флаги), укажите аргумент `--clear-vbmeta-flags`.

+### Изменение алгоритма CoW сжатия для вирутального A/B
+ 
+Алгоритм CoW (copy-on-write) сжатия для виртуального A/B можно изменить, используя аргумент `--vabc-algo <алгоритм>`, указав `gz` или `lz4`. Как правило, по умолчанию OTA использует алгоритм, который совместим с изначальной версией Android, на которой поставлялось устройство.
+ 
+* Девайсы, поставляемые с Android 12, поддерживают `gz` и `brotli` (последний не поддерживается avbroot)
+* Девайсы, поставляемые с Android 14, поддерживают `lz4`
+* Девайсы, поставляемые с Android 15, поддерживают `zstd` (не поддерживается avbroot)
+ 
+Выбор быстрого алгоритма, такого как lz4, может значительно ускорить установку OTA из-под системы (при использованием стороннего приложения для OTA-обновлений). Однако, при установке OTA в режиме Recovery, разницы в скорости не будет.
+ 
+Обратите внимание, что текущая используемая версия Android должна поддерживать выбранный алгоритм сжатия. В противном случае установка завершится ошибкой. Например, попытка установить OTA-обновление с Android 14, использующее алгоритм lz4, приведет к ошибке, если установка производится из-под Android 13.
+
 ### Использование в неинтерактивном режиме

 По умолчанию avbroot интерактивно запрашивает пароли к приватным ключам. Чтобы запустить avbroot в неинтерактивном режиме, можно:
@@ -441,17 +469,20 @@ Verified boot is disabled by vbmeta's header flags: 0x3

 * Использовать незашифрованные приватные ключи. Крайне не рекомендуется.

-### Извлечение всей OTA
+### Извлечение образов из OTA

-Чтобы извлечь все образы, содержащиеся в `payload.bin`, используйте команду:
+Чтобы извлечь образы разделов, содержащихся в `payload.bin`, используйте команду:

 ```bash
 avbroot ota extract \
    --input /путь/к/ota.zip \
-    --directory extracted \
-    --all
+    --directory extracted
 ```

+По умолчанию извлекаются только те образы, которые потенциально могут быть пропатчены с помощью avbroot. Чтобы извлечь все образы, используйте опцию `--all`. Для извлечения конкретных образов используйте опцию `--partition <название раздела>`, которую можно указать несколько раз.
+
+Эта команда также поддерживает извлечение встроенного сертификата OTA и публичного ключа AVB с помощью опций `--cert-ota` и `--public-key-avb`. Чтобы извлечь только эти компоненты, укажите аргумент `--none`, чтобы пропустить извлечение образов разделов.
+
 ### Режим записи ZIP

 По умолчанию, avbroot использует потоковую запись для вывода OTA во время патчинга. Это означает, что он вычисляет дайджест sha256 для цифровой подписи одновременно с записью файла. Такой режим приводит к тому, что в ZIP-файле появляются описатели данных, что является частью стандарта ZIP и работает на подавляющем большинстве устройств. Однако некоторые устройства могут иметь некорректно работающие парсеры ZIP-файлов и не смогут правильно прочитать ZIP-файлы OTA, содержащие описатели данных. Если это так, используйте опцию `--zip-mode seekable` при патчинге.
@@ -480,6 +511,53 @@ avbroot поддерживает делегирование всех опера

 Обратите внимание, что avbroot проверит подпись, возвращенную внешней программой, на соответствие с публичным ключом. Это гарантирует, что процесс патчинга завершится ошибкой, если был использован неправильный приватный ключ.

+### Размер страницы 16 КБ в настройках для разработчиков
+
+На современных устройствах с Android 16 и выше, в настройках для разработчиков может появиться опция переключения на ядро с размером страницы 16 КБ. Однако, эта функция не будет работать в системе, пропатченной с помощью avbroot, поскольку переключение данной настройки осуществляется путём установки инкрементальной OTA:
+
+* `/vendor/boot_otas/boot_ota_16k.zip` — используется для переключения на ядро с размером страницы 16 КБ (в разделе `boot` уже должно быть прошито ядро с размером страницы 4K)  
+* `/vendor/boot_otas/boot_ota_4k.zip` — используется для переключения на ядро с размером страницы 4 КБ (в разделе `boot` уже должно быть прошито ядро с размером страницы 16K)
+
+Эти файлы (в `boot_otas`) невозможно прошить на системе, пропатченной avbroot, потому что `payload.bin` внутри них подписан ключом производителя. Кроме того, это неполноценные OTA-файлы: у них нет метаданных, характерных для OTA, а сам zip-файл не подписан. Это просто обычный архив, который содержит подписанный `payload.bin`.
+
+Поддержка `boot_otas` не планируется. Это потребует реализации функционала для модификации ФС в инкрементальных OTA и их дальнейшей обработки, что сделать очень непросто.
+
+Если вы всё же хотите завести эту функцию, можно попробовать вручную подписать файлы в `boot_otas` собственным ключом. Поскольку инкрементальные OTA не пересоздаются, раздел `boot` должен оставаться без изменений во время выполнения команды `avbroot ota patch`.
+
+1. Распакуйте `vendor.img` с помощью avbroot и [afsr](https://github.com/chenxiaolong/afsr):
+    ```bash
+    avbroot avb unpack -i vendor.img
+    afsr unpack -i raw.img
+    ```
+
+2. Извлеките `payload.bin` из `boot_otas/boot_ota_16k.zip`.
+
+3. Переподпишите `payload.bin` вашим OTA-ключом:
+    ```bash
+    avbroot payload repack \
+        -i payload.bin.orig \
+        -o payload.bin \
+        -k ota.key \
+        --output-properties payload_properties.txt
+    ```
+
+4. Создайте новый zip, включающий `payload.bin` и `payload_properties.txt`. Файлы должны быть добавлены без сжатия (например, с помощью `zip -0`).
+
+5. Повторите эту процедуру для `boot_otas/boot_ota_4k.zip`.
+
+6. Соберите `vendor.img` обратно и подпишите его вашим AVB-ключом:
+    ```bash
+    afsr pack -o raw.img
+    avbroot avb pack -o vendor.img -k avb.key --recompute-size
+    ```
+
+7. Пропатчите обычный OTA-архив с прошивкой, подменив `vendor` на модифицированный образ:
+    ```bash
+    avbroot ota patch \
+        --replace vendor <модифицированный vendor.img> \
+        <дальше указываются аргументы, как при обычном патчинге>
+    ```
+
 ## Сборка из исходного кода

 Убедитесь, что у вас установлен [набор инструментов Rust.](https://www.rust-lang.org/ru/) Затем выполните:
@@ -13,28 +13,31 @@ anyhow = "1.0.75"
 base64 = "0.22.1"
 bitflags = { version = "2.4.1", features = ["serde"] }
 bstr = "1.6.2"
+bzip2 = "0.6.0"
 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"] }
+# We can't upgrade to 0.10.0 until x509-cert updates it too, since it's part of
+# the public API.
 const-oid = "0.9.5"
 crc32fast = "1.4.2"
 ctrlc = "3.4.0"
 dlv-list = "0.6.0"
-flate2 = "1.0.27"
+flate2 = { version = "1.0.29", features = ["zlib-rs"] }
 gf256 = { version = "0.3.0", features = ["rs"] }
 hex = { version = "0.4.3", features = ["serde"] }
-liblzma = "0.3.0"
+liblzma = "0.4.1"
 lz4_flex = "0.11.1"
 memchr = "2.6.0"
-miniz_oxide = "0.8.0"
 num-bigint-dig = "0.8.4"
 num-traits = "0.2.16"
 passterm = "2.0.3"
-phf = { version = "0.11.2", features = ["macros"] }
+phf = { version = "0.12.1", features = ["macros"] }
 pkcs8 = { version = "0.10.2", features = ["encryption", "pem"] }
-prost = "0.13.1"
+prost = "0.14.1"
+# We can't upgrade to 0.9.0 until rsa updates its rand_core dependency.
 rand = "0.8.5"
 rayon = "1.7.0"
 regex = { version = "1.9.4", default-features = false, features = ["perf", "std"] }
@@ -42,14 +45,14 @@ 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.17.0"
+ring = "0.17.14"
 rsa = { version = "0.9.2", features = ["sha1", "sha2"] }
 serde = { version = "1.0.188", features = ["derive"] }
 sha1 = "0.10.5"
 sha2 = "0.10.7"
 tempfile = "3.8.0"
 thiserror = "2.0.3"
-toml_edit = { version = "0.22.9", features = ["serde"] }
+toml_edit = { version = "0.23.3", features = ["serde"] }
 topological-sort = "0.2.2"
 tracing = "0.1.40"
 tracing-subscriber = "0.3.18"
@@ -57,34 +60,29 @@ x509-cert = { version = "0.2.4", features = ["builder"] }
 zerocopy = { version = "0.8.10", features = ["std"] }
 zerocopy-derive = "0.8.5"

-# 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/chenxiaolong/bzip2-rs"
-rev = "6e0f9836ec87b19261461b6cc1772e14aff8e851"
-
-# https://github.com/zip-rs/zip/pull/383
+# https://github.com/zip-rs/zip2/pull/367
+# https://github.com/zip-rs/zip2/pull/368
+# For getting the data offset when writing new zip entries.
 [dependencies.zip]
-git = "https://github.com/chenxiaolong/zip"
-rev = "989101f9384b9e94e36e6e9e0f51908fdf98bde6"
+git = "https://github.com/chenxiaolong/zip2"
+rev = "59685f4dadbfee8cb3ea74c8fbb402b60d8137e8"
 default-features = false
 features = ["deflate"]

 [target.'cfg(unix)'.dependencies]
 libc = "0.2.158"
-rustix = { version = "0.38.9", default-features = false, features = ["process"] }
+rustix = { version = "1.0.3", default-features = false, features = ["process"] }

 [build-dependencies]
-constcat = "0.5.0"
-prost-build = "0.13.1"
-protox = "0.7.0"
+constcat = "0.6.0"
+prost-build = "0.14.1"
+protox = "0.9.0"

 [dev-dependencies]
 assert_matches = "1.5.0"

 [features]
-static = ["bzip2/static", "liblzma/static"]
+static = ["liblzma/static"]

 [lints]
 workspace = true
@@ -10,7 +10,7 @@ use std::{

 use anyhow::Result;
 use clap::{Parser, Subcommand, ValueEnum};
-use tracing::{debug, Level};
+use tracing::{Level, debug};
 use tracing_subscriber::fmt::{format::Writer, time::FormatTime};

 use crate::cli::{avb, boot, completion, cpio, fec, hashtree, key, lp, ota, payload, sparse};
@@ -30,10 +30,13 @@ pub enum Command {
    Payload(payload::PayloadCli),
    Sparse(sparse::SparseCli),
    /// (Deprecated: Use `avbroot ota patch` instead.)
+    #[command(hide = true)]
    Patch(ota::PatchCli),
    /// (Deprecated: Use `avbroot ota extract` instead.)
+    #[command(hide = true)]
    Extract(ota::ExtractCli),
    /// (Deprecated: Use `avbroot boot magisk-info` instead.)
+    #[command(hide = true)]
    MagiskInfo(boot::MagiskInfoCli),
 }

@@ -5,13 +5,12 @@ use std::{
    collections::{HashMap, HashSet},
    ffi::{OsStr, OsString},
    fs::{self, File},
-    io::{self, BufReader, BufWriter, Cursor, Read, Seek, SeekFrom, Write},
+    io::{self, BufReader, BufWriter, Cursor, Seek, SeekFrom, Write},
    path::{Path, PathBuf},
-    str,
    sync::atomic::AtomicBool,
 };

-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{Context, Result, anyhow, bail};
 use cap_std::{
    ambient_authority,
    fs::{Dir, OpenOptions},
@@ -20,7 +19,7 @@ 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 tracing::{Span, debug_span, info, warn};

 use crate::{
    crypto::{self, PassphraseSource, RsaSigningKey},
@@ -28,7 +27,7 @@ use crate::{
        self, AlgorithmType, AppendedDescriptorMut, AppendedDescriptorRef, Descriptor, Footer,
        HashTreeDescriptor, Header, KernelCmdlineDescriptor,
    },
-    stream::{self, check_cancel, PSeekFile, Reopen, ToWriter},
+    stream::{self, PSeekFile, ReadFixedSizeExt, Reopen, ToWriter, check_cancel},
    util,
 };

@@ -96,18 +95,6 @@ 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(
@@ -195,13 +182,11 @@ 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(&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)
@@ -346,7 +331,7 @@ fn sign_or_clear(info: &mut AvbInfo, orig_header: &Header, key_group: &KeyGroup)
        } else {
            SignAction::Clear
        }
-    } else if originally_signed && &info.header != orig_header {
+    } else if originally_signed && (&info.header != orig_header || info.header.verify().is_err()) {
        SignAction::Sign
    } else {
        // If the original image was signed, we can preserve the existing
@@ -478,6 +463,10 @@ pub fn verify_headers(
        info!("{name} has an unsigned vbmeta header");
    }

+    if header.flags != 0 {
+        warn!("{name} has insecure flags: {:#x}", header.flags);
+    }
+
    for descriptor in &header.descriptors {
        let Some(target_name) = descriptor.partition_name() else {
            continue;
@@ -526,7 +515,7 @@ fn verify_and_repair(
            info!("Verifying hash tree descriptor{suffix}");

            match d.verify(&file, cancel_signal) {
-                Err(e @ avb::Error::HashTree(_)) if repair => {
+                Err(e @ avb::Error::HashTreeVerify(_)) if repair => {
                    warn!("Failed to verify hash tree descriptor{suffix}: {e}");
                    warn!("Attempting to repair using FEC data{suffix}");

@@ -639,9 +628,8 @@ fn compute_digest_recursive(
        .seek(SeekFrom::Start(header_offset))
        .with_context(|| format!("Failed to seek file: {path:?}"))?;

-    let mut raw_header_orig = vec![0u8; raw_header.len()];
-    raw_reader
-        .read_exact(&mut raw_header_orig)
+    let raw_header_orig = raw_reader
+        .read_vec_exact(raw_header.len())
        .with_context(|| format!("Failed to reread AVB header: {path:?}"))?;

    if raw_header != raw_header_orig {
@@ -747,7 +735,6 @@ fn repack_subcommand(cli: &RepackCli, cancel_signal: &AtomicBool) -> Result<()>
        // Write new hash tree and FEC data instead of copying the original.
        // There could have been errors in the original FEC data itself.
        if let AppendedDescriptorMut::HashTree(d) = info.header.appended_descriptor_mut()? {
-            promote_insecure_hash_algorithm(&mut d.hash_algorithm);
            d.update(&file, &file, None, cancel_signal)?;
        }

@@ -7,7 +7,7 @@ use std::{
    path::{Path, PathBuf},
 };

-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use clap::{Parser, Subcommand};

 use crate::{
@@ -9,7 +9,7 @@ use std::{
    sync::atomic::AtomicBool,
 };

-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use bstr::ByteSlice;
 use cap_std::{ambient_authority, fs::Dir};
 use clap::{Parser, Subcommand};
@@ -46,7 +46,7 @@ pub fn key_main(cli: &KeyCli) -> Result<()> {
            crypto::write_pem_cert_file(&c.output, &cert)
                .with_context(|| format!("Failed to write certificate: {:?}", c.output))?;
        }
-        KeyCommand::ExtractAvb(c) => {
+        KeyCommand::ExtractAvb(c) | KeyCommand::EncodeAvb(c) => {
            let public_key = if let Some(p) = &c.input.key {
                let passphrase = get_passphrase_source(&c.passphrase, p);
                let private_key = crypto::read_pem_key_file(p, &passphrase)
@@ -150,12 +150,12 @@ struct GenerateCertCli {
    validity: u64,
 }

-/// Extract the AVB public key from a private key or certificate.
+/// Convert a key or certificate to an AVB-encoded public key.
 ///
 /// The public key is stored in both the private key and the certificate. Either
 /// one can be used interchangeably.
 #[derive(Debug, Parser)]
-struct ExtractAvbCli {
+struct EncodeAvbCli {
    /// Path to output AVB public key.
    #[arg(short, long, value_name = "FILE", value_parser)]
    output: PathBuf,
@@ -183,7 +183,10 @@ struct DecodeAvbCli {
 enum KeyCommand {
    GenerateKey(GenerateKeyCli),
    GenerateCert(GenerateCertCli),
-    ExtractAvb(ExtractAvbCli),
+    /// (Deprecated: Use `avbroot key encode-avb` instead.)
+    #[command(hide = true)]
+    ExtractAvb(EncodeAvbCli),
+    EncodeAvb(EncodeAvbCli),
    DecodeAvb(DecodeAvbCli),
 }

@@ -9,7 +9,7 @@ use std::{
    sync::atomic::AtomicBool,
 };

-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use cap_std::{ambient_authority, fs::Dir};
 use clap::{CommandFactory, Parser, Subcommand};
 use rayon::iter::{
@@ -10,7 +10,7 @@ use std::{
    sync::atomic::AtomicBool,
 };

-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{Context, Result, anyhow, bail};
 use cap_std::{ambient_authority, fs::Dir};
 use clap::{Args, Parser, Subcommand};
 use tracing::info;
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2024 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2024-2025 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

 use std::{
@@ -10,10 +10,10 @@ use std::{
    sync::atomic::AtomicBool,
 };

-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{Context, Result, anyhow, bail};
 use clap::{Parser, Subcommand};
 use crc32fast::Hasher;
-use zerocopy::{little_endian, IntoBytes};
+use zerocopy::{IntoBytes, little_endian};

 use crate::{
    format::{
@@ -122,13 +122,13 @@ fn find_allocated_regions(
    loop {
        stream::check_cancel(cancel_signal)?;

-        start = match rustix::fs::seek(reader, SeekFrom::Data(end as i64)) {
+        start = match rustix::fs::seek(reader, SeekFrom::Data(end)) {
            Ok(offset) => offset,
            Err(e) if e == Errno::NXIO => break,
            Err(e) => return Err(e).with_context(|| format!("Failed to seek to data: {path:?}")),
        };

-        end = rustix::fs::seek(reader, SeekFrom::Hole(start as i64))
+        end = rustix::fs::seek(reader, SeekFrom::Hole(start))
            .with_context(|| format!("Failed to seek to hole: {path:?}"))?;

        result.push(start..end);
@@ -317,11 +317,11 @@ fn unpack_subcommand(
                })?;
            }
            ChunkData::Hole => {
-                // This cannot overflow.
-                let to_skip = chunk.bounds.len() * metadata.header.block_size;
+                // Unlike ChunkData::Data, this can overflow a u32.
+                let to_skip = i64::from(chunk.bounds.len()) * i64::from(metadata.header.block_size);

                writer
-                    .seek(SeekFrom::Current(to_skip.into()))
+                    .seek(SeekFrom::Current(to_skip))
                    .with_context(|| format!("Failed to seek file: {:?}", cli.output))?;
            }
            ChunkData::Crc32(_) => {}
@@ -1,11 +1,11 @@
-// SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2023-2025 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

 use std::{
    env::{self, VarError},
    ffi::{OsStr, OsString},
    fs::{self, File, OpenOptions},
-    io::{self, BufReader, BufWriter, Read, Write},
+    io::{self, Read, Write},
    path::{Path, PathBuf},
    process::{Command, ExitStatus, Stdio},
    time::Duration,
@@ -21,41 +21,43 @@ use cms::{
 };
 use passterm::PromptError;
 use pkcs8::{
-    pkcs5::{pbes2, scrypt},
    DecodePrivateKey, DecodePublicKey, EncodePrivateKey, EncodePublicKey, EncryptedPrivateKeyInfo,
    LineEnding, PrivateKeyInfo,
+    pkcs5::{pbes2, scrypt},
 };
 use rand::RngCore;
 use rsa::{
-    pkcs1v15::SigningKey, traits::PublicKeyParts, Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey,
+    Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey, pkcs1v15::SigningKey, traits::PublicKeyParts,
 };
 use serde::{Deserialize, Serialize};
 use sha1::Sha1;
 use sha2::{Digest, Sha256, Sha512};
 use thiserror::Error;
 use x509_cert::{
+    Certificate,
    builder::{Builder, CertificateBuilder, Profile},
-    der::{pem::PemLabel, referenced::OwnedToRef, Any, Decode, DecodePem, EncodePem},
+    der::{Any, Decode, DecodePem, EncodePem, pem::PemLabel, referenced::OwnedToRef},
    serial_number::SerialNumber,
    spki::{AlgorithmIdentifierOwned, SubjectPublicKeyInfoOwned},
    time::Validity,
-    Certificate,
 };

+use crate::util::DebugString;
+
 #[derive(Debug, Error)]
 pub enum Error {
    #[error("Signature algorithm not supported: {0:?}")]
    UnsupportedAlgorithm(SignatureAlgorithm),
    #[error("RSA key size ({}) not supported", .0 * 8)]
-    UnsupportedKey(usize),
+    UnsupportedKeySize(usize),
    #[error("Invalid digest length ({0} bytes) for {1:?}")]
    InvalidDigestLength(usize, SignatureAlgorithm),
    #[error("Invalid signature length ({0} bytes) for {1:?}")]
    InvalidSignatureLength(usize, SignatureAlgorithm),
-    #[error("Failed to run command: {0}")]
-    CommandSpawnFailed(String, #[source] io::Error),
-    #[error("Command failed with status: {1}: {0}")]
-    CommandExecutionFailed(String, ExitStatus),
+    #[error("Failed to run command: {0:?}")]
+    CommandSpawn(DebugString, #[source] io::Error),
+    #[error("Command failed with status: {1}: {0:?}")]
+    CommandExecution(DebugString, ExitStatus),
    #[error("Signature from signing helper does not match public key: {0:?}")]
    SigningHelperBadSignature(PathBuf),
    #[error("Passphrase prompt requires an interactive terminal")]
@@ -68,28 +70,40 @@ pub enum Error {
    InvalidEnvVar(OsString, #[source] VarError),
    #[error("PEM has start tag, but no end tag")]
    PemNoEndTag,
-    #[error("Failed to load encrypted private key")]
+    #[error("Failed to load encrypted RSA private key")]
    LoadKeyEncrypted(#[source] pkcs8::Error),
-    #[error("Failed to load unencrypted private key")]
+    #[error("Failed to load unencrypted RSA private key")]
    LoadKeyUnencrypted(#[source] pkcs8::Error),
-    #[error("Failed to save encrypted private key")]
+    #[error("Failed to save encrypted RSA private key")]
    SaveKeyEncrypted(#[source] pkcs8::Error),
-    #[error("Failed to save unencrypted private key")]
+    #[error("Failed to save unencrypted RSA private key")]
    SaveKeyUnencrypted(#[source] pkcs8::Error),
+    #[error("Failed to load RSA public key")]
+    LoadPubKey(#[source] pkcs8::spki::Error),
+    #[error("Failed to save RSA public key")]
+    SavePubKey(#[source] pkcs8::spki::Error),
+    #[error("Failed to load X509 certificate")]
+    LoadCert(#[source] x509_cert::der::Error),
+    #[error("Failed to save X509 certificate")]
+    SaveCert(#[source] x509_cert::der::Error),
+    #[error("Failed to generate RSA key")]
+    RsaGenerate(#[source] Box<rsa::Error>),
    #[error("Failed to RSA sign digest")]
-    RsaSign(#[source] rsa::Error),
+    RsaSign(#[source] Box<rsa::Error>),
    #[error("Failed to RSA verify signature")]
-    RsaVerify(#[source] rsa::Error),
-    #[error("X509 error")]
-    X509(#[from] x509_cert::builder::Error),
-    #[error("SPKI error")]
-    Spki(#[from] pkcs8::spki::Error),
-    #[error("DER error")]
-    Der(#[from] x509_cert::der::Error),
-    #[error("RSA error")]
-    Rsa(#[from] rsa::Error),
-    #[error("I/O error")]
-    Io(#[from] io::Error),
+    RsaVerify(#[source] Box<rsa::Error>),
+    #[error("Failed to generate X509 certificate")]
+    CertGenerate(#[source] x509_cert::builder::Error),
+    #[error("Invalid parameters for X509 certificate generation")]
+    CertParams(#[source] x509_cert::der::Error),
+    #[error("Failed to CMS sign digest")]
+    CmsSign(#[source] x509_cert::der::Error),
+    #[error("Failed to parse CMS signature")]
+    CmsParse(#[source] x509_cert::der::Error),
+    #[error("Failed to read file: {0:?}")]
+    ReadFile(PathBuf, #[source] io::Error),
+    #[error("Failed to write file: {0:?}")]
+    WriteFile(PathBuf, #[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;
@@ -130,6 +144,7 @@ pub enum PassphraseSource {

 impl PassphraseSource {
    pub fn new(key_file: &Path, pass_file: Option<&Path>, env_var: Option<&OsStr>) -> Self {
+        #[allow(clippy::option_if_let_else)]
        if let Some(v) = env_var {
            Self::EnvVar(v.to_owned())
        } else if let Some(p) = pass_file {
@@ -175,7 +190,8 @@ impl PassphraseSource {
                first
            }
            Self::EnvVar(v) => env::var(v).map_err(|e| Error::InvalidEnvVar(v.clone(), e))?,
-            Self::File(p) => fs::read_to_string(p)?
+            Self::File(p) => fs::read_to_string(p)
+                .map_err(|e| Error::ReadFile(p.clone(), e))?
                .trim_end_matches(['\r', '\n'])
                .to_owned(),
        };
@@ -187,7 +203,7 @@ impl PassphraseSource {
 fn check_key_size(size: usize) -> Result<()> {
    // RustCrypto does not support 8192-bit keys.
    if size > 4096 / 8 {
-        return Err(Error::UnsupportedKey(size));
+        return Err(Error::UnsupportedKeySize(size));
    }

    Ok(())
@@ -256,7 +272,9 @@ impl RsaSigningKey {
        };

        match self {
-            Self::Internal(key) => key.sign(scheme, digest).map_err(Error::RsaSign),
+            Self::Internal(key) => key
+                .sign(scheme, digest)
+                .map_err(|e| Error::RsaSign(Box::new(e))),
            Self::External {
                program,
                public_key,
@@ -292,7 +310,7 @@ impl RsaSigningKey {

                let mut child = command
                    .spawn()
-                    .map_err(|e| Error::CommandSpawnFailed(format!("{command:?}"), e))?;
+                    .map_err(|e| Error::CommandSpawn(DebugString::new(&command), e))?;

                // We don't bother with spawning a thread. The pipe capacity on
                // all major OSs is significantly larger than the digest, so we
@@ -304,14 +322,22 @@ impl RsaSigningKey {
                // * macOS: 4 KiB, 16 KiB (usually), or 64 KiB
                // * Windows: 4 KiB

-                let padded_digest = pkcs1v15_sign_pad(&scheme.prefix, digest, public_key.size())?;
-                child.stdin.as_mut().unwrap().write_all(&padded_digest)?;
+                let padded_digest = pkcs1v15_sign_pad(&scheme.prefix, digest, public_key.size())
+                    .map_err(|e| Error::RsaSign(Box::new(e)))?;
+                child
+                    .stdin
+                    .as_mut()
+                    .unwrap()
+                    .write_all(&padded_digest)
+                    .map_err(|e| Error::WriteFile("<signing helper stdin>".into(), e))?;

-                let child = child.wait_with_output()?;
+                let child = child
+                    .wait_with_output()
+                    .map_err(|e| Error::CommandSpawn(DebugString::new(&command), e))?;

                if !child.status.success() {
-                    return Err(Error::CommandExecutionFailed(
-                        format!("{command:?}"),
+                    return Err(Error::CommandExecution(
+                        DebugString::new(&command),
                        child.status,
                    ));
                } else if child.stdout.len() != self.size() {
@@ -355,7 +381,7 @@ impl RsaPublicKeyExt for RsaPublicKey {
        };

        self.verify(scheme, digest, signature)
-            .map_err(Error::RsaVerify)
+            .map_err(|e| Error::RsaVerify(Box::new(e)))
    }
 }

@@ -364,7 +390,7 @@ pub fn generate_rsa_key_pair() -> Result<RsaPrivateKey> {
    let mut rng = rand::thread_rng();

    // avbroot supports 4096-bit keys only.
-    let key = RsaPrivateKey::new(&mut rng, 4096)?;
+    let key = RsaPrivateKey::new(&mut rng, 4096).map_err(|e| Error::RsaGenerate(Box::new(e)))?;

    Ok(key)
 }
@@ -376,20 +402,27 @@ pub fn generate_cert(
    validity: Duration,
    subject: &str,
 ) -> Result<Certificate> {
-    let public_key_der = key.to_public_key().to_public_key_der()?;
+    let public_key_der = key
+        .to_public_key()
+        .to_public_key_der()
+        .map_err(Error::SavePubKey)?;
    let signing_key = SigningKey::<Sha256>::new(key.clone());

    let builder = CertificateBuilder::new(
        Profile::Root,
        SerialNumber::from(serial),
-        Validity::from_now(validity)?,
-        subject.parse()?,
-        SubjectPublicKeyInfoOwned::from_der(public_key_der.as_bytes())?,
+        Validity::from_now(validity).map_err(Error::CertParams)?,
+        subject.parse().map_err(Error::CertParams)?,
+        SubjectPublicKeyInfoOwned::from_der(public_key_der.as_bytes())
+            .map_err(Error::CertParams)?,
        &signing_key,
-    )?;
+    )
+    .map_err(Error::CertGenerate)?;

    let mut rng = rand::thread_rng();
-    let cert = builder.build_with_rng(&mut rng)?;
+    let cert = builder
+        .build_with_rng(&mut rng)
+        .map_err(Error::CertGenerate)?;

    Ok(cert)
 }
@@ -442,80 +475,92 @@ fn reformat_pem(data: &[u8]) -> Result<Vec<u8>> {
 }

 /// Read PEM-encoded certificate from a reader.
-pub fn read_pem_cert(mut reader: impl Read) -> Result<Certificate> {
+pub fn read_pem_cert(path: &Path, mut reader: impl Read) -> Result<Certificate> {
    let mut data = vec![];
-    reader.read_to_end(&mut data)?;
+    reader
+        .read_to_end(&mut data)
+        .map_err(|e| Error::ReadFile(path.to_owned(), e))?;

    let data = reformat_pem(&data)?;
-    let certificate = Certificate::from_pem(data)?;
+    let certificate = Certificate::from_pem(data).map_err(Error::LoadCert)?;

    Ok(certificate)
 }

 /// Write PEM-encoded certificate to a writer.
-pub fn write_pem_cert(mut writer: impl Write, cert: &Certificate) -> Result<()> {
-    let data = cert.to_pem(LineEnding::LF)?;
+pub fn write_pem_cert(path: &Path, mut writer: impl Write, cert: &Certificate) -> Result<()> {
+    let data = cert.to_pem(LineEnding::LF).map_err(Error::SaveCert)?;

-    writer.write_all(data.as_bytes())?;
+    writer
+        .write_all(data.as_bytes())
+        .map_err(|e| Error::WriteFile(path.to_owned(), e))?;

    Ok(())
 }

 /// Read PEM-encoded certificate from a file.
 pub fn read_pem_cert_file(path: &Path) -> Result<Certificate> {
-    let file = File::open(path)?;
-    let reader = BufReader::new(file);
+    let reader = File::open(path).map_err(|e| Error::ReadFile(path.to_owned(), e))?;

-    read_pem_cert(reader)
+    read_pem_cert(path, reader)
 }

 /// Write PEM-encoded certificate to a file.
 pub fn write_pem_cert_file(path: &Path, cert: &Certificate) -> Result<()> {
-    let file = File::create(path)?;
-    let writer = BufWriter::new(file);
+    let writer = File::create(path).map_err(|e| Error::WriteFile(path.to_owned(), e))?;

-    write_pem_cert(writer, cert)
+    write_pem_cert(path, writer, cert)
 }

 /// Read PEM-encoded PKCS8 public key from a reader.
-pub fn read_pem_public_key(mut reader: impl Read) -> Result<RsaPublicKey> {
+pub fn read_pem_public_key(path: &Path, mut reader: impl Read) -> Result<RsaPublicKey> {
    let mut data = String::new();
-    reader.read_to_string(&mut data)?;
+    reader
+        .read_to_string(&mut data)
+        .map_err(|e| Error::ReadFile(path.to_owned(), e))?;

-    let key = RsaPublicKey::from_public_key_pem(&data)?;
+    let key = RsaPublicKey::from_public_key_pem(&data).map_err(Error::LoadPubKey)?;

    Ok(key)
 }

 /// 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)?;
+pub fn write_pem_public_key(path: &Path, mut writer: impl Write, key: &RsaPublicKey) -> Result<()> {
+    let data = key
+        .to_public_key_pem(LineEnding::LF)
+        .map_err(Error::SavePubKey)?;

-    writer.write_all(data.as_bytes())?;
+    writer
+        .write_all(data.as_bytes())
+        .map_err(|e| Error::WriteFile(path.to_owned(), e))?;

    Ok(())
 }

 /// Read PEM-encoded PKCS8 public key from a file.
 pub fn read_pem_public_key_file(path: &Path) -> Result<RsaPublicKey> {
-    let file = File::open(path)?;
-    let reader = BufReader::new(file);
+    let reader = File::open(path).map_err(|e| Error::ReadFile(path.to_owned(), e))?;

-    read_pem_public_key(reader)
+    read_pem_public_key(path, reader)
 }

 /// 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);
+    let writer = File::create(path).map_err(|e| Error::WriteFile(path.to_owned(), e))?;

-    write_pem_public_key(writer, key)
+    write_pem_public_key(path, writer, key)
 }

 /// Read PEM-encoded PKCS8 private key from a reader.
-pub fn read_pem_key(mut reader: impl Read, source: &PassphraseSource) -> Result<RsaPrivateKey> {
+pub fn read_pem_key(
+    path: &Path,
+    mut reader: impl Read,
+    source: &PassphraseSource,
+) -> Result<RsaPrivateKey> {
    let mut data = String::new();
-    reader.read_to_string(&mut data)?;
+    reader
+        .read_to_string(&mut data)
+        .map_err(|e| Error::ReadFile(path.to_owned(), e))?;

    if data.contains("ENCRYPTED") {
        let passphrase = source.acquire(false)?;
@@ -528,6 +573,7 @@ pub fn read_pem_key(mut reader: impl Read, source: &PassphraseSource) -> Result<

 /// Write PEM-encoded PKCS8 private key to a writer.
 pub fn write_pem_key(
+    path: &Path,
    mut writer: impl Write,
    key: &RsaPrivateKey,
    source: &PassphraseSource,
@@ -570,20 +616,24 @@ pub fn write_pem_key(
            .encrypt_with_params(pbes2_params, passphrase)
            .map_err(Error::SaveKeyEncrypted)?;

-        secret_doc.to_pem(EncryptedPrivateKeyInfo::PEM_LABEL, LineEnding::LF)?
+        secret_doc
+            .to_pem(EncryptedPrivateKeyInfo::PEM_LABEL, LineEnding::LF)
+            .map_err(pkcs8::Error::Asn1)
+            .map_err(Error::SaveKeyEncrypted)?
    };

-    writer.write_all(data.as_bytes())?;
+    writer
+        .write_all(data.as_bytes())
+        .map_err(|e| Error::WriteFile(path.to_owned(), e))?;

    Ok(())
 }

 /// Read PEM-encoded PKCS8 private key from a file.
 pub fn read_pem_key_file(path: &Path, source: &PassphraseSource) -> Result<RsaPrivateKey> {
-    let file = File::open(path)?;
-    let reader = BufReader::new(file);
+    let reader = File::open(path).map_err(|e| Error::ReadFile(path.to_owned(), e))?;

-    read_pem_key(reader, source)
+    read_pem_key(path, reader, source)
 }

 /// Save PEM-encoded PKCS8 private key to a file.
@@ -603,16 +653,18 @@ pub fn write_pem_key_file(
        options.mode(0o600);
    }

-    let file = options.open(path)?;
-    let writer = BufWriter::new(file);
+    let writer = options
+        .open(path)
+        .map_err(|e| Error::WriteFile(path.to_owned(), e))?;

-    write_pem_key(writer, key, source)
+    write_pem_key(path, writer, key, source)
 }

 /// Get the RSA public key from a certificate.
 pub fn get_public_key(cert: &Certificate) -> Result<RsaPublicKey> {
    let public_key =
-        RsaPublicKey::try_from(cert.tbs_certificate.subject_public_key_info.owned_to_ref())?;
+        RsaPublicKey::try_from(cert.tbs_certificate.subject_public_key_info.owned_to_ref())
+            .map_err(Error::LoadPubKey)?;

    Ok(public_key)
 }
@@ -626,27 +678,26 @@ pub fn cert_matches_key(cert: &Certificate, key: &RsaSigningKey) -> Result<bool>

 /// Parse a CMS [`SignedData`] structure from raw DER-encoded data.
 pub fn parse_cms(data: &[u8]) -> Result<SignedData> {
-    let ci = ContentInfo::from_der(data)?;
-    let sd = ci.content.decode_as::<SignedData>()?;
+    let ci = ContentInfo::from_der(data).map_err(Error::CmsParse)?;
+    let sd = ci
+        .content
+        .decode_as::<SignedData>()
+        .map_err(Error::CmsParse)?;

    Ok(sd)
 }

-/// Get a list of all standard X509 certificates contained within a
+/// Get an iterator to all standard X509 certificates contained within a
 /// [`SignedData`] structure.
-pub fn get_cms_certs(sd: &SignedData) -> Vec<Certificate> {
-    sd.certificates.as_ref().map_or_else(Vec::new, |certs| {
-        certs
-            .0
-            .iter()
-            .filter_map(|cc| {
-                if let CertificateChoices::Certificate(c) = cc {
-                    Some(c.clone())
-                } else {
-                    None
-                }
-            })
-            .collect()
+pub fn iter_cms_certs(sd: &SignedData) -> impl Iterator<Item = &Certificate> {
+    sd.certificates.iter().flat_map(|certs| {
+        certs.0.iter().filter_map(|cc| {
+            if let CertificateChoices::Certificate(c) = cc {
+                Some(c)
+            } else {
+                None
+            }
+        })
    })
 }

@@ -669,14 +720,16 @@ pub fn cms_sign_external(

    let signed_data = SignedData {
        version: CmsVersion::V1,
-        digest_algorithms: DigestAlgorithmIdentifiers::try_from(vec![digest_algorithm.clone()])?,
+        digest_algorithms: DigestAlgorithmIdentifiers::try_from(vec![digest_algorithm.clone()])
+            .map_err(Error::CmsSign)?,
        encap_content_info: EncapsulatedContentInfo {
            econtent_type: const_oid::db::rfc5911::ID_DATA,
            econtent: None,
        },
-        certificates: Some(CertificateSet::try_from(vec![
-            CertificateChoices::Certificate(cert.clone()),
-        ])?),
+        certificates: Some(
+            CertificateSet::try_from(vec![CertificateChoices::Certificate(cert.clone())])
+                .map_err(Error::CmsSign)?,
+        ),
        crls: None,
        signer_infos: SignerInfos::try_from(vec![SignerInfo {
            version: CmsVersion::V1,
@@ -690,14 +743,15 @@ pub fn cms_sign_external(
                oid: const_oid::db::rfc5912::SHA_256_WITH_RSA_ENCRYPTION,
                parameters: None,
            },
-            signature: SignatureValue::new(signature)?,
+            signature: SignatureValue::new(signature).map_err(Error::CmsSign)?,
            unsigned_attrs: None,
-        }])?,
+        }])
+        .map_err(Error::CmsSign)?,
    };

    let signed_data = ContentInfo {
        content_type: const_oid::db::rfc5911::ID_SIGNED_DATA,
-        content: Any::encode_from(&signed_data)?,
+        content: Any::encode_from(&signed_data).map_err(Error::CmsSign)?,
    };

    Ok(signed_data)
@@ -4,7 +4,7 @@
 use std::{fmt, marker::PhantomData};

 use bstr::{ByteSlice, ByteVec};
-use serde::{de::Visitor, Deserializer, Serializer};
+use serde::{Deserializer, Serializer, de::Visitor};
 use thiserror::Error;

 #[derive(Clone, Debug, Error)]
@@ -13,7 +13,7 @@ use num_traits::ToPrimitive;
 use ring::digest::Context;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
-use zerocopy::{little_endian, FromBytes, IntoBytes};
+use zerocopy::{FromBytes, IntoBytes, little_endian};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};

 use crate::{
@@ -95,10 +95,16 @@ pub enum Error {
    },
    #[error("VTS signature is missing hash descriptor")]
    MissingHashDescriptor,
-    #[error("AVB error")]
-    Avb(#[from] avb::Error),
-    #[error("I/O error")]
-    Io(#[from] io::Error),
+    #[error("Failed to load VTS AVB signature")]
+    VtsAvbLoad(#[source] avb::Error),
+    #[error("Failed to save VTS AVB signature")]
+    VtsAvbSave(#[source] avb::Error),
+    #[error("Failed to generate VTS AVB signature")]
+    VtsAvbSign(#[source] avb::Error),
+    #[error("Failed to read boot image data: {0}")]
+    DataRead(&'static str, #[source] io::Error),
+    #[error("Failed to write boot image data: {0}")]
+    DataWrite(&'static str, #[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;
@@ -111,7 +117,7 @@ pub trait BootImageExt {

 /// Raw on-disk layout for the v0 image header.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawV0 {
    /// Magic value. This should be equal to [`BOOT_MAGIC`].
    magic: [u8; 8],
@@ -133,7 +139,7 @@ struct RawV0 {

 /// Raw on-disk layout for the extra v1 image header fields.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawV1Extra {
    recovery_dtbo_size: little_endian::U32,
    recovery_dtbo_offset: little_endian::U64,
@@ -142,7 +148,7 @@ struct RawV1Extra {

 /// Raw on-disk layout for the extra v2 image header fields.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawV2Extra {
    dtb_size: little_endian::U32,
    dtb_addr: little_endian::U64,
@@ -263,6 +269,7 @@ impl fmt::Display for BootImageV0Through2 {

 impl BootImageExt for BootImageV0Through2 {
    fn header_version(&self) -> u32 {
+        #[allow(clippy::bool_to_int_with_if)]
        if self.v2_extra.is_some() {
            2
        } else if self.v1_extra.is_some() {
@@ -293,7 +300,8 @@ impl<R: Read> FromReader<R> for BootImageV0Through2 {
    fn from_reader(reader: R) -> Result<Self> {
        let mut reader = CountingReader::new(reader);

-        let raw_v0 = RawV0::read_from_io(&mut reader)?;
+        let raw_v0 =
+            RawV0::read_from_io(&mut reader).map_err(|e| Error::DataRead("Boot::V0::header", e))?;

        if raw_v0.magic != BOOT_MAGIC {
            return Err(Error::UnknownMagic(raw_v0.magic));
@@ -336,7 +344,8 @@ impl<R: Read> FromReader<R> for BootImageV0Through2 {
        }

        let mut v1_data = if header_version >= 1 {
-            let raw_v1 = RawV1Extra::read_from_io(&mut reader)?;
+            let raw_v1 = RawV1Extra::read_from_io(&mut reader)
+                .map_err(|e| Error::DataRead("Boot::V1::header", e))?;

            let recovery_dtbo_size =
                util::check_bounds(raw_v1.recovery_dtbo_size.get(), ..=COMPONENT_MAX_SIZE)
@@ -362,7 +371,8 @@ impl<R: Read> FromReader<R> for BootImageV0Through2 {
        }

        let mut v2_data = if header_version == 2 {
-            let raw_v2 = RawV2Extra::read_from_io(&mut reader)?;
+            let raw_v2 = RawV2Extra::read_from_io(&mut reader)
+                .map_err(|e| Error::DataRead("Boot::V2::header", e))?;

            let dtb_size = util::check_bounds(raw_v2.dtb_size.get(), ..=COMPONENT_MAX_SIZE)
                .map_err(|e| Error::IntOutOfBounds("Boot::V2::dtb_size", e))?;
@@ -378,34 +388,50 @@ impl<R: Read> FromReader<R> for BootImageV0Through2 {
        };

        if let Some(v1) = &v1_data {
-            if reader.stream_position()? != u64::from(v1.header_size) {
+            if reader
+                .stream_position()
+                .map_err(|e| Error::DataRead("Boot::V1::header_size", e))?
+                != u64::from(v1.header_size)
+            {
                return Err(Error::InvalidHeaderSize(v1.header_size));
            }
        }

-        padding::read_discard(&mut reader, page_size.into())?;
+        padding::read_discard(&mut reader, page_size.into())
+            .map_err(|e| Error::DataRead("Boot::V0::header_padding", e))?;

-        let kernel = reader.read_vec_exact(kernel_size as usize)?;
-        padding::read_discard(&mut reader, page_size.into())?;
+        let kernel = reader
+            .read_vec_exact(kernel_size as usize)
+            .map_err(|e| Error::DataRead("Boot::V0::kernel", e))?;
+        padding::read_discard(&mut reader, page_size.into())
+            .map_err(|e| Error::DataRead("Boot::V0::kernel_padding", e))?;

-        let ramdisk = reader.read_vec_exact(ramdisk_size as usize)?;
-        padding::read_discard(&mut reader, page_size.into())?;
+        let ramdisk = reader
+            .read_vec_exact(ramdisk_size as usize)
+            .map_err(|e| Error::DataRead("Boot::V0::ramdisk", e))?;
+        padding::read_discard(&mut reader, page_size.into())
+            .map_err(|e| Error::DataRead("Boot::V0::ramdisk_padding", e))?;

-        let second = reader.read_vec_exact(second_size as usize)?;
-        padding::read_discard(&mut reader, page_size.into())?;
+        let second = reader
+            .read_vec_exact(second_size as usize)
+            .map_err(|e| Error::DataRead("Boot::V0::second", e))?;
+        padding::read_discard(&mut reader, page_size.into())
+            .map_err(|e| Error::DataRead("Boot::V0::second_padding", e))?;

        if let Some(v1) = &mut v1_data {
-            v1.v1_extra
-                .recovery_dtbo
-                .resize(v1.recovery_dtbo_size as usize, 0);
-            reader.read_exact(&mut v1.v1_extra.recovery_dtbo)?;
-            padding::read_discard(&mut reader, page_size.into())?;
+            v1.v1_extra.recovery_dtbo = reader
+                .read_vec_exact(v1.recovery_dtbo_size as usize)
+                .map_err(|e| Error::DataRead("Boot::V1::recovery_dtbo", e))?;
+            padding::read_discard(&mut reader, page_size.into())
+                .map_err(|e| Error::DataRead("Boot::V1::recovery_dtbo_padding", e))?;
        }

        if let Some(v2) = &mut v2_data {
-            v2.v2_extra.dtb.resize(v2.dtb_size as usize, 0);
-            reader.read_exact(&mut v2.v2_extra.dtb)?;
-            padding::read_discard(&mut reader, page_size.into())?;
+            v2.v2_extra.dtb = reader
+                .read_vec_exact(v2.dtb_size as usize)
+                .map_err(|e| Error::DataRead("Boot::V2::dtb", e))?;
+            padding::read_discard(&mut reader, page_size.into())
+                .map_err(|e| Error::DataRead("Boot::V2::dtb_padding", e))?;
        }

        let image = Self {
@@ -500,7 +526,9 @@ impl<W: Write> ToWriter<W> for BootImageV0Through2 {
            extra_cmdline,
        };

-        raw_v0.write_to_io(&mut writer)?;
+        raw_v0
+            .write_to_io(&mut writer)
+            .map_err(|e| Error::DataWrite("Boot::V0::header", e))?;

        if let Some(v1) = &self.v1_extra {
            let raw_v1 = RawV1Extra {
@@ -509,7 +537,9 @@ impl<W: Write> ToWriter<W> for BootImageV0Through2 {
                header_size: self.header_size().into(),
            };

-            raw_v1.write_to_io(&mut writer)?;
+            raw_v1
+                .write_to_io(&mut writer)
+                .map_err(|e| Error::DataWrite("Boot::V1::header", e))?;
        }

        if let Some(v2) = &self.v2_extra {
@@ -518,28 +548,46 @@ impl<W: Write> ToWriter<W> for BootImageV0Through2 {
                dtb_addr: v2.dtb_addr.into(),
            };

-            raw_v2.write_to_io(&mut writer)?;
+            raw_v2
+                .write_to_io(&mut writer)
+                .map_err(|e| Error::DataWrite("Boot::V2::header", e))?;
        }

-        padding::write_zeros(&mut writer, self.page_size.into())?;
+        padding::write_zeros(&mut writer, self.page_size.into())
+            .map_err(|e| Error::DataWrite("Boot::V0::header_padding", e))?;

-        writer.write_all(&self.kernel)?;
-        padding::write_zeros(&mut writer, self.page_size.into())?;
+        writer
+            .write_all(&self.kernel)
+            .map_err(|e| Error::DataWrite("Boot::V0::kernel", e))?;
+        padding::write_zeros(&mut writer, self.page_size.into())
+            .map_err(|e| Error::DataWrite("Boot::V0::kernel_padding", e))?;

-        writer.write_all(&self.ramdisk)?;
-        padding::write_zeros(&mut writer, self.page_size.into())?;
+        writer
+            .write_all(&self.ramdisk)
+            .map_err(|e| Error::DataWrite("Boot::V0::ramdisk", e))?;
+        padding::write_zeros(&mut writer, self.page_size.into())
+            .map_err(|e| Error::DataWrite("Boot::V0::ramdisk_padding", e))?;

-        writer.write_all(&self.second)?;
-        padding::write_zeros(&mut writer, self.page_size.into())?;
+        writer
+            .write_all(&self.second)
+            .map_err(|e| Error::DataWrite("Boot::V0::second", e))?;
+        padding::write_zeros(&mut writer, self.page_size.into())
+            .map_err(|e| Error::DataWrite("Boot::V0::second_padding", e))?;

        if let Some(v1) = &self.v1_extra {
-            writer.write_all(&v1.recovery_dtbo)?;
-            padding::write_zeros(&mut writer, self.page_size.into())?;
+            writer
+                .write_all(&v1.recovery_dtbo)
+                .map_err(|e| Error::DataWrite("Boot::V1::recovery_dtbo", e))?;
+            padding::write_zeros(&mut writer, self.page_size.into())
+                .map_err(|e| Error::DataWrite("Boot::V1::recovery_dtbo_padding", e))?;
        }

        if let Some(v2) = &self.v2_extra {
-            writer.write_all(&v2.dtb)?;
-            padding::write_zeros(&mut writer, self.page_size.into())?;
+            writer
+                .write_all(&v2.dtb)
+                .map_err(|e| Error::DataWrite("Boot::V2::dtb", e))?;
+            padding::write_zeros(&mut writer, self.page_size.into())
+                .map_err(|e| Error::DataWrite("Boot::V2::dtb_padding", e))?;
        }

        Ok(())
@@ -548,7 +596,7 @@ impl<W: Write> ToWriter<W> for BootImageV0Through2 {

 /// Raw on-disk layout for the v3 image header.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawV3 {
    /// Magic value. This should be equal to [`BOOT_MAGIC`].
    magic: [u8; 8],
@@ -563,7 +611,7 @@ struct RawV3 {

 /// Raw on-disk layout for the extra v4 image header fields.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawV4Extra {
    signature_size: little_endian::U32,
 }
@@ -621,11 +669,7 @@ impl fmt::Display for BootImageV3Through4 {

 impl BootImageExt for BootImageV3Through4 {
    fn header_version(&self) -> u32 {
-        if self.v4_extra.is_some() {
-            4
-        } else {
-            3
-        }
+        if self.v4_extra.is_some() { 4 } else { 3 }
    }

    fn header_size(&self) -> u32 {
@@ -646,7 +690,8 @@ impl<R: Read> FromReader<R> for BootImageV3Through4 {
    fn from_reader(reader: R) -> Result<Self> {
        let mut reader = CountingReader::new(reader);

-        let raw_v3 = RawV3::read_from_io(&mut reader)?;
+        let raw_v3 =
+            RawV3::read_from_io(&mut reader).map_err(|e| Error::DataRead("Boot::V3::header", e))?;

        if raw_v3.magic != BOOT_MAGIC {
            return Err(Error::UnknownMagic(raw_v3.magic));
@@ -668,7 +713,8 @@ impl<R: Read> FromReader<R> for BootImageV3Through4 {
            .map_err(|e| Error::StringNotUtf8("Boot::V3::cmdline", e, cmdline.to_vec()))?;

        let signature_size = if header_version == 4 {
-            let raw_v4 = RawV4Extra::read_from_io(&mut reader)?;
+            let raw_v4 = RawV4Extra::read_from_io(&mut reader)
+                .map_err(|e| Error::DataRead("Boot::V4::header", e))?;

            let size =
                util::check_bounds(raw_v4.signature_size.get(), ..=HDR_V4_SIGNATURE_SIZE as u32)
@@ -679,31 +725,48 @@ impl<R: Read> FromReader<R> for BootImageV3Through4 {
            None
        };

-        if reader.stream_position()? != u64::from(header_size) {
+        if reader
+            .stream_position()
+            .map_err(|e| Error::DataRead("Boot::V3::header_size", e))?
+            != u64::from(header_size)
+        {
            return Err(Error::InvalidHeaderSize(header_size));
        }

-        padding::read_discard(&mut reader, PAGE_SIZE.into())?;
+        padding::read_discard(&mut reader, PAGE_SIZE.into())
+            .map_err(|e| Error::DataRead("Boot::V3::header_padding", e))?;

-        let kernel = reader.read_vec_exact(kernel_size as usize)?;
-        padding::read_discard(&mut reader, PAGE_SIZE.into())?;
+        let kernel = reader
+            .read_vec_exact(kernel_size as usize)
+            .map_err(|e| Error::DataRead("Boot::V3::kernel", e))?;
+        padding::read_discard(&mut reader, PAGE_SIZE.into())
+            .map_err(|e| Error::DataRead("Boot::V3::kernel_padding", e))?;

-        let ramdisk = reader.read_vec_exact(ramdisk_size as usize)?;
-        padding::read_discard(&mut reader, PAGE_SIZE.into())?;
+        let ramdisk = reader
+            .read_vec_exact(ramdisk_size as usize)
+            .map_err(|e| Error::DataRead("Boot::V3::ramdisk", e))?;
+        padding::read_discard(&mut reader, PAGE_SIZE.into())
+            .map_err(|e| Error::DataRead("Boot::V3::ramdisk_padding", e))?;

        // 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 data = reader.read_vec_exact(s as usize)?;
+            let data = reader
+                .read_vec_exact(s as usize)
+                .map_err(|e| Error::DataRead("Boot::V4::signature", e))?;

            let signature = if s > 0 && !util::is_zero(&data) {
-                Some(Header::from_reader(Cursor::new(data))?)
+                let avb_header =
+                    Header::from_reader(Cursor::new(data)).map_err(Error::VtsAvbLoad)?;
+
+                Some(avb_header)
            } else {
                None
            };

-            padding::read_discard(&mut reader, PAGE_SIZE.into())?;
+            padding::read_discard(&mut reader, PAGE_SIZE.into())
+                .map_err(|e| Error::DataRead("Boot::V4::signature_padding", e))?;

            Some(V4Extra { signature })
        } else {
@@ -755,21 +818,26 @@ impl BootImageV3Through4 {
            cmdline,
        };

-        raw_v3.write_to_io(&mut writer)?;
+        raw_v3
+            .write_to_io(&mut writer)
+            .map_err(|e| Error::DataWrite("Boot::V3::header", e))?;

        let v4_signature = if let Some(v4) = &self.v4_extra {
            let mut sig_writer = Cursor::new(Vec::new());

            if let Some(s) = &v4.signature {
-                s.to_writer(&mut sig_writer)?;
+                s.to_writer(&mut sig_writer).map_err(Error::VtsAvbSave)?;

-                let size = sig_writer.stream_position()?;
+                let size = sig_writer
+                    .stream_position()
+                    .map_err(|e| Error::DataWrite("Boot::V4::signature_size", e))?;

                // The VTS signature is always a fixed size.
                util::check_bounds(size, ..=HDR_V4_SIGNATURE_SIZE)
                    .map_err(|e| Error::IntOutOfBounds("Boot::V4::signature_size", e))?;

-                padding::write_zeros(&mut sig_writer, HDR_V4_SIGNATURE_SIZE)?;
+                padding::write_zeros(&mut sig_writer, HDR_V4_SIGNATURE_SIZE)
+                    .map_err(|e| Error::DataWrite("Boot::V4::signature_inner_padding", e))?;
            }

            let sig = sig_writer.into_inner();
@@ -778,25 +846,37 @@ impl BootImageV3Through4 {
                signature_size: (sig.len() as u32).into(),
            };

-            raw_v4.write_to_io(&mut writer)?;
+            raw_v4
+                .write_to_io(&mut writer)
+                .map_err(|e| Error::DataWrite("Boot::V4::header", e))?;

            Some(sig)
        } else {
            None
        };

-        padding::write_zeros(&mut writer, PAGE_SIZE.into())?;
+        padding::write_zeros(&mut writer, PAGE_SIZE.into())
+            .map_err(|e| Error::DataWrite("Boot::V3::header_padding", e))?;

-        writer.write_all(&self.kernel)?;
-        padding::write_zeros(&mut writer, PAGE_SIZE.into())?;
+        writer
+            .write_all(&self.kernel)
+            .map_err(|e| Error::DataWrite("Boot::V3::kernel", e))?;
+        padding::write_zeros(&mut writer, PAGE_SIZE.into())
+            .map_err(|e| Error::DataWrite("Boot::V3::kernel_padding", e))?;

-        writer.write_all(&self.ramdisk)?;
-        padding::write_zeros(&mut writer, PAGE_SIZE.into())?;
+        writer
+            .write_all(&self.ramdisk)
+            .map_err(|e| Error::DataWrite("Boot::V3::ramdisk", e))?;
+        padding::write_zeros(&mut writer, PAGE_SIZE.into())
+            .map_err(|e| Error::DataWrite("Boot::V3::ramdisk_padding", e))?;

        if !skip_v4_sig {
            if let Some(sig) = v4_signature {
-                writer.write_all(&sig)?;
-                padding::write_zeros(&mut writer, PAGE_SIZE.into())?;
+                writer
+                    .write_all(&sig)
+                    .map_err(|e| Error::DataWrite("Boot::V4::signature", e))?;
+                padding::write_zeros(&mut writer, PAGE_SIZE.into())
+                    .map_err(|e| Error::DataWrite("Boot::V4::signature_padding", e))?;
            }
        }

@@ -823,10 +903,9 @@ impl BootImageV3Through4 {
                    .ok_or(Error::MissingHashDescriptor)?;

                if descriptor.hash_algorithm != "sha256" {
-                    return Err(avb::Error::UnsupportedHashAlgorithm(
+                    return Err(Error::VtsAvbSign(avb::Error::UnsupportedHashAlgorithm(
                        descriptor.hash_algorithm.clone(),
-                    )
-                    .into());
+                    )));
                }

                context.update(&descriptor.salt);
@@ -863,7 +942,7 @@ impl BootImageV3Through4 {

        descriptor.image_size = image_size;
        descriptor.root_digest = context.finish().as_ref().to_vec();
-        signature.sign(key)?;
+        signature.sign(key).map_err(Error::VtsAvbSign)?;

        Ok(true)
    }
@@ -879,7 +958,7 @@ impl<W: Write> ToWriter<W> for BootImageV3Through4 {

 /// Raw on-disk layout for the vendor v3 image header.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawVendorV3 {
    /// Magic value. This should be equal to [`VENDOR_BOOT_MAGIC`].
    magic: [u8; 8],
@@ -898,7 +977,7 @@ struct RawVendorV3 {

 /// Raw on-disk layout for the extra vendor v4 image header fields.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawVendorV4Extra {
    vendor_ramdisk_table_size: little_endian::U32,
    vendor_ramdisk_table_entry_num: little_endian::U32,
@@ -908,7 +987,7 @@ struct RawVendorV4Extra {

 /// Raw on-disk layout for the vendor v4 ramdisk table entry.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawVendorV4RamdiskTableEntry {
    ramdisk_size: little_endian::U32,
    ramdisk_offset: little_endian::U32,
@@ -1011,11 +1090,7 @@ impl fmt::Display for VendorBootImageV3Through4 {

 impl BootImageExt for VendorBootImageV3Through4 {
    fn header_version(&self) -> u32 {
-        if self.v4_extra.is_some() {
-            4
-        } else {
-            3
-        }
+        if self.v4_extra.is_some() { 4 } else { 3 }
    }

    fn header_size(&self) -> u32 {
@@ -1036,7 +1111,8 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
    fn from_reader(reader: R) -> Result<Self> {
        let mut reader = CountingReader::new(reader);

-        let raw_v3 = RawVendorV3::read_from_io(&mut reader)?;
+        let raw_v3 = RawVendorV3::read_from_io(&mut reader)
+            .map_err(|e| Error::DataRead("Vendor::V3::header", e))?;

        if raw_v3.magic != VENDOR_BOOT_MAGIC {
            return Err(Error::UnknownMagic(raw_v3.magic));
@@ -1076,7 +1152,8 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
        }

        let mut v4_data = if header_version == 4 {
-            let raw_v4 = RawVendorV4Extra::read_from_io(&mut reader)?;
+            let raw_v4 = RawVendorV4Extra::read_from_io(&mut reader)
+                .map_err(|e| Error::DataRead("Vendor::V4::header", e))?;

            let table_size = raw_v4.vendor_ramdisk_table_size.get();
            let table_entry_num = raw_v4.vendor_ramdisk_table_entry_num.get();
@@ -1092,7 +1169,7 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {

            let actual_table_size = table_entry_num
                .checked_mul(table_entry_size)
-                .ok_or_else(|| Error::IntOverflow("Vendor::V4::actual_table_size"))?;
+                .ok_or(Error::IntOverflow("Vendor::V4::actual_table_size"))?;
            if actual_table_size != table_size {
                return Err(Error::VendorV4InvalidRamdiskTableSize {
                    actual: actual_table_size,
@@ -1112,16 +1189,24 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
            None
        };

-        if reader.stream_position()? != u64::from(header_size) {
+        if reader
+            .stream_position()
+            .map_err(|e| Error::DataRead("Vendor::V3::header_size", e))?
+            != u64::from(header_size)
+        {
            return Err(Error::InvalidHeaderSize(header_size));
        }

-        padding::read_discard(&mut reader, page_size.into())?;
+        padding::read_discard(&mut reader, page_size.into())
+            .map_err(|e| Error::DataRead("Vendor::V3::header_padding", e))?;

        let mut ramdisks = vec![];

-        let mut vendor_ramdisk_data = reader.read_vec_exact(vendor_ramdisk_size as usize)?;
-        padding::read_discard(&mut reader, page_size.into())?;
+        let mut vendor_ramdisk_data = reader
+            .read_vec_exact(vendor_ramdisk_size as usize)
+            .map_err(|e| Error::DataRead("Vendor::V3::ramdisk", e))?;
+        padding::read_discard(&mut reader, page_size.into())
+            .map_err(|e| Error::DataRead("Vendor::V3::ramdisk_padding", e))?;

        // For v3, this is just one big ramdisk. For v4, we have to wait until
        // later to parse the data because the table of entries shows up later
@@ -1131,28 +1216,34 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
            vendor_ramdisk_data = vec![];
        }

-        let dtb = reader.read_vec_exact(dtb_size as usize)?;
-        padding::read_discard(&mut reader, page_size.into())?;
+        let dtb = reader
+            .read_vec_exact(dtb_size as usize)
+            .map_err(|e| Error::DataRead("Vendor::V3::dtb", e))?;
+        padding::read_discard(&mut reader, page_size.into())
+            .map_err(|e| Error::DataRead("Vendor::V3::dtb_padding", e))?;

        if let Some(v4) = &mut v4_data {
            let mut ramdisk_reader = Cursor::new(vendor_ramdisk_data);
            let mut total_ramdisk_size = 0;

            for index in 0..v4.vendor_ramdisk_table_entry_num {
-                let raw_entry = RawVendorV4RamdiskTableEntry::read_from_io(&mut reader)?;
+                let raw_entry = RawVendorV4RamdiskTableEntry::read_from_io(&mut reader)
+                    .map_err(|e| Error::DataRead("Vendor::V4::table_entry", e))?;

                let ramdisk_size =
                    util::check_bounds(raw_entry.ramdisk_size.get(), ..=vendor_ramdisk_size)
-                        .map_err(|e| Error::IntOutOfBounds("Vendor::V4::Meta::ramdisk_size", e))?;
+                        .map_err(|e| Error::IntOutOfBounds("Vendor::V4::ramdisk_size", e))?;

                let ramdisk_offset = raw_entry.ramdisk_offset.get();

                let ramdisk_name = raw_entry.ramdisk_name.trim_end_padding();
                let ramdisk_name = str::from_utf8(ramdisk_name).map_err(|e| {
-                    Error::StringNotUtf8("Vendor::V4::Meta::ramdisk_name", e, ramdisk_name.to_vec())
+                    Error::StringNotUtf8("Vendor::V4::ramdisk_name", e, ramdisk_name.to_vec())
                })?;

-                let table_offset = ramdisk_reader.stream_position()?;
+                let table_offset = ramdisk_reader
+                    .stream_position()
+                    .map_err(|e| Error::DataRead("Vendor::V4::table_offset", e))?;

                if u64::from(ramdisk_offset) != table_offset {
                    return Err(Error::VendorV4InvalidRamdiskEntryOffset {
@@ -1162,7 +1253,9 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
                    });
                }

-                let ramdisk = ramdisk_reader.read_vec_exact(ramdisk_size as usize)?;
+                let ramdisk = ramdisk_reader
+                    .read_vec_exact(ramdisk_size as usize)
+                    .map_err(|e| Error::DataRead("Vendor::V4::ramdisk", e))?;
                ramdisks.push(ramdisk);

                v4.v4_extra.ramdisk_metas.push(RamdiskMeta {
@@ -1181,9 +1274,15 @@ impl<R: Read> FromReader<R> for VendorBootImageV3Through4 {
                });
            }

-            padding::read_discard(&mut reader, page_size.into())?;
+            padding::read_discard(&mut reader, page_size.into())
+                .map_err(|e| Error::DataRead("Vendor::V4::table_padding", e))?;
+
+            let bootconfig = reader
+                .read_vec_exact(v4.bootconfig_size as usize)
+                .map_err(|e| Error::DataRead("Vendor::V4::bootconfig", e))?;
+            padding::read_discard(&mut reader, page_size.into())
+                .map_err(|e| Error::DataRead("Vendor::V4::bootconfig_padding", e))?;

-            let bootconfig = reader.read_vec_exact(v4.bootconfig_size as usize)?;
            v4.v4_extra.bootconfig = String::from_utf8(bootconfig).map_err(|e| {
                Error::StringNotUtf8("Vendor::V4::bootconfig", e.utf8_error(), e.into_bytes())
            })?;
@@ -1274,18 +1373,19 @@ impl<W: Write> ToWriter<W> for VendorBootImageV3Through4 {
            dtb_addr: self.dtb_addr.into(),
        };

-        raw_v3.write_to_io(&mut writer)?;
+        raw_v3
+            .write_to_io(&mut writer)
+            .map_err(|e| Error::DataWrite("Vendor::V3::header", e))?;

        if let Some(v4) = &self.v4_extra {
-            let table_entry_num =
-                self.ramdisks.len().to_u32().ok_or_else(|| {
-                    Error::IntOverflow("Vendor::V4::vendor_ramdisk_table_entry_num")
-                })?;
+            let table_entry_num = self.ramdisks.len().to_u32().ok_or(Error::IntOverflow(
+                "Vendor::V4::vendor_ramdisk_table_entry_num",
+            ))?;
            let table_entry_size = mem::size_of::<RawVendorV4RamdiskTableEntry>() as u32;
            let table_size = table_entry_num
                .checked_mul(table_entry_size)
                .and_then(|v| v.to_u32())
-                .ok_or_else(|| Error::IntOverflow("Vendor::V4::vendor_ramdisk_table_size"))?;
+                .ok_or(Error::IntOverflow("Vendor::V4::vendor_ramdisk_table_size"))?;

            let raw_v4 = RawVendorV4Extra {
                vendor_ramdisk_table_size: table_size.into(),
@@ -1294,18 +1394,27 @@ impl<W: Write> ToWriter<W> for VendorBootImageV3Through4 {
                bootconfig_size: (v4.bootconfig.len() as u32).into(),
            };

-            raw_v4.write_to_io(&mut writer)?;
+            raw_v4
+                .write_to_io(&mut writer)
+                .map_err(|e| Error::DataWrite("Vendor::V4::header", e))?;
        }

-        padding::write_zeros(&mut writer, self.page_size.into())?;
+        padding::write_zeros(&mut writer, self.page_size.into())
+            .map_err(|e| Error::DataWrite("Vendor::V3::header_padding", e))?;

        for ramdisk in &self.ramdisks {
-            writer.write_all(ramdisk)?;
+            writer
+                .write_all(ramdisk)
+                .map_err(|e| Error::DataWrite("Vendor::V3::ramdisk", e))?;
        }
-        padding::write_zeros(&mut writer, self.page_size.into())?;
+        padding::write_zeros(&mut writer, self.page_size.into())
+            .map_err(|e| Error::DataWrite("Vendor::V3::ramdisk_padding", e))?;

-        writer.write_all(&self.dtb)?;
-        padding::write_zeros(&mut writer, self.page_size.into())?;
+        writer
+            .write_all(&self.dtb)
+            .map_err(|e| Error::DataWrite("Vendor::V3::dtb", e))?;
+        padding::write_zeros(&mut writer, self.page_size.into())
+            .map_err(|e| Error::DataWrite("Vendor::V3::dtb_padding", e))?;

        if let Some(v4) = &self.v4_extra {
            let mut ramdisk_offset = 0;
@@ -1319,7 +1428,7 @@ impl<W: Write> ToWriter<W> for VendorBootImageV3Through4 {
                    .to_padded_array::<VENDOR_RAMDISK_NAME_SIZE>()
                    .ok_or_else(|| {
                        Error::StringTooLong(
-                            "Vendor::V4::Meta::ramdisk_name",
+                            "Vendor::V4::ramdisk_name",
                            VENDOR_RAMDISK_NAME_SIZE,
                            meta.ramdisk_name.clone(),
                        )
@@ -1333,14 +1442,20 @@ impl<W: Write> ToWriter<W> for VendorBootImageV3Through4 {
                    board_id: meta.board_id.map(|id| id.into()),
                };

-                raw_entry.write_to_io(&mut writer)?;
+                raw_entry
+                    .write_to_io(&mut writer)
+                    .map_err(|e| Error::DataWrite("Vendor::V4::table_entry", e))?;

                ramdisk_offset += ramdisk_size;
            }
-            padding::write_zeros(&mut writer, self.page_size.into())?;
+            padding::write_zeros(&mut writer, self.page_size.into())
+                .map_err(|e| Error::DataWrite("Vendor::V4::table_padding", e))?;

-            writer.write_all(v4.bootconfig.as_bytes())?;
-            padding::write_zeros(&mut writer, self.page_size.into())?;
+            writer
+                .write_all(v4.bootconfig.as_bytes())
+                .map_err(|e| Error::DataWrite("Vendor::V4::bootconfig", e))?;
+            padding::write_zeros(&mut writer, self.page_size.into())
+                .map_err(|e| Error::DataWrite("Vendor::V4::bootconfig_padding", e))?;
        }

        Ok(())
@@ -1387,7 +1502,9 @@ impl<R: Read + Seek> FromReader<R> for BootImage {
    type Error = Error;

    fn from_reader(mut reader: R) -> Result<Self> {
-        reader.rewind()?;
+        reader
+            .rewind()
+            .map_err(|e| Error::DataRead("Boot::V0::autodetect", e))?;

        match BootImageV0Through2::from_reader(&mut reader) {
            Ok(b) => return Ok(Self::V0Through2(b)),
@@ -1395,7 +1512,9 @@ impl<R: Read + Seek> FromReader<R> for BootImage {
            Err(e) => return Err(e),
        }

-        reader.rewind()?;
+        reader
+            .rewind()
+            .map_err(|e| Error::DataRead("Boot::V3::autodetect", e))?;

        match BootImageV3Through4::from_reader(&mut reader) {
            Ok(b) => return Ok(Self::V3Through4(b)),
@@ -1403,7 +1522,9 @@ impl<R: Read + Seek> FromReader<R> for BootImage {
            Err(e) => return Err(e),
        }

-        reader.rewind()?;
+        reader
+            .rewind()
+            .map_err(|e| Error::DataRead("Vendor::V3::autodetect", e))?;

        match VendorBootImageV3Through4::from_reader(&mut reader) {
            Ok(b) => return Ok(Self::VendorV3Through4(b)),
@@ -3,7 +3,7 @@

 use std::io::{self, Read, Seek, Write};

-use flate2::{read::GzDecoder, write::GzEncoder, Compression};
+use flate2::{Compression, read::GzDecoder, write::GzEncoder};
 use liblzma::{
    read::XzDecoder,
    stream::{Check, Stream},
@@ -13,6 +13,8 @@ use lz4_flex::frame::FrameDecoder;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;

+use crate::stream::ReadFixedSizeExt;
+
 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";
@@ -21,10 +23,12 @@ static XZ_MAGIC: &[u8; 6] = b"\xfd\x37\x7a\x58\x5a\x00";
 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),
+    #[error("I/O error when autodetecting compression format")]
+    AutoDetect(#[source] io::Error),
+    #[error("Failed to initialize legacy LZ4 encoder")]
+    Lz4Init(#[source] io::Error),
+    #[error("Failed to initialize XZ encoder")]
+    XzInit(#[source] liblzma::stream::Error),
 }

 type Result<T> = std::result::Result<T, Error>;
@@ -119,10 +123,9 @@ pub enum CompressedReader<R: Read> {

 impl<R: Read + Seek> CompressedReader<R> {
    pub fn new(mut reader: R, raw_if_unknown: bool) -> Result<Self> {
-        let mut magic = [0u8; 6];
-        reader.read_exact(&mut magic)?;
+        let magic = reader.read_array_exact::<6>().map_err(Error::AutoDetect)?;

-        reader.rewind()?;
+        reader.rewind().map_err(Error::AutoDetect)?;

        if &magic[0..2] == GZIP_MAGIC {
            Ok(Self::Gzip(GzDecoder::new(reader)))
@@ -181,10 +184,13 @@ impl<W: Write> CompressedWriter<W> {
            CompressedFormat::Gzip => {
                Ok(Self::Gzip(GzEncoder::new(writer, Compression::default())))
            }
-            CompressedFormat::Lz4Legacy => Ok(Self::Lz4Legacy(Lz4LegacyEncoder::new(writer)?)),
+            CompressedFormat::Lz4Legacy => {
+                let encoder = Lz4LegacyEncoder::new(writer).map_err(Error::Lz4Init)?;
+                Ok(Self::Lz4Legacy(encoder))
+            }
            CompressedFormat::Xz => {
                // Some kernels are compiled without support for the default CRC64.
-                let stream = Stream::new_easy_encoder(6, Check::Crc32)?;
+                let stream = Stream::new_easy_encoder(6, Check::Crc32).map_err(Error::XzInit)?;
                Ok(Self::Xz(XzEncoder::new_stream(writer, stream)))
            }
        }
@@ -13,6 +13,8 @@ use bstr::ByteSlice;
 use num_traits::{ToPrimitive, Zero};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};

 use crate::{
    escape,
@@ -48,55 +50,94 @@ const VEC_CAP_THRESHOLD: usize = 16384;
 pub enum Error {
    #[error("Unknown magic: {0:?}")]
    UnknownMagic([u8; 6]),
+    #[error("Path is not NULL-terminated: {:?}", .0.as_bstr())]
+    PathNotNullTerminated(Vec<u8>),
    #[error("Hard links are not supported: {:?}", .0.as_bstr())]
    HardLinksNotSupported(Vec<u8>),
    #[error("Entry of type {0} should not have data: {path:?}", path = .1.as_bstr())]
    EntryHasData(CpioEntryType, Vec<u8>),
-    #[error("No inodes available for device {0:x},{1:x}")]
-    DeviceFull(u32, u32),
+    #[error("No inodes available for device {major:x},{minor:x}")]
+    DeviceFull { major: u32, minor: u32 },
    #[error("{0:?} overflowed integer bounds during calculations")]
    IntOverflow(&'static str),
-    #[error("I/O error")]
-    Io(#[from] io::Error),
+    #[error("{0:?} contains invalid hex integer")]
+    InvalidHexInt(&'static str, #[source] InvalidHexCharError),
+    #[error("Failed to read cpio data: {0}")]
+    DataRead(&'static str, #[source] io::Error),
+    #[error("Failed to write cpio data: {0}")]
+    DataWrite(&'static str, #[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;

-/// Read u32 formatted as an ASCII 8-char wide hex string.
-fn read_int(mut reader: impl Read) -> io::Result<u32> {
-    let mut buf = [0u8; 8];
-    reader.read_exact(&mut buf)?;
+#[derive(Debug, Error)]
+#[error("{0:?}: Invalid hex char: {1:?}")]
+pub struct InvalidHexCharError(RawHexU32, char);

-    let mut value = 0;
+/// ASCII-encoded hex integer value used in cpio header fields.
+#[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
+#[repr(C, packed)]
+struct RawHexU32([u8; 8]);

-    for b in buf {
-        let c = b as char;
-        let digit = c.to_digit(16).ok_or_else(|| {
-            io::Error::new(
-                io::ErrorKind::InvalidData,
-                format!("{:?}: Invalid hex char: {c}", buf.as_bstr()),
-            )
-        })?;
-
-        value <<= 4;
-        value |= digit;
+impl fmt::Debug for RawHexU32 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.0.as_bstr())
    }
-
-    Ok(value)
 }

-/// Write u32 formatted as an ASCII 8-char wide hex string.
-fn write_int(mut writer: impl Write, mut value: u32) -> io::Result<()> {
-    let mut buf = [b'0'; 8];
-    let mut index = 7;
+#[allow(clippy::fallible_impl_from)]
+impl From<u32> for RawHexU32 {
+    fn from(mut value: u32) -> Self {
+        let mut buf = [b'0'; 8];
+        let mut index = 7;

-    while value != 0 {
-        buf[index] = char::from_digit(value & 0xf, 16).unwrap() as u8;
-        value >>= 4;
-        index -= 1;
+        while value != 0 {
+            buf[index] = char::from_digit(value & 0xf, 16).unwrap() as u8;
+            value >>= 4;
+            index -= 1;
+        }
+
+        Self(buf)
    }
+}

-    writer.write_all(&buf)
+impl TryFrom<RawHexU32> for u32 {
+    type Error = InvalidHexCharError;
+
+    fn try_from(raw_value: RawHexU32) -> std::result::Result<Self, Self::Error> {
+        let mut value = 0;
+
+        for b in raw_value.0 {
+            let c = b as char;
+            let digit = c.to_digit(16).ok_or(InvalidHexCharError(raw_value, c))?;
+
+            value <<= 4;
+            value |= digit;
+        }
+
+        Ok(value)
+    }
+}
+
+/// Raw on-disk layout for the cpio header.
+#[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
+#[repr(C, packed)]
+struct RawHeader {
+    /// Magic value. This should be equal to [`MAGIC_NEW`] or [`MAGIC_NEW_CRC`].
+    magic: [u8; 6],
+    inode: RawHexU32,
+    mode: RawHexU32,
+    uid: RawHexU32,
+    gid: RawHexU32,
+    nlink: RawHexU32,
+    mtime: RawHexU32,
+    file_size: RawHexU32,
+    dev_maj: RawHexU32,
+    dev_min: RawHexU32,
+    rdev_maj: RawHexU32,
+    rdev_min: RawHexU32,
+    path_size: RawHexU32,
+    crc32: RawHexU32,
 }

 /// Read a chunk of bytes from the reader. If `size` is less than
@@ -386,41 +427,45 @@ impl<R: Read> FromReader<R> for CpioEntry {
    fn from_reader(reader: R) -> Result<Self> {
        let mut reader = CountingReader::new(reader);

-        let mut magic = [0u8; 6];
-        reader.read_exact(&mut magic)?;
+        let header =
+            RawHeader::read_from_io(&mut reader).map_err(|e| Error::DataRead("header", e))?;

-        if magic != *MAGIC_NEW && magic != *MAGIC_NEW_CRC {
-            return Err(Error::UnknownMagic(magic));
+        if header.magic != *MAGIC_NEW && header.magic != *MAGIC_NEW_CRC {
+            return Err(Error::UnknownMagic(header.magic));
        }

-        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 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 path_size = read_int(&mut reader)?;
-        let crc32 = read_int(&mut reader)?;
+        macro_rules! get_field {
+            ($name:ident) => {
+                let $name = u32::try_from(header.$name)
+                    .map_err(|e| Error::InvalidHexInt(stringify!($name), e))?;
+            };
+        }
+
+        get_field!(inode);
+        get_field!(mode);
+        get_field!(uid);
+        get_field!(gid);
+        get_field!(nlink);
+        get_field!(mtime);
+        get_field!(file_size);
+        get_field!(dev_maj);
+        get_field!(dev_min);
+        get_field!(rdev_maj);
+        get_field!(rdev_min);
+        get_field!(path_size);
+        get_field!(crc32);

        let mut path = read_data(
            &mut reader,
            path_size.to_usize().unwrap(),
            &AtomicBool::new(false),
-        )?;
+        )
+        .map_err(|e| Error::DataRead("path", e))?;
        if path.last() != Some(&b'\0') {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "Filename is not NULL-terminated",
-            )
-            .into());
+            return Err(Error::PathNotNullTerminated(path));
        }
        path.pop();
-        padding::read_discard(&mut reader, 4)?;
+        padding::read_discard(&mut reader, 4).map_err(|e| Error::DataRead("path_padding", e))?;

        let file_type = CpioEntryType::from_mode(mode);
        let data = match file_type {
@@ -432,8 +477,10 @@ impl<R: Read> FromReader<R> for CpioEntry {
                    &mut reader,
                    file_size.to_usize().unwrap(),
                    &AtomicBool::new(false),
-                )?;
-                padding::read_discard(&mut reader, 4)?;
+                )
+                .map_err(|e| Error::DataRead("content", e))?;
+                padding::read_discard(&mut reader, 4)
+                    .map_err(|e| Error::DataRead("content_padding", e))?;

                CpioEntryData::Data(content)
            }
@@ -482,35 +529,47 @@ impl<W: Write> ToWriter<W> for CpioEntry {
            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)?;
-        }
-
        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, 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, path_size)?;
-        write_int(&mut writer, self.crc32)?;
+        let raw_header = RawHeader {
+            magic: if self.crc32 == 0 {
+                *MAGIC_NEW
+            } else {
+                *MAGIC_NEW_CRC
+            },
+            inode: self.inode.into(),
+            mode: mode.into(),
+            uid: self.uid.into(),
+            gid: self.gid.into(),
+            nlink: self.nlink.into(),
+            mtime: self.mtime.into(),
+            file_size: file_size.into(),
+            dev_maj: self.dev_maj.into(),
+            dev_min: self.dev_min.into(),
+            rdev_maj: self.rdev_maj.into(),
+            rdev_min: self.rdev_min.into(),
+            path_size: path_size.into(),
+            crc32: self.crc32.into(),
+        };

-        writer.write_all(&self.path)?;
-        writer.write_zeros_exact(1)?;
-        padding::write_zeros(&mut writer, 4)?;
+        raw_header
+            .write_to_io(&mut writer)
+            .map_err(|e| Error::DataWrite("header", e))?;
+
+        writer
+            .write_all(&self.path)
+            .map_err(|e| Error::DataWrite("path", e))?;
+        writer
+            .write_zeros_exact(1)
+            .map_err(|e| Error::DataWrite("path", e))?;
+        padding::write_zeros(&mut writer, 4).map_err(|e| Error::DataWrite("path_padding", e))?;

        if let CpioEntryData::Data(d) = &self.data {
-            writer.write_all(d)?;
-            padding::write_zeros(&mut writer, 4)?;
+            writer
+                .write_all(d)
+                .map_err(|e| Error::DataWrite("content", e))?;
+            padding::write_zeros(&mut writer, 4)
+                .map_err(|e| Error::DataWrite("content_padding", e))?;
        }

        Ok(())
@@ -554,7 +613,8 @@ impl<R: Read> CpioReader<R> {
            return Ok(None);
        }

-        self.skip_data()?;
+        self.skip_data()
+            .map_err(|e| Error::DataRead("content", e))?;

        let entry = CpioEntry::from_reader(&mut self.reader)?;

@@ -619,7 +679,8 @@ impl<W: Write> CpioWriter<W> {
    }

    pub fn start_entry(&mut self, entry: &CpioEntry) -> Result<()> {
-        self.finish_entry()?;
+        self.finish_entry()
+            .map_err(|e| Error::DataWrite("content", e))?;

        entry.to_writer(&mut self.writer)?;

@@ -633,13 +694,15 @@ impl<W: Write> CpioWriter<W> {
    }

    pub fn finish(mut self) -> Result<W> {
-        self.finish_entry()?;
+        self.finish_entry()
+            .map_err(|e| Error::DataWrite("content", e))?;

        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)?;
+            padding::write_zeros(&mut self.writer, IO_BLOCK_SIZE)
+                .map_err(|e| Error::DataWrite("block_padding", e))?;
        }

        Ok(self.writer.finish().0)
@@ -677,14 +740,15 @@ pub fn load(
    let mut entries = vec![];

    while let Some(mut entry) = cpio_reader.next_entry()? {
-        stream::check_cancel(cancel_signal)?;
+        stream::check_cancel(cancel_signal).map_err(|e| Error::DataRead("entry", e))?;

        if entry.file_type != CpioEntryType::Directory && entry.nlink > 1 {
            return Err(Error::HardLinksNotSupported(entry.path));
        }

        if let CpioEntryData::Size(s) = entry.data {
-            let data = read_data(&mut cpio_reader, s.to_usize().unwrap(), cancel_signal)?;
+            let data = read_data(&mut cpio_reader, s.to_usize().unwrap(), cancel_signal)
+                .map_err(|e| Error::DataWrite("data", e))?;
            entry.data = CpioEntryData::Data(data);
        }

@@ -707,11 +771,7 @@ pub fn sort(entries: &mut [CpioEntry]) {
 /// 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)
-        }
+        if i == u32::MAX { 1 } else { i.wrapping_add(1) }
    }

    // (dev maj, dev min) -> (inode set, last assigned inode)
@@ -740,7 +800,10 @@ pub fn assign_inodes(entries: &mut [CpioEntry], missing_only: bool) -> Result<()

            while set.contains(&unused) {
                if unused == *last {
-                    return Err(Error::DeviceFull(entry.dev_maj, entry.dev_min));
+                    return Err(Error::DeviceFull {
+                        major: entry.dev_maj,
+                        minor: entry.dev_min,
+                    });
                }

                unused = next_non_zero(unused);
@@ -764,7 +827,7 @@ pub fn save(
    let mut cpio_writer = CpioWriter::new(writer, pad_to_block_size);

    for entry in entries {
-        stream::check_cancel(cancel_signal)?;
+        stream::check_cancel(cancel_signal).map_err(|e| Error::DataWrite("entry", e))?;

        cpio_writer.start_entry(entry)?;
        // CpioEntryData::Data will have already been written.
@@ -16,7 +16,7 @@ use rayon::{
    slice::{ParallelSlice, ParallelSliceMut},
 };
 use thiserror::Error;
-use zerocopy::{little_endian, FromBytes, IntoBytes};
+use zerocopy::{FromBytes, IntoBytes, little_endian};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};

 use crate::{
@@ -68,8 +68,14 @@ pub enum Error {
    IntOutOfBounds(&'static str, #[source] OutOfBoundsError),
    #[error("{0:?} overflowed integer bounds during calculations")]
    IntOverflow(&'static str),
-    #[error("I/O error")]
-    Io(#[from] io::Error),
+    #[error("Failed to reopen input file")]
+    InputReopen(#[source] io::Error),
+    #[error("Failed to reopen output file")]
+    OutputReopen(#[source] io::Error),
+    #[error("Failed to read FEC data: {0}")]
+    DataRead(&'static str, #[source] io::Error),
+    #[error("Failed to write FEC data: {0}")]
+    DataWrite(&'static str, #[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;
@@ -364,7 +370,9 @@ impl Fec {
            "FEC buffer length does not match block size",
        );

-        let grid = self.read_round(reader, round)?;
+        let grid = self
+            .read_round(reader, round)
+            .map_err(|e| Error::DataRead("round", e))?;
        let encode = verityrs::FN_ENCODE[&self.rs_k];
        let parity = usize::from(self.parity());

@@ -385,7 +393,9 @@ impl Fec {
            "FEC buffer length does not match block size",
        );

-        let grid = self.read_round(reader, round)?;
+        let grid = self
+            .read_round(reader, round)
+            .map_err(|e| Error::DataRead("round", e))?;
        let is_correct = verityrs::FN_IS_CORRECT[&self.rs_k];
        let parity = usize::from(self.parity());

@@ -415,7 +425,9 @@ impl Fec {
            "FEC buffer length does not match block size",
        );

-        let mut grid = self.read_round(reader, round)?;
+        let mut grid = self
+            .read_round(reader, round)
+            .map_err(|e| Error::DataRead("round", e))?;
        let correct_errors = verityrs::FN_CORRECT_ERRORS[&self.rs_k];
        let parity = usize::from(self.parity());
        let mut num_corrected = 0;
@@ -433,7 +445,8 @@ impl Fec {
        }

        if num_corrected > 0 {
-            self.write_round(writer, round, &grid)?;
+            self.write_round(writer, round, &grid)
+                .map_err(|e| Error::DataWrite("round", e))?;
        }

        Ok(num_corrected)
@@ -454,9 +467,9 @@ impl Fec {
        fec.par_chunks_exact_mut(fec_size / self.rounds as usize)
            .enumerate()
            .map(|(round, buf)| -> Result<()> {
-                stream::check_cancel(cancel_signal)?;
+                stream::check_cancel(cancel_signal).map_err(Error::InputReopen)?;

-                let reader = input.reopen_boxed()?;
+                let reader = input.reopen_boxed().map_err(Error::InputReopen)?;
                self.generate_one_round(reader, round as u64, buf)
            })
            .collect::<Result<()>>()?;
@@ -489,9 +502,9 @@ impl Fec {
            .enumerate()
            .filter(|(round, _)| rounds_to_update.contains(&(*round as u64)))
            .map(|(round, buf)| -> Result<()> {
-                stream::check_cancel(cancel_signal)?;
+                stream::check_cancel(cancel_signal).map_err(Error::InputReopen)?;

-                let reader = input.reopen_boxed()?;
+                let reader = input.reopen_boxed().map_err(Error::InputReopen)?;
                self.generate_one_round(reader, round as u64, buf)
            })
            .collect::<Result<()>>()?;
@@ -522,9 +535,9 @@ impl Fec {
        fec.par_chunks_exact(fec_size / self.rounds as usize)
            .enumerate()
            .map(|(round, buf)| -> Result<()> {
-                stream::check_cancel(cancel_signal)?;
+                stream::check_cancel(cancel_signal).map_err(Error::InputReopen)?;

-                let reader = input.reopen_boxed()?;
+                let reader = input.reopen_boxed().map_err(Error::InputReopen)?;
                self.verify_one_round(reader, round as u64, buf)
            })
            .collect::<Result<()>>()?;
@@ -563,10 +576,10 @@ impl Fec {
            .par_chunks_exact(fec_size / self.rounds as usize)
            .enumerate()
            .map(|(round, buf)| -> Result<u64> {
-                stream::check_cancel(cancel_signal)?;
+                stream::check_cancel(cancel_signal).map_err(Error::InputReopen)?;

-                let reader = input.reopen_boxed()?;
-                let writer = output.reopen_boxed()?;
+                let reader = input.reopen_boxed().map_err(Error::InputReopen)?;
+                let writer = output.reopen_boxed().map_err(Error::OutputReopen)?;
                self.repair_one_round(reader, writer, round as u64, buf)
            })
            .collect::<Result<Vec<u64>>>()?
@@ -579,7 +592,7 @@ impl Fec {

 /// Raw on-disk layout for the FEC image header.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawHeader {
    /// Magic value. This should be equal to [`FEC_MAGIC`].
    magic: little_endian::U32,
@@ -627,10 +640,10 @@ impl FecImage {
        parity: u8,
        cancel_signal: &AtomicBool,
    ) -> Result<Self> {
-        let data_size = {
-            let mut file = input.reopen_boxed()?;
-            file.seek(SeekFrom::End(0))?
-        };
+        let data_size = input
+            .reopen_boxed()
+            .and_then(|mut f| f.seek(SeekFrom::End(0)))
+            .map_err(Error::InputReopen)?;
        let fec = Fec::new(data_size, FEC_BLOCK_SIZE as u32, parity)?;
        let fec_data = fec.generate(input, cancel_signal)?;

@@ -717,7 +730,9 @@ impl<R: Read> FromReader<R> for FecImage {
        // Avoid requiring seekable readers since we need to read everything
        // into memory anyway.
        let mut fec = Vec::new();
-        reader.read_to_end(&mut fec)?;
+        reader
+            .read_to_end(&mut fec)
+            .map_err(|e| Error::DataRead("fec", e))?;

        if fec.len() < FEC_BLOCK_SIZE {
            return Err(Error::DataTooSmall);
@@ -791,10 +806,18 @@ impl<W: Write> ToWriter<W> for FecImage {
    fn to_writer(&self, mut writer: W) -> Result<()> {
        let header = self.build_header()?;

-        writer.write_all(&self.fec)?;
-        header.write_to_io(&mut writer)?;
-        writer.write_zeros_exact((FEC_BLOCK_SIZE - 2 * header.as_bytes().len()) as u64)?;
-        header.write_to_io(&mut writer)?;
+        writer
+            .write_all(&self.fec)
+            .map_err(|e| Error::DataWrite("fec_data", e))?;
+        header
+            .write_to_io(&mut writer)
+            .map_err(|e| Error::DataWrite("fec_header_1", e))?;
+        writer
+            .write_zeros_exact((FEC_BLOCK_SIZE - 2 * header.as_bytes().len()) as u64)
+            .map_err(|e| Error::DataWrite("fec_header_padding", e))?;
+        header
+            .write_to_io(&mut writer)
+            .map_err(|e| Error::DataWrite("fec_header_2", e))?;

        Ok(())
    }
@@ -804,7 +827,7 @@ impl<W: Write> ToWriter<W> for FecImage {
 mod tests {
    use std::{
        io::{Cursor, Seek},
-        sync::{atomic::AtomicBool, Arc},
+        sync::{Arc, atomic::AtomicBool},
    };

    use assert_matches::assert_matches;
@@ -16,7 +16,7 @@ use rayon::{
 };
 use ring::digest::{Algorithm, Context};
 use thiserror::Error;
-use zerocopy::{little_endian, FromBytes, IntoBytes};
+use zerocopy::{FromBytes, IntoBytes, little_endian};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};

 use crate::{
@@ -24,7 +24,7 @@ use crate::{
        avb,
        padding::{self, ZeroPadding},
    },
-    stream::{self, FromReader, ReadSeekReopen, ToWriter},
+    stream::{self, FromReader, ReadFixedSizeExt, ReadSeekReopen, ToWriter},
    util::{self, NumBytes, OutOfBoundsError},
 };

@@ -50,8 +50,14 @@ pub enum Error {
    IntOutOfBounds(&'static str, #[source] OutOfBoundsError),
    #[error("{0:?} overflowed integer bounds during calculations")]
    IntOverflow(&'static str),
-    #[error("I/O error")]
-    Io(#[from] io::Error),
+    #[error("Failed to reopen input file")]
+    InputReopen(#[source] io::Error),
+    #[error("Failed to compute hash tree of input file")]
+    InputDigest(#[source] io::Error),
+    #[error("Failed to read hash tree data: {0}")]
+    DataRead(&'static str, #[source] io::Error),
+    #[error("Failed to write hash tree data: {0}")]
+    DataWrite(&'static str, #[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;
@@ -264,9 +270,10 @@ impl HashTree {
    ) -> 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 reader = input.reopen_boxed().map_err(Error::InputReopen)?;
+            let buf = reader
+                .read_vec_exact(image_size as usize)
+                .map_err(Error::InputDigest)?;

            let mut context = self.salted_context.clone();
            context.update(&buf);
@@ -291,7 +298,8 @@ impl HashTree {
                    prev_size as u64,
                    level_data,
                    cancel_signal,
-                )?;
+                )
+                .map_err(Error::InputDigest)?;
            } else if let Some(r) = ranges {
                // Read partial blocks from file.
                let block_ranges = self.blocks_for_ranges(image_size, r)?;
@@ -302,10 +310,12 @@ impl HashTree {
                    &block_ranges,
                    level_data,
                    cancel_signal,
-                )?;
+                )
+                .map_err(Error::InputDigest)?;
            } else {
                // Read entire file.
-                self.hash_one_level_parallel(input, image_size, level_data, cancel_signal)?;
+                self.hash_one_level_parallel(input, image_size, level_data, cancel_signal)
+                    .map_err(Error::InputDigest)?;
            }

            // No need to explicitly ensure the level is padded to the block
@@ -421,7 +431,7 @@ impl HashTree {

 /// Raw on-disk layout for our custom hash tree image header.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawHeader {
    /// Magic value. This should be equal to [`HashTreeImage::MAGIC`].
    magic: [u8; 16],
@@ -482,8 +492,8 @@ 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)
+    fn digest_algorithm(name: &str) -> Result<&'static Algorithm> {
+        avb::digest_algorithm(name)
            .map_err(|_| Error::UnsupportedHashAlgorithm(name.to_owned().into_bytes()))
    }

@@ -495,12 +505,12 @@ impl HashTreeImage {
        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 image_size = input
+            .reopen_boxed()
+            .and_then(|mut f| f.seek(SeekFrom::End(0)))
+            .map_err(Error::InputReopen)?;
+        let digest_algorithm = Self::digest_algorithm(algorithm)?;
+        let hash_tree = HashTree::new(block_size, digest_algorithm, salt);
        let (root_digest, hash_tree_data) = hash_tree.generate(input, image_size, cancel_signal)?;

        Ok(Self {
@@ -520,8 +530,8 @@ impl HashTreeImage {
        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);
+        let digest_algorithm = Self::digest_algorithm(&self.algorithm)?;
+        let hash_tree = HashTree::new(self.block_size, digest_algorithm, &self.salt);

        self.root_digest = hash_tree.update(
            input,
@@ -540,8 +550,8 @@ impl HashTreeImage {
        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);
+        let digest_algorithm = Self::digest_algorithm(&self.algorithm)?;
+        let hash_tree = HashTree::new(self.block_size, digest_algorithm, &self.salt);

        hash_tree.verify(
            input,
@@ -557,7 +567,8 @@ impl<R: Read> FromReader<R> for HashTreeImage {
    type Error = Error;

    fn from_reader(mut reader: R) -> Result<Self> {
-        let header = RawHeader::read_from_io(&mut reader)?;
+        let header =
+            RawHeader::read_from_io(&mut reader).map_err(|e| Error::DataRead("header", e))?;

        if header.magic != *Self::MAGIC {
            return Err(Error::InvalidHeaderMagic(header.magic));
@@ -571,14 +582,17 @@ impl<R: Read> FromReader<R> for HashTreeImage {
        let algorithm = str::from_utf8(algorithm)
            .map_err(|_| Error::UnsupportedHashAlgorithm(algorithm.to_vec()))?;

-        let mut salt = vec![0u8; usize::from(header.salt_size)];
-        reader.read_exact(&mut salt)?;
+        let salt = reader
+            .read_vec_exact(usize::from(header.salt_size))
+            .map_err(|e| Error::DataRead("header", e))?;

-        let mut root_digest = vec![0u8; usize::from(header.root_digest_size)];
-        reader.read_exact(&mut root_digest)?;
+        let root_digest = reader
+            .read_vec_exact(usize::from(header.root_digest_size))
+            .map_err(|e| Error::DataRead("root_digest", e))?;

-        let mut hash_tree = vec![0u8; header.hash_tree_size.get() as usize];
-        reader.read_exact(&mut hash_tree)?;
+        let hash_tree = reader
+            .read_vec_exact(header.hash_tree_size.get() as usize)
+            .map_err(|e| Error::DataRead("hash_tree", e))?;

        Ok(Self {
            image_size: header.image_size.get(),
@@ -619,10 +633,18 @@ impl<W: Write> ToWriter<W> for HashTreeImage {
            hash_tree_size: hash_tree_size.into(),
        };

-        header.write_to_io(&mut writer)?;
-        writer.write_all(&self.salt)?;
-        writer.write_all(&self.root_digest)?;
-        writer.write_all(&self.hash_tree)?;
+        header
+            .write_to_io(&mut writer)
+            .map_err(|e| Error::DataWrite("header", e))?;
+        writer
+            .write_all(&self.salt)
+            .map_err(|e| Error::DataWrite("salt", e))?;
+        writer
+            .write_all(&self.root_digest)
+            .map_err(|e| Error::DataWrite("root_digest", e))?;
+        writer
+            .write_all(&self.hash_tree)
+            .map_err(|e| Error::DataWrite("hash_tree", e))?;

        Ok(())
    }
@@ -1,8 +1,7 @@
-// SPDX-FileCopyrightText: 2024 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2024-2025 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

 use std::{
-    cmp::Ordering,
    fmt,
    io::{self, Read, Seek, Write},
    mem,
@@ -14,13 +13,15 @@ use bitflags::bitflags;
 use bstr::ByteSlice;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
-use zerocopy::{byteorder::little_endian, FromBytes, FromZeros, Immutable, IntoBytes};
+use zerocopy::{FromBytes, FromZeros, Immutable, IntoBytes, byteorder::little_endian};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};

 use crate::{
    format::padding,
-    stream::{CountingReader, FromReader, ReadDiscardExt, ToWriter, WriteZerosExt},
-    util::{self, is_zero, DebugString},
+    stream::{
+        CountingReader, FromReader, ReadDiscardExt, ReadFixedSizeExt, ToWriter, WriteZerosExt,
+    },
+    util::{self, DebugString, is_zero},
 };

 /// Magic value for [`RawGeometry::magic`].
@@ -58,8 +59,8 @@ const METADATA_MAX_SIZE: u32 = 128 * 1024;
 #[derive(Debug, Error)]
 pub enum Error {
    // Naming errors.
-    #[error("Invalid partition name: {0}")]
-    PartitionNameInvalid(String),
+    #[error("Invalid partition name: {0:?}")]
+    PartitionNameInvalid(DebugString),
    // Geometry errors.
    #[error("Invalid geometry magic: {0:#010x}")]
    GeometryInvalidMagic(u32),
@@ -150,10 +151,8 @@ pub enum Error {
    ExtentTypeZeroNotEmpty { index: usize },
    #[error("Extent #{index}: Invalid type: {extent_type}")]
    ExtentInvalidType { index: usize, extent_type: u32 },
-    #[error("Extent #{index}: Overlaps previous extent")]
-    ExtentOverlapsPrevious { index: usize },
-    #[error("Extent #{index}: Earlier block device index than previous extent")]
-    ExtentDeviceNotConsecutive { index: usize },
+    #[error("Extent #{index}: Overlaps another extent: #{other}")]
+    ExtentOverlapsAnother { index: usize, other: usize },
    #[error("Extent #{index}: Block device index too large")]
    ExtentDeviceIndexTooLarge { index: usize },
    // Partition group errors.
@@ -185,8 +184,10 @@ pub enum Error {
    #[error("Insufficient space on block devices to allocate sectors")]
    AllocatorDeviceFull,
    // Wrapped errors.
-    #[error("I/O error")]
-    Io(#[from] io::Error),
+    #[error("Failed to read LP data: {0}")]
+    DataRead(&'static str, #[source] io::Error),
+    #[error("Failed to write LP data: {0}")]
+    DataWrite(&'static str, #[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;
@@ -249,7 +250,7 @@ impl PartitionAttributes {

 /// Raw on-disk layout for the metadata geometry.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawGeometry {
    /// Magic value. This should be equal to [`GEOMETRY_MAGIC`].
    magic: little_endian::U32,
@@ -331,7 +332,7 @@ impl RawGeometry {

 /// Raw on-disk layout for a table descriptor within a [`RawHeader`].
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawTableDescriptor {
    /// Offset relative to the end of the [`RawHeader`].
    offset: little_endian::U32,
@@ -390,7 +391,7 @@ impl RawTableDescriptor {

 /// Raw on-disk layout for the metadata header.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawHeader {
    /// Magic value. This should be equal to [`HEADER_MAGIC`].
    magic: little_endian::U32,
@@ -568,7 +569,7 @@ impl RawHeader {

 /// A potentially invalid raw partition name string.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct PartitionName([u8; 36]);

 impl fmt::Debug for PartitionName {
@@ -594,20 +595,18 @@ impl PartitionName {

    fn validate(&self) -> Result<()> {
        let (prefix, suffix) = self.split();
-        let mut has_alnum = false;

-        for b in prefix {
-            match b {
-                b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' => has_alnum = true,
-                b'_' => {}
-                _ => return Err(Error::PartitionNameInvalid(format!("{self:?}"))),
-            }
-        }
+        // AOSP liblp's metadata_format.h says "Characters may only be
+        // alphanumeric or _", but AOSP creates partitions named like
+        // "system_b-cow".
+        let prefix_valid = prefix
+            .iter()
+            .all(|b| matches!(*b, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'-'));

-        if has_alnum && is_zero(suffix) {
+        if prefix_valid && is_zero(suffix) {
            Ok(())
        } else {
-            Err(Error::PartitionNameInvalid(format!("{self:?}")))
+            Err(Error::PartitionNameInvalid(DebugString::new(self)))
        }
    }

@@ -626,7 +625,7 @@ impl FromStr for PartitionName {
        let mut name = Self([0u8; 36]);

        if s.len() > name.0.len() {
-            return Err(Error::PartitionNameInvalid(format!("{s:?}")));
+            return Err(Error::PartitionNameInvalid(DebugString::new(s)));
        }

        let to_copy = s.len().min(name.0.len());
@@ -640,7 +639,7 @@ impl FromStr for PartitionName {

 /// Raw on-disk layout for an entry in the logical partitions table.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawPartition {
    /// Partition name in ASCII. This must be unique across all partitions.
    name: PartitionName,
@@ -702,7 +701,7 @@ impl RawPartition {
                    .first_extent_index
                    .get()
                    .checked_add(self.num_extents.get())
-                    .map_or(true, |n| n as usize > extents.len())
+                    .is_none_or(|n| n as usize > extents.len())
                {
                    return Err(Error::PartitionExtentIndicesTooLarge {
                        name: DebugString::new(self.name),
@@ -731,7 +730,7 @@ impl RawPartition {

 /// Raw on-disk layout for an entry in the extent table.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawExtent {
    /// Number of [`SECTOR_SIZE`]-byte sectors in this extent.
    num_sectors: little_endian::U64,
@@ -813,7 +812,7 @@ impl RawExtent {
                return Err(Error::ExtentInvalidType {
                    index,
                    extent_type: n,
-                })
+                });
            }
        }

@@ -823,7 +822,7 @@ impl RawExtent {

 /// Raw on-disk layout for an entry in the partition groups table.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawPartitionGroup {
    /// Partition group name in ASCII. This must be unique across all groups.
    name: PartitionName,
@@ -890,7 +889,7 @@ impl RawPartitionGroup {

 /// Raw on-disk layout for an entry in the block devices table.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawBlockDevice {
    /// The first [`SECTOR_SIZE`]-byte sector where actual data for the logical
    /// partitions can be allocated.
@@ -1006,23 +1005,29 @@ impl RawMetadataSlot {
            extent.validate(i, &self.block_devices)?;
        }

-        // Ensure that all extents are in increasing order and not overlapping.
-        let mut iter = self
+        // Ensure that all extents are not overlapping. We have to sort here
+        // because the extents may not be in order when loading the super
+        // partition on an actual device. Also, AOSP liblp's `metadata_format.h`
+        // says "Gaps between extents are not allowed", but AOSP frequently
+        // creates this situation after a virtual A/B CoW merge.
+        let mut sorted_extents = self
            .extents
            .iter()
-            .filter(|e| e.target_type.get() == RawExtent::TARGET_TYPE_LINEAR)
-            .enumerate();
-        while let (Some((_, a)), Some((i, b))) = (iter.next(), iter.next()) {
-            match a.target_source.get().cmp(&b.target_source.get()) {
-                Ordering::Equal => {
-                    if a.target_data.get() + a.num_sectors.get() > b.target_data.get() {
-                        return Err(Error::ExtentOverlapsPrevious { index: i });
-                    }
-                }
-                Ordering::Greater => {
-                    return Err(Error::ExtentDeviceNotConsecutive { index: i });
-                }
-                Ordering::Less => {}
+            .enumerate()
+            .filter(|(_, e)| e.target_type.get() == RawExtent::TARGET_TYPE_LINEAR)
+            .collect::<Vec<_>>();
+        sorted_extents.sort_by_key(|(_, e)| (e.target_source, e.target_data));
+
+        for window in sorted_extents.windows(2) {
+            let ((a_i, a), (b_i, b)) = (window[0], window[1]);
+
+            if a.target_source == b.target_source
+                && a.target_data.get() + a.num_sectors.get() > b.target_data.get()
+            {
+                return Err(Error::ExtentOverlapsAnother {
+                    index: b_i,
+                    other: a_i,
+                });
            }
        }

@@ -1052,47 +1057,52 @@ impl RawMetadata {
    /// Read the [`RawGeometry`] at the current offset.
    fn read_geometry(mut reader: impl Read) -> Result<(ImageType, RawGeometry)> {
        let mut buf = [0u8; GEOMETRY_SIZE as usize];
-        reader.read_exact(&mut buf)?;
+        reader
+            .read_exact(&mut buf)
+            .map_err(|e| Error::DataRead("geometry", e))?;

-        let image_type = if util::is_zero(&buf) {
-            ImageType::Normal
-        } else {
-            ImageType::Empty
-        };
+        // For non-empty images, AOSP says the first block is supposed to be
+        // filled with zeros, but Samsung puts their own SignerVer02 structure
+        // in there, so we can't rely on that.
+        let mut geometry = RawGeometry::ref_from_prefix(&buf).unwrap().0;

-        let geometry = match image_type {
-            ImageType::Normal => {
+        let image_type = match geometry.validate() {
+            Ok(()) => {
+                // This is an empty image for use with fastboot. These have no
+                // extra padding at the beginning of the file nor backup copies
+                // of the geometry and metadata structs.
+                ImageType::Empty
+            }
+            Err(Error::GeometryInvalidMagic(_)) => {
                // This is an normal non-empty image, which has extra padding at
                // the beginning to avoid having the geometry struct interpreted
                // as a boot sector.

                // Read the primary copy of the geometry.
-                reader.read_exact(&mut buf)?;
+                reader
+                    .read_exact(&mut buf)
+                    .map_err(|e| Error::DataRead("geometry_primary", e))?;

-                let mut geometry = RawGeometry::ref_from_prefix(&buf).unwrap().0;
+                geometry = RawGeometry::ref_from_prefix(&buf).unwrap().0;

                if geometry.validate().is_ok() {
                    // Skip the backup copy.
-                    reader.read_discard_exact(GEOMETRY_SIZE.into())?;
+                    reader
+                        .read_discard_exact(GEOMETRY_SIZE.into())
+                        .map_err(|e| Error::DataRead("geometry_secondary", e))?;
                } else {
                    // Try to parse the backup copy.
-                    reader.read_exact(&mut buf)?;
+                    reader
+                        .read_exact(&mut buf)
+                        .map_err(|e| Error::DataRead("geometry_secondary", e))?;

                    geometry = RawGeometry::ref_from_prefix(&buf).unwrap().0;
                    geometry.validate()?;
                }

-                geometry
-            }
-            ImageType::Empty => {
-                // This is an empty image for use with fastboot. These have no
-                // extra padding at the beginning of the file nor backup copies
-                // of the geometry and metadata structs.
-                let geometry = RawGeometry::ref_from_prefix(&buf).unwrap().0;
-                geometry.validate()?;
-
-                geometry
+                ImageType::Normal
            }
+            Err(e) => return Err(e),
        };

        Ok((image_type, geometry.to_owned()))
@@ -1108,9 +1118,13 @@ impl RawMetadata {
    ) -> Result<RawMetadataSlot> {
        let mut header = RawHeader::new_zeroed();

-        reader.read_exact(&mut header.as_mut_bytes()[..RawHeader::SIZE_V1_0])?;
+        reader
+            .read_exact(&mut header.as_mut_bytes()[..RawHeader::SIZE_V1_0])
+            .map_err(|e| Error::DataRead("header_v1.0", e))?;
        if header.size() > RawHeader::SIZE_V1_0 {
-            reader.read_exact(&mut header.as_mut_bytes()[RawHeader::SIZE_V1_0..])?;
+            reader
+                .read_exact(&mut header.as_mut_bytes()[RawHeader::SIZE_V1_0..])
+                .map_err(|e| Error::DataRead("header_v1.2", e))?;
        }

        // We'll end up validating this again at the end, but this initial
@@ -1118,8 +1132,9 @@ impl RawMetadata {
        // parsing the tables.
        header.validate(geometry)?;

-        let mut tables_buf = vec![0u8; header.tables_size.get() as usize];
-        reader.read_exact(&mut tables_buf)?;
+        let tables_buf = reader
+            .read_vec_exact(header.tables_size.get() as usize)
+            .map_err(|e| Error::DataRead("tables", e))?;

        let partitions = header
            .partitions
@@ -1210,20 +1225,26 @@ impl<R: Read> FromReader<R> for RawMetadata {
                let mut to_skip = u64::from(geometry.metadata_max_size.get());

                if slot.is_none() {
-                    let orig_offset = reader.stream_position()?;
+                    let orig_offset = reader
+                        .stream_position()
+                        .map_err(|e| Error::DataRead("orig_offset", e))?;

                    match Self::read_metadata(&mut reader, image_type, &geometry) {
                        Ok(m) => *slot = Some(m),
-                        Err(e @ Error::Io(_)) => return Err(e),
+                        Err(e @ Error::DataRead(_, _)) => return Err(e),
                        Err(e) => last_err = Some(e),
                    }

                    // Skip the remaining padding.
-                    let cur_offset = reader.stream_position()?;
+                    let cur_offset = reader
+                        .stream_position()
+                        .map_err(|e| Error::DataRead("cur_offset", e))?;
                    to_skip -= cur_offset - orig_offset;
                }

-                reader.read_discard(to_skip)?;
+                reader
+                    .read_discard(to_skip)
+                    .map_err(|e| Error::DataRead("slot_padding", e))?;
            }
        }

@@ -1251,11 +1272,17 @@ impl<W: Write> ToWriter<W> for RawMetadata {

        match self.image_type {
            ImageType::Normal => {
-                writer.write_zeros_exact(PARTITION_RESERVED_BYTES.into())?;
+                writer
+                    .write_zeros_exact(PARTITION_RESERVED_BYTES.into())
+                    .map_err(|e| Error::DataWrite("reserved", e))?;

                for _ in 0..2 {
-                    writer.write_all(geometry)?;
-                    writer.write_zeros_exact(geometry_padding as u64)?;
+                    writer
+                        .write_all(geometry)
+                        .map_err(|e| Error::DataWrite("geometry", e))?;
+                    writer
+                        .write_zeros_exact(geometry_padding as u64)
+                        .map_err(|e| Error::DataWrite("geometry_padding", e))?;
                }

                let metadata_max_size = self.geometry.metadata_max_size.get() as usize;
@@ -1270,24 +1297,50 @@ impl<W: Write> ToWriter<W> for RawMetadata {
                        let tables_size = slot.header.tables_size.get() as usize;
                        let metadata_padding = metadata_max_size - header.len() - tables_size;

-                        writer.write_all(header)?;
-                        writer.write_all(slot.partitions.as_bytes())?;
-                        writer.write_all(slot.extents.as_bytes())?;
-                        writer.write_all(slot.groups.as_bytes())?;
-                        writer.write_all(slot.block_devices.as_bytes())?;
-                        writer.write_zeros_exact(metadata_padding as u64)?;
+                        writer
+                            .write_all(header)
+                            .map_err(|e| Error::DataWrite("header", e))?;
+                        writer
+                            .write_all(slot.partitions.as_bytes())
+                            .map_err(|e| Error::DataWrite("partition_tables", e))?;
+                        writer
+                            .write_all(slot.extents.as_bytes())
+                            .map_err(|e| Error::DataWrite("extent_tables", e))?;
+                        writer
+                            .write_all(slot.groups.as_bytes())
+                            .map_err(|e| Error::DataWrite("group_tables", e))?;
+                        writer
+                            .write_all(slot.block_devices.as_bytes())
+                            .map_err(|e| Error::DataWrite("block_device_tables", e))?;
+                        writer
+                            .write_zeros_exact(metadata_padding as u64)
+                            .map_err(|e| Error::DataWrite("metadata_padding", e))?;
                    }
                }
            }
            ImageType::Empty => {
-                writer.write_all(geometry)?;
-                writer.write_zeros_exact(geometry_padding as u64)?;
+                writer
+                    .write_all(geometry)
+                    .map_err(|e| Error::DataWrite("geometry", e))?;
+                writer
+                    .write_zeros_exact(geometry_padding as u64)
+                    .map_err(|e| Error::DataWrite("geometry_padding", e))?;

-                writer.write_all(self.slots[0].header.as_bytes())?;
-                writer.write_all(self.slots[0].partitions.as_bytes())?;
-                writer.write_all(self.slots[0].extents.as_bytes())?;
-                writer.write_all(self.slots[0].groups.as_bytes())?;
-                writer.write_all(self.slots[0].block_devices.as_bytes())?;
+                writer
+                    .write_all(self.slots[0].header.as_bytes())
+                    .map_err(|e| Error::DataWrite("header", e))?;
+                writer
+                    .write_all(self.slots[0].partitions.as_bytes())
+                    .map_err(|e| Error::DataWrite("partition_tables", e))?;
+                writer
+                    .write_all(self.slots[0].extents.as_bytes())
+                    .map_err(|e| Error::DataWrite("extent_tables", e))?;
+                writer
+                    .write_all(self.slots[0].groups.as_bytes())
+                    .map_err(|e| Error::DataWrite("group_tables", e))?;
+                writer
+                    .write_all(self.slots[0].block_devices.as_bytes())
+                    .map_err(|e| Error::DataWrite("block_device_tables", e))?;
            }
        }

@@ -1587,7 +1640,7 @@ impl TryFrom<&RawMetadataSlot> for MetadataSlot {
    type Error = Error;

    fn try_from(raw_slot: &RawMetadataSlot) -> Result<Self> {
-        let mut slot = MetadataSlot {
+        let mut slot = Self {
            major_version: raw_slot.header.major_version.get(),
            minor_version: raw_slot.header.minor_version.get(),
            groups: Vec::with_capacity(raw_slot.groups.len()),
@@ -1667,7 +1720,7 @@ impl TryFrom<&MetadataSlot> for RawMetadataSlot {
    fn try_from(slot: &MetadataSlot) -> Result<Self> {
        let header_size = RawHeader::size_for_version(slot.major_version, slot.minor_version);

-        let mut raw_slot = RawMetadataSlot {
+        let mut raw_slot = Self {
            header: RawHeader {
                magic: HEADER_MAGIC.into(),
                major_version: slot.major_version.into(),
@@ -1884,7 +1937,7 @@ impl TryFrom<&Metadata> for RawMetadata {
        // We only do the bare minimum calculations needed here to fill out the
        // raw fields. There is no semantic validation.

-        let mut raw_metadata = RawMetadata {
+        let mut raw_metadata = Self {
            image_type: metadata.image_type,
            geometry: RawGeometry {
                magic: GEOMETRY_MAGIC.into(),
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2023-2025 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

 pub mod avb;
@@ -13,3 +13,4 @@ pub mod padding;
 pub mod payload;
 pub mod sparse;
 pub mod verityrs;
+pub mod zip;
@@ -1,29 +1,36 @@
-// SPDX-FileCopyrightText: 2022-2024 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2022-2025 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

 use std::{
+    cmp::Ordering,
    collections::BTreeMap,
-    fmt,
+    fmt::{self, Write as _},
    io::{self, Cursor, Read, Seek, SeekFrom, Write},
    iter,
+    path::Path,
+    str::FromStr,
    sync::atomic::AtomicBool,
 };

 use clap::ValueEnum;
 use cms::signed_data::SignedData;
-use const_oid::{db::rfc5912, ObjectIdentifier};
+use const_oid::{ObjectIdentifier, db::rfc5912};
 use memchr::memmem;
 use prost::Message;
-use ring::digest::Context;
+use ring::digest::{Algorithm, Context};
 use thiserror::Error;
-use x509_cert::{der::Encode, Certificate};
-use zip::{result::ZipError, write::FileOptions, CompressionMethod, ZipArchive, ZipWriter};
+use x509_cert::{Certificate, der::Encode};
+use zip::{CompressionMethod, DateTime, ZipArchive, result::ZipError, write::SimpleFileOptions};

 use crate::{
    crypto::{self, RsaPublicKeyExt, RsaSigningKey, SignatureAlgorithm},
-    format::payload::{self, PayloadHeader},
-    protobuf::build::tools::releasetools::{ota_metadata::OtaType, OtaMetadata},
-    stream::{self, FromReader, HashingReader, HashingWriter},
+    format::{
+        payload::{self, PayloadHeader},
+        zip::ZipWriterWrapper,
+    },
+    protobuf::build::tools::releasetools::{OtaMetadata, ota_metadata::OtaType},
+    stream::{self, FromReader, HashingReader, HashingWriter, ReadFixedSizeExt},
+    util,
 };

 pub const PATH_METADATA: &str = "META-INF/com/android/metadata";
@@ -49,10 +56,12 @@ pub enum Error {
    OtaMagicNotFound,
    #[error("Cannot find EOCD magic")]
    EocdMagicNotFound,
-    #[error("EOCD magic found in archive comment")]
-    EocdMagicInComment,
+    #[error("EOCD magic found in archive comment at offset {0}")]
+    EocdMagicInComment(usize),
    #[error("Zip is too small to contain EOCD")]
    ZipTooSmall,
+    #[error("Zip archive comment is not empty: {0}")]
+    ZipNonEmptyComment(u16),
    #[error("Signature offset exceeds archive comment size")]
    SignatureOffsetTooLarge,
    #[error("Expected exactly one CMS embedded certificate, but found {0}")]
@@ -67,34 +76,56 @@ pub enum Error {
    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")]
-    InsufficientReservedSpace(String, usize),
+    #[error("Mismatched {key:?} entry offsets: zip only: {zip_only:?}, prop only: {prop_only:?}")]
+    MismatchedPropertyFiles {
+        key: String,
+        zip_only: String,
+        prop_only: String,
+    },
+    #[error("Property files {value:?} exceed {reserved} byte reserved space")]
+    InsufficientReservedSpace { value: String, reserved: usize },
    #[error("Invalid property file entry: {0:?}")]
    InvalidPropertyFileEntry(String),
-    #[error("Missing entry in OTA zip: {0}")]
+    #[error("Missing entry in OTA zip: {0:?}")]
    MissingZipEntry(&'static str),
-    #[error("CMS signing error")]
-    CmsSign(#[from] crypto::Error),
-    #[error("Payload error")]
-    Payload(#[from] payload::Error),
-    #[error("Failed to decode protobuf message")]
-    ProtobufDecode(#[from] prost::DecodeError),
-    #[error("SPKI error")]
-    Spki(#[from] pkcs8::spki::Error),
-    #[error("x509 DER error")]
-    Der(#[from] x509_cert::der::Error),
-    #[error("Zip error")]
-    Zip(#[from] ZipError),
-    #[error("I/O error")]
-    Io(#[from] io::Error),
+    #[error("Failed to decode OTA metadata protobuf message")]
+    MetadataDecode(#[source] prost::DecodeError),
+    #[error("Failed to open zip file")]
+    ZipOpen(#[source] ZipError),
+    #[error("Failed to open zip entry: {0:?}")]
+    ZipEntryOpen(&'static str, #[source] ZipError),
+    #[error("Failed to start new zip entry: {0:?}")]
+    ZipEntryStart(&'static str, #[source] ZipError),
+    #[error("Failed to read zip entry: {0:?}")]
+    ZipEntryRead(&'static str, #[source] io::Error),
+    #[error("Failed to write zip entry: {0:?}")]
+    ZipEntryWrite(&'static str, #[source] io::Error),
+    #[error("Failed to open zip entry #{0}")]
+    ZipIndexOpen(usize, #[source] ZipError),
+    #[error("Failed to load OTA certificate")]
+    OtaCertLoad(#[source] crypto::Error),
+    #[error("Failed to extract public key from OTA certificate")]
+    OtaCertExtractPubKey(#[source] crypto::Error),
+    #[error("Failed to load payload binary")]
+    PayloadLoad(#[source] payload::Error),
+    #[error("Failed to load CMS signature")]
+    CmsLoad(#[source] crypto::Error),
+    #[error("Failed to save CMS signature")]
+    CmsSave(#[source] x509_cert::der::Error),
+    #[error("Failed to generate CMS signature")]
+    CmsSign(#[source] crypto::Error),
+    #[error("Failed to verify CMS signature")]
+    CmsVerify(#[source] crypto::Error),
+    #[error("Failed to read OTA data: {0}")]
+    DataRead(&'static str, #[source] io::Error),
+    #[error("Failed to write OTA data: {0}")]
+    DataWrite(&'static str, #[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;

 pub fn parse_protobuf_metadata(data: &[u8]) -> Result<OtaMetadata> {
-    Ok(OtaMetadata::decode(data)?)
+    OtaMetadata::decode(data).map_err(Error::MetadataDecode)
 }

 /// Synthesize protobuf structure from legacy plain-text metadata.
@@ -259,16 +290,48 @@ fn serialize_metadata(metadata: &OtaMetadata) -> (String, Vec<u8>) {

 #[derive(Clone, Debug)]
 pub struct ZipEntry {
-    pub name: String,
+    pub path: String,
    pub offset: u64,
    pub size: u64,
 }

-/// Parse OTA property files string.
-pub fn parse_property_files(data: &str) -> Result<Vec<ZipEntry>> {
-    let mut result = vec![];
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PropEntry {
+    name: String,
+    pub offset: u64,
+    pub size: u64,
+}

-    for entry in data.trim_end().split(',') {
+impl PropEntry {
+    pub fn new(path: &str, offset: u64, size: u64) -> Self {
+        Self {
+            name: property_file_name(path).to_owned(),
+            offset,
+            size,
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+}
+
+impl From<&ZipEntry> for PropEntry {
+    fn from(entry: &ZipEntry) -> Self {
+        Self::new(&entry.path, entry.offset, entry.size)
+    }
+}
+
+impl fmt::Display for PropEntry {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}:{}:{}", self.name, self.offset, self.size)
+    }
+}
+
+impl FromStr for PropEntry {
+    type Err = Error;
+
+    fn from_str(entry: &str) -> Result<Self> {
        let mut pieces = entry.split(':');

        let name = pieces
@@ -288,38 +351,63 @@ pub fn parse_property_files(data: &str) -> Result<Vec<ZipEntry>> {
            return Err(Error::InvalidPropertyFileEntry(entry.to_owned()));
        }

-        result.push(ZipEntry { name, offset, size });
+        Ok(Self { name, offset, size })
+    }
+}
+
+/// Parse OTA property files string.
+pub fn parse_property_files(data: &str) -> Result<Vec<PropEntry>> {
+    let mut result = vec![];
+
+    for entry in data.trim_end().split(',') {
+        result.push(entry.parse()?);
    }

    Ok(result)
 }

+/// Get the filename for use in property files entries.
+fn property_file_name(path: &str) -> &str {
+    path.rsplit_once('/').map_or(path, |p| p.1)
+}
+
 /// Compute the property files entries listing the offsets and sizes to every
 /// zip entry.
 fn compute_property_files(
    pf_name: &str,
-    entries: &[ZipEntry],
+    entries: &[PropEntry],
    max_length: Option<usize>,
    want_pb: bool,
 ) -> Result<String> {
-    let compute = |path: &'static str| -> Result<String> {
+    // AOSP's ota_utils.py reserves 15 bytes for the `<offset>:<size>`
+    // placeholder. Since the size of `metadata.pb` is almost always 4 digits,
+    // this prevents the offset from exceeding 10 digits. In the wild, there are
+    // OTA files larger than 10 GB. With ota_utils.py, this limit is never
+    // reached because it puts the OTA metadata files at the beginning of the
+    // zip. However, avbroot needs to put them at the end due to streaming
+    // writes, so we reserve an additional byte to allow offsets <100 GB.
+    const RESERVATION_SIZE: usize = 16;
+
+    let mut buf = String::new();
+
+    let mut append = |path: &'static str| -> Result<()> {
+        let name = property_file_name(path);
        let entry = entries
            .iter()
-            .find(|e| e.name == path)
-            .ok_or_else(|| Error::MissingZipEntry(path))?;
-        let name = path.rsplit_once('/').map_or(path, |p| p.1);
+            .find(|e| e.name == name)
+            .ok_or(Error::MissingZipEntry(path))?;

-        Ok(format!("{name}:{}:{}", entry.offset, entry.size))
+        let _ = write!(&mut buf, "{entry},");
+
+        Ok(())
    };

-    let mut tokens = vec![];
-
    if pf_name == PF_NAME {
-        tokens.push(compute(NAME_PAYLOAD_METADATA)?);
+        append(NAME_PAYLOAD_METADATA)?;
    }

    for path in [PATH_PAYLOAD, PATH_PROPERTIES] {
-        tokens.push(compute(path)?);
+        append(path)?;
    }

    for path in [
@@ -328,53 +416,63 @@ fn compute_property_files(
        "care_map.txt",
        "compatibility.zip",
    ] {
-        if let Ok(token) = compute(path) {
-            tokens.push(token);
-        }
+        // These are optional.
+        let _ = append(path);
    }

    if max_length.is_none() {
-        tokens.push(format!("metadata:{}", " ".repeat(15)));
+        buf.push_str(property_file_name(PATH_METADATA));
+        buf.push(':');
+        buf.extend(iter::repeat_n(' ', RESERVATION_SIZE));
+        buf.push(',');
+
        if want_pb {
-            tokens.push(format!("metadata.pb:{}", " ".repeat(15)));
+            buf.push_str(property_file_name(PATH_METADATA_PB));
+            buf.push(':');
+            buf.extend(iter::repeat_n(' ', RESERVATION_SIZE));
+            buf.push(',');
        }
    } else {
-        tokens.push(compute(PATH_METADATA)?);
+        append(PATH_METADATA)?;
        if want_pb {
-            tokens.push(compute(PATH_METADATA_PB)?);
+            append(PATH_METADATA_PB)?;
        }
    }

-    let mut joined = tokens.join(",");
+    // Strip final trailing comma.
+    buf.pop();

    if let Some(l) = max_length {
-        if joined.len() > l {
-            return Err(Error::InsufficientReservedSpace(joined, l));
+        if buf.len() > l {
+            return Err(Error::InsufficientReservedSpace {
+                value: buf,
+                reserved: l,
+            });
        }

-        let remain = l - joined.len();
-        joined.extend(iter::repeat(' ').take(remain));
+        let remain = l - buf.len();
+        buf.extend(iter::repeat_n(' ', remain));
    }

-    Ok(joined)
+    Ok(buf)
 }

 // Add fake payload_metadata.bin entry, covering the header + header signature
 // regions of the payload.
 fn add_payload_metadata_entry(
-    entries: &mut Vec<ZipEntry>,
+    entries: &mut Vec<PropEntry>,
    payload_metadata_size: u64,
 ) -> Result<()> {
    let payload_offset = entries
        .iter()
        .find(|e| e.name == PATH_PAYLOAD)
-        .ok_or_else(|| Error::MissingZipEntry(PATH_PAYLOAD))?
+        .ok_or(Error::MissingZipEntry(PATH_PAYLOAD))?
        .offset;
-    entries.push(ZipEntry {
-        name: NAME_PAYLOAD_METADATA.to_owned(),
-        offset: payload_offset,
-        size: payload_metadata_size,
-    });
+    entries.push(PropEntry::new(
+        NAME_PAYLOAD_METADATA,
+        payload_offset,
+        payload_metadata_size,
+    ));

    Ok(())
 }
@@ -402,17 +500,19 @@ impl fmt::Display for ZipMode {
 /// directory would start.
 pub fn add_metadata(
    zip_entries: &[ZipEntry],
-    zip_writer: &mut ZipWriter<impl Write>,
+    zip_writer: &mut ZipWriterWrapper<impl Write>,
    next_offset: u64,
    metadata: &OtaMetadata,
    payload_metadata_size: u64,
    zip_mode: ZipMode,
 ) -> Result<OtaMetadata> {
    let mut metadata = metadata.clone();
-    let options = FileOptions::default().compression_method(CompressionMethod::Stored);
+    let options = SimpleFileOptions::default()
+        .last_modified_time(DateTime::default())
+        .compression_method(CompressionMethod::Stored);

-    let mut zip_entries = zip_entries.to_owned();
-    add_payload_metadata_entry(&mut zip_entries, payload_metadata_size)?;
+    let mut prop_entries = zip_entries.iter().map(PropEntry::from).collect();
+    add_payload_metadata_entry(&mut prop_entries, payload_metadata_size)?;

    // Compute initial property files with reserved space as placeholders to
    // store the self-referential metadata entries later.
@@ -420,7 +520,7 @@ pub fn add_metadata(
    for pf in [PF_NAME, PF_STREAMING_NAME] {
        metadata.property_files.insert(
            pf.to_owned(),
-            compute_property_files(pf, &zip_entries, None, true)?,
+            compute_property_files(pf, &prop_entries, None, true)?,
        );
    }

@@ -429,48 +529,60 @@ pub fn add_metadata(
        let (legacy_raw, modern_raw) = serialize_metadata(&metadata);
        let raw_writer = Cursor::new(Vec::new());
        let mut writer = match zip_mode {
-            ZipMode::Streaming => ZipWriter::new_streaming(raw_writer),
-            ZipMode::Seekable => ZipWriter::new(raw_writer),
+            ZipMode::Streaming => ZipWriterWrapper::new_streaming(raw_writer),
+            ZipMode::Seekable => ZipWriterWrapper::new_seekable(raw_writer),
        };

-        writer.start_file_with_extra_data(PATH_METADATA, options)?;
-        let legacy_offset = writer.end_extra_data()?;
-        writer.write_all(legacy_raw.as_bytes())?;
+        let legacy_offset = writer
+            .start_file(PATH_METADATA, options)
+            .map_err(|e| Error::ZipEntryStart(PATH_METADATA, e))?;
+        writer
+            .write_all(legacy_raw.as_bytes())
+            .map_err(|e| Error::ZipEntryWrite(PATH_METADATA, e))?;

-        writer.start_file_with_extra_data(PATH_METADATA_PB, options)?;
-        let modern_offset = writer.end_extra_data()?;
-        writer.write_all(&modern_raw)?;
+        let modern_offset = writer
+            .start_file(PATH_METADATA_PB, options)
+            .map_err(|e| Error::ZipEntryStart(PATH_METADATA_PB, e))?;
+        writer
+            .write_all(&modern_raw)
+            .map_err(|e| Error::ZipEntryWrite(PATH_METADATA_PB, e))?;

-        zip_entries.push(ZipEntry {
-            name: PATH_METADATA.to_owned(),
-            offset: next_offset + legacy_offset,
-            size: legacy_raw.len() as u64,
-        });
-        zip_entries.push(ZipEntry {
-            name: PATH_METADATA_PB.to_owned(),
-            offset: next_offset + modern_offset,
-            size: modern_raw.len() as u64,
-        });
+        prop_entries.push(PropEntry::new(
+            PATH_METADATA,
+            next_offset + legacy_offset,
+            legacy_raw.len() as u64,
+        ));
+        prop_entries.push(PropEntry::new(
+            PATH_METADATA_PB,
+            next_offset + modern_offset,
+            modern_raw.len() as u64,
+        ));

        (next_offset + legacy_offset, next_offset + modern_offset)
    };

    // Compute the final property files using the offsets of the fake entries.
    for (key, value) in &mut metadata.property_files {
-        *value = compute_property_files(key, &zip_entries, Some(value.len()), true)?;
+        *value = compute_property_files(key, &prop_entries, Some(value.len()), true)?;
    }

    // Add the final metadata files to the real zip.
    {
        let (legacy_raw, modern_raw) = serialize_metadata(&metadata);

-        zip_writer.start_file_with_extra_data(PATH_METADATA, options)?;
-        let legacy_offset = zip_writer.end_extra_data()?;
-        zip_writer.write_all(legacy_raw.as_bytes())?;
+        let legacy_offset = zip_writer
+            .start_file(PATH_METADATA, options)
+            .map_err(|e| Error::ZipEntryStart(PATH_METADATA, e))?;
+        zip_writer
+            .write_all(legacy_raw.as_bytes())
+            .map_err(|e| Error::ZipEntryWrite(PATH_METADATA, e))?;

-        zip_writer.start_file_with_extra_data(PATH_METADATA_PB, options)?;
-        let modern_offset = zip_writer.end_extra_data()?;
-        zip_writer.write_all(&modern_raw)?;
+        let modern_offset = zip_writer
+            .start_file(PATH_METADATA_PB, options)
+            .map_err(|e| Error::ZipEntryStart(PATH_METADATA_PB, e))?;
+        zip_writer
+            .write_all(&modern_raw)
+            .map_err(|e| Error::ZipEntryWrite(PATH_METADATA_PB, e))?;

        assert_eq!(legacy_offset, temp_legacy_offset);
        assert_eq!(modern_offset, temp_modern_offset);
@@ -485,29 +597,80 @@ pub fn verify_metadata(
    metadata: &OtaMetadata,
    payload_metadata_size: u64,
 ) -> Result<()> {
-    let mut zip_reader = ZipArchive::new(reader)?;
+    let mut zip_reader = ZipArchive::new(reader).map_err(Error::ZipOpen)?;
    let mut zip_entries = vec![];

    for i in 0..zip_reader.len() {
-        let entry = zip_reader.by_index(i)?;
-        zip_entries.push(ZipEntry {
-            name: entry.name().to_owned(),
-            offset: entry.data_start(),
-            size: entry.size(),
-        });
+        let entry = zip_reader
+            .by_index(i)
+            .map_err(|e| Error::ZipIndexOpen(i, e))?;
+
+        if entry.compression() != CompressionMethod::Stored {
+            continue;
+        }
+
+        zip_entries.push(PropEntry::new(
+            entry.name(),
+            entry.data_start(),
+            entry.size(),
+        ));
    }

    add_payload_metadata_entry(&mut zip_entries, payload_metadata_size)?;

-    let metadata_pb = zip_entries.iter().find(|e| e.name == PATH_METADATA_PB);
+    zip_entries.sort_by(|a, b| a.name.cmp(&b.name));

    for (key, value) in &metadata.property_files {
-        let new_value =
-            compute_property_files(key, &zip_entries, Some(value.len()), metadata_pb.is_some())?;
-        if *value != new_value {
+        let mut prop_entries = parse_property_files(value)?;
+        prop_entries.sort_by(|a, b| a.name.cmp(&b.name));
+
+        // Check that this is a subset of the actual entries.
+        let mut zip_iter = zip_entries.iter().peekable();
+        let mut prop_iter = prop_entries.iter().peekable();
+        let mut zip_only = vec![];
+        let mut prop_only = vec![];
+
+        loop {
+            match (zip_iter.peek(), prop_iter.peek()) {
+                (Some(&zip), Some(&prop)) => match zip.name.cmp(&prop.name) {
+                    Ordering::Less => {
+                        // Exists in zip, but not in property files.
+                        zip_iter.next();
+                    }
+                    Ordering::Equal => {
+                        // If the zip had multiple files with the same filename,
+                        // but in different directories, this will fail.
+                        if zip != prop {
+                            zip_only.push(zip);
+                            prop_only.push(prop);
+                        }
+                        zip_iter.next();
+                        prop_iter.next();
+                    }
+                    Ordering::Greater => {
+                        // Exists in property files, but not in zip.
+                        prop_only.push(prop);
+                        prop_iter.next();
+                    }
+                },
+                (Some(_), None) => {
+                    // Exists in zip, but not in property files.
+                    zip_iter.next();
+                }
+                (None, Some(prop)) => {
+                    // Exists in property files, but not in zip.
+                    prop_only.push(prop);
+                    prop_iter.next();
+                }
+                (None, None) => break,
+            }
+        }
+
+        if !zip_only.is_empty() || !prop_only.is_empty() {
            return Err(Error::MismatchedPropertyFiles {
-                expected: value.clone(),
-                actual: new_value,
+                key: key.clone(),
+                zip_only: util::join(zip_only.into_iter().map(|e| e.to_string()), ","),
+                prop_only: util::join(prop_only.into_iter().map(|e| e.to_string()), ","),
            });
        }
    }
@@ -515,16 +678,141 @@ pub fn verify_metadata(
    Ok(())
 }

-/// Parse the CMS signature from the OTA zip comment. Returns the decoded CMS
-/// [`SignedData`] structure and the length of the file (from the beginning)
-/// that's covered by the signature. This does not perform any parsing of zip
-/// data structures.
-fn parse_ota_sig(mut reader: impl Read + Seek) -> Result<(SignedData, u64)> {
-    let file_size = reader.seek(SeekFrom::End(0))?;
+#[derive(Clone, Debug)]
+struct RawOtaSignature {
+    /// Decoded CMS structure.
+    signed_data: SignedData,
+    /// Length of the file (from the beginning) that's covered by the signature.
+    hashed_size: u64,
+}

-    reader.seek(SeekFrom::Current(-6))?;
-    let mut footer = [0u8; 6];
-    reader.read_exact(&mut footer)?;
+impl RawOtaSignature {
+    pub fn embedded_cert(&self) -> Result<&Certificate> {
+        let mut iter = crypto::iter_cms_certs(&self.signed_data);
+
+        let Some(cert) = iter.next() else {
+            return Err(Error::NotOneCmsCertificate(0));
+        };
+
+        let None = iter.next() else {
+            return Err(Error::NotOneCmsCertificate(2 + iter.count()));
+        };
+
+        Ok(cert)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct OtaSignature {
+    pub cert: Certificate,
+    pub digest_algo: &'static Algorithm,
+    pub sig_algo: SignatureAlgorithm,
+    pub sig: Vec<u8>,
+    pub data_size: u64,
+}
+
+impl TryFrom<RawOtaSignature> for OtaSignature {
+    type Error = Error;
+
+    fn try_from(raw_ota_sig: RawOtaSignature) -> Result<Self> {
+        let cert = raw_ota_sig.embedded_cert()?;
+
+        // Make sure this is a signature scheme we can handle. There's currently
+        // no Rust library to verify arbitrary CMS signatures for large files
+        // without fully reading them into memory.
+        let signers_len = raw_ota_sig.signed_data.signer_infos.0.len();
+        if signers_len != 1 {
+            return Err(Error::NotOneCmsSignerInfo(signers_len));
+        }
+
+        let signer = raw_ota_sig.signed_data.signer_infos.0.get(0).unwrap();
+        if signer.digest_alg.oid != rfc5912::ID_SHA_256
+            && signer.digest_alg.oid != rfc5912::ID_SHA_1
+        {
+            return Err(Error::UnsupportedDigestAlgorithm(signer.digest_alg.oid));
+        } else if signer.signature_algorithm.oid != rfc5912::RSA_ENCRYPTION
+            && signer.signature_algorithm.oid != rfc5912::SHA_256_WITH_RSA_ENCRYPTION
+        {
+            return Err(Error::UnsupportedSignatureAlgorithm(
+                signer.signature_algorithm.oid,
+            ));
+        }
+
+        // We support SHA1 for verification only.
+        let (digest_algo, sig_algo) = if signer.digest_alg.oid == rfc5912::ID_SHA_256 {
+            (&ring::digest::SHA256, SignatureAlgorithm::Sha256WithRsa)
+        } else {
+            (
+                &ring::digest::SHA1_FOR_LEGACY_USE_ONLY,
+                SignatureAlgorithm::Sha1WithRsa,
+            )
+        };
+
+        Ok(Self {
+            cert: cert.clone(),
+            digest_algo,
+            sig_algo,
+            sig: signer.signature.as_bytes().to_vec(),
+            data_size: raw_ota_sig.hashed_size,
+        })
+    }
+}
+
+impl OtaSignature {
+    /// Verify an OTA zip against its embedded certificate. This function makes
+    /// no assertion about whether the certificate is actually trusted.
+    ///
+    /// CMS signed attributes are intentionally not supported because AOSP
+    /// recovery does not support them either. It expects the CMS [`SignedData`]
+    /// structure to be used for nothing more than a raw signature transport
+    /// mechanism.
+    pub fn verify_ota(
+        &self,
+        mut reader: impl Read + Seek,
+        cancel_signal: &AtomicBool,
+    ) -> Result<()> {
+        let public_key = crypto::get_public_key(&self.cert).map_err(Error::OtaCertExtractPubKey)?;
+
+        // Manually hash the parts of the file covered by the signature.
+        reader
+            .seek(SeekFrom::Start(0))
+            .map_err(|e| Error::DataRead("raw_data", e))?;
+
+        let mut hashing_reader = HashingReader::new(reader, Context::new(self.digest_algo));
+
+        stream::copy_n(
+            &mut hashing_reader,
+            io::sink(),
+            self.data_size,
+            cancel_signal,
+        )
+        .map_err(|e| Error::DataRead("raw_data", e))?;
+
+        let (_, context) = hashing_reader.finish();
+        let digest = context.finish();
+
+        // Verify the signature against the public key.
+        public_key
+            .verify_sig(self.sig_algo, digest.as_ref(), &self.sig)
+            .map_err(Error::CmsVerify)?;
+
+        Ok(())
+    }
+}
+
+/// Parse the CMS signature from the OTA zip comment. This does not perform any
+/// parsing of zip data structures.
+fn parse_raw_ota_sig(mut reader: impl Read + Seek) -> Result<RawOtaSignature> {
+    let file_size = reader
+        .seek(SeekFrom::End(0))
+        .map_err(|e| Error::DataRead("file_size", e))?;
+
+    reader
+        .seek(SeekFrom::Current(-6))
+        .map_err(|e| Error::DataRead("footer", e))?;
+    let footer = reader
+        .read_array_exact::<6>()
+        .map_err(|e| Error::DataRead("footer", e))?;

    let abs_eoc_offset = u16::from_le_bytes(footer[0..2].try_into().unwrap());
    let sig_magic = u16::from_le_bytes(footer[2..4].try_into().unwrap());
@@ -543,89 +831,38 @@ fn parse_ota_sig(mut reader: impl Read + Seek) -> Result<(SignedData, u64)> {
        return Err(Error::SignatureOffsetTooLarge);
    }

-    reader.seek(SeekFrom::Start(file_size - eocd_size))?;
-    let mut eocd = vec![0u8; eocd_size as usize];
-    reader.read_exact(&mut eocd)?;
+    reader
+        .seek(SeekFrom::Start(file_size - eocd_size))
+        .map_err(|e| Error::DataRead("eocd", e))?;
+    let eocd = reader
+        .read_vec_exact(eocd_size as usize)
+        .map_err(|e| Error::DataRead("eocd", e))?;

    let mut eocd_magic_iter = memmem::find_iter(&eocd, ZIP_EOCD_MAGIC);
    if eocd_magic_iter.next() != Some(0) {
        return Err(Error::EocdMagicNotFound);
    }
-    if eocd_magic_iter.next().is_some() {
-        return Err(Error::EocdMagicInComment);
+    if let Some(offset) = eocd_magic_iter.next() {
+        return Err(Error::EocdMagicInComment(offset));
    }

    let sig_offset = eocd_size as usize - usize::from(abs_eoc_offset);
-    let sd = crypto::parse_cms(&eocd[sig_offset..eocd_size as usize - 6])?;
+    let signed_data =
+        crypto::parse_cms(&eocd[sig_offset..eocd_size as usize - 6]).map_err(Error::CmsLoad)?;
    // The signature covers everything aside from the archive comment and its
    // length field.
    let hashed_size = file_size - 2 - u64::from(comment_size);

-    Ok((sd, hashed_size))
+    Ok(RawOtaSignature {
+        signed_data,
+        hashed_size,
+    })
 }

-/// Verify an OTA zip against its embedded certificates. This function makes no
-/// assertion about whether the certificate is actually trusted. Returns the
-/// embedded certificate.
-///
-/// CMS signed attributes are intentionally not supported because AOSP recovery
-/// does not support them either. It expects the CMS [`SignedData`] structure to
-/// be used for nothing more than a raw signature transport mechanism.
-pub fn verify_ota(mut reader: impl Read + Seek, cancel_signal: &AtomicBool) -> Result<Certificate> {
-    let (sd, hashed_size) = parse_ota_sig(&mut reader)?;
-
-    // Make sure the certificate in the CMS structure matches the otacert zip
-    // entry.
-    let certs = crypto::get_cms_certs(&sd);
-    if certs.len() != 1 {
-        return Err(Error::NotOneCmsCertificate(certs.len()));
-    }
-
-    let cert = &certs[0];
-    let public_key = crypto::get_public_key(cert)?;
-
-    // Make sure this is a signature scheme we can handle. There's currently no
-    // Rust library to verify arbitrary CMS signatures for large files without
-    // fully reading them into memory.
-    if sd.signer_infos.0.len() != 1 {
-        return Err(Error::NotOneCmsSignerInfo(sd.signer_infos.0.len()));
-    }
-
-    let signer = sd.signer_infos.0.get(0).unwrap();
-    if signer.digest_alg.oid != rfc5912::ID_SHA_256 && signer.digest_alg.oid != rfc5912::ID_SHA_1 {
-        return Err(Error::UnsupportedDigestAlgorithm(signer.digest_alg.oid));
-    } else if signer.signature_algorithm.oid != rfc5912::RSA_ENCRYPTION
-        && signer.signature_algorithm.oid != rfc5912::SHA_256_WITH_RSA_ENCRYPTION
-    {
-        return Err(Error::UnsupportedSignatureAlgorithm(
-            signer.signature_algorithm.oid,
-        ));
-    }
-
-    // Manually hash the parts of the file covered by the signature.
-    reader.seek(SeekFrom::Start(0))?;
-
-    // We support SHA1 for verification only.
-    let (algorithm, algo) = if signer.digest_alg.oid == rfc5912::ID_SHA_256 {
-        (&ring::digest::SHA256, SignatureAlgorithm::Sha256WithRsa)
-    } else {
-        (
-            &ring::digest::SHA1_FOR_LEGACY_USE_ONLY,
-            SignatureAlgorithm::Sha1WithRsa,
-        )
-    };
-
-    let mut hashing_reader = HashingReader::new(reader, Context::new(algorithm));
-
-    stream::copy_n(&mut hashing_reader, io::sink(), hashed_size, cancel_signal)?;
-
-    let (_, context) = hashing_reader.finish();
-    let digest = context.finish();
-
-    // Verify the signature against the public key.
-    public_key.verify_sig(algo, digest.as_ref(), signer.signature.as_bytes())?;
-
-    Ok(cert.clone())
+/// Parse the signature information from the CMS signature embedded in the OTA
+/// zip archive comment.
+pub fn parse_ota_sig(reader: impl Read + Seek) -> Result<OtaSignature> {
+    parse_raw_ota_sig(reader)?.try_into()
 }

 /// Get and parse the protobuf-encoded OTA metadata, the PEM-encoded otacert,
@@ -633,38 +870,52 @@ pub fn verify_ota(mut reader: impl Read + Seek, cancel_signal: &AtomicBool) -> R
 pub fn parse_zip_ota_info(
    reader: impl Read + Seek,
 ) -> Result<(OtaMetadata, Certificate, PayloadHeader, String)> {
-    let mut zip = ZipArchive::new(reader)?;
+    let mut zip = ZipArchive::new(reader).map_err(Error::ZipOpen)?;

    let metadata = match zip.by_name(PATH_METADATA_PB) {
        Ok(mut entry) => {
            let mut buf = Vec::new();
-            entry.read_to_end(&mut buf)?;
+            entry
+                .read_to_end(&mut buf)
+                .map_err(|e| Error::ZipEntryRead(PATH_METADATA_PB, e))?;
            parse_protobuf_metadata(&buf)?
        }
        e @ Err(ZipError::FileNotFound) => {
            drop(e);
-            let mut entry = zip.by_name(PATH_METADATA)?;
+            let mut entry = zip
+                .by_name(PATH_METADATA)
+                .map_err(|e| Error::ZipEntryOpen(PATH_METADATA, e))?;
            let mut buf = String::new();
-            entry.read_to_string(&mut buf)?;
+            entry
+                .read_to_string(&mut buf)
+                .map_err(|e| Error::ZipEntryRead(PATH_METADATA, e))?;
            parse_legacy_metadata(&buf)?
        }
-        Err(e) => return Err(e.into()),
+        Err(e) => return Err(Error::ZipEntryOpen(PATH_METADATA_PB, e)),
    };

    let certificate = {
-        let entry = zip.by_name(PATH_OTACERT)?;
-        crypto::read_pem_cert(entry)?
+        let entry = zip
+            .by_name(PATH_OTACERT)
+            .map_err(|e| Error::ZipEntryOpen(PATH_OTACERT, e))?;
+        crypto::read_pem_cert(Path::new(PATH_OTACERT), entry).map_err(Error::OtaCertLoad)?
    };

    let header = {
-        let entry = zip.by_name(PATH_PAYLOAD)?;
-        PayloadHeader::from_reader(entry)?
+        let entry = zip
+            .by_name(PATH_PAYLOAD)
+            .map_err(|e| Error::ZipEntryOpen(PATH_PAYLOAD, e))?;
+        PayloadHeader::from_reader(entry).map_err(Error::PayloadLoad)?
    };

    let properties = {
-        let mut entry = zip.by_name(PATH_PROPERTIES)?;
+        let mut entry = zip
+            .by_name(PATH_PROPERTIES)
+            .map_err(|e| Error::ZipEntryOpen(PATH_PROPERTIES, e))?;
        let mut buf = String::new();
-        entry.read_to_string(&mut buf)?;
+        entry
+            .read_to_string(&mut buf)
+            .map_err(|e| Error::ZipEntryRead(PATH_PROPERTIES, e))?;
        buf
    };

@@ -672,17 +923,12 @@ pub fn parse_zip_ota_info(
 }

 /// Ensure that we're using a non-zip64 EOCD and there's no archive comment.
-fn validate_eocd(eocd: &[u8]) -> io::Result<()> {
+fn validate_eocd(eocd: &[u8]) -> Result<()> {
    if &eocd[..4] != b"PK\x05\x06" {
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidData,
-            "EOCD magic not found",
-        ));
+        return Err(Error::EocdMagicNotFound);
    } else if &eocd[20..22] != b"\0\0" {
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidData,
-            "Archive comment is not 0 bytes",
-        ));
+        let size = u16::from_le_bytes(eocd[20..22].try_into().unwrap());
+        return Err(Error::ZipNonEmptyComment(size));
    }

    Ok(())
@@ -697,8 +943,9 @@ fn compute_signature_comment(
    cert: &Certificate,
    digest: ring::digest::Digest,
 ) -> Result<Vec<u8>> {
-    let cms_signature = crypto::cms_sign_external(key, cert, digest.as_ref())?;
-    let cms_signature_der = cms_signature.to_der()?;
+    let cms_signature =
+        crypto::cms_sign_external(key, cert, digest.as_ref()).map_err(Error::CmsSign)?;
+    let cms_signature_der = cms_signature.to_der().map_err(Error::CmsSave)?;

    // Includes placeholder for the EOCD comment size field.
    let mut buf = vec![0; 2];
@@ -720,12 +967,8 @@ fn compute_signature_comment(
    // Archive comment size (for use by the OTA signature verifier).
    buf.extend(((comment_size) as u16).to_le_bytes());

-    if let Some(o) = memmem::find(&buf[2..], ZIP_EOCD_MAGIC) {
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidData,
-            format!("Archive comment contains EOCD magic at offset {o}"),
-        )
-        .into());
+    if let Some(offset) = memmem::find(&buf[2..], ZIP_EOCD_MAGIC) {
+        return Err(Error::EocdMagicInComment(offset));
    }

    // Archive comment size (for the EOCD comment size field).
@@ -758,21 +1001,23 @@ impl<W: Write> StreamingSigningWriter<W> {

    pub fn finish(mut self, key: &RsaSigningKey, cert: &Certificate) -> Result<W> {
        if self.used < self.queue.len() {
-            return Err(
-                io::Error::new(io::ErrorKind::InvalidData, "Too small to contain EOCD").into(),
-            );
+            return Err(Error::ZipTooSmall);
        }

        validate_eocd(&self.queue)?;

        // Chop off the archive comment size field and write the remaining data.
-        self.inner.write_all(&self.queue[..20])?;
+        self.inner
+            .write_all(&self.queue[..20])
+            .map_err(|e| Error::DataWrite("eocd_minus_comment", e))?;

        let (mut raw_writer, context) = self.inner.finish();
        let digest = context.finish();

        let size_and_comment = compute_signature_comment(key, cert, digest)?;
-        raw_writer.write_all(&size_and_comment)?;
+        raw_writer
+            .write_all(&size_and_comment)
+            .map_err(|e| Error::DataWrite("size_and_comment", e))?;

        Ok(raw_writer)
    }
@@ -832,18 +1077,20 @@ impl<W: Read + Write + Seek> SeekableSigningWriter<W> {
        cert: &Certificate,
        cancel_signal: &AtomicBool,
    ) -> Result<W> {
-        let file_size = self.seek(SeekFrom::End(0))?;
+        let file_size = self
+            .seek(SeekFrom::End(0))
+            .map_err(|e| Error::DataRead("file_size", e))?;

        // Android only supports non-zip64 EOCD.
        if file_size < 22 {
-            return Err(
-                io::Error::new(io::ErrorKind::InvalidData, "Too small to contain EOCD").into(),
-            );
+            return Err(Error::ZipTooSmall);
        }

-        self.seek_relative(-22)?;
-        let mut eocd = [0u8; 22];
-        self.read_exact(&mut eocd)?;
+        self.seek_relative(-22)
+            .map_err(|e| Error::DataRead("eocd", e))?;
+        let eocd = self
+            .read_array_exact::<22>()
+            .map_err(|e| Error::DataRead("eocd", e))?;

        validate_eocd(&eocd)?;

@@ -853,13 +1100,16 @@ impl<W: Read + Write + Seek> SeekableSigningWriter<W> {
            ring::digest::Context::new(&ring::digest::SHA256),
        );

-        self.rewind()?;
-        stream::copy_n(&mut self, &mut hashing_writer, file_size - 2, cancel_signal)?;
+        self.rewind().map_err(|e| Error::DataRead("raw_data", e))?;
+        stream::copy_n(&mut self, &mut hashing_writer, file_size - 2, cancel_signal)
+            .map_err(|e| Error::DataRead("raw_data", e))?;

        let digest = hashing_writer.finish().1.finish();

        let size_and_comment = compute_signature_comment(key, cert, digest)?;
-        self.inner.write_all(&size_and_comment)?;
+        self.inner
+            .write_all(&size_and_comment)
+            .map_err(|e| Error::DataWrite("size_and_comment", e))?;

        Ok(self.inner)
    }
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2024 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2024-2025 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

 use std::{
@@ -11,7 +11,7 @@ use std::{
 use crc32fast::Hasher;
 use dlv_list::{Index, VecList};
 use thiserror::Error;
-use zerocopy::{byteorder::little_endian, FromBytes, IntoBytes};
+use zerocopy::{FromBytes, IntoBytes, byteorder::little_endian};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};

 use crate::stream::ReadDiscardExt;
@@ -96,15 +96,17 @@ pub enum Error {
    #[error("Gap between end of last chunk {prev_end} and start of new chunk {cur_start}")]
    GapBetweenChunks { prev_end: u32, cur_start: u32 },
    // Wrapped errors.
-    #[error("I/O error")]
-    Io(#[from] io::Error),
+    #[error("Failed to read sparse data: {0}")]
+    DataRead(&'static str, #[source] io::Error),
+    #[error("Failed to write sparse data: {0}")]
+    DataWrite(&'static str, #[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;

 /// Raw on-disk layout for the header.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawHeader {
    /// Magic value. This should be equal to [`HEADER_MAGIC`].
    magic: little_endian::U32,
@@ -157,7 +159,7 @@ impl RawHeader {
            return Err(Error::UnsupportedMajorVersion(self.major_version.get()));
        }

-        if self.file_hdr_sz.get() < mem::size_of::<RawHeader>() as u16 {
+        if self.file_hdr_sz.get() < mem::size_of::<Self>() as u16 {
            return Err(Error::InvalidFileHeaderSize(self.file_hdr_sz.get()));
        } else if self.chunk_hdr_sz.get() < mem::size_of::<RawChunk>() as u16 {
            return Err(Error::InvalidChunkHeaderSize(self.chunk_hdr_sz.get()));
@@ -171,7 +173,7 @@ impl RawHeader {
    }

    fn excess_raw_header_bytes(&self) -> u16 {
-        self.file_hdr_sz.get() - mem::size_of::<RawHeader>() as u16
+        self.file_hdr_sz.get() - mem::size_of::<Self>() as u16
    }

    fn excess_raw_chunk_bytes(&self) -> u16 {
@@ -181,7 +183,7 @@ impl RawHeader {

 /// Raw on-disk layout for the chunk header.
 #[derive(Clone, Copy, FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
-#[repr(packed)]
+#[repr(C, packed)]
 struct RawChunk {
    /// Chunk type. Must be [`CHUNK_TYPE_RAW`], [`CHUNK_TYPE_FILL`],
    /// [`CHUNK_TYPE_DONT_CARE`], or [`CHUNK_TYPE_CRC32`].
@@ -223,7 +225,7 @@ impl RawChunk {
                return Err(Error::InvalidChunkType {
                    index,
                    chunk_type: t,
-                })
+                });
            }
        };

@@ -372,6 +374,9 @@ impl fmt::Debug for ChunkData {
 /// metadata they contain.
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Chunk {
+    /// When [`Self::data`] is [`ChunkData::Data`], this is guaranteed to not
+    /// exceed the bounds of [`u32`] when multiplied by [`Header::block_size`].
+    /// For other types of data, a 64-bit signed or unsigned integer is needed.
    pub bounds: ChunkBounds,
    pub data: ChunkData,
 }
@@ -694,11 +699,14 @@ impl<R: Read> SparseReader<R> {
    /// data chunks if they are not needed. If the underlying file is seekable
    /// and skipping chunks is needed, use [`Self::new_seekable`] instead.
    pub fn new(mut inner: R, crc_mode: CrcMode) -> Result<Self> {
-        let header = RawHeader::read_from_io(&mut inner)?;
+        let header =
+            RawHeader::read_from_io(&mut inner).map_err(|e| Error::DataRead("header", e))?;

        header.validate()?;

-        inner.read_discard(header.excess_raw_header_bytes().into())?;
+        inner
+            .read_discard(header.excess_raw_header_bytes().into())
+            .map_err(|e| Error::DataRead("header_excess", e))?;

        Ok(Self {
            inner,
@@ -741,7 +749,8 @@ impl<R: Read> SparseReader<R> {
                    return Err(Error::Crc32RandomRead);
                }

-                seek(&mut self.inner, SeekFrom::Current(self.data_remain.into()))?;
+                seek(&mut self.inner, SeekFrom::Current(self.data_remain.into()))
+                    .map_err(|e| Error::DataRead("data_remain", e))?;
                self.data_remain = 0;
            } else {
                return Err(Error::UnreadChunkData(self.data_remain));
@@ -752,12 +761,14 @@ impl<R: Read> SparseReader<R> {
            return Ok(None);
        }

-        let raw_chunk = RawChunk::read_from_io(&mut self.inner)?;
+        let raw_chunk =
+            RawChunk::read_from_io(&mut self.inner).map_err(|e| Error::DataRead("chunk", e))?;

        raw_chunk.validate(self.chunk, &self.header, self.block)?;

        self.inner
-            .read_discard(self.header.excess_raw_chunk_bytes().into())?;
+            .read_discard(self.header.excess_raw_chunk_bytes().into())
+            .map_err(|e| Error::DataRead("chunk_excess", e))?;

        let data: ChunkData;

@@ -769,7 +780,8 @@ impl<R: Read> SparseReader<R> {
                data = ChunkData::Data;
            }
            CHUNK_TYPE_FILL => {
-                let fill_value = little_endian::U32::read_from_io(&mut self.inner)?;
+                let fill_value = little_endian::U32::read_from_io(&mut self.inner)
+                    .map_err(|e| Error::DataRead("chunk_fill_value", e))?;

                if let Some(hasher) = &mut self.hasher {
                    hash_fill_chunk(&raw_chunk, fill_value, &self.header, hasher);
@@ -785,7 +797,8 @@ impl<R: Read> SparseReader<R> {
                data = ChunkData::Hole;
            }
            CHUNK_TYPE_CRC32 => {
-                let expected = little_endian::U32::read_from_io(&mut self.inner)?;
+                let expected = little_endian::U32::read_from_io(&mut self.inner)
+                    .map_err(|e| Error::DataRead("chunk_crc32", e))?;

                if let Some(hasher) = &mut self.hasher {
                    let actual = hasher.clone().finalize();
@@ -801,7 +814,7 @@ impl<R: Read> SparseReader<R> {
                data = ChunkData::Crc32(expected.get());
            }
            _ => unreachable!(),
-        };
+        }

        let chunk = Chunk {
            bounds: ChunkBounds {
@@ -886,7 +899,9 @@ impl<W: Write> SparseWriter<W> {

        header.validate()?;

-        header.write_to_io(&mut inner)?;
+        header
+            .write_to_io(&mut inner)
+            .map_err(|e| Error::DataWrite("header", e))?;

        Ok(Self {
            inner,
@@ -937,7 +952,9 @@ impl<W: Write> SparseWriter<W> {
        self.chunk += 1;
        self.block = chunk.bounds.end;

-        raw_chunk.write_to_io(&mut self.inner)?;
+        raw_chunk
+            .write_to_io(&mut self.inner)
+            .map_err(|e| Error::DataWrite("chunk", e))?;

        match chunk.data {
            ChunkData::Data => {
@@ -945,7 +962,9 @@ impl<W: Write> SparseWriter<W> {
                    raw_chunk.total_sz.get() - u32::from(self.header.chunk_hdr_sz.get());
            }
            ChunkData::Fill(fill_value) => {
-                self.inner.write_all(&fill_value.to_le_bytes())?;
+                self.inner
+                    .write_all(&fill_value.to_le_bytes())
+                    .map_err(|e| Error::DataWrite("chunk_fill_value", e))?;

                hash_fill_chunk(
                    &raw_chunk,
@@ -958,7 +977,9 @@ impl<W: Write> SparseWriter<W> {
                hash_fill_chunk(&raw_chunk, 0.into(), &self.header, &mut self.hasher);
            }
            ChunkData::Crc32(expected) => {
-                self.inner.write_all(&expected.to_le_bytes())?;
+                self.inner
+                    .write_all(&expected.to_le_bytes())
+                    .map_err(|e| Error::DataWrite("chunk_crc32", e))?;

                let actual = self.hasher.clone().finalize();
                if actual != expected {
@@ -0,0 +1,103 @@
+// SPDX-FileCopyrightText: 2025 Andrew Gunnerson
+// SPDX-License-Identifier: GPL-3.0-only
+
+use std::io::{self, Seek, SeekFrom, Write};
+
+use zip::{
+    ZipWriter,
+    result::ZipResult,
+    write::{FileOptionExtension, FileOptions, StreamWriter},
+};
+
+/// A wrapper around a seekable writer. `W` must implement [`Seek`], but only
+/// during the creation of a new instance. The resulting type can be stored in a
+/// parent container where the generic type does not implement [`Seek`].
+pub struct SeekWriter<W: Write> {
+    inner: W,
+    seek_fn: fn(&mut W, SeekFrom) -> io::Result<u64>,
+}
+
+impl<W: Write> SeekWriter<W> {
+    pub fn into_inner(self) -> W {
+        self.inner
+    }
+}
+
+impl<W: Write + Seek> SeekWriter<W> {
+    pub fn new(inner: W) -> Self {
+        Self {
+            inner,
+            seek_fn: W::seek,
+        }
+    }
+}
+
+impl<W: Write> Write for SeekWriter<W> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.inner.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+impl<W: Write> Seek for SeekWriter<W> {
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        (self.seek_fn)(&mut self.inner, pos)
+    }
+}
+
+/// This is an ugly hack to have a single type represent both seekable and
+/// streaming [`ZipWriter`]s. `W` only needs to implement [`Seek`] when creating
+/// a seekable instance via [`Self::new_seekable`].
+pub enum ZipWriterWrapper<W: Write> {
+    Streaming(ZipWriter<StreamWriter<W>>),
+    Seekable(ZipWriter<SeekWriter<W>>),
+}
+
+impl<W: Write + Seek> ZipWriterWrapper<W> {
+    pub fn new_seekable(inner: W) -> Self {
+        Self::Seekable(ZipWriter::new(SeekWriter::new(inner)))
+    }
+}
+
+impl<W: Write> ZipWriterWrapper<W> {
+    pub fn new_streaming(inner: W) -> Self {
+        Self::Streaming(ZipWriter::new_stream(inner))
+    }
+
+    pub fn start_file(
+        &mut self,
+        name: impl ToString,
+        options: FileOptions<impl FileOptionExtension>,
+    ) -> ZipResult<u64> {
+        match self {
+            Self::Streaming(z) => z.start_file(name, options),
+            Self::Seekable(z) => z.start_file(name, options),
+        }
+    }
+
+    pub fn finish(self) -> ZipResult<W> {
+        match self {
+            Self::Streaming(z) => Ok(z.finish()?.into_inner()),
+            Self::Seekable(z) => Ok(z.finish()?.into_inner()),
+        }
+    }
+}
+
+impl<W: Write> Write for ZipWriterWrapper<W> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        match self {
+            Self::Streaming(z) => z.write(buf),
+            Self::Seekable(z) => z.write(buf),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        match self {
+            Self::Streaming(z) => z.flush(),
+            Self::Seekable(z) => z.flush(),
+        }
+    }
+}
@@ -4,8 +4,8 @@
 use std::{
    process::ExitCode,
    sync::{
-        atomic::{AtomicBool, Ordering},
        Arc,
+        atomic::{AtomicBool, Ordering},
    },
 };

@@ -10,7 +10,7 @@ use std::{
 };

 use num_traits::{Num, PrimInt};
-use serde::{de::Visitor, Deserializer, Serializer};
+use serde::{Deserializer, Serializer, de::Visitor};

 pub fn serialize<S, T>(data: &T, serializer: S) -> Result<S::Ok, S::Error>
 where
@@ -4,12 +4,13 @@
 use std::{
    cmp::Ordering,
    collections::{HashMap, HashSet},
+    fmt::Write,
    fs::File,
-    io::{self, BufRead, BufReader, Cursor, Read, Seek},
+    io::{self, BufRead, BufReader, Cursor, Read},
    num::ParseIntError,
-    ops::Range,
+    ops::{Range, RangeFrom},
    path::{Path, PathBuf},
-    slice,
+    slice, str,
    sync::atomic::AtomicBool,
 };

@@ -23,9 +24,9 @@ use regex::bytes::Regex;
 use ring::digest::Context;
 use rsa::RsaPublicKey;
 use thiserror::Error;
-use tracing::{debug, debug_span, trace, warn, Span};
+use tracing::{Span, debug, debug_span, trace, warn};
 use x509_cert::Certificate;
-use zip::{result::ZipError, ZipArchive};
+use zip::{ZipArchive, result::ZipError};

 use crate::{
    crypto::{self, RsaSigningKey},
@@ -41,8 +42,6 @@ use crate::{

 #[derive(Debug, Error)]
 pub enum Error {
-    #[error("No compatible boot image found for {0}")]
-    NoTargets(&'static str),
    #[error("Boot image has no vbmeta footer")]
    NoFooter,
    #[error("No hash descriptor found in vbmeta header")]
@@ -53,41 +52,80 @@ pub enum Error {
    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("OTA certificate error")]
-    OtaCert(#[from] otacert::Error),
-    #[error("XZ stream error")]
-    XzStream(#[from] liblzma::stream::Error),
-    #[error("Zip error")]
-    Zip(#[source] ZipError),
-    #[error("Zip error for entry name: {0:?}")]
-    ZipEntryName(String, #[source] ZipError),
-    #[error("Zip error for entry index #{0}")]
-    ZipEntryIndex(usize, #[source] ZipError),
-    #[error("I/O error")]
-    Io(#[from] io::Error),
-    #[error("File I/O error")]
-    File(PathBuf, #[source] io::Error),
+    #[error("Failed to load potentially compressed ramdisk")]
+    RamdiskLoadCompression(#[source] compression::Error),
+    #[error("Failed to save potentially compressed ramdisk")]
+    RamdiskSaveCompression(#[source] compression::Error),
+    #[error("Failed to finalize compressed ramdisk")]
+    RamdiskSaveCompressionFinalize(#[source] io::Error),
+    #[error("Failed to load ramdisk cpio entries")]
+    RamdiskLoadCpio(#[source] cpio::Error),
+    #[error("Failed to save ramdisk cpio entries")]
+    RamdiskSaveCpio(#[source] cpio::Error),
+    #[error("Failed to load potentially compressed kernel")]
+    KernelLoadCompression(#[source] compression::Error),
+    #[error("Failed to read kernel image")]
+    KernelRead(#[source] io::Error),
+    #[error("Failed to load boot image")]
+    BootImageLoad(#[source] bootimage::Error),
+    #[error("Failed to save boot image")]
+    BootImageSave(#[source] bootimage::Error),
+    #[error("Failed to seek boot image")]
+    BootImageSeek(#[source] io::Error),
+    #[error("Failed to encode public key in AVB binary format")]
+    AvbEncodeKey(#[source] avb::Error),
+    #[error("Failed to load AVB header from boot image")]
+    AvbLoad(#[source] avb::Error),
+    #[error("Failed to update AVB header for boot image")]
+    AvbUpdate(#[source] avb::Error),
+    #[error("Failed to load OTA certificate")]
+    OtaCertLoad(#[source] crypto::Error),
+    #[error("Failed to generate replacement otacerts zip")]
+    OtaCertZip(#[source] otacert::Error),
+    #[error("Failed to initialize XZ encoder")]
+    XzInit(#[source] liblzma::stream::Error),
+    #[error("Failed to XZ compress entry: {:?}", .0.as_bstr())]
+    XzCompress(Vec<u8>, #[source] io::Error),
+    #[error("Failed to open zip file: {0:?}")]
+    ZipOpen(PathBuf, #[source] ZipError),
+    #[error("Failed to open zip entry: {0:?}")]
+    ZipEntryOpen(&'static str, #[source] ZipError),
+    #[error("Failed to read zip entry: {0:?}")]
+    ZipEntryRead(&'static str, #[source] io::Error),
+    #[error("Failed to open zip entry #{0}")]
+    ZipIndexOpen(usize, #[source] ZipError),
+    #[error("Failed to open file: {0:?}")]
+    FileOpen(PathBuf, #[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;

+#[derive(Debug, Error)]
+pub enum TargetsError {
+    #[error("No compatible boot image found for {0}")]
+    NoTargets(&'static str),
+    #[error("Targets validation error: {0}")]
+    TargetValidation(String),
+    #[error("Failed to open boot image: {0}")]
+    Open(String, #[source] io::Error),
+    #[error("Failed to load boot image: {0}")]
+    Load(String, #[source] Error),
+    #[error("Failed to save boot image: {0}")]
+    Save(String, #[source] Error),
+    #[error("Failed to patch boot image: {0}")]
+    Patch(String, #[source] Error),
+}
+
+type TargetsResult<T> = std::result::Result<T, TargetsError>;
+
 fn load_ramdisk(
    data: &[u8],
    cancel_signal: &AtomicBool,
 ) -> Result<(Vec<CpioEntry>, CompressedFormat)> {
    let raw_reader = Cursor::new(data);
-    let mut reader = CompressedReader::new(raw_reader, false)?;
-    let entries = cpio::load(&mut reader, false, cancel_signal)?;
+    let mut reader =
+        CompressedReader::new(raw_reader, false).map_err(Error::RamdiskLoadCompression)?;
+    let entries = cpio::load(&mut reader, false, cancel_signal).map_err(Error::RamdiskLoadCpio)?;

    trace!(
        "Loaded {:?} ramdisk with {} entries",
@@ -104,12 +142,15 @@ fn save_ramdisk(
    cancel_signal: &AtomicBool,
 ) -> Result<Vec<u8>> {
    let raw_writer = Cursor::new(vec![]);
-    let mut writer = CompressedWriter::new(raw_writer, format)?;
-    cpio::save(&mut writer, entries, false, cancel_signal)?;
+    let mut writer =
+        CompressedWriter::new(raw_writer, format).map_err(Error::RamdiskSaveCompression)?;
+    cpio::save(&mut writer, entries, false, cancel_signal).map_err(Error::RamdiskSaveCpio)?;

    trace!("Wrote {format:?} ramdisk with {} entries", entries.len());

-    let raw_writer = writer.finish()?;
+    let raw_writer = writer
+        .finish()
+        .map_err(Error::RamdiskSaveCompressionFinalize)?;
    Ok(raw_writer.into_inner())
 }

@@ -130,7 +171,7 @@ pub trait BootImagePatch {
        &self,
        boot_images: &HashMap<&'a str, BootImageInfo>,
        cancel_signal: &AtomicBool,
-    ) -> Result<Vec<&'a str>>;
+    ) -> TargetsResult<Vec<&'a str>>;

    fn patch(&self, boot_image: &mut BootImage, cancel_signal: &AtomicBool) -> Result<()>;
 }
@@ -151,13 +192,13 @@ impl MagiskRootPatcher {
    //   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: &'static [Range<u32>] = &[25102..25207, 25211..28200];
-    const VER_PREINIT_DEVICE: Range<u32> =
-        25211..Self::VERS_SUPPORTED[Self::VERS_SUPPORTED.len() - 1].end;
+    // - Versions newer than the latest supported version are assumed to support
+    //   the same features as the latest version
+    const VERS_SUPPORTED: &'static [Range<u32>] = &[25102..25207, 25211..30300];
+    const VER_PREINIT_DEVICE: RangeFrom<u32> = 25211..;
    const VER_RANDOM_SEED: Range<u32> = 25211..26103;
    const VER_PATCH_VBMETA: Range<u32> = Self::VERS_SUPPORTED[0].start..26202;
-    const VER_XZ_BACKUP: Range<u32> =
-        26403..Self::VERS_SUPPORTED[Self::VERS_SUPPORTED.len() - 1].end;
+    const VER_XZ_BACKUP: RangeFrom<u32> = 26403..;

    const ZIP_INIT_LD: &'static str = "lib/arm64-v8a/libinit-ld.so";
    const ZIP_LIBMAGISK: &'static str = "lib/arm64-v8a/libmagisk.so";
@@ -216,18 +257,21 @@ impl MagiskRootPatcher {
    }

    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).map_err(Error::Zip)?;
+        let reader = File::open(path)
+            .map(BufReader::new)
+            .map_err(|e| Error::FileOpen(path.to_owned(), e))?;
+        let mut zip = ZipArchive::new(reader).map_err(|e| Error::ZipOpen(path.to_owned(), e))?;
        let entry = zip
            .by_name(Self::ZIP_UTIL_FUNCTIONS)
-            .map_err(|e| Error::ZipEntryName(Self::ZIP_UTIL_FUNCTIONS.to_owned(), e))?;
+            .map_err(|e| Error::ZipEntryOpen(Self::ZIP_UTIL_FUNCTIONS, e))?;
        let mut entry = BufReader::new(entry);
        let mut line = String::new();

        loop {
            line.clear();
-            let n = entry.read_line(&mut line)?;
+            let n = entry
+                .read_line(&mut line)
+                .map_err(|e| Error::ZipEntryRead(Self::ZIP_UTIL_FUNCTIONS, e))?;
            if n == 0 {
                return Err(Error::FindMagiskVersion(path.to_owned()));
            }
@@ -243,14 +287,14 @@ impl MagiskRootPatcher {
        }
    }

-    fn xz_compress(reader: impl Read, cancel_signal: &AtomicBool) -> Result<Vec<u8>> {
-        let stream = Stream::new_easy_encoder(9, Check::Crc32)?;
+    fn xz_compress(name: &[u8], reader: impl Read, cancel_signal: &AtomicBool) -> Result<Vec<u8>> {
+        let stream = Stream::new_easy_encoder(9, Check::Crc32).map_err(Error::XzInit)?;
        let raw_writer = Cursor::new(Vec::new());
        let mut writer = XzEncoder::new_stream(raw_writer, stream);

-        stream::copy(reader, &mut writer, cancel_signal)?;
-
-        let raw_writer = writer.finish()?;
+        let raw_writer = stream::copy(reader, &mut writer, cancel_signal)
+            .and_then(|_| writer.finish())
+            .map_err(|e| Error::XzCompress(name.to_owned(), e))?;

        Ok(raw_writer.into_inner())
    }
@@ -339,7 +383,7 @@ impl MagiskRootPatcher {
                    new_path.extend(b".xz");

                    let reader = Cursor::new(data);
-                    let buf = Self::xz_compress(reader, cancel_signal)?;
+                    let buf = Self::xz_compress(&new_path, reader, cancel_signal)?;
                    new_data = Some(CpioEntryData::Data(buf));
                }
            }
@@ -381,22 +425,24 @@ impl BootImagePatch for MagiskRootPatcher {
        &self,
        boot_images: &HashMap<&'a str, BootImageInfo>,
        _cancel_signal: &AtomicBool,
-    ) -> Result<Vec<&'a str>> {
+    ) -> TargetsResult<Vec<&'a str>> {
        let mut targets = vec![];

        if boot_images.contains_key("init_boot") {
            targets.push("init_boot");
        } else if boot_images.contains_key("boot") {
            targets.push("boot");
-        };
+        }

        Ok(targets)
    }

    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)).map_err(Error::Zip)?;
+        let zip_reader = File::open(&self.apk_path)
+            .map(BufReader::new)
+            .map_err(|e| Error::FileOpen(self.apk_path.clone(), e))?;
+        let mut zip =
+            ZipArchive::new(zip_reader).map_err(|e| Error::ZipOpen(self.apk_path.clone(), e))?;

        // Load the first ramdisk. If it doesn't exist, we have to generate one
        // from scratch.
@@ -427,9 +473,11 @@ impl BootImagePatch for MagiskRootPatcher {
        {
            let mut zip_entry = zip
                .by_name(Self::ZIP_MAGISKINIT)
-                .map_err(|e| Error::ZipEntryName(Self::ZIP_MAGISKINIT.to_owned(), e))?;
+                .map_err(|e| Error::ZipEntryOpen(Self::ZIP_MAGISKINIT, e))?;
            let mut data = vec![];
-            zip_entry.read_to_end(&mut data)?;
+            zip_entry
+                .read_to_end(&mut data)
+                .map_err(|e| Error::ZipEntryRead(Self::ZIP_MAGISKINIT, e))?;

            entries.push(CpioEntry::new_file(
                b"init",
@@ -471,8 +519,8 @@ impl BootImagePatch for MagiskRootPatcher {
        for (source, target) in xz_files {
            let reader = zip
                .by_name(source)
-                .map_err(|e| Error::ZipEntryName(source.to_owned(), e))?;
-            let buf = Self::xz_compress(reader, cancel_signal)?;
+                .map_err(|e| Error::ZipEntryOpen(source, e))?;
+            let buf = Self::xz_compress(source.as_bytes(), reader, cancel_signal)?;

            entries.push(CpioEntry::new_file(target, 0o644, CpioEntryData::Data(buf)));
        }
@@ -497,10 +545,9 @@ impl BootImagePatch for MagiskRootPatcher {
        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(),
-            ));
+            if let Some(device) = &self.preinit_device {
+                writeln!(&mut magisk_config, "PREINITDEVICE={device}").unwrap();
+            }
        }

        // Magisk normally saves the original SHA1 digest in its config file. It
@@ -510,7 +557,7 @@ impl BootImagePatch for MagiskRootPatcher {
        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));
+            writeln!(&mut magisk_config, "RANDOMSEED={:#x}", self.random_seed).unwrap();
        }

        trace!("Magisk config: {magisk_config:?}");
@@ -523,7 +570,7 @@ impl BootImagePatch for MagiskRootPatcher {

        // Repack ramdisk.
        cpio::sort(&mut entries);
-        cpio::assign_inodes(&mut entries, false)?;
+        cpio::assign_inodes(&mut entries, false).map_err(Error::RamdiskSaveCpio)?;
        let new_ramdisk = save_ramdisk(&entries, ramdisk_format, cancel_signal)?;

        match boot_image {
@@ -590,18 +637,22 @@ impl OtaCertPatcher {
                continue;
            };

-            let mut zip = ZipArchive::new(Cursor::new(&data)).map_err(Error::Zip)?;
+            let mut zip = ZipArchive::new(Cursor::new(&data)).map_err(|e| {
+                Error::ZipOpen(str::from_utf8(Self::OTACERTS_PATH).unwrap().into(), e)
+            })?;

            for index in 0..zip.len() {
                let zip_entry = zip
                    .by_index(index)
-                    .map_err(|e| Error::ZipEntryIndex(index, e))?;
+                    .map_err(|e| Error::ZipIndexOpen(index, e))?;
                if !zip_entry.name().ends_with(".x509.pem") {
                    debug!("Skipping invalid entry path: {}", zip_entry.name());
                    continue;
                }

-                let certificate = crypto::read_pem_cert(zip_entry)?;
+                let path = PathBuf::from(zip_entry.name());
+                let certificate =
+                    crypto::read_pem_cert(&path, zip_entry).map_err(Error::OtaCertLoad)?;
                certificates.push(certificate);
            }
        }
@@ -639,10 +690,10 @@ impl BootImagePatch for OtaCertPatcher {
        &self,
        boot_images: &HashMap<&'a str, BootImageInfo>,
        cancel_signal: &AtomicBool,
-    ) -> Result<Vec<&'a str>> {
+    ) -> TargetsResult<Vec<&'a str>> {
        let mut targets = vec![];

-        'outer: for (name, info) in boot_images {
+        'outer: for (&name, info) in boot_images {
            let ramdisks = match &info.boot_image {
                BootImage::V0Through2(b) => slice::from_ref(&b.ramdisk),
                BootImage::V3Through4(b) => slice::from_ref(&b.ramdisk),
@@ -654,9 +705,10 @@ impl BootImagePatch for OtaCertPatcher {
                    continue;
                }

-                let (entries, _) = load_ramdisk(ramdisk, cancel_signal)?;
+                let (entries, _) = load_ramdisk(ramdisk, cancel_signal)
+                    .map_err(|e| TargetsError::Load(name.to_owned(), e))?;
                if entries.iter().any(|e| e.path == Self::OTACERTS_PATH) {
-                    targets.push(*name);
+                    targets.push(name);
                    continue 'outer;
                }
            }
@@ -672,7 +724,8 @@ impl BootImagePatch for OtaCertPatcher {
            BootImage::VendorV3Through4(b) => &mut b.ramdisks,
        };

-        let new_zip = otacert::create_zip(&self.cert, OtaCertBuildFlags::empty())?;
+        let new_zip = otacert::create_zip(&self.cert, OtaCertBuildFlags::empty())
+            .map_err(Error::OtaCertZip)?;
        trace!("Generated new {} byte otacerts.zip", new_zip.len());

        for ramdisk in ramdisks {
@@ -718,7 +771,8 @@ impl DsuPubKeyPatcher {
            entries.push(CpioEntry::new_directory(Self::DSU_KEYS_PATH, 0o755));
        }

-        let data = CpioEntryData::Data(avb::encode_public_key(&self.key)?);
+        let binary_key = avb::encode_public_key(&self.key).map_err(Error::AvbEncodeKey)?;
+        let data = CpioEntryData::Data(binary_key);

        if let Some(e) = entries
            .iter_mut()
@@ -727,7 +781,7 @@ impl DsuPubKeyPatcher {
            e.data = data;
        } else {
            entries.push(CpioEntry::new_file(Self::AVBROOT_KEY_PATH, 0o644, data));
-        };
+        }

        *ramdisk = save_ramdisk(&entries, ramdisk_format, cancel_signal)?;

@@ -744,11 +798,11 @@ impl BootImagePatch for DsuPubKeyPatcher {
        &self,
        boot_images: &HashMap<&'a str, BootImageInfo>,
        cancel_signal: &AtomicBool,
-    ) -> Result<Vec<&'a str>> {
+    ) -> TargetsResult<Vec<&'a str>> {
        let mut dsu_keys_targets = vec![];
        let mut first_stage_targets = vec![];

-        'outer: for (name, info) in boot_images {
+        'outer: for (&name, info) in boot_images {
            let ramdisks = match &info.boot_image {
                BootImage::V0Through2(b) => slice::from_ref(&b.ramdisk),
                BootImage::V3Through4(b) => slice::from_ref(&b.ramdisk),
@@ -760,15 +814,16 @@ impl BootImagePatch for DsuPubKeyPatcher {
                    continue;
                }

-                let (entries, _) = load_ramdisk(ramdisk, cancel_signal)?;
+                let (entries, _) = load_ramdisk(ramdisk, cancel_signal)
+                    .map_err(|e| TargetsError::Load(name.to_owned(), e))?;
                let mut found = false;

                for entry in entries {
                    if entry.path == Self::DSU_KEYS_PATH {
-                        dsu_keys_targets.push(*name);
+                        dsu_keys_targets.push(name);
                        found = true;
                    } else if entry.path == Self::FIRST_STAGE_PATH {
-                        first_stage_targets.push(*name);
+                        first_stage_targets.push(name);
                        found = true;
                    }
                }
@@ -783,7 +838,7 @@ impl BootImagePatch for DsuPubKeyPatcher {
            // Most builds trust as least one DSU key. For these builds, add the
            // user's key to the same directory.
            if dsu_keys_targets.len() > 1 {
-                return Err(Error::Validation(format!(
+                return Err(TargetsError::TargetValidation(format!(
                    "DSU keys found in more than one boot image: {dsu_keys_targets:?}",
                )));
            }
@@ -852,19 +907,22 @@ impl PrepatchedImagePatcher {
    }

    fn load_prepatched_image(&self) -> Result<BootImage> {
-        let raw_reader =
-            File::open(&self.prepatched).map_err(|e| Error::File(self.prepatched.clone(), e))?;
-        let boot_image = BootImage::from_reader(BufReader::new(raw_reader))?;
+        let reader = File::open(&self.prepatched)
+            .map(BufReader::new)
+            .map_err(|e| Error::FileOpen(self.prepatched.clone(), e))?;

-        Ok(boot_image)
+        BootImage::from_reader(reader).map_err(Error::BootImageLoad)
    }

    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 mut reader =
+                CompressedReader::new(raw_reader, true).map_err(Error::KernelLoadCompression)?;
+            reader
+                .read_to_end(&mut decompressed)
+                .map_err(Error::KernelRead)?;
        }

        let regex = Regex::new(Self::VERSION_REGEX).unwrap();
@@ -896,8 +954,10 @@ impl BootImagePatch for PrepatchedImagePatcher {
        &self,
        boot_images: &HashMap<&'a str, BootImageInfo>,
        _cancel_signal: &AtomicBool,
-    ) -> Result<Vec<&'a str>> {
-        let prepatched_image = self.load_prepatched_image()?;
+    ) -> TargetsResult<Vec<&'a str>> {
+        let prepatched_image = self
+            .load_prepatched_image()
+            .map_err(|e| TargetsError::Load("prepatched".to_owned(), e))?;

        let has_kernel = match prepatched_image {
            BootImage::V0Through2(b) => !b.kernel.is_empty(),
@@ -911,7 +971,7 @@ impl BootImagePatch for PrepatchedImagePatcher {
            targets.push("init_boot");
        } else if boot_images.contains_key("boot") {
            targets.push("boot");
-        };
+        }

        Ok(targets)
    }
@@ -1084,36 +1144,90 @@ impl BootImagePatch for PrepatchedImagePatcher {
    }
 }

+fn load_boot_image(reader: &mut dyn ReadSeek) -> Result<BootImageInfo> {
+    let (header, footer, image_size) = avb::load_image(&mut *reader).map_err(Error::AvbLoad)?;
+    let Some(footer) = footer else {
+        return Err(Error::NoFooter);
+    };
+
+    let section_reader =
+        SectionReader::new(reader, 0, footer.original_image_size).map_err(Error::BootImageSeek)?;
+    let boot_image = BootImage::from_reader(section_reader).map_err(Error::BootImageLoad)?;
+
+    let info = BootImageInfo {
+        header,
+        footer,
+        image_size,
+        boot_image,
+    };
+
+    trace!("Loaded {image_size} byte boot image");
+
+    Ok(info)
+}
+
+fn save_boot_image(
+    writer: &mut dyn WriteSeek,
+    info: &mut BootImageInfo,
+    key: &RsaSigningKey,
+) -> Result<()> {
+    let AppendedDescriptorMut::Hash(descriptor) = info
+        .header
+        .appended_descriptor_mut()
+        .map_err(Error::AvbUpdate)?
+    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);
+    info.boot_image
+        .to_writer(&mut hashing_writer)
+        .map_err(Error::BootImageSave)?;
+    let (writer, context) = hashing_writer.finish();
+
+    descriptor.image_size = writer.stream_position().map_err(Error::BootImageSeek)?;
+    "sha256".clone_into(&mut descriptor.hash_algorithm);
+    descriptor.root_digest = context.finish().as_ref().to_vec();
+
+    if !info.header.public_key.is_empty() {
+        debug!("Signing boot image");
+        info.header
+            .set_algo_for_key(key)
+            .map_err(Error::AvbUpdate)?;
+        info.header.sign(key).map_err(Error::AvbUpdate)?;
+    }
+
+    avb::write_appended_image(
+        writer,
+        &info.header,
+        &mut info.footer,
+        Some(info.image_size),
+    )
+    .map_err(Error::AvbUpdate)?;
+
+    Ok(())
+}
+
 pub fn load_boot_images<'a>(
    names: &[&'a str],
    open_input: impl Fn(&str) -> io::Result<Box<dyn ReadSeek>> + Sync,
-) -> Result<HashMap<&'a str, BootImageInfo>> {
+) -> TargetsResult<HashMap<&'a str, BootImageInfo>> {
    let parent_span = Span::current();

    names
        .par_iter()
-        .map(|name| {
+        .map(|&name| {
            let _span = debug_span!(parent: &parent_span, "image", name).entered();
-            let mut reader = open_input(name)?;
+            let mut reader =
+                open_input(name).map_err(|e| TargetsError::Open(name.to_owned(), e))?;

-            let (header, footer, image_size) = avb::load_image(&mut reader)?;
-            let Some(footer) = footer else {
-                return Err(Error::NoFooter);
-            };
+            let info =
+                load_boot_image(&mut reader).map_err(|e| TargetsError::Load(name.to_owned(), e))?;

-            let section_reader = SectionReader::new(reader, 0, footer.original_image_size)?;
-            let boot_image = BootImage::from_reader(section_reader)?;
-
-            let info = BootImageInfo {
-                header,
-                footer,
-                image_size,
-                boot_image,
-            };
-
-            trace!("Loaded {image_size} byte boot image: {name}");
-
-            Ok((*name, info))
+            Ok((name, info))
        })
        .collect()
 }
@@ -1130,7 +1244,7 @@ pub fn patch_boot_images<'a>(
    key: &RsaSigningKey,
    patchers: &[Box<dyn BootImagePatch + Sync>],
    cancel_signal: &AtomicBool,
-) -> Result<HashSet<&'a str>> {
+) -> TargetsResult<HashSet<&'a str>> {
    let parent_span = Span::current();

    if patchers.is_empty() {
@@ -1149,14 +1263,14 @@ pub fn patch_boot_images<'a>(
                debug_span!(parent: &parent_span, "patcher", name = p.patcher_name()).entered();
            p.find_targets(&images, cancel_signal).and_then(|targets| {
                if targets.is_empty() {
-                    Err(Error::NoTargets(p.patcher_name()))
+                    Err(TargetsError::NoTargets(p.patcher_name()))
                } else {
                    debug!("Found patcher targets: {targets:?}");
                    Ok(targets)
                }
            })
        })
-        .collect::<Result<Vec<_>>>()?;
+        .collect::<TargetsResult<Vec<_>>>()?;

    debug!("All patcher targets: {all_targets:?}");

@@ -1178,54 +1292,22 @@ pub fn patch_boot_images<'a>(
    // Apply all patches.
    groups
        .par_iter_mut()
-        .try_for_each(|(_, (info, patchers))| -> Result<()> {
+        .try_for_each(|(&name, (info, patchers))| -> TargetsResult<()> {
            patchers.iter().try_for_each(|p| {
                let _span =
                    debug_span!(parent: &parent_span, "patcher", name = p.patcher_name()).entered();
                p.patch(&mut info.boot_image, cancel_signal)
+                    .map_err(|e| TargetsError::Patch(name.to_owned(), e))
            })
        })?;

    // Resign and write new images.
-    groups
-        .par_iter_mut()
-        .map(|(name, (info, _))| {
-            let _span = debug_span!(parent: &parent_span, "image", name).entered();
+    groups.par_iter_mut().try_for_each(|(&name, (info, _))| {
+        let _span = debug_span!(parent: &parent_span, "image", name).entered();
+        let mut writer = open_output(name).map_err(|e| TargetsError::Open(name.to_owned(), e))?;

-            let AppendedDescriptorMut::Hash(descriptor) = info.header.appended_descriptor_mut()?
-            else {
-                return Err(Error::NoHashDescriptor);
-            };
-
-            let writer = open_output(name)?;
-
-            // 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);
-            info.boot_image.to_writer(&mut hashing_writer)?;
-            let (mut writer, context) = hashing_writer.finish();
-
-            descriptor.image_size = writer.stream_position()?;
-            "sha256".clone_into(&mut descriptor.hash_algorithm);
-            descriptor.root_digest = context.finish().as_ref().to_vec();
-
-            if !info.header.public_key.is_empty() {
-                debug!("Signing boot image");
-                info.header.set_algo_for_key(key)?;
-                info.header.sign(key)?;
-            }
-
-            avb::write_appended_image(
-                writer,
-                &info.header,
-                &mut info.footer,
-                Some(info.image_size),
-            )?;
-
-            Ok(())
-        })
-        .collect::<Result<()>>()?;
+        save_boot_image(&mut writer, info, key).map_err(|e| TargetsError::Save(name.to_owned(), e))
+    })?;

    Ok(groups.keys().copied().collect())
 }
@@ -1,13 +1,13 @@
-// SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

-use std::{borrow::Cow, cmp::Ordering, io::Cursor};
+use std::{borrow::Cow, cmp::Ordering, io::Cursor, path::Path};

 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 x509_cert::{Certificate, der::asn1::BitString};
+use zip::{CompressionMethod, DateTime, ZipWriter, result::ZipError, write::SimpleFileOptions};

 use crate::{crypto, format::ota};

@@ -17,12 +17,10 @@ pub enum Error {
    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),
+    #[error("Failed to write otacerts zip")]
+    ZipWrite(#[source] ZipError),
+    #[error("Failed to write certificate to otacerts zip")]
+    CertWrite(#[source] crypto::Error),
 }

 type Result<T> = std::result::Result<T, Error>;
@@ -81,8 +79,11 @@ pub fn create_zip(cert: &Certificate, flags: OtaCertBuildFlags) -> Result<Vec<u8
        CompressionMethod::Stored
    };

-    let options = FileOptions::default().compression_method(compression_method);
-    writer.start_file("ota.x509.pem", options)?;
+    let options = SimpleFileOptions::default()
+        .last_modified_time(DateTime::default())
+        .compression_method(compression_method);
+    let name = "ota.x509.pem";
+    writer.start_file(name, options).map_err(Error::ZipWrite)?;

    let cert = if flags.is_empty() {
        Cow::Borrowed(cert)
@@ -90,7 +91,9 @@ pub fn create_zip(cert: &Certificate, flags: OtaCertBuildFlags) -> Result<Vec<u8
        let mut modified = cert.clone();

        if flags.contains(OtaCertBuildFlags::REMOVE_SIGNATURE) {
-            modified.signature = BitString::from_bytes(&[])?;
+            // An empty ASN.1 bit string is always valid.
+            modified.signature =
+                BitString::from_bytes(&[]).expect("Empty ASN.1 bit string was invalid");
        }
        if flags.contains(OtaCertBuildFlags::REMOVE_EXTENSIONS) {
            if let Some(extensions) = &mut modified.tbs_certificate.extensions {
@@ -109,9 +112,9 @@ pub fn create_zip(cert: &Certificate, flags: OtaCertBuildFlags) -> Result<Vec<u8
        Cow::Owned(modified)
    };

-    crypto::write_pem_cert(&mut writer, &cert)?;
+    crypto::write_pem_cert(Path::new(name), &mut writer, &cert).map_err(Error::CertWrite)?;

-    let raw_writer = writer.finish()?;
+    let raw_writer = writer.finish().map_err(Error::ZipWrite)?;

    Ok(raw_writer.into_inner())
 }
@@ -10,7 +10,7 @@ use std::{
 use memchr::memmem;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use thiserror::Error;
-use tracing::{debug, debug_span, trace, Span};
+use tracing::{Span, debug, debug_span, trace};
 use x509_cert::Certificate;
 use zip::ZipArchive;

@@ -21,7 +21,7 @@ use crate::{
        ota,
    },
    patch::otacert,
-    stream::{self, ReadSeekReopen, SectionReader, WriteSeekReopen},
+    stream::{self, ReadFixedSizeExt, ReadSeekReopen, SectionReader, WriteSeekReopen},
    util,
 };

@@ -35,12 +35,14 @@ pub enum Error {
    NoHashTreeDescriptor,
    #[error("{0:?} overflowed integer bounds during calculations")]
    IntOverflow(&'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),
+    #[error("Failed to update AVB header")]
+    AvbUpdate(#[source] avb::Error),
+    #[error("Failed to generate replacement otacerts zip")]
+    OtaCertZip(#[source] otacert::Error),
+    #[error("Failed to read image data")]
+    ReadData(#[source] io::Error),
+    #[error("Failed to write image data")]
+    WriteData(#[source] io::Error),
 }

 type Result<T> = std::result::Result<T, Error>;
@@ -119,11 +121,15 @@ pub fn patch_system_image(

    let parent_span = Span::current();

-    let (mut header, footer, image_size) = avb::load_image(input.reopen_boxed()?)?;
+    let (mut header, footer, image_size) =
+        avb::load_image(input.reopen_boxed().map_err(Error::ReadData)?)
+            .map_err(Error::AvbUpdate)?;
    let Some(mut footer) = footer else {
        return Err(Error::NoFooter);
    };
-    let AppendedDescriptorMut::HashTree(descriptor) = header.appended_descriptor_mut()? else {
+    let AppendedDescriptorMut::HashTree(descriptor) =
+        header.appended_descriptor_mut().map_err(Error::AvbUpdate)?
+    else {
        return Err(Error::NoHashTreeDescriptor);
    };

@@ -133,17 +139,20 @@ pub fn patch_system_image(
    let modified_ranges = (0..num_chunks)
        .into_par_iter()
        .map(|chunk| -> Result<Vec<Range<u64>>> {
-            stream::check_cancel(cancel_signal)?;
+            stream::check_cancel(cancel_signal).map_err(Error::ReadData)?;

            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 reader = input.reopen_boxed().map_err(Error::ReadData)?;
+            reader
+                .seek(SeekFrom::Start(offset))
+                .map_err(Error::ReadData)?;
+            let buf = reader
+                .read_vec_exact(size as usize)
+                .map_err(Error::ReadData)?;

-            let mut writer = output.reopen_boxed()?;
+            let mut writer = output.reopen_boxed().map_err(Error::WriteData)?;
            let mut ranges = Vec::<Range<u64>>::new();

            for eocd_offset_rel in memmem::find_iter(&buf, ota::ZIP_EOCD_MAGIC) {
@@ -155,14 +164,17 @@ pub fn patch_system_image(
                };

                let zip_size = bounds_rel.end - bounds_rel.start;
-                let new_zip = otacert::create_zip_with_size(certificate, zip_size)?;
+                let new_zip = otacert::create_zip_with_size(certificate, zip_size)
+                    .map_err(Error::OtaCertZip)?;

                let bounds = offset + bounds_rel.start as u64..offset + bounds_rel.end as u64;

-                stream::check_cancel(cancel_signal)?;
+                stream::check_cancel(cancel_signal).map_err(Error::WriteData)?;

-                writer.seek(SeekFrom::Start(bounds.start))?;
-                writer.write_all(&new_zip)?;
+                writer
+                    .seek(SeekFrom::Start(bounds.start))
+                    .map_err(Error::WriteData)?;
+                writer.write_all(&new_zip).map_err(Error::WriteData)?;

                ranges.push(bounds);
            }
@@ -178,36 +190,27 @@ pub fn patch_system_image(
        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();
+    // Only need to update the hash tree and FEC data corresponding to the
+    // modified regions.
+    let update_ranges = Some(modified_ranges.as_slice());

-        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)?;
+    descriptor
+        .update(input, output, update_ranges, cancel_signal)
+        .map_err(Error::AvbUpdate)?;

    if !header.public_key.is_empty() {
        debug!("Signing system image");
-        header.set_algo_for_key(key)?;
-        header.sign(key)?;
+        header.set_algo_for_key(key).map_err(Error::AvbUpdate)?;
+        header.sign(key).map_err(Error::AvbUpdate)?;
    }

-    let writer = output.reopen_boxed()?;
-    avb::write_appended_image(writer, &header, &mut footer, Some(image_size))?;
+    let writer = output.reopen_boxed().map_err(Error::WriteData)?;
+    avb::write_appended_image(writer, &header, &mut footer, Some(image_size))
+        .map_err(Error::AvbUpdate)?;

-    let AppendedDescriptorMut::HashTree(descriptor) = header.appended_descriptor_mut()? else {
+    let AppendedDescriptorMut::HashTree(descriptor) =
+        header.appended_descriptor_mut().map_err(Error::AvbUpdate)?
+    else {
        return Err(Error::NoHashTreeDescriptor);
    };

@@ -215,15 +218,15 @@ pub fn patch_system_image(
    let hash_tree_end = descriptor
        .tree_offset
        .checked_add(descriptor.tree_size)
-        .ok_or_else(|| Error::IntOverflow("hash_tree_end"))?;
+        .ok_or(Error::IntOverflow("hash_tree_end"))?;
    let fec_data_end = descriptor
        .fec_offset
        .checked_add(descriptor.fec_size)
-        .ok_or_else(|| Error::IntOverflow("fec_data_end"))?;
+        .ok_or(Error::IntOverflow("fec_data_end"))?;
    let header_end = footer
        .vbmeta_offset
        .checked_add(footer.vbmeta_size)
-        .ok_or_else(|| Error::IntOverflow("avb_end"))?;
+        .ok_or(Error::IntOverflow("avb_end"))?;
    let footer_start = image_size - Footer::SIZE as u64;

    let other_ranges = util::merge_overlapping(&[
@@ -1,3 +1,4 @@
+#![allow(clippy::all)]
 #![allow(clippy::nursery)]
 #![allow(clippy::pedantic)]

@@ -5,8 +5,8 @@ use std::{
    fs::File,
    io::{self, BufReader, BufWriter, Cursor, Read, Seek, SeekFrom, Write},
    sync::{
-        atomic::{AtomicBool, Ordering},
        Arc, Mutex, RwLock,
+        atomic::{AtomicBool, Ordering},
    },
 };

@@ -1,10 +1,13 @@
-// SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2023-2025 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

 use std::{
    cmp::Ordering,
-    fmt, mem,
-    ops::{Bound, Range, RangeBounds},
+    fmt::{self, Display},
+    mem,
+    ops::{
+        Bound, Range, RangeBounds, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
+    },
    path::Path,
 };

@@ -43,59 +46,118 @@ impl fmt::Debug for DebugString {
    }
 }

-/// A single bound in a range.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum IntBound<T: PrimInt> {
-    Included(T),
-    Excluded(T),
+#[derive(Clone, Hash, PartialEq, Eq)]
+pub enum AnyRange<T> {
+    Range(Range<T>),
+    RangeFrom(RangeFrom<T>),
+    RangeFull(RangeFull),
+    RangeInclusive(RangeInclusive<T>),
+    RangeTo(RangeTo<T>),
+    RangeToInclusive(RangeToInclusive<T>),
 }

-/// A bounded primitive integer range. Unlike std's range types, this is a
-/// single type that can represent open, closed, and half-open intervals.
-#[derive(Clone, Copy, Debug)]
-pub struct IntRange<T: PrimInt> {
-    pub start: IntBound<T>,
-    pub end: IntBound<T>,
-}
-
-impl<T: PrimInt> IntRange<T> {
-    /// Returns [`None`] if the range bounds cannot be represented by `T`. If
-    /// the start and end of `range` are unbounded, then it gets converted to
-    /// [`IntBound::Included`] with `N`'s minimum or maximum value.
-    pub fn new<N: PrimInt, R: RangeBounds<N>>(range: R) -> Option<Self> {
-        let start = match range.start_bound() {
-            Bound::Included(n) => IntBound::Included(T::from(*n)?),
-            Bound::Excluded(n) => IntBound::Excluded(T::from(*n)?),
-            Bound::Unbounded => IntBound::Included(T::from(N::min_value())?),
+impl<T> AnyRange<T> {
+    pub fn with_bounds(start: Bound<T>, end: Bound<T>) -> Option<Self> {
+        let result = match (start, end) {
+            (Bound::Included(s), Bound::Excluded(e)) => Self::Range(s..e),
+            (Bound::Included(s), Bound::Unbounded) => Self::RangeFrom(s..),
+            (Bound::Unbounded, Bound::Unbounded) => Self::RangeFull(..),
+            (Bound::Included(s), Bound::Included(e)) => Self::RangeInclusive(s..=e),
+            (Bound::Unbounded, Bound::Excluded(e)) => Self::RangeTo(..e),
+            (Bound::Unbounded, Bound::Included(e)) => Self::RangeToInclusive(..=e),
+            (Bound::Excluded(_), _) => return None,
        };

-        let end = match range.end_bound() {
-            Bound::Included(n) => IntBound::Included(T::from(*n)?),
-            Bound::Excluded(n) => IntBound::Excluded(T::from(*n)?),
-            Bound::Unbounded => IntBound::Included(T::from(N::max_value())?),
-        };
-
-        Some(Self { start, end })
+        Some(result)
    }
 }

-impl<T: PrimInt + fmt::Display> fmt::Display for IntRange<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.start {
-            IntBound::Included(n) => write!(f, "[{n}, ")?,
-            IntBound::Excluded(n) => write!(f, "({n}, ")?,
-        }
+impl<T: PartialOrd<T>> AnyRange<T> {
+    pub fn contains<U>(&self, item: &U) -> bool
+    where
+        T: PartialOrd<U>,
+        U: ?Sized + PartialOrd<T>,
+    {
+        <Self as RangeBounds<T>>::contains(self, item)
+    }
+}

-        match self.end {
-            IntBound::Included(n) => write!(f, "{n}]"),
-            IntBound::Excluded(n) => write!(f, "{n})"),
+impl<T: fmt::Debug> fmt::Debug for AnyRange<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Range(r) => r.fmt(f),
+            Self::RangeFrom(r) => r.fmt(f),
+            Self::RangeFull(r) => r.fmt(f),
+            Self::RangeInclusive(r) => r.fmt(f),
+            Self::RangeTo(r) => r.fmt(f),
+            Self::RangeToInclusive(r) => r.fmt(f),
        }
    }
 }

+impl<T> RangeBounds<T> for AnyRange<T> {
+    fn start_bound(&self) -> Bound<&T> {
+        match self {
+            Self::Range(r) => r.start_bound(),
+            Self::RangeFrom(r) => r.start_bound(),
+            Self::RangeFull(r) => r.start_bound(),
+            Self::RangeInclusive(r) => r.start_bound(),
+            Self::RangeTo(r) => r.start_bound(),
+            Self::RangeToInclusive(r) => r.start_bound(),
+        }
+    }
+
+    fn end_bound(&self) -> Bound<&T> {
+        match self {
+            Self::Range(r) => r.end_bound(),
+            Self::RangeFrom(r) => r.end_bound(),
+            Self::RangeFull(r) => r.end_bound(),
+            Self::RangeInclusive(r) => r.end_bound(),
+            Self::RangeTo(r) => r.end_bound(),
+            Self::RangeToInclusive(r) => r.end_bound(),
+        }
+    }
+}
+
+impl<T> From<Range<T>> for AnyRange<T> {
+    fn from(value: Range<T>) -> Self {
+        Self::Range(value)
+    }
+}
+
+impl<T> From<RangeFrom<T>> for AnyRange<T> {
+    fn from(value: RangeFrom<T>) -> Self {
+        Self::RangeFrom(value)
+    }
+}
+
+impl<T> From<RangeFull> for AnyRange<T> {
+    fn from(value: RangeFull) -> Self {
+        Self::RangeFull(value)
+    }
+}
+
+impl<T> From<RangeInclusive<T>> for AnyRange<T> {
+    fn from(value: RangeInclusive<T>) -> Self {
+        Self::RangeInclusive(value)
+    }
+}
+
+impl<T> From<RangeTo<T>> for AnyRange<T> {
+    fn from(value: RangeTo<T>) -> Self {
+        Self::RangeTo(value)
+    }
+}
+
+impl<T> From<RangeToInclusive<T>> for AnyRange<T> {
+    fn from(value: RangeToInclusive<T>) -> Self {
+        Self::RangeToInclusive(value)
+    }
+}
+
 /// A non-generic type that can represent any 64-bit or smaller primitive
 /// integer.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum LargeInt {
    Signed(i64),
    Unsigned(u64),
@@ -112,13 +174,13 @@ impl fmt::Display for LargeInt {

 /// A non-generic type that can represent any 64-bit or smaller primitive
 /// integer range.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, PartialEq, Eq)]
 pub enum LargeIntRange {
-    Signed(IntRange<i64>),
-    Unsigned(IntRange<u64>),
+    Signed(AnyRange<i64>),
+    Unsigned(AnyRange<u64>),
 }

-impl fmt::Display for LargeIntRange {
+impl fmt::Debug for LargeIntRange {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Signed(r) => r.fmt(f),
@@ -128,8 +190,8 @@ impl fmt::Display for LargeIntRange {
 }

 /// An error returned when a value is not within a specific range.
-#[derive(Clone, Copy, Debug, Error)]
-#[error("Integer value {value} not in bounds: {range}")]
+#[derive(Clone, Debug, Error)]
+#[error("Integer value {value} not in bounds: {range:?}")]
 pub struct OutOfBoundsError {
    value: LargeInt,
    range: LargeIntRange,
@@ -138,7 +200,7 @@ pub struct OutOfBoundsError {
 /// Verify that `value` is within `bounds` and then return `value` if it is.
 pub fn check_bounds<T: PrimInt>(
    value: T,
-    bounds: impl RangeBounds<T>,
+    range: impl Into<AnyRange<T>>,
 ) -> Result<T, OutOfBoundsError> {
    const {
        assert!(
@@ -147,7 +209,9 @@ pub fn check_bounds<T: PrimInt>(
        );
    }

-    if !bounds.contains(&value) {
+    let range = range.into();
+
+    if !range.contains(&value) {
        let value = if T::min_value() != T::zero() {
            LargeInt::Signed(NumCast::from(value).unwrap())
        } else {
@@ -155,9 +219,33 @@ pub fn check_bounds<T: PrimInt>(
        };

        let range = if T::min_value() != T::zero() {
-            LargeIntRange::Signed(IntRange::new(bounds).unwrap())
+            let start = match range.start_bound() {
+                Bound::Excluded(n) => Bound::Excluded(NumCast::from(*n).unwrap()),
+                Bound::Included(n) => Bound::Included(NumCast::from(*n).unwrap()),
+                Bound::Unbounded => Bound::Unbounded,
+            };
+
+            let end = match range.end_bound() {
+                Bound::Excluded(n) => Bound::Excluded(NumCast::from(*n).unwrap()),
+                Bound::Included(n) => Bound::Included(NumCast::from(*n).unwrap()),
+                Bound::Unbounded => Bound::Unbounded,
+            };
+
+            LargeIntRange::Signed(AnyRange::with_bounds(start, end).unwrap())
        } else {
-            LargeIntRange::Unsigned(IntRange::new(bounds).unwrap())
+            let start = match range.start_bound() {
+                Bound::Excluded(n) => Bound::Excluded(NumCast::from(*n).unwrap()),
+                Bound::Included(n) => Bound::Included(NumCast::from(*n).unwrap()),
+                Bound::Unbounded => Bound::Unbounded,
+            };
+
+            let end = match range.end_bound() {
+                Bound::Excluded(n) => Bound::Excluded(NumCast::from(*n).unwrap()),
+                Bound::Included(n) => Bound::Included(NumCast::from(*n).unwrap()),
+                Bound::Unbounded => Bound::Unbounded,
+            };
+
+            LargeIntRange::Unsigned(AnyRange::with_bounds(start, end).unwrap())
        };

        return Err(OutOfBoundsError { value, range });
@@ -184,9 +272,15 @@ pub fn try_cast<T: PrimInt, V: PrimInt>(value: V) -> Result<T, OutOfBoundsError>
        };

        let range = if T::min_value() != T::zero() {
-            LargeIntRange::Signed(IntRange::new::<T, _>(..).unwrap())
+            let min = NumCast::from(T::min_value()).unwrap();
+            let max = NumCast::from(T::max_value()).unwrap();
+
+            LargeIntRange::Signed((min..=max).into())
        } else {
-            LargeIntRange::Unsigned(IntRange::new::<T, _>(..).unwrap())
+            let min = NumCast::from(T::min_value()).unwrap();
+            let max = NumCast::from(T::max_value()).unwrap();
+
+            LargeIntRange::Unsigned((min..=max).into())
        };

        OutOfBoundsError { value, range }
@@ -285,23 +379,51 @@ where
        .is_ok()
 }

+pub fn join(into_iter: impl IntoIterator<Item = impl Display>, sep: &str) -> String {
+    use std::fmt::Write;
+
+    let mut result = String::new();
+
+    for (i, item) in into_iter.into_iter().enumerate() {
+        if i > 0 {
+            result.push_str(sep);
+        }
+
+        write!(result, "{item}").expect("Failed to allocate");
+    }
+
+    result
+}
+
+pub fn sort<T: Ord>(iter: impl Iterator<Item = T>) -> Vec<T> {
+    let mut items = iter.collect::<Vec<_>>();
+    items.sort();
+    items
+}
+
 #[cfg(test)]
 mod tests {
-    use assert_matches::assert_matches;
-
    use super::*;

    #[test]
-    fn test_int_range() {
-        let range = IntRange::new::<u8, _>(..).unwrap();
-        assert_eq!(range.start, IntBound::Included(u8::MIN));
-        assert_eq!(range.end, IntBound::Included(u8::MAX));
+    fn test_any_range() {
+        let range = AnyRange::with_bounds(Bound::Included(0), Bound::Excluded(1)).unwrap();
+        assert_eq!(range, AnyRange::from(0..1));

-        let range = IntRange::<i8>::new(-2i16..2i16).unwrap();
-        assert_eq!(range.start, IntBound::Included(-2));
-        assert_eq!(range.end, IntBound::Excluded(2));
+        let range = AnyRange::with_bounds(Bound::Included(0), Bound::Unbounded).unwrap();
+        assert_eq!(range, AnyRange::from(0..));

-        assert!(IntRange::<u8>::new::<u16, _>(..).is_none());
+        let range = AnyRange::<i32>::with_bounds(Bound::Unbounded, Bound::Unbounded).unwrap();
+        assert_eq!(range, AnyRange::from(..));
+
+        let range = AnyRange::with_bounds(Bound::Included(0), Bound::Included(1)).unwrap();
+        assert_eq!(range, AnyRange::from(0..=1));
+
+        let range = AnyRange::with_bounds(Bound::Unbounded, Bound::Excluded(1)).unwrap();
+        assert_eq!(range, AnyRange::from(..1));
+
+        let range = AnyRange::with_bounds(Bound::Unbounded, Bound::Included(1)).unwrap();
+        assert_eq!(range, AnyRange::from(..=1));
    }

    #[test]
@@ -313,24 +435,12 @@ mod tests {
        check_bounds(0, -1..=1).unwrap();

        let err = check_bounds(i8::MAX, 0..=0).unwrap_err();
-        assert_matches!(err.value, LargeInt::Signed(127));
-        assert_matches!(
-            err.range,
-            LargeIntRange::Signed(IntRange {
-                start: IntBound::Included(0),
-                end: IntBound::Included(0),
-            })
-        );
+        assert_eq!(err.value, LargeInt::Signed(127));
+        assert_eq!(err.range, LargeIntRange::Signed(AnyRange::from(0..=0)));

        let err = check_bounds(u8::MAX, 0..=0).unwrap_err();
-        assert_matches!(err.value, LargeInt::Unsigned(255));
-        assert_matches!(
-            err.range,
-            LargeIntRange::Unsigned(IntRange {
-                start: IntBound::Included(0),
-                end: IntBound::Included(0),
-            })
-        );
+        assert_eq!(err.value, LargeInt::Unsigned(255));
+        assert_eq!(err.range, LargeIntRange::Unsigned(AnyRange::from(0..=0)));
    }

    #[test]
@@ -339,14 +449,8 @@ mod tests {
        assert_eq!(value, 255);

        let err = try_cast::<i8, _>(256u16).unwrap_err();
-        assert_matches!(err.value, LargeInt::Unsigned(256));
-        assert_matches!(
-            err.range,
-            LargeIntRange::Signed(IntRange {
-                start: IntBound::Included(-128),
-                end: IntBound::Included(127),
-            })
-        );
+        assert_eq!(err.value, LargeInt::Unsigned(256));
+        assert_eq!(err.range, LargeIntRange::Signed(AnyRange::from(-128..=127)));
    }

    #[test]
@@ -33,11 +33,12 @@ allow = [
    "Apache-2.0",
    "Apache-2.0 WITH LLVM-exception",
    "BSD-3-Clause",
+    "bzip2-1.0.6",
    "GPL-3.0",
    "ISC",
    "MIT",
-    "OpenSSL",
    "Unicode-3.0",
+    "Zlib",
 ]

 [[licenses.clarify]]
@@ -68,6 +69,5 @@ bypass = [
 unknown-registry = "deny"
 unknown-git = "deny"
 allow-git = [
-    "https://github.com/chenxiaolong/bzip2-rs",
-    "https://github.com/chenxiaolong/zip",
+    "https://github.com/chenxiaolong/zip2",
 ]
@@ -14,20 +14,22 @@ avbroot = { path = "../avbroot" }
 clap = { version = "4.4.1", features = ["derive"] }
 ctrlc = "3.4.0"
 hex = { version = "0.4.3", features = ["serde"] }
-ring = "0.17.0"
+ring = "0.17.14"
 rsa = { version = "0.9.6", features = ["hazmat"] }
 serde = { version = "1.0.188", features = ["derive"] }
 tempfile = "3.8.0"
-toml_edit = { version = "0.22.9", features = ["serde"] }
+toml_edit = { version = "0.23.3", 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
+# https://github.com/zip-rs/zip2/pull/367
+# https://github.com/zip-rs/zip2/pull/368
+# For getting the data offset when writing new zip entries.
 [dependencies.zip]
-git = "https://github.com/chenxiaolong/zip"
-rev = "989101f9384b9e94e36e6e9e0f51908fdf98bde6"
+git = "https://github.com/chenxiaolong/zip2"
+rev = "59685f4dadbfee8cb3ea74c8fbb402b60d8137e8"
 default-features = false

 [features]
@@ -12,8 +12,10 @@ security_patch_level = "2024-01-01"
 # Google Pixel 7 Pro
 # What's unique: init_boot (boot v4) + vendor_boot (vendor v4)

-[profile.pixel_v4_gki]
-vabc_algo = "Lz4"
+[profile.pixel_v4_gki.vabc]
+# CoW v3 is used starting with the Google Pixel 9a.
+version = "V3"
+algo = { kind = "Lz4" }

 [profile.pixel_v4_gki.partitions.boot]
 avb.signed = true
@@ -49,18 +51,19 @@ data.version = "vendor_v4"
 data.ramdisks = [["otacerts", "first_stage", "dsu_key_dir"]]

 [profile.pixel_v4_gki.hashes_streaming]
-original = "c00f891f941f3dddb28966f7b07f3acea773bee104dace82b37c2d1341f09422"
-patched = "ce9d8ee97828d233809742a5d3f23aa27b042675b1935ca9e3df0592c55788fd"
+original = "ef6261cd9ebea90f036e52a46160a400c5b8f6ef24ed2469c4a1e9689987aa06"
+patched = "37fd353a766a7b9a339fbf51fa79c703e94640dc6a2c6310d79357aaefcc7ca1"

 [profile.pixel_v4_gki.hashes_seekable]
-original = "96a6c366b5de1c3b10d4d6cb4ca503c83ac4cd9ca952a965cceb041990ba7022"
-patched = "e7b4609ba7a23609211dcae143bc43f091f286fbbb3a9301c02ee25614d35deb"
+original = "8a2c717607c10dfa5483d6f9a9f37b3d978acaf8d2ea18e36544af267943e750"
+patched = "2c4734c9e1d028ee6aaf02bb416e5e173857faffd2ca067366790655147b3afa"

 # Google Pixel 6a
 # What's unique: boot (boot v4, no ramdisk) + vendor_boot (vendor v4, 2 ramdisks)

-[profile.pixel_v4_non_gki]
-vabc_algo = "Lz4"
+[profile.pixel_v4_non_gki.vabc]
+version = "V2"
+algo = { kind = "Lz4" }

 [profile.pixel_v4_non_gki.partitions.boot]
 avb.signed = true
@@ -90,18 +93,19 @@ data.version = "vendor_v4"
 data.ramdisks = [["init", "otacerts", "first_stage", "dsu_key_dir"], ["dlkm"]]

 [profile.pixel_v4_non_gki.hashes_streaming]
-original = "4d692bc777b568b0626d3c08d2e6f83f1b472db5ad903486daaec6a78d0cc26e"
-patched = "e27673e4f30933710c11d51f0e73849068cbe9bc9f54e6076bdd93f9a5c8ea0a"
+original = "630220ef813a2b4743d1941179cc9705da86ad4805f1c52341dcb38fbce3d29e"
+patched = "b725e91751fe58aed20495aecbf9b4bdc14d2799cd88dcbd58f3a3b02b3af15b"

 [profile.pixel_v4_non_gki.hashes_seekable]
-original = "ea27ecd9718c17b63400b2548680bb3cee93ce63b4fc44ff9654ca0d9c5372a8"
-patched = "3456b14e014cf565a808a9e834d9105a23539f07b2c460db19c9384aadbc3b93"
+original = "1afbe6867ded345d941098ee7c7fcf94a3df52c50ff96ab8f3a67b2ab957259a"
+patched = "4357b977249006b101002c961916f962787315a80b8608494c6a1f0cf09cecd1"

 # Google Pixel 4a 5G
 # What's unique: boot (boot v3) + vendor_boot (vendor v3)

-[profile.pixel_v3]
-vabc_algo = "Lz4"
+[profile.pixel_v3.vabc]
+version = "V2"
+algo = { kind = "Gz" }

 [profile.pixel_v3.partitions.boot]
 avb.signed = true
@@ -132,19 +136,16 @@ data.version = "vendor_v3"
 data.ramdisks = [["otacerts", "first_stage", "dsu_key_dir"]]

 [profile.pixel_v3.hashes_streaming]
-original = "f432dc7931520feb238474aa707dd5299747562ffe6129f3f763b5f11ac473ab"
-patched = "3850a2e73bd783a1ec4a70c59f37d2374e017c20df7ab4b591182b14d187c18e"
+original = "9b65037343d45211e0f9706929cba34643a9c54274d1b39740c43f45974984e0"
+patched = "fb23ab9616968b38b96d1e5e6a503154f89aebc1741e89a9e9dfd2c4d9946b05"

 [profile.pixel_v3.hashes_seekable]
-original = "7d29ecc6780953c22052a576b8dc85066c8667a875e918a786a08ff4545b47d1"
-patched = "9f6342940b7cfbeb27b0567f006bb35cbee910ef038ec535403c662d5252ca71"
+original = "e581934887dd93b8a9d9c3aa5dec1d48aa7e01bf01ac507e8c5fb256b59cbe7d"
+patched = "669a826abc6d67e7e0b1def724aa7b470461087255c65663d195df1426a355f0"

 # Google Pixel 4a
 # What's unique: boot (boot v2)

-[profile.pixel_v2]
-vabc_algo = "Gzip"
-
 [profile.pixel_v2.partitions.boot]
 avb.signed = false
 data.type = "boot"
@@ -168,9 +169,9 @@ data.type = "vbmeta"
 data.deps = ["system"]

 [profile.pixel_v2.hashes_streaming]
-original = "1b45235b58054009cc496f6c3ee11d3dc16ed5c388c861761e26a6fce83103a0"
-patched = "193b2dc70dd465d686f35c7b7f74d2cc1b06a55e48cf5c2e4df0f667e03032fc"
+original = "f10ee15c900a474cc6bbefa705f272cef42636ea096e75563d2d78f6c4327fd1"
+patched = "6929f65909037f5550a53982b71e96bdf69ab876bc5e86702c469ed601be8a9a"

 [profile.pixel_v2.hashes_seekable]
-original = "52284308fae10cbaf09ade14e92f3bbe6149751a42bff15432982fcef8d890ab"
-patched = "7ad74ac87ddcaf34938017e6149a646041d70926e31ecda93e156e9397467b3b"
+original = "4e863d251b9ff6eaa1511f9c03e9bdb8919650b2e0eaf23e33892a639edafcaf"
+patched = "9a103222e73df70a097281525546d25c850df2ae7a2ba715aa5dfbbba3f7972b"
@@ -1,14 +1,14 @@
-// SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2023-2025 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

 use std::{collections::BTreeMap, fs, path::Path};

 use anyhow::{Context, Result};
-use avbroot::format::payload::VabcAlgo;
+use avbroot::format::payload::{CowVersion, VabcAlgo};
 use serde::{Deserialize, Serialize};
 use toml_edit::DocumentMut;

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Copy, Serialize, Deserialize)]
 pub struct Sha256Hash(
    #[serde(
        serialize_with = "hex::serialize",
@@ -17,7 +17,7 @@ pub struct Sha256Hash(
    pub [u8; 32],
 );

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct OtaInfo {
    pub device: String,
@@ -29,7 +29,7 @@ pub struct OtaInfo {
    pub security_patch_level: String,
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Copy, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Avb {
    pub signed: bool,
@@ -55,7 +55,7 @@ pub enum BootVersion {
    VendorV4,
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct BootData {
    pub version: BootVersion,
@@ -71,19 +71,19 @@ pub enum DmVerityContent {
    SystemOtacerts,
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Copy, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct DmVerityData {
    pub content: DmVerityContent,
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct VbmetaData {
    pub deps: Vec<String>,
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum Data {
    Boot(BootData),
@@ -91,30 +91,37 @@ pub enum Data {
    Vbmeta(VbmetaData),
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Copy, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Hashes {
    pub original: Sha256Hash,
    pub patched: Sha256Hash,
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Partition {
    pub avb: Avb,
    pub data: Data,
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Copy, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct VabcSettings {
+    pub version: CowVersion,
+    pub algo: VabcAlgo,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Profile {
-    pub vabc_algo: Option<VabcAlgo>,
+    pub vabc: Option<VabcSettings>,
    pub partitions: BTreeMap<String, Partition>,
    pub hashes_streaming: Hashes,
    pub hashes_seekable: Hashes,
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Config {
    pub ota_info: OtaInfo,
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2023-2024 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2023-2025 Andrew Gunnerson
 // SPDX-FileCopyrightText: 2023 Pascal Roeleven
 // SPDX-License-Identifier: GPL-3.0-only

@@ -14,12 +14,12 @@ use std::{
    path::{Path, PathBuf},
    slice,
    sync::{
-        atomic::{AtomicBool, Ordering},
        Arc,
+        atomic::{AtomicBool, Ordering},
    },
 };

-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{Context, Result, anyhow, bail};
 use avbroot::{
    cli::ota::{ExtractCli, PatchCli, VerifyCli},
    crypto::{self, PassphraseSource, RsaSigningKey},
@@ -36,11 +36,12 @@ use avbroot::{
        cpio::{self, CpioEntry, CpioEntryData},
        ota::{self, SigningWriter, ZipEntry, ZipMode},
        padding,
-        payload::{self, PayloadHeader, PayloadWriter},
+        payload::{self, CowVersion, PayloadHeader, PayloadWriter, VabcParams},
+        zip::ZipWriterWrapper,
    },
    patch::otacert::{self, OtaCertBuildFlags},
    protobuf::{
-        build::tools::releasetools::{ota_metadata::OtaType, DeviceState, OtaMetadata},
+        build::tools::releasetools::{DeviceState, OtaMetadata, ota_metadata::OtaType},
        chromeos_update_engine::{
            DeltaArchiveManifest, DynamicPartitionGroup, DynamicPartitionMetadata, PartitionUpdate,
        },
@@ -48,12 +49,12 @@ use avbroot::{
    stream::{self, CountingWriter, FromReader, HashingReader, PSeekFile, Reopen, ToWriter},
 };
 use clap::Parser;
-use rsa::{rand_core::OsRng, traits::PublicKeyParts, BigUint};
+use rsa::{BigUint, rand_core::OsRng, traits::PublicKeyParts};
 use tempfile::TempDir;
 use topological_sort::TopologicalSort;
 use tracing::{info, info_span};
 use x509_cert::Certificate;
-use zip::{write::FileOptions, CompressionMethod, ZipWriter};
+use zip::{CompressionMethod, DateTime, ZipWriter, write::SimpleFileOptions};

 use crate::{
    cli::{Cli, Command, HelperCli, ListCli, PassSource, ProfileGroup, TestCli},
@@ -97,7 +98,7 @@ fn verify_hash(path: &Path, sha256: &[u8; 32], cancel_signal: &AtomicBool) -> Re
 fn append_avb(
    file: &mut PSeekFile,
    name: &str,
-    avb: &Avb,
+    avb: Avb,
    hash_tree: bool,
    ota_info: &OtaInfo,
    key_avb: &RsaSigningKey,
@@ -295,7 +296,7 @@ fn create_ramdisk(
 fn create_boot_image(
    file: &mut PSeekFile,
    name: &str,
-    avb: &Avb,
+    avb: Avb,
    boot_data: &BootData,
    ota_info: &OtaInfo,
    key_avb: &RsaSigningKey,
@@ -374,7 +375,7 @@ fn create_boot_image(
                        .ramdisks
                        .iter()
                        .map(|c_list| {
-                            if c_list.iter().any(|c| *c == RamdiskContent::Dlkm) {
+                            if c_list.contains(&RamdiskContent::Dlkm) {
                                RamdiskMeta {
                                    ramdisk_type: bootimage::VENDOR_RAMDISK_TYPE_DLKM,
                                    ramdisk_name: "dlkm".to_owned(),
@@ -422,8 +423,8 @@ fn create_boot_image(
 fn create_dm_verity_image(
    file: &mut PSeekFile,
    name: &str,
-    avb: &Avb,
-    dm_verity_data: &DmVerityData,
+    avb: Avb,
+    dm_verity_data: DmVerityData,
    ota_info: &OtaInfo,
    key_avb: &RsaSigningKey,
    cert_ota: &Certificate,
@@ -451,7 +452,7 @@ fn create_dm_verity_image(
 fn create_vbmeta_image(
    file: &mut PSeekFile,
    name: &str,
-    avb: &Avb,
+    avb: Avb,
    vbmeta_data: &VbmetaData,
    inputs: &BTreeMap<String, PSeekFile>,
    key: &RsaSigningKey,
@@ -537,7 +538,7 @@ fn create_partition_images(
                create_boot_image(
                    &mut file,
                    name,
-                    &partition.avb,
+                    partition.avb,
                    data,
                    ota_info,
                    key_avb,
@@ -550,8 +551,8 @@ fn create_partition_images(
                create_dm_verity_image(
                    &mut file,
                    name,
-                    &partition.avb,
-                    data,
+                    partition.avb,
+                    *data,
                    ota_info,
                    key_avb,
                    cert_ota,
@@ -560,7 +561,7 @@ fn create_partition_images(
                .with_context(|| format!("Failed to create dm-verity image: {name}"))?;
            }
            Data::Vbmeta(data) => {
-                create_vbmeta_image(&mut file, name, &partition.avb, data, &files, key_avb)
+                create_vbmeta_image(&mut file, name, partition.avb, data, &files, key_avb)
                    .with_context(|| format!("Failed to create vbmeta image: {name}"))?;
            }
        }
@@ -580,6 +581,8 @@ fn create_payload(
    key_ota: &RsaSigningKey,
    cancel_signal: &AtomicBool,
 ) -> Result<(String, u64)> {
+    const COMPRESSION_FACTOR: u32 = 64 * 1024;
+
    let dynamic_partitions_names = partitions
        .iter()
        .filter(|(_, p)| matches!(&p.data, Data::DmVerity(_)))
@@ -594,17 +597,23 @@ fn create_payload(
            .map(PSeekFile::new)
            .with_context(|| format!("Failed to create temp file for: {name}"))?;

-        let vabc_algo = if dynamic_partitions_names.contains(name) {
-            profile.vabc_algo
+        let vabc_params = if dynamic_partitions_names.contains(name) {
+            profile.vabc.map(|v| VabcParams {
+                version: v.version,
+                algo: v.algo,
+                compression_factor: COMPRESSION_FACTOR,
+            })
        } else {
            None
        };

        let (partition_info, operations, cow_estimate) =
-            payload::compress_image(file, &writer, name, 4096, vabc_algo, cancel_signal)?;
+            payload::compress_image(file, &writer, name, 4096, vabc_params, cancel_signal)?;

        compressed.insert(name, writer);

+        let is_v3 = profile.vabc.is_some_and(|e| e.version == CowVersion::V3);
+
        payload_partitions.push(PartitionUpdate {
            partition_name: name.clone(),
            run_postinstall: None,
@@ -624,8 +633,8 @@ fn create_payload(
            fec_roots: None,
            version: None,
            merge_operations: vec![],
-            estimate_cow_size: cow_estimate,
-            estimate_op_count_max: None,
+            estimate_cow_size: cow_estimate.map(|e| e.size),
+            estimate_op_count_max: cow_estimate.and_then(|e| is_v3.then_some(e.num_ops)),
        });
    }

@@ -645,11 +654,16 @@ fn create_payload(
                    partition_names: dynamic_partitions_names,
                }],
                snapshot_enabled: Some(true),
-                vabc_enabled: Some(true),
-                vabc_compression_param: profile.vabc_algo.map(|a| a.to_string()),
-                cow_version: Some(2),
+                // Everything below is meant to be unset if VABC is not
+                // supported.
+                vabc_enabled: profile.vabc.map(|_| true),
+                vabc_compression_param: profile.vabc.map(|v| v.algo.to_string()),
+                cow_version: profile.vabc.map(|v| match v.version {
+                    CowVersion::V2 => 2,
+                    CowVersion::V3 => 3,
+                }),
                vabc_feature_set: None,
-                compression_factor: None,
+                compression_factor: profile.vabc.map(|_| COMPRESSION_FACTOR.into()),
            }),
            partial_update: None,
            apex_info: vec![],
@@ -728,14 +742,15 @@ fn create_ota(
    let mut zip_writer = match zip_mode {
        ZipMode::Streaming => {
            let signing_writer = SigningWriter::new_streaming(raw_writer);
-            ZipWriter::new_streaming(signing_writer)
+            ZipWriterWrapper::new_streaming(signing_writer)
        }
        ZipMode::Seekable => {
            let signing_writer = SigningWriter::new_seekable(raw_writer);
-            ZipWriter::new(signing_writer)
+            ZipWriterWrapper::new_seekable(signing_writer)
        }
    };
-    let options = FileOptions::default()
+    let options = SimpleFileOptions::default()
+        .last_modified_time(DateTime::default())
        .compression_method(CompressionMethod::Stored)
        .large_file(false);

@@ -745,17 +760,14 @@ fn create_ota(

    for path in [ota::PATH_OTACERT, ota::PATH_PAYLOAD, ota::PATH_PROPERTIES] {
        // All remaining entries are written immediately.
-        zip_writer
-            .start_file_with_extra_data(path, options)
-            .with_context(|| format!("Failed to begin new zip entry: {path}"))?;
        let offset = zip_writer
-            .end_extra_data()
-            .with_context(|| format!("Failed to end new zip entry: {path}"))?;
+            .start_file(path, options)
+            .with_context(|| format!("Failed to begin new zip entry: {path}"))?;
        let mut writer = CountingWriter::new(&mut zip_writer);

        match path {
            ota::PATH_OTACERT => {
-                crypto::write_pem_cert(&mut writer, cert_ota)
+                crypto::write_pem_cert(Path::new(path), &mut writer, cert_ota)
                    .with_context(|| format!("Failed to write entry: {path}"))?;
            }
            ota::PATH_PAYLOAD => {
@@ -785,7 +797,7 @@ fn create_ota(
        let size = writer.stream_position()?;

        entries.push(ZipEntry {
-            name: path.to_owned(),
+            path: path.to_owned(),
            offset,
            size,
        });
@@ -851,6 +863,7 @@ fn create_fake_magisk(output: &Path) -> Result<()> {
    let raw_writer =
        File::create(output).with_context(|| format!("Failed to open for writing: {output:?}"))?;
    let mut zip_writer = ZipWriter::new(raw_writer);
+    let options = SimpleFileOptions::default().last_modified_time(DateTime::default());

    for path in [
        "assets/stub.apk",
@@ -867,12 +880,12 @@ fn create_fake_magisk(output: &Path) -> Result<()> {
        "lib/x86_64/libmagisk64.so",
        "lib/x86_64/libmagiskinit.so",
    ] {
-        zip_writer.start_file(path, FileOptions::default())?;
+        zip_writer.start_file(path, options)?;
        write!(zip_writer, "dummy contents for {path}")?;
    }

    // avbroot looks for the version number in this file.
-    zip_writer.start_file("assets/util_functions.sh", FileOptions::default())?;
+    zip_writer.start_file("assets/util_functions.sh", options)?;
    zip_writer.write_all(b"MAGISK_VER_CODE=27000\n")?;

    Ok(())
@@ -1127,7 +1140,7 @@ fn clean_boot_image_certs(path: &Path, cancel_signal: &AtomicBool) -> Result<()>
        .iter_mut()
        .find(|e| e.path == b"system/etc/security/otacerts.zip")
    {
-        let mut zip_writer = ZipWriter::new(Cursor::new(Vec::new()));
+        let zip_writer = ZipWriter::new(Cursor::new(Vec::new()));
        let empty_zip = zip_writer.finish()?.into_inner();

        entry.data = CpioEntryData::Data(empty_zip);
@@ -1189,6 +1202,7 @@ fn test_subcommand(cli: &TestCli, cancel_signal: &AtomicBool) -> Result<()> {
        Some(_) => None,
        None => Some(TempDir::new().context("Failed to create temp directory")?),
    };
+    #[allow(clippy::option_if_let_else)]
    let work_dir = match &cli.config.work_dir {
        Some(w) => w.as_path(),
        None => work_temp_dir.as_ref().unwrap().path(),
@@ -1220,8 +1234,9 @@ fn test_subcommand(cli: &TestCli, cancel_signal: &AtomicBool) -> Result<()> {
        ] {
            let _span = info_span!("profile", name, %zip_mode).entered();

-            // Can't used NamedTempFile because avbroot does atomic replaces.
-            let profile_dir = work_dir.join(name);
+            // Can't use NamedTempFile because avbroot does atomic replaces.
+            let mut profile_dir = work_dir.join(name);
+            profile_dir.push(zip_mode.to_string());
            let out_original = profile_dir.join("ota.zip");
            let out_magisk = profile_dir.join("ota_magisk.zip");
            let out_prepatched = profile_dir.join("ota_prepatched.zip");
@@ -1324,7 +1339,7 @@ fn helper_mode() -> Result<()> {
    let cli = HelperCli::parse();

    let private_key_path = {
-        let parent = cli.public_key.parent().unwrap_or(Path::new("."));
+        let parent = cli.public_key.parent().unwrap_or_else(|| Path::new("."));
        let name = cli
            .public_key
            .file_name()
@@ -1398,7 +1413,10 @@ fn main() -> Result<()> {
    if env::var_os(ENV_HELPER_MODE).is_some() {
        return helper_mode();
    }
-    env::set_var(ENV_HELPER_MODE, "true");
+    // SAFETY: No multithreading at this point.
+    unsafe {
+        env::set_var(ENV_HELPER_MODE, "true");
+    }

    // Set up a cancel signal so we can properly clean up any temporary files.
    let cancel_signal = Arc::new(AtomicBool::new(false));
@@ -12,7 +12,7 @@ publish = false
 anyhow = "1.0.75"
 clap = { version = "4.4.1", features = ["derive"] }
 regex = { version = "1.9.4", default-features = false, features = ["perf", "std"] }
-toml_edit = "0.22.9"
+toml_edit = "0.23.3"

 [lints]
 workspace = true
@@ -1,15 +1,15 @@
-// SPDX-FileCopyrightText: 2023 Andrew Gunnerson
+// SPDX-FileCopyrightText: 2023-2025 Andrew Gunnerson
 // SPDX-License-Identifier: GPL-3.0-only

 use std::{
    collections::BTreeMap,
-    fmt,
+    fmt::{self, Write as _},
    fs::{self, File},
    io::{BufRead, BufReader},
    path::Path,
 };

-use anyhow::{anyhow, bail, Result};
+use anyhow::{Result, anyhow, bail};
 use regex::Regex;

 use crate::WORKSPACE_DIR;
@@ -108,7 +108,7 @@ fn update_changelog_links(path: &Path, base_url: &str) -> Result<()> {
    }

    for (link_ref, link) in links {
-        result.push_str(&format!("{link_ref}: {link}\n"));
+        let _ = writeln!(result, "{link_ref}: {link}");
    }

    fs::write(path, result)?;
@@ -7,9 +7,9 @@ use std::{
    path::Path,
 };

-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use clap::Parser;
-use toml_edit::{value, DocumentMut};
+use toml_edit::{DocumentMut, value};

 use crate::WORKSPACE_DIR;