Skip to main content
Back to Blog
• 10 min read (2052 words)

Retain Enterprise PKI with an Additional Hub Trust Anchor

Engineering illustration: a hub trust boundary accepting leaves from two direct issuers — the hub's own CA and one additional enterprise anchor.

Some organizations can’t hand issuance to anyone — not even a managed service with a good security story. If your enterprise CA is the issuer of record for building-system identities, the question isn’t whether to keep it; it’s how a managed hub can trust the certificates it issues without pretending your PKI doesn’t exist. The additional trust anchor is exactly that mechanism — narrower than it sounds, and worth understanding precisely.

This guide covers configuring enterprise issuer trust in HUBaaS, the managed BACnet/SC service: the difference between issuance and trusting an existing issuer, what “one additional CA” actually means, the direct-issuer requirement that trips up nested chains, mutual trust in both directions, and the change/rollback discipline a security review expects. Every CA name, fingerprint and node here is invented.

Where HUBaaS fits

HUBaaS is Hexomation’s managed BACnet Secure Connect service: per site, one primary hub, optional warm standby, and an optional hosted supervisory node — SC only, with no native field-protocol interfaces. Each managed hub carries its own CA for issuance, which makes the enterprise-issuer path an addition: the hub keeps its authority and also learns to trust yours.

That framing matters for scope. This is about admitting enterprise-issued operational certificates at connection time — not moving your CA into the service, not replacing the hub’s own issuance, and not any kind of key custody transfer. Feature availability follows the product plan and version.

The typical trigger is migration: a building portfolio already carrying enterprise-issued SC identities, where reissuing every node under a new authority is a project nobody wants. The anchor exists so the hub can accept what your PKI already made.

Issuing versus trusting are different operations

Enrollment — the hub CA issuing a leaf to a node — is one flow covered by its own companion guide. Trust anchoring is different: the enterprise CA has already issued the node’s operational certificate elsewhere, and you are telling the hub “accept operational certificates signed by this issuer.” No CSR crosses this path; nothing is enrolled through the hub’s EST service.

That means the enterprise PKI keeps doing everything it already does — issuance policy, renewal, revocation handling, audit. The hub’s job narrows to one question at connection time: was this leaf signed by an issuer I was configured to accept?

Keeping the two flows separate in your head prevents a recurring confusion: a node that was never enrolled through the hub is not an enrollment failure to debug — it’s a trust-acceptance question to answer. Different mechanism, different evidence, different fix.

One additional anchor, explicitly additive

The configuration surface is deliberately small: the hub accepts one additional customer CA setting — set it, or clear it. This is not a general trust store, not a list, and not unlimited anchors. Adding the anchor marks provisioning and reconciles the pods — including restarts — so treat the change as a maintenance event with an approval trail, not a silent toggle.

Three implications follow. First, “one” means choosing: if two enterprise issuers both need admission, the design conversation changes and the configuration model may not stretch — verify on the target release before planning around it. Second, clearing the anchor is a real operation with real consequences — enterprise-issued nodes lose their trust path and will fail to connect. Third, the hub’s own CA stays in place throughout; the anchor is additive, never a replacement.

The restart behavior deserves its own planning slot: accepted changes reconcile the pods, and reconciliation can restart them — an anchor change may interrupt sessions and force reconnects, and there is no zero-downtime guarantee. Schedule it like the maintenance event it is.

Direct issuer is the constraint that bites

Here is the requirement that breaks naive enterprise imports: the operational leaf must be directly signed by a configured issuer. Not “the chain anchors at this root.” If your enterprise CA issues through a nested intermediate — a common and perfectly reasonable PKI design — and only the root is configured as the trust anchor, a node presenting the intermediate-signed leaf is rejected: the issuer of record is the intermediate, not the anchor you configured. Note the asymmetry — if the intermediate is what actually signs the leaves, configuring it is the fix; intermediate chains do not inherently fail, unconfigured direct issuers do.

Illustrative trust diagram: the hub's own CA and one configured enterprise anchor each stand as direct issuers of node leaves — a nested intermediate under an anchored root is rejected because it is not the direct issuer.
Illustrative trust edges — direct issuer required; invented CA names and fingerprints.

The corollary is equally important: “the PEM parsed” is the API’s acceptance check, not a compatibility verdict. A certificate file can be perfectly valid PEM and still be the wrong anchor — the compatibility question is whether it directly issues the operational certificates your nodes actually present, which is a PKI topology question, not a file-format question.

So the pre-flight check is specific: a leaf’s issuer field identifies the candidate anchor — but a matching name is not proof of signature. Validate the leaf’s signature and certificate path against the proposed issuer (plus validity and certificate-profile constraints) before configuring it. A root that merely anchors a deeper chain fails this test no matter how official the file looks.

Trust runs both directions

Mutual TLS means the check is mutual: while the hub verifies the node against the configured issuers, the node verifies the hub against its own trust configuration — the same verification discipline applied in the opposite direction. Adding your CA to the hub solves only half the equation — the enterprise node must also be configured to trust the hub’s operational identity, or the handshake dies on the other side with a perfectly valid anchor doing nothing.

In practice one failure pattern is worth checking first: the hub-side change was verified but the node-side trust was assumed. Both halves need to land before any connection test means anything.

Node-side trust varies by implementation — verify how your node software takes anchor material, because a managed hub’s public CA fingerprint comes from the console’s documented workflow, and the node’s trust store is the other half of the same out-of-band discipline used at bootstrap.

What this path explicitly is not

Boundaries matter here more than most features, because trust-anchor configuration attracts wrong assumptions that other teams will happily repeat back at you. It is not CA private-key import or hosting — the anchor is public certificate material only; your private keys never leave your PKI. It is not arbitrary chain import or an unlimited trust store. It is not automatic enterprise CRL or OCSP synchronization — revocation stays your PKI’s responsibility, and the hub does not periodically learn your revocation lists.

That last one deserves emphasis and a correction to a tempting shortcut: revoking an enterprise-issued certificate in your own CA is not automatically enforced by this reviewed integration, because the hub’s acceptance is anchored to the issuer, not to your CRL. A one-shot disconnect is not exclusion — the node may simply reconnect — and removing the enterprise anchor is a broad change that denies every node depending on it, not a per-leaf revocation. If a leaf must be excluded, agree a verified enforcement procedure with your security owner and test that a denied node genuinely cannot reconnect — do not assume a capability this path doesn’t document.

Stated once more plainly, because the assumption is seductive and easy to repeat: adding your CA’s certificate is not adding your CA’s operations. Issuance, renewal, revocation, audit — all still yours, all still running where they ran before, and none of it automatically synchronized here.

Plan the change like a security change

The discipline that survives review: validate the CA material first — identify the candidate anchor from the leaf’s issuer field, then verify the leaf signature and path actually validate against it (with validity and certificate-profile constraints), not just that it parses; apply the anchor during a maintenance window knowing pods may restart; then test in both directions — a permitted node connects and an untrusted one is refused. Both halves of that test matter — acceptance of a legitimate node alone proves nothing about rejection of an illegitimate one.

Illustrative compatibility worksheet with unchecked boxes: leaf signature validates against the proposed issuer, enterprise node trusts the hub identity, pod restart window planned, permitted-node accept and untrusted-node reject both tested, rollback path and blast radius documented — all boxes empty.
Illustrative compatibility worksheet — checks to run before and after the change; no pass marks drawn.

And write the rollback down before you need it — with its blast radius made explicit: the revert is restoring the previous approved anchor value (or clearing the setting only if none existed before the change), knowing the same reconcile-and-restart applies, every node whose leaf depends on the removed anchor loses its trust path, and the node side of mutual trust may need its own reversion. Security approval before the change, not after.

Stage it if you can: apply the anchor in a lab or low-risk hub first, prove the accept-and-reject pair there, then schedule the production change. The configuration step is seconds; the verification is the actual work.

A synthetic migration, end to end

Imagine an invented portfolio: a hundred SC nodes whose operational certificates were issued by “Example Enterprises Internal CA” — every value here synthetic. The site gets a managed hub, and rather than reissuing every node under the hub CA, the team decides the enterprise issuer stays in place and the hub will be taught to accept it.

The run looks like this, on paper: inspect a node certificate — its issuer field identifies the candidate CA — then validate the leaf signature and certificate path against that candidate (validity and profile constraints included) before calling anything “the direct issuer.” Configure the single additional anchor during a maintenance window; pods reconcile and may restart. Nodes reconnect — the enterprise-issued ones on their existing leaves, because mutual trust was configured on their side too. Then the two-sided test: a node with that issuer is accepted, one without is refused — and the result goes into the change record alongside the rollback.

What the example deliberately does not show is a result: no timings, no success counts, no “it just worked.” The scenario is a shape to apply to your own estate, not a report of one that ran — the worksheet figure stays unchecked until your deployment fills it in.

The honest alternative

Where the anchor earns its place is continuity: enterprise-issued node identities keep working without reissuing everything under a hub CA — one migration avoided, one established PKI retained. Where it doesn’t fit is equally clear: if your policy requires complete custody of the PKI and the runtime — including the authority that accepts connections — a private, self-operated hub may be the correct architecture rather than a managed service with an added anchor.

Judge the fit by which constraint is actually yours: if the constraint is “issuance must stay ours,” the anchor answers it; if it’s “connection acceptance must stay ours,” the managed model itself is the question, not the anchor.

One more honest limit to carry into that judgment: the anchor’s “one additional” ceiling. If your enterprise issues through multiple parallel issuers across different estate slices, the configuration model may not stretch to all of them at once — that’s an architecture conversation to have before committing, not a configuration to discover mid-migration.

Your issuer, the hub’s acceptance

The short version: identify the candidate anchor from the leaf’s issuer field and then prove it — signature and path validation, validity and profile constraints — because parseable PEM is not compatibility; add the single additional anchor knowing pods may reconcile and restart; configure the node’s side of mutual trust; verify accept-and-reject in both directions; and keep revocation ownership where it belongs — with you, enforced through a procedure you agreed and tested, not assumed hub-side behavior.

The checklist that survives a security audit is small but non-negotiable: the right CA material (validated issuer of the leaves, not just a root), the right change window, the right node-side trust, the right two-sided test, and a written rollback with a stated blast radius. Get those five right and the anchor does exactly what it promises to do — nothing more, nothing less, and nothing surprising on connection day.

To review PKI compatibility for your enterprise CA, see the managed service at HUBaaS.io. Companion pieces cover the CA/EST bootstrap for hub-issued identities, timed admission windows, and connected-node inventory — the rest of the lifecycle this trust decision feeds into, including what a connected-node record does and does not prove about identity.

Continue Reading

Related Engineering Articles

View all articles