Patent Grant
11797683
This patent relates to techniques for processing encrypted data inputs, and more specifically, to protecting such systems and data against external monitoring attacks.
Systems that operate on sensitive data need to protect against the unauthorized access to, or disclosure or alteration of, such data by attackers. Attackers who gain access to cryptographic keys and other secrets could steal or tamper with the sensitive data, leading to severe consequences such as subversion of critical operations of the system through the introduction of unauthorized commands and the exposure of confidential or proprietary information. One compromised element may also be used to mount further attacks, endangering other elements of a system. More specifically, previous research has shown that an attacker can monitor a device's external characteristics such as operation timing, power consumption and/or electromagnetic radiation and use this additional information to extract the secret keys being used within the device. For example, as described by Kocher et al (see P. Kocher, J. Jaffe, B. Jun, “Differential Power Analysis,” Advances in Cryptology—Crypto 99 Proceedings, Lecture Notes In Computer Science Vol. 1666, Springer-Verlag, 1999), it is well known in the art that external monitoring of a device performing a sequence of cryptographic operations using the same set of keys with different data can result in the leakage of the key.
Because external monitoring attacks are typically passive and non-invasive, traditional tamper resistance defenses which are based on thwarting physical access or detecting improper usage are insufficient or impractical to provide protection against such attacks. For example, methods for managing secret keys using physically secure, well-shielded rooms are known in the background art. However, in many applications, requiring cryptographic systems to remain in physically isolated facilities is not feasible, given the environments in which they are expected to operate. In addition, such facilities are expensive to build and operate, and may still be imperfect in their ability to prevent small amounts of information from leaking to adversaries.
Of course, other methods are known in the background art that can mitigate the problem of information leakage from monitoring attacks without necessarily relying on physical shielding. These include methods for reducing the amount (or rate) of information leaking from transactions, modifying cryptographic algorithm implementations to randomize computational intermediates, and/or introducing noise in power consumption and operation timing.
For example, U.S. Pat. No. 6,539,092, entitled “Leak-Resistant Cryptographic Indexed Key Update,” provides methods for converting a shared master key and an index value (e.g., a counter) into a transaction key, where the derivation is protected against external monitoring attacks. Those methods work well in applications where the device(s) being protected against external monitoring attacks can contribute to the derivation of the transaction key. For example, the '092 patent describes how a smartcard can maintain an index counter which increments with each transaction, then use the index counter in the key derivation.
There are applications, however, where the participant(s) in a protocol should be protected against external monitoring attacks, but lack the ability to store sequence counters and updated keys, as described in the '092 patent. For example, consider the case where a device needs to regularly process the same input data, such as a device which contains a fixed and unchanging embedded key that is repeatedly used to decrypt ciphertexts in arbitrary order. Firmware encryption is an example of such an application; a microprocessor may be manufactured having an embedded key in fuses, and on every reboot the microprocessor needs to re-decrypt its firmware image loaded from an untrusted external flash. The firmware image may occasionally be updated, but the same ciphertext may also be decrypted repeatedly. Thus, both the application requirements and the physical manufacturing limitations (such as the inability to modify stored keys due to the use of one-time-programmable fuses to hold keys) can make it impractical for the device to limit the number of times the decryption key will be used. The firmware publisher could use the methods described in the '092 patent with a new index value each time a new encrypted firmware image is released, but the decrypting device cannot use a different index value on each reboot, since changing the index value to a value other than the one used by the encrypting device would result in an incorrect decryption. Thus, an attacker can potentially supply the decryption device with tampered data sets, then attempt to recover the secret key by monitoring external characteristics while the device processes (e.g., decrypts, etc.) these ciphertexts. Statistical side channel attacks, such as differential power analysis (DPA), can deduce a secret key from a set of measurements collected when a device uses the same key repeatedly to operate on different input values (such as the different firmware ciphertexts or tampered versions of the same firmware ciphertexts in the foregoing examples). Measurements from a single long message (e.g., comprising many block cipher inputs) or a collection of legitimate messages (such as multiple firmware versions) may also provide sufficient data for a side channel attack, even if ciphertext messages are not tampered.
Of course, in some situations where a device uses the same key for every transaction, the device could theoretically implement a lock-out (e.g., by self-destructing if a transaction or failure threshold is exceeded) to limit the number of transactions an adversary can observe. Lock-out mechanisms, however, introduce numerous practical problems, however, such as reliability concerns and the difficulties associated with storing a failure counter (e.g., many semiconductor manufacturing processes lack secure on-chip nonvolatile storage, and off-chip storage is difficult to secure).
In light of all the foregoing, a method that provides a verifiably secure way for devices to communicate and exchange data, with protection against external monitoring attacks and the ability for devices to reject non-genuine data, would be advantageous.
This patent describes ways to secure devices which utilize secret cryptographic keys against external monitoring attacks, as well as to provide improved security against conventional cryptanalysis and other attacks (such as DPA and other forms of external monitoring attacks) which gather information correlated to the device's internal operations. Various exemplary embodiments for encrypting sensitive data are disclosed in the specification.
While these various embodiments may vary considerably in their details, they are all encompassed within the following general technique, as may be readily verified with respect to the various embodiments described in the specification: With respect to encryption, each set of data to be encrypted is associated with a message identifier (such as a transaction/message counter, a hash of the plaintext, a random value, or another unique or semi-unique value). The encryption device derives a message key using the message identifier and an initial secret internal state that is shared with the decryption device(s). This derivation is performed in an iterative manner through a succession of one or more intermediate keys, starting from at least a portion of the shared secret internal state and leading up to the message key, where, in each iteration, the next key depends on at least one prior key and at least a portion of the message identifier. The plaintext may be decomposed into one or more segments. Each plaintext segment is encrypted with one or more secret keys that can include the message key, or keys further derived from the message key, to create the corresponding encrypted segment. Typically, a different key (or a different set of keys) is used for each segment.
The encrypting device then uses a secret key shared with the decrypting device (such as the message key, the secret internal secret, a different key, keys derived from the foregoing, etc.) to compute at least one validator. Derivation of the validator may be performed using an iterative process similar to that used to produce the message key, whereby a sequence of transformations are applied to the secret key to produce successive values (for example, where the generation of each intermediate includes hashing its parent value).
The encrypting device outputs the one or more encrypted segments and one or more validators. Additional information may also be output as needed to enable the recipient to determine the message identifier.
During the corresponding decryption process, a decrypting device receives the one or more encrypted segments, one or more validator(s), and the message identifier corresponding to the encrypted segment(s). It then uses one or more validators to verify that at least the first encrypted segment to be decrypted has not been modified. Verification of the validator may include computing a sequence of successive intermediate values, starting with a secret shared with the encrypting device and where each intermediate is the hash of its parent (and the specific hash operation depends on a portion of the hash of said encrypted segment(s)). Typically, the decryption process for an encrypted segment is only permitted to proceed if it is verified that the segment is not modified. If verification is successful, the decrypting device computes the message key (if not already derived), using the secret internal state that it shares with the encryption devices, by following the same iterative key derivation process followed by the encrypting device (i.e., starting from at least a portion of the shared secret internal state, leading to the final message key, through a sequence of intermediate keys, where at each step the next key depends on at least a portion of the message identifier and at least one prior key). Each encrypted segment (if determined to be unmodified) is decrypted with the one or more corresponding secret keys derived from the message key to recover the corresponding plaintext segment.
The techniques described in this patent enable parties to communicate cryptographically-protected sensitive data with increased security against external monitoring attacks. Although exemplary embodiments are described involving two parties, typically referred to as an “encrypting device” and a “decrypting device”, the term “device” is chosen for convenience and need not necessarily correspond directly to any particular role in a system design. The devices may, but are not required to, utilize different form factors or implementations. For example, the encrypting and decrypting devices could both be portable hardware devices. Alternatively, the encrypting device could be a software application running on a server operating in a facility, while the decrypting device could be a portable hardware device (or vice versa). Furthermore, although most cryptographic operations involve two parties, the techniques of this patent can, of course, be applied in environments involving only one party (such as in secure memory or storage systems in which both roles are under a single party's and/or device's control, e.g., in the exemplary environment illustrated in
Entropy Redistribution Operations
As used herein, an “entropy redistribution operation” (or “entropy distribution operation”) is an operation which mixes its input(s) such that unknown information about input bits is redistributed among the output bits. For example, suppose an x bit cryptographic key K0 is processed repeatedly with an entropy redistribution operation f such that key Ki=f(Ki−1) for each i>1. Next, suppose an adversary obtains y bits of information (e.g., obtained as part of an attempted external monitoring attack) about each of n different keys Ki, providing more than enough information to solve for key K0 (e.g., y*n>x). The use of the entropy distribution operation f can make such solution computationally infeasible. A cryptographic hash function H is an example of an operation that may be used as an entropy redistribution operation. For example, consider a strong hash function H that produces a 256-bit result. Given a random 256-bit initial key K0, let Ki=H(Ki−1) for each i>1. An adversary with knowledge of (for example) the least-significant bit of each K0 . . . K999,999 has 1,000,000 bits of data related to K0. A hypothetical adversary with infinite computing power could find K0 by testing all possible 2256 values for K0 to identify a value which is consistent with the known sequence of least-significant bits. Actual adversaries have finite computational power available, however, and the entropy redistribution operation prevents there from being a computationally practical way to solve for K0 (or any other Ki) given the information leaked through attempted external monitoring attacks.
Entropy redistribution operations may be implemented, without limitation, using cryptographic hash functions, operations constructed using block ciphers (such as AES), pseudorandom transformations, pseudorandom permutations, other cryptographic operations, or combinations thereof. As a matter of convenience, certain exemplary embodiments are described with respect to a hash, but those skilled in the art will understand that, pursuant to the foregoing, other entropy redistribution functions may also be used instead or in addition.
Multiple entropy redistribution operations can also be constructed from a base operation. By way of example, if two 256-bit entropy redistribution operations f0( ) and f1( ) are required, f0( ) could comprise applying the SHA-256 cryptographic hash function to the operation identifier string “f0” concatenated with the input to f0( ) while f1( ) could comprise applying SHA-256 to the operation identifier string “f1” concatenated with the input to f1( ) Entropy redistribution operations can be construed using the well-known AES block cipher. For example, to implement f0( ) . . . fb−1( ), each fi( ) can use its input as an AES-256 key to encrypt a pair of 128-bit input blocks that are unique to the choice of i within 0 . . . b−1, yielding 256 bits of output. A wide variety of block cipher based hash function and MAC constructions are also known in the background art and may also employed.
Shared Cryptographic Values and Operations
This section describes certain cryptographic value(s) and/or operation(s) shared by both the encryption device, and its corresponding decryption device, used to perform verifiable leak-resistant cryptographic operations as described in this patent.
The encrypting device and decrypting device are set up so that each has access to a base shared secret cryptographic state value, such as a secret key denoted as KROOT. This secret state may, for example, be stored in one or more of EEPROM, flash, fuses, or other storage on a tamper-resistant chip, and may be derived in whole or in part from other values or processes, or may be obtained externally. The method by which each of these devices obtained KROOT could include, without limitation, each being manufactured with KROOT, the devices negotiating KROOT directly with each other or via third parties (e.g., using protocols utilizing RSA, Diffie-Hellman, or other public key cryptographic techniques, or symmetric techniques), by receiving of KROOT via a physical keying interface, randomly generating KROOT (e.g., if the encrypting and decrypting device are the same), etc.
In addition, the encrypting device and decrypting device also are both able to compute a set of non-linear cryptographic entropy redistribution operations f0( ) f1( ), . . . , fb−1( ) where b>1 is a positive integer. These b entropy redistribution functions can be configured in a tree structure. For example, a simple b-ary tree structure of height Q (i.e., having Q+1 levels, from 0 through Q) can be created by using b distinct entropy distribution functions, f0( ), . . . fb−1( ) to represent the b possible branches of this b-ary tree at each node of the tree, each node representing a possible derived key. In such a tree, starting from a root cryptographic key KSTART (which is at level 0), b possible derived keys can be computed at level 1: f0(KSTART) for the leftmost branch; f1(KSTART) for the next branch; and continuing until fb−1(KSTART) for the rightmost branch. At level 2, b2 possible keys can be derived, since each of f0( ) . . . fb−1( ) could be applied to each of the b possible level 1 keys. Of course, computing a specific level 2 node only requires two, not b2, computations (i.e., the nodes not on the path are not computed). The tree continues for successive levels 1 through Q, where each possible key (i.e., a different node) of a prior level can be processed by applying f0( ) . . . fb−1( ) in turn to derive b additional possible derived keys. The entire key tree has Q+1 levels, starting with a single node at level 0, continuing with bi nodes at level i, and ending with bQ nodes at level Q. Thus, there are bQ possible paths from the root node at level 0 to the bQ final nodes at level Q. Each such possible path, corresponding to a unique the sequence of functions applied at the different levels, can be represented as a sequence of Q integers, each integer being selected from (0 . . . b−1).
For example, in an exemplary embodiment, b=2. Thus, two entropy redistribution operations, f0( ) and f1( ) are used (and may be constructed from a base operation, e.g., as described above). If Q=128 (i.e., the height is 128), 2128 paths are possible and 128 entropy redistribution function computations are required to derive the level Q key from the level 0 node (i.e., the starting key).
As a variation, embodiments can involve more variety in the choice of b, such as varying the value of b among levels, and/or varying b based on the route taken to a particular level. Likewise, the entropy redistribution operations can also be varied, such as by making the entropy redistribution operations fi( ) differ at different levels or making these operations depend on the sequence taken to a particular level.
The encrypting and decrypting devices are also able to perform a cryptographic, non-linear key chaining operation g( ), which may be (but is not necessarily) distinct from the functions fi( ). For example, in one embodiment, g( ) consists of a cryptographic hash operation. Variant embodiments can use different functions for different applications of g( ), including variants constructed from a base function (e.g., by hashing the input data with a counter or another value representing the application of g( )).
The encrypting device and decrypting device also have a cryptographic, collision-resistant, one-way hash function h( )(e.g., employed as a segment hashing function), which may be (but is not necessarily) distinct from the operations fi( ) and from g( )).
In an exemplary embodiment, each of the operations fi( ), g( ), and h( ) is constructed from a common cryptographic hash function by computing each operation as the cryptographic hash of an operation identifier and the input data. The operation identifier may, for example, be a zero-terminated string consisting of “f#”, “g” or “h” where # is the value of i for a given fi( ) such that the operation identifier for f0( ) would be “f0”. The HMAC of an operation identifier using the input as a key may also be used to implement these operations. Hash functions usable with the techniques of this patent include, without limitation, MD5, SHA-1, SHA-256, SHA-512, any SHA3 candidate operation, as well as combinations of the foregoing and constructions using the foregoing (such as HMAC). As used herein, each of the functions BLAKE, Blue Midnight Wish, CubeHash, ECHO, Fugue, Grostl, Hamsi, J H, Keccak, LANE, Luffa, Shabal, SHAvite-3, SIMD, and Skein is a “SHA3 candidate operation”. In other embodiments, the hash function is derived using other well known constructions such as, without limitation, Matyas-Meyer-Oseas, Davies-Meyer, Miyaguchi-Preneel, Merke-Damgard, etc., that convert block ciphers such as AES, DES or other ciphers into a hash function. Transformations that are not collision-resistant (such as MD5, reduced-round variants of hash transformations, or other mixing operations) can also redistribute entropy present in the input, but would be less attractive for use as the one-way function h( ).
Still other embodiments may utilize stream ciphers, potentially including lightweight and potentially cryptographically weak stream ciphers, in implementing entropy redistribution operations f0 . . . b−1( ). For example, the stream cipher RC4 may be employed, where the entropy redistribution operation input is used as the RC4 key and the RC4 output bytes are used as (or used to form) the entropy redistribution operation output.
The encrypting device and decrypting device have a secret key encryption function (or set of functions) ENC( ) with a corresponding decryption function DEC( ). In some embodiments, such as those with fixed-length messages, ENC( ) and DEC( ) may utilize conventional cipher constructions such as AES in ECB or CBC mode. Constructions of ENC( ) and DEC( ) for other embodiments are described later with respect to
This section describes an exemplary embodiment of the general technique for verifiable leak-resistant encryption and decryption. This first exemplary embodiment uses key chaining and ciphertext hash chaining.
Encryption
For convenience, following the traditional nomenclature in cryptography, we use the term “plaintext” to refer to the data to be encrypted. As those skilled in the art will understand, this does not necessarily mean that the input data is human-readable, and indeed, nothing precludes such data from itself being compressed, encoded, or even encrypted, prior to its being protected with the techniques of this patent. Similarly, those skilled will understand that the term “data” encompasses any quantity being processed, and could include, without limitation, content, data, software, code, and any other type of information.
Given a sensitive plaintext data message D to be protected, and with knowledge of a shared base secret cryptographic value KROOT, the encrypting device performs the following steps, as outlined in
The encrypting device also generates (step 101) a nonce N which (as will be shown below) may be used as a message identifier (or a precursor thereto) for use in connection with the encryption of D. For example, the nonce could be generated using a true random number generator, a pseudorandom number generator, some combination of true and pseudorandom number generators, a counter value or other (preferably unique or seldom-repeating) parameter, or by deriving N from keys and/or data (including without limitation D, e.g., by setting N to the hash of part or all of D) available to the encryption device. In
In the exemplary embodiments that follow, a message identifier H1 is formed using nonce N. In the most straightforward implementation, in which N serves as the message identifier, H1 may simply equal N. As another example, in which N serves as a precursor to the message identifier, the encrypting device could compute H1 (step 102) as the hash of N using the function h( ) Hashing is useful in situations where one wishes to produce a fixed-size message identifier, for example, to permit the incorporation of longer data values (such as text strings) while operating on shorter quantities for computational efficiency, or to convert variable-length data values to a uniform length message identifier for computational simplicity, or to reduce any ability adversaries may have to influence the selection of H1. Of course, hashing is only one way to produce the message identifier, and those skilled in the art will appreciate that functions other than h may be employed to produce H1.
After computing H1, the encrypting device computes a message key, KMESSAGE, using the shared base secret cryptographic value KROOT and H1 (103) as input to a leak resistant, key-tree-based key derivation process. For convenience of discussion, the key derivation process is presented here in the context of encryption (e.g., performed by the encrypting device), and more specifically, in the context of the first exemplary encryption process of
An exemplary key derivation process is diagrammed in
In an exemplary implementation, message identifier H1 is decomposed into Q parts P1, P2, . . . , PQ. In an exemplary decomposition, each part Pi is an integer from 0 thru (b−1) (e.g., if b=4 then each Pi is a two-bit value (0, 1, 2, or 3)). Likewise, if b=2, each Pi is a single bit (0 or 1). Hence, the path parts P1 . . . PQ can be used to specify a specific path from KSTART to KSTART,PATH by applying functions f0( ) f1( ), . . . , fb−1( ) to produce a plurality of intermediate keys leading to KSTART,PATH as follows. First, the function fP1 is applied to KSTART (203) to yield an intermediate key KSTART,P1, followed by the application of fP2 on KSTART,P1 to yield the intermediate key KSTART,P1,P2 (204) and so on, until the final application of fPQ on the intermediate key KSTART, P1, P2, . . . , PQ−1 (205) to yield the final derived key, KSTART, P1, P2, . . . , PQ (206). Note that the derivation of each intermediate key depends on at least one predecessor key (e.g., in the case of
At step 104, the data segment(s) are encrypted using at least one cryptographic key based on said message key KMESSAGE, producing ciphertext E=E1, . . . , EL is from the input segment(s) D=D1, . . . , DL. An exemplary embodiment for step 104 is shown in
The process of
After the L keys K1, . . . , KL for encrypting the L segments have been determined, the encryption of the segments proceeds as follows. The final (L'th) segment is processed first, where the plaintext input (306) to the ENC( ) function is the L'th data segment DL, concatenated with message integrity value computed by cryptographically hashing the entire plaintext D1 . . . DL. (The inclusion of the hash of D1 . . . DL is optional; embodiments may omit this, or concatenate other data such as sequence of ‘0’ bytes or some other form of padding). This L'th plaintext segment is encrypted by the key KL to yield the encrypted segment EL (307).
Next, the L−1'th segment is processed at (308) by applying the hash function h( ) to EL, appending this hash value to data segment DL−1, and using the result as the encryption input to the L−1'th segment. At (309), the L−1'th plaintext segment is then encrypted using the key KL−1 to yield encrypted segment EL−1. This process is repeated for the other segments. For instance, the encryption input (310) corresponding to the second plaintext segment is composed of the second data segment D2 followed by h(E3), the hash of the third encrypted segment, and input (310) is then encrypted using the key K2 to yield the encrypted segment E2 (311). Finally, the encryption input (312) corresponding to the first plaintext segment is composed of the first data segment D1 followed by h(E2), the hash of the second encrypted segment (311), and input (311) is then encrypted using the key K1 to yield the encrypted segment E1 (313). (As a variant of the foregoing, the subsequent segment hashes do not need to be encrypted, e.g., Ei could be formed by encrypting Di then concatenating the encryption result with the hash of Ei+1.)
The encrypted segments E1 . . . EL form the ciphertext E. Step 104 in
Note that the process of
Referring back to
Next, the encrypting device uses a secret key to compute V (106), which is a validator of the message identifier and ciphertext segment(s) Ei. Validator V is computed using the hash of at least one ciphertext segment (e.g., the hash H2=h(E1)) and an initial secret (e.g., KMESSAGE, or other values as described in the following paragraph). Computation of V may be performed using the leak resistant, key-tree-based key derivation process described in
The foregoing description commenced with KMESSAGE in deriving the validator, but alternate embodiments may start with a different value. For example, the key KMESSAGE at step 104 and the key KMESSAGE at step 106 may be different from each other but both derived from KROOT,H1. Likewise, the key used at step 106 may be derived from the KMESSAGE used at step 104, or vice versa, or a different base key (besides KROOT) may be employed as KSTART. Of course, KROOT itself may even be used as KSTART (e.g., if H2 is a hash of N and/or H1 and one or more ciphertext segments).
The validator, as utilized in this patent, is a verifiable cryptographic proof that some putative ciphertext is an unmodified version of an encryption of some plaintext message data associated with a particular message identifier, and was produced by an entity with access to a secret cryptographic value. The validator constructed at step 106 can be conveniently validated by a recipient, such as a decryption device, in a manner that avoids susceptibility to differential power analysis and related external monitoring attacks. In addition, the validator creation process (i.e., the performance of step 106) also enables the encryption device to avoid susceptibility to differential power analysis and related external monitoring attacks.
After computing the validator, the encryption process is complete. At step 107, the result is output. The output data consists of the information (if any, e.g., nonce N) required to enable a recipient to derive the message identifier, the validator V, and the encrypted result E (comprising encrypted segments E1, . . . , EN). By combining key chaining and ciphertext hash chaining, this type of encryption process is able to yield cryptographically-strong output with message authentication, while avoiding the re-use of secret keys located in the encrypting device in ways that would facilitate differential power analysis and related attacks against the encrypting device. The encryption result is created in a form which enables a decryption device to perform the decryption without re-using secret keys in ways that would facilitate differential power analysis and related attacks against the decryption device. The key-tree process limits the re-use of keys in the formation of KMESSAGE and the validator V, while the ciphertext hash chaining method limits the use of keys used in the data encryption.
The next section explains how the output data can be subsequently decrypted by the decrypting device.
Decryption
The exemplary decryption process begins at step 400 with obtaining (e.g., over an untrusted digital interface) the putative result of the encryption (namely, the message identifier (e.g., nonce N), the validator V, and the encrypted result E comprising segments E1, . . . , EN). At step 401, the device next computes the value H1 by hashing the received nonce N. Note that, unless the nonce was received incorrectly, the derived H1 will equal the H1 used in the encryption process. At step 402, the decrypting device computes the value H2 by hashing the segment E1 (and, if previously used during the encryption, other information about the message that was incorporated into the derivation of H2). At step 403, the device attempts to compute the message key, KMESSAGE, using the leak resistant, key-tree-based key derivation process described in
If the check at step 405 is successful, then the process moves to step 407 where a counter i is initialized to the value 1, a key register K is initialized to the result of computing g(KMESSAGE) which is the key for decrypting the first encrypted segment E1 (i.e., the value of K1 which is labeled 302 in
Note that in this embodiment, the decryption process can be done in a streaming manner (i.e., the decryption device could initially obtain N, V and E1 and then receive the remaining segments E2, . . . , EL one at a time), and still be able to carry out the steps outlined above. Streaming operation is, for example, useful if the decrypting device lacks sufficient memory to hold the entire message, or if initial portions of the decrypted data need to be available before the all of the data has been received and decrypted.
This section describes a second exemplary embodiment of the general technique for verifiable leak-resistant encryption and decryption. In contrast to the first exemplary embodiment which used ciphertext hash chaining, the second exemplary embodiment uses plaintext hash chaining. However, in both cases, the re-use of keys is controlled at both the encrypting device and the decrypting device to prevent differential power analysis and related attacks.
Encryption
The second exemplary embodiment of encryption by the encrypting device is shown in
The input message D is divided into a sequence of segments D1, . . . , DL (although L=1 is permitted), and these segments are used to create the plaintext segments B1, . . . , BL as follows. First, segment B1 (501) is formed by concatenating message segment D1 with the hash of any desired message data (denoted as X, which may include elements such as length L, message identifier N, a transaction identifier or counter, etc.) Next, B2 (502) is formed by concatenating D2 with h(B1) (i.e., the hash of B1). Each subsequent Bi up to BL−1 is then formed by concatenating Di with the hash of Bi−1. Finally, the last plaintext segment BL (504) is formed by concatenating DL with h(BL−1).
The next steps of the process (505-508) generate encryption keys for each of the plaintext segments using a key chaining process so that, similar to the first exemplary embodiment, each encryption key is directly or indirectly based on the message key. In the second exemplary embodiment, the first encryption key K1 is simply set to the value of message key KMESSAGE derived (505) by computing h(N) and then K1=KMESSAGE=KROOT, h(N) using the leak resistant, key-tree-based key derivation process as described in
The next step in the process is the encryption of each of the plaintext segments B1, . . . , BL with the corresponding keys K1, . . . , KL to yield the encrypted segments E1, . . . , EL. For instance, encrypted segment E1 is created by encrypting B1 with K1 (509), E2 is created by encrypting B2 with K2 (510), and so on, with EL−1 created by encrypting BL−1 with KL−1 (511), and EL is created by encrypting BL with KL (512). The encrypted result E consists of the segments E1, . . . , EL.
The next step in the process is the computation of the validator V for the encryption (513). First, the hash function h( ) is used to compute h(N∥E1∥ . . . ∥EL)∥h(BL)), where “∥” denotes concatenation. Next, Z=h(N∥E1∥ . . . ∥EL∥h(BL)) is computed, then KROOT, Z is computed using leak resistant key-tree-based key derivation process (e.g., as described in
The encryption process above can be employed in systems where the input data D arrives by streaming, or where for other reasons D cannot be processed all at once (e.g., because of memory limitations). In this case, the encrypting device commences by obtaining N, h(X), and K1. In addition, a running hash computation is initialized with N.
1. Create or obtain N
2. Initialize running hash calculation
3. Let H=h(X)
4. Let K=KROOT,h(N)
5. Update running hash calculation with N
6. Let i=1
7. Receive input data Di (e.g., streaming in)
8. Create Bi=concatenation of Di and H
9. Let H=h(Bi)
10. Create Ei=ENC(K, Di)
11. Update running hash calculation with Ei
12. Output Ei
13. Increment i
14. If more there is input data, go to step 7
15. Update running hash calculation with H
16. Finalize running hash calculation and store in Z
17. Compute V=h(KROOT,Z)
18. Output H (which equals h(BL), N, V
Decryption
The process of decryption is illustrated in
Next, the following operations are performed in a loop: At step 630, the segment Ei is decrypted with the key in key register K to produce a plaintext segment Bi which consists of a data segment Di and a hash value. At step 640 the hash from of the decrypted current segment is checked. For the first segment (i.e., i=1), the hash is compared against h(X), where X consists of the same fields as X during encryption. For segments after the first one (i.e., i>1), the hash from Bi is compared against the hash of the prior segment (i.e., h(Bi−1)). If the comparison fails, the decryption process fails at step 641. Otherwise, at step 650, the message portion of Bi (i.e., Di) is added to the output buffer (e.g., in RAM), and key register K is advanced to the next segment key by computing g(K) then storing the result in K. The counter i is also incremented by 1. At step 660, the value of i is compared with L and, if the value of i does not exceed L, the decryption process loops back to step 630. Otherwise, the decryption process is complete and at step 670, where the hash of the last plaintext segment (i.e., h(BL)), is compared to the received hash H. If the comparison at step 670 fails (i.e., the values are not equal), an error has occurred and the decryption fails (step 671). Otherwise the result data D1, . . . , DL are output in step 680.
In this embodiment, the hashes of the plaintext are chained, with plaintext segment Bi containing the hash of the plaintext Bi−1. This chaining, while not strictly necessary for leakage resistance, provides the additional property that any faults that occur during the decryption process can be detected because the plaintext is verified to be that same as what was encrypted. Thus, this embodiment is advantageous for use in environments where there is potential for corruption the decryption process.
Systems, Applications, and Variants
Up to this point, this patent has described a general technique for leak-resistant encryption and decryption, together with some exemplary embodiments of that technique. This section will describe some exemplary systems and/or applications in which the foregoing can be utilized, as well as additional variants of aspects of the exemplary embodiments described above.
Secure Firmware Loading
Upon bootstrap from the trusted bootstrap code in ROM, the SoC loads its sensitive software/data, over an untrusted interface (706), from an external, untrusted storage device, which in this embodiment is flash memory (709). To protect the sensitive software/data from disclosure or unauthorized modification, it is encrypted using the verifiable leak-resistant techniques (e.g., as shown in
In an optional enhancement to this embodiment, security is complemented by storing a minimum acceptable software version number in fuses, battery backed memory, or other local storage of the device onto which the software is to be loaded. All software to be loaded into the device would carry a version number, and the device would only accept software with a version number greater that the minimum. In addition, some software versions might specifically instruct the SoC to update the minimum acceptable software version number, thereby preventing malicious rollback of software to a prior version that was deemed unacceptable. The foregoing anti-rollback methods could be implemented independently of (i.e., as an adjunct to) the verifiable leak-resistant operations. Alternatively, the anti-rollback methods could be implemented as part of the message identifier, the validator, or the other secured quantities used in the verifiable leak-resistant operations.
Those with ordinary skill in the art will easily recognize that SoC applications are not limited to the specific architecture presented herein, and SoCs or other devices with a different internal architecture and/or components from the embodiment presented in
For example,
The use of verifiable leak-resistant cryptography substantially improves the security of existing processor designs by providing protection against monitoring attacks. In particular, this embodiment enhances the cryptographic hardware subcomponent (804) to include a hash function and a key tree processing capability that reuses the (e.g., AES) encryption capability of an existing secure processor design and implements the steps and method of the first exemplary embodiment to create a secure leak-resistant secure processor. In particular, any data written from cache (803) to the RAM memory (806) is encrypted using the leak resistant encryption process (e.g., as shown in
FPGA Bitstream Loading
The logic to be loaded into a field programmable gate array (FPGA) often contains highly sensitive trade secrets, cryptographic secrets, and/or other sensitive information that needs to be protected from disclosure or copying. This loaded logic, or upgraded logic is typically supplied to the FPGA as a bitstream from an external source, such as, without limitation, a flash memory device or a CPU or some other source (907). Some FPGAs contain nonvolatile memory for storing configuration data, while others must be re-loaded each time the chip is powered on. Existing FPGAs have the ability to decrypt bitstreams, typically using a key that is held a battery-backed memory or stored locally (such as using on-chip flash, EEPROM, or fuses). The FPGA decrypts the supplied encrypted bitstream before (or while) installing it into the programmable slices present within the FPGA. Differential power analysis attacks and related external monitoring attacks can be attempted against the bitstream decryption processes, posing a serious security risk as a successful attack can result in disclosure of the bitstream decryption key and/or the bitstream itself.
Referring to
Within the FPGA, the cryptographic secret KROOT for leak-resistant decryption is kept in the keystore (902) which stores the internal secret state, and which may be implemented using technologies such as, without limitation, fuses, battery-backed RAM (902, 903), EEPROM, flash, etc. The FPGA (900) receives the encrypted bitstream over interface (906). This bitstream could, for example, have been encrypted using either of the first embodiment or the second exemplary embodiment (corresponding to
If the embodiment of
If the second embodiment of
Network Communications and Other Packet-Based Applications
Device A has a keystore (1001) to store a table of shared cryptographic root keys with other devices it needs to communicate with. These keys may have been previously stored, or may be negotiated (e.g., using public key cryptography). Methods for using public key cryptosystems to negotiate keys are well known in the background art, and are utilized in protocols such as SSL and IPSEC. This embodiment could easily be integrated into these or other protocols.
Outbound packets or data segments to be encrypted originate from an application, operating system, driver, or other component (1002) and enter plaintext packet buffer (1003). Each packet is then processed using the segment encryption/decryption processing component (1004), where it is encrypted using a verifiable leak resistant encryption method (e.g., as described in
For inbound encrypted packets, it is assumed that the sending device has performed the encryption as described above. These packets are received from the network (1020) by the network interface component (1006) and then moved to the ciphertext packet buffer (1005). Each packet is then processed by segment encryption/decryption processing component (1004), where a leak-resistant decryption process (e.g., as described in
This process is outlined in
Next the hash of E is computed (1105) (e.g., using SHA-256). Then the validator V for the encryption is computed as KMESSAGE,h(E) (1106) using the leak resistant key-tree-based key derivation process outlined in
As an optional optimization, if the encrypting device has multiple packets buffered for sending, it can encrypt multiple packets simultaneously such that only a single validator is required for all packets. For example, the encryption process may be performed as shown in
A corresponding verifiable packet level leak resistant decryption process is illustrated in
Smart Card Applications
Verifiable leakage-resistant encryption and decryption can be implemented in smart-cards (e.g., in connection with protocols where the smart-card is required to perform encryption and/or decryption in a manner that is secure from differential power analysis and related external monitoring attacks). Examples of such systems and protocols include, without limitation, the derivation of keys (control words) for the decryption of pay television signals, payments (including off-line payments), identity verification/network login, mobile telephone SIM cards, and transit passes. The exemplary cryptographic techniques disclosed in this patent can be used to ensure that the secret keys within smart-cards are protected from external monitoring attacks while performing such protocols. Smart cards (or other security chips) can also be used to implement part or all of the leak resistant encryption or decryption processes utilized in a larger system, such as if the smart card implements the key-tree based key derivation process of
Mutual Authentication Applications
In many applications, two or more devices need to authenticate each other and/or exchange sensitive information amongst them. Example applications of such protocols include, without limitation: (i) authentication between a printer and a cartridge to ensure that both devices are genuine and not counterfeit; (ii) authentication between a set-top box and a smart-card to ensure that components are authentic (e.g., to prevent the introduction of stolen video decryption keys); (iii) authentication between a garage door and an opener; (iv) keyless entry systems (such as may be used in cars) which authenticate keys (e.g., prior to unlocking doors or starting the engine); (v) authentication protocols performed by frequently stolen items (such as car radios, GPS units, cell phones, etc.) to prevent stolen or tampered devices from being operated; and (vi) entry systems such as those found in secure buildings that authenticate keys/tokens prior to permitting entry. In these applications, challenge response protocols between the devices have traditionally been used both for mutual authentication and to set up a shared secret key for the exchange of sensitive information. Simple protocols to perform these authentications while resisting DPA can be constructed by using the methods of this patent to perform any required encryption or decryption operations. For example, a device can demonstrate its authenticity using techniques disclosed in this patent through its ability to supply a valid validator and/or decrypt a message.
Segment Encryption and Decryption with Intra-Segment Key Changes
This section describes exemplary variants of the ENC( ) and DEC( ) operations which can be used in place of conventional encryption processes (such as AES in ECB or CBC mode) in implementing the exemplary embodiments (e.g., as shown at step 320 of
Other than the changes to ENC( ) and DEC( ) the remainder of the operations in the first and second exemplary embodiments can be implemented as previously described. For example and without limitation, the operations involving the initial message key KMESSAGE, the validator V, and so forth, need not be changed.
The inputs to the encryption process for segment i are segment key Ki (1301) and data segment Di (1310). The input data segment Di (1310) is divided into sub-segments Di,1 (1311), Di,2 (1312), etc.
Referring to
The ENC( )) and DEC( ) process above are examples which involve rapid key changes so as to provide greater leakage tolerance. Other segment encryption and decryption methods can be used, including the application of stream ciphers and/or block ciphers (such as RC4, SEAL, AES, DES, triple DES, etc.) in ECB, CBC, or counter (e.g., Galois counter) modes. For such operations where the same key is applied to all the data in a segment, it may be advantageous to limit the size of each segment (e.g., by dividing up the data into sub-segments as shown in
Communications Channels
Data exchanges described herein may be accomplished in a wide range of possible manners. For example, and without limitation, conventional buses/interfaces (such as I2C, JTAG, PCI, serial I/O (including USB), PCI Express, Ethernet, etc.), wireless protocols (such as 802.11 family, Bluetooth, cellular telephony protocols, ISO14443, etc.), and intra-chip connections (such as APB, direct connections with other flip flops, etc.) may all be used. For each of the foregoing, the sending device(s) and receiving device(s) would have appropriate interfaces (e.g., interfaces of the foregoing types) with can send, receive, or send and receive (as appropriate).
Alternate Forms of Data Validation Prior to Decryption
The exemplary embodiments presented thus far, have utilized the leak-resistant key-tree-based key derivation process (e.g., as illustrated in
Non-Sequential Segment Key Derivation
Segment keys (e.g., K1, K2, . . . KL in
Reordering of Data Transmissions and Calculations
The ordering of data transmissions and operations can be altered. For example, the first exemplary embodiment described in
Alternatively, the encrypting device could encrypt the segments starting from D1 and ending with DL, with each segment Di+1 containing the hash of the encryption Ei of the previous segment. In this example, the segment D1 is (for example) extended by a string of 0's of size equal to the output length of the hash function to indicate it is the first segment. A validator, created using the key-tree is then computed using PATH=h(EL). For this variant, the decryption process is similar to
Substitution of Additional Validators for Hashes
Although some examples show hashes in data segments which authenticate subsequent encrypted segments, the subsequent segments can alternatively carry their own independent validator. For example,
Variations in Hashing
In some diagrams, a single operation, such as h( ) in
The output of hash function may be truncated, combined with other hash function outputs, or otherwise modified through post-processing. For example, SHA-2 produces a 256-bit output hash, but a shorter message identifier (such as 160-, 128-, 80- or 64-bits) may be desired. The function h( ) may use SHA-2 internally and return only some bits of its result.
Variations in Order of Operations
Some of the exemplary embodiments designate a specific order in which data elements are concatenated or combined. For instance, in
Variations in Tree-Based Key Derivation
If operations (such as fi) are invertible, it is possible to use a value other than the top of the tree as the starting value. Similarly, computed values can be cached (e.g., if the message identifier is a counter, the initial operations will usually not change from one message to the next and therefore do not need to be recomputed).
Error Detection and/or Correction
It is well known in the art that incorrect outputs produced as a result of injecting faults in a cryptographic device's operation can yield information about sensitive data and keys. When practical, cryptographic operations can be checked to help prevent the release of incorrect computations which can compromise secrets. For example, a simple and effective technique is to perform cryptographic operations twice, ideally using two (or more) independent hardware processors and implementations, with a comparator to verify that both (or all) produce identical results. If the results produced by the units do not match, the comparator will prevent either result from being used and/or trigger other error conditions. Within individual cryptographic operations (such as hashing steps), error-detection and/or error-correction logic can also be employed to help prevent or detect situations where cryptographic operations are performed incorrectly.
The techniques disclosed in this patent may additionally provide some inherent resistance against certain types of fault injection attacks on the encryption and decryption processes. During the encryption process, a limited or partial fault introduced during the key tree based key derivation process would produce random, unpredictable results due to the usage of entropy redistribution functions within this process. In particular, corrupted intermediates will typically be mixed by subsequent entropy redistribution functions, which will limit adversaries' ability to mount attacks utilizing defective results.
Likewise, during decryption, faults or errors introduced within the ciphertext or the message identifier processing will generally resulting the validator being rejected. The second embodiment, with plaintext hash chaining, provides further resistance since the plaintext segments are independently authenticated for correctness prior to being output. Of course, the checking of operations and other well known fault-detection techniques may additionally be utilized.
Self-diagnostic functions such as a POST (power-on-self-test) and random number testing may also be incorporated to verify that cryptographic functions and random number generation capability has not been damaged.
Additional Host Environments and Form Factors
Several exemplary systems and applications for the utilization of verifiable leak-resistant cryptography were described above. However, as those skilled in the art will appreciate, the techniques described above are not limited to particular host environments or form factors. Rather, they can be used in a wide variety of applications, including without limitation: application-specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), systems on chip (SoC), microprocessors, secure processors, secure network devices, cryptographic smartcards of all kinds (including without limitation smartcards substantially compliant with ISO 7816-1, ISO 7816-2, and ISO 7816-3 (“ISO 7816-compliant smartcards”)); contactless and proximity-based smartcards and cryptographic tokens (including without limitation smartcards substantially compliant with ISO 14443); stored value cards and systems; cryptographically secured credit and debit cards; customer loyalty cards and systems; cryptographically authenticated credit cards; cryptographic accelerators; gambling and wagering systems; secure cryptographic chips; tamper-resistant microprocessors; software programs (including without limitation programs for use on personal computers, servers, etc. and programs that can be loaded onto or embedded within cryptographic devices); key management devices; banking key management systems; secure web servers; defense systems; electronic payment systems; micropayment systems and meters; prepaid telephone cards; cryptographic identification cards and other identity verification systems; systems for electronic funds transfer; automatic teller machines; point of sale terminals; certificate issuance systems; electronic badges; door entry systems; physical locks of all kinds using cryptographic keys; systems for decrypting television signals (including without limitation, broadcast television, satellite television, and cable television); systems for decrypting enciphered music and other audio content (including music distributed over computer networks); systems for protecting video signals of all kinds; content protection and copy protection systems (such as those used to prevent unauthorized copying or use of movies, audio content, computer programs, video games, images, text, databases, etc.); cellular telephone scrambling and authentication systems (including telephone authentication smartcards); secure telephones (including key storage devices for such telephones); cryptographic PCMCIA cards; portable cryptographic tokens; and cryptographic data auditing systems.
All of the foregoing illustrates exemplary embodiments and applications of the verifiable leak-resistant cryptography, from which related variations, enhancements and modifications will be apparent in the context of the spirit and scope of the disclosure. Therefore, the invention(s) protected by this patent should not be limited to the foregoing disclosure, but rather construed by the claims appended hereto.
This is a Continuation of pending U.S. patent application Ser. No. 16/240,671 filed Jan. 4, 2019, which is a continuation of U.S. patent application Ser. No. 15/395,809 filed Dec. 30, 2016, which issued Apr. 16, 2019 as U.S. Pat. No. 10,262,141, which is a continuation of U.S. patent application Ser. No. 14/617,437 filed Feb. 9, 2015, which issued Feb. 14, 2017 as U.S. Pat. No. 9,569,623, which is a continuation of U.S. patent application Ser. No. 14/201,539 filed Mar. 7, 2014, which issued Mar. 10, 2015 as U.S. Pat. No. 8,977,864, which is a Continuation of U.S. patent application Ser. No. 13/762,703 filed Feb. 8, 2013, which issued on Apr. 22, 2014 as U.S. Pat. No. 8,707,052, which is a continuation of U.S. patent application Ser. No. 12/958,570 filed Dec. 2, 2010, which issued on Feb. 26, 2013 as U.S. Pat. No. 8,386,800, which claims priority to U.S. Provisional Patent Application Ser. No. 61/266,948 filed Dec. 4, 2009, each of which is incorporated by reference herein in their entirety. This application is also related to U.S. patent application Ser. No. 14/737,154 filed Jun. 11, 2015, which issued on Feb. 21, 2017 as U.S. Pat. No. 9,576,133, and to U.S. patent application Ser. No. 14/752,677 filed Jun. 26, 2015, which issued on Jun. 14, 2016 as U.S. Pat. No. 9,367,693, and to U.S. patent application Ser. No. 15/691,601 filed Aug. 30, 2017, which issued on Apr. 10, 2018 as U.S. Pat. No. 9,940,463, each of which is incorporated by reference herein in their entirety.
| Number | Name | Date | Kind |
|---|---|---|---|
| 4694491 | Horne et al. | Sep 1987 | A |
| 4908038 | Matsumura et al. | Mar 1990 | A |
| 4972472 | Brown et al. | Nov 1990 | A |
| 5017766 | Tamada et al. | May 1991 | A |
| 5179951 | Knudson | Jan 1993 | A |
| 5268962 | Abadi et al. | Dec 1993 | A |
| 5297207 | Degele | Mar 1994 | A |
| 5319172 | Komatsu | Jun 1994 | A |
| 5454037 | Pacella | Sep 1995 | A |
| 5491749 | Rogaway | Feb 1996 | A |
| 5511123 | Adams | Apr 1996 | A |
| 5513261 | Maher | Apr 1996 | A |
| 5944833 | Ugon | Aug 1999 | A |
| 5978475 | Schneier | Nov 1999 | A |
| 5991415 | Shamir | Nov 1999 | A |
| 6009177 | Sudia | Dec 1999 | A |
| 6049878 | Caronni et al. | Apr 2000 | A |
| 6188987 | Fielder | Feb 2001 | B1 |
| 6278783 | Kocher et al. | Aug 2001 | B1 |
| 6289455 | Kocher et al. | Sep 2001 | B1 |
| 6298442 | Kocher et al. | Oct 2001 | B1 |
| 6304658 | Kocher et al. | Oct 2001 | B1 |
| 6327661 | Kocher et al. | Dec 2001 | B1 |
| 6385727 | Cassagnol et al. | May 2002 | B1 |
| 6510518 | Jaffe et al. | Jan 2003 | B1 |
| 6539092 | Kocher | Mar 2003 | B1 |
| 6587563 | Crandall | Jul 2003 | B1 |
| 6640305 | Kocher et al. | Oct 2003 | B2 |
| 6654884 | Jaffe et al. | Nov 2003 | B2 |
| 6654889 | Trimberger | Nov 2003 | B1 |
| 6704871 | Kaplan | Mar 2004 | B1 |
| 6724894 | Singer | Apr 2004 | B1 |
| 6735313 | Bleichenbacher | May 2004 | B1 |
| 6901509 | Kocher | May 2005 | B1 |
| 6917685 | Watanabe et al. | Jul 2005 | B1 |
| 6931543 | Pang et al. | Aug 2005 | B1 |
| 6993138 | Hardjono | Jan 2006 | B1 |
| 6996724 | Murakami et al. | Feb 2006 | B2 |
| 7028191 | Michener et al. | Apr 2006 | B2 |
| 7039803 | Lotspiech et al. | May 2006 | B2 |
| 7117373 | Trimberger et al. | Oct 2006 | B1 |
| 7146501 | Tanaka | Dec 2006 | B2 |
| 7225339 | Asano | May 2007 | B2 |
| 7299358 | Chateau | Nov 2007 | B2 |
| 7330969 | Harrison et al. | Feb 2008 | B2 |
| 7333616 | Brettle et al. | Feb 2008 | B1 |
| 7339400 | Walstrum, Jr. et al. | Mar 2008 | B1 |
| 7373506 | Asano et al. | May 2008 | B2 |
| 7373668 | Trimberger | May 2008 | B1 |
| 7424612 | England et al. | Sep 2008 | B2 |
| 7434046 | Srivastava | Oct 2008 | B1 |
| 7539313 | Hardjono | May 2009 | B1 |
| 7545931 | Dillaway | Jun 2009 | B2 |
| 7550324 | Walstrum, Jr. et al. | Jun 2009 | B1 |
| 7581094 | Apostolopoulos et al. | Aug 2009 | B1 |
| 7587044 | Kocher et al. | Sep 2009 | B2 |
| 7599488 | Kocher et al. | Oct 2009 | B2 |
| 7607025 | Trimberger | Oct 2009 | B1 |
| 7634083 | Kocher et al. | Dec 2009 | B2 |
| 7657035 | Yato et al. | Feb 2010 | B2 |
| 7668310 | Kocher et al. | Feb 2010 | B2 |
| 7689602 | Sim-Tang | Mar 2010 | B1 |
| 7706538 | Hughes et al. | Apr 2010 | B1 |
| 7783886 | Walmsley | Aug 2010 | B2 |
| 7787620 | Kocher et al. | Aug 2010 | B2 |
| 7986158 | Langton | Jul 2011 | B2 |
| 8095800 | Creary et al. | Jan 2012 | B2 |
| 8190895 | Lauter | May 2012 | B2 |
| 8250373 | Hyser | Aug 2012 | B2 |
| 8261068 | Raizen et al. | Sep 2012 | B1 |
| 8261085 | Fernandez Gutierrez | Sep 2012 | B1 |
| 8270614 | Kim | Sep 2012 | B2 |
| 8332649 | Yokota et al. | Dec 2012 | B2 |
| 8332653 | Buer | Dec 2012 | B2 |
| 8368517 | Lu | Feb 2013 | B2 |
| 8386800 | Kocher et al. | Feb 2013 | B2 |
| 8683212 | Rodgers | Mar 2014 | B2 |
| 8707052 | Kocher et al. | Apr 2014 | B2 |
| 8879724 | Kocher et al. | Nov 2014 | B2 |
| 9552493 | Uzun et al. | Jan 2017 | B2 |
| 9712321 | Jin et al. | Jul 2017 | B2 |
| 9729316 | Jin et al. | Aug 2017 | B2 |
| 20010002486 | Kocher | May 2001 | A1 |
| 20010053220 | Kocher et al. | Dec 2001 | A1 |
| 20020094088 | Okaue | Jul 2002 | A1 |
| 20020099948 | Kocher et al. | Jul 2002 | A1 |
| 20020124178 | Kocher et al. | Sep 2002 | A1 |
| 20020129245 | Cassagnol et al. | Sep 2002 | A1 |
| 20020131592 | Hinnant | Sep 2002 | A1 |
| 20020141593 | Kurn | Oct 2002 | A1 |
| 20020150250 | Kitaya | Oct 2002 | A1 |
| 20030044017 | Briscoe | Mar 2003 | A1 |
| 20030056107 | Cammack | Mar 2003 | A1 |
| 20030076958 | Ishiguro | Apr 2003 | A1 |
| 20030093674 | Harrison et al. | May 2003 | A1 |
| 20030093684 | Kaiserswerth et al. | May 2003 | A1 |
| 20030142824 | Asano | Jul 2003 | A1 |
| 20030142826 | Asano | Jul 2003 | A1 |
| 20030161474 | Matsuzaki | Aug 2003 | A1 |
| 20030194085 | Dillaway | Oct 2003 | A1 |
| 20030200440 | England et al. | Oct 2003 | A1 |
| 20040030905 | Chow et al. | Feb 2004 | A1 |
| 20040111631 | Kocher et al. | Jun 2004 | A1 |
| 20040139321 | Shaffer, II | Jul 2004 | A1 |
| 20040165724 | Choi | Aug 2004 | A1 |
| 20040236720 | Basso | Nov 2004 | A1 |
| 20050010778 | Walmsley | Jan 2005 | A1 |
| 20050025316 | Pelly et al. | Feb 2005 | A1 |
| 20050027999 | Pelly et al. | Feb 2005 | A1 |
| 20050028192 | Hooper et al. | Feb 2005 | A1 |
| 20050038999 | Pelly | Feb 2005 | A1 |
| 20050044045 | Pelly et al. | Feb 2005 | A1 |
| 20050058291 | Candelore | Mar 2005 | A1 |
| 20050102507 | Sozzani | May 2005 | A1 |
| 20050108507 | Chheda et al. | May 2005 | A1 |
| 20050180573 | Pelly et al. | Aug 2005 | A1 |
| 20050210014 | Asano | Sep 2005 | A1 |
| 20050210179 | Walmsley | Sep 2005 | A1 |
| 20050213751 | Apostolopoulos | Sep 2005 | A1 |
| 20050234951 | MacCormick | Oct 2005 | A1 |
| 20050246533 | Gentry | Nov 2005 | A1 |
| 20050256910 | Kim | Nov 2005 | A1 |
| 20050289067 | Lampson | Dec 2005 | A1 |
| 20060021066 | Clayton | Jan 2006 | A1 |
| 20060036627 | Deran | Feb 2006 | A1 |
| 20060059344 | Mononen | Mar 2006 | A1 |
| 20060090081 | Baentsch et al. | Apr 2006 | A1 |
| 20060095379 | Kim | May 2006 | A1 |
| 20060117177 | Buer | Jun 2006 | A1 |
| 20060184807 | Kocher et al. | Aug 2006 | A1 |
| 20060242064 | Jogand-Coulomb | Oct 2006 | A1 |
| 20060242067 | Jogand-Coulomb | Oct 2006 | A1 |
| 20060294018 | Tuoriniemi | Dec 2006 | A1 |
| 20070113079 | Ito | May 2007 | A1 |
| 20070133806 | Asano | Jun 2007 | A1 |
| 20070198851 | Goto | Aug 2007 | A1 |
| 20070223696 | Furuyama | Sep 2007 | A1 |
| 20070263875 | Kitaya | Nov 2007 | A1 |
| 20070294496 | Goss | Dec 2007 | A1 |
| 20070297613 | Ghosh | Dec 2007 | A1 |
| 20070300207 | Booth | Dec 2007 | A1 |
| 20080010686 | Nemoto | Jan 2008 | A1 |
| 20080013724 | Shamoon | Jan 2008 | A1 |
| 20080013733 | Johansson | Jan 2008 | A1 |
| 20080022146 | Kocher et al. | Jan 2008 | A1 |
| 20080042804 | Burbridge | Feb 2008 | A1 |
| 20080075291 | Kamijoh | Mar 2008 | A1 |
| 20080085003 | Waisbard | Apr 2008 | A1 |
| 20080086636 | Jung | Apr 2008 | A1 |
| 20080172562 | Cachin | Jul 2008 | A1 |
| 20080205654 | Moos | Aug 2008 | A1 |
| 20080222427 | Baentsch et al. | Sep 2008 | A1 |
| 20080263363 | Jueneman et al. | Oct 2008 | A1 |
| 20080279376 | Jin et al. | Nov 2008 | A1 |
| 20090022323 | Lee | Jan 2009 | A1 |
| 20090048953 | Hazel et al. | Feb 2009 | A1 |
| 20090070583 | von Mueller et al. | Mar 2009 | A1 |
| 20090138710 | Minematsu | May 2009 | A1 |
| 20090138728 | Fujiwara | May 2009 | A1 |
| 20090187762 | Okamoto | Jul 2009 | A1 |
| 20090187766 | Vuillaume et al. | Jul 2009 | A1 |
| 20090204806 | Kanemura | Aug 2009 | A1 |
| 20090214029 | Jin et al. | Aug 2009 | A1 |
| 20090214031 | Jin et al. | Aug 2009 | A1 |
| 20090252324 | Seleznev et al. | Oct 2009 | A1 |
| 20090299989 | Zhang | Dec 2009 | A1 |
| 20090304185 | Ju | Dec 2009 | A1 |
| 20090319802 | Walmsley | Dec 2009 | A1 |
| 20090327741 | Zimmer et al. | Dec 2009 | A1 |
| 20100042842 | Huang | Feb 2010 | A1 |
| 20100045442 | Lu | Feb 2010 | A1 |
| 20100082991 | Baldwin | Apr 2010 | A1 |
| 20100104094 | Takashima | Apr 2010 | A1 |
| 20100122088 | Oxford | May 2010 | A1 |
| 20100125739 | Creary et al. | May 2010 | A1 |
| 20100161999 | Poovendran | Jun 2010 | A1 |
| 20100169657 | Ghouti | Jul 2010 | A1 |
| 20100169658 | Ghouti | Jul 2010 | A1 |
| 20100183150 | Lee | Jul 2010 | A1 |
| 20100211787 | Bukshpun | Aug 2010 | A1 |
| 20100278338 | Chang et al. | Nov 2010 | A1 |
| 20100281273 | Lee | Nov 2010 | A1 |
| 20110038481 | Modave et al. | Feb 2011 | A1 |
| 20110072266 | Takayama | Mar 2011 | A1 |
| 20110078457 | Starr | Mar 2011 | A1 |
| 20110083019 | Leppard | Apr 2011 | A1 |
| 20110258459 | Guilley et al. | Oct 2011 | A1 |
| 20110286596 | Gressel | Nov 2011 | A1 |
| 20120102336 | Chheda et al. | Apr 2012 | A1 |
| 20120115455 | Rao | May 2012 | A1 |
| 20120166773 | Alekseev | Jun 2012 | A1 |
| 20120198514 | McCune et al. | Aug 2012 | A1 |
| 20120260324 | Lenon | Oct 2012 | A1 |
| 20130124868 | Sorotokin | May 2013 | A1 |
| 20130326236 | Chheda et al. | Dec 2013 | A1 |
| 20140129815 | Shah et al. | May 2014 | A9 |
| 20160224799 | Uzun et al. | Aug 2016 | A1 |
| Number | Date | Country |
|---|---|---|
| 0781003 | Jun 1997 | EP |
| 2002-520905 | Jul 2002 | JP |
| 2003-022007 | Jan 2003 | JP |
| 2004-096754 | Mar 2004 | JP |
| 2009-081549 | Apr 2009 | JP |
| 2009-175544 | Aug 2009 | JP |
| 20080096054 | Oct 2008 | KR |
| WO-00-02342 | Jan 2000 | WO |
| WO-2007-084758 | Jul 2007 | WO |
| WO-2011-068996 | Jun 2011 | WO |
| Entry |
|---|
| Advanced Access Content System (AACS), Introduction and Common Cryptographic Elements, Revision 09.1 (Feb. 17, 2006), available at http://www.aacsla.com/specifications/specs091/AACS_Spec_Common_0.91.pdf. 82 Pages. |
| Beye, Michael et al., “Improved Anonymity for Key-trees*”, International Association for Cryptologic Research, vol. 20110728:025555, Jul. 22, 2011 (Jul. 22, 2011), pp. 1-16, XP061005092, [retrieved on Jul. 22, 2011]. 16 Pages. |
| CN Office Action dated Apr. 22, 2015 in CN Application No. 201080060319.3, Includes English Translation. 10 pages. |
| Dziembowski et al., “Leakage-Resilient Cryptography in the Standard Model,” FOCS, pp. 293-302, IEEE Computer Society, May 28, 2008. 13 pages. |
| EP—Extended European Search Report dated Dec. 4, 2015 re EP Appln. No. 10835139.6. 10 Pages. |
| EP Communication Pursuant to Article 94(3) EPC dated May 9, 2018 re: EP Appln. No. 10835139.6. 6 Pages. |
| EP Communication Pursuant to Article 94(3) EPC dated Jun. 8, 2020 re: EP Appln. No. 19164962.3. 7 pages. |
| EP Extended European Search Report dated Jul. 5, 2019 re: EP Appln. No. 19164962.3. 8 Pages. |
| EP Response filed on Jun. 10, 2016 with EP Appln. No. 10835139.6 in Response to the Extended European Search Report dated Dec. 4, 2015 and the Communication Pursuant to Rules 70(2) and 70a(2) EPC dated Dec. 22, 2015. 32 Pages. |
| Faust et al., “Leakage-Resilient Signatures,” TCC, vol. 5978 of Lecture Notes in Computer Science, pp. 343-360, 2010. 21 pages. |
| Hu, Lingxuan et al., “Secure Aggregation for Wireless Networks”, Applications and the Internet Workshops, 2003. Proceedings 2003 Symposium. pp. 384-391. Jan. 27-31, 2003. 8 Pages. |
| JP Decision of Rejection dated Nov. 28, 2013 in JP Application No. 2012-542196, Includes English Translation. 9 pages. |
| JP Office Action dated May 17, 2013 in JP Application No. 2012-542196, Includes English Translation. 15 pages. |
| Katz, Jonathan (2004) , “Binary Tree Encryption: Constructions and Applications”, In: Lim JI., Lee DH. (eds) Information Security and Cryptology—ICISC 2003. ICISC 2003. Lecture Notes in Computer Science, vol. 2971. Springer, Berlin, Heidelberg. 11 Pages. |
| Kocher et al., “Differential Power Analysis,” Advances in Cryptology—Crypto 99 Proceedings, Lecture Notes in Computer Science, vol. 1666, Springer-Verlag, 1999, pp. 388-397. 10 pages. |
| Kondratieva, Veronika et al., “Optimized Hash Tree for Authentication in Sensor Networks”, IEEE Communications Letters, vol. 11, No. 2, Feb. 2007, pp. 149-151. 3 Pages. |
| KR Office Action dated Sep. 5, 2016 Re: KR Appln. No. 2012-7014536. 13 Pages. (With Translation). |
| Lorentz Center, “Workshop on Provable Security Against Physical Attacks,” Feb. 15-19, 2010, found at http://www.lorentzcenter.nl/lc/web/2010/383/presentations/index.php3?wsid=383&type=presentations. 1 page. |
| McEvoy et al., “All-or-NothingTransforms as a Countermeasure to Differential Side-Channel Analysis,” Cryptology ePrint Archive, Report 2009/185, http://eprint.iacr.org/2009/185. 18 pages. |
| Menezes et al., “Handbook of Applied Cryptography,” pp. 71, 586, 636-637, CRC Press, Boca Raton, Florida, 1997. 6 pages. |
| Menezes et al., “Efficient Implementation,” Handbook of Applied Cryptography, CRC Press, Chapter 14, pp. 591-634, 1996. 44 pages. |
| Menezes et al., “Handbook of Applied Cryptography,” Chapters 1, 5, and 7, CRC Press, Boca Raton, Florida, 1997. 130 pages. |
| Menezes et al., “Handbook of Applied Cryptography,” CRC Press, 1996, pp. 285-298, 312-319, 452-462, 475, and 515-524, found at http://www.cacr.math.uwaterloo.ca/hac/ on Jun. 22, 2011. 45 pages. |
| Molnar, David et al., “Privacy and Security in Library RFID Issues, Practices, and Architectures”, Proceedings of the 11th ACM Conference on Computer and Communications Security : Washington, DC, USA, Oct. 25-29, 2004; [ACM Conference on Computer and Communications Security], New York, NY : ACM Press, 2 Penn Plaza, Suite 01 New York NY 10121, Oct. 25, 2004 (Oct. 25, 2004), pp. 210-219, XP058347820, DOI: 11.1145/1030083.1030112, ISBN: 978-1-58113-961-7. 10 Pages. |
| Office Action dated Dec. 10, 2015, re Application No. 219,906. 12 Pages. (With Translation). |
| PCT International Preliminary Report on Patentability dated Jun. 14, 2012 in International Application No. PCT/US2010/058768. 12 pages. |
| Petit et al., “A Block Cipher Based PRNG Secure Against Side-Channel Key Recovery,” Proceedings of ASIACCS 2008, pp. 56-65, Tokyo, Japan, Mar. 2008. 22 pages. |
| Pietrzak, K., “A Leakage-Resilient Mode of Operation,” Eurocrypt 2009, Lecture Notes in Computer Science, vol. 5479, pp. 462-482, Cologne, Germany, Apr. 2009. 20 pages. |
| Pietrzak, K., “Provable Security for Physical Cryptography,” Invited Talk, Paper, Proceedings of WEWORC 2009, Graz, Austria, Jul. 2009. 17 pages. |
| Pietrzak, K., “Provable Security for Physical Cryptography,” Invited Talk, Slides, Proceedings of WEWORC 2009, Graz, Austria, Jul. 2009. 126 pages. |
| Standaert et al., “Leakage Resilient Cryptography in Practice,” Cryptology ePrint Archive, Report 2009/341, 2009, found at http://eprint.iacr.org/2009/341.pdf. 37 pages. |
| Standaert, Francois-Xavier, “How Leaky is an Extractor?,” Workshop on Provable Security Against SID-Channel Attacks, Leiden, The Netherlands, Feb. 2010. 11 pages. |
| Su, Chien-Chung et al., “The New Intrusion Prevention and Detection Approaches for Clustering-Based Sensor Networks”, Wireless Communications and Networking Conference, IEEE New Orleans, LA, USA, pp. 1927-1932, Mar. 13-17, 2005. 6 Pages. |
| Tanaka et al., “Study on Practical Message Authentication Mechanisms for Digital Streaming Services,” IEICE Technical Report, Jul. 18, 2001, vol. 101, No. 204, Tokyo, Japan. 11 pages (no translation). |
| TW Office Action dated Jul. 16, 2013 in TW Application No. 99142160, Includes English Translation. 12 pages. |
| Number | Date | Country | |
|---|---|---|---|
| 20220083665 A1 | Mar 2022 | US |
| Number | Date | Country | |
|---|---|---|---|
| 61266948 | Dec 2009 | US |
| Number | Date | Country | |
|---|---|---|---|
| Parent | 16240671 | Jan 2019 | US |
| Child | 17382333 | US | |
| Parent | 15395809 | Dec 2016 | US |
| Child | 16240671 | US | |
| Parent | 14617437 | Feb 2015 | US |
| Child | 15395809 | US | |
| Parent | 14201539 | Mar 2014 | US |
| Child | 14617437 | US | |
| Parent | 13762703 | Feb 2013 | US |
| Child | 14201539 | US | |
| Parent | 12958570 | Dec 2010 | US |
| Child | 13762703 | US |
