Contents
SpecificationGlobalPlatform

GlobalPlatform TEE APIs

Trusted Execution Environment Client API and Internal Core API

These GlobalPlatform specifications define how ordinary software talks to trusted applications that keep cryptographic operations and confidential data inside a hardware-isolated trusted execution environment.

What it is

A trusted execution environment (TEE) is a hardware-isolated place where small programs handle secrets away from the main operating system. GlobalPlatform splits that idea into two interfaces. The TEE Client API is what applications in the ordinary execution environment call to reach the TEE. The TEE Internal Core API is what trusted applications (TAs) call inside the TEE for cryptographic operations and trusted storage.

On an automotive high-performance computer (HPC), the application processor often runs both sides. The rich side runs a general-purpose operating system and vehicle functions. The trusted side runs a compact TEE operating system and the TAs. The processor’s secure-world mechanism supplies isolation; these documents define the calls across that boundary. A client opens a context and a session, invokes a command, and receives a result, while key material is expected to stay inside the TEE.

Who it applies to

Use these specifications when rich-world software on an application processor must call trusted applications through a stable contract. On a vehicle HPC that work sits with boot and security firmware, the TA authors, and the client authors.

A hardware security module on a microcontroller is a different boundary and a different interface. Name the processor in the architecture so an HSM job and a TEE session stay distinct.

What it covers

The Client API is the rich-world sequence: initialize a context, open a session to a TA, share a memory buffer when the command needs one, invoke a command with a parameter list, then close the session. The client receives return codes and output parameters. TEE memory stays on the trusted side.

The Internal Core API is the TA side. A framework defines the entry points (create, destroy, open and close session, invoke command) and property access. Cryptographic operations cover digests, symmetric and asymmetric ciphers, and keys used without exporting the raw key. Trusted storage covers persistent objects held by the TEE, separate from the rich filesystem.

Document Called from Daily purpose
TEE Client API Rich-world applications Open a session and invoke a TA
TEE Internal Core API Trusted applications Crypto, trusted storage, and TA lifecycle

Boot, image authentication, vehicle networks, and diagnostics sit outside these texts. The TEE System Architecture and optional companions, such as a trusted user interface or secure-element access, are separate GlobalPlatform documents. A product may implement these two APIs on their own.

How it fits with other documents

Read the TEE System Architecture for the roles and the isolation assumptions, then use the two API specifications as the calls programmers write. The APIs assume secure boot has already loaded the TEE and the TAs you trust.

ISO/SAE 21434 remains the process for deciding that a TEE is an appropriate cybersecurity control and for assessing what can still go wrong. Algorithm choice, key lifetime, and functional-safety requirements belong in that wider engineering work.

Keep an HSM on a zone controller and a TEE on the HPC as separate boundaries. OP-TEE is one open implementation of these interfaces. Code that must survive a supplier change should follow the GlobalPlatform contracts. Private extensions stay with that vendor.

In practice

Start from the assets. Keys, certificates, counters, and decisions that must stay confidential or intact if the rich operating system is compromised belong in TAs. Ordinary compute stays in the rich world.

Keep each TA’s commands narrow and tied to one vehicle purpose, such as checking a firmware measurement or unwrapping a key for a named use. A command that exports key material, or that runs whatever operation the caller names, lets a compromised client misuse the TEE.

Treat shared memory as visible to the rich world. Keep secrets out of those buffers, and clear sensitive values you control when the command returns. Ship the TEE operating system and the TAs on the same controlled boot and update path as the other HPC security firmware.

When you accept a supplier stack, record the edition of each API, the optional features they left out, and any functions that exist only in their headers. Build clients and TAs to that common surface.

What it means for your discipline

  • HPC & application softwareCore

    You write the rich-world clients and the trusted applications against these two interfaces. Opening a session, defining command parameters, and calling cryptographic or trusted-storage services are part of ordinary feature work on the HPC.

  • CybersecurityCore

    You decide which keys, counters, and checks may exist only inside a trusted application, and you review each command so a rich-world caller cannot be led into exporting them. The security claim depends on that command design together with the isolation the TEE actually provides.

  • E/E architecturePartial

    You place the TEE on the HPC application processor and record which vehicle functions run as trusted applications. Keep this boundary distinct from a hardware security module on another controller.

  • Hardware & siliconPartial

    These APIs assume the application processor can isolate TEE memory and peripherals from the rich operating system, and that boot loads the TEE you intended. You own that isolation and boot path; the specifications describe the software calls above it.

  • Base softwarePartial

    On the HPC, platform software supplies the TEE operating system and the client library linked by rich-world code. Integration connects that stack to boot and storage while leaving TEE memory inaccessible to the rich operating system.

  • Software update & OTAPartial

    The TEE operating system and trusted applications are images in the HPC security-firmware update set. Plan their versions, signatures, and rollback together with the rest of that boot chain.

No direct stake: Functional safety · Networks & communication · Diagnostics & lifecycle