Secret opérationnel

Ce que c'est

Un secret opérationnel est une valeur qui permet à un logiciel, ou à
la personne qui l’exploite, d’agir sur un système et qui donne le
même pouvoir à quiconque la lit. Un mot de passe de connexion à une
base de données, un jeton d’API, la partie privée d’une paire de
clés SSH et la phrase secrète qui chiffre une sauvegarde sont tous
des secrets opérationnels. Dans l’usage courant, on parle simplement
de secrets. Leur création, leur stockage, leur renouvellement et
leur destruction constituent la gestion des secrets.

Deux choses les distinguent du code qui les entoure. La première est
leur lecteur. Un mot de passe utilisateur reste dans la mémoire
d’une personne et est saisi à une invite, tandis qu’un secret
opérationnel est lu par un programme, un script de déploiement ou
une tâche planifiée. Personne n’a besoin de le retenir. La fiche
OWASP sur la gestion des secrets lui attribue donc un cycle de vie
propre : génération avec le minimum de privilèges nécessaire,
renouvellement planifié, révocation en cas de fuite possible et
expiration lorsque la plateforme le permet, avec des durées de vie
allant de quelques minutes à plusieurs années. Les mots de passe
utilisateurs ne relèvent pas de ce renouvellement régulier. La
seconde distinction sépare le secret de la configuration qui le
désigne. Un nom d’hôte ou un chemin de dépôt de sauvegarde indique
un emplacement. Le secret est ce qui permet à son détenteur d’y
entrer et dont il faut compter les copies.

Les secrets s’emboîtent aussi. Le coffre qui les conserve a besoin
de son propre secret. La fiche indique que ce secret principal, par
exemple les identifiants racine d’un fournisseur cloud, doit
généralement être conservé ailleurs.

Pourquoi c'est important

Un secret fonctionne pour quiconque le présente. Un jeton ne porte
aucune trace de la personne censée le détenir : chaque copie élargit
donc l’ensemble des personnes et programmes qui peuvent l’utiliser.
Un dépôt de sources est le pire endroit où il puisse se retrouver.
Chaque clone emporte tout l’historique : une valeur enregistrée une
seule fois dans un commit voyage vers chaque ordinateur portable,
agent de construction et miroir qui récupère les changements. Elle
reste dans cet historique après la suppression de la ligne qui la
contenait.

Les référentiels en font des exigences. L’Application Security
Verification Standard d’OWASP demande une solution de gestion des
secrets, comme un coffre de clés, pour créer, stocker, contrôler
l’accès aux secrets du backend et les détruire. Il précise que les
secrets ne doivent figurer ni dans le code source de l’application
ni dans les artefacts de construction. Il demande le moindre
privilège pour leur accès et, à son niveau le plus élevé, leur
expiration et leur renouvellement. NIST SP 800-53 ajoute le
renforcement IA-5(7) : les moyens d’authentification statiques non
chiffrés ne doivent être incorporés ni aux applications ni à
d’autres supports de stockage statiques. Ses indications ferment
aussi une échappatoire : une valeur utilisée exactement telle
qu’elle est stockée compte comme non chiffrée, quel que soit le
fichier qui la contient.

Les compromis sont réels. Un coffre central est un système de plus
qui doit être disponible au moment où l’on en a le plus besoin. La
fiche souligne qu’en cas d’incident, on attend rapidement de
nouveaux identifiants. Partager un secret entre plusieurs services
économise du travail au prix de la traçabilité : après une fuite, on
ne peut pas savoir quel détenteur l’a perdu. La charge de travail
manuelle augmente avec chaque secret supplémentaire, d’où la
préférence de la fiche pour le renouvellement automatisé. Elle
avertit aussi que redémarrer une application laisse fonctionner un
identifiant volé. Seule sa révocation y met fin.

À quoi cela ressemble en pratique

Ce site énonce sa règle sur la page consacrée aux pratiques de
sécurité de l’entreprise : les secrets restent hors du dépôt. Les
identifiants sont conservés dans un coffre de secrets ou dans la
couche de déploiement, hors des sources et de tout ce que produit
une construction. Une analyse automatisée s’exécute à chaque commit
et le bloque lorsqu’elle détecte un secret.

Les notes d’ingénierie du dépôt précisent le fonctionnement.
L’analyseur est gitleaks, exécuté sur l’arbre de travail à chaque
commit, puis à nouveau dans le contrôle qualité complet. Toute
détection impose un arrêt que personne n’est censé contourner par
une liste d’exceptions. Le répertoire des dépendances et les
arborescences de sortie générées sont exclus, car ce sont des copies
entièrement reconstruites. Les notes consignent aussi une
défaillance plus discrète : lorsqu’un fichier disparaît pendant
l’analyse, gitleaks affiche une ligne d’erreur, mais termine quand
même avec succès. La tâche qui le lance échoue donc sur toute ligne
d’erreur. Le site lui-même est statique et ne contient aucun secret
applicatif. Il est déployé par SSH avec des clés conservées par sa
propriétaire.

Maintenir les secrets hors du dépôt les déplace là où ses
vérifications ne peuvent pas les atteindre. Un play de vérification
préalable des secrets pallie cette lacune. Les secrets venaient
d’être séparés par hôte et le code était correct, mais le coffre
chiffré de l’opératrice, conservé sur sa propre machine et invisible
au contrôle qualité obligatoire, contenait encore l’ancienne valeur
pour un seul hôte. La première convergence a atteint l’hôte en
service, exécuté huit tâches puis refusé de poursuivre à la
neuvième, après avoir déjà écrit les paramètres de swap en
production. La réponse a été un play qui ne contacte aucun hôte, ne
collecte aucune information système et exécute les deux mêmes
fichiers de tâches que la convergence réelle sur le coffre, en
environ une seconde, avant toute autre opération de provisionnement.
Réutiliser le code au lieu de reformuler la règle empêche la
vérification et la convergence de diverger. Un mauvais secret
entraîne désormais un refus au bout de deux secondes sur un
ordinateur portable.

La séparation elle-même consiste à attribuer une valeur par hôte à
chaque secret opérationnel. La plateforme n’avait qu’un hôte et
allait en avoir deux. Plusieurs secrets avaient été écrits comme des
valeurs uniques, dont le dépôt de sauvegarde, sa phrase secrète et
un dispositif d’alerte. Chaque valeur est devenue un dictionnaire
indexé par le nom d’hôte de l’inventaire, et deux raisons sont
consignées à côté de la configuration. Une alerte d’absence de
signal partagée entre deux hôtes reste au vert tant que l’un d’eux
continue à donner signe de vie : le second hôte masque donc la
défaillance du premier. Des dépôts restic séparés peuvent avoir des
clés maîtresses distinctes même s’ils utilisent la même phrase
secrète. Mais une personne qui obtient cette phrase et peut lire les
données chiffrées et les fichiers de clés des deux dépôts peut
déverrouiller les deux. Le partage de cette phrase rend donc leur
exposition interdépendante au lieu d’isoler les hôtes. L’hôte
existant figure dans les quatre dictionnaires, avec les champs de
son dépôt et de ses deux dispositifs d’alerte laissés vides. Cela
indique que la structure est en place et que l’opératrice doit
encore fournir les valeurs.

Où les problèmes surviennent

Un secret arrive dans un commit. Un analyseur signale une valeur
dans un diff, ou quelqu’un repère un jeton dans un fichier poussé,
parce qu’il se trouvait dans une configuration ou un jeu de données
de test au moment du commit. La fiche OWASP donne l’ordre de
réparation : révoquer d’abord la valeur exposée, puis la renouveler,
et seulement ensuite la retirer du code ou des journaux. Réécrire
l’historique pour supprimer le commit modifie tous les commits
suivants et casse leurs liens : cela demande donc de la préparation.
La détection doit précéder le commit, dans un hook pre-commit ou
dans l’éditeur, où une détection ne coûte rien.

L’analyse passe au vert sur des fichiers qu’elle n’a jamais lus. Une
exécution réussit alors qu’une partie de l’arbre n’a pas été
examinée : un fichier a disparu pendant le parcours, une exclusion
est trop large ou le secret n’a pas de forme reconnaissable. Les
règles fondées sur des motifs détectent les jetons de format fixe et
laissent passer un mot de passe inventé par une personne. C’est
pourquoi la fiche recommande plusieurs outils. Traitez toute erreur
d’analyseur comme un échec et limitez les exclusions aux copies
recréées par la construction.

Un secret sert à plusieurs détenteurs. Deux hôtes, deux services ou
toute une équipe utilisent la même valeur. Lorsqu’elle fuit, les
journaux ne permettent pas d’identifier la copie concernée et la
remplacer oblige à intervenir chez tous les détenteurs à la fois. SP
800-53 demande de changer les moyens d’authentification des comptes
de groupe ou de rôle à chaque changement dans la liste de leurs
membres. Un secret par détenteur transforme cette opération
coordonnée en un seul remplacement.

Le secret est livré avec la construction ou se retrouve dans un
journal. Une image de conteneur, un script inclus dans un paquet ou
une ligne de débogage emporte la valeur hors de l’endroit où elle
devait rester. L’ASVS cite les artefacts de construction au même
titre que le code source. La fiche demande de garder les secrets
hors des journaux et de les masquer lorsqu’une ligne doit y faire
référence. Analysez ce que produit la construction aussi bien que le
dépôt.

Pour aller plus loin

  * Fiche OWASP sur la gestion des secrets — cycle de vie d’un
secret, détection avant le commit et ordre de réparation après une
fuite.

  * Application Security Verification Standard d’OWASP — les
exigences de gestion des secrets du groupe 13.3 : coffre, moindre
privilège et renouvellement.

  * NIST SP 800-53 Rev. 5 — la gestion des moyens d’authentification
dans IA-5, dont IA-5(7) contre les moyens d’authentification
statiques incorporés.

  * Gitleaks — l’analyseur que ce site exécute sur son arbre de
travail à chaque commit.

hCette page sur le Web	URL:https://engineer.company/fr/glossary/secret/	engineer.company	70
