Software Solidification via Function Table Randomization
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software systems are dynamic and modifiable, leading to integrity issues due to unauthorized access and modifications, despite password and policy restrictions.
Innovation Solution
A method is introduced to create new references for functions, copy and associate their addresses, replace old references with dummy addresses, and randomize function table entries to prevent unauthorized execution, while optimizing code storage and execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If software is made dynamic and modifiable to allow user installation and modification, then ease of operation and adaptability are improved, but system integrity and security deteriorate due to unauthorized access and modifications
Solution Approach 1:
The software is divided into authorized code segments and unauthorized code segments. The function table is segmented to store only authorized function references. When code is executed, the system checks whether the code segment is authorized by verifying its presence in the function table, thus preventing unauthorized modifications while allowing legitimate software installation and modification.
Solution Approach 2:
The function table acts as an intermediary data structure between the code execution mechanism and the software installation/modification capability. It mediates by storing authorized function references and enabling the system to verify authorization without directly managing software installation or modification operations, thus maintaining integrity while preserving ease of operation.
2Reliability
If passwords and administrative controls are used to restrict software installation and modification, then system integrity is improved, but ease of operation deteriorates as possessors of administrative passwords gain access beyond their immediate responsibilities
Solution Approach 1:
Authorization is segmented at the function level rather than requiring broad administrative passwords. Each function or code segment can be independently authorized by adding its reference to the function table. This allows fine-grained control where specific functions can be made accessible to specific users or processes without granting broad administrative privileges, thus improving ease of operation while maintaining integrity.
Solution Approach 2:
The system changes the authorization parameter from binary (password-based admin/non-admin access) to a granular function-reference-based model. By storing specific function references in the function table, the system can control access at the function level, allowing possessors to access only their immediate responsibilities without gaining broader administrative access, thus resolving the contradiction between integrity and ease of operation.
3Adaptability or versatility
If code is copied and moved to different storage locations with new references, then adaptability and security are improved, but device complexity and storage management worsen
Solution Approach 1:
Code segments can be copied to different storage locations and each copy is assigned a new reference that is added to the function table. This allows the same code to be stored in multiple locations for redundancy or performance optimization while maintaining centralized authorization control through the function table, thus improving adaptability without proportionally increasing storage management complexity.
Solution Approach 2:
The function table serves as an intermediary that manages the complexity of code relocation. Instead of directly managing multiple storage locations and references, the system uses the function table to store authorized function references. This abstracts away the storage location complexity while maintaining adaptability, as the function table handles the mapping between code segments and their authorized locations.
Data Source
AI summary
A method for providing solidified software in a computing environment includes creating a new reference for a function in a function table; copying an address of the function and associating the address with the new reference; replacing the address associated with an old reference of the function with a dummy address; and substituting each old reference in normal code with the new reference, where injected code is not able to execute in the computing environment. The function table entries can be further randomized by reordering the entries, introducing intermediate mappings, or providing non-operative entries. Alternatively, all or part of the code of the function can be copied and moved to a different storage location and associated with the new reference. The copied code can be further randomized by the insertion of dummy code, utilizing reverse peephole techniques, varying the size of the copied portion, or interleaving non-operative code.