Hard Object Hardware Primitives for Module Isolation and Kernel Crossing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current computer systems lack effective hardware primitives to enforce fine-grain separation and protection between software modules, leading to vulnerabilities in software correctness and security, as modules within a process can access and interfere with each other's data, making programs brittle and prone to errors or attacks.
Innovation Solution
The Hard Object system introduces additional meta-data fields and instructions in page table entries and CPU status bits to enforce module isolation, allowing for fine-grain locality of causality, protecting heap and stack data, constraining control flow, and providing kernel services through normal function calls without the need for system calls.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If hardware engineers eliminate all locality of causality within a computer to give software engineers freedom to use any instruction to access any data, then ease of programming is improved, but software reliability deteriorates
Solution Approach 1:
The patent divides the address space into multiple modules, each with its own data segment. Hardware primitives enforce that code in one module can only access data in its own module unless explicitly permitted through controlled interfaces. This segmentation restores locality of causality at the module level while maintaining programming flexibility through well-defined inter-module communication mechanisms.
Solution Approach 2:
The patent implements fine-grain protection where each module has its own access control policies and data invariants. The hardware enforces that each module's code can access its own data without restriction while automatically preventing access to other modules' data. This local quality approach allows maximum freedom within each module's boundary while ensuring reliability through isolation.
2Reliability
If software engineers separate programs into modules with own data and code to maintain invariants, then software correctness is improved, but hardware protection capability deteriorates (lack of fine-grain hardware primitives)
Solution Approach 1:
The patent extends the existing page table structure by adding module identification fields to page table entries. This segmentation approach uses the existing hardware page table mechanism to enforce module boundaries, avoiding the need for completely new hardware structures while providing fine-grain module-level protection.
Solution Approach 2:
The patent makes the existing page table hardware serve multiple functions: traditional memory management (virtual to physical address translation) plus module-level access control. By encoding module identifiers in page table entries and using them for both address translation and access permission checks, the patent provides fine-grain protection without adding separate dedicated hardware protection structures.
3Reliability
If kernel mode is used to protect critical data and functions, then security is improved, but system call overhead increases
Solution Approach 1:
The patent extracts the access control functionality from the kernel mode system call mechanism and embeds it directly into the hardware page table structure. This extraction allows module-level protection to be enforced automatically by hardware during normal execution, eliminating the need for frequent system calls to enforce the same protection policies.
Solution Approach 2:
The patent implements self-service protection where the hardware automatically enforces module access boundaries through page table checks during every memory access. This self-service mechanism eliminates the need for software to actively manage protection by making system calls, as the hardware continuously enforces policies autonomously during normal program execution.
Data Source
AI summary
A method providing simple fine-grain hardware primitives with which software engineers can efficiently implement enforceable separation of programs into modules and constraints on control flow, thereby providing fine-grain locality of causality to the world of software. Additionally, a mechanism is provided to mark some modules, or parts thereof, as having kernel privileges and thereby allows the provision of kernel services through normal function calls, obviating the expensive prior art mechanism of system calls. Together with software changes, Object Oriented encapsulation semantics and control flow integrity in hardware are enforced.