Aller au contenu
English
Compte : non connecté, synchronisation possible Mon apprentissage
Selectionner le thème
English

Persistance : ce qu'un attaquant laisse derrière lui

Par mis à jour le

Améliorer cette page

Logo Kubernetes

Un attaquant qui a pris pied dans un cluster Kubernetes ne reste pas dépendant de la faille qui l'a fait entrer : il laisse derrière lui un objet qui lui rend l'accès, même si la faille est corrigée et le Pod d'origine supprimé. C'est la persistance. Cette leçon montre quels objets Kubernetes servent à cela, comment les repérer avec kubectl et le journal d'audit, dans quel ordre les supprimer sans toucher à l'application légitime, et comment vérifier que l'accès ne revient pas. Elle s'adresse à celui qui connaît déjà RBAC et les CronJobs, et prépare l'objectif « Persistence » du domaine « Kubernetes Threat Model » de la certification KCSA.

  • Définir la persistance et la distinguer de l'accès initial et de l'exécution.
  • Citer les mécanismes de persistance possibles dans un cluster.
  • Lister les objets qui peuvent servir de persistance et lire les événements et le journal d'audit pour repérer ce qui est nouveau.
  • Consigner puis supprimer l'objet qui recrée l'accès, sans retirer l'application légitime.
  • Vérifier que l'accès ne revient pas, et nommer les contrôles qui empêchent ou révèlent la persistance.
  • Avoir suivi la leçon Scénarios d'attaque dans un cluster, qui décrit les trois premières étapes d'une attaque : exécution, élévation de privilèges, réseau.
  • Savoir créer un CronJob et lire un DaemonSet, les deux objets qui lancent des Pods sans qu'on les relance à la main.
  • Connaître les liaisons RBAC : un ClusterRoleBinding donne un rôle à un compte de service sur tout le cluster.

La persistance est la capacité de l'attaquant à rester dans le cluster après avoir perdu son accès initial. Elle vient après deux autres étapes qu'il faut distinguer. L'accès initial est la faille ou le jeton volé qui l'a fait entrer. L'exécution est le code qu'il fait tourner une fois entré. La persistance est ce qu'il laisse en place pour que ce code revienne tout seul.

Dans un cluster, cet objet de persistance a un avantage pour l'attaquant : Kubernetes recrée ce qu'on lui demande de maintenir. Un Pod supprimé est relancé par son Deployment, un Job est créé de nouveau par son CronJob. Une charge malveillante déclarée dans l'un de ces objets profite de la même mécanique que l'application légitime. La page Phase 5 - L'installation décrit le principe général de la kill chain (la suite d'étapes d'une intrusion) : détourner un mécanisme légitime pour qu'il relance l'implant à la place de l'attaquant.

Quels objets servent de persistance dans Kubernetes ?

Section intitulée « Quels objets servent de persistance dans Kubernetes ? »

Plusieurs mécanismes reviennent. Le tableau dit pour chacun comment il fonctionne et où le chercher. Lisez-le comme une liste de contrôle : chaque ligne est une commande à passer sur un cluster que l'on soupçonne.

MécanismeCe qu'il faitOù le chercher
CronJobLance un Pod à intervalle fixe, au plus une fois par minutekubectl get cronjobs -A
DaemonSetGarde un Pod sur chaque nœud, y compris ceux ajoutés plus tardkubectl get daemonsets -A
ServiceAccount et liaison RBAC ajoutésDonne à l'attaquant un compte et des droits qui paraissent légitimeskubectl get serviceaccounts -A, kubectl get clusterrolebindings et kubectl get rolebindings -A (liaisons limitées à un namespace, kube-system compris)
Certificat client signé par une CSRReste valable jusqu'à son expiration et ne se révoque paskubectl get csr (une demande approuvée est supprimée une heure après son dernier changement d'état, la liste peut donc être vide)
Jeton de compte de service longue duréeUn Secret de type kubernetes.io/service-account-token reste valable tant qu'il existekubectl get secrets -A --field-selector type=kubernetes.io/service-account-token
Webhook d'admission malveillantS'insère dans la création de chaque objet, par exemple pour ajouter un conteneur à chaque Podkubectl get validatingwebhookconfigurations,mutatingwebhookconfigurations
Pod statique ou montage de l'hôteUn manifeste déposé dans le répertoire des Pods statiques du nœud est relancé par le kubelet, sans passer par l'APISur le nœud, /etc/kubernetes/manifests avec kubeadm

Le Pod statique se voit mal depuis l'API : le kubelet le lance depuis un fichier du nœud, et l'API n'en garde qu'une copie en lecture seule. Il demande déjà un accès au nœud : un Pod qui monte hostPath en écriture suffit. C'est la raison pour laquelle la leçon sur les Pod Security Standards refuse ce montage au niveau Baseline.

Une image piégée est un cas à part : l'attaquant pousse une version modifiée d'une image utilisée par un Deployment, et chaque Pod recréé porte la porte dérobée. Elle ne laisse aucun objet suspect dans le cluster. Seule la comparaison du digest de l'image avec celui que votre chaîne de construction a produit la révèle, ce que la leçon Supply Chain Security enseigne.

Pourquoi supprimer le compte ou le Pod ne suffit-il pas ?

Section intitulée « Pourquoi supprimer le compte ou le Pod ne suffit-il pas ? »

Supprimer l'objet que l'on voit, le compte ou le Pod, laisse en place celui qui le recrée. Le piège tient à deux objets liés : un compte de service et sa liaison qui donnent un droit fort, et une charge planifiée, CronJob ou DaemonSet, qui les recrée si on les supprime.

Le schéma montre la boucle. Regardez les deux flèches en pointillé : supprimer le compte et sa liaison seuls n'a d'effet que jusqu'au prochain passage de la charge planifiée, alors que supprimer la charge planifiée en premier coupe la boucle.

La charge planifiée de l'attaquant, CronJob ou DaemonSet, recrée à chaque passage un compte de service et sa liaison, qui donnent à l'attaquant le droit de lister les Secrets du cluster. Supprimer le compte et sa liaison seuls est annulé par le retour du compte. Supprimer d'abord la charge planifiée, puis le compte et sa liaison, retire l'accès pour de bon.recrée à chaque passageannulée par le retour ducompteretire l'accès pour de bonCharge planifiée de l'attaquantCronJob ou DaemonSetCompte de service et sa liaisondroit de lister les SecretsAccès de l'attaquantaux Secrets du clusterSuppression du compteet de sa liaison seulsSuppression de la charge planifiée,puis du compte et de sa liaison
Source · SVG
Échap pour fermer, + et − pour zoomer, défilement pour se déplacer. 100 %

Dans les labs de la formation (Kubernetes 1.37.2, essais du 2026-11-14), un compte de service et sa liaison supprimés seuls reviennent avec le droit de lister les Secrets du cluster. La charge du challenge de fin de module (leçon suivante) recrée l'accès en quelques secondes, et le CronJob du lab guidé de cette leçon le recrée à chaque minute. Ces rythmes dépendent de la charge qui recrée, pas de Kubernetes : un attaquant choisit le sien, de quelques secondes à plusieurs heures. C'est pourquoi la vérification, plus bas, attend plus longtemps que le délai le plus long.

Pour repérer une persistance, cherchez ce qui n'existait pas hier. Comparez l'état actuel du cluster à une référence que vous connaissez : le contenu du dépôt Git qui déploie le cluster, ou la liste relevée un jour où tout était sain. Sans référence, un objet de plus parmi des centaines passe inaperçu.

Commencez par les charges qui se relancent seules, dans tous les namespaces :

Fenêtre de terminal
kubectl get cronjobs,daemonsets -A

Regardez la colonne AGE et le nom de chaque objet. Un objet récent, dans un namespace où personne n'a déployé, avec un nom qui imite un composant système, mérite un examen. Passez ensuite aux droits :

Fenêtre de terminal
kubectl get serviceaccounts -A --sort-by=.metadata.creationTimestamp
kubectl get clusterrolebindings -o wide

Le premier tri place les comptes les plus récents en bas de la liste. Dans le second, la colonne SERVICEACCOUNTS dit à quels comptes de service chaque liaison donne son rôle. Une liaison vers cluster-admin ou vers un rôle qui lit les Secrets, donnée à un compte inconnu, est un signal fort.

Pour savoir ce qu'un compte peut vraiment faire, demandez-le au cluster plutôt que de lire les rôles à la main. La commande suivante suppose que vous avez le droit d'usurper une identité, ce qu'un administrateur a. Remplacez app-prod par le namespace du compte et compte-suspect par son nom :

Fenêtre de terminal
kubectl auth can-i list secrets --all-namespaces \
--as=system:serviceaccount:app-prod:compte-suspect

La réponse est yes ou no. Un yes sur un compte qu'aucune application n'utilise signale un accès que quelqu'un a créé pour s'en servir. Terminez par les points d'entrée du cluster, que les deux premières commandes ne voient pas :

Fenêtre de terminal
kubectl get validatingwebhookconfigurations,mutatingwebhookconfigurations
kubectl get secrets -A --field-selector type=kubernetes.io/service-account-token
kubectl get events -A --sort-by=.metadata.creationTimestamp

Les webhooks installés par vos outils (cert-manager, un moteur de politiques) sont attendus ; tout autre est à examiner. Un Secret de type kubernetes.io/service-account-token n'est plus créé automatiquement : tout ce que la commande liste a été demandé à la main, ou hérité d'un ancien cluster, et chaque jeton doit avoir un propriétaire connu. Les événements montrent les Jobs et Pods créés récemment, mais ils ne restent qu'environ une heure par défaut : pour une enquête plus ancienne, le journal d'audit prend le relais, à condition que le cluster l'ait activé.

Comment dater et attribuer une création avec le journal d'audit ?

Section intitulée « Comment dater et attribuer une création avec le journal d'audit ? »

Le journal d'audit dit qui a créé l'objet suspect et quand. Chaque ligne du fichier est un événement JSON : user.username dit qui a agi, verb dit quoi, objectRef dit sur quelle ressource. Vous n'avez besoin ici que de ces trois champs.

Ce journal n'est pas actif par défaut, ni avec kubeadm ni avec kind : il n'existe que si l'API server tourne avec les options --audit-policy-file et --audit-log-path. La leçon Audit logs, dans le module « Durcir le cluster », montre comment écrire la politique qui le produit. Sur un cluster managé, il se lit chez le fournisseur. Sinon, il se trouve au chemin donné par --audit-log-path, sur le nœud du plan de contrôle avec kubeadm. La commande suivante demande que jq soit installé. Pour une persistance, filtrez les créations d'objets sensibles :

Fenêtre de terminal
cat audit.log | jq 'select(.verb=="create" and
(.objectRef.resource=="cronjobs" or .objectRef.resource=="daemonsets"
or .objectRef.resource=="clusterrolebindings"))
| {time: .stageTimestamp, user: .user.username,
resource: .objectRef.resource, name: .objectRef.name}'

Regardez user.username. Si les créations viennent d'un utilisateur humain, par exemple kubernetes-admin, le compte administrateur que pose kubeadm, une personne les a faites avec ce certificat. Si elles viennent d'un compte de service (system:serviceaccount:namespace:nom), c'est une charge dans le cluster qui les crée : vous avez trouvé le compte compromis, et vous voyez à quel rythme il recrée. Ce rythme confirme la boucle : si la même liaison est créée toutes les minutes, un CronJob la recrée.

Comment retirer la persistance sans casser l'application ?

Section intitulée « Comment retirer la persistance sans casser l'application ? »

Pour retirer une persistance, supprimez d'abord l'objet qui recrée, puis ce qu'il recréait, après avoir consigné l'état. L'ordre compte : l'inverse laisse la boucle tourner. Voici le geste, avec un exemple où une charge nettoyage-cache du namespace app-prod recrée un compte agent-sauvegarde et sa liaison.

  1. Consignez l'objet avant toute suppression. Exportez-le depuis le cluster vivant, pas depuis un fichier que vous avez écrit : c'est la trace de ce qu'a laissé l'attaquant, avec ses champs creationTimestamp et serviceAccountName.

    Fenêtre de terminal
    kubectl get cronjob nettoyage-cache -n app-prod -o yaml > constat-persistance.yaml
  2. Remontez des Pods vers leur propriétaire si vous partez d'un Pod suspect. Le champ ownerReferences du Pod nomme le Job ou le ReplicaSet qui l'a créé, et le Job nomme à son tour le CronJob.

    Fenêtre de terminal
    kubectl get pod <pod> -n app-prod \
    -o jsonpath='{.metadata.ownerReferences[0].kind}/{.metadata.ownerReferences[0].name}{"\n"}'
  3. Supprimez la charge planifiée. Ses Jobs et ses Pods partent avec elle, car ils en dépendent.

    Fenêtre de terminal
    kubectl delete cronjob nettoyage-cache -n app-prod
  4. Supprimez ensuite le compte de service et la liaison qu'elle recréait. Sans la charge, ils ne reviennent plus.

    Fenêtre de terminal
    kubectl delete clusterrolebinding agent-sauvegarde
    kubectl delete serviceaccount agent-sauvegarde -n app-prod
  5. Considérez comme compromis tout ce que le compte pouvait lire. Un droit de lister les Secrets est un droit de les copier : changez les mots de passe et les clés que ces Secrets contiennent, car supprimer le compte ne les protège plus.

Pour ne pas retirer l'application légitime, ne supprimez que ce que la consignation a identifié, par son nom, et ne lancez jamais de suppression en masse sur un namespace. Les CronJobs, comptes et liaisons de l'application ont leurs propres noms : comparez-les à votre référence avant chaque delete. Le même geste s'applique à un DaemonSet ou à un webhook, en remplaçant le nom de l'objet à l'étape 3.

Pour vérifier le retrait, attendez plus longtemps que le plus long délai de recréation, puis redemandez au cluster. Un CronJob planifié chaque minute recrée l'accès en une minute au plus : deux minutes d'attente suffisent alors. Si la charge supprimée avait un rythme plus lent, attendez plus longtemps encore. Supprimez aussi le Pod d'origine, celui où l'attaquant avait exécuté son code, pour être sûr que rien ne repose sur lui :

Fenêtre de terminal
kubectl delete pod <pod-d-origine> -n app-prod

Après les deux minutes d'attente, redemandez au cluster ce qui existe et ce que le compte peut encore faire :

Fenêtre de terminal
kubectl get cronjobs,daemonsets -A
kubectl get serviceaccount agent-sauvegarde -n app-prod
kubectl auth can-i list secrets --all-namespaces \
--as=system:serviceaccount:app-prod:agent-sauvegarde

Le résultat attendu : plus de charge suspecte, NotFound pour le compte, et no pour le droit de lister les Secrets. Vérifiez enfin que l'application légitime est intacte avec kubectl get deployments -n app-prod : tous ses réplicas doivent être disponibles. Si le compte revient, une autre charge le recrée : reprenez la recherche, sur les DaemonSets et les webhooks en particulier.

Quels contrôles empêchent ou révèlent la persistance ?

Section intitulée « Quels contrôles empêchent ou révèlent la persistance ? »

Quatre contrôles de la formation agissent sur la persistance, chacun à un endroit différent. Le tableau dit pour chacun s'il prévient ou s'il détecte.

ContrôleRôleCe qu'il fait contre la persistanceLeçon
RBAC minimalPrévientSans droit de créer CronJobs, DaemonSets, liaisons ou webhooks, l'attaquant ne peut pas s'installerRBAC
Contrôle d'admissionPrévientUne politique refuse le hostPath, ou la liaison d'un compte à cluster-adminAdmission controllers
Journal d'auditDétecteUne fois activé, garde la trace de qui a créé quoi, et permet de dater la persistanceAudit logs
FalcoDétecteAlerte sur un shell ouvert, et sur les événements d'audit sensibles si on le branche sur le journalFalco

Le RBAC minimal agit avant l'installation : il retire à l'attaquant la capacité de s'ancrer. Kubernetes ajoute une protection : un compte ne peut pas créer une liaison qui donne plus de droits qu'il n'en a, sauf s'il possède le verbe bind (lier un rôle qu'il ne possède pas lui-même) ou escalate (créer ou modifier un rôle avec plus de droits qu'il n'en a). Ne donnez ces verbes à personne par commodité. Les contrôles qui détectent ne retirent rien : l'alerte de Falco ou une ligne d'audit ne remplace pas la suppression de l'objet.

Trois erreurs reviennent.

  • Supprimer d'abord le compte ou le Pod visible. La charge planifiée le recrée, et l'on croit à tort que le cluster est propre.
  • Supprimer sans consigner. Sans l'export de l'objet vivant, on perd ce qui permet de comprendre l'attaque, de dater la compromission et de chercher des objets jumeaux.
  • Oublier les Secrets déjà lus. Retirer l'accès n'annule pas ce que l'attaquant a copié, et seule la rotation des secrets le fait.

Ce lab guidé reprend la démonstration de cette leçon. Un namespace contient une charge planifiée qui recrée en silence l'accès d'un attaquant, à côté d'une application légitime de facturation. Vous listez ce qui est planifié, qui possède quels droits et ce qui a changé récemment, vous consignez l'objet coupable avant de le supprimer, puis vous retirez l'accès. La validation porte sur l'état du cluster : l'objet est consigné, la charge planifiée et les identités de l'attaquant ont disparu, l'accès ne revient pas après la suppression du Pod d'origine, et l'application légitime reste intacte.

  • La persistance est ce que l'attaquant laisse pour garder son accès quand la faille est corrigée et le Pod d'origine supprimé ; elle diffère de l'accès initial et de l'exécution.
  • Les objets qui servent de persistance sont les CronJobs, les DaemonSets, les comptes de service et leurs liaisons, les jetons longue durée, les webhooks d'admission et les Pods statiques.
  • Supprimer le compte ou le Pod visible ne suffit pas : la charge planifiée qui le recrée le ramène à son prochain passage, en quelques secondes ou à la minute suivante dans les labs de la leçon.
  • On repère ce qui est nouveau en comparant le cluster à une référence, avec kubectl get cronjobs,daemonsets -A, kubectl get clusterrolebindings -o wide et kubectl auth can-i, puis on date la création dans le journal d'audit, s'il est activé.
  • L'ordre de retrait est fixe : consigner l'objet, supprimer la charge qui recrée, puis le compte et la liaison, puis changer les secrets que le compte pouvait lire.
  • On vérifie en attendant plus longtemps que le délai de recréation, en supprimant le Pod d'origine et en redemandant le droit au cluster.
  • Le RBAC minimal et l'admission préviennent ; le journal d'audit et Falco détectent, sans rien retirer.

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

8 questions
8 min.
70% requis

Informations

  • Le chronomètre démarre au clic sur Démarrer
  • Questions à choix multiples, vrai/faux et réponses courtes
  • Vous pouvez naviguer entre les questions
  • Les résultats détaillés sont affichés à la fin

Lance le quiz et démarre le chronomètre