Datasets:

H836

/

cclab

like 0

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/home/user1/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 file: matchDirectories: - dir: /home/user1/ recursive: true ownerOnly: true readOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/home/user1/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 file: matchDirectories: - dir: /home/user1/ recursive: true ownerOnly: true readOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/readwrite', Specifies what to do when rules match, in which case the action 'Allow' allows access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 - WARNING file: matchDirectories: - dir: /credentials/ readOnly: true fromSource: - path: /readwrite action: Allow

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/readwrite', Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 - WARNING file: matchDirectories: - dir: /credentials/ readOnly: true fromSource: - path: /readwrite action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/home/user1/secret_data1.txt'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 file: matchPaths: - path: /home/user1/secret_data1.txt ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 file: matchDirectories: - dir: /credentials/ action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/apt'. '/usr/bin/apt-get'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 process: matchPaths: - path: /usr/bin/apt - path: /usr/bin/apt-get action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/var/www/html/wp-config.php'. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source '/bin/cat'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 file: matchPaths: - path: /var/www/html/wp-config.php fromSource: - path: /bin/cat action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/chmod'. '/usr/bin/chown'. '/bin/chmod'. '/bin/chown'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 process: matchPaths: - path: /usr/bin/chmod - path: /usr/bin/chown - path: /bin/chmod - path: /bin/chown action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/issue'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. '/etc/issue.net'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. '/etc/hosts'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. '/etc/sysconfig/network'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 file: matchPaths: - path: /etc/issue readOnly: true - path: /etc/issue.net readOnly: true - path: /etc/hosts readOnly: true - path: /etc/sysconfig/network readOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: nginx-2'. defines rules related to processes running in the selected pods. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/bin/'. '/usr/bin/'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: nginx-2 process: matchDirectories: - dir: /bin/ - dir: /usr/bin/ action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/local/tomcat/conf/jaspic-providers.xml'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /usr/local/tomcat/conf/jaspic-providers.xml ownerOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/modprobe.d/cramfs.conf'. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source '/bin/false'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /etc/modprobe.d/cramfs.conf fromSource: - path: /bin/false readOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/modprobe.d/udf.conf'. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source '/bin/false'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /etc/modprobe.d/udf.conf fromSource: - path: /bin/false readOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/fstab'. '/usr/lib/systemd/system/tmp.mount'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /etc/fstab - path: /usr/lib/systemd/system/tmp.mount action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/nginx/', ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/root/', ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /etc/nginx/ ownerOnly: true recursive: true - dir: /root/ ownerOnly: true recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*.mysql history' pattern. '/*.mysql_history' pattern. '/*.mysqlsh/history' pattern. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPatterns: - pattern: /*.mysql history - pattern: /*.mysql_history - pattern: /*.mysqlsh/history action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related Linux capabilities. apply the rule to the capability name 'net_raw'. Specifies what to do when rules match, in this case, the 'Block' action blocks the matching capability behavior.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns capabilities: matchCapabilities: - capability: net_raw action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/secret.txt'. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source '/bin/cat'. Specifies what to do when rules match, in which case the action 'Allow' allows access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /secret.txt fromSource: - path: /bin/cat action: Allow

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. applies the rule to files with the '/home/user1/secret_data*' pattern, ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPatterns: - pattern: /home/user1/secret_data* ownerOnly: true readOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the network-related policies. In this case, rule applies to raw network traffic. Specifies what to do when rules match, which means relevant network activities will be blocked.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns network: matchProtocols: - protocol: raw action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/local/bin/kubectl'. '/usr/bin/kubectl'. '/usr/local/bin/docker'. '/usr/bin/docker'. '/usr/local/bin/crictl'. '/usr/bin/crictl'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/local/bin/kubectl - path: /usr/bin/kubectl - path: /usr/local/bin/docker - path: /usr/bin/docker - path: /usr/local/bin/crictl - path: /usr/bin/crictl action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/sbin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchDirectories: - dir: /sbin/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/apt'. '/usr/bin/apt-get'. '/bin/apt-get'. '/sbin/apk'. '/bin/apt'. '/usr/bin/dpkg'. '/bin/dpkg'. '/usr/bin/gdebi'. '/bin/gdebi'. '/usr/bin/make'. '/bin/make'. '/usr/bin/yum'. '/bin/yum'. '/usr/bin/rpm'. '/bin/rpm'. '/usr/bin/dnf'. '/bin/dnf'. '/usr/bin/pacman'. '/usr/sbin/pacman'. '/bin/pacman'. '/sbin/pacman'. '/usr/bin/makepkg'. '/usr/sbin/makepkg'. '/bin/makepkg'. '/sbin/makepkg'. '/usr/bin/yaourt'. '/usr/sbin/yaourt'. '/bin/yaourt'. '/sbin/yaourt'. '/usr/bin/zypper'. '/bin/zypper'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/bin/apt - path: /usr/bin/apt-get - path: /bin/apt-get - path: /sbin/apk - path: /bin/apt - path: /usr/bin/dpkg - path: /bin/dpkg - path: /usr/bin/gdebi - path: /bin/gdebi - path: /usr/bin/make - path: /bin/make - path: /usr/bin/yum - path: /bin/yum - path: /usr/bin/rpm - path: /bin/rpm - path: /usr/bin/dnf - path: /bin/dnf - path: /usr/bin/pacman - path: /usr/sbin/pacman - path: /bin/pacman - path: /sbin/pacman - path: /usr/bin/makepkg - path: /usr/sbin/makepkg - path: /bin/makepkg - path: /sbin/makepkg - path: /usr/bin/yaourt - path: /usr/sbin/yaourt - path: /bin/yaourt - path: /sbin/yaourt - path: /usr/bin/zypper - path: /bin/zypper action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/ssl/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/etc/pki/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/usr/local/share/ca-certificates/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /etc/ssl/ readOnly: true recursive: true - dir: /etc/pki/ readOnly: true recursive: true - dir: /usr/local/share/ca-certificates/ readOnly: true recursive: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/local/bin/kubectl'. '/usr/bin/kubectl'. '/usr/local/bin/docker'. '/usr/bin/docker'. '/usr/local/bin/crictl'. '/usr/bin/crictl'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/local/bin/kubectl - path: /usr/bin/kubectl - path: /usr/local/bin/docker - path: /usr/bin/docker - path: /usr/local/bin/crictl - path: /usr/bin/crictl action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/dev/shm/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /dev/shm/ readOnly: true recursive: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/passwd'. '/etc/shadow'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file. defines rules related to processes running in the selected pods. applies the rule to processes with the '/proc/**/cmdline' pattern. '/proc/**/sched_debug' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /etc/passwd - path: /etc/shadow process: matchPatterns: - pattern: /proc/**/cmdline - pattern: /proc/**/sched_debug action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/passwd'. '/etc/shadow'. '/etc/group'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/useradd'. '/usr/sbin/useradd'. '/bin/adduser'. '/usr/sbin/adduser'. '/usr/sbin/userdel'. '/bin/userdel'. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /etc/passwd - path: /etc/shadow - path: /etc/group process: matchPaths: - path: /bin/useradd - path: /usr/sbin/useradd - path: /bin/adduser - path: /usr/sbin/adduser - path: /usr/sbin/userdel - path: /bin/userdel action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/passwd'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Allow' allows access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /etc/passwd ownerOnly: true action: Allow

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/bash'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies the action to take when rules match, in which case the 'Allow' action allows the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /bin/bash ownerOnly: true action: Allow

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/usr/share/elasticsearch/data/nodes/0/indices/', Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /usr/share/elasticsearch/data/nodes/0/indices/ action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/bin/bash'. '/bin/sh'. '/usr/bin/bash'. '/usr/bin/env'. '/usr/bin/shell'. '/bin/ksh'. '/etc/init.d'. '/dev/tty'. '/bin/zsh'. '/bin/tcsh'. '/bin/csh'. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source '/bin/bash'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/bash'. '/bin/sh'. '/usr/bin/bash'. '/usr/bin/env'. '/usr/bin/shell'. '/bin/ksh'. '/etc/init.d'. '/dev/tty'. '/bin/zsh'. '/bin/tcsh'. '/bin/csh'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /bin/bash - path: /bin/sh - path: /usr/bin/bash - path: /usr/bin/env - path: /usr/bin/shell - path: /bin/ksh - path: /etc/init.d - path: /dev/tty - path: /bin/zsh - path: /bin/tcsh - path: /bin/csh ownerOnly: true file: matchPaths: - path: /bin/bash - path: /bin/sh - path: /usr/bin/bash - path: /usr/bin/env - path: /usr/bin/shell - path: /bin/ksh - path: /etc/init.d - path: /dev/tty - path: /bin/zsh - path: /bin/tcsh - path: /bin/csh fromSource: - path: /bin/bash action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/**/fchmodat' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPatterns: - pattern: /**/fchmodat action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/mysql/my.cnf'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/mysql/mariadb.conf.d'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/mysql/conf.d'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/mysql/debian-start'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/mysql/debian.cnf'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/mysql/mariadb.cnf'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/mysqld.pid'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/tmp/mysql.sock'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/lib/systemd/system/mysql.service'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/lib/systemd/system/mysqld.service'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /etc/mysql/my.cnf ownerOnly: true - path: /etc/mysql/mariadb.conf.d ownerOnly: true - path: /etc/mysql/conf.d ownerOnly: true - path: /etc/mysql/debian-start ownerOnly: true - path: /etc/mysql/debian.cnf ownerOnly: true - path: /etc/mysql/mariadb.cnf ownerOnly: true - path: /mysqld.pid ownerOnly: true - path: /tmp/mysql.sock ownerOnly: true - path: /usr/lib/systemd/system/mysql.service ownerOnly: true - path: /usr/lib/systemd/system/mysqld.service ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/mongod.conf'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /etc/mongod.conf ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. applies the rule to files with the '/**/shosts.equiv' pattern, Specifies a rule that matches a specific file absolute path '/shosts.equiv'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPatterns: - pattern: /**/shosts.equiv matchPaths: - path: /shosts.equiv action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/**/chown' pattern. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPatterns: - pattern: /**/chown ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. applies the rule to files with the '/**/*.conf' pattern, ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPatterns: - pattern: /**/*.conf ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. applies the rule to files with the '/**/*ghostdog.sh' pattern, '/*ghostdog.sh' pattern, Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/chmod'. '/bin/sh'. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPatterns: - pattern: /**/*ghostdog.sh - pattern: /*ghostdog.sh process: matchPaths: - path: /usr/bin/chmod - path: /bin/sh action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/log/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. specifies a rule that matches a specific directory path '/dev/log/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /var/log/ recursive: true readOnly: true - dir: /dev/log/ recursive: true readOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/lib/mysql/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/var/lib/postgresql/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/etc/mysql/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/etc/postgres/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/var/log/mysql/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/var/log/postgresql/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /var/lib/mysql/ recursive: true - dir: /var/lib/postgresql/ recursive: true - dir: /etc/mysql/ recursive: true - dir: /etc/postgres/ recursive: true - dir: /var/log/mysql/ recursive: true - dir: /var/log/postgresql/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/**/qtp*' pattern. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/usr/bin/'. '/usr/local/bin/'. '/bin/'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/usr/bin/mvn'.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchDirectories: - dir: /usr/bin/ - dir: /usr/local/bin/ - dir: /bin/ fromSource: - path: /usr/bin/mvn matchPatterns: - pattern: /**/qtp* action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. applies the rule to files with the '/var/www/html/wp-content/uploads/**/*.php' pattern, '/var/www/html/wp-content/uploads/**/*.sh' pattern, Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPatterns: - pattern: /var/www/html/wp-content/uploads/**/*.php - pattern: /var/www/html/wp-content/uploads/**/*.sh action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/pwnkit/gconv-modules'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/pkexec'. '/pwnkit/pwnkit.c'. '/pwnkit/pwnkit.so'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/bin/pkexec - path: /pwnkit/pwnkit.c - path: /pwnkit/pwnkit.so file: matchPaths: - path: /pwnkit/gconv-modules action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. applies the rule to files with the '/**/databases.yml' pattern, Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPatterns: - pattern: /**/databases.yml action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/*/*/django-admin inspectdb*' pattern. '/*/*/django-admin inspectdb*' pattern. '/*/django-admin inspectdb*' pattern. '/django-admin inspectdb*' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPatterns: - pattern: /*/*/*/django-admin inspectdb* - pattern: /*/*/django-admin inspectdb* - pattern: /*/django-admin inspectdb* - pattern: /django-admin inspectdb* action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/root/.cache/pip/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /root/.cache/pip/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/local/lib/python2.7/dist-packages/pwnlib/shellcraft/templates/amd64/linux/syscalls/mprotect.asm'. '/usr/local/go/src/unsafe/unsafe.go'. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/usr/local/lib/python2.7/dist-packages/pwnlib/', specifies a rule that matches a specific directory path '/usr/lib/go-1.10/pkg/', specifies a rule that matches a specific directory path '/usr/lib/python3/dist-packages/', specifies a rule that matches a specific directory path '/usr/local/go/', Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/readlink'. '/usr/local/go/src/unsafe/unsafe.go'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/bin/readlink - path: /usr/local/go/src/unsafe/unsafe.go file: matchPaths: - path: /usr/local/lib/python2.7/dist-packages/pwnlib/shellcraft/templates/amd64/linux/syscalls/mprotect.asm - path: /usr/local/go/src/unsafe/unsafe.go matchDirectories: - dir: /usr/local/lib/python2.7/dist-packages/pwnlib/ - dir: /usr/lib/go-1.10/pkg/ - dir: /usr/lib/python3/dist-packages/ - dir: /usr/local/go/ action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. applies the rule to files with the '/**/httpd.conf' pattern, '/**/apache2.conf' pattern, Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPatterns: - pattern: /**/httpd.conf readOnly: false - pattern: /**/apache2.conf readOnly: false action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. applies the rule to files with the '/**/app.yaml' pattern, '/**/app.yml' pattern, '/**/application.yaml' pattern, '/**/application.yml' pattern, Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPatterns: - pattern: /**/app.yaml - pattern: /**/app.yml - pattern: /**/application.yaml - pattern: /**/application.yml action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/var/spool/cron/atjobs'. '/var/spool/cron/atspool'. '/proc/loadavg'. '/var/run/utmp'. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /var/spool/cron/atjobs - path: /var/spool/cron/atspool - path: /proc/loadavg - path: /var/run/utmp action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/*/*/*/nginx -s reload*' pattern. '/*/*/*/nginx -s reload*' pattern. '/*/*/nginx -s reload*' pattern. '/*/nginx -s reload*' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPatterns: - pattern: /*/*/*/*/nginx -s reload* - pattern: /*/*/*/nginx -s reload* - pattern: /*/*/nginx -s reload* - pattern: /*/nginx -s reload* action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/profile'. applies the rule to files with the '/**/.bash_profile' pattern, '/**/.bash_login' pattern, '/**/.profile' pattern, '/**/.bashrc' pattern, Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /etc/profile matchPatterns: - pattern: /**/.bash_profile - pattern: /**/.bash_login - pattern: /**/.profile - pattern: /**/.bashrc action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/log/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /var/log/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the network-related policies. In this case, rule applies to UDP network traffic. Specifies what to do when rules match, which means relevant network activities will be logged.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns network: matchProtocols: - protocol: udp action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/apt'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/apt'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/dpkg'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/dpkg'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/gdebi'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/gdebi'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/make'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/make'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/yum'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/yum'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/rpm'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/rpm'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/dnf'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/dnf'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/pacman'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/pacman'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/pacman'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/sbin/pacman'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/makepkg'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/makepkg'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/makepkg'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/sbin/makepkg'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/yaourt'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/yaourt'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/yaourt'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/sbin/yaourt'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/zypper'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/zypper'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/bin/apt ownerOnly: true - path: /bin/apt ownerOnly: true - path: /usr/bin/dpkg ownerOnly: true - path: /bin/dpkg ownerOnly: true - path: /usr/bin/gdebi ownerOnly: true - path: /bin/gdebi ownerOnly: true - path: /usr/bin/make ownerOnly: true - path: /bin/make ownerOnly: true - path: /usr/bin/yum ownerOnly: true - path: /bin/yum ownerOnly: true - path: /usr/bin/rpm ownerOnly: true - path: /bin/rpm ownerOnly: true - path: /usr/bin/dnf ownerOnly: true - path: /bin/dnf ownerOnly: true - path: /usr/bin/pacman ownerOnly: true - path: /usr/sbin/pacman ownerOnly: true - path: /bin/pacman ownerOnly: true - path: /sbin/pacman ownerOnly: true - path: /usr/bin/makepkg ownerOnly: true - path: /usr/sbin/makepkg ownerOnly: true - path: /bin/makepkg ownerOnly: true - path: /sbin/makepkg ownerOnly: true - path: /usr/bin/yaourt ownerOnly: true - path: /usr/sbin/yaourt ownerOnly: true - path: /bin/yaourt ownerOnly: true - path: /sbin/yaourt ownerOnly: true - path: /usr/bin/zypper ownerOnly: true - path: /bin/zypper ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/pam.conf'. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/pam.d/', recursive is disenabled, so the coverage will not extend. specifies a rule that matches a specific directory path '/var/lib/pam/', recursive is disenabled, so the coverage will not extend. specifies a rule that matches a specific directory path '/usr/lib/pam.d/', recursive is disenabled, so the coverage will not extend. specifies a rule that matches a specific directory path '/usr/lib/x86_64-linux-gnu/security/', recursive is disenabled, so the coverage will not extend. specifies a rule that matches a specific directory path '/usr/share/pam/', recursive is disenabled, so the coverage will not extend. specifies a rule that matches a specific directory path '/usr/share/pam-configs/', recursive is disenabled, so the coverage will not extend. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/pamfile'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/bin/pamfile file: matchPaths: - path: /etc/pam.conf readOnly: false matchDirectories: - dir: /etc/pam.d/ recursive: false readOnly: false - dir: /var/lib/pam/ recursive: false readOnly: false - dir: /usr/lib/pam.d/ recursive: false readOnly: false - dir: /usr/lib/x86_64-linux-gnu/security/ recursive: false readOnly: false - dir: /usr/share/pam/ recursive: false readOnly: false - dir: /usr/share/pam-configs/ recursive: false readOnly: false action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/*/tcpdump' pattern. '/*/tcpdump' pattern. '/*/*/nc' pattern. '/*/nc' pattern. '/*/*/ncat' pattern. '/*/ncat' pattern. '/*/*/nmap' pattern. '/*/nmap' pattern. '/*/*/dig' pattern. '/*/dig' pattern. '/*/*/tshark' pattern. '/*/tshark' pattern. '/*/*/ngrep' pattern. '/*/ngrep' pattern. '/*/*/telnet' pattern. '/*/telnet' pattern. '/*/*/mitmproxy' pattern. '/*/mitmproxy' pattern. '/*/*/socat' pattern. '/*/socat' pattern. '/*/*/zmap' pattern. '/*/zmap' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPatterns: - pattern: /*/*/tcpdump - pattern: /*/tcpdump - pattern: /*/*/nc - pattern: /*/nc - pattern: /*/*/ncat - pattern: /*/ncat - pattern: /*/*/nmap - pattern: /*/nmap - pattern: /*/*/dig - pattern: /*/dig - pattern: /*/*/tshark - pattern: /*/tshark - pattern: /*/*/ngrep - pattern: /*/ngrep - pattern: /*/*/telnet - pattern: /*/telnet - pattern: /*/*/mitmproxy - pattern: /*/mitmproxy - pattern: /*/*/socat - pattern: /*/socat - pattern: /*/*/zmap - pattern: /*/zmap action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/lib/mysql/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /var/lib/mysql/ recursive: true readOnly: false action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/bin/pg_dump'. '/usr/bin/pg_upgrade'. '/usr/bin/pg_dumpall'. '/usr/bin/pg_upgradecluster'. '/usr/lib/postgresql/13/bin/pg_dump'. '/usr/lib/postgresql/13/bin/pg_upgrade'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/pg_dump'. '/usr/bin/pg_dumpall'. '/usr/bin/pg_upgradecluster'. '/usr/bin/pg_upgrade'. '/usr/lib/postgresql/13/bin/pg_dump'. '/usr/lib/postgresql/13/bin/pg_upgrade'. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/bin/pg_dump - path: /usr/bin/pg_dumpall - path: /usr/bin/pg_upgradecluster - path: /usr/bin/pg_upgrade - path: /usr/lib/postgresql/13/bin/pg_dump - path: /usr/lib/postgresql/13/bin/pg_upgrade file: matchPaths: - path: /usr/bin/pg_dump - path: /usr/bin/pg_upgrade - path: /usr/bin/pg_dumpall - path: /usr/bin/pg_upgradecluster - path: /usr/lib/postgresql/13/bin/pg_dump - path: /usr/lib/postgresql/13/bin/pg_upgrade action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/psql'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/psql'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/share/postgresql-common/pg_wrapper'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/bin/psql ownerOnly: true - path: /bin/psql ownerOnly: true - path: /usr/share/postgresql-common/pg_wrapper ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/readwrite', Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns - WARNING file: matchDirectories: - dir: /credentials/ readOnly: true fromSource: - path: /readwrite action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/proc/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/lib/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/sys/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/pts/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Allow' allows access to the matching file. Specifies a rule that matches a specific file absolute path '/root/.bashrc'. '/root/.bash_history'. '/home/user1/.profile'. '/home/user1/.bashrc'. '/run/utmp'. '/dev/tty'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/home/user1/hello'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/usr/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies the action to take when rules match, in which case the 'Allow' action allows the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /home/user1/hello ownerOnly: true matchDirectories: - dir: /bin/ recursive: true - dir: /usr/bin/ recursive: true file: matchPaths: - path: /root/.bashrc - path: /root/.bash_history - path: /home/user1/.profile - path: /home/user1/.bashrc - path: /run/utmp - path: /dev/tty matchDirectories: - dir: /etc/ recursive: true - dir: /proc/ recursive: true - dir: /lib/ recursive: true - dir: /sys/ recursive: true - dir: /pts/ recursive: true action: Allow

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchDirectories: - dir: /credentials/ action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/credentials/password'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source '/readwrite'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPaths: - path: /credentials/password readOnly: true fromSource: - path: /readwrite action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/root/.bashrc'. '/root/.bash_history'. '/dev/tty'. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. specifies a rule that matches a specific directory path '/etc/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/proc/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Allow' allows access to the matching file. defines rules related to processes running in the selected pods. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/bin/'. Specifies the action to take when rules match, in which case the 'Allow' action allows the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchDirectories: - dir: /bin/ file: matchPaths: - path: /root/.bashrc - path: /root/.bash_history - path: /dev/tty matchDirectories: - dir: /credentials/ recursive: true readOnly: true - dir: /etc/ recursive: true - dir: /proc/ recursive: true action: Allow

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines the policy related to file access. applies the rule to files with the '/**/ZendApp/admin/configs/application.ini' pattern, '/**/ZendApp/module/Application/config/application.ini' pattern, '/**/application.ini' pattern, '/**/aplicacao/application/configs/application.ini' pattern, '/**/cloudexp/application/configs/application.ini' pattern, '/**/cms/application/configs/application.ini' pattern, '/**/moto/application/configs/application.iniZendApp/admin/configs/application.ini' pattern, '/**/moto/application/configs/application.ini' pattern, '/**/Partners/application/configs/application.ini' pattern, '/**/radio/application/configs/application.ini' pattern, '/**/seminovos/application/configs/application.ini' pattern, '/**/shop/application/configs/application.ini' pattern, '/**/site_cg/application/configs/application.iniradio/application/configs/application.ini' pattern, '/**/slr/application/configs/application.ini' pattern, Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns file: matchPatterns: - pattern: /**/ZendApp/admin/configs/application.ini - pattern: /**/ZendApp/module/Application/config/application.ini - pattern: /**/application.ini - pattern: /**/aplicacao/application/configs/application.ini - pattern: /**/cloudexp/application/configs/application.ini - pattern: /**/cms/application/configs/application.ini - pattern: /**/moto/application/configs/application.iniZendApp/admin/configs/application.ini - pattern: /**/moto/application/configs/application.ini - pattern: /**/Partners/application/configs/application.ini - pattern: /**/radio/application/configs/application.ini - pattern: /**/seminovos/application/configs/application.ini - pattern: /**/shop/application/configs/application.ini - pattern: /**/site_cg/application/configs/application.iniradio/application/configs/application.ini - pattern: /**/slr/application/configs/application.ini action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/sbin/'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchDirectories: - dir: /sbin/ action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'k8s-app: kube-dns'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/chmod'. '/usr/bin/chown'. '/bin/chmod'. '/bin/chown'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: k8s-app: kube-dns process: matchPaths: - path: /usr/bin/chmod - path: /usr/bin/chown - path: /bin/chmod - path: /bin/chown action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines rules related to system calls. specifies a rule for system calls directed to a specific directory path or the absolute executable path The corresponding system call is 'rmdir'. if a path is specified in fromSource, kubearmor will match only syscalls generated by the defined source. That is, only system calls generated by '/home/' exectuable path will be matched. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching system calls.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia syscalls: matchPaths: - syscall: - rmdir fromSource: - path: /home/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/local/tomcat/conf/server.xml'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPaths: - path: /usr/local/tomcat/conf/server.xml ownerOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/modprobe.d/udf.conf'. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source '/bin/false'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPaths: - path: /etc/modprobe.d/udf.conf fromSource: - path: /bin/false readOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/data/db/auditLog.json'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/data/db/auditLog.bson'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPaths: - path: /data/db/auditLog.json ownerOnly: true - path: /data/db/auditLog.bson ownerOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/proc/*/environ' pattern. '/*/grep MYSQL_PWD /proc/*/environ' pattern. '/*/*/grep MYSQL_PWD /proc/*/environ' pattern. '/*/*/*/grep MYSQL_PWD /proc/*/environ' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchPatterns: - pattern: /proc/*/environ - pattern: /*/grep MYSQL_PWD /proc/*/environ - pattern: /*/*/grep MYSQL_PWD /proc/*/environ - pattern: /*/*/*/grep MYSQL_PWD /proc/*/environ action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/home/user1/secret_data1.txt'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/root/.bashrc'. '/root/.bash_history'. '/home/user1/.profile'. '/home/user1/.bashrc'. '/run/utmp'. '/dev/tty'. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/proc/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Allow' allows access to the matching file. defines rules related to processes running in the selected pods. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/usr/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies the action to take when rules match, in which case the 'Allow' action allows the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchDirectories: - dir: /bin/ recursive: true - dir: /usr/bin/ recursive: true file: matchPaths: - path: /home/user1/secret_data1.txt readOnly: true ownerOnly: true - path: /root/.bashrc - path: /root/.bash_history - path: /home/user1/.profile - path: /home/user1/.bashrc - path: /run/utmp - path: /dev/tty matchDirectories: - dir: /etc/ recursive: true - dir: /proc/ recursive: true action: Allow

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/ls'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/bin/dash'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchPaths: - path: /bin/ls fromSource: - path: /bin/dash action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines rules related to processes running in the selected pods. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/sbin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchDirectories: - dir: /sbin/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/issue'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. '/etc/issue.net'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. '/etc/hosts'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. '/etc/sysconfig/network'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPaths: - path: /etc/issue readOnly: true - path: /etc/issue.net readOnly: true - path: /etc/hosts readOnly: true - path: /etc/sysconfig/network readOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchDirectories: - dir: /etc/ readOnly: true recursive: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/nginx/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchDirectories: - dir: /etc/nginx/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/ssl/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/etc/pki/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/usr/local/share/ca-certificates/', If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchDirectories: - dir: /etc/ssl/ readOnly: true recursive: true - dir: /etc/pki/ readOnly: true recursive: true - dir: /usr/local/share/ca-certificates/ readOnly: true recursive: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines rules related to processes running in the selected pods. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/sbin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchDirectories: - dir: /sbin/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/apt'. '/usr/bin/apt-get'. '/bin/apt-get'. '/sbin/apk'. '/bin/apt'. '/usr/bin/dpkg'. '/bin/dpkg'. '/usr/bin/gdebi'. '/bin/gdebi'. '/usr/bin/make'. '/bin/make'. '/usr/bin/yum'. '/bin/yum'. '/usr/bin/rpm'. '/bin/rpm'. '/usr/bin/dnf'. '/bin/dnf'. '/usr/bin/pacman'. '/usr/sbin/pacman'. '/bin/pacman'. '/sbin/pacman'. '/usr/bin/makepkg'. '/usr/sbin/makepkg'. '/bin/makepkg'. '/sbin/makepkg'. '/usr/bin/yaourt'. '/usr/sbin/yaourt'. '/bin/yaourt'. '/sbin/yaourt'. '/usr/bin/zypper'. '/bin/zypper'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchPaths: - path: /usr/bin/apt - path: /usr/bin/apt-get - path: /bin/apt-get - path: /sbin/apk - path: /bin/apt - path: /usr/bin/dpkg - path: /bin/dpkg - path: /usr/bin/gdebi - path: /bin/gdebi - path: /usr/bin/make - path: /bin/make - path: /usr/bin/yum - path: /bin/yum - path: /usr/bin/rpm - path: /bin/rpm - path: /usr/bin/dnf - path: /bin/dnf - path: /usr/bin/pacman - path: /usr/sbin/pacman - path: /bin/pacman - path: /sbin/pacman - path: /usr/bin/makepkg - path: /usr/sbin/makepkg - path: /bin/makepkg - path: /sbin/makepkg - path: /usr/bin/yaourt - path: /usr/sbin/yaourt - path: /bin/yaourt - path: /sbin/yaourt - path: /usr/bin/zypper - path: /bin/zypper action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/bin/', When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/bin/rm', specifies a rule that matches a specific directory path '/root/', When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/bin/rm', specifies a rule that matches a specific directory path '/home/', When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/bin/rm', specifies a rule that matches a specific directory path '/etc/', When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/bin/rm', Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/chsh'. '/bin/chmod'. '/bin/chown'. '/bin/chgrp'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchPaths: - path: /usr/bin/chsh - path: /bin/chmod - path: /bin/chown - path: /bin/chgrp file: matchDirectories: - dir: /bin/ fromSource: - path: /bin/rm - dir: /root/ fromSource: - path: /bin/rm - dir: /home/ fromSource: - path: /bin/rm - dir: /etc/ fromSource: - path: /bin/rm action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/log/elasticsearch/',

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchDirectories: - dir: /var/log/elasticsearch/ action: audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/usr/local/go/src/regexp/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchDirectories: - dir: /usr/local/go/src/regexp/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/**/mysql*' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchPatterns: - pattern: /**/mysql* action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/cups/', specifies a rule that matches a specific directory path '/etc/xdg/', specifies a rule that matches a specific directory path '/etc/ssh/', specifies a rule that matches a specific directory path '/etc/apparmor.d/', specifies a rule that matches a specific directory path '/etc/udev/', specifies a rule that matches a specific directory path '/etc/x11/', specifies a rule that matches a specific directory path '/etc/opt/', Specifies a rule that matches a specific file absolute path '/etc/resolv.conf'. '/etc/bash.bashrc'. '/etc/profile'. '/etc/dhcp/dhclient.conf'. '/etc/fstab'. '/etc/hostname'. '/etc/hosts'. '/etc/hosts.deny'. '/etc/mime.type'. '/etc/motd'. '/etc/timezone'. '/etc/sudoers'. '/etc/httpd/conf'. '/etc/httpd.conf.d'. '/etc/default/grub'. '/boot/grub/grub.cfg'. '/boot/grub/grub.cfg'. '/etc/default/grub'. applies the rule to files with the '/home/**/.config' pattern, '/home/**/.xinitrc' pattern, '/home/**/.vimrc' pattern, '/home/**/.bashrc' pattern, '/home/**/.editor' pattern, '/home/**/.gitconfig' pattern, '/home/**/.profile' pattern, '/home/**/.ssh/config' pattern, Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchDirectories: - dir: /etc/cups/ - dir: /etc/xdg/ - dir: /etc/ssh/ - dir: /etc/apparmor.d/ - dir: /etc/udev/ - dir: /etc/x11/ - dir: /etc/opt/ matchPaths: - path: /etc/resolv.conf - path: /etc/bash.bashrc - path: /etc/profile - path: /etc/dhcp/dhclient.conf - path: /etc/fstab - path: /etc/hostname - path: /etc/hosts - path: /etc/hosts.deny - path: /etc/mime.type - path: /etc/motd - path: /etc/timezone - path: /etc/sudoers - path: /etc/httpd/conf - path: /etc/httpd.conf.d - path: /etc/default/grub - path: /boot/grub/grub.cfg - path: /boot/grub/grub.cfg - path: /etc/default/grub matchPatterns: - pattern: /home/**/.config - pattern: /home/**/.xinitrc - pattern: /home/**/.vimrc - pattern: /home/**/.bashrc - pattern: /home/**/.editor - pattern: /home/**/.gitconfig - pattern: /home/**/.profile - pattern: /home/**/.ssh/config action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/dconf/db/local.d/00-disable-CAD'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPaths: - path: /etc/dconf/db/local.d/00-disable-CAD action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. applies the rule to files with the '/**/confluence/WEB-INF/lib/xwork-1.0.3-atlassian-8.jar' pattern, '/**/confluence/WEB-INF/lib/xwork-1.0.3.6.jar' pattern, '/**/confluence/WEB-INF/lib/webwork-2.1.5-atlassian-3.jar' pattern, Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file. defines rules related to processes running in the selected pods. applies the rule to processes with the '/**/confluence/WEB-INF/lib/xwork-1.0.3-atlassian-8.jar' pattern. '/**/confluence/WEB-INF/lib/xwork-1.0.3.6.jar' pattern. '/**/confluence/WEB-INF/lib/webwork-2.1.5-atlassian-3.jar' pattern. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPatterns: - pattern: /**/confluence/WEB-INF/lib/xwork-1.0.3-atlassian-8.jar - pattern: /**/confluence/WEB-INF/lib/xwork-1.0.3.6.jar - pattern: /**/confluence/WEB-INF/lib/webwork-2.1.5-atlassian-3.jar process: matchPatterns: - pattern: /**/confluence/WEB-INF/lib/xwork-1.0.3-atlassian-8.jar - pattern: /**/confluence/WEB-INF/lib/xwork-1.0.3.6.jar - pattern: /**/confluence/WEB-INF/lib/webwork-2.1.5-atlassian-3.jar action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/storage/vcops/user/conf/ssl/tcserver.truststore'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPaths: - path: /storage/vcops/user/conf/ssl/tcserver.truststore readOnly: true ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/sql/sql_type.cc'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPaths: - path: /sql/sql_type.cc action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/init/control-alt-delete.conf'. '/etc/init/control-alt-delete.override'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPaths: - path: /etc/init/control-alt-delete.conf - path: /etc/init/control-alt-delete.override action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/mysql/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchDirectories: - dir: /etc/mysql/ recursive: true ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/gdm/custom.conf'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPaths: - path: /etc/gdm/custom.conf action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. applies the rule to files with the '/**/*.conf' pattern, ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPatterns: - pattern: /**/*.conf ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/cd'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchPaths: - path: /bin/cd action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/**'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/usr/bin/netcat'. apply rules to the executable processes at paths '/usr/bin/**'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/usr/bin/nc'. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia process: matchPaths: - path: /usr/bin/** fromSource: - path: /usr/bin/netcat - path: /usr/bin/** fromSource: - path: /usr/bin/nc action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: saia'. defines the policy related to file access. applies the rule to files with the '/**/ua-parser.js' pattern, ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: saia file: matchPatterns: - pattern: /**/ua-parser.js ownerOnly: true action: Block