🔬 Mission pratique – Laboratoire (2 heures)

Architecture du Lab Docker

⚠️ Préparation de l'Environnement

Étapes Détaillées d'Implémentation

Étape 1 : Installation et Configuration Docker

# Installation Docker Engine
sudo apt update
sudo apt install docker.io docker-compose -y

# Configuration sécurité de base
sudo systemctl start docker
sudo systemctl enable docker

# Ajout utilisateur au groupe docker (éviter sudo)
sudo usermod -aG docker $USER
# Déconnexion/reconnexion nécessaire

# Vérification installation
docker --version
docker-compose --version

# Test hello-world
docker run --rm hello-worldCopier

Étape 2 : Création d'une Image Sécurisée

docker-lab/
├── secure-app/
│   ├── Dockerfile
│   ├── nginx.conf
│   └── html/
│       └── index.html
├── vulnerable-app/
│   └── Dockerfile
└── docker-compose.yml

# Création structure
mkdir -p ~/mon_lab/docker-lab/{secure-app/html,vulnerable-app}
cd ~/mon_lab/docker-labCopier

# secure-app/Dockerfile
# Image minimale Alpine
FROM nginx:1.24-alpine

# Création utilisateur non-root
RUN addgroup -g 1001 -S appgroup && \
    adduser -u 1001 -S appuser -G appgroup

# Configuration sécurité Nginx
RUN echo "daemon off;" >> /etc/nginx/nginx.conf && \
    echo "user appuser appgroup;" >> /etc/nginx/nginx.conf

# Suppression fichiers inutiles
RUN rm -rf /usr/share/nginx/html/* && \
    rm -rf /etc/nginx/conf.d/default.conf

# Copie configuration custom
COPY nginx.conf /etc/nginx/nginx.conf
COPY html/ /usr/share/nginx/html/

# Changer propriétaire fichiers
RUN chown -R appuser:appgroup /usr/share/nginx/html && \
    chown -R appuser:appgroup /var/cache/nginx && \
    chown -R appuser:appgroup /var/log/nginx

# User non-root
USER appuser

# Exposition port
EXPOSE 8080

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:8080/ || exit 1

# Entrypoint sécurisé
ENTRYPOINT ["nginx"]
CMD ["-c", "/etc/nginx/nginx.conf"]Copier

# secure-app/nginx.conf
events {
    worker_connections 1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    # Logging
    access_log /var/log/nginx/access.log;
    error_log /var/log/nginx/error.log warn;

    # Headers sécurité
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;

    server {
        listen 8080;
        server_name _;
        
        root /usr/share/nginx/html;
        index index.html;

        # Sécurité supplémentaire
        server_tokens off;
        
        location / {
            try_files $uri $uri/ =404;
        }
        
        # Blocage accès fichiers sensibles
        location ~ /\.(?!well-known) {
            deny all;
        }
        
        location ~* \.(log|sql|bak|old)$ {
            deny all;
        }
    }
}Copier

    


    
🚀 Application Conteneurisée Sécurisée
    
Déployée avec les meilleures pratiques Docker
    

        
User non-root (appuser:1001)
        
Capabilities limitées
        
Filesystem read-only
        
Scans réguliers
    

Copier

# Build de l'image sécurisée
cd secure-app
docker build -t pctamalou/secure-app:1.0 .

# Inspection de l'image
docker image inspect pctamalou/secure-app:1.0 | jq '.[0].Config.User'Copier

Étape 3 : Déploiement avec Options de Sécurité

# Lancement conteneur sécurisé
docker run -d \
  --name secure-app \
  --restart unless-stopped \
  --read-only \
  --cap-drop ALL \
  --cap-add NET_BIND_SERVICE \
  --security-opt no-new-privileges \
  --security-opt seccomp=/etc/docker/seccomp/default.json \
  --pids-limit 100 \
  --memory 256m \
  --cpus 0.5 \
  -p 8080:8080 \
  -v secure-app-data:/var/cache/nginx \
  -v secure-app-logs:/var/log/nginx \
  pctamalou/secure-app:1.0

# Vérification
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
curl http://localhost:8080Copier

Étape 4 : Création d'un Conteneur Vulnérable (À NE PAS REPRODUIRE EN PROD)

# vulnerable-app/Dockerfile
FROM ubuntu:latest

RUN apt update && apt install -y nginx

# Mauvaise pratique : root explicite
USER root

# Exposition tous les ports
EXPOSE 80 443 22

CMD ["nginx", "-g", "daemon off;"]Copier

# Build et lancement vulnérable
cd ../vulnerable-app
docker build -t vulnerable-app .

# Lancement avec TOUTES les mauvaises pratiques
docker run -d \
  --name vuln-app \
  --privileged \
  --net=host \
  --pid=host \
  -v /:/host \
  -p 8081:80 \
  vulnerable-app

# Vérification de la vulnérabilité
docker exec vuln-app whoami  # root
docker exec vuln-app ls /host  # Accès à tout l'hôte !Copier

Étape 5 : Scanning de Sécurité

# Installation Trivy
sudo apt install trivy -y

# Scan image vulnérable
trivy image vulnerable-app

# Scan image sécurisée
trivy image pctamalou/secure-app:1.0

# Scan avec sortie JSON pour analyse
trivy image --format json --output trivy-report.json nginx:alpine

# Benchmark sécurité Docker
docker run -it --net host --pid host --userns host --cap-add audit_control \
  -e DOCKER_CONTENT_TRUST=1 \
  -v /etc:/etc:ro \
  -v /usr/bin/docker-containerd:/usr/bin/docker-containerd:ro \
  -v /usr/bin/docker-runc:/usr/bin/docker-runc:ro \
  -v /lib/systemd/system:/lib/systemd/system:ro \
  -v /sbin/iptables:/sbin/iptables:ro \
  -v /var/lib:/var/lib:ro \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  --label docker_bench_security \
  docker/docker-bench-securityCopier

Étape 6 : Tests d'Échappement (Simulation)

# Test 1 : Conteneur sécurisé (devrait échouer)
docker exec secure-app sh -c "whoami; cat /etc/shadow"

# Test 2 : Conteneur vulnérable (devrait réussir)
docker exec vuln-app sh -c "whoami; ls /host/etc/shadow"

# Test 3 : Exploitation kernel (simulée)
# Dirty Cow exploit (CVE-2016-5195) - À tester seulement en lab isolé
# docker run --privileged -it ubuntu bash
# apt update && apt install -y gcc
# wget https://raw.githubusercontent.com/dirtycow/dirtycow.github.io/master/dirtyc0w.c
# gcc -pthread dirtyc0w.c -o dirtyc0w

Étape 7 : Docker Compose pour Orchestration Sécurisée

# docker-compose.yml
version: '3.8'

services:
  secure-app:
    build: ./secure-app
    image: pctamalou/secure-app:1.0
    container_name: secure-app
    restart: unless-stopped
    read_only: true
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    cap_add:
      - NET_BIND_SERVICE
    mem_limit: 256m
    cpus: 0.5
    ports:
      - "8080:8080"
    volumes:
      - secure-app-data:/var/cache/nginx
      - secure-app-logs:/var/log/nginx
    networks:
      - secure-net

  vulnerable-app:
    build: ./vulnerable-app
    container_name: vulnerable-app
    privileged: true
    network_mode: host
    pid: host
    volumes:
      - /:/host
    ports:
      - "8081:80"
    # À NE PAS UTILISER EN PRODUCTION

volumes:
  secure-app-data:
  secure-app-logs:

networks:
  secure-net:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/24Copier

Exercice Avancé : Policy Engine avec OPA/Gatekeeper

# Exemple de ConstraintTemplate OPA Gatekeeper
apiVersion: templates.gatekeeper.sh/v1beta1
kind: ConstraintTemplate
metadata:
  name: k8srequiredlabels
spec:
  crd:
    spec:
      names:
        kind: K8sRequiredLabels
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequiredlabels
        violation[{"msg": msg, "details": {"missing_labels": missing}}] {
          provided := {label | input.review.object.metadata.labels[label]}
          required := {"app", "version"}
          missing := required - provided
          count(missing) > 0
          msg := sprintf("you must provide labels: %v", [missing])
        }