Gesture-based computing interfaces, such as touch screen computing, provide intuitive and natural user interaction for a wide variety of applications. Gesture-based computer interfaces typically employ a standard interaction scheme: an initial view of the interface is rendered on the display, the user interacts with the interface by performing a gesture, and an updated view of the interface is rendered based on the gesture. Such gesture computing often benefits from real-time rendering of the corresponding user interface. For example, zooming or panning in an application becomes more usable when the user interface tracks the user's fingers quickly and smoothly. To accomplish smooth content rendering in the user interface, many computing systems offload some or all of the content rendering to dedicated processor graphics circuitry, sometimes called a graphics processing unit (“GPU”).
Traditionally, if any components of a computing device involved in a calculation or transaction were compromised due to malicious activity, the security of the entire calculation or transaction was potentially compromised. Therefore, security vulnerabilities in gesture response and view rendering components traditionally exposed the entire system to security vulnerabilities. For example, considering a secure bank transaction application, an attacker exploiting the view rendering component could switch “authorize” and “cancel” controls in the user interface, thereby causing the application to authorize transactions against the user's wishes. Or the attacker could access confidential data by directly copying an image of the rendered user interface. For example, considering a video editing application, an attacker may attempt to exploit the view rendering component to copy decoded video content and defeat copy protection mechanisms. Increased use of processor graphics in gesture-based computing may increase the potential attack surface exploitable by malicious attackers.
Computer processors have for some time included security primitives allowing the creation of hardware-enforced secure execution environments for code executing on the processor. Such secure execution environments protect against security vulnerabilities by verifying the authenticity of code and preventing access or modifications of code by unauthorized entities running on the processor itself. However, such processor-based secure execution environments generally do not provide the level of performance needed for graphics-intensive tasks like rendering content data in response to gesture input.