KICS : scanner Terraform et Kubernetes avant le déploiement

KICS vous permet de scanner vos fichiers Terraform et Kubernetes avant le déploiement pour détecter des erreurs comme un Security Group SSH ouvert à Internet, un conteneur privilégié, ou l’absence de readinessProbe. Dans ce guide, on reste sur un usage simple et reproductible : exécuter l’image Docker officielle, lire les findings, puis corriger les misconfigurations les plus dangereuses.

Les exemples présentés ici ont été validés sur deux labs locaux contenant du code volontairement vulnérable. Le but n’est pas de couvrir toutes les options de KICS, mais de montrer un flux de travail réaliste pour une revue IaC rapide avant la CI/CD.

Ce que fait KICS

KICS signifie Keeping Infrastructure as Code Secure. C’est un scanner de misconfigurations pour l’Infrastructure as Code maintenu par Checkmarx. Il analyse des fichiers sources et compare leur contenu à une base de règles de sécurité.

Concrètement, KICS cherche par exemple :

des règles réseau trop ouvertes dans Terraform
des buckets ou ressources sans garde-fous de base
des manifests Kubernetes avec des privilèges excessifs
des probes, limites mémoire ou restrictions de sécurité absentes

Quand utiliser KICS

Utilisez KICS quand vous voulez un retour rapide sur vos fichiers Terraform, Kubernetes, Dockerfile ou autres formats IaC, sans attendre un déploiement réel.

Les cas d’usage les plus utiles sont :

revue locale avant commit
job CI/CD sur pull request
contrôle d’un dossier de manifests ou de modules
comparaison rapide entre plusieurs scanners IaC

Installation la plus simple : l’image Docker officielle

Dans ce guide, on utilise uniquement la méthode que j’ai validée : l’image Docker officielle checkmarx/kics:latest.

docker run --rm \
  -v "$PWD":/path \
  checkmarx/kics:latest \
  scan -p /path --report-formats json --output-path /path

Cette commande :

monte votre dossier courant dans le conteneur
scanne le contenu monté
écrit un rapport JSON dans le dossier scanné

Vérification : vous devez obtenir un fichier results.json à la fin du scan.

Lab Terraform validé

Le premier lab contient un exemple Terraform très simple, mais volontairement vulnérable :

resource "aws_security_group" "bad_sg" {
  name = "allow-all-ssh"

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_s3_bucket" "bad_bucket" {
  bucket = "demo-kics-bucket-example"
}

Lancer le scan Terraform

docker run --rm \
  -v /home/bob/Projets/lab-kics/terraform-bad:/path \
  checkmarx/kics:latest \
  scan -p /path --report-formats json --output-path /path

Résultat réellement observé

Le scan validé ici a produit :

11 findings au total
2 HIGH
3 MEDIUM
1 LOW
5 INFO

Les findings les plus intéressants sont :

Sévérité	Finding	Ce que KICS a détecté
HIGH	Sensitive Port Is Exposed To Entire Network	le port 22/TCP est exposé
HIGH	Unrestricted Security Group Ingress	`0.0.0.0/0` est autorisé
MEDIUM	Security Group With Unrestricted Access To SSH	SSH est ouvert publiquement
MEDIUM	S3 Bucket Without Versioning	le bucket n’a pas de versioning
MEDIUM	S3 Bucket Logging Disabled	le logging S3 est absent

Comment lire ces résultats

Ici, KICS ne vous dit pas seulement qu’une ressource est “mauvaise”. Il indique aussi :

le type de ressource concerné
la ligne du fichier
la valeur attendue
la valeur observée

Sur ce lab, la priorité est claire : refermer le port 22, supprimer 0.0.0.0/0, puis ajouter les garde-fous du bucket S3.

Lab Kubernetes validé

Le second lab cible un manifest Kubernetes volontairement faible :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: insecure-nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: insecure-nginx
  template:
    metadata:
      labels:
        app: insecure-nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          securityContext:
            privileged: true
            runAsUser: 0

Lancer le scan Kubernetes

docker run --rm \
  -v /home/bob/Projets/lab-kics/k8s-bad:/path \
  checkmarx/kics:latest \
  scan -p /path --report-formats json --output-path /path

Résultat réellement observé

Le scan validé ici a produit :

21 findings au total
2 HIGH
9 MEDIUM
9 LOW
1 INFO

Les findings les plus importants sont :

Sévérité	Finding	Ce que KICS a détecté
HIGH	Container Is Privileged	`privileged: true`
HIGH	Privilege Escalation Allowed	`allowPrivilegeEscalation` absent
MEDIUM	Container Running As Root	`runAsUser: 0`
MEDIUM	Readiness Probe Is Not Configured	aucune `readinessProbe`
MEDIUM	Memory Limits Not Defined	aucune limite mémoire
MEDIUM	Memory Requests Not Defined	aucune requête mémoire

On retrouve aussi plusieurs findings LOW sur l’image nginx:latest, l’absence de digest, l’absence de capacités supprimées et le manque de configuration de sécurité complémentaire.

Corriger les problèmes les plus visibles

Sur un manifest Kubernetes comme celui du lab, l’ordre de correction le plus rationnel est le suivant :

Supprimer les privilèges dangereux : passez privileged à false et définissez allowPrivilegeEscalation: false.
Sortir du mode root : utilisez runAsNonRoot: true et un UID non privilégié.
Déclarer les ressources : ajoutez resources.requests et resources.limits pour le CPU et la mémoire.
Ajouter une readinessProbe : évitez d’envoyer du trafic vers un conteneur qui n’est pas prêt.
Stabiliser l’image : remplacez :latest par un tag précis, idéalement avec digest.

Exemple de correction minimale :

securityContext:
  privileged: false
  allowPrivilegeEscalation: false
  runAsNonRoot: true
  runAsUser: 10001
  capabilities:
    drop:
      - ALL
readinessProbe:
  httpGet:
    path: /
    port: 80
resources:
  requests:
    cpu: 100m
    memory: 128Mi
  limits:
    cpu: 500m
    memory: 256Mi

Intégrer KICS en CI/CD

Une intégration simple consiste à exécuter le même conteneur dans votre pipeline.

name: kics

on:
  pull_request:
  push:
    branches: [main]

jobs:
  scan-iac:
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@v4
      - name: Scan Terraform and Kubernetes
        run: |
          docker run --rm \
            -v "$PWD":/path \
            checkmarx/kics:latest \
            scan -p /path

Si vous voulez exploiter les résultats dans un autre outil, conservez aussi le rapport JSON avec --report-formats json --output-path /path.

Pièges courants avec KICS

Scanner trop large : lancer un scan à la racine d’un gros dépôt produit vite beaucoup de bruit.
Confondre LOW et négligeable : plusieurs findings LOW peuvent décrire une mauvaise hygiène persistante.
Ignorer le contexte : un finding sur latest n’a pas le même impact qu’un conteneur privilégié.
Traiter KICS comme un remédiateur automatique : l’outil signale, mais il faut encore corriger intelligemment.

À retenir

KICS est un scanner IaC utile pour détecter tôt les misconfigurations Terraform et Kubernetes.
La méthode la plus simple et validée ici est l’usage de l’image Docker officielle.
Sur le lab Terraform, les problèmes dominants étaient l’ouverture SSH et l’absence de garde-fous S3.
Sur le lab Kubernetes, les problèmes dominants étaient le mode privilégié, l’exécution en root et l’absence de probe et de ressources.
Le bon usage de KICS consiste à l’exécuter avant le déploiement, localement puis dans la CI/CD.

Prochaines étapes

Checkov Comparer KICS avec un autre scanner IaC très répandu.

Security Context Kubernetes Corriger proprement les privilèges des Pods et conteneurs.

Probes Kubernetes Ajouter des readiness et liveness probes sans faux positifs.

Terraform Renforcer vos modules et votre hygiène IaC côté provisionnement.