Skip to content

Free tools

Kubernetes RBAC Checker

Paste Role, ClusterRole, RoleBinding and ClusterRoleBinding manifests, or the output of kubectl get with -o yaml or -o json. The page says who gets what and flags the rights an attacker looks for first, each with the rule it came from, what an attacker does with it and what to change.

No network. Nothing you enter leaves this tab. The manifests are parsed and checked in your browser, nothing is stored, and nothing about what you paste is counted or logged.

Load a sample

YAML documents separated by ---, a kubectl List, or JSON, up to 1 MB. kubectl get roles,rolebindings -n NAMESPACE -o yaml and kubectl get clusterroles,clusterrolebindings -o yaml both work; other kinds in the paste are skipped. Anchors, aliases and tags are refused with the line they are on. Ctrl or Cmd and Enter checks it.

Results

Who gets what, each finding and the rule it came from appear here.

Reading the results

Who gets what
When bindings are pasted with the roles they name, the page joins them: each user, group and service account, the role it gets, where (one namespace or the whole cluster) and what that role can do. A binding to cluster-admin, admin, edit or view is read from what those built-in roles grant, even when they are not pasted.
How rules are matched
As the API server matches them: a verb, an API group and a resource each match by name or *, and a * resource covers every subresource. resourceNames narrow a rule to the named objects, so a named rule grants no create or deletecollection on a top-level resource, and grants list or watch only to a request with a matching metadata.name field selector. What a role grants is worked out per binding: a RoleBinding grants only within its namespace and nothing on cluster-scoped resources such as nodes or webhooks, except bind on a ClusterRole and changes to the namespace itself.
Scope and severity
The same right is rated one step higher across the cluster than in one namespace, and a Role in kube-system is rated as cluster-wide, because the controllers' service accounts live there. A rule limited to named objects is one step lower, except bind on cluster-admin, admin or edit. Built-in roles, labelled kubernetes.io/bootstrapping: rbac-defaults, have their own findings shown as notes, but their rights still count for every binding to them.
Escalation verbs
escalate and bind let a subject write or bind a role with rights it does not hold, and impersonate lets it act as someone else, system:masters included. bind is used together with create on rolebindings, as in the RBAC reference's role-grantor example; without a write on bindings or roles in the same role it is rated one step lower.
Secrets, pods and workloads
list and watch on secrets return their contents, not only names. Creating a pod, or any workload with a pod template, means running as any service account in the namespace and mounting any Secret there. exec, attach, ephemeral containers and nodes/proxy run commands in containers that are already running; nodes/proxy also skips admission and the pod audit trail.
Tokens, certificates and webhooks
create on serviceaccounts/token mints a token for an existing service account. Approving certificate signing requests can issue a client certificate with any name and group. Whoever writes a mutating or validating webhook configuration decides where every admitted object is sent.
Public groups, cluster-admin and aggregation
system:anonymous and system:unauthenticated are anyone who can reach the API server; system:authenticated is every user and every service account. The default discovery bindings to those groups are reported as notes. An aggregated ClusterRole takes the rules of every ClusterRole that carries its label, so a label that feeds view can quietly hand out Secrets.

What this check cannot see

RBAC objects are one input to what a subject can do in a cluster. This page reads only what you paste, so it cannot see:

  • Roles and bindings that are not in the paste, including other bindings that give the same subjects more.
  • Who is in a group: membership comes from the identity provider or the client certificate, never from RBAC.
  • Members of system:masters, who bypass RBAC entirely; no binding shows them.
  • Other authorizers: the Node authorizer, webhook authorizers and cloud mappings such as EKS access entries, the aws-auth ConfigMap or GKE IAM.
  • Admission control, such as Pod Security admission, ValidatingAdmissionPolicy, Kyverno or Gatekeeper, which can refuse a pod a role is allowed to create.
  • Which service accounts exist in a namespace and what they hold; anyone who can create a pod there can run as any of them.
  • What the Secrets contain, and which cloud identities are attached to service accounts.
  • Operators and controllers that act with their own permissions on behalf of whoever can create their custom resources.
  • Whether the API server and kubelets accept anonymous requests, and who can reach them on the network.
  • Version differences, such as whether get on pods/exec is still enough for a WebSocket exec on your API server.

A clean result means none of the patterns this page knows appear in what you pasted. It is not proof the RBAC is safe: what each subject can really do depends on everything above, and on kubectl auth can-i run as that subject against the cluster itself.