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.
Message quality measures whether a commit identifies its scope, purpose, rationale, testing, and supporting references. It does not change the security-severity score.
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
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
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
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
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
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
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
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
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
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)
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
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
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
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
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
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
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
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
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)
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…
Expand any commit for its author, full message, clarity score, changed files, triage signals, analysis, and source link.
Security candidateAdd support for fulfillment payload (#3321)by Bastien Teinturier · 1819a5e8 · Aug 21, 2026 · 44 filesMessage 88 · StrongLow 37Details
Commit message · Bastien Teinturier
Add support for fulfillment payload (#3321)
This adds support for including a payload in `update_fulfill_htlc` that the recipient encrypts for the payer. This can be useful to transmit data atomically with the fulfillment of a payment. The main challenge is that intermediate nodes may drop or tamper with this fulfillment payload, which is why we include it in the HMACs of the attribution data, which lets senders detect which pair of nodes may be malicious.
We limit error packets and fulfillment payloads to 32kB to leave room for future TLVs. We silently truncate payloads that are larger, which ensures that the messages we create are always compliant. We truncate attribution data that doesn't have the expected length as well.
See https://github.com/lightning/bolts/pull/1344
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
cryptography-sensitive pathparser or protocol path
AI analysis · Low 37/100
This commit adds a new optional encrypted payload to Lightning payment fulfillment messages. It is a feature implementation, not a fix for an active vulnerability. The code does introduce a safety check: if a peer sends an oversized fulfillment payload, the node force-closes the channel after first relaying the payment preimage upstream so funds are not lost. The main risk is that any bugs in the new encryption, wrapping, or truncation logic could affect payment settlement or channel stability, but the commit itself is defensive and follows a proposed Lightning specification.
Security candidateExplicitly match on-the-fly HTLCs after a restart (#3357)by Bastien Teinturier · aa321d69 · Aug 19, 2026 · 3 filesMessage 93 · StrongHigh 72Details
Commit message · Bastien Teinturier
Explicitly match on-the-fly HTLCs after a restart (#3357)
When we restart our node, we look at HTLCs that have been received but not relayed yet: they must be failed back, otherwise we would let them in the incoming channel until their timeout is reached, which would force our peer to force-close.
There is an exception for HTLCs that are paying for an on-the-fly funded channel: we will explicitly retry relaying those HTLCs, even after a restart, because that's how we get paid for the funding fees. We were only matching them by `payment_hash`, which wasn't precise enough: an attacker could initiate an on-the-fly channel and then send unrelated HTLCs that use the same `payment_hash`, just to mess up with us and get some of our channels force-closed.
We already have the detailed information about on-the-fly HTLCs in our DB, so we now use that to match HTLCs on the corresponding `channel_id` and `htlc_id`, which guarantees uniqueness.
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
explicit security language
AI analysis · High 72/100
This commit fixes a bug in the Eclair Lightning node where, after a restart, the node could be tricked into keeping the wrong incoming payments alive. An attacker could reuse the same payment identifier (payment_hash) from a legitimate in-flight channel funding request on unrelated payments. Because the old code matched only by payment_hash, those unrelated payments would be treated as part of the funding flow and not failed back. If left unresolved until their deadline, this could force the node to force-close its channels, costing money and disrupting service. The fix matches by the exact channel and HTLC identifier instead, which is unique.
Better documentation for remote `bitcoind` (#3359)
Our documentation didn't make it clear enough that `bitcoind` should ideally run on the same machine as `eclair`. If that's not possible, since `bitcoind` doesn't provide support for TLS for its RPC and ZMQ endpoints, the node operator MUST setup a secure tunnel (providing encryption and authentication) between `eclair` and `bitcoind`. If that isn't provided, a network attacker may drop or alter messages between `eclair` and `bitcoind`, which can lead to a loss of funds.
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
This commit only updates user documentation. It adds warnings that the Bitcoin node (bitcoind) should run on the same machine as Eclair, and if it runs remotely, operators must use a secure encrypted tunnel. No code was changed, so this patch does not by itself fix or introduce a security flaw.
When restarting our node, we have a custom hook to avoid failing HTLCs downstream when they're used with on-the-fly funding, because we want to retry relaying those HTLCs. That doesn't apply to on-chain failures though, because at that point the downstream channel has been closed.
* Don't relay on-the-fly HTLCs twice after restart
Before relaying on-the-fly HTLCs, we verify that they aren't already being relayed. We only look at the pending changes, because once the HTLCs are relayed we change their in-memory state in the Peer actor.
But if we restart after cross-signing on-the-fly HTLCs, we previously would relay them again, thus paying the downstream user twice. We now also look at the commitment transactions to avoid that.
* Force-close unpaid on-the-fly channels
When we fund an on-the-fly channel for which fees must be paid in the follow-up HTLCs, our peer may act maliciously and ignore those HTLCs when we relay them after funding the channel. We've already funded the channel so it's too late to recover the on-chain fees we've paid, so we previously just failed back the corresponding upstream HTLCs and gave up on relaying them to the funded channel.
However, the HTLCs may already be cross-signed and pending on the funded channel, which means that our peer could fulfill it and get paid while we have failed the corresponding upstream HTLCs. In that case, we lose funds. We can only fail the upstream HTLCs if we're sure that we haven't relayed them yet,
Since obtaining this state is asynchronous and complex, we now opt-in to a safer approach: we force-close the channel, check its commitments, and only fail the upstream HTLCs that weren't relayed. If they have been relayed, they will automatically be failed back when our HTLC-timeout transaction confirms.
* Reject on-the-fly payment for batch of `payment_hashes`
While the protocol supports batching `payment_hashes`, we currently only use it for one `payment_hash` at a time. It's thus safer to restrict it to this to prevent potential abuse. We also explicitly reject the case where an attacker tries to insert the same `payment_hash` twice to mess up our state.
* Correctly relay preimages upstream after timeout
If we receive the preimage for an on-the-fly payment *after* the HTLC has timed out, we still need to relay that preimage upstream, otherwise we've paid downstream without being paid upstream.
98/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
explicit security languagesigning boundarysigning or wallet path
AI analysis · High 78/100
This commit fixes several bugs in Eclair's 'on-the-fly funding' feature, which lets a node open a Lightning channel and pay for it using future payment fees. The bugs could allow a malicious peer to make the node pay twice, lose money on force-closed channels, or fail to collect incoming payments after timeouts. The patch adds checks to prevent double-relaying payments, force-closes channels when fees are unpaid, and ensures preimages are still forwarded upstream even after an HTLC timeout.
Security candidateHarden permissions of seeds and datadir (#3340)by rorp · 17edd765 · Aug 13, 2026 · 4 filesMessage 53 · ThinModerate 62Details
Commit message · rorp
Harden permissions of seeds and datadir (#3340)
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
defensive validationcredential or privilege statecryptography-sensitive path
AI analysis · Moderate 62/100
This commit tightens file and folder permissions for Eclair's sensitive data. It ensures that seed files (which protect the node's identity and Lightning channel funds) and the data directory are readable only by the owner on Linux/macOS systems. Previously, these files could inherit looser default permissions, potentially allowing other local users on the same machine to read secrets and steal funds. Windows is unaffected because it uses a different permission model.
While `DEBUG` logs shouldn't be activated on mainnet, it is dangerous that they expose key material. We remove those logs.
* Remove onion shared secrets from unparsable failure logs
When receiving a failure that we couldn't parse, we added the shared secrets in the logs to help us troubleshoot (because we've seen that error frequently on our node). It didn't let us figure out the issue, which most likely comes from a buggy intermediate or final node. We now remove those secrets from the logs for safety.
* Make incoming connection tracker idempotent
If we receive multiple times a request to track a given node, we ignore the redundant ones.
* More robust network DB clean-up on restart
On restart, we remove `channel_update`s that we cannot decode from our network DB. The way the code was written could be an issue depending on the postgres driver, because it potentially interleaved SELECT and DELETE clauses. It apparently doesn't matter for our current version of the postgres driver, but it's more future-proof to explicitly split the SELECTs from the DELETEs.
* Check wake-up config before trying message wake-up
We didn't check the wake-up config parameter when relaying onion messages, which wasted resources by creating actors that would be useless.
* Include wallet node_id encoding when resolving blinded paths
When resolving the introduction point of a blinded path and checking whether one of the nodes is ourselves, we must check that with all potential encodings, including the wallet-reserved one.
* Don't include extraneous HTLCs in trampolinefee calculation
When relaying a trampoline payment, we must ensure that we don't include extraneous payments (that are rejected), otherwise we will use a very large route fee budget.
* Correctly clean up MPP payment-initiator state
When directly crafting MPP payments using the `sendtoroute` API, we use the child payment ID as tracking key in the `PaymentInitiator` internal state. If the payment fails, the `PaymentFailed` event will correctly use that ID, so the state will be cleaned up. But if the payment succeeds, the `PaymentSent` event uses the *parent* payment ID so the state wasn't correctly cleaned up. We now clean up the child state as well.
* Explicitly handle empty payment types
We've recently improved our liquidity ads codec, but we weren't properly handling the case where no payment types are provided (even though this will likely be rejected by remote nodes).
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
cryptography-sensitive pathparser or protocol path
AI analysis · Moderate 64/100
This commit is a bundled maintenance patch for the Eclair Lightning node. It removes sensitive cryptographic keys and shared secrets from debug/error logs, fixes a bug where rejected payments could still be counted when calculating trampoline routing fees, prevents state leaks in manually crafted multi-part payments, makes incoming-connection tracking idempotent, avoids unnecessary peer wake-up attempts, handles an edge case in liquidity-ads encoding, separates database SELECT and DELETE operations for safety, and correctly recognizes wallet-encoded node IDs when resolving blinded payment paths. Several of these changes have clear security relevance, particularly the logging cleanup and the trampoline-fee fix, but they are defensive hardening and bug fixes rather than a single critical vulnerability.
Security candidateMultiple bug fixes found by AI scanning (#3346)by Bastien Teinturier · 0c4ddc4d · Aug 12, 2026 · 5 filesMessage 88 · StrongHigh 74Details
Commit message · Bastien Teinturier
Multiple bug fixes found by AI scanning (#3346)
* Fix 0-fee commitments fee bumping with remote-main
When using 0-fee commitments, if our peer publishes their commitment and our main output is large enough, we don't need to use a wallet input to pay RBF fees, we can directly do it using our main output.
However, we didn't take into account the whole package weight when doing so: this means that there was a balance range where we would not correctly bump the commit tx to the target feerate.
* Retry transaction publishing on unclassified failures
We classify bitcoind publish failures by substring-matching the RPC error message. Any rejection that doesn't match any of the RPC error messages that we know would previously not be retried.
This was dangerous, as it could cause us to abandon a time-sensitive transaction, which could cause loss of funds. We now eagerly retry when we cannot classify the RPC publish failure.
* Fix `channel_ready` using invalid musig2 nonce if RBF
We must use `commitments1` instead of `d.commitments` when creating our `channel_ready` message to ensure that we use the correct musig2 nonce for taproot channels. Otherwise, if we have multiple RBF attempts and the ony confirming is *not* the latest one, we will use the wrong nonce.
* Fix out-of-bound array access in payment FSM
Remote failures can be manipulated to trigger an out-of-bound array access which crashes the payment lifecycle actor.
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
nonce handling
AI analysis · High 74/100
This commit fixes four separate bugs in the Eclair Lightning node, all reported as found by AI scanning. Two of the bugs can cause loss of funds: one miscalculates transaction fees when bumping a channel close, and another could abandon time-sensitive transactions on unrecognized Bitcoin RPC errors. A third bug could use the wrong cryptographic nonce after a channel funding RBF, and a fourth could crash the payment actor via a maliciously crafted remote failure message. The commit is a straightforward set of fixes, but it is partial in the sense that it does not include broader hardening beyond the specific bugs identified.
Correctly handle unknown flags in `channel_update` (#3341)
We previously ignored unknown `channel_flags` and `message_flags` in the channel updates we received at decoding time, which means we would always replace them by `0` when re-encoding the channel update before forwarding it. If a flag that we don't understand was set to `1`, the signature becomes invalid.
In order to be future-proof, we must preserve the values of unknown flags during a codec round-trip: this way old eclair nodes will still correctly relay future channel updates that contain flags that haven't yet been specified.
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 boundaryparser or protocol path
AI analysis · Moderate 64/100
This commit fixes a bug in how Eclair handled unknown flag bits in Lightning 'channel_update' messages. Previously, the software silently cleared any flag bits it did not recognize when re-encoding a message before forwarding it. Because those flag bits are part of the signed data, clearing them made the digital signature invalid. The fix now preserves all unknown flag bits through a decode-encode round trip, so older Eclair nodes can still correctly relay future channel updates that use newly defined flags.
When our peer sends us an invalid `tx_signatures`, we processed it and ignored the failure when we've already sent our own `tx_signatures`, because the transaction may be broadcast and may confirm anyway.
We now stop processing those invalid `tx_signatures` repeatedly: if our peer sends us more than 3 invalid `tx_signatures` for a given funding transaction, they're definitely buggy so we'll just wait for the transaction to confirm without trying to obtain the fully signed one locally.
We also now avoid unnecessary DB writes on `shutdown`. We don't need to write to the DB every time we receive `shutdown` from our peer, since the BOLTs require `shutdown` to be retransmitted on reconnection.
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
signing boundary
AI analysis · Low 47/100
This update changes how the Eclair Lightning node handles repeated bad 'tx_signatures' messages from a peer during dual-funded channel opens and splices. Previously, every bad signature was processed and logged, which could waste CPU and disk writes and might be abused to keep a node busy. Now, after three bad signatures for the same funding transaction, the node stops processing them and just waits for the on-chain confirmation. The patch also removes unnecessary database writes when receiving repeated 'shutdown' messages. The commit message frames this as a robustness improvement against buggy or malicious peers, not as a critical vulnerability fix.
✓ 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 pathsigning or wallet path
AI analysis · Informational 22/100
This commit updates Eclair's underlying Bitcoin library from version 0.47 to 0.48 and makes small code adjustments to match the new library's API. The changes touch how private keys are derived and how test data is converted. There is no direct evidence in the commit that this fixes a security vulnerability, but library updates can include bug fixes or improvements that affect cryptographic handling.
We refactor the attribution data code to make it more consistent with the rest of the Sphinx-related code. We add comments and intermediate variables to make it more readable. We introduce intermediate classes to hold data and add better symmetry between the success and failure cases.
This will make it easier to implement trampoline attribution and add fulfillment data (https://github.com/lightning/bolts/pull/1344).
* Refactor trampoline attribution data
We correctly extract shared secrets (including trampoline shared secrets) and detect when we're inside a blinded path to avoid including attribution data. Note that we don't use the trampoline shared secret yet, since full trampoline isn't implemented (see https://github.com/ACINQ/eclair/pull/2819 for the full changes).
We add tests for attribution data with blinded paths and trampoline payments.
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
cryptography-sensitive path
AI analysis · Low 34/100
This commit is a code refactor of how Eclair handles 'attribution data'—extra encrypted timing and accountability information attached to Lightning payment success and failure messages. It restructures the code to support future trampoline payments and blinded routes, and adds tests. The commit itself does not claim to fix a security bug; it is described as making later features easier to implement. However, the refactor changes how shared secrets are extracted and how attribution data is included or omitted for blinded and trampoline payments, which touches privacy-sensitive logic.
Security candidateAdd support for zero-fee commitment format (#3192)by Bastien Teinturier · 35403401 · May 20, 2026 · 42 filesMessage 100 · StrongLow 34Details
Commit message · Bastien Teinturier
Add support for zero-fee commitment format (#3192)
* Add support for zero-fee commitment format
We add support for the zero-fee commitment format specified in https://github.com/lightning/bolts/pull/1228.
Channels using this commitment format benefit from better protection against pinning attacks (thanks to TRUC/v3 transactions), don't need the `update_fee` mechanism, have less dust exposure risk, and use an overall simpler state machine.
In this commit, we simply introduce the commitment format and create the corresponding transactions.
* Rename `ClaimRemoteDelayedOutputTx`
It isn't delayed anymore for v3 transactions. We could use static wallet public key, but in most cases it wouldn't work and adds extra complexity so we don't do it. We add a comment in the documentation of this class to explain why we're always making a 2nd-stage transaction.
* Validate channel parameters
We apply slightly different validation for zero-fee commitments:
- the commit feerate must be `0 sat/byte` - the max number of accepted HTLCs must be at most 114 - `update_fee` cannot be used
We verify those requirements during channel creation and add tests for normal channel operation.
* Handle force-closing zero-fee channels
We add support for force-close zero-fee channels. When publishing the local commit, this works mostly the same way as other channel types. The only difference is that we don't even attempt to publish the commit tx individually: we always bundle it with the anchor transaction.
When we detect the remote commit though, we're able to introduce some new behavior:
- if we have a large enough main output, we use that to pay the fees of the remote commit tx (unless it is already confirmed), which avoids using a wallet input - otherwise, we spend the anchor output, which competes with the remote peer package
Since we're only using the anchor transaction or our main output to spend the ephemeral anchor, we cannot publish HTLC txs until the commit tx is confirmed. We will in the future make *all* transactions go through the `ReplaceableTxPublisher`, and at the point we'll be able to simplify this, but it's too early for this refactoring, so for now we simply wait for the commit tx to be confirmed before publishing HTLC txs.
* Don't force-close on remote `error`
When using zero-fee commitments, we don't force-close when receiving an `error` from our peer: if they want to force-close the channel, they can publish their commitment instead of forcing us to publish ours. It is especially true when the commit tx doesn't pay any fees, because the publisher will pay the entire fees for the force-close.
Note that for wallet peers, we could introduce a mechanism where they send us their signed commit tx in the error message if they don't have any wallet input to pay the fees, and we could be nice and publish it while paying the fees from our main output (which isn't delayed since it is the remote commit from our point of view).
100/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
explicit security languagedefensive validationsigning or wallet path
AI analysis · Low 34/100
This commit adds an experimental new Lightning channel type to Eclair called 'zero-fee commitments.' It is a large feature patch implementing a draft BOLT specification (PR 1228), not a fix for a known vulnerability. The change introduces new transaction formats, validation rules, and force-close behavior. Because it is experimental, disabled by default, and extensively tested, it is unlikely to be an immediate security issue, but any large change to consensus-sensitive transaction code carries risk of subtle bugs.
Security candidateBump org.postgresql:postgresql version (#3305)by Bastien Teinturier · 76da19f1 · May 7, 2026 · 2 filesMessage 81 · StrongLow 36Details
Commit message · Bastien Teinturier
Bump org.postgresql:postgresql version (#3305)
This fixes a vulnerability, which doesn't apply to eclair in known deployements, but is worth fixing in case some nodes use untrusted database hosts which could lead to DoS attacks.
81/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
This commit updates the PostgreSQL database driver used by the Eclair Lightning node software from version 42.7.8 to 42.7.11. The commit message says this fixes a vulnerability that could allow denial-of-service (DoS) attacks if a node connects to an untrusted database host. The developers state it does not affect known Eclair deployments, but they are patching it as a precaution.
Security candidateFix flaky DER signature weight test (#3299)by Bastien Teinturier · 0f5d4b89 · May 5, 2026 · 1 fileMessage 100 · StrongInformational 15Details
Commit message · Bastien Teinturier
Fix flaky DER signature weight test (#3299)
This test was flaky because for the funding output, we provide two signatures, which means that we need twice the slack for the variable DER encoding length.
100/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
signing boundarysigning or wallet path
AI analysis · Informational 15/100
This commit only adjusts a flaky unit test that checks transaction weight estimates. It widens the allowed tolerance for variable-length ECDSA signatures when two signatures are involved instead of one. There is no change to production code, no security fix, and no vulnerability.
Security candidateAdd support for the official splicing protocol (#2887)by Bastien Teinturier · 68b0096a · Apr 30, 2026 · 24 filesMessage 93 · StrongLow 35Details
Commit message · Bastien Teinturier
Add support for the official splicing protocol (#2887)
We replace our experimental version of `splice_init`, `splice_ack` and `splice_locked` by their official version. If our peer is using the experimental feature bit, we convert our outgoing messages to use the experimental encoding and incoming messages to the official messages.
We also change the TLV fields added to `tx_add_input`, `tx_signatures` and `splice_locked` to match the spec version. We always write both the official and experimental TLV to updated nodes (because the experimental one is odd and will be ignored) but we drop the official TLV if our peer is using the experimental feature, because it won't understand the even TLV field.
We do the same thing for the `commit_sig` TLV. For peers who support the official splicing version, we insert the `start_batch` message before the batch of `commit_sig` messages.
This guarantees backwards-compatibility with peers who only support the experimental feature.
We introduce a `retransmit_flags` field to `my_current_funding_locked` and `next_funding` to ask our peer to retransmit `commitment_signed` or `announcement_signatures` if we're expecting them. With this change, we don't need to retransmit `splice_locked` on reconnection anymore to trigger the exchange of `announcement_signatures`. We don't need to retransmit it to let our peer know that we've seen enough confirmations for the splice either, since `my_current_funding_locked` implies that.
This allows us to completely remove retransmission of `splice_locked` on reconnection, and also get rid of the `your_last_funding_locked` TLV, which greatly simplifies the reconnection logic. We do keep them for backwards-compatibility with existing Phoenix users though, but we'll be able to clean it up once they have updated.
Note that this works with taproot channels since we will simply provide nonces in `channel_reestablish` when we need our peer to send announcement signatures (not supported yet since taproot channels are never announced).
We rollback using the `next_commitment_number` to let our peer know that we haven't received their `commit_sig` and instead use the retransmit flags added to the `next_funding` TLV, unless our peer is using the legacy splicing protocol.
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 boundarysigning or wallet pathauthentication pathparser or protocol path
AI analysis · Low 35/100
This commit adds official Lightning channel splicing support to Eclair and replaces an experimental protocol. It includes backwards-compatibility shims for older Phoenix wallets, changes how reconnection messages request retransmission of signatures, and renumbers some protocol feature bits. The changes are broad and touch consensus-critical wire protocol and channel state logic, so bugs could affect channel safety, but the commit itself is a feature implementation rather than a clear security fix.
Security candidateStore our closing_complete in the simple close session (#3289)by Fabrice Drouin · da7cd962 · Apr 21, 2026 · 4 filesMessage 96 · StrongLow 32Details
Commit message · Fabrice Drouin
Store our closing_complete in the simple close session (#3289)
In the simple close session, which is never persisted, we just need to remember our closing_complete and the partial signatures it contains, instead of keeping our musig2 nonces and generating our partial signatures a second time to build the final closing tx when we receive our peer's partial signatures. We also check our peer's partial signature and fail early if they're not valid, instead of building a fully sign closing tx and then verify that it is correct.
96/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
signing boundarynonce handlingsigning or wallet path
AI analysis · Low 32/100
This commit changes how Eclair (a Bitcoin Lightning node) remembers its own closing signatures during a mutual channel close. Previously, the code re-generated signing nonces and re-signed closing transactions when the peer's signature arrived. Now it stores the original closing message and reuses its signatures. It also adds an early check that the peer's partial signature is valid before trying to build a final signed transaction. The change is a defensive correctness improvement rather than a clear fix for an active exploit.
``` A node receiving a ping message: - if num_pong_bytes is less than 65532: - MUST respond by sending a pong message, with byteslen equal to num_pong_bytes. - otherwise (num_pong_bytes is not less than 65532): - MUST ignore the ping. ```
These reply-less pings are used to insert cover traffic to thwart network-level traffic analysis. We wanted to allow them in #3278 but we missed this ping flood protection that needed to be updated.
We also had an off-by-one in the maximum pong length that is now fixed.
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
cryptography-sensitive path
AI analysis · Moderate 51/100
This commit fixes two related bugs in how Eclair handles Lightning network 'ping' messages. First, it corrects an off-by-one error so pings asking for a 65532-byte reply are now ignored (matching the BOLT1 spec), instead of being answered. Second, it stops treating these 'reply-less' pings as a flood attack, so they no longer count toward the pending-ping limit that disconnects peers. The practical effect is that legitimate cover-traffic pings no longer risk getting a peer disconnected, and the protocol boundary now matches the specification.
Security candidateAdd backwards-compatible parts of the official splicing protocol (#3261)by Bastien Teinturier · 129df369 · Apr 3, 2026 · 12 filesMessage 86 · StrongLow 35Details
Commit message · Bastien Teinturier
Add backwards-compatible parts of the official splicing protocol (#3261)
* Add `funding_txid` to `commit_sig`
In https://github.com/lightning/bolts/pull/1160 we add a TLV field to `commit_sig` messages to let the receiver know to which `funding_txid` this signature applies. This is more resilient than relying on the order of the `commit_sig` messages in the batch. This is an odd TLV, so we can start writing it right now without creating compatibility issues.
We also slightly refactor existing code to make it easier to introduce a backwards-compat layer when migrating to the official splicing. We also increase the default number of RBF attempts allowed.
* Insert a `start_batch` message during splices
In https://github.com/lightning/bolts/pull/1160, we introduce a message to let our peer know how many `commit_sig` messages they will receive and treat them as a batch. This replaces our previous version that did something similar, but by adding a batch TLV in every `commit_sig` message we send.
We currently do both: we keep inserting the experimental batch TLV, and we start by sending a `start_batch` message (with the same information). Since it is an odd message (127), it should be safely ignored if our peer doesn't understand it.
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
signing boundaryparser or protocol path
AI analysis · Low 35/100
This commit updates the Eclair Lightning node software to support a new, backwards-compatible draft of the official Bitcoin Lightning 'splicing' protocol. It adds a funding transaction identifier to commitment signatures and introduces a 'start_batch' message so peers know when multiple signatures belong together. It also keeps the older experimental batching mechanism for compatibility with older Phoenix wallets. The changes are primarily a protocol upgrade and compatibility shim, not a clear security fix, though they reduce ambiguity about which signature applies to which funding transaction during splices.
Add a fuzzing module based on Jazzer to allow fuzzing parts of eclair. This commit includes fuzz tests for codecs to be used as examples. It is a separate module (minimal interaction with the other modules). We include helper scripts to run many fuzz tests in parallel or generate reports.
76/100 · AdequateMessage clarity
✓ Descriptive subject✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
fuzzing or regression evidencecryptography-sensitive pathparser or protocol path
AI analysis · Informational 15/100
This commit adds a new testing-only module that uses a fuzzing tool called Jazzer to automatically throw random data at Eclair's Lightning message parsers. It does not change any production code, network behavior, or security logic. It is purely a defensive testing improvement.
* der2compact() and compact2der() methods have been removed, new signInputCompact() method has been added
* Use Transaction.encodeWitnessEcdsaSig() instead of low-level calls
* Replace local der() methode with bitcoin-lib's encodeWitnessEcdsaSig()
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
cryptography-sensitive pathsigning or wallet path
AI analysis · Informational 22/100
This commit updates Eclair to use a newer version of its underlying Bitcoin library (bitcoin-lib 0.47). Most changes are mechanical: replacing local helper functions with new library-provided equivalents for encoding signatures and signing transaction inputs. There is no direct evidence in the commit message or diff that this fixes a specific security vulnerability, but it does touch cryptographic code and updates a dependency, which can sometimes address bugs or weaknesses in the library itself.
Close connection when receiving malformed messages (#3273)
When receiving a message that we're supposed to be able to decode, for which decoding fails, we must send a warning and close the connection. This ensures that the connection state cannot become corrupted, which may otherwise happen if we fail to deserialize a `commit_sig` message (for example) and simply ignored it while continuing to process the next messages.
Fixes #3271
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
cryptography-sensitive path
AI analysis · High 70/100
This patch fixes a bug in Eclair, a Bitcoin Lightning Network node implementation. Previously, if a peer sent a message that Eclair couldn't properly decode (for example, a corrupted or unexpected 'commit_sig' message), Eclair would log a warning but otherwise ignore it and keep processing later messages. This could cause the two peers' views of the channel state to drift out of sync, potentially leading to incorrect behavior or security issues. The fix makes Eclair send a warning back to the peer and immediately close the connection when it fails to decode a message it expected to understand.
✓ Descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body✓ Links an issue, advisory, or supporting reference
Why it was queued
cryptography-sensitive path
AI analysis · Informational 23/100
This commit updates the PostgreSQL JDBC driver used by the Eclair Lightning node software from version 42.6.0 to 42.7.8, and also bumps the embedded PostgreSQL test library from 2.0.1 to 2.2.0. The accompanying checksum file is updated to match the new library versions and their transitive dependencies. The commit message frames this as a routine minor library upgrade. There is no direct code change in Eclair itself, and no explicit security advisory or CVE is referenced in the commit materials.
Security candidateAdd duration information to payment events (#3241)by Bastien Teinturier · 9856db85 · Jan 20, 2026 · 32 filesMessage 81 · StrongInformational 19Details
Commit message · Bastien Teinturier
Add duration information to payment events (#3241)
We now record start and end time for payment events, and for remote failures, which lets us easily identify slower paths and faulty nodes. We properly track the settlement of each individual payment now.
We also clean-up field names and harmonize those events. Note that we don't update the DB schema at that point: this will be done in another PR that batches all DB schema changes.
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 pathseed or entropy path
AI analysis · Informational 19/100
This commit is a refactoring and observability improvement for the Eclair Lightning node. It adds start/end timestamps to payment events and failures, renames some timestamp fields for consistency, and updates how payment hashes are derived from preimages. There is no direct security vulnerability visible in the diff; the changes are primarily for monitoring, metrics, and database/event-stream hygiene. A few places now use the current time instead of a previously stored request time when recording relay settlement, which is a behavioral change but not an obvious exploit.
✓ 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 pathsigning or wallet pathparser or protocol path
AI analysis · Low 27/100
This commit updates Eclair to use a newer version of its underlying Bitcoin library (bitcoin-lib 0.46). The main change is a code refactor in how Taproot addresses and scripts are created: instead of passing an optional script tree, callers now explicitly choose between a 'key path' tweak (for simple key-spending) or a 'script path' tweak (for script-spending). The commit also updates related cryptographic checksums and test code. There is no direct evidence in the commit message or diff that this fixes a known security vulnerability; it appears to be a routine dependency and API refactor.
Security candidateIdentify failing node by its index (#3224)by Thomas HUET · 856e236f · Dec 15, 2025 · 16 filesMessage 76 · AdequateLow 35Details
Commit message · Thomas HUET
Identify failing node by its index (#3224)
When a HTLC is failed remotely, the failing node was previously identified by its node id. However this is not enough if the same node appears multiple times in the payment route, for instance for circular rebalancing. We now identify the failing node using its index in the payment route.
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
cryptography-sensitive path
AI analysis · Low 35/100
This commit fixes a routing bug in the Eclair Lightning node. When a payment failed somewhere along the path, the software used to identify the failing node only by its public key. That caused confusion when the same node appeared more than once in a route (for example, in circular rebalancing payments), because the wrong occurrence could be blamed. The fix adds the failing node's position (index) in the route so the correct hop is identified. This is a correctness/reliability improvement rather than a direct theft-of-funds vulnerability, but misidentifying the failing hop could lead to poor routing decisions, unnecessary retries, or incorrect blacklisting of channels/nodes.