Debian Codegraph @

pkg/admission/plugin/cel/compile.go

raw
1 /*
2 Copyright 2022 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 cel
18
19 import (
20 "fmt"
21
22 "github.com/google/cel-go/cel"
23
24 "k8s.io/apimachinery/pkg/util/version"
25 celconfig "k8s.io/apiserver/pkg/apis/cel"
26 apiservercel "k8s.io/apiserver/pkg/cel"
27 "k8s.io/apiserver/pkg/cel/common"
28 "k8s.io/apiserver/pkg/cel/environment"
29 "k8s.io/apiserver/pkg/cel/library"
30 "k8s.io/apiserver/pkg/cel/mutation"
31 )
32
33 const (
34 ObjectVarName = "object"
35 OldObjectVarName = "oldObject"
36 ParamsVarName = "params"
37 RequestVarName = "request"
38 NamespaceVarName = "namespaceObject"
39 AuthorizerVarName = "authorizer"
40 RequestResourceAuthorizerVarName = "authorizer.requestResource"
41 VariableVarName = "variables"
42 )
43
44 // BuildRequestType generates a DeclType for AdmissionRequest. This may be replaced with a utility that
45 // converts the native type definition to apiservercel.DeclType once such a utility becomes available.
46 // The 'uid' field is omitted since it is not needed for in-process admission review.
47 // The 'object' and 'oldObject' fields are omitted since they are exposed as root level CEL variables.
48 func BuildRequestType() *apiservercel.DeclType {
49 field := func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField {
50 return apiservercel.NewDeclField(name, declType, required, nil, nil)
51 }
52 fields := func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField {
53 result := make(map[string]*apiservercel.DeclField, len(fields))
54 for _, f := range fields {
55 result[f.Name] = f
56 }
57 return result
58 }
59 gvkType := apiservercel.NewObjectType("kubernetes.GroupVersionKind", fields(
60 field("group", apiservercel.StringType, true),
61 field("version", apiservercel.StringType, true),
62 field("kind", apiservercel.StringType, true),
63 ))
64 gvrType := apiservercel.NewObjectType("kubernetes.GroupVersionResource", fields(
65 field("group", apiservercel.StringType, true),
66 field("version", apiservercel.StringType, true),
67 field("resource", apiservercel.StringType, true),
68 ))
69 userInfoType := apiservercel.NewObjectType("kubernetes.UserInfo", fields(
70 field("username", apiservercel.StringType, false),
71 field("uid", apiservercel.StringType, false),
72 field("groups", apiservercel.NewListType(apiservercel.StringType, -1), false),
73 field("extra", apiservercel.NewMapType(apiservercel.StringType, apiservercel.NewListType(apiservercel.StringType, -1), -1), false),
74 ))
75 return apiservercel.NewObjectType("kubernetes.AdmissionRequest", fields(
76 field("kind", gvkType, true),
77 field("resource", gvrType, true),
78 field("subResource", apiservercel.StringType, false),
79 field("requestKind", gvkType, true),
80 field("requestResource", gvrType, true),
81 field("requestSubResource", apiservercel.StringType, false),
82 field("name", apiservercel.StringType, true),
83 field("namespace", apiservercel.StringType, false),
84 field("operation", apiservercel.StringType, true),
85 field("userInfo", userInfoType, true),
86 field("dryRun", apiservercel.BoolType, false),
87 field("options", apiservercel.DynType, false),
88 ))
89 }
90
91 // BuildNamespaceType generates a DeclType for Namespace.
92 // Certain nested fields in Namespace (e.g. managedFields, ownerReferences etc.) are omitted in the generated DeclType
93 // by design.
94 func BuildNamespaceType() *apiservercel.DeclType {
95 field := func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField {
96 return apiservercel.NewDeclField(name, declType, required, nil, nil)
97 }
98 fields := func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField {
99 result := make(map[string]*apiservercel.DeclField, len(fields))
100 for _, f := range fields {
101 result[f.Name] = f
102 }
103 return result
104 }
105
106 specType := apiservercel.NewObjectType("kubernetes.NamespaceSpec", fields(
107 field("finalizers", apiservercel.NewListType(apiservercel.StringType, -1), true),
108 ))
109 conditionType := apiservercel.NewObjectType("kubernetes.NamespaceCondition", fields(
110 field("status", apiservercel.StringType, true),
111 field("type", apiservercel.StringType, true),
112 field("lastTransitionTime", apiservercel.TimestampType, true),
113 field("message", apiservercel.StringType, true),
114 field("reason", apiservercel.StringType, true),
115 ))
116 statusType := apiservercel.NewObjectType("kubernetes.NamespaceStatus", fields(
117 field("conditions", apiservercel.NewListType(conditionType, -1), true),
118 field("phase", apiservercel.StringType, true),
119 ))
120 metadataType := apiservercel.NewObjectType("kubernetes.NamespaceMetadata", fields(
121 field("name", apiservercel.StringType, true),
122 field("generateName", apiservercel.StringType, true),
123 field("namespace", apiservercel.StringType, true),
124 field("labels", apiservercel.NewMapType(apiservercel.StringType, apiservercel.StringType, -1), true),
125 field("annotations", apiservercel.NewMapType(apiservercel.StringType, apiservercel.StringType, -1), true),
126 field("UID", apiservercel.StringType, true),
127 field("creationTimestamp", apiservercel.TimestampType, true),
128 field("deletionGracePeriodSeconds", apiservercel.IntType, true),
129 field("deletionTimestamp", apiservercel.TimestampType, true),
130 field("generation", apiservercel.IntType, true),
131 field("resourceVersion", apiservercel.StringType, true),
132 field("finalizers", apiservercel.NewListType(apiservercel.StringType, -1), true),
133 ))
134 return apiservercel.NewObjectType("kubernetes.Namespace", fields(
135 field("metadata", metadataType, true),
136 field("spec", specType, true),
137 field("status", statusType, true),
138 ))
139 }
140
141 // CompilationResult represents a compiled validations expression.
142 type CompilationResult struct {
143 Program cel.Program
144 Error *apiservercel.Error
145 ExpressionAccessor ExpressionAccessor
146 OutputType *cel.Type
147 }
148
149 // Compiler provides a CEL expression compiler configured with the desired admission related CEL variables and
150 // environment mode.
151 type Compiler interface {
152 CompileCELExpression(expressionAccessor ExpressionAccessor, options OptionalVariableDeclarations, mode environment.Type) CompilationResult
153 }
154
155 type compiler struct {
156 varEnvs variableDeclEnvs
157 }
158
159 func NewCompiler(env *environment.EnvSet) Compiler {
160 return &compiler{varEnvs: mustBuildEnvs(env)}
161 }
162
163 type variableDeclEnvs map[OptionalVariableDeclarations]*environment.EnvSet
164
165 // CompileCELExpression returns a compiled CEL expression.
166 // perCallLimit was added for testing purpose only. Callers should always use const PerCallLimit from k8s.io/apiserver/pkg/apis/cel/config.go as input.
167 func (c compiler) CompileCELExpression(expressionAccessor ExpressionAccessor, options OptionalVariableDeclarations, envType environment.Type) CompilationResult {
168 resultError := func(errorString string, errType apiservercel.ErrorType, cause error) CompilationResult {
169 return CompilationResult{
170 Error: &apiservercel.Error{
171 Type: errType,
172 Detail: errorString,
173 Cause: cause,
174 },
175 ExpressionAccessor: expressionAccessor,
176 }
177 }
178
179 env, err := c.varEnvs[options].Env(envType)
180 if err != nil {
181 return resultError(fmt.Sprintf("unexpected error loading CEL environment: %v", err), apiservercel.ErrorTypeInternal, nil)
182 }
183
184 ast, issues := env.Compile(expressionAccessor.GetExpression())
185 if issues != nil {
186 return resultError("compilation failed: "+issues.String(), apiservercel.ErrorTypeInvalid, apiservercel.NewCompilationError(issues))
187 }
188 found := false
189 returnTypes := expressionAccessor.ReturnTypes()
190 for _, returnType := range returnTypes {
191 if ast.OutputType().IsExactType(returnType) || cel.AnyType.IsExactType(returnType) {
192 found = true
193 break
194 }
195 }
196 if !found {
197 var reason string
198 if len(returnTypes) == 1 {
199 reason = fmt.Sprintf("must evaluate to %v but got %v", returnTypes[0].String(), ast.OutputType().String())
200 } else {
201 reason = fmt.Sprintf("must evaluate to one of %v but got %v", returnTypes, ast.OutputType().String())
202 }
203
204 return resultError(reason, apiservercel.ErrorTypeInvalid, nil)
205 }
206
207 _, err = cel.AstToCheckedExpr(ast)
208 if err != nil {
209 // should be impossible since env.Compile returned no issues
210 return resultError("unexpected compilation error: "+err.Error(), apiservercel.ErrorTypeInternal, nil)
211 }
212 prog, err := env.Program(ast,
213 cel.InterruptCheckFrequency(celconfig.CheckFrequency),
214 )
215 if err != nil {
216 return resultError("program instantiation failed: "+err.Error(), apiservercel.ErrorTypeInternal, nil)
217 }
218 return CompilationResult{
219 Program: prog,
220 ExpressionAccessor: expressionAccessor,
221 OutputType: ast.OutputType(),
222 }
223 }
224
225 func mustBuildEnvs(baseEnv *environment.EnvSet) variableDeclEnvs {
226 requestType := BuildRequestType()
227 namespaceType := BuildNamespaceType()
228 envs := make(variableDeclEnvs, 8) // since the number of variable combinations is small, pre-build a environment for each
229 for _, hasParams := range []bool{false, true} {
230 for _, hasAuthorizer := range []bool{false, true} {
231 var err error
232 for _, strictCost := range []bool{false, true} {
233 decl := OptionalVariableDeclarations{HasParams: hasParams, HasAuthorizer: hasAuthorizer, StrictCost: strictCost}
234 envs[decl], err = createEnvForOpts(baseEnv, namespaceType, requestType, decl)
235 if err != nil {
236 panic(err)
237 }
238 }
239 // We only need this ObjectTypes where strict cost is true
240 decl := OptionalVariableDeclarations{HasParams: hasParams, HasAuthorizer: hasAuthorizer, StrictCost: true, HasPatchTypes: true}
241 envs[decl], err = createEnvForOpts(baseEnv, namespaceType, requestType, decl)
242 if err != nil {
243 panic(err)
244 }
245 }
246 }
247 return envs
248 }
249
250 func createEnvForOpts(baseEnv *environment.EnvSet, namespaceType *apiservercel.DeclType, requestType *apiservercel.DeclType, opts OptionalVariableDeclarations) (*environment.EnvSet, error) {
251 var envOpts []cel.EnvOption
252 envOpts = append(envOpts,
253 cel.Variable(ObjectVarName, cel.DynType),
254 cel.Variable(OldObjectVarName, cel.DynType),
255 cel.Variable(NamespaceVarName, namespaceType.CelType()),
256 cel.Variable(RequestVarName, requestType.CelType()))
257 if opts.HasParams {
258 envOpts = append(envOpts, cel.Variable(ParamsVarName, cel.DynType))
259 }
260 if opts.HasAuthorizer {
261 envOpts = append(envOpts,
262 cel.Variable(AuthorizerVarName, library.AuthorizerType),
263 cel.Variable(RequestResourceAuthorizerVarName, library.ResourceCheckType))
264 }
265
266 extended, err := baseEnv.Extend(
267 environment.VersionedOptions{
268 // Feature epoch was actually 1.26, but we artificially set it to 1.0 because these
269 // options should always be present.
270 IntroducedVersion: version.MajorMinor(1, 0),
271 EnvOptions: envOpts,
272 DeclTypes: []*apiservercel.DeclType{
273 namespaceType,
274 requestType,
275 },
276 },
277 )
278 if err != nil {
279 return nil, fmt.Errorf("environment misconfigured: %w", err)
280 }
281 if opts.StrictCost {
282 extended, err = extended.Extend(environment.StrictCostOpt)
283 if err != nil {
284 return nil, fmt.Errorf("environment misconfigured: %w", err)
285 }
286 }
287
288 if opts.HasPatchTypes {
289 extended, err = extended.Extend(hasPatchTypes)
290 if err != nil {
291 return nil, fmt.Errorf("environment misconfigured: %w", err)
292 }
293 }
294 return extended, nil
295 }
296
297 var hasPatchTypes = environment.VersionedOptions{
298 // Feature epoch was actually 1.32, but we artificially set it to 1.0 because these
299 // options should always be present.
300 IntroducedVersion: version.MajorMinor(1, 0),
301 EnvOptions: []cel.EnvOption{
302 common.ResolverEnvOption(&mutation.DynamicTypeResolver{}),
303 environment.UnversionedLib(library.JSONPatch), // for jsonPatch.escape() function
304 },
305 }