Patent Grant
11343108
Conventional secure communication techniques involve transmitting encrypted information over a channel such as an electrical transmission line, a fiber-optic cable, or through free space using electromagnetic waves. Such techniques make use of cryptographic methods utilizing shared secrets (i.e., a cryptographic key) between a sender and a receiver to ensure that only the intended parties can properly encode and decode a message. In some conventional approaches, the sender and receiver may share cryptographic tables or exchange information between them to arrive at a shared key. In such approaches the length of the shared keys used and the number of available keys will depend upon memory limitations and/or available communications bandwidth.
In an embodiment, a method includes receiving an initial instruction from a remote computing device using a client computing device having an addressable cryptographic table, retrieving first and second bitstreams having different lengths from the addressable cryptographic table by deriving addresses in the addressable cryptographic table from the initial instruction, accessing first and second bit values stored at addresses belonging to the derived addresses in the addressable cryptographic table, outputting the first bit values as the first bitstream and the second bit values as the second bitstream, concatenating the first bitstream with data from the first bitstream to form a data stream having a desired length, concatenating the second bitstream with data from the second bitstream to form a selector stream having the desired length, and forming a first composite encryption key having a length longer than a length of the first bitstream and the second bitstream by selecting values of the data stream identified by corresponding bit values of the selector stream.
In an embodiment, the method includes determining, as the different lengths of the first and second bitstream, two co-prime integers, and selecting a product of the different lengths as the desired length. In an embodiment, the method includes selecting a permutation instruction from a set of allowed permutation instructions defined in memory of the computing device, applying one or more permutation instructions or logical operations to the selector stream to produce additional selector streams, and forming additional composite encryption keys by selecting values of the data stream identified by corresponding values of respective additional selector strings. In an embodiment, applying the one or more permutation instructions or logical operations includes applying a unique permutation function that uniquely reorders values of the selector stream to produce each additional selector stream. In an embodiment, retrieving the first and second bitstreams from the addressable cryptographic table comprises measuring physical characteristics of physical unclonable function (“PUF”) devices of a PUF array of the computing device at addresses in the PUF array derived from the initial instruction. In an embodiment, measuring the physical characteristics of the PUF devices of the PUF array comprises repeatedly measuring each PUF device and returning values for each PUF device based on statistical characteristics of the repeated measurements of that PUF device. In an embodiment, the method includes encoding into the first composite encryption key an error correction code, and executing an error correction method on the first composite encryption key using parity bits, data helpers, response based cryptographic methods, ternary cryptography, and fuzzy extractors.
In an embodiment, a device includes a processor and a memory coupled to the processor. The memory stores instructions that, when executed by the processor, cause the processor to perform the steps of receiving an initial instruction from a remote computing device using a client computing device having an addressable cryptographic table, retrieving first and second bitstreams having different lengths from the addressable cryptographic table by deriving addresses in the addressable cryptographic table from the initial instruction, accessing first and second bit values stored at addresses belonging to the derived addresses in the addressable cryptographic table, outputting the first bit values as the first bitstream and the second bit values as the second bitstream, concatenating the first bitstream with data from the first bitstream to form a data stream having a desired length, concatenating the second bitstream with data from the second bitstream to form a selector stream having the desired length, and forming a first composite encryption key having a length longer than a length of the first bitstream and the second bitstream by selecting values of the data stream identified by corresponding bit values of the selector stream.
In an embodiment, a device includes a processor and a memory coupled to the processor. The memory stores instructions that, when executed by the processor, cause the processor to perform the steps of receiving an initial instruction from a remote computing device, retrieving first and second bitstreams having different lengths from an addressable cryptographic table by determining first and second bit values stored at addresses belonging to addresses derived from the initial instruction in the addressable cryptographic table, concatenating the first bitstream with data from the first bitstream to form a data stream having a desired length, concatenating the second bitstream with data from the second bitstream to form a selector stream having the desired length, and forming a first composite encryption key having a length longer than a length of the first bitstream and the second bitstream by selecting values of the data stream identified by corresponding bit values of the selector stream.
The above features and advantages of the present invention will be better understood from the following detailed description taken in conjunction with the accompanying drawings.
The drawings described herein constitute part of this specification and includes exemplary embodiments of the present invention which may be embodied in various forms. It is to be understood that in some instances, various aspects of the invention may be shown exaggerated or enlarged to facilitate an understanding of the invention. Therefore, drawings may not be to scale.
The described features, advantages, and characteristics may be combined in any suitable manner in one or more embodiments. One skilled in the relevant art will recognize that the circuit may be practiced without one or more of the specific features or advantages of a particular embodiment. In other instances, additional features and advantages may be recognized in certain embodiments that may not be present in all embodiments.
Reference throughout this specification to “one embodiment,” “an embodiment,” or similar language means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment. Thus appearances of the phrase “in one embodiment,” “in an embodiment,” and similar language throughout this specification may, but do not necessarily, all refer to the same embodiment.
Conventional encryption schemes using shared keys have disadvantages. In particular, the keys must be shared ahead of time and/or stored by both parties. It can be time consuming and resource-intensive to share and store large keys, particularly when it is desirable to use a larger number of keys (in polymorphic encryption schemes, for example). While known methods may be used to generate multiple longer keys from existing keys, the overall entropy of resulting encryption schemes may be reduced, compromising security.
Accordingly, the present disclosure describes systems and methods to generate numerous extended variable length cryptographic keys using shorter keys as inputs while preserving high levels of entropy. Private keys are generated using data in addressable cryptographic tables addressed using public keys. Extended length private keys may be derived from private keys such that the original private key space is obscured and new composite private keys do not repeat any patterns of the original private keys. One key is used as bit selector stream and the other key is used as a data stream to form the new composite private key. This invention extends the new composite private key space by the use of permutations and manipulations against the original bit selector stream. This results in no repetition across multiple composite private key spaces. Multiple composite keys can be produced from one data stream by applying permutations and other manipulations of the selector stream. Composite key generation performance may be optimized by using multiple ordered key pairs in parallel. This multi-threaded design improves the speed of key generation many times over by organizing the generation of composite keys around multiple key pairs in parallel. The composite key space is extended indefinitely by the use of key extensions as part of the encrypted payload. This has the impact of private key lengths that are as long as the data to be encrypted and decrypted.
In embodiments of the communication system 100B having the security circuitry 112B, the security circuitry 112B may include a dedicated PUF array. In such embodiments, the processing circuitry 110B may be configured to respond to an authentication challenge which specifies an address (or range of addresses) in the PUF array and a set of operations to perform in order to generate a unique response to the authentication challenge. Such embodiments may be designed to communicate with embodiments of communication system 100A configured to store security data 122A in the memory 120A. In such embodiments, the processing circuitry 110A is configured to generate authentication challenges and receive responses to those challenges. The responses and challenges may be saved as part of the security data 122A. In such embodiments the processing circuitry 110A may be further configured to send randomly-selected challenges to embodiments of communication system 100B having security circuitry 112B. In certain embodiments described herein, transmitting the challenges to communication system 100B allows communication systems 100A and 100B to agree upon the challenge responses as shared encryption keys without required information which might compromise the secrecy of those keys to be transmitted, as described below.
In some embodiments, the functionality of the cryptographic tables 210A,B may be realized by one party (e.g., “Bob”) having an array of physical unclonable function (PUF) devices (a “PUF array” and another party (e.g., “Alice) having access to information characterizing the PUF array. For purposes of this disclosure, a PUF array may be any array of devices having unique physical characteristics which may be used to identify a user or device in possession of the array. In practice, unique PUF arrays may be produced using known semiconductor or other mass production techniques with sufficient variability such that it is highly improbable that any two arrays produced using the same process will possess indistinguishable physical characteristics. Non-limiting examples of such characteristics are time delays of transistor-based ring oscillators and transistor threshold voltages. Other non-limiting examples include optical devices. For example, Bob may possess an optical PUF device which, when illuminated by a light source such as a laser produces a unique image due to minute manufacturing variations. This image may be digitized and the pixels may be used to form an addressable PUF array. Another example is an array of SRAM cells each of which will “default” to storing a ‘0’ or a ‘ 1’.
The measured characteristics of a PUF array (or a subset of devices in a PUF array) may not be perfectly deterministic to due to aging, thermal drift, or other causes. For example, some of the SRAM cells in an SRAM-based array may always store a ‘0’ or ‘ 1’ after a power cycle while others may oscillate between states. Non-deterministic devices may be dealt with in a number of ways. As one example, a system may repeatedly measure each device either before or in response to an attempt to read values of the devices. Devices whose measurements vary more than a threshold may be excluded and the system may store (or receive) instruction for substituting measurements of other devices in place of the “unreliable” devices. In other schemes, PUF devices may be measured repeatedly and assigned values based on statistical characteristics. For instance, devices that store a ‘0’ more than a certain percentage of the time may be assigned a ‘0’ value and devices that store ‘1’ more than a certain percentage of the time may be assigned a ‘1’ value. In some schemes devices that store a ‘0’ or ‘1’ may be assigned a third value as part of a ternary scheme in which reliable devices are assigned a ‘0’ or a ‘ 1’ while “unreliable” devices are assigned a third value. This concept may be extended to quaternary and other number systems. In some schemes, a device having a PUF array with potentially unreliable devices may store or otherwise receive error correction information such as parity and/or checksum data and may employ suitable error-correcting codes and other error-correction techniques. In an embodiment, error correction methods may be performed on the composite encryption key using parity bits, data helpers, response based cryptographic methods, ternary cryptography, and fuzzy extractors.
As above, it may be desirable in certain applications to generate very long encryption keys and/or to generate multiple encryption keys for use with polymorphic encryption schemes. However, the length of each encryption key 240 and the number of possible unique encryption keys 240 is limited by the sizes of the cryptographic tables 210A,B. While longer keys can be generating by exchanging multiple public keys this may be bandwidth intensive and introduce unacceptable latency.
As an example, a composite key generation method begins with two private keys that are on average 21.3 KB long. These private keys are unique and are generated using two unique public keys (e.g., two public keys 220) to retrieve values from a cryptographic table (e.g., a cryptographic table 210). In general, the composite key generation process requires the steps comprising: At a minimum, two or more unique private keys, denoted as K1, K2, . . . , KN, with respective lengths of L1, L2, . . . , LN bytes are selected. Each of the private keys must have different lengths wherein L1≠L2≠ . . . ≠LN and a greatest common denominator gcd(L1, L2, . . . , LN)=1. Because each of the private keys are based upon a randomly-selected public key, there will be no repeating predictable data patterns. The keys may also be derived from other cryptographic keys.
As illustrated by
For the selection of private key lengths, lengths L1 and L2 are typically selected to be prime numbers where L1≠L2. Thus, gcd(L1, L2)=1 always holds true. If unique primes run out in the key length ranges, then non-prime lengths may be used as long as gcd(L1, L2)=1. Based on mathematical number theory with the condition of gcd(L1, L2)=1, then the relative byte offset in each K1 and K2 are uniquely paired such that no same offset pairs will repeat during the scope of the S1 and D1 byte alignments. This will result in a composite bit stream with no repeating data patterns due to repeated byte pairings from the respective K1 and K2.
After the generation of C1, then on average the composite key length will L1×L2×50%. The 50% comes from the usage of selector streams with a uniform random distribution of ‘1’ values. Using two prime key lengths of 21,701 bytes and 21,683 bytes, then a single composite key length is on average 21,701×21,683×0.50 224.37 MB. These two example key lengths will be used for the remaining calculations in this text. The select modifiers uniquely extend the composite private keys, wherein each of the new composite key derivatives greatly expands the total composite key space. There are two distinct forms of select modifications: the permutation modifiers and the XOR modifiers. After the first composite private key C1 is formed by C1=generateComposite(S1, D1), then the composite key space is uniquely extended by use of permutation and data manipulation functions against every byte in the original S1 which forms the new derivative selector S2. The result is C2=generateComposite(S2, D1). As many unique derivatives SN are created, then the result is a corresponding number of unique CN derivatives. The original data stream, D1, is never changed for the initial pair of selector and data, (S1, D1).
Additional composite keys may be created by permuting values of the selector stream. A set of permutation operations may be defined and a system may store (or receive) instructions that determine which permutations to apply, in which order such that two communicating parties can independently generate the same additional selectors and thus generate identical sets of additional composite keys. We denote fundamental permutations by pk where k≥0. p0 (also referred to as the pass-through) is defined as p0[12345678]=12345678. For example, p0[0b11110000]=0b11110000. p1 (also referred to as the even-odd bit swap) is defined by p1[12345678]=21436587. For example, p1[0b10101010]=0b01010101. p2 is defined as p2[12345678]=34127856. For example, p2[0b00111100]=0b11000011.
Bit-rotate permutations are functions are denoted as bk where k>0 and #<8. b0 (also referred to as the bit-rotate pass-through) is defined by b0[12345678]=12345678. For example, b0[0b10110010]=0b10110010. b1[12345678]=23456781. For example, b1(0b10110010)=0b01100101. b2[12345678]=34567812. For example, b2[0b10110010]=0b11001010. For the base and bit-rotate permutations, these are classified as permutation function maps 1-byte (8-bits)→1-byte (8-bits). Mathematically, there are P(8,8)=8!/(8-8)!=40,320 different possible permutations. Thus far, there are chosen 50 different base permutations and for each there are 8 bit-rotate permutations. This results in a selection of 50×8=400 different byte permutations. In order to detect and remove any duplicate pe1 mutations, a program is used to verify permutation uniqueness for each base permutation and enumerate each bit rotate into a complete list. All of these 400 permutations are unique.
Additional permutation functions make use of the XOR function. Distinct from the permutation building blocks are a completely different class of functions for changing the selector bytes referred to as the XOR manipulation functions. In this class of manipulator functions, there are no permutations and consist of only individual bit changes. XOR functions are manipulation functions, denoted as xk where k≥0. The XOR function is denoted by the {circumflex over ( )} bit operator. Consider x0 (also referred to as the pass-through). Defined as x0(bits)=bits {circumflex over ( )} 0b00000000. For example, x0[0b11110000]=0b11110000{circumflex over ( )} 0b00000000=0b00001111. Consider x1. Defined as x1 [bits]=bits {circumflex over ( )}0b11111111. For example, x1[0b11110000)=0b11110000 {circumflex over ( )}0b11111111=0b00001111. Consider x2. Defined as x2[bits]=bits {circumflex over ( )}0b11011101. For example, x2[0b11110000]=0b11110000 {circumflex over ( )}0b11011101=0b00101101. For the XOR byte manipulation function, there are 28=256 different possibilities. So far, there are 128 XOR manipulation functions chosen for use in composite key generation. When the permutation and XOR manipulations are combined together, then this results in 50×8×128=51,200 different selector byte manipulations.
The set of basic permutation functions {p, b} may be combined with XOR-based manipulations. In this language, the initial formation of the first composite key is based upon a pass-through selector formed by selByte=b0[p0[x0[selByte] ] ] for every byte in the selector. Then, the composite key generation process continues in a very ordered manor, as shown in
Thus far, these permutation functions map are 1-byte (8-bits) at the input→1-byte (8-bits) at the output. However, the permutation mappings may be extended to include other input output mappings, like using adjacent bytes as inputs. Using a combination of the current byte and previous bytes, example mappings include: 2-byte (16-bits)→1-byte (8-bits) permutations. For example, where the previous byte bit positions ‘abcdefgh’ and the current byte bit positions ‘12345678’, then a new byte of ‘b2d4f6h8’ can be formed. The number of possible permutations is P(16,8)=16!/(16-8)!≈5.1×108. 3-byte (24-bits)→1-byte (8-bits) mappings yield P(24,8)=24!/(24-8)!≈2.9×1010 permutations. 4-byte (32-bits)→1-byte (8-bits) mappings yield P(32,8)=32!/(32-8)!≈4.2×1011 possible permutations. As the number of base permutations is increased from 50 to, for example, 1024, the composite key space expands substantially from 50×8×128=51,200 different selector byte manipulations to 1024×8×128=1,048,576, a twenty-fold increase. Hence, there is essentially no limit to the number of possible permutations.
Thus far, we have the discussed composite private keys based on a single ordered key pair such as C1=generateComposite(S1, D1), where S1=concatenateX(K1, L2) and D1=concatenateX(K2, L1). If the assignments are reversed between the K1 and K2, then C2=generateComposite(selector2, data2) where select2=concatenateX(K2, L1) and D2=concatenateX(K1, L2). Since the selector/data roles are reversed, then this results in unique C1 and C2 keys. Thus, the composite key length can be doubled by generating both concatenate(C1, C2). This results in 2×10.96 TB≈21.92 TB of total composite key space using just two unique K1 and K2 values. As N number of unique keys are added with gcd(len-i, len-j)=1 for all keys where len-i≠len-j, then there will be (N)×(N−1) unique ordered key pairs. As shown in
Initially, in any given encryption or decryption session, each of the public keys must be defined upfront. The number of public keys is set depending upon the desired total composite private key space and/or the amount of parallel ordered key pair generation worker threads, as discussed in more detail below.
The storage and communication of the public keys is largely dependent upon the use case. In the case of encryption/decryption applications, the two systems (i.e., the sender and receiver) may each have separately secured identical cryptographic tables and passwords, and they communicate an initial set of public keys and the encrypted file. The initial key exchange will be referenced as ‘KeySet1’. As the encryption and decryption is writing or reading the encrypted stream, the XOR encrypted data will be organized in logical “data blocks.” The size of the data blocks is implementation dependent. One possible implementation is to arrange the data blocks around the indices of the bN[pN[xN [selByte] ] ] calls that were described previously. The significance of these data blocks is that they will be used during the key extension process.
It is anticipated to use the composite private key space to encrypt very large amounts of data. Therefore, at some point, the last of the composite private key space may run out for the continuing XOR encryption process. At that point, new public and private key pairs (labeled as KeySetN′) have to be generated. If the encryption session begins with a KeySet1 exchange of N-keys, then each key extension must also include N keys. To exchange the new key extension KeySetN, then the associated public keys required to generate KeySetN will be embedded as part of the encrypted data payload, at the beginning of the last encrypted “data block” (
A creative way of generating the key space faster is to implement a threading algorithm that generates the composite key space in parallel. One such innovative threading algorithm is to organize the processing of ordered key pairs into separate threads.
We now formally prove that non-repeating byte alignments are generated by methods disclosed above. We begins with two private keys, K1 and K2, with respective lengths of L1 and L2, where L1≠L2 and gcd(L1, L2)=1. The keys K1 and K2 will be byte indexed using respective integer offsets r1 and r2, where 0≤r1<q1 and 0≤r2<q2. We form S1 by concatenating K1 with itself p2 times, so that the length of S1 is a total of q1×q2 bytes. We form D1 by concatenating K2 with itself q1 times, so that the data stream D1 has a total length of q1×q2 bytes. The streams S1 and D1 are aligned such that they are both indexed by the integer i offset, where O≤i<q1×q2.
Claim: Since the streams S1 and D1 are byte indexed by i, there exists unique byte index pairs r1 and r2 within the associated streams K1 and K2 for the entire indexed length of O≤i<q1 •q2.
Proof: By the Division Algorithm, there exists unique integers m and r1 such that i=m •q1+r1, where 0≤r1<q1 and 0≤i<q1×q2 and, there exists unique integers n and r2 such that i=n×q2+r2, where 0≤r2<q2 and 0≤i<q1×q2. It follows that r1=i mod q1 and r2=i mod p2. Then by definition of congruence, r1=i mod q1 ↔i=r1 mod q1 and r2=i mod q2 ↔i=r2 mod q2. Since gcd(q1, q2)=1 and by the Chinese Remainder Theorem, then there exists unique integers r1 and r2 for any integer i, modulo q1×q2. The overall significance of this claim is that the composite bytes generated from the streams S1 and D1 will not have duplicate composite bytes due to duplicate byte offset pairs from their respective source streams.
In an embodiment, a method includes receiving an initial instruction from a remote computing device using a client computing device having an addressable cryptographic table, retrieving first and second bitstreams having different lengths from the addressable cryptographic table by deriving addresses in the addressable cryptographic table from the initial instruction, accessing first and second bit values stored at addresses belonging to the derived addresses in the addressable cryptographic table, outputting the first bit values as the first bitstream and the second bit values as the second bitstream, concatenating the first bitstream with data from the first bitstream to form a data stream having a desired length, concatenating the second bitstream with data from the second bitstream to form a selector stream having the desired length, and forming a first composite encryption key having a length longer than a length of the first bitstream and the second bitstream by selecting values of the data stream identified by corresponding bit values of the selector stream.
In an embodiment, the method includes determining, as the different lengths of the first and second bitstream, two co-prime integers, and selecting a product of the different lengths as the desired length. In an embodiment, the method includes selecting a permutation instruction from a set of allowed permutation instructions defined in memory of the computing device, applying one or more permutation instructions or logical operations to the selector stream to produce additional selector streams, and forming additional composite encryption keys by selecting values of the data stream identified by corresponding values of respective additional selector strings. In an embodiment, applying the one or more permutation instructions or logical operations includes applying a unique permutation function that uniquely reorders values of the selector stream to produce each additional selector stream. In an embodiment, retrieving the first and second bitstreams from the addressable cryptographic table comprises measuring physical characteristics of physical unclonable function (“PUF”) devices of a PUF array of the computing device at addresses in the PUF array derived from the initial instruction. In an embodiment, measuring the physical characteristics of the PUF devices of the PUF array comprises repeatedly measuring each PUF device and returning values for each PUF device based on statistical characteristics of the repeated measurements of that PUF device. In an embodiment, the method includes encoding into the first composite encryption key an error correction code, and executing an error correction method on the first composite encryption key using parity bits, data helpers, response based cryptographic methods, ternary cryptography, and fuzzy extractors.
In an embodiment, a device includes a processor and a memory coupled to the processor. The memory stores instructions that, when executed by the processor, cause the processor to perform the steps of receiving an initial instruction from a remote computing device using a client computing device having an addressable cryptographic table, retrieving first and second bitstreams having different lengths from the addressable cryptographic table by deriving addresses in the addressable cryptographic table from the initial instruction, accessing first and second bit values stored at addresses belonging to the derived addresses in the addressable cryptographic table, outputting the first bit values as the first bitstream and the second bit values as the second bitstream, concatenating the first bitstream with data from the first bitstream to form a data stream having a desired length, concatenating the second bitstream with data from the second bitstream to form a selector stream having the desired length, and forming a first composite encryption key having a length longer than a length of the first bitstream and the second bitstream by selecting values of the data stream identified by corresponding bit values of the selector stream.
In an embodiment, a device includes a processor and a memory coupled to the processor. The memory stores instructions that, when executed by the processor, cause the processor to perform the steps of receiving an initial instruction from a remote computing device, retrieving first and second bitstreams having different lengths from an addressable cryptographic table by determining first and second bit values stored at addresses belonging to addresses derived from the initial instruction in the addressable cryptographic table, concatenating the first bitstream with data from the first bitstream to form a data stream having a desired length, concatenating the second bitstream with data from the second bitstream to form a selector stream having the desired length, and forming a first composite encryption key having a length longer than a length of the first bitstream and the second bitstream by selecting values of the data stream identified by corresponding bit values of the selector stream.
The described features, advantages, and characteristics may be combined in any suitable manner in one or more embodiments. One skilled in the relevant art will recognize that the circuit may be practiced without one or more of the specific features or advantages of a particular embodiment. In other instances, additional features and advantages may be recognized in certain embodiments that may not be present in all embodiments.
Reference throughout this specification to “one embodiment,” “an embodiment,” or similar language means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment. Thus appearances of the phrase “in one embodiment,” “in an embodiment,” and similar language throughout this specification may, but do not necessarily, all refer to the same embodiment.
The present application claims priority to U.S. Provisional Application 62/860,474 entitled “Generation of Composite Private Keys” and filed on Jun. 12, 2019.
| Number | Name | Date | Kind |
|---|---|---|---|
| 5434917 | Naccache et al. | Jul 1995 | A |
| 8300450 | Christensen et al. | Oct 2012 | B2 |
| 10320573 | Cambou | Jun 2019 | B2 |
| 20030210783 | Filippi | Nov 2003 | A1 |
| 20080044027 | Van Dijk | Feb 2008 | A1 |
| 20110103161 | Tuyls | May 2011 | A1 |
| 20120128151 | Boehm | May 2012 | A1 |
| 20120131340 | Teuwen | May 2012 | A1 |
| 20120183135 | Paral et al. | Jul 2012 | A1 |
| 20120265928 | Mun et al. | Oct 2012 | A1 |
| 20130156183 | Komano | Jun 2013 | A1 |
| 20140093074 | Gotze | Apr 2014 | A1 |
| 20150007337 | Krutzik | Jan 2015 | A1 |
| 20150071432 | Zhu et al. | Mar 2015 | A1 |
| 20150195088 | Rostami et al. | Jul 2015 | A1 |
| 20150234751 | Van Der Sluis | Aug 2015 | A1 |
| 20160042628 | Roston | Feb 2016 | A1 |
| 20160078252 | Chandra | Mar 2016 | A1 |
| 20170017808 | Kwong | Jan 2017 | A1 |
| 20170046129 | Cambou | Feb 2017 | A1 |
| 20180129801 | Cambou | May 2018 | A1 |
| 20180145838 | Wang | May 2018 | A1 |
| 20180176012 | Hung | Jun 2018 | A1 |
| 20180278418 | Chang | Sep 2018 | A1 |
| 20180329962 | Schrijen | Nov 2018 | A1 |
| 20190165956 | Adham | May 2019 | A1 |
| 20190280858 | Cambou | Sep 2019 | A1 |
| 20200382293 | Cambou | Dec 2020 | A1 |
| 20210281432 | Cambou | Sep 2021 | A1 |
| 20210399905 | Kwak | Dec 2021 | A1 |
| Number | Date | Country |
|---|---|---|
| 2015105687 | Jul 2015 | WO |
| WO-2019140218 | Jul 2019 | WO |
| Number | Date | Country | |
|---|---|---|---|
| 20200396091 A1 | Dec 2020 | US |
| Number | Date | Country | |
|---|---|---|---|
| 62860474 | Jun 2019 | US |
