Datasets:

H836

/

cclab

like 0

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchDirectories: - dir: /var/cache/nginx/client_temp/ fromSource: - path: /usr/sbin/nginx action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo'. 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: app: mongo 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 'app: mongo'. 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: app: mongo 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 'app: mongo'. 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: app: mongo 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 'app: mongo'. 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: app: mongo 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 'app: mongo'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/etc/fstab'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/crontab'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/group'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/hosts'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/hosts.allow'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/hosts.deny'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/issue'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/motd'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/mtab'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/passwd'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/profile'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/resolv.conf'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/proc/cpuinfo'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/proc/filesystems'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/proc/interrupts'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/proc/ioports'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/proc/meminfo'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/proc/modules'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/proc/mounts'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/proc/stat'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/proc/swaps'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/var/log/lastlog'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/var/log/messages'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/var/log/wtmp'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/services'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. '/etc/shadow'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchPaths: - path: /etc/fstab readOnly: false ownerOnly: true - path: /etc/crontab readOnly: false ownerOnly: true - path: /etc/group readOnly: false ownerOnly: true - path: /etc/hosts readOnly: false ownerOnly: true - path: /etc/hosts.allow readOnly: false ownerOnly: true - path: /etc/hosts.deny readOnly: false ownerOnly: true - path: /etc/issue readOnly: false ownerOnly: true - path: /etc/motd readOnly: false ownerOnly: true - path: /etc/mtab readOnly: false ownerOnly: true - path: /etc/passwd readOnly: false ownerOnly: true - path: /etc/profile readOnly: false ownerOnly: true - path: /etc/resolv.conf readOnly: false ownerOnly: true - path: /proc/cpuinfo readOnly: false ownerOnly: true - path: /proc/filesystems readOnly: false ownerOnly: true - path: /proc/interrupts readOnly: false ownerOnly: true - path: /proc/ioports readOnly: false ownerOnly: true - path: /proc/meminfo readOnly: false ownerOnly: true - path: /proc/modules readOnly: false ownerOnly: true - path: /proc/mounts readOnly: false ownerOnly: true - path: /proc/stat readOnly: false ownerOnly: true - path: /proc/swaps readOnly: false ownerOnly: true - path: /var/log/lastlog readOnly: false ownerOnly: true - path: /var/log/messages readOnly: false ownerOnly: true - path: /var/log/wtmp readOnly: false ownerOnly: true - path: /etc/services readOnly: false ownerOnly: true - path: /etc/shadow readOnly: false ownerOnly: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo'. 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: app: mongo process: matchPatterns: - pattern: /**/tcpdump network: matchProtocols: - protocol: UDP action: Audit

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo process: matchPatterns: - pattern: /*/crontab - pattern: /*/*/crontab matchPaths: - path: /usr/bin/crontab - path: /bin/crontab - path: /usr/sbin/crontab - path: /sbin/crontab action: Audit

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

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

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchPaths: - path: /var/log/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 'app: mongo'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/var/log/mysql.log'. 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/bin/rm'. '/usr/bin/touch'. '/usr/bin/cat'. '/usr/bin/nano'. '/usr/bin/vi'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchPaths: - path: /var/log/mysql.log fromSource: - path: /usr/bin/rm - path: /usr/bin/touch - path: /usr/bin/cat - path: /usr/bin/nano - path: /usr/bin/vi action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/systemd/system/', 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/systemd/', 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/systemd/system/', 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. 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 '/etc/systemd/system/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/usr/lib/systemd/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/lib/systemd/system/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo process: matchDirectories: - dir: /etc/systemd/system/ recursive: true - dir: /usr/lib/systemd/ recursive: true - dir: /lib/systemd/system/ recursive: true file: matchDirectories: - dir: /etc/systemd/system/ recursive: true readOnly: false - dir: /usr/lib/systemd/ recursive: true readOnly: false - dir: /lib/systemd/system/ recursive: true readOnly: false action: Audit

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchDirectories: - dir: /etc/postgresql/ recursive: true readOnly: false - dir: /etc/postgresql-common/ recursive: true readOnly: false action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/usr/local/lib/python3.10/site-packages/requests/', 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. defines rules related to processes running in the selected pods. applies the rule to processes with the '/*/*/*/python -m pip install requests*' pattern. '/*/*/python -m pip install requests*' pattern. '/*/python -m pip install requests*' pattern. '/*/*/*/pip install requests*' pattern. '/*/*/pip install requests*' pattern. '/*/pip install requests*' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo process: matchPatterns: - pattern: /*/*/*/python -m pip install requests* - pattern: /*/*/python -m pip install requests* - pattern: /*/python -m pip install requests* - pattern: /*/*/*/pip install requests* - pattern: /*/*/pip install requests* - pattern: /*/pip install requests* file: matchDirectories: - dir: /usr/local/lib/python3.10/site-packages/requests/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/opt/redislabs/log/', ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. applies the rule to files with the '/var/log/**.log' pattern, '/var/*/*.log' pattern, ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchDirectories: - dir: /var/opt/redislabs/log/ ownerOnly: true matchPatterns: - pattern: /var/log/**.log - pattern: /var/*/*.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 'app: mongo'. defines the policy related to file access. applies the rule to files with the '/**/robomongo.json' 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: app: mongo file: matchPatterns: - pattern: /**/robomongo.json action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchPaths: - path: /proc/meminfo - path: /proc/mounts action: Audit

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

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

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/bin/cat', Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo - WARNING file: matchDirectories: - dir: /credentials/ fromSource: - path: /bin/cat action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchDirectories: - dir: /credentials/ 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 'app: mongo'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/home/user1/secret_data1.txt'. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchPaths: - path: /home/user1/secret_data1.txt readOnly: 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 'app: mongo'. defines the policy related to file access. 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 file absolute path '/usr/bin/shred'. '/usr/bin/rm'. '/bin/mv'. '/bin/rm'. '/usr/bin/mv'. Specifies a rule that matches a specific file absolute path '/root/*_history'. 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/bin/shred'. '/usr/bin/rm'. '/bin/rm'. '/bin/mv'. '/usr/bin/mv'. Specifies a rule that matches a specific file absolute path '/home/*/*_history'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo file: matchPaths: - fromSource: - path: /usr/bin/shred - path: /usr/bin/rm - path: /bin/mv - path: /bin/rm - path: /usr/bin/mv path: /root/*_history - fromSource: - path: /usr/bin/shred - path: /usr/bin/rm - path: /bin/rm - path: /bin/mv - path: /usr/bin/mv path: /home/*/*_history action: Block

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

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

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

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

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines rules related to system calls. specifies a policy for the specific system calls 'unlink'. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching system calls.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db syscalls: matchSyscalls: - syscall: - 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 'app: mongo-db'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/local/tomcat/conf/jaspic-providers.xml'. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

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

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - path: /usr/local/tomcat/conf/catalina.policy ownerOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/tmp/', 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/auditd', specifies a rule that matches a specific directory path '/bin/auditd', specifies a rule that matches a specific directory path '/sbin/auditd', Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchDirectories: - dir: /var/tmp/ fromSource: - path: /usr/bin/auditd - path: /bin/auditd - path: /sbin/auditd action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. defines the policy related to file access. applies the rule to files with the '/etc/*hado?' 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: app: mongo-db file: matchPatterns: - pattern: /etc/*hado? action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db network: matchProtocols: - protocol: raw action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the network-related policies. In this case, rule applies to TCP network traffic. When the 'fromSource' field is defined, the action is only applied from '/usr/bin/curl' Specifies what to do when rules match, which means relevant network activities will be allowed.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db network: matchProtocols: - protocol: tcp fromSource: - path: /usr/bin/curl action: Allow

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

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

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. 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 file absolute path '/usr/bin/shred'. '/usr/bin/rm'. '/bin/mv'. '/bin/rm'. '/usr/bin/mv'. Specifies a rule that matches a specific file absolute path '/root/*_history'. 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/bin/shred'. '/usr/bin/rm'. '/bin/rm'. '/bin/mv'. '/usr/bin/mv'. Specifies a rule that matches a specific file absolute path '/home/*/*_history'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - fromSource: - path: /usr/bin/shred - path: /usr/bin/rm - path: /bin/mv - path: /bin/rm - path: /usr/bin/mv path: /root/*_history - fromSource: - path: /usr/bin/shred - path: /usr/bin/rm - path: /bin/rm - path: /bin/mv - path: /usr/bin/mv path: /home/*/*_history action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - path: /etc/shadow action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPaths: - path: /usr/bin/rsync - path: /bin/rsync - path: /usr/bin/scp - path: /bin/scp - path: /usr/bin/scp - path: /bin/scp action: Block

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

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

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. 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 file absolute path '/usr/bin/shred'. '/usr/bin/rm'. '/bin/mv'. '/bin/rm'. '/usr/bin/mv'. Specifies a rule that matches a specific file absolute path '/root/*_history'. 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/bin/shred'. '/usr/bin/rm'. '/bin/rm'. '/bin/mv'. '/usr/bin/mv'. Specifies a rule that matches a specific file absolute path '/home/*/*_history'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - fromSource: - path: /usr/bin/shred - path: /usr/bin/rm - path: /bin/mv - path: /bin/rm - path: /usr/bin/mv path: /root/*_history - fromSource: - path: /usr/bin/shred - path: /usr/bin/rm - path: /bin/rm - path: /bin/mv - path: /usr/bin/mv path: /home/*/*_history action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchDirectories: - dir: /bin/ readOnly: true recursive: true - dir: /sbin/ readOnly: true recursive: true - dir: /usr/sbin/ readOnly: true recursive: true - dir: /usr/bin/ readOnly: true recursive: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/log/cassandra/', 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 a rule that matches a specific directory path '/storage/log/vcops/log/cassandra/', 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: app: mongo-db file: matchDirectories: - dir: /var/log/cassandra/ recursive: true ownerOnly: true - dir: /storage/log/vcops/log/cassandra/ 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 'app: mongo-db'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/usr/local/go/src/crypto/elliptic/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchDirectories: - dir: /usr/local/go/src/crypto/elliptic/ recursive: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. applies the rule to files with the '/**/mocha/*.*' pattern, Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPatterns: - pattern: /**/mocha/*.* action: Audit

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPatterns: - pattern: /**/postgresql.conf action: Audit

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - path: /etc/fapolicyd/fapolicyd.conf ownerOnly: true - path: /etc/fapolicyd/fapolicyd.rules ownerOnly: true action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/local/lib/node_modules/js-yaml/bin/js-yaml.js'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - path: /usr/local/lib/node_modules/js-yaml/bin/js-yaml.js action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - path: /sql/item_subselect.cc action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - path: /sql/sql_string.h action: Block

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

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

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchDirectories: - dir: /etc/mysql/ recursive: true ownerOnly: true - dir: /usr/lib/mysql/ recursive: true ownerOnly: true - dir: /usr/share/mysql/ recursive: true ownerOnly: true - dir: /var/lib/mysql/ recursive: true ownerOnly: true - dir: /var/log/mysql/ recursive: true ownerOnly: true - dir: /usr/local/mysql/ recursive: true ownerOnly: true action: Block

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

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

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. 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 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPaths: - path: /usr/bin/apt matchPaths: - path: /usr/bin/wget matchPaths: - path: /usr/bin/curl matchPaths: - path: /usr/bin/http matchPaths: - path: /usr/bin/zypp matchPaths: - path: /usr/bin/yum action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. 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/'. '/usr/local/bin/'. '/bin/'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/usr/bin/mvn'. applies the rule to processes with the '/**/qtp*' pattern. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

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

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/bin/who'. '/usr/bin/w'. '/usr/bin/id'. '/usr/bin/whoami'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPaths: - path: /usr/bin/who - path: /usr/bin/w - path: /usr/bin/id - path: /usr/bin/whoami action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. defines rules related to processes running in the selected pods. applies the rule to processes with the '/**/chmod' pattern. '/**/chown' pattern. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPatterns: - pattern: /**/chmod - pattern: /**/chown action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchDirectories: - dir: /var/cache/nginx/client_temp/ fromSource: - path: /usr/sbin/nginx action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. 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: app: mongo-db 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 'app: mongo-db'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/bin/md5sum'. '/dev/zero'. '/usr/bin/sha1sum'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file. defines rules related to processes running in the selected pods. applies the rule to processes with the '/etc/systemd/system/*.service' pattern. '/etc/systemd/system/*.service.d/*CPUShares.conf' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPatterns: - pattern: /etc/systemd/system/*.service - pattern: /etc/systemd/system/*.service.d/*CPUShares.conf file: matchPaths: - path: /usr/bin/md5sum - path: /dev/zero - path: /usr/bin/sha1sum action: Audit

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/var/adm/wtmp'. '/var/adm/pacct'. '/var/adm/sulog'. '/var/log/wtmp'. '/var/log/btmp'. '/var/run/utmp'. 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/dpkg'. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPaths: - path: /usr/bin/dpkg file: matchPaths: - path: /var/adm/wtmp - path: /var/adm/pacct - path: /var/adm/sulog - path: /var/log/wtmp - path: /var/log/btmp - 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 'app: mongo-db'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/proc/meminfo'. '/proc/mounts'. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file. defines rules related to processes running in the selected pods. applies the rule to processes with the '^/proc/\*/maps$' pattern. '^/proc/\*/mem$' pattern. '/*/mv * /dev/null' pattern. '/*/*/mv * /dev/null' pattern. '/*/mkfs.ext4 /dev/*' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPatterns: - pattern: ^/proc/\*/maps$ - pattern: ^/proc/\*/mem$ - pattern: /*/mv * /dev/null - pattern: /*/*/mv * /dev/null - pattern: /*/mkfs.ext4 /dev/* file: matchPaths: - path: /proc/meminfo - path: /proc/mounts action: Audit

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

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

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. 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/'. '/sbin/'. '/usr/sbin/'. '/usr/bin/'. When the 'fromSource' field is defined, the action is only applied to source processes in the path '/bin/mkdir'. Specifies the action to take when rules match, in which case the 'Block' action blocks the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchDirectories: - dir: /bin/ - dir: /sbin/ - dir: /usr/sbin/ - dir: /usr/bin/ fromSource: - path: /bin/mkdir action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/etc/systemd/system/', 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/systemd/', 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/systemd/system/', 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. 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 '/etc/systemd/system/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/usr/lib/systemd/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/lib/systemd/system/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchDirectories: - dir: /etc/systemd/system/ recursive: true - dir: /usr/lib/systemd/ recursive: true - dir: /lib/systemd/system/ recursive: true file: matchDirectories: - dir: /etc/systemd/system/ recursive: true readOnly: false - dir: /usr/lib/systemd/ recursive: true readOnly: false - dir: /lib/systemd/system/ recursive: true readOnly: false action: Audit

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

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

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/usr/lib/python3.6/site-packages/st/__init__.py'. applies the rule to files with the '/**/**/**/**/root/.ssh/id_rsa' pattern, '/%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa' pattern, '/usr/lib/**/site-packages/pip/_internal/network/download.py' pattern, '/usr/lib/**/**/pip/download.py' pattern, '/usr/lib/**/**/**/pip/**/**/download.py' pattern, '/usr/local/lib/python?/dist-packages/pip/_internal/network/download.py' pattern, Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file. defines rules related to processes running in the selected pods. apply rules to the executable processes at paths '/usr/lib/python3/site-packages/pip/_internal/network/download.py'. '/usr/lib/python2/site-packages/pip/_internal/network/download.py'. '/usr/local/lib/python3.5/dist-packages/pip/_internal/network/download.py'. '/usr/lib/python3/dist-packages/pip/download.py'. '/usr/lib/python2/dist-packages/pip/download.py'. '/usr/lib/python3.6/site-packages/st/__init__.py'. applies the rule to processes with the '/usr/lib/**/**/pip/download.py' pattern. '/usr/lib/**/**/**/pip/**/**/download.py' pattern. '/usr/local/lib/python?/dist-packages/pip/_internal/network/download.py' pattern. Specifies the action to take when rules match, in which case the 'Audit' action logs the execution of the matching process.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - path: /usr/lib/python3.6/site-packages/st/__init__.py matchPatterns: - pattern: /**/**/**/**/root/.ssh/id_rsa - pattern: /%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa - pattern: /usr/lib/**/site-packages/pip/_internal/network/download.py - pattern: /usr/lib/**/**/pip/download.py - pattern: /usr/lib/**/**/**/pip/**/**/download.py - pattern: /usr/local/lib/python?/dist-packages/pip/_internal/network/download.py process: matchPaths: - path: /usr/lib/python3/site-packages/pip/_internal/network/download.py - path: /usr/lib/python2/site-packages/pip/_internal/network/download.py - path: /usr/local/lib/python3.5/dist-packages/pip/_internal/network/download.py - path: /usr/lib/python3/dist-packages/pip/download.py - path: /usr/lib/python2/dist-packages/pip/download.py - path: /usr/lib/python3.6/site-packages/st/__init__.py matchPatterns: - pattern: /usr/lib/**/**/pip/download.py - pattern: /usr/lib/**/**/**/pip/**/**/download.py - pattern: /usr/local/lib/python?/dist-packages/pip/_internal/network/download.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 'app: mongo-db'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/var/opt/redislabs/log/', ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. applies the rule to files with the '/var/log/**.log' pattern, '/var/*/*.log' pattern, ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. Specifies what to do when rules match, in which case the action 'Audit' monitorings access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchDirectories: - dir: /var/opt/redislabs/log/ ownerOnly: true matchPatterns: - pattern: /var/log/**.log - pattern: /var/*/*.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 'app: mongo-db'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/bin/cat', Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db - WARNING file: matchDirectories: - dir: /credentials/ recursive: 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 'app: mongo-db'. defines the policy related to file access. Specifies a rule that matches a specific file absolute path '/root/.bashrc'. '/root/.bash_history'. '/home/user1/.profile'. '/home/user1/.bashrc'. '/run/utmp'. '/dev/tty'. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/home/user1/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. ownerOnly is enabled, so only the owner of the executable defined by matchPaths and matchDirectories can run. If readOnly is enabled, the read operation will be only allowed, and any other operations (e.g., write) will be blocked. specifies a rule that matches a specific directory path '/etc/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. specifies a rule that matches a specific directory path '/proc/', recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies what to do when rules match, in which case the action 'Allow' allows access to the matching file. defines rules related to processes running in the selected pods. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. '/usr/bin/'. recursive is enabled, so the coverage will extend to the subdirectories of the directory defined with matchDirectories. Specifies the action to take when rules match, in which case the 'Allow' action allows the execution of the matching process.

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

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/bin/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: app: mongo-db - WARNING file: matchDirectories: - dir: /credentials/ 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 'app: mongo-db'. defines the policy related to file access. similar to matchpath, but for dictionaries, specifies a rule that matches a specific directory path '/credentials/', When the 'fromSource' field is defined, access to the file is controlled exclusively for the specified source. In this case, working rules are established for the specified source specifies a rule that matches a specific directory path '/bin/cat', Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db - WARNING file: matchDirectories: - dir: /credentials/ fromSource: - path: /bin/cat action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchDirectories: - dir: /credentials/ recursive: true action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. applies the rule to files with the '/**/debug/default/*' 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: app: mongo-db file: matchPatterns: - pattern: /**/debug/default/* action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - path: /etc/motd readOnly: true - path: /etc/issue readOnly: true - path: /etc/issue.net readOnly: true action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPaths: - path: /usr/bin/rsync - path: /bin/rsync - path: /usr/bin/scp - path: /bin/scp - path: /usr/bin/scp - path: /bin/scp action: Block

Create a KubeArmorPolicy for a kubernetes environment. Selects the Kubernetes pods to which this policy will apply. In this case, it selects pods with the label 'app: mongo-db'. defines the policy related to file access. 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 file absolute path '/usr/bin/shred'. '/usr/bin/rm'. '/bin/mv'. '/bin/rm'. '/usr/bin/mv'. Specifies a rule that matches a specific file absolute path '/root/*_history'. 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/bin/shred'. '/usr/bin/rm'. '/bin/rm'. '/bin/mv'. '/usr/bin/mv'. Specifies a rule that matches a specific file absolute path '/home/*/*_history'. Specifies what to do when rules match, in which case the action 'Block' blocks access to the matching file.

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchPaths: - fromSource: - path: /usr/bin/shred - path: /usr/bin/rm - path: /bin/mv - path: /bin/rm - path: /usr/bin/mv path: /root/*_history - fromSource: - path: /usr/bin/shred - path: /usr/bin/rm - path: /bin/rm - path: /bin/mv - path: /usr/bin/mv path: /home/*/*_history action: Block

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

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

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPaths: - path: /usr/bin/who - path: /usr/bin/w - path: /usr/bin/id - path: /usr/bin/whoami action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db file: matchDirectories: - dir: /dev/shm/ readOnly: true recursive: true action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mongo-db process: matchPaths: - path: /bin/busybox action: Block

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mysql file: matchDirectories: - dir: /usr/local/tomcat/temp/ ownerOnly: true action: Audit

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

kind: KubeArmorPolicy spec: selector: matchLabels: app: mysql file: matchPaths: - path: /usr/local/mysql/data/mysqld.local.err ownerOnly: true action: Audit

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

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

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

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