Hard Object Hardware Enforcement of Encapsulation and Unforgeability
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Modern computer hardware lacks fine-grain hardware primitives to efficiently enforce module isolation and protect software modules from errant or malicious behavior within a single process, leading to software reliability and security issues due to the lack of locality of causality, making it difficult to ensure program correctness and security.
Innovation Solution
The Hard Object system introduces a lightweight modification to existing hardware platforms that enforces encapsulation, unforgeability, and transactionality by using module-ids, references, and agents to constrain access to data, ensuring that operations on objects are allowed only by their module, through valid references, and exhibit isolation and sequential consistency, allowing mutually untrusting programs to run safely in the same address space.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If hardware engineers eliminate all locality of causality within a computer to give software freedom to access any data, then software flexibility and ease of programming are improved, but software reliability and security deteriorate
Solution Approach 1:
The patent divides the address space into discrete objects, each with its own protection domain and access control list. This segmentation allows the system to maintain global address space accessibility while enforcing fine-grained access control at the object level, thus preserving software flexibility while improving reliability through enforced boundaries.
Solution Approach 2:
The patent introduces an intermediary access control mechanism that sits between software and hardware, mediating all memory accesses. This intermediary layer (the access control hardware) enforces locality of causality by checking access rights against object boundaries, allowing software freedom while preventing unauthorized access and improving reliability.
2Reliability
If software engineers separate programs into modules to maintain invariants, then software correctness is improved, but hardware complexity increases due to lack of fine-grain hardware primitives
Solution Approach 1:
The patent implements self-service through automatic access control checking performed by hardware for every memory access. The system serves itself by enforcing module boundaries and invariant protection without requiring complex software enforcement mechanisms, thus improving software correctness while keeping hardware relatively simple through automated rather than manual enforcement.
Solution Approach 2:
The patent creates a universal access control mechanism that handles multiple functions: module isolation, invariant protection, security enforcement, and transactionality. This single hardware primitive serves multiple purposes, improving software correctness across different concerns while avoiding the need for multiple separate hardware mechanisms, thus reducing overall hardware complexity.
3Object-affected harmful factors
If hardware provides fine-grain access control to enforce module isolation, then software security is improved, but hardware complexity and overhead increase
Solution Approach 1:
The patent applies local quality by associating specific access control lists and protection domains with individual objects rather than applying uniform protection across the entire address space. This allows fine-grained security enforcement at the object level while keeping the hardware implementation simple and localized to relevant memory accesses, thus improving security without proportionally increasing overall hardware complexity.
Solution Approach 2:
The patent implements partial action by enforcing access control only where necessary - at object boundaries and for protected resources - rather than applying comprehensive control to all memory operations. This selective enforcement improves software security for critical objects while minimizing hardware overhead by avoiding unnecessary checking for unprotected or less sensitive accesses.
4Reliability
If the system uses traditional virtual machines or operating systems for isolation, then security is improved, but performance and efficiency deteriorate due to overhead
Solution Approach 1:
The patent replaces the mechanical system of virtual machines and operating system kernels with a hardware-based access control mechanism. This substitution eliminates the software overhead of virtualization layers and OS mediation, providing security through hardware-enforced object boundaries while maintaining direct software execution, thus improving performance without sacrificing security.
Solution Approach 2:
The patent extracts the essential security function from complex virtual machine and operating system structures, isolating the core access control mechanism into dedicated hardware. This extraction removes unnecessary overhead layers while retaining the fundamental security benefit, thus improving performance by eliminating virtualization overhead while maintaining security through hardware-enforced isolation.
Data Source
AI summary
A hardware-implemented method to support three desirable software properties: encapsulation, referential integrity/capabilities, and transactions. These properties in turn may be used to support software correctness, specifically the enforcement of invariants, and computer security, specifically protecting parts of programs from each other within a single process.