Os factos de anexo que uma política de governação lê
Um plugin de governação anexado ao papel ir-verdict recebe o grafo inteiro da compilação, e cada anexo de Feature na compilação chega com ele. Cada anexo contém um conjunto fixo de factos sobre si próprio: que Feature nomeia, que ranhura preenche, em que ligação foi escrito, quando foi escrito numa, que FeatureRecipe o realiza, o que o autor do catálogo declarou sobre ele, o que um autor nele escreveu, e se lida com material que alguém declarou sensível. Uma coisa não chega tal como está escrita: um valor que um autor declarou sensível chega retido — ver Os valores declarados sensíveis chegam retidos.
Esta página enumera esses factos e diz o que cada um afirma e não afirma. Para o socket em si — os quatro papéis, as severidades do veredicto, o canal de entrada do operador e os dois motores de políticas incluídos no compilador — ver policy-socket.md. Para a tabela campo a campo com tipos e obrigatoriedade, ver a referência do esquema do grafo gerada; esta página ensina a ler os factos, e essa página é o contrato.
Onde ficam os anexos no payload
Os anexos estão pendurados no grafo da compilação sob feature_values_mapping, tendo como chave o id do nó e depois o nome de instância que o autor deu a cada anexo:
input.graph.spec.feature_values_mapping[<node id>][<attachment name>]O nome do anexo é estrutural e não decorativo. É a chave pela qual um autor preenche uma ranhura, pelo que é também aquilo que o compilador emparelha com as ranhuras declaradas do Component anfitrião.
Um anexo escrito numa das ligações de um componente — sob features: numa entrada uses, no Aggregate ou na Release — é um dos anexos do componente consumidor, pelo que fica no mesmo compartimento, no nó do componente consumidor. A sua chave é o nome que o compilador lhe dá, o alias da ligação e a ranhura unidos por um ponto: gpt.credential para a ranhura credential da ligação escrita sob o alias gpt. O ponto nunca aparece num nome que um autor escreve, pelo que essa chave nunca é igual ao nome de um dos anexos próprios do nó. Uma política, porém, não lê a ligação a partir da chave: a entrada contém-na como dado, em connection mais 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ê estes factos. Uma política render-verdict recebe os artefactos renderizados e nenhum grafo; uma política label-transform recebe uma projeção das etiquetas e dos valores dos nós, com os seus valores declarados sensíveis retidos como aqui, que não contém nenhum anexo; uma política annotation-transform recebe os componentes que pode anotar. Uma regra que lê factos de anexo 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 anexos
Todos os anexos de um nó ficam no mesmo compartimento, seja o que for que a sua Feature produza — uma Feature operacional, uma Feature de credencial, uma Feature de identidade. Nenhuma família recebe uma projeção mais estreita do que outra, pelo que uma política que percorre o compartimento os vê a todos e nunca precisa de saber que família está a observar antes de poder ler um facto.
Identidade: type e resolved_version
type é o URI da Feature do catálogo que o anexo nomeia. resolved_version é a versão exata em que a resolução se fixou para esta compilação. Ambos estão sempre presentes.
Metadados do catálogo, transportados literalmente: labels e catalog_annotations
labels são os metadata.labels próprios da entidade Feature anexada. catalog_annotations são os metadata.annotations próprios dessa entidade. Ambos são transportados pela ordem em que a entidade do catálogo os declara, e nenhum é filtrado, normalizado ou despojado do prefixo — uma chave no namespace próprio do autor do catálogo chega exatamente tal como está escrita, e o compilador não lê nenhuma delas.
É esse transporte literal que permite que uma política tenha como chave uma etiqueta de cuja existência o compilador não tem motivo para saber. Um autor de catálogo que marca as Features de credencial com uma etiqueta da sua própria invenção pode escrever uma regra diretamente sobre essa etiqueta.
Cada um está ausente do anexo quando a Feature não declara nenhum, e quando o seu type não se resolve em nenhuma entidade do catálogo.
catalog_annotations descreve a entidade que o anexo nomeia. É uma questão diferente de annotation_key e annotation_source mais abaixo, que descrevem como o anexo passou a existir. Um anexo escrito num bloco features: contém anotações do catálogo sem conter nenhum dos outros dois.
Que ranhura o anexo preenche: binding
binding tem três respostas, e a terceira não é uma variante da segunda:
| Valor | Significado |
|---|---|
| um nome de ranhura | O anexo preenche a ranhura de anexo declarada com esse nome. |
free | O anexo não preenche nenhuma ranhura declarada. Trata-se de uma constatação positiva: o conjunto de ranhuras foi resolvido e nenhuma ranhura declarada tem este nome. |
| ausente | Não foi possível resolver o conjunto de ranhuras declaradas do Component anfitrião, pelo que se desconhece que ranhura é preenchida. |
O conjunto de ranhuras declaradas de onde vem o nome depende do sítio onde o anexo foi escrito. Um anexo do bloco próprio do nó preenche uma ranhura que o Component anfitrião declara no seu próprio featuresSchema. Um anexo escrito numa ligação — um que contém connection mais abaixo — preenche uma ranhura que o socket da ligação declara, no featuresSchema desse socket no Component anfitrião. Assim, o mesmo valor, credential, nomeia uma ranhura do Component num anexo e uma ranhura de um socket noutro, e é connection que os distingue.
O emparelhamento faz-se pelo nome — um anexo preenche uma ranhura quando a Feature é anexada sob o nome da ranhura, no bloco do componente ou na ligação — pelo que o valor é uma chave exata do conjunto de ranhuras declaradas. Nada é lido da chave do anexo: o anexo de uma ligação tem a chave gpt.credential e comunica credential. É transportado o nome da ranhura em vez de um simples indicador porque que ranhura foi preenchida é a metade mais útil da resposta.
Um anexo escrito numa ligação nunca comunica free. As ranhuras de um socket são os únicos nomes que uma ligação através dele pode conter, e uma ligação que contenha qualquer outro nome é recusada quando a compilação é carregada, pelo que todos esses anexos, num grafo que chega a uma política, preenchem uma ranhura declarada.
Uma política que trate um binding ausente como free comunicará uma incógnita como constatação. Convém testar free explicitamente.
Em que ligação o anexo foi escrito: connection
connection está presente em todos os anexos escritos numa das ligações do nó, e ausente em todos os anexos do bloco próprio do nó. Contém dois campos, as coordenadas dessa ligação no nó:
| Campo | Significado |
|---|---|
socket | O socket através do qual a ligação é ligada. |
alias | O alias sob o qual a ligação está escrita. |
O par nomeia uma das arestas do grafo: a aresta cujo source é o nó que contém o anexo e cujos socket e alias são estes. O target dessa aresta é o componente ao qual o anexo é apresentado. Assim, uma política junta um anexo àquilo que ele alcança — algo que nenhum facto do anexo por si só pode dizer, porque o anexo 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:
- Regista onde o autor escreveu o anexo. É preenchido a partir da ligação em que o anexo foi escrito, nunca extraído da chave do anexo, pelo que contém o socket — que a chave não contém — bem como o alias.
- Não contém a ranhura. Que ranhura do socket o anexo preenche é
binding, lido da mesma forma que para qualquer anexo; a ranhura é comunicada uma única vez, aí. - Não descreve o destino. O destino, as suas etiquetas e quem ligou a aresta — o programador, a Release ou uma Feature — são factos da aresta e do nó de destino, lidos aí após a junção.
- Uma ligação que uma Feature traça não contém anexos, pelo que nenhum anexo contém uma
connectionque nomeie uma aresta desse tipo. Uma credencial de que a ligação própria de uma Feature precisa é um anexo que preenche uma ranhura que a Feature declara, e não contém nenhumaconnection. - Ausente significa o bloco próprio do nó. Um anexo sem
connectionfoi escrito nosfeatures:próprios do componente (ou chegou-lhe a partir de um âmbito mais amplo ou por expansão orientada por anotações). Não é uma constatação de que o anexo não é apresentado a nenhum outro componente: aquilo que a credencial própria de um componente alcança é decidido pela forma como a sua entrega está ligada, que este campo não descreve.
Para além de decidir de que conjunto de ranhuras declaradas são lidos binding e a metade de ranhura de sensitive, connection não altera nada no anexo: a sua FeatureRecipe, o seu contrato provides, o resto dos seus factos e o seu lugar no compartimento são os de qualquer anexo que o nó contém.
Que FeatureRecipe realiza o anexo: realization
realization nomeia a FeatureRecipe que o Manifest da Release associa ao anexo, como <name>:<version>. O Manifest associa pelo nome próprio do anexo onde o seu nível name mapeia esse nome — para um anexo escrito numa ligação, o seu nome qualificado, gpt.credential acima — e, caso contrário, pelo tipo de Feature que o anexo nomeia. A FeatureRecipe nomeada é aquela com que uma compilação dos mesmos documentos renderiza o anexo: o grafo regista a associação antes de qualquer coisa ser renderizada, e a renderização associa o anexo 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 o lado onde aparece.
aggrega inspectimprime-o como a realização do anexo, e onde um destino carimba a proveniência naquilo que renderiza, os documentos que essa FeatureRecipe renderiza contêm-no como o seu valor deaggrega.ai/recipe-uri, pelo que uma política junta um anexo àquilo que 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 o mesmo nome e a mesma versão. Qual delas fica associada é decidido pelo mapeamento do Manifest, que nomeia a capacidade sempre que o nome por si só seria ambíguo; este campo não o repete.
- Os anexos próprios de uma fronteira de uma Release também o contêm, sob
boundary_features, lidos da mesma forma. Um anexo ao nível da fronteira alcança também cada componente que a fronteira contém, e aí contém a mesma realização. - Ausente significa associado a nada. Um anexo que o Manifest não associa a nenhuma FeatureRecipe que o catálogo contém não contém nenhuma
realization. Uma compilação de uma composição assim é interrompida antes de renderizar, nomeando o anexo por mapear — mas uma política neste papel é consultada antes dessa interrupção, pelo que pode encontrar um anexo que não contém nenhuma. A regra acima deixa passar um anexo assim, porque o seu corpo associarealizationprimeiro; uma regra que pretenda comunicá-lo testa explicitamente a chave em falta.
Como o anexo passou a existir: origin e os seus dois companheiros
origin distingue um anexo que um programador digitou de um que a expansão orientada por anotações produziu:
| Valor | Significado |
|---|---|
explicit | Escrito num bloco features:. |
annotation | Produzido pela expansão orientada por anotações. |
mixed | As folhas de valores ou de infra do anexo contêm uma mistura de ambos; o detalhe por folha está nos mapas de proveniência. |
annotation_key nomeia a anotação que desencadeou um anexo sintético, e annotation_source localiza a 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 do anexo — o domínio do programador. infra é o seu dimensionamento físico por instância — o do operador. inject é o encaminhamento 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.
Aquilo que o values de um anexo de credencial contém é escolha do autor, e o compilador transporta o que tiver sido escrito sem resolver nenhum dos dois: uma credencial por referência contém um ponteiro para um armazenamento de segredos, e uma por valor contém o próprio material. Seja qual for, uma folha que a Feature anexada declara sensível chega a uma política retida, como descreve a secção seguinte; uma folha que ela deixa por declarar, como um localizador publicado, chega tal 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 transporta 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 de todo ser lido é retido por inteiro, com o motivo unreadable, porque nenhuma folha no seu interior pôde ser avaliada.
A retenção segue as marcações do próprio grafo, pelo que alcança exatamente as folhas que estas nomeiam, onde quer que se encontrem:
- os
valuese oinfrade qualquer anexo, seja qual for o âmbito que escreveu o anexo — o bloco próprio do componente, um subsistema, uma fronteira ou a Release, uma expansão orientada por anotações — e quer tenha sido escrito no bloco próprio do nó, quer numa das suas ligações, de acordo com as folhas que o seusensitive_payload_leavesnomeia; - o
infrade um anexo ao nível da fronteira, sobboundary_features, de acordo com a sua própria marcação; - os próprios
valueseinfrade um nó, sobvalues_mappingeinfra_mapping, de acordo com o própriosensitive_payload_leavesdo nó; - os próprios
valueseinfrade uma ligaçã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 qual uma política raciocina fica intacto. O tipo, a versão resolvida, as etiquetas, as anotações de catálogo, binding, connection, realization, origin e os seus mapas de proveniência, os três factos de sensibilidade e todas as folhas que nenhuma declaração marca chegam tal como foram escritos. A chave de uma folha retida também sobrevive, pelo que uma política continua a ver que folhas um payload transporta e quais delas transportam material declarado — só o valor está ausente. Uma regra sobre por onde viaja o material declarado sensível, e por que via, é portanto plenamente exprimível; uma regra sobre o conteúdo do material não o é, por conceção.
O bloco uses escrito pelo autor de um nó, transportado no nó ao lado das suas arestas, mantém de cada anexo escrito numa ligação apenas o seu type e a sua description. Os valores do anexo são transportados uma única vez, no próprio anexo, onde a retenção os alcança.
Uma política que queira 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, pelo que uma política e uma pessoa que leia o grafo veem as mesmas folhas retidas. Essas superfícies devolvem os valores a uma pessoa que os peça com --unredacted; o payload que uma política recebe não oferece esse pedido, e nele os próprios valores declarados de um nó são retidos nas mesmas condições que os de um anexo. Aplica-se ao payload que uma política recebe e a nada mais: o grafo a partir do qual a compilação renderiza fica intacto, pelo que a retenção não altera nenhum byte renderizado. Nada é retido daquilo que uma política render-verdict recebe, porque os artefactos renderizados são aquilo que esse papel julga.
De onde vem cada folha: values_provenance e infra_provenance
Cada um é indexado pelo caminho pontuado da folha dentro do seu pilar, e cada entrada regista o origin dessa folha — a mesma distinção explicit / annotation, aplicada uma folha de cada vez. Uma folha contribuída por uma anotação transporta 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 substituiu uma contribuída por uma anotação, a entrada transporta também a contribuição suprimida que substituiu, pelo que uma política consegue ver o que foi sobreposto e não apenas o que prevaleceu.
As três unidades de sensibilidade
O payload transporta três factos de sensibilidade, e estes situam-se em três unidades diferentes: um anexo inteiro, uma chave de entrega, uma folha do payload.
Cada um é calculado a partir das suas próprias entradas. Nenhum é derivado de outro, e em particular a resposta por anexo nunca é propagada para as unidades mais estreitas. Confundir dois quaisquer deles produz uma política errada numa direção que falha silenciosamente, pelo que vale a pena ler os três separadamente antes de escrever uma regra sobre qualquer um deles.
Cada um deles é derivado daquilo que um autor declarou — sensitive: true numa folha do esquema de uma Feature, ou sensitive: true numa ranhura de anexo que um Component declara, para os seus próprios anexos ou num dos seus sockets. O conteúdo de nenhum valor é inspecionado, e nenhum significado é extraído do nome de um campo.
sensitive — uma resposta para o anexo inteiro
Verdadeiro quando a Feature anexada declara uma folha sensível nos seus values, infra ou provides, ou quando a ranhura que o anexo preenche declara que o que quer que a associe lida com material secreto — a ranhura de anexo com o mesmo nome do Component anfitrião ou, para um anexo que transporta connection, a ranhura com esse nome que o socket da ligação declara. Não definido quando nenhuma das duas declarações está presente.
Isto responde a o que a entidade é, pelo que deliberadamente não varia com aquilo que um autor em particular escreveu. Lê as declarações da Feature em vez do subconjunto de folhas sensíveis que este anexo acabou por preencher, porque um campo que fosse sensível numa Release e não noutra 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 continua a associar-se a uma ranhura sensível como anexo sensível, porque a ranhura assim o disse. Um preenchimento que declara uma folha sensível é um anexo sensível mesmo quando a ranhura não fez tal declaração, e mesmo quando é um anexo livre que não se associa a nenhuma ranhura.
sensitive_inject — uma resposta por chave de entrega
O subconjunto de inject cuja chave provides referenciada a Feature anexada declara sensível, transportado 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 no mesmo anexo e com o mesmo mecanismo. Ausente quando o anexo 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 deste anexo transporta cujo caminho a Feature anexada 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 o anexo acaba por transportar, não o bloco que um autor escreveu. Uma folha que está num valor que o esquema da Feature declara como default é nomeada tal como uma em que um autor escreveu esse valor: uma predefinição preenchida é um dado que o payload transporta, e uma marcação lida apenas do bloco escrito deixá-la-ia 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 faz-se segmento a segmento sobre o caminho pontuado, pelo que 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 numa 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 faz-se sobre o payload achatado nas suas folhas, não sobre as chaves de nível superior do pilar, pelo que uma folha aninhada dentro de um mapa aninhado é comparada como qualquer outra.
As folhas chegam pela 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 transportam, o que mantém os dados transmitidos idênticos byte a byte entre execuções com entrada idêntica.
Esta unidade responde a onde este anexo colocou dados, o que varia necessariamente por Release. É por isso que se cruza com aquilo que foi escrito, ao passo que sensitive não: os dois são respostas a perguntas diferentes, e aplicar a regra de um ao campo do outro estragá-lo-ia.
Ler os três em conjunto
Um autor que anexa uma Feature de credenciais que declara sensíveis a sua folha de values literalPassword e a sua chave de provides password, preenchendo uma ranhura credentials declarada, e que escreve inline uma palavra-passe 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. O anexo lida, de alguma forma, com material declarado sensível (sensitive). A chave de ambiente DATABASE_PASSWORD é uma das que o transportam (sensitive_inject). E o payload deste anexo transporta um valor especificamente em values.literalPassword (sensitive_payload_leaves) — enquanto values.secretName, um localizador que a Feature deixa deliberadamente sem marcação, está ausente dessa lista, embora o payload também o transporte. A palavra-passe que o autor escreveu chega retida, enquanto o localizador ao lado chega tal como foi escrito: a marcação diz a uma política que existe ali um valor, e o próprio valor nunca chega a ela.
Uma regra que recusa um segredo literal num artefacto renderizado quer o terceiro. Uma regra que exige que todos os anexos que lidam com credenciais transportem uma etiqueta de propriedade quer o primeiro. Substituir um pelo outro altera quais compilações param.
A ausência não é uma permissão
Uma folha só é listada onde uma declaração a cobre. Assim, um sensitive_payload_leaves ausente afirma que este anexo não nomeia nenhuma folha que a sua Feature declara sensível — nunca que o payload não é sensível. Também não distingue um anexo que não tem nenhuma folha dessas para nomear de um produtor que não comunica de todo este eixo: esses dois permanecem indistinguíveis, e quem lê uma chave ausente fica a saber isso e nada mais.
Um guest que leia uma lista de folhas ausente como permissão para mostrar ou emitir um valor em claro leu a marcação ao contrário.
A chave é omitida por completo dos dados transmitidos quando estaria vazia, pelo que um anexo cuja Feature e cuja ranhura não declaram nada transporta exatamente os bytes que transportaria se a marcação não existisse. É essa omissão que torna fácil a leitura errada, e é por isso que vale a pena enunciar a direção com clareza.
O caso mais claro é um anexo que é sensível e não lista nenhuma folha. Tome-se o anexo acima e alterem-se duas coisas — o autor escreve apenas o localizador, deixando por 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. O anexo continua a lidar com material secreto; simplesmente não o faz através de uma folha ou de uma chave de entrega que este anexo transporte. Uma política baseada no valor agregado recusa esta compilação, e uma política baseada na marcação por folha deixa-a 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 verifica-se no sentido inverso para sensitive_inject: um anexo pode escrever uma folha sensível sem encaminhar nada de 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 controlo. Declarar sensível uma folha ou uma ranhura não cifra nada, não valida nem rejeita um valor e não impõe um mecanismo de entrega. Nenhum resultado de compilação muda por estar presente uma declaração.
Na maioria dos destinos também não altera 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 standard, porque dispõe de uma primitiva nativa de sensibilidade por valor na qual a declaração pode assentar — ver 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 alterar.
O que as declarações fazem em toda a parte é tornar o facto 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 esse respeito. Transformar uma marcação num resultado de compilação é o trabalho da política, e é para isso que este socket existe. E uma política é informada sobre o material declarado sensível sem que este lhe seja entregue: a marcação chega, o valor chega retido.
Referências cruzadas
policy-socket.md— o socket de governação: os quatro papéis, as severidades do veredicto, o canal de entrada do operador, os motores de políticas que são distribuídos dentro do compilador e a anexação de um plugin a um espaço de trabalho.plugin-contract.md— o posicionamento do socket no pipeline e as suas formas de transmissão tipadas.- referência do esquema do grafo — o contrato campo a campo do grafo de compilação, incluindo cada campo de um anexo.
entities/component.md«Ranhuras de anexo» — declarar uma ranhura, e declarar uma ranhura sensível; e ofeaturesSchemaque um socket declara para as ligações que passam por ele.entities/aggregate.md«Os anexos próprios de uma ligação» — escrever um anexo numa ligação, e o nome que este recebe.vocabulary/compact-form-authoring.md«Declarar uma folha sensível» — a palavra-chavesensitive:e o limite daquilo que declará-la permite alcançar.vocabulary/labels-and-annotations.md— as superfícies de etiquetas e anotações que uma política lê.