AQ
← All projectsACINQ

Eclair

Scala implementation of a Lightning Network node.

BitcoinLightning NetworkNormal
Repository coverage

231 commits in the local evidence base

Every captured commit receives deterministic security triage and a separate communication-quality score. Security candidates and broader second-pass signals receive full-patch Ollama analysis.

66security candidates48second-pass queue208AI analyses
4commits · 30 days
26commits · 60 days
80commits · 180 days
161commits · 365 days
Backfill bands
Aug 5 → Feb 691 seen11 candidatesComplete
Feb 6 → Jun 660 seen5 candidatesComplete
Jun 6 → Jul 62 seen0 candidatesComplete
Jul 6 → Aug 514 seen0 candidatesComplete
Commit communication

Does the history explain itself?

Message quality measures whether a commit identifies its scope, purpose, rationale, testing, and supporting references. It does not change the security-severity score.

78/100 average clarity
143Strong · 80–100
54Adequate · 60–79
23Thin · 40–59
11Opaque · 0–39
3security candidates with opaque commit messaging
Read the scoring rubric →
Developer activity

Who is changing the project?

Public Git author strings; identities are not independently verified.

DeveloperCommitsCandidatesAnalyzedHigh riskMessage avg.
pm47451633876
Bastien Teinturier13332127581
Fabrice Drouin291424269
Thomas HUET16116075
rorp313069
Nishant Bansal212084
dependabot[bot]111081
ekzyis101058
Rusty Russell101081
Analysis record

Published AI watches

Last scanned 35 minutes ago

Informational 15 AI analysisMessage 36 · Opaque
AQ ACINQEclair BitcoinLightning Network

Back to dev (#3424)

This commit is a routine post-release housekeeping change. It bumps the software version from 0.14.6 to 0.15.0-SNAPSHOT across several build files, adds a blank release-notes template for the next version, and intentionally adds a startup …

Startup guard added to block accidental execution of development snapshotNo vulnerability fix, cryptographic change, or trust-boundary modification present
c96c3d44by Fabrice Drouin+73−57 files
No security note in commit
High 74 AI analysisMessage 53 · Thin
AQ ACINQEclair BitcoinLightning Network

Eclair v0.14.6 release (#3420)

This commit is the release packaging for Eclair v0.14.6. The release notes explicitly state it contains 'security hardening fixes' that can be exploited by malicious nodes, and thank a researcher for responsible disclosure. The actual code…

Vendor release notes explicitly label the release as containing 'security hardening fixes' exploitable by malicious nodesNew default-on configuration `require-confirmed-inputs-for-splicing` mitigates unconfirmed-input double-spend risk during splicingRelease notes credit @erickcestari for responsible disclosures
50e046efby Fabrice Drouin+28−198 files
Vendor flagged security relevance
High 72 AI analysisMessage 88 · Strong
AQ ACINQEclair BitcoinLightning Network

Splicing robustness improvements (#3417)

This commit hardens Eclair's Lightning channel 'splicing' feature against a malicious peer. Splicing lets users resize a channel by creating a new funding transaction. The patch fixes several ways an attacker could exploit unconfirmed spli…

New default-on configuration `require-confirmed-inputs-for-splicing` to prevent double-spend of unconfirmed splice inputsLimit on remote splice inputs/outputs (10) to bound CPFP costForce-close now selects a commitment whose funding tx is known to bitcoind, re-evaluated per block and splice spend events
c07cc745by pm47+518−6011 files
Vendor flagged security relevance
Moderate 64 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Flag peers that leave liquidity fees unpaid (#3416)

This commit fixes a security gap in Eclair's Lightning node software. A peer could repeatedly get free channel funding ('liquidity') by backing out of payments meant to cover the fees right before the funding transaction was signed. Previo…

Fixes a logic flaw allowing repeated unpaid liquidity feesAdds peer suspicion flagging tied to funding txidExpands state handling for asynchronous LiquidityPurchaseAborted events
c5b9afc0by pm47+192−154 files
Vendor flagged security relevance
Informational 15 AI analysisMessage 36 · Opaque
AQ ACINQEclair BitcoinLightning Network

Back to dev (#3413)

This commit is a routine post-release housekeeping change. It bumps the project version from 0.14.5 to 0.15.0-SNAPSHOT, removes published release checksums, and adds a blank release-notes template. It also adds a startup guard that refuses…

No vulnerability signals presentStartup guard added to block accidental use of development snapshot
06716fceby Fabrice Drouin+73−108 files
No security note in commit
Moderate 67 AI analysisMessage 53 · Thin
AQ ACINQEclair BitcoinLightning Network

Eclair v0.14.5 release (#3412)

This commit is the release packaging for Eclair v0.14.5. The release notes state it is a patch release containing 'security hardening fixes' that can be exploited by malicious nodes, and thank two people for responsible disclosures. The ac…

Release notes explicitly describe 'security hardening fixes' and warn that 'some of these issues can be exploited by malicious nodes'Two independent researchers are credited for responsible disclosuresRemoval of an 'unsafe startup' guard indicates the prior development snapshot was considered unsafe and this release is meant to be safe to run
01384e93by Fabrice Drouin+14−268 files
Vendor flagged security relevance
High 82 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Check remote previous txOut against the blockchain (#3411)

This commit fixes a security bug in Eclair's taproot channel splicing. When two users splice a Lightning channel, one side can describe its bitcoin inputs by sending only a small summary (the txOut) instead of the full previous transaction…

Missing cryptographic/chain validation of peer-supplied transaction dataTaproot signature commits to spent outputs, making a signed-but-unconfirmable splice possiblePotential HTLC theft via old commitment publication after splice timeout
ae0927edby pm47+111−43 files
Vendor flagged security relevance
High 78 AI analysisMessage 86 · Strong
AQ ACINQEclair BitcoinLightning Network

Reject onion per-hop lengths that overflow an `Int` (#3408)

This fix closes a denial-of-service bug in Eclair's Lightning onion routing. A remote sender could craft a malformed per-hop payload length that, when converted from a large number to a normal integer, wrapped around to a negative or tiny …

Integer overflow / truncation from Long to IntNegative length bypasses upper-bound checkException escapes Try block causing DoS
40279a1bby pm47+20−32 files
Vendor flagged security relevance
Informational 15 AI analysisMessage 36 · Opaque
AQ ACINQEclair BitcoinLightning Network

Back to dev (#3405)

This commit is a routine post-release housekeeping change. It bumps the project version from 0.14.4 to 0.15.0-SNAPSHOT, removes the published checksums for the 0.14.4 release, and adds a placeholder release-notes file for the next version.…

No security-relevant code changesAdded explicit unsafe-startup guard to prevent accidental use of development snapshotNo references to CVEs, advisories, or security issues in commit message or diff
c4910b7bby Fabrice Drouin+73−108 files
No security note in commit
High 84 AI analysisMessage 53 · Thin
AQ ACINQEclair BitcoinLightning Network

Eclair v0.14.4 release (#3403)

This commit is the official release marker for Eclair v0.14.4. The release notes included in the commit describe it as a security-hardening patch release with fixes for multiple issues, some of which can be exploited by malicious nodes. Th…

Release notes explicitly label the release as containing 'security hardening fixes' exploitable by malicious nodesHTTP API now rejects Origin-header requests to mitigate browser-based CSRF against basic-authenticated endpointsSeed file length validation added (commit a07fff5)
e1c212c4by Fabrice Drouin+90−8210 files
Vendor flagged security relevance
High 82 AI analysisMessage 93 · Strong
AQ ACINQEclair BitcoinLightning Network

Retry publishing txs evicted by unconfirmed conflicts (#3397)

This commit fixes a security bug in the Eclair Lightning node where a malicious peer could trick the node into permanently giving up on publishing its own commitment or penalty transactions. By publishing and then double-spending a conflic…

The commit message explicitly describes theft risk: "This lets them steal HTLCs by publishing their commitment later"Attack vector involves a malicious peer withholding tx_signatures and double-spending a splice inputFix changes abandonment logic for local commit anchor preconditions
21f1bc8dby pm47+100−254 files
Vendor flagged security relevance
Moderate 66 AI analysisMessage 93 · Strong
AQ ACINQEclair BitcoinLightning Network

Keep unsigned settlements when rejecting commands (#3401)

This commit fixes a bug in Eclair, a Bitcoin Lightning Network node implementation. When the node received a duplicate command to settle a payment (fulfill or fail), it would mistakenly delete the still-pending settlement from its database…

Loss of pending HTLC settlement state on disconnect/reconnectUpstream HTLC timeout risk for relayed fulfilled downstream HTLCsDuplicate/conflicting command handling caused premature DB acknowledgement
7686dfadby pm47+38−32 files
Vendor flagged security relevance
Moderate 66 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Force-close again when a splice RBF sibling confirms (#3400)

This commit fixes a bug in Eclair, a Bitcoin Lightning Network node implementation. When one node force-closed a channel because its peer never finished signing a 'splice' (a way to resize a Lightning channel on-chain), and the peer later …

Funds-locking bug in channel close logicHTLCs not enforced on-chain after confirmed double-spendIncorrect re-force-close trigger condition
9a1ecc99by pm47+59−72 files
Vendor flagged security relevance
Critical 89 AI analysisMessage 78 · Adequate
AQ ACINQEclair BitcoinLightning Network

Reject unpublishable splices (#3396)

This commit fixes a set of vulnerabilities in Eclair's Lightning channel splicing protocol that could let a malicious peer trick the victim into signing a splice transaction that can never be published on the Bitcoin network. Because the v…

Commit title and message explicitly describe preventing a malicious peer from making us sign an unpublishable splice transactionAdds validation of absolute lockTime against current block height to prevent indefinite publication delayAdds rejection of BIP 68 relative lock time on all interactive-tx inputs, including shared splice input
af994180by pm47+235−35 files
Vendor flagged security relevance
High 74 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Reject onion per-hop lengths exceeding packet (#3395)

This commit fixes a bug in how Eclair processes encrypted routing instructions (onion packets) for Lightning payments. A malicious sender could craft a packet that claimed its inner payload was longer than the packet itself. The old code e…

Unchecked length field from attacker-controlled onion packet used for slicingException thrown outside Try block, bypassing expected error handlingRelayer crash could leave HTLC un-failed
d3a146a0by pm47+16−22 files
Vendor flagged security relevance
Moderate 53 AI analysisMessage 98 · Strong
AQ ACINQEclair BitcoinLightning Network

Remove `spendfromchanneladdress` nonce after one sig (#3392)

This commit fixes a cryptographic safety issue in a manual Bitcoin/Lightning recovery tool. When a user runs the `spendfromchanneladdress` operation, the code was re-reading a secret signing nonce from a stored map after using it once. Non…

nonce reuse prevention in Schnorr-like/MuSig2 partial signature flowprivate nonce removed from in-memory store after single usemanual recovery command affected, not hot path
c89af115by pm47+1−11 file
Vendor flagged security relevance
Moderate 66 AI analysisMessage 88 · Strong
AQ ACINQEclair BitcoinLightning Network

Reject seed files with an invalid length (#3389)

This patch fixes a bug in the Eclair Bitcoin Lightning node where, if the node crashed while creating its secret seed file, it could leave an empty file behind. On the next restart, Eclair would silently use that empty seed to generate all…

Use of weak/predictable cryptographic seed for key derivationMissing input validation on security-critical seed fileNon-atomic file write creating corrupt/empty secret material
a07fff56by pm47+31−12 files
Vendor flagged security relevance
Low 25 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Upgrade postgresql client from 42.7.11 to 42.7.12 (#3330)

This commit updates the PostgreSQL database driver used by Eclair from version 42.7.11 to 42.7.12. It is a routine dependency bump by an automated tool. The commit itself does not say what bugs the new driver fixes, but small point-release…

Dependency version bump of a database driverPoint-release upgrade may include upstream security fixes, but none are named in the commitNo application code changes or direct vulnerability evidence in the diff
972dfe99by dependabot[bot]+3−12 files
No security note in commit
Low 31 AI analysisMessage 58 · Thin
AQ ACINQEclair BitcoinLightning Network

Use bitcoin-kmp 0.49 (depends on bitcoin-kmp 0.32.0 and secp256k1-kmp 0.24.0) (#3362)

This commit updates Eclair's Bitcoin library dependency from version 0.48 to 0.49, which internally uses newer versions of bitcoin-kmp and secp256k1-kmp. The code changes only replace old property accesses (like `.txid`) with new method ca…

Dependency version bump for Bitcoin and secp256k1 cryptographic librariesSource changes are API adaptations (.txid -> .getTxid), not logic changesSecurity-critical validation code is touched (PSBT/transaction integrity checks against malicious Bitcoin Core)
6162e2aaby Fabrice Drouin+22−44 files
No security note in commit
Informational 15 AI analysisMessage 86 · Strong
AQ ACINQEclair BitcoinLightning Network

Update build to improve release process (#3381)

This commit is a routine build-system update. It upgrades several Maven plugin versions, removes the git commit ID from one jar manifest field to avoid a build-time circular dependency, and adds an optional build profile for a fuzz-testing…

c3e9f5d6by Fabrice Drouin+834−105 files
No security note in commit
Repository ledger

Explore captured commits

Expand any commit for its author, full message, clarity score, changed files, triage signals, analysis, and source link.

AI review queuedBack to dev (#3424)by Fabrice Drouin · c96c3d44 · Oct 28, 2026 · 7 filesMessage 36 · OpaqueInformational 15Details
Commit message · Fabrice Drouin

Back to dev (#3424)

After release 0.14.6

36/100 · OpaqueMessage clarity
✓ Subject identifies a change✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
second-pass: opaque commit message
AI analysis · Informational 15/100

This commit is a routine post-release housekeeping change. It bumps the software version from 0.14.6 to 0.15.0-SNAPSHOT across several build files, adds a blank release-notes template for the next version, and intentionally adds a startup guard that refuses to run the development snapshot unless a special override flag is set. There is no security vulnerability being fixed here; the change is meant to prevent users from accidentally running unfinished development code.

Security candidateEclair v0.14.6 release (#3420)by Fabrice Drouin · 50e046ef · Oct 27, 2026 · 8 filesMessage 53 · ThinHigh 74Details
Commit message · Fabrice Drouin

Eclair v0.14.6 release (#3420)

Eclair v0.14.6 release

53/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
cryptography-sensitive path
AI analysis · High 74/100

This commit is the release packaging for Eclair v0.14.6. The release notes explicitly state it contains 'security hardening fixes' that can be exploited by malicious nodes, and thank a researcher for responsible disclosure. The actual code changes in the commit are only version bumps and removal of a startup blocker; the security fixes themselves are not visible in this single commit. A new default setting is added that requires confirmed inputs for splicing to prevent a specific double-spend risk.

AI review queuedSplicing robustness improvements (#3417)by pm47 · c07cc745 · Oct 27, 2026 · 11 filesMessage 88 · StrongHigh 72Details
Commit message · pm47

Splicing robustness improvements (#3417)

Make splicing more robust when splice transactions don't confirm:

- add `require-confirmed-inputs-for-splicing` (enabled by default): splices only spend confirmed transactions, and we limit the number of inputs and outputs our peer can add
- when force-closing, use a commitment whose funding transaction is known by our bitcoind, and re-evaluate it when blocks are found or splice transactions are published
- when CPFP-ing our commit tx, take its unconfirmed funding transaction into account
- claim the outputs of a previous remote commitment as soon as it confirms
- warn against using `zero_fee_commitments` when splicing with untrusted peers

Note that `require-confirmed-inputs-for-dual-funding` doesn't apply to splices anymore.

* Add tests for splices with unconfirmed parents

We add a `require-confirmed-inputs-for-splicing` setting (not used yet)
and tests showing that we should:
- require our peer's splice inputs to be confirmed
- not splice on top of an unconfirmed splice transaction
- limit the number of inputs and outputs our peer adds to a splice

* Only splice with confirmed parents

When `require-confirmed-inputs-for-splicing` is set (the default), we
now require our peer to only use confirmed inputs in splices, and we
don't initiate a splice on top of an unconfirmed splice transaction (our
peer already cannot). We also limit the number of inputs and outputs our
peer can add to a splice transaction to 10.

Note that `require-confirmed-inputs-for-dual-funding` doesn't apply to
splices anymore, only to channel creation.

* Require confirmed splice inputs in tests

We use the default value of `require-confirmed-inputs-for-splicing` in
tests. Our test wallet now considers the inputs it uses to fund
transactions confirmed (this can be disabled to test unconfirmed inputs),
and shares them with other test wallets so that our peer can verify them.

Tests that splice on top of unconfirmed splices now explicitly disable
it: those scenarios can still happen with zero-conf, so we keep testing
them.

* Add tests for force-close with unconfirmed splices

We add tests for the commitment we use when force-closing while splice
transactions are unconfirmed. Our test wallet now considers the
transactions it has published to be in its mempool.

* Force-close with a commitment whose funding tx can confirm

When force-closing while splice transactions are unconfirmed (without
zero-conf), we now use the most recent commitment whose funding tx is
known by our bitcoind (in its mempool or confirmed), or the most recent
confirmed commitment otherwise. We re-evaluate it at every block and
when a splice transaction spends a funding output, and force-close again
using a different commitment if needed.

* Add test for anchor CPFP with an unconfirmed funding tx

When our commit tx spends an unconfirmed funding transaction, our anchor
tx should also pay for that funding transaction to reach our target
feerate.

* Pay for unconfirmed funding tx when CPFP-ing commit tx

Miners evaluate our anchor tx with all of its unconfirmed ancestors.
When our commit tx spends an unconfirmed funding transaction (with
zero-conf or splices), we now include the fees and weight of its
unconfirmed ancestors when computing the fees our anchor tx must pay.

* Warn against zero_fee_commitments with splicing

With zero_fee_commitments, our commit tx is a v3 transaction, which
cannot spend an unconfirmed v2 transaction such as a splice transaction
(TRUC rules), so we cannot CPFP it. We document that this feature should
not be used when splicing with untrusted peers.

* Add test for claiming htlcs of a previous remote commit

When our peer publishes its commit tx for a previous commitment, we
should claim its outputs as soon as it confirms.

Existing tests that confirm a previous commit tx now use a height that
is deep enough to directly test the min-depth handling.

* Claim previous remote commit outputs as soon as it confirms

When our peer publishes its commit tx for a previous commitment, we
waited for min-depth before claiming its outputs. We now claim them as
soon as it confirms, without forgetting our other commitments, which we
only reset once it is deeply confirmed. We don't do it for revoked
commit txs, whose outputs are delayed.

* Add test for published stale local commit tx

When we switch to a different commitment while force-closing (because
the funding tx of our commit tx left our mempool), the commit tx we
previously published may still confirm, since miners may still have it
along with its parent splice transaction. We must then claim its outputs
instead of treating it as a remote commit tx.

* Handle our stale local commit tx in CLOSING

When force-closing, we may switch to a different commitment if the
funding tx of our commit tx isn't known by our bitcoind anymore. The
commit tx we previously published may still confirm though: we now
recognize it as one of our local commit txs and force-close again with
its commitment, instead of handling it as a remote commit tx, which
would lead to ERR_INFORMATION_LEAK or to a bogus revoked commit.


Reported-by: @erickcestari
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Co-authored-by: Fabrice Drouin <sstone@users.noreply.github.com>

88/100 · StrongMessage clarity
✓ Descriptive subject✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · High 72/100

This commit hardens Eclair's Lightning channel 'splicing' feature against a malicious peer. Splicing lets users resize a channel by creating a new funding transaction. The patch fixes several ways an attacker could exploit unconfirmed splice transactions: by double-spending inputs to make the splice invalid, by adding so many inputs/outputs that the honest node can't afford to speed it up (CPFP), or by publishing an old commitment while a splice is stuck. The changes add a new default-on setting that requires splice inputs to be confirmed, limit how many inputs/outputs a peer can add, make force-closing pick a commitment whose funding transaction is actually known to the node's own Bitcoin Core, include unconfirmed ancestors when paying to speed up a commitment, and claim outputs from an old remote commitment as soon as it confirms. The commit message explicitly warns that using zero-fee commitments with splicing and untrusted peers can lead to loss of funds.

Security candidateFlag peers that leave liquidity fees unpaid (#3416)by pm47 · c5b9afc0 · Oct 27, 2026 · 4 filesMessage 81 · StrongModerate 64Details
Commit message · pm47

Flag peers that leave liquidity fees unpaid (#3416)

When a peer buys liquidity using `from_future_htlc`, we take the risk of not being paid, and rely on our suspicious peers mechanism (`max-suspicious-peers`) to bound that risk. But a peer could withdraw the payments that should pay the fees *before* the purchase is signed (with `will_fail_htlc`, by letting the proposal time out, or by disconnecting): we then signed the funding transaction without recording any fee debt, and the peer was never flagged, so it could repeat this indefinitely.


* Flag peers that leave liquidity fees unpaid

When signing a liquidity purchase paid with from_future_htlc, we now
flag our peer as suspicious if some of its fees cannot be collected from
its pending payments, as we already do when funded HTLCs are failed.

* Track underpaid liquidity purchases by funding tx

Underpaid liquidity purchases are now tracked by funding txid instead
of payment hash, and are only cleared by the node operator (using
enableFromFutureHtlc) or when restarting. Failed relays are still keyed
by payment hash. Both count towards max-suspicious-peers, and each is
reported in its own metric.

* Forget underpaid liquidity purchases when aborted

When a liquidity purchase is aborted before its funding transaction is
published, we haven't lost any fees: we now remove the corresponding
underpaid entry, and fail the upstream HTLCs of its funded payments.
We handle this event regardless of our connection state, since it is
sent asynchronously by the channel.


Reported-by: @erickcestari
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · Moderate 64/100

This commit fixes a security gap in Eclair's Lightning node software. A peer could repeatedly get free channel funding ('liquidity') by backing out of payments meant to cover the fees right before the funding transaction was signed. Previously, Eclair didn't flag this behavior, so the peer could do it over and over. The patch now flags such peers as suspicious and temporarily blocks them from using this fee-deferral feature, limiting potential losses.

Security candidateBack to dev (#3413)by Fabrice Drouin · 06716fce · Oct 22, 2026 · 8 filesMessage 36 · OpaqueInformational 15Details
Commit message · Fabrice Drouin

Back to dev (#3413)

After release 0.14.5

36/100 · OpaqueMessage clarity
✓ Subject identifies a change✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body! Opaque security-relevant change
Why it was queued
cryptography-sensitive path
AI analysis · Informational 15/100

This commit is a routine post-release housekeeping change. It bumps the project version from 0.14.5 to 0.15.0-SNAPSHOT, removes published release checksums, and adds a blank release-notes template. It also adds a startup guard that refuses to run the development snapshot unless a special override flag is set, explicitly warning that this version is unsafe to use. There is no security vulnerability here; the change is a deliberate safety measure, not a fix for an exploitable bug.

Security candidateEclair v0.14.5 release (#3412)by Fabrice Drouin · 01384e93 · Oct 20, 2026 · 8 filesMessage 53 · ThinModerate 67Details
Commit message · Fabrice Drouin

Eclair v0.14.5 release (#3412)

Eclair v0.14.5 release

53/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
cryptography-sensitive path
AI analysis · Moderate 67/100

This commit is the release packaging for Eclair v0.14.5. The release notes state it is a patch release containing 'security hardening fixes' that can be exploited by malicious nodes, and thank two people for responsible disclosures. The actual code changes in this commit are only version number updates and removal of a startup safety guard that had blocked running the previous snapshot. The security fixes themselves are not visible in this commit; they were presumably made in earlier commits that this release bundles.

Security candidateCheck remote previous txOut against the blockchain (#3411)by pm47 · ae0927ed · Oct 20, 2026 · 3 filesMessage 81 · StrongHigh 82Details
Commit message · pm47

Check remote previous txOut against the blockchain (#3411)

When splicing taproot channels, our peer may only send the `txOut` of its inputs (amount and script) instead of the full previous transaction. Nothing checked that this `txOut` matched the actual output, so our peer could lie about it. Since taproot signatures commit to every spent output, we would sign a splice transaction that can never confirm and keep using it as our latest commitment, while our peer can publish its commitment for the previous funding output after upstream HTLCs have timed out, and steal HTLCs.

This also bypasses the restriction of splices to phoenix peers, which relies on phoenix only adding confirmed swap-in inputs: the swap-in script and confirmation checks used the claimed `txOut`.

We now fetch the previous transaction from our bitcoin node for every remote input that was sent without it, and abort if its output doesn't match.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · High 82/100

This commit fixes a security bug in Eclair's taproot channel splicing. When two users splice a Lightning channel, one side can describe its bitcoin inputs by sending only a small summary (the txOut) instead of the full previous transaction. Before this fix, Eclair trusted that summary without checking it against the actual blockchain. A dishonest peer could lie about the amount or script of its input, causing the splice transaction to be permanently unconfirmable. Because taproot signatures commit to the spent outputs, the victim would have already signed an invalid splice, while the attacker could later publish the old channel commitment and steal HTLCs (pending Lightning payments) after they time out. The fix fetches the real previous transaction from the user's own bitcoin node and aborts if the summary does not match.

Security candidateReject onion per-hop lengths that overflow an `Int` (#3408)by pm47 · 40279a1b · Oct 20, 2026 · 2 filesMessage 86 · StrongHigh 78Details
Commit message · pm47

Reject onion per-hop lengths that overflow an `Int` (#3408)

The per-hop payload length is decoded as a `Long` (the varint may use up to 9 bytes) but converted to an `Int` without checking that it fits. A sender who knows our node id can compute the shared secret and a valid hmac, so they can choose a length that wraps around when converted:

- fe 80 00 00 05 wraps to a negative value, which passes the upper bound check added in d3a146a08 and then throws when extracting the hmac, outside of the `Try`. Like before that fix, the exception escaped the relayer (which was resumed, so the HTLC was never failed upstream and kept its slot until expiry) and aborted the `PostRestartHtlcCleaner` on the next restart.
- 9-byte varints can wrap to small positive values (one of them even overflows the Long once the varint size is added), which made us silently accept a garbage per-hop payload.

We now require the decoded length to be non-negative and to fit in an Int before converting it, which turns all these cases into an `InvalidOnionVersion` error as for other invalid lengths.

Reported-by: Fire
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>

86/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
memory safetycryptography-sensitive path
AI analysis · High 78/100

This fix closes a denial-of-service bug in Eclair's Lightning onion routing. A remote sender could craft a malformed per-hop payload length that, when converted from a large number to a normal integer, wrapped around to a negative or tiny value. That bypassed safety checks and crashed the relayer or the post-restart cleanup logic, leaving affected HTLCs stuck until they expired. The patch now rejects oversized lengths before converting them.

Lower-priorityMake Dockerfile work for release versions (#3406)by Fabrice Drouin · c621fbe8 · Oct 20, 2026 · 1 fileMessage 86 · StrongTriage 8Details
Commit message · Fabrice Drouin

Make Dockerfile work for release versions (#3406)

Our docker file first builds eclair without sources to download and cache all
its dependencies, and then builds with the actual source files.
This is standard for many maven projects but does not work for release builds
which include a checksum verification for eclair-core.jar (which requires that
we build the exact same source files).
=> Here we skip check verification during the first step. They will all be
verified during the second build.

86/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
defensive validation
Lower-priorityNever relay HTLCs expiring after upstream HTLCs (#3409)by pm47 · ff61467a · Oct 20, 2026 · 2 filesMessage 81 · StrongTriage 0Details
Commit message · pm47

Never relay HTLCs expiring after upstream HTLCs (#3409)

When relaying a trampoline payment, we set the route's maximum CLTV to
ensure that our outgoing HTLCs expire before the incoming ones. But when
no route was found, the path-finding retry relaxed the maximum CLTV to
2016 blocks, which could let the payer use routing hints or blinded paths
with large CLTV deltas to make us send HTLCs expiring long after the
incoming HTLCs. The payer could then get their incoming HTLCs refunded
on-chain while the recipient claims our outgoing HTLCs.

We now only relax the route length in that retry.

Reported-by: @Nuhiat-Arefin
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Security candidateBack to dev (#3405)by Fabrice Drouin · c4910b7b · Oct 16, 2026 · 8 filesMessage 36 · OpaqueInformational 15Details
Commit message · Fabrice Drouin

Back to dev (#3405)

After release 0.14.4

36/100 · OpaqueMessage clarity
✓ Subject identifies a change✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body! Opaque security-relevant change
Why it was queued
cryptography-sensitive path
AI analysis · Informational 15/100

This commit is a routine post-release housekeeping change. It bumps the project version from 0.14.4 to 0.15.0-SNAPSHOT, removes the published checksums for the 0.14.4 release, and adds a placeholder release-notes file for the next version. It also adds a startup guard in Boot.scala that refuses to start the development snapshot unless a special unsafe-startup flag is set, which is a safety measure rather than a vulnerability.

Lower-priorityUpdate eclair-v0.14.4.md (#3404)by Fabrice Drouin · 397abfcb · Oct 15, 2026 · 1 fileMessage 53 · ThinTriage 0Details
Commit message · Fabrice Drouin

Update eclair-v0.14.4.md (#3404)

53/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
documentation-only discount
Security candidateEclair v0.14.4 release (#3403)by Fabrice Drouin · e1c212c4 · Oct 15, 2026 · 10 filesMessage 53 · ThinHigh 84Details
Commit message · Fabrice Drouin

Eclair v0.14.4 release (#3403)

Eclair v0.14.4 release

53/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
cryptography-sensitive path
AI analysis · High 84/100

This commit is the official release marker for Eclair v0.14.4. The release notes included in the commit describe it as a security-hardening patch release with fixes for multiple issues, some of which can be exploited by malicious nodes. The most clearly described issue is a cross-site request forgery (CSRF) risk on the node's HTTP API: because the API uses HTTP basic authentication and accepts form-encoded parameters, any website visited by the node operator could trick the browser into making authenticated API calls. The release mitigates this by rejecting API requests that carry a browser-style Origin header. Other listed fixes cover seed-file validation, interactive transaction funding, remote closing scripts, channel funding/replacement logic, onion routing packet handling, and transaction publishing. The commit itself only changes version numbers, release notes, CI configuration, and build checksums; the actual code fixes are in the referenced parent commits.

Security candidateRetry publishing txs evicted by unconfirmed conflicts (#3397)by pm47 · 21f1bc8d · Oct 13, 2026 · 4 filesMessage 93 · StrongHigh 82Details
Commit message · pm47

Retry publishing txs evicted by unconfirmed conflicts (#3397)

* Keep retrying local anchor on unconfirmed conflicts

When the funding output was spent and our local commit tx couldn't be found,
we assumed that a remote commit tx was available and permanently gave up on
our local anchor. Since #3376, we may force-close with an older commitment
when our peer withholds tx_signatures for a splice: if our peer publishes
that splice transaction, our commit tx is rejected because it conflicts with
it, and if our peer then double-spends their splice input, we never publish
our commit tx again (until we restart). This lets them steal HTLCs by
publishing their commitment later.

We now only give up on our local anchor if a remote commit tx is actually
available, or if the funding output is spent by a confirmed transaction.
Otherwise we retry at the next block, which publishes our commit tx with our
anchor as soon as the conflicting transaction is evicted.

* Retry final txs after unconfirmed conflicts

When a final (non-replaceable) transaction was rejected because it conflicts
with an unconfirmed mempool transaction, we never retried it. But our peer
can evict that conflicting transaction by double-spending one of its other
inputs, which makes our transaction valid again: our peer could then use
this to make us abandon our commit tx or our penalty transactions.

We now retry at every block until the conflicting transaction confirms, as
we already do for replaceable transactions.

* Retry local anchor with unconfirmed funding tx (#3402)

When the funding output is spent by an unconfirmed transaction and no remote
commit tx is available, we keep retrying our local anchor. But we detected
this by checking the funding output in the UTXO set, which doesn't contain
outputs of unconfirmed transactions: when the funding tx was unconfirmed
(e.g. with 0-conf), we thus still gave up on our commit tx.

If the funding tx is unconfirmed, it can only be spent by an unconfirmed
transaction, so we now retry at the next block in that case as well.

---------

Reported-By: [project-loupe](https://github.com/project-loupe)
Reported-By: @erickcestari

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Fabrice Drouin <sstone@users.noreply.github.com>

93/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · High 82/100

This commit fixes a security bug in the Eclair Lightning node where a malicious peer could trick the node into permanently giving up on publishing its own commitment or penalty transactions. By publishing and then double-spending a conflicting transaction, an attacker could prevent the node from claiming funds it was owed, potentially allowing the attacker to steal HTLCs or delay justice transactions. The fix makes the node keep retrying publication each block until the conflicting transaction actually confirms.

Security candidateKeep unsigned settlements when rejecting commands (#3401)by pm47 · 7686dfad · Oct 13, 2026 · 2 filesMessage 93 · StrongModerate 66Details
Commit message · pm47

Keep unsigned settlements when rejecting commands (#3401)

When a settlement command was rejected, we scheduled the deletion of the
pending settlement command stored in our DB for that HTLC. But it may have
been rejected because we had already proposed a settlement for that HTLC,
for example when receiving a duplicate of the same command: if that pending
settlement hadn't been signed yet, it would be lost if we disconnected before
signing it, since we wouldn't replay it on reconnection. For a relayed HTLC
that was fulfilled downstream, this could lead to the upstream HTLC timing
out instead of being fulfilled.

We now keep the pending settlement command in our DB in that case: it is
acknowledged once signed.

Reported-By: [project-loupe](https://github.com/project-loupe)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

93/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · Moderate 66/100

This commit fixes a bug in Eclair, a Bitcoin Lightning Network node implementation. When the node received a duplicate command to settle a payment (fulfill or fail), it would mistakenly delete the still-pending settlement from its database. If the node disconnected before that settlement was signed, it would not be replayed on reconnection. For a payment being forwarded through the node, this could mean the downstream side got paid but the upstream side never received the proof it needed, causing the upstream payment to time out and potentially costing the node money. The fix keeps the pending settlement in the database until it has actually been signed.

Security candidateForce-close again when a splice RBF sibling confirms (#3400)by pm47 · 9a1ecc99 · Oct 13, 2026 · 2 filesMessage 81 · StrongModerate 66Details
Commit message · pm47

Force-close again when a splice RBF sibling confirms (#3400)

Since #3376, when our peer withholds their tx_signatures for a splice, we
force-close using a previous commitment, and force-close again if that splice
confirms later. But when the unsigned transaction was an RBF attempt of a
splice, we force-closed using its RBF sibling, which has the same funding tx
index: when the RBF attempt confirmed, we didn't detect that it double-spent
the commit tx we published, and never force-closed again. Our funds stayed
locked until our peer published their commitment, and our HTLCs weren't
enforced on-chain.

We now force-close again whenever the confirmed splice transaction
double-spends the funding transaction of the commit tx we published.

Reported-By: @erickcestari
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · Moderate 66/100

This commit fixes a bug in Eclair, a Bitcoin Lightning Network node implementation. When one node force-closed a channel because its peer never finished signing a 'splice' (a way to resize a Lightning channel on-chain), and the peer later published a different version of that splice (an RBF attempt) which confirmed, Eclair failed to notice that the confirmed transaction had replaced the one used in the force-close. As a result, the node would not re-force-close with the correct commitment, leaving its funds stuck and its payment guarantees unenforced on-chain. The fix makes Eclair re-force-close whenever the confirmed splice transaction spends the same funds as the previously published commitment.

Lower-prioritySettle relayed on-the-fly upstreams on hash reuse (#3399)by pm47 · c96478a8 · Oct 13, 2026 · 2 filesMessage 93 · StrongTriage 0Details
Commit message · pm47

Settle relayed on-the-fly upstreams on hash reuse (#3399)

When an on-the-fly HTLC was settled, we fulfilled the upstream HTLCs of the
payment we were tracking for that payment_hash. But we stop tracking funded
payments when their HTLCs reach their expiry, while those HTLCs can still be
claimed on-chain, and a new payment may then reuse the same payment_hash: we
would fulfill the upstream HTLCs of that new payment instead of the ones of
the payment that was relayed. A colluding payer and recipient could thus
claim the original HTLC downstream while the original upstream HTLCs time
out back to the payer.

We now only consider the tracked payment relayed if it matches the payment
that was settled, and otherwise fulfill the upstream HTLCs of the settled
payment while we keep tracking the new one.

Reported-by: project-loupe
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

93/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Security candidateReject unpublishable splices (#3396)by pm47 · af994180 · Oct 13, 2026 · 5 filesMessage 78 · AdequateCritical 89Details
Commit message · pm47

Reject unpublishable splices (#3396)

Collection of fixes to prevent a malicious peer to make us sign a splice tx that cannot be published.

* Reject interactive txs with a future lock time

Our peer chooses the lock time of interactive transactions (in open_channel2,
splice_init and tx_init_rbf) and we didn't check it. With a lock time far in
the future, the transaction cannot be published: for a splice, we would then
force-close with a commitment that can never confirm, while our peer can
still publish its commitment for the previous funding output, which lets
them steal HTLCs.

We now reject lock times that are more than a few blocks ahead of our current
block height, to allow for small differences in block height with our peer.

* Reject interactive-tx inputs with relative lock times

Our peer chooses the nSequence of the inputs it adds, including the shared
input when it is the splice initiator. We only rejected values that disable
RBF, so our peer could use a relative lock time (BIP 68) to prevent us from
publishing the transaction for up to 65535 blocks: for a splice, we would
then force-close with a commitment that cannot confirm, while our peer can
still publish its commitment for the previous funding output.

We now reject inputs that enable a relative lock time.

* Check signed splice feerate when we don't contribute

We only checked the feerate of the signed interactive transaction when both
peers contributed to it. When we didn't contribute to a splice, our peer
could provide large witnesses for its inputs and make the feerate of the
signed transaction much lower than the target, potentially below the relay
minimum: we would then force-close with a commitment that cannot confirm,
while our peer can still publish its commitment for the previous funding
output.

A splice transaction funds our latest commitment, so we now check its
feerate even when we don't contribute to it.

* Reject non-standard witnesses in tx_signatures

We only checked that our peer's witnesses were valid, using standard script
flags, but not that they satisfied Bitcoin Core's witness standardness rules
(P2WSH stack and script sizes, taproot annex, tapscript stack items) or that
the signed transaction didn't exceed the standard weight. Our peer could thus
make us store a valid splice transaction that cannot be relayed: we would then
force-close with a commitment that cannot confirm, while our peer can still
publish its commitment for the previous funding output.

We now reject such tx_signatures, as required by BOLT 2.

---------

Closes https://github.com/project-loupe/audit-eclair/issues/62
Closes https://github.com/project-loupe/audit-eclair/issues/91
Closes https://github.com/project-loupe/audit-eclair/issues/400
Closes https://github.com/project-loupe/audit-eclair/issues/265

Reported-By: [project-loupe](https://github.com/project-loupe)
Reported-By: @erickcestari
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

78/100 · AdequateMessage clarity
✓ Descriptive subject✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundarysigning or wallet path
AI analysis · Critical 89/100

This commit fixes a set of vulnerabilities in Eclair's Lightning channel splicing protocol that could let a malicious peer trick the victim into signing a splice transaction that can never be published on the Bitcoin network. Because the victim's latest commitment transaction depends on that splice transaction confirming, the victim would be unable to recover their funds through a normal force-close, while the attacker could still broadcast an older commitment and steal HTLCs (pending routed payments). The fixes reject future lock times, relative time locks on inputs, non-standard witnesses, and too-low feerates when the victim does not contribute to the splice.

Security candidateReject onion per-hop lengths exceeding packet (#3395)by pm47 · d3a146a0 · Oct 13, 2026 · 2 filesMessage 81 · StrongHigh 74Details
Commit message · pm47

Reject onion per-hop lengths exceeding packet (#3395)

The sender knows the shared secret, so it can build an onion with a valid
hmac whose per-hop payload length is larger than the packet. We didn't
check that length: we either decoded a garbage next packet, or threw when
extracting the hmac, outside of the Try. This exception escaped the relayer
(which was then resumed, so the HTLC was never failed) and would prevent
PostRestartHtlcCleaner from initializing on the next restart.

We now return InvalidOnionVersion, as we already do for an invalid length.

Closes https://github.com/project-loupe/audit-eclair/issues/104
Closes https://github.com/project-loupe/audit-eclair/issues/215
Closes https://github.com/project-loupe/audit-eclair/issues/140

Reported-By: [project-loupe](https://github.com/project-loupe)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
cryptography-sensitive path
AI analysis · High 74/100

This commit fixes a bug in how Eclair processes encrypted routing instructions (onion packets) for Lightning payments. A malicious sender could craft a packet that claimed its inner payload was longer than the packet itself. The old code either produced garbage or crashed outside of the expected error-handling path. That crash could escape the payment relayer, meaning the node would not properly fail the affected payment, and it could also break startup recovery code after a restart. The fix adds a length check and returns a standard invalid-onion error instead of crashing.

Lower-priorityOnly relay on-the-fly payment on funded channel (#3394)by pm47 · 6b61581f · Oct 13, 2026 · 2 filesMessage 81 · StrongTriage 0Details
Commit message · pm47

Only relay on-the-fly payment on funded channel (#3394)

We previously relayed funded on-the-fly payments on any channel with our peer whose funding index was high enough. At expiry we only inspect the funded channel, so we could fail upstream while the HTLC was still claimable on another channel.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Lower-priorityUse published commitment in PostRestartHtlcCleaner (#3393)by pm47 · 248893a3 · Oct 8, 2026 · 2 filesMessage 81 · StrongTriage 0Details
Commit message · pm47

Use published commitment in PostRestartHtlcCleaner (#3393)

Since #3376 we may force-close with an older commitment, so HTLC outputs must be matched against the commitment of the published commit tx, as the live CLOSING handler already does.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Security candidateRemove `spendfromchanneladdress` nonce after one sig (#3392)by pm47 · c89af115 · Oct 8, 2026 · 1 fileMessage 98 · StrongModerate 53Details
Commit message · pm47

Remove `spendfromchanneladdress` nonce after one sig (#3392)

Nonces must not be re-used. Although `spendfromchanneladdress` is a
manual recovery operation, there is no reason why we keep the nonce
after the first signature.

Fixes https://github.com/project-loupe/audit-eclair/issues/35.

98/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
signing boundary
AI analysis · Moderate 53/100

This commit fixes a cryptographic safety issue in a manual Bitcoin/Lightning recovery tool. When a user runs the `spendfromchanneladdress` operation, the code was re-reading a secret signing nonce from a stored map after using it once. Nonces must never be reused in this signature scheme, because reuse can leak the private key. The change removes the nonce from the map immediately after it is used, so it cannot be reused accidentally or maliciously in a later signature.

Lower-priorityValidate remote closing script updates (#3387)by pm47 · 380feec7 · Oct 6, 2026 · 3 filesMessage 76 · AdequateTriage 8Details
Commit message · pm47

Validate remote closing script updates (#3387)

We only validated our peer's closing script in their first shutdown. Subsequent shutdown messages (in `SHUTDOWN`, `NEGOTIATING` and `NEGOTIATING_SIMPLE`) and closing_complete could replace it with an arbitrary script and bypasses option_upfront_shutdown_script.

We now ignore those messages and send a warning when the script is invalid, as required by BOLT 2.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

76/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
defensive validation
Lower-priorityHarden interactive-tx funding against a malicious bitcoind (#3390)by pm47 · e43fbf69 · Oct 5, 2026 · 4 filesMessage 81 · StrongTriage 8Details
Commit message · pm47

Harden interactive-tx funding against a malicious bitcoind (#3390)

With the "Eclair signer" mode, bitcoind selects coins and builds transactions, but Eclair holds the keys and signs. A compromised bitcoind therefore can't steal wallet funds directly. But it could still make us pay excessive mining fees during dual-funding and splicing by under-reporting the fee or by tampering with the outputs we rebuild our contributions from.

Fixes:
- https://github.com/project-loupe/audit-eclair/issues/54
- https://github.com/project-loupe/audit-eclair/issues/262
- https://github.com/project-loupe/audit-eclair/issues/264

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
defensive validation
Security candidateReject seed files with an invalid length (#3389)by pm47 · a07fff56 · Oct 5, 2026 · 2 filesMessage 88 · StrongModerate 66Details
Commit message · pm47

Reject seed files with an invalid length (#3389)

Seed files were read without checking their length. Creating a seed file is not atomic: if we crash between creating the file and writing the seed, an empty seed file is left behind. On the next restart we
would then derive our node and channel keys from an empty seed.

We now refuse to start if a seed file doesn't contain exactly 32 bytes. The only exception is legacy seeds (before 31022ceca5), which were serialized compressed private keys: 32 bytes followed by 0x01. We keep accepting them, without dropping the trailing byte, so that our keys don't change.

88/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
secret or key materialcryptography-sensitive path
AI analysis · Moderate 66/100

This patch fixes a bug in the Eclair Bitcoin Lightning node where, if the node crashed while creating its secret seed file, it could leave an empty file behind. On the next restart, Eclair would silently use that empty seed to generate all the node's private keys, producing predictable keys that could let an attacker steal funds. The fix now refuses to start unless the seed file contains exactly 32 bytes, while still accepting older 33-byte legacy seed files.