Kubescape: Kubernetes Security from Development to Runtime
What Kubescape is
Kubescape is a Kubernetes security tool written in Go. Its README calls it "an open-source Kubernetes security platform" covering "hardening, posture management, and runtime security", and its tagline is "Comprehensive Kubernetes Security from Development to Runtime". The same README says it "was created by ARMO and is a Cloud Native Computing Foundation (CNCF) incubating project", and the CNCF badge on the repository reads "Incubating project".
In practice there are two ways to run it. The first is a single CLI binary that scans a live cluster, a directory of YAML manifests, a Helm chart, a Kustomize directory, a Git repository or a container image on demand. The second is an in-cluster operator, installed with a Helm chart, which adds continuous scanning, image vulnerability scanning, eBPF runtime detection and network policy generation. This page concentrates on the CLI. It is the part most teams try first, and the part that runs in a CI job against manifests before anything reaches a cluster.
The audience is platform engineers, cluster operators and developers who write Kubernetes manifests. Typical goals are gating pull requests on misconfigurations, checking clusters against the NSA-CISA hardening guidance, MITRE ATT&CK or CIS Benchmarks, and producing SARIF, JUnit or HTML reports for code scanning and audits. The repository is kubescape/kubescape, created on 12 August 2021 and licensed under Apache-2.0. The latest release when this page was checked was v4.0.21, published on 13 November 2026.
How it works
CLI mode: OPA, Rego and the regolibrary
The architecture document describes a command layer (scan, fix, patch, list, download, vap, mcpserver, operator) on top of a core engine that loads Kubernetes resources, evaluates them against controls and formats the results. Policy evaluation uses Open Policy Agent. The controls are Rego rules from a separate project, kubescape/regolibrary, which the architecture doc describes as holding "Security controls (200+)", framework definitions and remediation guidance. The AllControls framework in the regolibrary release used for this page lists 290 controls.
A control has an ID such as C-0057 (privileged container), a severity derived from a base score, and one or more rules. Frameworks are named sets of controls: NSA, MITRE, several CIS Benchmark variants, SOC2, ArmoBest, DevOpsBest and others. Unless told otherwise, the CLI downloads the frameworks, exceptions, control inputs and attack tracks from the regolibrary GitHub releases at scan time. In v4.0.21 that download is checked against a Sigstore-signed checksums.txt, which matters a great deal offline, as the hands-on section shows.
Image scanning wraps Anchore's Syft and Grype: Syft builds an SBOM and Grype matches it against a vulnerability database. Image patching wraps Copacetic and BuildKit. The go.mod on master pins OPA v1.22.0, Grype v0.104.1 and Helm v3.21.4. The v4.0.21 binary reports the same OPA, Grype and Helm versions, and was built with Go 1.27.4.
Operator mode
For continuous monitoring, the README points to the kubescape-operator Helm chart. Per the architecture doc, it runs an operator, Kubevuln for image scanning, a host scanner, a storage component that keeps results as custom resources, and a node agent for eBPF runtime security built on Inspektor Gadget. The README lists Prometheus metrics among the operator's features. The kubescape mcpserver command reads the vulnerability and configuration results that the operator stores, so its MCP tools are only useful with the operator installed.
What the CLI talks to
The architecture doc's "Actors and actions" table lists every outbound connection, which is unusually thorough. For a manifest scan the relevant ones are: the policy source (the regolibrary GitHub releases by default, or local files given with --use-artifacts-from or --use-from); a version-check service, version-check.ks-services.co, called on scan and version unless KS_SKIP_UPDATE_CHECK is true; and, only when configured, the ARMO backend, webhook receivers and OpenTelemetry collectors. Per that table, the version check sends "the client version and build, the framework and scanning context, whether the run came from a pipeline, the account ID when one is configured", plus a node count and a cluster-derived ID for cluster scans.
Key features in 4.0.21
- Misconfiguration scanning of clusters, YAML files, Helm charts, Kustomize directories and Git repositories against NSA-CISA, MITRE ATT&CK and CIS Benchmarks, per the README feature table.
- Two scores per report: a control compliance score (passed resources over evaluated resources) and a framework compliance score (the average of the control scores), as defined in the getting-started guide.
- CI gates:
--severity-threshold,--compliance-threshold,--fail-coverage-below,--fail-on-degraded-configand baseline diffing with--baselineand--baseline-fail-on-new. - Many output formats: the CLI reference lists pretty-printer, JSON, JUnit, Prometheus, PDF, HTML, SARIF, several GitLab formats, GitHub Actions annotations, YAML, CSV, Markdown, PolicyReport, an exceptions baseline, and CycloneDX or SPDX SBOMs.
- Auto-fix:
kubescape fixrewrites manifest files from a JSON scan report, or writes a unified diff with--output-patch. - Image scanning and patching through Grype and Copacetic, with KEV and EPSS columns, according to the image-scanning doc.
- Pod Security Standards prediction:
kubescape predict pssreports which workloads would fail Baseline or Restricted enforcement. - Validating Admission Policies:
kubescape vapprints a CEL policy library and policy bindings to pipe intokubectl apply. - Report privacy:
--hidepseudonymises names and namespaces, and--encryptencrypts sensitive metadata with a key fromKUBESCAPE_MASTER_KEY. - MCP server for AI assistants, plus integrations listed in the README: a GitHub Action, GitLab CI and Jenkins docs, MegaLinter, a VS Code extension and a Lens extension.
Getting started
The README's one-line installer (the getting-started guide adds: "We're a security product; please read the file before you run it!"):
curl -s https://raw.githubusercontent.com/kubescape/kubescape/master/install.sh | /bin/bash
Homebrew, Krew, AUR, Nix, Chocolatey and Scoop packages are listed too. The installation guide notes that the official Homebrew formula "has git scanning disabled". Scanning local files and charts:
# Scan local YAML files
kubescape scan /path/to/manifests/
# Scan a Helm chart
kubescape scan /path/to/helm/chart/
Helm values can be overridden the same way as with Helm itself:
kubescape scan /path/to/helm/chart/directory --values my-values.yaml --set image.tag=1.2.3
For air-gapped use, artifacts are downloaded on a connected machine and copied over:
# Download all artifacts
kubescape download artifacts --output /path/to/offline/dir
# Download a specific framework
kubescape download framework nsa --output /path/to/nsa.json
# Scan using downloaded artifacts
kubescape scan --use-artifacts-from /path/to/offline/dir
Gating a pipeline, per the README:
kubescape scan framework nsa --compliance-threshold 80
kubescape scan --view resource --compliance-threshold 80
kubescape scan --severity-threshold high
Auto-fixing from a saved report:
# First, scan and save results to JSON
kubescape scan /path/to/manifests --format json --output results.json
# Then apply fixes
kubescape fix results.json
# Dry run (preview changes without applying)
kubescape fix results.json --dry-run
And the operator for in-cluster scanning:
# Add the Kubescape Helm repository
helm repo add kubescape https://kubescape.github.io/helm-charts/
# Install the operator
helm upgrade --install kubescape kubescape/kubescape-operator \
--namespace kubescape \
--create-namespace
Hands-on: Kubescape 4.0.21 on a Linux VM
Everything in this section was run on 21 November 2026 in a cloud VM: Ubuntu 24.04.5 LTS, Linux 6.18, x86_64, 2 vCPUs, about 7.8 GiB RAM, no swap. There was no Kubernetes cluster and no Docker daemon. Outbound network access was limited to PyPI and raw.githubusercontent.com, so github.com release downloads, the Sigstore TUF CDN, the version-check service and the Grype database host were all unreachable. The input was the official kubescape_4.0.21_linux_amd64.tar.gz (125 MB), whose SHA-256 matched the release's checksums.sha256. Policies came from the release assets of kubescape/regolibrary, downloaded separately on a connected machine on the same day. Every file listed in its checksums.txt that was present verified OK. Wall times and peak RSS were measured with a small wrapper around Python's resource.getrusage, because /usr/bin/time was not installed. All numbers come from a single machine and are only indicative.
Binary and startup
| Check | Result |
|---|---|
| Archive contents | kubescape, README.md, LICENSE |
| Binary | 297,332,494 bytes (about 284 MiB), statically linked ELF with debug info, not stripped; ldd: "not a dynamic executable" |
| Build info | Go 1.27.4; module github.com/kubescape/kubescape/v4 v4.0.21; commit 42df4e16, build date 2026-11-13T13:55:52Z |
kubescape version | Prints "Your current version is: v4.0.21" plus build commit and date; 0.11 to 0.13 s warm (0.38 s on the first run), about 124 MiB peak RSS |
| Version check blocked | No message and no delay. The proxy log showed one refused connection to version-check.ks-services.co per scan or version run; with KS_SKIP_UPDATE_CHECK=true the CLI logs "Skipping version check" |
The installation guide's "Expected Output" block shows Kubescape version: vX.X.X; the actual wording differs, which matters only to scripts that parse it. kubescape version --format json returns a clean object with version, commit and date.
No network: the Sigstore wall
A plain kubescape scan manifests/ with no local policies failed after 0.9 s with exit code 1 and this error: "checksum verification failed: error verifying checksums.txt: failed to fetch Sigstore trusted root: failed to create TUF client failed to load metadata: tuf refresh failed: Get https://tuf-repo-cdn.sigstore.dev/15.root.json". kubescape download artifacts and kubescape list frameworks failed with the same error. list has no flag for local artifacts, and it ignored policy files copied into ~/.kubescape. Signed policy downloads are a sound default. The practical consequence is that a machine able to reach GitHub but not tuf-repo-cdn.sigstore.dev (a common egress allowlist gap) cannot fetch policies at all. The troubleshooting guide's network advice covers proxies and offline artifacts but does not mention the Sigstore host.
Building an offline artifacts directory
Because kubescape download artifacts could not run here, the directory was assembled by hand from the regolibrary release assets. The file names come from the v4.0.21 source of download.go and loadpolicy.go: one lower-cased <framework>.json per framework, plus exceptions.json, controls-inputs.json and attack-tracks.json. Three attempts behaved very differently:
| Artifacts directory | Behaviour |
|---|---|
| Raw release assets, unrenamed | Scan ran (0.8 s, 189 MiB) but printed a "Scan Coverage Warning": exceptions and control inputs "were served from bundled defaults", coverage score 90% with 137/137 controls evaluated. Adding --fail-on-degraded-config turned this into exit 1: "scan policy inputs were degraded" |
Correct names, but allcontrols.json taken from the combined frameworks asset (control metadata without Rego rules) | Only 26 controls ran, and the hardened manifests reported "All controls passed. No issues found", exit 0, with no coverage warning |
| Correct names, full per-framework assets (11 frameworks, 3.6 MB) | 137 controls evaluated, no warnings; used for every result below |
The second row is the one to remember. A malformed artifacts directory can quietly shrink a scan to a fraction of its controls while still reporting success. Anyone mirroring policies should generate them with kubescape download artifacts and check the control count in the JSON report, not only the exit code. A side effect: --use-artifacts-from also copied attack-tracks.json into ~/.kubescape.
Insecure versus hardened manifests
Two test sets were written for this page. The insecure set holds a Deployment in default with nginx:latest, hostNetwork, hostPID, a hostPort, a privileged container that adds SYS_ADMIN and NET_ADMIN, a writable hostPath: / mount, an AWS-style secret in a plain environment variable and no resource limits. It also contains a NodePort Service, a ClusterRole with * on everything and a ClusterRoleBinding of the default service account to cluster-admin. The hardened set holds a Namespace labelled for Restricted PSS, a ServiceAccount without token automount, a non-root read-only Deployment with dropped capabilities, RuntimeDefault seccomp, resource requests and limits and probes, a digest-pinned image, a ClusterIP Service and a NetworkPolicy. Results with the offline artifacts:
| Scan | Controls | Insecure | Hardened | Time / peak RSS |
|---|---|---|---|---|
| Default (security view: AllControls + WorkloadScan) | 137 (10 skipped) | 34 failed; 67.88%; 16 high, 11 medium, 7 low | 5 failed; 89.05%; 3 high, 2 low | 0.72 s / about 195 MiB |
scan framework nsa | 20 | 14 failed; 30.00% | 0 failed; 100% | 0.30 s / 154 MiB |
scan framework mitre | 17 | 4 failed; 76.47% | 0 failed; 100% | 0.22 to 0.26 s / about 150 MiB |
scan framework cis-v1.12.0 | 32 (5 skipped) | 5 failed; 68.75% | 1 failed; 81.25% | 0.32 to 0.35 s / about 155 MiB |
scan framework soc2 | 5 | 2 failed; 60.00% | 0 failed; 100% | 0.22 s / 155 MiB |
The hardened set's five remaining failures are informative. C-0211 ("Apply Security Context to Your Pods and Containers") wants seLinuxOptions and fsGroupChangePolicy; --show-evidence printed the exact paths and line numbers. C-0076 and C-0077 want recommended labels such as tier and version. C-0236 and C-0237 check image signatures, which a file scan cannot satisfy. Ten controls were skipped, either as manual-review controls or because their configuration lists (allowed registries, digest exemptions) were empty. The AWS key in the insecure Deployment was flagged by C-0012, and its value did not appear in any report file.
The RBAC objects were a surprise. In the insecure set, the wildcard ClusterRole was not flagged and did not appear among the scanned resources, and the binding to cluster-admin raised nothing, because cluster-admin is not defined in the files. A separate file that bound the wildcard ClusterRole to a user alice produced 17 failed access-control controls, including C-0187 (wildcards) and C-0035 (administrative roles), all reported against the subject User/alice. In file scans, Kubescape judges RBAC through bindings to roles defined in the same scan, not through roles alone.
Exit codes and thresholds
| Command | Insecure | Hardened |
|---|---|---|
--severity-threshold critical | 0 | 0 |
--severity-threshold high | 1, "compliance result exceeds severity threshold: high" | 1 (C-0211 and the signature controls are high) |
scan framework nsa --compliance-threshold 80 | 1, "scan compliance-score is below permitted threshold: 30.00 (compliance-threshold: 80.00)" | 0 |
Default view, --compliance-threshold 99 | 0 (ignored, as the docs say) | not run |
--view control --compliance-threshold 99 | 1 (67.88 below 99) | not run |
--compliance-threshold 101 | 1: "out of range threshold: --compliance-threshold must be between 0 and 100" | 1, same message |
The getting-started guide warns that the default kubescape scan <path> does not evaluate score thresholds, and the binary behaves exactly that way. A pipeline that passes --compliance-threshold without a framework or --view gates on nothing. Even the hardened set failed --severity-threshold high because of the image-signature controls, so a realistic gate needs exceptions or --exclude-controls for checks that cannot pass in a file scan.
Output formats
For the insecure set, every format below was written with --format X --output r.X, taking 0.85 to 2.1 s and 196 to 235 MiB each:
| Format | Size | Notes |
|---|---|---|
| json | 164,296 B | Full report with summaryDetails, results, resources |
| sarif | 98,922 B | SARIF 2.1.0, 44 rules, 34 results with file, line, fingerprint and fixes |
| junit | 38,859 B | Written as r.junit.xml; 156 tests, 50 failures, coverage properties per suite |
| html / pdf | 143,845 B / 296,200 B | PDF is three pages |
| csv / markdown / yaml | 21,380 B / 24,276 B / 206,882 B | Markdown written as r.markdown.md |
| github-actions | 3,300 B | ::error file=app.yaml,line=17,title=C-0004 … annotations |
| policyreport / prometheus / exceptions | 40,443 B / 87,762 B / 21,287 B | The exceptions baseline landed as r.exceptions.exceptions.json |
| gitlab-codequality | none | Rejected: "invalid format", although the CLI reference on master lists it |
Three gotchas. First, --output appends a format suffix when the file name lacks the expected extension. Second, the pretty-printer summary still goes to stdout when --format json --output file is used. Third, report files are created with mode 0600. Comma-separated formats such as --format json,html,junit --output multi produced all three files in one 0.87 s run.
Auto-fix, Helm and PSS prediction
kubescape fix --dry-runon the insecure report proposed nine field changes, includingprivileged = false,allowPrivilegeEscalation = false,readOnlyRootFilesystem = true,runAsNonRoot = true, aRuntimeDefaultseccomp profile, a read-only hostPath mount andautomountServiceAccountToken = false. It reported "Would auto-fix 7 of 34 flagged control instances". The rest were listed either as "no auto-fix available" (hostNetwork, hostPID, hostPort, hostPath) or as needing user-supplied values (limits, probes), since--skip-user-valuesis on by default.--output-patchwrote a clean 32-line unified diff. After--no-confirm, a rescan showed 26 failed controls and 73.72%, up from 34 and 67.88%. The fix addeddrop: [NET_RAW]but kept theSYS_ADMINadd, so fixed files still need review.- Helm: a small chart with a
hardenedvalue rendered without a Helm binary. The default values gave 23 failed controls (75.91%);--set hardened=true --release-name prod --release-namespace shopgave 9 (86.13%), reported againsttemplates/deployment.yamlas Deploymentprod-demoinshop. The CLI logged "Rendering Helm chart for Kubernetes v1.20.0, as it declares no kubeVersion", which matches the documented default. C-0013 (non-root) still failed because it also wantsrunAsGroup. kubescape predict pssneeded no policy artifacts and ran in about 0.2 s. For the insecure Deployment it listed 14 violations across Baseline and Restricted ("passes at: Privileged") and exited 1. For the hardened set it printed "1/1 workloads pass at Restricted" and exited 0.
Report privacy flags
--hide replaced names and namespaces with stable pseudonyms such as res-4b5e… and ns-37a8…. --encrypt accepted 16-, 32- and 64-character values of KUBESCAPE_MASTER_KEY and refused an 8-character key ("want at least 16"). That matches the README's "at least 16 characters", but not the CLI reference, which says the key "must be exactly 32 characters long". The round trip did not work: kubescape decrypt exited 1 on every encrypted file-scan report produced here, for both test sets and all three key lengths, with "encrypted value remains at report[…]["evidence"][0]["value"]".
Scaling and an independent second opinion
Copies of the insecure Deployment and Service were generated in separate files and scanned with the default view. For comparison, Checkov 3.4.6, installed from PyPI into a 237 MB virtualenv, ran on the same directories with --framework kubernetes:
| Objects | Kubescape 4.0.21 | Checkov 3.4.6 |
|---|---|---|
| 4 to 6 (test sets) | 0.7 s, about 195 MiB | 2.3 to 2.8 s, 181 to 205 MiB |
| 200 | 4.1 s, 274 MiB | 3.6 s, 232 MiB |
| 1,000 | 25.7 s, 367 MiB | 8.2 s, 491 MiB |
| 2,000 | 60.8 s, 566 MiB | not run |
Kubescape's time grew faster than linearly with this input. --incremental, which the CLI reference says caches each resource's verdict, gave about 20 s on both the first and second run at 1,000 objects, so no measurable gain for file scans here. On findings, Checkov failed 32 checks on the insecure set and none on the hardened set. Unlike Kubescape, it flagged the wildcard ClusterRole directly (CKV_K8S_49) and the latest tag (CKV_K8S_14). Kubescape, in turn, flagged the writable hostPath mount, the credential in an environment variable and the missing signature, which Checkov's Kubernetes checks did not report here.
What could not be tested
- Cluster scans: no cluster; the CLI stops with "failed connecting to Kubernetes cluster … no configuration has been provided".
- Image scanning:
kubescape scan image nginx:1.27failed in 0.15 s with "failed to load vulnerability db: database does not exist", because the Grype database could not be downloaded. With--skip-db-updatethe message adds "run once without --skip-db-update to download it". Registry access was not available either. - Image patching, the operator, VAP deployment and runtime detection: these need Docker, BuildKit or a cluster.
- MCP server: it starts on stdio and warns "No --workspace configured: local IaC scans will run in unconstrained mode", but its tools need operator data.
- Trivy: its release binaries are on github.com, which was unreachable, so it was not run.
Use cases
- Pull-request gates on manifests and charts: scan the rendered chart or Kustomize output, upload SARIF to code scanning, and fail on
--severity-thresholdor a framework score. Charts packaged with Helm render in-process, but dependencies must already be vendored incharts/. - Pre-sync checks in GitOps: run the same scan in the repository that Argo CD syncs from, so a privileged pod is caught before the sync rather than after.
- Compliance evidence: NSA, MITRE, CIS v1.12.0 and SOC2 framework reports in PDF, HTML or JUnit, with exceptions and an exceptions baseline to track accepted risks.
- PSS rollout planning:
predict pssshows which workloads would break before a namespace is labelledenforce: restricted. - Continuous cluster posture: the operator rescans workloads, scans images and exposes metrics that Prometheus can scrape. Scan traces can also go to an OpenTelemetry Collector via
--otel-endpoint. - Air-gapped clusters: possible with pre-downloaded artifacts and an offline Grype database image, subject to the artifact caveats above.
How Kubescape compares
Descriptions come from each project's README and licence as read on 21 November 2026. Checkov was also run against the same manifests (see above); Trivy and Polaris were not run.
| Project | Scope per its README | Kubernetes angle | Licence |
|---|---|---|---|
| Kubescape 4.0.21 | Kubernetes security platform: posture, image CVEs, runtime (operator) | Frameworks (NSA, MITRE, CIS, SOC2), compliance scores, auto-fix, PSS prediction, VAP helpers, in-cluster operator | Apache-2.0; CNCF incubating |
| Trivy | "A comprehensive and versatile security scanner" for container images, filesystems, Git repositories, VM images and Kubernetes | Misconfigurations, vulnerabilities, secrets and licences; trivy k8s cluster reports and a separate Trivy Operator | Apache-2.0; an Aqua Security project |
| Checkov | Static analysis for infrastructure as code plus software composition analysis | Kubernetes, Helm and Kustomize among many IaC formats (Terraform, CloudFormation, Dockerfile and more); Python 3.10 to 3.13 | Apache-2.0; "Maintained by Prisma Cloud" |
| Polaris | "An open source policy engine for Kubernetes that validates and remediates resource configuration" | 30+ built-in policies, custom policies in JSON Schema; dashboard, admission controller or CLI | Apache-2.0; by Fairwinds |
Trivy is the broadest of the group. One binary covers images, filesystems, IaC and secrets across many ecosystems, so a team that already uses it for container CVEs gets Kubernetes misconfiguration checks without adding a tool. Kubescape goes deeper on Kubernetes specifically: named compliance frameworks with scores, attack-path prioritisation, relationship-aware RBAC controls, PSS prediction, admission-policy helpers and an operator with eBPF runtime detection. The two can also be used side by side, Trivy for artifacts and Kubescape for cluster posture.
Checkov fits teams whose repositories mix Terraform, CloudFormation and Kubernetes and who want a single policy runner. In this test it was quicker on large manifest sets and needed no policy download. Polaris is the lightest-weight option when the goal is a small set of best-practice checks, optionally enforced by an admission webhook. Kubescape is the stronger choice when NSA, MITRE or CIS reports, compliance scores or the in-cluster platform matter.
Limits, trade-offs and when not to use it
- Offline needs care. Without local artifacts, nothing works unless both GitHub and
tuf-repo-cdn.sigstore.devare reachable. With a hand-assembled directory, a mistake can silently shrink the scan; in this test, 26 controls ran instead of 137 and the output still said "All controls passed". Usekubescape download artifacts, pin--controls-version, and assert on control counts or add--fail-on-degraded-config. - A large binary. At about 284 MiB, and about 124 MiB RSS just to print its version, it is heavy for small CI runners or containers. That is the cost of embedding OPA, Helm, Grype, Syft and Copacetic in one executable.
- Threshold semantics are easy to get wrong.
--compliance-thresholdis ignored in the default view, and signature controls fail every unsigned image in a file scan. Plan exceptions before turning on--severity-threshold high. - File-scan RBAC is relationship-based. A wildcard ClusterRole on its own, or a binding to a built-in role, produced no finding here. A simpler per-object linter catches those.
- Scaling on big repositories. 2,000 objects took about 61 s and 566 MiB on 2 vCPUs, and
--incrementaldid not help file scans in this test. - Auto-fix is partial. It fixed 7 of 34 findings and left an added
SYS_ADMINcapability in place. Review the diff with--output-patchrather than writing files in place. - Docs ahead of or behind the binary. Observed:
gitlab-codequalityis documented but rejected by v4.0.21; the master-key length is documented as exactly 32 characters in one place and at least 16 in another (the binary enforces 16);decryptfailed on encrypted reports; the CLI reference says a failed scan "never leaves an empty file at a new path", but an empty-directory scan left a 0-byte, mode-0600 file; and the installation guide's sample version output does not match the real wording. - Vendor gravity. All five core maintainers listed in the governance repo are from ARMO or Softwine, the architecture doc names
api.armosec.ioas the default backend for the microservice image when an account or access key is set, and the roadmap openly asks which features land in OSS versus "the ARMO platform". The CLI is fully usable without an account; just be clear about which features need one. - When not to use it: when images and code dependencies are the main concern and Kubernetes manifests are incidental (a general scanner fits better); when only a handful of best-practice checks are wanted in a tiny CI image; or in a locked-down network where neither the Sigstore CDN nor a policy mirror is an option.
Network calls, telemetry and security reporting
Reporting to the ARMO backend is opt-in: --submit defaults to false, and the architecture doc says the CLI uses the backend "only when an account ID or --server is configured". OpenTelemetry export is off unless --otel-endpoint or an OTEL_EXPORTER_OTLP_* variable is set, and the doc notes that variables inherited from the environment count. The one call made by default is the version check described above. Set KS_SKIP_UPDATE_CHECK=true in CI to stop it, as was done for most runs here. Scan reports redact container environment variables and Secret or ConfigMap data, which this test confirmed for the planted key.
Security issues go through GitHub private vulnerability reports. The central SECURITY.md promises a response within seven working days and a 90-day disclosure timeline, and says the project is supported under the Linux Foundation CRA stewardship framework. The docs index marks the security self-assessment as "Incomplete" pending maintainer review. Public adopters listed in the governance repo include Intel, Rabobank, Gitpod, Energi Danmark and AWS workshop material. To keep secrets out of manifests in the first place, pair a scanner like this with Gitleaks in the same pipeline, which can also run in Jenkins jobs alongside Kubescape's documented Jenkins integration. For the secrets themselves, a manager such as OpenBao avoids the plain environment variables that C-0012 flags.
Project activity
Checked 21 November 2026: latest release v4.0.21, published 13 November 2026, licence Apache-2.0, per the GitHub releases page and the repository's licence file. The kubescape/kubescape repository had about 12,000 stars (11,967 at the time of writing) and 1,117 forks. It is written in Go, was created on 12 August 2021 and develops on master, last pushed on 20 November 2026. The governance repository's roadmap covers 2026H2 and 2027H1, with items such as CEL controls alongside Rego, VEX ingestion and eBPF-based prevention. Release notes are on the GitHub releases page, and documentation is at kubescape.io.
Enjoying this project?
Discover more amazing open-source projects on TechLogHub. We curate the best developer tools and projects.
Repository:https://github.com/kubescape/kubescape
GitHub - kubescape/kubescape: Kubescape: Kubernetes Security from Development to Runtime
Kubescape is an Apache-2.0, CNCF incubating Kubernetes security platform. Version 4.0.21 tested offline on a Linux VM: manifest and Helm scans, NSA, MITRE and C...
github - kubescape/kubescape
Related Projects
RAGFlow: Open-Source RAG Engine with Agentic Retrieval
Self-hosted RAG engine with deep document parsing, grounded citations and agentic retrieval.
Hugo: Fast Static Site Generator Written in Go
Single-binary Go static site generator with built-in asset pipelines, live dev server and Hugo Modules.
Syncthing: Continuous Peer-to-Peer File Synchronization
Open-source peer-to-peer file sync between your own devices, encrypted with TLS and no central cloud copy.
Maintain Kubescape: Kubernetes Security from Development to Runtime? Add the badge to your README
Show that the project is featured on TechLogHub and send readers to this write-up.
[](https://techloghub.com/open-source/kubescape?utm_source=techloghub_badge&utm_medium=referral&utm_campaign=readme)