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.