Cours DevSecOps : du commit à l’attestation vérifiable

Le problème concret : GitHub Actions face à OIDC

La difficulté réelle apparaît lorsque le comportement nominal rencontre les droits, les erreurs et la production.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c11 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme GitHub Actions en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester OIDC, la fixture cours-devsecops-commit-attestation-c11 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à dependency review. L’exploitation surveille alors la transition entre dependency review et SBOM, tandis que la sécurité vérifie que SLSA ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c12 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. Si la vérification de SLSA échoue, le rollback restaure la configuration liée à GitHub Actions, rejoue cours-devsecops-commit-attestation-c12 et compare le nouvel état au témoin produit par OIDC. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à dependency review, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par SBOM et GitHub Actions : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c12 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c13 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme dependency review en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester SBOM, la fixture cours-devsecops-commit-attestation-c13 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SLSA. L’exploitation surveille alors la transition entre SLSA et GitHub Actions, tandis que la sécurité vérifie que OIDC ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c14 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. Si la vérification de OIDC échoue, le rollback restaure la configuration liée à dependency review, rejoue cours-devsecops-commit-attestation-c14 et compare le nouvel état au témoin produit par SBOM. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SLSA, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par GitHub Actions et dependency review : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c14 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c15 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme SLSA en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester GitHub Actions, la fixture cours-devsecops-commit-attestation-c15 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à OIDC. L’exploitation surveille alors la transition entre OIDC et dependency review, tandis que la sécurité vérifie que SBOM ne reçoit ni autorité implicite ni donnée excédentaire.

Frontières de confiance autour de dependency review

Le bon design sépare ce que le modèle propose de ce que l’application autorise et vérifie.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c21 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. La décision finale reste bornée par SBOM et GitHub Actions : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c21 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme OIDC en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester dependency review, la fixture cours-devsecops-commit-attestation-c21 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SBOM.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c22 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. L’exploitation surveille alors la transition entre SLSA et GitHub Actions, tandis que la sécurité vérifie que OIDC ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de GitHub Actions échoue, le rollback restaure la configuration liée à OIDC, rejoue cours-devsecops-commit-attestation-c22 et compare le nouvel état au témoin produit par dependency review. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SBOM, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c23 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. La décision finale reste bornée par GitHub Actions et dependency review : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c23 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme SBOM en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester SLSA, la fixture cours-devsecops-commit-attestation-c23 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à GitHub Actions.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c24 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. L’exploitation surveille alors la transition entre OIDC et dependency review, tandis que la sécurité vérifie que SBOM ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de dependency review échoue, le rollback restaure la configuration liée à SBOM, rejoue cours-devsecops-commit-attestation-c24 et compare le nouvel état au témoin produit par SLSA. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à GitHub Actions, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c25 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. La décision finale reste bornée par dependency review et SLSA : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c25 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme GitHub Actions en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester OIDC, la fixture cours-devsecops-commit-attestation-c25 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à dependency review.

Construire le chemin de décision avec SBOM

Le point de départ n’est pas une fonctionnalité, mais une frontière de décision observable.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c31 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SBOM, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par SLSA et OIDC : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c31 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme dependency review en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c32 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. Pour tester SLSA, la fixture cours-devsecops-commit-attestation-c32 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à GitHub Actions. L’exploitation surveille alors la transition entre GitHub Actions et OIDC, tandis que la sécurité vérifie que dependency review ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de OIDC échoue, le rollback restaure la configuration liée à dependency review, rejoue cours-devsecops-commit-attestation-c32 et compare le nouvel état au témoin produit par SBOM.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c33 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à GitHub Actions, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par OIDC et SBOM : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c33 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme SLSA en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c34 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. Pour tester OIDC, la fixture cours-devsecops-commit-attestation-c34 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à dependency review. L’exploitation surveille alors la transition entre dependency review et SBOM, tandis que la sécurité vérifie que SLSA ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de SBOM échoue, le rollback restaure la configuration liée à SLSA, rejoue cours-devsecops-commit-attestation-c34 et compare le nouvel état au témoin produit par GitHub Actions.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c35 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à dependency review, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par SBOM et GitHub Actions : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c35 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme OIDC en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

8 exercices avec correction

1. Exercice 1 : identifier le contrôle manquant entre GitHub Actions et OIDC. Correction : placer une règle explicite, un refus et une preuve avant l’effet.
2. Exercice 2 : identifier le contrôle manquant entre OIDC et dependency review. Correction : placer une règle explicite, un refus et une preuve avant l’effet.
3. Exercice 3 : identifier le contrôle manquant entre dependency review et SBOM. Correction : placer une règle explicite, un refus et une preuve avant l’effet.
4. Exercice 4 : identifier le contrôle manquant entre SBOM et SLSA. Correction : placer une règle explicite, un refus et une preuve avant l’effet.
5. Exercice 5 : identifier le contrôle manquant entre SLSA et GitHub Actions. Correction : placer une règle explicite, un refus et une preuve avant l’effet.
6. Exercice 6 : identifier le contrôle manquant entre GitHub Actions et OIDC. Correction : placer une règle explicite, un refus et une preuve avant l’effet.
7. Exercice 7 : identifier le contrôle manquant entre OIDC et dependency review. Correction : placer une règle explicite, un refus et une preuve avant l’effet.
8. Exercice 8 : identifier le contrôle manquant entre dependency review et SBOM. Correction : placer une règle explicite, un refus et une preuve avant l’effet.

3 TP

1. TP 1 : construire une fixture cours-devsecops-commit-attestation-lab-1, provoquer un échec contrôlé, corriger et documenter le rollback.
2. TP 2 : construire une fixture cours-devsecops-commit-attestation-lab-2, provoquer un échec contrôlé, corriger et documenter le rollback.
3. TP 3 : construire une fixture cours-devsecops-commit-attestation-lab-3, provoquer un échec contrôlé, corriger et documenter le rollback.

Projet : intégrer les contrôles étudiés dans un pipeline complet, produire les preuves et défendre les compromis devant une revue technique.

Vérifier le comportement de SLSA

Un système exploitable commence par une question simple : qui décide, sur quelles preuves, et que peut-on annuler ?

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c41 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. Si la vérification de OIDC échoue, le rollback restaure la configuration liée à dependency review, rejoue cours-devsecops-commit-attestation-c41 et compare le nouvel état au témoin produit par SBOM. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SLSA, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par GitHub Actions et dependency review : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c41 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c42 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme SLSA en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester GitHub Actions, la fixture cours-devsecops-commit-attestation-c42 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à OIDC. L’exploitation surveille alors la transition entre OIDC et dependency review, tandis que la sécurité vérifie que SBOM ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c43 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. Si la vérification de SBOM échoue, le rollback restaure la configuration liée à SLSA, rejoue cours-devsecops-commit-attestation-c43 et compare le nouvel état au témoin produit par GitHub Actions. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à OIDC, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par dependency review et SLSA : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c43 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c44 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme OIDC en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester dependency review, la fixture cours-devsecops-commit-attestation-c44 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SBOM. L’exploitation surveille alors la transition entre SBOM et SLSA, tandis que la sécurité vérifie que GitHub Actions ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c45 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. Si la vérification de GitHub Actions échoue, le rollback restaure la configuration liée à OIDC, rejoue cours-devsecops-commit-attestation-c45 et compare le nouvel état au témoin produit par dependency review. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SBOM, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par SLSA et OIDC : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c45 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Échecs plausibles, signaux et diagnostic

La difficulté réelle apparaît lorsque le comportement nominal rencontre les droits, les erreurs et la production.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c51 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. L’exploitation surveille alors la transition entre OIDC et dependency review, tandis que la sécurité vérifie que SBOM ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de dependency review échoue, le rollback restaure la configuration liée à SBOM, rejoue cours-devsecops-commit-attestation-c51 et compare le nouvel état au témoin produit par SLSA. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à GitHub Actions, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c52 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. La décision finale reste bornée par dependency review et SLSA : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c52 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme GitHub Actions en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester OIDC, la fixture cours-devsecops-commit-attestation-c52 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à dependency review.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c53 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. L’exploitation surveille alors la transition entre SBOM et SLSA, tandis que la sécurité vérifie que GitHub Actions ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de SLSA échoue, le rollback restaure la configuration liée à GitHub Actions, rejoue cours-devsecops-commit-attestation-c53 et compare le nouvel état au témoin produit par OIDC. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à dependency review, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c54 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. La décision finale reste bornée par SLSA et OIDC : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c54 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme dependency review en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester SBOM, la fixture cours-devsecops-commit-attestation-c54 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SLSA.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c55 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. L’exploitation surveille alors la transition entre GitHub Actions et OIDC, tandis que la sécurité vérifie que dependency review ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de OIDC échoue, le rollback restaure la configuration liée à dependency review, rejoue cours-devsecops-commit-attestation-c55 et compare le nouvel état au témoin produit par SBOM. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SLSA, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Déploiement progressif et retour arrière

Le bon design sépare ce que le modèle propose de ce que l’application autorise et vérifie.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c61 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. Pour tester OIDC, la fixture cours-devsecops-commit-attestation-c61 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à dependency review. L’exploitation surveille alors la transition entre dependency review et SBOM, tandis que la sécurité vérifie que SLSA ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de SBOM échoue, le rollback restaure la configuration liée à SLSA, rejoue cours-devsecops-commit-attestation-c61 et compare le nouvel état au témoin produit par GitHub Actions.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c62 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à dependency review, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par SBOM et GitHub Actions : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c62 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme OIDC en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c63 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. Pour tester SBOM, la fixture cours-devsecops-commit-attestation-c63 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SLSA. L’exploitation surveille alors la transition entre SLSA et GitHub Actions, tandis que la sécurité vérifie que OIDC ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de GitHub Actions échoue, le rollback restaure la configuration liée à OIDC, rejoue cours-devsecops-commit-attestation-c63 et compare le nouvel état au témoin produit par dependency review.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c64 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SLSA, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par GitHub Actions et dependency review : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c64 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme SBOM en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c65 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. Pour tester GitHub Actions, la fixture cours-devsecops-commit-attestation-c65 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à OIDC. L’exploitation surveille alors la transition entre OIDC et dependency review, tandis que la sécurité vérifie que SBOM ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de dependency review échoue, le rollback restaure la configuration liée à SBOM, rejoue cours-devsecops-commit-attestation-c65 et compare le nouvel état au témoin produit par SLSA.

Critères de décision pour la production

Le point de départ n’est pas une fonctionnalité, mais une frontière de décision observable.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c71 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme OIDC en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester dependency review, la fixture cours-devsecops-commit-attestation-c71 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SBOM. L’exploitation surveille alors la transition entre SBOM et SLSA, tandis que la sécurité vérifie que GitHub Actions ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c72 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. Si la vérification de GitHub Actions échoue, le rollback restaure la configuration liée à OIDC, rejoue cours-devsecops-commit-attestation-c72 et compare le nouvel état au témoin produit par dependency review. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SBOM, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par SLSA et OIDC : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c72 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c73 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme SBOM en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester SLSA, la fixture cours-devsecops-commit-attestation-c73 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à GitHub Actions. L’exploitation surveille alors la transition entre GitHub Actions et OIDC, tandis que la sécurité vérifie que dependency review ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c74 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. Si la vérification de dependency review échoue, le rollback restaure la configuration liée à SBOM, rejoue cours-devsecops-commit-attestation-c74 et compare le nouvel état au témoin produit par SLSA. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à GitHub Actions, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par OIDC et SBOM : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c74 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c75 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme GitHub Actions en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester OIDC, la fixture cours-devsecops-commit-attestation-c75 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à dependency review. L’exploitation surveille alors la transition entre dependency review et SBOM, tandis que la sécurité vérifie que SLSA ne reçoit ni autorité implicite ni donnée excédentaire.

Contrôles à conserver après la mise en service

Un système exploitable commence par une question simple : qui décide, sur quelles preuves, et que peut-on annuler ?

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c81 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. La décision finale reste bornée par SLSA et OIDC : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c81 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme dependency review en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester SBOM, la fixture cours-devsecops-commit-attestation-c81 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SLSA.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c82 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. L’exploitation surveille alors la transition entre GitHub Actions et OIDC, tandis que la sécurité vérifie que dependency review ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de OIDC échoue, le rollback restaure la configuration liée à dependency review, rejoue cours-devsecops-commit-attestation-c82 et compare le nouvel état au témoin produit par SBOM. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SLSA, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c83 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. La décision finale reste bornée par OIDC et SBOM : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c83 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme SLSA en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester GitHub Actions, la fixture cours-devsecops-commit-attestation-c83 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à OIDC.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c84 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. L’exploitation surveille alors la transition entre dependency review et SBOM, tandis que la sécurité vérifie que SLSA ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de SBOM échoue, le rollback restaure la configuration liée à SLSA, rejoue cours-devsecops-commit-attestation-c84 et compare le nouvel état au témoin produit par GitHub Actions. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à OIDC, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c85 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. La décision finale reste bornée par SBOM et GitHub Actions : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c85 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme OIDC en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester dependency review, la fixture cours-devsecops-commit-attestation-c85 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SBOM.

Exercices guidés et corrections

La difficulté réelle apparaît lorsque le comportement nominal rencontre les droits, les erreurs et la production.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c91 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SLSA, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par GitHub Actions et dependency review : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c91 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme SBOM en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c92 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. Pour tester GitHub Actions, la fixture cours-devsecops-commit-attestation-c92 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à OIDC. L’exploitation surveille alors la transition entre OIDC et dependency review, tandis que la sécurité vérifie que SBOM ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de dependency review échoue, le rollback restaure la configuration liée à SBOM, rejoue cours-devsecops-commit-attestation-c92 et compare le nouvel état au témoin produit par SLSA.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c93 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à OIDC, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par dependency review et SLSA : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c93 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme GitHub Actions en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c94 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. Pour tester dependency review, la fixture cours-devsecops-commit-attestation-c94 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SBOM. L’exploitation surveille alors la transition entre SBOM et SLSA, tandis que la sécurité vérifie que GitHub Actions ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de SLSA échoue, le rollback restaure la configuration liée à GitHub Actions, rejoue cours-devsecops-commit-attestation-c94 et compare le nouvel état au témoin produit par OIDC.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c95 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SBOM, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par SLSA et OIDC : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c95 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme dependency review en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Trois TP progressifs

Le bon design sépare ce que le modèle propose de ce que l’application autorise et vérifie.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c101 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. Si la vérification de dependency review échoue, le rollback restaure la configuration liée à SBOM, rejoue cours-devsecops-commit-attestation-c101 et compare le nouvel état au témoin produit par SLSA. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à GitHub Actions, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par OIDC et SBOM : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c101 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c102 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme GitHub Actions en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester OIDC, la fixture cours-devsecops-commit-attestation-c102 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à dependency review. L’exploitation surveille alors la transition entre dependency review et SBOM, tandis que la sécurité vérifie que SLSA ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c103 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. Si la vérification de SLSA échoue, le rollback restaure la configuration liée à GitHub Actions, rejoue cours-devsecops-commit-attestation-c103 et compare le nouvel état au témoin produit par OIDC. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à dependency review, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par SBOM et GitHub Actions : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c103 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c104 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme dependency review en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester SBOM, la fixture cours-devsecops-commit-attestation-c104 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SLSA. L’exploitation surveille alors la transition entre SLSA et GitHub Actions, tandis que la sécurité vérifie que OIDC ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c105 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. Si la vérification de OIDC échoue, le rollback restaure la configuration liée à dependency review, rejoue cours-devsecops-commit-attestation-c105 et compare le nouvel état au témoin produit par SBOM. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SLSA, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par GitHub Actions et dependency review : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c105 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Projet de synthèse et critères d’évaluation

Le point de départ n’est pas une fonctionnalité, mais une frontière de décision observable.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c111 part de GitHub Actions et traite OIDC comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à dependency review de produire un résultat observable avant que SBOM puisse déclencher l’effet attendu autour de SLSA. L’exploitation surveille alors la transition entre dependency review et SBOM, tandis que la sécurité vérifie que SLSA ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de SBOM échoue, le rollback restaure la configuration liée à SLSA, rejoue cours-devsecops-commit-attestation-c111 et compare le nouvel état au témoin produit par GitHub Actions. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à OIDC, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c112 part de OIDC et traite dependency review comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SBOM de produire un résultat observable avant que SLSA puisse déclencher l’effet attendu autour de GitHub Actions. La décision finale reste bornée par SBOM et GitHub Actions : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c112 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme OIDC en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester dependency review, la fixture cours-devsecops-commit-attestation-c112 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à SBOM.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c113 part de dependency review et traite SBOM comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à SLSA de produire un résultat observable avant que GitHub Actions puisse déclencher l’effet attendu autour de OIDC. L’exploitation surveille alors la transition entre SLSA et GitHub Actions, tandis que la sécurité vérifie que OIDC ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de GitHub Actions échoue, le rollback restaure la configuration liée à OIDC, rejoue cours-devsecops-commit-attestation-c113 et compare le nouvel état au témoin produit par dependency review. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à SBOM, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c114 part de SBOM et traite SLSA comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à GitHub Actions de produire un résultat observable avant que OIDC puisse déclencher l’effet attendu autour de dependency review. La décision finale reste bornée par GitHub Actions et dependency review : ce qui n’est pas démontré par le scénario cours-devsecops-commit-attestation-c114 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Construire un pipeline pédagogique complet combinant revue de dépendances, OIDC, SBOM et provenance SLSA. Elle transforme SBOM en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester SLSA, la fixture cours-devsecops-commit-attestation-c114 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à GitHub Actions.

Dans « Cours DevSecOps : du commit à l’attestation vérifiable », le scénario cours-devsecops-commit-attestation-c115 part de SLSA et traite GitHub Actions comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OIDC de produire un résultat observable avant que dependency review puisse déclencher l’effet attendu autour de SBOM. L’exploitation surveille alors la transition entre OIDC et dependency review, tandis que la sécurité vérifie que SBOM ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de dependency review échoue, le rollback restaure la configuration liée à SBOM, rejoue cours-devsecops-commit-attestation-c115 et compare le nouvel état au témoin produit par SLSA. Ce niveau de détail rend « Cours DevSecOps : du commit à l’attestation vérifiable » révisable : chaque affirmation opérationnelle renvoie à GitHub Actions, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Checklist opérationnelle

• Le contrôle autour de GitHub Actions a une entrée, une règle, un refus et une preuve.
• Le contrôle autour de OIDC a une entrée, une règle, un refus et une preuve.
• Le contrôle autour de dependency review a une entrée, une règle, un refus et une preuve.
• Le contrôle autour de SBOM a une entrée, une règle, un refus et une preuve.
• Le contrôle autour de SLSA a une entrée, une règle, un refus et une preuve.