Os fatos de vinculação que uma política de governança lê
Um plugin de governança vinculado ao papel ir-verdict recebe o grafo inteiro do build, e cada vinculação de Feature no build chega com ele. Cada vinculação traz um conjunto fixo de fatos sobre si mesma: qual Feature ela nomeia, qual slot preenche, em qual conexão foi escrita, quando foi escrita em uma, qual FeatureRecipe a realiza, o que o autor do catálogo declarou sobre ela, o que um autor escreveu nela, e se ela lida com material que alguém declarou sensível. Uma coisa não chega como está escrita: um valor que um autor declarou sensível chega retido — veja Os valores declarados sensíveis chegam retidos.
Esta página enumera esses fatos e diz o que cada um afirma e o que não afirma. Para o socket em si — os quatro papéis, as severidades do veredito, o canal de entrada do operador e os dois mecanismos de políticas que vêm dentro do compilador — veja policy-socket.md. Para a tabela campo a campo com tipos e obrigatoriedade, veja a referência do esquema do grafo gerada; esta página ensina a ler os fatos, e aquela página é o contrato.
Onde as vinculações ficam no payload
As vinculações ficam penduradas no grafo do build sob feature_values_mapping, tendo como chave o id do nó e depois o nome de instância que o autor deu a cada vinculação:
input.graph.spec.feature_values_mapping[<node id>][<attachment name>]O nome da vinculação é estrutural, e não decorativo. É a chave pela qual um autor preenche um slot, então também é o que o compilador emparelha com os slots declarados do Component hospedeiro.
Uma vinculação escrita em uma das conexões de um componente — sob features: em uma entrada uses, no Aggregate ou na Release — é uma das vinculações do componente consumidor, então fica no mesmo compartimento, no nó do componente consumidor. Sua chave é o nome que o compilador lhe dá, o alias da conexão e o slot unidos por um ponto: gpt.credential para o slot credential da conexão escrita sob o alias gpt. O ponto nunca aparece em um nome que um autor escreve, então essa chave nunca é igual ao nome de uma das vinculações próprias do nó. Uma política, porém, não lê a conexão a partir da chave: a entrada a traz como dado, em connection abaixo.
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])}Só ir-verdict vê esses fatos. Uma política render-verdict recebe os artefatos renderizados e nenhum grafo; uma política label-transform recebe uma projeção dos rótulos e valores dos nós, com seus valores declarados sensíveis retidos como aqui, que não traz nenhuma vinculação; uma política annotation-transform recebe os componentes que pode anotar. Uma regra que lê fatos de vinculação pertence a ir-verdict, e movê-la para outro papel produz uma regra que nunca dispara em vez de um erro, porque um caminho que não existe é simplesmente indefinido.
Um único compartimento, todas as famílias de vinculações
Toda vinculação em um nó fica no mesmo compartimento, seja o que for que sua Feature produza — uma Feature operacional, uma Feature de credencial, uma Feature de identidade. Nenhuma família recebe uma projeção mais estreita que outra, então uma política que percorre o compartimento vê todas elas e nunca precisa saber qual família está olhando antes de poder ler um fato.
Identidade: type e resolved_version
type é o URI da Feature do catálogo que a vinculação nomeia. resolved_version é a versão exata em que a resolução se fixou para este build. Ambos estão sempre presentes.
Metadados do catálogo, levados literalmente: labels e catalog_annotations
labels são os metadata.labels próprios da entidade Feature vinculada. catalog_annotations são os metadata.annotations próprios dessa entidade. Ambos são levados na ordem em que a entidade do catálogo os declara, e nenhum deles é filtrado, normalizado ou tem o prefixo removido — uma chave no namespace próprio do autor do catálogo chega exatamente como está escrita, e o compilador não lê nenhuma delas.
É esse transporte literal que permite que uma política tenha como chave um rótulo cuja existência o compilador não tem motivo para conhecer. Um autor de catálogo que marca Features de credencial com um rótulo de sua própria invenção pode escrever uma regra diretamente sobre esse rótulo.
Cada um está ausente da vinculação quando a Feature não declara nenhum, e quando seu type não se resolve em nenhuma entidade do catálogo.
catalog_annotations descreve a entidade que a vinculação nomeia. É uma questão diferente de annotation_key e annotation_source abaixo, que descrevem como a vinculação passou a existir. Uma vinculação escrita em um bloco features: traz anotações do catálogo sem trazer nenhum dos outros dois.
Qual slot a vinculação preenche: binding
binding tem três respostas, e a terceira não é uma variante da segunda:
| Valor | Significado |
|---|---|
| um nome de slot | A vinculação preenche o slot de vinculação declarado com esse nome. |
free | A vinculação não preenche nenhum slot declarado. É uma constatação positiva: o conjunto de slots foi resolvido e nenhum slot declarado traz esse nome. |
| ausente | O conjunto de slots declarados do Component hospedeiro não pôde ser resolvido, então não se sabe qual slot é preenchido. |
De qual conjunto de slots declarados o nome vem depende de onde a vinculação foi escrita. Uma vinculação do bloco próprio do nó preenche um slot que o Component hospedeiro declara em seu próprio featuresSchema. Uma vinculação escrita em uma conexão — uma que traz connection abaixo — preenche um slot que o socket da conexão declara, no featuresSchema desse socket no Component hospedeiro. Assim, o mesmo valor, credential, nomeia um slot do Component em uma vinculação e um slot de um socket em outra, e connection é o que distingue as duas.
O emparelhamento é por nome — uma vinculação preenche um slot quando a Feature é vinculada sob o nome do slot, no bloco do componente ou na conexão — então o valor é uma chave exata do conjunto de slots declarados. Nada é lido da chave da vinculação: a vinculação de uma conexão tem a chave gpt.credential e relata credential. O nome do slot é levado em vez de um simples sinalizador porque qual slot foi preenchido é a metade mais útil da resposta.
Uma vinculação escrita em uma conexão nunca relata free. Os slots de um socket são os únicos nomes que uma conexão através dele pode trazer, e uma conexão que traz qualquer outro nome é recusada quando o build é carregado, então toda vinculação desse tipo em um grafo que chega a uma política preenche um slot declarado.
Uma política que trata um binding ausente como free vai relatar uma incógnita como constatação. Teste free explicitamente.
Em qual conexão a vinculação foi escrita: connection
connection está presente em toda vinculação escrita em uma das conexões do nó, e ausente em toda vinculação do bloco próprio do nó. Ele traz dois campos, as coordenadas dessa conexão no nó:
| Campo | Significado |
|---|---|
socket | O socket através do qual a conexão é conectada. |
alias | O alias sob o qual a conexão é escrita. |
O par nomeia uma das arestas do grafo: a aresta cujo source é o nó que traz a vinculação e cujos socket e alias são estes. O target dessa aresta é o componente ao qual a vinculação é apresentada. Assim, uma política junta uma vinculação ao que ela alcança — algo que nenhum fato da vinculação sozinha pode dizer, porque a vinculação fica no nó consumidor:
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])}O que connection afirma, e o que não afirma:
- Registra onde o autor escreveu a vinculação. É preenchido a partir da conexão em que a vinculação foi escrita, nunca extraído da chave da vinculação, então contém o socket — que a chave não traz — além do alias.
- Não traz o slot. Qual slot do socket a vinculação preenche é
binding, lido da mesma forma que para qualquer vinculação; o slot é relatado uma única vez, ali. - Não descreve o destino. O destino, seus rótulos e quem conectou a aresta — o desenvolvedor, a Release ou uma Feature — são fatos da aresta e do nó de destino, lidos ali após a junção.
- Uma conexão que uma Feature traça não traz vinculações, então nenhuma vinculação traz uma
connectionque nomeie uma aresta desse tipo. Uma credencial de que a conexão própria de uma Feature precisa é uma vinculação que preenche um slot que a Feature declara, e não traz nenhumaconnection. - Ausente significa o bloco próprio do nó. Uma vinculação sem
connectionfoi escrita nosfeatures:próprios do componente (ou chegou a ele a partir de um escopo mais amplo ou por expansão orientada por anotações). Não é uma constatação de que a vinculação não é apresentada a nenhum outro componente: o que a credencial própria de um componente alcança é decidido por como sua entrega está conectada, o que este campo não descreve.
Além de decidir de qual conjunto de slots declarados binding e a metade de slot de sensitive são lidos, connection não muda nada na vinculação: sua FeatureRecipe, seu contrato provides, o resto de seus fatos e seu lugar no compartimento são os de qualquer vinculação que o nó traz.
Qual FeatureRecipe realiza a vinculação: realization
realization nomeia a FeatureRecipe que o Manifest da Release associa à vinculação, como <name>:<version>. O Manifest associa pelo nome próprio da vinculação onde seu nível name mapeia esse nome — para uma vinculação escrita em uma conexão, seu nome qualificado, gpt.credential acima — e, caso contrário, pelo tipo de Feature que a vinculação nomeia. A FeatureRecipe nomeada é aquela com a qual um build dos mesmos documentos renderiza a vinculação: o grafo registra a associação antes que qualquer coisa seja renderizada, e a renderização associa a vinculação da mesma forma.
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])}O que realization afirma, e o que não afirma:
- É o mesmo par em todo lugar em que aparece.
aggrega inspecto imprime como a realização da vinculação, e onde um destino carimba a procedência no que renderiza, os documentos que essa FeatureRecipe renderiza o trazem como seu valor deaggrega.ai/recipe-uri, de modo que uma política junta uma vinculação ao que ela renderiza sem traduzir entre formas. - Nomeia a FeatureRecipe por nome e versão, não por capacidade. Duas capacidades podem cada uma publicar uma FeatureRecipe sob um mesmo nome e uma mesma versão. Qual delas é associada é decidido pelo mapeamento do Manifest, que nomeia a capacidade sempre que o nome sozinho seria ambíguo; este campo não o repete.
- As vinculações próprias de uma fronteira de Release também o trazem, sob
boundary_features, lidas da mesma forma. Uma vinculação no nível da fronteira também alcança cada componente que a fronteira contém, e ali traz a mesma realização. - Ausente significa associada a nada. Uma vinculação que o Manifest não associa a nenhuma FeatureRecipe que o catálogo contém não traz nenhuma
realization. Um build de uma composição assim é interrompido antes de renderizar, nomeando a vinculação sem mapeamento — mas uma política nesse papel é consultada antes dessa interrupção, então pode encontrar uma vinculação que não traz nenhuma. A regra acima deixa passar uma vinculação assim, porque seu corpo associarealizationprimeiro; uma regra que queira relatá-la testa explicitamente a chave ausente.
Como a vinculação passou a existir: origin e seus dois companheiros
origin distingue uma vinculação que um desenvolvedor digitou de uma que a expansão orientada por anotações produziu:
| Valor | Significado |
|---|---|
explicit | Escrita em um bloco features:. |
annotation | Produzida pela expansão orientada por anotações. |
mixed | As folhas de valores ou de infra da vinculação trazem uma mistura de ambas; o detalhe por folha está nos mapas de proveniência. |
annotation_key nomeia a anotação que acionou uma vinculação sintética, e annotation_source localiza sua declaração como <release-file-path>:<dotted-yaml-key-path>. Ambos estão ausentes quando origin é explicit.
Os payloads escritos pelo autor: values, infra e inject
values é a configuração operacional da vinculação — o domínio do desenvolvedor. infra é seu dimensionamento físico por instância — o do operador. inject é o roteamento agnóstico da injeção, que mapeia as chaves de entrega para as chaves provides a partir das quais são preenchidas, tendo como primeira chave o mecanismo de entrega.
O que o values de uma vinculação de credencial traz é escolha do autor, e o compilador leva o que quer que tenha sido escrito sem resolver nenhum dos dois: uma credencial por referência traz um ponteiro para um armazenamento de segredos, e uma por valor traz o próprio material. Seja qual for, uma folha que a Feature vinculada declara sensível chega a uma política retida, como a próxima seção descreve; uma folha que ela deixa sem declarar, como um localizador publicado, chega como está escrita.
Os valores declarados sensíveis chegam retidos
Cada folha que o grafo marca como declarada sensível chega a este socket como um marcador de retenção em vez de como o valor que um autor escreveu. O marcador é um objeto de chave única que carrega o motivo pelo qual o valor está ausente:
{ "aggrega_withheld": "declared" }declared significa que uma declaração cobre a folha. Um payload que não pôde ser lido de forma alguma é retido inteiro, com o motivo unreadable, porque nenhuma folha dentro dele pôde ser julgada.
A retenção segue as marcações do próprio grafo, então alcança exatamente as folhas que elas nomeiam, onde quer que estejam:
- os
valuese oinfrade toda vinculação, qualquer que seja o escopo que escreveu a vinculação — o bloco próprio do componente, um subsistema, uma fronteira ou a Release, uma expansão orientada por anotações — e quer ela tenha sido escrita no bloco próprio do nó ou em uma de suas conexões, de acordo com as folhas que seusensitive_payload_leavesnomeia; - o
infrade uma vinculação no nível da fronteira, sobboundary_features, de acordo com sua própria marcação; - os
valuese oinfrapróprios de um nó, sobvalues_mappingeinfra_mapping, de acordo com osensitive_payload_leavespróprio do nó; - os
valuese oinfrapróprios de uma conexão, na aresta e na entradausesdo nó consumidor, de acordo com osensitive_payload_leavesda aresta, que nomeia as folhas que o socket do componente consumidor declara sensíveis.
Aquilo sobre o que uma política raciocina fica intacto. O tipo, a versão resolvida, os rótulos, as anotações de catálogo, binding, connection, realization, origin e seus mapas de proveniência, os três fatos de sensibilidade e toda folha que nenhuma declaração marca chegam como foram escritos. A chave de uma folha retida também permanece, então uma política ainda vê quais folhas um payload carrega e quais delas carregam material declarado — só o valor está ausente. Uma regra sobre por onde trafega o material declarado sensível, e por qual rota, é portanto plenamente expressável; uma regra sobre o conteúdo do material não é, por design.
O bloco uses escrito pelo autor de um nó, carregado no nó ao lado de suas arestas, mantém de cada vinculação escrita em uma conexão apenas seu type e sua description. Os valores da vinculação são carregados uma única vez, na própria vinculação, onde a retenção os alcança.
Uma política que quer distinguir uma folha retida de uma escrita pelo autor testa a presença da chave do marcador:
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])}É a mesma retenção que --ir-graph aplica quando um comando imprime o grafo e que aggrega/irGraph do daemon aplica quando responde a um cliente, então uma política e uma pessoa que lê o grafo veem as mesmas folhas retidas. Essas superfícies devolvem os valores a uma pessoa que os pede com --unredacted; o payload que uma política recebe não oferece tal solicitação, e nele os valores declarados próprios de um nó são retidos nas mesmas condições que os de uma vinculação. Isso se aplica ao payload que uma política recebe e a nada mais: o grafo a partir do qual o build renderiza permanece intocado, então a retenção não muda nenhum byte renderizado. Nada é retido daquilo que uma política render-verdict recebe, porque os artefatos renderizados são o que esse papel julga.
De onde vem cada folha: values_provenance e infra_provenance
Cada um é indexado pelo caminho pontuado da folha dentro de seu pilar, e cada entrada registra o origin dessa folha — a mesma distinção explicit / annotation, aplicada uma folha de cada vez. Uma folha contribuída por uma anotação carrega além disso a superfície de autoria em que foi declarada, a chave de anotação que a contribuiu e a localização no código-fonte dessa declaração. Onde uma folha explícita sobrescreveu uma contribuída por uma anotação, a entrada carrega também a contribuição suprimida que ela substituiu, então uma política pode ver o que foi sobrescrito e não apenas o que prevaleceu.
As três unidades de sensibilidade
O payload carrega três fatos de sensibilidade, e eles ficam em três unidades diferentes: uma vinculação inteira, uma chave de entrega, uma folha do payload.
Cada um é calculado a partir de suas próprias entradas. Nenhum é derivado de outro, e em particular a resposta por vinculação nunca é propagada para as unidades mais estreitas. Confundir dois quaisquer deles produz uma política errada em uma direção que falha silenciosamente, então vale a pena ler os três separadamente antes de escrever uma regra sobre qualquer um deles.
Cada um deles é derivado do que um autor declarou — sensitive: true em uma folha do esquema de uma Feature, ou sensitive: true em um slot de vinculação que um Component declara, para suas próprias vinculações ou em um de seus sockets. O conteúdo de nenhum valor é inspecionado, e nenhum significado é extraído do nome de um campo.
sensitive — uma resposta para a vinculação inteira
Verdadeiro quando a Feature vinculada declara uma folha sensível em seus values, infra ou provides, ou quando o slot que a vinculação preenche declara que o que quer que o associe lida com material secreto — o slot de vinculação de mesmo nome do Component hospedeiro ou, para uma vinculação que carrega connection, o slot com esse nome que o socket da conexão declara. Não definido quando nenhuma das duas declarações está presente.
Isso responde o que a entidade é, então deliberadamente não varia com o que um autor em particular escreveu. Lê as declarações da Feature em vez do subconjunto de folhas sensíveis que esta vinculação calhou de preencher, porque um campo que fosse sensível em uma Release e não em outra seria inutilizável para uma política que raciocina sobre a entidade de catálogo.
As duas metades são independentes, e cada uma vale por si. Uma Feature que não declara nenhuma folha sensível ainda associa um slot sensível como uma vinculação sensível, porque o slot assim disse. Um preenchimento que declara uma folha sensível é uma vinculação sensível mesmo quando o slot não fez tal declaração, e mesmo quando é uma vinculação livre que não associa nenhum slot.
sensitive_inject — uma resposta por chave de entrega
O subconjunto de inject cuja chave provides referenciada a Feature vinculada declara sensível, carregado na forma própria de inject: mecanismo, depois chave de entrega, com a chave provides referenciada como valor.
Uma chave de entrega preenchida a partir de uma chave provides que a Feature marcou como sensível aparece aqui; uma preenchida a partir de uma chave não marcada não aparece, mesmo na mesma vinculação e com o mesmo mecanismo. Ausente quando a vinculação não declara nenhum mecanismo de entrega, ou não referencia nenhuma chave provides sensível.
sensitive_payload_leaves — uma resposta por folha do payload
As folhas que o payload desta vinculação carrega cujo caminho a Feature vinculada declara sensível, cada uma como o caminho pontuado, prefixado pelo pilar, que o dado ocupa: values.<path> ou infra.<path>.
O payload lido aqui é aquele que a vinculação acaba carregando, não o bloco que um autor escreveu. Uma folha que está em um valor que o esquema da Feature declara como default é nomeada da mesma forma que uma em que um autor escreveu esse valor: um padrão preenchido é um dado que o payload carrega, e uma marcação lida apenas do bloco escrito o deixaria sem nome.
Uma folha aparece onde um caminho que o esquema da Feature declara sensível a cobre — a declaração nomeia essa folha, ou nomeia um objeto que a contém. A correspondência é feita segmento a segmento sobre o caminho pontuado, então uma declaração em db cobre db.password e não alcança uma folha irmã chamada dbPassword. Nada é extraído do próprio texto do caminho e nenhum valor é inspecionado — se o autor escreveu o próprio material em uma folha marcada, ou um ponteiro para ele, não é possível saber aqui e não é o que a marcação afirma.
A comparação é feita sobre o payload achatado em suas folhas, não sobre as chaves de nível superior do pilar, então uma folha aninhada dentro de um mapa aninhado é comparada como qualquer outra.
As folhas chegam na ordem em que o payload as contém, as do pilar values antes das do pilar infra — a mesma ordem que os próprios payloads carregam, o que mantém os dados transmitidos idênticos byte a byte entre execuções com entrada idêntica.
Esta unidade responde onde esta vinculação colocou dados, o que necessariamente varia por Release. É por isso que ela se cruza com o que foi escrito, enquanto sensitive não: os dois são respostas a perguntas diferentes, e aplicar a regra de um ao campo do outro o quebraria.
Ler os três em conjunto
Um autor que vincula uma Feature de credenciais que declara sensíveis sua folha de values literalPassword e sua chave de provides password, preenchendo um slot credentials declarado, e que escreve inline uma senha literal:
{ "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"]}Três perguntas diferentes, três respostas diferentes. A vinculação lida, de alguma forma, com material declarado sensível (sensitive). A chave de ambiente DATABASE_PASSWORD é uma das que o carregam (sensitive_inject). E o payload desta vinculação carrega um valor especificamente em values.literalPassword (sensitive_payload_leaves) — enquanto values.secretName, um localizador que a Feature deliberadamente deixa sem marcação, está ausente dessa lista, embora o payload também o carregue. A senha que o autor escreveu chega retida, enquanto o localizador ao lado dela chega como foi escrito: a marcação diz a uma política que há um valor ali, e o próprio valor nunca chega a ela.
Uma regra que nega um segredo literal em um artefato renderizado quer o terceiro. Uma regra que exige que toda vinculação que lida com credenciais carregue um rótulo de propriedade quer o primeiro. Substituir um pelo outro muda quais builds param.
A ausência não é uma permissão
Uma folha é listada apenas onde uma declaração a cobre. Então um sensitive_payload_leaves ausente afirma que esta vinculação não nomeia nenhuma folha que sua Feature declara sensível — nunca que o payload não é sensível. Também não separa uma vinculação que não tem tal folha para nomear de um produtor que não relata este eixo de forma alguma: esses dois permanecem indistinguíveis, e quem lê uma chave ausente aprende isso e nada mais.
Um guest que lê uma lista de folhas ausente como permissão para exibir ou emitir um valor em texto claro leu a marcação ao contrário.
A chave é omitida inteiramente dos dados transmitidos quando estaria vazia, então uma vinculação cuja Feature e cujo slot não declaram nada carrega exatamente os bytes que carregaria se a marcação não existisse. Essa omissão é o que torna fácil a leitura equivocada, e é por isso que vale a pena afirmar a direção com clareza.
O caso mais claro é uma vinculação que é sensível e não lista nenhuma folha. Pegue a vinculação acima e mude duas coisas — o autor escreve apenas o localizador, deixando sem preencher a folha declarada sensível, e preenche a chave de ambiente a partir da chave de provides name não marcada da Feature em vez 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 continua verdadeiro — as declarações da Feature não mudaram — enquanto as duas unidades mais estreitas desapareceram. A vinculação ainda lida com material secreto; ela simplesmente não o faz por meio de uma folha ou de uma chave de entrega que esta vinculação carrega. Uma política baseada no valor agregado nega este build, e uma política baseada na marcação por folha o deixa passar. Ambas são regras defensáveis, e qual delas uma política quer é uma decisão que o autor da política toma deliberadamente.
A mesma assimetria vale no sentido inverso para sensitive_inject: uma vinculação pode escrever uma folha sensível sem encaminhar nada sensível por uma chave de entrega, ou encaminhar uma chave provides sensível sem escrever valor algum.
O que uma declaração de sensibilidade não faz
A marcação anota; não é um controle. Declarar sensível uma folha ou um slot não criptografa nada, não valida nem rejeita um valor e não força um mecanismo de entrega. Nenhum resultado de build muda porque uma declaração está presente.
Na maioria dos destinos ela também não muda nenhum byte renderizado: um valor declarado sensível que um autor forneceu inline é renderizado exatamente como um não declarado. O Terraform é a exceção entre os destinos da biblioteca padrão, porque possui uma primitiva nativa de sensibilidade por valor na qual a declaração pode se apoiar — veja providers/terraform.md “Entradas de módulo declaradas sensíveis”. Um destino sem uma noção própria de sensibilidade não tem nada que uma declaração possa mudar.
O que as declarações fazem em toda parte é tornar o fato legível — para a própria saída de depuração do compilador, e para uma política neste socket que decide o que fazer a respeito. Transformar uma marcação em um resultado de build é o trabalho da política, e é para isso que este socket existe. E uma política é informada sobre o material declarado sensível sem recebê-lo: a marcação chega, o valor chega retido.
Referências cruzadas
policy-socket.md— o socket de governança: os quatro papéis, as severidades do veredito, o canal de entrada do operador, os mecanismos de políticas que acompanham o compilador e a vinculação de um plugin a um espaço de trabalho.plugin-contract.md— o posicionamento do socket no pipeline e suas formas de transmissão tipadas.- referência do esquema do grafo — o contrato campo a campo do grafo de build, incluindo cada campo de uma vinculação.
entities/component.md“Slots de vinculação” — declarar um slot, e declarar um slot sensível; e ofeaturesSchemaque um socket declara para as conexões que passam por ele.entities/aggregate.md“As vinculações próprias de uma conexão” — escrever uma vinculação em uma conexão, e o nome que ela recebe.vocabulary/compact-form-authoring.md“Declarar uma folha sensível” — a palavra-chavesensitive:e o limite do que declará-la alcança.vocabulary/labels-and-annotations.md— as superfícies de rótulos e anotações que uma política lê.