AppArmor

# Controllare lo stato di AppArmor
sudo apparmor_status
# oppure
sudo aa-status

# Output tipico:
apparmor module is loaded.
27 profiles are loaded.
27 profiles are in enforce mode.
   /usr/bin/evince
   /usr/sbin/nginx
   ...
0 profiles are in complain mode.
3 processes have profiles defined.
3 processes are in enforce mode.

# Verificare se AppArmor è abilitato nel kernel
cat /sys/module/apparmor/parameters/enabled
Y

# I profili di sistema sono qui:
ls /etc/apparmor.d/

# Ubuntu/Debian (già installato)
sudo apt install apparmor apparmor-utils apparmor-profiles

# Tools utili
sudo apt install apparmor-profiles-extra

# Abilitare all'avvio (se disabilitato)
sudo systemctl enable apparmor
sudo systemctl start apparmor

# Mettere un profilo in complain
sudo aa-complain /usr/sbin/nginx

# Mettere in enforce
sudo aa-enforce /usr/sbin/nginx

# Disabilitare un profilo
sudo aa-disable /usr/sbin/nginx

# Ricaricare un profilo
sudo apparmor_parser -r /etc/apparmor.d/usr.sbin.nginx

# Glob patterns nei profili
/etc/myapp/        r,   # solo la directory
/etc/myapp/*       r,   # tutti i file diretti (non ricorsivo)
/etc/myapp/**      r,   # ricorsivo: tutti i file e subdirectory
/var/log/**.log    rw,  # tutti i .log ricorsivamente
@{HOME}/.config/   r,   # variabile: espande la home dell'utente

# Passo 1: avvia il generatore di profilo
sudo aa-genprof /usr/sbin/nginx

# L'output ti chiederà di avviare l'app in un altro terminale e usarla
Please start the application to be profiled in
another window and exercise its functionality now.

Once completed, select the (S)can option below in
order to scan the system logs for AppArmor events.

[(S)can system log for AppArmor events] / (F)inish

# In un altro terminale: avvia e usa nginx
sudo systemctl start nginx
curl http://localhost/
curl http://localhost/api/test

# Torna a aa-genprof, premi S per scansionare i log
# Per ogni accesso negato, scegli cosa fare:
  (A)llow / (D)eny / (I)gnore / (G)lob / (Q)uit

# Analizzare i log per proporre aggiornamenti
sudo aa-logprof

# Oppure da un file di log specifico
sudo aa-logprof -f /var/log/syslog

# Vedere le violazioni in tempo reale
sudo journalctl -f | grep -i apparmor

# Formato del log di violazione:
kernel: audit: type=1400 audit(1234567890.123:456):
  apparmor="DENIED" operation="open"
  profile="/usr/sbin/nginx"
  name="/etc/ssl/private/nginx.key"
  pid=1234 comm="nginx"
  requested_mask="r" denied_mask="r"

# Traduzione: nginx ha cercato di leggere la chiave SSL e AppArmor l'ha bloccato
# Soluzione: aggiungere /etc/ssl/private/nginx.key r, al profilo

find / -perm -4000 -type f 2>/dev/null

# Vedere le capability di un processo
cat /proc/$(pgrep nginx)/status | grep Cap
CapInh: 0000000000000000
CapPrm: 0000000000000400
CapEff: 0000000000000400
CapBnd: 000001ffffffffff
CapAmb: 0000000000000000

# Decodificare il valore hex in nomi leggibili
capsh --decode=0000000000000400
0x0000000000000400=cap_net_bind_service

# Vedere le capability del processo corrente
capsh --print

# Sintassi: setcap <capability>=<set> <file>
# Set: e=effective, p=permitted, i=inheritable

# Esempio classico: nginx su porta 80 senza root
sudo setcap cap_net_bind_service=ep /usr/sbin/nginx

# Verificare le capability impostate
getcap /usr/sbin/nginx
/usr/sbin/nginx cap_net_bind_service=ep

# Ping senza SUID (moderno)
getcap /bin/ping
/bin/ping cap_net_raw=ep

# Rimuovere tutte le capability da un binario
sudo setcap -r /usr/sbin/nginx

# Vedere tutte le capability nel sistema
getcap -r / 2>/dev/null

# /etc/systemd/system/myapp.service
[Unit]
Description=My App

[Service]
User=myapp
Group=myapp
ExecStart=/usr/bin/myapp

# Aggiungi solo le capability necessarie
AmbientCapabilities=CAP_NET_BIND_SERVICE
CapabilityBoundingSet=CAP_NET_BIND_SERVICE

# Hardening aggiuntivo
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes
ReadWritePaths=/var/lib/myapp

[Install]
WantedBy=multi-user.target

# seccomp con systemd (modo più semplice)
[Service]
# Allowlist per tipo di servizio
SystemCallFilter=@system-service      # preset per servizi generici
SystemCallFilter=@network-io          # syscall di rete
SystemCallFilter=~@privileged         # ~ = nega queste
SystemCallFilter=~@mount              # nega le syscall di mount

# Preset disponibili:
# @basic-io, @file-system, @io-event, @ipc, @keyring
# @memlock, @module, @mount, @network-io, @obsolete
# @privileged, @process, @raw-io, @reboot, @setuid
# @signal, @swap, @system-service, @timer

# Vedere le syscall in un preset
systemd-analyze syscall-filter @privileged

# Profilo seccomp JSON per Docker (estratto)
{
  "defaultAction": "SCMP_ACT_ERRNO",
  "syscalls": [
    {
      "names": ["read", "write", "open", "close", "stat",
                "fstat", "lstat", "poll", "lseek", "mmap",
                "accept", "connect", "send", "recv" /* ... */],
      "action": "SCMP_ACT_ALLOW"
    }
  ]
}

# Applicare un profilo custom a un container
docker run --security-opt seccomp=/path/to/profile.json myimage

# Disabilitare seccomp (per debug, mai in produzione)
docker run --security-opt seccomp=unconfined myimage

strace -c -f -S name nginx 2>&1 | tail -20

# Output: statistiche per syscall
% time     seconds  usecs/call     calls syscall
 32.54    0.001234          12       100 read
 28.12    0.001067          10       102 write
  8.45    0.000321           8        40 epoll_wait
  ...

# Vedere le capability di un container in esecuzione
docker inspect mycontainer | jq '.[0].HostConfig.CapAdd'

# Aggiungere solo la capability necessaria
docker run --cap-drop ALL --cap-add NET_BIND_SERVICE nginx

# Container con profilo AppArmor custom
docker run --security-opt apparmor=my-nginx-profile nginx

# Vedere il profilo AppArmor di un container attivo
docker inspect mycontainer | jq '.[0].HostConfig.SecurityOpt'

securityContext:
  runAsNonRoot: true
  runAsUser: 1000
  allowPrivilegeEscalation: false
  readOnlyRootFilesystem: true
  capabilities:
    drop:
      - ALL
    add:
      - NET_BIND_SERVICE
  seccompProfile:
    type: RuntimeDefault

# Podman: rootless di default
podman run nginx  # gira come utente normale

# Docker rootless setup
dockerd-rootless-setuptool.sh install
export DOCKER_HOST=unix:///run/user/1000/docker.sock
docker run nginx

# Log in tempo reale
sudo journalctl -f -k | grep -i apparmor

# Tutte le violazioni di oggi
sudo journalctl --since today | grep -i "apparmor.*denied"

# Log di audit (se auditd è installato)
sudo ausearch -m avc -ts recent

# Anatomia di una violazione:
apparmor="DENIED"           # azione intrapresa
operation="open"             # cosa stava facendo
profile="/usr/sbin/nginx"    # quale profilo ha negato
name="/etc/ssl/private/cert.key"  # cosa voleva accedere
pid=12345                    # processo
comm="nginx"                 # nome del comando
requested_mask="r"           # permesso richiesto
denied_mask="r"              # permesso negato

# 1. Controlla lo stato del profilo
sudo aa-status | grep myapp

# 2. Metti temporaneamente in complain
sudo aa-complain /usr/bin/myapp

# 3. Avvia l'app e guarda i log
sudo journalctl -f | grep apparmor &
sudo systemctl start myapp

# 4. Aggiorna il profilo con aa-logprof
sudo aa-logprof

# 5. Torna in enforce
sudo aa-enforce /usr/bin/myapp

# Errore "Operation not permitted"
# potrebbe essere una capability mancante

# Traccia le syscall fallite
strace -e trace=all myapp 2>&1 | grep EPERM

# Verifica le capability del processo
cat /proc/$(pgrep myapp)/status | grep Cap
capsh --decode=<hex-value>

# Controlla se serve una capability specifica
man 7 capabilities | grep -A3 "CAP_NET_BIND"

# Unit file systemd con hardening completo
# /etc/systemd/system/myapp.service
[Unit]
Description=My FastAPI App
After=network.target

[Service]
Type=exec
User=myapp
Group=myapp
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/venv/bin/uvicorn main:app --host 0.0.0.0 --port 8080

# AppArmor profile (se definito)
AppArmorProfile=opt.myapp.run

# Capabilities
AmbientCapabilities=CAP_NET_BIND_SERVICE
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
NoNewPrivileges=yes

# Filesystem isolation
PrivateTmp=yes
PrivateDevices=yes
ProtectSystem=strict
ProtectHome=yes
ProtectKernelTunables=yes
ProtectKernelModules=yes
ProtectControlGroups=yes
ReadWritePaths=/var/lib/myapp /var/log/myapp

# Syscall filter
SystemCallFilter=@system-service @network-io
SystemCallFilter=~@privileged ~@mount ~@reboot
SystemCallArchitectures=native

[Install]
WantedBy=multi-user.target