CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-103033

CVE-2026-103033: Pre-Verification Nil-Map Panic and Denial of Service in ALTCHA Go Library

Alon Barad
Alon Barad
Software Engineer

Nov 20, 2026·10 min read·2 visits

Executive Summary (TL;DR)

An uninitialized map assignment in github.com/altcha-org/altcha-lib-go prior to v2.1.0 allows unauthenticated remote attackers to trigger a runtime panic via malformed percent-encoding in the VerificationData field before HMAC signature verification takes place.

CVE-2026-103033 (GHSA-gfwj-45pc-w6r5) is an unauthenticated pre-verification Denial of Service (DoS) vulnerability in the Go implementation of the ALTCHA bot-prevention library (github.com/altcha-org/altcha-lib-go). In versions 2.0.0 and 2.0.1, the internal function parseServerSignature conditionally initializes the ServerSignatureVerificationData.Extra map only when url.ParseQuery returns no error. When an attacker submits a payload containing both an unrecognized query parameter and malformed percent-encoding in the VerificationData field, url.ParseQuery returns partially parsed parameters alongside an error. Because execution continues without initializing the Extra map, the subsequent loop attempts to write unknown parameters into a nil map, triggering a fatal Go runtime panic before cryptographic signature verification occurs.

Vulnerability Overview

ALTCHA is a self-hosted, proof-of-work mechanism used to protect web endpoints against automated spam and abuse without relying on intrusive user challenges. The Go library (github.com/altcha-org/altcha-lib-go) provides server-side verification routines for checking both client proof-of-work challenges and server signatures. Specifically, the VerifyServerSignature and VerifyServerSignatureSafe functions validate signed verification payloads generated by an ALTCHA verification server.

In versions 2.0.0 and 2.0.1 of altcha-lib-go, a flaw exists in the parseServerSignature internal helper function located in altcha.go. This function is responsible for decoding the incoming server signature payload—which may be provided as a raw struct or a Base64-encoded JSON string—and parsing the VerificationData URL query string into a structured ServerSignatureVerificationData object. Because parseServerSignature executes at the very beginning of the verification workflow, it processes untrusted input prior to any HMAC cryptographic validation.

The vulnerability is classified under CWE-248 (Uncaught Exception) and CWE-476 (NULL Pointer Dereference). When parseServerSignature parses the VerificationData query string using Go's standard library net/url.ParseQuery, it fails to properly handle error states where partial query data is returned alongside a parsing error. Specifically, the verificationData.Extra map is only allocated with make(map[string]interface{}) when url.ParseQuery succeeds without error, yet the function proceeds to iterate over any returned query keys regardless of the error state.

If an unauthenticated client supplies a VerificationData string containing an unrecognized parameter followed by a malformed percent-encoded sequence (such as %ZZ), the routine attempts to insert the unrecognized parameter into the uninitialized verificationData.Extra map. In Go, assigning a value to a nil map triggers an immediate runtime panic (panic: assignment to entry in nil map). Depending on the host application's architecture and panic-recovery middleware, this results in abrupt request termination, log flooding, or full termination of the Go server process.

Root Cause Analysis

The root cause of CVE-2026-103033 lies in an incompatible interaction between the error-handling semantics of Go's net/url.ParseQuery function and the conditional initialization of the ServerSignatureVerificationData.Extra map inside parseServerSignature. Unlike many functions that return a nil result when an error occurs, url.ParseQuery processes key-value pairs sequentially and returns both the accumulated url.Values map parsed up to or alongside the error and a non-nil error object whenever it encounters invalid URL escape sequences.

In the vulnerable implementation of parseServerSignature, the developer declared var verificationData ServerSignatureVerificationData. In Go, declaring a struct without explicit field initialization sets all fields to their respective zero values; for the Extra field (of type map[string]interface{}), the zero value is nil. The allocation statement verificationData.Extra = make(map[string]interface{}) was placed inside the conditional block if err == nil immediately following params, err := url.ParseQuery(parsedPayload.VerificationData).

When url.ParseQuery encounters a malformed percent-encoding sequence, err is non-nil, causing execution to bypass the if err == nil block entirely. Consequently, none of the standard known fields (Classification, Country, Email, Expire, etc.) are populated, and verificationData.Extra remains nil. Crucially, the if err == nil path does not have a corresponding else branch to return the error to the caller, so execution continues directly to the for key, values := range params loop below it.

During this loop, the function checks each key present in params against the package-level knownFields map (if !knownFields[key]). Any parameter key that is not part of the predefined standard schema is treated as an extra custom parameter and written to verificationData.Extra[key]. Because params contains valid key-value pairs parsed prior to or alongside the malformed token, and verificationData.Extra is still nil, the write operation verificationData.Extra[key] = values[0] causes the Go runtime to panic.

> [!NOTE] > In the Go runtime, reading from or deleting a key from a nil map is a safe no-op that returns the value type's zero value. However, attempting to write to a nil map is an unrecoverable runtime violation that immediately invokes runtime.panic.

Code Analysis

The vulnerability was introduced in commit f14102c7e9bda8c7feb509be363da6fc1c8c25c8 and affects versions 2.0.0 and 2.0.1 of github.com/altcha-org/altcha-lib-go. Below is the vulnerable implementation of parseServerSignature in altcha.go prior to the fix:

func parseServerSignature(payload interface{}) (ServerSignaturePayload, ServerSignatureVerificationData, error) {
	var parsedPayload ServerSignaturePayload
	// ... [Payload decoding / JSON unmarshaling into parsedPayload] ...
 
	var verificationData ServerSignatureVerificationData
	params, err := url.ParseQuery(parsedPayload.VerificationData)
	if err == nil {
		// BUG: Extra map is ONLY allocated when url.ParseQuery returns no error
		verificationData.Extra = make(map[string]interface{})
		verificationData.Classification = params.Get("classification")
		verificationData.Country = params.Get("country")
		verificationData.DetectedLanguage = params.Get("detectedLanguage")
		verificationData.Email = params.Get("email")
		verificationData.Expire, _ = strconv.ParseInt(params.Get("expire"), 10, 64)
		verificationData.Fields = strings.Split(params.Get("fields"), ",")
		verificationData.Reasons = strings.Split(params.Get("reasons"), ",")
		verificationData.Score, _ = strconv.ParseFloat(params.Get("score"), 64)
		verificationData.Time, _ = strconv.ParseInt(params.Get("time"), 10, 64)
		verificationData.Verified = params.Get("verified") == "true"
	}
 
	// Execution continues even when err != nil and params is non-empty
	for key, values := range params {
		if !knownFields[key] {
			if len(values) == 1 {
				// PANIC: assignment to entry in nil map if err != nil
				verificationData.Extra[key] = values[0]
			} else if len(values) > 1 {
				// PANIC: assignment to entry in nil map if err != nil
				verificationData.Extra[key] = values
			}
		}
	}
	return parsedPayload, verificationData, nil
}

Furthermore, examining the public entry point VerifyServerSignature shows why this flaw is reachable without authentication or knowledge of the secret hmacKey. The parsing function is invoked before any cryptographic digest comparison occurs:

func VerifyServerSignature(payload interface{}, hmacKey string) (bool, ServerSignatureVerificationData, error) {
	// 1. Pre-verification parsing happens first on untrusted input
	parsedPayload, verificationData, err := parseServerSignature(payload)
	if err != nil {
		return false, verificationData, err
	}
	// 2. Cryptographic HMAC calculation is never reached when a panic occurs above
	// ...
}

The vulnerability was patched in commit 2c4fc27a7b2d5b89f7175676445efcacc564c27c by moving the map allocation statement outside of the if err == nil conditional block:

--- a/altcha.go
+++ b/altcha.go
@@ -277,9 +277,9 @@ func parseServerSignature(payload interface{}) (ServerSignaturePayload, ServerSi
 	}
 
 	var verificationData ServerSignatureVerificationData
+	verificationData.Extra = make(map[string]interface{})
 	params, err := url.ParseQuery(parsedPayload.VerificationData)
 	if err == nil {
-		verificationData.Extra = make(map[string]interface{})
 		verificationData.Classification = params.Get("classification")
 		verificationData.Country = params.Get("country")
 		verificationData.DetectedLanguage = params.Get("detectedLanguage")

Assessing fix completeness: hoisting verificationData.Extra = make(map[string]interface{}) before url.ParseQuery guarantees that verificationData.Extra is always a valid, non-nil map before the for key, values := range params loop executes. Even if url.ParseQuery returns an error alongside partially parsed parameters, writing unknown keys to verificationData.Extra no longer causes a nil-map panic. Subsequent cryptographic verification in VerifyServerSignature will then evaluate the malformed payload against the expected HMAC signature and safely reject invalid or tampered payloads.

Exploitation

Exploiting CVE-2026-103033 requires no authentication, valid challenge solution, or cryptographic key material. The sole prerequisite is network access to an application endpoint that accepts an ALTCHA server signature payload and passes it to altcha.VerifyServerSignature or altcha.VerifyServerSignatureSafe.

To trigger the vulnerability, an attacker constructs a ServerSignaturePayload JSON object containing four standard fields: algorithm, verificationData, signature, and verified. Within the verificationData string, the attacker must include two distinct elements:

  1. At least one parameter key that is not in the library's knownFields map (i.e., any key other than classification, country, detectedLanguage, email, expire, fields, reasons, score, time, or verified).
  2. At least one malformed URL percent-encoding sequence (such as %ZZ, %1, or a trailing %) that causes net/url.ParseQuery to return an error.

An example malicious JSON structure prior to Base64 encoding is shown below:

{
  "algorithm": "SHA-256",
  "verificationData": "customField=exploitValue&malformed=%ZZ",
  "signature": "0000000000000000000000000000000000000000000000000000000000000000",
  "verified": true
}

When encoded in Base64 (eyJhbGdvcml0aG0iOiJTSEEtMjU2IiwidmVyaWZpY2F0aW9uRGF0YSI6ImN1c3RvbUZpZWxkPWV4cGxvaXRWYWx1ZSZtYWxmb3JtZWQ9JVpaIiwic2lnbmF0dXJlIjoiMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCIsInZlcmlmaWVkIjp0cnVlfQ==) and submitted to the target endpoint, the execution proceeds as follows:

  1. parseServerSignature decodes the Base64 payload and unmarshals the JSON into parsedPayload.
  2. url.ParseQuery("customField=exploitValue&malformed=%ZZ") parses the first key-value pair into params["customField"] = []string{"exploitValue"}, encounters %ZZ while parsing the second pair, and returns params along with the error url: invalid URL escape "%ZZ".
  3. Because err != nil, the if err == nil block is skipped, leaving verificationData.Extra as nil.
  4. The loop iterates over params, inspects the key "customField", determines that !knownFields["customField"] is true, and executes verificationData.Extra["customField"] = "exploitValue", immediately panicking the active goroutine.

Impact Assessment

CVE-2026-103033 carries a CVSS v3.1 base score of 5.3 (Medium) with the vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L. The vulnerability is purely an availability issue (A:L) with no impact on confidentiality (C:N) or integrity (I:N), as Go's runtime memory safety guarantees prevent a nil-map assignment from corrupting adjacent memory or leading to code execution.

The operational impact on availability depends heavily on the execution context and framework used by the host Go application. In applications built directly on Go's standard net/http server, each incoming HTTP request runs in an isolated goroutine managed by net/http.conn.serve. By default, net/http wraps handler execution in a defer block that calls recover() when a panic occurs, logs a full stack trace, and closes the client connection without crashing the main server process.

However, in architectures where VerifyServerSignature is invoked outside the standard net/http recovery boundary, the availability impact escalates from a single-request abort to a full application crash:

  • Asynchronous Worker Goroutines: If a handler offloads signature verification to a background goroutine (go verifyPayload(...)) without its own recover() block, an unhandled panic in any child goroutine immediately terminates the entire Go OS process.
  • Custom TCP/RPC Servers & Queue Consumers: Services processing payloads over raw sockets, gRPC interceptors without recovery middleware, or message queues (e.g., Kafka, RabbitMQ consumers) will crash completely upon receiving a single crafted payload, causing a service outage or crash-loop if the malformed message is repeatedly redelivered.

Even in standard net/http deployments where the process survives, an unauthenticated attacker can send a steady stream of small HTTP requests containing the malformed payload to force repeated stack unwinding and error logging, degrading service performance and exhausting log ingestion quotas.

Remediation

The primary remediation is to upgrade github.com/altcha-org/altcha-lib-go to version v2.1.0 or later, which includes commit 2c4fc27a7b2d5b89f7175676445efcacc564c27c to unconditionally initialize verificationData.Extra prior to parsing query parameters.

Developers can update their Go module dependencies using the following commands:

go get -u github.com/altcha-org/altcha-lib-go@v2.1.0
go mod tidy

If an immediate dependency upgrade is not feasible, applications can implement two defensive workarounds. First, wrap calls to altcha.VerifyServerSignature or altcha.VerifyServerSignatureSafe in a wrapper function that explicitly catches panics via recover() and converts them into standard Go errors:

func SafeVerifyServerSignature(payload interface{}, hmacKey string) (verified bool, data altcha.ServerSignatureVerificationData, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("altcha server signature verification panic recovered: %v", r)
			verified = false
		}
	}()
	return altcha.VerifyServerSignature(payload, hmacKey)
}

Second, applications can pre-validate the VerificationData field before invoking the ALTCHA library by decoding the payload and calling url.ParseQuery directly, rejecting any request where url.ParseQuery returns a non-nil error.

Official Patches

ALTCHAOfficial patch commit fixing nil-map panic in parseServerSignature
ALTCHARelease v2.1.0 containing the security fix
GitHub Security AdvisoryOfficial GitHub Security Advisory GHSA-gfwj-45pc-w6r5

Fix Analysis (1)

Technical Appendix

CVSS Score
5.3/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L

Affected Systems

github.com/altcha-org/altcha-lib-go (versions >= 2.0.0, < 2.1.0)

Affected Versions Detail

Product
Affected Versions
Fixed Version
altcha-lib-go
altcha-org
>= 2.0.0, < 2.1.02.1.0
AttributeDetail
CVE IDCVE-2026-103033 (GHSA-gfwj-45pc-w6r5)
Weakness ClassCWE-248 (Uncaught Exception) / CWE-476 (NULL Pointer Dereference)
Attack VectorNetwork (Pre-verification HTTP/RPC payload)
CVSS v3.1 Score5.3 Medium (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L)
Affected Componentgithub.com/altcha-org/altcha-lib-go (parseServerSignature in altcha.go)
ImpactRuntime Panic (assignment to entry in nil map) / Denial of Service
Exploit StatusProof-of-Concept (Trivially reproducible via malformed percent-encoding)
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
CWE-248
Uncaught Exception

The software does not catch an exception or signal (such as a runtime panic in Go), which can lead to unexpected program termination or unhandled denial of service states.

Vulnerability Timeline

Fix committed to altcha-org/altcha-lib-go repository (commit 2c4fc27a7b2d5b89f7175676445efcacc564c27c)
2026-07-25
CVE-2026-103033 and GitHub Security Advisory GHSA-gfwj-45pc-w6r5 published
2026-11-19

References & Sources

  • [1]GitHub Security Advisory GHSA-gfwj-45pc-w6r5
  • [2]Fix Commit 2c4fc27a7b2d5b89f7175676445efcacc564c27c
  • [3]ALTCHA Go Library Release v2.1.0
  • [4]NVD - CVE-2026-103033 Detail
  • [5]CVE.org Record - CVE-2026-103033
  • [6]CVEListV5 JSON Record - CVE-2026-103033

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 1 hour ago•CVE-2026-103025
8.7

CVE-2026-103025: Unbounded Memory Allocation and Decompression Bomb in bep/imagemeta PNG Parser

CVE-2026-103025 (GHSA-7hvw-3c2q-45qg) is a high-severity denial-of-service (DoS) vulnerability in github.com/bep/imagemeta prior to version 0.17.3. The PNG metadata parser fails to validate declared chunk lengths prior to heap buffer allocation (CWE-789) and inflates zlib-compressed zTXt IPTC chunks without an output size limit (CWE-409). Additionally, out-of-bounds slice indexing in the PNG zTXt handler and IPTC character set resolver allows remote attackers to trigger runtime panics.

Amit Schendel
Amit Schendel
1 views•1 min read
•about 3 hours ago•CVE-2026-114516
9.8

CVE-2026-114516: Pre-Authentication Path Traversal and Arbitrary File Read in Etherpad

A pre-authentication path traversal vulnerability exists in Etherpad versions 1.8.14 prior to 3.3.3 within the `/static/*` plugin asset handler. In `src/node/utils/Minify.ts`, an unconditional backslash-to-forward-slash conversion is executed after pathname sanitization has already concluded. On POSIX systems, this transforms benign backslash characters into directory traversal sequences (`../`), allowing unauthenticated remote attackers to read arbitrary files from the host filesystem, extract administrative credentials from `settings.json`, and achieve remote code execution via the plugin installation interface.

Alon Barad
Alon Barad
3 views•10 min read
•about 4 hours ago•CVE-2026-128135
7.1

CVE-2026-128135: Sandbox Escape and Arbitrary File Overwrite via Hardlink Following in NLTK ZIP Extraction

A local sandbox escape vulnerability exists in the Natural Language Toolkit (NLTK) versions 3.9.4 through 3.10.3 within its ZIP archive extraction implementation. Due to a type mismatch in member resolution and a failure to inspect filesystem link counts (st_nlink > 1), the extraction routine follows pre-planted hardlinks inside the extraction root, allowing a local attacker to truncate and overwrite arbitrary out-of-root files writable by the executing process.

Alon Barad
Alon Barad
5 views•10 min read
•about 5 hours ago•CVE-2026-129304
5.4

CVE-2026-129304: Improper Input Validation and Redis Glob Injection in Guard Core

CVE-2026-129304 is an improper input validation and Redis glob pattern injection vulnerability in Guard Core versions 1.0.0 through 3.12.0. The header parsing routine _extract_from_forwarded_header() extracts values from the X-Forwarded-For HTTP header without verifying that the extracted substring is a valid IPv4 or IPv6 address. In deployments configured with trusted_proxies where the target header index is client-controllable, arbitrary strings containing Redis glob metacharacters reach BehaviorTracker and are interpolated directly into Redis key names and blocking KEYS queries. This allows unauthenticated attackers to aggregate cross-client behavioral metrics, trigger false-positive rate limits, cause denial of service via O(N) Redis keyspace scans, or raise unhandled ValueError exceptions during automated IP ban operations.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 6 hours ago•CVE-2026-77597
3.5

CVE-2026-77597: Blind Server-Side Request Forgery in iSponsorBlockTV DIAL Discovery

iSponsorBlockTV prior to version 2.11.0 contains a blind Server-Side Request Forgery (SSRF) vulnerability in its Simple Service Discovery Protocol (SSDP) and Discovery and Launch (DIAL) client implementation. During local device discovery, the application processes SSDP responses without validating that the URL specified in the LOCATION header or the subsequent application-url response header matches the IP address of the responding UDP host. An adjacent network attacker can spoof SSDP responses to induce the iSponsorBlockTV host to send arbitrary HTTP GET requests and constrained HTTP POST requests to internal network endpoints or loopback services.

Alon Barad
Alon Barad
5 views•12 min read
•about 7 hours ago•CVE-2026-121707
8.7

CVE-2026-121707: Regular Expression Denial of Service (ReDoS) in Effect Schema.TemplateLiteral

CVE-2026-121707 is a high-severity Regular Expression Denial of Service (ReDoS) vulnerability in the Effect TypeScript library prior to version 3.22.1. When evaluating untrusted input against Schema.TemplateLiteral definitions containing multiple string spans, the dynamically compiled regular expression exhibits polynomial backtracking complexity. Because JavaScript runtimes execute on a single-threaded event loop, processing specially crafted non-matching strings causes synchronous CPU starvation and complete application unresponsiveness.

Amit Schendel
Amit Schendel
5 views•10 min read