Debian Codegraph @

pkg/endpoints/filters/audit_test.go

raw
1 /*
2 Copyright 2016 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 filters
18
19 import (
20 "context"
21 "net/http"
22 "net/http/httptest"
23 "reflect"
24 "sync"
25 "testing"
26 "time"
27
28 "github.com/google/uuid"
29
30 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
31 "k8s.io/apimachinery/pkg/types"
32 "k8s.io/apimachinery/pkg/util/wait"
33 auditinternal "k8s.io/apiserver/pkg/apis/audit"
34 "k8s.io/apiserver/pkg/audit"
35 "k8s.io/apiserver/pkg/audit/policy"
36 "k8s.io/apiserver/pkg/authentication/user"
37 "k8s.io/apiserver/pkg/endpoints/request"
38 "k8s.io/apiserver/pkg/endpoints/responsewriter"
39 )
40
41 type fakeAuditSink struct {
42 lock sync.Mutex
43 events []*auditinternal.Event
44 }
45
46 func (s *fakeAuditSink) ProcessEvents(evs ...*auditinternal.Event) bool {
47 s.lock.Lock()
48 defer s.lock.Unlock()
49 for _, e := range evs {
50 event := e.DeepCopy()
51 s.events = append(s.events, event)
52 }
53 return true
54 }
55
56 func (s *fakeAuditSink) Events() []*auditinternal.Event {
57 s.lock.Lock()
58 defer s.lock.Unlock()
59 return append([]*auditinternal.Event{}, s.events...)
60 }
61
62 func (s *fakeAuditSink) Pop(timeout time.Duration) (*auditinternal.Event, error) {
63 var result *auditinternal.Event
64 err := wait.Poll(50*time.Millisecond, wait.ForeverTestTimeout, wait.ConditionFunc(func() (done bool, err error) {
65 s.lock.Lock()
66 defer s.lock.Unlock()
67 if len(s.events) == 0 {
68 return false, nil
69 }
70 result = s.events[0]
71 s.events = s.events[1:]
72 return true, nil
73 }))
74 return result, err
75 }
76
77 func TestConstructResponseWriter(t *testing.T) {
78 inner := &responsewriter.FakeResponseWriter{}
79 actual := decorateResponseWriter(context.Background(), inner, nil, nil, nil)
80 switch v := actual.(type) {
81 case *auditResponseWriter:
82 default:
83 t.Errorf("Expected auditResponseWriter, got %v", reflect.TypeOf(v))
84 }
85 if innerGot := actual.(responsewriter.UserProvidedDecorator).Unwrap(); inner != innerGot {
86 t.Errorf("Expected the decorator to return the inner http.ResponseWriter object")
87 }
88
89 actual = decorateResponseWriter(context.Background(), &responsewriter.FakeResponseWriterFlusherCloseNotifier{}, nil, nil, nil)
90 //lint:file-ignore SA1019 Keep supporting deprecated http.CloseNotifier
91 if _, ok := actual.(http.CloseNotifier); !ok {
92 t.Errorf("Expected http.ResponseWriter to implement http.CloseNotifier")
93 }
94 if _, ok := actual.(http.Flusher); !ok {
95 t.Errorf("Expected the wrapper to implement http.Flusher")
96 }
97 if _, ok := actual.(http.Hijacker); ok {
98 t.Errorf("Expected http.ResponseWriter not to implement http.Hijacker")
99 }
100
101 actual = decorateResponseWriter(context.Background(), &responsewriter.FakeResponseWriterFlusherCloseNotifierHijacker{}, nil, nil, nil)
102 //lint:file-ignore SA1019 Keep supporting deprecated http.CloseNotifier
103 if _, ok := actual.(http.CloseNotifier); !ok {
104 t.Errorf("Expected http.ResponseWriter to implement http.CloseNotifier")
105 }
106 if _, ok := actual.(http.Flusher); !ok {
107 t.Errorf("Expected the wrapper to implement http.Flusher")
108 }
109 if _, ok := actual.(http.Hijacker); !ok {
110 t.Errorf("Expected http.ResponseWriter to implement http.Hijacker")
111 }
112 }
113
114 func TestDecorateResponseWriterWithoutChannel(t *testing.T) {
115 ev := &auditinternal.Event{}
116 actual := decorateResponseWriter(context.Background(), &responsewriter.FakeResponseWriter{}, ev, nil, nil)
117
118 // write status. This will not block because firstEventSentCh is nil
119 actual.WriteHeader(42)
120 if ev.ResponseStatus == nil {
121 t.Fatalf("Expected ResponseStatus to be non-nil")
122 }
123 if ev.ResponseStatus.Code != 42 {
124 t.Errorf("expected status code 42, got %d", ev.ResponseStatus.Code)
125 }
126 }
127
128 func TestDecorateResponseWriterWithImplicitWrite(t *testing.T) {
129 ev := &auditinternal.Event{}
130 actual := decorateResponseWriter(context.Background(), &responsewriter.FakeResponseWriter{}, ev, nil, nil)
131
132 // write status. This will not block because firstEventSentCh is nil
133 actual.Write([]byte("foo"))
134 if ev.ResponseStatus == nil {
135 t.Fatalf("Expected ResponseStatus to be non-nil")
136 }
137 if ev.ResponseStatus.Code != 200 {
138 t.Errorf("expected status code 200, got %d", ev.ResponseStatus.Code)
139 }
140 }
141
142 func TestDecorateResponseWriterChannel(t *testing.T) {
143 sink := &fakeAuditSink{}
144 ev := &auditinternal.Event{}
145 actual := decorateResponseWriter(context.Background(), &responsewriter.FakeResponseWriter{}, ev, sink, nil)
146
147 done := make(chan struct{})
148 go func() {
149 t.Log("Writing status code 42")
150 actual.WriteHeader(42)
151 t.Log("Finished writing status code 42")
152 close(done)
153
154 actual.Write([]byte("foo"))
155 }()
156
157 // sleep some time to give write the possibility to do wrong stuff
158 time.Sleep(100 * time.Millisecond)
159
160 t.Log("Waiting for event in the channel")
161 ev1, err := sink.Pop(time.Second)
162 if err != nil {
163 t.Fatal("Timeout waiting for events")
164 }
165 t.Logf("Seen event with status %v", ev1.ResponseStatus)
166
167 if !reflect.DeepEqual(ev, ev1) {
168 t.Fatalf("ev1 and ev must be equal")
169 }
170
171 <-done
172 t.Log("Seen the go routine finished")
173
174 // write again
175 _, err = actual.Write([]byte("foo"))
176 if err != nil {
177 t.Errorf("unexpected error: %v", err)
178 }
179 }
180
181 type fakeHTTPHandler struct{}
182
183 func (*fakeHTTPHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
184 w.WriteHeader(200)
185 }
186
187 func TestAudit(t *testing.T) {
188 shortRunningPath := "/api/v1/namespaces/default/pods/foo"
189 longRunningPath := "/api/v1/namespaces/default/pods?watch=true"
190
191 delay := 500 * time.Millisecond
192
193 for _, test := range []struct {
194 desc string
195 path string
196 verb string
197 auditID string
198 omitStages []auditinternal.Stage
199 handler func(http.ResponseWriter, *http.Request)
200 expected []auditinternal.Event
201 respHeader bool
202 }{
203 // short running requests with read-only verb
204 {
205 "read-only empty",
206 shortRunningPath,
207 "GET",
208 "",
209 nil,
210 func(http.ResponseWriter, *http.Request) {},
211 []auditinternal.Event{
212 {
213 Stage: auditinternal.StageRequestReceived,
214 Verb: "get",
215 RequestURI: shortRunningPath,
216 },
217 {
218 Stage: auditinternal.StageResponseComplete,
219 Verb: "get",
220 RequestURI: shortRunningPath,
221 ResponseStatus: &metav1.Status{Code: 200},
222 },
223 },
224 false,
225 },
226 {
227 "short running with auditID",
228 shortRunningPath,
229 "GET",
230 uuid.New().String(),
231 nil,
232 func(w http.ResponseWriter, req *http.Request) {
233 w.Write([]byte("foo"))
234 },
235 []auditinternal.Event{
236 {
237 Stage: auditinternal.StageRequestReceived,
238 Verb: "get",
239 RequestURI: shortRunningPath,
240 },
241 {
242 Stage: auditinternal.StageResponseComplete,
243 Verb: "get",
244 RequestURI: shortRunningPath,
245 ResponseStatus: &metav1.Status{Code: 200},
246 },
247 },
248 true,
249 },
250 {
251 "read-only panic",
252 shortRunningPath,
253 "GET",
254 "",
255 nil,
256 func(w http.ResponseWriter, req *http.Request) {
257 panic("kaboom")
258 },
259 []auditinternal.Event{
260 {
261 Stage: auditinternal.StageRequestReceived,
262 Verb: "get",
263 RequestURI: shortRunningPath,
264 },
265 {
266 Stage: auditinternal.StagePanic,
267 Verb: "get",
268 RequestURI: shortRunningPath,
269 ResponseStatus: &metav1.Status{Code: 500},
270 },
271 },
272 false,
273 },
274 // short running request with non-read-only verb
275 {
276 "writing empty",
277 shortRunningPath,
278 "PUT",
279 "",
280 nil,
281 func(http.ResponseWriter, *http.Request) {},
282 []auditinternal.Event{
283 {
284 Stage: auditinternal.StageRequestReceived,
285 Verb: "update",
286 RequestURI: shortRunningPath,
287 },
288 {
289 Stage: auditinternal.StageResponseComplete,
290 Verb: "update",
291 RequestURI: shortRunningPath,
292 ResponseStatus: &metav1.Status{Code: 200},
293 },
294 },
295 false,
296 },
297 {
298 "writing sleep",
299 shortRunningPath,
300 "PUT",
301 "",
302 nil,
303 func(w http.ResponseWriter, req *http.Request) {
304 w.Write([]byte("foo"))
305 time.Sleep(delay)
306 },
307 []auditinternal.Event{
308 {
309 Stage: auditinternal.StageRequestReceived,
310 Verb: "update",
311 RequestURI: shortRunningPath,
312 },
313 {
314 Stage: auditinternal.StageResponseComplete,
315 Verb: "update",
316 RequestURI: shortRunningPath,
317 ResponseStatus: &metav1.Status{Code: 200},
318 },
319 },
320 true,
321 },
322 {
323 "writing 403+write",
324 shortRunningPath,
325 "PUT",
326 "",
327 nil,
328 func(w http.ResponseWriter, req *http.Request) {
329 w.WriteHeader(403)
330 w.Write([]byte("foo"))
331 },
332 []auditinternal.Event{
333 {
334 Stage: auditinternal.StageRequestReceived,
335 Verb: "update",
336 RequestURI: shortRunningPath,
337 },
338 {
339 Stage: auditinternal.StageResponseComplete,
340 Verb: "update",
341 RequestURI: shortRunningPath,
342 ResponseStatus: &metav1.Status{Code: 403},
343 },
344 },
345 true,
346 },
347 {
348 "writing panic",
349 shortRunningPath,
350 "PUT",
351 "",
352 nil,
353 func(w http.ResponseWriter, req *http.Request) {
354 panic("kaboom")
355 },
356 []auditinternal.Event{
357 {
358 Stage: auditinternal.StageRequestReceived,
359 Verb: "update",
360 RequestURI: shortRunningPath,
361 },
362 {
363 Stage: auditinternal.StagePanic,
364 Verb: "update",
365 RequestURI: shortRunningPath,
366 ResponseStatus: &metav1.Status{Code: 500},
367 },
368 },
369 false,
370 },
371 {
372 "writing write+panic",
373 shortRunningPath,
374 "PUT",
375 "",
376 nil,
377 func(w http.ResponseWriter, req *http.Request) {
378 w.Write([]byte("foo"))
379 panic("kaboom")
380 },
381 []auditinternal.Event{
382 {
383 Stage: auditinternal.StageRequestReceived,
384 Verb: "update",
385 RequestURI: shortRunningPath,
386 },
387 {
388 Stage: auditinternal.StagePanic,
389 Verb: "update",
390 RequestURI: shortRunningPath,
391 ResponseStatus: &metav1.Status{Code: 500},
392 },
393 },
394 true,
395 },
396 // long running requests
397 {
398 "empty longrunning",
399 longRunningPath,
400 "GET",
401 "",
402 nil,
403 func(http.ResponseWriter, *http.Request) {},
404 []auditinternal.Event{
405 {
406 Stage: auditinternal.StageRequestReceived,
407 Verb: "watch",
408 RequestURI: longRunningPath,
409 },
410 {
411 Stage: auditinternal.StageResponseStarted,
412 Verb: "watch",
413 RequestURI: longRunningPath,
414 ResponseStatus: &metav1.Status{Code: 200},
415 },
416 {
417 Stage: auditinternal.StageResponseComplete,
418 Verb: "watch",
419 RequestURI: longRunningPath,
420 ResponseStatus: &metav1.Status{Code: 200},
421 },
422 },
423 false,
424 },
425 {
426 "empty longrunning with audit id",
427 longRunningPath,
428 "GET",
429 uuid.New().String(),
430 nil,
431 func(w http.ResponseWriter, req *http.Request) {
432 w.Write([]byte("foo"))
433 },
434 []auditinternal.Event{
435 {
436 Stage: auditinternal.StageRequestReceived,
437 Verb: "watch",
438 RequestURI: longRunningPath,
439 },
440 {
441 Stage: auditinternal.StageResponseStarted,
442 Verb: "watch",
443 RequestURI: longRunningPath,
444 ResponseStatus: &metav1.Status{Code: 200},
445 },
446 {
447 Stage: auditinternal.StageResponseComplete,
448 Verb: "watch",
449 RequestURI: longRunningPath,
450 ResponseStatus: &metav1.Status{Code: 200},
451 },
452 },
453 true,
454 },
455 {
456 "sleep longrunning",
457 longRunningPath,
458 "GET",
459 "",
460 nil,
461 func(http.ResponseWriter, *http.Request) {
462 time.Sleep(delay)
463 },
464 []auditinternal.Event{
465 {
466 Stage: auditinternal.StageRequestReceived,
467 Verb: "watch",
468 RequestURI: longRunningPath,
469 },
470 {
471 Stage: auditinternal.StageResponseStarted,
472 Verb: "watch",
473 RequestURI: longRunningPath,
474 ResponseStatus: &metav1.Status{Code: 200},
475 },
476 {
477 Stage: auditinternal.StageResponseComplete,
478 Verb: "watch",
479 RequestURI: longRunningPath,
480 ResponseStatus: &metav1.Status{Code: 200},
481 },
482 },
483 false,
484 },
485 {
486 "sleep+403 longrunning",
487 longRunningPath,
488 "GET",
489 "",
490 nil,
491 func(w http.ResponseWriter, req *http.Request) {
492 time.Sleep(delay)
493 w.WriteHeader(403)
494 },
495 []auditinternal.Event{
496 {
497 Stage: auditinternal.StageRequestReceived,
498 Verb: "watch",
499 RequestURI: longRunningPath,
500 },
501 {
502 Stage: auditinternal.StageResponseStarted,
503 Verb: "watch",
504 RequestURI: longRunningPath,
505 ResponseStatus: &metav1.Status{Code: 403},
506 },
507 {
508 Stage: auditinternal.StageResponseComplete,
509 Verb: "watch",
510 RequestURI: longRunningPath,
511 ResponseStatus: &metav1.Status{Code: 403},
512 },
513 },
514 true,
515 },
516 {
517 "write longrunning",
518 longRunningPath,
519 "GET",
520 "",
521 nil,
522 func(w http.ResponseWriter, req *http.Request) {
523 w.Write([]byte("foo"))
524 },
525 []auditinternal.Event{
526 {
527 Stage: auditinternal.StageRequestReceived,
528 Verb: "watch",
529 RequestURI: longRunningPath,
530 },
531 {
532 Stage: auditinternal.StageResponseStarted,
533 Verb: "watch",
534 RequestURI: longRunningPath,
535 ResponseStatus: &metav1.Status{Code: 200},
536 },
537 {
538 Stage: auditinternal.StageResponseComplete,
539 Verb: "watch",
540 RequestURI: longRunningPath,
541 ResponseStatus: &metav1.Status{Code: 200},
542 },
543 },
544 true,
545 },
546 {
547 "403+write longrunning",
548 longRunningPath,
549 "GET",
550 "",
551 nil,
552 func(w http.ResponseWriter, req *http.Request) {
553 w.WriteHeader(403)
554 w.Write([]byte("foo"))
555 },
556 []auditinternal.Event{
557 {
558 Stage: auditinternal.StageRequestReceived,
559 Verb: "watch",
560 RequestURI: longRunningPath,
561 },
562 {
563 Stage: auditinternal.StageResponseStarted,
564 Verb: "watch",
565 RequestURI: longRunningPath,
566 ResponseStatus: &metav1.Status{Code: 403},
567 },
568 {
569 Stage: auditinternal.StageResponseComplete,
570 Verb: "watch",
571 RequestURI: longRunningPath,
572 ResponseStatus: &metav1.Status{Code: 403},
573 },
574 },
575 true,
576 },
577 {
578 "panic longrunning",
579 longRunningPath,
580 "GET",
581 "",
582 nil,
583 func(w http.ResponseWriter, req *http.Request) {
584 panic("kaboom")
585 },
586 []auditinternal.Event{
587 {
588 Stage: auditinternal.StageRequestReceived,
589 Verb: "watch",
590 RequestURI: longRunningPath,
591 },
592 {
593 Stage: auditinternal.StagePanic,
594 Verb: "watch",
595 RequestURI: longRunningPath,
596 ResponseStatus: &metav1.Status{Code: 500},
597 },
598 },
599 false,
600 },
601 {
602 "write+panic longrunning",
603 longRunningPath,
604 "GET",
605 "",
606 nil,
607 func(w http.ResponseWriter, req *http.Request) {
608 w.Write([]byte("foo"))
609 panic("kaboom")
610 },
611 []auditinternal.Event{
612 {
613 Stage: auditinternal.StageRequestReceived,
614 Verb: "watch",
615 RequestURI: longRunningPath,
616 },
617 {
618 Stage: auditinternal.StageResponseStarted,
619 Verb: "watch",
620 RequestURI: longRunningPath,
621 ResponseStatus: &metav1.Status{Code: 200},
622 },
623 {
624 Stage: auditinternal.StagePanic,
625 Verb: "watch",
626 RequestURI: longRunningPath,
627 ResponseStatus: &metav1.Status{Code: 500},
628 },
629 },
630 true,
631 },
632 {
633 "omit RequestReceived",
634 shortRunningPath,
635 "GET",
636 "",
637 []auditinternal.Stage{auditinternal.StageRequestReceived},
638 func(w http.ResponseWriter, req *http.Request) {
639 w.Write([]byte("foo"))
640 },
641 []auditinternal.Event{
642 {
643 Stage: auditinternal.StageResponseComplete,
644 Verb: "get",
645 RequestURI: shortRunningPath,
646 ResponseStatus: &metav1.Status{Code: 200},
647 },
648 },
649 true,
650 },
651 {
652 "emit Panic only",
653 longRunningPath,
654 "GET",
655 "",
656 []auditinternal.Stage{auditinternal.StageRequestReceived, auditinternal.StageResponseStarted, auditinternal.StageResponseComplete},
657 func(w http.ResponseWriter, req *http.Request) {
658 w.Write([]byte("foo"))
659 panic("kaboom")
660 },
661 []auditinternal.Event{
662 {
663 Stage: auditinternal.StagePanic,
664 Verb: "watch",
665 RequestURI: longRunningPath,
666 ResponseStatus: &metav1.Status{Code: 500},
667 },
668 },
669 true,
670 },
671 } {
672 t.Run(test.desc, func(t *testing.T) {
673 sink := &fakeAuditSink{}
674 fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelRequestResponse, test.omitStages)
675 handler := WithAudit(http.HandlerFunc(test.handler), sink, fakeRuleEvaluator, func(r *http.Request, ri *request.RequestInfo) bool {
676 // simplified long-running check
677 return ri.Verb == "watch"
678 })
679 handler = WithAuditInit(handler)
680
681 req, _ := http.NewRequest(test.verb, test.path, nil)
682 req = withTestContext(req, &user.DefaultInfo{Name: "admin"}, nil)
683 if test.auditID != "" {
684 req.Header.Add("Audit-ID", test.auditID)
685 }
686 req.RemoteAddr = "127.0.0.1"
687
688 func() {
689 defer func() {
690 recover()
691 }()
692 handler.ServeHTTP(httptest.NewRecorder(), req)
693 }()
694
695 events := sink.Events()
696 t.Logf("audit log: %v", events)
697
698 if len(events) != len(test.expected) {
699 t.Fatalf("Unexpected amount of lines in audit log: %d", len(events))
700 }
701 expectedID := types.UID("")
702 for i, expect := range test.expected {
703 event := events[i]
704 if event.User.Username != "admin" {
705 t.Errorf("Unexpected username: %s", event.User.Username)
706 }
707 if event.Stage != expect.Stage {
708 t.Errorf("Unexpected Stage: %s", event.Stage)
709 }
710 if event.Verb != expect.Verb {
711 t.Errorf("Unexpected Verb: %s", event.Verb)
712 }
713 if event.RequestURI != expect.RequestURI {
714 t.Errorf("Unexpected RequestURI: %s", event.RequestURI)
715 }
716
717 if test.auditID != "" && event.AuditID != types.UID(test.auditID) {
718 t.Errorf("Unexpected AuditID in audit event, AuditID should be the same with Audit-ID http header")
719 }
720 if expectedID == types.UID("") {
721 expectedID = event.AuditID
722 } else if expectedID != event.AuditID {
723 t.Errorf("Audits for one request should share the same AuditID, %s differs from %s", expectedID, event.AuditID)
724 }
725 if event.ObjectRef.APIVersion != "v1" {
726 t.Errorf("Unexpected apiVersion: %s", event.ObjectRef.APIVersion)
727 }
728 if event.ObjectRef.APIGroup != "" {
729 t.Errorf("Unexpected apiGroup: %s", event.ObjectRef.APIGroup)
730 }
731 if (event.ResponseStatus == nil) != (expect.ResponseStatus == nil) {
732 t.Errorf("Unexpected ResponseStatus: %v", event.ResponseStatus)
733 continue
734 }
735 if (event.ResponseStatus != nil) && (event.ResponseStatus.Code != expect.ResponseStatus.Code) {
736 t.Errorf("Unexpected status code : %d", event.ResponseStatus.Code)
737 }
738 }
739 })
740 }
741 }
742
743 func TestAuditNoPanicOnNilUser(t *testing.T) {
744 fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelRequestResponse, nil)
745 handler := WithAudit(&fakeHTTPHandler{}, &fakeAuditSink{}, fakeRuleEvaluator, nil)
746 req, _ := http.NewRequest("GET", "/api/v1/namespaces/default/pods", nil)
747 req = withTestContext(req, nil, nil)
748 req.RemoteAddr = "127.0.0.1"
749 handler.ServeHTTP(httptest.NewRecorder(), req)
750 }
751
752 func TestAuditLevelNone(t *testing.T) {
753 sink := &fakeAuditSink{}
754 var handler http.Handler
755 handler = http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
756 w.WriteHeader(200)
757 })
758 fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelNone, nil)
759 handler = WithAudit(handler, sink, fakeRuleEvaluator, nil)
760
761 req, _ := http.NewRequest("GET", "/api/v1/namespaces/default/pods", nil)
762 req.RemoteAddr = "127.0.0.1"
763 req = withTestContext(req, &user.DefaultInfo{Name: "admin"}, nil)
764
765 handler.ServeHTTP(httptest.NewRecorder(), req)
766 if len(sink.events) > 0 {
767 t.Errorf("Generated events, but should not have: %#v", sink.events)
768 }
769 }
770
771 func TestAuditIDHttpHeader(t *testing.T) {
772 for _, test := range []struct {
773 desc string
774 requestHeader string
775 level auditinternal.Level
776 expectedHeader bool
777 }{
778 {
779 // we always want an audit ID since it can appear in logging/tracing and it is propagated
780 // to the aggregated apiserver(s) to improve correlation.
781 "http header when there is no audit",
782 "",
783 auditinternal.LevelNone,
784 true,
785 },
786 {
787 // we always want an audit ID since it can appear in logging/tracing and it is propagated
788 // to the aggregated apiserver(s) to improve correlation.
789 "http header when there is no audit even the request header specified",
790 uuid.New().String(),
791 auditinternal.LevelNone,
792 true,
793 },
794 {
795 "server generated header",
796 "",
797 auditinternal.LevelRequestResponse,
798 true,
799 },
800 {
801 "user provided header",
802 uuid.New().String(),
803 auditinternal.LevelRequestResponse,
804 true,
805 },
806 } {
807 t.Run(test.desc, func(t *testing.T) {
808 sink := &fakeAuditSink{}
809 var handler http.Handler
810 handler = http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
811 w.WriteHeader(200)
812 })
813 fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(test.level, nil)
814 handler = WithAudit(handler, sink, fakeRuleEvaluator, nil)
815 handler = WithAuditInit(handler)
816
817 req, _ := http.NewRequest("GET", "/api/v1/namespaces/default/pods", nil)
818 req.RemoteAddr = "127.0.0.1"
819 req = withTestContext(req, &user.DefaultInfo{Name: "admin"}, nil)
820 if test.requestHeader != "" {
821 req.Header.Add("Audit-ID", test.requestHeader)
822 }
823
824 w := httptest.NewRecorder()
825 handler.ServeHTTP(w, req)
826 resp := w.Result()
827 if test.expectedHeader {
828 if resp.Header.Get("Audit-ID") == "" {
829 t.Errorf("[%s] expected Audit-ID http header returned, but not returned", test.desc)
830 return
831 }
832 // if get Audit-ID returned, it should be the same with the requested one
833 if test.requestHeader != "" && resp.Header.Get("Audit-ID") != test.requestHeader {
834 t.Errorf("[%s] returned audit http header is not the same with the requested http header, expected: %s, get %s", test.desc, test.requestHeader, resp.Header.Get("Audit-ID"))
835 }
836 } else {
837 if resp.Header.Get("Audit-ID") != "" {
838 t.Errorf("[%s] expected no Audit-ID http header returned, but got %s", test.desc, resp.Header.Get("Audit-ID"))
839 }
840 }
841 })
842 }
843 }
844
845 func withTestContext(req *http.Request, user user.Info, ae *auditinternal.Event) *http.Request {
846 ctx := audit.WithAuditContext(req.Context())
847 if user != nil {
848 ctx = request.WithUser(ctx, user)
849 }
850 if ae != nil {
851 ac := audit.AuditContextFrom(ctx)
852 ac.Event = *ae
853 }
854 if info, err := newTestRequestInfoResolver().NewRequestInfo(req); err == nil {
855 ctx = request.WithRequestInfo(ctx, info)
856 }
857 return req.WithContext(ctx)
858 }