Datasets:

H836

/

system

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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/var/www/html/wp-content/uploads/**/*.php' 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. apply rules to the executable processes at paths '/bin/sh'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/usr/sbin/apache2'. 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: container: ubuntu-1 process: matchPaths: - path: /bin/sh fromSource: - path: /usr/sbin/apache2 file: matchPatterns: - pattern: /var/www/html/wp-content/uploads/**/*.php 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 'container: ubuntu-1'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/www/html/wp-content/uploads/workreap-temp/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. ownerOnly in disenabled, so any user can access this file. applies the rule to files with the '/**/wp-content/uploads/workreap-temp/' pattern, ownerOnly in disenabled, so any user can access this file. '/**/**/wp-content/uploads/workreap-temp/' pattern, ownerOnly in disenabled, so any user can access this file. 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. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/www/html/wp-content/uploads/workreap-temp/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. ownerOnly in disenabled, so any user can access this file. applies the rule to processes with the '/**/wp-content/uploads/workreap-temp/' pattern. ownerOnly in disenabled, so any user can access this file. '/**/**/wp-content/uploads/workreap-temp/' pattern. ownerOnly in disenabled, so any user can access this file. 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: container: ubuntu-1 process: matchDirectories: - dir: /var/www/html/wp-content/uploads/workreap-temp/ recursive: true ownerOnly: false matchPatterns: - pattern: /**/wp-content/uploads/workreap-temp/ ownerOnly: false - pattern: /**/**/wp-content/uploads/workreap-temp/ ownerOnly: false file: matchDirectories: - dir: /var/www/html/wp-content/uploads/workreap-temp/ readOnly: false recursive: true ownerOnly: false matchPatterns: - pattern: /**/wp-content/uploads/workreap-temp/ readOnly: false ownerOnly: false - pattern: /**/**/wp-content/uploads/workreap-temp/ readOnly: false ownerOnly: 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/**/initial.php' 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 '/**/curl' pattern. '/**/bash' 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: container: ubuntu-1 file: matchPatterns: - pattern: /**/initial.php process: matchPatterns: - pattern: /**/curl - pattern: /**/bash 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/**/WEB-INF/*' pattern, '/**/WEB-INF/*.*' 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: container: ubuntu-1 file: matchPatterns: - pattern: /**/WEB-INF/* - pattern: /**/WEB-INF/*.* 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/local/lib/python2.7/site-packages/django/core/files/uploadedfile.py'. '/usr/local/lib/python2.7/site-packages/django/core/files/uploadhandler.py'. '/usr/local/lib/python2.7/site-packages/django/http/multipartparser.py'. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/usr/local/lib/python2.7/dist-packages/django/', specifies a rule that matches a specific directory path '/usr/local/lib/python2.7/dist-packages/django/core/', specifies a rule that matches a specific directory path '/usr/local/lib/python2.7/dist-packages/django/conf/', specifies a rule that matches a specific directory path '/usr/local/lib/python2.7/dist-packages/', Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /usr/local/lib/python2.7/site-packages/django/core/files/uploadedfile.py - path: /usr/local/lib/python2.7/site-packages/django/core/files/uploadhandler.py - path: /usr/local/lib/python2.7/site-packages/django/http/multipartparser.py matchDirectories: - dir: /usr/local/lib/python2.7/dist-packages/django/ - dir: /usr/local/lib/python2.7/dist-packages/django/core/ - dir: /usr/local/lib/python2.7/dist-packages/django/conf/ - dir: /usr/local/lib/python2.7/dist-packages/ 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/pydoc'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/pydoc'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. applies the rule to processes with the '/usr/bin/pydoc*' pattern. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/pydoc*' 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/pydoc ownerOnly: true - path: /bin/pydoc ownerOnly: true matchPatterns: - pattern: /usr/bin/pydoc* ownerOnly: true - pattern: /bin/pydoc* 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/**/files.md5' 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: container: ubuntu-1 file: matchPatterns: - pattern: /**/files.md5 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/passwd'. '/etc/shadow'. 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 '/src/server'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /etc/passwd - path: /etc/shadow fromSource: - path: /src/server 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/**/*' pattern, similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/app/', 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/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. 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 '/usr/sbin/addgroup', 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. 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 '/usr/sbin/adduser', 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 '/app/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/opt/java/openjdk/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/usr/local/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. '/usr/glibc-compat/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: container: ubuntu-1 file: matchPatterns: - pattern: /**/* process: matchDirectories: - dir: /app/ recursive: true - dir: /opt/java/openjdk/bin/ recursive: true - dir: /bin/ recursive: true - dir: /usr/local/bin/ recursive: true - dir: /usr/bin/ recursive: true - dir: /usr/glibc-compat/bin/ recursive: true file: matchDirectories: - dir: /app/ recursive: true - dir: /etc/ recursive: true fromSource: - path: /usr/sbin/addgroup - dir: /etc/ recursive: true fromSource: - path: /usr/sbin/adduser 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 'container: ubuntu-1'. 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 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. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/usr/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/usr/local/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/usr/sbin/apache2'. 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: container: ubuntu-1 process: matchDirectories: - dir: /usr/bin/ recursive: true - dir: /usr/local/bin/ recursive: true - dir: /bin/ recursive: true fromSource: - path: /usr/sbin/apache2 file: matchDirectories: - dir: /etc/ 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/**/glpi/plugins/barcode/front/send.php' 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: container: ubuntu-1 file: matchPatterns: - pattern: /**/glpi/plugins/barcode/front/send.php 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 'container: ubuntu-1'. defines the policy related Linux capabilities. apply the rule to the capability name 'sys_admin'. Specifies what to do when rules match, in this case, the 'Block' action blocks the matching capability behavior.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 capabilities: matchCapabilities: - capability: sys_admin 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/hostname'. '/etc/hosts.allow'. '/etc/hosts'. '/etc/lsb-release'. '/etc/networks'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /etc/hostname - path: /etc/hosts.allow - path: /etc/hosts - path: /etc/lsb-release - path: /etc/networks 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. 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 '/usr/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/usr/local/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 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 process: matchDirectories: - dir: /usr/bin/ recursive: true - dir: /bin/ recursive: true - dir: /usr/local/bin/ 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/docker'. '/usr/bin/cri-ctl'. '/usr/bin/kubectl'. applies the rule to processes with the '/*/*/*/kubectl' pattern. '/*/*/kubectl' pattern. '/*/kubectl' pattern. '/*/*/*/cri-ctl' pattern. '/*/*/cri-ctl' pattern. '/*/cri-ctl' pattern. '/*/*/*/docker' pattern. '/*/*/docker' pattern. '/*/docker' 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/docker - path: /usr/bin/cri-ctl - path: /usr/bin/kubectl matchPatterns: - pattern: /*/*/*/kubectl - pattern: /*/*/kubectl - pattern: /*/kubectl - pattern: /*/*/*/cri-ctl - pattern: /*/*/cri-ctl - pattern: /*/cri-ctl - pattern: /*/*/*/docker - pattern: /*/*/docker - pattern: /*/docker 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/id'. '/usr/bin/groups'. '/usr/bin/net'. '/usr/bin/finger'. '/usr/bin/getent'. '/usr/bin/lslogins'. '/usr/bin/users'. '/usr/bin/w'. '/usr/bin/last'. '/usr/bin/lastlog'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/id - path: /usr/bin/groups - path: /usr/bin/net - path: /usr/bin/finger - path: /usr/bin/getent - path: /usr/bin/lslogins - path: /usr/bin/users - path: /usr/bin/w - path: /usr/bin/last - path: /usr/bin/lastlog 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/ps'. '/usr/bin/ps'. '/usr/bin/pgrep'. '/usr/bin/top'. '/usr/bin/htop'. 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: container: ubuntu-1 process: matchPaths: - path: /bin/ps - path: /usr/bin/ps - path: /usr/bin/pgrep - path: /usr/bin/top - path: /usr/bin/htop 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/*/*/django-admin check*' pattern. '/*/*/django-admin check*' pattern. '/*/django-admin check*' pattern. '/django-admin check*' 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: container: ubuntu-1 process: matchPatterns: - pattern: /*/*/*/django-admin check* - pattern: /*/*/django-admin check* - pattern: /*/django-admin check* - pattern: /django-admin check* 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/*/*/django-admin dbshell*' pattern. '/*/*/django-admin dbshell*' pattern. '/*/django-admin dbshell*' pattern. '/django-admin dbshell*' 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: container: ubuntu-1 process: matchPatterns: - pattern: /*/*/*/django-admin dbshell* - pattern: /*/*/django-admin dbshell* - pattern: /*/django-admin dbshell* - pattern: /django-admin dbshell* 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/*/*/django-admin dumpdata*' pattern. '/*/*/django-admin dumpdata*' pattern. '/*/django-admin dumpdata*' pattern. '/django-admin dumpdata*' 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: container: ubuntu-1 process: matchPatterns: - pattern: /*/*/*/django-admin dumpdata* - pattern: /*/*/django-admin dumpdata* - pattern: /*/django-admin dumpdata* - pattern: /django-admin dumpdata* 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/*/*/python -m pip install*' pattern. '/*/*/python -m pip install*' pattern. '/*/python -m pip install*' pattern. '/*/*/*/pip install*' pattern. '/*/*/pip install*' pattern. '/*/pip install*' 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: container: ubuntu-1 process: matchPatterns: - pattern: /*/*/*/python -m pip install* - pattern: /*/*/python -m pip install* - pattern: /*/python -m pip install* - pattern: /*/*/*/pip install* - pattern: /*/*/pip install* - pattern: /*/pip install* 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/*/*/*/*/settings.py*' pattern, '/*/*/*/settings.py*' pattern, '/*/*/settings.py*' pattern, '/*/settings.py*' 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: container: ubuntu-1 file: matchPatterns: - pattern: /*/*/*/*/settings.py* - pattern: /*/*/*/settings.py* - pattern: /*/*/settings.py* - pattern: /*/settings.py* 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/*/*/*/*/urls.py*' pattern, '/*/*/*/urls.py*' pattern, '/*/*/urls.py*' pattern, '/*/urls.py*' 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: container: ubuntu-1 file: matchPatterns: - pattern: /*/*/*/*/urls.py* - pattern: /*/*/*/urls.py* - pattern: /*/*/urls.py* - pattern: /*/urls.py* 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/mgmt/tm/util/bash'. 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: container: ubuntu-1 process: matchPaths: - path: /mgmt/tm/util/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 'container: ubuntu-1'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/src/static/.git/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. applies the rule to files with the '/**/.git/' pattern, '/**/.git/*' pattern, '/**/.git/*.*' pattern, '/**/.git/**/*.*' 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: container: ubuntu-1 file: matchDirectories: - dir: /src/static/.git/ recursive: true matchPatterns: - pattern: /**/.git/ - pattern: /**/.git/* - pattern: /**/.git/*.* - pattern: /**/.git/**/*.* 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/conf/defaults.ini'. '/conf/grafana.ini'. '/etc/grafana/grafana.ini'. '/etc/grafana/defaults.ini'. '/etc/passwd'. '/etc/shadow'. '/home/grafana/.bash_history'. '/home/grafana/.ssh/id_rsa'. '/root/.bash_history'. '/root/.ssh/id_rsa'. '/usr/local/etc/grafana/grafana.ini'. '/var/lib/grafana/grafana.db'. applies the rule to files with the '/**/public/plugins/alertlist/etc/passwd' 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. apply rules to the executable processes at paths '/proc/net/fib_trie'. '/proc/net/tcp'. '/proc/self/cmdline'. 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: container: ubuntu-1 file: matchPaths: - path: /conf/defaults.ini - path: /conf/grafana.ini - path: /etc/grafana/grafana.ini - path: /etc/grafana/defaults.ini - path: /etc/passwd - path: /etc/shadow - path: /home/grafana/.bash_history - path: /home/grafana/.ssh/id_rsa - path: /root/.bash_history - path: /root/.ssh/id_rsa - path: /usr/local/etc/grafana/grafana.ini - path: /var/lib/grafana/grafana.db matchPatterns: - pattern: /**/public/plugins/alertlist/etc/passwd process: matchPaths: - path: /proc/net/fib_trie - path: /proc/net/tcp - path: /proc/self/cmdline 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/sleep'. 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: container: ubuntu-1 process: matchPaths: - path: /bin/sleep 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. 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 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /secret.txt fromSource: - path: /bin/cat 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 'container: ubuntu-1'. 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 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /secret.txt 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 'container: ubuntu-1'. 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. 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 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /home/user1/secret_data1.txt ownerOnly: true fromSource: - path: /bin/cat 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 'container: ubuntu-1'. 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. 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: container: ubuntu-1 file: matchPaths: - path: /home/user1/secret_data1.txt ownerOnly: true 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/sleep'. 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: container: ubuntu-1 process: matchPaths: - path: /bin/sleep 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/**/.htpasswd' 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 '/**/htpasswd' 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: container: ubuntu-1 file: matchPatterns: - pattern: /**/.htpasswd process: matchPatterns: - pattern: /**/htpasswd 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/selinux/semanage.conf'. '/etc/sysconfig/selinux'. '/etc/apparmor.d'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /etc/selinux/semanage.conf - path: /etc/sysconfig/selinux - path: /etc/apparmor.d 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/**/.env' pattern, '/**/.env.dev.local' pattern, '/**/.env.development.local' pattern, '/**/.env.prod.local' pattern, '/**/.env.production.local' pattern, '/**/.env.local' pattern, '/**/.env.example' pattern, '/**/.env.stage' pattern, '/**/.env.live' pattern, '/**/.env.backup' pattern, '/**/.env.save' pattern, '/**/.env.old' pattern, '/**/.env_1' pattern, '/**/.env_sample' pattern, '/**/api/.env' 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: container: ubuntu-1 file: matchPatterns: - pattern: /**/.env - pattern: /**/.env.dev.local - pattern: /**/.env.development.local - pattern: /**/.env.prod.local - pattern: /**/.env.production.local - pattern: /**/.env.local - pattern: /**/.env.example - pattern: /**/.env.stage - pattern: /**/.env.live - pattern: /**/.env.backup - pattern: /**/.env.save - pattern: /**/.env.old - pattern: /**/.env_1 - pattern: /**/.env_sample - pattern: /**/api/.env 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/**/storage/logs/laravel.log' 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: container: ubuntu-1 file: matchPatterns: - pattern: /**/storage/logs/laravel.log 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines the policy related to file access. applies the rule to files with the '/**/service.pwd' 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: container: ubuntu-1 file: matchPatterns: - pattern: /**/service.pwd 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/sbin/groupdel'. '/usr/sbin/userdel'. '/usr/sbin/chgpasswd'. '/usr/sbin/groupmod0o'. '/usr/sbin/groupadd'. '/usr/sbin/newusers'. '/usr/sbin/chpasswd'. '/usr/sbin/usermod'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/sbin/groupdel - path: /usr/sbin/userdel - path: /usr/sbin/chgpasswd - path: /usr/sbin/groupmod0o - path: /usr/sbin/groupadd - path: /usr/sbin/newusers - path: /usr/sbin/chpasswd - path: /usr/sbin/usermod 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/tmp/kdevtmpfsi'. '/var/tmp/kinsing'. '/tmp/zzz'. 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 '/tmp/kdevtmpfsi'. '/var/tmp/kinsing'. 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: container: ubuntu-1 process: matchPaths: - path: /tmp/kdevtmpfsi - path: /var/tmp/kinsing file: matchPaths: - path: /tmp/kdevtmpfsi - path: /var/tmp/kinsing - path: /tmp/zzz 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/ping'. 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: container: ubuntu-1 process: matchPaths: - path: /bin/ping 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 'container: ubuntu-1'. 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. apply rules to the executable processes at paths '/usr/sbin/adduser'. '/usr/sbin/useradd'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/sbin/adduser - path: /usr/sbin/useradd file: matchPaths: - path: /etc/passwd - path: /etc/shadow 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/var/log/wtmp'. '/var/run/utmp'. '/var/log/auth.log'. '/etc/passwd'. '/etc/shadow'. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/ssh/', Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /var/log/wtmp - path: /var/run/utmp - path: /var/log/auth.log - path: /etc/passwd - path: /etc/shadow matchDirectories: - dir: /etc/ssh/ 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/mv'. '/bin/cp'. '/bin/rm'. '/bin/rmdir'. '/bin/ls'. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/lib/postgresql/data/'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/usr/lib/postgresql/14/bin/postgres'. 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: container: ubuntu-1 process: matchPaths: - path: /bin/mv - path: /bin/cp - path: /bin/rm - path: /bin/rmdir - path: /bin/ls matchDirectories: - dir: /var/lib/postgresql/data/ fromSource: - path: /usr/lib/postgresql/14/bin/postgres 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/passwd'. '/etc/passwd-'. '/etc/shadow'. '/etc/shadow-'. 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 '/etc'. 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 '/etc/passwd'. '/etc/passwd-'. '/etc/shadow'. '/etc/shadow-'. 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: container: ubuntu-1 process: matchPaths: - path: /etc/passwd - path: /etc/passwd- - path: /etc/shadow - path: /etc/shadow- file: matchPaths: - path: /etc/passwd - path: /etc/passwd- - path: /etc/shadow - path: /etc/shadow- fromSource: - path: /etc 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/bin/pg_ctlcluster'. '/var/log/postgresql'. '/usr/lib/postgresql/13/bin/pg_ctl'. 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 '/usr'. '/lib'. '/var'. 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/pg_ctlcluster'. '/var/log/postgresql'. '/usr/lib/postgresql/13/bin/pg_ctl'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/pg_ctlcluster - path: /var/log/postgresql - path: /usr/lib/postgresql/13/bin/pg_ctl file: matchPaths: - path: /usr/bin/pg_ctlcluster - path: /var/log/postgresql - path: /usr/lib/postgresql/13/bin/pg_ctl fromSource: - path: /usr - path: /lib - path: /var 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 'container: ubuntu-1'. 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. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /etc/mysql/my.cnf 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/netstat'. '/bin/netstat'. '/usr/sbin/ip'. '/usr/bin/ip'. '/sbin/ip'. '/bin/ip'. '/usr/sbin/iw'. '/sbin/iw'. '/usr/sbin/ethtool'. '/sbin/ethtool'. '/usr/sbin/ifconfig'. '/sbin/ifconfig'. '/usr/sbin/arp'. '/sbin/arp'. '/usr/sbin/iwconfig'. '/sbin/iwconfig'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/netstat - path: /bin/netstat - path: /usr/sbin/ip - path: /usr/bin/ip - path: /sbin/ip - path: /bin/ip - path: /usr/sbin/iw - path: /sbin/iw - path: /usr/sbin/ethtool - path: /sbin/ethtool - path: /usr/sbin/ifconfig - path: /sbin/ifconfig - path: /usr/sbin/arp - path: /sbin/arp - path: /usr/sbin/iwconfig - path: /sbin/iwconfig 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 'container: ubuntu-1'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/rc0.d/', specifies a rule that matches a specific directory path '/etc/rc1.d/', specifies a rule that matches a specific directory path '/etc/rc2.d/', specifies a rule that matches a specific directory path '/etc/rcS.d/', Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchDirectories: - dir: /etc/rc0.d/ - dir: /etc/rc1.d/ - dir: /etc/rc2.d/ - dir: /etc/rcS.d/ 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/rm'. '/usr/bin/unlink'. '/usr/bin/rmdir'. applies the rule to processes with the '/**/rm' pattern. '/**/rmdir' pattern. '/**/unlink' 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/rm - path: /usr/bin/unlink - path: /usr/bin/rmdir matchPatterns: - pattern: /**/rm - pattern: /**/rmdir - pattern: /**/unlink 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 'container: ubuntu-1'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/run/secrets/kubernetes.io/serviceaccount/', 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. Specifies a rule that matches a specific file absolute path '/etc/hostname'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/bin/hostname'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/env'. 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: container: ubuntu-1 process: matchPaths: - path: /bin/hostname ownerOnly: true - path: /usr/bin/env ownerOnly: true file: matchPaths: - path: /etc/hostname ownerOnly: true matchDirectories: - dir: /var/run/secrets/kubernetes.io/serviceaccount/ 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/docker'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/docker 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/root/.bash_history'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /root/.bash_history 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 'container: ubuntu-1'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/usr/local/share/ca-certificates/', 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. Specifies a rule that matches a specific file absolute path '/etc/ca-certificates.conf'.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /etc/ca-certificates.conf matchDirectories: - dir: /usr/local/share/ca-certificates/ 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/certutil'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/certutil 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/nc' pattern. '/*/*/nc' pattern. '/*/ncat' pattern. '/*/*/ncat' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process. apply rules to the executable processes at paths '/usr/bin/nc'. '/usr/bin/ncat'.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 process: matchPaths: - path: /usr/bin/nc - path: /usr/bin/ncat matchPatterns: - pattern: /*/nc - pattern: /*/*/nc - pattern: /*/ncat - pattern: /*/*/ncat 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/sbin/insmod'. '/usr/sbin/modprobe'. '/usr/sbin/rmmod'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/sbin/insmod - path: /usr/sbin/modprobe - path: /usr/sbin/rmmod 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. 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 what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchDirectories: - dir: /var/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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/dev/bus/usb'. '/dev/fd0'. '/dev/fd1'. '/dev/scd0'. '/dev/scd0'. '/dev/sr0'. '/dev/sr1'. 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 '/dev/ttyUSB0'. '/dev/ttyUSB1'. '/dev/ttyACM0'. '/dev/ttyS0'. 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: container: ubuntu-1 file: matchPaths: - path: /dev/bus/usb - path: /dev/fd0 - path: /dev/fd1 - path: /dev/scd0 - path: /dev/scd0 - path: /dev/sr0 - path: /dev/sr1 process: matchPaths: - path: /dev/ttyUSB0 - path: /dev/ttyUSB1 - path: /dev/ttyACM0 - path: /dev/ttyS0 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 'container: ubuntu-1'. 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 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchDirectories: - dir: /var/lib/mysql/ 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/nginx/nginx.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: container: ubuntu-1 file: matchPaths: - path: /etc/nginx/nginx.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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/*/*/*/nginx -s stop*' pattern. '/*/*/*/nginx -s stop*' pattern. '/*/*/nginx -s stop*' pattern. '/*/nginx -s stop*' 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: container: ubuntu-1 process: matchPatterns: - pattern: /*/*/*/*/nginx -s stop* - pattern: /*/*/*/nginx -s stop* - pattern: /*/*/nginx -s stop* - pattern: /*/nginx -s stop* 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/sbin/iptables'. '/sbin/iptables'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/sbin/iptables - path: /sbin/iptables 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/profile.d/autologout.sh'. '/etc/profile.d/bash_autologout.sh'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /etc/profile.d/autologout.sh - path: /etc/profile.d/bash_autologout.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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/my.cnf'. '/etc/profile'. '/etc/X11/xorg.conf'. '/etc/sudoers'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /etc/my.cnf - path: /etc/profile - path: /etc/X11/xorg.conf - path: /etc/sudoers 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/ssh/moduli'. '/etc/ssh/ssh_host_ecdsa_key'. '/etc/ssh/ssh_host_ed25519_key'. '/etc/ssh/ssh_host_rsa_key'. '/etc/ssh/ssh_import_id'. '/etc/ssh/ssh_config'. '/etc/ssh/ssh_host_ecdsa_key.pub'. '/etc/ssh/ssh_host_ed25519_key.pub'. '/etc/ssh/ssh_host_rsa_key.pub'. '/etc/ssh/sshd_config'. '/usr/lib/openssh/agent-launch'. '/usr/lib/openssh/ssh-session-cleanup'. 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/ssh'. '/usr/bin/ssh-add'. '/usr/bin/ssh-argv0'. '/usr/bin/ssh-copy-id'. '/usr/bin/ssh-import-id'. '/usr/bin/ssh-import-id-gh'. '/usr/bin/ssh-import-id-lp'. '/usr/bin/ssh-keygen'. '/usr/bin/ssh-keyscan'. '/usr/lib/openssh/ssh-keysign'. '/usr/lib/openssh/sftp-server'. '/usr/lib/openssh/ssh-pkcs11-helper'. 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: container: ubuntu-1 file: matchPaths: - path: /etc/ssh/moduli - path: /etc/ssh/ssh_host_ecdsa_key - path: /etc/ssh/ssh_host_ed25519_key - path: /etc/ssh/ssh_host_rsa_key - path: /etc/ssh/ssh_import_id - path: /etc/ssh/ssh_config - path: /etc/ssh/ssh_host_ecdsa_key.pub - path: /etc/ssh/ssh_host_ed25519_key.pub - path: /etc/ssh/ssh_host_rsa_key.pub - path: /etc/ssh/sshd_config - path: /usr/lib/openssh/agent-launch - path: /usr/lib/openssh/ssh-session-cleanup process: matchPaths: - path: /usr/bin/ssh - path: /usr/bin/ssh-add - path: /usr/bin/ssh-argv0 - path: /usr/bin/ssh-copy-id - path: /usr/bin/ssh-import-id - path: /usr/bin/ssh-import-id-gh - path: /usr/bin/ssh-import-id-lp - path: /usr/bin/ssh-keygen - path: /usr/bin/ssh-keyscan - path: /usr/lib/openssh/ssh-keysign - path: /usr/lib/openssh/sftp-server - path: /usr/lib/openssh/ssh-pkcs11-helper 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/ssh'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/ssh'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/sudo'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/sudo'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/visudo'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/sbin/visudo'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/last'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/last'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/find'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/find'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/file'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/ss'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/ufw'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/iptables'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/passwd'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/pwck'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/setfacl'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/getfacl'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/sestatus'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/lshw'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/lshw'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/lscpu'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/lscpu'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/lsblk'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/lsblk'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/lsusb'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/lsusb'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/lspci'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/lspci'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/lsscsi'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/lsscsi'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/hdparm'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/sbin/hdparm'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/fdisk'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/sbin/fdisk'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/sbin/dmidecode'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/sbin/dmidecode'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/usr/bin/wget'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/bin/wget'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/ssh ownerOnly: true - path: /bin/ssh ownerOnly: true - path: /usr/bin/sudo ownerOnly: true - path: /bin/sudo ownerOnly: true - path: /usr/sbin/visudo ownerOnly: true - path: /sbin/visudo ownerOnly: true - path: /usr/bin/last ownerOnly: true - path: /bin/last ownerOnly: true - path: /usr/bin/find ownerOnly: true - path: /bin/find ownerOnly: true - path: /usr/bin/file ownerOnly: true - path: /usr/bin/ss ownerOnly: true - path: /usr/sbin/ufw ownerOnly: true - path: /usr/sbin/iptables ownerOnly: true - path: /usr/bin/passwd ownerOnly: true - path: /usr/sbin/pwck ownerOnly: true - path: /usr/bin/setfacl ownerOnly: true - path: /usr/bin/getfacl ownerOnly: true - path: /usr/sbin/sestatus ownerOnly: true - path: /usr/bin/lshw ownerOnly: true - path: /bin/lshw ownerOnly: true - path: /usr/bin/lscpu ownerOnly: true - path: /bin/lscpu ownerOnly: true - path: /usr/bin/lsblk ownerOnly: true - path: /bin/lsblk ownerOnly: true - path: /usr/bin/lsusb ownerOnly: true - path: /bin/lsusb ownerOnly: true - path: /usr/bin/lspci ownerOnly: true - path: /bin/lspci ownerOnly: true - path: /usr/bin/lsscsi ownerOnly: true - path: /bin/lsscsi ownerOnly: true - path: /usr/sbin/hdparm ownerOnly: true - path: /sbin/hdparm ownerOnly: true - path: /usr/sbin/fdisk ownerOnly: true - path: /sbin/fdisk ownerOnly: true - path: /usr/sbin/dmidecode ownerOnly: true - path: /sbin/dmidecode ownerOnly: true - path: /usr/bin/wget ownerOnly: true - path: /bin/wget 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/hostapd/hostapd.conf'. '/etc/network/interfaces'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /etc/hostapd/hostapd.conf - path: /etc/network/interfaces 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 'container: ubuntu-1'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/dev/', specifies a rule that matches a specific directory path '/root/', 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'. '/usr/bin/nc'. '/usr/bin/dig'. '/usr/bin/ncat'. '/usr/bin/nmap'. '/usr/sbin/tcpdump'. '/usr/bin/tcpdump'. '/usr/bin/tshark'. '/usr/bin/ngrep'. '/usr/bin/telnet'. '/usr/bin/mitmproxy'. '/usr/bin/socat'. '/usr/sbin/zmap'. '/usr/bin/login'. '/usr/bin/su'. '/usr/sbin/nologin'. '/usr/bin/faillog'. '/usr/bin/lastlog'. '/usr/bin/newgrp'. '/usr/bin/sg'. '/usr/sbin/shadowconfig'. '/usr/sbin/grpck'. '/usr/sbin/pwunconv'. '/usr/sbin/grpconv'. '/usr/sbin/pwck'. '/usr/sbin/groupmod'. '/usr/sbin/vipw'. '/usr/sbin/pwconv'. '/usr/sbin/useradd'. '/usr/sbin/newusers'. '/usr/sbin/cppw'. '/usr/sbin/chpasswd'. '/usr/sbin/usermod'. '/usr/sbin/groupadd'. '/usr/sbin/groupdel'. '/usr/sbin/grpunconv'. '/usr/sbin/chgpasswd'. '/usr/sbin/userdel'. '/usr/bin/chage'. '/usr/bin/chsh'. '/usr/bin/gpasswd'. '/usr/bin/chfn'. '/usr/bin/expiry'. '/usr/bin/passwd'. '/usr/sbin/vigr'. '/usr/sbin/cpgr'. '/usr/sbin/adduser'. '/usr/sbin/addgroup'. '/usr/sbin/deluser'. '/usr/sbin/delgroup'. '/usr/bin/chage'. '/usr/bin/gpasswd'. '/usr/bin/lastlog'. '/usr/bin/newgrp'. '/usr/bin/sg'. '/usr/sbin/adduser'. '/usr/sbin/deluser'. '/usr/sbin/chpasswd'. '/usr/sbin/groupadd'. '/usr/sbin/groupdel'. '/usr/sbin/addgroup'. '/usr/sbin/delgroup'. '/usr/sbin/groupmems'. '/usr/sbin/groupmod'. '/usr/sbin/grpck'. '/usr/sbin/grpconv'. '/usr/sbin/grpunconv'. '/usr/sbin/newusers'. '/usr/sbin/pwck'. '/usr/sbin/pwconv'. '/usr/sbin/pwunconv'. '/usr/sbin/useradd'. '/usr/sbin/userdel'. '/usr/sbin/usermod'. '/usr/sbin/vigr'. '/usr/sbin/vipw'. '/usr/sbin/unix_chkpwd'. '/usr/bin/openssl'. '/usr/sbin/update-ca-certificates'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/chmod - path: /usr/bin/nc - path: /usr/bin/dig - path: /usr/bin/ncat - path: /usr/bin/nmap - path: /usr/sbin/tcpdump - path: /usr/bin/tcpdump - path: /usr/bin/tshark - path: /usr/bin/ngrep - path: /usr/bin/telnet - path: /usr/bin/mitmproxy - path: /usr/bin/socat - path: /usr/sbin/zmap - path: /usr/bin/login - path: /usr/bin/su - path: /usr/sbin/nologin - path: /usr/bin/faillog - path: /usr/bin/lastlog - path: /usr/bin/newgrp - path: /usr/bin/sg - path: /usr/sbin/shadowconfig - path: /usr/sbin/grpck - path: /usr/sbin/pwunconv - path: /usr/sbin/grpconv - path: /usr/sbin/pwck - path: /usr/sbin/groupmod - path: /usr/sbin/vipw - path: /usr/sbin/pwconv - path: /usr/sbin/useradd - path: /usr/sbin/newusers - path: /usr/sbin/cppw - path: /usr/sbin/chpasswd - path: /usr/sbin/usermod - path: /usr/sbin/groupadd - path: /usr/sbin/groupdel - path: /usr/sbin/grpunconv - path: /usr/sbin/chgpasswd - path: /usr/sbin/userdel - path: /usr/bin/chage - path: /usr/bin/chsh - path: /usr/bin/gpasswd - path: /usr/bin/chfn - path: /usr/bin/expiry - path: /usr/bin/passwd - path: /usr/sbin/vigr - path: /usr/sbin/cpgr - path: /usr/sbin/adduser - path: /usr/sbin/addgroup - path: /usr/sbin/deluser - path: /usr/sbin/delgroup - path: /usr/bin/chage - path: /usr/bin/gpasswd - path: /usr/bin/lastlog - path: /usr/bin/newgrp - path: /usr/bin/sg - path: /usr/sbin/adduser - path: /usr/sbin/deluser - path: /usr/sbin/chpasswd - path: /usr/sbin/groupadd - path: /usr/sbin/groupdel - path: /usr/sbin/addgroup - path: /usr/sbin/delgroup - path: /usr/sbin/groupmems - path: /usr/sbin/groupmod - path: /usr/sbin/grpck - path: /usr/sbin/grpconv - path: /usr/sbin/grpunconv - path: /usr/sbin/newusers - path: /usr/sbin/pwck - path: /usr/sbin/pwconv - path: /usr/sbin/pwunconv - path: /usr/sbin/useradd - path: /usr/sbin/userdel - path: /usr/sbin/usermod - path: /usr/sbin/vigr - path: /usr/sbin/vipw - path: /usr/sbin/unix_chkpwd - path: /usr/bin/openssl - path: /usr/sbin/update-ca-certificates file: matchDirectories: - dir: /dev/ - dir: /root/ 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/root/.bashrc'. '/root/.bash_profile'. '/root/.bash_history'. '/root/.bash_login'. '/root/.bash_logout'. '/root/.inputrc'. '/root/.profile'. '/home/*/.bashrc'. '/home/*/.bash_profile'. '/home/*/.bash_history'. '/home/*/.bash_login'. '/home/*/.bash_logout'. '/home/*/.inputrc'. '/home/*/.profile'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /root/.bashrc - path: /root/.bash_profile - path: /root/.bash_history - path: /root/.bash_login - path: /root/.bash_logout - path: /root/.inputrc - path: /root/.profile - path: /home/*/.bashrc - path: /home/*/.bash_profile - path: /home/*/.bash_history - path: /home/*/.bash_login - path: /home/*/.bash_logout - path: /home/*/.inputrc - path: /home/*/.profile 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 'container: ubuntu-1'. 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/'. 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. '/sbin/'. 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. '/usr/bin/'. 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. '/usr/sbin/'. 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 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: container: ubuntu-1 process: matchDirectories: - dir: /bin/ ownerOnly: true recursive: true - dir: /sbin/ ownerOnly: true recursive: true - dir: /usr/bin/ ownerOnly: true recursive: true - dir: /usr/sbin/ 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 'container: ubuntu-1'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/boot/', 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 '/lib/', 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 '/lib64/', 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 '/usr/lib/', 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 '/usr/local/lib/', 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 '/usr/local/sbin/', 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 '/usr/local/bin/', 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/.ssh/', 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: container: ubuntu-1 file: matchDirectories: - dir: /boot/ ownerOnly: true recursive: true - dir: /lib/ ownerOnly: true recursive: true - dir: /lib64/ ownerOnly: true recursive: true - dir: /usr/lib/ ownerOnly: true recursive: true - dir: /usr/local/lib/ ownerOnly: true recursive: true - dir: /usr/local/sbin/ ownerOnly: true recursive: true - dir: /usr/local/bin/ ownerOnly: true recursive: true - dir: /root/.ssh/ 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/var/log/auth.log'. '/var/log/daemon.log'. '/var/log/debug'. '/var/log/debug'. '/var/log/syslog'. '/var/log/faillog'. '/var/log/lastlog'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /var/log/auth.log - path: /var/log/daemon.log - path: /var/log/debug - path: /var/log/debug - path: /var/log/syslog - path: /var/log/faillog - path: /var/log/lastlog 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/proc/cmdline'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /proc/cmdline 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. 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. 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: container: ubuntu-1 file: matchDirectories: - dir: /etc/ recursive: true 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/audit/audit'. '/etc/audit/auditd.conf'. '/var/log/audit/audit.log'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchPaths: - path: /etc/audit/audit - path: /etc/audit/auditd.conf - path: /var/log/audit/audit.log 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/log/audit/', ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies a rule that matches a specific file absolute path '/var/log/audit/audit.log'. 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: container: ubuntu-1 file: matchDirectories: - dir: /var/log/audit/ ownerOnly: true matchPaths: - path: /var/log/audit/audit.log 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 'container: ubuntu-1'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/sudoers.d/', 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 '/etc/pam.d/', 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 '/etc/', 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 file absolute path '/etc/shadow'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/sudoers'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/pam.conf'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/security/pwquality.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 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchDirectories: - dir: /etc/sudoers.d/ ownerOnly: true recursive: true - dir: /etc/pam.d/ ownerOnly: true recursive: true - dir: /etc/ ownerOnly: true recursive: true matchPaths: - path: /etc/shadow ownerOnly: true - path: /etc/sudoers ownerOnly: true - path: /etc/pam.conf ownerOnly: true - path: /etc/security/pwquality.conf 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/apt'. '/usr/bin/wget'. '/usr/bin/curl'. '/usr/bin/http'. '/usr/bin/shell'. '/usr/bin/zypp'. '/usr/bin/yum'. '/usr/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 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 process: matchPaths: - path: /usr/bin/apt - path: /usr/bin/wget - path: /usr/bin/curl - path: /usr/bin/http - path: /usr/bin/shell - path: /usr/bin/zypp - path: /usr/bin/yum - path: /usr/bin/zypper 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 'container: ubuntu-1'. 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. 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 '/usr/bin/shred', specifies a rule that matches a specific directory path '/bin/shred', specifies a rule that matches a specific directory path '/usr/bin/rm', specifies a rule that matches a specific directory path '/bin/rm', specifies a rule that matches a specific directory path '/usr/bin/mv', specifies a rule that matches a specific directory path '/bin/mv', Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: container: ubuntu-1 file: matchDirectories: - dir: /var/log/ recursive: true fromSource: - path: /usr/bin/shred - path: /bin/shred - path: /usr/bin/rm - path: /bin/rm - path: /usr/bin/mv - path: /bin/mv 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/sbin/alternatives'. '/usr/bin/dnf'. '/usr/bin/rpm'. '/usr/bin/yum'. '/usr/bin/rpmkeys'. '/bin/dnf'. '/bin/rpm'. '/bin/yum'. '/bin/rpmkeys'. '/usr/bin/dpkg'. '/bin/dpkg'. '/usr/bin/dpkg-divert'. '/bin/dpkg-divert'. '/usr/bin/apt'. '/bin/apt'. '/usr/bin/apt-get'. '/bin/apt-get'. '/usr/bin/apt-key'. '/bin/apt-key'. '/usr/bin/apt-config'. '/bin/apt-config'. '/usr/bin/apt-cache'. '/bin/apt-cache'. '/usr/bin/gem'. '/bin/gem'. '/usr/bin/pip'. '/bin/pip'. '/usr/bin/pip3'. '/bin/pip3'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/sbin/alternatives - path: /usr/bin/dnf - path: /usr/bin/rpm - path: /usr/bin/yum - path: /usr/bin/rpmkeys - path: /bin/dnf - path: /bin/rpm - path: /bin/yum - path: /bin/rpmkeys - path: /usr/bin/dpkg - path: /bin/dpkg - path: /usr/bin/dpkg-divert - path: /bin/dpkg-divert - path: /usr/bin/apt - path: /bin/apt - path: /usr/bin/apt-get - path: /bin/apt-get - path: /usr/bin/apt-key - path: /bin/apt-key - path: /usr/bin/apt-config - path: /bin/apt-config - path: /usr/bin/apt-cache - path: /bin/apt-cache - path: /usr/bin/gem - path: /bin/gem - path: /usr/bin/pip - path: /bin/pip - path: /usr/bin/pip3 - path: /bin/pip3 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/root/.bash_history'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/usr/bin/shred'. '/bin/shred'. '/usr/bin/rm'. '/bin/rm'. '/usr/bin/mv'. '/bin/mv'. apply rules to the executable processes at paths '/home/*/.bash_history'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/usr/bin/shred'. '/bin/shred'. '/usr/bin/rm'. '/bin/rm'. '/usr/bin/mv'. '/bin/mv'. 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: container: ubuntu-1 process: matchPaths: - path: /root/.bash_history fromSource: - path: /usr/bin/shred - path: /bin/shred - path: /usr/bin/rm - path: /bin/rm - path: /usr/bin/mv - path: /bin/mv - path: /home/*/.bash_history fromSource: - path: /usr/bin/shred - path: /bin/shred - path: /usr/bin/rm - path: /bin/rm - path: /usr/bin/mv - path: /bin/mv 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/etc/crontab'. '/etc/anacrontab'. '/etc/fcrontab'. '/etc/hcron'. '/etc/jobber'. 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: container: ubuntu-1 process: matchPaths: - path: /etc/crontab - path: /etc/anacrontab - path: /etc/fcrontab - path: /etc/hcron - path: /etc/jobber 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 'container: ubuntu-1'. 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: container: ubuntu-1 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/apt'. '/usr/bin/wget'. '/usr/bin/curl'. '/usr/bin/http'. '/usr/bin/zypp'. '/usr/bin/yum'. 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: container: ubuntu-1 process: matchPaths: - path: /usr/bin/apt - path: /usr/bin/wget - path: /usr/bin/curl - path: /usr/bin/http - path: /usr/bin/zypp - path: /usr/bin/yum 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 'container: ubuntu-1'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/apt/sources.list'. '/etc/yum.conf'. '/var/log/dpkg.log'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. '/var/log/yum.log'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. '/var/log/zypper.log'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/apt/sources.list.d/', 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/yum.repos.d/', 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/zypp/repos.d/', 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: container: ubuntu-1 file: matchPaths: - path: /etc/apt/sources.list - path: /etc/yum.conf - path: /var/log/dpkg.log readOnly: true - path: /var/log/yum.log readOnly: true - path: /var/log/zypper.log readOnly: true matchDirectories: - dir: /etc/apt/sources.list.d/ recursive: true - dir: /etc/yum.repos.d/ recursive: true - dir: /etc/zypp/repos.d/ 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 'container: ubuntu-1'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/**/tcpdump' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process. 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: container: ubuntu-1 process: matchPatterns: - pattern: /**/tcpdump network: matchProtocols: - protocol: UDP action: Audit