Anonymous event proofs with group signatures
The device-integrity computing system uses device integrity tokens and anonymous certificates to secure client device communications, addressing vulnerabilities in public networks and enhancing privacy by anonymizing trust levels.
Patent Information
- Application Number
- JP2023081793
- Authority / Receiving Office
- JP · JP
- Patent Type
- Patents
- Current Assignee / Owner
- Priority Date
- 2020-07-09
- Filing Date
- 2023-05-17
- Publication Date
- 2024-11-13
- Estimated Expiration
- 2041-03-16
AI Technical Summary
Client devices face challenges in maintaining communication integrity over public networks, as they are vulnerable to interception, modification, and fraudulent requests, while existing authentication techniques compromise user privacy by using stable device identifiers for tracking.
A device-integrity computing system generates device integrity tokens using public key cryptography and blind signature schemes, ensuring secure communication channels without revealing the client device's identity, and employs group signature schemes to enhance privacy by anonymizing device trust levels.
This approach provides secure communication channels that protect against fraudulent requests and data integrity, while minimizing user tracking and privacy risks by using anonymous certificates and group signatures.
Smart Images

Figure 0007583108000001 
Figure 0007583108000002 
Figure 0007583108000003
Abstract
Description
[Background technology]
[0001] Client devices transmit requests and other data over public networks, such as the Internet. These communications can be altered by other parties, such as parties that intercept the communications and / or intermediaries that receive the communications and forward them to other parties.
[0002] Client devices are also subject to malicious attacks such as viruses and malware that can send fraudulent requests without the user's knowledge or authentication. In addition, other parties can emulate client devices to send requests that appear to originate from a client device but that actually come from the other party's device.
[0003] Various authentication techniques can be used to prevent fraud and abuse and to protect the integrity of transactions over public networks. At the same time, these authentication techniques can involve privacy issues. For example, users of client devices may not want to share information (such as stable device identifiers) that can be used to track client devices or users of those client devices, and data providers may operate under privacy protection standards that prevent the data provider from receiving or processing such information. Summary of the Invention [Problem to be solved by the invention]
[0004] This specification describes technologies related to authentication techniques to protect the integrity of communications sent from a client device while at the same time avoiding the use of stable device identifiers that can be used to track a client device or its user. [Means for solving the problem]
[0005] In general, a first inventive aspect of the subject matter described herein may be embodied in a computer-implemented method comprising: receiving, by a device integrity computing system, a request for N device integrity elements from a client device, the request including a device level tamper detection signal for the client device and, for each of the N device integrity elements, public key data including at least one of (i) a respective public key for the device integrity element, or (ii) a derivative of the respective public key for the device integrity element; determining, by the device integrity computing system, a verdict of authenticity of the client device based at least on the device level tamper detection signal; generating, by the device integrity computing system, for each of the N device integrity elements, a device integrity element using at least the public key data for the device integrity element, the device integrity element including a digital signature generated based on a set of content including the public key data for the device integrity element; and transmitting, by the device integrity computing system, the N device integrity elements to the client device, where N may be, for example, an integer equal to or greater than 1. Other implementations of this aspect include corresponding apparatus, systems, and computer programs configured to implement aspects of the method encoded on computer storage devices.
[0006] In some aspects, each device integrity element includes a respective device integrity token including a set of content for the device integrity element, the set of content for the device integrity element including a timestamp indicating a time at which a verdict of trustworthiness was determined and public key data for the device integrity element, and generating each device integrity element includes digitally signing the set of content for the device integrity element using a private key of the device integrity computing system. The set of content for the device integrity element may further include the verdict of trustworthiness.
[0007] In some aspects, generating each device integrity element includes generating a blind signature of the public key data for the device integrity element using a blind signature scheme, the device integrity element being the blind signature. The method may further include publishing M blind signature verification keys corresponding to the M trust levels of the client device, and maintaining M respective signing keys corresponding to the M verification keys.
[0008] In some aspects, determining the trust verdict may include assigning a level of trust to the client device selected from M trust levels. For example, the public key data for each device integrity element may include a derivative of a public key for the device integrity element, where the derivative of the public key for the device integrity element may include a blinded public key that has been blinded using a blinded signature scheme. The derivative of the public key for the device integrity element may include a blinded truncated cryptographic hash of the public key for the device integrity element.
[0009] In some aspects, the blind signature scheme includes a privately verifiable blind signature scheme For example, the privately verifiable blind signature scheme may be an IETF VOPRF blind signature scheme.
[0010] In another aspect, the blind signature scheme comprises a publicly verifiable blind signature scheme For example, the publicly verifiable blind signature scheme may be a blind RSA signature scheme.
[0011] Another inventive aspect of the subject matter described herein may be embodied in a method executed by a client device, the method including: sending a first request for an anonymous certificate to a device integrity computing system, the request including a device level fraud detection signal for the client device; receiving an anonymous certificate from the device integrity computing system, the anonymous certificate corresponding to a given signature group selected from a set of device trust groups based on at least the device level fraud detection signal, each device trust group corresponding to a respective trust category; creating an anonymous certification token including (i) a set of data including the second request and a certification token creation timestamp indicating a time of creation of the anonymous certification token, and (ii) a digital signature of the set of data generated using a group signature scheme by the anonymous certificate; and sending the certification token to a recipient. Other implementations of this aspect include corresponding apparatuses, systems, and computer programs configured to implement aspects of the method encoded on a computer storage device.
[0012] In some aspects, the group signature scheme is a Direct Anonymous Attestation (DAA) signature scheme. The DAA signature scheme can be an Elliptic Curve Cryptography (ECC) DAA signature scheme. The ECC DAA signature scheme can be an ECC DAA signature scheme using a Barreto-Naehrig curve.
[0013] In some aspects, the anonymous certificate is an irrevocable anonymous certificate that indicates that the client device has been irrevocably assigned to a given signature group.
[0014] In some aspects, the set of device trust groups includes at least a first trust group including devices having a first trust level as members and a second trust group including devices having a second trust level as members, the second trust level being lower than the first trust level, where a given group is one of the first group or the second signature group. The first and second trust groups may have corresponding first and second group public keys published by the device integrity computing system.
[0015] In some aspects, the method further includes storing the anonymous certificate in a secure private key store on the client device.
[0016] In some embodiments, the token creation timestamp has a time resolution of less than about 1 millisecond or less than about 1 microsecond.
[0017] In some implementations, the method further includes receiving information indicating an attestation token quantity limit and, prior to the creating step, verifying that the creation does not exceed the attestation token quantity limit. The attestation token quantity limit can be a limit on the number of anonymous tokens that are eligible to be sent from a client device to a selected destination domain within a selected time frame, or the attestation token quantity limit can be a limit on the number of anonymous tokens that are eligible to be sent from one or more selected applications on a client device to a selected destination domain within a selected time frame, or the attestation token quantity limit can be a limit on the number of anonymous tokens that are eligible to be sent from a client device to a selected endpoint in a selected destination domain within a selected time frame, or the attestation token quantity limit can be a limit on the number of anonymous tokens that are eligible to be sent from one or more selected applications on a client device to a selected endpoint in a selected destination domain within a selected time frame, or any combination thereof.
[0018] The subject matter described in this specification can be implemented in particular embodiments to realize one or more of the following advantages.
[0019] Using the attestation token to transmit data from a client device provides a secure communication channel between the client device and another entity's computer or other device. By including a digital signature of the data contained in the attestation token along with the attestation token, the entity can verify that the data in the attestation token has not been altered since the attestation token was created. Additionally, by including the token creation time in the attestation token, the recipient can determine whether the request is new or is potentially part of a replay attack.
[0020] The attestation token may also include a device integrity token that indicates the integrity of the client device that sent the attestation token, which allows a recipient of the attestation token to verify that the data came from a trusted client device and not, for example, from an emulator or compromised device. The device integrity token may be generated and digitally signed by a trusted device analyzer (e.g., a third-party device analyzer) so that a recipient of the attestation token can verify that the client device was evaluated by a trusted device analyzer and that the data in the device integrity token was not modified after being created by the trusted device analyzer.
[0021] Although attestation tokens protect the integrity of communications sent from a client device, there are potential privacy issues associated with the use of attestation tokens. The first privacy issue is that re-use of the same device integrity token in multiple attestation tokens can potentially allow an attestation token receiver to correlate multiple requests sent by the same client device and aggregate user data based on the correlation. The techniques described herein can improve privacy for such correlation by using multiple device integrity tokens, each containing a unique public key of the client device. For example, a client device can generate a batch of N public / private key pairs and then transmit the N public keys to a third-party device analyzer to receive a batch of N corresponding device integrity tokens. The client device can then use, for example, a new device integrity token for each request, or the client device can use the same device integrity token for all requests within a certain time interval, or the client device can use the same device integrity token for all requests originating from the same application on the client device, or some combination thereof. Limiting the use of each public key limits the amount of requests that a receiver can correlate based on the public key. Using this batch approach also reduces the burden on the device analyzer by processing fewer requests, reduces network bandwidth consumption, and reduces latency at the client device when sending requests including the device integrity token that would otherwise be introduced if the client device sent a request for the device integrity token every time the device integrity token was needed.
[0022] A second privacy issue is that sharing a stable public key of a client device with a device analyzer could potentially enable the device analyzer to track the client device. For example, by colluding with the device analyzer, a recipient of multiple separate attestation tokens could know that the device analyzer received them in the same batch request from the same device, and thus the recipient of such attestation tokens could correlate multiple requests sent by the same client device and aggregate user data based on the correlation. The techniques described herein can improve privacy against such tracking by sending a blinded version of the public key to the device analyzer, rather than the raw value of the public key. For example, a client device can generate a batch of N public-private key pairs, blind the N public keys (or cryptographic hashes of the public keys), and then send the N blinded keys to the device analyzer, and the third-party device analyzer would return a batch of N corresponding blinded signatures without even receiving the raw value of the client device public key.
[0023] Further aspects of the present disclosure may provide the advantage of improving privacy against tracking by both trusted device analyzers and attestation token recipients by using a group signature scheme rather than a public key signature scheme. For example, a third-party device analyzer may assign a client device to a signature group corresponding to the client device's level of trust and provide the signature group's anonymous certificate to the client device. The client may then sign each attestation token using the group signature scheme with the anonymous certificate, and the attestation token recipient may validate the anonymous signature using the public group key published by the third-party device analyzer. Using this approach frees the client device's resources from the burden of creating many public / private key pairs and the device analyzer's resources from the burden of creating device integrity tokens for each public key. This frees up the respective resources to perform other functions and allows the device analyzer to evaluate a larger number of client devices in a shorter period of time using the freed up resources. Thus, using a group signature scheme provides a more efficient process since the generation of public / private key pairs is reduced.
[0024] Various features and advantages of the foregoing subject matter are described below with reference to the drawings. Additional features and advantages will be apparent from the subject matter described herein and from the claims. [Brief description of the drawings]
[0025] [Figure 1] FIG. 1 is a block diagram of an environment in which a digital component system distributes digital components. [Diagram 2] FIG. 10 is a flow diagram illustrating an example process for requesting and receiving a batch of N device integrity tokens. [Diagram 3] FIG. 2 is a flow diagram illustrating an example process for sending, receiving, and validating an authentication token. [Figure 4]FIG. 11 is a flow diagram illustrating an example process for requesting and receiving a batch of N blind-signed device integrity tokens. [Diagram 5] FIG. 2 is a flow diagram illustrating an example process for sending, receiving, and validating a blind signed authentication token. [Figure 6] FIG. 2 is a flow diagram illustrating an example process for requesting an anonymous private key of a signing group. [Figure 7] FIG. 2 is a flow diagram illustrating an example process for sending, receiving, and validating anonymous signed attestation tokens. [Figure 8] FIG. 11 is a flow diagram illustrating an example process for throttling attestation tokens to comply with published token quantity limits. [Figure 9] FIG. 1 is a block diagram of an exemplary computer system. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0026] Like reference numbers and designations in the various drawings indicate like elements.
[0027] In general, the systems and techniques described herein can provide a secure communication channel between client devices and other entities, such as content publishers, digital component distribution systems, and digital component providers that create and provide digital components for distribution by the digital component distribution system. The client device can provide attestation tokens along with requests and other data transmissions over the network that are used by other entities to validate the integrity of the request and the integrity of the client device. Requests can include, for example, requests to manage a user's data (e.g., delete user-related data), requests for content, and / or requests for digital components to present with other content. Securing the communication channel using attestation tokens ensures that unauthorized users cannot change, delete, or otherwise access user data, change the content of a request, or create new requests, for example, to deceive the digital component distribution system and / or provider.
[0028] In some approaches, the attestation token may be digitally signed using a private key of the client device. The client device may maintain the private key in secret. The attestation token may include, among other things, a public key corresponding to the private key, a payload, and a device integrity token. The device integrity token may include a verdict indicating a level of integrity of the client device as determined by a trusted device integrity system, e.g., a third-party device integrity system maintained by an entity distinct from the user of the client device and the recipient of the attestation token. The device integrity token may also include the client device's public key (or a cryptographic hash of the public key) to bind the device integrity token to the client device.
[0029] The device integrity token may be digitally signed by the device integrity system using a private key that the device integrity system holds in secret. A public key corresponding to this private key may be provided to the recipient so that the recipient can trust that the client device has been evaluated by the device integrity system, for example by verifying the digital signature of the device integrity token using the public key. This combination using two pairs of keys provides a secure communications channel that allows the recipient to validate the integrity of the client device and of communications received from the client device, and binds the device integrity token to the client device such that other devices cannot use the device integrity token to forge their integrity.
[0030] In some approaches, the device integrity system does not receive the raw data of the public key for inclusion in the device integrity token. Instead, the client device can send a blinded public key or a blinded derivative of the public key (e.g., a blinded truncated cryptographic hash of the public key) by blinding the public key or its derivative using a blind signature scheme. In a blind signature scheme, the device integrity system can prove the integrity of the client device without receiving the raw value of the client device's public key, improving the privacy of the client device or user by reducing the risk of potential tracking via the public key. The device integrity system can publish a blind signature verification key that the recipient can use to verify the blind signature.
[0031] In another approach, a group signature scheme can be used with the device integrity system as the group manager. For example, the device integrity system can publish M group verification keys for M trust groups, assign client devices to one of the M trust groups, and deliver anonymous certificates to the client devices. The client devices can anonymously sign attestation tokens using the anonymous certificates, and these anonymous signatures can be verified by a receiver using the published group verification key. In the group signature scheme, neither the device integrity system nor the receiver of the attestation token needs to receive the raw value of the client device's public key, further improving the privacy of the client device or user by reducing the risk of potential tracking via the public key.
[0032] 1 is a block diagram of an environment 100 in which a digital component system 150 distributes digital components 129. The exemplary environment 100 includes a data communications network 105, such as a local area network (LAN), a wide area network (WAN), the Internet, a mobile network, or a combination thereof. The network 105 connects client devices 110, publishers 130, websites 140, digital component distribution systems 150, and device integrity systems 170 (also referred to as device integrity computing systems). The exemplary environment 100 may include many different client devices 110, publishers 130, websites 140, digital component distribution systems 150, and device integrity systems 170.
[0033] A website 140 is one or more resources 145 associated with a domain name and hosted by one or more servers. An exemplary website is a collection of web pages formatted in HTML that can contain text, images, multimedia content, and programming elements such as scripts. Each website 140 is maintained by a publisher 130, which is an entity that controls, manages, and / or owns the website 140.
[0034] Resources 145 are any data that can be provided over network 105. Resources 145 are identified by a resource address, e.g., a Universal Resource Locator (URL), associated with resource 145. Resources include HTML pages, word processing documents, and Portable Document Format (PDF) documents, images, videos, and feed sources, just to name a few. Resources can include content such as words, phrases, images, and sounds, which may include embedded information (e.g., meta information in a hyperlink) and / or embedded instructions (e.g., scripts).
[0035] The client devices 110 are electronic devices capable of communicating over the network 105. Exemplary client devices 110 include personal computers, mobile communication devices, e.g., smartphones, digital media players, smart speakers, wearable devices (e.g., smart watches, etc.), and other devices capable of sending and receiving data over the network 105. The client devices 110 typically include an application 111, such as a web browser and / or a native application, that facilitates sending and receiving data over the network 105. A native application is an application developed for a specific platform or device. A publisher 130 can develop and provide the native application to the client devices 110.
[0036] Some resources 145, application pages, or other application content may include digital component slots for presenting the resource 145 or application page in a digital component. As used throughout this specification, the phrase "digital component" refers to a discrete unit of digital content or information (e.g., a video clip, an audio clip, a multimedia clip, an image, text, or another unit of content, etc.). A digital component 129 may be stored electronically in a physical memory device as a single file or as a collection of files, a digital component may take the form of a video file, an audio file, a multimedia file, an image file, or a text file, and may include advertising information; thus, an advertisement is a type of digital component. For example, a digital component 129 may be content intended to supplement the content of a web page, resource, or application page presented by an application 111. More specifically, a digital component 129 may include digital content related to the resource content (e.g., the digital component may relate to the same topic as the web page content, or to a related topic). Thus, the provision of a digital component by the digital component delivery system 150 may supplement and generally enhance the web page content.
[0037] When the application 111 loads a resource 145 or application content that includes one or more digital component slots, the application 111, which may be a web browser, can request a digital component 129 for each slot from a digital component delivery system 150. The digital component delivery system 150 can then request the digital components from a digital component provider 160. A digital component provider 160 is an entity that provides digital components for presentation with the resource 145 and / or other content. An exemplary digital component provider is an advertiser that provides advertisements.
[0038] In some cases, the digital component distribution system 150 may also request digital components from one or more digital component partners 152. A digital component partner 152 is an entity that selects digital components on behalf of a digital component provider 160 in response to a digital component request.
[0039] The digital component delivery system 150 can select a digital component for each digital component slot based on various criteria. For example, the digital component delivery system 150 can select a digital component from the digital components received from the digital component provider 160 and / or the digital component partner 152 based on relevance to the resource 145 or other application content, the performance of the digital component (e.g., the rate at which users interact with the digital component), etc. The digital component delivery system 150 can then provide the selected digital component to the client device 110 for presentation together with the resource 145 or other application content. The digital component delivery system 150 can transmit the selected digital component 129 to one or more client devices 110 for presentation by the application 111 running on the client device 110.
[0040] When application 111 sends request 120 over network 105, application 111 can send attestation token 122 with the request. For example, if application 111 sends a digital component request to digital component distribution system 150, the request can include attestation token 122. Similarly, if application 111 sends a request to another entity (e.g., publisher 130, digital component distribution system 150, digital component partner 152, or digital component provider 160) to manage, e.g., delete, data stored by that entity, the request can include attestation token 122.
[0041] In some implementations, the applications 111 are configured to send attestation tokens 122 for specified types of requests. For example, each application 111 that sends attestation tokens 122 may include a software development kit (SDK) or application programming interface (API) that causes the application 111 to generate and / or send the attestation tokens 122. The SDK may specify a set of requests in which the attestation tokens 122 should be included, such as, for example, requests to manage user data, requests to request digital components, etc. Other types of requests, for example, a request requesting a news webpage, may not require the attestation token 122.
[0042] The client device 110 may also include a trusted program 114 that generates attestation tokens for the application 111. The trusted program 114 may include trusted code from a trusted source that is difficult to forge. For example, the trusted program 114 may be an operating system, a portion of an operating system, a web browser, etc. Generally, the trusted program 114 is difficult to break into, and the amount of time and effort that a criminal would need to expend to tamper with the trusted program 114 is extremely high. In addition, because the trusted program 114 is provided and maintained by a trusted source, any vulnerabilities that arise can be addressed by the source. Because the trusted program is difficult to break into, using such a trusted program in this manner provides a technical advantage of increasing security at the client device. In addition, because the trusted program is maintained by a trusted source, the program provides the advantage of reducing vulnerabilities in the trusted program.
[0043] The trusted program 114 may be local to the client device 110. For example, the trusted program 114 may be a device driver for the operating system of the client device 110. In some implementations, the trusted program 114 operates entirely local to the client device 110, reducing the need to transmit user information. In some implementations, the trusted program 114 may operate locally to the client device 110 over a network, such as the network 105. For example, the trusted program 114 may be a web browser that is installed on the user device 110 and transmits and receives information over the network 105.
[0044] The trusted program 114 may generate cryptographic keys (e.g., public / private key pairs), store cryptographic keys in secure storage 115 (e.g., a secure cache), store device integrity tokens in secure storage 115, generate attestation tokens, generate blind signatures of cryptographic keys or derivatives thereof, and / or fetch and store certificates, as described in more detail below. In some implementations, the trusted program 114 interacts with a device integrity client to send data to and receive data from the device integrity system 170. In some implementations, the trusted program 114 is configured to generate attestation tokens 122 for each of a set of requests of a specified type, such as, for example, a request to change user privacy settings.
[0045] The attestation token 122 is used by the entity to validate the integrity of the request and the integrity of the client device 110. For example, allowing users to manage their own data stored by other entities may open up the possibility for malicious users to manage and / or steal other users' data. In the case of digital components, some malicious entities may attempt to tamper with the parameters of the digital component request, for example, to specify a different resource to which the digital component is provided and / or to specify a different user to which the digital component is presented, in order to make the request appear more valuable than it actually is. In addition, some malicious parties may attempt to emulate the client device of others for fraudulent purposes.
[0046] The attestation token 122 provides a secure communications channel, via an intermediary, between the client device 110 and another entity's computer or other device, preventing others from altering the request 120 and ensuring that the request 120 came from a validated client device 110.
[0047] The trusted program 114 can generate different types of attestation tokens 122 having different formats or containing different content. In some implementations, the attestation token 122 includes set contents including the public key 113 of the client device 110, a token creation time indicating the time when the attestation token 122 is created, payload data, and a device integrity token generated by the device integrity system 170 or the trusted program 114 using data received from the client device 110. The attestation token 122 can also include a digital signature generated by the trusted program 114 using a private key 112 corresponding to the public key 113 included in the attestation token 122 and the set of content. That is, the trusted program 114 can digitally sign the set of content using the private key 112 and include the resulting digital signature in the attestation token 122 along with the set of content.
[0048] In some implementations, the attestation token 122 includes a set of contents including payload data, an attestation token creation time indicating the time the attestation token 122 is created, and a digital signature of the set of contents. In this example, the trusted program 114 can generate the digital signature using a group signature scheme and a certificate issued to the client device 110 by the device integrity system 170.
[0049] In either example, the client device 110 may include the attestation token 122 in the request 120 sent to the digital component distribution system 150 or other recipient. The recipient of the attestation token 122 may attempt to validate the attestation token 122 and / or the device integrity token (if appropriate) included in the attestation token 122. If the attestation token 122 passes validation, the recipient may determine whether the client device 110 is a trusted device and process the request accordingly. If the attestation token 122 does not pass validation, the recipient may ignore or delete the request 120, for example, without responding to the request 120 or without modifying data in response to the request 120. Exemplary processes for generating requests including the attestation token 122 and validating the attestation token are illustrated in FIGS. 2-8 and described below.
[0050] The attestation token creation time indicates the time when the attestation token 122 was created. The trusted program 114 may record the creation time when the trusted program 114 creates the attestation token. This attestation token creation time may be a high-resolution timestamp (e.g., seconds, milliseconds, or microseconds precision). The attestation token creation time may be used to determine if the request 120 that includes the attestation token 122 is a new request or a recent request. For example, an entity receiving the attestation token 122 may compare the token creation time to the current time or the time the attestation token 122 was received. If the difference between the two times exceeds a threshold, the entity may determine that the request is not new or is invalid, as described in more detail below.
[0051] The attestation token creation time may also be used to detect replay attacks. For example, if multiple requests are received with the same set of data, including the same attestation token creation time, the entity receiving the requests can determine that the requests are duplicates and / or that the requests are part of a replay attack.
[0052] The attestation token creation time, in combination with other data, can also serve as a transaction identifier for the request 120. For example, the transaction identifier can be a combination of two or more of the attestation token creation time and the public key 113 of the attestation token 122 in implementations in which the attestation token 122 includes the public key 113. The transaction identifier can be used to de-duplicate multiple versions of the same request received from multiple channels. For example, the digital component provider 160-3 can receive the same request from both the digital component distribution system 150 and the digital component partner 152. In this example, the transaction identifier can be based on the token creation time and the public key 113 of the attestation token 122. The digital component provider 160-3 can compare the two pieces of data in the two or more requests to determine whether the requests are duplicates.
[0053] The payload may include data for an individual request 120. For example, if the request 120 is for a digital component, the payload may include data that can be used to select the digital component. This payload may include a resource 145 that has digital component slots (or a URL for the resource 145), information about the resource 145 (e.g., the topic of the resource), information about the digital component slots (e.g., the number of slots, the type of slot, the size of the slot, etc.), information about the client device 110 if the user enabled this feature (e.g., the type of device, the IP address of the device, the geographic location of the client device 110), and / or other suitable information.
[0054] If the request 120 is to manage the user's data at the publisher 130, the digital component distribution system 150, the digital component partner 152, the digital component provider 160, or another entity, the request 120 may include data specifying the requested changes. For example, if the user selects to remove all of the user's data from the digital component provider 160-2, the payload includes the removal of this data and data specifying the digital component provider 160-2 (e.g., an identifier or network address of the digital component provider 160-2).
[0055] The device integrity system 170 evaluates device level fraud detection signals received from the client device 110, for example from the trusted program 114, and determines the level of trustworthiness (or integrity) of the client device 110 based on the device level fraud detection signals. The device level fraud detection signals may include data representing operational characteristics or metrics of the client device that may be used to determine whether the client device is compromised or whether the client device is operating as a normal client device or an emulated client device. Some operational characteristics and metrics are often different for a real client device compared to an emulator. In some implementations, the device level fraud detection signals include application level fraud detection signals that include operational characteristics and metrics of the application 111 that is requesting the trust token. The trusted program 114 may collect these device level fraud detection signals and include them in the request for the trust token.
[0056] The device integrity system 170 can issue a verdict indicating a level of trustworthiness (or integrity) of the client device 110. A recipient can use the verdict to determine whether to trust a request 120 that includes the verdict. For example, if the verdict indicates that the client device 110 is not trustworthy, the recipient can ignore the request, e.g., by not responding to the request.
[0057] As described above, in some approaches, the device private / public key pair (and the device integrity token associated with the device public key) may be modified across multiple attestation tokens to improve the privacy of the client device or user against tracking by attestation token recipients. For example, a client device may generate a batch of private / public key pairs and retrieve a corresponding batch of device integrity tokens from a device integrity server, thereby reducing or eliminating device integrity token reuse. An illustrative example of this batch process is shown in FIG. 2.
[0058] In this example, the client device 200 creates (201) N public / private key pairs. For example, a trusted program in the client device 200 may generate the public / private key pairs. The public / private key pairs may be asymmetric key pairs. Each public / private key pair includes a private key and a public key that corresponds to and is mathematically linked to the private key. Data that is digitally signed using a private key can only be verified using the corresponding public key. Similarly, data that is encrypted using a public key can only be decrypted using the corresponding private key.
[0059] The client device 200 sends 202 a request for N device integrity elements to the device integrity computing system 220. The number N can be an integer equal to or greater than 1. In this example, the device integrity elements are device integrity tokens, and the request is for N device integrity tokens corresponding to the N public / private key pairs. The trusted program can determine the number N of device integrity tokens to request based on how frequently the trusted program uses unique device integrity tokens in the request. The client device can generate a public / private key pair for each requested device integrity token and include the public key data in the request. In this example, the public key data can be the public key itself. Thus, the request includes passing the N public keys 211 of the client device 200 to the device integrity server 220. In this example, the N public keys 211 include the actual public keys, e.g., the raw data of the N public keys 211. The request can also include device level fraud detection signals. For example, the trusted program can collect device level fraud detection signals and include these signals in the request.
[0060] The device integrity computing system 220 receives the request (221). Based on the device level fraud detection signal received from the client device, the device integrity computing system 220 determines a level of trust for the client device (222). For example, the device integrity computing system may have M possible trust levels, each corresponding to a respective verdict. In this example, the device integrity computing system 220 may select one of these M possible trust levels based on the device level fraud detection signal, as described above.
[0061] The device integrity computing system 220 generates 223 N device integrity elements. In this example, each device integrity element is in the form of a device integrity token. That is, the device integrity computing system 220 generates a respective device integrity token for each received public key.
[0062] Each device integrity token may include a trust verdict, a timestamp for the trust verdict, and one of the N public keys 211 of the client device 200. The timestamp indicates the time at which the device integrity token is generated. The device integrity system may generate each device integrity token based on one of the N public keys 211. For example, the device integrity system 220 may assemble a set of data including the public key of the client device 200, the trust verdict, and the timestamp. In some approaches where the trust verdict includes just two possible verdicts (trusted and untrusted), the trust verdict may be omitted from the device integrity token. In other words, in these approaches, the device integrity system may generate device integrity tokens for trusted devices (these tokens omit the implicit trust verdict) and may simply refuse to generate device integrity tokens for untrusted devices.
[0063] The device integrity computing system 220 digitally signs each of the N device integrity tokens (224). For example, the device integrity computing system 220 may use the device integrity system's private key to generate a digital signature based on other data of the device integrity token (e.g., the trust verdict, the client device's 200 public key, and a timestamp).
[0064] The device integrity computing system 220 sends the N device integrity tokens to the client device (225). The client device 200 receives the batch of device integrity tokens and stores them for later use (203). The client device 200 may store the device integrity tokens locally, for example, in a cache or secure storage maintained by a trusted program. Each cached device integrity token may include, for example, (1) a verdict of authenticity determined by the device integrity computing system 220, (2) a timestamp for the creation of the device integrity token, (3) the public key of the client device, and (4) a digital signature of the token components signed using the private key of the device integrity computing system 220.
[0065] As shown in the example of Figure 2, upon obtaining a batch of device integrity tokens, a client device can use the device integrity tokens to assemble and transmit the attestation tokens as part of various requests toward digital component providers or other attestation token recipients, as described above. Illustrative examples of such requests are shown as a process flow diagram in Figure 3.
[0066] To prepare a request, the client device 300 may retrieve a device integrity token from the client device's local storage (301). In various approaches, the client device 300 may, for example, (1) use a new device integrity token for each request, or (2) use the same device integrity token for a selected time interval (e.g., H consecutive times) and use a different device integrity token when the interval expires, or (3) use the same device integrity token for all requests originating from the same application or website (e.g., where a different device integrity token is used for each application or website), or (4) use a combination of two or more of these token reuse approaches (e.g., use the same device integrity token for all requests originating from the same application or website within a selected time interval). Thus, the client device 300 may retrieve a device integrity token based on the application or website for which the request is generated or the current time the request is generated.
[0067] The client device 300 may generate a request (302). The request 311 may include, for example, the payload data (as described above), a request creation timestamp, the retrieved device integrity token, a device public key corresponding to the device integrity token, and a digital signature of the request components. A trusted program on the client device, or a trusted component of the client device's operating system, may generate the request 311, which may include or be in the form of an attestation token, by accessing the payload data and the device integrity token. The trusted program may also determine the current time as the request creation timestamp. The trusted program may generate a digital signature of the payload data, the public key, and the timestamp using a private key of the client device (e.g., a private key corresponding to the device public key included in the request). In some approaches, as a simple optimization to reduce the attestation token size, the attestation token omits the device public key, since the device public key is already present in the device integrity token, which is included as a component of the attestation token.
[0068] The client device 300 sends 303 the request 311 to a recipient computing system 320. In this example, the recipient is a digital component provider. For example, the client device 300 can send the request 311 to a digital component distribution system, which can send the request to one or more digital component providers.
[0069] The receiving computing system 320 receives the request (321). The receiving computing system 320 validates the request (322). For example, the receiving computing system 320 may validate the request by verifying the digital signature of the request using the device public key included in the request. The receiving computing system 320 may attempt to verify the digital signature using the public key and the content of the request signed by the client device 300, such as, for example, the payload data, a timestamp, a public key, and a device integrity token. If any of this content is altered after the digital signature is generated, the verification will fail. For example, if a malicious party inserts the device integrity token into a different request or inserts a different device integrity token with a higher trust verdict into the request, the signature verification will fail. This ensures that the content of the request was not altered during transmission of the request, for example by an intermediary.
[0070] The receiving computing system 320 validates (323) the device integrity token. For example, the receiving computing system 320 may validate the device integrity token by verifying the signature of the device integrity token with the device integrity computing system's public key. This in turn ensures that the contents of the device integrity token have not been altered since the device integrity token was issued by the device integrity token computing system. If the attestation token includes a device public key, validating the device integrity token may also include verifying that the device public key included in the attestation token matches the device public key included within the device integrity token.
[0071] The receiving computing system 320 validates (324) the timeliness of the device integrity token and the authenticity of the client device, for example, to verify that the device integrity token was recently created (i.e., not created more than a selected time interval, such as H hours or D days before the time the request was made, for H,D=1,2,3,...) and to verify that the authenticity verdict in the device integrity token is sufficient to comply with the request.
[0072] If all of these validation checks are passed, the receiving computing system 320 can respond (325) to the request, e.g., modify settings, add or remove user data, deliver the digital component, etc., as described above. If any of the validation checks are failed, the receiving computing system 320 can ignore the request. For example, the receiving computing system 320 may not respond to the request, may not perform the requested action, etc.
[0073] For requests that include delivering a digital component, the response 325 can optionally include sending the appropriate digital component 312. For example, the recipient computing system 320 can select a digital component based on the payload of the request and send the digital component to a digital component delivery system that sent the request to the digital component provider. The digital component delivery system can then send the digital component to the client device 300. The client device 300 can receive 304 the digital component. The client device 300 can then present the digital component.
[0074] As explained above, in some approaches, a blind signature scheme may be used such that the device integrity computing system does not see the raw data of the client device's public key in the process for generating the device integrity token. For example, the client device may generate a batch of private / public key pairs and then use the blind signature scheme to blind the public keys (or suitable derivatives of these public keys that may be used as values for the commit phase of the blind signature scheme, such as a cryptographic hash of the public key, or a cryptographic hash of the public key concatenated with the device model number) before sending the public keys to the device integrity system to retrieve the corresponding batch of device integrity elements. In this example, the device integrity elements are blind signatures of the blinded public keys. An illustrative example of this batch process is shown in FIG. 4.
[0075] In this example, the device integrity computing system 420 may define M different trust levels for client devices and publish M different blind signature verification keys 411 for the corresponding M trust levels (421). For example, the M levels may include two levels: trusted and untrusted. In another example, the M levels may include three levels: suspicious, satisfactory, and trustworthy. In another example, the M levels may include four levels: dishonest, suspicious, satisfactory, and trustworthy. Other amounts of levels may be used. Thus, M may be an integer greater than or equal to 2. In some approaches, instead of assigning a blind signature verification key to the lowest level of trust (e.g., the “untrusted” or “dishonest” level of trust), the lowest level of trust may be omitted from the M levels of trust, and the device integrity computing system may simply refuse to provide blind signatures to devices with the lowest level of trust. Thus, in these approaches, M may be an integer greater than or equal to 1.
[0076] The device integrity computing system 420 can use a blind signature scheme to generate respective blind signature verification keys 411 for each level of trust. The blind signature scheme can be a privately verifiable blind signature scheme, such as the Internet Engineering Task Force's (IETF) Verifiable Oblivious Pseudorandom Functions (VOPRF) blind signature scheme. In another approach, the blind signature scheme can be a publicly verifiable blind signature scheme, such as the Rivest-Shamir-Adleman (RSA) blind signature scheme.
[0077] The device integrity computing system 420 may publish the blind signature verification key 411 so that client devices, including the client device 400, may obtain the blind signature verification key 411. For example, the device integrity computing system 420 may publish the blind signature verification key 411 to a website or a mobile app store.
[0078] The client device 400 may receive these blind signature verification keys (401). For example, the client device 400 may download the blind signature verification key 411 and store the blind signature verification key 411 locally, e.g., in a secure storage or cache. The client device 400 may retain the blind signature verification key 411 to verify blind signatures subsequently received from the device integrity computing system 420, as described further below. In some approaches, the device integrity computing system 420 may publish new blind signature verification keys 411 periodically (e.g., hourly, daily, weekly, or other suitable time period), and this refresh of the set of blind signature verification keys may be used to validate the timeliness of the device integrity token, as described further below.
[0079] To obtain a batch of N device integrity tokens, the client device 400 creates N public / private key pairs 402. For example, a trusted program on the client device can create a respective asymmetric public / private key pair for each device integrity token.
[0080] The client device 400 blinds (403) each public key or each derivative of the public key according to the blind signature scheme used to generate the blind signature verification key. That is, the client device 400 blinds the public key data for each public key if the public key data is either a public key or a derivative of the public key. Blinding the public keys may include obscuring the raw value of the public key by applying a blinding coefficient to the raw value of the public key. In this way, the device integrity computing system 420 cannot access the raw values of the public keys received from the client device 400 and cannot use these values to track the user or the client device 400, for example, using data received from another entity that received the raw values of the public keys along with additional data.
[0081] To reduce the amount of data that needs to be blind-signed by the device integrity computing system 420, instead of blinding each entire device public key, the client device 400 (e.g., its trusted program) can generate a derivative of the public key and blind the derivative of the public key. The derivative can be a cryptographic hash of the public key. For example, the client device 400 can generate a cryptographic hash of each public key using a cryptographic hash function and then blind the cryptographic hash of the public keys using a blind signature scheme. In some implementations, the cryptographic hash algorithm can be SHA256.
[0082] In some implementations, the client device 400 can further reduce the data size of the blinded public key data by truncating the cryptographic hash and then blinding the truncated cryptographic hash. For example, this truncation can limit the cryptographic hash to 16 bytes from the original cryptographic hash, which has a larger data size. This truncation results in a shorter cryptographic hash that the client device 400 blinds using a blind signature scheme.
[0083] Reducing the amount of data that is blind signed in this manner reduces the burden on the device integrity computing system 420 when blind signing the data (e.g., reducing CPU cycles, data storage requirements, memory consumption, etc.), allowing the device integrity computing system 420 to generate blind signatures faster and more efficiently and process more requests than if it were provided with a blinded version of the full public key. This also reduces bandwidth consumption on the network over which the requests are sent, allowing large amounts of blinded public key data to be sent in a single request.
[0084] The client device 400 sends 404 a request 412 for N device integrity tokens to the device integrity computing system 420. The number N can be an integer equal to or greater than 1. The request can include blinded public key data for each public key 411 generated by the client device 400. For example, the request can include the N blinded public keys, a blinded cryptographic hash of the N public keys, or a blinded truncated cryptographic hash of the N public keys. The request can also include a device level fraud detection signal, for example, collected by a trusted program on the client device 400.
[0085] The device integrity computing system 420 receives the request (422). The device integrity computing system 420 may determine a verdict of trustworthiness of the client device 400 based on the device-level fraud detection signal (423). For example, the device integrity computing system 400 may have M possible verdicts of trustworthiness (corresponding to the M blind signature verification keys revealed in operation 421). The device integrity computing system 420 may assign the client device 400 to one of the M possible verdicts based on the device-level fraud detection signal.
[0086] Upon determining a verdict of trustworthiness for the client device 400, the device integrity computing system 400 signs each portion of the blind public key data (e.g., each of the N blind public keys or each blind cryptographic hash) using a blind signature private key (424). For example, the device integrity computing system 420 may obtain a blind signature private key corresponding to the trustworthiness verdict determined for the client device 400, e.g., a blind signature private key corresponding to a public blind signature verification key for the determined trustworthiness verdict (424). Using the blind signature scheme in this manner, the device integrity computing system 420 may generate a digital signature of the blind public key data without knowing the actual value of the public key data.
[0087] The device integrity computing system 420 returns (425) the N blind signatures 413 to the client device. The client device 400 receives (405) the blind signatures from the device integrity computing system.
[0088] The client device 400 unblinds the blind signatures using the blind signature scheme (406). For example, a trusted program on the client device 400 can validate each blind signature using the blind public key data from which the blind signatures were generated and a blind signature verification key published by the device integrity computing system 420. To do this, the trusted program can attempt to validate the blind signatures using multiple blind signature verification keys, e.g., one for each trust verdict. If the verdict does not match the verdict assigned to the client device 400, the blind signature will not pass validation using the blind signature verification key because of that verdict. The trusted program can determine the assigned trust verdict of the client device 400 based on the blind signature verification key that validated the blind signature and passed, e.g., the trust verdict corresponding to the blind verification key is the verdict assigned to the client device 400. If the validation passes, the trusted program can unblind the blind signatures using the blind signature scheme.
[0089] The client device 400 generates a batch of device integrity tokens (408). For example, a trusted program in the client device 400 can generate a device integrity token for each public key generated in operation 402 above. Each device integrity token can include, for example, (1) the public key of the client device for which the device integrity token is being generated, (2) a verdict of authenticity determined by the device integrity computing system, and (3) an unblinded blind signature of the blinded public key or a cryptographic hash of the public key (e.g., after truncation). In some approaches, the verdict of authenticity can be omitted since the device integrity token can be implied from the unblinded blind signature. If the blind signature is not publicly verifiable, the device integrity computing system can also return a verdict when the device integrity computing system is invoked to verify the blind signature (e.g., see 541 in FIG. 5 described below). If the blind signature is publicly verifiable, the public key verifying the blind signature also implies a verdict of authenticity of the device.
[0090] The client device 400 stores the device integrity token (410). For example, a trusted program on the client device 400 can store the device integrity token in a secure storage for later use when sending a request that should include the device integrity token. The secure storage can be a token cache on the client device 400.
[0091] As shown in the example of Figure 4, upon generating and storing a batch of device integrity tokens, a client device can use the device integrity tokens to assemble and transmit attestation tokens as part of various requests made to digital component providers or other attestation token recipients, as described above. Illustrative examples of such requests are shown as a process flow diagram in Figure 5.
[0092] To prepare a request, the client device 500 can retrieve a device integrity token (501), for example, from a token cache of the client device. In various approaches, the client can, for example, (1) use a new device integrity token for each request, or (2) use the same device integrity token over a selected time interval (e.g., H consecutive times), or (3) use the same device integrity token for all requests originating from the same application or website, or (4) use a combination of these token reuse approaches (e.g., use the same device integrity token for all requests originating from the same application or website within a selected time interval). Thus, the client device 500 can retrieve a device integrity token based on the application or website for which the request is generated, or the current time the request is generated.
[0093] The client device 500 can assemble a request 511 that includes a set of content including a request payload (as described above), a request creation timestamp indicating the time the request is generated, a device integrity token, and a device public key corresponding to the device integrity token (e.g., a public key whose public key data is blind-signed and included in the device integrity token with an unblinded blind signature). The request can also include a digital signature of the set of content signed (502) using a private key of the client device (e.g., a private key corresponding to the public key included in the request). For example, a trusted program on the client device 500 can generate a digital signature based on the set of content using the private key. The request can include or be in the form of an attestation token. For example, the attestation token can include a set of content (e.g., with an attestation token creation timestamp) and a digital signature.
[0094] The client device 500 sends (503) a request 511 to a recipient computing system 520. If the recipient is a digital component provider, the client device 500 can send the request to a digital component distribution system, which then forwards the request to the appropriate digital component provider.
[0095] The receiving computing system 520 validates the request (522). The receiving computing system 520 may validate the request by verifying the digital signature of the request using the device public key included in the request. The receiving computing system 520 may also validate the request by comparing a timestamp in the request to the time the request was received. If the signature passes validation and the timestamp is within a threshold duration of the current time, the client device 500 may consider the request to have passed validation.
[0096] The receiving computing system 520 also validates the device integrity token. This validation process may vary based on the blind signature scheme used by the device integrity computing system 540 when generating the blind signature. If the blind signature scheme is a publicly verifiable scheme (e.g., RSA), the receiving computing system 520 may validate the device integrity token (523a) without invoking the device integrity computing system. In this example, the receiving computing system 520 may use the blind signature scheme to verify the unblinded blind signature of the public key data included in the device integrity token. If a cryptographic hash of the public key is used, the receiving computing system 520 may generate a cryptographic hash of the public key included in the request using the same cryptographic hash function as the client device 500 (truncating it, if appropriate) and use the blind signature scheme to verify the unblinded blind signature of the cryptographic hash.
[0097] If the blind signature scheme is a private verifiable scheme (e.g., IETF VOPRF), the receiving computing system 520 may call the device integrity computing system 540 to verify the unblinded blind signature (523b). In this example, the receiving computing system 520 may send the unblinded blind signature and the public key or a cryptographic hash of the public key to the device integrity computing system 540.
[0098] The device integrity computing system 540 may attempt to verify the unblinded blind signature using the blind signature scheme and provide a response to the digital component provider 541. The response may indicate whether the verification was successful and the authenticity of the client device corresponding to the blind signature verification key that verifies the unblinded blind signature.
[0099] The receiving computing system 520 validates (524) the timeliness of the device integrity token and the trustworthiness of the client device, e.g., to verify that the device integrity token was recently created and that the trustworthiness verdict in the device integrity token is a sufficient verdict to comply with the request. Because the device integrity computing system 540 may periodically republish a new blind signature verification key, validating the timeliness may include verifying that the blind signature of the device integrity token was not signed with an invalid old key, e.g., by determining that the device integrity token was verified with an expired blind signature verification key. In one approach, the receiving computing system may determine that the blind signature verification key is expired because the validity date of the blind signature verification key was encoded as part of the published key's URL. In another approach, the receiving computing system may determine that the blind signature verification key is expired because the verification key was published with metadata that encodes the verification key's expiration date.
[0100] If all of these validation checks are passed, the receiving computing system 520 may respond (525) to the request, e.g., modify settings, add or remove user data, deliver the digital component, etc., as described above. Thus, for a request that includes delivering a digital component, the response 525 may optionally include sending the appropriate digital component 512 to the client device 500. In this example, the client device 500 may present the digital component. If any of the validation checks are failed, the receiving computing system 520 may ignore the request, may choose, e.g., not to send a response to the request, update settings, etc.
[0101] While the approaches shown in the examples of Figures 2-5 and described above involve using the device public key of the client device, other approaches may forego the use of the device public key for a group signature scheme. Generally speaking, a group signature scheme is a method that allows members of a group to anonymously sign messages on behalf of the group. In a group signature scheme, a group manager publishes a group signing function sign(message,C) that can be used to sign a message with certificate C, where certificate C is a secret certificate (also known as an anonymous private key) that has been privately issued by the group manager to members of the group. The group manager also publishes a group verification key K (also known as a group public key) and a group signature verification function verify(sign(message,C),K), which returns TRUE if and only if the message was signed with the group signature function using the anonymous certificate C and K is the group verification key of C.
[0102] These techniques may use a group signature scheme with the device integrity system as the group manager for attestation of client device requests. Some group signature schemes allow the group manager to deanonymize anonymous signatures created by members of the group, but privacy considerations may favor group signature schemes that do not include this deanonymization capability, such as direct anonymous attestation (DAA). For example, in some approaches, the device integrity system may use an elliptic curve cryptography (ECC) DAA scheme, such as ECC DAA with a Barreto-Naehrig curve. Additionally, some group signature schemes may allow the group manager to revoke group membership, but efficiency considerations may favor group signature schemes that do not include this revocation capability, such that the techniques are scalable to the Internet scale, e.g., with groups that include millions or billions of group members.
[0103] An illustrative example of a group signature scheme for attestation of client device requests is shown in the process flow diagrams of FIG. 6 and FIG. 7. In this example, the device integrity computing system 620 can define M different trust levels for client devices and publish M different group verification keys for the corresponding M trust levels. For example, the device integrity system can publish one, two, or more group verification keys, e.g., ECC DAA verification keys, corresponding to levels of device trust. In an approach where M=1, the group verification key corresponds to a certain minimum level of trust, and devices that do not meet the minimum level of trust do not participate as members of the trust group. In an approach where M≧2, a different group verification key corresponds to each level or classification of device trust. In some approaches, the device integrity computing system can publish new group verification keys periodically (e.g., hourly, daily, weekly, or other time periods as needed), and this refresh of the set of group verification keys can be used to validate the timeliness of client device requests, as further described below.
[0104] 6, a client device 600 may request 601 a private device integrity certificate in the form of a secret certificate for one of M trust groups managed by a device integrity server 620. The request may include, for example, a device level fraud detection signal collected by a trusted program of the client device 600.
[0105] The device integrity computing system receives the request (621). The device integrity computing system 620 can determine a trust verdict for the client device based on the device-level fraud detection signal and assign the client device to a selected trust group corresponding to the trust verdict (622).
[0106] The device integrity computing system 620 may then generate or select an anonymous certificate 611 corresponding to the selected trust group and return the anonymous certificate 611 to the client device (623). For example, the device integrity computing system may generate a credential corresponding to an ECC DAA validation key associated with the device trust level assigned to the device by the device integrity computing system. The client device 600 may receive the anonymous certificate 611 and securely store it locally at the client device 600, for example, in a private key store (602). For example, the client device may encrypt the certificate using a master key in the private key store, so that a malicious party cannot misuse the certificate or use it on a different device.
[0107] Upon obtaining an anonymous certificate of membership in a particular trust group, the client device can use the anonymous certificate to assemble and transmit attestation tokens as part of various requests made from digital component providers or other attestation token recipients. In this example, the attestation tokens can be referred to as anonymous attestation tokens because they do not include the client device's public key. An illustrative example of such a request is shown as a process flow diagram in FIG. 7.
[0108] A client device 700 may initiate a request made from a digital component provider or other attestation token recipient (701). In some implementations, the client device may optionally verify that the request does not exceed attestation token limits, as described further below (702). The client device 700 retrieves an anonymous certificate (703), e.g., from a private key store on the client device, having previously obtained the certificate from a device integrity computing system, as described above and in FIG. 6.
[0109] The client device 700 generates a request 711 and signs the request with the retrieved anonymous certificate (704). Generating the request can include, for example, generating a set of content including a request payload and a request creation timestamp. The request payload can include, for example, data that can be used to select a digital component or data that specifies a requested change to be made by the attestation token recipient, such as removing data. The request creation timestamp can indicate the time the request was created. In some examples, the request creation timestamp has a time resolution small enough to detect duplicate requests or replay attacks. For example, the request creation timestamp can have a time resolution of less than about 1 millisecond or less than about 1 microsecond. In approaches where the group signature scheme is a probabilistic group signature scheme, two separate signatures of the same request 711 by the client device 700 generate different signatures. In these approaches, the recipient of the request 711 can prevent duplicate requests or replay attacks by rejecting requests that have identical signatures.
[0110] Contrary to the other approaches described above and in Figures 3 and 5, the request 711 does not include the public key of the client device, nor does it include a device integrity token (compare request 311 in Figure 3 and request 511 in Figure 5). These attestation token features of the previously described approaches are not necessary in the group signature scheme of the present approach, where possession and use of an anonymous certificate C by the client device indicates that the client device is a member of a trust group managed by the device integrity computing system. The client device signs the request 711 using the anonymous certificate C using a published group signature function sign(message, C). For example, the client device 700 can generate a digital signature of a set of content using the anonymous certificate C, and the client device can sign the request using an ECC DAA signature scheme with an ECC DAA certificate previously provided to the client device by the device integrity server, for example.
[0111] The client device sends (705) a request 711 to a recipient computing system 720. If the recipient is a digital component provider, the client device 700 can send the request to a digital component distribution system, which then forwards the request to the appropriate digital component provider.
[0112] The receiving computing system 720 receives the request (722). Prior to receiving the request 711 from the client device 700, the receiving computing system 720 receives (721) a set of M different group verification keys for the M trust classes of the device integrity computing system. The device integrity computing system 740 publishes (741) these M group verification keys and may periodically republish new group verification keys (e.g., hourly, daily, weekly, or other time periods as needed), where the attestation token recipient periodically receives new group verification keys for validating requests from the client device. In one approach, the group verification keys are published on a well-known path using a well-known URL so that any receiving computing system 720 can fetch the group verification keys using a standard HTTP request. The path may encode date / time information or metadata accompanying the group verification keys may encode a key expiration date, so that the receiving computing system can determine whether the keys are current, as described further below.
[0113] The receiving computing system 720 validates 723 the timeliness of the request. For example, the receiving system may consider the request creation timestamp to, among other things, ensure that the request is not a duplicate (or a replay attempt) and that the request is not stale (e.g., the difference between the request creation timestamp and the time the receiving computing system received the request within a threshold).
[0114] The receiving computing system 720 validates (724) the anonymous signature and authenticity of the request. For example, the receiving party can validate the anonymous signature by evaluating a verification function verify(sign(message,C),K) for each published group verification key K in the set of M published group verification keys. The verification function can be, for example, an ECC DAA signature verification function computed using an ECC DAA verification key previously published by the device integrity server. If the function is FALSE for all published group verification keys K, the receiving party can determine that the request has been tampered with or that the client device 700 does not belong to any trust group. On the other hand, if the function is true for a particular group verification key K, then the client device 700 belongs to the trust group corresponding to that particular group verification key K.
[0115] If these validation checks are successful, the attestation token recipient can respond to the request (725), e.g., modify settings, add or remove user data, and deliver the digital component as described above. For requests that include delivering a digital component, the response 725 can then optionally include sending the appropriate digital component 712 to the client device 700. The client device 700 receives the digital component (706). The client device 700 can then present the digital component to a user of the client device 700.
[0116] While the group signature approach shown in FIGS. 6 and 7 and described above enhances the privacy of a client device or user by preventing tracking based on the client device's device public key, it may also prevent an attestation token recipient (e.g., a digital component provider) from identifying rogue devices or applications that may send an unreasonable amount of requests to the attestation token recipient. Thus, in some approaches, the client device may include a trusted throttler that can throttle the client device from sending an excessive amount of attestation tokens. Referring again to FIG. 7, the throttler may, for example, perform operation 702 verifying that an initiated request does not exceed an authentication token limit before allowing the request to proceed. The throttler may, for example, be a thread, process, subroutine, or other component of a trusted operating system of the client device. Although the throttler is described below in the context of the group signature approach of FIGS. 6-8, it is contemplated that the throttler may be used to limit the amount of attestation tokens in any of the attestation token contexts described herein. For example, the throttler may be used to limit requests 311 of FIG. 3 or requests 511 of FIG. 5.
[0117] An illustrative example of this throttling approach is shown in the process flow diagram of Figure 8. Various attestation token receivers 850, such as digital component providers and other receivers of requests or other communications that include attestation tokens, can publish information indicative of attestation token quantity limits (851). For example, the attestation token receivers can publish (1) a limit on the number of tokens that can be sent from each individual client device to a selected destination domain of the receiver within a selected time frame (e.g., no more than X requests within Y seconds, minutes, or hours), (2) a limit on the number of tokens that can be sent from one or more selected applications on an individual client device to a selected destination domain of the receiver within a selected time frame (e.g., no more than X requests from application A or from any application other than application A within Y seconds, minutes, or hours), (3) a limit on the number of tokens that can be sent from an individual client device to a selected endpoint in a selected destination domain of the receiver within a selected time frame, (4) a limit on the number of tokens that can be sent from one or more selected applications on a client device to a selected endpoint in a selected destination domain within a selected time frame, or (5) any combination of two or more of such limits.
[0118] The throttler 830 receives (821) the published token quantity limit information as a component of the trusted program 820 (e.g., operating system) of the client device 800. The published token quantity limit information can be received in various ways. In one approach, each attestation token receiver publishes the token quantity information in a file signed with the token receiver's private key. The trusted crawler periodically fetches these files (along with the public key for the token receiver) and delivers these files to each client device 800. The throttler 830 on each client device then complies with the throttling requirements after verifying the token receiver's signature. For example, the throttler 830 can ensure that the limit is not exceeded by not generating attestation tokens for requests that exceed the limit.
[0119] In another approach, each token receiver submits signed token amount information to a digital distribution platform (such as a mobile app store where mobile apps can be downloaded). The digital distribution platform verifies and signs the token amount information. Each token receiver then delivers the twice-signed token amount information to the client device 800. The throttler 830 on each client device then complies with the throttling requirements after verifying the signatures of both the token receiver and the digital distribution platform. For example, the throttler 830 can ensure that the limit is not exceeded by not generating a proof token for requests that exceed the limit.
[0120] When an application 810 on a client device initiates a request to a trusted program 820 for an attestation token (811), the trusted program 820 receives the request (822). The trusted program 820 can then call a throttler to evaluate whether complying with the request would cause the client device to exceed one or more of the published token quantity limits (823). If the request would exceed one or more of the published token quantity limits, the trusted program 820 rejects the attestation token request (step 823a). If the request does not exceed the published token quantity limits, the trusted operating system 820 enables an attestation token to be generated and sent to the appropriate attestation token recipient (step 823b).
[0121] In addition to the above, a user may be given controls that allow the user to make choices regarding both whether and when the systems, programs, or features described herein may enable collection of user information (e.g., information about the user's social network, social actions or activities, occupation, user preferences, or the user's current location) and whether personalized content or communications from the server are sent to the user. In addition, some data may be treated in one or more ways before being stored or used such that personally identifiable information is removed. For example, the user's identification information may be treated such that personally identifiable information (e.g., phone number, IMEI, device serial number) is not specific to the user, or the user's geographic location may be generalized (such as to the city, ZIP code, or state level) when location information is obtained such that the user's specific location is not identifiable. Thus, the user can control what information about the user is collected, how that information is used, the retention policy of the information, and what information is provided to the user.
[0122] 9 is a block diagram of an exemplary computer system 900 that can be used to perform the operations described above. The system 900 includes a processor 910, a memory 920, a storage device 930, and an input / output device 940. Each of the components 910, 920, 930, and 940 can be interconnected using, for example, a system bus 950. The processor 910 is capable of processing instructions for execution within the system 900. In some implementations, the processor 910 is a single-threaded processor. In another implementation, the processor 910 is a multi-threaded processor. The processor 910 is capable of processing instructions stored in the memory 920 or the storage device 930.
[0123] The memory 920 stores information within the system 900. In one implementation, the memory 920 is a computer-readable medium. In some implementations, the memory 920 is a volatile memory unit. In another implementation, the memory 920 is a non-volatile memory unit.
[0124] The storage device 930 is capable of providing mass storage for the system 900. In some implementations, the storage device 930 is a computer-readable medium. In various different implementations, the storage device 930 may include, for example, a hard disk device, an optical disk device, a storage device shared over a network by multiple computing devices (e.g., a cloud storage device), or some other mass storage device.
[0125] The input / output device 940 provides input / output operations for the system 900. In some implementations, the input / output device 940 may include one or more of a network interface device, e.g., an Ethernet card, a serial communication device, e.g., an RS-232 port, and / or a wireless interface device, e.g., an 802.11 card. In another implementation, the input / output device may include a driver device configured to receive input data and send output data to the external device 960, e.g., a keyboard, a printer, and a display device. However, other implementations may be used, such as a mobile computing device, a mobile communication device, a set-top box television client device, etc.
[0126] Although an exemplary processing system is described in FIG. 9, implementations of the subject matter and functional operations described herein can be implemented in other types of digital electronic circuitry, or in computer software, firmware, or hardware, including the structures disclosed herein and their structural equivalents, or in one or more combinations thereof.
[0127] The subject matter and embodiments of the operations described herein may be implemented in digital electronic circuitry, or in computer software, firmware, or hardware, including the structures disclosed herein and structural equivalents thereof, or in a combination of one or more of them. The subject matter described herein may be implemented as one or more computer programs, i.e., one or more modules of computer program instructions encoded on computer storage medium(s) for execution by or to control the operation of a data processing device. Alternatively or additionally, the program instructions may be encoded on an artificially generated propagated signal, e.g., a machine-generated electrical, optical, or electromagnetic signal, generated to encode information for transmission to an appropriate receiver device for execution by the data processing device. The computer storage medium may be or may be included in a computer readable storage device, a computer readable storage substrate, a random or serial access memory array or device, or a combination of one or more of them. Furthermore, although a computer storage medium is not a propagating signal, a computer storage medium may be a source or destination of computer program instructions encoded in an artificially generated propagating signal. A computer storage medium may also be, or be contained in, one or more separate physical components or media (eg, multiple CDs, disks, or other storage devices).
[0128] The operations described herein may be implemented as operations performed by a data processing apparatus on data stored on one or more computer-readable storage devices or received from other sources.
[0129] The term "data processing apparatus" encompasses all kinds of apparatus, devices, and machines for processing data, including, by way of example, programmable processors, computers, systems on chips, or a combination of the above. The apparatus may include special purpose logic circuitry, e.g., a field programmable gate array (FPGA) or an application specific integrated circuit (ASIC). In addition to hardware, the apparatus may also include code that creates an execution environment for the computer program in question, e.g., code constituting a processor firmware, a protocol stack, a database management system, an operating system, a cross-platform runtime environment, a virtual machine, or a combination of one or more of these. The apparatus and execution environment may implement a variety of different computing model infrastructures, such as web services, distributed computing infrastructures, and grid computing infrastructures.
[0130] A computer program (also known as a program, software, software application, script, or code) may be written in any form of programming language, including compiled or interpreted, declarative or procedural, and may be deployed in any form, including as a stand-alone program or as a module, component, subroutine, object, or other unit suitable for use in a computing environment. A computer program may correspond to a file in a file system, but this is not required. A program may be stored in a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program, or in multiple cooperating files (e.g., files that store one or more modules, subprograms, or portions of code). A computer program may be deployed to run on one computer or on multiple computers located at one site or distributed across multiple sites and interconnected by a communication network.
[0131] The processes and logic flows described herein may be performed by one or more programmable processors executing one or more computer programs to perform actions by operating on input data and generating output. The processes and logic flows may also be implemented by, and an apparatus may be implemented as, special purpose logic circuitry, for example, an FPGA (field programmable gate array) or an ASIC (application specific integrated circuit).
[0132] Processors suitable for executing computer programs include, by way of example, both general-purpose and special-purpose microprocessors. Generally, a processor receives instructions and data from a read-only memory or a random access memory or both. The essential elements of a computer are a processor for performing actions according to instructions and one or more memory devices for storing instructions and data. Generally, a computer also includes one or more mass storage devices for storing data, such as magnetic disks, magneto-optical disks, or optical disks, or is operatively coupled to receive data from or transfer data to them, or both. However, a computer need not have such devices. Furthermore, a computer may be embedded in another device, such as a mobile phone, a personal digital assistant (PDA), a mobile audio or video player, a game console, a global positioning system (GPS) receiver, or a portable storage device (e.g., a universal serial bus (USB) flash drive), to name just a few. Devices suitable for storing computer program instructions and data include all forms of non-volatile memory, media and memory devices, including, by way of example, semiconductor memory devices, e.g., EPROM, EEPROM, and flash memory devices, magnetic disks, e.g., internal hard disks or removable disks, magneto-optical disks, and CD-ROM and DVD-ROM disks. The processor and memory may be supplemented by, or incorporated in, special purpose logic circuitry.
[0133] To provide for interaction with a user, embodiments of the subject matter described herein can be implemented on a computer having a display device, such as a CRT (cathode ray tube) or LCD (liquid crystal display) monitor, for displaying information to the user, as well as a keyboard and a pointing device, such as, for example, a mouse or trackball, through which the user can provide input to the computer. Other types of devices can also be used to provide interaction with the user, for example, feedback provided to the user can be any form of sensory feedback, such as, for example, visual feedback, auditory feedback, or tactile feedback, and input from the user can be received in any form, including acoustic, speech, or tactile input. In addition, the computer can interact with the user by sending documents to a device used by the user and receiving documents from the device, for example, by sending a web page to a web browser on the user's client device in response to a request received from the web browser.
[0134] An embodiment of the subject matter described herein may be implemented in a computing system that includes back-end components, e.g., a data server, or includes middleware components, e.g., an application server, or includes front-end components, e.g., a client computer having a graphical user interface or web browser through which a user may interact with an implementation of the subject matter described herein, or includes any combination of one or more such back-end, middleware, or front-end components. The components of the system may be interconnected by any form or medium of digital data communication, e.g., a communication network. Examples of communication networks include local area networks ("LANs") and wide area networks ("WANs"), internetworks (e.g., the Internet), and peer-to-peer networks (e.g., ad-hoc peer-to-peer networks).
[0135] A computing system may include clients and servers. Clients and servers are generally remote from each other and typically interact through a communications network. The relationship of clients and servers arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. In some embodiments, the server transmits data (e.g., HTML pages) to the client devices (e.g., for the purpose of displaying the data to and receiving user input from a user interacting with the client device). Data generated at the client device (e.g., the result of a user interaction) may be received at the server from the client device.
[0136] Although this specification contains many specific implementation details, these should not be interpreted as limitations on the scope of the invention or what may be claimed, but rather as descriptions of features specific to certain embodiments of a particular invention. Some features described in the context of separate embodiments may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented in multiple embodiments separately or in any suitable subcombination. Furthermore, although features may be described above as working in some combinations and may even be initially claimed as such, one or more features from a claimed combination may, in some cases, be deleted from the combination, and the claimed combination may be directed to a subcombination or a variation of the subcombination.
[0137] Similarly, although operations are shown in the figures in a particular order, this should not be understood as requiring that such operations be performed in the particular order or sequence shown, or that all of the illustrated operations be performed, to achieve desirable results. In some situations, multitasking and parallel processing may be advantageous. Furthermore, the separation of various system components in the embodiments described above should not be understood as requiring such separation in all embodiments, and it should be understood that the program components and systems described may generally be incorporated together in a single software product or packaged in multiple software products.
[0138] Thus, specific embodiments of the subject matter have been described. Other embodiments are within the scope of the following claims. In some cases, the actions recited in the claims may be performed in a different order and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order or sequence shown to achieve desirable results. In some implementations, multitasking and parallel processing may be advantageous. [Explanation of symbols]
[0139] 100 Environment 105 Data Communication Network 110 Client Devices 111 Applications 112 Private key 113 Public Key 114 Trusted Programs 115 Secure Storage 120 requests 122 Proof Token 129 Digital Components 130 Publisher 140 websites 145 resources 150 Digital Component Distribution System 152 Digital Component Partners 160 Digital Component Providers 170 Device Integrity System 200 client devices 211 Public Key 220 Device Integrity Computing System 300 client devices 311 request 312 Digital Components 320 Receiving Computing System 325 Responses 400 client devices 411 Blind Signature Verification Key 412 request 413 Blind Signatures 420 Device Integrity Computing System 500 client devices 511 request 512 Digital Components 520 Receiving Computing System 525 Response 540 Device Integrity Computing System 600 client devices 611 Anonymous Certificate 620 Device Integrity Computing System 700 client devices 711 request 712 Digital Components 720 Receiving Computing System 740 Device Integrity Computing System 800 client devices 810 Application 820 Trusted Programs 830 Throttle 850 Evidence Token Receiver 900 Computer Systems 910 Processor 920 Memory 930 Storage Devices 940 Input / Output Devices 950 System Bus 960 External Devices
Claims
1. A method performed by a receiving computing system, comprising: receiving from a client device a verification token comprising (i) a set of data and (ii) a digital signature generated using said set of data; validating the attestation token based on the digital signature, evaluating a verification function using the group verification key, the set of data, and the digital signature for one or more group verification keys of a plurality of group verification keys to identify a given group verification key for which the digital signature passes verification, wherein each group verification key corresponds to a respective category of trust; determining that the category of trust corresponds to the given group verification key; validating the attestation token based at least on the category of trust corresponding to the given group verification key; a validating step, comprising: performing an action in response to verifying the attestation token; A method comprising:
2. receiving the attestation token includes receiving a request from the client device that includes the attestation token; The method of claim 1 , wherein performing the action comprises sending a response to the request to the client device.
3. The method of claim 1 or 2, wherein the digital signature is generated using a group signature scheme and an anonymous certificate provided to the client device based on an evaluation of a device-level fraud detection signal for the client device.
4. The method of claim 3 , wherein the anonymous certificate is an irrevocable anonymous certificate indicating that the client device has been irrevocably assigned to a given signing group.
5. The method according to claim 3 or 4, wherein the group signature scheme is a Direct Anonymous Attestation (DAA) signature scheme.
6. The method of claim 5 , wherein the DAA signature scheme is an Elliptic Curve Cryptography (ECC) DAA signature scheme.
7. The method of claim 5 , wherein the ECC DAA signature scheme is an ECC DAA signature scheme using a Barreto-Naehrig curve.
8. the attestation token includes an attestation token creation timestamp indicating the time when the attestation token was created; 8. A method according to any one of claims 1 to 7, wherein validating the attestation token comprises determining that a time difference between a time the attestation token was received and a time the attestation token was created is within a threshold.
9. The method of claim 8 , wherein the attestation token creation timestamp has a time resolution of less than about 1 millisecond or less than about 1 microsecond.
10. The method of any one of claims 1 to 9, comprising the step of obtaining the plurality of group verification keys before receiving the attestation token.
11. The method of any one of claims 1 to 10, comprising the step of periodically obtaining the plurality of group verification keys.
12. 1. A system comprising: one or more processors; one or more memories storing computer readable instructions configured to cause the one or more processors to perform the method of any one of claims 1 to 11; A system including:
13. A non-transitory computer-readable medium storing instructions that, when executed by one or more computers, cause the one or more computers to perform operations of the method of any one of claims 1 to 11.
Citation Information
Patent Citations
Resource operation method and device
CN107659406A
Apparatus and method for direct anonymous attestation from bilinear maps
JP2009027708A
Cloaking authority system
US10154061B1
Apparatus and method for direct anonymous attestation from bilinear maps
US20080270786A1
Systems and methods for distributed key storage
US20200162251A1
