Nov 20, 2026·10 min read·2 visits
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.
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.
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.
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.
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:
knownFields map (i.e., any key other than classification, country, detectedLanguage, email, expire, fields, reasons, score, time, or verified).%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:
parseServerSignature decodes the Base64 payload and unmarshals the JSON into parsedPayload.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".err != nil, the if err == nil block is skipped, leaving verificationData.Extra as nil.params, inspects the key "customField", determines that !knownFields["customField"] is true, and executes verificationData.Extra["customField"] = "exploitValue", immediately panicking the active goroutine.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:
go verifyPayload(...)) without its own recover() block, an unhandled panic in any child goroutine immediately terminates the entire Go OS process.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.
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 tidyIf 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.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L| Product | Affected Versions | Fixed Version |
|---|---|---|
altcha-lib-go altcha-org | >= 2.0.0, < 2.1.0 | 2.1.0 |
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-103033 (GHSA-gfwj-45pc-w6r5) |
| Weakness Class | CWE-248 (Uncaught Exception) / CWE-476 (NULL Pointer Dereference) |
| Attack Vector | Network (Pre-verification HTTP/RPC payload) |
| CVSS v3.1 Score | 5.3 Medium (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) |
| Affected Component | github.com/altcha-org/altcha-lib-go (parseServerSignature in altcha.go) |
| Impact | Runtime Panic (assignment to entry in nil map) / Denial of Service |
| Exploit Status | Proof-of-Concept (Trivially reproducible via malformed percent-encoding) |
| CISA KEV Status | Not Listed |
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.
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.
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.
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.
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.
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.
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.