Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Les faits de rattachement que lit une politique de gouvernance

Un plugin de gouvernance rattaché au rôle ir-verdict reçoit le graphe de build entier, et chaque rattachement de Feature du build arrive avec lui. Chaque rattachement porte un ensemble fixe de faits sur lui-même : quelle Feature il nomme, quel emplacement il remplit, sur quelle connexion il a été écrit, lorsqu’il a été écrit sur l’une d’elles, quelle FeatureRecipe le réalise, ce que l’auteur du catalogue a déclaré à son sujet, ce qu’un auteur y a écrit, et s’il manipule du contenu que quelqu’un a déclaré sensible. Une chose n’arrive pas telle qu’écrite : une valeur qu’un auteur a déclarée sensible arrive retenue — voir Les valeurs déclarées sensibles arrivent retenues.

Cette page énumère ces faits et dit ce que chacun affirme et n’affirme pas. Pour le socket lui-même — les quatre rôles, les niveaux de gravité des verdicts, le canal d’entrée de l’opérateur et les deux moteurs de politiques livrés dans le compilateur — voir policy-socket.md. Pour la table champ par champ avec les types et le caractère obligatoire, voir la référence du schéma du graphe générée ; cette page enseigne comment lire les faits, et cette page-là est le contrat.

Où se trouvent les rattachements dans la charge utile

Les rattachements sont accrochés au graphe de build sous feature_values_mapping, avec pour clé l’identifiant du nœud puis le nom d’instance que l’auteur a donné à chaque rattachement :

input.graph.spec.feature_values_mapping[<node id>][<attachment name>]

Le nom du rattachement est porteur de sens plutôt que décoratif. C’est la clé par laquelle un auteur remplit un emplacement, donc c’est aussi ce que le compilateur apparie aux emplacements déclarés du Component hôte.

Un rattachement écrit sur l’une des connexions d’un composant — sous features: sur une entrée uses, dans l’Aggregate ou dans la Release — est l’un des rattachements du composant consommateur, il se trouve donc dans le même compartiment, sur le nœud du composant consommateur. Sa clé est le nom que lui donne le compilateur, l’alias de la connexion et l’emplacement joints par un point : gpt.credential pour l’emplacement credential de la connexion écrite sous l’alias gpt. Le point n’apparaît jamais dans un nom qu’écrit un auteur, de sorte que cette clé n’est jamais égale au nom de l’un des rattachements propres du nœud. Une politique ne lit pas pour autant la connexion dans la clé : l’entrée la porte comme donnée, dans connection ci-dessous.

package security
import rego.v1
deny contains msg if {
some node_id, attachments in input.graph.spec.feature_values_mapping
some name, attachment in attachments
attachment.binding == "free"
msg := sprintf("%v carries attachment %v, which fills no declared slot.", [node_id, name])
}

Seul ir-verdict voit ces faits. Une politique render-verdict reçoit les artefacts rendus et aucun graphe ; une politique label-transform reçoit une projection des labels et des valeurs des nœuds, ses valeurs déclarées sensibles retenues comme ici, qui ne porte aucun rattachement ; une politique annotation-transform reçoit les composants qu’elle peut annoter. Une règle qui lit des faits de rattachement a sa place à ir-verdict, et la déplacer vers un autre rôle produit une règle qui ne se déclenche jamais plutôt qu’une erreur, car un chemin qui n’existe pas est simplement indéfini.

Un seul compartiment, toutes les familles de rattachements

Chaque rattachement d’un nœud se trouve dans le même compartiment, quoi que produise sa Feature — une Feature opérationnelle, une Feature d’identifiants, une Feature d’identité. Aucune famille ne reçoit une projection plus étroite qu’une autre, de sorte qu’une politique qui parcourt le compartiment les voit toutes et n’a jamais besoin de savoir quelle famille elle regarde avant de pouvoir lire un fait.

Identité : type et resolved_version

type est l’URI de la Feature du catalogue que nomme le rattachement. resolved_version est la version exacte sur laquelle la résolution s’est arrêtée pour ce build. Les deux sont toujours présents.

Métadonnées du catalogue, reportées telles quelles : labels et catalog_annotations

labels sont les propres metadata.labels de l’entité Feature rattachée. catalog_annotations sont les propres metadata.annotations de cette entité. Les deux sont portés dans l’ordre où l’entité du catalogue les déclare, et aucun n’est filtré, normalisé ni dépouillé de son préfixe — une clé dans le propre namespace de l’auteur du catalogue arrive exactement telle qu’écrite, et le compilateur n’en lit aucune.

C’est ce report tel quel qui permet de fonder une politique sur un label dont le compilateur n’a aucune raison de connaître l’existence. Un auteur de catalogue qui marque les Features d’identifiants avec un label de sa propre invention peut écrire une règle directement sur ce label.

Chacun est absent du rattachement lorsque la Feature n’en déclare aucun, et lorsque son type ne se résout en aucune entité du catalogue.

catalog_annotations décrit l’entité que nomme le rattachement. C’est une question différente de annotation_key et annotation_source ci-dessous, qui décrivent comment le rattachement est apparu. Un rattachement écrit dans un bloc features: porte des annotations de catalogue sans porter aucun des deux autres.

Quel emplacement remplit le rattachement : binding

binding a trois réponses, et la troisième n’est pas une variante de la deuxième :

ValeurSignification
un nom d’emplacementLe rattachement remplit l’emplacement de rattachement déclaré portant ce nom.
freeLe rattachement ne remplit aucun emplacement déclaré. C’est un constat positif : l’ensemble des emplacements a été résolu et aucun emplacement déclaré ne porte ce nom.
absentL’ensemble des emplacements déclarés du Component hôte n’a pas pu être résolu, donc on ne sait pas quel emplacement est rempli.

L’ensemble d’emplacements déclarés dont provient le nom dépend de l’endroit où le rattachement a été écrit. Un rattachement du bloc propre du nœud remplit un emplacement que le Component hôte déclare dans son propre featuresSchema. Un rattachement écrit sur une connexion — un rattachement portant connection ci-dessous — remplit un emplacement que déclare le socket de la connexion, dans le featuresSchema de ce socket sur le Component hôte. Ainsi, la même valeur, credential, nomme un emplacement du Component sur un rattachement et un emplacement d’un socket sur un autre, et c’est connection qui les distingue.

L’appariement se fait par nom — un rattachement remplit un emplacement lorsque la Feature est rattachée sous le nom de l’emplacement, sur le bloc du composant ou sur la connexion — donc la valeur est une clé exacte de l’ensemble des emplacements déclarés. Rien n’est lu dans la clé du rattachement : le rattachement d’une connexion a pour clé gpt.credential et rapporte credential. Le nom de l’emplacement est porté plutôt qu’un simple indicateur parce que quel emplacement a été rempli est la moitié la plus utile de la réponse.

Un rattachement écrit sur une connexion ne rapporte jamais free. Les emplacements d’un socket sont les seuls noms qu’une connexion passant par lui peut porter, et une connexion portant tout autre nom est refusée au chargement du build, de sorte que chacun de ces rattachements, dans un graphe qui atteint une politique, remplit un emplacement déclaré.

Une politique qui traite un binding absent comme free rapportera une inconnue comme un constat. Testez free explicitement.

Sur quelle connexion le rattachement a été écrit : connection

connection est présent sur chaque rattachement écrit sur l’une des connexions du nœud, et absent sur chaque rattachement du bloc propre du nœud. Il porte deux champs, les coordonnées de cette connexion sur le nœud :

ChampSignification
socketLe socket par lequel la connexion est reliée.
aliasL’alias sous lequel la connexion est écrite.

La paire nomme l’une des arêtes du graphe : l’arête dont le source est le nœud portant le rattachement et dont le socket et l’alias sont ceux-ci. Le target de cette arête est le composant auquel le rattachement est présenté. Ainsi, une politique joint un rattachement à ce qu’il atteint — ce qu’aucun fait sur le rattachement seul ne peut dire, car le rattachement se trouve sur le nœud consommateur :

package security
import rego.v1
deny contains msg if {
some node_id, attachments in input.graph.spec.feature_values_mapping
some name, attachment in attachments
attachment.labels["feature.aggrega.ai/kind"] == "secret"
some edge in input.graph.spec.edges
edge.source == node_id
edge.socket == attachment.connection.socket
edge.alias == attachment.connection.alias
input.graph.spec.nodes[edge.target].labels["example.com/trust-zone"] == "external"
msg := sprintf("%v presents the credential %v to %v, outside the trust zone.", [node_id, name, edge.target])
}

Ce que connection affirme, et ce qu’il n’affirme pas :

  • Il enregistre où l’auteur a écrit le rattachement. Il est renseigné à partir de la connexion sur laquelle le rattachement a été écrit, jamais extrait de la clé du rattachement, de sorte qu’il contient le socket — que la clé ne porte pas — ainsi que l’alias.
  • Il ne porte pas l’emplacement. L’emplacement du socket que remplit le rattachement est binding, lu de la même façon que pour tout rattachement ; l’emplacement est rapporté une seule fois, là.
  • Il ne décrit pas la cible. La cible, ses labels et qui a relié l’arête — le développeur, la Release ou une Feature — sont des faits de l’arête et du nœud cible, lus là après la jointure.
  • Une connexion que trace une Feature ne porte aucun rattachement, de sorte qu’aucun rattachement ne porte de connection nommant une telle arête. Un identifiant dont a besoin la connexion propre d’une Feature est un rattachement remplissant un emplacement que la Feature déclare, et il ne porte aucune connection.
  • Absent signifie le bloc propre du nœud. Un rattachement sans connection a été écrit dans les propres features: du composant (ou l’a atteint depuis une portée plus large ou par expansion pilotée par les annotations). Ce n’est pas un constat que le rattachement n’est présenté à aucun autre composant : ce qu’atteint l’identifiant propre d’un composant est décidé par la façon dont sa livraison est reliée, que ce champ ne décrit pas.

Hormis le fait de décider dans quel ensemble d’emplacements déclarés sont lus binding et la moitié emplacement de sensitive, connection ne change rien au rattachement : sa FeatureRecipe, son contrat provides, le reste de ses faits et sa place dans le compartiment sont ceux de tout rattachement que porte le nœud.

Quelle FeatureRecipe réalise le rattachement : realization

realization nomme la FeatureRecipe que le Manifest de la Release lie au rattachement, sous la forme <name>:<version>. Le Manifest lie par le propre nom du rattachement lorsque son niveau name fait correspondre ce nom — pour un rattachement écrit sur une connexion, son nom qualifié, gpt.credential ci-dessus — et sinon par le type de Feature que nomme le rattachement. La FeatureRecipe nommée est celle avec laquelle un build des mêmes documents rend le rattachement : le graphe enregistre la liaison avant que quoi que ce soit ne soit rendu, et le rendu lie le rattachement de la même façon.

package security
import rego.v1
approved_realizations := {"approved-credential:1.0.0"}
deny contains msg if {
some node_id, attachments in input.graph.spec.feature_values_mapping
some name, attachment in attachments
attachment.labels["feature.aggrega.ai/kind"] == "secret"
realization := attachment.realization
not realization in approved_realizations
msg := sprintf("%v realizes the credential %v with %v, which is not an approved FeatureRecipe.",
[node_id, name, realization])
}

Ce que realization affirme, et ce qu’il n’affirme pas :

  • C’est la même paire partout où elle apparaît. aggrega inspect l’affiche comme la réalisation du rattachement, et lorsqu’une cible appose la provenance sur ce qu’elle rend, les documents que rend cette FeatureRecipe la portent comme valeur de aggrega.ai/recipe-uri, de sorte qu’une politique joint un rattachement à ce qu’il rend sans traduire entre des formes.
  • Il nomme la FeatureRecipe par nom et version, pas par capacité. Deux capacités peuvent chacune publier une FeatureRecipe sous un même nom et une même version. Laquelle est liée est réglé par la correspondance du Manifest, qui nomme la capacité partout où le nom seul serait ambigu ; ce champ ne le répète pas.
  • Les rattachements propres d’une frontière de Release le portent aussi, sous boundary_features, lus de la même façon. Un rattachement au niveau d’une frontière atteint aussi chaque composant que contient la frontière, et y porte la même réalisation.
  • Absent signifie lié à rien. Un rattachement que le Manifest ne lie à aucune FeatureRecipe que contient le catalogue ne porte aucune realization. Un build d’une telle composition s’arrête avant de rendre, en nommant le rattachement sans correspondance — mais une politique à ce rôle est interrogée avant cet arrêt, elle peut donc rencontrer un rattachement qui n’en porte aucune. La règle ci-dessus laisse passer un tel rattachement, car son corps lie d’abord realization ; une règle qui veut le rapporter teste explicitement la clé manquante.

Comment le rattachement est apparu : origin et ses deux compagnons

origin distingue un rattachement qu’un développeur a saisi d’un rattachement que l’expansion pilotée par les annotations a produit :

ValeurSignification
explicitRédigé dans un bloc features:.
annotationProduit par l’expansion pilotée par les annotations.
mixedLes feuilles de valeurs ou d’infra du rattachement portent un mélange des deux ; le détail par feuille se trouve dans les tables de provenance.

annotation_key nomme l’annotation qui a déclenché un rattachement synthétique, et annotation_source localise sa déclaration sous la forme <release-file-path>:<dotted-yaml-key-path>. Les deux sont absents lorsque origin vaut explicit.

Les charges utiles rédigées : values, infra et inject

values est la configuration opérationnelle du rattachement — le domaine du développeur. infra est son dimensionnement physique par instance — celui de l’opérateur. inject est le routage d’injection agnostique, qui fait correspondre les clés de livraison aux clés provides à partir desquelles elles se remplissent, avec pour première clé le mécanisme de livraison.

Ce que porte le values d’un rattachement d’identifiants est le choix de l’auteur, et le compilateur porte ce qui a été écrit sans résoudre l’un ou l’autre : un identifiant par référence porte un pointeur vers un magasin de secrets, et un identifiant par valeur porte le contenu lui-même. Quoi qu’il en soit, une feuille que la Feature rattachée déclare sensible atteint une politique retenue, comme le décrit la section suivante ; une feuille qu’elle laisse non déclarée, comme un localisateur publié, arrive telle qu’écrite.

Les valeurs déclarées sensibles arrivent retenues

Chaque feuille que le graphe marque comme déclarée sensible arrive à ce socket sous la forme d’un marqueur de rétention plutôt que de la valeur qu’un auteur a écrite. Le marqueur est un objet à clé unique qui porte la raison pour laquelle la valeur est absente :

{ "aggrega_withheld": "declared" }

declared signifie qu’une déclaration couvre la feuille. Une charge utile qui n’a pas pu être lue du tout est retenue en entier, avec la raison unreadable, parce qu’aucune feuille qu’elle contient n’a pu être jugée.

La rétention suit les marquages propres du graphe, si bien qu’elle atteint exactement les feuilles qu’ils nomment, où qu’elles se trouvent :

  • les values et l’infra de chaque rattachement, quelle que soit la portée qui a écrit le rattachement — le bloc propre du composant, un sous-système, une frontière ou la Release, une expansion pilotée par les annotations — et qu’il ait été écrit sur le bloc propre du nœud ou sur l’une de ses connexions, selon les feuilles que nomme son sensitive_payload_leaves ;
  • l’infra d’un rattachement au niveau d’une frontière, sous boundary_features, selon son propre marquage ;
  • les values et l’infra propres d’un nœud, sous values_mapping et infra_mapping, selon le sensitive_payload_leaves propre du nœud ;
  • les values et l’infra propres d’une connexion, sur l’arête et dans l’entrée uses du nœud consommateur, selon le sensitive_payload_leaves de l’arête, qui nomme les feuilles que le socket du composant consommateur déclare sensibles.

Ce sur quoi raisonne une politique est intact. Le type, la version résolue, les labels, les annotations de catalogue, binding, connection, realization, origin et ses tables de provenance, les trois faits de sensibilité et chaque feuille qu’aucune déclaration ne marque arrivent tels qu’écrits. La clé d’une feuille retenue subsiste aussi, si bien qu’une politique voit toujours quelles feuilles porte une charge utile et lesquelles d’entre elles portent du contenu déclaré — seule la valeur est absente. Une règle sur l’endroit où transite le contenu déclaré sensible, et par quel chemin, est donc entièrement exprimable ; une règle portant sur la teneur de ce contenu ne l’est pas, par conception.

Le bloc uses écrit par l’auteur d’un nœud, porté sur le nœud à côté de ses arêtes, ne garde de chaque rattachement écrit sur une connexion que son type et sa description. Les valeurs du rattachement sont portées une seule fois, sur le rattachement lui-même, là où la rétention les atteint.

Une politique qui veut distinguer une feuille retenue d’une feuille écrite par l’auteur teste la présence de la clé du marqueur :

package security
import rego.v1
audit contains msg if {
some node_id, attachments in input.graph.spec.feature_values_mapping
some name, attachment in attachments
some key, value in attachment.values
is_object(value)
value.aggrega_withheld
msg := sprintf("%v/%v writes a declared-sensitive value at values.%v.", [node_id, name, key])
}

C’est la même rétention que celle qu’applique --ir-graph lorsqu’une commande affiche le graphe et qu’applique aggrega/irGraph du démon lorsqu’il répond à un client, si bien qu’une politique et une personne qui lit le graphe voient les mêmes feuilles retenues. Ces surfaces rendent les valeurs à une personne qui les demande avec --unredacted ; la charge utile que reçoit une politique n’offre pas une telle demande, et les valeurs déclarées propres d’un nœud y sont retenues aux mêmes conditions que celles d’un rattachement. Elle s’applique à la charge utile que reçoit une politique et à rien d’autre : le graphe à partir duquel le build effectue le rendu n’est pas modifié, si bien que la rétention ne change aucun octet rendu. Rien n’est retenu de ce que reçoit une politique render-verdict, parce que les artefacts rendus sont ce que ce rôle juge.

D’où vient chaque feuille : values_provenance et infra_provenance

Chacune a pour clé le chemin pointé de la feuille dans son pilier, et chaque entrée enregistre l’origin de cette feuille — la même distinction explicit / annotation, appliquée une feuille à la fois. Une feuille apportée par une annotation porte en outre la surface de rédaction sur laquelle elle a été déclarée, la clé d’annotation qui l’a apportée et la position dans la source de cette déclaration. Là où une feuille explicite a écrasé une feuille apportée par une annotation, l’entrée porte aussi la contribution supprimée qu’elle a remplacée, si bien qu’une politique peut voir ce qui a été écrasé et non seulement ce qui l’a emporté.

Les trois unités de sensibilité

La charge utile porte trois faits de sensibilité, et ils se situent à trois unités différentes : un rattachement entier, une clé de livraison, une feuille de la charge utile.

Chacun est calculé à partir de ses propres entrées. Aucun n’est dérivé d’un autre, et en particulier la réponse par rattachement n’est jamais propagée vers les unités plus étroites. Confondre deux d’entre eux produit une politique erronée dans une direction qui échoue silencieusement ; il vaut donc la peine de lire les trois séparément avant d’écrire une règle portant sur l’un d’eux.

Chacun d’eux est dérivé de ce qu’un auteur a déclaré — sensitive: true sur une feuille du schéma d’une Feature, ou sensitive: true sur un emplacement de rattachement qu’un Component déclare, pour ses propres rattachements ou sur l’un de ses sockets. Le contenu d’aucune valeur n’est inspecté, et aucun sens n’est tiré du nom d’un champ.

sensitive — une réponse pour tout le rattachement

Vrai lorsque soit la Feature rattachée déclare une feuille sensible dans ses values, son infra ou ses provides, soit l’emplacement que remplit le rattachement déclare que quoi que ce soit qui le lie manipule du contenu secret — l’emplacement de rattachement du même nom du Component hôte ou, pour un rattachement portant connection, l’emplacement de ce nom que déclare le socket de la connexion. Non défini lorsqu’aucune des deux déclarations n’est présente.

Ceci répond à ce qu’est l’entité, et ne varie donc délibérément pas selon ce qu’un auteur particulier a écrit. Il lit les déclarations de la Feature plutôt que le sous-ensemble de feuilles sensibles que ce rattachement s’est trouvé remplir, parce qu’un champ sensible dans une Release et pas dans une autre serait inutilisable pour une politique qui raisonne sur l’entité de catalogue.

Les deux moitiés sont indépendantes, et chacune tient seule. Une Feature qui ne déclare aucune feuille sensible lie quand même un emplacement sensible en tant que rattachement sensible, parce que l’emplacement l’a dit. Un remplissage qui déclare une feuille sensible est un rattachement sensible même lorsque l’emplacement n’a fait aucune déclaration de ce genre, et même lorsqu’il s’agit d’un rattachement libre qui ne lie aucun emplacement.

sensitive_inject — une réponse par clé de livraison

Le sous-ensemble de inject dont la clé provides référencée est déclarée sensible par la Feature rattachée, porté dans la forme propre de inject : mécanisme, puis clé de livraison, avec la clé provides référencée comme valeur.

Une clé de livraison remplie à partir d’une clé provides que la Feature a marquée sensible apparaît ici ; une clé remplie à partir d’une clé non marquée n’y apparaît pas, même sur le même rattachement et avec le même mécanisme. Absent lorsque le rattachement ne déclare aucun mécanisme de livraison, ou ne référence aucune clé provides sensible.

sensitive_payload_leaves — une réponse par feuille de la charge utile

Les feuilles que porte la charge utile de ce rattachement dont la Feature rattachée déclare le chemin sensible, chacune sous la forme du chemin pointé, préfixé par le pilier, qu’occupe la donnée : values.<path> ou infra.<path>.

La charge utile lue ici est celle que le rattachement finit par porter, pas le bloc qu’un auteur a écrit. Une feuille qui se trouve à une valeur que le schéma de la Feature déclare comme default est nommée au même titre qu’une feuille où un auteur a écrit cette valeur : une valeur par défaut remplie est une donnée que porte la charge utile, et un marquage lu sur le seul bloc écrit la laisserait sans nom.

Une feuille apparaît là où un chemin que le schéma de la Feature déclare sensible la couvre — la déclaration nomme cette feuille, ou nomme un objet qui la contient. La correspondance s’effectue segment par segment sur le chemin pointé, si bien qu’une déclaration sur db couvre db.password et n’atteint pas une feuille sœur nommée dbPassword. Rien n’est tiré du texte du chemin lui-même et aucune valeur n’est inspectée — que l’auteur ait écrit le contenu lui-même sur une feuille marquée, ou un pointeur vers celui-ci, n’est pas connaissable ici et n’est pas ce qu’affirme le marquage.

La comparaison porte sur la charge utile aplatie en ses feuilles, non sur les clés de premier niveau du pilier, si bien qu’une feuille imbriquée dans une table associative imbriquée est comparée comme n’importe quelle autre.

Les feuilles arrivent dans l’ordre où la charge utile les contient, celles du pilier values avant celles du pilier infra — le même ordre que portent les charges utiles elles-mêmes, et c’est ce qui maintient les données transmises identiques à l’octet près d’une exécution à l’autre pour une entrée identique.

Cette unité répond à où ce rattachement a mis des données, ce qui varie nécessairement selon la Release. C’est pourquoi elle croise ce qui a été écrit alors que sensitive ne le fait pas : les deux sont des réponses à des questions différentes, et appliquer la règle de l’un au champ de l’autre le casserait.

Lire les trois ensemble

Un auteur rattache une Feature d’identifiants qui déclare sensibles sa feuille values literalPassword et sa clé provides password, remplit un emplacement credentials déclaré et écrit en ligne un mot de passe littéral :

{
"type": "example/db-credential",
"resolved_version": "1.0.0",
"binding": "credentials",
"values": {
"secretName": "db-creds",
"literalPassword": { "aggrega_withheld": "declared" }
},
"inject": {
"env": { "DATABASE_PASSWORD": "password" }
},
"sensitive": true,
"sensitive_inject": {
"env": { "DATABASE_PASSWORD": "password" }
},
"sensitive_payload_leaves": ["values.literalPassword"]
}

Trois questions différentes, trois réponses différentes. Le rattachement manipule, d’une manière ou d’une autre, du contenu déclaré sensible (sensitive). La clé d’environnement DATABASE_PASSWORD est l’une de celles qui le portent (sensitive_inject). Et la charge utile de ce rattachement porte une valeur précisément à values.literalPassword (sensitive_payload_leaves) — tandis que values.secretName, un localisateur que la Feature laisse délibérément non marqué, est absent de cette liste bien que la charge utile le porte aussi. Le mot de passe que l’auteur a écrit arrive retenu, tandis que le localisateur à côté arrive tel qu’écrit : le marquage dit à une politique qu’une valeur est là, et la valeur elle-même ne l’atteint jamais.

Une règle qui refuse un secret littéral dans un artefact rendu a besoin du troisième. Une règle qui exige que chaque rattachement manipulant des identifiants porte un label de propriété a besoin du premier. Substituer l’un à l’autre change les builds qui s’arrêtent.

L’absence n’est pas une autorisation

Une feuille n’est listée que là où une déclaration la couvre. Un sensitive_payload_leaves absent indique donc que ce rattachement ne nomme aucune feuille que sa Feature déclare sensible — jamais que la charge utile n’est pas sensible. Il ne distingue pas non plus un rattachement qui n’a aucune feuille de ce genre à nommer d’un producteur qui ne rapporte pas du tout cet axe : les deux restent indiscernables, et le lecteur d’une clé absente apprend cela et rien de plus.

Un guest qui lit une liste de feuilles absente comme une autorisation d’afficher ou d’émettre une valeur en clair a lu le marquage à l’envers.

La clé est entièrement omise des données transmises lorsqu’elle serait vide, si bien qu’un rattachement dont la Feature et l’emplacement ne déclarent rien porte exactement les octets qu’il porterait si le marquage n’existait pas. C’est cette omission qui rend la mauvaise lecture facile, et c’est pourquoi la direction mérite d’être énoncée clairement.

Le cas le plus clair est un rattachement qui est sensible et ne liste aucune feuille. Prenez le rattachement ci-dessus et changez deux choses — l’auteur n’écrit que le localisateur, en laissant non remplie la feuille déclarée sensible, et remplit la clé d’environnement à partir de la clé provides name non marquée de la Feature au lieu de password :

{
"type": "example/db-credential",
"resolved_version": "1.0.0",
"binding": "credentials",
"values": { "secretName": "db-creds" },
"inject": {
"env": { "DATABASE_PASSWORD": "name" }
},
"sensitive": true
}

sensitive est toujours vrai — les déclarations de la Feature n’ont pas changé — tandis que les deux unités plus étroites ont disparu. Le rattachement manipule toujours du contenu secret ; simplement, il ne le fait pas au moyen d’une feuille ou d’une clé de livraison que porte ce rattachement. Une politique fondée sur la valeur agrégée refuse ce build, et une politique fondée sur le marquage par feuille le laisse passer. Les deux sont des règles défendables, et celle que veut une politique est une décision que l’auteur de la politique prend délibérément.

La même asymétrie joue dans l’autre sens pour sensitive_inject : un rattachement peut écrire une feuille sensible sans acheminer rien de sensible par une clé de livraison, ou acheminer une clé provides sensible sans écrire aucune valeur.

Ce qu’une déclaration de sensibilité ne fait pas

Le marquage annote ; ce n’est pas un contrôle. Déclarer sensible une feuille ou un emplacement ne chiffre rien, ne valide ni ne rejette une valeur, et n’impose pas de mécanisme de livraison. Aucun résultat de build ne change du fait qu’une déclaration est présente.

Sur la plupart des cibles, elle ne change pas non plus d’octet rendu : une valeur déclarée sensible qu’un auteur a fournie en ligne est rendue exactement comme une valeur non déclarée. Terraform est l’exception parmi les cibles de la bibliothèque standard, parce qu’il dispose d’une primitive native de sensibilité par valeur sur laquelle la déclaration peut s’appuyer — voir providers/terraform.md « Entrées de module déclarées sensibles ». Une cible sans notion de sensibilité propre n’offre rien qu’une déclaration puisse changer.

Ce que font les déclarations partout, c’est rendre le fait lisible — pour la sortie de débogage du compilateur lui-même, et pour une politique sur ce socket qui décide de ce qu’il faut en faire. Transformer un marquage en résultat de build est le travail de la politique, et c’est la raison d’être de ce socket. Et une politique est informée du contenu déclaré sensible sans qu’il lui soit remis : le marquage arrive, la valeur arrive retenue.

Références croisées

  • policy-socket.md — le socket de gouvernance : les quatre rôles, les niveaux de gravité des verdicts, le canal d’entrée de l’opérateur, les moteurs de politiques livrés dans le compilateur, et le rattachement d’un plugin à un espace de travail.
  • plugin-contract.md — la place du socket dans le pipeline et ses formes de transmission typées.
  • référence du schéma du graphe — le contrat champ par champ du graphe de build, y compris chaque champ d’un rattachement.
  • entities/component.md « Emplacements de rattachement » — déclarer un emplacement, et déclarer un emplacement sensible ; ainsi que le featuresSchema qu’un socket déclare pour les connexions qui passent par lui.
  • entities/aggregate.md « Les rattachements propres d’une connexion » — écrire un rattachement sur une connexion, et le nom qu’il prend.
  • vocabulary/compact-form-authoring.md « Déclarer une feuille sensible » — le mot-clé sensitive: et la limite de ce que sa déclaration permet d’obtenir.
  • vocabulary/labels-and-annotations.md — les surfaces de labels et d’annotations que lit une politique.