entityOS Sentinel · Reward Program

Find a flaw in the entityOS platform. Get rewarded.

If you find a flaw, we want to hear from you first. Report responsibly, get acknowledged, and earn a reward.

Reward Tiers

Severity decides the reward.

Indicative ranges in AUD, paid at entityOS's discretion based on validated impact, exploitability and report quality.

Critical

A$600 – A$1,000

Allowlist / mTLS bypass, RCE, SSI credential forgery, cross-tenant data exposure.

High

A$400 – A$600

Auth bypass, IAM privilege escalation, certificate validation flaw.

Medium

A$200 – A$400

Stored XSS in a sensitive context, IDOR, exploitable logic flaw.

Low

Recognition + A$50 – A$200

Minor information disclosure, non-sensitive misconfiguration.

Duplicate, theoretical, and out-of-scope reports may receive recognition only. One reward per unique root-cause issue.

In Scope & How It Works

What we want eyes on.

  • API / Interface Endpoint

    API Gateway, interface / VPC endpoints and the IAM roles behind them.

  • Web & console surfaces

    entityos.io, the developer console and any first-party web application.

  1. Report

    You submit a clear, reproducible report through this form.

  2. Acknowledge

    We confirm receipt and assign a reference, typically within a few business days.

  3. Triage

    We validate, reproduce and assign a severity tier.

  4. Remediate

    We fix the issue, usually inside a ~90-day disclosure window.

  5. Reward & credit

    You're paid per the tier and credited (if you wish) once the fix ships.

Architecture & Trust Model

Know the trust model before you report.

entityOS is a fully managed cloud platform. An app built on it is a thin client — static form (HTML & CSS) and function (JavaScript via the entityOS SDK) running in the visitor's browser — that talks to the entityOS API. The API, not the client, is the security boundary: authentication and authorisation are enforced server-side, per object and field. A lot of what looks exposed on the client is public by design. Please factor this in so your report lands in scope.

By design — not a vulnerability

These are inherent to the thin-client model. On their own they are not findings.

Client code is visible

The app's HTML, CSS and JavaScript — including SDK controllers and list/form configuration such as the util-view-table field definitions — are delivered to the browser and fully inspectable via View Source / DevTools. Reading or modifying client code is expected.

Your own data in app.data

Returned records are cached client-side in the app.data object for the signed-in session. Seeing your own data there, or in XHR responses, is not a disclosure.

Direct API calls & a modified client

The client is untrusted. Calling the API directly, or editing the JavaScript to add fields or change parameters, cannot exceed the permissions the server grants the authenticated user. "I changed the client" is not, by itself, a finding.

Public per-site assets

Static files served at site<nnnn>.entityos.cloud are public to the app's users by design.

Managed backend

Hosting, servers and OS / platform patching are managed by entityOS / ibCom. Generic version banners or platform-owned components are usually out of scope.

In scope — what we want

The test is always the server-side API response, not the client.

Broken object / field authorisation

A direct API call or modified client that returns or writes data the signed-in user should not have access to.

Cross-space / cross-tenant access

One space (account) reading, writing or enumerating another space's data.

IDOR at the API

OBJECT_SEARCH / OBJECT_MANAGE calls returning or mutating records outside the user's grant by changing an id or parameter.

Auth / session bypass & privilege escalation

Bypassing logon, reusing or forging a session, or gaining rights the account was not granted.

Injection or logic flaws the API accepts

Input the server-side API acts on rather than rejecting, or a workflow that can be driven to an unintended state.

The edge, mTLS/PKI, SSI & API scope above

Everything listed under In Scope — the closed-internet edge, mTLS/PKI, self-sovereign identity, and the API / interface endpoints.

When you report, tell us what the server-side API did — the request you sent and the response you got back. A finding that reduces to "the client exposes X" or "I can edit the JavaScript" is solved by architectural design and will be closed as out of scope.

Submit a Report

Report a vulnerability.

One issue per submission. Include enough detail for us to reproduce it. Don't access or modify data that isn't yours, and don't run denial-of-service or spam tests.

Please give the issue a short title.
Please choose the affected area.
Please pick a severity.
Please describe the vulnerability.
Please include reproduction steps.
Host evidence somewhere we can reach and paste the links. Do not include real customer data.
If your evidence is encrypted or password-protected, share the password here so we can open it.
Please enter a valid email address.
Please confirm good-faith, responsible disclosure.
We need your consent to follow up.

Report received.

Thank you for disclosing responsibly. We've logged your report and the team has been alerted. Use the following reference in the subject, and the password you set to zip any evidence and send to security@ibCom.biz:

—

We'll acknowledge by email shortly. Please keep the issue confidential until it's resolved.

Send another report →

Safe Harbour

Good-faith research is welcome.

If you make a genuine effort to follow this policy, we will treat your research as authorised, will not pursue legal action, and will work with you to understand and resolve the issue quickly.

In short: report only what you find, don't pivot or exfiltrate, give us reasonable time to fix it, and acknowledge it.