Debian Codegraph @

pkg/authorization/cel/compile_test.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 "reflect"
22 "strings"
23 "testing"
24
25 v1 "k8s.io/api/authorization/v1"
26 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
27 apiservercel "k8s.io/apiserver/pkg/cel"
28 genericfeatures "k8s.io/apiserver/pkg/features"
29 utilfeature "k8s.io/apiserver/pkg/util/feature"
30 featuregatetesting "k8s.io/component-base/featuregate/testing"
31 )
32
33 func TestCompileCELExpression(t *testing.T) {
34 cases := []struct {
35 name string
36 expression string
37 expectedError string
38
39 authorizeWithSelectorsEnabled bool
40 }{
41 {
42 name: "SubjectAccessReviewSpec user comparison",
43 expression: "request.user == 'bob'",
44 },
45 {
46 name: "undefined fields",
47 expression: "request.time == 'now'",
48 expectedError: "undefined field",
49 },
50 {
51 name: "Syntax errors",
52 expression: "request++'",
53 expectedError: "Syntax error",
54 },
55 {
56 name: "bad return type",
57 expression: "request.user",
58 expectedError: "must evaluate to bool",
59 },
60 {
61 name: "undeclared reference",
62 expression: "x.user",
63 expectedError: "undeclared reference",
64 },
65 {
66 name: "fieldSelector not enabled",
67 expression: "request.resourceAttributes.fieldSelector.rawSelector == 'foo'",
68 authorizeWithSelectorsEnabled: false,
69 expectedError: `undefined field 'fieldSelector'`,
70 },
71 {
72 name: "fieldSelector rawSelector",
73 expression: "request.resourceAttributes.fieldSelector.rawSelector == 'foo'",
74 authorizeWithSelectorsEnabled: true,
75 },
76 {
77 name: "fieldSelector requirement",
78 expression: "request.resourceAttributes.fieldSelector.requirements.exists(r, r.key == 'foo' && r.operator == 'In' && ('bar' in r.values))",
79 authorizeWithSelectorsEnabled: true,
80 },
81 {
82 name: "labelSelector not enabled",
83 expression: "request.resourceAttributes.labelSelector.rawSelector == 'foo'",
84 authorizeWithSelectorsEnabled: false,
85 expectedError: `undefined field 'labelSelector'`,
86 },
87 {
88 name: "labelSelector rawSelector",
89 expression: "request.resourceAttributes.labelSelector.rawSelector == 'foo'",
90 authorizeWithSelectorsEnabled: true,
91 },
92 {
93 name: "labelSelector requirement",
94 expression: "request.resourceAttributes.labelSelector.requirements.exists(r, r.key == 'foo' && r.operator == 'In' && ('bar' in r.values))",
95 authorizeWithSelectorsEnabled: true,
96 },
97 }
98
99 for _, tc := range cases {
100 t.Run(tc.name, func(t *testing.T) {
101 featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, genericfeatures.AuthorizeWithSelectors, tc.authorizeWithSelectorsEnabled)
102
103 // create new compiler because it depends on the feature gate
104 compiler := NewDefaultCompiler()
105
106 _, err := compiler.CompileCELExpression(&SubjectAccessReviewMatchCondition{
107 Expression: tc.expression,
108 })
109 if len(tc.expectedError) > 0 && (err == nil || !strings.Contains(err.Error(), tc.expectedError)) {
110 t.Fatalf("expected error: %s compiling expression %s, got: %v", tc.expectedError, tc.expression, err)
111 }
112 if len(tc.expectedError) == 0 && err != nil {
113 t.Fatalf("unexpected error %v compiling expression %s", err, tc.expression)
114 }
115 })
116 }
117 }
118
119 func TestBuildRequestType(t *testing.T) {
120 featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, genericfeatures.AuthorizeWithSelectors, true)
121 f := func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField {
122 return apiservercel.NewDeclField(name, declType, required, nil, nil)
123 }
124 fs := func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField {
125 result := make(map[string]*apiservercel.DeclField, len(fields))
126 for _, f := range fields {
127 result[f.Name] = f
128 }
129 return result
130 }
131
132 requestDeclType := buildRequestType(f, fs)
133 requestType := reflect.TypeOf(v1.SubjectAccessReviewSpec{})
134 if len(requestDeclType.Fields) != requestType.NumField() {
135 t.Fatalf("expected %d fields for SubjectAccessReviewSpec, got %d", requestType.NumField(), len(requestDeclType.Fields))
136 }
137 resourceAttributesDeclType := buildResourceAttributesType(f, fs)
138 resourceAttributeType := reflect.TypeOf(v1.ResourceAttributes{})
139 if len(resourceAttributesDeclType.Fields) != resourceAttributeType.NumField() {
140 t.Fatalf("expected %d fields for ResourceAttributes, got %d", resourceAttributeType.NumField(), len(resourceAttributesDeclType.Fields))
141 }
142 nonResourceAttributesDeclType := buildNonResourceAttributesType(f, fs)
143 nonResourceAttributeType := reflect.TypeOf(v1.NonResourceAttributes{})
144 if len(nonResourceAttributesDeclType.Fields) != nonResourceAttributeType.NumField() {
145 t.Fatalf("expected %d fields for NonResourceAttributes, got %d", nonResourceAttributeType.NumField(), len(nonResourceAttributesDeclType.Fields))
146 }
147 if err := compareFieldsForType(t, requestType, requestDeclType, f, fs); err != nil {
148 t.Error(err)
149 }
150 }
151
152 func compareFieldsForType(t *testing.T, nativeType reflect.Type, declType *apiservercel.DeclType, field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) error {
153 for i := 0; i < nativeType.NumField(); i++ {
154 nativeField := nativeType.Field(i)
155 jsonTagParts := strings.Split(nativeField.Tag.Get("json"), ",")
156 if len(jsonTagParts) < 1 {
157 t.Fatal("expected json tag to be present")
158 }
159 fieldName := jsonTagParts[0]
160
161 declField, ok := declType.Fields[fieldName]
162 if !ok {
163 t.Fatalf("expected field %q to be present", nativeField.Name)
164 }
165 declFieldType := nativeTypeToCELType(t, nativeField.Type, field, fields)
166 if declFieldType == nil {
167 return fmt.Errorf("no field type found for %s %v", nativeField.Name, nativeField.Type)
168 }
169 if declFieldType.CelType().Equal(declField.Type.CelType()).Value() != true {
170 return fmt.Errorf("expected native field %q to have type %v, got %v", nativeField.Name, nativeField.Type, declField.Type)
171 }
172 }
173 return nil
174 }
175
176 func nativeTypeToCELType(t *testing.T, nativeType reflect.Type, field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) *apiservercel.DeclType {
177 switch nativeType {
178 case reflect.TypeOf(""), reflect.TypeOf(metav1.LabelSelectorOperator("")), reflect.TypeOf(metav1.FieldSelectorOperator("")):
179 return apiservercel.StringType
180 case reflect.TypeOf([]string{}):
181 return apiservercel.NewListType(apiservercel.StringType, -1)
182 case reflect.TypeOf(map[string]v1.ExtraValue{}):
183 return apiservercel.NewMapType(apiservercel.StringType, apiservercel.NewListType(apiservercel.StringType, -1), -1)
184 case reflect.TypeOf(&v1.ResourceAttributes{}):
185 resourceAttributesDeclType := buildResourceAttributesType(field, fields)
186 if err := compareFieldsForType(t, reflect.TypeOf(v1.ResourceAttributes{}), resourceAttributesDeclType, field, fields); err != nil {
187 t.Error(err)
188 return nil
189 }
190 return resourceAttributesDeclType
191 case reflect.TypeOf(&v1.NonResourceAttributes{}):
192 nonResourceAttributesDeclType := buildNonResourceAttributesType(field, fields)
193 if err := compareFieldsForType(t, reflect.TypeOf(v1.NonResourceAttributes{}), nonResourceAttributesDeclType, field, fields); err != nil {
194 t.Error(err)
195 return nil
196 }
197 return nonResourceAttributesDeclType
198 case reflect.TypeOf(&v1.FieldSelectorAttributes{}):
199 selectorAttributesDeclType := buildFieldSelectorType(field, fields)
200 if err := compareFieldsForType(t, reflect.TypeOf(v1.FieldSelectorAttributes{}), selectorAttributesDeclType, field, fields); err != nil {
201 t.Error(err)
202 return nil
203 }
204 return selectorAttributesDeclType
205 case reflect.TypeOf(&v1.LabelSelectorAttributes{}):
206 selectorAttributesDeclType := buildLabelSelectorType(field, fields)
207 if err := compareFieldsForType(t, reflect.TypeOf(v1.LabelSelectorAttributes{}), selectorAttributesDeclType, field, fields); err != nil {
208 t.Error(err)
209 return nil
210 }
211 return selectorAttributesDeclType
212 case reflect.TypeOf([]metav1.FieldSelectorRequirement{}):
213 requirementType := buildSelectorRequirementType(field, fields)
214 if err := compareFieldsForType(t, reflect.TypeOf(metav1.FieldSelectorRequirement{}), requirementType, field, fields); err != nil {
215 t.Error(err)
216 return nil
217 }
218 return apiservercel.NewListType(requirementType, -1)
219 case reflect.TypeOf([]metav1.LabelSelectorRequirement{}):
220 requirementType := buildSelectorRequirementType(field, fields)
221 if err := compareFieldsForType(t, reflect.TypeOf(metav1.LabelSelectorRequirement{}), requirementType, field, fields); err != nil {
222 t.Error(err)
223 return nil
224 }
225 return apiservercel.NewListType(requirementType, -1)
226 default:
227 t.Fatalf("unsupported type %v", nativeType)
228 }
229 return nil
230 }