Debian Codegraph @

pkg/admission/plugin/policy/validating/plugin.go

raw
1 /*
2 Copyright 2024 The Kubernetes Authors.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 package validating
18
19 import (
20 "context"
21 "io"
22 "sync"
23
24 v1 "k8s.io/api/admissionregistration/v1"
25 "k8s.io/apimachinery/pkg/api/meta"
26 "k8s.io/apiserver/pkg/admission"
27 "k8s.io/apiserver/pkg/admission/initializer"
28 "k8s.io/apiserver/pkg/admission/plugin/cel"
29 "k8s.io/apiserver/pkg/admission/plugin/policy/generic"
30 "k8s.io/apiserver/pkg/admission/plugin/policy/matching"
31 "k8s.io/apiserver/pkg/admission/plugin/webhook/matchconditions"
32 "k8s.io/apiserver/pkg/authorization/authorizer"
33 "k8s.io/apiserver/pkg/cel/environment"
34 "k8s.io/apiserver/pkg/features"
35 utilfeature "k8s.io/apiserver/pkg/util/feature"
36 "k8s.io/client-go/dynamic"
37 "k8s.io/client-go/informers"
38 "k8s.io/client-go/kubernetes"
39 )
40
41 const (
42 // PluginName indicates the name of admission plug-in
43 PluginName = "ValidatingAdmissionPolicy"
44 )
45
46 var (
47 lazyCompositionEnvTemplateWithStrictCostInit sync.Once
48 lazyCompositionEnvTemplateWithStrictCost *cel.CompositionEnv
49
50 lazyCompositionEnvTemplateWithoutStrictCostInit sync.Once
51 lazyCompositionEnvTemplateWithoutStrictCost *cel.CompositionEnv
52 )
53
54 func getCompositionEnvTemplateWithStrictCost() *cel.CompositionEnv {
55 lazyCompositionEnvTemplateWithStrictCostInit.Do(func() {
56 env, err := cel.NewCompositionEnv(cel.VariablesTypeName, environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion(), true))
57 if err != nil {
58 panic(err)
59 }
60 lazyCompositionEnvTemplateWithStrictCost = env
61 })
62 return lazyCompositionEnvTemplateWithStrictCost
63 }
64
65 func getCompositionEnvTemplateWithoutStrictCost() *cel.CompositionEnv {
66 lazyCompositionEnvTemplateWithoutStrictCostInit.Do(func() {
67 env, err := cel.NewCompositionEnv(cel.VariablesTypeName, environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion(), false))
68 if err != nil {
69 panic(err)
70 }
71 lazyCompositionEnvTemplateWithoutStrictCost = env
72 })
73 return lazyCompositionEnvTemplateWithoutStrictCost
74 }
75
76 // Register registers a plugin
77 func Register(plugins *admission.Plugins) {
78 plugins.Register(PluginName, func(configFile io.Reader) (admission.Interface, error) {
79 return NewPlugin(configFile), nil
80 })
81 }
82
83 // Plugin is an implementation of admission.Interface.
84 type Policy = v1.ValidatingAdmissionPolicy
85 type PolicyBinding = v1.ValidatingAdmissionPolicyBinding
86 type PolicyEvaluator = Validator
87 type PolicyHook = generic.PolicyHook[*Policy, *PolicyBinding, PolicyEvaluator]
88
89 type Plugin struct {
90 *generic.Plugin[PolicyHook]
91 }
92
93 var _ admission.Interface = &Plugin{}
94 var _ admission.ValidationInterface = &Plugin{}
95 var _ initializer.WantsExcludedAdmissionResources = &Plugin{}
96
97 func NewPlugin(_ io.Reader) *Plugin {
98 handler := admission.NewHandler(admission.Connect, admission.Create, admission.Delete, admission.Update)
99
100 p := &Plugin{
101 Plugin: generic.NewPlugin(
102 handler,
103 func(f informers.SharedInformerFactory, client kubernetes.Interface, dynamicClient dynamic.Interface, restMapper meta.RESTMapper) generic.Source[PolicyHook] {
104 return generic.NewPolicySource(
105 f.Admissionregistration().V1().ValidatingAdmissionPolicies().Informer(),
106 f.Admissionregistration().V1().ValidatingAdmissionPolicyBindings().Informer(),
107 NewValidatingAdmissionPolicyAccessor,
108 NewValidatingAdmissionPolicyBindingAccessor,
109 compilePolicy,
110 f,
111 dynamicClient,
112 restMapper,
113 )
114 },
115 func(a authorizer.Authorizer, m *matching.Matcher, client kubernetes.Interface) generic.Dispatcher[PolicyHook] {
116 return NewDispatcher(a, generic.NewPolicyMatcher(m))
117 },
118 ),
119 }
120 p.SetEnabled(true)
121 return p
122 }
123
124 // Validate makes an admission decision based on the request attributes.
125 func (a *Plugin) Validate(ctx context.Context, attr admission.Attributes, o admission.ObjectInterfaces) error {
126 return a.Plugin.Dispatch(ctx, attr, o)
127 }
128
129 func compilePolicy(policy *Policy) Validator {
130 hasParam := false
131 if policy.Spec.ParamKind != nil {
132 hasParam = true
133 }
134 strictCost := utilfeature.DefaultFeatureGate.Enabled(features.StrictCostEnforcementForVAP)
135 optionalVars := cel.OptionalVariableDeclarations{HasParams: hasParam, HasAuthorizer: true, StrictCost: strictCost}
136 expressionOptionalVars := cel.OptionalVariableDeclarations{HasParams: hasParam, HasAuthorizer: false, StrictCost: strictCost}
137 failurePolicy := policy.Spec.FailurePolicy
138 var matcher matchconditions.Matcher = nil
139 matchConditions := policy.Spec.MatchConditions
140 var compositionEnvTemplate *cel.CompositionEnv
141 if strictCost {
142 compositionEnvTemplate = getCompositionEnvTemplateWithStrictCost()
143 } else {
144 compositionEnvTemplate = getCompositionEnvTemplateWithoutStrictCost()
145 }
146 filterCompiler := cel.NewCompositedCompilerFromTemplate(compositionEnvTemplate)
147 filterCompiler.CompileAndStoreVariables(convertv1beta1Variables(policy.Spec.Variables), optionalVars, environment.StoredExpressions)
148
149 if len(matchConditions) > 0 {
150 matchExpressionAccessors := make([]cel.ExpressionAccessor, len(matchConditions))
151 for i := range matchConditions {
152 matchExpressionAccessors[i] = (*matchconditions.MatchCondition)(&matchConditions[i])
153 }
154 matcher = matchconditions.NewMatcher(filterCompiler.CompileCondition(matchExpressionAccessors, optionalVars, environment.StoredExpressions), failurePolicy, "policy", "validate", policy.Name)
155 }
156 res := NewValidator(
157 filterCompiler.CompileCondition(convertv1Validations(policy.Spec.Validations), optionalVars, environment.StoredExpressions),
158 matcher,
159 filterCompiler.CompileCondition(convertv1AuditAnnotations(policy.Spec.AuditAnnotations), optionalVars, environment.StoredExpressions),
160 filterCompiler.CompileCondition(convertv1MessageExpressions(policy.Spec.Validations), expressionOptionalVars, environment.StoredExpressions),
161 failurePolicy,
162 )
163
164 return res
165 }
166
167 func convertv1Validations(inputValidations []v1.Validation) []cel.ExpressionAccessor {
168 celExpressionAccessor := make([]cel.ExpressionAccessor, len(inputValidations))
169 for i, validation := range inputValidations {
170 validation := ValidationCondition{
171 Expression: validation.Expression,
172 Message: validation.Message,
173 Reason: validation.Reason,
174 }
175 celExpressionAccessor[i] = &validation
176 }
177 return celExpressionAccessor
178 }
179
180 func convertv1MessageExpressions(inputValidations []v1.Validation) []cel.ExpressionAccessor {
181 celExpressionAccessor := make([]cel.ExpressionAccessor, len(inputValidations))
182 for i, validation := range inputValidations {
183 if validation.MessageExpression != "" {
184 condition := MessageExpressionCondition{
185 MessageExpression: validation.MessageExpression,
186 }
187 celExpressionAccessor[i] = &condition
188 }
189 }
190 return celExpressionAccessor
191 }
192
193 func convertv1AuditAnnotations(inputValidations []v1.AuditAnnotation) []cel.ExpressionAccessor {
194 celExpressionAccessor := make([]cel.ExpressionAccessor, len(inputValidations))
195 for i, validation := range inputValidations {
196 validation := AuditAnnotationCondition{
197 Key: validation.Key,
198 ValueExpression: validation.ValueExpression,
199 }
200 celExpressionAccessor[i] = &validation
201 }
202 return celExpressionAccessor
203 }
204
205 func convertv1beta1Variables(variables []v1.Variable) []cel.NamedExpressionAccessor {
206 namedExpressions := make([]cel.NamedExpressionAccessor, len(variables))
207 for i, variable := range variables {
208 namedExpressions[i] = &Variable{Name: variable.Name, Expression: variable.Expression}
209 }
210 return namedExpressions
211 }