# US 2017/0257383 A1 · Deterministic reproduction of client/server computer state or output sent to one or more client computers

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

- Number: US 2017/0257383 A1
- Document ID: US20170257383A1
- Status: Published application
- Kind: A1
- Application number: 15/060,322
- Filed: 2016-03-03
- Published: 2017-09-07
- Earliest claimed: 2016-03-03
- Assignees: Shape Security, Inc.
- Applicants: Shape Security, Inc.
- Inventors: MICHAEL J. FICARRA
- Web page: https://patentgrep.com/patent/US20170257383A1

## CPC

- H04L 63/08: {for authentication of entities (cryptographic mechanisms or cryptographic arrangements for entity authentication H04L9/32)}
- G06F 21/44: Program or device authentication
- H04L 63/1408: {by monitoring network traffic (monitoring network traffic per se H04L43/00)}
- H04L 63/1425: {Traffic logging, e.g. anomaly detection}
- H04L 63/1441: {Countermeasures against malicious traffic (countermeasures against attacks on cryptographic mechanisms H04L9/002)}
- H04L 67/02: based on web technology, e.g. hypertext transfer protocol [HTTP]
- G06F 2221/2101: Auditing as a secondary aspect
- G06F 2221/2103: Challenge-response
- G06F 2221/2119: Authenticating web pages, e.g. with suspicious links
- H04L: TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION (arrangements common to telegraphic and telephonic communication H04M)
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Computer systems and methods for improving security or performance of one or more client computers interacting with a plurality of server computers. In an embodiment, a computer system comprises a first server computer and a second server computer; wherein the first server computer is configured to: generate a challenge nonce, wherein the challenge nonce corresponds to a challenge state; generate the challenge state based on the challenge nonce, wherein the challenge state corresponds to a response state; send, to a first client computer, the challenge nonce and the challenge state, but not the response state; wherein the second server computer is configured to: receive, from the first client computer, a test nonce and a test response state; determine whether the test response state matches the response state based on the test nonce, without: receiving the challenge state from the first server computer; receiving the challenge state from the first client computer.

## Claims

### Claim 1

A computer system, configured to improve security or performance of one or more client computers interacting with a plurality of server computers, comprising a first server computer and a second server computer;
wherein the first server computer is configured to:
generate a challenge nonce, wherein the challenge nonce corresponds to a challenge state;
generate the challenge state based on the challenge nonce, wherein the challenge state corresponds to a response state;
send, to a first client computer, the challenge nonce and the challenge state, but not the response state;
wherein the second server computer is configured to:
receive, from the first client computer, a test nonce and a test response state;
determine whether the test response state matches the response state based on the test nonce, without:
receiving the challenge state from the first server computer;
receiving the challenge state from the first client computer.

### Claim 2 (depends on 1)

The computer system of claim 1, wherein:
the first server computer does not persistently store the challenge nonce;
the first server computer does not persistently store the challenge state; and
the first server computer does not generate the response state.

### Claim 3 (depends on 1)

The computer system of claim 1, wherein the challenge nonce matches the test nonce, and the second server computer is configured to:
generate the challenge state based on the test nonce;
generate the response state based on the challenge state.

### Claim 4 (depends on 3)

The computer system of claim 3, wherein the second server computer is configured to perform a positive action in response to determining that the test response state matches the response state.

### Claim 5 (depends on 1)

The computer system of claim 1, wherein the test nonce does not match the challenge nonce, and wherein the second server computer is configured to:
generate an expected challenge state based on the test nonce;
generate an expected response state based on the expected challenge state;
determine that the expected response state is different than the response state, and in response, determine that the test response state does not match the response state.

### Claim 6 (depends on 5)

The computer system of claim 5, wherein the second server computer is configured to perform a negative action in response to determining that the test response state does not match the response state.

### Claim 7 (depends on 5)

The computer system of claim 5, wherein the test response state matches the response state.

### Claim 8 (depends on 1)

The computer system of claim 1, wherein the challenge state comprises a set of instructions, which when executed produces the response state.

### Claim 9 (depends on 8)

The computer system of claim 8, wherein the first server computer is configured to include the set of instructions in a web page, wherein sending the set of instructions to the first client computer comprises sending the web page to the first client computer.

### Claim 10 (depends on 8)

The computer system of claim 8, wherein a third server computer is configured to:
receive, from the first client computer, an error message that includes the test nonce, wherein the test nonce is the challenge nonce;
store the error message with the test nonce;
receive, from a second client computer, a request for the error message and the set of instructions sent to the first client computer that caused the first client computer to send the error message, and in response, generate the set of instructions based on the test nonce, and send the set of instructions to the second client computer.

### Claim 11 (depends on 1)

The computer system of claim 1, wherein the first server computer and the second server computer are configured to, for each unique nonce, among a set of unique nonces:
generate a unique challenge state comprising a unique set of instructions that define one or more unique functions, which when executed, causes the one or more unique functions to generate a unique response state.

### Claim 12 (depends on 11)

The computer system of claim 11, wherein, for each unique nonce among the set of unique nonces, the unique response state is a unique stack trace based on the one or more unique functions.

### Claim 13

A computer system comprising:
a plurality of computers coupled to one or more non-transitory computer readable media storing a set of instructions which, when executed by the plurality of computers, causes:
a first computer to:
generate a challenge nonce, wherein the challenge nonce corresponds to a challenge state;
generate the challenge state based on the challenge nonce, wherein the challenge state corresponds to a response state;
send, to a first client computer, the challenge nonce and the challenge state, but not the response state;
a second computer to:
receive, from the first client computer, a test nonce and a test response state;
determine whether the test response state matches the response state based on the test nonce, without:
receiving the challenge state from the first computer;
receiving the challenge state from the first client computer.

### Claim 14 (depends on 13)

The computer system of claim 13, wherein the set of instructions, when executed by the plurality of computers, does not cause the first computer to:
persistently store the challenge nonce;
store the challenge state;
generate the response state.

### Claim 15 (depends on 13)

The computer system of claim 13, wherein the challenge nonce matches the test nonce, and wherein the set of instructions, when executed by the plurality of computers, causes the second computer to:
generate the challenge state based on the test nonce;
generate the response state based on the challenge state.

### Claim 16 (depends on 15)

The computer system of claim 15, wherein the set of instructions, when executed by the plurality of computers, causes the second computer to perform a positive action in response to determining that the test response state matches the response state.

### Claim 17 (depends on 13)

The computer system of claim 13, wherein the test nonce does not match the challenge nonce, and wherein the set of instructions, when executed by the plurality of computers, causes the second computer to:
generate an expected challenge state based on the test nonce;
generate an expected response state based on the expected challenge state;
determine that the expected response state is different than the response state, and in response, determine that the test response state does not match the response state.

### Claim 18 (depends on 17)

The computer system of claim 17, wherein the set of instructions, when executed by the plurality of computers, causes the second computer to perform a negative action in response to determining that the test response state does not match the response state.

### Claim 19 (depends on 17)

The computer system of claim 17, wherein the test response state matches the response state.

### Claim 20 (depends on 13)

The computer system of claim 13, wherein the challenge state comprises one or more instructions, which when executed produces the response state.

### Claim 21 (depends on 20)

The computer system of claim 20, wherein the set of instructions, when executed by the plurality of computers, causes the first computer to include the one or more instructions in a web page, wherein sending the one or more instructions to the first client computer comprises sending the web page to the first client computer.

### Claim 22 (depends on 20)

The computer system of claim 20, wherein the set of instructions, when executed by the plurality of computers, causes a third server computer to:
receive, from the first client computer, an error message that includes the test nonce, wherein the test nonce is the challenge nonce;
store the error message with the test nonce;
receive, from a second client computer, a request for the error message and the one or more instructions sent to the first client computer that caused the first client computer to send the error message, and in response, generate the one or more instructions based on the test nonce, and send the one or more instructions to the second client computer.

### Claim 23 (depends on 13)

The computer system of claim 13, wherein the set of instructions, when executed by the plurality of computers, causes the first computer, and the second computer, to, for each unique nonce, among a set of unique nonces:
generate a unique challenge state comprising a unique set of instructions that define one or more unique functions, which when executed, causes the one or more unique functions to generate a unique response state.

### Claim 24 (depends on 23)

The computer system of claim 23, wherein, for each unique nonce among the set of unique nonces, the unique response state is a unique stack trace based on the one or more unique functions.

### Claim 25

A method comprising:
generating, at a first server computer, a challenge nonce, wherein the challenge nonce corresponds to a challenge state;
generating, at the first server computer, the challenge state based on the challenge nonce, wherein the challenge state corresponds to a response state;
sending, from the first server computer, to a first client computer, the challenge nonce and the challenge state, but not the response state;
receiving, at a second server computer, from the first client computer, a test nonce and a test response state;
determining, at the second server computer, whether the test response state matches the response state based on the test nonce, without:
receiving the challenge state from the first server computer;
receiving the challenge state from the first client computer.

### Claim 26

A method comprising:
generating, at a server computer, a challenge nonce, wherein the challenge nonce corresponds to a challenge state;
generating, at the server computer, the challenge state based on the challenge nonce, wherein the challenge state corresponds to a response state;
sending, from the server computer, to a first client computer, the challenge nonce and the challenge state, but not the response state;
receiving, at the server computer, from the first client computer, a test nonce and a test response state;
determining, at the server computer, whether the test response state matches the response state based on the test nonce, without:
the server computer persistently storing the challenge nonce;
the server computer persistently storing the challenge state.
