/

CVE-2026-44797

Severity:

HIGH RISK

(8.5)

Server-Side Request Forgery (SSRF) in Nautobot

CVE-2026-44797

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized network access from the Nautobot server to internal or otherwise restricted endpoints, potentially leading to data exposure or lateral movement.

Severity:

HIGH RISK

(8.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

Nautobot's configurable Webhook feature can be misused to send HTTP requests from the Nautobot server to arbitrary internal or external hosts.

When users with sufficient permissions configure webhooks to target sensitive or restricted endpoints, this can enable SSRF-style attacks such as probing internal networks, accessing metadata services, or interacting with protected services.

Affected context

The vulnerability arises in Nautobot deployments where:

  • The Webhook data model and feature set are enabled and actively used.
  • Users are granted permissions to create, edit, or manage webhook definitions.
  • Outbound network egress from the Nautobot server (or its hosting environment) is allowed to internal services, metadata APIs, or other sensitive infrastructure.

In such environments, webhook URLs may be configured to point to unintended or restricted destinations, turning Nautobot into a pivot point for SSRF-style behaviors.

Exploit preconditions

  • Attack surface: Nautobot's Webhook configuration and execution mechanism.
  • Required access: Authenticated user with sufficient privileges to create or modify webhooks and trigger events that cause those webhooks to fire.
  • Trigger point: Any application event or operation that causes the configured webhook to be executed (e.g., object creation, update, or deletion).
  • Why exploitation is possible: The webhook feature permits user-controlled URLs without sufficiently constraining reachable targets, so the Nautobot server issues outbound HTTP requests on behalf of the user to potentially sensitive network locations.

Why this happens

The underlying issue corresponds to CWE-918: Server-Side Request Forgery (SSRF). Nautobot's webhook system allows users to specify arbitrary URL endpoints that the server will contact when certain events occur.

Because these URLs are treated as trusted destinations and not thoroughly restricted or validated against a safe allowlist or network policy, a user with configuration access can direct webhook calls toward internal or otherwise sensitive services that should not be reachable.

This pattern reflects a lack of strong egress control and contextual validation around server-initiated HTTP requests using user-influenced URLs.

Potential impact

  • Unauthorized access to internal HTTP-based services that are not exposed publicly.
  • Interaction with cloud metadata services, which may disclose credentials, tokens, or instance metadata.
  • Network reconnaissance of internal address ranges, including detection of open ports or responsive services.
  • Indirect access to sensitive APIs or management interfaces that trust traffic originating from the Nautobot server's network location.
  • Possible abuse of reachable internal services to pivot further into the environment, depending on available targets and misconfigurations.

General mitigation guidance

Effective mitigation focuses on constraining where server-side HTTP requests can go and reducing the trust placed in user-configured URLs.

Common defensive patterns include:

  • Enforcing strict allowlists for webhook destinations, limiting callbacks to vetted domains or service endpoints.
  • Implementing URL validation logic that rejects local addresses (e.g., 127.0.0.0/8, ::1), link-local, private RFC1918/4193 ranges, and other sensitive network segments unless explicitly justified.
  • Applying network-level egress controls (firewall rules, security groups, service mesh policies) to prevent Nautobot from reaching internal services that are not meant to be accessed via webhooks.
  • Segregating Nautobot into a network zone with minimal access to critical internal systems, following least privilege for outbound connectivity.
  • Designing webhook capabilities so that sensitive behaviors rely on pre-registered, non-user-editable endpoints rather than free-form URLs where possible.

How teams detect issues like this

Identifying and monitoring SSRF patterns in webhook configurations and behavior can reduce risk:

  • Periodic review of webhook definitions, focusing on endpoints that reference internal IP ranges, localhost, metadata addresses, or non-standard ports.
  • Log analysis of outbound HTTP requests originating from the Nautobot server, with alerts for suspicious destinations (e.g., internal IPs, cloud metadata endpoints, or unexpected internal domains).
  • Static or configuration analysis checks in CI/CD pipelines to flag webhook URLs pointing to disallowed or non-approved domains.
  • Policy enforcement through infrastructure-as-code or configuration management to ensure that only approved destinations can be configured for webhooks.
  • Use of automated security testing tools or SSRF-focused scanners against staging environments to surface risky webhook behaviors.

Sources

SourceLink
github.comgithub.com/nautobot/nautobot/commit/16aa4aa9796ab7a31c4d615ec945e1f16d8c77c4
github.comgithub.com/nautobot/nautobot/commit/7324c8f0d8c7245fbc691e15d729adc2d2707d08
github.comgithub.com/nautobot/nautobot/releases/tag/v2.4.33
github.comgithub.com/nautobot/nautobot/releases/tag/v3.1.2
github.comgithub.com/nautobot/nautobot/security/advisories/GHSA-c35q-vxrp-ph26

Frequently asked

questions

It requires authenticated access to Nautobot with permissions to configure or manage webhooks and to trigger the corresponding events. However, once such access exists, an attacker may use Nautobot as a proxy to reach internal resources that are not otherwise exposed to the internet.

The attacker typically needs an account with sufficient privileges to create or modify webhook configurations and to cause those webhooks to fire (for example by creating, editing, or deleting objects that trigger webhook events).

The safest pattern is to restrict webhook destinations to a tightly controlled allowlist of approved domains or services, validate URLs against that policy, and back this up with network egress controls that technically enforce the same restrictions.

Prevention involves treating any user-influenced URL as untrusted, enforcing strict validation and normalization, limiting outbound connectivity from application servers, and regularly reviewing webhook or callback configurations. Integrating SSRF-specific checks into code review, security testing, and infrastructure policies helps catch similar design patterns early.

Find out what's already
exploitable in your codebase.