EP
← All projectsElements Project

Core Lightning

Modular C implementation of the Lightning Network protocol and node stack.

BitcoinLightning NetworkActive incident
Repository coverage

2330 commits in the local evidence base

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

228security candidates319second-pass queue1977AI analyses
99commits · 30 days
229commits · 60 days
709commits · 180 days
1578commits · 365 days
Backfill bands
Aug 5 → Feb 61049 seen37 candidatesComplete
Feb 6 → Jun 6579 seen10 candidatesComplete
Jun 6 → Jul 678 seen1 candidatesComplete
Jul 6 → Aug 5147 seen16 candidatesComplete
Commit communication

Does the history explain itself?

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

71/100 average clarity
628Strong · 80–100
1399Adequate · 60–79
272Thin · 40–59
31Opaque · 0–39
Read the scoring rubric →
Developer activity

Who is changing the project?

Public Git author strings; identities are not independently verified.

DeveloperCommitsCandidatesAnalyzedHigh riskMessage avg.
cdecker331217581
daywalker9019315113471
Níckolas Goline961252376
Amperstrand322278
Rusty Russell96977961173
Sangbida Chaudhuri18537157167
Vincenzo Palazzo19714185
Lagrang3115679170
dovgopoly18016165
Dusty Daemon821378066
ShahanaFarooqui931093063
Peter Neuroth1469110074
Analysis record

Published AI watches

Last scanned 43 minutes ago

Informational 15 AI analysisMessage 85 · Strong
EP Elements ProjectCore Lightning BitcoinLightning Network

doc: bring lightning-downgrade's version list up to v26.12.

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.

2e7a9f5aby Ken Sedgwick+9−12 files
No security note in commit
Informational 23 AI analysisMessage 66 · Adequate
EP Elements ProjectCore Lightning BitcoinLightning Network

Makefile: install lightning-downgrade.

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…

06ea9ba0by Ken Sedgwick+1−01 file
No security note in commit
Low 27 AI analysisMessage 83 · Strong
EP Elements ProjectCore Lightning BitcoinLightning Network

wallet: create bwatch tables before backfilling them

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
ce2a6836by daywalker90+105−02 files
No security note in commit
Informational 15 AI analysisMessage 5 · Opaque
EP Elements ProjectCore Lightning BitcoinLightning Network

v26.12rc1

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…

4002c4e9by Níckolas Goline+164−1110 files
No security note in commit
Low 30 AI analysisMessage 68 · Adequate
EP Elements ProjectCore Lightning BitcoinLightning Network

wallet: store payment failure details per groupid

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
24082c6dby daywalker90+6−34 files
No security note in commit
Low 43 AI analysisMessage 83 · Strong
EP Elements ProjectCore Lightning BitcoinLightning Network

cln-plugin: do not panic when the log writer task is gone

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
8661ffabby cdecker+29−11 file
No security note in commit
Informational 15 AI analysisMessage 90 · Strong
EP Elements ProjectCore Lightning BitcoinLightning Network

docs: explain hsmtool HTLC recovery

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…

f90c140dby Sangbida Chaudhuri+85−01 file
No security note in commit
Informational 15 AI analysisMessage 68 · Adequate
EP Elements ProjectCore Lightning BitcoinLightning Network

tests: make test_delpay_works deterministic

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.

a224ca81by daywalker90+16−161 file
No security note in commit
Informational 20 AI analysisMessage 73 · Adequate
EP Elements ProjectCore Lightning BitcoinLightning Network

doc: say that listtransactions gives blockheight 0 for a tx not in a block

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…

bc281be3by Peter Neuroth+4−42 files
No security note in commit
Informational 20 AI analysisMessage 50 · Thin
EP Elements ProjectCore Lightning BitcoinLightning Network

fixup! pyln-client: don't crash Millisatoshi.to_approx_str() on zero

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
02612ed5by Amartya Singh+4−31 file
No security note in commit
Moderate 62 AI analysisMessage 73 · Adequate
EP Elements ProjectCore Lightning BitcoinLightning Network

wallet: reject unmodifiable PSBTs in addpsbtoutput/addpsbtinput

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
42472816by daywalker90+14−12 files
Vendor flagged security relevance
Moderate 59 AI analysisMessage 83 · Strong
EP Elements ProjectCore Lightning BitcoinLightning Network

tests: show addpsbtoutput/addpsbtinput crash on an unmodifiable v2 PSBT

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
42e268abby daywalker90+60−01 file
No security note in commit
Informational 20 AI analysisMessage 73 · Adequate
EP Elements ProjectCore Lightning BitcoinLightning Network

pyln-client: don't crash Millisatoshi.to_approx_str() on zero

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 …

5ebe365dby Amartya Singh+3−12 files
No security note in commit
Moderate 59 AI analysisMessage 83 · Strong
EP Elements ProjectCore Lightning BitcoinLightning Network

dualopen and splicing: add minimal verification of tx_signatures

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
c6be4f71by Lagrang3+633−97 files
Vendor flagged security relevance
Moderate 54 AI analysisMessage 85 · Strong
EP Elements ProjectCore Lightning BitcoinLightning Network

channeld: abort_channels no longer fails a channel with a signed splice

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
c87f5573by Andezion+22−11 file
No security note in commit
Moderate 51 AI analysisMessage 73 · Adequate
EP Elements ProjectCore Lightning BitcoinLightning Network

lightningd: fix crash on mutual close of an unconfirmed dual-funded channel

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
555143beby Sangbida Chaudhuri+9−31 file
Vendor flagged security relevance
High 74 AI analysisMessage 73 · Adequate
EP Elements ProjectCore Lightning BitcoinLightning Network

cln-grpc: reject malformed request values instead of panicking

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
b2703436by daywalker90+1558−12135 files
Vendor flagged security relevance
Informational 15 AI analysisMessage 51 · Thin
EP Elements ProjectCore Lightning BitcoinLightning Network

nix: drop protobuf again

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…

a0459eeeby Peter Neuroth+0−11 file
No security note in commit
Informational 15 AI analysisMessage 73 · Adequate
EP Elements ProjectCore Lightning BitcoinLightning Network

make: check gRPC protos for breaking changes against the last release

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…

db5fea70by daywalker90+43−84 files
No security note in commit
Repository ledger

Explore captured commits

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

AI review 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.

AI review queuedlightningd: reject newlines in persistent setconfig valuesby Sangbida Chaudhuri · 4cc27c32 · Sep 29, 2026 · 1 fileMessage 73 · AdequateModerate 62Details
Commit message · Sangbida Chaudhuri

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.

AI review queuedwallet: fixed timestamps for invented bookkeeper depositsby daywalker90 · 498e5086 · Sep 17, 2026 · 1 fileMessage 73 · AdequateInformational 15Details
Commit message · daywalker90

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.

AI review queuedclnrest: bound YAML deserialization to prevent alias-expansion OOMby daywalker90 · b355315e · Sep 8, 2026 · 3 filesMessage 85 · StrongCritical 85Details
Commit message · daywalker90

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.

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 · 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.

Aug 15 16:34:14 citrine lightningd[1976574]: cln-askrene: ./plugins/askrene/child/additional_costs.h:26: additional_cost_htable_add: Assertion `!additional_c ost_htable_getmatch_(ht, k, h, v, &i)' failed.

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

Reported-by: Vincenzo Palazzo (Bitcoin Security Council finding 2026-08-11)
Co-Authored-By: Grok 4.5
Signed-off-by: Lagrang3 <lagrang3@protonmail.com>

78/100 · AdequateMessage clarity
✓ 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.

AI review queuedtests: huge log entries don't crash lightningdby daywalker90 · 7a05b8fa · Aug 13, 2026 · 2 filesMessage 78 · AdequateModerate 64Details
Commit message · daywalker90

tests: huge log entries don't crash lightningd

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":

FATAL SIGNAL 11
backtrace: lightningd/invoice.c:971 (invoice_check_onchain_payment)
backtrace: lightningd/chaintopology.c:84 (filter_block_txs)
backtrace: lightningd/chaintopology.c:1020 (add_tip)
backtrace: lightningd/chaintopology.c:1117 (get_new_block)

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.