Debian Codegraph @

pkg/authorization/cel/compile.go

raw
1 /*
2 Copyright 2023 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 celast "github.com/google/cel-go/common/ast"
24 "github.com/google/cel-go/common/operators"
25 "github.com/google/cel-go/common/types/ref"
26
27 authorizationv1 "k8s.io/api/authorization/v1"
28 "k8s.io/apimachinery/pkg/util/version"
29 apiservercel "k8s.io/apiserver/pkg/cel"
30 "k8s.io/apiserver/pkg/cel/environment"
31 genericfeatures "k8s.io/apiserver/pkg/features"
32 utilfeature "k8s.io/apiserver/pkg/util/feature"
33 )
34
35 const (
36 subjectAccessReviewRequestVarName = "request"
37
38 fieldSelectorVarName = "fieldSelector"
39 labelSelectorVarName = "labelSelector"
40 )
41
42 // CompilationResult represents a compiled authorization cel expression.
43 type CompilationResult struct {
44 Program cel.Program
45 ExpressionAccessor ExpressionAccessor
46
47 // These track if a given expression uses fieldSelector and labelSelector,
48 // so construction of data passed to the CEL expression can be optimized if those fields are unused.
49 UsesFieldSelector bool
50 UsesLabelSelector bool
51 }
52
53 // EvaluationResult contains the minimal required fields and metadata of a cel evaluation
54 type EvaluationResult struct {
55 EvalResult ref.Val
56 ExpressionAccessor ExpressionAccessor
57 }
58
59 // Compiler is an interface for compiling CEL expressions with the desired environment mode.
60 type Compiler interface {
61 CompileCELExpression(expressionAccessor ExpressionAccessor) (CompilationResult, error)
62 }
63
64 type compiler struct {
65 envSet *environment.EnvSet
66 }
67
68 // NewDefaultCompiler returns a new Compiler following the default compatibility version.
69 // Note: the compiler construction depends on feature gates and the compatibility version to be initialized.
70 func NewDefaultCompiler() Compiler {
71 return NewCompiler(environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion(), true))
72 }
73
74 // NewCompiler returns a new Compiler.
75 func NewCompiler(env *environment.EnvSet) Compiler {
76 return &compiler{
77 envSet: mustBuildEnv(env),
78 }
79 }
80
81 func (c compiler) CompileCELExpression(expressionAccessor ExpressionAccessor) (CompilationResult, error) {
82 resultError := func(errorString string, errType apiservercel.ErrorType) (CompilationResult, error) {
83 err := &apiservercel.Error{
84 Type: errType,
85 Detail: errorString,
86 }
87 return CompilationResult{
88 ExpressionAccessor: expressionAccessor,
89 }, err
90 }
91 env, err := c.envSet.Env(environment.StoredExpressions)
92 if err != nil {
93 return resultError(fmt.Sprintf("unexpected error loading CEL environment: %v", err), apiservercel.ErrorTypeInternal)
94 }
95 ast, issues := env.Compile(expressionAccessor.GetExpression())
96 if issues != nil {
97 return resultError("compilation failed: "+issues.String(), apiservercel.ErrorTypeInvalid)
98 }
99 found := false
100 returnTypes := expressionAccessor.ReturnTypes()
101 for _, returnType := range returnTypes {
102 if ast.OutputType() == returnType {
103 found = true
104 break
105 }
106 }
107 if !found {
108 var reason string
109 if len(returnTypes) == 1 {
110 reason = fmt.Sprintf("must evaluate to %v but got %v", returnTypes[0].String(), ast.OutputType())
111 } else {
112 reason = fmt.Sprintf("must evaluate to one of %v", returnTypes)
113 }
114
115 return resultError(reason, apiservercel.ErrorTypeInvalid)
116 }
117 checkedExpr, err := cel.AstToCheckedExpr(ast)
118 if err != nil {
119 // should be impossible since env.Compile returned no issues
120 return resultError("unexpected compilation error: "+err.Error(), apiservercel.ErrorTypeInternal)
121 }
122 celAST, err := celast.ToAST(checkedExpr)
123 if err != nil {
124 // should be impossible since env.Compile returned no issues
125 return resultError("unexpected compilation error: "+err.Error(), apiservercel.ErrorTypeInternal)
126 }
127
128 var usesFieldSelector, usesLabelSelector bool
129 celast.PreOrderVisit(celast.NavigateAST(celAST), celast.NewExprVisitor(func(e celast.Expr) {
130 // we already know we use both, no need to inspect more
131 if usesFieldSelector && usesLabelSelector {
132 return
133 }
134
135 var fieldName string
136 switch e.Kind() {
137 case celast.SelectKind:
138 // simple select (.fieldSelector / .labelSelector)
139 fieldName = e.AsSelect().FieldName()
140 case celast.CallKind:
141 // optional select (.?fieldSelector / .?labelSelector)
142 if e.AsCall().FunctionName() != operators.OptSelect {
143 return
144 }
145 args := e.AsCall().Args()
146 // args[0] is the receiver (what comes before the `.?`), args[1] is the field name being optionally selected (what comes after the `.?`)
147 if len(args) != 2 || args[1].Kind() != celast.LiteralKind || args[1].AsLiteral().Type() != cel.StringType {
148 return
149 }
150 fieldName, _ = args[1].AsLiteral().Value().(string)
151 }
152
153 switch fieldName {
154 case fieldSelectorVarName:
155 usesFieldSelector = true
156 case labelSelectorVarName:
157 usesLabelSelector = true
158 }
159 }))
160
161 prog, err := env.Program(ast)
162 if err != nil {
163 return resultError("program instantiation failed: "+err.Error(), apiservercel.ErrorTypeInternal)
164 }
165 return CompilationResult{
166 Program: prog,
167 ExpressionAccessor: expressionAccessor,
168 UsesFieldSelector: usesFieldSelector,
169 UsesLabelSelector: usesLabelSelector,
170 }, nil
171 }
172
173 func mustBuildEnv(baseEnv *environment.EnvSet) *environment.EnvSet {
174 field := func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField {
175 return apiservercel.NewDeclField(name, declType, required, nil, nil)
176 }
177 fields := func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField {
178 result := make(map[string]*apiservercel.DeclField, len(fields))
179 for _, f := range fields {
180 result[f.Name] = f
181 }
182 return result
183 }
184 subjectAccessReviewSpecRequestType := buildRequestType(field, fields)
185 extended, err := baseEnv.Extend(
186 environment.VersionedOptions{
187 // we record this as 1.0 since it was available in the
188 // first version that supported this feature
189 IntroducedVersion: version.MajorMinor(1, 0),
190 EnvOptions: []cel.EnvOption{
191 cel.Variable(subjectAccessReviewRequestVarName, subjectAccessReviewSpecRequestType.CelType()),
192 },
193 DeclTypes: []*apiservercel.DeclType{
194 subjectAccessReviewSpecRequestType,
195 },
196 },
197 )
198 if err != nil {
199 panic(fmt.Sprintf("environment misconfigured: %v", err))
200 }
201
202 return extended
203 }
204
205 // buildRequestType generates a DeclType for SubjectAccessReviewSpec.
206 // if attributes are added here, also add to convertObjectToUnstructured.
207 func buildRequestType(field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) *apiservercel.DeclType {
208 resourceAttributesType := buildResourceAttributesType(field, fields)
209 nonResourceAttributesType := buildNonResourceAttributesType(field, fields)
210 return apiservercel.NewObjectType("kubernetes.SubjectAccessReviewSpec", fields(
211 field("resourceAttributes", resourceAttributesType, false),
212 field("nonResourceAttributes", nonResourceAttributesType, false),
213 field("user", apiservercel.StringType, false),
214 field("groups", apiservercel.NewListType(apiservercel.StringType, -1), false),
215 field("extra", apiservercel.NewMapType(apiservercel.StringType, apiservercel.NewListType(apiservercel.StringType, -1), -1), false),
216 field("uid", apiservercel.StringType, false),
217 ))
218 }
219
220 // buildResourceAttributesType generates a DeclType for ResourceAttributes.
221 // if attributes are added here, also add to convertObjectToUnstructured.
222 func buildResourceAttributesType(field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) *apiservercel.DeclType {
223 resourceAttributesFields := []*apiservercel.DeclField{
224 field("namespace", apiservercel.StringType, false),
225 field("verb", apiservercel.StringType, false),
226 field("group", apiservercel.StringType, false),
227 field("version", apiservercel.StringType, false),
228 field("resource", apiservercel.StringType, false),
229 field("subresource", apiservercel.StringType, false),
230 field("name", apiservercel.StringType, false),
231 }
232 if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.AuthorizeWithSelectors) {
233 resourceAttributesFields = append(resourceAttributesFields, field("fieldSelector", buildFieldSelectorType(field, fields), false))
234 resourceAttributesFields = append(resourceAttributesFields, field("labelSelector", buildLabelSelectorType(field, fields), false))
235 }
236 return apiservercel.NewObjectType("kubernetes.ResourceAttributes", fields(resourceAttributesFields...))
237 }
238
239 func buildFieldSelectorType(field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) *apiservercel.DeclType {
240 return apiservercel.NewObjectType("kubernetes.FieldSelectorAttributes", fields(
241 field("rawSelector", apiservercel.StringType, false),
242 field("requirements", apiservercel.NewListType(buildSelectorRequirementType(field, fields), -1), false),
243 ))
244 }
245
246 func buildLabelSelectorType(field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) *apiservercel.DeclType {
247 return apiservercel.NewObjectType("kubernetes.LabelSelectorAttributes", fields(
248 field("rawSelector", apiservercel.StringType, false),
249 field("requirements", apiservercel.NewListType(buildSelectorRequirementType(field, fields), -1), false),
250 ))
251 }
252
253 func buildSelectorRequirementType(field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) *apiservercel.DeclType {
254 return apiservercel.NewObjectType("kubernetes.SelectorRequirement", fields(
255 field("key", apiservercel.StringType, false),
256 field("operator", apiservercel.StringType, false),
257 field("values", apiservercel.NewListType(apiservercel.StringType, -1), false),
258 ))
259 }
260
261 // buildNonResourceAttributesType generates a DeclType for NonResourceAttributes.
262 // if attributes are added here, also add to convertObjectToUnstructured.
263 func buildNonResourceAttributesType(field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) *apiservercel.DeclType {
264 return apiservercel.NewObjectType("kubernetes.NonResourceAttributes", fields(
265 field("path", apiservercel.StringType, false),
266 field("verb", apiservercel.StringType, false),
267 ))
268 }
269
270 func convertObjectToUnstructured(obj *authorizationv1.SubjectAccessReviewSpec, includeFieldSelector, includeLabelSelector bool) map[string]interface{} {
271 // Construct version containing every SubjectAccessReview user and string attribute field, even omitempty ones, for evaluation by CEL
272 extra := obj.Extra
273 if extra == nil {
274 extra = map[string]authorizationv1.ExtraValue{}
275 }
276 ret := map[string]interface{}{
277 "user": obj.User,
278 "groups": obj.Groups,
279 "uid": string(obj.UID),
280 "extra": extra,
281 }
282 if obj.ResourceAttributes != nil {
283 resourceAttributes := map[string]interface{}{
284 "namespace": obj.ResourceAttributes.Namespace,
285 "verb": obj.ResourceAttributes.Verb,
286 "group": obj.ResourceAttributes.Group,
287 "version": obj.ResourceAttributes.Version,
288 "resource": obj.ResourceAttributes.Resource,
289 "subresource": obj.ResourceAttributes.Subresource,
290 "name": obj.ResourceAttributes.Name,
291 }
292
293 if includeFieldSelector && obj.ResourceAttributes.FieldSelector != nil {
294 if len(obj.ResourceAttributes.FieldSelector.Requirements) > 0 {
295 requirements := make([]map[string]interface{}, 0, len(obj.ResourceAttributes.FieldSelector.Requirements))
296 for _, r := range obj.ResourceAttributes.FieldSelector.Requirements {
297 requirements = append(requirements, map[string]interface{}{
298 "key": r.Key,
299 "operator": r.Operator,
300 "values": r.Values,
301 })
302 }
303 resourceAttributes[fieldSelectorVarName] = map[string]interface{}{"requirements": requirements}
304 }
305 if len(obj.ResourceAttributes.FieldSelector.RawSelector) > 0 {
306 resourceAttributes[fieldSelectorVarName] = map[string]interface{}{"rawSelector": obj.ResourceAttributes.FieldSelector.RawSelector}
307 }
308 }
309
310 if includeLabelSelector && obj.ResourceAttributes.LabelSelector != nil {
311 if len(obj.ResourceAttributes.LabelSelector.Requirements) > 0 {
312 requirements := make([]map[string]interface{}, 0, len(obj.ResourceAttributes.LabelSelector.Requirements))
313 for _, r := range obj.ResourceAttributes.LabelSelector.Requirements {
314 requirements = append(requirements, map[string]interface{}{
315 "key": r.Key,
316 "operator": r.Operator,
317 "values": r.Values,
318 })
319 }
320 resourceAttributes[labelSelectorVarName] = map[string]interface{}{"requirements": requirements}
321 }
322 if len(obj.ResourceAttributes.LabelSelector.RawSelector) > 0 {
323 resourceAttributes[labelSelectorVarName] = map[string]interface{}{"rawSelector": obj.ResourceAttributes.LabelSelector.RawSelector}
324 }
325 }
326
327 ret["resourceAttributes"] = resourceAttributes
328 }
329 if obj.NonResourceAttributes != nil {
330 ret["nonResourceAttributes"] = map[string]string{
331 "verb": obj.NonResourceAttributes.Verb,
332 "path": obj.NonResourceAttributes.Path,
333 }
334 }
335 return ret
336 }