Secure Interpreted Program Execution via Capability Subsets

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing security measures in mobile terminals do not effectively isolate interpreted programs from each other and the host platform, making them vulnerable to malicious code execution, which can lead to unauthorized actions and data theft.

Innovation Solution

A method is introduced that involves providing a shared interpreter library and a prototype stub executable, loading an interpreted program, forming a stub executable, associating it with the program, assigning capabilities, and executing it in a separate process context, while ensuring that only authorized code sections are executed by checking if the capabilities of the stub executable are a subset of the capabilities of the external interpreted program code section.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If interpreted programs are allowed to run freely in mobile terminals, then the functionality and value-added services are improved, but security is worsened due to inability to isolate malicious code from the host system and other applications

Engineering Contradiction:
ImprovefunctionalityVSAvoidsecurity
Core Design Contradiction:
Adaptability or versatilityVSReliability

Solution Approach 1:

The system segments the execution environment by creating isolated process contexts for each interpreted program. Each program runs in its own sandboxed environment with restricted access to system resources, preventing malicious code from affecting the host system or other applications while maintaining full functionality of the interpreted programs.

Inventive Principle:
Principle #1Segmentation

2Reliability

If application isolation is implemented for interpreted programs, then security is improved, but device complexity is worsened due to need for additional isolation mechanisms and process management structures

Engineering Contradiction:
ImprovesecurityVSAvoidsystem complexity
Core Design Contradiction:
ReliabilityVSDevice complexity

Solution Approach 1:

The system introduces an intermediary layer (the isolation mechanism) between the interpreted programs and the host system. This mediator manages process contexts and enforces security policies, providing structured isolation without requiring fundamental changes to the underlying operating system or hardware architecture.

Inventive Principle:
Principle #24Intermediary (Mediator)

3Reliability

If capability assignment is enforced for stub executables, then security is improved by preventing unauthorized access, but ease of operation is worsened due to additional capability checking and verification steps

Engineering Contradiction:
ImprovesecurityVSAvoidoperational simplicity
Core Design Contradiction:
ReliabilityVSEase of operation

Solution Approach 1:

The system performs capability assignment and verification in advance during the program loading and stub creation phase. By pre-configuring security capabilities and validating them before execution, the system minimizes runtime overhead and maintains operational simplicity while ensuring security requirements are met.

Inventive Principle:
Principle #10Preliminary action

Data Source

PatentUS7444624B2Method for the secure interpretation of programs in electronic devices
Publication Date: 2008.10.28 NOKIA TECHNOLOGIES OY
  • US7444624B2 patent drawing
  • US7444624B2 patent drawing
  • US7444624B2 patent drawing

AI summary

The invention relates to method for secure interpretation of a program in an electronic device. An interpreted program is loaded and a stub executable is formed using a prototype stub executable. The stub executable is associated with the interpreted program. At least one second capability also is assigned to the interpreted program and further to the stub executable. The stub executable invokes at least one function in a shared interpreter library to interpret the interpreted program. An interpreter engine checks whether the interpreted program refers an external interpreted program code section. The interpreter engine infers at least one second capability for the external interpreted program code section. The interpreter engine disallows the execution of said external interpreted program code section if said at least one first capability is not a subset of said at least one second capability.