Trusted Execution Environment Data Stream Integrity
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current data stream processing technologies face challenges in ensuring secure and efficient processing, particularly in trusted execution environments where protected memory is scarce, and there is a risk of malicious alterations to analysis outcomes.
Innovation Solution
Implementing a method that uses a trusted execution environment with a graph-based data structure and key-value store to securely process data streams by temporarily storing state parts in unprotected memory, ensuring integrity through cryptographic hashes and minimizing computational overhead.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If state parts of computations are stored in protected memory of trusted execution environment, then security and integrity are improved, but computational resource requirements and memory consumption increase
Solution Approach 1:
The patent divides the computation state into segments represented by a graph-based data structure, where only critical segments are stored in protected memory while others reside in unprotected memory. This segmentation allows selective protection of essential state parts, reducing overall protected memory consumption while maintaining integrity where needed.
Solution Approach 2:
The patent introduces cryptographic hash functions as intermediaries to verify the integrity of state parts stored in unprotected memory. Instead of storing all state in protected memory, hash values serve as mediators that enable integrity verification with minimal protected memory overhead, resolving the contradiction between security and memory consumption.
2Reliability
If more protected memory is allocated for data stream processing, then security against malicious alterations is improved, but computational overhead and resource requirements increase
Solution Approach 1:
The patent applies partial protection by storing only essential state parts in protected memory rather than protecting the entire computation state. This partial action approach provides adequate security against malicious alterations while avoiding the excessive computational overhead of protecting all data, thus resolving the contradiction between security and computational overhead.
Solution Approach 2:
The patent changes the parameter of protection from binary (protected/unprotected) to a spectrum based on cryptographic verification. By using hash verification with minimal protected memory, the system achieves security with reduced computational overhead, transforming the protection mechanism from resource-intensive to efficient.
3Productivity
If state parts are moved to unprotected memory for efficient processing, then processing speed and efficiency are improved, but risk of malicious alterations increases
Solution Approach 1:
The patent implements feedback through cryptographic hash verification that continuously monitors the integrity of state parts in unprotected memory. This feedback mechanism detects malicious alterations and enables recovery, allowing efficient processing in unprotected memory while mitigating the risk of alterations through active verification.
Solution Approach 2:
The patent performs preliminary cryptographic hashing of state parts before storing them in unprotected memory. This preliminary action creates integrity checkpoints that enable detection of malicious alterations, allowing the system to safely store state parts in unprotected memory while maintaining security through pre-established verification mechanisms.
Data Source
AI summary
A method for securing data stream processing includes implementing a stage of a data processing pipeline in a trusted execution environment. A state of the stage is represented by a graph-based data structure. Protected memory of the trusted execution environment is reserved for computations of the stage. A key-value store is maintained in the protected memory. The key-value store includes hashes of graph segments of the graph-based data structure for the computations and memory locations of the graph segments. A state part of the computations is moved from the protected memory to unprotected memory. The state part of the computations is loaded back to the protected memory. An integrity of a computation using the state part of the computations is checked using the hashes in the key-value store.