Read-Once Memory Container for Secure Inter-Process Data Transfer

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing solutions for securely passing secrets between computer programs in memory are inadequate due to the risk of unauthorized access and the need for page-sized DMA management and limited process I/O, which can lead to insecurity.

Innovation Solution

A read-once memory container is allocated in memory to store data from a first computer program, allowing a second program to access and use the data, with a validity indicator ensuring the data's integrity, and upon access, the data becomes unreadable without being rewritten, providing a secure mechanism for secret data transfer.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If secret data is stored in memory while process context changes, then data can be accessed by different programs, but security is compromised because any process with equal security levels can snoop the data

Engineering Contradiction:
Improvedata accessibilityVSAvoidsecurity
Core Design Contradiction:
Adaptability or versatilityVSReliability

Solution Approach 1:

The patent segments memory into read-once memory containers that are isolated from general memory access. These containers are specifically allocated for secret data transfer between programs, preventing unauthorized processes from snooping data while allowing controlled access to authorized programs through the validity indicator mechanism.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent introduces read-once memory containers as an intermediary mechanism between source and destination programs. The containers act as secure intermediaries that hold secret data during transfer, using validity indicators to mediate access control and ensure only authorized programs can read the data once.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Reliability

If read-once memory container is used to store secret data, then security is improved by preventing unauthorized access, but data cannot be read again after first access

Engineering Contradiction:
ImprovesecurityVSAvoiddata reusability
Core Design Contradiction:
ReliabilityVSEase of operation

Solution Approach 1:

The patent applies preliminary action by writing a validity indicator to the read-once memory container before the actual secret data. This preliminary marker enables the container to be read once securely, and after reading, the validity indicator is consumed, preventing any subsequent reads and ensuring the data cannot be reused or snooped.

Inventive Principle:
Principle #10Preliminary action

3Reliability

If validity indicator is written to read-once memory container, then data integrity is ensured through validation, but additional memory operations are required

Engineering Contradiction:
Improvedata integrityVSAvoidmemory operations
Core Design Contradiction:
ReliabilityVSDevice complexity

Solution Approach 1:

The patent merges the validity indicator and secret data into a single read-once memory container. By combining these elements, the system ensures data integrity through the validity indicator while minimizing additional operations - both the indicator and data are written once and read once together, reducing the need for separate validation steps.

Inventive Principle:
Principle #5Merging (Combining)

Data Source

PatentUS11467954B2Passing data between programs using read-once memory
Publication Date: 2022.10.11 LENOVO SWITZERLAND INTERNATIONAL GMBH
  • US11467954B2 patent drawing
  • US11467954B2 patent drawing
  • US11467954B2 patent drawing

AI summary

In one aspect, a device may include at least one processor and storage accessible to the at least one processor. The storage may include instructions executable by the at least one processor to allocate, in memory, a read-once memory container to store data from a first computer program. The instructions may also be executable to write the data from the first computer program to the read-once memory container and to permit a second computer program to use the data as stored in the read-once memory container. The data, upon being accessed from the read-once memory container, may not be readable again from the read-once memory container without being written again.