Secure String Memory Management for VM Data Protection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Standard virtual programming languages do not provide adequate protection for sensitive information, particularly when deployed on vulnerable platforms like public cloud hosting, as immutable objects in memory can leak sensitive data, and existing solutions like char[] or byte[] arrays introduce complexity and vulnerabilities.
Innovation Solution
Implementing a method to store encrypted data in memory and overwrite plaintext values immediately after use, using an encryption key derived from external parameters that are difficult for attackers to access, thereby minimizing the exposure window of sensitive data.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If sensitive data is stored in immutable objects like managed String objects in heap memory, then code simplicity is maintained, but security is compromised as data can be leaked through memory dumps, debugging, and confidentiality attacks
Solution Approach 1:
The patent segments sensitive data storage by creating a specialized secure string class that separates sensitive data from standard string objects. This secure string type isolates sensitive information in a protected manner while maintaining the immutable property, thus preserving code simplicity without sacrificing security.
Solution Approach 2:
The patent introduces an intermediary mechanism through the secure string class that acts as a mediator between the need for immutable strings and security requirements. This intermediary enforces secure storage practices automatically, preventing data leakage while maintaining ease of use for developers.
2Object-affected harmful factors
If char[] or byte[] arrays are used instead of string objects to store sensitive data, then security is improved by allowing manual memory management, but code complexity increases and programmers must manually manage memory
Solution Approach 1:
The secure string class provides self-service by automatically managing the lifecycle of sensitive data in memory. It handles allocation, encryption, and secure deletion without requiring manual intervention from programmers, thus maintaining security while eliminating the complexity of manual memory management.
Solution Approach 2:
The patent changes the fundamental parameter of string mutability by creating an immutable secure string type that combines the security benefits of mutable arrays with the simplicity of immutable strings. This parameter change allows automatic memory management while maintaining security.
3Ease of operation
If garbage collection is used to manage eviction of sensitive data from memory, then automatic memory management is achieved, but security is compromised as garbage collection is non-deterministic and does not guarantee memory overwriting
Solution Approach 1:
The patent applies preliminary action by overwriting sensitive data with secure deletion immediately when it is no longer needed, rather than relying on future garbage collection. This deterministic overwriting occurs at the precise moment when security is required, ensuring reliable data eviction while maintaining automatic memory management.
Solution Approach 2:
The secure string class implements feedback mechanisms through finalizers or disposal patterns that detect when the object is no longer needed and automatically trigger secure deletion. This feedback loop ensures that sensitive data is reliably evicted from memory as soon as it becomes unnecessary, combining automatic management with deterministic security.
4Object-affected harmful factors
If encryption is used to protect sensitive data in memory, then security is improved by reducing exposure window, but additional computational overhead is introduced
Solution Approach 1:
The patent applies periodic action by encrypting and decrypting data only when needed during its lifecycle, rather than maintaining continuous encryption. Sensitive data is decrypted temporarily for processing and then immediately re-encrypted or securely deleted, minimizing the time data remains in plaintext and reducing overall computational overhead while maintaining security.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
Techniques for reducing compromise of sensitive data in a virtual machine are described. During initiation of a secure string instance of a program module in memory allocated to the virtual machine, the program module can receive sensitive data in plaintext and retrieves parameters sourced from outside the allocated memory. During the execution of the program module, the sensitive data can be encrypted using a key based on the parameters to obtain encrypted data. The program module can overwrite the sensitive data with the encrypted data. The program module can receive a trigger to send a message that is generated using the sensitive data. The encrypted data can be decrypted using the key based on the parameters to obtain the sensitive data. After encryption and decryption, the program module can generate the message using the sensitive data and overwrite the sensitive data and the parameters used to encrypt the sensitive data.