Перейти к содержимому
AggregaAggrega
Выберите язык: Русский
Эта страница переведена машинным способом. Читать оригинал на английском.

Факты о подключениях, которые читает политика управления

Плагин управления, подключённый в роли ir-verdict, получает весь граф сборки, и вместе с ним приходит каждое подключение Feature в сборке. Каждое подключение несёт фиксированный набор фактов о себе: какую Feature оно называет, какой слот заполняет, на каком соединении оно записано, если записано на соединении, какой FeatureRecipe его реализует, что о нём объявил автор каталога, что в него записал автор и обрабатывает ли оно материал, который кто-либо объявил конфиденциальным. Одно не приходит в записанном виде: значение, которое автор объявил конфиденциальным, приходит скрытым — см. Значения, объявленные конфиденциальными, приходят скрытыми.

На этой странице перечислены эти факты и указано, что каждый из них утверждает и чего не утверждает. О самом сокете — четырёх ролях, уровнях серьёзности вердиктов, канале ввода оператора и двух движках политик, поставляемых внутри компилятора, — см. policy-socket.md. Таблицу по каждому полю с типами и обязательностью см. в сгенерированном справочнике по схеме графа; эта страница объясняет, как читать факты, а та страница является контрактом.

Где вложения находятся в полезной нагрузке

Вложения располагаются в графе сборки под feature_values_mapping с ключами по идентификатору узла, а затем по имени экземпляра, которое автор дал каждому вложению:

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

Имя вложения несёт смысловую нагрузку, а не служит украшением. Это ключ, по которому автор заполняет слот, поэтому именно его компилятор сопоставляет с объявленными слотами сущности Component, в которой размещено вложение.

Вложение, записанное на одном из соединений компонента — под features: в записи uses, в сущности Aggregate или в сущности Release, — является одним из вложений потребляющего компонента, поэтому оно находится в той же корзине, на узле потребляющего компонента. Его ключ — имя, которое даёт ему компилятор: псевдоним соединения и слот, соединённые точкой: gpt.credential для слота credential соединения, записанного под псевдонимом gpt. Точка никогда не встречается в имени, которое пишет автор, поэтому такой ключ никогда не совпадает с именем одного из собственных вложений узла. Однако политика не извлекает соединение из ключа: запись содержит его как данные, в connection ниже.

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])
}

Эти факты видит только ir-verdict. Политика render-verdict получает отрисованные артефакты и не получает граф; политика label-transform получает проекцию меток и значений узлов, в которой объявленные чувствительными значения скрыты так же, как здесь, и которая вообще не содержит вложений; политика annotation-transform получает компоненты, которые она может аннотировать. Правило, читающее факты о вложениях, относится к ir-verdict, и перенос его в другую роль даёт не ошибку, а правило, которое никогда не срабатывает, поскольку отсутствующий путь просто не определён.

Одна корзина для всех семейств вложений

Все вложения узла находятся в одной корзине, что бы ни производила их сущность Feature — операционная сущность Feature, сущность Feature учётных данных или сущность Feature идентичности. Ни одно семейство не получает более узкой проекции, чем другое, поэтому политика, обходящая корзину, видит их все и никогда не должна знать, с каким семейством имеет дело, прежде чем прочитать факт.

Идентичность: type и resolved_version

type — это URI сущности Feature из каталога, которую называет присоединение. resolved_version — точная версия, на которой остановилось разрешение для этой сборки. Оба поля присутствуют всегда.

Метаданные каталога, передаваемые дословно: labels и catalog_annotations

labels — это собственные metadata.labels присоединённой сущности Feature. catalog_annotations — собственные metadata.annotations этой сущности. Оба передаются в том порядке, в котором их объявляет сущность каталога, и ни одно из них не фильтруется, не нормализуется и не лишается префикса — ключ в собственном пространстве имён автора каталога приходит точно в том виде, в каком он написан, и компилятор не читает ни один из них.

Именно эта дословная передача позволяет строить политику на метке, о существовании которой компилятору незачем знать. Автор каталога, помечающий сущности Features с учётными данными меткой собственного изобретения, может написать правило непосредственно для этой метки.

Каждое из них отсутствует в подключении, если сущность Feature не объявляет ни одного значения, а также если её type не разрешается ни в одну сущность каталога.

catalog_annotations описывает сущность, которую называет присоединение. Это другой вопрос, чем annotation_key и annotation_source ниже, которые описывают, как присоединение появилось. Присоединение, записанное в блоке features:, несёт аннотации каталога, не неся ни одного из двух других полей.

Какой слот заполняет вложение: binding

У binding три возможных ответа, и третий не является вариантом второго:

ЗначениеЗначение
имя слотаВложение заполняет объявленный слот вложения с этим именем.
freeВложение не заполняет ни одного объявленного слота. Это положительный вывод: набор слотов был разрешён, и ни один объявленный слот не носит этого имени.
отсутствуетОбъявленный набор слотов сущности Component, на которой размещено вложение, не удалось разрешить, поэтому неизвестно, какой слот заполнен.

Из какого объявленного набора слотов берётся имя, зависит от того, где было написано вложение. Вложение собственного блока узла заполняет слот, который основная сущность Component объявляет в собственной featuresSchema. Вложение, написанное на соединении, — то, у которого есть connection (см. ниже), — заполняет слот, объявленный сокетом соединения в featuresSchema этого сокета на основной сущности Component. Таким образом, одно и то же значение credential в одном вложении именует слот сущности Component, а в другом — слот сокета, и различить их позволяет именно connection.

Сопоставление выполняется по имени — вложение заполняет слот, когда Feature присоединена под именем слота, в блоке компонента или на соединении, — поэтому значение является точным ключом из объявленного набора слотов. Из ключа вложения ничего не извлекается: вложение соединения имеет ключ gpt.credential и сообщает credential. Передаётся имя слота, а не просто флаг, потому что какой именно слот заполнен — более полезная половина ответа.

Вложение, написанное на соединении, никогда не сообщает free. Слоты сокета — единственные имена, которые может нести проходящее через него соединение, а соединение с любым другим именем отклоняется при загрузке сборки, поэтому каждое такое вложение в графе, дошедшем до политики, заполняет объявленный слот.

Политика, которая считает отсутствующий binding равным free, сообщит о неизвестном как о выводе. Проверяйте free явно.

На каком соединении записано присоединение: connection

connection присутствует в каждом присоединении, записанном на одном из соединений узла, и отсутствует в каждом присоединении собственного блока узла. Он содержит два поля — координаты этого соединения на узле:

ПолеЗначение
socketСокет, через который проведено соединение.
aliasПсевдоним, под которым записано соединение.

Эта пара называет одно из рёбер графа: ребро, у которого source — узел, несущий присоединение, а socket и alias — эти значения. target этого ребра — компонент, которому представляется присоединение. Так политика связывает присоединение с тем, чего оно достигает, — этого не может сказать ни один факт самого присоединения, потому что присоединение находится на потребляющем узле:

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])
}

Что утверждает connection и чего не утверждает:

  • Он фиксирует, где автор записал присоединение. Он заполняется из соединения, на котором записано присоединение, и никогда не извлекается из ключа присоединения, поэтому содержит сокет, которого ключ не несёт, а также псевдоним.
  • Он не содержит слот. Какой слот сокета заполняет присоединение, указывает binding, который читается так же, как для любого присоединения; слот сообщается один раз — там.
  • Он не описывает цель. Цель, её метки и то, кто провёл ребро — разработчик, сущность Release или сущность Feature, — это факты ребра и целевого узла, которые читаются там после связывания.
  • Соединение, которое проводит сущность Feature, не несёт присоединений, поэтому ни одно присоединение не несёт connection, называющий такое ребро. Учётные данные, нужные собственному соединению сущности Feature, — это присоединение, заполняющее слот, который объявляет эта сущность Feature, и оно не несёт connection.
  • Отсутствие означает собственный блок узла. Присоединение без connection было записано в собственном features: компонента (или попало туда из более широкой области видимости либо путём расширения по аннотациям). Это не означает, что присоединение не представляется никакому другому компоненту: чего достигают собственные учётные данные компонента, определяется тем, как проведена их доставка, а это поле её не описывает.

Помимо того, что connection определяет, из какого набора объявленных слотов читаются binding и слотовая половина sensitive, он ничего не меняет в присоединении: его FeatureRecipe, его контракт provides, остальные его факты и его место в корзине такие же, как у любого присоединения узла.

Какой FeatureRecipe реализует вложение: realization

realization называет FeatureRecipe, который Manifest сущности Release привязывает к вложению, в виде <name>:<version>. Manifest привязывает по собственному имени вложения, если его уровень name сопоставляет это имя (для вложения, записанного на соединении, — по его полному имени, gpt.credential выше), а иначе — по типу Feature, который называет вложение. Названный FeatureRecipe — тот, с которым сборка тех же документов отрисовывает вложение: граф фиксирует привязку до начала отрисовки, и при отрисовке вложение привязывается так же.

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])
}

Что утверждает realization, а что нет:

  • Это одна и та же пара везде, где она встречается. aggrega inspect выводит её как реализацию вложения, а если целевая платформа проставляет происхождение на том, что отрисовывает, документы, которые отрисовывает этот FeatureRecipe, несут её как значение aggrega.ai/recipe-uri, поэтому политика связывает вложение с тем, что оно отрисовывает, без преобразования между формами.
  • Оно называет FeatureRecipe по имени и версии, а не по возможности. Две возможности могут каждая опубликовать FeatureRecipe под одними и теми же именем и версией. Какой из них привязан, определяет сопоставление в Manifest, которое называет возможность везде, где одного имени было бы недостаточно для однозначности; это поле его не повторяет.
  • Собственные вложения границы Release тоже его несут, в boundary_features, и читаются так же. Вложение уровня границы также достигает каждого компонента, который содержит граница, и несёт там ту же реализацию.
  • Отсутствие означает, что вложение ни к чему не привязано. Вложение, которое Manifest не привязывает ни к одному FeatureRecipe из каталога, не несёт realization. Сборка такой композиции останавливается до отрисовки, называя несопоставленное вложение, но политика в этой роли вызывается до этой остановки, поэтому может встретить вложение без него. Правило выше пропускает такое вложение, потому что его тело сначала связывает realization; правило, которое должно о нём сообщать, явно проверяет отсутствие ключа.

Как возникло подключение: origin и два сопутствующих поля

origin отличает подключение, написанное разработчиком вручную, от подключения, созданного расширением на основе аннотаций:

ЗначениеЗначение
explicitНаписано в блоке features:.
annotationСоздано расширением на основе аннотаций.
mixedЛистья values или infra подключения содержат смесь обоих вариантов; подробности по каждому листу — в картах происхождения.

annotation_key называет аннотацию, которая породила синтетическое подключение, а annotation_source указывает место её объявления в виде <release-file-path>:<dotted-yaml-key-path>. Оба поля отсутствуют, когда origin равно explicit.

Заданные автором полезные нагрузки: values, infra и inject

values — это операционная конфигурация присоединения, зона ответственности разработчика. infra — его физические размеры для каждого экземпляра, зона ответственности оператора. inject — агностичная маршрутизация внедрения: она сопоставляет ключи доставки с ключами provides, из которых они заполняются, и сгруппирована в первую очередь по механизму доставки.

Что содержит values присоединения учётных данных, выбирает автор, и компилятор переносит то, что было записано, не разрешая ни один из вариантов: учётные данные по ссылке содержат указатель на хранилище секретов, а учётные данные по значению содержат сам материал. В любом случае лист, который присоединённая сущность Feature объявляет чувствительным, поступает в политику скрытым, как описано в следующем разделе; лист, который она оставляет необъявленным, например опубликованный локатор, поступает в том виде, в каком был записан.

Значения, объявленные чувствительными, поступают скрытыми

Каждый лист, который граф помечает как объявленный чувствительным, поступает в этот сокет в виде маркера сокрытия, а не значения, которое написал автор. Маркер — это объект с одним ключом, содержащий причину отсутствия значения:

{ "aggrega_withheld": "declared" }

declared означает, что лист покрыт объявлением. Полезная нагрузка, которую вообще не удалось прочитать, скрывается целиком с причиной unreadable, поскольку ни один лист внутри неё невозможно оценить.

Сокрытие следует собственным пометкам графа, поэтому оно затрагивает ровно те листы, которые они называют, где бы те ни находились:

  • values и infra каждого вложения, какая бы область их ни написала — собственный блок компонента, подсистема, граница или Release, расширение на основе аннотаций, — и независимо от того, написаны ли они в собственном блоке узла или на одном из его соединений, по листам, которые называет его sensitive_payload_leaves;
  • infra вложения уровня границы в boundary_features — по его собственной пометке;
  • собственные values и infra узла в values_mapping и infra_mapping — по собственному sensitive_payload_leaves узла;
  • собственные values и infra соединения — на ребре и в записи uses потребляющего узла — по sensitive_payload_leaves ребра, которое называет листья, объявленные чувствительными сокетом потребляющего компонента.

То, на чём основывает свои выводы политика, остаётся нетронутым. Тип, разрешённая версия, метки, аннотации каталога, binding, connection, realization, origin и его карты происхождения, все три факта чувствительности и каждый лист, не помеченный ни одним объявлением, поступают в записанном виде. Ключ скрытого листа тоже сохраняется, поэтому политика по-прежнему видит, какие листы содержит полезная нагрузка и какие из них содержат объявленный материал, — отсутствует только значение. Поэтому правило о том, куда и каким путём перемещается материал, объявленный чувствительным, полностью выразимо; правило о содержимом этого материала — нет, и так задумано.

Написанный автором блок uses узла, переносимый на узле рядом с его рёбрами, сохраняет для каждого вложения, написанного на соединении, только его type и description. Значения вложения переносятся один раз — на самом вложении, где их затрагивает сокрытие.

Политика, которой нужно отличить скрытый лист от написанного автором, проверяет наличие ключа маркера:

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])
}

Это то же сокрытие, которое применяет --ir-graph, когда команда выводит граф, и aggrega/irGraph демона, когда он отвечает клиенту, поэтому политика и человек, читающий граф, видят одни и те же скрытые листы. Эти интерфейсы возвращают значения человеку, который запрашивает их с --unredacted; в полезной нагрузке, которую получает политика, такого запроса нет, и собственные объявленные значения узла скрываются от неё на тех же условиях, что и значения вложения. Сокрытие применяется к полезной нагрузке, которую получает политика, и ни к чему больше: граф, по которому выполняется рендеринг сборки, не затрагивается, поэтому сокрытие не меняет ни одного отрендеренного байта. Из того, что получает политика render-verdict, ничего не скрывается, поскольку эта роль оценивает именно отрендеренные артефакты.

Откуда взялся каждый лист: values_provenance и infra_provenance

Каждая из этих карт индексируется путём к листу через точку внутри своего раздела, и каждая запись фиксирует origin этого листа — то же различие explicit / annotation, применённое к одному листу за раз. Лист, внесённый аннотацией, дополнительно несёт поверхность авторинга, на которой он был объявлен, ключ аннотации, внёсший его, и расположение этого объявления в исходном коде. Если явный лист перезаписал лист, внесённый аннотацией, запись также содержит подавленный вклад, который он заменил, так что политика видит, что было переопределено, а не только то, что победило.

Три единицы чувствительности

Полезная нагрузка несёт три факта о чувствительности, и они относятся к трём разным единицам: целое вложение, один ключ доставки, один лист полезной нагрузки.

Каждый вычисляется из собственных входных данных. Ни один не выводится из другого, и в частности ответ для вложения никогда не распространяется вниз на более узкие единицы. Смешение любых двух из них даёт политику, которая ошибается незаметно, поэтому стоит разобрать все три по отдельности, прежде чем писать правило против любого из них.

Каждый из них выводится из того, что автор объявил, — sensitive: true на листе схемы сущности Feature или sensitive: true на слоте вложения, который объявляет сущность Component, для собственных вложений или на одном из своих сокетов. Содержимое значений не проверяется, и из имени поля не извлекается никакой смысл.

sensitive — один ответ для всего вложения

Истинно, когда либо вложенная сущность Feature объявляет чувствительный лист в своих values, infra или provides, либо слот, который заполняет вложение, объявляет, что всё, что к нему привязывается, обрабатывает секретный материал, — слот вложения с тем же именем у сущности Component хоста или, для вложения с connection, слот с этим именем, объявленный сокетом соединения. Не задано, когда ни одного из этих объявлений нет.

Этот ответ говорит о том, что представляет собой сущность, поэтому он намеренно не зависит от того, что написал конкретный автор. Он читает объявления сущности Feature, а не подмножество чувствительных листьев, которые это вложение заполнило, поскольку поле, чувствительное в одном Release и нечувствительное в другом, было бы бесполезно для политики, рассуждающей о сущности каталога.

Обе половины независимы, и каждая действует сама по себе. Сущность Feature, которая не объявляет ни одного чувствительного листа, всё равно привязывается к чувствительному слоту как чувствительное вложение, потому что так указал слот. Заполнение, объявляющее чувствительный лист, является чувствительным вложением, даже если слот такого объявления не делал, и даже если это свободное вложение, не привязанное ни к какому слоту.

sensitive_inject — один ответ на каждый ключ доставки

Подмножество inject, чей упомянутый ключ provides вложенная сущность Feature объявляет чувствительным, в собственной форме inject: механизм, затем ключ доставки, а в качестве значения — упомянутый ключ provides.

Ключ доставки, заполняемый из ключа provides, который сущность Feature пометила как чувствительный, попадает сюда; ключ, заполняемый из непомеченного ключа, не попадает, даже в том же вложении и в том же механизме. Отсутствует, когда вложение не объявляет механизма доставки или не ссылается ни на один чувствительный ключ provides.

sensitive_payload_leaves — один ответ на каждый лист полезной нагрузки

Листья, которые несёт полезная нагрузка этого вложения, чей путь вложенная сущность Feature объявляет чувствительным, каждый в виде пути через точку с префиксом раздела, который занимает элемент данных: values.<path> или infra.<path>.

Здесь читается та полезная нагрузка, которую вложение в итоге несёт, а не блок, написанный автором. Лист со значением, которое схема сущности Feature объявляет как default, указывается наравне с листом, значение которого написал автор: заполненное значение по умолчанию — это данные, которые несёт полезная нагрузка, а пометка, считанная только с написанного блока, оставила бы его неуказанным.

Лист попадает в список, когда путь, объявленный чувствительным в схеме сущности Feature, покрывает его, — объявление называет этот лист или объект, который его содержит. Сопоставление идёт посегментно по пути через точку, поэтому объявление на db покрывает db.password и не затрагивает соседний лист с именем dbPassword. Из текста самого пути ничего не извлекается, и ни одно значение не проверяется: написал ли автор в помеченном листе сам материал или указатель на него, здесь узнать нельзя, и пометка этого не утверждает.

Сравнение идёт по полезной нагрузке, развёрнутой до листьев, а не по ключам верхнего уровня раздела, поэтому лист во вложенной карте сравнивается так же, как любой другой.

Листья поступают в том порядке, в котором их содержит полезная нагрузка: листья раздела values перед листьями раздела infra, — в том же порядке, что и сами полезные нагрузки; именно это сохраняет побайтовую идентичность передаваемых данных между запусками на одинаковых входных данных.

Эта единица отвечает на вопрос, куда это вложение поместило данные, а это неизбежно меняется от одного Release к другому. Поэтому она пересекается с тем, что было написано, а sensitive нет: они отвечают на разные вопросы, и применение любого из правил к другому полю нарушило бы его.

Как читать все три вместе

Автор вкладывает сущность Feature для учётных данных, которая объявляет чувствительными свой лист значений literalPassword и свой ключ provides password, заполняет объявленный слот credentials и пишет пароль прямо в тексте:

{
"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"]
}

Три разных вопроса — три разных ответа. Вложение вообще обрабатывает материал, объявленный чувствительным (sensitive). Ключ окружения DATABASE_PASSWORD является одним из тех, что его несут (sensitive_inject). А полезная нагрузка этого вложения несёт значение именно в values.literalPassword (sensitive_payload_leaves), тогда как values.secretName — локатор, который сущность Feature намеренно оставляет непомеченным, — в этом списке отсутствует, хотя полезная нагрузка тоже его несёт. Пароль, написанный автором, поступает скрытым, а локатор рядом с ним — в том виде, в каком написан: пометка сообщает политике, что значение есть, а само значение до неё никогда не доходит.

Правилу, запрещающему секрет в явном виде в отрисованном артефакте, нужен третий факт. Правилу, требующему, чтобы каждое вложение, работающее с учётными данными, имело метку владельца, нужен первый. Подмена одного другим меняет то, какие сборки останавливаются.

Отсутствие — не разрешение

Лист указывается только там, где его покрывает объявление. Поэтому отсутствие sensitive_payload_leaves означает, что это вложение не называет ни одного листа, который его сущность Feature объявляет чувствительным, — но никогда не означает, что полезная нагрузка нечувствительна. Оно также не отличает вложение, у которого нет такого листа, от источника, который вообще не сообщает об этой оси: эти два случая остаются неразличимыми, и тот, кто читает отсутствующий ключ, узнаёт только это и ничего больше.

Гостевой модуль, который считает отсутствие списка листьев разрешением отобразить или вывести значение в открытом виде, прочитал пометку наоборот.

Ключ полностью опускается из передаваемых данных, когда он был бы пустым, поэтому вложение, чьи сущность Feature и слот ничего не объявляют, несёт ровно те байты, которые несло бы, если бы пометки не существовало. Именно это опускание облегчает неверное прочтение, и поэтому направление стоит сформулировать явно.

Нагляднее всего это видно на чувствительном вложении, которое не указывает ни одного листа. Возьмём вложение выше и изменим две вещи: автор пишет только локатор, оставляя объявленный чувствительным лист незаполненным, и заполняет ключ окружения из непомеченного ключа provides name сущности Feature вместо password:

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

sensitive по-прежнему истинно — объявления сущности Feature не изменились, — а обе более узкие единицы исчезли. Вложение по-прежнему обрабатывает секретный материал; просто не через лист или ключ доставки, которые несёт это вложение. Политика, опирающаяся на сводный признак, запрещает эту сборку, а политика, опирающаяся на пометку по листьям, пропускает её. Оба правила обоснованны, и какое из них нужно политике, — это решение, которое автор политики принимает осознанно.

Та же асимметрия действует и в обратную сторону для sensitive_inject: вложение может содержать чувствительный лист, не передавая ничего чувствительного через ключ доставки, или передавать чувствительный ключ provides, не задавая вообще никакого значения.

Чего не делает объявление чувствительности

Пометка аннотирует, но не является механизмом контроля. Объявление листа или слота чувствительным ничего не шифрует, не проверяет и не отклоняет значение и не навязывает механизм доставки. Ни один результат сборки не меняется из-за наличия объявления.

На большинстве целевых платформ оно также не меняет ни одного отрисованного байта: объявленное чувствительным значение, указанное автором inline, отрисовывается точно так же, как необъявленное. Terraform — исключение среди целевых платформ стандартной библиотеки, поскольку у него есть собственный примитив чувствительности на уровне отдельного значения, на который может лечь объявление, — см. providers/terraform.md, раздел «Declared-sensitive module inputs». У целевой платформы без собственного понятия чувствительности объявлению нечего менять.

Повсюду объявления делают одно: они делают факт видимым — для собственного отладочного вывода компилятора и для политики в этом сокете, которая решает, что с ним делать. Превратить пометку в результат сборки — задача политики, ради этого и существует этот сокет. При этом политика узнаёт об объявленном чувствительным материале, не получая его самого: пометка поступает, а значение поступает скрытым.

Перекрёстные ссылки

  • policy-socket.md — сокет управления: четыре роли, уровни серьёзности вердиктов, канал ввода оператора, движки политик, поставляемые в составе компилятора, и подключение плагина к рабочему пространству.
  • plugin-contract.md — место сокета в конвейере и его типизированные форматы передачи данных.
  • справочник по схеме графа — поле за полем контракт графа сборки, включая каждое поле вложения.
  • entities/component.md «Attachment Slots» — объявление слота и объявление слота чувствительным, а также featuresSchema, которую сокет объявляет для проходящих через него соединений.
  • entities/aggregate.md «A connection’s own attachments» — запись вложения на соединении и имя, которое оно получает.
  • vocabulary/compact-form-authoring.md «Declaring a leaf sensitive» — ключевое слово sensitive: и предел того, чего достигает его объявление.
  • vocabulary/labels-and-annotations.md — поверхности меток и аннотаций, которые читает политика.