Hard Object Hardware Enforcement for Software Memory Safety
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software systems lack the ability to enforce sufficient locality of causality, leading to bugs and security vulnerabilities due to unrestricted access to memory and data, making software correctness and security intractable at scale.
Innovation Solution
Implementing the Hard Object system, which enforces locality of causality through hardware modifications and software annotations, ensuring that instruction and data access adhere to specific module identifiers, lifetime associations, and other constraints to prevent unauthorized access and ensure memory safety.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If hardware engineers eliminate all locality of causality within software to give software engineers freedom to write programs, then ease of programming is improved, but security and correctness deteriorate
Solution Approach 1:
The patent segments the address space into distinct modules, each with its own identity and boundaries. Hardware enforcement mechanisms check module identifiers on memory accesses to ensure that code can only access data within its own module or authorized modules, thereby restoring locality of causality while maintaining programming flexibility through defined interfaces
Solution Approach 2:
The patent introduces hardware enforcement mechanisms as intermediaries between software and memory. These mechanisms automatically check module identifiers and enforce boundaries without requiring software to manually manage security, thus preserving ease of programming while ensuring security through automated boundary enforcement
2Adaptability or versatility
If software is given unrestricted access to memory and data, then programming flexibility is improved, but software correctness becomes intractable
Solution Approach 1:
The patent divides the address space into modular segments with distinct identities. Each module has clearly defined boundaries enforced by hardware, which automatically checks module identifiers on memory accesses. This segmentation maintains programming flexibility within modules while making correctness tractable through automated boundary enforcement
Solution Approach 2:
The hardware enforcement mechanisms automatically manage module boundary verification without requiring software to implement complex security checks. The system serves itself by autonomously enforcing locality of causality through module identifier checks, thereby maintaining flexibility while reducing the complexity of ensuring correctness
Data Source
AI summary
Modifications to existing computer hardware, compiler changes or source-to-source transforms performed during the software build process, and a collection of libraries and modifications to existing standard system software and libraries. The invention allows a program author to enforce various kinds of locality of causality in software to provide enforcement of boundaries for the following aspects of a computer program: control, space, time, modularity, reference, initialization, and mutability. Where these properties do not suffice to guarantee a property at static time, dynamic checks may be added and the constraints on control flow prevent such dynamic checks from being avoided by the program.