Skip to main content

6.15 Security in Connectivity Engineering

From OLIVE 1.3, several platform behaviours that used to be permissive are now enforced. Most of the change is invisible while you work normally — but a handful of things that used to work no longer do, and a handful of new rules apply to what you build.

This page is written for connectivity engineers and OLIVE users. It answers three questions: what does the platform enforce around my connectivity?, what changed that might break something I already built?, and what am I responsible for?

For deployment-level security settings, see the Administrator and Operator handbook.

Why connectivity code is treated as sensitive​

OLIVE exists to call other systems. A connector executes with the platform's outbound reach and can be invoked by privileged users; a microfrontend component runs inside the authenticated user's browser session. That means your definitions run inside the platform's trust boundary — a mistake in connectivity is not contained the way an ordinary form input is.

The platform closes what it can from its side. The rest is documented here.


1. Where your connectivity may call​

Internal addresses are blocked​

Every outbound HTTP call OLIVE makes passes through a shared egress guard. It rejects, before the request leaves:

  • private address ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, and similar)
  • Kubernetes-internal service names
  • link-local and cloud metadata addresses, in particular 169.254.169.254

This applies to Data Orchestrator datapoints, OpenAPI import, image fetching in the Prompt Caller, and OAuth/OIDC configuration. A blocked attempt is recorded as a security event (OLIFETCH1) that your operator can see.

If you had a datapoint calling an in-cluster service or an internal host, it will now fail

This is intended, not a defect. A platform that will call any URL a user configures is a pivot into the operating organisation's internal network. The route forward is described below — it is not something you can re-enable from a datapoint definition.

Public destinations are not restricted​

The guard is about internal reach. Calls to public internet addresses are not blocked, so an integration with an external SaaS API, a public data source or a partner endpoint works the way it always did.

(At the infrastructure level, some services have no internet access at all because they never need it — the storage components, for example — but that does not affect connectivity you write.)

If your use case genuinely needs an internal address​

The commonest case is a service of your own: you host something in the same cluster — an API, a converter, a legacy adapter — and connectivity needs to call it. In 1.2 that worked, because the cluster-internal name resolved and nothing stopped the call. In 1.3 it is refused like any other internal destination, and the fact that the service is yours makes no difference to the guard.

The block on internal addresses is not absolute. OLIVE itself has to reach a number of internal addresses in order to work at all, and those are registered with the platform rather than being exceptions in the egress guard. The same registration can, in principle, cover an additional internal destination — and only an OLIVE operator can make that registration.

What that means in practice:

  • It is not something you configure in a datapoint, a connector or a template.
  • There is currently no public API for it, and the mechanism may change in a future release. For that reason it is deliberately not documented here as a pattern to build against — anything you built directly on it today could break on upgrade.
Tell us about the use case

We would like to hear where this is actually needed. If you have a use case that requires OLIVE to call an internal destination, describe it to your Tenant Admin — what system, why it cannot be reached as an external endpoint, and what the connectivity is meant to do. They pass it to the OLIVE operator, who raises it with OLIVE support at olive-support@boc-group.com, and we come back with the approach that fits your situation.

We are collecting these cases on purpose. How often this comes up, and what for, is what decides whether the mechanism becomes a documented, supported feature in a future release. A use case you report is a vote for that; a workaround built quietly around the guard is not.


2. Placeholders in HTTP datapoints​

OLIVE lets you use placeholders almost everywhere in an HTTP datapoint definition. Because a placeholder's value is resolved at execution time, it cannot be validated when you define it — so the platform secures the positions instead, with a strict character allow list per position.

PositionPermitted
URL host[a-z0-9-] and .; each label must match ^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$; 253 characters total
Port[0-9]{1,5}
MethodExact match against a fixed set
Query key / valueA-Za-z0-9, -, ., _, ~, %, &, =
Header nameNot substitutable
Header valuePrintable ASCII (\x20–\x7E) only, no leading or trailing whitespace
Body (form)Same rules as query key/value; multipart bodies must be FormData
What this breaks

Two patterns from earlier versions no longer work:

  1. A placeholder that produces a http header name. Header names are fixed in the definition. Where you previously computed a header name, define the header explicitly.
  2. A placeholder value containing characters outside the allow list for its position — newlines in a header value, unescaped separators in a query value, arbitrary characters in a host. These were exactly the inputs that allowed a crafted value to forge headers, split a request, redirect to an unintended domain or corrupt a body.

Encode the value before it reaches the placeholder, or move the varying part to a position with a wider allow list.


3. Your job, your session, your files​

Three things that used to be reachable by anyone inside a tenant are now bound to the user who created them.

Jobs​

Each job invocation stores a token derived from the triggering user's identity, issuer and tenant. Polling a job's status or results, and calling setResponse, pause, cancel or resume on it, verifies that token. Guessing or obtaining a job ID is no longer sufficient.

Continuing a workflow as a different user

Some workflows legitimately need to be continued by someone other than the person who started them — a manual task completed by an approver, for example. There is an explicit, documented option that disables the ownership check for that invocation. Use it deliberately for the invocations that need it, rather than as a general setting. An attempt to touch another user's job without it is recorded as OLIORCH1.

Session memory​

  • Session IDs are now generated server-side, when you store the first item. The store call returns the ID, and that returned ID is what every subsequent read and write must use. A client-supplied session ID is no longer accepted, so code that invented or reused an ID of its own needs reworking.
  • You can flag data as sensitive. Sensitive entries are bound to the creating user and verified on every subsequent read and write.
  • Session IDs no longer appear in logs or in debug structures, including in JSONata-reachable input.

Client-supplied keys that could previously collide (key1, key2) and misroute data to the wrong destination are no longer accepted.

Files​

  • A file key or URL alone no longer grants read access.
  • Read and write paths are separated, so system files cannot be overwritten — including microfrontend code. Downloading a component, modifying it and uploading it under the same key no longer works.
  • File names, extensions and MIME types are validated, path traversal is blocked, and upload limits are enforced.
  • Uploads carry a category — core, static or temp — which decides who may overwrite the file. Writing static needs the editor role and core the admin role; an upload with no category is a temp file that any user of the tenant can replace.

See File handling in Connectivity for the mechanics.

No malware scanning

Uploaded files are validated for type, extension and size, but they are not scanned for malware. Treat uploaded content accordingly.


4. Roles: user, editor, admin​

From OLIVE 1.3 the user, editor and admin permission levels are genuinely different permissions rather than three names for the same set. What each level may do, which content only an admin may change (entries tagged core, pilets), and why holding both editor and admin should be avoided are described in Roles In OLIVE – Platform Permissions.

Every privileged operation is checked in one place and emits a security event on both success and denial (OLIAUTHZ1–OLIAUTHZ3), so a role problem shows up in the log rather than as a silent partial failure.

Do not execute connectivity as an administrator​

Connectivity executes with the permissions of the user who runs it, not those of the user who wrote it. A connector containing a privileged datapoint — clearing data, changing log settings, any admin-only operation — fails the role check for an ordinary user and succeeds for an administrator.

That is the ordinary, expected behaviour, and it is also what makes the admin role dangerous in daily use. Run by an ordinary user, the privileged datapoint is refused and the denial is recorded as OLIAUTHZ2. Run by an administrator, it goes through — performing an administrative action that the administrator never intended and may not have noticed in the definition.

The person who wrote the connector never needed the admin role. They only needed an administrator willing to press execute.

Keep the admin role out of everyday work
  • Do not use an admin account to execute or test connectivity. Use an ordinary user or editor account for that, and sign in as administrator only for the administrative task at hand.
  • Do not use an admin account for daily work at all. If you hold both roles, hold them as two accounts rather than one.
  • Be wary of a request to "just run this one". If someone asks an administrator to execute a connector or a datapoint on their behalf, the sensible response is to ask why it does not work under their own account.
  • If you are writing connectivity that appears to need admin rights to run, stop and ask. Ordinary connectivity should not need them. Either the definition is doing something it should not, or the work belongs in an administrative procedure rather than in a connector.

Before an administrator executes any connectivity — for a genuine one-off, for example — read the whole definition first, including everything it calls. A connector composes other elements, so "this datapoint looks harmless" is not the same as "this connector is harmless".

Administrative actions that do run are recorded as OLIAUTHZ1, with the acting user, so they are reviewable after the fact.


5. Secrets​

Credentials, API keys, certificates and tokens belong in HashiCorp Vault, never in a connectivity definition, a parameter default, a template or a file you upload.

When a service reads a secret, it authenticates to Vault with the requesting user's JWT, so Vault evaluates your identity, tenant and roles against its own policies — the application does not decide for itself what it may read. Secret access and modification are logged (OLISEC1, OLISEC2).

Practical rules:

  • Reference secrets; do not inline them.
  • A secret key cannot escape its folder — path traversal through a secrets key is blocked.
  • Infrastructure secrets (storage credentials, for example) are on a separate path with a separate policy. You cannot surface one inside your repository space by naming an entry cleverly.

See Authentication and Secrets Management.


6. What is logged, and what you should not log​

The platform records a defined catalogue of security events. Credentials, tokens, secrets and request or response bodies are never logged — a secret's use is recorded, never its value. Where developers genuinely need request and response detail, a separate developer log stream exists — active only in development environments, never in production.

Security events do record who acted and from where: the source IP address, the user name and the tenant. That is deliberate and expected of an audit trail.

What this means for you:

  • Do not put credentials, tokens or personal data into log output from your connectivity, transformations or custom services. It will either be dropped or it will end up somewhere it should not be.
  • Request-level diagnostics in an authenticated deployment are off by default and are enabled by your OLIVE operator for a troubleshooting window. Do not design a workflow that depends on them being on.
  • Every log record carries the tenant ID and a traceable request identifier, so a single action can be reconstructed across every service it touched. Quote the request ID when reporting a problem — it is the fastest way for an operator to find what happened.

7. Tenant boundaries​

Your connectivity runs inside one tenant, and four independent mechanisms keep it there: the JWT claim check in every service, the per-tenant Vault role, the per-tenant namespace and storage, and network policies that give no route between tenant namespaces.

Anything that looks like a way to address another tenant's data is a defect, not a feature. Cross-tenant access attempts are recorded as OLIAUTHN4.

The consequence for engineering: do not design anything that depends on reaching another tenant. Share reusable assets through export/import instead.


8. If you write microfrontend components or custom services​

This is the part of OLIVE where your code runs with the platform's privileges, so the responsibility is yours rather than the platform's:

  • Your dependencies are your supply chain. Pin them to exact versions. OLIVE pins its own and does not adopt a third-party package version younger than one week; apply the same discipline.
  • Your images are yours to build and secure. If your component ships as a container image, it needs the same treatment as any other: a maintained, pinned base image, no package installation at runtime, no running as root.
  • Anything you render in the user's browser runs in their authenticated session. Nothing sandboxes a microfrontend component from the session it is loaded into — add rel="noopener noreferrer" to links that open new windows, never pass untrusted data into innerHTML, keep secrets out of the bundle, and respect the Content Security Policy rather than asking for it to be relaxed. The full list, with a pre-handover checklist, is in Client Microfrontends → Your Security Responsibilities.
  • Do not weaken TLS. NODE_TLS_REJECT_UNAUTHORIZED=0 exists for controlled laboratory environments only. If you need to trust an internal CA, that is a deployment setting your OLIVE operator configures, not something to disable per service.
  • Have your code security-reviewed before production, by someone other than its author. Your Tenant Admin is also expected to review connectivity and microfrontend code before switching it on in a production tenant — but that is a second line of defence, not a substitute. They can see what your code does; only you know what it was meant to do. Make it reviewable.

Quick checklist​

Before you hand connectivity over for a production tenant:

  • No credentials, tokens or personal data in definitions, parameter defaults, templates or log output
  • All secrets referenced from Vault
  • Every HTTP datapoint that calls an OLIVE API (file-storage-service, session-memory, data-orchestrator, repository) carries an auth reference — it works without one only in an unauthenticated development deployment
  • No calls to internal, Kubernetes-internal or metadata addresses
  • Any genuine need for an internal destination raised with your Tenant Admin
  • No placeholder producing a http header name; placeholder values within the allow list for their position
  • Workflows that a different user must continue use the explicit ownership-check option, deliberately
  • Session data that is sensitive is flagged as such
  • Uploaded file types, extensions and sizes are within the platform's limits
  • Roles assigned correctly — nothing relies on an editor holding admin permissions
  • Nothing in the connectivity requires an administrator to execute it
  • Not built, tested or run from an admin account
  • Dependencies pinned; no NODE_TLS_REJECT_UNAUTHORIZED=0
  • Microfrontend components checked against the UI component checklist