Merkle Trees are used in various places in the Fuchsia ecosystem, including the FAR Archive Format, the Blob Storage Filesystem, and the Package Manager.

In Zircon `zx-verity`

provides an API for application components to read data from local storage. When retrieving data the integrity of the data is verified and causing reads to fail when the data has been modified or corrupted. zx-verity is based on a Merkle Tree, and is derived from a similar system in Chrome OS.

All of these implementations share the algorithm documented herein.

- Block size: 8kb, 0 padded.
- Root digest size: 32 bytes.
- Hash algorithm: SHA-256.
- Block digest computation: SHA-256((offset | level) + input length + data)

The merkle tree contains levels. A level is a row of the tree, starting at 0 and counting upward. Level 0 represents the level that contains hashes of chunks of the input stream.

Each level contains a number of hashes of the previous level. The hashes within a level are computed from 8kb blocks from the previous level (or data, if level 0), prepended with a block identity.

A block identity is the binary OR of the starting byte index of the block within the current level, and the current level index.

- Initialize the level with an index, an offset starting at 0, and an empty list of hashes.
- For each 8kb (or remainder of) of input, compute the next block identity by taking the binary OR of the the level index and the current offset.
- Init a SHA-256 digest, append to it the identity, the length of the input, the input, and if the input is shorter than 8kb, a pad of 0 up to 8kb.
- Append the output of the digest to the levels list of hashes. Increment the offset by 32.
- Repeat 1-4 until all input is consumed.
- If the length of hashes is 32, finish.
- If the length of hashes is not 8kb aligned, 0 fill up to an 8kb alignment and compute more levels until there is a root level containing a single 32 byte digest.

Compute level 0 with the input data. Construct and compute subsequent levels using the previous level hashes as input data, until a level hashes contains exactly 32 bytes. This last level contains the root digest of the merkle tree.

As a special case, when there is no input data, implementations may need to handle the calculation independently. The digest of the empty input is simply the SHA-256 of 8 0 bytes, the block identity of a single 0 length block.

- The empty digest:
`15ec7bf0b50732b49f8228e07d24365338f9e3ab994b00af08e5a3bffe55fd8b`

- 8192 bytes of
`0xff`

- “oneblock”`68d131bc271f9c192d4f6dcd8fe61bef90004856da19d0f2f514a7f4098b0737`

- 65536 bytes of
`0xff`

- “small”`f75f59a944d2433bc6830ec243bfefa457704d2aed12f30539cd4f18bf1d62cf`

- 2105344 bytes of
`0xff`

- “large”`7d75dfb18bfd48e03b5be4e8e9aeea2f89880cb81c1551df855e0d0a0cc59a67`

- 2109440 bytes of
`0xff`

- “unaligned”`7577266aa98ce587922fdc668c186e27f3c742fb1b732737153b70ae46973e43`

`0xff0080`

bytes filled with repetitions of`0xff0080`

- “fuchsia”`2feb488cffc976061998ac90ce7292241dfa86883c0edc279433b5c4370d0f30`