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 only updates documentation. It adds new version entries to the manual page for the lightning-downgrade tool and mentions the tool in the upgrade guide. No code, database logic, or security behavior is changed.
This is a packaging/build fix, not a security vulnerability. The `lightning-downgrade` utility was being compiled but accidentally left out of the list of programs installed by `make install`. As a result, official release archives contain…
This commit fixes a database upgrade bug in Core Lightning. Wallets created with version v26.06.10 were missing two new tables (our_outputs and our_txs) because they skipped the migrations that create them. When users later upgraded, a fol…
Database migration failure could prevent node startup after upgradeFixes missing table creation before data backfillAdds regression test for upgrade path from v26.06.10
This commit is a routine version bump from v26.06.10 to v26.12rc1 for Core Lightning. It only updates version strings in packaging files, a changelog, and a lockfile. There are no code changes that introduce, fix, or modify any security-se…
This commit fixes a database bug in Core Lightning where failure details for a payment attempt were being overwritten by later retry attempts that shared the same payment identifier fragment. The fix makes the failure record match on an ad…
Data integrity bug causing incorrect error reporting across payment retry groupsNo memory safety, authentication, authorization, or cryptographic issues presentNo external input is trusted or validated differently
This commit fixes a bug in Core Lightning's Rust plugin library where a plugin could crash with a panic if it tried to log a message after the internal log-writing task had already stopped, such as during shutdown. The fix makes the plugin…
panic on send failure replaced with stderr fallbacklog message no longer silently dropped on writer task exitunit test added for dropped-receiver scenario
This commit only adds documentation to the manual page for an existing command-line tool (hsmtool). It explains how to recover funds from old Lightning payment commitments (HTLCs) after losing channel state. There are no code changes, no n…
This commit only changes a test file to make a flaky test more reliable. It does not modify any production code, so it has no security impact on real users.
This commit only updates documentation to explain that the `listtransactions` command reports a block height and transaction index of 0 when a transaction is not currently in a block (for example, because it hasn't been mined yet or was re…
This is a small bug fix in a Python helper library used by Core Lightning. The Millisatoshi.to_approx_str() method previously crashed with a math error when converting a zero amount to a human-readable string. The patch makes zero return "…
No security-relevant signals presentFix is a routine correctness/robustness improvement
This commit is a trivial formatting cleanup (removing an extra blank line and adding one) in a test file. It does not change any code behavior, fix any bug, or alter any security-relevant logic.
This update fixes a crash in two wallet commands, addpsbtoutput and addpsbtinput. These commands let users add extra transaction outputs or inputs to a PSBT (a Bitcoin transaction planning file). If a user supplied a PSBT whose version 2 '…
Daemon crash (assertion failure) on crafted/strict PSBT inputMissing validation of PSBT v2 modifiable flags before mutationUser-controlled input directly passed to libwally without precondition check
This commit only adds a new test case that demonstrates two Core Lightning commands, addpsbtoutput and addpsbtinput, crash with an internal assertion when given a v2 PSBT that does not allow adding inputs or outputs. The test is marked as …
Daemon abort due to failed assertion in PSBT helper functionsRPC commands addpsbtoutput and addpsbtinput lack validation of PSBT modifiability flags before calling libwallyPotential denial-of-service vector: any caller able to submit a crafted v2 PSBT can crash lightningd
This commit fixes a minor bug in Core Lightning's Python client library where calling a pretty-printing method on a zero-amount payment would crash with a ValueError. It is a routine correctness fix, not a security vulnerability. There is …
This commit adds missing safety checks in Core Lightning when a peer sends signatures for opening or splicing a dual-funded Lightning channel. Before the patch, the software accepted peer-provided transaction witnesses without verifying th…
Missing input validation on peer-provided witness dataBOLT-2 compliance fix for tx_signaturesRejection of empty witness stacks
This fix prevents a user-issued 'abort channels' command from incorrectly failing a Lightning channel when a splice transaction has already been signed. Previously, the code would pass the latest in-flight splice to a routine that aborts i…
Denial-of-service/availability impact: user-initiated abort could inadvertently fail a funded channelProtocol compliance fix: avoids sending tx_abort after tx_signatures, which BOLT 2 forbidsState-handling bug in splice negotiation lifecycle
This update fixes a bug where a specific type of Lightning channel close could crash the node. It only happens when both parties cooperatively close a dual-funded channel that has not yet been confirmed and has gone through a funding bump …
NULL pointer dereference leading to daemon crash (denial of service)Crash occurs in cooperative-close path for unconfirmed dual-funded/RBF channelsFix uses canonical channel funding key instead of splice-only field
This commit fixes a security bug in Core Lightning's gRPC plugin (cln-grpc). Previously, a malformed request from a gRPC client could crash the plugin: bad public keys, hashes, secrets, channel IDs, or enum values triggered Rust 'unwrap()'…
Denial-of-service via malformed gRPC request causing tonic worker task panicDenial-of-service via std::process::exit(1) in ProofField conversion on missing oneofSilent integer truncation of u16/u8 fields via 'as' casts
This commit removes the protobuf package from the Nix build environment because it is no longer needed. A previous change made the cln-grpc component use its own bundled protoc compiler instead of relying on the system one. The Python bind…
This commit adds a new automated check to the project's build process that compares gRPC protocol definitions against the last release to catch accidental breaking changes early. It does not change any runtime code, fix a bug, or introduce…
Expand any commit for its author, full message, clarity score, changed files, triage signals, analysis, and source link.
AI review queuedconnectd: keep the subd fd until connectd has received itby dovgopoly · 5e19c704 · Sep 29, 2026 · 10 filesMessage 73 · AdequateLow 30Details
Commit message · dovgopoly
connectd: keep the subd fd until connectd has received it
On macOS, a socket passed over SCM_RIGHTS whose sender closes its copy before the receiver's recvmsg completes can arrive unable to read. lightningd closed its end of a new subd's connection right after queueing it for connectd, so openingd or channeld could start with a dead connection: openingd logged "Peer connection lost", and fundchannel failed or hung waiting for accept_channel.
connectd now replies to peer_connect_subd once it has the fd, and lightningd keeps its copy until the reply arrives.
Changelog-Fixed: macOS: fundchannel no longer fails or hangs with "Peer connection lost" when opening channels under load.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Low 30/100
This commit fixes a macOS-specific bug where opening a Lightning channel could fail or hang with 'Peer connection lost'. The root cause was a race condition in how file descriptors (sockets) were passed between internal processes: the sender closed its copy too early, before the receiver had fully received it. The fix makes the sender wait for an acknowledgment before closing its copy. It is a reliability/availability fix, not an exploitable security vulnerability.
lightningd: reject newlines in persistent setconfig values
Changelog-Fixed: `setconfig` no longer permits config-line injection through persistent option values.
(cherry picked from commit 54178251aafc0ef793ab9a4dd9c44320bd40812d)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
second-pass: broader security terminology
AI analysis · Moderate 62/100
This commit fixes a bug in Core Lightning's `setconfig` RPC command. Previously, a user or attacker who could call `setconfig` could store a configuration value containing newline characters. Because persistent settings are written into a config file line-by-line, those newlines could split one setting into multiple lines, effectively injecting extra configuration directives. The patch now rejects any persistent value containing `\n` or `\r`.
AI review queuedlightningd: don't abort when a splice RBF reuses a funding txidby Sangbida Chaudhuri · 834073bf · Sep 28, 2026 · 1 fileMessage 73 · AdequateHigh 70Details
Commit message · Sangbida Chaudhuri
lightningd: don't abort when a splice RBF reuses a funding txid
An RBF that rebuilds a byte-identical splice transaction collides with the channel_funding_inflights primary key, and the DB layer treats that as fatal. Fail the pending splice command and the channel instead.
Changelog-Fixed: A channel peer can no longer crash lightningd by RBF-ing a splice into a transaction the node has already recorded. Co-authored-by: Cursor <cursoragent@cursor.com>
(cherry picked from commit d268f127c6394578125fb3b7be9382548677f238)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
second-pass: broader security terminology
AI analysis · High 70/100
This fix prevents a malicious or misbehaving channel peer from crashing a Core Lightning node by repeatedly proposing the same splice transaction. Before the patch, the node would hit a database primary-key conflict and abort entirely. Now it detects the duplicate funding transaction, fails the splice command, and marks the channel with an internal error instead of crashing.
AI review queueddocs: drop dead example_hooks key from openchannel2_signby daywalker90 · e4ce6835 · Sep 22, 2026 · 2 filesMessage 85 · StrongInformational 15Details
Commit message · daywalker90
docs: drop dead example_hooks key from openchannel2_sign
`example_hooks` is not part of the rpc meta-schema and is not consumed by tools/fromschema.py (its FOOTER_KEY_SEQUENCE only knows `examples` and `example_notifications`), so it was never rendered. The same file already carries an `examples` block.
Changelog-None
85/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Informational 15/100
This commit removes an unused documentation key called example_hooks from two JSON schema files. The key was never read by any tool and had no effect on the software's behavior. It is purely a cleanup of dead documentation content.
wallet: fixed timestamps for invented bookkeeper deposits
migrate_setup_coinmoves() stamped wallet deposits with wall-clock time via coinmvt_current_time(), so a slow migration could place the deposit after the channel journal entry in bkpr-listaccountevents, flaking test_migration_no_bkpr.
Use base_timestamp + 1, like the channel moves, so the order is stable.
Changelog-None
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Informational 15/100
This is a tiny internal fix to make a bookkeeping migration produce stable event ordering. It changes the timestamp used when creating historical 'deposit' records during a one-time database migration, so the records sort consistently with channel records instead of using the real-time clock. There is no security issue here.
AI review queuedlightningd: watch a dual-funded channel's funding outputs before lock-inby Níckolas Goline · eedd50b3 · Sep 16, 2026 · 5 filesMessage 73 · AdequateHigh 79Details
Commit message · Níckolas Goline
lightningd: watch a dual-funded channel's funding outputs before lock-in
A dual-funded channel armed its funding-output spend watch only at lock-in. Until then we watched whether the funding tx had confirmed and how deep it was, neither of which fires when the output is spent. With funding-confirms at 3 the opener can confirm the funding and close on it in the next block: we never see the spend, lock in anyway, keep routing over a channel with no funding output, and never notice the cheat once the peer's commitment is revoked. The single-funded path has always watched from channel creation.
Arm channel_watch_inflight_outs() as soon as a candidate is recorded, before our commitment_signed goes out, since that is the moment the peer can broadcast it; the restart path already re-arms for every channel with inflights. When a spend arrives while we are still awaiting lock-in, the spent candidate is by definition the one that got mined: adopt it as the channel's funding, as opening_depth_cb would have, before onchaind is started, so onchaind is not handed the latest attempt's commitment for an outpoint that may never exist. The candidate watch that fired becomes the channel's funding_spend_watch, so drop_to_chain() does not add a second watch on the same outpoint while the block scanner is still iterating it. At lock-in, drop the candidate watches again: the outpoint is the channel's own from then on, and a surviving candidate watch would fire funding_spent() twice on every later close.
Changelog-Fixed: dual-funding: a channel whose funding output is spent before lock-in is now handed to onchaind instead of being locked in and used.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> (cherry picked from commit e44cf3401eccb9e6306aaa5ede8f9d52ead44b57)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · High 79/100
This fix closes a serious bug in Core Lightning's dual-funded channel opening. Before the patch, the node only started watching for a spend of the new channel's funding output after the channel had 'locked in.' A malicious or careless peer could confirm the funding transaction and immediately spend the funding output in a close transaction before lock-in. The node would miss the spend, still lock in the channel, continue routing payments over a channel whose funding no longer existed, and fail to detect a later cheating attempt. The patch arms the spend watch as soon as the funding candidate is recorded, and correctly hands the channel to onchaind if a spend is seen before lock-in.
AI review queuedlightningd: refuse channels whose channel_id is already in useby cdecker · 7c6926c1 · Sep 15, 2026 · 7 filesMessage 73 · AdequateHigh 72Details
Commit message · cdecker
lightningd: refuse channels whose channel_id is already in use
A v1 channel_id is derived from the funding outpoint, which the peer chooses and which we can't check until it confirms. We only refused an outpoint already used by a live channel with the same peer, so a second channel could end up sharing a forgotten channel's channel_id. When it is closed too we abort in closed_channel_map_add() with "Assertion `!closed_channel_map_getmatch_(...)' failed", and since the channel is in the db, onchaind or a restart then crashes us again every time.
Refuse to commit a channel whose channel_id is used by any live or closed channel, in the fundee, funder and dual-funding paths, and allow duplicates in the closed channel map so nodes which already have such channels in their db can close and load them.
Changelog-Fixed: lightningd: a peer reusing a funding outpoint can no longer crash the node with a duplicate channel_id. (cherry picked from commit 84bfdf4fe1f8176cf361d474a12df20cfa704778)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
second-pass: broader security terminology
AI analysis · High 72/100
This update fixes a crash bug in Core Lightning. A malicious or careless peer could open a new Lightning channel using the same funding transaction details as an old, forgotten channel. Because the channel ID is derived from those details, the new channel would share the same ID. When either channel later closed, the program hit an internal 'this should never happen' assertion and crashed, then kept crashing on restart because the duplicate ID was stored in the database. The fix refuses to commit any new channel whose ID is already used by a live or closed channel, and allows the database to hold duplicates for already-affected nodes so they can close and restart safely.
AI review queuedpytest: channels reusing a funding outpoint must not crash usby cdecker · 8e94554b · Sep 15, 2026 · 1 fileMessage 65 · AdequateModerate 50Details
Commit message · cdecker
pytest: channels reusing a funding outpoint must not crash us
(cherry picked from commit bc01ae602ced2a5c46312900e6cea02c617ecd69)
65/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
second-pass: broader security terminology
AI analysis · Moderate 50/100
This commit adds a test showing that Core Lightning can crash if a node's database ends up with two channels sharing the same internal channel ID—one already closed and another later closed with the same ID. The test is currently marked as expected to fail, meaning the underlying crash bug has not been fixed yet. It appears to be a denial-of-service issue: a malformed or manipulated local database state causes lightningd to crash on channel close and then again on every restart.
AI review queuedwss-proxy: time out handshakes so the accept loop can't be stalledby daywalker90 · 1950f99a · Sep 10, 2026 · 2 filesMessage 73 · AdequateModerate 63Details
Commit message · daywalker90
wss-proxy: time out handshakes so the accept loop can't be stalled
The TLS and websocket handshakes were awaited inline in the accept loop before per-connection work was spawned. A client which connected and never completed a handshake parked the loop, so no further accept() was serviced and the whole WSS endpoint was unavailable to everyone.
Spawn a task per accepted stream immediately, and run both handshakes inside that task under a 10 second timeout (matching the pattern used by other plugins), so an idle client is dropped and can never block new connections.
Changelog-Fixed: wss-proxy: an idle client no longer blocks the accept loop and prevents all new connections
(cherry picked from commit cadf29066fa5927e99039d23401973ab73b93949)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
second-pass: broader security terminology
AI analysis · Moderate 63/100
This update fixes a bug in Core Lightning's WebSocket Secure (WSS) proxy where a single client could connect but never finish its handshake, accidentally freezing the entire WSS service so no one else could connect. The fix moves each connection's TLS and WebSocket handshakes into its own background task and adds a 10-second timeout, so a stuck client is dropped without blocking others.
clnrest: bound YAML deserialization to prevent alias-expansion OOM
An unauthenticated POST to /v1/{method} with Content-Type: application/yaml is parsed before the rune is verified. serde_yaml_ng 0.10.0 resolves YAML anchors/aliases by re-deserializing the anchored node, bounded only by the number of alias dereferences, not by what each dereference materializes.
Two distinct amplifications are possible: nested sequences of aliases multiply into billions of nodes, and a single large anchored scalar aliased many times is copied once per reference. A ~11 KB nested body expands to ~9 GB, and a ~0.5 MB body with a large anchored scalar expands to ~2 GB while materializing only a few thousand nodes.
Deserialize YAML request bodies with our own budget (plugins/rest-plugin/src/yaml.rs): a counting serde DeserializeSeed/Visitor materializes at most MAX_YAML_NODES nodes and at most MAX_YAML_BYTES of string data, aborting the parse once either bound is exceeded. This keeps the footprint of any single request to a few MB regardless of the input, while behavior on legitimate documents is unchanged.
Changelog-Fixed: clnrest: an unauthenticated YAML request using anchors/aliases could exhaust memory and crash the plugin; YAML deserialization is now bounded. (cherry picked from commit b8c87a2b649620af371cdda578e195199a83f0ec)
85/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
second-pass: broader security terminology
AI analysis · Critical 85/100
This update fixes a memory exhaustion flaw in Core Lightning's REST plugin. An attacker could send a small, specially crafted YAML request to the clnrest endpoint that explodes internally into gigabytes of data, crashing the plugin. The patch adds hard limits on how large a YAML request can expand during parsing, so even malicious input stays small.
AI review queuedCCAN: update after 32-bit and MacOS cleanups.by Rusty Russell · 26ccced5 · Aug 21, 2026 · 34 filesMessage 78 · AdequateLow 47Details
Commit message · Rusty Russell
CCAN: update after 32-bit and MacOS cleanups.
The addition of GitHub CI to CCAN, especially 32 bit builds and MacOS tests lead to more refinement (mostly in tests), so this catches up to that.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
78/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
second-pass: unusually broad change
AI analysis · Low 47/100
This commit updates the CCAN utility library used by Core Lightning. Most changes are test fixes and portability cleanups for 32-bit and macOS builds. The one genuinely security-relevant code change is in the file-descriptor passing helper (fdpass_recv): it now uses a larger ancillary buffer and also checks the MSG_CTRUNC flag, so a malicious or misbehaving peer cannot force the process to leak file descriptors by sending more fds than expected. A second change in the I/O engine fixes a case where a write-side EPIPE could leave a connection's read side permanently disabled. The commit message itself does not frame these as security fixes.
AI review queuedwallet: let wallet_inflight_save update i_sent_sigsby Sangbida Chaudhuri · d502d418 · Aug 20, 2026 · 1 fileMessage 73 · AdequateLow 30Details
Commit message · Sangbida Chaudhuri
wallet: let wallet_inflight_save update i_sent_sigs
Turns out we never persisted this flag after the fact. We're about to start relying on it, so save it properly.
Co-authored-by: Cursor <cursoragent@cursor.com> (cherry picked from commit 7a01495359add9c1f1160440fee5335c4a5608f1)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Low 30/100
This commit fixes a bug where a flag called i_sent_sigs was not being saved to the database when updating a channel funding inflight. The flag tracks whether a node has already sent signatures for a funding transaction. Because the flag was not persisted, a node could forget it had sent signatures after a restart, which could lead to incorrect behavior in upcoming code that relies on this flag. The fix is a one-line SQL update change to also write the i_sent_sigs column.
AI review queuedcommon: minor typo fixesby w3lld1 · 273d7f02 · Aug 20, 2026 · 2 filesMessage 28 · OpaqueInformational 15Details
Commit message · w3lld1
common: minor typo fixes
28/100 · OpaqueMessage clarity
✓ Subject identifies a change! No meaningful explanatory body
Why it was queued
second-pass: opaque commit message
AI analysis · Informational 15/100
This commit only fixes typos and comment style. It changes two C-style comments from // to /* */ and corrects a grammar error in a documentation comment ('element' to 'elements'). There are no code behavior changes, no bug fixes, and no security relevance.
AI review queuedpyln-testing: truncate long testnamesby Peter Neuroth · c4fe4cba · Aug 19, 2026 · 2 filesMessage 90 · StrongInformational 20Details
Commit message · Peter Neuroth
pyln-testing: truncate long testnames
Postgres truncates identifiers at 63 bytes. This can lead to 'DuplicateDatabase' errors for tests with long names, as the nonce and the node_id may collapse. This commit truncates the testname in favor of the node_id and the nonce, to avoid conflicting db names.
Changelog-None
Signed-off-by: Peter Neuroth <pet.v.ne@gmail.com>
90/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification
Why it was queued
second-pass: broader security terminology
AI analysis · Informational 20/100
This change fixes a test-infrastructure bug in Core Lightning's Python testing helpers. When running tests against a PostgreSQL database, very long test names could be silently shortened by PostgreSQL, causing different test runs or nodes to accidentally share the same database name and fail with a 'DuplicateDatabase' error. The patch makes sure the unique parts of the name (node ID and random nonce) are kept while the long human-readable test name is shortened instead. It is a reliability fix for the test suite, not a security vulnerability in the live lightning node software.
AI review queuedaskrene: fix crash loading node bias with descriptionby Vincenzo Palazzo · 4681177d · Aug 18, 2026 · 2 filesMessage 91 · StrongModerate 59Details
Commit message · Vincenzo Palazzo
askrene: fix crash loading node bias with description
load_node_bias() passed take(description) to two consecutive set_node_bias() calls. The first call's tal_strdup() consumes the take (tal_resize_ + tal_steal), so the second take() was on freed memory and we aborted in to_tal_hdr() with "Not a valid header" while loading the layer at startup. Since askrene is an important plugin, lightningd shuts down and the node cannot restart at all.
The description is already a copy off tmpctx, so simply don't take() it: set_node_bias() strdups it into the bias anyway.
With this, the test from the previous commit passes.
Fixes: #9433 Reported-by: endothermicdev Changelog-Fixed: askrene: node failed to start (`exited before replying to init`) when a persistent layer contains a node bias with a description Signed-off-by: Vincenzo Palazzo <vincenzopalazzodev@gmail.com>
91/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
Why it was queued
second-pass: broader security terminology
AI analysis · Moderate 59/100
This commit fixes a bug in Core Lightning's askrene plugin that could prevent a node from restarting. When a saved routing layer contained a node bias with a description, the plugin accidentally freed the description's memory while using it a second time, causing an immediate crash during startup. The fix removes the incorrect 'take ownership' call so the description remains valid for both uses. There is no evidence this crash can be triggered remotely or used as an attack; it appears to be a reliability bug that only affects nodes that already have such saved data.
AI review queuedtests: restart the node which owns the layer in node bias testby Vincenzo Palazzo · 0f3f67a0 · Aug 18, 2026 · 1 fileMessage 91 · StrongInformational 12Details
Commit message · Vincenzo Palazzo
tests: restart the node which owns the layer in node bias test
test_node_bias_persistence() restarted l2, but the layer and its node bias records live in l1's datastore. The assert compared l1's in-memory layer against itself, so load_node_bias() was never actually exercised and this test could not have caught the startup crash in #9433.
Restarting l1 instead makes the test reload the layer from the datastore at startup. This is the reproducer for #9433; it fails until the next commit.
✓ Specific, 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
second-pass: broader security terminology
AI analysis · Informational 12/100
This commit only fixes a test case so it actually exercises the intended code path. It does not change any production code, so it cannot introduce or fix a real-world security vulnerability by itself. The test change is a reproducer for a startup crash reported elsewhere, but the crash fix is in a separate commit.
AI review queuedaskrene: exclude stubchannels from routingby niftynei · c313eff5 · Aug 15, 2026 · 2 filesMessage 80 · StrongModerate 60Details
Commit message · niftynei
askrene: exclude stubchannels from routing
My node has some recovered channels, which were causing a crash in askrene, due to the fact that they have duplicate scids.
Easy fix is simply to skip recovered stubs when planning routes.
Changelog-Fixed: Crash when trying to pay and you have recovered channel stubs in your peers list
80/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
second-pass: broader security terminology
AI analysis · Moderate 60/100
This commit fixes a crash in Core Lightning's routing plugin (askrene) that occurred when a user had 'recovered channel stubs'—placeholder records left behind after restoring a node from a backup. These stubs all share the same placeholder channel ID (1x1x1), which caused an internal table that expects unique IDs to fail an assertion and crash the plugin. The fix makes askrene skip these stubs when planning routes. The crash is triggered by normal user actions (trying to pay with recovered stubs present), not by a remote attacker, and the plugin can be restarted.
AI review queuedlightningd: fix crash on invoice_payment_hook_doneby Lagrang3 · f435096d · Aug 13, 2026 · 2 filesMessage 78 · AdequateModerate 66Details
Commit message · Lagrang3
lightningd: fix crash on invoice_payment_hook_done
``` Valgrind error file: valgrind-errors.3449770 ==3449770== Invalid read of size 8 ==3449770== at 0x1B4F4A: htlc_set_fail_ (htlc_set.c:77) ==3449770== by 0x1B59FB: invoice_payment_hooks_done (invoice.c:276) ==3449770== by 0x1EC5DF: hook_done (plugin_hook.c:243) ==3449770== by 0x1EC710: plugin_hook_call_next (plugin_hook.c:343) ==3449770== by 0x1EC90E: plugin_hook_callback (plugin_hook.c:299) ==3449770== by 0x1E6316: plugin_response_handle (plugin.c:692) ==3449770== by 0x1EB443: plugin_read_json (plugin.c:781) ==3449770== by 0x283D01: next_plan (io.c:60) ==3449770== by 0x28418C: do_plan (io.c:422) ==3449770== by 0x284245: io_ready (io.c:439) ==3449770== by 0x285BE3: io_loop (poll.c:471) ==3449770== by 0x1B9A99: io_loop_with_timers (io_loop_with_timers.c:22) ==3449770== Address 0x38 is not stack'd, malloc'd or (recently) free'd ==3449770== { <insert_a_suppression_name_here> Memcheck:Addr8 fun:htlc_set_fail_ fun:invoice_payment_hooks_done fun:hook_done fun:plugin_hook_call_next fun:plugin_hook_callback fun:plugin_response_handle fun:plugin_read_json fun:next_plan fun:do_plan fun:io_ready fun:io_loop fun:io_loop_with_timers }
```
Changelog-Fixed: lightningd: fix crash of lightningd on race condition between delinvoice and a returning invoice_payment hook for fallback onchain settlements
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
second-pass: broader security terminology
AI analysis · Moderate 66/100
This commit fixes a crash in the Core Lightning node software. The crash happens when an invoice is deleted while a plugin's 'invoice_payment' hook is still processing a payment that came in through an on-chain fallback address. By the time the hook finishes, the internal data structure it expected to use (the HTLC set) had already been cleared, causing the node to read invalid memory and crash. The fix simply checks whether that data still exists before using it.
Drive log_to_files() directly with an entry far larger than any stack buffer, using a plugin which emits one on demand.
Nothing bounds a log entry, so testing this through clnrest is the wrong shape: requests are now capped at 2MiB before any parameter is parsed, so an oversized request is rejected long before it can reach the logger, and a test written that way passes whether or not the daemon is fixed. A plugin can hand us an entry of any size, which is what we actually want to exercise.
(cherry picked from commit 50910c956694006b516b8bca1dbc214f79842772)
78/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
second-pass: broader security terminology
AI analysis · Moderate 64/100
This commit adds a test for a previously fixed crash in Core Lightning's logging code. The bug was that log entries could be arbitrarily large, and the daemon used to allocate a stack buffer based on the entry's length, which could exhaust the stack and crash the process. The test uses a plugin to feed the logger an 8 MB entry and checks the node stays alive. The commit itself only adds the test and plugin; it does not contain the actual fix.
AI review queuedclnrest: restrict maximum size of request bodies to 2MiBby daywalker90 · 804b9df8 · Aug 12, 2026 · 4 filesMessage 73 · AdequateHigh 74Details
Commit message · daywalker90
clnrest: restrict maximum size of request bodies to 2MiB
Changelog-Fixed: clnrest: an unauthenticated user could crash the node with a large request body; bodies are now capped at 2MiB. (cherry picked from commit d5c2f6dbf1b7a54679b97d2a71015ad45443baf8)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
second-pass: broader security terminology
AI analysis · High 74/100
This update fixes a bug in Core Lightning's built-in REST plugin (clnrest). Before the fix, anyone on the network could send a very large request to the REST API without logging in, causing the node to crash. The patch now refuses bodies larger than 2 MB and returns an error instead of trying to read unlimited data.
AI review queuedconnectd: bound the SOCKS5 request hostname to the request bufferby Níckolas Goline · 10b7961b · Aug 11, 2026 · 2 filesMessage 73 · AdequateHigh 73Details
Commit message · Níckolas Goline
connectd: bound the SOCKS5 request hostname to the request buffer
The SOCKS5 CONNECT request is built into a fixed 255-byte buffer, but a domain-name request needs 7 + strlen(host) bytes and the host length was never checked. A host longer than 248 bytes overran the buffer while the request was assembled, corrupting the adjacent length field, which was then used as the io_write() length and produced a large out-of-bounds read: the proxy socket received connectd's heap instead of the request, and connectd died. The host reaches this both from a proxied connect and from a gossiped DNS address.
Size the buffer to hold the largest legal request (header plus a maximum-length domain name), and refuse a hostname which still does not fit rather than building a request we cannot represent. Truncating the host is not an option: that is a connection to the wrong destination.
Changelog-Fixed: connectd: a proxied connection to a very long hostname (including a gossiped DNS address) could crash the node. (cherry picked from commit 04ca809936794de47943951b9d116d9fd1ea1844)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
second-pass: broader security terminology
AI analysis · High 73/100
This update fixes a bug in Core Lightning's Tor/proxy connection code. When the node tried to connect through a SOCKS5 proxy to a hostname longer than 248 characters, it wrote past the end of a small fixed buffer. That corrupted the recorded message length, causing the proxy to be sent random data from the program's memory and crashing the node. The fix enlarges the buffer to the legal maximum and rejects hostnames that are still too long instead of overflowing.
AI review queuedcommon: treat a reorged close output as csv-lockedby cdecker · 9d0c1d49 · Aug 11, 2026 · 2 filesMessage 85 · StrongModerate 60Details
Commit message · cdecker
common: treat a reorged close output as csv-locked
If, during a run of CLN, a close gets confirmed, its outputs are added to the wallet. If then the close is reorged out, i.e., it loses its confirmation, using it in this inconsistent state, can cause a crash, due to a derefence on the confirmation height which is unset.
Changelog-Fixed: wallet: Addressed a crash when attempting to spend a previously confirmed but reorged out close transaction output. (cherry picked from commit 4c078a0e61c8eea7ec3549c71688808dcfe479f0)
85/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
signing or wallet pathsecond-pass: broader security terminologysecond-pass: security-sensitive path
AI analysis · Moderate 60/100
This update fixes a crash in Core Lightning's wallet. If a channel-closing transaction had been confirmed and then a blockchain reorganization removed that confirmation, the wallet could try to spend the output while its confirmation height was missing. That led to a null-pointer crash. The fix treats such outputs as still time-locked so they are not spent until re-confirmed.
AI review queuedonchaind: Close a racy onchain resolutionby cdecker · faf8fa84 · Aug 11, 2026 · 1 fileMessage 85 · StrongModerate 57Details
Commit message · cdecker
onchaind: Close a racy onchain resolution
Upon timing out an upstream incoming HTLC, we were setting the resolution to be ignored, since the funds will presumably be returned to the peer, not us. However, since the HTLC timeout and the internal resolution do not line up perfectly, due to the security margin, there is a chance for a late preimage coming in, resolving the HTLC in the other direction, i.e., we now own it. If that resolution comes in after we have internally marked the output as ignored, we would not clean up our prior decision, leaving the HTLC stranded, but recoverable.
This just ensures that we clear our internal resolution too, when the downstream preimage comes in, so that we can use the preimage to grab the funds in the HTLC.
Changelog-Fixed: onchaind: Fixed a race between preimage return from downstream to upstream
85/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Names security-relevant behavior explicitly
Why it was queued
second-pass: broader security terminology
AI analysis · Moderate 57/100
This fix addresses a timing bug in Core Lightning's on-chain dispute handler. When a payment hash preimage arrives late from a downstream peer, the software could have already marked the related funds as 'ignored' because the upstream timeout had passed. The old code stopped processing once it saw an existing resolution, leaving the funds stuck. The fix clears the prior 'ignored' resolution so the late preimage can still be used to claim the funds. It is a recoverable race condition, not a direct theft of funds, but it could delay or complicate recovery of HTLC funds during on-chain settlement.
AI review queuedlightningd: handle amountless invoices in the onchain payment checkby Níckolas Goline · f818385d · Aug 11, 2026 · 2 filesMessage 73 · AdequateModerate 69Details
Commit message · Níckolas Goline
lightningd: handle amountless invoices in the onchain payment check
invoice_check_onchain_payment() compared the received amount against *details->msat, which is NULL when the invoice was created with amount_msat="any":
The HTLC path already checks this; do the same onchain, where an amountless invoice likewise accepts any amount.
Changelog-Fixed: lightningd: crash when an onchain payment arrived for the fallback address of an invoice created with amount_msat="any". (cherry picked from commit 6d025a3dab76ec5380474b2a8065c48aec309f33)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
second-pass: broader security terminology
AI analysis · Moderate 69/100
This fix repairs a crash in Core Lightning's invoice handling. When someone paid the on-chain fallback address of an invoice that accepted 'any' amount, the software dereferenced a NULL pointer and died with a fatal signal (segmentation fault). The patch simply skips the amount comparison when no specific amount was set, matching the behavior already used for regular Lightning payments.
AI review queuedwallet: persist the inflight i_sent_sigs flag across restartsby Dusty Daemon · 10088288 · Aug 7, 2026 · 2 filesMessage 73 · AdequateLow 42Details
Commit message · Dusty Daemon
wallet: persist the inflight i_sent_sigs flag across restarts
This flag was previously memory only, lets upgrade it to be used across restarts.
Changelog-None
(cherry picked from commit 5293e073560291ada3811cbbfe4240080df2ebab)
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Low 42/100
This change fixes a bug where a flag tracking whether a node had already sent transaction signatures during a 'splice' (a way to resize a Lightning channel) was stored only in memory. If the node restarted mid-process, it could forget that it had already sent signatures and either resend them or get confused about the splice state. Persisting the flag to the database makes splicing more robust across restarts.