Low-level Code Signing Mechanism for Secure Function Access
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing operating systems face challenges in ensuring secure access to executable code and functions without violating defined security policies, particularly in verifying the cryptographic signatures of applications attempting to instantiate secure classes, functions, and input parameters.
Innovation Solution
A security handler within the operating system verifies the cryptographic signatures of applications by comparing local digital signatures with test digital signatures obtained using hash functions and public keys associated with secure classes, functions, and input parameters, allowing access only to those signed with corresponding code signing keys.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If cryptographic signature verification is implemented for all applications accessing secure classes and functions, then security is improved, but system complexity and verification time increase
Solution Approach 1:
The patent applies preliminary action by pre-computing and storing hash values of secure classes, functions, and input parameters in a database before runtime. When an application requests access, the system retrieves pre-stored hash values and compares them with computed hashes from the application's cryptographic signature, eliminating the need for complex real-time cryptographic verification of the entire codebase and significantly reducing verification time and system complexity
Solution Approach 2:
The patent uses copying by creating hash copies of the original secure classes, functions, and input parameters. Instead of verifying the entire cryptographic signature of applications against the original code, the system computes hash copies of the relevant code segments and compares these simplified representations, maintaining security while reducing the computational complexity of the verification process
2Reliability
If cryptographic signature verification is performed for every access request, then access control security is improved, but processing time increases
Solution Approach 1:
The system performs preliminary hashing of secure classes, functions, and input parameters during system initialization or code loading, storing these pre-computed hash values in a database. During runtime access requests, the system retrieves these pre-stored hashes and performs only a simple comparison with newly computed hashes from the application's signature, reducing verification time from complex cryptographic analysis to simple hash comparison
Solution Approach 2:
The patent segments the verification process by dividing it into two phases: offline pre-computation of hash values for secure code elements, and online rapid comparison of these hashes with application signatures. This segmentation allows the time-consuming hashing operation to be performed once beforehand, while runtime verification only requires fast hash comparison, significantly reducing the time loss for each access request
3Reliability
If comprehensive code signing verification is implemented for applications, then security policy enforcement is improved, but ease of operation deteriorates
Solution Approach 1:
The patent introduces an intermediary mechanism in the form of a security handler that automatically performs cryptographic signature verification and security policy enforcement. This intermediary layer transparently intercepts application requests, verifies signatures against stored hashes, and enforces security policies without requiring application developers to manually implement verification logic or users to understand cryptographic processes, thus maintaining ease of operation while ensuring comprehensive security policy enforcement
Data Source
AI summary
Before an application is allowed to execute a secure function, code signing keys associated with the application are analyzed for correspondence with the class that contains the secure function as well as correspondence with the secure function. Optionally, code signing keys associated with the application are analyzed for correspondence with the input parameters to the function.