DOCA SHA Offload Engine
Examples
- “Can I offload SHA in an existing OpenSSL pipeline without
rewriting?” — this is in scope. Load the engine; do not
start a new
doca-sha pipeline here.
- “How do I prove OpenSSL used DOCA SHA, not CPU SHA?” —
use the SHA-224 negative test; do not treat a successful
digest as proof of offload.
Quick answer (answer from this file)
- Device gate first. The DOCA SHA engine exists only on BlueField-2;
BlueField-3 has no SHA acceleration engine (public DOCA SHA guide), so
there is nothing to offload there: say so and stop.
- Load probe:
openssl engine dynamic -pre NO_VCHECK:1 -pre SO_PATH:<engine .so> -pre LOAD -vvv -t -c.
- Positive test:
openssl dgst -sha256 -engine <engine .so> -engine_impl <file>
reports the engine was set.
- Negative test: an unsupported digest (
-sha224) must fail with the
engine selected; it must not silently fall back.
- Performance: compare
openssl speed -evp sha256 with and without
the engine (add -async_jobs for parallelism). Report measured numbers
only; never quote numbers from memory.
Instructions
Follow Loading order below. Open the tasks companion for
configure / run. Open the capabilities companion for when
offload wins and how to verify it. Do not open every
companion file.
Where to start: This is a tool skill for the OpenSSL
ENGINE installed by the doca-sha-offload-engine package
under ${DOCA_DIR}/tools/doca_sha_offload_engine/ as
libdoca_sha_offload_engine.so, next to its
engine_readme.md. It is not a CLI —
it is a shared object loaded by an OpenSSL-based
application or by openssl itself, that re-routes SHA-1 /
SHA-256 / SHA-512 (one-shot only, via the EVP_Digest
interface) onto the DOCA SHA hardware path. Open
the tasks companion and start at
## configure for the PCIe-address
configuration and the OpenSSL prerequisites; jump to
## run for the “load the engine and
prove it actually runs” flow. Open
the capabilities companion when the question is
what the engine actually offloads vs falls back to,
when the engine is a perf win vs not, or how to verify
offload actually engaged. If DOCA is not installed yet,
route to doca-setup/SKILL.md first.
If the user is building a new SHA pipeline from scratch
(not wrapping an existing OpenSSL-based one), this skill
is the wrong surface — route to
../../libs/doca-sha/SKILL.md (doca-sha/SKILL.md)
instead.
Example questions this skill answers well
The CLASSES of doca-sha-offload-engine questions this
skill is built to answer, each with one worked example.
The class is the load-bearing piece; the worked example
is one instance.
- “I have an existing OpenSSL-based pipeline doing SHA;
can I offload the SHA to DOCA without rewriting the
app?” — worked example: “the app uses
EVP_DigestInit_ex / EVP_DigestUpdate /
EVP_DigestFinal_ex against EVP_sha256(); can I
drop in DOCA-SHA offload via an engine load?”.
Answered by the “when this engine is the right
surface” rule in
the capabilities companion
- the engine-load mechanics in
the tasks companion.
- “Did the engine actually load? Or did OpenSSL just
fall back to software SHA?” — worked example: “my
openssl dgst invocation completed; how do I know
DOCA SHA actually did the work and OpenSSL did not
silently use the software path?”. Answered by the
“prove the engine actually ran” pattern in
the capabilities companion
(the SHA-224 negative test and the -engine_impl
flag) + the verification flow in
the tasks companion.
- “For what message-size range is the engine offload a
win vs CPU SHA?” — worked example: “my pipeline
hashes 4 KB blocks at a time; is the engine a win
there, or does the round-trip to DOCA SHA cost more
than the CPU hash itself?”. Answered by the
message-size-window rule in
the capabilities companion
- the
openssl speed perf-comparison pattern in
the tasks companion.
- “What SHA algorithms does the engine actually
support — and what happens for the ones it does not?”
— worked example: “my pipeline mixes SHA-1, SHA-256,
SHA-512, and SHA-224 — what does the engine do for
each?”. Answered by the algorithm-coverage matrix in
the capabilities companion.
- “Should I use this engine, or call doca-sha
directly?” — worked example: “I am writing a new
service from scratch; does the engine save me work or
does it add complexity I do not need?”. Answered by
the “engine vs library” selection table in
the capabilities companion.
- “What OpenSSL versions does the engine require, and
what about OpenSSL 3.x's deprecation of the ENGINE
API?” — worked example: “my host has OpenSSL 3.0;
will the engine still load?”. Answered by the version
overlay in
the capabilities companion
(verified surface: the engine is documented for
OpenSSL 1.1.1f on Ubuntu 20.04 and OpenSSL 3.0.2 on
Ubuntu 22.04 per the shipped
engine_readme.md).
When to load this skill
Load this skill when the user is — or the agent needs to
— deploy the DOCA SHA Offload Engine into an OpenSSL-based
pipeline on a host with DOCA installed and a SHA-capable
device. Concretely:
- Wiring the engine into an existing OpenSSL-based
application or
openssl CLI invocation, with the
intent of no source-level code changes (or only the
minimum ENGINE_load_dynamic / ENGINE_by_id block
shown in the shipped engine_readme.md).
- Verifying the engine actually engaged for the
hot-path digests (the “is offload real or did OpenSSL
fall back to software” question).
- Characterizing the message-size range over which the
engine is a perf win vs the CPU
sha1 / sha256 /
sha512 paths.
- Deciding between “adopt the engine” (existing
pipeline, minimal change) and “rewrite to doca-sha”
(new pipeline, fine-grained control needed).
Do not load this skill for users building a new
SHA-pipeline from scratch — route to
../../libs/doca-sha/SKILL.md (doca-sha/SKILL.md).
Do not load this skill for users wanting algorithms the
engine does not implement (MD5, SHA-3, SHA-224, HMAC-SHA,
streaming/incremental SHA via EVP_DigestUpdate chains
that the engine treats as one-shot only).
What this skill provides
This is a thin loader. Substantive material lives in
two companion files:
- the capabilities companion — what the engine offloads (verified:
one-shot SHA-1, SHA-256, SHA-512 via the OpenSSL
EVP_Digest high-level interface), what it does NOT
offload (anything else — including SHA-224, MD5,
SHA-3, HMAC-SHA, and any chained
EVP_DigestInit_ex / EVP_DigestUpdate /
EVP_DigestFinal_ex pattern that the engine implements
by buffering and then calling DOCA SHA in one shot at
Final), the engine-vs-library selection rule, the
message-size-window rule for when offload is a perf
win, the verified ctrl-cmd surface (set_pci_addr),
the version overlay (OpenSSL ≥ 1.1.1; the shipped
engine_readme.md documents testing on OpenSSL 1.1.1f and 3.0.2; OpenSSL 3.x deprecates the ENGINE
API but still supports it via the legacy code path),
the layered error taxonomy, the observability surface
(the “prove offload engaged” pattern using the
SHA-224 negative test and -engine_impl), and the
safety overlay.
- the tasks companion — step-by-step workflows for the in-scope
task verbs:
install, configure (PCIe address
selection — the engine defaults to 03:00.0 and
exposes the set_pci_addr ctrl-cmd), build (none:
the package ships the engine pre-built), modify (refuses
engine patching; modify the load-time invocation and the
PCIe address instead), run (load the engine via
openssl engine dynamic; the verification pattern;
the OpenSSL programmatic ENGINE_load_dynamic block),
test (the “prove the engine ran” SHA-224 negative
test; the openssl speed perf comparison; the
message-size window characterization), debug (walk
the error taxonomy layer by layer), use (the
engine-vs-library decision for the user's specific
pipeline), plus a Deferred task verbs block.
The skill assumes a host where DOCA is already installed,
OpenSSL ≥ 1.1.1 is present (libssl-dev or equivalent),
and the deploying user can access the selected DOCA SHA PCIe device. Verify
device visibility and run the engine-load smoke as that same user before
integration; if either fails with a permission error, stop and route to
doca-setup rather than guessing a group, ACL, or sudo policy.
What this skill deliberately does not ship
This skill is agent guidance, not a samples or
scripts bundle. It deliberately does not contain — and
pull requests should not add:
- Pre-written OpenSSL ENGINE application source code
beyond the verbatim block in the shipped
engine_readme.md (the ENGINE_load_dynamic /
ENGINE_by_id / ENGINE_ctrl_cmd_string /
ENGINE_init / ENGINE_set_default_digests sequence,
cross-referenced into the tasks companion).
The shipped readme is the worked example.
- A
samples/, bindings/, or reference/
subtree. This is a thin loader for a shipped
shared-object; substantive material lives in the
shipped engine_readme.md and the doca-sha library docs.
- Performance numbers from agent memory. The
message-size-window where the engine wins is
device-, firmware-, OpenSSL-version-, and
workload-specific. The
openssl speed comparison
pattern in the tasks companion is the
way to capture it on the user's actual hardware;
quoting a number from memory is the cross-platform
failure mode this skill exists to prevent.
- Wrappers, parsers, or scripts in any language
that consume the engine's stdout or the
openssl speed output format.
Loading order
- Read this skill first to confirm the user's
question is in scope (the user actually has an
existing OpenSSL-based pipeline and wants to offload
to DOCA SHA without code changes; if the user is
building from scratch, route to
../../libs/doca-sha/ (doca-sha/SKILL.md)).
- For what the engine offloads vs falls back, the
engine-vs-library selection rule, the message-size-
window rule, the version overlay, the error taxonomy,
the observability surface (and the prove-offload-
actually-engaged pattern), and the safety overlay,
see the capabilities companion.
- For step-by-step workflows —
install,
configure, build, modify, run, test,
debug, use — see the tasks companion.
Related skills
../../libs/doca-sha/SKILL.md (doca-sha/SKILL.md) —
the underlying DOCA SHA library. The engine is a
thin OpenSSL-ENGINE wrapper around doca-sha; when the
user needs fine-grained control over the SHA task
surface (partial-hash, custom buffer permissions,
cap-query for unusual message sizes), the library is
the right answer. The engine wraps the one-shot
task; the library exposes both one-shot and partial-
hash per
doca-sha/SKILL.md.
doca-version/SKILL.md — the
canonical version-detection chain. The engine has a
TWO-axis version overlay (DOCA-side and OpenSSL-side);
the version skill carries the four-way match rule
this skill layers on top of.
doca-debug/SKILL.md — the
cross-cutting debug ladder. The engine surfaces its
own error taxonomy; when the cause is below DOCA
(driver, firmware), the taxonomy hands off here.
doca-setup/SKILL.md — env
preparation, install verification, the libssl-dev
install path, and the NGC DOCA container path.
doca-public-knowledge-map/SKILL.md —
routing to the public DOCA SHA documentation set on
docs.nvidia.com/doca/sdk/ and to the OpenSSL
ENGINE / openssl-engine upstream documentation on
openssl.org.
doca-hardware-safety/SKILL.md —
the bundle-wide hardware-safety meta-policy. The
engine binds to a specific PCIe device; the
set_pci_addr ctrl is the artifact-specific overlay,
but any host-side change underneath (firmware burn,
BFB reflash) runs through the meta-policy.
1---2license: Apache-2.03name: doca-sha-offload-engine4description: >5 Use this skill when wiring the DOCA SHA Offload Engine (an OpenSSL6 ENGINE) into an existing OpenSSL pipeline to offload one-shot SHA-1,7 SHA-256, or SHA-512 (EVP_Digest) onto DOCA SHA hardware without8 rewriting against doca-sha. Covers engine load mechanics (`openssl9 engine dynamic`, `set_pci_addr` ctrl, `-engine_impl`), the SHA-22410 negative test that proves offload engaged, the message-size window11 where offload beats CPU SHA, and engine-vs-library selection. Trigger12 even when the user does not say "DOCA SHA Offload Engine" or "OpenSSL13 ENGINE" — typical implicit phrasings: "speed up openssl SHA on14 BlueField", "offload SHA without code changes", "is openssl using the15 accelerator or falling back to software", "prove DOCA SHA actually16 ran", "openssl dgst hashed but I'm not sure it was offloaded". Refuse17 and route elsewhere for new SHA pipelines (use doca-sha), MD5 / SHA-318 / SHA-224 / HMAC-SHA offload, incremental hashing via chained19 `EVP_DigestUpdate`, or OpenSSL PROVIDER authoring.20metadata:21 source: https://skillmd.com/skills/nvidia/doca-sha-offload-engine22 author: NVIDIA <doca-feedback@nvidia.com>23 kind: tool24 doca_version: "3.5"25 tags:26 - doca27 - sha28 - openssl29compatibility: >30 Requires DOCA SDK installed at /opt/mellanox/doca on Linux (Ubuntu31 22.04/24.04 or RHEL/SLES) with a BlueField-2 DPU (not BF-3)32 attached, plus OpenSSL ≥ 1.1.1 (libssl-dev for ENGINE API callers)33 on the build host. The engine ships under34 /opt/mellanox/doca/tools/doca_sha_offload_engine/ as35 libdoca_sha_offload_engine.so; reads the user's local install via36 `pkg-config doca-sha` and inspects37 /opt/mellanox/doca/{lib,include,samples,applications}. The validation38 steps require a live DOCA install.39---4041# DOCA SHA Offload Engine4243## Examples4445- **“Can I offload SHA in an existing OpenSSL pipeline without46 rewriting?”** — this is in scope. Load the engine; do not47 start a new `doca-sha` pipeline here.48- **“How do I prove OpenSSL used DOCA SHA, not CPU SHA?”** —49 use the SHA-224 negative test; do not treat a successful50 digest as proof of offload.5152## Quick answer (answer from this file)53541. **Device gate first.** The DOCA SHA engine exists only on BlueField-2;55 BlueField-3 has no SHA acceleration engine (public DOCA SHA guide), so56 there is nothing to offload there: say so and stop.572. **Load probe:** `openssl engine dynamic -pre NO_VCHECK:1 -pre SO_PATH:<engine .so> -pre LOAD -vvv -t -c`.583. **Positive test:** `openssl dgst -sha256 -engine <engine .so> -engine_impl <file>`59 reports the engine was set.604. **Negative test:** an unsupported digest (`-sha224`) must fail with the61 engine selected; it must not silently fall back.625. **Performance:** compare `openssl speed -evp sha256` with and without63 the engine (add `-async_jobs` for parallelism). Report measured numbers64 only; never quote numbers from memory.6566## Instructions6768Follow Loading order below. Open the tasks companion for69configure / run. Open the capabilities companion for when70offload wins and how to verify it. Do not open every71companion file.7273**Where to start:** This is a tool skill for the OpenSSL74ENGINE installed by the `doca-sha-offload-engine` package75under `${DOCA_DIR}/tools/doca_sha_offload_engine/` as76`libdoca_sha_offload_engine.so`, next to its77`engine_readme.md`. It is **not a CLI** —78it is a shared object loaded by an OpenSSL-based79application or by `openssl` itself, that re-routes SHA-1 /80SHA-256 / SHA-512 (one-shot only, via the `EVP_Digest`81interface) onto the DOCA SHA hardware path. Open82the tasks companion and start at83`## configure` for the PCIe-address84configuration and the OpenSSL prerequisites; jump to85`## run` for the *“load the engine and86prove it actually runs”* flow. Open87the capabilities companion when the question is88*what the engine actually offloads vs falls back to*,89*when the engine is a perf win vs not*, or *how to verify90offload actually engaged*. If DOCA is not installed yet,91route to `doca-setup/SKILL.md` first.92If the user is building a new SHA pipeline from scratch93(not wrapping an existing OpenSSL-based one), this skill94is the wrong surface — route to95`../../libs/doca-sha/SKILL.md` (`doca-sha/SKILL.md`)96instead.9798## Example questions this skill answers well99100The CLASSES of `doca-sha-offload-engine` questions this101skill is built to answer, each with one worked example.102The class is the load-bearing piece; the worked example103is one instance.104105- **“I have an existing OpenSSL-based pipeline doing SHA;106 can I offload the SHA to DOCA without rewriting the107 app?”** — worked example: *“the app uses108 `EVP_DigestInit_ex` / `EVP_DigestUpdate` /109 `EVP_DigestFinal_ex` against `EVP_sha256()`; can I110 drop in DOCA-SHA offload via an engine load?”*.111 Answered by the *“when this engine is the right112 surface”* rule in113 the capabilities companion114 + the engine-load mechanics in115 the tasks companion.116- **“Did the engine actually load? Or did OpenSSL just117 fall back to software SHA?”** — worked example: *“my118 `openssl dgst` invocation completed; how do I know119 DOCA SHA actually did the work and OpenSSL did not120 silently use the software path?”*. Answered by the121 *“prove the engine actually ran”* pattern in122 the capabilities companion123 (the SHA-224 negative test and the `-engine_impl`124 flag) + the verification flow in125 the tasks companion.126- **“For what message-size range is the engine offload a127 win vs CPU SHA?”** — worked example: *“my pipeline128 hashes 4 KB blocks at a time; is the engine a win129 there, or does the round-trip to DOCA SHA cost more130 than the CPU hash itself?”*. Answered by the131 message-size-window rule in132 the capabilities companion133 + the `openssl speed` perf-comparison pattern in134 the tasks companion.135- **“What SHA algorithms does the engine actually136 support — and what happens for the ones it does not?”**137 — worked example: *“my pipeline mixes SHA-1, SHA-256,138 SHA-512, and SHA-224 — what does the engine do for139 each?”*. Answered by the algorithm-coverage matrix in140 the capabilities companion.141- **“Should I use this engine, or call doca-sha142 directly?”** — worked example: *“I am writing a new143 service from scratch; does the engine save me work or144 does it add complexity I do not need?”*. Answered by145 the *“engine vs library”* selection table in146 the capabilities companion.147- **“What OpenSSL versions does the engine require, and148 what about OpenSSL 3.x's deprecation of the ENGINE149 API?”** — worked example: *“my host has OpenSSL 3.0;150 will the engine still load?”*. Answered by the version151 overlay in152 the capabilities companion153 (verified surface: the engine is documented for154 OpenSSL 1.1.1f on Ubuntu 20.04 and OpenSSL 3.0.2 on155 Ubuntu 22.04 per the shipped `engine_readme.md`).156157## When to load this skill158159Load this skill when the user is — or the agent needs to160— deploy the DOCA SHA Offload Engine into an OpenSSL-based161pipeline on a host with DOCA installed and a SHA-capable162device. Concretely:163164- Wiring the engine into an existing OpenSSL-based165 application or `openssl` CLI invocation, with the166 intent of no source-level code changes (or only the167 minimum `ENGINE_load_dynamic` / `ENGINE_by_id` block168 shown in the shipped `engine_readme.md`).169- Verifying the engine actually engaged for the170 hot-path digests (the *“is offload real or did OpenSSL171 fall back to software”* question).172- Characterizing the message-size range over which the173 engine is a perf win vs the CPU `sha1` / `sha256` /174 `sha512` paths.175- Deciding between *“adopt the engine”* (existing176 pipeline, minimal change) and *“rewrite to doca-sha”*177 (new pipeline, fine-grained control needed).178179Do **not** load this skill for users building a new180SHA-pipeline from scratch — route to181`../../libs/doca-sha/SKILL.md` (`doca-sha/SKILL.md`).182Do not load this skill for users wanting algorithms the183engine does not implement (MD5, SHA-3, SHA-224, HMAC-SHA,184streaming/incremental SHA via `EVP_DigestUpdate` chains185that the engine treats as one-shot only).186187## What this skill provides188189This is a **thin loader**. Substantive material lives in190two companion files:191192- the capabilities companion — what the engine offloads (verified:193 one-shot SHA-1, SHA-256, SHA-512 via the OpenSSL194 `EVP_Digest` high-level interface), what it does NOT195 offload (anything else — including SHA-224, MD5,196 SHA-3, HMAC-SHA, and any chained197 `EVP_DigestInit_ex` / `EVP_DigestUpdate` /198 `EVP_DigestFinal_ex` pattern that the engine implements199 by buffering and then calling DOCA SHA in one shot at200 `Final`), the engine-vs-library selection rule, the201 message-size-window rule for when offload is a perf202 win, the verified ctrl-cmd surface (`set_pci_addr`),203 the version overlay (OpenSSL ≥ 1.1.1; the shipped204 `engine_readme.md` documents testing on OpenSSL 1.1.1f and 3.0.2; OpenSSL 3.x deprecates the ENGINE205 API but still supports it via the legacy code path),206 the layered error taxonomy, the observability surface207 (the *“prove offload engaged”* pattern using the208 SHA-224 negative test and `-engine_impl`), and the209 safety overlay.210- the tasks companion — step-by-step workflows for the in-scope211 task verbs: `install`, `configure` (PCIe address212 selection — the engine defaults to `03:00.0` and213 exposes the `set_pci_addr` ctrl-cmd), `build` (none:214 the package ships the engine pre-built), `modify` (refuses215 engine patching; modify the load-time invocation and the216 PCIe address instead), `run` (load the engine via217 `openssl engine dynamic`; the verification pattern;218 the OpenSSL programmatic `ENGINE_load_dynamic` block),219 `test` (the *“prove the engine ran”* SHA-224 negative220 test; the `openssl speed` perf comparison; the221 message-size window characterization), `debug` (walk222 the error taxonomy layer by layer), `use` (the223 engine-vs-library decision for the user's specific224 pipeline), plus a `Deferred task verbs` block.225226The skill assumes a host where DOCA is already installed,227OpenSSL ≥ 1.1.1 is present (`libssl-dev` or equivalent),228and the deploying user can access the selected DOCA SHA PCIe device. Verify229device visibility and run the engine-load smoke as that same user before230integration; if either fails with a permission error, stop and route to231`doca-setup` rather than guessing a group, ACL, or `sudo` policy.232233## What this skill deliberately does not ship234235This skill is **agent guidance**, not a samples or236scripts bundle. It deliberately does not contain — and237pull requests should not add:238239- **Pre-written OpenSSL ENGINE application source code**240 beyond the verbatim block in the shipped241 `engine_readme.md` (the `ENGINE_load_dynamic` /242 `ENGINE_by_id` / `ENGINE_ctrl_cmd_string` /243 `ENGINE_init` / `ENGINE_set_default_digests` sequence,244 cross-referenced into the tasks companion).245 The shipped readme is the worked example.246- **A `samples/`, `bindings/`, or `reference/`247 subtree.** This is a thin loader for a shipped248 shared-object; substantive material lives in the249 shipped `engine_readme.md` and the doca-sha library docs.250- **Performance numbers from agent memory.** The251 message-size-window where the engine wins is252 device-, firmware-, OpenSSL-version-, and253 workload-specific. The `openssl speed` comparison254 pattern in the tasks companion is the255 way to capture it on the user's actual hardware;256 quoting a number from memory is the cross-platform257 failure mode this skill exists to prevent.258- **Wrappers, parsers, or scripts** in any language259 that consume the engine's stdout or the `openssl260 speed` output format.261262## Loading order2632641. Read this skill first to confirm the user's265 question is in scope (the user actually has an266 existing OpenSSL-based pipeline and wants to offload267 to DOCA SHA *without* code changes; if the user is268 building from scratch, route to269 `../../libs/doca-sha/` (`doca-sha/SKILL.md`)).2702. **For what the engine offloads vs falls back, the271 engine-vs-library selection rule, the message-size-272 window rule, the version overlay, the error taxonomy,273 the observability surface (and the prove-offload-274 actually-engaged pattern), and the safety overlay,275 see the capabilities companion.**2763. **For step-by-step workflows — `install`,277 `configure`, `build`, `modify`, `run`, `test`,278 `debug`, `use` — see the tasks companion.**279280## Related skills281282- `../../libs/doca-sha/SKILL.md` (`doca-sha/SKILL.md`) —283 the underlying DOCA SHA library. The engine is a284 thin OpenSSL-ENGINE wrapper around doca-sha; when the285 user needs fine-grained control over the SHA task286 surface (partial-hash, custom buffer permissions,287 cap-query for unusual message sizes), the library is288 the right answer. The engine wraps the *one-shot*289 task; the library exposes both one-shot and partial-290 hash per291 `doca-sha/SKILL.md`.292- `doca-version/SKILL.md` — the293 canonical version-detection chain. The engine has a294 TWO-axis version overlay (DOCA-side and OpenSSL-side);295 the version skill carries the four-way match rule296 this skill layers on top of.297- `doca-debug/SKILL.md` — the298 cross-cutting debug ladder. The engine surfaces its299 own error taxonomy; when the cause is below DOCA300 (driver, firmware), the taxonomy hands off here.301- `doca-setup/SKILL.md` — env302 preparation, install verification, the `libssl-dev`303 install path, and the NGC DOCA container path.304- `doca-public-knowledge-map/SKILL.md` —305 routing to the public DOCA SHA documentation set on306 `docs.nvidia.com/doca/sdk/` and to the OpenSSL307 ENGINE / `openssl-engine` upstream documentation on308 `openssl.org`.309- `doca-hardware-safety/SKILL.md` —310 the bundle-wide hardware-safety meta-policy. The311 engine binds to a specific PCIe device; the312 `set_pci_addr` ctrl is the artifact-specific overlay,313 but any host-side change underneath (firmware burn,314 BFB reflash) runs through the meta-policy.