Use new load_rules() methods to load all rules at once

This speeds up rules loading a bit because rules are only compiled
once instead of for each rules file.

This doesn't change rules validation yet. Validation needs some
additional work to handle splitting the (single) load result back into
individual results for the json/text based output.

Signed-off-by: Mark Stemm <mark.stemm@gmail.com>

.circleci/config.yml

@@ -1,232 +0,0 @@
-version: 2.1
-jobs:
-  "build-arm64":
-    machine:
-      enabled: true
-      image: ubuntu-2204:2022.10.2
-    resource_class: arm.large
-    steps:
-
-      # Install dependencies to build the modern BPF probe skeleton.
-      - run:
-          name: Install deps ⛓️
-          command: |
-            sudo apt update
-            sudo apt install -y --no-install-recommends ca-certificates cmake build-essential clang-14 git pkg-config autoconf automake libelf-dev
-            sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-14 90
-            sudo update-alternatives --install /usr/bin/llvm-strip llvm-strip /usr/bin/llvm-strip-14 90
-            git clone https://github.com/libbpf/bpftool.git --branch v7.0.0 --single-branch
-            cd bpftool
-            git submodule update --init
-            cd src && sudo make install
-
-      # Path to the source code
-      - checkout:
-          path: /tmp/source-arm64/falco
-
-      # Build the skeleton
-      - run:
-          name: Build modern BPF skeleton 🐝
-          command: |
-            mkdir -p /tmp/source-arm64/falco/skeleton-build
-            cd /tmp/source-arm64/falco/skeleton-build && cmake -DUSE_BUNDLED_DEPS=ON -DBUILD_FALCO_MODERN_BPF=ON -DCREATE_TEST_TARGETS=Off ../
-            make ProbeSkeleton
-
-      # Build the Falco packages (tar, deb, rpm) inside the centos7 builder.
-      # This dockerfile returns as output:
-      # - the build directory. (under /tmp/${DEST_BUILD_DIR})
-      # - the 3 packages: tar, deb, rpm. (under /tmp/packages)
-      - run:
-          name: Build Falco packages 🏗️
-          command: |
-            FALCO_VERSION=$(cat /tmp/source-arm64/falco/skeleton-build/userspace/falco/config_falco.h | grep 'FALCO_VERSION ' | cut -d' ' -f3 | sed -e 's/^"//' -e 's/"$//')
-            DOCKER_BUILDKIT=1 docker build -f /tmp/source-arm64/falco/docker/builder/modern-falco-builder.Dockerfile --output type=local,dest=/tmp --build-arg CMAKE_OPTIONS="-DCMAKE_BUILD_TYPE=Release -DUSE_BUNDLED_DEPS=On -DFALCO_ETC_DIR=/etc/falco -DBUILD_FALCO_MODERN_BPF=ON -DMODERN_BPF_SKEL_DIR=/source/skeleton-build/skel_dir -DBUILD_DRIVER=Off -DBUILD_BPF=Off -DFALCO_VERSION=${FALCO_VERSION}" --build-arg DEST_BUILD_DIR=/build-arm64/release /tmp/source-arm64/falco
-
-      - store_artifacts:
-          path: /tmp/packages
-          destination: /packages
-
-      - persist_to_workspace:
-          root: /tmp
-          paths:
-            - build-arm64/release
-            - source-arm64
-
-  # Build a statically linked Falco release binary using musl
-  # This build is 100% static, there are no host dependencies
-  "build-musl":
-    docker:
-      - image: alpine:3.17
-    resource_class: large
-    steps:
-      - checkout:
-          path: /source-static/falco
-      - run:
-          name: Update base image
-          command: apk update
-      - run:
-          name: Install build dependencies
-          command: apk add g++ gcc cmake make git bash perl linux-headers autoconf automake m4 libtool elfutils-dev libelf-static patch binutils bpftool clang
-      - run:
-          name: Prepare project
-          command: |
-            mkdir -p /build-static/release
-            cd /build-static/release
-            cmake -DCPACK_GENERATOR=TGZ -DBUILD_BPF=Off -DBUILD_DRIVER=Off -DCMAKE_BUILD_TYPE=Release -DUSE_BUNDLED_DEPS=On -DUSE_BUNDLED_LIBELF=Off -DBUILD_LIBSCAP_MODERN_BPF=ON -DMUSL_OPTIMIZED_BUILD=On -DFALCO_ETC_DIR=/etc/falco /source-static/falco
-      - run:
-          name: Build
-          command: |
-            cd /build-static/release
-            make -j6 all
-      - run:
-          name: Package
-          command: |
-            cd /build-static/release
-            make -j6 package
-      - run:
-          name: Prepare artifacts
-          command: |
-            mkdir -p /tmp/packages
-            cp /build-static/release/*.tar.gz /tmp/packages
-      - store_artifacts:
-          path: /tmp/packages
-          destination: /packages
-      - persist_to_workspace:
-          root: /
-          paths:
-            - build-static/release
-            - source-static
-
-  # This build is static, dependencies are bundled in the Falco binary
-  "build-centos7":
-    machine:
-      enabled: true
-      image: ubuntu-2204:2022.10.2
-    resource_class: large
-    steps:
-
-      # Install dependencies to build the modern BPF probe skeleton.
-      - run:
-          name: Install deps ⛓️
-          command: |
-            sudo apt update
-            sudo apt install -y --no-install-recommends ca-certificates cmake build-essential clang-14 git pkg-config autoconf automake libelf-dev
-            sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-14 90
-            sudo update-alternatives --install /usr/bin/llvm-strip llvm-strip /usr/bin/llvm-strip-14 90
-            git clone https://github.com/libbpf/bpftool.git --branch v7.0.0 --single-branch
-            cd bpftool
-            git submodule update --init
-            cd src && sudo make install
-
-      # Path for the source code
-      - checkout:
-          path: /tmp/source/falco
-
-      - run:
-          name: Build modern BPF skeleton 🐝
-          command: |
-            mkdir -p /tmp/source/falco/skeleton-build
-            cd /tmp/source/falco/skeleton-build && cmake -DUSE_BUNDLED_DEPS=ON -DBUILD_FALCO_MODERN_BPF=ON -DCREATE_TEST_TARGETS=Off ../
-            make ProbeSkeleton
-
-      # Build the Falco packages (tar, deb, rpm) inside the centos7 builder.
-      # This dockerfile returns as output:
-      # - the build directory. (under /tmp/${DEST_BUILD_DIR})
-      # - the 3 packages: tar, deb, rpm. (under /tmp/packages)
-      - run:
-          name: Build Falco packages 🏗️
-          command: |
-            FALCO_VERSION=$(cat /tmp/source/falco/skeleton-build/userspace/falco/config_falco.h | grep 'FALCO_VERSION ' | cut -d' ' -f3 | sed -e 's/^"//' -e 's/"$//')
-            DOCKER_BUILDKIT=1 docker build -f /tmp/source/falco/docker/builder/modern-falco-builder.Dockerfile --output type=local,dest=/tmp --build-arg CMAKE_OPTIONS="-DCMAKE_BUILD_TYPE=Release -DUSE_BUNDLED_DEPS=On -DFALCO_ETC_DIR=/etc/falco -DBUILD_FALCO_MODERN_BPF=ON -DMODERN_BPF_SKEL_DIR=/source/skeleton-build/skel_dir -DBUILD_DRIVER=Off -DBUILD_BPF=Off -DFALCO_VERSION=${FALCO_VERSION}" --build-arg DEST_BUILD_DIR=/build/release /tmp/source/falco
-
-      - store_artifacts:
-          path: /tmp/packages
-          destination: /packages
-
-      - persist_to_workspace:
-          root: /tmp
-          paths:
-            - build/release
-            - source
-
-  # Execute integration tests based on the build results coming from the "build-centos7" job
-  "tests-integration":
-    docker:
-      - image: falcosecurity/falco-tester:latest
-        environment:
-          SOURCE_DIR: "/source"
-          BUILD_DIR: "/build"
-          BUILD_TYPE: "release"
-    steps:
-      - setup_remote_docker
-      - attach_workspace:
-          at: /
-      - run:
-          name: Execute integration tests
-          command: /usr/bin/entrypoint test
-      - store_test_results:
-          path: /build/release/integration-tests-xunit
-  "tests-integration-static":
-    docker:
-      - image: falcosecurity/falco-tester:latest
-        environment:
-          SOURCE_DIR: "/source-static"
-          BUILD_DIR: "/build-static"
-          BUILD_TYPE: "release"
-          SKIP_PACKAGES_TESTS: "true"
-          SKIP_PLUGINS_TESTS: "true"
-    steps:
-      - setup_remote_docker
-      - attach_workspace:
-          at: /
-      - run:
-          name: Execute integration tests
-          command: /usr/bin/entrypoint test
-      - store_test_results:
-          path: /build-static/release/integration-tests-xunit
-  # Execute integration tests based on the build results coming from the "build-arm64" job
-  "tests-integration-arm64":
-    machine:
-      enabled: true
-      image: ubuntu-2004:202101-01
-    resource_class: arm.medium
-    steps:
-      - attach_workspace:
-          at: /tmp
-      - run:
-          name: Execute integration tests
-          command: |
-            docker run -e BUILD_TYPE="release" -e BUILD_DIR="/build" -e SOURCE_DIR="/source" -it -v /var/run/docker.sock:/var/run/docker.sock -v /tmp/source-arm64:/source -v /tmp/build-arm64:/build \
-              falcosecurity/falco-tester:latest \
-              test
-      - store_test_results:
-          path: /tmp/build-arm64/release/integration-tests-xunit
-  "tests-driver-loader-integration":
-    machine:
-      image: ubuntu-2004:202107-02
-    steps:
-      - attach_workspace:
-          at: /tmp/ws
-      - run:
-          name: Execute driver-loader integration tests
-          command: /tmp/ws/source/falco/test/driver-loader/run_test.sh /tmp/ws/build/release/
-
-workflows:
-  version: 2.1
-  build_and_test:
-    jobs:
-      - "build-musl"
-      - "build-arm64"
-      - "build-centos7"
-      - "tests-integration":
-          requires:
-            - "build-centos7"
-      - "tests-integration-arm64":
-          requires:
-            - "build-arm64"
-      - "tests-integration-static":
-          requires:
-            - "build-musl"
-      - "tests-driver-loader-integration":
-          requires:
-            - "build-centos7"

.github/workflows/ci.yml

@@ -1,7 +1,9 @@
 name: CI Build
 on:
   pull_request:
-    branches: [master]
+    branches:
+      - master
+      - release/*
   workflow_dispatch:
 
 # Checks if any concurrent jobs under the same pull request or branch are being executed
@@ -11,104 +13,105 @@ concurrency:
   cancel-in-progress: true  
 
 jobs:
-  build-minimal:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout
+  fetch-version:
+    uses: ./.github/workflows/reusable_fetch_version.yaml
+
+  build-dev-packages:
+    needs: [fetch-version]
+    uses: ./.github/workflows/reusable_build_packages.yaml
+    with:
+      arch: x86_64
+      version: ${{ needs.fetch-version.outputs.version }}
+
+  test-dev-packages:
+    needs: [fetch-version, build-dev-packages]
+    uses: ./.github/workflows/reusable_test_packages.yaml
+    strategy:
+      fail-fast: false
+      matrix:
+        static: ["static", ""]
+    with:
+      arch: x86_64
+      static: ${{ matrix.static != '' && true || false }}
+      version: ${{ needs.fetch-version.outputs.version }}
+
+  build-dev-minimal:
+    uses: ./.github/workflows/reusable_build_dev.yaml
+    with:
+      arch: x86_64
+      git_ref: ${{ github.event.pull_request.head.sha }}
+      minimal: true
+      build_type: Debug
+  
+  # builds using system deps, checking out the PR's code
+  # note: this also runs a command that generates an output of form: "<engine_version> <some_hash>",
+  # of which <some_hash> is computed by hashing in order the following:
+  # - Driver schema version supported by the built-in falcosecurity/libs
+  # - The supported event types usable in Falco rules (evt.type=xxx)
+  # - The supported rules fields with their name, type, and description
+  build-dev:
+    uses: ./.github/workflows/reusable_build_dev.yaml
+    with:
+      arch: x86_64
+      git_ref: ${{ github.event.pull_request.head.sha }}
+      minimal: false
+      build_type: Debug
+      cmd: "echo $(build/userspace/falco/falco -c ./falco.yaml --version | grep 'Engine:' | awk '{print $2}') $(echo $(build/userspace/falco/falco -c ./falco.yaml --version | grep 'Schema version:' | awk '{print $3}') $(build/userspace/falco/falco -c ./falco.yaml --list --markdown | grep '^`' | sort) $(build/userspace/falco/falco -c ./falco.yaml --list-syscall-events | sort) | sha256sum)"
+
+  # checks the falco engine checksum for consistency
+  check-engine-checksum:
+    runs-on: ubuntu-latest
+    needs: [build-dev]
+    steps:    
+      - name: Checkout PR head ref
         uses: actions/checkout@v3
         with:
           fetch-depth: 0
           ref: ${{ github.event.pull_request.head.sha }}
 
-      - name: Update base image
-        run: sudo apt update -y
-
-      - name: Install build dependencies
-        run: sudo DEBIAN_FRONTEND=noninteractive apt install libjq-dev libyaml-cpp-dev libelf-dev cmake build-essential git -y
-
-      - name: Prepare project
+      - name: Check Engine checksum
         run: |
-          mkdir build-minimal
-          pushd build-minimal
-          cmake -DMINIMAL_BUILD=On -DBUILD_BPF=Off -DBUILD_DRIVER=Off -DCMAKE_BUILD_TYPE=Release -DBUILD_FALCO_UNIT_TESTS=On ..
-          popd
+          prev_hash=$(grep CHECKSUM "./userspace/engine/falco_engine_version.h" | awk '{print $3}' | sed -e 's/"//g')
+          cur_hash=$(echo "${{ needs.build-dev.outputs.cmdout }}" | cut -d ' ' -f 2)
+          
+          echo "encoded checksum: $prev_hash"
+          echo "current checksum: $cur_hash"
+          if [ $prev_hash != $cur_hash ]; then
+            echo "current engine checksum differs from the one encoded in userspace/engine/falco_engine_version.h"
+            exit 1
+          else
+            echo "current and encoded engine checksum are matching"
+          fi
 
-      - name: Build
-        run: |
-          pushd build-minimal
-          make -j4 all
-          popd
-
-      - name: Run unit tests
-        run: |
-          pushd build-minimal
-          sudo ./unit_tests/falco_unit_tests 
-          popd
-
-  build-ubuntu-focal:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout
+  # checks the falco engine version and enforce bumping when necessary
+  check-engine-version:
+    runs-on: ubuntu-latest
+    needs: [build-dev]
+    steps:    
+      - name: Checkout base ref
         uses: actions/checkout@v3
         with:
           fetch-depth: 0
-          ref: ${{ github.event.pull_request.head.sha }}
+          ref: ${{ github.base_ref }}
 
-      - name: Update base image
-        run: sudo apt update -y
-
-      - name: Install build dependencies
-        run: sudo DEBIAN_FRONTEND=noninteractive apt install libssl-dev libyaml-dev libc-ares-dev libprotobuf-dev protobuf-compiler libjq-dev libyaml-cpp-dev libgrpc++-dev protobuf-compiler-grpc rpm libelf-dev cmake build-essential libcurl4-openssl-dev linux-headers-$(uname -r) clang llvm git -y
-
-      - name: Prepare project
+      - name: Check Engine version
         run: |
-          mkdir build
-          pushd build
-          cmake -DBUILD_BPF=On -DCMAKE_BUILD_TYPE=Release -DBUILD_FALCO_UNIT_TESTS=On ..
-          popd
+          base_hash=$(grep CHECKSUM "./userspace/engine/falco_engine_version.h" | awk '{print $3}' | sed -e 's/"//g')
+          base_engine_ver=$(grep ENGINE_VERSION "./userspace/engine/falco_engine_version.h" | awk '{print $3}' | sed -e 's/(//g' -e 's/)//g')
 
-      - name: Build
-        run: |
-          pushd build
-          KERNELDIR=/lib/modules/$(uname -r)/build make -j4 all
-          popd
+          cur_hash=$(echo "${{ needs.build-dev.outputs.cmdout }}" | cut -d ' ' -f 2)
+          cur_engine_ver=$(echo "${{ needs.build-dev.outputs.cmdout }}" | cut -d ' ' -f 1)
 
-      - name: Run unit tests
-        run: |
-          pushd build
-          sudo ./unit_tests/falco_unit_tests 
-          popd
-
-  build-ubuntu-focal-debug:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          ref: ${{ github.event.pull_request.head.sha }}
-
-      - name: Update base image
-        run: sudo apt update -y
-
-      - name: Install build dependencies
-        run: sudo DEBIAN_FRONTEND=noninteractive apt install libssl-dev libyaml-dev libc-ares-dev libprotobuf-dev protobuf-compiler libjq-dev libyaml-cpp-dev libgrpc++-dev protobuf-compiler-grpc rpm libelf-dev cmake build-essential libcurl4-openssl-dev linux-headers-$(uname -r) clang llvm git -y
-
-      - name: Prepare project
-        run: |
-          mkdir build
-          pushd build
-          cmake -DCMAKE_BUILD_TYPE=Debug -DBUILD_BPF=On -DBUILD_FALCO_UNIT_TESTS=On ..
-          popd
-
-      - name: Build
-        run: |
-          pushd build
-          KERNELDIR=/lib/modules/$(uname -r)/build make -j4 all
-          popd
-
-      - name: Run unit tests
-        run: |
-          pushd build
-          sudo ./unit_tests/falco_unit_tests 
-          popd
+          echo "baseref checksum: $base_hash"
+          echo "baseref engine version: $base_engine_ver"
+          echo "headref checksum: $cur_hash"
+          echo "headref engine version: $cur_engine_ver"
+          if [ "$base_hash" != "$cur_hash" ]; then
+              echo "engine checksum for baseref and headref differ"
+              if [ "$base_engine_ver" == "$cur_engine_ver" ]; then
+                  echo "engine version must be bumped"
+                  exit 1
+              else
+                  echo "engine version for baseref and headref differ too, so no bump is required"
+              fi
+          fi

.github/workflows/engine-version-weakcheck.yaml

@@ -0,0 +1,41 @@
+# NOTE: it is UNSAFE to run ANY kind of script when using the pull_request_target trigger!
+# DO NOT TOUCH THIS FILE UNLESS THE TRIGGER IS CHANGED.
+# See warning in https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target.
+
+name: Engine version checks (weak)
+on:
+  pull_request_target:
+    paths:
+      - 'userspace/engine/*.cpp'
+      - 'userspace/engine/*.h'
+
+jobs:
+  paths-filter:
+    runs-on: ubuntu-latest
+    outputs:
+      engine_version_changed: ${{ steps.filter.outputs.engine_version }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: dorny/paths-filter@v2
+      id: filter
+      with:
+        filters: |
+          engine_version:
+            - 'userspace/engine/falco_engine_version.h'
+
+  check-engine-version-weak:
+    runs-on: ubuntu-22.04
+    permissions:
+      pull-requests: write
+    needs: paths-filter
+    if: needs.paths-filter.outputs.engine_version_changed == 'false'
+    steps:
+      - name: Check driver Falco engine version
+        uses: mshick/add-pr-comment@v2
+        with:
+          message: |
+            This PR may bring feature or behavior changes in the Falco engine and may require the engine version to be bumped.
+
+            Please double check **userspace/engine/falco_engine_version.h** file. See [versioning for FALCO_ENGINE_VERSION](https://github.com/falcosecurity/falco/blob/master/RELEASE.md#falco-repo-this-repo).
+
+            /hold

.github/workflows/images_bumper.yml

@@ -1,64 +0,0 @@
-name: Builder and Tester Images Bumper
-
-on:
-  push:
-    branches: [master]
-
-jobs:
-  paths-filter:
-    runs-on: ubuntu-latest
-    outputs:
-      builder_changed: ${{ steps.filter.outputs.builder }}
-      tester_changed: ${{ steps.filter.outputs.tester }}
-    steps:
-    - uses: actions/checkout@v2
-    - uses: dorny/paths-filter@v2
-      id: filter
-      with:
-        filters: |
-          builder:
-            - 'docker/builder/**'
-          tester:
-            - 'docker/tester/**'
-
-  update-builder-tester-images:
-    runs-on: ubuntu-22.04
-    needs: paths-filter
-    if: needs.paths-filter.outputs.builder_changed == 'true' || needs.paths-filter.outputs.tester_changed == 'true'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKERHUB_USER }}
-          password: ${{ secrets.DOCKERHUB_SECRET }}
-          
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-        with:
-          platforms: 'amd64,arm64'
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-      
-      - name: Build and push new builder image
-        if: needs.paths-filter.outputs.builder_changed == 'true'
-        uses: docker/build-push-action@v3
-        with:
-          context: docker/builder
-          platforms: linux/amd64,linux/arm64
-          tags: latest
-          push: true
-
-      - name: Build and push new tester image
-        if: needs.paths-filter.outputs.tester_changed == 'true'
-        uses: docker/build-push-action@v3
-        with:
-          context: docker/tester
-          platforms: linux/amd64,linux/arm64
-          tags: latest
-          push: true

.github/workflows/master.yaml

@@ -9,37 +9,8 @@ concurrency:
   cancel-in-progress: true  
 
 jobs:
-  # We need to use an ubuntu-latest to fetch Falco version because
-  # Falco version is computed by some cmake scripts that do git sorceries
-  # to get the current version.
-  # But centos7 jobs have a git version too old and actions/checkout does not 
-  # fully clone the repo, but uses http rest api instead.
   fetch-version:
-    runs-on: ubuntu-latest
-    # Map the job outputs to step outputs
-    outputs:
-      version: ${{ steps.store_version.outputs.version }}  
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          
-      - name: Install build dependencies
-        run: |
-          sudo apt update 
-          sudo apt install -y cmake build-essential
-      
-      - name: Configure project
-        run: |
-          mkdir build && cd build
-          cmake -DUSE_BUNDLED_DEPS=On ..
-          
-      - name: Load and store Falco version output
-        id: store_version
-        run: |
-          FALCO_VERSION=$(cat build/userspace/falco/config_falco.h | grep 'FALCO_VERSION ' | cut -d' ' -f3 | sed -e 's/^"//' -e 's/"$//')
-          echo "version=${FALCO_VERSION}" >> $GITHUB_OUTPUT     
+    uses: ./.github/workflows/reusable_fetch_version.yaml 
 
   build-dev-packages:
     needs: [fetch-version]
@@ -56,9 +27,28 @@ jobs:
       arch: aarch64
       version: ${{ needs.fetch-version.outputs.version }}
     secrets: inherit
-    
+
+  test-dev-packages:
+    needs: [fetch-version, build-dev-packages]
+    uses: ./.github/workflows/reusable_test_packages.yaml
+    strategy:
+      fail-fast: false
+      matrix:
+        static: ["static", ""]
+    with:
+      arch: x86_64
+      static: ${{ matrix.static != '' && true || false }}
+      version: ${{ needs.fetch-version.outputs.version }}
+  
+  test-dev-packages-arm64:
+    needs: [fetch-version, build-dev-packages-arm64]
+    uses: ./.github/workflows/reusable_test_packages.yaml
+    with:
+      arch: aarch64
+      version: ${{ needs.fetch-version.outputs.version }}
+
   publish-dev-packages:
-    needs: [fetch-version, build-dev-packages, build-dev-packages-arm64]
+    needs: [fetch-version, test-dev-packages, test-dev-packages-arm64]
     uses: ./.github/workflows/reusable_publish_packages.yaml
     with:
       bucket_suffix: '-dev'

.github/workflows/release.yaml

@@ -65,9 +65,28 @@ jobs:
       arch: aarch64
       version: ${{ github.event.release.tag_name }}
     secrets: inherit
+
+  test-packages:
+    needs: [release-settings, build-packages]
+    uses: ./.github/workflows/reusable_test_packages.yaml
+    strategy:
+      fail-fast: false
+      matrix:
+        static: ["static", ""]
+    with:
+      arch: x86_64
+      static: ${{ matrix.static != '' && true || false }}
+      version: ${{ github.event.release.tag_name }}
+  
+  test-packages-arm64:
+    needs: [release-settings, build-packages-arm64]
+    uses: ./.github/workflows/reusable_test_packages.yaml
+    with:
+      arch: aarch64
+      version: ${{ github.event.release.tag_name }}
     
   publish-packages:
-    needs: [release-settings, build-packages, build-packages-arm64]
+    needs: [release-settings, test-packages, test-packages-arm64]
     uses: ./.github/workflows/reusable_publish_packages.yaml
     with:
       bucket_suffix: ${{ needs.release-settings.outputs.bucket_suffix }}

.github/workflows/reusable_build_dev.yaml

@@ -0,0 +1,85 @@
+# This is a reusable workflow used by the master CI
+on:
+  workflow_call:
+    outputs:
+      cmdout:
+        description: "Post-build command output"
+        value: ${{ jobs.build-and-test.outputs.cmdout }}
+    inputs:
+      arch:
+        description: x86_64 or aarch64
+        required: true
+        type: string
+      minimal:
+        description: Minimal build
+        required: true
+        type: boolean
+      build_type:
+        description: One of 'Debug' or 'Release'
+        required: true
+        type: string
+      git_ref:
+        description: Git ref used for checking out the code
+        required: true
+        type: string
+      cmd:
+        description: If defined, this command is executed after a successful build and its output is set in the `cmdout` output
+        required: false
+        default: ''
+        type: string
+       
+jobs:
+  build-and-test:
+    # See https://github.com/actions/runner/issues/409#issuecomment-1158849936
+    runs-on: ${{ (inputs.arch == 'aarch64' && fromJSON('[ "self-hosted", "linux", "ARM64" ]')) || 'ubuntu-22.04' }}
+    container: ${{ (inputs.arch == 'aarch64' && 'ubuntu:22.04') || '' }}
+    outputs:
+      cmdout: ${{ steps.run_cmd.outputs.out }}  
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          ref: ${{ inputs.git_ref }}
+
+      - name: Update base image
+        run: sudo apt update -y
+      
+      - name: Install build dependencies
+        run: sudo DEBIAN_FRONTEND=noninteractive apt install libjq-dev libelf-dev libyaml-cpp-dev cmake build-essential git -y
+
+      - name: Install build dependencies (non-minimal)
+        if: inputs.minimal != true
+        run: sudo DEBIAN_FRONTEND=noninteractive apt install libssl-dev libyaml-dev libc-ares-dev libprotobuf-dev protobuf-compiler libgrpc++-dev protobuf-compiler-grpc rpm libcurl4-openssl-dev linux-headers-$(uname -r) clang llvm -y
+      
+      - name: Prepare project
+        run: |
+          mkdir build
+          pushd build
+          cmake \
+            -DBUILD_FALCO_UNIT_TESTS=On \
+            -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} \
+            -DBUILD_BPF=${{ inputs.minimal == true && 'OFF' || 'ON' }} \
+            -DBUILD_DRIVER=${{ inputs.minimal == true && 'OFF' || 'ON' }} \
+            -DMINIMAL_BUILD=${{ inputs.minimal == true && 'ON' || 'OFF' }} \
+            ..
+          popd
+
+      - name: Build
+        run: |
+          pushd build
+          KERNELDIR=/lib/modules/$(uname -r)/build make -j4 all
+          popd
+
+      - name: Run unit tests
+        run: |
+          pushd build
+          sudo ./unit_tests/falco_unit_tests 
+          popd
+
+      - name: Run command
+        id: run_cmd
+        if: inputs.cmd != ''
+        run: |
+          OUT=$(${{ inputs.cmd }})
+          echo "out=${OUT}" >> $GITHUB_OUTPUT

.github/workflows/reusable_build_docker.yaml

@@ -71,3 +71,4 @@ jobs:
         with:
           name: falco-images
           path: /tmp/falco-*.tar
+          retention-days: 1

.github/workflows/reusable_build_packages.yaml

@@ -36,6 +36,7 @@ jobs:
         with:
           name: bpf_probe_${{ inputs.arch }}.skel.h
           path: skeleton-build/skel_dir/bpf_probe.skel.h
+          retention-days: 1
           
   build-packages:
     # See https://github.com/actions/runner/issues/409#issuecomment-1158849936
@@ -49,7 +50,7 @@ jobs:
           yum -y install centos-release-scl
           yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++
           source /opt/rh/devtoolset-9/enable
-          yum install -y wget git make m4 rpm-build
+          yum install -y wget git make m4 rpm-build perl-IPC-Cmd
     
       - name: Checkout
         uses: actions/checkout@v3
@@ -158,3 +159,59 @@ jobs:
           name: falco-${{ inputs.version }}-static-x86_64.tar.gz
           path: |
             ${{ github.workspace }}/build/falco-${{ inputs.version }}-static-x86_64.tar.gz
+
+  build-wasm-package:
+    if: ${{ inputs.arch == 'x86_64' }}
+    runs-on: ubuntu-latest
+    steps:
+      # Always install deps before invoking checkout action, to properly perform a full clone.
+      - name: Install build dependencies
+        run: |
+          sudo apt update
+          sudo DEBIAN_FRONTEND=noninteractive apt install cmake build-essential git emscripten -y
+
+      - name: Select node version
+        uses: actions/setup-node@v3
+        with:
+          node-version: 14
+    
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          
+      - name: Prepare project
+        run: |
+          mkdir build && cd build
+          emcmake cmake \
+            -DBUILD_BPF=Off \
+            -DBUILD_DRIVER=Off \
+            -DBUILD_LIBSCAP_MODERN_BPF=OFF \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DUSE_BUNDLED_DEPS=On \
+            -DFALCO_ETC_DIR=/etc/falco \
+            -DBUILD_FALCO_UNIT_TESTS=On \
+            -DFALCO_VERSION=${{ inputs.version }} \
+            ..
+          
+      - name: Build project
+        run: |
+          cd build
+          emmake make -j6 all
+      
+      - name: Run unit Tests
+        run: |
+          cd build
+          node ./unit_tests/falco_unit_tests.js
+      
+      - name: Build packages
+        run: |
+          cd build
+          emmake make -j6 package
+          
+      - name: Upload Falco WASM package
+        uses: actions/upload-artifact@v3
+        with:
+          name: falco-${{ inputs.version }}-wasm.tar.gz
+          path: |
+            ${{ github.workspace }}/build/falco-${{ inputs.version }}-wasm.tar.gz

.github/workflows/reusable_fetch_version.yaml

@@ -0,0 +1,40 @@
+# This is a reusable workflow used by master and release CI
+on:
+  workflow_call:
+    outputs:
+      version:
+        description: "Falco version"
+        value: ${{ jobs.fetch-version.outputs.version }}
+    
+jobs:
+  # We need to use an ubuntu-latest to fetch Falco version because
+  # Falco version is computed by some cmake scripts that do git sorceries
+  # to get the current version.
+  # But centos7 jobs have a git version too old and actions/checkout does not 
+  # fully clone the repo, but uses http rest api instead.
+  fetch-version:
+    runs-on: ubuntu-latest
+    # Map the job outputs to step outputs
+    outputs:
+      version: ${{ steps.store_version.outputs.version }}  
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          
+      - name: Install build dependencies
+        run: |
+          sudo apt update 
+          sudo apt install -y cmake build-essential
+      
+      - name: Configure project
+        run: |
+          mkdir build && cd build
+          cmake -DUSE_BUNDLED_DEPS=On ..
+          
+      - name: Load and store Falco version output
+        id: store_version
+        run: |
+          FALCO_VERSION=$(cat build/userspace/falco/config_falco.h | grep 'FALCO_VERSION ' | cut -d' ' -f3 | sed -e 's/^"//' -e 's/"$//')
+          echo "version=${FALCO_VERSION}" >> $GITHUB_OUTPUT

.github/workflows/reusable_publish_packages.yaml

@@ -47,31 +47,31 @@ jobs:
         uses: actions/download-artifact@v3
         with:
           name: falco-${{ inputs.version }}-x86_64.rpm
-          path: /tmp/falco-rpm
+          path: /tmp/falco-build-rpm
 
       - name: Download RPM aarch64
         uses: actions/download-artifact@v3
         with:
           name: falco-${{ inputs.version }}-aarch64.rpm
-          path: /tmp/falco-rpm
+          path: /tmp/falco-build-rpm
 
       - name: Download binary x86_64
         uses: actions/download-artifact@v3
         with:
           name: falco-${{ inputs.version }}-x86_64.tar.gz
-          path: /tmp/falco-bin
+          path: /tmp/falco-build-bin
 
       - name: Download binary aarch64
         uses: actions/download-artifact@v3
         with:
           name: falco-${{ inputs.version }}-aarch64.tar.gz
-          path: /tmp/falco-bin
+          path: /tmp/falco-build-bin
 
       - name: Download static binary x86_64
         uses: actions/download-artifact@v3
         with:
           name: falco-${{ inputs.version }}-static-x86_64.tar.gz
-          path: /tmp/falco-bin-static
+          path: /tmp/falco-build-bin-static
         
       - name: Import gpg key 
         env:
@@ -91,21 +91,21 @@ jobs:
           expect eof
           EOF
           chmod +x ~/sign
-          ~/sign /tmp/falco-rpm/falco-*.rpm
-          rpm --qf %{SIGPGP:pgpsig} -qp /tmp/falco-rpm/falco-*.rpm | grep SHA256
+          ~/sign /tmp/falco-build-rpm/falco-*.rpm
+          rpm --qf %{SIGPGP:pgpsig} -qp /tmp/falco-build-rpm/falco-*.rpm | grep SHA256
           
       - name: Publish rpm
         run: |
-          ./scripts/publish-rpm -f /tmp/falco-rpm/falco-${{ inputs.version }}-x86_64.rpm -f /tmp/falco-rpm/falco-${{ inputs.version }}-aarch64.rpm -r rpm${{ inputs.bucket_suffix }}
+          ./scripts/publish-rpm -f /tmp/falco-build-rpm/falco-${{ inputs.version }}-x86_64.rpm -f /tmp/falco-build-rpm/falco-${{ inputs.version }}-aarch64.rpm -r rpm${{ inputs.bucket_suffix }}
       
       - name: Publish bin
         run: |
-          ./scripts/publish-bin -f /tmp/falco-bin/falco-${{ inputs.version }}-x86_64.tar.gz -r bin${{ inputs.bucket_suffix }} -a x86_64
-          ./scripts/publish-bin -f /tmp/falco-bin/falco-${{ inputs.version }}-aarch64.tar.gz -r bin${{ inputs.bucket_suffix }} -a aarch64
+          ./scripts/publish-bin -f /tmp/falco-build-bin/falco-${{ inputs.version }}-x86_64.tar.gz -r bin${{ inputs.bucket_suffix }} -a x86_64
+          ./scripts/publish-bin -f /tmp/falco-build-bin/falco-${{ inputs.version }}-aarch64.tar.gz -r bin${{ inputs.bucket_suffix }} -a aarch64
           
       - name: Publish static
         run: |
-          ./scripts/publish-bin -f /tmp/falco-bin-static/falco-${{ inputs.version }}-static-x86_64.tar.gz -r bin${{ inputs.bucket_suffix }} -a x86_64
+          ./scripts/publish-bin -f /tmp/falco-build-bin-static/falco-${{ inputs.version }}-static-x86_64.tar.gz -r bin${{ inputs.bucket_suffix }} -a x86_64
           
   publish-packages-deb:
     runs-on: ubuntu-latest
@@ -117,8 +117,7 @@ jobs:
       - name: Install dependencies
         run: |
           apt update -y
-          apt-get install apt-utils bzip2 gpg python python3-pip -y
-          pip install awscli
+          apt-get install apt-utils bzip2 gpg awscli -y
       
       # Configure AWS role; see https://github.com/falcosecurity/test-infra/pull/1102
       # Note: master CI can only push dev packages as we have 2 different roles for master and release.
@@ -132,13 +131,13 @@ jobs:
         uses: actions/download-artifact@v3
         with:
           name: falco-${{ inputs.version }}-x86_64.deb
-          path: /tmp/falco-deb
+          path: /tmp/falco-build-deb
 
       - name: Download deb aarch64
         uses: actions/download-artifact@v3
         with:
           name: falco-${{ inputs.version }}-aarch64.deb
-          path: /tmp/falco-deb
+          path: /tmp/falco-build-deb
 
       - name: Import gpg key 
         env:
@@ -147,4 +146,4 @@ jobs:
           
       - name: Publish deb
         run: |
-          ./scripts/publish-deb -f /tmp/falco-deb/falco-${{ inputs.version }}-x86_64.deb -f /tmp/falco-deb/falco-${{ inputs.version }}-aarch64.deb -r deb${{ inputs.bucket_suffix }}
+          ./scripts/publish-deb -f /tmp/falco-build-deb/falco-${{ inputs.version }}-x86_64.deb -f /tmp/falco-build-deb/falco-${{ inputs.version }}-aarch64.deb -r deb${{ inputs.bucket_suffix }}

.github/workflows/reusable_test_packages.yaml

@@ -0,0 +1,87 @@
+# This is a reusable workflow used by master and release CI
+on:
+  workflow_call:
+    inputs:
+      arch:
+        description: x86_64 or aarch64
+        required: true
+        type: string
+      static:
+        description: Falco packages use a static build
+        required: false
+        type: boolean
+        default: false
+      version:
+        description: The Falco version to use when testing packages
+        required: true
+        type: string
+
+jobs:
+  test-packages:
+    # See https://github.com/actions/runner/issues/409#issuecomment-1158849936
+    runs-on: ${{ (inputs.arch == 'aarch64' && fromJSON('[ "self-hosted", "linux", "ARM64" ]')) || 'ubuntu-latest' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          submodules: 'true'
+      
+      - name: Setup Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '>=1.17.0'
+
+      - name: Download binary
+        uses: actions/download-artifact@v3
+        with:
+          name: falco-${{ inputs.version }}${{ inputs.static && '-static' || '' }}-${{ inputs.arch }}.tar.gz
+      
+      - name: Install Falco package
+        run: |
+          ls falco-*.tar.gz
+          tar -xvf $(ls falco-*.tar.gz)
+          cd falco-${{ inputs.version }}-${{ inputs.arch }}
+          sudo cp -r * /
+
+      # x86_64 job run on ubuntu-22.04 and here we can install kernel-headers
+      - name: Install dependencies for falco-driver-loader tests on x86
+        if: ${{ inputs.arch == 'x86_64' }}
+        run: |
+          sudo apt update -y
+          sudo apt install -y --no-install-recommends build-essential clang make llvm gcc dkms linux-headers-$(uname -r)
+
+      - name: Install go-junit-report
+        run: |
+          pushd submodules/falcosecurity-testing
+          go install github.com/jstemmer/go-junit-report/v2@latest
+          popd
+  
+      - name: Generate regression test files
+        run: |
+          pushd submodules/falcosecurity-testing
+          go generate ./...
+          popd
+
+      # Right now we are not able to install kernel-headers on our ARM64 self-hosted runner.
+      # For this reason, we disable the falco-driver-loader tests, which require kernel headers on the host.
+      - name: Run regression tests
+        run: |
+          pushd submodules/falcosecurity-testing
+          ./build/falco.test -falco-static=${{ inputs.static && 'true' || 'false' }} -test.timeout=90s -test.v >> ./report.txt 2>&1 || true
+          if ${{ inputs.static && 'false' || 'true' }}; then
+            ./build/falcoctl.test -test.timeout=90s -test.v >> ./report.txt 2>&1 || true
+            ./build/k8saudit.test -test.timeout=90s -test.v >> ./report.txt 2>&1 || true
+            if ${{ inputs.arch == 'x86_64' && 'true' || 'false' }}; then
+                sudo ./build/falco-driver-loader.test -test.timeout=90s -test.v >> ./report.txt 2>&1 || true
+            fi
+          fi
+          cat ./report.txt | go-junit-report -set-exit-code > report.xml
+          popd
+
+      - name: Test Summary
+        if: always() # run this even if previous step fails
+        uses: test-summary/action@v2
+        with:
+          paths: "submodules/falcosecurity-testing/report.xml"
+          show: "fail"

.gitignore

@@ -2,14 +2,6 @@
 *~
 *.pyc
 
-test/traces-negative
-test/traces-positive
-test/traces-info
-test/job-results
-test/.phoronix-test-suite
-test/results*.json.*
-test/build
-
 .vscode/*
 
 *.idea*

.gitmodules

@@ -2,3 +2,7 @@
 	path = submodules/falcosecurity-rules
 	url = https://github.com/falcosecurity/rules.git
 	branch = main
+[submodule "submodules/falcosecurity-testing"]
+	path = submodules/falcosecurity-testing
+	url = https://github.com/falcosecurity/testing.git
+	branch = main

ADOPTERS.md

@@ -68,12 +68,16 @@ This is a list of production adopters of Falco (in alphabetical order):
 
 * [Shapesecurity/F5](https://www.shapesecurity.com/) Shapesecurity defends against application fraud attacks like Account Take Over, Credential Stuffing, Fake Accounts, etc. Required by FedRamp certification, we needed to find a FIM solution to help monitor and protect our Kubernetes clusters. Traditional FIM solutions were not scalable and not working for our environment, but with Falco we found the solution we needed. Falco's detection capabilities have helped us identify anomalous behaviour within our clusters. We leverage Sidekick (https://github.com/falcosecurity/charts/tree/master/falcosidekick) to send Falco alerts to a PubSub which in turn publishes those alerts to our SIEM (SumoLogic)
 
-* [Yahoo! JAPAN](https://www.yahoo.co.jp/) Yahoo! JAPAN is a leading company of internet in Japan. We build an AI Platform in our private cloud and provide it to scientists in our company. AI Platform is a multi-tenant Kubernetes environment and more flexible, faster, more efficient Machine Learning environment. Falco is used to detect unauthorized commands and malicious access and our AI Platform is monitored and alerted by Falco.
-
 * [Sysdig](https://www.sysdig.com/) Sysdig originally created Falco in 2016 to detect unexpected or suspicious activity using a rules engine on top of the data that comes from the sysdig kernel system call driver. Sysdig provides tooling to help with vulnerability management, compliance, detection, incident response and forensics in Cloud-native environments. Sysdig Secure has extended Falco to include: a rule library, the ability to update macros, lists & rules via the user interface and API, automated tuning of rules, and rule creation based on profiling known system behavior. On top of the basic Falco rules, Sysdig Secure implements the concept of a "Security policy" that can comprise several rules which are evaluated for a user-defined infrastructure scope like Kubernetes namespaces, OpenShift clusters, deployment workload, cloud regions etc.
 
+* [Thales Group](https://www.thalesgroup.com) Thales is a global technology leader with more than 81,000 employees on five continents. The Thales Group is investing in digital and “deep tech” innovations – Big Data, artificial intelligence, connectivity, cybersecurity and quantum technology – to build a future we can all trust. In the past few years, the Cloud-Native paradigms and its frameworks and tools have challenged the way applications and services are developed, delivered, and instantiated. All sorts of services are container-based workloads managed by higher level layers of orchestration such as the Kubernetes environment. Thales is committed to develop Cloud-Native services and to provide its customers with security features that ensure their applications and services are protected against cyber threats. Falco is a framework that can help Thales' products and services reach the level of trust, security and safety our clients need.
+
+* [Vinted](https://vinted.com/) Vinted uses Falco to continuously monitor container activities, identifying security threats, and ensuring compliance. The container-native approach, rule-based real-time threat detection, community support, extensibility, and compliance capabilities are the main factors why we chose it to enhance Vinted Kubernetes security. Falco Sidekick is used to send critical and warning severity alerts to our incident management solution (RTIR).
+
 * [Xenit AB](https://xenit.se/contact/) Xenit is a growth company with services within cloud and digital transformation. We provide an open-source Kubernetes framework that we leverage to help our customers get their applications to production as quickly and as securely as possible. We use Falco's detection capabilities to identify anomalous behaviour within our clusters in both Azure and AWS.
 
+* [Yahoo! JAPAN](https://www.yahoo.co.jp/) Yahoo! JAPAN is a leading company of internet in Japan. We build an AI Platform in our private cloud and provide it to scientists in our company. AI Platform is a multi-tenant Kubernetes environment and more flexible, faster, more efficient Machine Learning environment. Falco is used to detect unauthorized commands and malicious access and our AI Platform is monitored and alerted by Falco.
+
 ## Projects that use Falco libs
 
 * [R6/Phoenix](https://r6security.com/) is an attack surface protection company that uses moving target defense to provide fully automated, proactive and devops friendly security to its customers. There are a set of policies you can add to enable the moving target defense capabilities. Some of them are triggered by a combination of Falco's findings. You can kill, restart and rename pods according to the ever changing policies.

CHANGELOG.md

@@ -1,5 +1,142 @@
 # Change Log
 
+## v0.35.1
+
+Released on 2023-06-29
+
+### Major Changes
+
+
+### Minor Changes
+
+* update(userspace): change description of snaplen option stating only performance implications [[#2634](https://github.com/falcosecurity/falco/pull/2634)] - [@loresuso](https://github.com/loresuso)
+* update(cmake): bump libs to 0.11.3 [[#2662](https://github.com/falcosecurity/falco/pull/2662)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* cleanup(config): minor config clarifications [[#2651](https://github.com/falcosecurity/falco/pull/2651)] - [@incertum](https://github.com/incertum)
+* update(cmake): bump falco rules to v1.0.1 [[#2648](https://github.com/falcosecurity/falco/pull/2648)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* chore(userspace/falco): make source matching error more expressive [[#2623](https://github.com/falcosecurity/falco/pull/2623)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* update(.github): integrate Go regression tests [[#2437](https://github.com/falcosecurity/falco/pull/2437)] - [@jasondellaluce](https://github.com/jasondellaluce)
+
+
+### Bug Fixes
+
+* fix(scripts): fixed falco-driver-loader to manage debian kernel rt and cloud flavors. [[#2627](https://github.com/falcosecurity/falco/pull/2627)] - [@FedeDP](https://github.com/FedeDP)
+* fix(userspace/falco): solve live multi-source issues when loading more than two sources [[#2653](https://github.com/falcosecurity/falco/pull/2653)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* fix(driver-loader): fix ubuntu kernel version parsing [[#2635](https://github.com/falcosecurity/falco/pull/2635)] - [@therealbobo](https://github.com/therealbobo)
+* fix(userspace): switch to timer_settime API for stats writer. [[#2646](https://github.com/falcosecurity/falco/pull/2646)] - [@FedeDP](https://github.com/FedeDP)
+
+
+
+### Non user-facing changes
+
+* CI: bump ubuntu version for tests-driver-loader-integration job [[#2661](https://github.com/falcosecurity/falco/pull/2661)] - [@Andreagit97](https://github.com/Andreagit97)
+
+## v0.35.0
+
+Released on 2023-06-07
+
+### Major Changes
+
+* BREAKING CHANGE: support for metadata enrichment from Mesos has been removed. [[#2465](https://github.com/falcosecurity/falco/pull/2465)] - [@leogr](https://github.com/leogr)
+
+* new(falco): introduce new metrics w/ Falco internal: metrics snapshot option and new metrics config [[#2333](https://github.com/falcosecurity/falco/pull/2333)] - [@incertum](https://github.com/incertum)
+* new(scripts): properly manage talos prebuilt drivers [[#2537](https://github.com/falcosecurity/falco/pull/2537)] - [@FedeDP](https://github.com/FedeDP)
+* new(release): released container images are now signed with cosign [[#2546](https://github.com/falcosecurity/falco/pull/2546)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* new(ci): ported master and release artifacts publishing CI to gha [[#2501](https://github.com/falcosecurity/falco/pull/2501)] - [@FedeDP](https://github.com/FedeDP)
+* new(app_actions): introduce base_syscalls user option [[#2428](https://github.com/falcosecurity/falco/pull/2428)] - [@incertum](https://github.com/incertum)
+* new(falco/config): add new configurations for http_output that allow custom CA certificates and stores. [[#2458](https://github.com/falcosecurity/falco/pull/2458)] - [@alacuku](https://github.com/alacuku)
+* new(userspace): add a new `syscall_drop_failed` config option to drop failed syscalls exit events [[#2456](https://github.com/falcosecurity/falco/pull/2456)] - [@FedeDP](https://github.com/FedeDP)
+
+
+### Minor Changes
+
+* update(cmake): bump Falco rules to 1.0.0 [[#2618](https://github.com/falcosecurity/falco/pull/2618)] - [@loresuso](https://github.com/loresuso)
+* update(cmake): bump libs to 0.11.1 [[#2614](https://github.com/falcosecurity/falco/pull/2614)] - [@loresuso](https://github.com/loresuso)
+* update(cmake): bump plugins to latest versions [[#2610](https://github.com/falcosecurity/falco/pull/2610)] - [@loresuso](https://github.com/loresuso)
+* update(cmake): bump falco rules to 1.0.0-rc1 [[#2609](https://github.com/falcosecurity/falco/pull/2609)] - [@loresuso](https://github.com/loresuso)
+* update(cmake): bump libs to 0.11.0 [[#2608](https://github.com/falcosecurity/falco/pull/2608)] - [@loresuso](https://github.com/loresuso)
+* cleanup(docs): update release.md [[#2599](https://github.com/falcosecurity/falco/pull/2599)] - [@incertum](https://github.com/incertum)
+* update(cmake): bump libs to 0.11.0-rc5 and driver to 5.0.1. [[#2600](https://github.com/falcosecurity/falco/pull/2600)] - [@FedeDP](https://github.com/FedeDP)
+* cleanup(docs): adjust falco readme style and content [[#2594](https://github.com/falcosecurity/falco/pull/2594)] - [@incertum](https://github.com/incertum)
+* cleanup(userspace, config): improve metrics UX, add include_empty_values option [[#2593](https://github.com/falcosecurity/falco/pull/2593)] - [@incertum](https://github.com/incertum)
+* feat: add the curl and jq packages to the falco-no-driver docker image [[#2581](https://github.com/falcosecurity/falco/pull/2581)] - [@therealdwright](https://github.com/therealdwright)
+* update: add missing exception, required_engine_version, required_plugin_version to -L json output [[#2584](https://github.com/falcosecurity/falco/pull/2584)] - [@loresuso](https://github.com/loresuso)
+* feat: add image source OCI label to docker images [[#2592](https://github.com/falcosecurity/falco/pull/2592)] - [@therealdwright](https://github.com/therealdwright)
+* cleanup(config): improve falco config [[#2571](https://github.com/falcosecurity/falco/pull/2571)] - [@incertum](https://github.com/incertum)
+* update(cmake): bump libs and plugins to latest dev versions [[#2586](https://github.com/falcosecurity/falco/pull/2586)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* chore(userspace/falco): always print invalid syscalls from custom set [[#2578](https://github.com/falcosecurity/falco/pull/2578)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* update(build): upgrade falcoctl to 0.5.0 [[#2572](https://github.com/falcosecurity/falco/pull/2572)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* chore(userspace/falco/app): print all supported plugin caps [[#2564](https://github.com/falcosecurity/falco/pull/2564)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* update: get rules details with `-l` or `-L` flags when json output format is specified [[#2544](https://github.com/falcosecurity/falco/pull/2544)] - [@loresuso](https://github.com/loresuso)
+* update!: bump libs version, and support latest plugin features, add --nodriver option [[#2552](https://github.com/falcosecurity/falco/pull/2552)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* cleanup(actions): now modern bpf support `-A` flag [[#2551](https://github.com/falcosecurity/falco/pull/2551)] - [@Andreagit97](https://github.com/Andreagit97)
+* update: `falco-driver-loader` now uses now uses $TMPDIR if set [[#2518](https://github.com/falcosecurity/falco/pull/2518)] - [@jabdr](https://github.com/jabdr)
+* update: improve control and UX of ignored events [[#2509](https://github.com/falcosecurity/falco/pull/2509)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* update: bump libs and adapt Falco to new libsinsp event source management [[#2507](https://github.com/falcosecurity/falco/pull/2507)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* new(app_actions)!: adjust base_syscalls option, add base_syscalls.repair [[#2457](https://github.com/falcosecurity/falco/pull/2457)] - [@incertum](https://github.com/incertum)
+* update(scripts): support al2022 and al2023 in falco-driver-loader. [[#2494](https://github.com/falcosecurity/falco/pull/2494)] - [@FedeDP](https://github.com/FedeDP)
+* update: sync libs with newest event name APIs [[#2471](https://github.com/falcosecurity/falco/pull/2471)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* update!: remove `--mesos-api`, `-pmesos`, and `-pm` command-line flags [[#2465](https://github.com/falcosecurity/falco/pull/2465)] - [@leogr](https://github.com/leogr)
+* cleanup(unit_tests): try making test_configure_interesting_sets more robust [[#2464](https://github.com/falcosecurity/falco/pull/2464)] - [@incertum](https://github.com/incertum)
+
+
+### Bug Fixes
+
+* fix: unquote quoted URL's to avoid libcurl errors [[#2596](https://github.com/falcosecurity/falco/pull/2596)] - [@therealdwright](https://github.com/therealdwright)
+* fix(userspace/engine): store alternatives as array in -L json output [[#2597](https://github.com/falcosecurity/falco/pull/2597)] - [@loresuso](https://github.com/loresuso)
+* fix(userspace/engine): store required engine version as string in -L json output [[#2595](https://github.com/falcosecurity/falco/pull/2595)] - [@loresuso](https://github.com/loresuso)
+* fix(userspace/falco): report plugin deps rules issues in any case [[#2589](https://github.com/falcosecurity/falco/pull/2589)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* fix(userspace): hotreload on wrong metrics [[#2582](https://github.com/falcosecurity/falco/pull/2582)] - [@therealbobo](https://github.com/therealbobo)
+* fix(userspace): check the supported number of online CPUs with modern bpf [[#2575](https://github.com/falcosecurity/falco/pull/2575)] - [@Andreagit97](https://github.com/Andreagit97)
+* fix(userspace/falco): don't hang on terminating error when multi sourcing [[#2576](https://github.com/falcosecurity/falco/pull/2576)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* fix(userspace/falco): properly format numeric values in metrics [[#2569](https://github.com/falcosecurity/falco/pull/2569)] - [@jasondellaluce](https://github.com/jasondellaluce)
+* fix(scripts): properly support debian kernel releases embedded in kernel version [[#2377](https://github.com/falcosecurity/falco/pull/2377)] - [@FedeDP](https://github.com/FedeDP)
+
+
+
+### Non user-facing changes
+
+* docs(README.md): add scope/status badge and simply doc structure [[#2611](https://github.com/falcosecurity/falco/pull/2611)] - [@leogr](https://github.com/leogr)
+* build(deps): Bump submodules/falcosecurity-rules from `3471984` to `16fb709` [[#2598](https://github.com/falcosecurity/falco/pull/2598)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+* docs(proposals): Falco roadmap management [[#2547](https://github.com/falcosecurity/falco/pull/2547)] - [@leogr](https://github.com/leogr)
+* build(deps): Bump submodules/falcosecurity-rules from `b2290ad` to `3471984` [[#2577](https://github.com/falcosecurity/falco/pull/2577)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+* update(build): libs 0.11.0-rc2 [[#2573](https://github.com/falcosecurity/falco/pull/2573)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* build(deps): Bump submodules/falcosecurity-rules from `3f52480` to `b2290ad` [[#2570](https://github.com/falcosecurity/falco/pull/2570)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+* update(ci): use repo instead of master branch for reusable workflows [[#2568](https://github.com/falcosecurity/falco/pull/2568)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* cleanup(ci): cleaned up circleci workflow. [[#2566](https://github.com/falcosecurity/falco/pull/2566)] - [@FedeDP](https://github.com/FedeDP)
+* build(deps): Bump requests from 2.26.0 to 2.31.0 in /test [[#2567](https://github.com/falcosecurity/falco/pull/2567)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+* fix(ci): simplify and fix multi-arch image publishing process [[#2542](https://github.com/falcosecurity/falco/pull/2542)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* fix(ci): get the manifest for the correct tag [[#2563](https://github.com/falcosecurity/falco/pull/2563)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* build(deps): Bump submodules/falcosecurity-rules from `3f52480` to `6da15ae` [[#2559](https://github.com/falcosecurity/falco/pull/2559)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+* fix(ci): properly use `docker save` to store images. [[#2560](https://github.com/falcosecurity/falco/pull/2560)] - [@FedeDP](https://github.com/FedeDP)
+* fix(ci): docker arg is named `TARGETARCH`. [[#2558](https://github.com/falcosecurity/falco/pull/2558)] - [@FedeDP](https://github.com/FedeDP)
+* fix(ci): set docker TARGET_ARCH [[#2557](https://github.com/falcosecurity/falco/pull/2557)] - [@FedeDP](https://github.com/FedeDP)
+* fix(ci): use normal docker to build docker images, instead of buildx. [[#2556](https://github.com/falcosecurity/falco/pull/2556)] - [@FedeDP](https://github.com/FedeDP)
+* docs: improve documentation and description of base_syscalls option [[#2515](https://github.com/falcosecurity/falco/pull/2515)] - [@Happy-Dude](https://github.com/Happy-Dude)
+* Updating Falco branding guidelines [[#2493](https://github.com/falcosecurity/falco/pull/2493)] - [@aijamalnk](https://github.com/aijamalnk)
+* build(deps): Bump submodules/falcosecurity-rules from `f773578` to `6da15ae` [[#2553](https://github.com/falcosecurity/falco/pull/2553)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+* fix(cmake): properly exclude prereleases when fetching latest tag from cmake [[#2550](https://github.com/falcosecurity/falco/pull/2550)] - [@FedeDP](https://github.com/FedeDP)
+* fix(ci): load falco image before building falco-driver-loader [[#2549](https://github.com/falcosecurity/falco/pull/2549)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* fix(ci): correctly tag slim manifest [[#2545](https://github.com/falcosecurity/falco/pull/2545)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* cleanup(config): modern bpf is no more experimental [[#2538](https://github.com/falcosecurity/falco/pull/2538)] - [@Andreagit97](https://github.com/Andreagit97)
+* new(ci): add RC/prerelease support [[#2533](https://github.com/falcosecurity/falco/pull/2533)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* fix(ci): configure ECR public region [[#2531](https://github.com/falcosecurity/falco/pull/2531)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* fix(ci): falco images directory, ecr login [[#2528](https://github.com/falcosecurity/falco/pull/2528)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* fix(ci): separate rpm/bin/bin-static/deb packages before publication, rename bin-static [[#2527](https://github.com/falcosecurity/falco/pull/2527)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* fix(ci): add Cloudfront Distribution ID [[#2525](https://github.com/falcosecurity/falco/pull/2525)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* fix(ci): escape heredoc [[#2521](https://github.com/falcosecurity/falco/pull/2521)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* chore(ci): build-musl-package does not need to wait for build-packages anymore [[#2520](https://github.com/falcosecurity/falco/pull/2520)] - [@FedeDP](https://github.com/FedeDP)
+* fix: ci Falco version [[#2516](https://github.com/falcosecurity/falco/pull/2516)] - [@FedeDP](https://github.com/FedeDP)
+* fix(ci): fetch version step, download rpms/debs, minor change [[#2519](https://github.com/falcosecurity/falco/pull/2519)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* chore(ci): properly install recent version of git (needed >= 2.18 by checkout action) [[#2514](https://github.com/falcosecurity/falco/pull/2514)] - [@FedeDP](https://github.com/FedeDP)
+* fix(ci): enable toolset before every make command [[#2513](https://github.com/falcosecurity/falco/pull/2513)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* fix(ci): remove unnecessary mv [[#2512](https://github.com/falcosecurity/falco/pull/2512)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* fix(ci): bucket -> bucket_suffix [[#2511](https://github.com/falcosecurity/falco/pull/2511)] - [@LucaGuerra](https://github.com/LucaGuerra)
+* build(deps): Bump submodules/falcosecurity-rules from `5857874` to `1bd7e4a` [[#2478](https://github.com/falcosecurity/falco/pull/2478)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+* build(deps): Bump submodules/falcosecurity-rules from `694adf5` to `5857874` [[#2473](https://github.com/falcosecurity/falco/pull/2473)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+* cleanup(ci): properly set a concurrency for CI workflows. [[#2470](https://github.com/falcosecurity/falco/pull/2470)] - [@FedeDP](https://github.com/FedeDP)
+* build(deps): Bump submodules/falcosecurity-rules from `e0646a0` to `694adf5` [[#2466](https://github.com/falcosecurity/falco/pull/2466)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+* build(deps): Bump submodules/falcosecurity-rules from `0b0f50f` to `e0646a0` [[#2460](https://github.com/falcosecurity/falco/pull/2460)] - [@dependabot[bot]](https://github.com/apps/dependabot)
+
 ## v0.34.1
 
 Released on 2023-02-20

CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2019 The Falco Authors.
+# Copyright (C) 2023 The Falco Authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 # the License. You may obtain a copy of the License at
@@ -20,6 +20,14 @@ option(MINIMAL_BUILD "Build a minimal version of Falco, containing only the engi
 option(MUSL_OPTIMIZED_BUILD "Enable if you want a musl optimized build" OFF)
 option(BUILD_FALCO_UNIT_TESTS "Build falco unit tests" OFF)
 
+if(EMSCRIPTEN)
+  set(USE_BUNDLED_DEPS ON CACHE BOOL "" FORCE)
+  set(BUILD_DRIVER OFF CACHE BOOL "" FORCE)
+  set(ENABLE_DKMS OFF CACHE BOOL "" FORCE)
+  set(BUILD_BPF OFF CACHE BOOL "" FORCE)
+  set(CPACK_GENERATOR TGZ CACHE BOOL "" FORCE)
+endif()
+
 # gVisor is currently only supported on Linux x86_64
 if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" AND CMAKE_SYSTEM_NAME MATCHES "Linux" AND NOT MINIMAL_BUILD)
   option(BUILD_FALCO_GVISOR "Build gVisor support for Falco" ON)
@@ -68,7 +76,11 @@ if(NOT DEFINED FALCO_ETC_DIR)
 endif()
 
 # This will be used to print the architecture for which Falco is compiled.
-set(FALCO_TARGET_ARCH ${CMAKE_SYSTEM_PROCESSOR})
+if (EMSCRIPTEN)
+  set(FALCO_TARGET_ARCH "wasm")
+else()
+  set(FALCO_TARGET_ARCH ${CMAKE_SYSTEM_PROCESSOR})
+endif()
 
 if(NOT FALCO_EXTRA_DEBUG_FLAGS)
   set(FALCO_EXTRA_DEBUG_FLAGS "-D_DEBUG")
@@ -95,7 +107,10 @@ endif()
 
 # explicitly set hardening flags
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-set(FALCO_SECURITY_FLAGS "-Wl,-z,relro,-z,now -fstack-protector-strong")
+set(FALCO_SECURITY_FLAGS "")
+if(NOT EMSCRIPTEN)
+  set(FALCO_SECURITY_FLAGS "${FALCO_SECURITY_FLAGS} -Wl,-z,relro,-z,now -fstack-protector-strong")
+endif()
 if(CMAKE_BUILD_TYPE STREQUAL "release")
   set(FALCO_SECURITY_FLAGS "${FALCO_SECURITY_FLAGS} -D_FORTIFY_SOURCE=2")
 endif()
@@ -118,8 +133,6 @@ set(CMAKE_CXX_FLAGS_DEBUG "${FALCO_EXTRA_DEBUG_FLAGS}")
 set(CMAKE_C_FLAGS_RELEASE "-O3 -fno-strict-aliasing -DNDEBUG")
 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -fno-strict-aliasing -DNDEBUG")
 
-include(GetFalcoVersion)
-
 set(PACKAGE_NAME "falco")
 set(DRIVER_NAME "falco")
 set(DRIVER_DEVICE_NAME "falco")
@@ -147,25 +160,26 @@ include(ExternalProject)
 # libs
 include(falcosecurity-libs)
 
+# compute FALCO_VERSION (depends on libs)
+include(falco-version)
+
 # jq
 include(jq)
 
 # nlohmann-json
 include(njson)
 
-# b64
-include(b64)
-
 # yaml-cpp
 include(yaml-cpp)
 
-if(NOT MINIMAL_BUILD)
+if(NOT WIN32 AND NOT APPLE AND NOT MINIMAL_BUILD AND NOT EMSCRIPTEN)
   # OpenSSL
   include(openssl)
 
   # libcurl
   include(curl)
 
+  # todo(jasondellaluce,rohith-raju): support webserver for non-linux builds too
   # cpp-httlib
   include(cpp-httplib)
 endif()
@@ -173,14 +187,18 @@ endif()
 include(cxxopts)
 
 # One TBB
-include(tbb)
+if (NOT EMSCRIPTEN)
+  include(tbb)
+endif()
 
-if(NOT MINIMAL_BUILD)
+if (NOT MINIMAL_BUILD)
   include(zlib)
-  include(cares)
-  include(protobuf)
-  # gRPC
-  include(grpc)
+  if (NOT WIN32 AND NOT APPLE AND NOT EMSCRIPTEN)
+    include(cares)
+    include(protobuf)
+    # gRPC
+    include(grpc)
+  endif()
 endif()
 
 # Installation
@@ -189,17 +207,11 @@ install(FILES falco.yaml DESTINATION "${FALCO_ETC_DIR}" COMPONENT "${FALCO_COMPO
 if(NOT MINIMAL_BUILD)
   # Coverage
   include(Coverage)
-
-  # Tests
-  add_subdirectory(test)
 endif()
 
 # Rules
 include(rules)
 
-# Dockerfiles
-add_subdirectory(docker)
-
 # Clang format
 # add_custom_target(format COMMAND clang-format --style=file -i $<TARGET_PROPERTY:falco,SOURCES> COMMENT "Formatting ..." VERBATIM)
 
@@ -217,12 +229,11 @@ add_subdirectory(scripts)
 add_subdirectory(userspace/engine)
 add_subdirectory(userspace/falco)
 
-if(NOT MUSL_OPTIMIZED_BUILD)
+if(NOT WIN32 AND NOT APPLE AND NOT EMSCRIPTEN AND NOT MUSL_OPTIMIZED_BUILD)
   include(plugins)
+  include(falcoctl)
 endif()
 
-include(falcoctl)
-
 # Packages configuration
 include(CPackConfig)
 

OWNERS

@@ -4,6 +4,8 @@ approvers:
   - jasondellaluce
   - fededp
   - andreagit97
+  - incertum
+  - LucaGuerra
 reviewers:
   - kaizhe
 emeritus_approvers:

README.md

@@ -1,71 +1,20 @@
-<p align="center"><img src="https://raw.githubusercontent.com/falcosecurity/community/master/logo/primary-logo.png" width="360"></p>
-<p align="center"><b>Cloud Native Runtime Security.</b></p>
+# Falco
 
-<hr>
+[![Latest release](https://img.shields.io/github/v/release/falcosecurity/falco?style=for-the-badge)](https://github.com/falcosecurity/falco/releases/latest) [![Supported Architectures](https://img.shields.io/badge/ARCHS-x86__64%7Caarch64-blueviolet?style=for-the-badge)](https://github.com/falcosecurity/falco/releases/latest) [![License](https://img.shields.io/github/license/falcosecurity/falco?style=for-the-badge)](COPYING) [![Docs](https://img.shields.io/badge/docs-latest-green.svg?style=for-the-badge)](https://falco.org/docs)
 
-[![Build Status](https://img.shields.io/circleci/build/github/falcosecurity/falco/master?style=for-the-badge)](https://circleci.com/gh/falcosecurity/falco) [![CII Best Practices Summary](https://img.shields.io/cii/summary/2317?label=CCI%20Best%20Practices&style=for-the-badge)](https://bestpractices.coreinfrastructure.org/projects/2317) [![GitHub](https://img.shields.io/github/license/falcosecurity/falco?style=for-the-badge)](COPYING) [![Latest](https://img.shields.io/github/v/release/falcosecurity/falco?style=for-the-badge)](https://github.com/falcosecurity/falco/releases/latest) ![Architectures](https://img.shields.io/badge/ARCHS-x86__64%7Caarch64-blueviolet?style=for-the-badge)
+[![Falco Core Repository](https://github.com/falcosecurity/evolution/blob/main/repos/badges/falco-core-blue.svg)](https://github.com/falcosecurity/evolution/blob/main/REPOSITORIES.md#core-scope) [![Stable](https://img.shields.io/badge/status-stable-brightgreen?style=for-the-badge)](https://github.com/falcosecurity/evolution/blob/main/REPOSITORIES.md#stable)  [![OpenSSF Best Practices](https://img.shields.io/cii/summary/2317?label=OpenSSF%20Best%20Practices&style=for-the-badge)](https://bestpractices.coreinfrastructure.org/projects/2317)
 
-## Latest releases
+[![Falco](https://falco.org/img/brand/falco-horizontal-color.svg)](https://falco.org)
 
-<!-- 
-Badges in the following table are constructed by using the
-https://img.shields.io/badge/dynamic/xml endpoint.
+[Falco](https://falco.org/) is a cloud native runtime security tool for Linux operating systems. It is designed to detect and alert on abnormal behavior and potential security threats in real-time.
 
-Parameters are configured for fetching packages from S3 before 
-(filtered by prefix, sorted in ascending order) and for picking 
-the latest package by using an XPath selector after.
+At its core, Falco is a kernel monitoring and detection agent that observes events, such as syscalls, based on custom rules. Falco can enhance these events by integrating metadata from the container runtime and Kubernetes. The collected events can be analyzed off-host in SIEM or data lake systems.
 
-- Common query parameters:
-
-color=#300aec7
-style=flat-square
-label=Falco
-
-- DEB packages parameters:
-
-url=https://falco-distribution.s3-eu-west-1.amazonaws.com/?prefix=packages/deb/stable/falco-
-query=substring-before(substring-after((/*[name()='ListBucketResult']/*[name()='Contents'])[last()]/*[name()='Key'],"falco-"),".asc")
-
-- RPM packages parameters:
-
-url=https://falco-distribution.s3-eu-west-1.amazonaws.com/?prefix=packages/rpm/falco-
-query=substring-before(substring-after((/*[name()='ListBucketResult']/*[name()='Contents'])[last()]/*[name()='Key'],"falco-"),".asc")
-
-- BIN packages parameters:
-
-url=https://falco-distribution.s3-eu-west-1.amazonaws.com/?prefix=packages/bin/x86_64/falco-
-query=substring-after((/*[name()='ListBucketResult']/*[name()='Contents'])[last()]/*[name()='Key'], "falco-")
-
-Notes:
- - if more than 1000 items are present under as S3 prefix, 
-   the actual latest package will be not picked;
-   see https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html
- - for `-dev` packages, the S3 prefix is modified accordingly
- - finally, all parameters are URL encoded and appended to the badge endpoint
-
--->
-
-|              | stable                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-|--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| rpm-x86_64          | [![rpm](https://img.shields.io/badge/dynamic/xml?color=%2300aec7&style=flat-square&label=Falco&query=substring-before%28substring-after%28%28%2F%2A%5Bname%28%29%3D%27ListBucketResult%27%5D%2F%2A%5Bname%28%29%3D%27Contents%27%5D%29%5Blast%28%29%5D%2F%2A%5Bname%28%29%3D%27Key%27%5D%2C%22falco-%22%29%2C%22.asc%22%29&url=https%3A%2F%2Ffalco-distribution.s3-eu-west-1.amazonaws.com%2F%3Fprefix%3Dpackages%2Frpm%2Ffalco-%26delimiter=aarch64)][2]          |
-| deb-x86_64          | [![deb](https://img.shields.io/badge/dynamic/xml?color=%2300aec7&style=flat-square&label=Falco&query=substring-before%28substring-after%28%28%2F%2A%5Bname%28%29%3D%27ListBucketResult%27%5D%2F%2A%5Bname%28%29%3D%27Contents%27%5D%29%5Blast%28%29%5D%2F%2A%5Bname%28%29%3D%27Key%27%5D%2C%22falco-%22%29%2C%22.asc%22%29&url=https%3A%2F%2Ffalco-distribution.s3-eu-west-1.amazonaws.com%2F%3Fprefix%3Dpackages%2Fdeb%2Fstable%2Ffalco-%26delimiter=aarch64)][4] |
-| binary-x86_64       | [![bin](https://img.shields.io/badge/dynamic/xml?color=%2300aec7&style=flat-square&label=Falco&query=substring-after%28%28%2F%2A%5Bname%28%29%3D%27ListBucketResult%27%5D%2F%2A%5Bname%28%29%3D%27Contents%27%5D%29%5Blast%28%29%5D%2F%2A%5Bname%28%29%3D%27Key%27%5D%2C%20%22falco-%22%29&url=https%3A%2F%2Ffalco-distribution.s3-eu-west-1.amazonaws.com%2F%3Fprefix%3Dpackages%2Fbin%2Fx86_64%2Ffalco-)][6]                                                     |
-| rpm-aarch64    | [![rpm](https://img.shields.io/badge/dynamic/xml?color=%2300aec7&style=flat-square&label=Falco&query=substring-before%28substring-after%28%28%2F%2A%5Bname%28%29%3D%27ListBucketResult%27%5D%2F%2A%5Bname%28%29%3D%27Contents%27%5D%29%5Blast%28%29%5D%2F%2A%5Bname%28%29%3D%27Key%27%5D%2C%22falco-%22%29%2C%22.asc%22%29&url=https%3A%2F%2Ffalco-distribution.s3-eu-west-1.amazonaws.com%2F%3Fprefix%3Dpackages%2Frpm%2Ffalco-%26delimiter=x86_64)][2]           |
-| deb-aarch64    | [![deb](https://img.shields.io/badge/dynamic/xml?color=%2300aec7&style=flat-square&label=Falco&query=substring-before%28substring-after%28%28%2F%2A%5Bname%28%29%3D%27ListBucketResult%27%5D%2F%2A%5Bname%28%29%3D%27Contents%27%5D%29%5Blast%28%29%5D%2F%2A%5Bname%28%29%3D%27Key%27%5D%2C%22falco-%22%29%2C%22.asc%22%29&url=https%3A%2F%2Ffalco-distribution.s3-eu-west-1.amazonaws.com%2F%3Fprefix%3Dpackages%2Fdeb%2Fstable%2Ffalco-%26delimiter=x86_64)][4]  |
-| binary-aarch64 | [![bin](https://img.shields.io/badge/dynamic/xml?color=%2300aec7&style=flat-square&label=Falco&query=substring-after%28%28%2F%2A%5Bname%28%29%3D%27ListBucketResult%27%5D%2F%2A%5Bname%28%29%3D%27Contents%27%5D%29%5Blast%28%29%5D%2F%2A%5Bname%28%29%3D%27Key%27%5D%2C%20%22falco-%22%29&url=https%3A%2F%2Ffalco-distribution.s3-eu-west-1.amazonaws.com%2F%3Fprefix%3Dpackages%2Fbin%2Faarch64%2Ffalco-)][8]                                                    |
-
-For comprehensive information on the latest updates and changes to the project, please refer to the [change log](CHANGELOG.md). Additionally, we have documented the [release process](RELEASE.md) for delivering new versions of Falco.
-
-## Introduction to Falco
-
-[Falco](https://falco.org/), originally created by [Sysdig](https://sysdig.com), is an incubating project under the [CNCF](https://cncf.io).
-
-Falco is a cloud native runtime security tool for Linux operating systems. It is designed to detect and alert on abnormal behavior and potential security threats in real-time.
-
-At its core, Falco is a kernel event monitoring and detection agent that captures events, such as syscalls, based on custom rules. Falco can enhance these events by integrating metadata from the container runtime and Kubernetes. The collected events can be analyzed off-host in SIEM or data lake systems.
+Falco, originally created by [Sysdig](https://sysdig.com), is an incubating project under the [Cloud Native Computing Foundation](https://cncf.io) (CNCF) used in production by various [organisations](https://github.com/falcosecurity/falco/blob/master/ADOPTERS.md).
 
 For detailed technical information and insights into the cyber threats that Falco can detect, visit the official [Falco](https://falco.org/) website.
 
+For comprehensive information on the latest updates and changes to the project, please refer to the [change log](CHANGELOG.md). Additionally, we have documented the [release process](RELEASE.md) for delivering new versions of Falco.
 
 ## Falco Repo: Powering the Core of The Falco Project
 
@@ -97,8 +46,7 @@ Considerations and guidance for Falco adopters:
 
 ## How to Contribute
 
-Please refer to the [contributing guide](https://github.com/falcosecurity/.github/blob/main/CONTRIBUTING.md) and the [code of conduct](https://github.com/falcosecurity/evolution/CODE_OF_CONDUCT.md) for more information on how to contribute.
-
+Please refer to the [contributing guide](https://github.com/falcosecurity/.github/blob/main/CONTRIBUTING.md) and the [code of conduct](https://github.com/falcosecurity/evolution/blob/main/CODE_OF_CONDUCT.md) for more information on how to contribute.
 
 ## Join the Community
 
@@ -124,11 +72,24 @@ To report security vulnerabilities, please follow the community process outlined
 
 Stay updated with Falco's evolving capabilities by exploring the [Falco Roadmap](https://github.com/orgs/falcosecurity/projects/5), which provides insights into the features currently under development and planned for future releases.
 
-
 ## License
 
 Falco is licensed to you under the [Apache 2.0](./COPYING) open source license.
 
+## Why is Falco in C++ rather than Go or {language}?
+
+1. The first lines of code at the base of Falco were written some time ago, where Go didn't yet have the same level of maturity and adoption as today.
+2. The Falco execution model is sequential and mono-thread due to the statefulness requirements of the tool, and so most of the concurrency-related selling points of the Go runtime would not be leveraged at all.
+3. The Falco code deals with very low-level programming in many places (e.g. some headers are shared with the eBPF probe and the Kernel module), and we all know that interfacing Go with C is possible but brings tons of complexity and tradeoffs to the table.
+4. As a security tool meant to consume a crazy high throughput of events per second, Falco needs to squeeze performance in all hot paths at runtime and requires deep control on memory allocation, which the Go runtime can't provide (there's also garbage collection involved).
+5. Although Go didn't suit the engineering requirements of the core of Falco, we still thought that it could be a good candidate for writing Falco extensions through the plugin system. This is the main reason we gave special attention and high priority to the development of the plugin-sdk-go.
+6. Go is not a requirement for having statically-linked binaries. In fact, we provide fully-static Falco builds since few years. The only issue with those is that the plugin system can't be supported with the current dynamic library model we currently have.
+7. The plugin system has been envisioned to support multiple languages, so on our end maintaining a C-compatible codebase is the best strategy to ensure maximum cross-language compatibility.
+8. In general, plugins have GLIBC requirements/dependencies because they have low-level C bindings required for dynamic loading. A potential solution for the future could be to also support plugin to be statically-linked at compilation time and so released as bundled in the Falco binary. Although no work started yet in this direction, this would solve most issues you reported and would provide a totally-static binary too. Of course, this would not be compatible with dynamic loading anymore, but it may be a viable solution for our static-build flavor of Falco.
+9. Memory safety is definitely a concern and we try our best to keep an high level of quality even though C++ is quite error prone. For instance, we try to use smart pointers whenever possible, we build the libraries with an address sanitizer in our CI, we run Falco through Valgrind before each release, and have ways to stress-test it to detect performance regressions or weird memory usage (e.g. https://github.com/falcosecurity/event-generator). On top of that, we also have third parties auditing the codebase by time to time. None of this make a perfect safety standpoint of course, but we try to maximize our odds. Go would definitely make our life easier from this perspective, however the tradeoffs never made it worth it so far due to the points above.
+10. The C++ codebase of falcosecurity/libs, which is at the core of Falco, is quite large and complex. Porting all that code to another language would be a major effort requiring lots of development resource and with an high chance of failure and regression. As such, our approach so far has been to choose refactors and code polishing instead, up until we'll reach an optimal level of stability, quality, and modularity, on that portion of code. This would allow further developments to be smoother and more feasibile in the future.
+
+
 ## Resources
 
  - [Governance](https://github.com/falcosecurity/evolution/blob/main/GOVERNANCE.md)
@@ -138,13 +99,3 @@ Falco is licensed to you under the [Apache 2.0](./COPYING) open source license.
  - [Repositories Guidelines](https://github.com/falcosecurity/evolution/blob/main/REPOSITORIES.md)
  - [Repositories List](https://github.com/falcosecurity/evolution/blob/main/README.md#repositories)
  - [Adopters List](https://github.com/falcosecurity/falco/blob/master/ADOPTERS.md)
-
-
-[1]: https://download.falco.org/?prefix=packages/rpm-dev/
-[2]: https://download.falco.org/?prefix=packages/rpm/
-[3]: https://download.falco.org/?prefix=packages/deb-dev/stable/
-[4]: https://download.falco.org/?prefix=packages/deb/stable/
-[5]: https://download.falco.org/?prefix=packages/bin-dev/x86_64/
-[6]: https://download.falco.org/?prefix=packages/bin/x86_64/
-[7]: https://download.falco.org/?prefix=packages/bin-dev/aarch64/
-[8]: https://download.falco.org/?prefix=packages/bin/aarch64/

RELEASE.md

@@ -217,7 +217,7 @@ This section provides more details around the versioning of the components that
 
 ### Falco repo (this repo)
 - Falco version is a git tag (`x.y.z`), see [Procedures](#procedures) section. Note that the Falco version is a sem-ver-like schema, but not fully compatible with sem-ver.
-- [FALCO_ENGINE_VERSION](https://github.com/falcosecurity/falco/blob/master/userspace/engine/falco_engine_version.h) is not sem-ver and must be bumped either when a backward incompatible change has been introduced to the rules files syntax and/or `FALCO_FIELDS_CHECKSUM` computed via `falco --list -N | sha256sum` has changed. The primary idea is that when new filter / display fields (see currently supported [Falco fields](https://falco.org/docs/rules/supported-fields/)) are introduced, a version change indicates that these fields were not available in previous engine versions. See the [rules release guidelines](https://github.com/falcosecurity/rules/blob/main/RELEASE.md#versioning-a-ruleset) to understand how this affects the versioning of Falco rules. Breaking changes introduced in the Falco engine are not necessarily tied to the drivers or libs versions. Lastly, `FALCO_ENGINE_VERSION` is typically incremented once during a Falco release cycle, while `FALCO_FIELDS_CHECKSUM` is bumped whenever necessary during the development and testing phases of the release cycle.
+- [FALCO_ENGINE_VERSION](https://github.com/falcosecurity/falco/blob/master/userspace/engine/falco_engine_version.h) is not sem-ver and must be bumped either when a backward incompatible change has been introduced to the rules files syntax and loading logic, and/or when `FALCO_ENGINE_CHECKSUM` has changed. The checksum is computed by considering the available rules fields (see currently supported [Falco fields](https://falco.org/docs/reference/rules/supported-fields/)), the event types (see currently supported [Falco events](https://falco.org/docs/reference/rules/supported-events/)), and the supported driver schema version. A checksum indicates that something was not available in previous engine versions. See the [rules release guidelines](https://github.com/falcosecurity/rules/blob/main/RELEASE.md#versioning-a-ruleset) to understand how this affects the versioning of Falco rules. Breaking changes introduced in the Falco engine are not necessarily tied to the drivers or libs versions. The version number must be incremented every time and only when a single change or an atomic group of changes - which meet the criteria described above - is included in the `master` branch. Thus, a version bump can occur multiple times during the development and testing phases of a given release cycle. A given version bump must not group multiple changes that occurred sporadically during the release cycle.
 - During development and release preparation, libs and driver reference commits are often bumped in Falco's cmake setup ([falcosecurity-libs cmake](https://github.com/falcosecurity/falco/blob/master/cmake/modules/falcosecurity-libs.cmake#L30) and [driver cmake](https://github.com/falcosecurity/falco/blob/master/cmake/modules/driver.cmake#L29)) in order to merge new Falco features. In practice, they are mostly bumped at the same time referencing the same `libs` commit. However, for the official Falco build `FALCOSECURITY_LIBS_VERSION` flag that references the stable libs version is used (read below).
 - Similarly, Falco plugins versions are bumped in Falco's cmake setup ([plugins cmake](https://github.com/falcosecurity/falco/blob/master/cmake/modules/plugins.cmake)) and those versions are the ones used for the Falco release.
 - At release time Plugin, Libs and Driver versions are compatible with Falco.

brand/README.md

@@ -7,13 +7,9 @@ Falco is an open source security project whose brand and identity are governed b
 
 This document describes the official branding guidelines of The Falco Project. Please see the [Falco Branding](https://falco.org/community/falco-brand/) page on our website for further details.
 
-Content in this document can be used to publicly share about Falco.
-
-
-
 ### Logo
 
-There are 3 logos available for use in this directory. Use the primary logo unless required otherwise due to background issues, or printing.
+There are 3 logos available for use in this directory. Use the primary logo unless required otherwise due to background issues or printing.
 
 The Falco logo is Apache 2 licensed and free to use in media and publication for the CNCF Falco project.
 
@@ -36,55 +32,6 @@ The primary colors are those in the first two rows.
 
 > Cloud Native Runtime Security
 
-### What is Falco?
-
-Falco is a runtime security project originally created by Sysdig, Inc.
-Falco was contributed to the CNCF in October 2018.
-The CNCF now owns The Falco Project.
-
-### What is Runtime Security?
-
-Runtime security refers to an approach to preventing unwanted activity on a computer system. 
-With runtime security, an operator deploys **both** prevention tooling (access control, policy enforcement, etc) along side detection tooling (systems observability, anomaly detection, etc).
-Runtime security is the practice of using detection tooling to detect unwanted behavior, such that it can then be prevented using prevention techniques.
-Runtime security is a holistic approach to defense, and useful in scenarios where prevention tooling either was unaware of an exploit or attack vector, or when defective applications are ran in even the most secure environment.
-
-### What does Falco do?
-
-Falco consumes signals from the Linux kernel, and container management tools such as Docker and Kubernetes.
-Falco parses the signals and asserts them against security rules.
-If a rule has been violated, Falco triggers an alert. 
-
-### How does Falco work?
-
-Falco traces kernel events and reports information about the system calls being executed at runtime.
-Falco leverages the extended berkeley packet filter (eBPF) which is a kernel feature implemented for dynamic crash-resilient and secure code execution in the kernel. 
-Falco enriches these kernel events with information about containers running on the system.
-Falco also can consume signals from other input streams such as the containerd socket, the Kubernetes API server and the Kubernetes audit log.
-At runtime, Falco will reason about these events and assert them against configured security rules.
-Based on the severity of a violation an alert is triggered.
-These alerts are configurable and extensible, for instance sending a notification or [plumbing through to other projects like Prometheus](https://github.com/falcosecurity/falco-exporter). 
-
-### Benefits of using Falco
-
- - **Strengthen Security** Create security rules driven by a context-rich and flexible engine to define unexpected application behavior.
- - **Reduce Risk** Immediately respond to policy violation alerts by plugging Falco into your current security response workflows and processes.
- - **Leverage up-to-date Rules** Alert using community-sourced detections of malicious activity and CVE exploits.
-    
-### Falco and securing Kubernetes
-
-Securing Kubernetes requires putting controls in place to detect unexpected behavior that could be malicious or harmful to a cluster or application(s). 
-
-Examples of malicious behavior include: 
-
- - Exploits of unpatched and new vulnerabilities in applications or Kubernetes itself. 
- - Insecure configurations in applications or Kubernetes itself. 
- - Leaked or weak credentials or secret material.
- - Insider threats from adjacent applications running at the same layer. 
-
-Falco is capable of [consuming the Kubernetes audit logs](https://kubernetes.io/docs/tasks/debug-application-cluster/falco/#use-falco-to-collect-audit-events).
-By adding Kubernetes application context, and Kubernetes audit logs teams can understand who did what.
-
 ### Writing about Falco
 
 ##### Yes
@@ -100,49 +47,31 @@ Notice the capitalization of the following terms.
  - the falco project
  - the Falco project
 
-### Encouraged Phrasing
-
-Below are phrases that the project has reviewed, and found to be effective ways of messaging Falco's value add.
-Even when processes are in place for vulnerability scanning and implementing pod security and network policies, not every risk will be addressed. You still need mechanisms to confirm these security barriers are effective, help configure them, and provide with a last line of defense when they fail.
-
-##### Falco as a factory
-
-This term refers to the concept that Falco is a stateless processing engine. A large amount of data comes into the engine, but meticulously crafted security alerts come out.
-
-##### The engine that powers...
-
-Falco ultimately is a security engine. It reasons about signals coming from a system at runtime, and can alert if an anomaly is detected.
-
-##### Anomaly detection
-
-This refers to an event that occurs with something unusual, concerning, or odd occurs.
-We can associate anomalies with unwanted behavior, and alert in their presence.
-
-##### Detection tooling
-
-Falco does not prevent unwanted behavior.
-Falco however alerts when unusual behavior occurs.
-This is commonly referred to as **detection** or **forensics**.
-
 ---
 
-# Glossary 
+# Glossary
 
-#### Probe
+This section contains key terms specifically used within the context of The Falco Project. For a more comprehensive list of Falco-related terminology, we invite you to visit the [Glossary](https://falco.org/docs/reference/glossary/) page on our official website.
+
+#### eBPF Probe
 
 Used to describe the `.o` object that would be dynamically loaded into the kernel as a secure and stable (e)BPF probe. 
 This is one option used to pass kernel events up to userspace for Falco to consume.
-Sometimes this word is incorrectly used to refer to a `module`.
 
-#### Module
+#### Modern eBPF Probe
+
+More robust [eBPF probe](#ebpf-probe), which brings the CO-RE paradigm, better performances, and maintainability. 
+Unlike the legacy probe, the modern eBPF probe is not shipped as a separate artifact but bundled into the Falco binary itself.
+This is one option used to pass kernel events up to userspace for Falco to consume.
+
+#### Kernel Module
 
 Used to describe the `.ko` object that would be loaded into the kernel as a potentially risky kernel module.
 This is one option used to pass kernel events up to userspace for Falco to consume.
-Sometimes this word is incorrectly used to refer to a `probe`.
 
 #### Driver 
 
-The global term for the software that sends events from the kernel. Such as the eBPF `probe` or the `kernel module`.
+The global term for the software that sends events from the kernel. Such as the [eBPF probe](#ebpf-probe), the [Modern eBPF probe](#modern-ebpf-probe), or the [Kernel Module](#kernel-module).
 
 #### Plugin
 
@@ -150,13 +79,5 @@ Used to describe a dynamic shared library (`.so` files in Unix, `.dll` files in
 
 #### Falco
 
-The name of the project, and also the name of [the main engine](https://github.com/falcosecurity/falco) that the rest of the project is built on.
-
-#### Sysdig, Inc
-
-The name of the company that originally created The Falco Project, and later donated to the CNCF.
-
-#### sysdig 
-
-A [CLI tool](https://github.com/draios/sysdig) used to evaluate kernel system events at runtime. 
+The name of the project and also the name of [the main engine](https://github.com/falcosecurity/falco) that the rest of the project is built on.
 

cmake/modules/CPackConfig.cmake

@@ -20,24 +20,36 @@ set(CPACK_PACKAGE_VERSION "${FALCO_VERSION}")
 set(CPACK_PACKAGE_VERSION_MAJOR "${FALCO_VERSION_MAJOR}")
 set(CPACK_PACKAGE_VERSION_MINOR "${FALCO_VERSION_MINOR}")
 set(CPACK_PACKAGE_VERSION_PATCH "${FALCO_VERSION_PATCH}")
-set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CMAKE_SYSTEM_PROCESSOR}")
 set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_SOURCE_DIR}/cmake/cpack/CMakeCPackOptions.cmake")
 set(CPACK_STRIP_FILES "ON")
 set(CPACK_PACKAGE_RELOCATABLE "OFF")
+if (EMSCRIPTEN)
+  set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-wasm")
+else()
+  set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CMAKE_SYSTEM_PROCESSOR}")
+endif()
 
 # Built packages will include only the following components
 set(CPACK_INSTALL_CMAKE_PROJECTS
-  "${CMAKE_CURRENT_BINARY_DIR};${FALCO_COMPONENT_NAME};${FALCO_COMPONENT_NAME};/"
-  "${CMAKE_CURRENT_BINARY_DIR};${DRIVER_COMPONENT_NAME};${DRIVER_COMPONENT_NAME};/"
+  "${CMAKE_CURRENT_BINARY_DIR};${FALCO_COMPONENT_NAME};${FALCO_COMPONENT_NAME};/" 
 )
-if(NOT MUSL_OPTIMIZED_BUILD) # static builds do not have plugins
+
+if(CMAKE_SYSTEM_NAME MATCHES "Linux") # only Linux has drivers
   list(APPEND CPACK_INSTALL_CMAKE_PROJECTS
-    "${CMAKE_CURRENT_BINARY_DIR};${PLUGINS_COMPONENT_NAME};${PLUGINS_COMPONENT_NAME};/"
-  )
+    "${CMAKE_CURRENT_BINARY_DIR};${DRIVER_COMPONENT_NAME};${DRIVER_COMPONENT_NAME};/")
+endif()
+
+if(NOT WIN32 AND NOT APPLE AND NOT EMSCRIPTEN AND NOT MUSL_OPTIMIZED_BUILD) # static builds do not have plugins
+  list(APPEND CPACK_INSTALL_CMAKE_PROJECTS
+    "${CMAKE_CURRENT_BINARY_DIR};${PLUGINS_COMPONENT_NAME};${PLUGINS_COMPONENT_NAME};/")
 endif()
 
 if(NOT CPACK_GENERATOR)
+  if (CMAKE_SYSTEM_NAME MATCHES "Linux")
     set(CPACK_GENERATOR DEB RPM TGZ)
+  else()
+    set(CPACK_GENERATOR TGZ)
+  endif()
 endif()
 
 message(STATUS "Using package generators: ${CPACK_GENERATOR}")

cmake/modules/GetFalcoVersion.cmake

@@ -1,84 +0,0 @@
-#
-# Copyright (C) 2020 The Falco Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations under the License.
-#
-
-# Retrieve git ref and commit hash
-include(GetGitRevisionDescription)
-
-# Create the falco version variable according to git index
-if(NOT FALCO_VERSION)
-  # Try to obtain the exact git tag
-  git_get_exact_tag(FALCO_TAG)
-  if(NOT FALCO_TAG)
-      # Obtain the closest tag
-      git_describe(FALCO_VERSION "--always" "--tags" "--abbrev=7")
-      string(REGEX MATCH "^[0-9]+.[0-9]+.[0-9]+$" FALCO_TAG ${FALCO_VERSION})
-      if(FALCO_VERSION MATCHES "NOTFOUND$" OR FALCO_TAG STREQUAL "")
-        # Fetch current hash
-        get_git_head_revision(refspec FALCO_HASH)
-        if(NOT FALCO_HASH OR FALCO_HASH MATCHES "NOTFOUND$")
-          set(FALCO_VERSION "0.0.0")
-        else()
-          # Obtain the closest tag
-          git_get_latest_tag(FALCO_LATEST_TAG)
-          if(NOT FALCO_LATEST_TAG OR FALCO_LATEST_TAG MATCHES "NOTFOUND$")
-            set(FALCO_VERSION "0.0.0")
-          else()
-            # Compute commit delta since tag
-            git_get_delta_from_tag(FALCO_DELTA ${FALCO_LATEST_TAG} ${FALCO_HASH})
-            if(NOT FALCO_DELTA OR FALCO_DELTA MATCHES "NOTFOUND$")
-              set(FALCO_VERSION "0.0.0")
-            else()
-              # Cut hash to 7 bytes
-              string(SUBSTRING ${FALCO_HASH} 0 7 FALCO_HASH)
-              # Format FALCO_VERSION to be semver with prerelease and build part
-              set(FALCO_VERSION
-                    "${FALCO_LATEST_TAG}-${FALCO_DELTA}+${FALCO_HASH}")
-            endif()
-          endif()
-        endif()
-      endif()
-      # Format FALCO_VERSION to be semver with prerelease and build part
-      string(REPLACE "-g" "+" FALCO_VERSION "${FALCO_VERSION}")
-  else()
-    # A tag has been found: use it as the Falco version
-    set(FALCO_VERSION "${FALCO_TAG}")
-  endif()
-endif()
-
-# Remove the starting "v" in case there is one
-string(REGEX REPLACE "^v(.*)" "\\1" FALCO_VERSION "${FALCO_VERSION}")
-
-# TODO(leodido) > ensure Falco version is semver before extracting parts Populate partial version variables
-string(REGEX MATCH "^(0|[1-9][0-9]*)" FALCO_VERSION_MAJOR "${FALCO_VERSION}")
-string(REGEX REPLACE "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\..*" "\\2" FALCO_VERSION_MINOR "${FALCO_VERSION}")
-string(REGEX REPLACE "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*).*" "\\3" FALCO_VERSION_PATCH
-                     "${FALCO_VERSION}")
-string(
-  REGEX
-  REPLACE
-    "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)-((0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*)(\\.(0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*))*).*"
-    "\\5"
-    FALCO_VERSION_PRERELEASE
-    "${FALCO_VERSION}")
-
-if(FALCO_VERSION_PRERELEASE STREQUAL "${FALCO_VERSION}")
-  set(FALCO_VERSION_PRERELEASE "")
-endif()
-if(NOT FALCO_VERSION_BUILD)
-  string(REGEX REPLACE ".*\\+([0-9a-zA-Z-]+(\\.[0-9a-zA-Z-]+)*)" "\\1" FALCO_VERSION_BUILD "${FALCO_VERSION}")
-endif()
-if(FALCO_VERSION_BUILD STREQUAL "${FALCO_VERSION}")
-  set(FALCO_VERSION_BUILD "")
-endif()
-
-message(STATUS "Falco version: ${FALCO_VERSION}")

cmake/modules/GetGitRevisionDescription.cmake

@@ -1,275 +0,0 @@
-# * Returns a version string from Git
-#
-# These functions force a re-configure on each git commit so that you can trust the values of the variables in your
-# build system.
-#
-# get_git_head_revision(<refspecvar> <hashvar> [<additional arguments to git describe> ...])
-#
-# Returns the refspec and sha hash of the current head revision
-#
-# git_describe(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe on the source tree, and adjusting the output so that it tests false if an error
-# occurs.
-#
-# git_get_exact_tag(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe --exact-match on the source tree, and adjusting the output so that it tests false
-# if there was no exact matching tag.
-#
-# git_local_changes(<var>)
-#
-# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes. Uses the return code of "git diff-index --quiet
-# HEAD --". Does not regard untracked files.
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author: 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net> http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010. Distributed under the Boost Software License, Version 1.0. (See
-# accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-if(__get_git_revision_description)
-  return()
-endif()
-set(__get_git_revision_description YES)
-
-# We must run the following at "include" time, not at function call time, to find the path to this module rather than
-# the path to a calling list file
-get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
-
-function(get_git_head_revision _refspecvar _hashvar)
-  set(GIT_PARENT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-  set(GIT_DIR "${GIT_PARENT_DIR}/.git")
-  while(NOT EXISTS "${GIT_DIR}") # .git dir not found, search parent directories
-    set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
-    get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
-    if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
-      # We have reached the root directory, we are not in git
-      set(${_refspecvar}
-          "GITDIR-NOTFOUND"
-          PARENT_SCOPE)
-      set(${_hashvar}
-          "GITDIR-NOTFOUND"
-          PARENT_SCOPE)
-      return()
-    endif()
-    set(GIT_DIR "${GIT_PARENT_DIR}/.git")
-  endwhile()
-  # check if this is a submodule
-  if(NOT IS_DIRECTORY ${GIT_DIR})
-    file(READ ${GIT_DIR} submodule)
-    string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_RELATIVE ${submodule})
-    get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
-    get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE)
-  endif()
-  set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
-  if(NOT EXISTS "${GIT_DATA}")
-    file(MAKE_DIRECTORY "${GIT_DATA}")
-  endif()
-
-  if(NOT EXISTS "${GIT_DIR}/HEAD")
-    return()
-  endif()
-  set(HEAD_FILE "${GIT_DATA}/HEAD")
-  configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY)
-
-  configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in" "${GIT_DATA}/grabRef.cmake" @ONLY)
-  include("${GIT_DATA}/grabRef.cmake")
-
-  set(${_refspecvar}
-      "${HEAD_REF}"
-      PARENT_SCOPE)
-  set(${_hashvar}
-      "${HEAD_HASH}"
-      PARENT_SCOPE)
-endfunction()
-
-function(git_get_latest_tag _var)
-  if(NOT GIT_FOUND)
-    find_package(Git QUIET)
-  endif()
-
-  # We use git describe --tags `git rev-list --exclude "*.*.*-*" --tags --max-count=1`
-  # Note how we eclude prereleases tags (the ones with "-alphaX")
-  execute_process(COMMAND
-          "${GIT_EXECUTABLE}"
-          rev-list
-          --exclude "*.*.*-*"
-          --tags
-          --max-count=1
-          WORKING_DIRECTORY
-          "${CMAKE_CURRENT_SOURCE_DIR}"
-          RESULT_VARIABLE
-          res
-          OUTPUT_VARIABLE
-          tag_hash
-          ERROR_QUIET
-          OUTPUT_STRIP_TRAILING_WHITESPACE)
-  if(NOT res EQUAL 0)
-    set(out "${tag_hash}-${res}-NOTFOUND" PARENT_SCOPE)
-    return()
-  endif()
-
-  execute_process(COMMAND
-    "${GIT_EXECUTABLE}"
-    describe
-    --tags
-    ${tag_hash}
-    WORKING_DIRECTORY
-    "${CMAKE_CURRENT_SOURCE_DIR}"
-    RESULT_VARIABLE
-    res
-    OUTPUT_VARIABLE
-    out
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-  if(NOT res EQUAL 0)
-    set(out "${out}-${res}-NOTFOUND")
-  endif()
-  set(${_var} "${out}" PARENT_SCOPE)
-endfunction()
-
-function(git_get_delta_from_tag _var tag hash)
-  if(NOT GIT_FOUND)
-    find_package(Git QUIET)
-  endif()
-
-  # Count commits in HEAD
-  execute_process(COMMAND
-    "${GIT_EXECUTABLE}"
-    rev-list
-    --count
-    ${hash}
-    WORKING_DIRECTORY
-    "${CMAKE_CURRENT_SOURCE_DIR}"
-    RESULT_VARIABLE
-    res
-    OUTPUT_VARIABLE
-    out_counter_head
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-  if(NOT res EQUAL 0)
-    set(${_var} "HEADCOUNT-NOTFOUND" PARENT_SCOPE)
-    return()
-  endif()
-
-  # Count commits in latest tag
-  execute_process(COMMAND
-    "${GIT_EXECUTABLE}"
-    rev-list
-    --count
-    ${tag}
-    WORKING_DIRECTORY
-    "${CMAKE_CURRENT_SOURCE_DIR}"
-    RESULT_VARIABLE
-    res
-    OUTPUT_VARIABLE
-    out_counter_tag
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-  if(NOT res EQUAL 0)
-    set(${_var} "TAGCOUNT-NOTFOUND" PARENT_SCOPE)
-    return()
-  endif()
-
-  execute_process(COMMAND
-    expr
-    ${out_counter_head} - ${out_counter_tag}
-    WORKING_DIRECTORY
-    "${CMAKE_CURRENT_SOURCE_DIR}"
-    RESULT_VARIABLE
-    res
-    OUTPUT_VARIABLE
-    out_delta
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-  if(NOT res EQUAL 0)
-    set(${_var} "DELTA-NOTFOUND" PARENT_SCOPE)
-    return()
-  endif()
-  set(${_var} "${out_delta}" PARENT_SCOPE)
-endfunction()
-
-function(git_describe _var)
-  if(NOT GIT_FOUND)
-    find_package(Git QUIET)
-  endif()
-  get_git_head_revision(refspec hash)
-  if(NOT GIT_FOUND)
-    set(${_var}
-            "GIT-NOTFOUND"
-            PARENT_SCOPE)
-    return()
-  endif()
-  if(NOT hash)
-    set(${_var}
-            "HEAD-HASH-NOTFOUND"
-            PARENT_SCOPE)
-    return()
-  endif()
-
-  execute_process(COMMAND
-          "${GIT_EXECUTABLE}"
-          describe
-          ${hash}
-          ${ARGN}
-          WORKING_DIRECTORY
-          "${CMAKE_CURRENT_SOURCE_DIR}"
-          RESULT_VARIABLE
-          res
-          OUTPUT_VARIABLE
-          out
-          ERROR_QUIET
-          OUTPUT_STRIP_TRAILING_WHITESPACE)
-  if(NOT res EQUAL 0)
-    set(out "${out}-${res}-NOTFOUND")
-  endif()
-
-  set(${_var}
-          "${out}"
-          PARENT_SCOPE)
-endfunction()
-
-function(git_get_exact_tag _var)
-  git_describe(out --exact-match ${ARGN})
-  set(${_var}
-      "${out}"
-      PARENT_SCOPE)
-endfunction()
-
-function(git_local_changes _var)
-  if(NOT GIT_FOUND)
-    find_package(Git QUIET)
-  endif()
-  get_git_head_revision(refspec hash)
-  if(NOT GIT_FOUND)
-    set(${_var}
-        "GIT-NOTFOUND"
-        PARENT_SCOPE)
-    return()
-  endif()
-  if(NOT hash)
-    set(${_var}
-        "HEAD-HASH-NOTFOUND"
-        PARENT_SCOPE)
-    return()
-  endif()
-
-  execute_process(
-    COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    RESULT_VARIABLE res
-    OUTPUT_VARIABLE out
-    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-  if(res EQUAL 0)
-    set(${_var}
-        "CLEAN"
-        PARENT_SCOPE)
-  else()
-    set(${_var}
-        "DIRTY"
-        PARENT_SCOPE)
-  endif()
-endfunction()

cmake/modules/GetGitRevisionDescription.cmake.in

@@ -1,41 +0,0 @@
-#
-# Internal file for GetGitRevisionDescription.cmake
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-set(HEAD_HASH)
-
-file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
-
-string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
-if(HEAD_CONTENTS MATCHES "ref")
-	# named branch
-	string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
-	if(EXISTS "@GIT_DIR@/${HEAD_REF}")
-		configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-	else()
-		configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
-		file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
-		if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
-			set(HEAD_HASH "${CMAKE_MATCH_1}")
-		endif()
-	endif()
-else()
-	# detached HEAD
-	configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
-endif()
-
-if(NOT HEAD_HASH)
-	file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
-	string(STRIP "${HEAD_HASH}" HEAD_HASH)
-endif()

cmake/modules/cpp-httplib.cmake

@@ -24,8 +24,8 @@ else()
 
 	ExternalProject_Add(cpp-httplib
 		PREFIX "${PROJECT_BINARY_DIR}/cpp-httplib-prefix"
-		URL "https://github.com/yhirose/cpp-httplib/archive/refs/tags/v0.11.3.tar.gz"
-		URL_HASH "SHA256=799b2daa0441d207f6cd1179ae3a34869722084a434da6614978be1682c1e12d"
+		URL "https://github.com/yhirose/cpp-httplib/archive/refs/tags/v0.13.1.tar.gz"
+		URL_HASH "SHA256=9b837d290b61e3f0c4239da0b23bbf14c382922e2bf2a9bac21c1e3feabe1ff9"
 		CONFIGURE_COMMAND ""
 		BUILD_COMMAND ""
 		INSTALL_COMMAND "")	

cmake/modules/driver-repo/CMakeLists.txt

@@ -15,11 +15,12 @@ cmake_minimum_required(VERSION 3.5.1)
 project(driver-repo NONE)
 
 include(ExternalProject)
+message(STATUS "Driver repository: ${DRIVER_REPO}")
 message(STATUS "Driver version: ${DRIVER_VERSION}")
 
 ExternalProject_Add(
   driver
-  URL "https://github.com/falcosecurity/libs/archive/${DRIVER_VERSION}.tar.gz"
+  URL "https://github.com/${DRIVER_REPO}/archive/${DRIVER_VERSION}.tar.gz"
   URL_HASH "${DRIVER_CHECKSUM}"
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""

cmake/modules/driver.cmake

@@ -20,18 +20,29 @@ if(DRIVER_SOURCE_DIR)
   set(DRIVER_VERSION "0.0.0-local")
   message(STATUS "Using local version for driver: '${DRIVER_SOURCE_DIR}'")
 else()
+  # DRIVER_REPO accepts a repository name (<org name>/<repo name>) alternative to the falcosecurity/libs repository.
+  # In case you want to test against a fork of falcosecurity/libs just pass the variable -
+  # ie., `cmake -DDRIVER_REPO=<your-gh-handle>/libs ..` 
+  if (NOT DRIVER_REPO)
+    set(DRIVER_REPO "falcosecurity/libs")
+  endif()
+
   # DRIVER_VERSION accepts a git reference (branch name, commit hash, or tag) to the falcosecurity/libs repository
   # which contains the driver source code under the `/driver` directory.
   # The chosen driver version must be compatible with the given FALCOSECURITY_LIBS_VERSION.
   # In case you want to test against another driver version (or branch, or commit) just pass the variable -
   # ie., `cmake -DDRIVER_VERSION=dev ..`
   if(NOT DRIVER_VERSION)
-    set(DRIVER_VERSION "5.0.1+driver")
-    set(DRIVER_CHECKSUM "SHA256=8b197b916b6419dac8fb41807aa05d822164c7bfd2c3eef66d20d060a05a485a")
+    set(DRIVER_VERSION "6.0.0+driver")
+    set(DRIVER_CHECKSUM "SHA256=573cef7b9c69cfe1d5d8b873d2a20ad8235a2a96997df6bcebd120692dee7a91")
   endif()
 
   # cd /path/to/build && cmake /path/to/source
-  execute_process(COMMAND "${CMAKE_COMMAND}" -DDRIVER_VERSION=${DRIVER_VERSION} -DDRIVER_CHECKSUM=${DRIVER_CHECKSUM}
+  execute_process(COMMAND "${CMAKE_COMMAND}"
+      -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}"
+      -DDRIVER_REPO=${DRIVER_REPO}
+      -DDRIVER_VERSION=${DRIVER_VERSION}
+      -DDRIVER_CHECKSUM=${DRIVER_CHECKSUM}
     ${DRIVER_CMAKE_SOURCE_DIR} WORKING_DIRECTORY ${DRIVER_CMAKE_WORKING_DIR})
 
   # cmake --build .

cmake/modules/falco-version.cmake

@@ -0,0 +1,48 @@
+#
+# Copyright (C) 2020 The Falco Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+#
+
+# Retrieve git ref and commit hash
+include(GetVersionFromGit)
+
+# Get Falco version variable according to git index
+if(NOT FALCO_VERSION)
+  set(FALCO_VERSION "0.0.0")
+  get_version_from_git(FALCO_VERSION "" "")
+endif()
+
+# Remove the starting "v" in case there is one
+string(REGEX REPLACE "^v(.*)" "\\1" FALCO_VERSION "${FALCO_VERSION}")
+
+string(REGEX MATCH "^(0|[1-9][0-9]*)" FALCO_VERSION_MAJOR "${FALCO_VERSION}")
+string(REGEX REPLACE "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\..*" "\\2" FALCO_VERSION_MINOR "${FALCO_VERSION}")
+string(REGEX REPLACE "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*).*" "\\3" FALCO_VERSION_PATCH
+                     "${FALCO_VERSION}")
+string(
+  REGEX
+  REPLACE
+    "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)-((0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*)(\\.(0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*))*).*"
+    "\\5"
+    FALCO_VERSION_PRERELEASE
+    "${FALCO_VERSION}")
+
+if(FALCO_VERSION_PRERELEASE STREQUAL "${FALCO_VERSION}")
+  set(FALCO_VERSION_PRERELEASE "")
+endif()
+if(NOT FALCO_VERSION_BUILD)
+  string(REGEX REPLACE ".*\\+([0-9a-zA-Z-]+(\\.[0-9a-zA-Z-]+)*)" "\\1" FALCO_VERSION_BUILD "${FALCO_VERSION}")
+endif()
+if(FALCO_VERSION_BUILD STREQUAL "${FALCO_VERSION}")
+  set(FALCO_VERSION_BUILD "")
+endif()
+
+message(STATUS "Falco version: ${FALCO_VERSION}")

cmake/modules/falcoctl.cmake

@@ -15,14 +15,14 @@ include(ExternalProject)
 
 string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} FALCOCTL_SYSTEM_NAME)
 
-set(FALCOCTL_VERSION "0.5.0")
+set(FALCOCTL_VERSION "0.6.0")
 
 if(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64")
     set(FALCOCTL_SYSTEM_PROC_GO "amd64")
-    set(FALCOCTL_HASH "ba82ee14ee72fe5737f1b5601e403d8a9422dfe2c467d1754eb488001eeea5f1")
+    set(FALCOCTL_HASH "b81c36449b525e1de871288741beeadead021ac133d9b306f0636be1befe58a5")
 else() # aarch64
     set(FALCOCTL_SYSTEM_PROC_GO "arm64")
-    set(FALCOCTL_HASH "be145ece641d439011cc4a512d0fd2dac5974cab7399f9a7cd43f08eb43dd446")
+    set(FALCOCTL_HASH "6e99fd765f67cdd46fa8c5b2969e97497856d2e615698ced04046c8898187b18")
 endif()
 
 ExternalProject_Add(

cmake/modules/falcosecurity-libs-repo/CMakeLists.txt

@@ -15,11 +15,12 @@ cmake_minimum_required(VERSION 3.5.1)
 project(falcosecurity-libs-repo NONE)
 
 include(ExternalProject)
+message(STATUS "Libs repository: ${FALCOSECURITY_LIBS_REPO}")
 message(STATUS "Libs version: ${FALCOSECURITY_LIBS_VERSION}")
 
 ExternalProject_Add(
   falcosecurity-libs
-  URL "https://github.com/falcosecurity/libs/archive/${FALCOSECURITY_LIBS_VERSION}.tar.gz"
+  URL "https://github.com/${FALCOSECURITY_LIBS_REPO}/archive/${FALCOSECURITY_LIBS_VERSION}.tar.gz"
   URL_HASH "${FALCOSECURITY_LIBS_CHECKSUM}"
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""

cmake/modules/falcosecurity-libs.cmake

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2021 The Falco Authors.
+# Copyright (C) 2023 The Falco Authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 # the License. You may obtain a copy of the License at
@@ -23,17 +23,25 @@ if(FALCOSECURITY_LIBS_SOURCE_DIR)
   set(FALCOSECURITY_LIBS_VERSION "0.0.0-local")
   message(STATUS "Using local version of falcosecurity/libs: '${FALCOSECURITY_LIBS_SOURCE_DIR}'")
 else()
+  # FALCOSECURITY_LIBS_REPO accepts a repository name (<org name>/<repo name>) alternative to the falcosecurity/libs repository.
+  # In case you want to test against a fork of falcosecurity/libs just pass the variable -
+  # ie., `cmake -DFALCOSECURITY_LIBS_REPO=<your-gh-handle>/libs ..` 
+  if (NOT FALCOSECURITY_LIBS_REPO)
+    set(FALCOSECURITY_LIBS_REPO "falcosecurity/libs")
+  endif()
+
   # FALCOSECURITY_LIBS_VERSION accepts a git reference (branch name, commit hash, or tag) to the falcosecurity/libs repository.
   # In case you want to test against another falcosecurity/libs version (or branch, or commit) just pass the variable -
   # ie., `cmake -DFALCOSECURITY_LIBS_VERSION=dev ..` 
   if(NOT FALCOSECURITY_LIBS_VERSION)
-    set(FALCOSECURITY_LIBS_VERSION "0.11.0-rc5")
-    set(FALCOSECURITY_LIBS_CHECKSUM "SHA256=079ab5f596a0d8af2a7f843e8159f83cb7c864331019aaed822daa737c75e9e7")
+    set(FALCOSECURITY_LIBS_VERSION "0.13.0-rc1")
+    set(FALCOSECURITY_LIBS_CHECKSUM "SHA256=a75526b664bce2ba05912e056e48be39b0b1cb797b2055d107e55afbee2c8233")
   endif()
 
   # cd /path/to/build && cmake /path/to/source
   execute_process(COMMAND "${CMAKE_COMMAND}"
       -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}"
+      -DFALCOSECURITY_LIBS_REPO=${FALCOSECURITY_LIBS_REPO}
       -DFALCOSECURITY_LIBS_VERSION=${FALCOSECURITY_LIBS_VERSION}
       -DFALCOSECURITY_LIBS_CHECKSUM=${FALCOSECURITY_LIBS_CHECKSUM}
     ${FALCOSECURITY_LIBS_CMAKE_SOURCE_DIR} WORKING_DIRECTORY ${FALCOSECURITY_LIBS_CMAKE_WORKING_DIR})
@@ -45,8 +53,10 @@ endif()
 
 set(LIBS_PACKAGE_NAME "falcosecurity")
 
-add_definitions(-D_GNU_SOURCE)
-add_definitions(-DHAS_CAPTURE)
+if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+  add_definitions(-D_GNU_SOURCE)
+  add_definitions(-DHAS_CAPTURE)
+endif()
 
 if(MUSL_OPTIMIZED_BUILD)
   add_definitions(-DMUSL_OPTIMIZED)

cmake/modules/plugins.cmake

@@ -14,7 +14,7 @@
 include(ExternalProject)
 
 # 'stable' or 'dev'
-set(PLUGINS_DOWNLOAD_BUCKET "dev")
+set(PLUGINS_DOWNLOAD_BUCKET "stable")
 
 string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} PLUGINS_SYSTEM_NAME)
 
@@ -23,11 +23,11 @@ if(NOT DEFINED PLUGINS_COMPONENT_NAME)
 endif()
 
 # k8saudit
-set(PLUGIN_K8S_AUDIT_VERSION "0.6.0-0.5.3-33%2B81ffddd")
+set(PLUGIN_K8S_AUDIT_VERSION "0.6.0")
 if(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64")
-    set(PLUGIN_K8S_AUDIT_HASH "990e5c67d3b3c7cf5d30c73d73871b58767171ce7c998c1ca1d94d70c67db290")
+    set(PLUGIN_K8S_AUDIT_HASH "560e8f8dc8fd169e524d95462d65b5227415a7a157442e82383c7d9f456ce58f")
 else() # aarch64
-    set(PLUGIN_K8S_AUDIT_HASH "c3634dfa83c8c8898811ab6b7587ea6d1c6dfffbdfa56def28cab43aaf01f88c")
+    set(PLUGIN_K8S_AUDIT_HASH "e4757af1bac42b21c5937340790841dedc3805759050a6ffb22d1761e1dd1d31")
 endif()
 
 ExternalProject_Add(
@@ -43,7 +43,7 @@ install(FILES "${PROJECT_BINARY_DIR}/k8saudit-plugin-prefix/src/k8saudit-plugin/
 ExternalProject_Add(
   k8saudit-rules
   URL "https://download.falco.org/plugins/${PLUGINS_DOWNLOAD_BUCKET}/k8saudit-rules-${PLUGIN_K8S_AUDIT_VERSION}.tar.gz"
-  URL_HASH "SHA256=2e3214fee00a012b32402aad5198df889773fc5f86b8ab87583fbc56ae5fb78c"
+  URL_HASH "SHA256=44cee2fb88312d889213e1dbe1b9902d0a3f5c594cce73b2cac8e54fb51321b7"
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND "")
@@ -51,11 +51,11 @@ ExternalProject_Add(
 install(FILES "${PROJECT_BINARY_DIR}/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml" DESTINATION "${FALCO_ETC_DIR}" COMPONENT "${PLUGINS_COMPONENT_NAME}")
 
 # cloudtrail
-set(PLUGIN_CLOUDTRAIL_VERSION "0.8.0-0.7.3-33%2B81ffddd")
+set(PLUGIN_CLOUDTRAIL_VERSION "0.8.0")
 if(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64")
-    set(PLUGIN_CLOUDTRAIL_HASH "144c297ae4285ea84b04af272f708a8b824f58bc9427a2eb91b467a6285d9e10")
+    set(PLUGIN_CLOUDTRAIL_HASH "13ba77602c0859936f6e3b00f93bd218c463300c6a797b694a0d5aeecde13976")
 else() # aarch64
-    set(PLUGIN_CLOUDTRAIL_HASH "19e7e8e11aaecd16442f65a265d3cd80ffb736ca4d3d8215893900fa0f04b926")
+    set(PLUGIN_CLOUDTRAIL_HASH "a01730738e9d5769f69957a204c8afe528b059e9a22f59792dfc65e19d6a43db")
 endif()
 
 ExternalProject_Add(
@@ -71,7 +71,7 @@ install(FILES "${PROJECT_BINARY_DIR}/cloudtrail-plugin-prefix/src/cloudtrail-plu
 ExternalProject_Add(
   cloudtrail-rules
   URL "https://download.falco.org/plugins/${PLUGINS_DOWNLOAD_BUCKET}/cloudtrail-rules-${PLUGIN_CLOUDTRAIL_VERSION}.tar.gz"
-  URL_HASH "SHA256=4f51d4bd9679f7f244c225b6fe530323f3536663da26a5b9d94d6953ed4e2cbc"
+  URL_HASH "SHA256=27f2fc0a74d39476ad968a61318dec65a82b109c4a462b9fa22be45425ddaaad"
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND "")
@@ -79,11 +79,11 @@ ExternalProject_Add(
 install(FILES "${PROJECT_BINARY_DIR}/cloudtrail-rules-prefix/src/cloudtrail-rules/aws_cloudtrail_rules.yaml" DESTINATION "${FALCO_ETC_DIR}" COMPONENT "${PLUGINS_COMPONENT_NAME}")
 
 # json
-set(PLUGIN_JSON_VERSION "0.7.0-0.6.2-36%2B81ffddd")
+set(PLUGIN_JSON_VERSION "0.7.0")
 if(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64")
-    set(PLUGIN_JSON_HASH "a9d8c595a139df5dc0cf2117127b496c94a9d3a3d0e84c1f18b3ccc9163f5f4a")
+    set(PLUGIN_JSON_HASH "a7bf52009a935f22b473724f722566fde27aec5c7d618ecd426eed81e477e94d")
 else() # aarch64
-    set(PLUGIN_JSON_HASH "7d78620395526d1e6a948cc915d1d52a343c2b637c9ac0e3892e76826fcdc2df")
+    set(PLUGIN_JSON_HASH "9cd65fac3f1cbc7f723b69671d42d35901cd322a23d8f2b9dc95fb0593918a7e")
 endif()
 
 ExternalProject_Add(

cmake/modules/rules.cmake

@@ -15,8 +15,8 @@ include(GNUInstallDirs)
 include(ExternalProject)
 
 # falco_rules.yaml
-set(FALCOSECURITY_RULES_FALCO_VERSION "falco-rules-0.1.0")
-set(FALCOSECURITY_RULES_FALCO_CHECKSUM "SHA256=0d3705a4650f09d10e7831b16e7af59c1da34ff19e788896e9ee77010014db4d")
+set(FALCOSECURITY_RULES_FALCO_VERSION "falco-rules-1.0.1")
+set(FALCOSECURITY_RULES_FALCO_CHECKSUM "SHA256=2348d43196bbbdea92e3f67fa928721a241b0406d0ef369693bdefcec2b3fa13")
 set(FALCOSECURITY_RULES_FALCO_PATH "${PROJECT_BINARY_DIR}/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml")
 ExternalProject_Add(
   falcosecurity-rules-falco

docker/CMakeLists.txt

@@ -1 +0,0 @@
-add_subdirectory(local)

docker/README.md

@@ -7,11 +7,5 @@ This directory contains various ways to package Falco as a container and related
 | Name | Directory | Description |
 |---|---|---|
 | [falcosecurity/falco:latest](https://hub.docker.com/repository/docker/falcosecurity/falco), [falcosecurity/falco:_tag_](https://hub.docker.com/repository/docker/falcosecurity/falco), [falcosecurity/falco:master](https://hub.docker.com/repository/docker/falcosecurity/falco) | docker/falco | Falco (DEB built from git tag or from the master) with all the building toolchain. |
-| _not yet published (experimental)_ | docker/ubi | Falco (built from RedHat's UBI base image) with the building toolchain. |
 | [falcosecurity/falco-driver-loader:latest](https://hub.docker.com/repository/docker/falcosecurity/falco-driver-loader), [falcosecurity/falco-driver-loader:_tag_](https://hub.docker.com/repository/docker/falcosecurity/falco-driver-loader), [falcosecurity/falco-driver-loader:master](https://hub.docker.com/repository/docker/falcosecurity/falco-driver-loader) | docker/driver-loader | `falco-driver-loader` as entrypoint with the building toolchain. |
 | [falcosecurity/falco-no-driver:latest](https://hub.docker.com/repository/docker/falcosecurity/falco-no-driver), [falcosecurity/falco-no-driver:_tag_](https://hub.docker.com/repository/docker/falcosecurity/falco-no-driver),[falcosecurity/falco-no-driver:master](https://hub.docker.com/repository/docker/falcosecurity/falco-no-driver) | docker/no-driver | Falco (TGZ built from git tag or from the master) without the building toolchain. |
-| [falcosecurity/falco-builder:latest](https://hub.docker.com/repository/docker/falcosecurity/falco-builder) | docker/builder | The complete build tool chain for compiling Falco from source. See [the documentation](https://falco.org/docs/getting-started/source/) for more details on building from source. Used to build Falco (CI). |
-| [falcosecurity/falco-tester:latest](https://hub.docker.com/repository/docker/falcosecurity/falco-tester) | docker/tester | Container image for running the Falco test suite. Used to run Falco integration tests (CI). |
-| _not to be published_ | docker/local | Built on-the-fly and used by falco-tester. |
-
-> Note: `falco-builder`, `falco-tester` (and the `docker/local` image that it's built on the fly) are not integrated into the release process because they are development and CI tools that need to be manually pushed only when updated.

docker/builder/Dockerfile

@@ -1,47 +0,0 @@
-FROM centos:7
-
-LABEL name="falcosecurity/falco-builder"
-LABEL usage="docker run -v $PWD/..:/source -v $PWD/build:/build falcosecurity/falco-builder cmake"
-LABEL maintainer="cncf-falco-dev@lists.cncf.io"
-LABEL org.opencontainers.image.source="https://github.com/falcosecurity/falco"
-
-ARG BUILD_TYPE=release
-ARG BUILD_DRIVER=OFF
-ARG BUILD_BPF=OFF
-ARG BUILD_WARNINGS_AS_ERRORS=ON
-ARG MAKE_JOBS=4
-ARG FALCO_VERSION
-ARG CMAKE_VERSION=3.22.5
-
-ENV BUILD_TYPE=${BUILD_TYPE}
-ENV BUILD_DRIVER=${BUILD_DRIVER}
-ENV BUILD_BPF=${BUILD_BPF}
-ENV BUILD_WARNINGS_AS_ERRORS=${BUILD_WARNINGS_AS_ERRORS}
-ENV MAKE_JOBS=${MAKE_JOBS}
-ENV FALCO_VERSION=${FALCO_VERSION}
-ENV CMAKE_VERSION=${CMAKE_VERSION}
-
-# build toolchain
-RUN yum -y install centos-release-scl && \
-    INSTALL_PKGS="devtoolset-7-gcc devtoolset-7-gcc-c++ devtoolset-7-toolchain devtoolset-7-libstdc++-devel llvm-toolset-7.0 glibc-static autoconf automake libtool createrepo expect git which libcurl-devel rpm-build libyaml-devel" && \
-    yum -y install --setopt=tsflags=nodocs $INSTALL_PKGS && \
-    rpm -V $INSTALL_PKGS
-
-
-RUN source scl_source enable devtoolset-7 llvm-toolset-7.0
-
-RUN curl -L -o /tmp/cmake-${CMAKE_VERSION}-linux-$(uname -m).tar.gz https://github.com/kitware/cmake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-$(uname -m).tar.gz && \
-    gzip -d /tmp/cmake-${CMAKE_VERSION}-linux-$(uname -m).tar.gz && \
-    tar -xpf /tmp/cmake-${CMAKE_VERSION}-linux-$(uname -m).tar --directory=/tmp && \
-    cp -R /tmp/cmake-${CMAKE_VERSION}-linux-$(uname -m)/* /usr && \
-    rm -rf /tmp/cmake-${CMAKE_VERSION}-linux-$(uname -m)
-
-COPY ./root /
-
-# DTS
-ENV BASH_ENV=/usr/bin/scl_enable \
-    ENV=/usr/bin/scl_enable \
-    PROMPT_COMMAND=". /usr/bin/scl_enable"
-
-ENTRYPOINT ["entrypoint"]
-CMD ["usage"]

docker/builder/README.md

@@ -1,8 +1,6 @@
 # Builder folder
 
-* We use `Dockerfile` to build the `centos7` Falco builder image.
 * We use `modern-falco-builder.Dockerfile` to build Falco with the modern probe and return it as a Dockerfile output. This Dockerfile doesn't generate a Docker image but returns as output (through the `--output` command):
   * Falco `tar.gz`.
   * Falco `deb` package.
   * Falco `rpm` package.
-  * Falco build directory, used by other CI jobs.

docker/builder/modern-falco-builder.Dockerfile

@@ -41,22 +41,3 @@ ARG DEST_BUILD_DIR="/build"
 COPY --from=build-stage /build/release/falco-*.tar.gz /packages/
 COPY --from=build-stage /build/release/falco-*.deb /packages/
 COPY --from=build-stage /build/release/falco-*.rpm /packages/
-
-# This is what we need for integration tests. We don't export all the build directory
-# outside the container since its size is almost 6 GB, we export only what is strictly necessary
-# for integration tests.
-# This is just a workaround to fix the CI build until we replace our actual testing framework.
-COPY --from=build-stage /build/release/cloudtrail-plugin-prefix ${DEST_BUILD_DIR}/cloudtrail-plugin-prefix
-COPY --from=build-stage /build/release/cloudtrail-rules-prefix ${DEST_BUILD_DIR}/cloudtrail-rules-prefix
-COPY --from=build-stage /build/release/falcosecurity-rules-falco-prefix ${DEST_BUILD_DIR}/falcosecurity-rules-falco-prefix
-COPY --from=build-stage /build/release/falcosecurity-rules-local-prefix ${DEST_BUILD_DIR}/falcosecurity-rules-local-prefix
-COPY --from=build-stage /build/release/json-plugin-prefix ${DEST_BUILD_DIR}/json-plugin-prefix
-COPY --from=build-stage /build/release/k8saudit-plugin-prefix ${DEST_BUILD_DIR}/k8saudit-plugin-prefix
-COPY --from=build-stage /build/release/k8saudit-rules-prefix ${DEST_BUILD_DIR}/k8saudit-rules-prefix
-COPY --from=build-stage /build/release/scripts ${DEST_BUILD_DIR}/scripts
-COPY --from=build-stage /build/release/test ${DEST_BUILD_DIR}/test
-COPY --from=build-stage /build/release/userspace/falco/falco ${DEST_BUILD_DIR}/userspace/falco/falco
-COPY --from=build-stage /build/release/userspace/falco/config_falco.h ${DEST_BUILD_DIR}/userspace/falco/config_falco.h
-COPY --from=build-stage /build/release/falco-*.tar.gz ${DEST_BUILD_DIR}/
-COPY --from=build-stage /build/release/falco-*.deb ${DEST_BUILD_DIR}/
-COPY --from=build-stage /build/release/falco-*.rpm ${DEST_BUILD_DIR}/

docker/builder/root/usr/bin/entrypoint

@@ -1,59 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu -o pipefail
-
-SOURCE_DIR=/source
-BUILD_DIR=/build
-CMD=${1:-usage}
-shift
-
-# Build type can be "debug" or "release", fallbacks to "release" by default
-BUILD_TYPE=$(echo "$BUILD_TYPE" | tr "[:upper:]" "[:lower:]")
-FALCO_EXTRA_DEBUG_FLAGS=
-case "$BUILD_TYPE" in
-"debug")
-    FALCO_EXTRA_DEBUG_FLAGS="-D_DEBUG -DNDEBUG"
-    ;;
-*)
-    BUILD_TYPE="release"
-    ;;
-esac
-
-case "$CMD" in
-"cmake")
-    # Check that source directory contains Falco
-    if [ ! -d "$SOURCE_DIR/falco" ]; then
-        echo "Missing falco source." >&2
-        exit 1
-    fi
-    # Prepare build directory
-    mkdir -p "$BUILD_DIR/$BUILD_TYPE"
-    cd "$BUILD_DIR/$BUILD_TYPE"
-
-    cmake \
-    -DCMAKE_BUILD_TYPE="$BUILD_TYPE" \
-    -DCMAKE_INSTALL_PREFIX=/usr \
-    -DBUILD_DRIVER="$BUILD_DRIVER" \
-    -DBUILD_BPF="$BUILD_BPF" \
-    -DBUILD_WARNINGS_AS_ERRORS="$BUILD_WARNINGS_AS_ERRORS" \
-    -DFALCO_VERSION="$FALCO_VERSION" \
-    -DFALCO_EXTRA_DEBUG_FLAGS="$FALCO_EXTRA_DEBUG_FLAGS" \
-    -DUSE_BUNDLED_DEPS=ON \
-    "$SOURCE_DIR/falco"
-    exit "$(printf '%d\n' $?)"
-    ;;
-"bash")
-    CMD=/bin/bash
-    ;& # fallthrough
-"usage")
-    exec "$CMD" "$@"
-    ;;
-*)
-    if [ ! -d "$BUILD_DIR/$BUILD_TYPE" ]; then
-        echo "Missing $BUILD_DIR/$BUILD_TYPE directory: run cmake."
-        exit 1
-    fi
-    cd "$BUILD_DIR/$BUILD_TYPE"
-    make -j"$MAKE_JOBS" "$CMD"
-    ;;
-esac

docker/builder/root/usr/bin/scl_enable

@@ -1,6 +0,0 @@
-# IMPORTANT: Do not add more content to this file unless you know what you are doing.
-#            This file is sourced every time the shell session is opened.
-#
-# This will make scl collection binaries work out of box.
-unset BASH_ENV PROMPT_COMMAND ENV
-source scl_source enable devtoolset-7 llvm-toolset-7.0

docker/builder/root/usr/bin/usage

@@ -1,53 +0,0 @@
-#!/usr/bin/env bash
-
-gccversion=$(gcc --version | head -n1)
-cppversion=$(g++ -dM -E -x c++ /dev/null | grep -F __cplusplus | cut -d' ' -f3)
-cmakeversion=$(cmake --version | head -n1)
-clangversion=$(clang --version | head -n1)
-
-cat <<EOF
-Hello, this is the Falco builder container.
-
-How to use.
-
-    The default commands for the Falco builder image reports usage and environment info.
-    * docker run falcosecurity/falco-builder
-    * docker run falcosecurity/falco-builder usage
-
-    It supports bash.
-    * docker run -ti falcosecurity/falco-builder bash
-
-    To build Falco it needs:
-    - a bind-mount on the source directory (ie., the directory containing the Falco source as sibling)
-
-    Optionally, you can also bind-mount the build directory.
-    So, you can execute it from the Falco root directory as follows.
-
-    * docker run -v $PWD/..:/source -v $PWD/build:/build falcosecurity/falco-builder cmake
-    * docker run -v $PWD/..:/source -v $PWD/build:/build falcosecurity/falco-builder [<cmake-target-x>, ..., <cmake-target-y>]
-
-    Eg.,
-    * docker run -v $PWD/..:/source -v $PWD/build:/build falcosecurity/falco-builder tests
-    * docker run -v $PWD/..:/source -v $PWD/build:/build falcosecurity/falco-builder install
-
-How to build.
-
-    * cd docker/builder && DOCKER_BUILDKIT=1 docker build -t falcosecurity/falco-builder .
-
-    In case you want to customise the builder at build time the following build arguments are provided:
-    - BUILD_TYPE                whether you want a "release" or "debug" build (defaults to "release").
-    - BUILD_DRIVER              whether to build the driver or not (defaults to "OFF")
-    - BUILD_BPF                 whether to build the BPF driver or not (defaults to "OFF")
-    - BUILD_WARNINGS_AS_ERRORS  whether to intend warnings as errors or not (defaults to "ON")
-    - MAKE_JOBS                 the number of jobs to use during make (defaults to "4")
-    - FALCO_VERSION             the version to label the build (built from git index in case it is missing)
-
-    It is possible to change these at runtime (in the container) since environment variables with the same names are provided, too.
-
-Environment.
-
-    * ${gccversion}
-    * cplusplus ${cppversion}
-    * ${cmakeversion}
-    * ${clangversion}
-EOF

docker/local/CMakeLists.txt

@@ -1,17 +0,0 @@
-add_subdirectory(traces)
-add_subdirectory(rules)
-
-add_custom_target(local-Dockerfile ALL
-	DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/Dockerfile)
-
-add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Dockerfile
-	COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Dockerfile ${CMAKE_CURRENT_BINARY_DIR}/Dockerfile
-	DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/Dockerfile)
-
-add_custom_target(local-docker-entrypoint ALL
-	DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/docker-entrypoint)
-
-add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/docker-entrypoint
-	COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/docker-entrypoint.sh ${CMAKE_CURRENT_BINARY_DIR}/docker-entrypoint.sh
-	DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/docker-entrypoint.sh)
-

docker/local/Dockerfile

@@ -1,135 +0,0 @@
-FROM debian:buster
-
-LABEL usage="docker run -i -t -v /var/run/docker.sock:/host/var/run/docker.sock -v /dev:/host/dev -v /proc:/host/proc:ro -v /boot:/host/boot:ro -v /lib/modules:/host/lib/modules:ro -v /usr:/host/usr:ro --name NAME IMAGE"
-LABEL maintainer="cncf-falco-dev@lists.cncf.io"
-LABEL org.opencontainers.image.source="https://github.com/falcosecurity/falco"
-
-ARG TARGETARCH
-
-ARG FALCO_VERSION=
-RUN test -n FALCO_VERSION
-ENV FALCO_VERSION ${FALCO_VERSION}
-
-ENV HOST_ROOT /host
-
-ENV HOME /root
-
-RUN cp /etc/skel/.bashrc /root && cp /etc/skel/.profile /root
-
-RUN apt-get update \
-	&& apt-get install -y --no-install-recommends \
-	bash-completion \
-	bc \
-	clang-7 \
-	ca-certificates \
-	curl \
-	dkms \
-	gnupg2 \
-	gcc \
-	jq \
-	libc6-dev \
-	libelf-dev \
-	libyaml-0-2 \
-	llvm-7 \
-	netcat \
-	xz-utils \
-	libmpc3 \
-	binutils \
-	libgomp1 \
-	libitm1 \
-	libatomic1 \
-	liblsan0 \
-	libtsan0 \
-	libcc1-0 \
-	patchelf \
-	&& rm -rf /var/lib/apt/lists/*
-
-RUN if [ "$TARGETARCH" = "amd64" ]; \
-    then apt-get install -y --no-install-recommends libmpx2 libquadmath0; \
-    fi
-
-# gcc 6 is no longer included in debian stable, but we need it to
-# build kernel modules on the default debian-based ami used by
-# kops. So grab copies we've saved from debian snapshots with the
-# prefix https://snapshot.debian.org/archive/debian/20170517T033514Z
-# or so.
-
-RUN if [ "$TARGETARCH" = "amd64" ]; then curl -L -o libcilkrts5_6.3.0-18_${TARGETARCH}.deb https://download.falco.org/dependencies/libcilkrts5_6.3.0-18_${TARGETARCH}.deb; fi; \
-    curl -L -o cpp-6_6.3.0-18_${TARGETARCH}.deb https://download.falco.org/dependencies/cpp-6_6.3.0-18_${TARGETARCH}.deb \
-	&& curl -L -o gcc-6-base_6.3.0-18_${TARGETARCH}.deb https://download.falco.org/dependencies/gcc-6-base_6.3.0-18_${TARGETARCH}.deb \
-	&& curl -L -o gcc-6_6.3.0-18_${TARGETARCH}.deb https://download.falco.org/dependencies/gcc-6_6.3.0-18_${TARGETARCH}.deb \
-	&& curl -L -o libasan3_6.3.0-18_${TARGETARCH}.deb https://download.falco.org/dependencies/libasan3_6.3.0-18_${TARGETARCH}.deb \
-	&& curl -L -o libgcc-6-dev_6.3.0-18_${TARGETARCH}.deb https://download.falco.org/dependencies/libgcc-6-dev_6.3.0-18_${TARGETARCH}.deb \
-	&& curl -L -o libubsan0_6.3.0-18_${TARGETARCH}.deb https://download.falco.org/dependencies/libubsan0_6.3.0-18_${TARGETARCH}.deb \
-	&& curl -L -o libmpfr4_3.1.3-2_${TARGETARCH}.deb https://download.falco.org/dependencies/libmpfr4_3.1.3-2_${TARGETARCH}.deb \
-	&& curl -L -o libisl15_0.18-1_${TARGETARCH}.deb https://download.falco.org/dependencies/libisl15_0.18-1_${TARGETARCH}.deb \
-	&& dpkg -i cpp-6_6.3.0-18_${TARGETARCH}.deb gcc-6-base_6.3.0-18_${TARGETARCH}.deb gcc-6_6.3.0-18_${TARGETARCH}.deb libasan3_6.3.0-18_${TARGETARCH}.deb; \
-    if [ "$TARGETARCH" = "amd64" ]; then dpkg -i libcilkrts5_6.3.0-18_${TARGETARCH}.deb; fi; \
-    dpkg -i libgcc-6-dev_6.3.0-18_${TARGETARCH}.deb libubsan0_6.3.0-18_${TARGETARCH}.deb libmpfr4_3.1.3-2_${TARGETARCH}.deb libisl15_0.18-1_${TARGETARCH}.deb \
-	&& rm -f cpp-6_6.3.0-18_${TARGETARCH}.deb gcc-6-base_6.3.0-18_${TARGETARCH}.deb gcc-6_6.3.0-18_${TARGETARCH}.deb libasan3_6.3.0-18_${TARGETARCH}.deb libcilkrts5_6.3.0-18_${TARGETARCH}.deb libgcc-6-dev_6.3.0-18_${TARGETARCH}.deb libubsan0_6.3.0-18_${TARGETARCH}.deb libmpfr4_3.1.3-2_${TARGETARCH}.deb libisl15_0.18-1_${TARGETARCH}.deb
-
-# gcc 5 is no longer included in debian stable, but we need it to
-# build centos kernels, which are 3.x based and explicitly want a gcc
-# version 3, 4, or 5 compiler. So grab copies we've saved from debian
-# snapshots with the prefix https://snapshot.debian.org/archive/debian/20190122T000000Z.
-
-RUN if [ "$TARGETARCH" = "amd64" ]; then curl -L -o libmpx0_5.5.0-12_${TARGETARCH}.deb https://download.falco.org/dependencies/libmpx0_5.5.0-12_${TARGETARCH}.deb; fi; \
-    curl -L -o cpp-5_5.5.0-12_${TARGETARCH}.deb https://download.falco.org/dependencies/cpp-5_5.5.0-12_${TARGETARCH}.deb \
-	&& curl -L -o gcc-5-base_5.5.0-12_${TARGETARCH}.deb https://download.falco.org/dependencies/gcc-5-base_5.5.0-12_${TARGETARCH}.deb \
-	&& curl -L -o gcc-5_5.5.0-12_${TARGETARCH}.deb https://download.falco.org/dependencies/gcc-5_5.5.0-12_${TARGETARCH}.deb \
-	&& curl -L -o libasan2_5.5.0-12_${TARGETARCH}.deb	https://download.falco.org/dependencies/libasan2_5.5.0-12_${TARGETARCH}.deb \
-	&& curl -L -o libgcc-5-dev_5.5.0-12_${TARGETARCH}.deb https://download.falco.org/dependencies/libgcc-5-dev_5.5.0-12_${TARGETARCH}.deb \
-	&& curl -L -o libisl15_0.18-4_${TARGETARCH}.deb https://download.falco.org/dependencies/libisl15_0.18-4_${TARGETARCH}.deb \
-	&& dpkg -i cpp-5_5.5.0-12_${TARGETARCH}.deb gcc-5-base_5.5.0-12_${TARGETARCH}.deb gcc-5_5.5.0-12_${TARGETARCH}.deb libasan2_5.5.0-12_${TARGETARCH}.deb; \
-    if [ "$TARGETARCH" = "amd64" ]; then dpkg -i libmpx0_5.5.0-12_${TARGETARCH}.deb; fi; \
-    dpkg -i libgcc-5-dev_5.5.0-12_${TARGETARCH}.deb libisl15_0.18-4_${TARGETARCH}.deb \
-	&& rm -f cpp-5_5.5.0-12_${TARGETARCH}.deb gcc-5-base_5.5.0-12_${TARGETARCH}.deb gcc-5_5.5.0-12_${TARGETARCH}.deb libasan2_5.5.0-12_${TARGETARCH}.deb libgcc-5-dev_5.5.0-12_${TARGETARCH}.deb libisl15_0.18-4_${TARGETARCH}.deb libmpx0_5.5.0-12_${TARGETARCH}.deb
-
-# Since our base Debian image ships with GCC 7 which breaks older kernels, revert the
-# default to gcc-5.
-RUN rm -rf /usr/bin/gcc && ln -s /usr/bin/gcc-5 /usr/bin/gcc
-
-RUN rm -rf /usr/bin/clang \
-	&& rm -rf /usr/bin/llc \
-	&& ln -s /usr/bin/clang-7 /usr/bin/clang \
-	&& ln -s /usr/bin/llc-7 /usr/bin/llc
-
-# Some base images have an empty /lib/modules by default
-# If it's not empty, docker build will fail instead of
-# silently overwriting the existing directory
-RUN rm -df /lib/modules \
-	&& ln -s $HOST_ROOT/lib/modules /lib/modules
-
-ADD falco-${FALCO_VERSION}-*.deb /
-RUN dpkg -i /falco-${FALCO_VERSION}-$(uname -m).deb
-
-# Change the falco config within the container to enable ISO 8601
-# output.
-RUN sed -e 's/time_format_iso_8601: false/time_format_iso_8601: true/' < /etc/falco/falco.yaml > /etc/falco/falco.yaml.new \
-	&& mv /etc/falco/falco.yaml.new /etc/falco/falco.yaml
-
-# debian:stable head contains binutils 2.31, which generates
-# binaries that are incompatible with kernels < 4.16. So manually
-# forcibly install binutils 2.30-22 instead.
-RUN if [ "$TARGETARCH" = "amd64" ] ; then \
-    curl -L -o binutils-x86-64-linux-gnu_2.30-22_${TARGETARCH}.deb https://download.falco.org/dependencies/binutils-x86-64-linux-gnu_2.30-22_${TARGETARCH}.deb; \
-    else  \
-    curl -L -o  binutils-aarch64-linux-gnu_2.30-22_${TARGETARCH}.deb https://download.falco.org/dependencies/binutils-aarch64-linux-gnu_2.30-22_${TARGETARCH}.deb; \
-    fi
-
-RUN curl -L -o binutils_2.30-22_${TARGETARCH}.deb https://download.falco.org/dependencies/binutils_2.30-22_${TARGETARCH}.deb \
-	&& curl -L -o libbinutils_2.30-22_${TARGETARCH}.deb https://download.falco.org/dependencies/libbinutils_2.30-22_${TARGETARCH}.deb \
-	&& curl -L -o binutils-common_2.30-22_${TARGETARCH}.deb https://download.falco.org/dependencies/binutils-common_2.30-22_${TARGETARCH}.deb \
-	&& dpkg -i *binutils*.deb \
-	&& rm -f *binutils*.deb
-
-# The local container also copies some test trace files and
-# corresponding rules that are used when running regression tests.
-COPY rules/*.yaml /rules/
-COPY traces/*.scap /traces/
-
-COPY ./docker-entrypoint.sh /
-
-ENTRYPOINT ["/docker-entrypoint.sh"]
-
-CMD ["/usr/bin/falco"]

docker/local/docker-entrypoint.sh

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-#
-# Copyright (C) 2020 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-
-# Set the SKIP_DRIVER_LOADER variable to skip loading the driver
-
-if [[ -z "${SKIP_DRIVER_LOADER}" ]]; then
-    echo "* Setting up /usr/src links from host"
-
-    for i in "$HOST_ROOT/usr/src"/*
-    do
-        base=$(basename "$i")
-        ln -s "$i" "/usr/src/$base"
-    done
-
-    /usr/bin/falco-driver-loader
-fi
-
-exec "$@"

docker/local/rules/CMakeLists.txt

@@ -1,7 +0,0 @@
-include(copy_files_to_build_dir)
-
-# Note: list of rules is created at cmake time, not build time
-file(GLOB test_rule_files
-	"${CMAKE_CURRENT_SOURCE_DIR}/../../../test/rules/*.yaml")
-
-copy_files_to_build_dir("${test_rule_files}" docker-local-rules)

docker/local/traces/CMakeLists.txt

@@ -1,7 +0,0 @@
-include(copy_files_to_build_dir)
-
-# Note: list of traces is created at cmake time, not build time
-file(GLOB test_trace_files
-	"${CMAKE_CURRENT_SOURCE_DIR}/../../../test/trace_files/*.scap")
-
-copy_files_to_build_dir("${test_trace_files}" docker-local-traces)

docker/tester/Dockerfile

@@ -1,30 +0,0 @@
-FROM fedora:31
-
-LABEL name="falcosecurity/falco-tester"
-LABEL usage="docker run -v /boot:/boot:ro -v /var/run/docker.sock:/var/run/docker.sock -v $PWD/..:/source -v $PWD/build:/build --name <name> falcosecurity/falco-tester test"
-LABEL maintainer="cncf-falco-dev@lists.cncf.io"
-LABEL org.opencontainers.image.source="https://github.com/falcosecurity/falco"
-
-ARG TARGETARCH
-
-ENV FALCO_VERSION=
-ENV BUILD_TYPE=release
-
-RUN if [ "$TARGETARCH" = "amd64" ] ; then curl -L -o grpcurl.tar.gz \
-    https://github.com/fullstorydev/grpcurl/releases/download/v1.8.6/grpcurl_1.8.6_linux_x86_64.tar.gz; \
-    else curl -L -o grpcurl.tar.gz \
-    https://github.com/fullstorydev/grpcurl/releases/download/v1.8.6/grpcurl_1.8.6_linux_arm64.tar.gz; \
-    fi;
-
-RUN dnf install -y python-pip python docker findutils jq unzip sed curl && dnf clean all
-ENV PATH="/root/.local/bin/:${PATH}"
-RUN pip install --user avocado-framework==69.0
-RUN pip install --user avocado-framework-plugin-varianter-yaml-to-mux==69.0
-RUN pip install --user watchdog==0.10.2
-RUN pip install --user pathtools==0.1.2
-RUN tar -C /usr/bin -xvf grpcurl.tar.gz
-
-COPY ./root /
-
-ENTRYPOINT ["entrypoint"]
-CMD ["usage"]

docker/tester/root/runners/deb.Dockerfile

@@ -1,21 +0,0 @@
-FROM ubuntu:18.04
-LABEL maintainer="cncf-falco-dev@lists.cncf.io"
-
-ARG FALCO_VERSION=
-RUN test -n FALCO_VERSION
-ENV FALCO_VERSION ${FALCO_VERSION}
-
-RUN apt update -y
-RUN apt install dkms -y
-
-ADD falco-${FALCO_VERSION}-*.deb /
-RUN dpkg -i /falco-${FALCO_VERSION}-$(uname -m).deb
-
-# Change the falco config within the container to enable ISO 8601 output.
-RUN sed -e 's/time_format_iso_8601: false/time_format_iso_8601: true/' < /etc/falco/falco.yaml > /etc/falco/falco.yaml.new \
-    && mv /etc/falco/falco.yaml.new /etc/falco/falco.yaml
-
-COPY rules/*.yaml /rules/
-COPY trace_files/*.scap /traces/
-
-CMD ["/usr/bin/falco"]

docker/tester/root/runners/rpm.Dockerfile

@@ -1,22 +0,0 @@
-FROM centos:7
-
-LABEL maintainer="cncf-falco-dev@lists.cncf.io"
-
-ARG FALCO_VERSION=
-RUN test -n FALCO_VERSION
-ENV FALCO_VERSION ${FALCO_VERSION}
-
-RUN yum update -y
-RUN yum install epel-release -y
-
-ADD falco-${FALCO_VERSION}-*.rpm /
-RUN yum install -y /falco-${FALCO_VERSION}-$(uname -m).rpm
-
-# Change the falco config within the container to enable ISO 8601 output.
-RUN sed -e 's/time_format_iso_8601: false/time_format_iso_8601: true/' < /etc/falco/falco.yaml > /etc/falco/falco.yaml.new \
-    && mv /etc/falco/falco.yaml.new /etc/falco/falco.yaml
-
-COPY rules/*.yaml /rules/
-COPY trace_files/*.scap /traces/
-
-CMD ["/usr/bin/falco"]

docker/tester/root/runners/tar.gz.Dockerfile

@@ -1,21 +0,0 @@
-FROM ubuntu:18.04
-LABEL maintainer="cncf-falco-dev@lists.cncf.io"
-
-ARG FALCO_VERSION=
-RUN test -n FALCO_VERSION
-ENV FALCO_VERSION ${FALCO_VERSION}
-
-RUN apt update -y
-RUN apt install dkms curl -y
-
-ADD falco-${FALCO_VERSION}-*.tar.gz /
-RUN cp -R /falco-${FALCO_VERSION}-$(uname -m)/* /
-
-# Change the falco config within the container to enable ISO 8601 output.
-RUN sed -e 's/time_format_iso_8601: false/time_format_iso_8601: true/' < /etc/falco/falco.yaml > /etc/falco/falco.yaml.new \
-    && mv /etc/falco/falco.yaml.new /etc/falco/falco.yaml
-
-COPY rules/*.yaml /rules/
-COPY trace_files/*.scap /traces/
-
-CMD ["/usr/bin/falco"]

docker/tester/root/usr/bin/entrypoint

@@ -1,93 +0,0 @@
-#!/usr/bin/env bash
-
-BUILD_DIR=${BUILD_DIR:-/build}
-SOURCE_DIR=${SOURCE_DIR:-/source}
-SKIP_PACKAGES_TESTS=${SKIP_PACKAGES_TESTS:-false}
-
-CMD=${1:-test}
-shift
-
-# Stop the execution if a command in the pipeline has an error, from now on
-set -e -u -o pipefail
-
-# build type can be "debug" or "release", fallbacks to "release" by default
-BUILD_TYPE=$(echo "$BUILD_TYPE" | tr "[:upper:]" "[:lower:]")
-case "$BUILD_TYPE" in
-"debug")
-    ;;
-*)
-    BUILD_TYPE="release"
-    ;;
-esac
-
-build_image() {
-    BUILD_DIR=$1
-    BUILD_TYPE=$2
-    FALCO_VERSION=$3
-    PACKAGE_TYPE=$4
-    PACKAGE="$BUILD_DIR/$BUILD_TYPE/falco-$FALCO_VERSION-$(uname -m).${PACKAGE_TYPE}"
-    if [ ! -f "$PACKAGE" ]; then
-        echo "Package not found: ${PACKAGE}." >&2
-        exit 1
-    fi
-    DOCKER_IMAGE_NAME="falcosecurity/falco:test-${PACKAGE_TYPE}"
-    echo "Building local docker image $DOCKER_IMAGE_NAME from latest ${PACKAGE_TYPE} package..."
-
-    mkdir -p /runner-rootfs
-    cp "$PACKAGE" /runner-rootfs
-    cp -R "$SOURCE_DIR/falco/test/rules" /runner-rootfs
-    cp -R "$SOURCE_DIR/falco/test/trace_files" /runner-rootfs
-    docker build -f "/runners/$PACKAGE_TYPE.Dockerfile" --build-arg FALCO_VERSION="$FALCO_VERSION" -t "$DOCKER_IMAGE_NAME" /runner-rootfs
-}
-
-clean_image() {
-    PACKAGE_TYPE=$1
-    DOCKER_IMAGE_NAME="falcosecurity/falco:test-${PACKAGE_TYPE}"
-    docker rmi -f "$DOCKER_IMAGE_NAME"
-}
-
-case "$CMD" in
-"test")
-    if [ -z "$FALCO_VERSION" ]; then
-        echo "Automatically figuring out Falco version."
-        FALCO_VERSION_FULL=$("$BUILD_DIR/$BUILD_TYPE/userspace/falco/falco" --version)
-        FALCO_VERSION=$(echo "$FALCO_VERSION_FULL" | head -n 1 | cut -d' ' -f3  | tr -d '\r')
-        echo "Falco version: $FALCO_VERSION"
-    fi
-    if [ -z "$FALCO_VERSION" ]; then
-        echo "Falco version cannot be guessed, please provide it with the FALCO_VERSION environment variable." >&2
-        exit 1
-    fi
-
-    # build docker images
-    if [ "$SKIP_PACKAGES_TESTS" = false ] ; then
-        build_image "$BUILD_DIR" "$BUILD_TYPE" "$FALCO_VERSION" "deb"
-        build_image "$BUILD_DIR" "$BUILD_TYPE" "$FALCO_VERSION" "rpm"
-        build_image "$BUILD_DIR" "$BUILD_TYPE" "$FALCO_VERSION" "tar.gz"
-    fi
-
-    # check that source directory contains Falco
-    if [ ! -d "$SOURCE_DIR/falco/test" ]; then
-        echo "Missing $SOURCE_DIR/falco/test directory." >&2
-        exit 1
-    fi
-
-    # run tests
-    echo "Running regression tests ..."
-    cd "$SOURCE_DIR/falco/test"
-    SKIP_PACKAGES_TESTS=$SKIP_PACKAGES_TESTS ./run_regression_tests.sh -d "$BUILD_DIR/$BUILD_TYPE"
-
-    # clean docker images
-    if [ "$SKIP_PACKAGES_TESTS" = false ] ; then
-        clean_image "deb"
-        clean_image "rpm"
-        clean_image "tar.gz"
-    fi
-    ;;
-"bash")
-    CMD=/bin/bash
-    ;& # fallthrough
-"usage")
-    exec "$CMD" "$@"
-    ;;
-esac

docker/tester/root/usr/bin/usage

@@ -1,41 +0,0 @@
-#!/usr/bin/env bash
-
-pythonversion=$(python -c 'import sys; version=sys.version_info[:3]; print("{0}.{1}.{2}".format(*version))')
-pipversion=$(pip --version | cut -d' ' -f 1,2,5,6)
-dockerversion=$(docker --version)
-avocadoversion=$(pip show avocado-framework | grep Version)
-avocadoversion=${avocadoversion#"Version: "}
-
-cat <<EOF
-Hello, this is the Falco tester container.
-
-How to use.
-
-    The default commands for the Falco tester image reports usage and environment info.
-    * docker run falcosecurity/falco-tester
-    * docker run falcosecurity/falco-tester usage
-
-    It supports bash.
-    * docker run -ti falcosecurity/falco-tester bash
-
-    To run Falco regression tests you need to provide:
-    - the docker socket
-    - the boot directory
-    - the source directory
-    - the directory where Falco has been built
-    - the environment variable FALCO_VARIABLE set to the value obtained during the Falco's build
-
-    Assuming you are running it from the Falco root directory, you can run it as follows.
-    * docker run -v /boot:/boot:ro -v /var/run/docker.sock:/var/run/docker.sock -v $PWD/..:/source -v $PWD/build:/build -e FALCO_VERSION=<current_falco_version> falcosecurity/falco-tester test
-
-How to build.
-
-    * cd docker/tester && DOCKER_BUILDKIT=1 docker build -t falcosecurity/falco-tester .
-
-Environment.
-
-    * python ${pythonversion}
-    * ${pipversion}
-    * avocado ${avocadoversion}
-    * ${dockerversion}
-EOF

docker/ubi/Dockerfile

@@ -1,46 +0,0 @@
-ARG UBI_VERSION=latest
-FROM registry.access.redhat.com/ubi8/ubi:${UBI_VERSION}
-
-ARG FALCO_VERSION
-RUN test -n "$FALCO_VERSION" || (echo "FALCO_VERSION  not set" && false)
-ENV FALCO_VERSION=${FALCO_VERSION}
-
-LABEL "name"="Falco Runtime Security"
-LABEL "vendor"="Falco"
-LABEL "version"="${FALCO_VERSION}"
-LABEL "release"="${FALCO_VERSION}"
-LABEL "ubi-version"="${UBI_VERSION}"
-LABEL "summary"="Falco is a security policy engine that monitors system calls and cloud events, and fires alerts when security policies are violated."
-LABEL "description"="Falco is a security policy engine that monitors system calls and cloud events, and fires alerts when security policies are violated."
-LABEL "io.k8s.display-name"="Falco"
-LABEL "io.k8s.description"="Falco is a security policy engine that monitors system calls and cloud events, and fires alerts when security policies are violated."
-LABEL maintainer="cncf-falco-dev@lists.cncf.io"
-LABEL org.opencontainers.image.source="https://github.com/falcosecurity/falco"
-LABEL usage="docker run -i -t --privileged -v /var/run/docker.sock:/host/var/run/docker.sock -v /dev:/host/dev -v /proc:/host/proc:ro -v /boot:/host/boot:ro -v /lib/modules:/host/lib/modules:ro -v /usr:/host/usr:ro -v /etc:/host/etc --name NAME IMAGE"
-
-
-ENV HOST_ROOT /host
-ENV HOME /root
-
-RUN  dnf -y update && \
-     dnf -y install \
-          curl \
-          make \
-          cmake \
-          gcc \
-          llvm-toolset \
-          clang \
-          kmod \
-     && dnf -y clean all ; rm -rf /var/cache/{dnf,yum}
-
-RUN mkdir /build && cd /build/ && curl --remote-name-all -L https://github.com/dell/dkms/archive/refs/tags/v3.0.3.tar.gz && \
-     tar xvf v3.0.3.tar.gz && cd dkms-3.0.3 && make install-redhat && rm -rf /build
-
-RUN mkdir /deploy && cd /deploy/ && curl --remote-name-all -L https://download.falco.org/packages/bin/$(uname -m)/falco-${FALCO_VERSION}-$(uname -m).tar.gz && \
-     cd / && tar --strip-components=1 -xvf /deploy/falco-${FALCO_VERSION}-$(uname -m).tar.gz && \
-     rm -rf /deploy
-
-COPY ./docker-entrypoint.sh /
-
-ENTRYPOINT ["/docker-entrypoint.sh"]
-CMD ["/usr/bin/falco"]

docker/ubi/docker-entrypoint.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-#
-# Copyright (C) 2022 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# Set the SKIP_DRIVER_LOADER variable to skip loading the driver
-
-if [[ -z "${SKIP_DRIVER_LOADER}" ]]; then
-
-    # Required by dkms to find the required dependencies on RedHat UBI
-    rm -fr /usr/src/kernels/ && rm -fr /usr/src/debug/
-    rm -fr /lib/modules && ln -s $HOST_ROOT/lib/modules /lib/modules
-    rm -fr /boot && ln -s $HOST_ROOT/boot /boot
-
-    echo "* Setting up /usr/src links from host"
-
-    for i in "$HOST_ROOT/usr/src"/*
-    do
-        base=$(basename "$i")
-        ln -s "$i" "/usr/src/$base"
-    done
-
-    /usr/bin/falco-driver-loader
-fi
-
-exec "$@"

falco.yaml

@@ -134,12 +134,17 @@
 # By arranging the order of files and rules thoughtfully, you can ensure that
 # desired customizations and rule behaviors are prioritized and applied as
 # intended.
+# 
+# With Falco 0.36 and beyond, it's now possible to apply multiple rules that match 
+# the same event type, eliminating concerns about rule prioritization based on the 
+# "first match wins" principle. However, enabling the `all` matching option may result
+# in a performance penalty. We recommend carefully testing this alternative setting  
+# before deploying it in production. Read more under the `rule_matching` configuration.
 rules_file:
   - /etc/falco/falco_rules.yaml
   - /etc/falco/falco_rules.local.yaml
   - /etc/falco/rules.d
 
-
 #################
 # Falco plugins #
 #################
@@ -148,7 +153,7 @@ rules_file:
 #
 # --- [Description]
 #
-# Falco plugins enable integration with other services in the your ecosystem.
+# Falco plugins enable integration with other services in your ecosystem.
 # They allow Falco to extend its functionality and leverage data sources such as
 # Kubernetes audit logs or AWS CloudTrail logs. This enables Falco to perform
 # fast on-host detections beyond syscalls and container events. The plugin
@@ -162,10 +167,11 @@ rules_file:
 #
 # Please note that if your intention is to enrich Falco syscall logs with fields
 # such as `k8s.ns.name`, `k8s.pod.name`, and `k8s.pod.*`, you do not need to use
-# the `k8saudit` plugin. This information is automatically extracted from the
-# container runtime socket. The `k8saudit` plugin is specifically designed to
-# integrate with Kubernetes audit logs and is not required for basic enrichment
-# of syscall logs with Kubernetes-related fields.
+# the `k8saudit` plugin nor the `-k`/`-K` Kubernetes metadata enrichment. This
+# information is automatically extracted from the container runtime socket. The
+# `k8saudit` plugin is specifically designed to integrate with Kubernetes audit
+# logs and is not required for basic enrichment of syscall logs with
+# Kubernetes-related fields.
 #
 # --- [Usage]
 #
@@ -266,6 +272,9 @@ buffered_outputs: false
 
 # [Stable] `outputs`
 #
+# [DEPRECATED]
+# This config is deprecated and it will be removed in Falco 0.37
+#
 # A throttling mechanism, implemented as a token bucket, can be used to control
 # the rate of Falco outputs. Each event source has its own rate limiter,
 # ensuring that alerts from one source do not affect the throttling of others.
@@ -289,6 +298,27 @@ outputs:
   rate: 0
   max_burst: 1000
 
+# [Experimental] `rule_matching`
+#
+# The `rule_matching` configuration key's values are:
+#  - `first`: Falco stops checking conditions of rules against upcoming event
+#    at the first matching rule
+#  - `all`: Falco will continue checking conditions of rules even if a matching 
+#    one was already found
+#
+# Rules conditions are evaluated in the order they are defined in the rules files.
+# For this reason, when using `first` as value, only the first defined rule will 
+# trigger, possibly shadowing other rules.
+# In case `all` is used as value, rules still trigger in the order they were
+# defined.
+# 
+# Effectively, with this setting, it is now possible to apply multiple rules that match
+# the same event type. This eliminates concerns about rule prioritization based on the
+# "first match wins" principle. However, enabling the `all` matching option may result in
+# a performance penalty. We recommend carefully testing this alternative setting before
+# deploying it in production.
+rule_matching: first
+
 
 ##########################
 # Falco outputs channels #
@@ -328,6 +358,9 @@ file_output:
 # [Stable] `http_output`
 #
 # Send logs to an HTTP endpoint or webhook.
+#
+# When using falcosidekick, it is necessary to set `json_output` to true, which is
+# conveniently done automatically for you when using `falcosidekick.enabled=true`.
 http_output:
   enabled: false
   url: http://some.url
@@ -341,6 +374,14 @@ http_output:
   # Path to a folder that will be used as the CA certificate store. CA certificate need to be
   # stored as indivitual PEM files in this directory.
   ca_path: "/etc/ssl/certs"
+  # Tell Falco to use mTLS
+  mtls: false
+  # Path to the client cert.
+  client_cert: "/etc/ssl/certs/client.crt"
+  # Path to the client key.
+  client_key: "/etc/ssl/certs/client.key"
+  # Whether to echo server answers to stdout
+  echo: false
 
 # [Stable] `program_output`
 #
@@ -492,8 +533,8 @@ log_level: info
 # operational logs. It allows you to specify the desired log level for the `libs`
 # library specifically, providing more granular control over the logging
 # behavior of the underlying components used by Falco. Only logs of a certain
-# severity level or higher will be emitted. Supported levels: "emergency",
-# "alert", "critical", "error", "warning", "notice", "info", "debug". It is not
+# severity level or higher will be emitted. Supported levels: "fatal",
+# "critical", "error", "warning", "notice", "info", "debug", "trace". It is not
 # recommended for production use.
 libs_logger:
   enabled: false
@@ -595,9 +636,10 @@ syscall_event_drops:
   max_burst: 1
   simulate_drops: false
 
-# [Experimental] `metrics`
+# [Stable] `metrics`
 #
 # Generates "Falco internal: metrics snapshot" rule output when `priority=info` at minimum
+# By selecting `output_file`, equivalent JSON output will be appended to a file.
 #
 # periodic metric snapshots (including stats and resource utilization) captured
 # at regular intervals
@@ -629,6 +671,9 @@ syscall_event_drops:
 #
 # It's important to note that the output fields and their names can be subject
 # to change until the metrics feature reaches a stable release.
+# In addition, the majority of fields represent an instant snapshot, with the
+# exception of event rates per second and drop percentage stats. These values
+# are computed based on the delta between two snapshots.
 #
 # To customize the hostname in Falco, you can set the environment variable
 # `FALCO_HOSTNAME` to your desired hostname. This is particularly useful in
@@ -672,7 +717,8 @@ syscall_event_drops:
 # must be set to `info` at a minimum.
 #
 # `output_file`: Append stats to a `jsonl` file. Use with caution in production
-# as Falco does not automatically rotate the file.
+# as Falco does not automatically rotate the file. It can be used in combination
+# with `output_rule`.
 #
 # `resource_utilization_enabled`: Emit CPU and memory usage metrics. CPU usage
 # is reported as a percentage of one CPU and can be normalized to the total
@@ -713,6 +759,8 @@ syscall_event_drops:
 metrics:
   enabled: false
   interval: 1h
+  # Typically, in production, you only use `output_rule` or `output_file`, but not both. 
+  # However, if you have a very unique use case, you can use both together.
   output_rule: true
   # output_file: /tmp/falco_stats.jsonl
   resource_utilization_enabled: true
@@ -788,7 +836,7 @@ syscall_buf_size_preset: 4
 # visibility into the system.
 syscall_drop_failed_exit: false
 
-# [Experimental] `base_syscalls`, use with caution, read carefully
+# [Stable] `base_syscalls`, use with caution, read carefully
 #
 # --- [Description]
 #

scripts/CMakeLists.txt

@@ -15,40 +15,42 @@
 # limitations under the License.
 #
 
-# Systemd
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/scripts/systemd)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-kmod-inject.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-kmod.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-bpf.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-modern-bpf.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-custom.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falcoctl-artifact-follow.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-
-# Debian
-configure_file(debian/postinst.in debian/postinst COPYONLY)
-configure_file(debian/postrm.in debian/postrm COPYONLY)
-configure_file(debian/prerm.in debian/prerm COPYONLY)
-
-# Rpm
-configure_file(rpm/postinstall.in rpm/postinstall COPYONLY)
-configure_file(rpm/postuninstall.in rpm/postuninstall COPYONLY)
-configure_file(rpm/preuninstall.in rpm/preuninstall COPYONLY)
-
-configure_file(falco-driver-loader falco-driver-loader @ONLY)
-
-# Install Falcoctl config file
-if(NOT DEFINED FALCOCTL_ETC_DIR)
-	set(FALCOCTL_ETC_DIR "${CMAKE_INSTALL_FULL_SYSCONFDIR}/falcoctl")
-endif()
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/falcoctl/falcoctl.yaml DESTINATION "${FALCOCTL_ETC_DIR}" COMPONENT "${FALCO_COMPONENT_NAME}")
-
 if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+	# Systemd
+	file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/scripts/systemd)
+	configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-kmod-inject.service"
+			"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
+	configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-kmod.service"
+			"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
+	configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-bpf.service"
+			"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
+	configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-modern-bpf.service"
+			"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
+	configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-custom.service"
+			"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
+	configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falcoctl-artifact-follow.service"
+			"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
+
+	# Debian
+	configure_file(debian/postinst.in debian/postinst COPYONLY)
+	configure_file(debian/postrm.in debian/postrm COPYONLY)
+	configure_file(debian/prerm.in debian/prerm COPYONLY)
+
+	# Rpm
+	configure_file(rpm/postinstall.in rpm/postinstall COPYONLY)
+	configure_file(rpm/postuninstall.in rpm/postuninstall COPYONLY)
+	configure_file(rpm/preuninstall.in rpm/preuninstall COPYONLY)
+
+	# driver loader
+	configure_file(falco-driver-loader falco-driver-loader @ONLY)
 	install(PROGRAMS ${PROJECT_BINARY_DIR}/scripts/falco-driver-loader
 		DESTINATION ${FALCO_BIN_DIR} COMPONENT "${FALCO_COMPONENT_NAME}")
 endif()
+
+# Install Falcoctl config file
+if (NOT WIN32 AND NOT APPLE AND NOT EMSCRIPTEN AND NOT MUSL_OPTIMIZED_BUILD)
+	if(NOT DEFINED FALCOCTL_ETC_DIR)
+		set(FALCOCTL_ETC_DIR "${CMAKE_INSTALL_FULL_SYSCONFDIR}/falcoctl")
+	endif()
+	install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/falcoctl/falcoctl.yaml DESTINATION "${FALCOCTL_ETC_DIR}" COMPONENT "${FALCO_COMPONENT_NAME}")
+endif()

scripts/falco-driver-loader

@@ -117,7 +117,9 @@ get_target_id() {
 		# Older RHEL distros
 		OS_ID=rhel
 	else
-		return 1
+		# No target id can be determinand
+		TARGET_ID="undetermined"
+		return
 	fi
 
 	# Overwrite the OS_ID if /etc/VERSION file is present.
@@ -151,13 +153,19 @@ get_target_id() {
 		# Real kernel release is embedded inside the kernel version.
 		# Moreover, kernel arch, when present, is attached to the former,
 		# therefore make sure to properly take it and attach it to the latter.
+		# Moreover, we support 3 flavors for debian kernels: cloud, rt and normal.
+		# KERNEL-RELEASE will have a `-rt`, or `-cloud` if we are in one of these flavors.
+		# Manage it to download the correct driver.
+		#
+		# Example: KERNEL_RELEASE="5.10.0-0.deb10.22-rt-amd64" and `uname -v`="5.10.178-3"
+		# should lead to: KERNEL_RELEASE="5.10.178-3-rt-amd64"
 		TARGET_ID=$(echo "${OS_ID}" | tr '[:upper:]' '[:lower:]')
 		local ARCH_extra=""
-		if [[ $KERNEL_RELEASE =~ -(amd64|arm64) ]];
+		if [[ $KERNEL_RELEASE =~ -?(rt-|cloud-|)(amd64|arm64) ]];
 		then
-			ARCH_extra="-${BASH_REMATCH[1]}"
+			ARCH_extra="-${BASH_REMATCH[1]}${BASH_REMATCH[2]}"
 		fi
-		if [[ $(uname -v) =~ ([0-9]+\.[0-9]+\.[0-9]+\-[0-9]+) ]];
+		if [[ ${DRIVER_KERNEL_VERSION} =~ ([0-9]+\.[0-9]+\.[0-9]+\-[0-9]+) ]];
 		then
 			KERNEL_RELEASE="${BASH_REMATCH[1]}${ARCH_extra}"
 		fi
@@ -165,14 +173,26 @@ get_target_id() {
 	("ubuntu")
 		# Extract the flavor from the kernelrelease
 		# Examples:
-		# 5.0.0-1028-aws-5.0 -> ubuntu-aws-5.0
+		# 5.0.0-1028-aws-5.0 -> ubuntu-aws
 		# 5.15.0-1009-aws -> ubuntu-aws
 		if [[ $KERNEL_RELEASE =~ -([a-zA-Z]+)(-.*)?$ ]];
 		then
-			TARGET_ID="ubuntu-${BASH_REMATCH[1]}${BASH_REMATCH[2]}"
+			TARGET_ID="ubuntu-${BASH_REMATCH[1]}"
 		else
 			TARGET_ID="ubuntu-generic"
 		fi
+
+
+		# In the case that the kernelversion isn't just a number
+		# we keep also the remaining part excluding `-Ubuntu`.
+		# E.g.:
+		# from the following `uname -v` result
+		# `#26~22.04.1-Ubuntu SMP Mon Apr 24 01:58:15 UTC 2023`
+		# we obtain the kernelversion`26~22.04.1`
+		if [[ ${DRIVER_KERNEL_VERSION} =~ (^\#[0-9]+\~[^-]*-Ubuntu .*$) ]];
+		then
+			KERNEL_VERSION=$(echo "${DRIVER_KERNEL_VERSION}" | sed 's/#\([^-\\ ]*\).*/\1/g')
+		fi
 		;;
 	("flatcar")
 		KERNEL_RELEASE="${VERSION_ID}"
@@ -209,7 +229,6 @@ get_target_id() {
 		TARGET_ID=$(echo "${OS_ID}" | tr '[:upper:]' '[:lower:]')
 		;;
 	esac
-	return 0
 }
 
 flatcar_relocate_tools() {
@@ -240,7 +259,7 @@ flatcar_relocate_tools() {
 
 load_kernel_module_compile() {
 	# Skip dkms on UEK hosts because it will always fail
-	if [[ $(uname -r) == *uek* ]]; then
+	if [[ ${DRIVER_KERNEL_RELEASE} == *uek* ]]; then
 		>&2 echo "Skipping because the dkms install always fail (on UEK hosts)"
 		return
 	fi
@@ -251,7 +270,7 @@ load_kernel_module_compile() {
 	fi
 
 	if [ "${TARGET_ID}" == "flatcar" ]; then
-		KERNEL_RELEASE=$(uname -r)
+		KERNEL_RELEASE=${DRIVER_KERNEL_RELEASE}
 		echo "* Flatcar detected (version ${VERSION_ID}); relocating kernel tools"
 		flatcar_relocate_tools
 	fi
@@ -325,9 +344,9 @@ load_kernel_module_download() {
 print_clean_termination() {
 	echo
 	echo "[SUCCESS] Cleaning phase correctly terminated."
-	echo 
+	echo
 	echo "================ Cleaning phase ================"
-	echo 
+	echo
 }
 
 print_filename_components() {
@@ -337,10 +356,24 @@ print_filename_components() {
 	echo " - kernel version: ${KERNEL_VERSION}"
 }
 
+print_as_env_vars() {
+	echo "ARCH=\"${ARCH}\""
+	echo "KERNEL_RELEASE=\"${KERNEL_RELEASE}\""
+	echo "KERNEL_VERSION=\"${KERNEL_VERSION}\""
+	echo "ENABLE_COMPILE=\"${ENABLE_COMPILE}\""
+	echo "ENABLE_DOWNLOAD=\"${ENABLE_DOWNLOAD}\""
+	echo "TARGET_ID=\"${TARGET_ID}\""
+	echo "DRIVER=\"${DRIVER}\""
+	echo "DRIVERS_REPO=\"${DRIVERS_REPO}\""
+	echo "DRIVER_VERSION=\"${DRIVER_VERSION}\""
+	echo "DRIVER_NAME=\"${DRIVER_NAME}\""
+	echo "FALCO_VERSION=\"${FALCO_VERSION}\""
+}
+
 clean_kernel_module() {
-	echo 
+	echo
 	echo "================ Cleaning phase ================"
-	echo 
+	echo
 
 	if ! hash lsmod > /dev/null 2>&1; then
 		>&2 echo "This program requires lsmod."
@@ -383,7 +416,7 @@ clean_kernel_module() {
 		echo "[WARNING] '${KMOD_NAME}' module is still loaded, you could have incompatibility issues."
 		echo
 	fi
-	
+
 	if ! hash dkms >/dev/null 2>&1; then
 		echo "- Skipping dkms remove (dkms not found)."
 		print_clean_termination
@@ -468,6 +501,12 @@ load_bpf_probe_compile() {
 		make modules_prepare > /dev/null
 	}
 
+	if [ "${TARGET_ID}" == "flatcar" ]; then
+		KERNEL_RELEASE=${DRIVER_KERNEL_RELEASE}
+		echo "* Flatcar detected (version ${VERSION_ID}); relocating kernel tools"
+		flatcar_relocate_tools
+	fi
+
 	if [ "${TARGET_ID}" == "cos" ]; then
 		echo "* COS detected (build ${BUILD_ID}), using COS kernel headers"
 
@@ -504,7 +543,7 @@ load_bpf_probe_compile() {
 		MINIKUBE_VERSION="$(cat "${HOST_ROOT}/etc/VERSION")"
 		echo "* Minikube detected (${MINIKUBE_VERSION}), using linux kernel sources for minikube kernel"
 		local kernel_version
-		kernel_version=$(uname -r)
+		kernel_version=${DRIVER_KERNEL_RELEASE}
 		local -r kernel_version_major=$(echo "${kernel_version}" | cut -d. -f1)
 		local -r kernel_version_minor=$(echo "${kernel_version}" | cut -d. -f2)
 		local -r kernel_version_patch=$(echo "${kernel_version}" | cut -d. -f3)
@@ -517,9 +556,9 @@ load_bpf_probe_compile() {
 	fi
 
 	if [ -n "${BPF_USE_LOCAL_KERNEL_SOURCES}" ]; then
-		local -r kernel_version_major=$(uname -r | cut -d. -f1)
-		local -r kernel_version=$(uname -r | cut -d- -f1)
-		KERNEL_EXTRA_VERSION="-$(uname -r | cut -d- -f2)"
+		local -r kernel_version_major=$(echo "${DRIVER_KERNEL_RELEASE}" | cut -d. -f1)
+		local -r kernel_version=$(echo "${DRIVER_KERNEL_RELEASE}" | cut -d- -f1)
+		KERNEL_EXTRA_VERSION="-$(echo "${DRIVER_KERNEL_RELEASE}" | cut -d- -f2)"
 
 		echo "* Using downloaded kernel sources for kernel version ${kernel_version}..."
 
@@ -642,13 +681,16 @@ print_usage() {
 	echo "  --clean        try to remove an already present driver installation"
 	echo "  --compile      try to compile the driver locally (default true)"
 	echo "  --download     try to download a prebuilt driver (default true)"
-	echo "  --source-only  skip execution and allow sourcing in another script"
+	echo "  --source-only  skip execution and allow sourcing in another script using `. falco-driver-loader`"
+	echo "  --print-env    skip execution and print env variables for other tools to consume"
 	echo ""
 	echo "Environment variables:"
 	echo "  DRIVERS_REPO             specify different URL(s) where to look for prebuilt Falco drivers (comma separated)"
 	echo "  DRIVER_NAME              specify a different name for the driver"
 	echo "  DRIVER_INSECURE_DOWNLOAD whether you want to allow insecure downloads or not"
 	echo "  DRIVER_CURL_OPTIONS      specify additional options to be passed to curl command used to download Falco drivers"
+	echo "  DRIVER_KERNEL_RELEASE    specify the kernel release for which to download/build the driver in the same format used by 'uname -r' (e.g. '6.1.0-10-cloud-amd64')"
+	echo "  DRIVER_KERNEL_VERSION    specify the kernel version for which to download/build the driver in the same format used by 'uname -v' (e.g. '#1 SMP PREEMPT_DYNAMIC Debian 6.1.38-2 (2023-07-27)')"
 	echo ""
 	echo "Versions:"
 	echo "  Falco version  ${FALCO_VERSION}"
@@ -658,13 +700,16 @@ print_usage() {
 
 ARCH=$(uname -m)
 
-KERNEL_RELEASE=$(uname -r)
+DRIVER_KERNEL_RELEASE=${DRIVER_KERNEL_RELEASE:-$(uname -r)}
+KERNEL_RELEASE=${DRIVER_KERNEL_RELEASE}
 
 if ! hash sed > /dev/null 2>&1; then
 	>&2 echo "This program requires sed"
 	exit 1
 fi
-KERNEL_VERSION=$(uname -v | sed 's/#\([[:digit:]]\+\).*/\1/')
+
+DRIVER_KERNEL_VERSION=${DRIVER_KERNEL_VERSION:-$(uname -v)}
+KERNEL_VERSION=$(echo "${DRIVER_KERNEL_VERSION}" | sed 's/#\([[:digit:]]\+\).*/\1/')
 
 DRIVERS_REPO=${DRIVERS_REPO:-"@DRIVERS_REPO@"}
 
@@ -685,7 +730,8 @@ DRIVER_VERSION=${DRIVER_VERSION:-"@DRIVER_VERSION@"}
 DRIVER_NAME=${DRIVER_NAME:-"@DRIVER_NAME@"}
 FALCO_VERSION="@FALCO_VERSION@"
 
-TARGET_ID="placeholder" # when no target id can be fetched, we try to build the driver from source anyway, using a placeholder name
+TARGET_ID=
+get_target_id
 
 DRIVER="module"
 if [ -v FALCO_BPF_PROBE ]; then
@@ -700,6 +746,7 @@ ENABLE_DOWNLOAD=
 clean=
 has_args=
 has_opts=
+print_env=
 source_only=
 while test $# -gt 0; do
 	case "$1" in
@@ -736,6 +783,10 @@ while test $# -gt 0; do
 			source_only="true"
 			shift
 			;;
+		--print-env)
+			print_env="true"
+			shift
+			;;
 		--*)
 			>&2 echo "Unknown option: $1"
 			print_usage
@@ -754,55 +805,61 @@ if [ -z "$has_opts" ]; then
 	ENABLE_DOWNLOAD="yes"
 fi
 
-if [ -z "$source_only" ]; then
-	echo "* Running falco-driver-loader for: falco version=${FALCO_VERSION}, driver version=${DRIVER_VERSION}, arch=${ARCH}, kernel release=${KERNEL_RELEASE}, kernel version=${KERNEL_VERSION}"
+if [ -n "$source_only" ]; then
+	# Return or exit, depending if we've been sourced.
+	(return 0 2>/dev/null) && return || exit 0
+fi
 
-	if [ "$(id -u)" != 0 ]; then
-		>&2 echo "This program must be run as root (or with sudo)"
+if [ -n "$print_env" ]; then
+	print_as_env_vars
+	exit 0
+fi
+
+echo "* Running falco-driver-loader for: falco version=${FALCO_VERSION}, driver version=${DRIVER_VERSION}, arch=${ARCH}, kernel release=${KERNEL_RELEASE}, kernel version=${KERNEL_VERSION}"
+
+if [ "$(id -u)" != 0 ]; then
+	>&2 echo "This program must be run as root (or with sudo)"
+	exit 1
+fi
+
+if [ "$TARGET_ID" = "undetermined" ]; then
+	if [ -n "$ENABLE_COMPILE" ]; then
+		ENABLE_DOWNLOAD=
+		>&2 echo "Detected an unsupported target system, please get in touch with the Falco community. Trying to compile anyway."
+	else
+		>&2 echo "Detected an unsupported target system, please get in touch with the Falco community."
+		exit 1
+	fi
+fi
+
+if [ -n "$clean" ]; then
+	if [ -n "$has_opts" ]; then
+		>&2 echo "Cannot use --clean with other options"
 		exit 1
 	fi
 
-	get_target_id
-	res=$?
-	if [ $res != 0 ]; then
-		if [ -n "$ENABLE_COMPILE" ]; then
-			ENABLE_DOWNLOAD=
-			>&2 echo "Detected an unsupported target system, please get in touch with the Falco community. Trying to compile anyway."
-		else
-			>&2 echo "Detected an unsupported target system, please get in touch with the Falco community."
-			exit 1
-		fi
+	echo "* Running falco-driver-loader with: driver=$DRIVER, clean=yes"
+	case $DRIVER in
+	module)
+		clean_kernel_module
+		;;
+	bpf)
+		>&2 echo "--clean not supported for driver=bpf"
+		exit 1
+	esac
+else
+	if ! hash curl > /dev/null 2>&1; then
+		>&2 echo "This program requires curl"
+		exit 1
 	fi
 
-	if [ -n "$clean" ]; then
-		if [ -n "$has_opts" ]; then
-			>&2 echo "Cannot use --clean with other options"
-			exit 1
-		fi
-
-		echo "* Running falco-driver-loader with: driver=$DRIVER, clean=yes"
-		case $DRIVER in
+	echo "* Running falco-driver-loader with: driver=$DRIVER, compile=${ENABLE_COMPILE:-"no"}, download=${ENABLE_DOWNLOAD:-"no"}"
+	case $DRIVER in
 		module)
-			clean_kernel_module
+			load_kernel_module
 			;;
 		bpf)
-			>&2 echo "--clean not supported for driver=bpf"
-			exit 1
-		esac
-	else
-		if ! hash curl > /dev/null 2>&1; then
-			>&2 echo "This program requires curl"
-			exit 1
-		fi
-
-		echo "* Running falco-driver-loader with: driver=$DRIVER, compile=${ENABLE_COMPILE:-"no"}, download=${ENABLE_DOWNLOAD:-"no"}"
-		case $DRIVER in
-			module)
-				load_kernel_module
-				;;
-			bpf)
-				load_bpf_probe
-				;;
-		esac
-	fi
+			load_bpf_probe
+			;;
+	esac
 fi

scripts/systemd/falco-bpf.service

@@ -8,7 +8,8 @@ Wants=falcoctl-artifact-follow.service
 Type=simple
 User=root
 Environment=FALCO_BPF_PROBE=
-ExecStart=/usr/bin/falco --pidfile=/var/run/falco.pid
+ExecStart=/usr/bin/falco
+ExecReload=kill -1 $MAINPID
 UMask=0077
 TimeoutSec=30
 RestartSec=15s

scripts/systemd/falco-custom.service

@@ -7,7 +7,8 @@ Wants=falcoctl-artifact-follow.service
 [Service]
 Type=simple
 User=%u
-ExecStart=/usr/bin/falco --pidfile=/var/run/falco.pid
+ExecStart=/usr/bin/falco
+ExecReload=kill -1 $MAINPID
 UMask=0077
 TimeoutSec=30
 RestartSec=15s

scripts/systemd/falco-kmod.service

@@ -9,7 +9,8 @@ Wants=falcoctl-artifact-follow.service
 [Service]
 Type=simple
 User=root
-ExecStart=/usr/bin/falco --pidfile=/var/run/falco.pid
+ExecStart=/usr/bin/falco
+ExecReload=kill -1 $MAINPID
 UMask=0077
 TimeoutSec=30
 RestartSec=15s

scripts/systemd/falco-modern-bpf.service

@@ -7,7 +7,8 @@ Wants=falcoctl-artifact-follow.service
 [Service]
 Type=simple
 User=root
-ExecStart=/usr/bin/falco --pidfile=/var/run/falco.pid --modern-bpf
+ExecStart=/usr/bin/falco --modern-bpf
+ExecReload=kill -1 $MAINPID
 UMask=0077
 TimeoutSec=30
 RestartSec=15s

test/.gitignore

@@ -1,2 +0,0 @@
-falco_traces.yaml
-venv/*

test/CMakeLists.txt

@@ -1,6 +0,0 @@
-add_subdirectory(trace_files)
-
-if(NOT MUSL_OPTIMIZED_BUILD)
-    add_subdirectory(plugins)
-    add_subdirectory(confs/plugins)
-endif()

test/OWNERS

@@ -1,2 +0,0 @@
-labels:
-  - area/tests

test/README.md

@@ -1,116 +0,0 @@
-# Falco regression tests
-
-This folder contains the Regression tests suite for Falco.
-
-You can find instructions on how to run this test suite on the Falco website [here](https://falco.org/docs/getting-started/source/#run-regression-tests).
-
-## Test suites
-
-- [falco_tests](./falco_tests.yaml)
-- [falco_traces](./falco_traces.yaml.in)
-- [falco_tests_package](./falco_tests_package.yaml)
-- [falco_k8s_audit_tests](./falco_k8s_audit_tests.yaml)
-
-## Running locally
-
-This step assumes you already built Falco.
-
-Note that the tests are intended to be run against a [release build](https://falco.org/docs/getting-started/source/#specify-the-build-type) of Falco, at the moment.
-
-Also, it assumes you prepared [falco_traces](#falco_traces) (see the section below).
-
-**Requirements**
-
-- Python 3.x
-- [Virtualenv](https://virtualenv.pypa.io/en/latest/)
-- [grpcurl](https://github.com/fullstorydev/grpcurl)
-
-**Setup and execution**
-
-Using `virtualenv` the steps to locally run a specific test suite are the following ones (**from this directory**):
-
-```console
-virtualenv venv
-source venv/bin/activate
-pip install -r requirements.txt
-BUILD_DIR="../build" avocado run --mux-yaml falco_tests.yaml --job-results-dir /tmp/job-results -- falco_test.py
-deactivate
-```
-
-The name of the specific test suite to run is `falco_tests.yaml` in this case. Change it to run others test suites.
-
-In case you want to only execute a specific test case, use the `--mux-filter-only` parameter as follows:
-
-```console
-BUILD_DIR="../build" avocado run --mux-yaml falco_tests.yaml --job-results-dir /tmp/job-results --mux-filter-only /run/trace_files/program_output -- falco_test.py
-```
-
-To obtain the path of all the available variants for a given test suite, execute:
-
-```console
-avocado variants --mux-yaml falco_tests.yaml
-```
-
-### falco_traces
-
-The `falco_traces.yaml` test suite gets generated through the `falco_traces.yaml.in` file and some fixtures (`scap` files) downloaded from the web at execution time.
-
-1. Ensure you have `unzip` and `xargs` utilities
-2. Prepare the test suite with the following command:
-
-    ```console
-    bash run_regression_tests.sh -p -v
-    ```
-
-### falco_tests_package
-
-The `falco_tests_package.yaml` test suite requires some additional setup steps to be successfully run on your local machine.
-
-In particular, it requires some runners (ie., docker images) to be already built and present into your local machine.
-
-1. Ensure you have `docker` up and running
-2. Ensure you build Falco (with bundled deps)
-
-    The recommended way of doing it by running the `falcosecurity/falco-builder` docker image from the project root:
-
-    ```console
-    docker run -v $PWD/..:/source -v $PWD/mybuild:/build falcosecurity/falco-builder cmake
-    docker run -v $PWD/..:/source -v $PWD/mybuild:/build falcosecurity/falco-builder falco
-    ```
-
-3. Ensure you build the Falco packages from the Falco above:
-
-    ```console
-    docker run -v $PWD/..:/source -v $PWD/mybuild:/build falcosecurity/falco-builder package
-    ```
-
-4. Ensure you build the runners:
-
-    ```console
-    FALCO_VERSION=$(./mybuild/release/userspace/falco/falco --version  | head -n 1 | cut -d' ' -f3 | tr -d '\r')
-    mkdir -p /tmp/runners-rootfs
-    cp -R ./test/rules /tmp/runners-rootfs
-    cp -R ./test/trace_files /tmp/runners-rootfs
-    cp ./mybuild/release/falco-${FALCO_VERSION}-x86_64.{deb,rpm,tar.gz} /tmp/runners-rootfs
-    docker build -f docker/tester/root/runners/deb.Dockerfile --build-arg FALCO_VERSION=${FALCO_VERSION} -t falcosecurity/falco:test-deb /tmp/runners-rootfs
-    docker build -f docker/tester/root/runners/rpm.Dockerfile --build-arg FALCO_VERSION=${FALCO_VERSION} -t falcosecurity/falco:test-rpm /tmp/runners-rootfs
-    docker build -f docker/tester/root/runners/tar.gz.Dockerfile --build-arg FALCO_VERSION=${FALCO_VERSION} -t falcosecurity/falco:test-tar.gz /tmp/runners-rootfs
-    ```
-
-5. Run the `falco_tests_package.yaml` test suite from the `test` directory
-
-    ```console
-    cd test
-    BUILD_DIR="../mybuild" avocado run --mux-yaml falco_tests_package.yaml --job-results-dir /tmp/job-results -- falco_test.py
-    ```
-
-### Execute all the test suites
-
-In case you want to run all the test suites at once, you can directly use the `run_regression_tests.sh` runner script.
-
-```console
-cd test
-./run_regression_tests.sh -v -d ../build
-```
-
-Just make sure you followed all the previous setup steps.

test/confs/drops_alert.yaml

@@ -1,11 +0,0 @@
-syscall_event_drops:
-  actions:
-    - alert
-  rate: .03333
-  max_burst: 10
-  simulate_drops: true
-
-stdout_output:
-  enabled: true
-
-log_stderr: true

test/confs/drops_exit.yaml

@@ -1,11 +0,0 @@
-syscall_event_drops:
-  actions:
-    - exit
-  rate: .03333
-  max_burst: 10
-  simulate_drops: true
-
-stdout_output:
-  enabled: true
-
-log_stderr: true

test/confs/drops_ignore.yaml

@@ -1,11 +0,0 @@
-syscall_event_drops:
-  actions:
-    - ignore
-  rate: .03333
-  max_burst: 10
-  simulate_drops: true
-
-stdout_output:
-  enabled: true
-
-log_stderr: true

test/confs/drops_ignore_log.yaml

@@ -1,12 +0,0 @@
-syscall_event_drops:
-  actions:
-    - ignore
-    - log
-  rate: .03333
-  max_burst: 10
-  simulate_drops: true
-
-stdout_output:
-  enabled: true
-
-log_stderr: true

test/confs/drops_log.yaml

@@ -1,13 +0,0 @@
-syscall_event_drops:
-  actions:
-    - log
-  rate: .03333
-  max_burst: 10
-  simulate_drops: true
-
-stdout_output:
-  enabled: true
-
-log_stderr: true
-
-log_level: debug

test/confs/drops_none.yaml

@@ -1,11 +0,0 @@
-syscall_event_drops:
-  actions:
-    - log
-  rate: .03333
-  max_burst: 10
-  simulate_drops: false
-
-stdout_output:
-  enabled: true
-
-log_stderr: true

test/confs/drops_threshold_neg.yaml

@@ -1,12 +0,0 @@
-syscall_event_drops:
-  threshold: -1
-  actions:
-    - ignore
-  rate: .03333
-  max_burst: 10
-  simulate_drops: true
-
-stdout_output:
-  enabled: true
-
-log_stderr: true

test/confs/drops_threshold_oor.yaml

@@ -1,12 +0,0 @@
-syscall_event_drops:
-  threshold: 1.1
-  actions:
-    - ignore
-  rate: .03333
-  max_burst: 10
-  simulate_drops: true
-
-stdout_output:
-  enabled: true
-
-log_stderr: true

test/confs/file_output.yaml

@@ -1,44 +0,0 @@
-#
-# Copyright (C) 2019 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# File containing Falco rules, loaded at startup.
-rules_file: /etc/falco_rules.yaml
-
-# Whether to output events in json or text
-json_output: false
-
-# Send information logs to stderr and/or syslog Note these are *not* security
-# notification logs! These are just Falco lifecycle (and possibly error) logs.
-log_stderr: false
-log_syslog: false
-
-# Where security notifications should go.
-# Multiple outputs can be enabled.
-
-syslog_output:
-  enabled: false
-
-file_output:
-  enabled: true
-  filename: /tmp/falco_outputs/file_output.txt
-
-stdout_output:
-  enabled: true
-
-program_output:
-  enabled: false
-  program: mail -s "Falco Notification" someone@example.com

test/confs/grpc_unix_socket.yaml

@@ -1,38 +0,0 @@
-#
-# Copyright (C) 2020 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# Whether to output events in json or text.
-json_output: false
-
-# Send information logs to stderr and/or syslog
-# Note these are *not* security notification logs!
-# These are just Falco lifecycle (and possibly error) logs.
-log_stderr: false
-log_syslog: false
-
-# Where security notifications should go.
-stdout_output:
-  enabled: false
-
-# gRPC server using an unix socket.
-grpc:
-    enabled: true
-    bind_address: "unix:///tmp/falco/falco.sock"
-    threadiness: 8
-
-grpc_output:
-  enabled: true

test/confs/plugins/CMakeLists.txt

@@ -1,16 +0,0 @@
-# This list is populated at cmake time, not build time
-file(GLOB test_conf_files
-	"${CMAKE_CURRENT_SOURCE_DIR}/*.yaml")
-
-foreach(conf_file_path ${test_conf_files})
-	get_filename_component(conf_file ${conf_file_path} NAME)
-	add_custom_target(test-conf-${conf_file} ALL
-		DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${conf_file})
-	add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${conf_file}
-		COMMAND sed -e s!BUILD_DIR!${CMAKE_BINARY_DIR}! < ${CMAKE_CURRENT_SOURCE_DIR}/${conf_file} > ${CMAKE_CURRENT_BINARY_DIR}/${conf_file}
-		DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${conf_file})
-	list(APPEND PLUGINS_CONF_FILES_TARGETS test-conf-${conf_file})
-endforeach()
-
-add_custom_target(conf-files-plugins ALL)
-add_dependencies(conf-files-plugins ${PLUGINS_CONF_FILES_TARGETS})

test/confs/plugins/cloudtrail_json_create_instances.yaml

@@ -1,14 +0,0 @@
-stdout_output:
-  enabled: true
-
-plugins:
-  - name: cloudtrail
-    library_path: BUILD_DIR/cloudtrail-plugin-prefix/src/cloudtrail-plugin/libcloudtrail.so
-    init_config: ""
-    open_params: "BUILD_DIR/test/trace_files/plugins/alice_start_instances.json"
-  - name: json
-    library_path: BUILD_DIR/json-plugin-prefix/src/json-plugin/libjson.so
-    init_config: ""
-
-# Optional
-load_plugins: [cloudtrail, json]

test/confs/plugins/cloudtrail_json_create_instances_bigevent.yaml

@@ -1,14 +0,0 @@
-stdout_output:
-  enabled: true
-
-plugins:
-  - name: cloudtrail
-    library_path: BUILD_DIR/cloudtrail-plugin-prefix/src/cloudtrail-plugin/libcloudtrail.so
-    init_config: ""
-    open_params: "BUILD_DIR/test/trace_files/plugins/alice_start_instances_bigevent.json"
-  - name: json
-    library_path: BUILD_DIR/json-plugin-prefix/src/json-plugin/libjson.so
-    init_config: ""
-
-# Optional
-load_plugins: [cloudtrail, json]

test/confs/plugins/incompatible_extract_sources.yaml

@@ -1,14 +0,0 @@
-stdout_output:
-  enabled: true
-
-plugins:
-  - name: cloudtrail
-    library_path: BUILD_DIR/cloudtrail-plugin-prefix/src/cloudtrail-plugin/libcloudtrail.so
-    init_config: ""
-    open_params: ""
-  - name: test_extract_p1
-    library_path: BUILD_DIR/test/plugins/libtest_extract_p1.so
-    init_config: ""
-
-# Optional
-load_plugins: [cloudtrail, test_extract_p1]

test/confs/plugins/incompatible_plugin_api.yaml

@@ -1,10 +0,0 @@
-stdout_output:
-  enabled: true
-
-plugins:
-  - name: incompatible_plugin_api
-    library_path: BUILD_DIR/test/plugins/libtest_incompat_api.so
-    init_config: ""
-
-# Optional
-load_plugins: [incompatible_plugin_api]

test/confs/plugins/k8s_audit.yaml

@@ -1,29 +0,0 @@
-#
-# Copyright (C) 2022 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-stdout_output:
-  enabled: true
-
-plugins:
-  - name: k8saudit
-    library_path: BUILD_DIR/k8saudit-plugin-prefix/src/k8saudit-plugin/libk8saudit.so
-    init_config: ""
-    open_params: "" # to be filled out by each test case
-  - name: json
-    library_path: BUILD_DIR/json-plugin-prefix/src/json-plugin/libjson.so
-    init_config: ""
-
-load_plugins: [k8saudit, json]

test/confs/plugins/overlap_extract_sources.yaml

@@ -1,17 +0,0 @@
-stdout_output:
-  enabled: true
-
-plugins:
-  - name: test_source
-    library_path: BUILD_DIR/test/plugins/libtest_source.so
-    init_config: ""
-    open_params: ""
-  - name: test_extract_p1
-    library_path: BUILD_DIR/test/plugins/libtest_extract_p1.so
-    init_config: ""
-  - name: test_extract_p2
-    library_path: BUILD_DIR/test/plugins/libtest_extract_p2.so
-    init_config: ""
-
-# Optional
-load_plugins: [test_source, test_extract_p1, test_extract_p2]

test/confs/plugins/wrong_plugin_path.yaml

@@ -1,10 +0,0 @@
-stdout_output:
-  enabled: true
-
-plugins:
-  - name: wrong_plugin_path
-    library_path: BUILD_DIR/test/plugins/wrong_plugin_path.so
-    init_config: ""
-
-# Optional
-load_plugins: [wrong_plugin_path]

test/confs/program_output.yaml

@@ -1,44 +0,0 @@
-#
-# Copyright (C) 2020 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# File containing Falco rules, loaded at startup.
-rules_file: /etc/falco_rules.yaml
-
-# Whether to output events in json or text
-json_output: false
-
-# Send information logs to stderr and/or syslog
-# Note these are *not* security notification logs!
-# These are just Falco lifecycle (and possibly error) logs.
-log_stderr: false
-log_syslog: false
-
-# Where security notifications should go.
-# Multiple outputs can be enabled.
-syslog_output:
-  enabled: false
-
-file_output:
-  enabled: false
-  filename: ./output.txt
-
-stdout_output:
-  enabled: true
-
-program_output:
-  enabled: true
-  program: cat >> /tmp/falco_outputs/program_output.txt

test/confs/stdout_output.yaml

@@ -1,42 +0,0 @@
-#
-# Copyright (C) 2020 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# File containing Falco rules, loaded at startup.
-rules_file: /etc/falco_rules.yaml
-
-# Whether to output events in json or text
-json_output: false
-
-# Send information logs to stderr and/or syslog Note these are *not* security
-# notification logs! These are just Falco lifecycle (and possibly error) logs.
-log_stderr: false
-log_syslog: false
-
-# Where security notifications should go.
-# Multiple outputs can be enabled.
-
-syslog_output:
-  enabled: false
-
-file_output:
-  enabled: false
-
-stdout_output:
-  enabled: true
-
-program_output:
-  enabled: false

test/driver-loader/run_test.sh

@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-#
-# Copyright (C) 2020 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-set -euo pipefail
-
-BUILD_DIR=$1
-
-SCRIPT=$(readlink -f $0)
-SCRIPTDIR=$(dirname "$SCRIPT")
-RUNNERDIR="${SCRIPTDIR}/runner"
-FALCO_VERSION=$(cat ${BUILD_DIR}/userspace/falco/config_falco.h | grep 'FALCO_VERSION ' | cut -d' ' -f3 | sed -e 's/^"//' -e 's/"$//')
-DRIVER_VERSION=$(cat ${BUILD_DIR}/userspace/falco/config_falco.h | grep 'DRIVER_VERSION ' | cut -d' ' -f3 | sed -e 's/^"//' -e 's/"$//')
-FALCO_PACKAGE="falco-${FALCO_VERSION}-x86_64.tar.gz"
-
-cp "${BUILD_DIR}/${FALCO_PACKAGE}" "${RUNNERDIR}"
-pushd "${RUNNERDIR}"
-docker build --build-arg FALCO_VERSION="$FALCO_VERSION" \
-    -t falcosecurity/falco:test-driver-loader \
-    -f "${RUNNERDIR}/Dockerfile" "${RUNNERDIR}"
-popd
-rm -f "${RUNNERDIR}/${FALCO_PACKAGE}"
-
-docker run --rm --privileged \
-    -e FALCO_VERSION="$FALCO_VERSION" \
-    -e DRIVER_VERSION="$DRIVER_VERSION" \
-    -v /dev:/host/dev \
-    -v /proc:/host/proc:ro \
-    -v /boot:/host/boot:ro \
-    -v /lib/modules:/host/lib/modules:ro \
-    -v /usr:/host/usr:ro \
-    -v /etc:/host/etc:ro \
-    falcosecurity/falco:test-driver-loader
-
-docker rmi -f falcosecurity/falco:test-driver-loader

test/driver-loader/runner/Dockerfile

@@ -1,32 +0,0 @@
-FROM ubuntu:18.04
-
-ARG FALCO_VERSION=
-RUN test -n FALCO_VERSION
-ENV FALCO_VERSION ${FALCO_VERSION}
-ENV DRIVER_VERSION=
-ENV HOST_ROOT=/host
-
-# Minimal set of deps required to run falco-driver-loader and falco
-RUN apt-get update -y
-RUN apt-get install -y --no-install-recommends \
-	ca-certificates \
-	dkms \
-	curl \
-	gcc \
-	clang-7 \
-	llvm-7 \
-	libelf-dev
-
-RUN rm -rf /usr/bin/clang \
-	&& rm -rf /usr/bin/llc \
-	&& ln -s /usr/bin/clang-7 /usr/bin/clang \
-	&& ln -s /usr/bin/llc-7 /usr/bin/llc
-
-RUN rm -rf /lib/modules \
-	&& ln -s $HOST_ROOT/lib/modules /lib/modules
-
-ADD falco-${FALCO_VERSION}-x86_64.tar.gz /
-RUN cp -R /falco-${FALCO_VERSION}-x86_64/* /
-
-COPY test.sh /
-CMD /test.sh

test/driver-loader/runner/test.sh

@@ -1,136 +0,0 @@
-#!/usr/bin/env bash
-#
-# Copyright (C) 2020 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-set -euo pipefail
-
-FALCO="falco -M 1"
-FALCO_DRIVER_LOADER=falco-driver-loader
-
-
-function init() {
-
-	# We need this here since is not part of the falco-driver-loader script
-	#
-	# todo(leogr): maybe this can be moved into falco-driver-loader directly
-	# since it depends on HOST_ROOT
-	if [ -n "${HOST_ROOT}" ]; then
-		echo "INIT: Setting up /usr/src links from host"
-		for i in "$HOST_ROOT/usr/src"/*
-		do
-			base=$(basename "$i")
-			ln -s "$i" "/usr/src/$base"
-		done
-	fi
-
-	local EXPECTED_DRIVER_VERSION=${DRIVER_VERSION}
-
-	# We need some env vars to be populated
-	# Just source falco-driver-loader, and call get_target_id
-	# Loaded driver will be cleaned up later, if any.
-	echo "INIT: Sourcing ${FALCO_DRIVER_LOADER} to get env vars populated"
-	set +eu
-	source $FALCO_DRIVER_LOADER --source-only
-	get_target_id
-	set -eu
-
-	if [ ! "${EXPECTED_DRIVER_VERSION}" = "${DRIVER_VERSION}" ]; then
-		echo "INIT: Unexpected DRIVER_VERSION in falco-driver-loader"
-		echo "Expected: ${EXPECTED_DRIVER_VERSION}"
-		echo "Found: ${DRIVER_VERSION}"
-		exit 1
-	fi
-
-	FALCO_KERNEL_MODULE_PATH="${HOME}/.falco/${DRIVER_NAME}_${TARGET_ID}_${KERNEL_RELEASE}_${KERNEL_VERSION}.ko"
-	FALCO_BPF_PROBE_PATH="${HOME}/.falco/${DRIVER_NAME}_${TARGET_ID}_${KERNEL_RELEASE}_${KERNEL_VERSION}.o"
-	cleanup_drivers
-}
-
-function cleanup_drivers() {
-    echo "CLEANUP: remove drivers, if any"
-
-    # kernel module
-    rmmod "$DRIVER_NAME" > /dev/null 2>&1 || true
-    dkms uninstall "$DRIVER_NAME/$DRIVER_VERSION" > /dev/null 2>&1 || true
-    rm -f "$FALCO_KERNEL_MODULE_PATH"
-
-    # bpf probe
-	local PROBE_INSTALL_PATH="${HOME}/.falco/${DRIVER_NAME}-bpf.o"
-    rm -f "$FALCO_BPF_PROBE_PATH"
-    rm -f "$PROBE_INSTALL_PATH"
-}
-
-function run_test() {
-    echo ""
-    echo "TEST: $1"
-	echo ""
-    $1
-	echo ""
-    echo "PASS: $1"
-    echo ""
-	cleanup_drivers
-}
-
-function assert_kernel_module() {
-	echo "ASSERT: module loaded"
-    local KMOD_NAME=$(echo "${DRIVER_NAME}" | tr "-" "_")
-    if ! lsmod | grep "${KMOD_NAME}" > /dev/null 2>&1; then
-        echo "FAIL: module not loaded"
-        exit 1
-    fi
-	echo "ASSERT: falco works with module"
-	if ! $FALCO; then
-		echo "FAIL: falco does not work with module"
-		exit 1
-	fi
-}
-
-function assert_bpf_probe() {
-	local PROBE_INSTALL_PATH="${HOME}/.falco/${DRIVER_NAME}-bpf.o"
-	echo "ASSERT: eBPF probe at $PROBE_INSTALL_PATH"
-    if ! test -f "$PROBE_INSTALL_PATH"; then 
-        echo "FAIL: eBPF probe not found"
-        exit 1
-    fi
-	echo "ASSERT: falco works with bpf"
-	if ! FALCO_BPF_PROBE="" $FALCO; then
-		echo "FAIL: falco does not work with bpf"
-		exit 1
-	fi
-}
-
-function test_kernel_module() {
-    $FALCO_DRIVER_LOADER
-	assert_kernel_module
-}
-
-
-function test_bpf_probe() {
-    $FALCO_DRIVER_LOADER bpf
-	assert_bpf_probe
-}
-
-echo "falco-driver-loader tester"
-echo ""
-echo "Falco version: $FALCO_VERSION"
-echo "Driver version: $DRIVER_VERSION"
-echo "HOST_ROOT: ${HOST_ROOT}"
-echo ""
-
-init
-
-run_test "test_kernel_module"
-run_test "test_bpf_probe"

test/falco_k8s_audit_tests.yaml

@@ -1,776 +0,0 @@
-#
-# Copyright (C) 2019 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-trace_files: !mux
-
-  compat_engine_v4_create_disallowed_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
-      - ./rules/k8s_audit/engine_v4/allow_only_apache_container.yaml
-    detect_counts:
-      - Create Disallowed Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
-
-  compat_engine_v4_create_allowed_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
-      - ./rules/k8s_audit/engine_v4/allow_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
-
-  compat_engine_v4_create_privileged_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
-    detect_counts:
-      - Create Privileged Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_privileged.json
-
-  compat_engine_v4_create_privileged_trusted_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
-      - ./rules/k8s_audit/trust_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_privileged.json
-
-  compat_engine_v4_create_unprivileged_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
-
-  compat_engine_v4_create_hostnetwork_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
-    detect_counts:
-      - Create HostNetwork Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_hostnetwork.json
-
-  compat_engine_v4_create_hostnetwork_trusted_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
-      - ./rules/k8s_audit/trust_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_hostnetwork.json
-
-  user_outside_allowed_set:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/allow_namespace_foo.yaml
-    detect_counts:
-      - Disallowed K8s User: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/some-user_creates_namespace_foo.json
-
-  user_in_allowed_set:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/allow_namespace_foo.yaml
-      - ./rules/k8s_audit/allow_user_some-user.yaml
-      - ./rules/k8s_audit/disallow_kactivity.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/some-user_creates_namespace_foo.json
-
-  create_disallowed_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/allow_only_apache_container.yaml
-    detect_counts:
-      - Create Disallowed Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
-
-  create_allowed_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/allow_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
-
-  create_privileged_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Create Privileged Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_privileged.json
-
-  create_privileged_no_secctx_1st_container_2nd_container_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Create Privileged Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_no_secctx_1st_container_privileged_2nd_container.json
-
-  create_privileged_2nd_container_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Create Privileged Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_privileged_2nd_container.json
-
-  create_privileged_trusted_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/trust_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_privileged.json
-
-  create_unprivileged_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
-
-  create_unprivileged_trusted_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/trust_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
-
-  create_sensitive_mount_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Create Sensitive Mount Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_sensitive_mount.json
-
-  create_sensitive_mount_2nd_container_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Create Sensitive Mount Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_sensitive_mount_2nd_container.json
-
-  create_sensitive_mount_trusted_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/trust_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_sensitive_mount.json
-
-  create_unsensitive_mount_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unsensitive_mount.json
-
-  create_unsensitive_mount_trusted_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/trust_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unsensitive_mount.json
-
-  create_hostnetwork_pod:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Create HostNetwork Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_hostnetwork.json
-
-  create_hostnetwork_trusted_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/trust_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_hostnetwork.json
-
-  create_nohostnetwork_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_nohostnetwork.json
-
-  create_nohostnetwork_trusted_pod:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/trust_nginx_container.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_nohostnetwork.json
-
-  create_nodeport_service:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/disallow_kactivity.yaml
-    detect_counts:
-      - Create NodePort Service: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_service_nodeport.json
-
-  create_nonodeport_service:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/disallow_kactivity.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_service_nonodeport.json
-
-  create_configmap_private_creds:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/disallow_kactivity.yaml
-    detect_counts:
-      - Create/Modify Configmap With Private Credentials: 6
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_configmap_sensitive_values.json
-
-  create_configmap_no_private_creds:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/disallow_kactivity.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_configmap_no_sensitive_values.json
-
-  anonymous_user:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Anonymous Request Allowed: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/anonymous_creates_namespace_foo.json
-
-  pod_exec:
-    detect: True
-    detect_level: NOTICE
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Attach/Exec Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/exec_pod.json
-
-  pod_attach:
-    detect: True
-    detect_level: NOTICE
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Attach/Exec Pod: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/attach_pod.json
-
-  namespace_outside_allowed_set:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/allow_user_some-user.yaml
-    detect_counts:
-      - Create Disallowed Namespace: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/some-user_creates_namespace_foo.json
-
-  namespace_in_allowed_set:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/allow_namespace_foo.yaml
-      - ./rules/k8s_audit/disallow_kactivity.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/minikube_creates_namespace_foo.json
-
-  create_pod_in_kube_system_namespace:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Pod Created in Kube Namespace: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_pod_kube_system_namespace.json
-
-  create_pod_in_kube_public_namespace:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Pod Created in Kube Namespace: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_pod_kube_public_namespace.json
-
-  create_serviceaccount_in_kube_system_namespace:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Service Account Created in Kube Namespace: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_serviceaccount_kube_system_namespace.json
-
-  create_serviceaccount_in_kube_public_namespace:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Service Account Created in Kube Namespace: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_serviceaccount_kube_public_namespace.json
-
-  system_clusterrole_deleted:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - System ClusterRole Modified/Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/delete_cluster_role_kube_aggregator.json
-
-  system_clusterrole_modified:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - System ClusterRole Modified/Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/modify_cluster_role_node_problem_detector.json
-
-  attach_cluster_admin_role:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - Attach to cluster-admin Role: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/attach_cluster_admin_role.json
-
-  create_cluster_role_wildcard_resources:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - ClusterRole With Wildcard Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_cluster_role_wildcard_resources.json
-
-  create_cluster_role_wildcard_verbs:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - ClusterRole With Wildcard Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_cluster_role_wildcard_verbs.json
-
-  create_writable_cluster_role:
-    detect: True
-    detect_level: NOTICE
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - ClusterRole With Write Privileges Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_cluster_role_write_privileges.json
-
-  create_pod_exec_cluster_role:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - ClusterRole With Pod Exec Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_cluster_role_pod_exec.json
-
-  create_deployment:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Deployment Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_deployment.json
-
-  delete_deployment:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Deployment Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/delete_deployment.json
-
-  create_service:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Service Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_service.json
-
-  delete_service:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Service Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/delete_service.json
-
-  create_configmap:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s ConfigMap Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_configmap.json
-
-  delete_configmap:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s ConfigMap Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/delete_configmap.json
-
-  create_namespace:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-      - ./rules/k8s_audit/allow_namespace_foo.yaml
-      - ./rules/k8s_audit/allow_user_some-user.yaml
-    detect_counts:
-      - K8s Namespace Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/some-user_creates_namespace_foo.json
-
-  delete_namespace:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Namespace Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/delete_namespace_foo.json
-
-  create_serviceaccount:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Serviceaccount Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_serviceaccount.json
-
-  delete_serviceaccount:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Serviceaccount Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/delete_serviceaccount.json
-
-  create_clusterrole:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Role/Clusterrole Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_clusterrole.json
-
-  delete_clusterrole:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Role/Clusterrole Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/delete_clusterrole.json
-
-  create_clusterrolebinding:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Role/Clusterrolebinding Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_clusterrolebinding.json
-
-  delete_clusterrolebinding:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Role/Clusterrolebinding Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/delete_clusterrolebinding.json
-
-  create_secret:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Secret Created: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_secret.json
-
-  # Should *not* result in any event as the secret rules skip service account token secrets
-  create_service_account_token_secret:
-    detect: False
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_service_account_token_secret.json
-
-  create_kube_system_secret:
-    detect: False
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_kube_system_secret.json
-
-  delete_secret:
-    detect: True
-    detect_level: INFO
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    detect_counts:
-      - K8s Secret Deleted: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/delete_secret.json
-
-  fal_01_003:
-    detect: False
-    enable_source: k8s_audit
-    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
-      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/fal_01_003.json
-    stderr_contains: 'data not recognized as a k8s audit event'
-
-  json_pointer_correct_parse:
-    detect: True
-    detect_level: WARNING
-    enable_source: k8s_audit
-    rules_file:
-      - ./rules/k8s_audit/single_rule_with_json_pointer.yaml
-    detect_counts:
-      - json_pointer_example: 1
-    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json

test/falco_test.py

@@ -1,730 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2019 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-import os
-import re
-import json
-import glob
-import shutil
-import stat
-import subprocess
-import sys
-import urllib.request
-
-from avocado import Test
-from avocado import main
-from avocado.utils import process
-from watchdog.observers import Observer
-from watchdog.events import PatternMatchingEventHandler
-
-
-class FalcoTest(Test):
-
-    def setUp(self):
-        """
-        Load the kernel module if not already loaded.
-        """
-        build_dir = "/build"
-        if 'BUILD_DIR' in os.environ:
-            build_dir = os.environ['BUILD_DIR']
-
-        self.falcodir = self.params.get('falcodir', '/', default=build_dir)
-
-        self.stdout_is = self.params.get('stdout_is', '*', default='')
-        self.stderr_is = self.params.get('stderr_is', '*', default='')
-
-        self.stdout_contains = self.params.get(
-            'stdout_contains', '*', default='')
-
-        if not isinstance(self.stdout_contains, list):
-            self.stdout_contains = [self.stdout_contains]
-
-        self.stderr_contains = self.params.get(
-            'stderr_contains', '*', default='')
-
-        if not isinstance(self.stderr_contains, list):
-            self.stderr_contains = [self.stderr_contains]
-
-        self.stdout_not_contains = self.params.get(
-            'stdout_not_contains', '*', default='')
-
-        if not isinstance(self.stdout_not_contains, list):
-            if self.stdout_not_contains == '':
-                self.stdout_not_contains = []
-            else:
-                self.stdout_not_contains = [self.stdout_not_contains]
-
-        self.stderr_not_contains = self.params.get(
-            'stderr_not_contains', '*', default='')
-
-        if not isinstance(self.stderr_not_contains, list):
-            if self.stderr_not_contains == '':
-                self.stderr_not_contains = []
-            else:
-                self.stderr_not_contains = [self.stderr_not_contains]
-
-        self.validate_ok = self.params.get('validate_ok', '*', default='')
-        self.validate_warnings = self.params.get('validate_warnings', '*', default='')
-        self.validate_errors = self.params.get('validate_errors', '*', default='')
-
-        self.exit_status = self.params.get('exit_status', '*', default=0)
-        self.should_detect = self.params.get('detect', '*', default=False)
-        self.check_detection_counts = self.params.get('check_detection_counts', '*', default=True)
-        self.trace_file = self.params.get('trace_file', '*', default='')
-
-        if self.trace_file and not os.path.isabs(self.trace_file):
-            self.trace_file = os.path.join(build_dir, "test", self.trace_file)
-
-        self.json_output = self.params.get('json_output', '*', default=False)
-        self.json_include_output_property = self.params.get(
-            'json_include_output_property', '*', default=True)
-        self.json_include_tags_property = self.params.get(
-            'json_include_tags_property', '*', default=True)
-        self.all_events = self.params.get('all_events', '*', default=False)
-        self.priority = self.params.get('priority', '*', default='debug')
-        self.addl_cmdline_opts = self.params.get('addl_cmdline_opts', '*', default='')
-        self.enable_source = self.params.get('enable_source', '*', default='')
-        self.rules_file = self.params.get(
-            'rules_file', '*', default='BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml')
-
-        if not isinstance(self.rules_file, list):
-            self.rules_file = [self.rules_file]
-
-        self.validate_rules_file = self.params.get(
-            'validate_rules_file', '*', default=False)
-
-        if self.validate_rules_file == False:
-            self.validate_rules_file = []
-        else:
-            # Always enable json output when validating rules
-            # files. Makes parsing errors/warnings easier
-            self.json_output = True
-            if not isinstance(self.validate_rules_file, list):
-                self.validate_rules_file = [self.validate_rules_file]
-        
-        # can be either empty, a string, or a list
-        if self.enable_source == '':
-            self.enable_source = []
-        else:
-            if not isinstance(self.enable_source, list):
-                self.enable_source = [self.enable_source]
-
-        self.rules_args = ""
-
-        for file in self.validate_rules_file:
-            if not os.path.isabs(file):
-                file = os.path.join(self.basedir, file)
-            self.rules_args = self.rules_args + "-V " + file + " "
-
-        for file in self.rules_file:
-            if not os.path.isabs(file):
-                file = os.path.join(self.basedir, file.replace("BUILD_DIR", build_dir))
-            self.rules_args = self.rules_args + "-r " + file + " "
-
-        self.conf_file = self.params.get(
-            'conf_file', '*', default=os.path.join(self.basedir, '../falco.yaml'))
-        self.conf_file = self.conf_file.replace("BUILD_DIR", build_dir)
-        if not os.path.isabs(self.conf_file):
-            self.conf_file = os.path.join(self.basedir, self.conf_file)
-
-        self.run_duration = self.params.get('run_duration', '*', default='')
-
-        self.disabled_rules = self.params.get(
-            'disabled_rules', '*', default='')
-
-        if self.disabled_rules == '':
-            self.disabled_rules = []
-
-        if not isinstance(self.disabled_rules, list):
-            self.disabled_rules = [self.disabled_rules]
-
-        self.disabled_args = ""
-
-        for rule in self.disabled_rules:
-            self.disabled_args = self.disabled_args + "-D " + rule + " "
-
-        self.detect_counts = self.params.get(
-            'detect_counts', '*', default=False)
-        if self.detect_counts == False:
-            self.detect_counts = {}
-        else:
-            detect_counts = {}
-            for item in self.detect_counts:
-                for key, value in list(item.items()):
-                    detect_counts[key] = value
-            self.detect_counts = detect_counts
-
-        # Maps from rule name to set of evttypes
-        self.rules_events = self.params.get('rules_events', '*', default=False)
-        if self.rules_events == False:
-            self.rules_events = {}
-        else:
-            events = {}
-            for item in self.rules_events:
-                for item2 in item:
-                    events[item2[0]] = set(item2[1])
-            self.rules_events = events
-
-        if self.should_detect:
-            self.detect_level = self.params.get('detect_level', '*')
-
-            if not isinstance(self.detect_level, list):
-                self.detect_level = [self.detect_level]
-
-        self.package = self.params.get('package', '*', default='None')
-
-        self.addl_docker_run_args = self.params.get(
-            'addl_docker_run_args', '*', default='')
-
-        self.copy_local_driver = self.params.get(
-            'copy_local_driver', '*', default=False)
-
-        # Used by possibly_copy_local_driver as well as docker run
-        self.module_dir = os.path.expanduser("~/.falco")
-
-        self.outputs = self.params.get('outputs', '*', default='')
-
-        if self.outputs == '':
-            self.outputs = {}
-        else:
-            outputs = []
-            for item in self.outputs:
-                for key, value in list(item.items()):
-                    output = {}
-                    output['file'] = key
-                    output['line'] = value
-                    outputs.append(output)
-                    filedir = os.path.dirname(output['file'])
-                    # Create the parent directory for the trace file if it doesn't exist.
-                    if not os.path.isdir(filedir):
-                        os.makedirs(filedir)
-            self.outputs = outputs
-
-        self.output_strictly_contains = self.params.get(
-            'output_strictly_contains', '*', default='')
-
-        if self.output_strictly_contains == '':
-            self.output_strictly_contains = {}
-        else:
-            output_strictly_contains = []
-            for item in self.output_strictly_contains:
-                for key, value in list(item.items()):
-                    output = {}
-                    output['actual'] = key
-                    output['expected'] = value
-                    output_strictly_contains.append(output)
-                    if not output['actual'] == 'stdout':
-                        # Clean up file from previous tests, if any
-                        if os.path.exists(output['actual']):
-                            os.remove(output['actual'])
-                        # Create the parent directory for the file if it doesn't exist.
-                        filedir = os.path.dirname(output['actual'])
-                        if not os.path.isdir(filedir):
-                            os.makedirs(filedir)
-            self.output_strictly_contains = output_strictly_contains
-
-        self.grpcurl_res = None
-        self.grpc_observer = None
-        self.grpc_address = self.params.get(
-            'address', 'grpc/*', default='/run/falco/falco.sock')
-        if self.grpc_address.startswith("unix://"):
-            self.is_grpc_using_unix_socket = True
-            self.grpc_address = self.grpc_address[len("unix://"):]
-        else:
-            self.is_grpc_using_unix_socket = False
-        self.grpc_proto = self.params.get('proto', 'grpc/*', default='')
-        self.grpc_service = self.params.get('service', 'grpc/*', default='')
-        self.grpc_method = self.params.get('method', 'grpc/*', default='')
-        self.grpc_results = self.params.get('results', 'grpc/*', default='')
-        if self.grpc_results == '':
-            self.grpc_results = []
-        else:
-            if type(self.grpc_results) == str:
-                self.grpc_results = [self.grpc_results]
-
-        self.disable_tags = self.params.get('disable_tags', '*', default='')
-
-        if self.disable_tags == '':
-            self.disable_tags = []
-
-        self.run_tags = self.params.get('run_tags', '*', default='')
-
-        if self.run_tags == '':
-            self.run_tags = []
-
-        self.time_iso_8601 = self.params.get(
-            'time_iso_8601', '*', default=False)
-
-    def tearDown(self):
-        if self.package != 'None':
-            self.uninstall_package()
-
-    def check_rules_events(self, res):
-
-        found_events = {}
-
-        for match in re.finditer('Event types for rule ([^:]+): (\S+)', res.stderr.decode("utf-8")):
-            rule = match.group(1)
-            events = set(match.group(2).split(","))
-            found_events[rule] = events
-
-        self.log.debug(
-            "Expected events for rules: {}".format(self.rules_events))
-        self.log.debug("Actual events for rules: {}".format(found_events))
-
-        for rule in list(found_events.keys()):
-            if found_events.get(rule) != self.rules_events.get(rule):
-                self.fail("rule {}: expected events {} differs from actual events {}".format(
-                    rule, self.rules_events.get(rule), found_events.get(rule)))
-
-    def check_detections(self, res):
-        # Get the number of events detected.
-        match = re.search('Events detected: (\d+)', res.stdout.decode("utf-8"))
-        if match is None:
-            self.fail(
-                "Could not find a line 'Events detected: <count>' in falco output")
-
-        events_detected = int(match.group(1))
-
-        if not self.should_detect and events_detected > 0:
-            self.fail("Detected {} events when should have detected none".format(
-                events_detected))
-
-        if self.should_detect:
-            if events_detected == 0:
-                self.fail("Detected {} events when should have detected > 0".format(
-                    events_detected))
-
-            for level in self.detect_level:
-                level_line = '(?i){}: (\d+)'.format(level)
-                match = re.search(level_line, res.stdout.decode("utf-8"))
-
-                if match is None:
-                    self.fail(
-                        "Could not find a line '{}: <count>' in falco output".format(level))
-
-                    events_detected = int(match.group(1))
-
-                    if not events_detected > 0:
-                        self.fail("Detected {} events at level {} when should have detected > 0".format(
-                            events_detected, level))
-
-    def check_detections_by_rule(self, res):
-        # Get the number of events detected for each rule. Must match the expected counts.
-        match = re.search('Triggered rules by rule name:(.*)',
-                          res.stdout.decode("utf-8"), re.DOTALL)
-        if match is None:
-            self.fail(
-                "Could not find a block 'Triggered rules by rule name: ...' in falco output")
-
-        triggered_rules = match.group(1)
-
-        for rule, count in list(self.detect_counts.items()):
-            expected = '\s{}: (\d+)'.format(
-                re.sub(r'([$\.*+?()[\]{}|^])', r'\\\1', rule))
-            match = re.search(expected, triggered_rules)
-
-            if match is None:
-                actual_count = 0
-            else:
-                actual_count = int(match.group(1))
-
-            if actual_count != count:
-                self.fail("Different counts for rule {}: expected={}, actual={}".format(
-                    rule, count, actual_count))
-            else:
-                self.log.debug(
-                    "Found expected count for rule {}: {}".format(rule, count))
-
-    def check_outputs(self):
-        for output in self.outputs:
-            # Open the provided file and match each line against the
-            # regex in line.
-            file = open(output['file'], 'r')
-            found = False
-            for line in file:
-                match = re.search(output['line'], line)
-
-                if match is not None:
-                    found = True
-
-            if found == False:
-                self.fail("Could not find a line '{}' in file '{}'".format(
-                    output['line'], output['file']))
-
-        return True
-
-    def get_validate_json(self, res):
-        if self.validate_json is None:
-            # The first line of stdout should be the validation result as json
-            self.validate_json = json.loads(res.stdout.decode("utf-8").partition('\n')[0])
-        return self.validate_json
-
-    def check_validate_ok(self, res):
-        if self.validate_ok != '':
-            vobj = self.get_validate_json(res)
-            for expected in self.validate_ok:
-                found = False
-                for vres in vobj["falco_load_results"]:
-                    if vres["successful"] and os.path.basename(vres["name"]) == expected:
-                        found = True
-                        break
-                if not found:
-                    self.fail("Validation json did not contain a successful result for file '{}'".format(expected))
-
-    def check_validate_warnings(self, res):
-        if self.validate_warnings != '':
-            vobj = self.get_validate_json(res)
-            for warnobj in self.validate_warnings:
-                found = False
-                for vres in vobj["falco_load_results"]:
-                    for warning in vres["warnings"]:
-                        if warning["code"] == warnobj["code"]:
-                            if ("message" in warnobj and warning["message"] == warnobj["message"]) or ("message_contains" in warnobj and warnobj["message_contains"] in warning["message"]):
-                                for loc in warning["context"]["locations"]:
-                                    if loc["item_type"] == warnobj["item_type"] and loc["item_name"] == warnobj["item_name"]:
-                                        found = True
-                                        break
-                if not found:
-                    if "message" in warnobj:
-                        self.fail("Validation json did not contain a warning '{}' for '{}' '{}' with message '{}'".format(
-                            warnobj["code"], warnobj["item_type"], warnobj["item_name"], warnobj["message"]))
-                    else:
-                        self.fail("Validation json did not contain a warning '{}' for '{}' '{}' with message containing '{}'".format(
-                            warnobj["code"], warnobj["item_type"], warnobj["item_name"], warnobj["message_contains"]))
-
-    def check_validate_errors(self, res):
-        if self.validate_errors != '':
-            vobj = self.get_validate_json(res)
-            for errobj in self.validate_errors:
-                found = False
-                for vres in vobj["falco_load_results"]:
-                    for error in vres["errors"]:
-                        if error["code"] == errobj["code"]:
-                            if ("message" in errobj and error["message"] == errobj["message"]) or ("message_contains" in errobj and errobj["message_contains"] in error["message"]):
-                                for loc in error["context"]["locations"]:
-                                    if loc["item_type"] == errobj["item_type"] and loc["item_name"] == errobj["item_name"]:
-                                        found = True
-                                        break
-                if not found:
-                    if "message" in errobj:
-                        self.fail("Validation json did not contain a error '{}' for '{}' '{}' with message '{}'".format(
-                            errobj["code"], errobj["item_type"], errobj["item_name"], errobj["message"]))
-                    else:
-                        self.fail("Validation json did not contain a error '{}' for '{}' '{}' with message containing '{}'".format(
-                            errobj["code"], errobj["item_type"], errobj["item_name"], errobj["message_contains"]))
-
-
-    def check_json_event_output(self, res):
-        if self.json_output:
-            # Just verify that any lines starting with '{' are valid json objects.
-            # Doesn't do any deep inspection of the contents.
-            for line in res.stdout.decode("utf-8").splitlines():
-                if line.startswith('{'):
-                    obj = json.loads(line)
-                    attrs = ['time', 'rule', 'priority']
-                    if self.json_include_output_property:
-                        attrs.append('output')
-                    if self.json_include_tags_property:
-                        attrs.append('tags')
-                    for attr in attrs:
-                        if not attr in obj:
-                            self.fail(
-                                "Falco JSON object {} does not contain property \"{}\"".format(line, attr))
-
-    def check_output_strictly_contains(self, res):
-        for output in self.output_strictly_contains:
-            # Read the expected output (from a file) and actual output (either from a file or the stdout),
-            # then check if the actual one strictly contains the expected one.
-
-            expected = open(output['expected']).read()
-
-            if output['actual'] == 'stdout':
-                actual = res.stdout.decode("utf-8")
-            else:
-                actual = open(output['actual']).read()
-
-            actual_cursor = actual
-            expected_lines = expected.splitlines()
-            for line in expected_lines:
-                pos = actual_cursor.find(line)
-                if pos < 0:
-                    self.fail("Output '{}' does not strictly contains the expected content '{}'".format(
-                        output['actual'], output['expected']))
-                    return False
-                actual_cursor = actual_cursor[pos + len(line):]
-
-        return True
-
-    def install_package(self):
-
-        if self.package.startswith("docker:"):
-
-            image = self.package.split(":", 1)[1]
-            # Remove an existing falco-test container first. Note we don't check the output--docker rm
-            # doesn't have an -i equivalent.
-            res = process.run("docker rm falco-test", ignore_status=True)
-
-            self.falco_binary_path = "docker run --rm --name falco-test --privileged " \
-                                     "-v /var/run/docker.sock:/host/var/run/docker.sock " \
-                                     "-v /dev:/host/dev -v /proc:/host/proc:ro -v /boot:/host/boot:ro " \
-                                     "-v /lib/modules:/host/lib/modules:ro -v {}:/root/.falco:ro " \
-                                     "-v /usr:/host/usr:ro {} {} falco".format(
-                                         self.module_dir, self.addl_docker_run_args, image)
-
-        elif self.package.endswith(".deb"):
-            self.falco_binary_path = '/usr/bin/falco'
-
-            package_glob = "{}/{}".format(self.falcodir, self.package)
-
-            matches = glob.glob(package_glob)
-
-            if len(matches) != 1:
-                self.fail("Package path {} did not match exactly 1 file. Instead it matched: {}",
-                          package_glob, ",".join(matches))
-
-            package_path = matches[0]
-
-            cmdline = "dpkg -i {}".format(package_path)
-            self.log.debug(
-                "Installing debian package via \"{}\"".format(cmdline))
-            res = process.run(cmdline, timeout=120, sudo=True)
-
-        elif self.package.endswith(".rpm"):
-            self.falco_binary_path = '/usr/bin/falco'
-
-            package_glob = "{}/{}".format(self.falcodir, self.package)
-
-            matches = glob.glob(package_glob)
-
-            if len(matches) != 1:
-                self.fail("Package path {} did not match exactly 1 file. Instead it matched: {}",
-                          package_glob, ",".join(matches))
-
-            package_path = matches[0]
-
-            cmdline = "rpm -i --nodeps --noscripts {}".format(package_path)
-            self.log.debug(
-                "Installing centos package via \"{}\"".format(cmdline))
-            res = process.run(cmdline, timeout=120, sudo=True)
-
-    def uninstall_package(self):
-
-        if self.package.startswith("docker:"):
-            self.log.debug("Nothing to do, docker run with --rm")
-
-        elif self.package.endswith(".rpm"):
-            cmdline = "rpm -e --noscripts --nodeps falco"
-            self.log.debug(
-                "Uninstalling centos package via \"{}\"".format(cmdline))
-            res = process.run(cmdline, timeout=120, sudo=True)
-
-        elif self.package.endswith(".deb"):
-            cmdline = "dpkg --purge falco"
-            self.log.debug(
-                "Uninstalling debian package via \"{}\"".format(cmdline))
-            res = process.run(cmdline, timeout=120, sudo=True)
-
-    def possibly_copy_driver(self):
-        # Remove the contents of ~/.falco regardless of copy_local_driver.
-        self.log.debug("Checking for module dir {}".format(self.module_dir))
-        if os.path.isdir(self.module_dir):
-            self.log.info(
-                "Removing files below directory {}".format(self.module_dir))
-            for rmfile in glob.glob(self.module_dir + "/*"):
-                self.log.debug("Removing file {}".format(rmfile))
-                os.remove(rmfile)
-
-        if self.copy_local_driver:
-            verlines = [str.strip() for str in subprocess.check_output(
-                [self.falco_binary_path, "--version"]).splitlines()]
-            verstr = verlines[0].decode("utf-8")
-            self.log.info("verstr {}".format(verstr))
-            falco_version = verstr.split(" ")[2]
-            self.log.info("falco_version {}".format(falco_version))
-            arch = subprocess.check_output(["uname", "-m"]).rstrip()
-            self.log.info("arch {}".format(arch))
-            kernel_release = subprocess.check_output(["uname", "-r"]).rstrip()
-            self.log.info("kernel release {}".format(kernel_release))
-
-            # falco-driver-loader has a more comprehensive set of ways to
-            # find the config hash. We only look at /boot/config-<kernel release>
-            md5_output = subprocess.check_output(
-                ["md5sum", "/boot/config-{}".format(kernel_release)]).rstrip()
-            config_hash = md5_output.split(" ")[0]
-
-            driver_filename = "falco-{}-{}-{}-{}.ko".format(
-                falco_version, arch, kernel_release, config_hash)
-            driver_path = os.path.join(self.falcodir, "driver", "falco.ko")
-            module_path = os.path.join(self.module_dir, driver_filename)
-            self.log.debug("Copying {} to {}".format(driver_path, module_path))
-            shutil.copyfile(driver_path, module_path)
-
-    def init_grpc_handler(self):
-        self.grpcurl_res = None
-        if len(self.grpc_results) > 0:
-            if not self.is_grpc_using_unix_socket:
-                self.fail("This test suite supports gRPC with unix socket only")
-
-            cmdline = "grpcurl -format text -import-path ../userspace/falco " \
-                "-proto {} -plaintext -unix {} " \
-                "{}/{}".format(self.grpc_proto, self.grpc_address,
-                               self.grpc_service, self.grpc_method)
-            that = self
-
-            class GRPCUnixSocketEventHandler(PatternMatchingEventHandler):
-                def on_created(self, event):
-                    # that.log.info("EVENT: {}", event)
-                    that.grpcurl_res = process.run(cmdline)
-
-            path = os.path.dirname(self.grpc_address)
-            process.run("mkdir -p {}".format(path))
-            event_handler = GRPCUnixSocketEventHandler(patterns=['*'],
-                                                       ignore_directories=True)
-            self.grpc_observer = Observer()
-            self.grpc_observer.schedule(event_handler, path, recursive=False)
-            self.grpc_observer.start()
-
-    def check_grpc(self):
-        if self.grpc_observer is not None:
-            self.grpc_observer.stop()
-            self.grpc_observer = None
-            if self.grpcurl_res is None:
-                self.fail("gRPC responses not found")
-
-            for exp_result in self.grpc_results:
-                found = False
-                for line in self.grpcurl_res.stdout.decode("utf-8").splitlines():
-                    if exp_result in line:
-                        found = True
-                        break
-
-                if found == False:
-                    self.fail(
-                        "Could not find a line with '{}' in gRPC responses (protobuf text".format(exp_result))
-
-    def test(self):
-        self.log.info("Trace file %s", self.trace_file)
-
-        self.falco_binary_path = '{}/userspace/falco/falco'.format(
-            self.falcodir)
-
-        self.possibly_copy_driver()
-
-        self.init_grpc_handler()
-
-        if self.package != 'None':
-            # This sets falco_binary_path as a side-effect.
-            self.install_package()
-
-        self.validate_json = None
-
-        trace_arg = self.trace_file
-
-        if self.trace_file:
-            trace_arg = "-e {}".format(self.trace_file)
-
-        extra_cmdline = ''
-        for source in self.enable_source:
-            extra_cmdline += ' --enable-source="{}"'.format(source)
-        extra_cmdline += ' ' + self.addl_cmdline_opts
-
-        # Run falco
-        cmd = '{} {} {} -c {} {} -o json_output={} -o json_include_output_property={} -o json_include_tags_property={} -o priority={} -v {}'.format(
-            self.falco_binary_path, self.rules_args, self.disabled_args, self.conf_file, trace_arg, self.json_output,
-            self.json_include_output_property, self.json_include_tags_property, self.priority, extra_cmdline)
-
-        for tag in self.disable_tags:
-            cmd += ' -T {}'.format(tag)
-
-        for tag in self.run_tags:
-            cmd += ' -t {}'.format(tag)
-
-        if self.run_duration:
-            cmd += ' -M {}'.format(self.run_duration)
-
-        if self.all_events:
-            cmd += ' -A'
-
-        if self.time_iso_8601:
-            cmd += ' -o time_format_iso_8601=true'
-
-        self.falco_proc = process.SubProcess(cmd, env=dict(os.environ, FALCO_HOSTNAME="test-falco-hostname"))
-
-        res = self.falco_proc.run(timeout=180, sig=9)
-
-        if self.stdout_is != '':
-            print(self.stdout_is)
-            if self.stdout_is != res.stdout.decode("utf-8"):
-                self.fail("Stdout was not exactly {}".format(self.stdout_is))
-
-        if self.stderr_is != '':
-            if self.stderr_is != res.stdout.decode("utf-8"):
-                self.fail("Stdout was not exactly {}".format(self.stderr_is))
-
-        for pattern in self.stderr_contains:
-            match = re.search(pattern, res.stderr.decode("utf-8"), re.DOTALL)
-            if match is None:
-                self.fail(
-                    "Stderr of falco process did not contain content matching {}".format(pattern))
-
-        for pattern in self.stdout_contains:
-            match = re.search(pattern, res.stdout.decode("utf-8"), re.DOTALL)
-            if match is None:
-                self.fail("Stdout of falco process '{}' did not contain content matching {}".format(
-                    res.stdout.decode("utf-8"), pattern))
-
-        for pattern in self.stderr_not_contains:
-            match = re.search(pattern, res.stderr.decode("utf-8"))
-            if match is not None:
-                self.fail(
-                    "Stderr of falco process contained content matching {} when it should have not".format(pattern))
-
-        for pattern in self.stdout_not_contains:
-            match = re.search(pattern, res.stdout.decode("utf-8"))
-            if match is not None:
-                self.fail("Stdout of falco process '{}' did contain content matching {} when it should have not".format(
-                    res.stdout.decode("utf-8"), pattern))
-
-        if res.exit_status != self.exit_status:
-            self.error("Falco command \"{}\" exited with unexpected return value {} (!= {})".format(
-                cmd, res.exit_status, self.exit_status))
-
-        self.check_validate_ok(res)
-        self.check_validate_errors(res)
-        self.check_validate_warnings(res)
-
-        # No need to check any outputs if the falco process exited abnormally.
-        if res.exit_status != 0:
-            return
-
-        if len(self.rules_events) > 0:
-            self.check_rules_events(res)
-        if len(self.validate_rules_file) == 0 and self.check_detection_counts:
-            self.check_detections(res)
-        if len(self.detect_counts) > 0:
-            self.check_detections_by_rule(res)
-        if not self.validate_rules_file:
-            self.check_json_event_output(res)
-        self.check_outputs()
-        self.check_output_strictly_contains(res)
-        self.check_grpc()
-        pass
-
-
-if __name__ == "__main__":
-    main()

test/falco_tests_exceptions.yaml

@@ -1,270 +0,0 @@
-#
-# Copyright (C) 2016-2020 The Falco Authors..
-#
-# This file is part of falco.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-trace_files: !mux
-
-  rule_exception_no_fields:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: ex1
-        code: LOAD_ERR_YAML_VALIDATE
-        message: "Item has no mapping for key 'fields'"
-    validate_rules_file:
-      - rules/exceptions/item_no_fields.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_no_name:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: ""
-        code: LOAD_ERR_YAML_VALIDATE
-        message: "Item has no mapping for key 'name'"
-    validate_rules_file:
-      - rules/exceptions/item_no_name.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_append_no_name:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: ""
-        code: LOAD_ERR_YAML_VALIDATE
-        message: "Item has no mapping for key 'name'"
-    validate_rules_file:
-      - rules/exceptions/append_item_no_name.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_unknown_fields:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: ex1
-        code: LOAD_ERR_VALIDATE
-        message: "'not.exist' is not a supported filter field"
-    validate_rules_file:
-      - rules/exceptions/item_unknown_fields.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_comps_fields_len_mismatch:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: ex1
-        code: LOAD_ERR_VALIDATE
-        message: "Fields and comps lists must have equal length"
-    validate_rules_file:
-      - rules/exceptions/item_comps_fields_len_mismatch.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_unknown_comp:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: ex1
-        code: LOAD_ERR_VALIDATE
-        message: "'no-comp' is not a supported comparison operator"
-    validate_rules_file:
-      - rules/exceptions/item_unknown_comp.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_fields_values_len_mismatch:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: ex1
-        code: LOAD_ERR_VALIDATE
-        message: "Fields and values lists must have equal length"
-    validate_rules_file:
-      - rules/exceptions/item_fields_values_len_mismatch.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_append_fields_values_len_mismatch:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: ex1
-        code: LOAD_ERR_VALIDATE
-        message: "Fields and values lists must have equal length"
-    validate_rules_file:
-      - rules/exceptions/append_item_fields_values_len_mismatch.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_append_item_not_in_rule:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: ex2
-        code: LOAD_ERR_VALIDATE
-        message: "Rule exception must have fields property with a list of fields"
-    validate_rules_file:
-      - rules/exceptions/append_item_not_in_rule.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_no_values:
-    detect: True
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_no_values.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_one_value:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_one_value.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_append_one_value:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_append_one_value.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_second_value:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_second_value.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_append_second_value:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_append_second_value.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_second_item:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_second_item.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_append_second_item:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_append_second_item.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_third_item:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_third_item.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_append_third_item:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_append_third_item.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_quoted:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_quoted.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_append_multiple_values:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_append_multiple.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_comp:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_comp.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_append_comp:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_append_comp.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_values_listref:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_values_listref.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_values_listref_noparens:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_values_listref_noparens.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_values_list:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_values_list.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_single_field:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_single_field.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_single_field_append:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_single_field_append.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_new_single_field_append:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_new_single_field_append.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_new_second_field_append:
-    detect: False
-    detect_level: WARNING
-    rules_file:
-      - rules/exceptions/rule_exception_new_second_field_append.yaml
-    trace_file: trace_files/cat_write.scap
-
-  rule_exception_new_append_no_field:
-    exit_status: 1
-    validate_errors:
-      - item_type: exception
-        item_name: proc_cmdline
-        code: LOAD_ERR_VALIDATE
-        message: "Rule exception must have fields property with a list of fields"
-    validate_rules_file:
-      - rules/exceptions/rule_exception_new_no_field_append.yaml
-    trace_file: trace_files/cat_write.scap
-

test/falco_tests_package.yaml

@@ -1,41 +0,0 @@
-#
-# Copyright (C) 2019 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-trace_files: !mux
-
-  docker_deb_package:
-    package: docker:falcosecurity/falco:test-deb
-    detect: True
-    detect_level: WARNING
-    rules_file: /rules/rule_names_with_spaces.yaml
-    trace_file: /traces/cat_write.scap
-    conf_file: /etc/falco/falco.yaml
-
-  docker_rpm_package:
-    package: docker:falcosecurity/falco:test-rpm
-    detect: True
-    detect_level: WARNING
-    rules_file: /rules/rule_names_with_spaces.yaml
-    trace_file: /traces/cat_write.scap
-    conf_file: /etc/falco/falco.yaml
-
-  docker_bin_package:
-    package: docker:falcosecurity/falco:test-tar.gz
-    detect: True
-    detect_level: WARNING
-    rules_file: /rules/rule_names_with_spaces.yaml
-    trace_file: /traces/cat_write.scap
-    conf_file: /etc/falco/falco.yaml

test/falco_tests_plugins.yaml

@@ -1,113 +0,0 @@
-#
-# Copyright (C) 2021 The Falco Authors.
-#
-# This file is part of Falco.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-trace_files: !mux
-
-  list_plugins:
-    check_detection_counts: False
-    rules_file:
-      - rules/plugins/cloudtrail_create_instances.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/cloudtrail_json_create_instances.yaml
-    addl_cmdline_opts: --list-plugins
-    stdout_contains: "2 Plugins Loaded.*Name: cloudtrail.*Name: json.*"
-
-  list_plugin_fields:
-    check_detection_counts: False
-    rules_file:
-      - rules/plugins/cloudtrail_create_instances.yaml
-    conf_file: BUILD_DIR/test/confs/plugins/cloudtrail_json_create_instances.yaml
-    addl_cmdline_opts: --list
-    stdout_contains: "ct.id"
-
-  detect_create_instance:
-    enable_source: aws_cloudtrail
-    detect: True
-    detect_level: INFO
-    rules_file:
-      - rules/plugins/cloudtrail_create_instances.yaml
-    detect_counts:
-      - 'Cloudtrail Create Instance': 1
-    conf_file: BUILD_DIR/test/confs/plugins/cloudtrail_json_create_instances.yaml
-
-  detect_create_instance_bigevent:
-    enable_source: aws_cloudtrail
-    detect: True
-    detect_level: INFO
-    rules_file:
-      - rules/plugins/cloudtrail_create_instances.yaml
-    detect_counts:
-      - 'Cloudtrail Create Instance': 1
-    conf_file: BUILD_DIR/test/confs/plugins/cloudtrail_json_create_instances_bigevent.yaml
-
-  incompatible_extract_sources:
-    exit_status: 1
-    stderr_contains: "Plugin '.*' is loaded but unused as not compatible with any known event source"
-    conf_file: BUILD_DIR/test/confs/plugins/incompatible_extract_sources.yaml
-    rules_file:
-      - rules/plugins/cloudtrail_create_instances.yaml
-
-  overlap_extract_sources:
-    exit_status: 1
-    stderr_contains: "Plugin '.*' supports extraction of field 'test.field' that is overlapping for source 'test_source'"
-    conf_file: BUILD_DIR/test/confs/plugins/overlap_extract_sources.yaml
-    rules_file:
-      - rules/plugins/cloudtrail_create_instances.yaml
-
-  incompat_plugin_api:
-    exit_status: 1
-    stderr_contains: "plugin required API version '10000000.0.0' not compatible with the framework's API version '.*'"
-    conf_file: BUILD_DIR/test/confs/plugins/incompatible_plugin_api.yaml
-    rules_file:
-      - rules/plugins/cloudtrail_create_instances.yaml
-
-  incompat_plugin_rules_version:
-    exit_status: 1
-    stderr_contains: "Plugin 'cloudtrail' version '.*' is not compatible with required plugin version '100000.0.0'"
-    conf_file: BUILD_DIR/test/confs/plugins/cloudtrail_json_create_instances.yaml
-    rules_file:
-      - rules/plugins/cloudtrail_incompat_plugin_version.yaml
-
-  wrong_plugin_path:
-    exit_status: 1
-    stderr_contains: "cannot load plugin.*No such file or directory"
-    conf_file: BUILD_DIR/test/confs/plugins/wrong_plugin_path.yaml
-    rules_file:
-      - rules/plugins/cloudtrail_incompat_plugin_version.yaml
-
-  no_plugins_unknown_source:
-    exit_status: 0
-    validate_warnings:
-      - item_type: rule
-        item_name: Cloudtrail Create Instance
-        code: LOAD_UNKNOWN_SOURCE
-        message: "Unknown source aws_cloudtrail, skipping"
-    validate_rules_file:
-      - rules/plugins/cloudtrail_create_instances.yaml
-
-  no_plugins_unknown_source_rule_exception:
-    exit_status: 0
-    validate_warnings:
-      - item_type: rule
-        item_name: Cloudtrail Create Instance
-        code: LOAD_UNKNOWN_SOURCE
-        message: "Unknown source aws_cloudtrail, skipping"
-    validate_rules_file:
-      - rules/plugins/cloudtrail_create_instances_exceptions.yaml
-
-
-

test/falco_traces.yaml.in

@@ -1,183 +0,0 @@
-#
-# Copyright (C) 2020 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-has_json_output: !mux
-  yes:
-    json_output: True
-  no:
-    json_output: False
-
-traces: !mux
-  change-thread-namespace:
-    trace_file: traces-positive/change-thread-namespace.scap
-    detect: False
-    detect_level: NOTICE
-    detect_counts:
-      - "Change thread namespace": 0
-
-  container-privileged:
-    trace_file: traces-positive/container-privileged.scap
-    all_events: True
-    detect: True
-    detect_level: INFO
-    detect_counts:
-      - "Launch Privileged Container": 3
-
-  container-sensitive-mount:
-    trace_file: traces-positive/container-sensitive-mount.scap
-    all_events: True
-    detect: True
-    detect_level: INFO
-    detect_counts:
-      - "Launch Sensitive Mount Container": 3
-
-  create-files-below-dev:
-    trace_file: traces-positive/create-files-below-dev.scap
-    detect: True
-    detect_level: ERROR
-    detect_counts:
-      - "Create files below dev": 1
-
-  db-program-spawned-process:
-    trace_file: traces-positive/db-program-spawned-process.scap
-    all_events: True
-    detect: True
-    detect_level: NOTICE
-    detect_counts:
-      - "DB program spawned process": 1
-
-  falco-event-generator:
-    trace_file: traces-positive/falco-event-generator.scap
-    detect: True
-    detect_level: [ERROR, WARNING, NOTICE, DEBUG]
-    detect_counts:
-      - "Write below binary dir": 1
-      - "Read sensitive file untrusted": 3
-      - "Run shell untrusted": 1
-      - "Write below rpm database": 1
-      - "Write below etc": 1
-      - "System procs network activity": 1
-      - "Mkdir binary dirs": 1
-      - "System user interactive": 0
-      - "DB program spawned process": 1
-      - "Non sudo setuid": 1
-      - "Create files below dev": 1
-      - "Modify binary dirs": 2
-      - "Change thread namespace": 0
-
-  mkdir-binary-dirs:
-    trace_file: traces-positive/mkdir-binary-dirs.scap
-    detect: True
-    detect_level: ERROR
-    detect_counts:
-      - "Mkdir binary dirs": 1
-
-  modify-binary-dirs:
-    trace_file: traces-positive/modify-binary-dirs.scap
-    detect: True
-    detect_level: ERROR
-    detect_counts:
-      - "Modify binary dirs": 1
-
-  non-sudo-setuid:
-    trace_file: traces-positive/non-sudo-setuid.scap
-    detect: True
-    detect_level: NOTICE
-    detect_counts:
-      - "Non sudo setuid": 1
-
-  read-sensitive-file-after-startup:
-    trace_file: traces-positive/read-sensitive-file-after-startup.scap
-    detect: True
-    detect_level: WARNING
-    detect_counts:
-      - "Read sensitive file untrusted": 1
-      - "Read sensitive file trusted after startup": 1
-
-  read-sensitive-file-untrusted:
-    trace_file: traces-positive/read-sensitive-file-untrusted.scap
-    detect: True
-    detect_level: WARNING
-    detect_counts:
-      - "Read sensitive file untrusted": 1
-
-  # This should *not* generate any falco alerts as of the changes in
-  # https://github.com/falcosecurity/libs/pull/94--the execve event in
-  # this trace file is PPME_SYSCALL_EXECVE_18, which was deprecated by
-  # PPME_SYSCALL_EXECVE_19 in 2018.
-  #
-  # This activity in this trace file overlaps with the activity in
-  # falco-event-generator.scap so the rule is still being tested.
-  run-shell-untrusted:
-    trace_file: traces-positive/run-shell-untrusted.scap
-    detect: True
-    detect_level: DEBUG
-    detect_counts:
-      - "Run shell untrusted": 1
-
-  system-binaries-network-activity:
-    trace_file: traces-positive/system-binaries-network-activity.scap
-    detect: True
-    detect_level: NOTICE
-    detect_counts:
-      - "System procs network activity": 1
-
-  system-user-interactive:
-    trace_file: traces-positive/system-user-interactive.scap
-    all_events: True
-    detect: True
-    detect_level: INFO
-    detect_counts:
-      - "System user interactive": 1
-
-  user-mgmt-binaries:
-    trace_file: traces-positive/user-mgmt-binaries.scap
-    all_events: True
-    detect: True
-    detect_level: NOTICE
-    detect_counts:
-      - "User mgmt binaries": 1
-
-  write-binary-dir:
-    trace_file: traces-positive/write-binary-dir.scap
-    detect: True
-    detect_level: ERROR
-    detect_counts:
-      - "Write below binary dir": 4
-
-  write-etc:
-    trace_file: traces-positive/write-etc.scap
-    detect: True
-    detect_level: ERROR
-    detect_counts:
-      - "Write below etc": 1
-
-  write-rpm-database:
-    trace_file: traces-positive/write-rpm-database.scap
-    detect: True
-    detect_level: ERROR
-    detect_counts:
-      - "Write below rpm database": 1
-
-  # This generates two notices starting from https://github.com/falcosecurity/falco/pull/2092
-  # When a new version of the scap files is generated this should then become "traces-positive"
-  docker-compose:
-    trace_file: traces-negative/docker-compose.scap
-    all_events: True
-    detect: True
-    detect_level: NOTICE
-    detect_counts:
-      - "Redirect STDOUT/STDIN to Network Connection in Container": 2

test/output_files/single_rule_with_cat_write.json

@@ -1,8 +0,0 @@
-{"hostname":"test-falco-hostname","output":"2016-08-04T16:17:57.881781397+0000: Warning An open was seen (command=cat /dev/null)","priority":"Warning","rule":"open_from_cat","source":"syscall","tags":["filesystem","process","testing"],"time":"2016-08-04T16:17:57.881781397Z", "output_fields": {"evt.time.iso8601":1470327477881781397,"proc.cmdline":"cat /dev/null"}}
-{"hostname":"test-falco-hostname","output":"2016-08-04T16:17:57.881785348+0000: Warning An open was seen (command=cat /dev/null)","priority":"Warning","rule":"open_from_cat","source":"syscall","tags":["filesystem","process","testing"],"time":"2016-08-04T16:17:57.881785348Z", "output_fields": {"evt.time.iso8601":1470327477881785348,"proc.cmdline":"cat /dev/null"}}
-{"hostname":"test-falco-hostname","output":"2016-08-04T16:17:57.881796705+0000: Warning An open was seen (command=cat /dev/null)","priority":"Warning","rule":"open_from_cat","source":"syscall","tags":["filesystem","process","testing"],"time":"2016-08-04T16:17:57.881796705Z", "output_fields": {"evt.time.iso8601":1470327477881796705,"proc.cmdline":"cat /dev/null"}}
-{"hostname":"test-falco-hostname","output":"2016-08-04T16:17:57.881799840+0000: Warning An open was seen (command=cat /dev/null)","priority":"Warning","rule":"open_from_cat","source":"syscall","tags":["filesystem","process","testing"],"time":"2016-08-04T16:17:57.881799840Z", "output_fields": {"evt.time.iso8601":1470327477881799840,"proc.cmdline":"cat /dev/null"}}
-{"hostname":"test-falco-hostname","output":"2016-08-04T16:17:57.882003104+0000: Warning An open was seen (command=cat /dev/null)","priority":"Warning","rule":"open_from_cat","source":"syscall","tags":["filesystem","process","testing"],"time":"2016-08-04T16:17:57.882003104Z", "output_fields": {"evt.time.iso8601":1470327477882003104,"proc.cmdline":"cat /dev/null"}}
-{"hostname":"test-falco-hostname","output":"2016-08-04T16:17:57.882008208+0000: Warning An open was seen (command=cat /dev/null)","priority":"Warning","rule":"open_from_cat","source":"syscall","tags":["filesystem","process","testing"],"time":"2016-08-04T16:17:57.882008208Z", "output_fields": {"evt.time.iso8601":1470327477882008208,"proc.cmdline":"cat /dev/null"}}
-{"hostname":"test-falco-hostname","output":"2016-08-04T16:17:57.882045694+0000: Warning An open was seen (command=cat /dev/null)","priority":"Warning","rule":"open_from_cat","source":"syscall","tags":["filesystem","process","testing"],"time":"2016-08-04T16:17:57.882045694Z", "output_fields": {"evt.time.iso8601":1470327477882045694,"proc.cmdline":"cat /dev/null"}}
-{"hostname":"test-falco-hostname","output":"2016-08-04T16:17:57.882054739+0000: Warning An open was seen (command=cat /dev/null)","priority":"Warning","rule":"open_from_cat","source":"syscall","tags":["filesystem","process","testing"],"time":"2016-08-04T16:17:57.882054739Z", "output_fields": {"evt.time.iso8601":1470327477882054739,"proc.cmdline":"cat /dev/null"}}

test/output_files/single_rule_with_cat_write.txt

@@ -1,8 +0,0 @@
-2016-08-04T16:17:57.881781397+0000: Warning An open was seen (command=cat /dev/null)
-2016-08-04T16:17:57.881785348+0000: Warning An open was seen (command=cat /dev/null)
-2016-08-04T16:17:57.881796705+0000: Warning An open was seen (command=cat /dev/null)
-2016-08-04T16:17:57.881799840+0000: Warning An open was seen (command=cat /dev/null)
-2016-08-04T16:17:57.882003104+0000: Warning An open was seen (command=cat /dev/null)
-2016-08-04T16:17:57.882008208+0000: Warning An open was seen (command=cat /dev/null)
-2016-08-04T16:17:57.882045694+0000: Warning An open was seen (command=cat /dev/null)
-2016-08-04T16:17:57.882054739+0000: Warning An open was seen (command=cat /dev/null)