From 494000b9164fcaf0b61524cf89631560a10cc878 Mon Sep 17 00:00:00 2001 From: Steve Myers Date: Sat, 23 Nov 2024 17:35:59 -0600 Subject: [PATCH] blog: add 2024 Q4 code audit --- docs/_blog/2024_q4_code_audit.md | 17 + docs/audits/2024_q4/bdk_audit_report.md | 1031 +++++++++++++++++ .../2024_q4/bdk_audit_test_coverage.png | Bin 0 -> 95677 bytes 3 files changed, 1048 insertions(+) create mode 100644 docs/_blog/2024_q4_code_audit.md create mode 100644 docs/audits/2024_q4/bdk_audit_report.md create mode 100644 docs/audits/2024_q4/bdk_audit_test_coverage.png diff --git a/docs/_blog/2024_q4_code_audit.md b/docs/_blog/2024_q4_code_audit.md new file mode 100644 index 0000000000..68417ad3ca --- /dev/null +++ b/docs/_blog/2024_q4_code_audit.md @@ -0,0 +1,17 @@ +--- +title: "2024 Q4 Code Audit" +description: "2024 Code Audit by Wizardsardine" +authors: + - Steve Myers +date: "2024-12-03" +tags: ["BDK", "project"] +draft: false +--- + +A heartfelt thank you to our friends at [Spiral](https://spiral.xyz/) for sponsoring a code audit of the current `bdk` 1.0.0-beta Rust codebase. The effort was led by [Antoine Poinsot](https://github.com/darosior) from [Wizardsardine](https://wizardsardine.com/), who did a fantastic job providing insightful and actionable recommendations for the BDK team. You can find the full report [here](https://gist.github.com/darosior/4aeb9512d7f1ac7666abc317d6f9453b). + +As outlined in Antoine's report, the audit's primary focus was to review the core components that constitute a BDK-based wallet, particularly the new methods for managing and synchronizing chain data. The audit scope included some reasonable simplifying assumptions, such as trusting that the Electrum or Esplora servers to which BDK wallets connect are not malicious. However, Antoine went above and beyond and also recommended a few simple fixes we can do to guard against certain types of bad server behavior. + +While no critical defects were identified, a potential denial of service/performance issue was uncovered, along with opportunities to improve the code's fault tolerance and API documentation. The team is currently addressing the performance issue, as well as some of the more straightforward recommendations. All suggested improvements have been [added to our issues backlog](https://github.com/bitcoindevkit/bdk/issues?q=is%3Aissue+label%3Aaudit) for future releases. + +If you are a user or potential user of BDK, or a Bitcoin Rust developer, we would love to hear your feedback. Please reach out on the [BDK Discord](https://discord.gg/dstn4dQ) or comment on individual [GitHub issues](https://github.com/bitcoindevkit/bdk/issues?q=is%3Aissue+is%3Aopen). As a fully free and open-source project, the BDK team relies on YOU our community of users and contributors to help us deliver the best Bitcoin wallet library possible. \ No newline at end of file diff --git a/docs/audits/2024_q4/bdk_audit_report.md b/docs/audits/2024_q4/bdk_audit_report.md new file mode 100644 index 0000000000..da4cffd490 --- /dev/null +++ b/docs/audits/2024_q4/bdk_audit_report.md @@ -0,0 +1,1031 @@ +--- +title: "Wizardsardine BDK Audit Report" +description: "2024 Code Audit by Wizardsardine" +authors: + - Antoine Poinsot +date: "2024-10-21" +tags: ["BDK", "project"] +draft: true +--- + +[Spiral](https://spiral.xyz/) hired [Wizardsardine](https://wizardsardine.com/) for 10 days to perform +a (partial) audit of the [BDK wallet library](https://github.com/bitcoindevkit/bdk) (at tag +`v1.0.0-beta.2`). + +This audit was focused on the `bdk_chain`, `bdk_electrum`/`bdk_esplora` and `bdk_wallet` crates with +the intention to look for defects which could lead to returning incorrect information to a user +about their wallet or to prevent them from reliably using it under realistic circumstances (e.g. a +crash bug which can be triggered by a third party, or a significant slowdown in performing some +operations). + +A threat model I considered interesting for the purpose of this review was that of a server-side +software using BDK to perform Bitcoin tasks and serving its clients through a public API. In this +fairly standard scenario, a crash internal to the BDK library could lead to a Denial of Service for +all users of the application. + +From my discussion with the developers of the library, remote Esplora and Electrum servers are +trusted sources of information about the Bitcoin network. A rogue server providing invalid +information is therefore considered out of scope. Likewise, I didn't focus on finding crashes that +can be triggered by a malicious server (although I did report some). + +I have used test coverage reports to guide me throughout this audit. I join to this document a full +report of the code coverage of all the unit tests from the library. It's available +[here](https://darosior.github.io/bdk_coverage/unit_tests/coverage/home/darosior/projects/bdk/crates/index.html). + +![image](bdk_audit_test_coverage.png) + +We conducted this audit in three parts. First I carefully inspected the code of each module under +review for logic errors, leveraging the unit test framework. I did not find it necessary to write +and share new unit tests (besides some reproductions, see the details section) since the reviewed +module already have extensive unit test coverage as can be observed from the above report. A second +part of the audit was undertaken by @Pythcoiner (who works with us at Wizardsardine on Liana's QA) +and consisted of manually testing the library, looking for surprising behaviour in corner cases. +Finally, I wrote two fuzz targets (code is shared along with this report): +- The first one exercised the `Wallet` interface under a number of conditions with data generated by + the fuzzer (apply an update, roundtrip to persistence, or create a transaction, then repeat). It's + more superfluous as it's general, but is a good way to assert some general invariants (for + instance "the balance is the same before and after round-tripping to persistence") and checking + nothing crashes if we just throw random data at the high-level interface. +- The second one specifically targets the reorg logic in `bdk_chain` (the `merge_chains` function). + Based on the fuzzer's input it creates an initial chain and an updated chain, merges the two, then + asserts some invariants (it does connect when it should, etc). + +BDK is a large project and 10 days is not enough to perform a comprehensive review of the library. +Only the 4 modules I focused on already amount to 15,777 lines of code (without accounting for the +unit test directories). Here is a list of things I did not have time to do and think would be +beneficial: +- More fuzz coverage. I only started writing a couple fuzz targets after having reviewed the 15k + lines of sources. These targets can be improved, asserting more invariants and exercising more + logic. New, more specific, targets may also be introduced. As BDK currently has no fuzz coverage, + and its modular architecture makes it adapted to fuzzing, this is probably the highest value thing + to implement to further give assurance in the quality of the library. +- Deeper review of the unit tests. I only skimmed through those, allocating my remaining time to + writing the fuzz targets instead. Despite the good coverage, reading carefully the unit tests is a + good way to stumble upon / think of edge cases which aren't (completely) tested. +- Review of the persistence (in particular the SQLite implementation) and the coin selection + modules. The findings reported in this area are due to my fuzzer, I did not carefully review the + logic there. +- Benchmark the transaction graph reconciliation with the canonical chain in the presence of large + unconfirmed transaction chains and/or high number of conflicts. + +Overall, I found the code I reviewed to be of high quality and adequately tested. The library is +also elegantly architectured. + + +## bdk_chain + +The "anchors" model elegantly avoids potential consistency issues when syncing: even if the chain +tip of the source changes while you're querying it, you always have the individual anchors from +which you can reconcile. The downside, of course, is that for every operation on the graph you have +to reconcile which transactions are "canonical" for a given chain. + +The cost of checking a transaction's confirmation status should stay manageable as long as the chain +source isn't sending maliciously crafted anchors (since it could effectively lead +`try_get_chain_position` to iterate across the whole chain for each transaction and every single of +its ancestors and descendants, which can quickly blowup for a transaction chain). However, the check +of whether an output is spent is `O(n^2)`. Typically under the threat model of BDK running on a +server and serving an API to multiple clients, a single client could DoS the server (thereby +preventing all other users from accessing information about their wallet) by creating a bunch of +RBF's for an output it owns. See below for details. + +The `seen_at` mechanism makes sense, but it being a timestamp is imperfect as two conflicting +transactions might share the same `last_seen` value. A timestamp is certainly a useful information +to store and provide to users, but for the purpose of ordering conflicting unconfirmed transactions +a counter may be preferable. Clients could choose to use `last_seen` as a counter, but some +functions in the library assume it is a timestamp (for instance `TxGraph::apply_update()` inserts +the current time as `seen_at` when applying the update). + +In the `keychain_txout` module documentation, you advise to only check revealed scriptpubkeys for +regular sync. This is fragile as it only guarantees not to miss deposits for single-person +descriptors where a single wallet is used. The documentation currently presents lookahead scripts as +specific to full scans when recovering a wallet. It'd be preferable to advise using a lookahead at +all times, even if only a smaller one for regular syncs. + +I haven't thought about a realistic scenario in which this could be an issue, but note two different +descriptor templates (as in actual descriptors are differing, not only the xpubs inside) can have +the same descriptor ID. For instance `multi(1,A,B)` and `sortedmulti(1,B,A)`. + +### Security risks + +- For a given outpoint `try_get_chain_spend` will iterate over all its (conflicting) spends and call + `try_get_chain_position` for each of those, which will in turn iterate over all its conflicts + (since the transaction itself is part of the `unconfirmed_ancestors_tx` iterator) until one is + confirmed or has a higher `seen_at`. As an example, let's take a confirmed outpoint spent by a + transaction RBF'd 100 times. For each version of the spending transaction `try_get_chain_spend` + will call `try_get_chain_position`, which will iterate over its ancestors using + `TxAncestors::new_include_root()`, which includes itself. In this example the iterator will only + contain the spend itself. Then `walk_conflicts` will be called on the spend, which will return an + iterator over all the 99 other spends of the original outpoint from which we'll only break after + encountering a transaction with a higher `seen_at`. Since we'll do that for each of the 100 + spends, assuming the `seen_at` values of the transaction are perfectly ordered, we'll perform + `99*100/2 = 4950` iterations (99 for the first one, 98 for the second one, and so on down to 1 for + the last one). This issue is further exacerbated by how: + 1. each spend can spend more than one output. If each is spending a 100 outputs, that's 49'500 + iterations in total. + 2. even after one of the conflicting spends gets mined this might still be an issue, depending on + the position of the confirmed spend in the `spends` map (which is indexed by outpoint, so can + be gamed). + 3. current RBF rules requiring a feerate increase can be bypassed: + https://github.com/bitcoin/bitcoin/pull/23121, which largely reduces the cost of an attack + exploiting this. +- In `apply_changeset` the derivation index aren't sanitized. It could include a hardened index, + which would break an invariant and trigger an internal crash. + +### Quirks + +- The return value of `self._check_changeset_is_applied(&changeset)` in `LocalChain::apply_update` + isn't checked. I think you want it inside a `debug_assert!` like the other occurrences. +- `list_canonical_txs` is missing the `Error = Infallible` type constraint. +- In `try_get_chain_position` the logic to filter out confirmed ancestors was copy-pasted for the + descendants (you can see as the comment wasn't updated, it still mentions "We're filtering the + ancestors"). But if a confirmed descendant is encountered it means the transaction is confirmed + too, so it could shortcut? + +### Nits + +- No need to re-define `rust-bitcoin`'s `COINBASE_MATURITY`. +- `CheckPoint`'s doc comment could mention it's guaranteed to always have at least one element, + since it's an invariant relied upon across the project. +- `merge_chains`'s doc comment is outdated. +- The doc comment for the `rusqlite_impl` module is a placeholder: `//! Module for stuff`. +- Like `walk_ancestors`, `walk_descendants`'s doc could mention it excludes the root tx from the + iterator. +- In `SpkIterator::next()`, `derived_descriptor`'s descriptor is unwrapped because "the descriptor + cannot need hardened derivation". It'd be better to have "we check it's never hardened in the + constructor" as it's a stronger invariant. (Mentioning as I initially missed it was also checked + in `SpkIterator::new_with_range()` by re-assigning to `end` the minimum between `end` and + `BIP32_MAX_INDEX`.) +- For `SpkTxOutIndex::outputs_in_range()` the excluded bounds aren't tested, you can just change + them to whatever and no test would fail. + + +## `bdk_esplora` + +One thing I initially intended to look for was consistency issues in `sync` and `full_scan` if the +server's tip change while you are making requests (for instance getting duplicate transactions in +case a block is reorg'd). But this is not an issue in the BDK model which uses individual anchors +per transaction. + +It's surprising that `seen_ats` doesn't get populated in the sync result. The documentation could at +least mention the returned `TxUpdate` will always have an empty `seen_ats` mapping and populating +that is left as a responsibility of the caller. + +### Security risks + +- Out of scope, but a rogue Esplora server can make an application crash by returning an empty list + of blocks to a `/blocks` request, as `latest_blocks` is assumed to never be empty in + `fetch_block()`. + +### Nits + +- Top-level documentation states "A `stop_gap` of 0 will be treated as a `stop_gap` of 1" but it's + not the case. After making `parallel_requests` requests in the first iteration of the loop, even + if all indexes were detected as active, `gap_limit_reached` would be set to `true` if `stop_gap` + is set to `0`. Not only would it not be the case if `stop_gap` was set to 1, but it's also + surprising to stop whereas there was no gap. + +## `bdk_electrum` + +The implementation assumes the remote server would not purposefully try to crash us nor serve us +invalid data. It should be possible to protect from malicious servers by syncing the best header +chain and validating Merkle proofs for confirmed transactions against it. Syncing the header chain +is itself prone to DoS if naïvely done through the P2P protocol (cf [this Bitcoin Core security +advisory](https://bitcoincore.org/en/2024/09/18/disclose-headers-oom/)). The fix implemented in +Bitcoin Core introduces complexity which may not be required for a wallet library, where just using +recent checkpoints would be more reasonable than for a full node. Alternatively, BDK could leverage +the Electrum peer discovery protocol and assume at least one of N queried servers provides it the most +work chain. As Electrum permits to query the header chain backward from the tip it should also be +possible to verify it without resorting to something akin to Bitcoin Core's pre-sync. + +Checking Merkle proof of transactions against the most work chain would make it possible to protect +from a malicious server trivially crashing the wallet or providing invalid data for free. This still +leaves the door open to being crashed using unconfirmed transaction data, which may only be solved +by limiting the number of unconfirmed transactions stored in the graph. In any case the server is +trusted with the validity of unconfirmed transactions data. + +As advised I did not spend too much time looking for remote crash bugs from the part of the Electrum +server, as it can always do that right now by sending a ton of data to be stored. Though I did +mention those I came across. + +### Security risks + +- Transaction Merkle proof verification does not check the Merkle proof for the coinbase in addition + to get the depth of the Merkle tree. This enables an attack by which an attacker can fake a + deeply-confirmed payment to a BDK wallet for the cost of bruteforcing around 70 bits (maybe less). + See + https://delvingbitcoin.org/t/great-consensus-cleanup-revival/710#merkle-tree-attacks-using-64-bytes-transactions-8. + This would require the Electrum server to be malicious as well. +- An Electrum server can trigger a panic in `populate_with_txids` by returning a transaction with no + output to a `transaction.get` call. + +### Quirks / Bugs + +- `fetch_prev_txout` should not try to query the prevouts of coinbase transactions, this will query + a `000...000` transaction to the Electrum server which will return an error and will make the + overall `sync()` fail. + +### Nits + +- You cache transactions but not their anchor's validity, which significantly reduces the gains from + caching as you need to make a request for Merkle proofs anyways. +- In `populate_with_txids` you state "because of restrictions of the Electrum API, we have to use + the `script_get_history` call to get confirmation status of our transaction". But Electrum + supports a `verbose` parameter to the `transaction.get` call, which appears to return the number + of confirmations of the transaction. See https://electrumx-spesmilo.readthedocs.io/en/latest/protocol-methods.html#blockchain-transaction-get + + +## `bdk_wallet` + +TL;DR: untrusted inputs (PSBT, amounts) provided to the public interface should be sanitized before +being used internally. + +### Security risks + +- The library will crash on descriptors without an address form, as it assumes it can always get it + but doesn't check it. For instance importing a `raw()` descriptor would make BDK crash internally. + This can be an issue for a server providing an API to register descriptors and monitor them using + BDK. +- All across the crate, unchecked arithmetic is used. The unchecked arithmetic rountines of + rust-bitcoin's `Amount` type will panic if the result of an operation overflows. This is an issue + for externally-provided values, such as for instance recipient amounts or fees. +- `Wallet::sign`, which could presumably be called with externally-provided PSBTs, calls + `update_psbt_with_descriptor` which assumes multiple invariants on the PSBT. The PSBT is not + sanity checked beforehand and would therefore make it possible to crash an application using the + library and exposing a sign endpoint. The invariants are assumed in `PsbtUtils::get_utxo_for`'s + implementation for `Psbt` (called from `update_psbt_with_descriptor`): it assumes the inner tx has + at least as many inputs as the PSBT and it assumes that the transaction provided in the PSBT + input's `non_witness_utxo` field has does contain the output index referenced by the inner + transaction. +- In `build_fee_bump` when getting the original utxos the function assumes the previous + transaction's output list does contain the output referred by each input of the transaction to be + bumped. It will crash otherwise. Although it generally holds, it doesn't necessarily. +- In `get_psbt_input`, the size of the previous transaction's output vector is similarly assumed, + which could lead to a crash when creating a transaction. +- In the `signer` module, the previous transaction contained in a PSBT input is not validated + against the outpoint for legacy and segwit v0 transactions. This is checked when creating a + transaction, but this module may be used to sign a PSBT as an external participant. +- The descriptor is not checked in `Wallet::create_with_params` (it only is in `load_with_params`), + allowing to create a `Wallet` with an incompatible (multipath, hardened steps, ..) descriptor + which would break a number of invariants during usage of the `Wallet`. +- In the transaction builder, `current_height` will crash on an invalid absolute locktime height. If + `None` was provided by the caller, this would let a remote chain source crash us by providing at + invalid tip height. But that's considered out of scope. Although it seems unlikely that this + parameter would be exposed to a third party, it's safer to only panic on inconsistent internal + state and not on externally provided inputs. +- Out of scope since we trust our chain source but the transaction creation code will crash if the + tip's height is not less than 500'000'000 (`LockTime::from_height` L1305), which could allow a + remote Electrum or Esplora server to crash us. + +### Quirks / Bugs + +- You consider unconfirmed coins when creating a transaction, but you do not account for the size of + their ancestors. This can lead to largely underestimating the fees for the transaction, and to + reporting a largely overestimated feerate to the user. +- In `Wallet::load_with_params`, `change_signers` is not set when `check_change_descriptor` is + `None`. +- You create transactions with nVersion set to 1 if no CSV. Nowadays >85% of transactions on the + network are version 2, I think it would make you stick out. It's likely the <15% of version 1 + transactions are created by old wallet. It's likely that BDK would be used with newer output + types. If these two assumptions hold, it would make it possible to identify a BDK transaction with + near certainty. Version 2 is also necessary if you want to eventually implement BIP 326 + nSequence-based anti-fee-sniping. +- In `create_tx`, after `fee_amount` is used in coin selection it gets assigned new values which end + up never being used. +- RBF signalling should probably be turned on by default. First because it could be misinterpreted + by users as "this way my transaction has significantly less chances of getting replaced" while + most of the network hashrate runs with full-RBF and from 28.0 it's also the Bitcoin Core default + (nodes will relay replacements for transaction not explicitly signalling RBF). It is also a + fingerprint as around 70% of transactions signal RBF right now, and this number is growing. +- In `finalize_psbt`, the code at lines 1910-1911 assumes a PSBT input corresponds to the inner + transaction input. This only holds because it was checked 50 lines before (L1862). It'd be more + careful to use `get(n).ok_or(...)?` to access the input around line 1910 too, in case the check 50 + lines earlier was removed or updated. This is the kind of bug that could slip through review as + it'd affect code outside the diff, and could realistically cause an issue as a PSBT is often + externally provided: it can be reasonably anticipated to be turned into a remote crasher for some + applications. +- `Utxo::txout()` will crash if `prev_tx.output` does not contain its prevout. The only place where + a `Utxo::Foreign` is created without checking whether the outpoint's index is within the bounds of + `prev_tx.output` is in `build_fee_bump`, where BDK would have crashed earlier (L1653) if it wasn't + the case. +- In the SQLite persistence the foreign key constraint from anchor to transactions is not checked. + Adding an anchor for a non-existing transaction will prevent persisting the wallet. +- The `last_seen` timestamp (`u64`) may not fit in SQLite's INTEGER (`i64`) type. This is not + checked prior to making the SQL request. + +### Nits + +- When possible to use anti fee-sniping, you always set the current height. All implementations of + anti fee-sniping I'm aware of randomize this by sometimes using a much lower height (typically 100 + less) to avoid consistently giving up the height at which a transaction was crafted. I'm not sure + how useful this randomization is, but you might want to consider it. Especially as you already + have a RNG at hand in this function. +- The doc comment for `CoinSelectionAlgorithm::coin_select` mentions a non-existing `database` + parameter. +- Consistency between descriptor network and chain genesis hash isn't checked in `load_with_params` + nor in `create_with_params`. +- In `Wallet::create_tx` when the outputs vector of the transaction is empty, you have a comment "We + have a drain_to address and the utxos we must spend (this happens, for example, when we RBF)" + which seems misleading to me. If by "when we RBF" you mean what `build_fee_bump` does, then it's + incorrect as `build_fee_bump` won't set `params.drain_to`. +- `TxBuilder::add_data` could enforce common standardness rules (max 80 bytes and at most one such + output per transaction). It would also prevent a potential panic to be triggered from within + rust-bitcoin (in `push_slice_no_opt`) if the data is too large, although I don't think it's + realistic as a request for creating a 4GiB `OP_RETURN` would probably fail before then. + + +## Fuzz targets + +These are two fuzz targets that I wrote against Libfuzzer, as integrated by +[`cargo-fuzz`](https://github.com/rust-fuzz/cargo-fuzz), for the purpose of finding issues I can +report. + +These were not written for the purpose of being shared, but I figured you may find it useful as a +starting point to integrate fuzzing in the BDK project. As such, please pardon the confusing / +debug-quality code there. + +### `bdkwallet.rs` + +```rust +#![no_main] + +use libfuzzer_sys::fuzz_target; + +use bdk_wallet::{ + bitcoin::{self, hashes::Hash, psbt::PsbtSighashType}, + chain::{BlockId, ConfirmationBlockTime, TxUpdate}, + KeychainKind, SignOptions, TxOrdering, Update as WalletUpdate, Wallet, +}; +use rusqlite::Connection; +use std::{ + cmp, + collections::{BTreeMap, BTreeSet, HashMap, VecDeque}, +}; + +// TODO: use more complicated descriptors. +const EXTERNAL_DESC: &str = "tr(xprvA1NeLXFV4y3Q3uZERyTp54EyaiRG76DcN3gXzW5bQpjt1JSTnTpi6KS4na6JsZMriWAiVcbePA9RAfNXmrfnXVJj33FvHUFgNNErYPaZE4g/122/1'/0'/0/*)"; +const INTERNAL_DESC: &str = "wpkh(xprv9y5m1SxNcjAY8DJPHqXM67ETRFwpjsacG9xGBiTBMj5A2KupsjuNJuFuFJAzoQJb7fjp3jz78TsmDmqpaTtCBzAKEuqE1NMC3Net5Ma2hY6/84'/1'/0'/1/*)"; +const NETWORK: bitcoin::Network = bitcoin::Network::Bitcoin; + +enum Action { + Update, + Persist, + TxCreate, +} + +impl Action { + pub fn from_byte(byte: u8) -> Option { + if byte == 0x00 { + Some(Self::Update) + } else if byte == 0x01 { + Some(Self::Persist) + } else if byte == 0x02 { + Some(Self::TxCreate) + } else { + None + } + } +} + +struct UniqueHash { + data: [u8; 32], +} + +impl UniqueHash { + pub fn new() -> Self { + Self { data: [0; 32] } + } + + pub fn get(&mut self) -> [u8; 32] { + for byte in self.data.iter_mut().rev() { + if *byte < u8::MAX { + *byte += 1; + break; + } + } + self.data + } + + pub fn get_block_hash(&mut self) -> bitcoin::BlockHash { + bitcoin::hash_types::BlockHash::from_byte_array(self.get()) + } + + pub fn get_txid(&mut self) -> bitcoin::Txid { + bitcoin::hash_types::Txid::from_byte_array(self.get()) + } +} + +macro_rules! next_or_return { + ($iter:expr) => { + match $iter.next() { + Some(val) => val, + None => return, + } + }; +} + +fn scale(byte: u8) -> u32 { + (byte as u32) * 0x01000000 +} + +fn scale_u64(byte: u8) -> u64 { + (byte as u64) * 0x0100000000000000 +} + +fuzz_target!(|data: &[u8]| { + let mut data_iter = data.iter(); + let mut conn = Connection::open_in_memory().unwrap(); + let mut wallet = Wallet::create(EXTERNAL_DESC, INTERNAL_DESC) + .network(NETWORK) + .create_wallet(&mut conn) + .unwrap(); + let mut unique_hash = UniqueHash::new(); + let mut unconfirmed_txids = VecDeque::new(); + + // Exercise the Wallet logic based on the fuzzer's input. + loop { + let action = if let Some(a) = Action::from_byte(*next_or_return!(data_iter)) { + a + } else { + return; + }; + + match action { + Action::Update => { + // Start with active indices. + let mut last_active_indices = BTreeMap::new(); + if next_or_return!(data_iter) & 0x01 == 0x01 { + let indices_count = *next_or_return!(data_iter) as u32; + let index_start = scale(*next_or_return!(data_iter)); + last_active_indices + .extend((index_start..indices_count).map(|i| (KeychainKind::Internal, i))); + } + if next_or_return!(data_iter) & 0x01 == 0x01 { + let indices_count = *next_or_return!(data_iter) as u32; + let index_start = scale(*next_or_return!(data_iter)); + last_active_indices + .extend((index_start..indices_count).map(|i| (KeychainKind::External, i))); + } + + // Now do the transaction graph update. + // TODO: more edge cases, eg coinbase txs. + let txs_count = *next_or_return!(data_iter) as usize; + let mut txs = Vec::with_capacity(txs_count); + for _ in 0..txs_count { + let version = scale(*next_or_return!(data_iter)) as i32; + let version = bitcoin::transaction::Version(version); + let lock_time = scale(*next_or_return!(data_iter)); + let lock_time = bitcoin::absolute::LockTime::from_consensus(lock_time); + let txin_count = *next_or_return!(data_iter) as usize; + let mut input = Vec::with_capacity(txin_count); + for _ in 0..txin_count { + let previous_output = bitcoin::OutPoint::new( + unique_hash.get_txid(), + *next_or_return!(data_iter) as u32, + ); + input.push(bitcoin::TxIn { + previous_output, + ..Default::default() + }); + } + let txout_count = *next_or_return!(data_iter) as usize; + let mut output = Vec::with_capacity(txout_count); + for _ in 0..txout_count { + let script_pubkey = if next_or_return!(data_iter) & 0x01 == 0x01 { + wallet + .next_unused_address(KeychainKind::External) + .script_pubkey() + } else if next_or_return!(data_iter) & 0x01 == 0x01 { + wallet + .next_unused_address(KeychainKind::Internal) + .script_pubkey() + } else { + bitcoin::ScriptBuf::from_bytes(unique_hash.get().into()) + }; + let amount = *next_or_return!(data_iter) as u64 * 1_000; + let value = bitcoin::Amount::from_sat(amount); + output.push(bitcoin::TxOut { + value, + script_pubkey, + }); + } + let tx = bitcoin::Transaction { + version, + lock_time, + input, + output, + }; + unconfirmed_txids.push_back(tx.compute_txid()); + txs.push(tx.into()); + } + + let txouts_count = *next_or_return!(data_iter) as usize; + let mut txouts = BTreeMap::new(); + for _ in 0..txouts_count { + let outpoint = bitcoin::OutPoint::new( + unique_hash.get_txid(), + *next_or_return!(data_iter) as u32, + ); + let amount = *next_or_return!(data_iter) as u64 * 1_000; + let value = bitcoin::Amount::from_sat(amount); + txouts.insert( + outpoint, + bitcoin::TxOut { + value, + script_pubkey: Default::default(), + }, + ); + } + + let mut anchors = BTreeSet::new(); + while next_or_return!(data_iter) & 0x01 == 0x01 { + let height = scale(*next_or_return!(data_iter)); + let hash = unique_hash.get_block_hash(); + let block_id = BlockId { height, hash }; + let confirmation_time = scale_u64(*next_or_return!(data_iter)); + let anchor = ConfirmationBlockTime { + block_id, + confirmation_time, + }; + // FIXME: inserting anchors for transactions not in the tx graph will fail the + // SQLite persistence. + //let txid = unconfirmed_txids + //.pop_front() + //.unwrap_or(unique_hash.get_txid()); + if let Some(txid) = unconfirmed_txids.pop_front() { + anchors.insert((anchor, txid)); + } else { + break; + } + } + + let mut seen_ats = HashMap::new(); + while next_or_return!(data_iter) & 0x01 == 0x01 { + let time = + cmp::min(scale_u64(*next_or_return!(data_iter)), i64::MAX as u64 - 1); + let txid = unconfirmed_txids + .pop_front() + .unwrap_or(unique_hash.get_txid()); + seen_ats.insert(txid, time); + } + + let tx_update = TxUpdate { + txs, + txouts, + anchors, + seen_ats, + }; + + // Finally, do the chain update. + // TODO: sometimes generate invalid updates, reorgs, etc. + let chain = if next_or_return!(data_iter) & 0x01 == 0x01 { + let mut tip = wallet.latest_checkpoint(); + let tip_height = tip.height(); + let blocks_count = *next_or_return!(data_iter) as u32; + for i in 1..blocks_count + 1 { + tip = tip + .push(BlockId { + height: tip_height + i, + hash: unique_hash.get_block_hash(), + }) + .unwrap(); + } + Some(tip) + } else { + None + }; + + // The Wallet update should never fail as we only ever create a consistent chain. + let update = WalletUpdate { + last_active_indices, + tx_update, + chain, + }; + wallet.apply_update(update).unwrap(); + } + // Assert the wallet roundtrips to persistence and check some invariants. + Action::Persist => { + let balance_before = wallet.balance(); + let next_indices_before = ( + wallet.next_derivation_index(KeychainKind::Internal), + wallet.next_derivation_index(KeychainKind::External), + ); + let tip_before = wallet.latest_checkpoint(); + + wallet + .persist(&mut conn) + .expect("We should always be able to persist."); + let expected_genesis = bitcoin::BlockHash::from_slice( + bitcoin::blockdata::constants::ChainHash::BITCOIN.as_bytes(), + ) + .unwrap(); + wallet = Wallet::load() + .descriptor(KeychainKind::Internal, Some(INTERNAL_DESC)) + .descriptor(KeychainKind::External, Some(EXTERNAL_DESC)) + .check_network(NETWORK) + .check_genesis_hash(expected_genesis) + .load_wallet(&mut conn) + .expect("We should always be able to load back from persistence.") + .expect("Must exist as it was persisted just now."); + + assert_eq!(wallet.balance(), balance_before); + let next_indices_after = ( + wallet.next_derivation_index(KeychainKind::Internal), + wallet.next_derivation_index(KeychainKind::External), + ); + assert_eq!(next_indices_after, next_indices_before); + assert_eq!(wallet.latest_checkpoint(), tip_before); + } + Action::TxCreate => { + let utxo = wallet.list_unspent().next(); + let change_address = wallet.next_unused_address(KeychainKind::Internal); + let receive_address = wallet.next_unused_address(KeychainKind::External); + + let mut tx_builder = if next_or_return!(data_iter) & 0x01 == 0x01 { + wallet.build_tx() + } else { + // TODO: be smarter, don't always pick the first one, sometimes pick a + // canonical one. + let txid = wallet.tx_graph().full_txs().next().map(|tx| tx.txid); + if let Some(txid) = txid { + if let Ok(builder) = wallet.build_fee_bump(txid) { + builder + } else { + return; + } + } else { + return; + } + }; + + if next_or_return!(data_iter) & 0x01 == 0x01 { + let mut rate = *next_or_return!(data_iter) as u64; + if next_or_return!(data_iter) & 0x01 == 0x01 { + rate *= 1_000; + } + let rate = bitcoin::FeeRate::from_sat_per_vb(rate).expect("within range."); + tx_builder.fee_rate(rate); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + // FIXME: this can't be * 100 as as I initially set it to be as rust-bitcoin + // panics internally on overflowing Amount additions. + let mut fee = *next_or_return!(data_iter) as u64; + if next_or_return!(data_iter) & 0x01 == 0x01 { + fee *= 1_000; + } + let fee = bitcoin::Amount::from_sat(fee); + tx_builder.fee_absolute(fee); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + if let Some(ref utxo) = utxo { + tx_builder.add_utxo(utxo.outpoint).expect("known utxo."); + } + } + + // TODO: add foreign utxo + + if next_or_return!(data_iter) & 0x01 == 0x01 { + tx_builder.manually_selected_only(); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + if let Some(ref utxo) = utxo { + tx_builder.add_unspendable(utxo.outpoint); + } + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + let sighash = PsbtSighashType::from_u32(*next_or_return!(data_iter) as u32); + tx_builder.sighash(sighash); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + let ordering = if next_or_return!(data_iter) & 0x01 == 0x01 { + TxOrdering::Shuffle + } else { + TxOrdering::Untouched + }; + tx_builder.ordering(ordering); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + let lock_time = scale(*next_or_return!(data_iter)); + let lock_time = bitcoin::absolute::LockTime::from_consensus(lock_time); + tx_builder.nlocktime(lock_time); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + let version = scale(*next_or_return!(data_iter)) as i32; + tx_builder.version(version); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + tx_builder.do_not_spend_change(); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + tx_builder.only_spend_change(); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + tx_builder.only_witness_utxo(); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + tx_builder.include_output_redeem_witness_script(); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + tx_builder.add_global_xpubs(); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + tx_builder.drain_wallet(); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + tx_builder.enable_rbf(); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + tx_builder.allow_dust(true); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + let recipients_count = *next_or_return!(data_iter) as usize; + let mut recipients = Vec::with_capacity(recipients_count); + + for _ in 0..recipients_count { + let spk = if next_or_return!(data_iter) & 0x01 == 0x01 { + let spk_size = (*next_or_return!(data_iter) >> 3) as usize + 1; + bitcoin::ScriptBuf::from_bytes(unique_hash.get()[..spk_size].into()) + } else if next_or_return!(data_iter) & 0x01 == 0x01 { + change_address.script_pubkey() + } else { + receive_address.script_pubkey() + }; + let amount = *next_or_return!(data_iter) as u64 * 1_000; + let amount = bitcoin::Amount::from_sat(amount); + recipients.push((spk, amount)); + } + + tx_builder.set_recipients(recipients); + } + + // TODO: add data + + if next_or_return!(data_iter) & 0x01 == 0x01 { + let spk = if next_or_return!(data_iter) & 0x01 == 0x01 { + let spk_size = (*next_or_return!(data_iter) >> 3) as usize + 1; + bitcoin::ScriptBuf::from_bytes(unique_hash.get()[..spk_size].into()) + } else if next_or_return!(data_iter) & 0x01 == 0x01 { + change_address.script_pubkey() + } else { + receive_address.script_pubkey() + }; + tx_builder.drain_to(spk); + } + + let mut psbt = if let Ok(tx) = tx_builder.finish() { + tx + } else { + return; + }; + let mut sign_options = SignOptions::default(); + + if next_or_return!(data_iter) & 0x01 == 0x01 { + sign_options.trust_witness_utxo = true; + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + let height = scale(*next_or_return!(data_iter)); + sign_options.assume_height = Some(height); + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + sign_options.allow_all_sighashes = true; + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + sign_options.try_finalize = false; + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + sign_options.tap_leaves_options = bdk_wallet::signer::TapLeavesOptions::None; + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + sign_options.sign_with_tap_internal_key = false; + } + + if next_or_return!(data_iter) & 0x01 == 0x01 { + sign_options.allow_grinding = false; + } + + if wallet.sign(&mut psbt, sign_options.clone()).is_err() { + return; + } + + // If after all this we managed to create and fully sign a valid transaction, add + // it to the wallet. + if let Ok(finalized) = wallet.finalize_psbt(&mut psbt, sign_options) { + if finalized { + let tx = match psbt.extract_tx() { + Err(e) => { + assert!(matches!( + e, + bitcoin::psbt::ExtractTxError::AbsurdFeeRate { .. } + )); + return; + } + Ok(tx) => tx, + }; + let mut wallet_update = WalletUpdate::default(); + wallet_update.tx_update.txs.push(tx.into()); + wallet.apply_update(wallet_update).unwrap(); + } + } + } + } + } +}); +``` + +### `merge_chains.rs` + +```rust +#![no_main] + +use bdk_chain::{ + bitcoin::{self, hashes::Hash}, + local_chain::{ChangeSet, LocalChain}, + CheckPoint, +}; +use libfuzzer_sys::fuzz_target; +use std::{ + cmp, + collections::{BTreeMap, BTreeSet, HashMap, VecDeque}, +}; + +struct UniqueHash { + data: [u8; 32], +} + +impl UniqueHash { + pub fn new() -> Self { + Self { data: [0; 32] } + } + + pub fn get(&mut self) -> [u8; 32] { + for byte in self.data.iter_mut().rev() { + if *byte < u8::MAX { + *byte += 1; + break; + } + } + self.data + } + + pub fn get_block_hash(&mut self) -> bitcoin::BlockHash { + bitcoin::hash_types::BlockHash::from_byte_array(self.get()) + } +} + +macro_rules! next_or_return { + ($iter:expr) => { + match $iter.next() { + Some(val) => val, + None => return, + } + }; +} + +fn is_odd(n: &u8) -> bool { + n & 0x01 == 0x01 +} + +fuzz_target!(|data: &[u8]| { + let mut data = data.iter(); + let mut unique_hashes = UniqueHash::new(); + + // First create an initial, valid, chain. + // TODO: scale chain size to a few thousands. + let initial_chain_len = cmp::max(1, *next_or_return!(data) as u32); + let mut initial_blocks = BTreeMap::new(); + initial_blocks.insert(0, Some(unique_hashes.get_block_hash())); + for i in 1..initial_chain_len - 1 { + if is_odd(next_or_return!(data)) { + initial_blocks.insert( + i, + is_odd(next_or_return!(data)).then_some(unique_hashes.get_block_hash()), + ); + } else { + let height = cmp::max(1, *next_or_return!(data) as u32); + initial_blocks.insert( + height, + is_odd(next_or_return!(data)).then_some(unique_hashes.get_block_hash()), + ); + } + } + let mut initial_chain = LocalChain::from_changeset(ChangeSet { + blocks: initial_blocks.clone(), + }) + .expect("A genesis block is always present."); + let initial_chain_height = initial_chain.tip().height(); + + // Now create another chain to be merged with the initial one. Sometimes extend the initial + // chain, sometimes not, depending on the fuzzer's input. + // TODO: sometimes add some hashes from the initial chain in the update chain. + let mut connects = false; + let mut reorg_height = None; + let update_chain_len = cmp::max(2, *next_or_return!(data) as u32); + let (mut height, mut update_cp) = if is_odd(next_or_return!(data)) { + ( + cmp::max(1, *next_or_return!(data) as u32), + CheckPoint::new((0, initial_chain.genesis_hash()).into()), + ) + } else { + connects = true; + ( + initial_chain_height + 1, + CheckPoint::new(initial_chain.tip().block_id()), + ) + }; + for _ in 0..update_chain_len - 1 { + height += if is_odd(next_or_return!(data)) { + *next_or_return!(data) as u32 + } else { + 0 + }; + let hash = unique_hashes.get_block_hash(); + update_cp = update_cp + .push((height, hash).into()) + .expect("Height is always increasing."); + // BDK requires that the block right after the point of agreement in the initial chain be + // included in the original chain for it to connect. We check if this block is this "first + // block to conflict" by: + // 1) Checking it is at all in the initial chain + if !connects && initial_blocks.contains_key(&height) { + // 2) Checking it does indeed conflict with the block in the initial chain. + if let Some(Some(conflict_h)) = initial_blocks.get(&height) { + if hash != *conflict_h { + // 3) Checking the block right before is the point of agreement. + if let Some(ref prev) = update_cp.prev() { + if let Some(Some(agree_h)) = initial_blocks.get(&prev.height()) { + if prev.hash() == *agree_h { + // 4) Checking the block right after the point of agreement in the + // initial chain is indeed at the height of our conflict block. + if let Some((initial_agree_h, _)) = + initial_blocks.range(prev.height() + 1..).next() + { + if *initial_agree_h == height { + //eprintln!("Connects"); + connects = true; + reorg_height = Some(height); + } + } + } + } + } + } + } + } + height += 1; + } + + //dbg!(&initial_chain); + //dbg!(&update_cp); + let merge_res = initial_chain.apply_update(update_cp.clone()); + if connects { + //dbg!(&merge_res); + let merge_res = merge_res.expect("Must only fail if it cannot connect."); + let new_chain_height = update_cp.height(); + // All blocks in the update but the very first must have been recorded as newly added, no + // matter if it was extending or reorg'ing the chain. + loop { + if let Some(cp) = update_cp.prev() { + let update_hash = merge_res + .blocks + .get(&update_cp.height()) + .expect("Must contain all blocks from update.") + .expect("Must be an added block."); + assert_eq!(update_cp.hash(), update_hash); + update_cp = cp; + } else { + break; + } + } + // If the update chain is smaller than the initial block, all blocks in the initial chain + // whose height is higher than the update's tip must have been recorded as dropped. + if new_chain_height < initial_chain_height { + if let Some(_) = reorg_height { + assert!(merge_res + .blocks + .range(new_chain_height + 1..) + .all(|entry| entry.1.is_none())); + } + } + } +}); +``` \ No newline at end of file diff --git a/docs/audits/2024_q4/bdk_audit_test_coverage.png b/docs/audits/2024_q4/bdk_audit_test_coverage.png new file mode 100644 index 0000000000000000000000000000000000000000..86084defaba209e54c0d91ae48e7d8f2ed14d284 GIT binary patch literal 95677 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