/

CVE-2026-30064

Severity:

HIGH RISK

(7.5)

Improper Input Validation (CWE-20) in free5gc buildFilter

CVE-2026-30064

Deferred

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20

Impact:

Denial of Service

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A high-severity input validation flaw in free5gc's buildFilter function may allow a crafted input to trigger a denial-of-service condition. The issue becomes risky when attacker-controlled data reaches filter processing without sufficient validation or resource safeguards.

Affected context

The vulnerability occurs in the processor/processor.go component of free5gc v4.0.1, specifically within the buildFilter function. Deployments may be exposed when untrusted or externally influenced input is passed to this function and malformed values are processed without adequate validation.

Exploit preconditions

  • Attack surface: Input processing through the free5gc processor component
  • Required access: Ability to provide or influence data consumed by buildFilter
  • Trigger point: Handling of crafted filter-related input
  • Why exploitation is possible: Insufficient validation may allow malformed input to reach processing logic that can consume excessive resources, encounter an unhandled error, or otherwise disrupt service availability

Why this happens

The underlying issue is improper input validation, mapped to CWE-20. The buildFilter function appears to process input without adequately enforcing expected formats, ranges, structures, or resource-related constraints, allowing unexpected values to reach downstream logic and potentially cause service disruption.

Potential impact

  • The affected service may become unavailable or unresponsive
  • Processing workers may terminate or restart unexpectedly
  • Legitimate requests could experience delays or failures
  • Repeated crafted inputs could cause sustained resource exhaustion

General mitigation guidance

Mitigation generally focuses on reducing trust in incoming data and making filter processing fail safely.

Common defensive patterns include:

  • Enforcing strict allowlist-based validation for filter structure, types, lengths, and ranges
  • Rejecting malformed input before it reaches deeper processing logic
  • Applying bounded resource usage, timeouts, and request-size limits
  • Handling validation failures without panics, uncontrolled loops, or excessive allocation
  • Running processing components with only the privileges and resources they require
  • Separating externally supplied filter data from trusted internal configuration

How teams detect issues like this

Detection approaches may include:

  • Static analysis for unchecked parsing, unbounded loops, unchecked allocations, and missing error handling in buildFilter paths
  • Code review checks for externally controlled values reaching filter construction without schema or range validation
  • Fuzz testing with malformed, oversized, nested, and boundary-value inputs
  • Runtime monitoring for processor crashes, restart spikes, latency increases, and resource exhaustion
  • Policy enforcement requiring validation schemas, bounded processing, and negative test coverage for input-handling code

Sources

SourceLink
github.comgithub.com/free5gc/free5gc/issues/770

Frequently asked

questions

Exploitability depends on whether an attacker can submit or influence data that reaches the affected buildFilter function. If that input is exposed through a network-accessible service, crafted requests may be able to trigger the condition.

The required access depends on the free5gc deployment and its access controls. Authentication may limit exposure, but any authorized or unauthenticated path that accepts attacker-controlled filter input should be evaluated.

Validate filter inputs against a strict schema before processing, enforce size and complexity limits, and ensure malformed values produce controlled errors rather than service disruption.

Combine allowlist-based validation, fuzz testing, defensive resource limits, robust error handling, and monitoring for abnormal processor behavior.

Find out what's already
exploitable in your codebase.