diff --git a/job.yaml b/job.yaml index c60ed1f..86cb02f 100644 --- a/job.yaml +++ b/job.yaml @@ -53,13 +53,21 @@ spec: serviceAccountName: node-collector containers: - name: node-collector - image: ghcr.io/aquasecurity/node-collector:0.2.0 + image: ghcr.io/aquasecurity/node-collector:0.2.1 command: - node-collector args: - k8s - - --node - - kind-control-plane + - --kubelet-config + - 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 + - --kubelet-config-mapping + - LS0tCmt1YmVsZXRBbm9ueW1vdXNBdXRoQXJndW1lbnRTZXQ6IGt1YmVsZXRjb25maWcuYXV0aGVudGljYXRpb24uYW5vbnltb3VzLmVuYWJsZWQKa3ViZWxldEF1dGhvcml6YXRpb25Nb2RlQXJndW1lbnRTZXQ6IGt1YmVsZXRjb25maWcuYXV0aG9yaXphdGlvbi5tb2RlCmt1YmVsZXRDbGllbnRDYUZpbGVBcmd1bWVudFNldDoga3ViZWxldGNvbmZpZy5hdXRoZW50aWNhdGlvbi54NTA5LmNsaWVudENBRmlsZQprdWJlbGV0UmVhZE9ubHlQb3J0QXJndW1lbnRTZXQ6IGt1YmVsZXRjb25maWcucmVhZE9ubHlQb3J0Cmt1YmVsZXRTdHJlYW1pbmdDb25uZWN0aW9uSWRsZVRpbWVvdXRBcmd1bWVudFNldDoga3ViZWxldGNvbmZpZy5zdHJlYW1pbmdDb25uZWN0aW9uSWRsZVRpbWVvdXQKa3ViZWxldFByb3RlY3RLZXJuZWxEZWZhdWx0c0FyZ3VtZW50U2V0OiBrdWJlbGV0Y29uZmlnLnByb3RlY3RLZXJuZWxEZWZhdWx0cwprdWJlbGV0TWFrZUlwdGFibGVzVXRpbENoYWluc0FyZ3VtZW50U2V0OiBrdWJlbGV0Y29uZmlnLm1ha2VJUFRhYmxlc1V0aWxDaGFpbnMKa3ViZWxldEV2ZW50UXBzQXJndW1lbnRTZXQ6IGt1YmVsZXRjb25maWcuZXZlbnRSZWNvcmRRUFMiLAprdWJlbGV0Um90YXRlS3ViZWxldFNlcnZlckNlcnRpZmljYXRlQXJndW1lbnRTZXQ6IGt1YmVsZXRjb25maWcuZmVhdHVyZUdhdGVzLlJvdGF0ZUt1YmVsZXRTZXJ2ZXJDZXJ0aWZpY2F0ZQprdWJlbGV0Um90YXRlQ2VydGlmaWNhdGVzQXJndW1lbnRTZXQ6IGt1YmVsZXRjb25maWcucm90YXRlQ2VydGlmaWNhdGVzCmt1YmVsZXRUbHNDZXJ0RmlsZVRsc0FyZ3VtZW50U2V0OiBrdWJlbGV0Y29uZmlnLnRsc0NlcnRGaWxlCmt1YmVsZXRUbHNQcml2YXRlS2V5RmlsZUFyZ3VtZW50U2V0OiBrdWJlbGV0Y29uZmlnLnRsc1ByaXZhdGVLZXlGaWxlCmt1YmVsZXRPbmx5VXNlU3Ryb25nQ3J5cHRvZ3JhcGhpYzoga3ViZWxldGNvbmZpZy50bHNDaXBoZXJTdWl0ZXMKCg== + - --spec-version-mapping + - LS0tCnZlcnNpb25fbWFwcGluZzoKICBrOHM6CiAgICAtIG9wOiAiPj0iCiAgICAgIGNsdXN0ZXJfdmVyc2lvbjogIjEuMjEiCiAgICAgIHNwZWM6IGs4cy1jaXMtMS4yMy4wCiAgZ2tlOgogICAgLSBvcDogIj49IgogICAgICBjbHVzdGVyX3ZlcnNpb246ICIxLjIxIgogICAgICBzcGVjOiBna2UtY2lzLTEuMi4wCiAgZWtzOgogICAgLSBvcDogIj49IgogICAgICBjbHVzdGVyX3ZlcnNpb246ICIxLjIxIgogICAgICBzcGVjOiBla3MtY2lzLTEuMi4wCiAgYWtzOgogICAgLSBvcDogIj49IgogICAgICBjbHVzdGVyX3ZlcnNpb246ICIxLjIxIgogICAgICBzcGVjOiBha3MtY2lzLTEuMAogIHJrZTI6CiAgICAtIG9wOiAiPj0iCiAgICAgIGNsdXN0ZXJfdmVyc2lvbjogIjEuMjEiCiAgICAgIHNwZWM6IHJrZTItY2lzLTEuMjQKICBtaWNyb2s4czoKICAgIC0gb3A6ICI+PSIKICAgICAgY2x1c3Rlcl92ZXJzaW9uOiAiMS4yMSIKICAgICAgc3BlYzogbWljcm9rOHMtY2lzLTEuMjQKICBvY3A6CiAgICAtIG9wOiAiPj0iCiAgICAgIGNsdXN0ZXJfdmVyc2lvbjogIjQuMCIKICAgICAgc3BlYzogcmgtY2lzLTEuMAoK + - --node-config + - ---
node:
  apiserver:
    confs:
      - /etc/kubernetes/manifests/kube-apiserver.yaml
      - /etc/kubernetes/manifests/kube-apiserver.yml
      - /etc/kubernetes/manifests/kube-apiserver.manifest
      - /var/snap/kube-apiserver/current/args
      - /var/snap/microk8s/current/args/kube-apiserver
      - /etc/origin/master/master-config.yaml
      - /etc/kubernetes/manifests/talos-kube-apiserver.yaml
      - /var/lib/rancher/rke2/agent/pod-manifests/kube-apiserver.yaml
    defaultconf: /etc/kubernetes/manifests/kube-apiserver.yaml
  controllermanager:
    confs:
      - /etc/kubernetes/manifests/kube-controller-manager.yaml
      - /etc/kubernetes/manifests/kube-controller-manager.yml
      - /etc/kubernetes/manifests/kube-controller-manager.manifest
      - /var/snap/kube-controller-manager/current/args
      - /var/snap/microk8s/current/args/kube-controller-manager
      - /etc/kubernetes/manifests/talos-kube-controller-manager.yaml
      - /var/lib/rancher/rke2/agent/pod-manifests/kube-controller-manager.yaml
    defaultconf: /etc/kubernetes/manifests/kube-controller-manager.yaml
    kubeconfig:
      - /etc/kubernetes/controller-manager.conf
      - /var/lib/kube-controller-manager/kubeconfig
      - /system/secrets/kubernetes/kube-controller-manager/kubeconfig
    defaultkubeconfig: /etc/kubernetes/controller-manager.conf
  scheduler:
    confs:
      - /etc/kubernetes/manifests/kube-scheduler.yaml
      - /etc/kubernetes/manifests/kube-scheduler.yml
      - /etc/kubernetes/manifests/kube-scheduler.manifest
      - /var/snap/kube-scheduler/current/args
      - /var/snap/microk8s/current/args/kube-scheduler
      - /etc/origin/master/scheduler.json
      - /etc/kubernetes/manifests/talos-kube-scheduler.yaml
      - /var/lib/rancher/rke2/agent/pod-manifests/kube-scheduler.yaml
    defaultconf: /etc/kubernetes/manifests/kube-scheduler.yaml
    kubeconfig:
      - /etc/kubernetes/scheduler.conf
      - /var/lib/kube-scheduler/kubeconfig
      - /var/lib/kube-scheduler/config.yaml
      - /system/secrets/kubernetes/kube-scheduler/kubeconfig
    defaultkubeconfig: /etc/kubernetes/scheduler.conf
  etcd:
    datadirs:
      - /var/lib/etcd/default.etcd
      - /var/lib/etcd/data.etcd
    confs:
      - /etc/kubernetes/manifests/etcd.yaml
      - /etc/kubernetes/manifests/etcd.yml
      - /etc/kubernetes/manifests/etcd.manifest
      - /etc/etcd/etcd.conf
      - /var/snap/etcd/common/etcd.conf.yml
      - /var/snap/etcd/common/etcd.conf.yaml
      - /var/snap/microk8s/current/args/etcd
      - /usr/lib/systemd/system/etcd.service
      - /var/lib/rancher/rke2/agent/pod-manifests/etcd.yaml
      - /var/lib/rancher/k3s/server/db/etcd/config
    defaultconf: /etc/kubernetes/manifests/etcd.yaml
    defaultdatadir: /var/lib/etcd/default.etcd
  flanneld:
    defaultconf: /etc/sysconfig/flanneld
  kubernetes:
    defaultconf: /etc/kubernetes/config
  kubelet:
    cafile:
      - /etc/kubernetes/pki/ca.crt
      - /etc/kubernetes/certs/ca.crt
      - /etc/kubernetes/cert/ca.pem
      - /var/snap/microk8s/current/certs/ca.crt
      - /var/lib/rancher/rke2/agent/server.crt
      - /var/lib/rancher/rke2/agent/client-ca.crt
      - /var/lib/rancher/k3s/agent/client-ca.crt
    svc:
      - /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
      - /etc/systemd/system/kubelet.service
      - /lib/systemd/system/kubelet.service
      - /etc/systemd/system/snap.kubelet.daemon.service
      - /etc/systemd/system/snap.microk8s.daemon-kubelet.service
      - /etc/systemd/system/atomic-openshift-node.service
      - /etc/systemd/system/origin-node.service
    bins:
      - hyperkube kubelet
      - kubelet
    kubeconfig:
      - /etc/kubernetes/kubelet.conf
      - /etc/kubernetes/kubelet-kubeconfig.conf
      - /var/lib/kubelet/kubeconfig
      - /etc/kubernetes/kubelet-kubeconfig
      - /etc/kubernetes/kubelet/kubeconfig
      - /etc/kubernetes/ssl/kubecfg-kube-node.yaml
      - /var/snap/microk8s/current/credentials/kubelet.config
      - /etc/kubernetes/kubeconfig-kubelet
      - /var/lib/rancher/rke2/agent/kubelet.kubeconfig
      - /var/lib/rancher/k3s/server/cred/admin.kubeconfig
      - /var/lib/rancher/k3s/agent/kubelet.kubeconfig
    confs:
      - /etc/kubernetes/kubelet-config.yaml
      - /var/lib/kubelet/config.yaml
      - /var/lib/kubelet/config.yml
      - /etc/kubernetes/kubelet/kubelet-config.json
      - /etc/kubernetes/kubelet/config
      - /home/kubernetes/kubelet-config.yaml
      - /home/kubernetes/kubelet-config.yml
      - /etc/default/kubeletconfig.json
      - /etc/default/kubelet
      - /var/lib/kubelet/kubeconfig
      - /var/snap/kubelet/current/args
      - /var/snap/microk8s/current/args/kubelet
      - /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
      - /etc/systemd/system/kubelet.service
      - /lib/systemd/system/kubelet.service
      - /etc/systemd/system/snap.kubelet.daemon.service
      - /etc/systemd/system/snap.microk8s.daemon-kubelet.service
      - /etc/kubernetes/kubelet.yaml
      - /var/lib/rancher/rke2/agent/kubelet.kubeconfig
    defaultconf: /var/lib/kubelet/config.yaml
    defaultsvc: /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
    defaultkubeconfig: /etc/kubernetes/kubelet.conf
    defaultcafile: /etc/kubernetes/pki/ca.crt
  proxy:
    bins:
      - kube-proxy
      - hyperkube proxy
      - hyperkube kube-proxy
      - proxy
      - openshift start network
    confs:
      - /etc/kubernetes/proxy
      - /etc/kubernetes/addons/kube-proxy-daemonset.yaml
      - /etc/kubernetes/addons/kube-proxy-daemonset.yml
      - /var/snap/kube-proxy/current/args
      - /var/snap/microk8s/current/args/kube-proxy
    kubeconfig:
      - /etc/kubernetes/kubelet-kubeconfig
      - /etc/kubernetes/kubelet-kubeconfig.conf
      - /etc/kubernetes/kubelet/config
      - /etc/kubernetes/ssl/kubecfg-kube-proxy.yaml
      - /var/lib/kubelet/kubeconfig
      - /var/snap/microk8s/current/credentials/proxy.config
      - /var/lib/rancher/rke2/agent/kubeproxy.kubeconfig
      - /var/lib/rancher/k3s/agent/kubeproxy.kubeconfig
    svc:
      - /lib/systemd/system/kube-proxy.service
      - /etc/systemd/system/snap.microk8s.daemon-proxy.service
    defaultconf: /etc/kubernetes/addons/kube-proxy-daemonset.yaml
    defaultkubeconfig: /etc/kubernetes/proxy.conf
 + - --node-commands + - ---
commands:
  - key: kubeAPIServerSpecFilePermission
    title: API server pod specification file permissions
    nodeType: master
    audit: stat -c %a $apiserver.confs
  - key: kubeAPIServerSpecFileOwnership
    title: API server pod specification file ownership
    nodeType: master
    audit: stat -c %U:%G $apiserver.confs
  - key: kubeControllerManagerSpecFilePermission
    title: Controller manager pod specification file permissions
    nodeType: master
    audit: stat -c %a $controllermanager.confs
  - key: kubeControllerManagerSpecFileOwnership
    title: Controller manager pod specification file ownership is set to root:root
    nodeType: master
    audit: stat -c %U:%G $controllermanager.confs
  - key: kubeSchedulerSpecFilePermission
    title: Scheduler pod specification file permissions
    nodeType: master
    audit: stat -c %a $scheduler.confs
  - key: kubeSchedulerSpecFileOwnership
    title: Scheduler pod specification file ownership
    nodeType: master
    audit: stat -c %U:%G $scheduler.confs
  - key: kubeEtcdSpecFilePermission
    title: Etcd pod specification file permissions
    nodeType: master
    audit: stat -c %a $etcd.confs
  - key: kubeEtcdSpecFileOwnership
    title: Etcd pod specification file ownership
    nodeType: master
    audit: stat -c %U:%G $etcd.confs
  - key: containerNetworkInterfaceFilePermissions
    title: Container Network Interface file permissions
    nodeType: master
    audit: stat -c %a /*/cni/*
  - key: containerNetworkInterfaceFileOwnership
    title: Container Network Interface file ownership
    nodeType: master
    audit: stat -c %U:%G /*/cni/*
  - key: etcdDataDirectoryPermissions
    title: Etcd data directory permissions
    nodeType: master
    audit: stat -c %a $etcd.datadirs
  - key: etcdDataDirectoryOwnership
    title: Etcd data directory Ownership
    nodeType: master
    audit: stat -c %U:%G $etcd.datadirs
  - key: adminConfFilePermissions
    title: admin.conf file permissions
    nodeType: master
    audit: stat -c %a /etc/kubernetes/admin.conf
  - key: adminConfFileOwnership
    title: admin.conf file ownership
    nodeType: master
    audit: stat -c %U:%G /etc/kubernetes/admin.conf
  - key: schedulerConfFilePermissions
    title: scheduler.conf file permissions
    nodeType: master
    audit: stat -c %a $scheduler.kubeconfig
  - key: schedulerConfFileOwnership
    title: scheduler.conf file ownership
    nodeType: master
    audit: stat -c %U:%G $scheduler.kubeconfig
  - key: controllerManagerConfFilePermissions
    title: controller-manager.conf file permissions
    nodeType: master
    audit: stat -c %a $controllermanager.kubeconfig
  - key: controllerManagerConfFileOwnership
    title: controller-manager.conf file ownership
    nodeType: master
    audit: stat -c %U:%G $controllermanager.kubeconfig
  - key: kubePKIDirectoryFileOwnership
    title: Kubernetes PKI directory and file ownership
    nodeType: master
    audit: stat -c %U:%G $(ls -R $kubelet.cafile | awk
      '/:$/&&f{s=$0;f=0}/:$/&&!f{sub(/:$/,"");s=$0;f=1;next}NF&&f{print s"/"$0
      }')
  - key: kubernetesPKICertificateFilePermissions
    title: Kubernetes PKI certificate file permissions
    nodeType: master
    audit: stat -c %a $(ls -aR $kubelet.cafile |
      awk'/:$/&&f{s=$0;f=0}/:$/&&!f{sub(/:$/,"");s=$0;f=1;next}NF&&f{print
      s"/"$0}' | grep \.crt$)
  - key: kubePKIKeyFilePermissions
    title: Kubernetes PKI certificate file permissions
    nodeType: master
    audit: stat -c %a $(ls -aR $kubelet.cafile | awk
      '/:$/&&f{s=$0;f=0}/:$/&&!f{sub(/:$/,"");s=$0;f=1;next}NF&&f{print s"/"$0}'
      | grep \.key$)
  - key: kubeletServiceFilePermissions
    title: Kubelet service file permissions
    nodeType: worker
    audit: stat -c %a $kubelet.svc
  - key: kubeletServiceFileOwnership
    title: Kubelet service file ownership
    nodeType: worker
    audit: stat -c %U:%G $kubelet.svc
  - key: kubeconfigFileExistsPermissions
    title: Kubeconfig file exists ensure permissions
    nodeType: worker
    audit: output=`stat -c %a $(ps -ef | grep $proxy.bins |grep 'kubeconfig' | grep
      -o 'kubeconfig=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1')
      2>/dev/null` || echo $output
  - key: kubeconfigFileExistsOwnership
    title: Kubeconfig file exists ensure ownership
    nodeType: worker
    audit: output=`stat -c %U:%G $(ps -ef | grep $proxy.bins |grep 'kubeconfig' |
      grep -o 'kubeconfig=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1')
      2>/dev/null` || echo $output
  - key: kubeletConfFilePermissions
    title: kubelet.conf file permissions
    nodeType: worker
    audit: stat -c %a $kubelet.kubeconfig
  - key: kubeletConfFileOwnership
    title: kubelet.conf file ownership
    nodeType: worker
    audit: stat -c %U:%G $kubelet.kubeconfig
  - key: certificateAuthoritiesFilePermissions
    title: Client certificate authorities file permissions
    nodeType: worker
    audit: stat -c %a $(ps -ef | grep kubelet |grep 'client-ca-file' | grep -o
      'client-ca-file=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1') 2>
      /dev/null
  - key: certificateAuthoritiesFileOwnership
    title: Client certificate authorities file ownership
    nodeType: worker
    audit: stat -c %U:%G $(ps -ef | grep $kubelet.bins |grep 'client-ca-file' | grep
      -o 'client-ca-file=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1') 2>
      /dev/null
  - key: kubeletConfigYamlConfigurationFilePermission
    title: kubelet config.yaml configuration file permissions
    nodeType: worker
    audit: stat -c %a $kubelet.confs
  - key: kubeletConfigYamlConfigurationFileOwnership
    title: kubelet config.yaml configuration file ownership
    nodeType: worker
    audit: stat -c %U:%G $kubelet.confs
  - key: kubeletAnonymousAuthArgumentSet
    title: kubelet --anonymous-auth argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --anonymous-auth' | grep -o '
      --anonymous-auth=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'
  - key: kubeletAuthorizationModeArgumentSet
    title: kubelet --authorization-mode argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --authorization-mode' | grep -o '
      --authorization-mode=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'
  - key: kubeletClientCaFileArgumentSet
    title: kubelet --client-ca-file argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --client-ca-file' | grep -o '
      --client-ca-file=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'
  - key: kubeletReadOnlyPortArgumentSet
    title: kubelet --read-only-port argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --read-only-port' | grep -o '
      --read-only-port=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'
  - key: kubeletStreamingConnectionIdleTimeoutArgumentSet
    title: kubelet --streaming-connection-idle-timeout argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --streamingConnectionIdleTimeout' |
      grep -o ' --streamingConnectionIdleTimeout=[^"]\S*' | awk -F "=" '{print
      $2}' |awk 'FNR <= 1'
  - key: kubeletProtectKernelDefaultsArgumentSet
    title: kubelet --protect-kernel-defaults argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --protect-kernel-defaults' | grep -o
      ' --protect-kernel-defaults=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR
      <= 1'
  - key: kubeletMakeIptablesUtilChainsArgumentSet
    title: kubelet --make-iptables-util-chains argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --make-iptables-util-chains' | grep
      -o ' --make-iptables-util-chains=[^"]\S*' | awk -F "=" '{print $2}' |awk
      'FNR <= 1'
  - key: kubeletHostnameOverrideArgumentSet
    title: kubelet hostname-override argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --hostname-override' | grep -o '
      --hostname-override=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'
  - key: kubeletEventQpsArgumentSet
    title: kubelet --event-qps argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --event-qps' | grep -o '
      --event-qps=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'
  - key: kubeletTlsCertFileTlsArgumentSet
    title: kubelet --tls-cert-file argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --tls-cert-file' | grep -o '
      --tls-cert-file=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'
  - key: kubeletTlsPrivateKeyFileArgumentSet
    title: kubelet --tls-private-key-file argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --tls-private-key-file' | grep -o '
      --tls-private-key-file=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'
  - key: kubeletRotateCertificatesArgumentSet
    title: kubelet --rotate-certificates argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep ' --rotate-certificates' | grep -o '
      --rotate-certificates=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'
  - key: kubeletRotateKubeletServerCertificateArgumentSet
    title: kubelet RotateKubeletServerCertificate argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep 'RotateKubeletServerCertificate' | grep
      -o 'RotateKubeletServerCertificate=[^"]\S*' | awk -F "=" '{print $2}' |awk
      'FNR <= 1'
  - key: kubeletRotateKubeletServerCertificateArgumentSet
    title: kubelet RotateKubeletServerCertificate argument is set
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep 'RotateKubeletServerCertificate' | grep
      -o 'RotateKubeletServerCertificate=[^"]\S*' | awk -F "=" '{print $2}' |awk
      'FNR <= 1'
  - key: kubeletOnlyUseStrongCryptographic
    title: Kubelet only makes use of Strong Cryptographic
    nodeType: worker
    audit: ps -ef | grep $kubelet.bins |grep 'TLSCipherSuites' | grep -o
      'TLSCipherSuites=[^"]\S*' | awk -F "=" '{print $2}' |awk 'FNR <= 1'

 resources: limits: cpu: 100m diff --git a/pkg/collector/collect.go b/pkg/collector/collect.go index 83efb57..c052f08 100644 --- a/pkg/collector/collect.go +++ b/pkg/collector/collect.go @@ -17,6 +17,7 @@ import ( "github.com/Masterminds/semver" "github.com/spf13/cobra" + "gopkg.in/yaml.v3" ) const ( @@ -44,7 +45,9 @@ func CollectData(cmd *cobra.Command) error { if err != nil { return err } - lp, err := LoadConfigParams() + nodeFileconfig := cmd.Flag("node-config").Value.String() + specVersionMapping := cmd.Flag("spec-version-mapping").Value.String() + lp, mp, err := LoadConfigParams(nodeFileconfig, specVersionMapping) if err != nil { return err } @@ -53,59 +56,89 @@ func CollectData(cmd *cobra.Command) error { if err != nil { return err } - sv, err := specID(cmd, cluster, lp) + specName := cmd.Flag("spec-name").Value.String() + specVersion := cmd.Flag("spec-version").Value.String() + clusterVersion := cmd.Flag("cluster-version").Value.String() + sv, err := specID(specName, specVersion, clusterVersion, cluster, mp) if err != nil { return err } - for _, infoCollector := range infoCollectorMap { - nodeInfo := make(map[string]*Info) - if fmt.Sprintf("%s-%s", infoCollector.Name, infoCollector.Version) != sv { - continue - } - for _, ci := range infoCollector.Collectors { - if ci.NodeType != nodeType && nodeType != MasterNode { - continue - } - output, err := shellCmd.Execute(ci.Audit) + nodeCommands := cmd.Flag("node-commands").Value.String() + commands, err := GetNodesCommands(nodeCommands, infoCollectorMap, nodeType, sv) + if len(commands) == 0 { + return fmt.Errorf("spec not found") + } + nodeInfo, err := ExecuteCommands(shellCmd, commands) + if err != nil { + return err + } + nodeName := cmd.Flag("node").Value.String() + kubeletConfig := cmd.Flag("kubelet-config").Value.String() + if nodeName != "" || kubeletConfig != "" { + nodeConfig, err := loadNodeConfig(ctx, *cluster, nodeName, kubeletConfig) + if err == nil { + kubeletConfigMapping := cmd.Flag("kubelet-config-mapping").Value.String() + mapping, err := LoadKubeletMapping(kubeletConfigMapping) if err != nil { return err } - values := StringToArray(output, ",") - nodeInfo[ci.Key] = &Info{Values: values} + configVal := getValuesFromkubeletConfig(nodeConfig, mapping) + mergeConfigValues(nodeInfo, configVal) } - nodeName := cmd.Flag("node").Value.String() - kubeletConfig := cmd.Flag("kubelet-config").Value.String() - if nodeName != "" || kubeletConfig != "" { - nodeConfig, err := loadNodeConfig(ctx, *cluster, nodeName, kubeletConfig) - if err == nil { - mapping, err := LoadKubeletMapping() - if err != nil { - return err - } - configVal := getValuesFromkubeletConfig(nodeConfig, mapping) - mergeConfigValues(nodeInfo, configVal) - } + } + nodeData := Node{ + APIVersion: Version, + Kind: Kind, + Type: nodeType, + Metadata: map[string]string{"creationTimestamp": time.Now().Format(time.RFC3339)}, + Info: nodeInfo, + } + outputFormat := cmd.Flag("output").Value.String() + err = printOutput(nodeData, outputFormat, os.Stdout) + if err != nil { + return err + } + return nil +} + +func GetNodesCommands(nodeCommands string, infoCollectorMap map[string]*SpecInfo, nodeType string, sv string) ([]Command, error) { + var commands []Command + var specInfo SpecInfo + if nodeCommands != "" { + base64Commands, err := base64.StdEncoding.DecodeString(nodeCommands) + if err != nil { + return nil, err } - nodeData := Node{ - APIVersion: Version, - Kind: Kind, - Type: nodeType, - Metadata: map[string]string{"creationTimestamp": time.Now().Format(time.RFC3339)}, - Info: nodeInfo, + err = yaml.Unmarshal(base64Commands, &specInfo) + if err != nil { + return nil, err + } + commands = specInfo.Commands + } else { + for _, infoCollector := range infoCollectorMap { + if fmt.Sprintf("%s-%s", infoCollector.Name, infoCollector.Version) == sv { + commands = infoCollector.Commands + break + } } - outputFormat := cmd.Flag("output").Value.String() - err = printOutput(nodeData, outputFormat, os.Stdout) + } + return commands, nil +} + +func ExecuteCommands(shellCmd Shell, ci []Command) (map[string]*Info, error) { + nodeInfo := make(map[string]*Info) + for _, c := range ci { + output, err := shellCmd.Execute(c.Audit) if err != nil { - return err + return nil, err } + values := StringToArray(output, ",") + nodeInfo[c.Key] = &Info{Values: values} } - return nil + return nodeInfo, nil } -func specID(cmd *cobra.Command, cluster *Cluster, lp *Config) (string, error) { - specName := cmd.Flag("spec-name").Value.String() - specVersion := cmd.Flag("spec-version").Value.String() - clusterVersion := cmd.Flag("cluster-version").Value.String() +func specID(specName, specVersion, clusterVersion string, cluster *Cluster, mp *Mapper) (string, error) { switch { case specName != "" && specVersion != "": return fmt.Sprintf("%s-%s", specName, specVersion), nil @@ -115,13 +148,13 @@ func specID(cmd *cobra.Command, cluster *Cluster, lp *Config) (string, error) { Name: strings.TrimSuffix(specName, "-cis"), Version: majorVersion(clusterVersion), }, - lp.VersionMapping), nil + mp.VersionMapping), nil default: // auto detect spec by platform type (k8s, aks, eks and etc) and version p, err := cluster.Platfrom() if err != nil { return "", err } - return specByPlatfromVersion(p, lp.VersionMapping), nil + return specByPlatfromVersion(p, mp.VersionMapping), nil } } diff --git a/pkg/collector/collect_test.go b/pkg/collector/collect_test.go index c5209d6..8fdf28d 100644 --- a/pkg/collector/collect_test.go +++ b/pkg/collector/collect_test.go @@ -3,6 +3,7 @@ package collector import ( "encoding/json" "os" + "reflect" "testing" "github.com/stretchr/testify/assert" @@ -57,7 +58,7 @@ func TestParseNodeConfig(t *testing.T) { nodeConfig := make(map[string]interface{}) err = json.Unmarshal(data, &nodeConfig) assert.NoError(t, err) - mapping, err := LoadKubeletMapping() + mapping, err := LoadKubeletMapping("") assert.NoError(t, err) m := getValuesFromkubeletConfig(nodeConfig, mapping) for k, v := range m { @@ -118,10 +119,10 @@ func TestSpecByVersionName(t *testing.T) { t.Run(tt.name, func(t *testing.T) { f, err := os.ReadFile(tt.versionMappingfile) assert.NoError(t, err) - var config Config - err = yaml.Unmarshal(f, &config) + var mapper Mapper + err = yaml.Unmarshal(f, &mapper) assert.NoError(t, err) - gotSpec := specByPlatfromVersion(tt.platfrom, config.VersionMapping) + gotSpec := specByPlatfromVersion(tt.platfrom, mapper.VersionMapping) assert.Equal(t, gotSpec, tt.wantSpec) }) } @@ -172,3 +173,32 @@ func TestPlatfromVersion(t *testing.T) { }) } } + +func TestNodeCommamnd(t *testing.T) { + tests := []struct { + name string + commands string + want []Command + }{ + { + name: "k8s version", + commands: "LS0tCmNvbW1hbmRzOgogIC0ga2V5OiBrdWJlQVBJU2VydmVyU3BlY0ZpbGVQZXJtaXNzaW9uCiAgICB0aXRsZTogQVBJIHNlcnZlciBwb2Qgc3BlY2lmaWNhdGlvbiBmaWxlIHBlcm1pc3Npb25zCiAgICBub2RlVHlwZTogbWFzdGVyCiAgICBhdWRpdDogc3RhdCAtYyAlYSAkYXBpc2VydmVyLmNvbmZzCgo=", + want: []Command{ + { + Key: "kubeAPIServerSpecFilePermission", + Title: "API server pod specification file permissions", + NodeType: "master", + Audit: "stat -c %a $apiserver.confs", + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetNodesCommands(tt.commands, nil, "worker", "k8s-cis-1.23.2") + assert.NoError(t, err) + assert.True(t, reflect.DeepEqual(got, tt.want)) + }) + } +} diff --git a/pkg/collector/config/specs/k8s-cis-1.23.0.yaml b/pkg/collector/config/specs/k8s-cis-1.23.0.yaml index a51b98c..c6fdb6f 100644 --- a/pkg/collector/config/specs/k8s-cis-1.23.0.yaml +++ b/pkg/collector/config/specs/k8s-cis-1.23.0.yaml @@ -2,7 +2,7 @@ version: "1.23.0" name: k8s-cis title: Node Specification for info collector -collectors: +commands: - key: kubeAPIServerSpecFilePermission title: API server pod specification file permissions nodeType: master diff --git a/pkg/collector/info.go b/pkg/collector/info.go index 9dfccfb..e564fbb 100644 --- a/pkg/collector/info.go +++ b/pkg/collector/info.go @@ -2,6 +2,7 @@ package collector import ( "embed" + "encoding/base64" "fmt" "strings" @@ -49,20 +50,43 @@ func LoadConfig(configMap map[string]string) (map[string]*SpecInfo, error) { } // LoadConfigParams load audit params data -func LoadConfigParams() (*Config, error) { - fullPath := fmt.Sprintf("%s/%s", configFolder, "config.yaml") - fContent, err := params.ReadFile(fullPath) - if err != nil { - return nil, err +func LoadConfigParams(nodeFileconfig, specVersionMapping string) (*Config, *Mapper, error) { + var decodedNodeFileconfig, decodedspecVersionMapping []byte + var err error + if nodeFileconfig != "" && specVersionMapping != "" { + decodedNodeFileconfig, err = base64.StdEncoding.DecodeString(nodeFileconfig) + if err != nil { + return nil, nil, err + } + decodedspecVersionMapping, err = base64.StdEncoding.DecodeString(specVersionMapping) + if err != nil { + return nil, nil, err + } + } else { + fullPath := fmt.Sprintf("%s/%s", configFolder, "config.yaml") + decodedNodeFileconfig, err = params.ReadFile(fullPath) + if err != nil { + return nil, nil, err + } + decodedspecVersionMapping = decodedNodeFileconfig } - return getNodeParams(string(fContent)) + return getNodeParams(string(decodedNodeFileconfig), string(decodedspecVersionMapping)) } -func LoadKubeletMapping() (map[string]string, error) { - fullPath := fmt.Sprintf("%s/%s", configFolder, "kubeletconfig-mapping.yaml") - fContent, err := params.ReadFile(fullPath) - if err != nil { - return nil, err +func LoadKubeletMapping(kubletConfigMapping string) (map[string]string, error) { + var fContent []byte + var err error + if len(kubletConfigMapping) > 0 { + fContent, err = base64.StdEncoding.DecodeString(kubletConfigMapping) + if err != nil { + return nil, err + } + } else { + fullPath := fmt.Sprintf("%s/%s", configFolder, "kubeletconfig-mapping.yaml") + fContent, err = params.ReadFile(fullPath) + if err != nil { + return nil, err + } } mapping := make(map[string]string) err = yaml.Unmarshal(fContent, &mapping) @@ -74,14 +98,14 @@ func LoadKubeletMapping() (map[string]string, error) { // SpecInfo spec info with require comand to collect type SpecInfo struct { - Version string `yaml:"version"` - Name string `yaml:"name"` - Title string `yaml:"title"` - Collectors []Collector `yaml:"collectors"` + Version string `yaml:"version"` + Name string `yaml:"name"` + Title string `yaml:"title"` + Commands []Command `yaml:"commands"` } // Collector details of info to collect -type Collector struct { +type Command struct { Key string `yaml:"key"` Title string `yaml:"title"` Audit string `yaml:"audit"` @@ -97,13 +121,18 @@ func getSpecInfo(info string) (*SpecInfo, error) { return &specInfo, nil } -func getNodeParams(info string) (*Config, error) { +func getNodeParams(config string, mapping string) (*Config, *Mapper, error) { var np Config - err := yaml.Unmarshal([]byte(info), &np) + err := yaml.Unmarshal([]byte(config), &np) if err != nil { - return nil, err + return nil, nil, err + } + var mp Mapper + err = yaml.Unmarshal([]byte(mapping), &mp) + if err != nil { + return nil, nil, err } - return &np, nil + return &np, &mp, nil } // Node output node data with info results @@ -121,10 +150,11 @@ type Info struct { } type Config struct { - Node NodeParams `yaml:"node"` + Node NodeParams `yaml:"node"` +} +type Mapper struct { VersionMapping map[string][]SpecVersion `yaml:"version_mapping"` } - type SpecVersion struct { Name string Version string `yaml:"cluster_version"` diff --git a/pkg/command/root.go b/pkg/command/root.go index 1abb585..0d74430 100644 --- a/pkg/command/root.go +++ b/pkg/command/root.go @@ -13,7 +13,11 @@ func init() { rootCmd.PersistentFlags().StringP("spec-version", "v", "", "spec version. example 1.23.0") rootCmd.PersistentFlags().StringP("cluster-version", "c", "", "cluser version. example 1.23.0") rootCmd.PersistentFlags().StringP("node", "n", "", "node name") - rootCmd.PersistentFlags().StringP("kubelet-config", "", "", "kubelet config via api /api/v1/nodes/<>/proxy/configz encoded in base64") + rootCmd.PersistentFlags().StringP("kubelet-config", "", "", "kubelet config via api /api/v1/nodes/<>/proxy/configz encoded to base64") + rootCmd.PersistentFlags().StringP("spec-version-mapping", "", "", "k8s spec-version mapping encoded to base64") + rootCmd.PersistentFlags().StringP("node-config", "", "", "k8s node file config encoded to base64") + rootCmd.PersistentFlags().StringP("node-commands", "", "", "k8s node commands to be executed encoded to base64") + rootCmd.PersistentFlags().StringP("kubelet-config-mapping", "", "", "kubelet config api mapping encoded to base64") } var rootCmd = &cobra.Command{