diff --git a/chaoscenter/subscriber/pkg/k8s/client.go b/chaoscenter/subscriber/pkg/k8s/client.go index dd66d7f8c..bd84e987c 100644 --- a/chaoscenter/subscriber/pkg/k8s/client.go +++ b/chaoscenter/subscriber/pkg/k8s/client.go @@ -1,6 +1,8 @@ package k8s import ( + "fmt" + wfclientset "github.com/argoproj/argo-workflows/v3/pkg/client/clientset/versioned" v1alpha12 "github.com/argoproj/argo-workflows/v3/pkg/client/clientset/versioned/typed/workflow/v1alpha1" "k8s.io/client-go/discovery" @@ -15,10 +17,15 @@ var KubeConfig *string // getKubeConfig setup the config for access cluster resource func (k8s *k8sSubscriber) GetKubeConfig() (*rest.Config, error) { // Use in-cluster config if kubeconfig path is not specified - if *KubeConfig == "" { + if *KubeConfig == "" || KubeConfig == nil { return rest.InClusterConfig() } - return clientcmd.BuildConfigFromFlags("", *KubeConfig) + + config, err := clientcmd.BuildConfigFromFlags("", *KubeConfig) + if err != nil { + return nil, fmt.Errorf("failed to build config from kubeconfig: %v", err) + } + return config, nil } func (k8s *k8sSubscriber) GetGenericK8sClient() (*kubernetes.Clientset, error) { diff --git a/chaoscenter/subscriber/pkg/k8s/fuzz/client_fuzz_test.go b/chaoscenter/subscriber/pkg/k8s/fuzz/client_fuzz_test.go new file mode 100644 index 000000000..2d16ce98f --- /dev/null +++ b/chaoscenter/subscriber/pkg/k8s/fuzz/client_fuzz_test.go @@ -0,0 +1,38 @@ +package fuzz + +import ( + "subscriber/pkg/graphql" + "subscriber/pkg/k8s" + "testing" + + fuzz "github.com/AdaLogics/go-fuzz-headers" +) + +func FuzzGenerateArgoClient(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + namespace string + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + return + } + + if targetStruct.namespace == "" { + targetStruct.namespace = "default-namespace" + } + subscriberGraphql := graphql.NewSubscriberGql() + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + + wfClient, err := subscriberK8s.GenerateArgoClient(targetStruct.namespace) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + + if wfClient == nil { + t.Errorf("Returned payload is nil") + } + }) +} diff --git a/chaoscenter/subscriber/pkg/k8s/fuzz/log_fuzz_test.go b/chaoscenter/subscriber/pkg/k8s/fuzz/log_fuzz_test.go new file mode 100644 index 000000000..43e27d910 --- /dev/null +++ b/chaoscenter/subscriber/pkg/k8s/fuzz/log_fuzz_test.go @@ -0,0 +1,108 @@ +package fuzz + +import ( + "subscriber/pkg/graphql" + "subscriber/pkg/k8s" + "subscriber/pkg/types" + "testing" + + fuzz "github.com/AdaLogics/go-fuzz-headers" +) + +func FuzzGetLogs(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + PodName string + Namespace string + Container string + }{} + + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + + response, err := subscriberK8s.GetLogs(targetStruct.PodName, targetStruct.Namespace, targetStruct.Container) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + if response == "" { + t.Errorf("Returned payload is nil") + } + }) +} + +func FuzzCreatePodLogs(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + podLog types.PodLogRequest + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + return + } + subscriberGraphql := graphql.NewSubscriberGql() + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + _, err = subscriberK8s.CreatePodLog(targetStruct.podLog) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + }) +} + +func FuzzSendPodLogs(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + infraData map[string]string + podLog types.PodLogRequest + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + return + } + subscriberGraphql := graphql.NewSubscriberGql() + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + subscriberK8s.SendPodLogs(targetStruct.infraData, targetStruct.podLog) + }) +} + +func FuzzGenerateLogPayload(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + cid string + accessKey string + version string + podLog types.PodLogRequest + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + return + } + subscriberGraphql := graphql.NewSubscriberGql() + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + response, err := subscriberK8s.GenerateLogPayload(targetStruct.cid, targetStruct.accessKey, targetStruct.version, targetStruct.podLog) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + if response == nil { + t.Errorf("Returned payload is nil") + } + + }) +} diff --git a/chaoscenter/subscriber/pkg/k8s/fuzz/objects_fuzz_test.go b/chaoscenter/subscriber/pkg/k8s/fuzz/objects_fuzz_test.go new file mode 100644 index 000000000..631bb2bef --- /dev/null +++ b/chaoscenter/subscriber/pkg/k8s/fuzz/objects_fuzz_test.go @@ -0,0 +1,269 @@ +package fuzz + +import ( + "subscriber/pkg/graphql" + "subscriber/pkg/k8s" + "subscriber/pkg/types" + "testing" + + fuzz "github.com/AdaLogics/go-fuzz-headers" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/client-go/dynamic" +) + +func FuzzGetKubernetesNamespaces(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &types.KubeNamespaceRequest{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + + response, err := subscriberK8s.GetKubernetesNamespaces(*targetStruct) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + if response == nil { + t.Errorf("Returned response is nil") + } else if len(response) == 0 { + t.Errorf("Returned response is an empty slice") + } else { + for _, ns := range response { + if ns.Name == "" { + t.Errorf("Namespace name is empty in response") + } + } + } + }) +} + +func FuzzGetKubernetesObjects(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &types.KubeObjRequest{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + + response, err := subscriberK8s.GetKubernetesObjects(*targetStruct) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + if response == nil { + t.Errorf("Returned response is nil") + return + } + + if response.Namespace == "" { + t.Errorf("Namespace in response is empty") + } + + if response.Data == nil { + t.Errorf("Data in response is nil") + } else { + if len(response.Data) == 0 { + t.Errorf("Data in response is an empty slice") + } + } + }) +} +func FuzzGetObjectDataByNamespace(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + namespace string + dynamicClient dynamic.Interface + resourceType schema.GroupVersionResource + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + + if targetStruct.dynamicClient == nil { + t.Logf("dynamicClient is nil") + return + } + if targetStruct.resourceType == (schema.GroupVersionResource{}) { + t.Logf("resourceType is uninitialized") + return + } + if targetStruct.namespace == "" { + t.Logf("namespace is empty") + return + } + + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + + response, err := subscriberK8s.GetObjectDataByNamespace(targetStruct.namespace, targetStruct.dynamicClient, targetStruct.resourceType) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + if response == nil { + t.Errorf("Returned response is nil") + return + } + }) +} + +func FuzzGenerateKubeNamespace(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + cid string + accessKey string + version string + kubenamespacerequest types.KubeNamespaceRequest + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + response, err := subscriberK8s.GenerateKubeNamespace(targetStruct.cid, targetStruct.accessKey, targetStruct.version, targetStruct.kubenamespacerequest) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + if response == nil { + t.Errorf("Returned response is nil") + return + } + }) +} + +func FuzzGenerateKubeObject(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + cid string + accessKey string + version string + kubenamespacerequest types.KubeObjRequest + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + response, err := subscriberK8s.GenerateKubeObject(targetStruct.cid, targetStruct.accessKey, targetStruct.version, targetStruct.kubenamespacerequest) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + if response == nil { + t.Errorf("Returned response is nil") + return + } + }) +} + +func FuzzSendKubeNamespaces(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + infraData map[string]string + kubenamespacerequest types.KubeNamespaceRequest + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + err = subscriberK8s.SendKubeNamespaces(targetStruct.infraData, targetStruct.kubenamespacerequest) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + }) +} + +func FuzzSendKubeObjects(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + infraData map[string]string + kubeobjectrequest types.KubeObjRequest + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + err = subscriberK8s.SendKubeObjects(targetStruct.infraData, targetStruct.kubeobjectrequest) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + }) +} diff --git a/chaoscenter/subscriber/pkg/k8s/fuzz/operations_fuzz_test.go b/chaoscenter/subscriber/pkg/k8s/fuzz/operations_fuzz_test.go new file mode 100644 index 000000000..340ef45ea --- /dev/null +++ b/chaoscenter/subscriber/pkg/k8s/fuzz/operations_fuzz_test.go @@ -0,0 +1,130 @@ +package fuzz + +import ( + "subscriber/pkg/graphql" + "subscriber/pkg/k8s" + pkgTypes "subscriber/pkg/types" + "testing" + + fuzz "github.com/AdaLogics/go-fuzz-headers" +) + +func FuzzCheckComponentStatus(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + componentEnv string + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + err = subscriberK8s.CheckComponentStatus(targetStruct.componentEnv) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + }) +} + +func FuzzAgentRegister(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + accessKey string + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + _, err = subscriberK8s.AgentRegister(targetStruct.accessKey) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + }) +} + +func FuzzAgentOperations(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + infraAction pkgTypes.Action + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + response, err := subscriberK8s.AgentOperations(targetStruct.infraAction) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + if response == nil { + t.Errorf("Returned response is nil") + return + } + }) +} + +func FuzzAgentConfirm(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + fuzzConsumer := fuzz.NewConsumer(data) + targetStruct := &struct { + infraData map[string]string + }{} + err := fuzzConsumer.GenerateStruct(targetStruct) + if err != nil { + t.Skip("Failed to generate struct:", err) + return + } + subscriberGraphql := graphql.NewSubscriberGql() + if subscriberGraphql == nil { + t.Fatalf("Failed to create a GraphQL subscriber") + } + + subscriberK8s := k8s.NewK8sSubscriber(subscriberGraphql) + if subscriberK8s == nil { + t.Fatalf("Failed to create a Kubernetes subscriber") + } + response, err := subscriberK8s.AgentConfirm(targetStruct.infraData) + if err != nil { + t.Logf("Unexpected error: %v", err) + return + } + if response == nil { + t.Errorf("Returned response is nil") + return + } + }) +} diff --git a/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzAgentConfirm/582528ddfad69eb5 b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzAgentConfirm/582528ddfad69eb5 new file mode 100644 index 000000000..a96f5599e --- /dev/null +++ b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzAgentConfirm/582528ddfad69eb5 @@ -0,0 +1,2 @@ +go test fuzz v1 +[]byte("0") diff --git a/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGenerateArgoClient/582528ddfad69eb5 b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGenerateArgoClient/582528ddfad69eb5 new file mode 100644 index 000000000..a96f5599e --- /dev/null +++ b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGenerateArgoClient/582528ddfad69eb5 @@ -0,0 +1,2 @@ +go test fuzz v1 +[]byte("0") diff --git a/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetLogs/0c6be63e12aa5eb7 b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetLogs/0c6be63e12aa5eb7 new file mode 100644 index 000000000..3e8c5b305 --- /dev/null +++ b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetLogs/0c6be63e12aa5eb7 @@ -0,0 +1,2 @@ +go test fuzz v1 +[]byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x000") diff --git a/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetLogs/582528ddfad69eb5 b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetLogs/582528ddfad69eb5 new file mode 100644 index 000000000..a96f5599e --- /dev/null +++ b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetLogs/582528ddfad69eb5 @@ -0,0 +1,2 @@ +go test fuzz v1 +[]byte("0") diff --git a/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetObjectDataByNamespace/582528ddfad69eb5 b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetObjectDataByNamespace/582528ddfad69eb5 new file mode 100644 index 000000000..a96f5599e --- /dev/null +++ b/chaoscenter/subscriber/pkg/k8s/fuzz/testdata/fuzz/FuzzGetObjectDataByNamespace/582528ddfad69eb5 @@ -0,0 +1,2 @@ +go test fuzz v1 +[]byte("0")