Device security

Application and MDM interfaces

Otukan defines the interfaces a protected Android device offers to apps and MDM: who may call each one, what it relies on and how it stays stable per model.

  • Narrow by design

    Apps and management each get a defined, permissioned route to device-level protection, and no more reach than their role needs.

  • Evidence with a source

    Every integrity report states where it came from and when, and is signed with device keys where the chipset supports it.

  • Stable across releases

    Each interface is versioned per model and retested with each firmware release, and consumers see change notes before devices update.

Interface risks Otukan handles

An interface is also an attack surface, so each one has a defined refusal and a record.

Unapproved app query

  1. Detect

    The permission declared in the system image blocks any caller outside the approved list, even when the app is installed.

  2. Respond

    The call fails and no device state is returned to that app.

  3. Report

    The refused call is logged with the calling package for your security team.

Out-of-policy command

  1. Detect

    Otukan's device-level protection compares each management request with the agreed management control list.

  2. Respond

    Controls fixed in firmware stay as they are; permitted changes apply.

  3. Report

    The refused request is reported with the management service that sent it.

Forged integrity report

  1. Detect

    Otukan's report verification on your server checks the signature against the device key and a fresh challenge the server issued.

  2. Respond

    The report is rejected and the device is handled as unverified by your rules.

  3. Report

    The mismatch is recorded with the device identity and the values it claimed.

Interface drift after update

  1. Detect

    Otukan's release tests compare each interface's behaviour with its contract on the models in scope.

  2. Respond

    Otukan flags the difference to the OEM before the release is signed.

  3. Report

    App and management teams receive change notes naming the interface and version.

What Otukan delivers for your interfaces

Each programme leaves your engineers with written, testable definitions rather than assumptions about what the device will answer.

  • Interface contract

    A versioned description of each app-facing and management-facing interface per model: inputs, answers, error states and the device states it covers.

  • Caller permission map

    The list of apps and management services allowed to use each interface, and the Android permission in the system image that enforces it.

  • Management control list

    Which device-level controls your management system may switch, and which stay fixed in firmware whatever a policy says.

  • Consumer change notes

    Notes for app and management teams describing interface changes in a firmware release, issued ahead of the rollout.

How Otukan sets up your interfaces

  1. List the consumers

    Name each app, backend and management service that needs to read or steer device protection.

  2. Write the contract

    Agree inputs, answers, error states and device lifecycle states for each interface, per model.

  3. Build and permission

    Otukan builds the interfaces into your firmware and binds each to its approved callers.

  4. Test on your models

    Each interface is tested on physical devices, including refused calls and offline states.

  5. Version and maintain

    Interface versions move with firmware releases, with change notes issued before rollout.

A mobile security team evaluates application and MDM interfaces by asking three things of each one: which party owns it on the device, what device-level evidence it passes upward, and who keeps it stable when firmware changes. Otukan defines these interfaces for Android-based devices carrying its firmware-level protection. Apps get a narrow, permissioned way to ask about device state. Management gets policy hooks and integrity reports it can act on. Each interface is documented, versioned per model and retested with each release. Apple defines its own management and attestation model, so iPhone and iPad sit outside this page.

Integration boundary

An interface between device protection and the software above it crosses several owners. The OEM ships it in the system image, the ODM builds it, the chipset decides whether its answers can be hardware-signed, and the institution decides who may use it. Otukan agrees these points per interface before building anything.

InterfaceUsed byOwned on the device byWhat Otukan agrees
Device state queryYour apps and apps you approveOEM system imageWhich apps may call it, what they receive, how access is granted
Management policy hooksYour management system or Otukan device managementOEM, with the institution setting policyWhich controls management may switch and which stay fixed in firmware
Integrity reportsYour verification server, management and security monitoringOtukan protection, keyed per device where the chipset allowsReport fields, freshness rule and recipients
First-boot provisioningYour enrolment serviceODM factory process and OEMWhich settings are in place before the user first sees the device

Who may call what

Access to each interface is granted through Android permissions declared in the system image. An app outside the approved list cannot reach the interface even when a user installs it. The caller permission map names each approved app, the permission it holds and the reason it needs it, so a reviewer can check the list line by line.

When the buyer is not the builder

When an institution buys devices from an OEM, the OEM builds the interfaces and the institution chooses which management service and which apps are authorised to use them. Otukan records both decisions, so a later change to the approved callers goes through the institution, not only the OEM.

Control scope

An interface is only as trustworthy as the protection beneath it. Otukan maps the dependencies of each interface before it is published to your developers.

DependencyWhy the interface relies on itBehaviour when it is absent
Firmware integrityAn answer about device state means little if the image beneath it is not the approved oneReports mark the state as unverified rather than trusted
Hardware-backed keysYour server can confirm a report came from that deviceReports are labelled as software-signed so consumers apply their own lower-trust rule
Telemetry pathReports reach management and your backendThe last verified state is kept with its time, and the device is listed as silent
Lifecycle stateEnrolment, factory reset, repair and retirement change what the device should answerBehaviour for each state is written into the contract in advance

Clear lines between consumers

Each interface does one job. Apps can read device state but cannot change device policy. Management can switch permitted controls but cannot read app data through the security interface. No interface exposes keys. These lines keep a compromise of one consumer from spreading to another, and they make each interface simple to test.

Qualification

Before your team builds apps or management workflows on these interfaces, Otukan provides the evidence that they will hold for the models you ship.

Question to settleEvidence Otukan provides
Which models expose which interfacesAn interface matrix per model and firmware build
Who may change an interfaceA change control record naming the OEM approver and, where relevant, the institution
How consumers learn of changesA versioned contract, with change notes issued ahead of each release
How long an interface version is maintainedA period agreed per model in the maintenance plan, running to the model’s end of support

Interface versions follow the firmware, not the calendar. When a release changes an answer or adds a field, the version rises and the change notes explain what app and management teams need to adjust. A release that would break a published contract is flagged to the OEM before it is signed.

How device evidence is labelled and consumed is covered on device integrity signals. How management acts on security findings is covered on MDM security integration. For the parent topic, see OEM device security integration. For the management product, see mobile device management.

Common questions

  • Can we keep the MDM we already use?

    Yes. The management-facing interface is documented and authenticated, so the management system your institution runs can consume it. Otukan device management works with the same interface. What the management side may change is set by the management control list, whichever system sends the request.

  • Can third-party apps read device state?

    Only if you approve them. The permission map lists each app allowed to query device state and the permission that enforces it. An approved app receives the state its role needs, such as whether the device passed its integrity checks, and never keys or data belonging to other apps.

  • What do apps receive while a device is offline?

    The last verified state, with the time it was produced. Otukan marks stale answers as stale, so an app handling a sensitive action can ask for a fresh check, and your backend can decide how long a stored result remains acceptable.

  • Does this apply to iPhone and iPad?

    No. Apple defines the management and attestation interfaces on iOS and iPadOS. This page covers Android-based devices whose firmware an OEM or ODM builds, where Otukan's protection sits beneath the operating system.

Give apps and MDM answers they can trust

Tell us whether you are an OEM or an institution, which models are involved, and which apps or management system need to read or steer device-level protection. We do not ask for signing keys, source code or unreleased images.

Or request a technical demo