# US 2025/0148073 A1 · Systems and methods for managing state

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2025/0148073 A1
- Document ID: US20250148073A1
- Status: Published application
- Kind: A1
- Application number: 18/942,275
- Filed: 2024-11-08
- Published: 2025-05-08
- Earliest claimed: 2019-07-29
- Assignees: Intertrust Technologies Corporation
- Applicants: Intertrust Technologies Corporation
- Inventors: Stephen G. Mitchell
- Web page: https://patentgrep.com/patent/US20250148073A1

## CPC

- G06F 21/14: against software analysis or reverse engineering, e.g. by obfuscation
- G06F 21/54: by adding security routines or objects to programs
- G06F 21/51: at application loading time, e.g. accepting, rejecting, starting or inhibiting executable software based on integrity or source reliability
- G06F 21/52: during program execution, e.g. stack integrity {; Preventing unwanted data erasure; Buffer overflow}
- G06F 21/74: operating in dual or compartmented mode, i.e. at least one secure mode
- H04L 9/0861: {Generation of secret information including derivation or calculation of cryptographic keys or passwords}
- H04L 9/3242: {involving keyed hash functions, e.g. message authentication codes [MACs], CBC-MAC or HMAC}
- H04L 9/3263: {involving certificates, e.g. public key certificate [PKC] or attribute certificate [AC]; Public key infrastructure [PKI] arrangements (network architectures or network communication protocols for supporting authentication of entities using certificates in a packet data network H04L63/0823)}
- H04L 9/50: {using hash chains, e.g. blockchains or hash trees}
- G06F 12/1408: {by using cryptography (for digital transmission H04L9/00)}
- G06F 21/123: {by using dedicated hardware, e.g. dongles, smart cards, cryptographic processors, global positioning systems [GPS] devices}
- G06F 21/125: {by manipulating the program code, e.g. source code, compiled code, interpreted code, machine code}
- G06F 21/64: Protecting data integrity, e.g. using checksums, certificates or signatures
- G06F 2221/2107: File encryption
- H04L 2209/16: Obfuscation or hiding, e.g. involving white box
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)
- H04L: TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION (arrangements common to telegraphic and telephonic communication H04M)

## Abstract

The disclosure relates to systems and methods for managing state using relatively small assistance from protected hardware. Obfuscated code segments may communicate with supporting protected hardware, store encrypted state values in main memory, and/or communicate via secure channels to secure platform hardware components. In various embodiments, consistent state may be achieved, at least in part, by computing secure tag information and storing the secure tag information in a secure and/or otherwise protected device register. Consistent with embodiments disclosed herein, the tag information may be used to derive keys used to encrypt and/or decrypt stored state information. Tag information may further be used in connection with verification operations prior to using the information to derive associated keys.

## Claims

### Claim at position 1

1-20. (canceled)

### Claim 21

A method for managing a protected software function performed by a computing system comprising secure hardware, a processor, and a non-transitory computer-readable medium storing instructions that, when executed by the processor, cause the computing system to perform the method, the method comprising:
receiving at least one protected input from the secure hardware and encrypted initial program state information;
retrieving a previous secure tag and a current secure tag associated with the encrypted initial program state information from a protected memory register of the secure hardware;
decrypting the at least one protected input using a program input decryption key to generate decrypted program input from the secure hardware and a nonce value;
comparing the nonce value and the previous secure tag to determine that the nonce value and the previous secure tag match;
generating a state decryption key based on a protected fixed key and the previous secure tag;
decrypting the encrypted initial program state information using the state decryption key to generate decrypted initial program state information;
executing the protected software function using, at least in part, the decrypted program input and the decrypted initial program state information to generate updated program state information and program output information;
generating a state encryption key based on the protected fixed key and the current secure tag;
encrypting the updated program state information using the state encryption key to generate encrypted updated program state information; and
storing the encrypted updated program state information in system memory maintained on the non-transitory computer-readable medium.

### Claim 22 (depends on 21)

The method of claim 21, wherein the method further comprises validating the previous secure tag and the current secure tag.

### Claim 23 (depends on 22)

The method of claim 22, wherein validating the previous secure tag and the current secure tag comprises generating a hash value based, at least in part, on the previous secure tag and comparing the generated hash value with the current secure tag.

### Claim 24 (depends on 23)

The method of claim 23, wherein validating the previous secure tag and the current secure tag further comprises determining, based on the comparison, that the generated hash value and the current secure tag are the same value.

### Claim 25 (depends on 23)

The method of claim 23, wherein generating the hash value is further based on a shared key.

### Claim 26 (depends on 21)

The method of claim 21, wherein the program input decryption key is generated using, at least in part, a shared key.

### Claim 27 (depends on 26)

The method of claim 26, wherein the shared key comprises a key shared between the secure hardware and the protected software function.

### Claim 28 (depends on 21)

The method of claim 21, wherein the method further comprises receiving one or more software function inputs and wherein executing the protected software function to generate the updated program state information and the program output information further comprises executing the protected software function further using the one or more software function inputs.

### Claim 29 (depends on 28)

The method of claim 28, wherein the software function inputs comprise at least one of an external program input, a dynamic device resource input, and a static device resource input.

### Claim 30 (depends on 21)

The method of claim 21, wherein the previous secure tag and the current secure tag comprise message authentication code tags.

### Claim 31 (depends on 30)

The method of claim 30, wherein the previous secure tag and the current secure tag comprise sequential tags included in the protected memory register.

### Claim 32 (depends on 31)

The method of claim 31, wherein the previous secure tag and the current secure tag comprise sequential tags included in a hash chain maintained in the protected memory register.

### Claim 33 (depends on 21)

The method of claim 21, wherein receiving the encrypted initial program state information comprises retrieving the encrypted initial program state information from the system memory.

### Claim 34 (depends on 21)

The method of claim 21, wherein the protected software function comprises an obfuscated software function.

### Claim 35 (depends on 21)

The method of claim 21, wherein the protected software function comprises a whitebox protected software function.

### Claim 36 (depends on 21)

The method of claim 21, wherein generating the state decryption key comprises generating the state decryption key using a key derivation function with the protected fixed key and the previous secure tag as inputs to the key derivation function.

### Claim 37 (depends on 21)

The method of claim 21, wherein generating the state encryption key comprises generating the state encryption key using a key derivation function with the protected fixed key and the current secure tag as inputs to the key derivation function.

### Claim 38 (depends on 21)

The method of claim 21, wherein decrypting the encrypted initial program state information using the state decryption key is performed using an authenticated decryption function.

### Claim 39 (depends on 21)

The method of claim 21, wherein encrypting the updated program state information using the state encryption key is performed using an authenticated encryption function.
