Patent Application
20220058022
The present invention relates broadly to protecting the privacy of computer and machine instructions, information and devices. The processes and device are generally used to maintain the privacy of information transmitted through communication and transmission systems, and maintain the privacy of the computer instructions. For example, the hiding processes may be used to protect the metadata of a phone call; in some embodiments, the phone call may be transmitted via voice over IP (internet protocol) with a mobile phone. These processes and devices also may be used to hide passive data stored on a computer or another physical device such as a tape drive. In some embodiments, symmetric cryptographic methods and machines are also used to supplement the hiding process.
In an embodiment, the information (data) is hidden by a sending agent, called Alice. Alice transmits the hidden data to a receiving agent, called Bob. The receiving agent, Bob, applies an extraction process or device. The output of this extraction process or device is the same information (data) that Alice gathered before hiding and sending it. Eve is the name of the agent who is attempting to obtain the information or data. One of Alice and Bob's primary objectives is to assure that Eve cannot capture the private information that was hidden and transmitted between them.
In another embodiment, Alice desires to hide data and securely store the hidden data somewhere and retrieve it and access the hidden data at a later time. The output of this extraction process or device is the same information (data) that Alice gathered before hiding and storing it.
In some embodiments of our invention we describe computing machine that is structurally stable to small changes made to its program instructions. Our procedures use quantum randomness to build unpredictable stable instructions and use quantum randomness to generate noise such that the program instructions are hidden in the noise. In some embodiments, our procedures can execute just before running a program so that the computing task can be performed with a different representation of its program instructions during each run. In some embodiments, our invention expands the engineering method of stability to a cryptographically stable machine with an adversary; our invention describes cryptographically stable computing machines that are resistant to malware sabotage.
The subject matter discussed in this background section should not be assumed to be prior art merely as a result of its mention in the background section. Similarly, a problem mentioned in the background section or associated with the subject matter of the background section should not be assumed to have been previously recognized in the prior art. The subject matter in the “Summary and some Advantages of Invention” section represents different approaches, which in and of themselves may also be inventions, and various problems, which may have been first recognized by the inventor.
In information security, a fundamental problem is for a sender, Alice, to securely transmit a message M to a receiver, Bob, so that the adversary, Eve, receives no information about the message. In Shannon's seminal paper [2], his model assumes that Eve has complete access to a public, noiseless channel: Eve sees an identical copy of ciphertext C that Bob receives, where C(M, K) is a function of message M lying in message space and secret key K lying in key space
.
In this specification, the symbol P will express a probability. The expression P(E) is the probability that event E occurs and it satisfies 0≤P(E)≤1. For example, suppose the sample space is the 6 faces of die and E is the event of rolling a 1 or 5 with that die and each of the 6 faces is equally likely. Then P(E)=2/6=1/3. The conditional probability
P(A∩B) is the probability that event A occurs and also event B occurs. The conditional probability P(A|B) expresses the probability that event A will occur, under the condition that someone knows event B already occurred. The expression that follows the symbol “|” represents the conditional event. Events A and B are independent if P(A∩B)=P(A)P(B).
Expressed in terms of conditional probabilities, Shannon [2] defined a cryptographic method to be perfectly secret if P(M)=P(M|Eve sees ciphertext C) for every cipher text C and for every message M in the message space . In other words, Eve has no more information about what the message M is after Eve sees ciphertext C pass through the public channel. Shannon showed for a noiseless, public channel that the entropy of the keyspace
must be at least as large as the message space
in order to achieve perfect
secrecy.
Shannon's communication secrecy model [2] assumes that message sizes in the message space are finite and the same size. Shannon's model assumes that the transformations (encryption methods) on the message space are invertible and map a message of one size to the same size. Shannon's model assumes that the transformation applied to the message is based on the key. In the prior art, there is no use of random noise that is independent of the message or the key. In the prior art, there is no notion of being able to send a hidden or encrypted message inside the random noise where Eve is not necessarily revealed the size of the message. In the prior art, there is no notion of using random noise to hide the secret channel and transmitting a key inside this channel that is indistinguishable from the noise.
Quantum cryptography was introduced by Weisner and eventually published by Bennett, Brassard, et al. [3, 4]. Quantum cryptography based on the uncertainty principle of quantum physics: by measuring one component of the polarization of a photon, Eve irreversibly loses her ability to measure the orthogonal component of the polarization. Unfortunately, this type of cryptography requires an expensive physical infrastructure that is challenging to implement over long distances [5, 6]. Furthermore, Alice and Bob still need a shared, authentication secret to successfully perform this quantum cryptography in order to assure that Eve cannot corrupt messages about the polarization bases, communicated on Alice and Bob's public channel.
Malware plays a critical role in breaching computer systems. Cybersecurity research has primarily focused on malware detection [7, 8, 9, 10]. It is unlikely that malware detection methods can solely provide an adequate solution to the malware problem: There does not exist a register machine algorithm that can detect all malware [11]. Furthermore, some recent malware implementations use NP problems [12] to encrypt and hide the malware [13]. Overall, detection methods are currently up against fundamental limits in theoretical computer science [14].
During a 20 year study, the DARPA program, CRASH [15], compared the number of lines of source code in security software versus malware. Security code grew from about 10,000 to 10 million lines; while malware code was almost constant at 125 lines. This study found that an almost constant number of lines of malware code can hijack a computer program, independent of the security software's size.
The instability of register machine [16, 17] computers enables malware to sabotage the purpose of a computer program, by making small changes to one or more instructions in an original, uninfected program. Programming languages such as C, Java, Lisp and Python rely upon branching instructions. After a branching instruction of a register machine program has been sabotaged, the malware can start executing. Even if there is a routine (in hardware and/or software) to verify that the program is executing properly, this verification routine may never execute. The sequential execution of unstable register machine instructions cripples the program from protecting itself.
The prior art in mathematical research, computer science, and electrical engineering has not attempted to design malware resistant computation based on structural stability. For over 80 years, dynamical systems has extensively studied structural stability [18, 19, 20, 21] on phase spaces [22], containing an uncountable number of states. (A space X is uncountable [23] if X contains an infinite number of states and there does not exist a one-to-one correspondence between X and the natural numbers ={0, 1, 2, 3, 4, 5, 6, 7, . . . ,}.)
During the execution of a register machine [16, 17], the machine's state at any moment lies in a discrete space, containing a countable number of states. (A space X is countable if there exists a one-to-one correspondence between X and ) Based on dynamical systems and information theory, a novelty of our invention(s) introduces mathematical and computational tools to build a structurally stable sequential machine. Structurally stable means the sequential machine is resistant to small changes to the program instructions. Our invention(s) are inspired by the Red Queen hypothesis [24] in evolutionary biology: organisms evolve using robustness, unpredictability and variability to hinder infection from parasites. In some embodiments, a novel part of our invention(s) expands the engineering method of stability to a cryptographically stable machine with an adversary; our invention describes cryptographically stable computing machines that are resistant to malware sabotage.
In some parts of the prior art, conventional wisdom believes that hiding data in the open cannot provide adequate information security. The invention(s), described herein, demonstrate that our process of hiding data inside noise or hiding machine instructions inside noise can be quite effective. A process for hiding machine instructions inside of random noise is demonstrated and described. A process for hiding data inside of random noise is also demonstrated and described. In some embodiments, the data hidden is a key. In some embodiments, the data hidden is a public key. In some embodiments, the data hidden is encrypted data. In some embodiments, the data hidden is encrypted data that was first encrypted by a block cipher. In some embodiments, the instructions hidden are hidden instructions that were first encrypted by a block cipher. In some embodiments, the data hidden is encrypted data that was first encrypted by a stream cipher. In some embodiments, the hidden data may be hidden metadata that is associated with the TCP/IP infrastructure [1] used to transmit information.
The invention(s) described herein are not bound to Shannon's limitations [2] because they use noise, rather than seek to eliminate noise. When the data generation and random noise have the same probability distribution or both have a uniform probability distribution, and the key size is fixed, the security of the key transmission can be made arbitrarily close to perfect secrecy—where arbitrarily close is defined in section 10.11—by increasing the noise size. The processes, devices and machines described herein are practical; they can be implemented with current TCP/IP infrastructure acting as a transmission medium and a random noise generator providing the random noise and key generation.
Overall, our invention(s) that hide machine instructions (opcodes and operands), data and keys inside random noise exhibits the following favorable security properties.
Fully homomorphic encryption (FHE) [25] is a method for protecting Alice's computations on data in the cloud. FHE DOES NOT address the protection of the computer's operations that stores the private FHE key. In other words, FHE defers the malware problem to the user's local computer; FHE does not address how to hinder malware on the local computer. Furthermore, some FHE keys are 1 Gigabyte and the plaintextto-ciphertext expansion is 10,000 to 1 for just 100 bits of security [26, 27]. These memory requirements are not economically feasible for protecting instructions in hardware.
In [28], they present a general approach to addressing code-injection attacks in scripting and interpreted languages (e.g., web-based SQL injection), by randomizing the instructions. In [28], they do not address malware attacks at the machine instruction (physical hardware) level; there is no notion nor use of stability to build instruction opcodes and operands that are resistant to small changes.
Secure multi-party computation (MPC) [29, 30] enables a group to jointly perform a computation without disclosing any participant's private inputs. MPC does not address when Alice does not trust her own machine, or the machine instructions executed on her machine. Overall, none of these prior art methods address the malware problem, described in section 4.
In the prior art, register machines execute one instruction at a time [17, 16]. Even if there is a procedure to assure that the register machine program is executing correctly, this friendly procedure may never execute due to just one rogue branch instruction. Typical programming languages (e.g., C, Fortran, Java, Lisp and Python) are Turing complete and depend upon branching instructions. While conditional branching instructions are not required for universal computation, Rojas's methods [31] still use unconditional branching and program self-modification. Moreover, about 75% to 80% of the control flow instructions, executed on register machines, are conditional branch instructions. (See figure A.14 in [17].)
These observations suggest that a computer program's purpose can be subverted because the register machine behavior is not always invariant when small changes are made to one or more instructions. In contrast, the nervous systems of some organisms do not seem to share this weakness [32, 33].
Overall, the purpose of our invention(s) of stable computation are based on the following design principle: if a small or moderate change is made to a register machine program, then the program's purpose is stable; if a large change is made, the program can no longer execute. Our principle is partly based on the observation that it is generally far more difficult to detect if a small change has altered the purpose of a program. With a small change, the tampered register machine program still can execute, but does not perform the task that the original program was designed to accomplish. (Our unstable C program provides an example of a small 1-bit change.) For this reason, our invention(s) create stable computation that is also incomprehensible to malware authors so that it is far more challenging for malware to subvert the program without completely destroying its functionality.
We demonstrate unstable computation with C source code [34] that adds 3 integers. This C code shows how small changes to the address of only one instruction can substantially alter the program's behavior.
In the following figures, although they may depict various examples of the invention, the invention is not limited to the examples depicted in the figures.
.
for n=64, n=128, and n=256.
In this specification, the term “data” is broad and refers to any kind of information. In some embodiments, data may refer to plaintext information. In some embodiments, data may refer to voice information, transmitted with a landline phone or mobile phone. In some embodiments, data may refer to metadata. In some embodiments, data may refer to email or other information available on the Internet. In some embodiments, data may refer to the information in a sequence of values. In some embodiments, data may refer to the information in a sequence of bit values. In some embodiments, data may refer to the information in a sequence of numbers. In some embodiments, data may refer to the information in a sequence or collection of physical values or physical measurements. In some embodiments, data may refer to the information in a physical location (e.g., GPS coordinates of an auto or a mailing address in Venezia, Italia) or to the information in an abstract location—for example, a computer memory address or a virtual address. In some embodiments, data may refer to the information contained in Shakespeare's King Lear or Dostoevsky's Grand Inquisitor or Euclid's Elements. In some embodiments, data may refer to the information in Kepler's astronomical measurements or a collection of geophysical measurements. In some embodiments, data may refer to the information in to a sequence of times or collection of times. In some embodiments, data may refer to the information in statistical data such as economic or insurance information. In some embodiments, data may refer to medical information (e.g., an incurable cancer diagnosis) or genetic information (e.g., that a person has the amino acid substitution causing sickle cell anemia). In some embodiments, data may refer to the information in a photograph of friends or family or satellite photos. In some embodiments, data may refer to the information in a code or sequence of codes. In some embodiments, data may refer to the information in a sequence of language symbols for a language that has not yet been discovered or designed. In some embodiments, data may refer to financial information—for example, data may refer to a bid quote on a financial security, or an ask quote on a financial security. In some embodiments, data may refer to information about a machine or a collection of machines—for example, an electrical grid or a power plant. In some embodiments, data may refer to what electrical engineers sometimes call signal in information theory. In some embodiments, data may refer to a cryptographic key. In some embodiments, data may refer to a sequence or collection of computer program instructions (e.g., native machine instructions or source code information). In some embodiments, data may refer to a prime number or a mathematical formula or a mathematical invariant information. In some embodiments, data may refer to an internet protocol address or internet traffic information. In some embodiments, data may refer to a combination or amalgamation or synthesis of one or more of these types of aforementioned information.
In this specification, the term “noise” is information that is distinct from data and has a different purpose. Noise is information that helps hide the data so that the noise hinders the adversary Eve from finding or obtaining the data. This hiding of the data helps maintain the privacy of the data. In some embodiments, hiding the data means rearranging or permuting the data inside the noise. An example of data is a key. Hiding a key inside noise helps protect the privacy of the key; the key may subsequently help execute a cryptographic algorithm by a first party (e.g., Alice) or a second party (e.g., Bob).
In this specification, the term “location” may refer to geographic locations and/or storage locations. A particular storage location may be a collection of contiguous and/or noncontiguous locations on one or more machine readable media. Two different storage locations may refer to two different sets of locations on one or more machine-readable media in which the locations of one set may be intermingled with the locations of the other set.
In this specification, the term “machine-readable medium” refers to any non-transitory medium capable of carrying or conveying information that is readable by a machine. One example of a machine-readable medium is a computer-readable medium. Another example of a machine-readable medium is paper having holes that are detected that trigger different mechanical, electrical, and/or logic responses. The term machine-readable medium also includes media that carry information while the information is in transit from one location to another, such as copper wire and/or optical fiber and/or the atmosphere and/or outer space.
In this specification, the term “process” refers to a series of one or more operations. In an embodiment, “process” may also include operations or effects that are best described as non-deterministic. In an embodiment, “process” may include some operations that can be executed by a digital computer program and some physical effects that are non-deterministic, which cannot be executed by a digital computer program and cannot be performed by a finite sequence of processor instructions.
In this specification, the machine-implemented processes implement algorithms and non-deterministic processes on a machine. The formal notion of “algorithm” was introduced in Turing's work [36] and refers to a finite machine that executes a finite number of instructions with finite memory. In other words, an algorithm can be executed with a finite number of machine instructions on a processor. “Algorithm” is a deterministic process in the following sense: if the finite machine is completely known and the input to the machine is known, then the future behavior of the machine can be determined. However, there is quantum random number generator (QRNG) hardware (
Some examples of physically non-deterministic processes are as follows. In some embodiments that utilize non-determinism, photons strike a semitransparent mirror and can take two or more paths in space. In one embodiment, if the photon is reflected by the semitransparent mirror, then it takes on one bit value b∈{0, 1}; if the photon passes through by the semitransparent mirror, then the non-deterministic process produces another bit value 1−b. In another embodiment, the spin of an electron may be sampled to generate the next non-deterministic bit. In still another embodiment, a protein, composed of amino acids, spanning a cell membrane or artificial membrane, that has two or more conformations can be used to detect non-determinism: the protein conformation sampled may be used to generate a non-deterministic value in {0, . . . n−1} where the protein has n distinct conformations. In an alternative embodiment, one or more rhodopsin proteins could be used to detect the arrival times of photons and the differences of arrival times could generate non-deterministic bits. In some embodiments, a Geiger counter may be used to sample non-determinism.
In this specification, the term “photodetector” refers to any type of device or physical object that detects or absorbs photons. A photodiode is an embodiment of a photodetector. A phototransistor is an embodiment of a photodetector. A rhodopsin protein is an embodiment of a photodetector.
In this specification, the term “key” is a type of information and is a value or collection of values to which one or more operations are performed. In some embodiments, one or more of these operations are cryptographic operations. {0,1}n is the set of all bit-strings of length n. When a key is represented with bits, mathematically a n-bit key is an element of the collection {0, 1}n which is the collection of strings of 0's and 1's of length n. For example, the string of 0's and 1's that starts after this colon is a 128-bit key: 01100001 11000110 01010011 01110001 11000101 10001110 11011001 11010101 01011001 01100100 10110010 10101010 01101101 10000111 10101011 00010111. In an embodiment, n=3000 so that a key is a string of 3000 bits.
In other embodiments, a key may be a sequence of values that are not represented as bits. Consider the set {A, B, C, D, E}. For example, the string that starts after this colon is a 40-symbol key selected from the set {A, B, C, D, E}: ACDEB AADBC EAEBB AAECB ADDCB BDCCE ACECB EACAE. In an embodiment, a key could be a string of length n selected from {A, B, C, D, E}n. In an embodiment, n=700 so that the key is a string of 700 symbols where each symbol is selected from {A, B, C, D, E}.
In some embodiments, a key is a collection of one or more values, that specifies how a particular encryption function will encrypt a message. For example, a key may be a sequence of 0's and 1's that are bitwise exclusive-or'ed with the bits that comprise a message to form the encrypted message.
In some embodiments, hidden data (key) 109 in
In another embodiment, a key may be a sequence of values that a block cipher reads as input in order to encrypt a message with the block cipher encryption algorithm ε. In another embodiment, a key may be a sequence of values that a block cipher reads as input in order to decrypt an encrypted messsage with the block cipher's decryption algorithm . If Eve does not know that key, then it is difficult for Eve to decrypt the encrypted message ε(K, M). AES [39] is a common block cipher algorithm that reads 256-bit keys as input. Serpent [40] is also a block cipher algorithm that reads 256-bit keys as input.
In other embodiments, the key be a public key. In some embodiments, a key may refer to a public key for the RSA public-key algorithm [41]. In this case, a key is a huge prime number. In some embodiments, random generator 128 generates a key that is subsequently hidden by scatter map instructions 130.
Information system 100 may be a system for transmitting hidden data. Data 104 refers to information that has a purpose and that has not been hidden yet. In some embodiments, data is intended to be delivered to another location, software unit, machine, person, or other entity.
In some embodiments, data 104 is voice metadata that has not yet been hidden. Voice metadata may contain the IP address of the sending (calling) phone and also the IP address of the receiving phone. Voice metadata may contain the time of the call and the date. Some embodiments of a mobile phone are shown in
In an embodiment, data may be unhidden information being transmitted wirelessly between satellites. Data may be represented in analog form in some embodiments and may be represented in digital form. In an embodiment, the sound waves transmitted from a speaker's mouth into a mobile phone microphone are data. The representation of this data information before reaching the microphone is in analog form. Subsequently, the data information may be digitally sampled so it is represented digitally after being received by the mobile phone microphone. In general, data herein refers to any kind of information that has not been hidden or encrypted and that has a purpose.
In information system 100, noise helps hide the data. It may be desirable to keep the contents of data 104 private or secret. Consequently, it may be desirable to hide data 104, so that the transmitted information is expected to be unintelligible to an unintended recipient should the unintended recipient attempt to read and/or extract the hidden data transmitted. Data 104 may be a collection of multiple, not yet hidden information blocks, an entire message of data, a segment of data (information), or any other portion of a data.
Hiding process 106 may be a series of steps that are performed on data 104. In one embodiment, the term “process” refers to one or more instructions for sending machine 102 to execute the series of operations that may be stored on a machine-readable medium. Alternatively, the process may be carried out by and therefore refer to hardware (e.g., logic circuits) or may be a combination of instructions stored on a machine-readable medium and hardware that cause the operations to be executed by sending machine 102 or receiving machine 112. Data 104 may be input for hiding process 106. The steps that are included in hiding process 106 may include one or more mathematical operations and/or one or more other operations.
As a post-processing step, one-way hash function 948 may be applied to a sequence of random events such as quantum events (non-deterministic) generated by non-deterministic generator 942 in
In
In some embodiments, as shown in
In some embodiments, hiding process 106 requests random generator 128 to help generate one or more keys (shown in cipher instructions 129) for encrypting at least part of data 104. In an embodiment, non-deterministic generator 942 (
Sending machine 102 may be an information machine that handles information at or is associated with a first location, software unit, machine, person, sender, or other entity. Sending machine 102 may be a computer, a phone, a mobile phone, a telegraph, a satellite, or another type of electronic device, a mechanical device, or other kind of machine that sends information. Sending machine 102 may include one or more processors and/or may include specialized circuitry for handling information. Sending machine 102 may receive data 104 from another source (e.g., a transducer such as a microphone which is inside mobile phone 402 or 502 of
Sending machine 102 may implement any of the hiding processes described in this specification. Hiding process 106 may include any of the hiding processes described in this specification. For example, hiding process 106 may implement any of the embodiments of the hiding processes 1 or 3, as described in section 10.7; hiding process 106 may implement any of the embodiments of the hiding process 5, as described in section 10.12; hiding process 106 may implement any of the embodiments of the hiding processes 6 or 7, as described in section 10.13; hiding process 106 may implement any of the embodiments of the hiding processes 8 or 9, as described in section 10.15. In some embodiments, hidden data 132, shown in
Transmission path 110 is the path taken by hidden data 109 to reach the destination to which hidden data 109 was sent. Transmission path 110 may include one or more networks, as shown in
Receiving machine 112 may be an information machine that handles information at the destination of an hidden data 109. Receiving machine 112 may be a computer, a phone, a telegraph, a router, a satellite, or another type of electronic device, a mechanical device, or other kind of machine that receives information. Receiving machine 112 may include one or more processors and/or specialized circuitry configured for handling information, such as hidden data 109. Receiving machine 112 may receive hidden data 109 from another source and/or reconstitute (e.g., extract) all or part of hidden data 109. Receiving machine 112 may implement any of the hiding processes described in this specification and is capable of extracting any message hidden by sending machine 102 and hiding process 106.
In one embodiment, receiving machine 112 only receives hidden data 109 from transmission path 110, while hiding process 106 is implemented manually and/or by another information machine. In another embodiment, receiving machine 112 implements extraction process 116 that reproduces all or part of data 104, referred to as extracted data 114 in
Receiving machine 112 may be identical to sending machine 102. For example, receiving machine 112 may receive data 104 from another source, produce all or part of data 104, and/or implement hiding process 106. Similar to sending machine 102, receiving machine 112 may create keys and random noise and random data. Receiving machine 112 may transmit the output of extraction process 116, via transmission path 110 to another entity and/or receive hidden data 109 (via transmission path 110) from another entity. Receiving machine 112 may present hidden data 109 for use as input to extraction process 116.
In this specification, the term “public key” refers to any kind of public key used in public key cryptography. In an embodiment, “public key” refers to an RSA public key. In an embodiment, “public key” refers to an elliptic curve public key. In an embodiment, “public key” refers to a lattice public key. In an embodiment, “public key” refers to a Goppa code public key.
In this specification, the term “public key” is a type of information and is a value or collection of values to which one or more operations are performed. In some embodiments, one or more of these operations are cryptographic operations. {0, 1}n is the set of all bit-strings of length n. When a public key is represented with bits, mathematically a n-bit key is an element of the collection {0, 1}n which is the collection of strings of 0's and 1's of length n. For example, the string of 0's and 1's that starts after this colon is a 128-bit key: 01100001 11000110 01010011 01110001 11000101 10001110 11011001 11010101 01011001 01100100 10110010 10101010 01101101 10000111 10101011 00010111. In an embodiment, n=3000 so that a key is a string of 3000 bits.
In other embodiments, a public key may be a sequence of values that are not represented as bits. Consider the set {A, B, C, D, E}. For example, the string that starts after this colon is a 40-symbol key selected from the set {A, B, C, D, E}: ACDEB AADBC EAEBB AAECB ADDCB BDCCE ACECB EACAE. In an embodiment, a key could be a string of length n selected from {A, B, C, D, E}n. In an embodiment, n=700 so that the key is a string of 700 symbols where each symbol is selected from {A, B, C, D, E}.
In some embodiments, hidden public key(s) 149 in
In some embodiments, public key(s) 144 are RSA public key(s), which is a well-known public key cryptography [41]. RSA is described from the perspective of Alice. Alice chooses two huge primes pA and qA. Alice computes nA=pAqA and a random number rA which has no common factor with (pA−1)(qA−1). In other words, 1 is the greatest common divisor of rA and (pA−1)(qA−1). The Euler-phi function is defined as follows. If k=1, then ϕ(k)=1; if k>1, then ϕ(k) is the number positive integers i such that i<k and i and k are relatively prime. Relatively prime means the greatest common divisor of i and k is 1. The positive integer eA is randomly selected such that eA is relatively prime to ϕ(nA).
Alice computes ϕ(nA)=nA+1−pA−qA. Alice computes the multiplicative inverse of rA modulo ϕ(nA); the multiplicative inverse is dA=eA−1 modulo ϕ(nA). Alice makes public her public key (nA, rA): that is, the two positive integers (nA, rA) are Alice's public key.
In an embodiment, random generator 168 generates r1 . . . rρ which is input to private key instructions 164. In an embodiment that hides RSA public keys, private key instruction 164 use r1 . . . rρ to find two huge primes pA and qA and a random number rA relatively prime to (pA−1)(qA−1).
In an embodiment, random generator 168 and private key instructions 164 generate two huge primes pA and qA; compute nA=pAqA; and randomly choose eA that is relatively prime to ϕ(nA). In an embodiment, private key instructions 164 compute dA=eA−1 modulo o(nA). In an embodiment, an RSA private key is (nA, dA). In an embodiment that hides RSA public keys, public key instructions 166 compute RSA public key (nA, rA). In an embodiment, positive integer nA is a string of 4096 bits and rA is a string of 4096 bits.
Information system 140 may be a system for transmitting hidden public key(s). Public key(s) 144 refers to information that has a purpose and that has not been hidden yet. In some embodiments, public key(s) 144 is intended to be delivered to another location, software unit, machine, person, or other entity.
In some embodiments, public key(s) 144 may serve as part of a key exchange that has not yet been hidden. In an embodiment, public key(s) 144 may be unhidden information before it is hidden and transmitted wirelessly between satellites. Public key(s) 144 may be represented in analog form in some embodiments and may be represented in digital form. In an embodiment, the public key(s) may be one or more RSA public keys based on huge prime numbers. In an another embodiment, the public key(s) may be one or more elliptic curve public keys, computed from an elliptic curve over a finite field.
In information system 140, noise helps hide public key(s) 144. Although they are public, it may be desirable to keep public key(s) 144 private or secret from Eve. For example, it is known that Shor's quantum computing algorithm [62] can compute in polynomial time the corresponding private key of a RSA public key. As another example, an analogue of Shor's algorithm [63] can compute in polynomial time the corresponding private key of an elliptic curve public key. If Eve has a quantum computer that computes enough qubits, then Eve could find the private key of an RSA public key that is disclosed to Eve and consequently breach the security of information system 140. One or more RSA public keys could be hidden in noise to protect them from Eve's quantum computer. Consequently, it may be desirable to hide public key(s) 144, so that the transmitted information is expected to be unintelligible to an unintended recipient should the unintended recipient attempt to read and/or extract the hidden public key(s) 149 transmitted. Public key(s) 144 may be a collection of multiple, not yet hidden blocks of information, an entire sequence of public keys, a segment of public keys, or any other portion of one or more public keys. When there is more than one public key, public keys 144 may be computed from distinct commutative groups, as described in section 10.16. For example, one commutative group may be based on an elliptic curve over a finite field; another commutative group may be based on multiplication modulo, as used in RSA.
Hiding process 146 may be a series of steps that are performed on public keys 144. In one embodiment, the term “process” refers to one or more instructions for sending machine 142 to execute the series of operations that may be stored on a machine-readable medium. Alternatively, the process may be carried out by and therefore refer to hardware (e.g., logic circuits) or may be a combination of instructions stored on a machine-readable medium and hardware that cause the operations to be executed by sending machine 142 or receiving machine 152. Public key(s) 144 may be input for hiding process 146. The steps that are included in hiding process 146 may include one or more mathematical operations and/or one or more other operations.
As a post-processing step, one-way hash function 948 may be applied to a sequence of random events such as quantum events (non-deterministic) generated by non-deterministic generator 942 in
In
Sending machine 142 may be an information machine that handles information at or is associated with a first location, software unit, machine, person, sender, or other entity. Sending machine 142 may be a computer, a phone, a mobile phone, a telegraph, a satellite, or another type of electronic device, a mechanical device, or other kind of machine that sends information. Sending machine 142 may include one or more processors and/or may include specialized circuitry for handling information. Sending machine 142 may receive public key(s) 144 from another source (e.g., a transducer such as a microphone which is inside mobile phone 402 or 502 of
Sending machine 142 may implement any of the hiding processes described in this specification. Hiding process 146 may include any of the hiding processes described in this specification. For example, hiding process 146 may implement any of the embodiments of the hiding processes 3 in section 10.7 and processes 10, 11 in section 10.17.
In some embodiments, hiding process 162, shown in
Transmission path 150 is the path taken by hidden public key(s) 149 to reach the destination to which hidden public key(s) 149 was sent. Transmission path 150 may include one or more networks, as shown in
Receiving machine 152 may be an information machine that handles information at the destination of an hidden public key(s) 149. Receiving machine 152 may be a computer, a phone, a telegraph, a router, a satellite, or another type of electronic device, a mechanical device, or other kind of machine that receives information. Receiving machine 152 may include one or more processors and/or specialized circuitry configured for handling information, such as hidden public key(s) 149. Receiving machine 152 may receive hidden public key(s) 149 from another source and/or reconstitute (e.g., extract) all or part of hidden public key(s) 149. Receiving machine 152 may implement any of the hiding processes described in this specification and is capable of extracting any message hidden by sending machine 142 and hiding process 146.
In one embodiment, receiving machine 152 only receives hidden public key 149 from transmission path 150, while hiding process 146 is implemented manually and/or by another information machine. In another embodiment, receiving machine 152 implements extraction process 156 that reproduces all or part of public key(s) 144, referred to as extracted public key(s) 154 in
Receiving machine 152 may be identical to sending machine 142. For example, receiving machine 152 may receive 144 from another source, produce all or part of public key(s) 144, and/or implement hiding process 146. Similar to sending machine 142, receiving machine 152 may create keys and random noise and random public key(s). Receiving machine 152 may transmit the output of extraction process 156, via transmission path 150 to another entity and/or receive hidden public key(s) 149 (via transmission path 150) from another entity. Receiving machine 152 may present hidden public key(s) 149 for use as input to extraction process 156.
Information system 200 illustrates some of the variations of the manners of implementing information system 100. Sending machine 202 is one embodiment of sending machine 101. Sending machine 202 may be a secure USB memory storage device as shown in 3A. Sending machine 202 may be an authentication token as shown in
Sending machine 202 or sending machine 400 may communicate wirelessly with computer 204. In an embodiment, computer 204 may be a call station for receiving hidden data 109 from sending machine 400. A user may use input system 254 and output system 252 of sending machine (mobile phone) 400 to transmit hidden voice data or hidden metadata to a receiving machine that is a mobile phone. In an embodiment, input system 254 in
Computer 204 is connected to system 210, and is connected, via network 212, to system 214, system 216, and system 218, which is connected to system 220. Network 212 may be any one or any combination of one or more Local Area Networks (LANs), Wide Area Networks (WANs), wireless networks, telephones networks, and/or other networks. System 218 may be directly connected to system 220 or connected via a LAN to system 220. Network 212 and system 214, 216, 218, and 220 may represent Internet servers or nodes that route hidden data (e.g., hidden voice data or hidden metadata) received from sending machine 400 shown in
In
In an embodiment, hiding process 106 and extraction process 116 execute in a secure area of processor system 258 of
In an embodiment, specialized hardware in processor system 258 may be embodied as an ASIC (application specific integrated circuit) that computes SHA-1 and/or SHA-512 and/or Keccak and/or BLAKE and/or JH and/or Skein that help execute the HMAC function in process 6 named Hiding One or More Keys with Authentication or help execute process 7 named Hiding Encrypted Data Elements with Authentication. An ASIC chip can increase the execution speed and protect the privacy of hiding process 106 and extraction process 116.
In an embodiment, input system 254 of
In an embodiment, memory system 256 of
In
More details are provided on computationally intractable. In an embodiment, there is an amount of time T that encrypted information must stay secret. If encrypted information has no economic value or strategic value after time T, then computationally intractable means that the number of computational steps required by all the world's computing power will take more time to compute than time T. Let C(t) denote all the world's computing power at the time t in years.
Consider an online bank transaction that encrypts the transaction details of that transaction. Then in most embodiments, the number of computational steps that can be computed by all the world's computers for the next 30 years is in many embodiments likely to be computationally intractable as that particular bank account is likely to no longer exist in 30 years or have a very different authentication interface.
To make the numbers more concrete, the 2013 Chinese supercomputer that broke the world's computational speed record computes about 33,000 trillion calculations per second [42]. If T=1 one year and we can assume that there are at most 1 billion of these supercomputers. (This can be inferred from economic considerations, based on a far too low 1 million dollar price for each supercomputer. Then these 1 billion supercomputers would cost 1,000 trillion dollars.). Thus, C(2014)×1 year is less than 109×33×1015×3600×24×365=1.04×1033 computational steps.
As just discussed, in some embodiments and applications, computationally intractable may be measured in terms of how much the encrypted information is worth in economic value and what is the current cost of the computing power needed to decrypt that encrypted information. In other embodiments, economic computational intractability may be useless. For example, suppose a family wishes to keep their child's whereabouts unknown to violent kidnappers. Suppose T=100 years because it is about twice their expected lifetimes. Then 100 years×C(2064) is a better measure of computationally intractible for this application. In other words, for critical applications that are beyond an economic value, one should strive for a good estimate of the world's computing power.
One-way functions that exhibit completeness and a good avalanche effect or the strict avalanche criterion [43] are preferable embodiments: these properties are favorable for one-way hash functions. The definition of completeness and a good avalanche effect are quoted directly from [43]:
A hash function, also denoted as Φ, is a function that accepts as its input argument an arbitrarily long string of bits (or bytes) and produces a fixed-size output of information. The information in the output is typically called a message digest or digital fingerprint. In other words, a hash function maps a variable length m of input information to a fixed-sized output, Φ(m), which is the message digest or information digest. Typical output sizes range from 160 to 512 bits, but can also be larger. An ideal hash function is a function Φ, whose output is uniformly distributed in the following way: Suppose the output size of Φ is n bits. If the message m is chosen randomly, then for each of the 2n possible outputs z, the probability that Φ(m)=z is 2−n. In an embodiment, the hash functions that are used are one-way.
A good one-way hash function is also collision resistant. A collision occurs when two distinct information elements are mapped by the one-way hash function Φ to the same digest. Collision resistant means it is computationally intractable for an adversary to find collisions: more precisely, it is computationally intractable to find two distinct information elements m1, m2 where m1≠m2 and such that Φ(m1)=Φ(m2).
A number of one-way hash functions may be used to implement one-way hash function 148. In an embodiment, SHA-512 can implement one-way hash function 148, designed by the NSA and standardized by NIST [44]. The message digest size of SHA-512 is 512 bits. Other alternative hash functions are of the type that conform with the standard SHA-384, which produces a message digest size of 384 bits. SHA-1 has a message digest size of 160 bits. An embodiment of a one-way hash function 148 is Keccak [45]. An embodiment of a one-way hash function 148 is BLAKE [46]. An embodiment of a one-way hash function 148 is Grøstl [47]. An embodiment of a one-way hash function 148 is JH [48]. Another embodiment of a one-way hash function is Skein [49].
The emission times of the photons emitted by the LED experimentally obey the energy-time form of the Heisenberg uncertainty principle. The energy-time form of the Heisenberg uncertainty principle contributes to the non-determinism of random noise generator 142 because the photon emission times are unpredictable due to the uncertainty principle. In
In
A photodiode is a semiconductor device that converts light (photons) into electrical current, which is called a photocurrent. The photocurrent is generated when photons are absorbed in the photodiode. Photodiodes are similar to standard semiconductor diodes except that they may be either exposed or packaged with a window or optical fiber connection to allow light (photons) to reach the sensitive part of the device. A photodiode may use a PIN junction or a p-n junction to generate electrical current from the absorption of photons. In some embodiments, the photodiode may be a phototransistor.
A phototransistor is a semiconductor device comprised of three electrodes that are part of a bipolar junction transistor. Light or ultraviolet light activates this bipolar junction transistor. Illumination of the base generates carriers which supply the base signal while the base electrode is left floating. The emitter junction constitutes a diode, and transistor action amplifies the incident light inducing a signal current.
When one or more photons with high enough energy strikes the photodiode, it creates an electron-hole pair. This phenomena is a type of photoelectric effect. If the absorption occurs in the junction's depletion region, or one diffusion length away from the depletion region, these carriers (electron-hole pair) are attracted from the PIN or p-n junction by the built-in electric field of the depletion region. The electric field causes holes to move toward the anode, and electrons to move toward the cathode; the movement of the holes and electrons creates a photocurrent. In some embodiments, the amount of photocurrent is an analog value, which can be digitized by a analog-to-digital converter. In some embodiments, the analog value is amplified before being digitized. The digitized value is what becomes the random noise. In some embodiments, a one-way hash function 948 in
In an embodiment, the sampling of the digitized photocurrent values may converted to threshold times as follows. A photocurrent threshold θ is selected as a sampling parameter. If a digitized photocurrent value i1 is above θ at time t1, then t1 is recorded as a threshold time. If the next digitized photocurrent value i2 above θ occurs at time t2, then t2 is recorded as the next threshold time. If the next digitized value i3 above θ occurs at time t3, then ta is recorded as the next threshold time.
After three consecutive threshold times are recorded, these three times can determine a bit value as follows. If t2−t1>t3−t2, then random noise generator produces a 1 bit. If t2−t1<t3−t2, then random noise generator produces a 0 bit. If t2−t1=t3−t2, then no noise information is produced. To generate the next bit, random noise generator 942 or 952 continues the same sampling steps as before and three new threshold times are produced and compared.
In an alternative sampling method, a sample mean μ is established for the photocurrent. when it is illuminated with photons. In some embodiments, the sampling method is implemented as follows. Let i1 be the photocurrent value sampled at the first sampling time, i1 is compared to μ. ϵ is selected as a parameter in the sampling method that is much smaller number than μ. If i1 is greater than μ+ϵ, then a 1 bit is produced by the random noise generator 942 or 952. If i1 is less than μ−ϵ, then a 0 bit is produced by random noise generator 942 or 952. If i1 is in the interval [μ−ϵ, μ+ϵ], then NO bit is produced by random noise generator 942 or 952.
Let i2 be the photocurrent value sampled at the next sampling time. i2 is compared to μ. If i2 is greater than μ+ϵ, then a 1 bit is produced by the random noise generator 942 or 952. If i2 is less than μ−ϵ, then a 0 bit is produced by the random noise generator 942 or 952. If i2 is in the interval [μ−ϵ, μ+ϵ], then NO bit is produced by the random noise generator 942 or 952. This alternative sampling method continues in the same way with photocurrent values i3, i4, and so on. In some embodiments, the parameter ϵ is selected as zero instead of a small positive number relative to μ.
Some alternative hardware embodiments of non-deterministic generator 128 (
In some embodiments, the seek time of a hard drive can be used as random noise values as the air turbulence in the hard drive affects the seek time in a non-deterministic manner. In some embodiments, local atmospheric noise can be used as a source of random noise. For example, the air pressure, the humidity or the wind direction could be used. In other embodiments, the local sampling of smells based on particular molecules could also be used as a source of random noise.
In some embodiments, a Geiger counter may be used to sample non-determinism and generate random noise. In these embodiments, the unpredictability is due to radioactive decay rather than photon emission, arrivals and detection.
In an embodiment, a deterministic generator 962 (
In some embodiments, Φ and ψ are the same one-way hash functions. In other embodiments, Φ and ψ are different one-way hash functions. In an embodiment, Φ is one-way hash function SHA-512 and ψ is one-way hash function Keccak. In another embodiment, Φ is one-way hash function Keccak and ψ is one-way hash function SHA-512.
In an embodiment, the ith generator Δ(i) is composed of N bits and updated with generator update instructions 966. The N bits of Δ(i) are represented as Δi,0 Δi,1 . . . Δi,N−1 where each bit Δi,j is a 0 or 1. In an embodiment, generator update instructions 966 are executed according to the following two steps described in machine 1:
Update (Δi+1,0 Δi+1,1 . . . Δi+1,d−1)=Φ(Δi,0 Δi,1 . . . Δi,d−1)
Update Δi+1,j=Δi,j for each j satisfying d≤j≤N−1
In an embodiment, the size of the deterministic generator N may be 1024. In another embodiment, N may be fifty thousand. In another embodiment, N may be ten billion.
In an embodiment, one-way hash instructions 964 are performed by processor system 258 (
In an embodiment, the instructions that execute machine 1 and help execute deterministic generator 962 may expressed in the C programming language before compilation. In an embodiment, the instructions that execute machine 1 and help execute deterministic generator 962 may be expressed in the native machine instructions of processor system 258. In an embodiment, the instructions that execute machine 1 may be implemented as an ASIC, which is part of processor system 258.
Machine 1. Generating Noise with a Machine
In an embodiment, machine 2 generates key(s) 970 as follows. Φ is one-way hash function with digest size d and is executed with one-way hash instructions 964. In some embodiment, ψ is a one-way hash function with digest size at least m bits (size of one or more keys) and is executed with one-way hash instructions 968. In some embodiments, if m is greater than digest size of ψ, then the generator update steps in machine 2 may be called more than once to generate enough keys.
In some embodiments, Φ and ψ are the same one-way hash functions. In other embodiments, Φ and ψ are different one-way hash functions. In an embodiment, Φ is one-way hash function SHA-512 and ψ is one-way hash function Keccak. In another embodiment, Φ is one-way hash function Keccak and ψ is one-way hash function SHA-512.
In an embodiment, the ith generator Δ(i) is composed of N bits and updated with generator update instructions 966. The N bits of Δ(i) are represented as Δi,0 Δi,1 . . . Δi,N−1 where each bit Δi,j is a 0 or 1. In an embodiment, generator update instructions 966 are executed according to the following two steps described in machine 2:
Update (Δi+1,0 Δi+1,1 . . . Δi+1,d−1)=Φ(Δi,0 Δi,1 . . . Δi,d−1)
Update Δi+1,j=Δi,j for each j satisfying d≤j≤N−1
In an embodiment, the size of the deterministic generator N may be 1024. In another embodiment, N may be fifty thousand. In another embodiment, N may be ten billion.
In an embodiment, one-way hash instructions 964 are performed by processor system 258 (
In an embodiment, the instructions that execute machine 2 and help execute deterministic generator 962 may expressed in the C programming language before compilation. In an embodiment, the instructions that execute machine 2 and help execute deterministic generator 962 may be expressed in the native machine instructions of processor system 258. In an embodiment, the instructions that execute machine 2 may be implemented as an ASIC, which is part of processor system 258. In an embodiment, memory system 956 may store one or more keys 970.
Machine 2. Generating One or More Keys with a Machine
A scatter map is a function that permutes data (information) to a sequence of distinct locations inside the random noise. To formally define a scatter map, the location space is defined first.
Let m, n∈, where m≤n. The set
m,n={(l1, l2 . . . lm)∈{1, 2, . . . n}m:lj≠lk whenever j≠k} is called an (m, n) location space.
The location space m,n has
elements.
Given a location element (l1, l2 . . . lm)∈m,n, the noise locations with respect to (l1, l2 . . . lm) are denoted as
(l1, l2 . . . lm)={1, 2, . . . , n}−{li: 1≤i≤m}.
An (m, n) scatter map is an element π=(l1, l2 . . . lm)∈Lm,n such that π: {0, 1}m×{0, 1}n-m→{0,1}n and π(d1, . . . , dm, r1, r2 . . . rn−m)=(s1, . . . sn) where the hiding locations s, are selected as follows. Set sl(π). Set si
(π).
Definition 3 describes how the scatter map selects the hiding locations of the parts of the key or data hidden in the noise. Furthermore, the scatter map process stores the noise in the remaining locations that do not contain parts of the key or data. Before the scatter map process begins, it is assumed that an element π∈m,n is randomly selected with a uniform distribution and Alice and Bob already have secret scatter map π=(l1, l2 . . . lm).
Hiding Process 1. Scatter Map Process Hides Data before Transmitting
= (s1 . . . sn) so that the data d1d2 . . . dm is hidden in the noise.
to Bob.
.
.
In an embodiment of process 1, scatter map π is executed by scatter map instructions 130 (=(s1 . . . sn) so that the data d1d2 . . . dm is hidden in the noise.
In an embodiment of process 1, output system 252 in to Bob. Output system 252 is part of sending machine 102 in
. Input system 254 is a part of receiving machine 112 in
In an alternative embodiment, Alice (first party) hides data inside noise so that she can protect its confidentiality and retrieve it at a later time. In an embodiment, hidden data 186 of
= (s1 . . . sn) so that the data d1d2 . . . dm is hidden in the noise.
to memory .
In hiding process 2, storing machine 180, as shown in
= (s1 . . . sn) so that the one or more keys k1k2 . . . km are hidden in
to Bob.
.
.
In an embodiment of process 3, scatter map π is executed by scatter map instructions 130 (=(s1 . . . sn) so that the one or more keys k1k2 . . . km are hidden in the noise. In
.
In an embodiment of process 3, output system 252 is used during the step Alice sends S to Bob. Output system 252 is part of sending machine 102 in . Input system 254 is a part of receiving machine 112 in
When the scatter size is n, process 1 takes n steps to hide the data inside the noise. When the scatter size is n, process 3 takes n steps to hide one or more keys inside the noise. When the bit-rate of a random noise generator is x bits per second, then a transmission with scatter size x bits is practical. When x=10,000, a key size of 2000 bits and noise size of 8000 bits is feasible. When x=20,000, a data size of 5000 bits and noise size of 1500 bits is feasible. In some applications, Alice and Bob may also establish the key size or data size m as a shared secret, where m is not disclosed to Eve.
In the interests of being conservative about the security, the mathematical analysis in section 10.11 assumes that Eve knows the data or key size m. For applications where Eve doesn't know m, the security will be stronger than the results obtained in the upcoming sections.
This section analyzes the mathematics of when a scatter map is safest to reuse for multiple, hidings of data transmissions or hidings of data stored. Suppose that scatter map π∈m,n is established with Alice and Bob, according to a uniform probability distribution and adversary Eve has no information about π. Before Eve sees Alice's first scatter storage or first scatter transmission from Alice to Bob, from Eve's perspective, the probability
for each (l1, l2 . . . lm) in m,n: in other words, Eve has zero information about π with respect to
m,n.
Rule 1. The Noise and Data (Machine Instruction) have the Same Bias
The noise and data (machine instruction) satisfy the same bias property if the probability distribution of the noise and the probability distribution of the data are the same. In an embodiment, the data is a machine instruction. In an embodiment, the noise is generated by non-deterministic generator 942 and has two outcomes (binary) and each outcome has probability 1/2; and each indivisible unit of the data has two outcomes and each outcome has probability 1/2.
In another embodiment the noise is generated by deterministic generator 962 and has two outcomes (binary) and the first outcome has probability 1/10 and the second outcome has probability 9/10; and each indivisible unit of the data has two outcomes and the first outcome for a data unit has probability 1/10 and the second outcome has probability 9/10.
In another embodiment the noise is generated by deterministic generator 962 and has three outcomes: the first outcome has probability 1/100; the second outcome has probability 29/100; and the third outcome has probability 70/100. And the primitive units of data have three outcomes: the first outcome has probability 1/100; the second outcome has probability 29/100; and the third outcome has probability 70/100.
Our next rule describes that prior history of outcomes has no influence on which outcome occurs next. In probability theory, this is sometimes called stochastic independence.
History has no effect on the next event. Each outcome oi is independent of the history. Let pi be the probability of outcome oi where there are m outcomes. A standard assumption of probability theory is that the sum of the probabilities of a finite number of mutually exclusive outcomes is 1 when these outcomes cover all possible outcomes. That is,
Stochastic independence means that no correlation exists between previous or future outcomes. If the history of the prior j−1 outcomes is b1, b2, . . . , bj−1, then the conditional probability of outcome oi on the jth trial is still pi, regardless of this history. This is expressed in terms of the conditional probabilities: for every outcome oi, P(xj=oi|x1=b1, . . . , xj−1=bj−1)=pi.
Process 4 shows how to generate biased noise that is unpredictable so that unencrypted data with a bias can still be effectively hidden. In hiding process 4, a line starting with; is a comment.
are indexed as {o1, o2, . . . , om}, when
In an embodiment, hiding process 4 can be implemented as a computing system (
Next, two more rules are stated whose purpose is to design embodiments that do not lead leak information to Eve. Section 10.13 shows some embodiments that authenticate the data or key(s) hidden in the noise. Embodiments that follow these rules help hinder Eve from actively sabotaging Alice and Bob to violate these rules.
For each scattered transmission, described in process 1 or process 3, Alice creates new data d1 . . . dm or creates a new key k1 . . . km. Alice also creates new noise r1 . . . rn−m from a non-deterministic generator that satisfies rule 1 (The Noise and Data have the Same Bias) and rule 2 (Stochastic Independence).
During the kth scattered transmission or storage, Eve only sees scattered (k); Eve receives no auxiliary information from Alice or Bob. Scattered
(k) represents the key(s) or data hidden in the noise.
When Eve initially has zero information about π w.r.t. m,n, and rules 3 and 4 hold, then Eve still has zero information about π after she observes scattered transmissions
(1),
(2), . . .
(k).
In a proof of theorem 1, the following terminology is used. i lies in π=(l1, l2 . . . lm) if i=lj for some 1≤j≤m. Similarly, i lies outside π if i≠lj for every 1≤j≤m. In this latter case, i is a noise location.
PROOF. Consider the ith bit location in the scattered transmission. Let xi(k) denote the ith bit observed by Eve during the kth scattered transmission (k). The scatter map π is established before the first transmission based on a uniform probability distribution; rule 3 implies the data generation and noise generation obey the two properties of no bias and history has no effect, These rules imply the conditional probabilities P(xi(k+1)=1|xi(k)=b)=1/2=P(xi(k+1)=0|xi(k)=b) hold for b∈{0, 1}, independent of whether i lies in π or i lies outside π. Rule 4 implies that if Eve's observation of
(1),
(2), . . .
(k) enabled her to obtain some information, better than
about whether i lies in π or i lies outside π, then this would imply that the probability distribution of the noise is distinct from the probability distribution of the data, which is a contradiction. □
Theorem 1 is not precisely true if the probability distribution of the noise is distinct from the probability distribution of the data. In some embodiments, the probability distribution of the noise may be close enough to the probability distribution of the data so that Eve cannot obtain enough information to guess or figure out hiding locations. With this in mind, for a positive ϵ>0 and ϵ<1/2, we define what it means for the probability distribution of the noise to be ϵ-close to the probability distribution of the data.
Definition 4. Probability Distributions that are ϵ-Close
Suppose the noise outcomes and the data outcomes are binary. That is, each noise outcome can be represented with a bit and each data outcome can be represented with a bit. Let (p0,2p1) be the noise distribution. This means that the probability of a noise bit being a 0 is p0 and probability of a noise bit being 1 is p1, so p0+p1=1. Let (q0, q1) be the data distribution. This means that the probability of a data bit being a 0 is q0 and probability of a data bit being 1 is q1. The probability distribution of the noise is ϵ-close to the probability distribution of the data if |p0−q0|<ϵ and |p1−q1|<ϵ.
Suppose the noise has m distinct outcomes and the data has m distinct outcomes. Let (p1, p2, . . . , pm) be the probability distribution of the noise, where
Let (q1, q2, . . . , qm) be the probability distribution of the data, where
The probability distribution of the noise is ϵ-close to the probability distribution of the data if |pi−qi|<ϵ for every i such that 1≤i≤m.
In embodiments, remark 2 advises us not to let Alice violate rule 3: an example of what Alice should not do is send the same data or same key in multiple executions of process 1 or process 3 and the noise is randomly generated for each execution.
This section provides the intuition for effective hiding. Effective hiding occurs when Eve obtains no additional information about scatter map σ after Eve observes multiple hidden key or hidden data transmissions. Section 10.8 provides mathematical analysis of this intuition.
The effectiveness of the hiding depends upon the following observation. Even after Eve executes a search algorithm for the data (signal) in the noise, Eve's search algorithm does NOT know when it has found the key or the data because her search algorithm CANNOT distinguish the signal from the noise. This is illustrated by
The pixel values in
possibilities for scatter map σ. Even if Eve's search method stumbles upon the correct sequence of locations, Eve's method has no basis for distinguishing the data from the noise because the key and noise probability distributions are equal. For
In
This section describes a further enhancement of our invention(s) and makes Eve's challenge far more difficult for her to capture or estimate the scatter map: the locations of where to hide the information, or data, or keys, or public keys can dynamically change. This means the scatter map dynamically changes in a way so that Alice can extract the hidden information at a later time even though each block of data units are hidden at different locations. In terms of mathematics, the scatter map π(k) dynamically changes as a function of the kth storing or kth transmission. Precisely, π(j)≠π(k) when j≠k.
In an embodiment, Alice hides information in blocks of 4 data (information) units and the noise size is 60 data (information) units. In some embodiments a unit may represent a bit: there are two choices for each di. In other embodiments, there may be 4 choices for each unit di. In the first hiding of the data or information in the noise, Alice hides data unit d0 at location 63; Alice hides data unit d1 at location 2; Alice hides data unit d2 at location 17; and Alice hides data unit d3 at location 38. As described in section, Alice stores the noise units in the remaining 60 locations.
In the second hiding of 4 data units d4, d5, d6, and d7, Alice hides data unit d4 at location 28; Alice hides data unit d5 at location 51; Alice hides data unit d6 at location 46; and Alice hides data unit d7 at location 12. The hiding locations in the first hiding are different from the hiding location in the second hiding. In other words, the enhancement described in machine 3 provides dynamic hiding locations.
Described below, machine 3 describes an embodiment of hiding locator machine 980 of
In a machine 3 embodiment of hiding locator machine 980, N=1024 is the size of the hiding locator Δ(i), and Δ(i) is updated by hiding locator update instructions 986. In another embodiment, N is fifty thousand. In another embodiment, N is ten billion.
In a machine 3 embodiment, b=32. Since 232 is greater than 4 billion, there are more than 4 billion possible hiding locations for a single hiding of data when b=32. In a machine 3 embodiment, b=64. Since 264 is greater than 1019, there are more than 1019 possible hiding locations for a single hiding of data when b=64. In a machine 3 embodiment, b=5000.
In a machine 3 embodiment of hiding locator machine 980, one-way hash instructions 984 are performed by processor system 258 (
In an embodiment, the instructions that execute machine 3 and help execute hiding locator machine 980 may expressed in the C programming language before compilation. In an embodiment, the instructions that execute machine 3 and help execute hiding locator machine 980 may be expressed in the native machine instructions of processor system 258. In an embodiment, the instructions that execute machine 3 may be implemented as an ASIC, which is part of processor system 258. In an embodiment, memory system 956 may store one or more dynamic hiding locations 982.
The size of the location space is significantly greater than the data or key size. Even for values of n as small as 30,
The uniform distribution of the noise and the data generation and a large enough noise size poses Eve with the challenge that even after seeing the transmission =(s1 . . . sn), she has almost no more information about the data or key(s), than before the creation of k1 k2 . . . km. The forthcoming analysis will make this notion of almost no more information more precise.
In some applications, Alice and Bob may also establish the data size m as a shared secret, where m is not disclosed to Eve. In the interests of being conservative about the security, it is assumed that Eve knows the data size m. For applications where Eve doesn't know m, the information security will be stronger than the results obtained in this section.
Processes 1 and 3 are analyzed with counting and asymptotic results that arise from the binomial distribution. First, some preliminary definitions are established.
For 0≤i≤n, define Ei,n={r∈{0,1}n:η1(r)=i}. When n=4, E0,4={0000}, E1,4={0001, 0010, 0100, 1000}, E2,4={0011,0101,0110, 1001,1010, 1100}, E3,4={0111, 1011,1101, 1110} and E4,4={1111}. Note
The expression—the ith element of Ek,n—refers to ordering the set Ek,n according to an increasing sequence of natural numbers that each binary string represents and selecting the ith element of this ordering. For example, the 3rd element of E2,4 is 0110.
In
Equation 10.1 follows from the independence of events Rk and Bl,j.
P(Rk∩Bl,j)=P(Rk)∩P(Bl,j) (10.1)
whenever 0≤k≤ρ and 0≤j≤m and 1<l≤(jm).
Equation 10.2 follows from the definitions in
whenever 0≤j≤min{k, m} and 1≤l≤(jm).
A finite sample space and
imply that each event
Furthermore, Bl
whenever 0≤j≤min{k, m} and 1≤l≤(jm). The mathematical steps that establish equation 10.3 are shown below.
Definition 5. Let c be a positive integer. ƒ:→
is called a binomial c-standard deviations function if there exists N∈
such that whenever ρ≥N, then
Define the function
Then hc is a binomial c-standard deviations function. Lemmas 2 and 3 may be part of the binomial distribution folklore; for the sake of completeness, they are proven below.
Let k: →
be a binomial c-standard deviations function. Then
PROOF. A simple calculation shows that
Since k(ρ) is a binomial c-standard deviations function
This implies
apply the squeeze theorem to equation 10.4. □
The work from lemma 2 helps prove lemma 3. Lemma 3 helps prove that equation 10.3 converges to 2−m when k(ρ) is a binomial c-standard deviations function.
Fix m∈. Let k:
→
be a binomial c-standard deviations function. For any b, j such that 0≤b, j≤m, then
PROOF. Using a similar computation to equation 10.4 inside of c+1 standard deviations instead of c, then ρ can be made large enough so that k(ρ)−b and k(ρ)−j lie within c+1 standard deviations so that
where 0≤i≤m. W.L.O.G., suppose j<b. Thus,
□
Fix data size m∈. Let c∈
. Let k:
→N be a binomial c-standard deviations function. Then
from equation 10.3.
Theorem 4 is not true when k(ρ) stays on or near the boundary of Pascal's triangle. Consider
The math confirms common sense: namely, if Eve sees event A0, then Eve knows that Alice's data is all zeroes. A practical and large enough noise size enables process 1 or process 3 to effectively hide the data transmission so that outlier events such as A0, A1 do not occur in practice. For example, when n=2048, P(A0)=2−2048 and P(A1)=2−2037.
Definitions 6, 7 and theorems 5, 6 provide a basis for calculating how big the noise size should be in order to establish an extremely low probability that Eve will see outlier events such as A0.
ƒ:→
is an binomial ϵ-tail function if there exists N∈
such that n≥N implies that
The area under the standard normal curve from −∞ to x is expressed as
For each c∈, set ϵc=4Φ(−c). The function
is a binomial ϵc-tail function.
PROOF. This is an immediate consequence of the central limit theorem [51, 52], applied to the binomial distribution. Some details are provided.
Define
In [53], DeMoivre proved for each fixed x that
Now ϵc is four times the value of
which verifies that gc is a binomial ϵc-tail function. □
This example provides some perspective on some ϵ-tails and Eve's conditional probabilities. For n=2500, the scatter mean μ is 1250 and the standard deviation
Set c=20, so μ−cσ=750. A calculation shows that
For n=4096, the scatter mean is 2048 and the standard deviation σ=32. Set c=50 standard deviations, so μ−cσ=448. A calculation shows that
Some of Eve's conditional probabilities are calculated for n=2500 and data size m=576. The average number of 1's in a key is μkey=288 and the standard deviation σkey=12.
A typical case is when j=300 and k=1275, which are both one standard deviation to the right of the data and scatter mean, respectively. When Eve's conditional probability equals 2−m, the secrecy ratio is exactly 1. Using equation 10.3, a computer calculation shows that the secrecy ratio is
so 2−576<P(Bl,300|A1275)<2−575.
A rare event is when j=228 and k=1225. That is, j=228 is five standard deviations to the left of μkey and k=1225 is one standard deviation to the left of the scatter mean. A calculation shows that
Thus, 2−577<P(Bl,288|A1225)<2−576.
An extremely rare event occurs when j=228 and k=1125. Event A1125 is 4 standard deviations to the left.
Thus, 2−565<P(Bl,228|A1125)<2−564. While a secrecy ratio of 3840 is quite skew, it still means that even if Eve sees a scatter transmission 4 standard deviations to the left, there is still a probability in the interval [2−565, 2−564] of Alice's data element being the event Bl,228.
Even when Eve sees a highly skewed, scattered transmission and obtains some information about the current hidden data element, Eve's observation provides her with no information about the next data element hidden in a subsequent transmission. The secrecy ratio calculations in example 1 provide the motivation for definition 7.
Let ϵ>0. Eve's conditional probabilities P(Bl,j|Ak(ρ)) are ϵ-close to perfect secrecy if there exists a binomial ϵ-tail function ƒ such that for any function k: →
satisfying ƒ(ρ)≤k(ρ)≤ρ−ƒ(ρ), then
For any ϵ>0, there exists M∈ such that ϵc<ϵ for all c≥M and c∈
. Furthermore, function gc is a binomial ϵc-tail function that makes Eve's conditional probabilities P(Bl,j|Ak(ρ)) ϵc-close to perfect secrecy, where gc(ρ)≤k(ρ)≤ρ−gc(ρ).
PROOF. Since
there exists M∈ such that ϵc<ϵ for all c≥M. Recall that
For all ρ∈, |gc(ρ)−hc(ρ)|≤1 and gc(4ρ2)−hc(4ρ2)=0. This fact and hc is a binomial c-standard deviations function together imply that lemma 3 and hence theorem 4 also hold for function gc. That is,
Whenever function k satisfies gc(ρ)≤k(ρ)≤ρ−gc(ρ), this implies k is a binomial c+1-standard deviations function. Thus, this theorem immediately follows from theorems 4, 5 and from definition 7. □
In some embodiments, the key or data may be transformed by the sender (Alice) before being scattered and subsequently transmitted to the receiver (Bob). In an embodiment, each bit of the key or the data may be transformed according to the map Φ: {0, 1}→{01, 10} where Φ(0)=01 and Φ(1)=10. Suppose the data is K=010010000. Φ−1 denotes the inverse of Φ. The inverse of Φ is used by Bob to reconstruct the data d1d2 . . . dm from the transformed data t1t2 . . . t2m after Bob extracts t1t2 . . . t2m from the scattered transmission received from Alice. Note that Φ−1(01)=0 and Φ−1(10)=1. In some embodiments, data transformation instructions 126, shown in
After applying Φ to each bit of K, the transformation is Φ(0) Φ(1) Φ(0) Φ(0) Φ(1) Φ(0) Φ(0) Φ(0) Φ(0)=01 10 01 01 10 01 01 01 01. After this transformation by Φ, each of these 18 bits is scattered inside random noise. Suppose K is scattered inside of 130 bits of noise, then the location space will be 18,148. A scatter map π in
18,148 has 18 locations. That is, π=(l1, l2, . . . , l18) and each li satisfies 1≤li≤148.
2m,n to hide the transformed 2m bits inside of n−2m bits of random noise. In an embodiment, the data size may be m=32. In another embodiment, the data size may be m=128. In another embodiment, the data size may be m=1000. In another embodiment, the data size may be m=4096. In another embodiment, the data size may be m=512000.
In alternative embodiments, the map ψ: {0, 1}→{01, 10} where ψ(0)=10 and ψ(1)=01, may be used to transform the data before scattering (hiding) the data inside the noise. In an embodiment, the map ψ transforms the 16 bits of data 0100 1110 1001 0110 to a 32-bit transformation 10011010 01010110 01101001 10010110, before this 32-bit transformation is scattered by the sender (Alice) inside of random noise. After Bob extracts the transformed data 10011010 01010110 01101001 10010110 from the scattered transmission, Bob applies the inverse of ψ to each substring of two bits. For the first two bits, ψ−1(10)=0, so d1=0. For bits 3 and 4, Bob computes ψ−1(01)=1, so Bob reconstructs d2=1. For bits 5 and 6, Bob computes ψ−1(10)=0, so his third reconstructed data bit d3=0. Bob continues this reconstruction of the 16th bit of data with bits 31 and 32 and computes ψ−1(10)=0, and reconstructs bit d16=0. In some embodiments, data transformation instructions 126, shown in
Before the scatter map process using a data transformation is started, an element π∈2m,n is randomly selected and securely distributed to Alice and Bob. Note 2m<n.
= (s1 . . . sn) so that the transformed data is hidden inside the noise.
= (s1 . . . sn) to Bob.
.
It is assumed that Alice and Bob have previously established secret scatter map σ=(l1, l2 . . . lm) and authentication key κ. In some embodiments, Alice and Bob may establish scatter map σ and authentication key κ with a Diffie-Hellman-Merkle exchange [54, 55], where their public keys are signed in a secure computing or private manufacturing environment; alternatively, in other embodiments, Alice and Bob may establish σ and κ via a different channel or in the same physical location by a face to face exchange or using a physical delivery by a mutually trusted courier.
Let hκ denote an MAC (e.g., HMAC [64] or [65]) function which will be used to authenticate the scattered transmission. The use of hκ helps hinder the following attack by Eve. An active Eve could flip a bit at bit location l in the scattered transmission. If no authentication occurs on the noise and the hidden key bits, then upon Alice resending a scattered transmission due to Alice and Bob not arriving at the same session key secret, Eve gains information that l lies in σ. If the scattered transmission is not authenticated, Eve's manipulation of the bits in
helps her violate rule 4.
Hiding Process 6. Hiding One or More Keys with Authentication
= (s1 . . . sn) so that
and hκ(
) to Bob.
′ and hκ(
) from Alice. Bob computes hκ(
′) and checks it against hκ(
).
′) is valid, Bob uses scatter map σ to extract one or more keys k1 . . . km from
;
′ and asks Alice to resend
.
In some embodiments of process 6, scatter map σ is executed by scatter map instructions 130 (
In some embodiments of process 6, the probability distribution of the data elements is biased and the probability distribution of the noise is biased. In preferred embodiments, the probability distribution of the data elements is the same as the probability distribution of the noise even though they are both biased. In some embodiments, the probability distribution of the data elements is almost the same the probability distribution of the noise. Almost the same probability distribution means that an average hacker that is eavesdropping on the hidden data transmissions would not be able to find where the data is being hidden after a seeing the hidden transmissions for a reasonable amount of time. In an embodiment, a reasonable amount of time is 3 months. In another embodiment, a reasonable amount of time is 1 year. In another embodiment, a reasonable amount of time is 5 years.
In other embodiments, Alice encrypts plaintext data d1, . . . dm with a block or stream cipher before the encrypted data e1, . . . em is hidden in random noise; this is described in process 7 below.
Hiding Process 7. Hiding Encrypted Data Elements with Authentication
= (s1 . . . sn)
′ and hκ(
) from Alice. Bob computes hκ(
′) and checks it against hκ(
).
′) is valid, Bob uses scatter map σ to extract e1 . . . em from
and subsequently uses
and key K to decrypt e1 . . . em and obtain d1 . . . dm.
′ and asks Alice to resend
.
In some embodiments of process 7, catter map σ is executed by scatter map instructions 130 (
In some embodiments of process 7, encryption algorithm ε is the block cipher Serpent [40] and is executed with cipher instructions 129 as shown in
In some embodiments of process 7, encryption algorithm ε is a block cipher and also uses the cipher block chaining mode. In some embodiments of process 7, encryption algorithm ε is a stream cipher.
Suppose that the encrypted data element e1e2 . . . e128 has 128 bits and these bits are hidden inside of 128 bits r1r2 . . . r128 of random noise. In an embodiment following process 7, block cipher Serpent is executed with cipher instructions 126 to encrypt the data element as e1e2 . . . e128 before scatter map instructions 130 are applied to hide encrypted bits e1e2 . . . e128 in random noise r1r2 . . . r128 produced by random number generator 128.
The hiding of encrypted bits e1e2 . . . e128 by scatter map instructions 130 is shown in 128,256|>10192. The complexity 10192 of finding the scatter map σ in
128,256 is substantially greater than the complexity of Serpent which is at most 2256<1077. In embodiments where more the noise size is larger, the complexity of finding the scatter map can be much greater than 10192.
When Eve does not receive any auxiliary information (that is, rule 4 holds), it is extremely unlikely that Eve can extract any information about the bit locations even after Eve observes 625,000 encrypted data elements, each hidden in 128 bits of noise. If Eve has the computing power to brute-force search through each element σ∈128,256 and subsequently to find data element e1 . . . e128, Eve still has no way of knowing if this particular σ is the one that Alice used to hide encrypted bits e1e2 . . . e128. Eve needs some auxiliary information.
Consider the following cryptographic method. Alice places her one-time lock a on message m and transmits m⊕a to Bob. Bob applies his one-time lock b and sends m⊕a⊕b back to Alice. Alice removes her lock, by applying a to m⊕a⊕b and sends m⊕b back to Bob. Bob removes lock b from m⊕b to read message m. This method of one-time locks is vulnerable if Eve can see the three transmissions m⊕a, m⊕a⊕b and m⊕b because Eve can compute m=(m⊕a)⊕(m⊕a⊕b)⊕(m⊕b).
In an embodiment, process 8 protects these one-time locks by using two distinct and independent scatter maps πA, πB to hide each transmission inside a new generation of random noise. Independent means that any information given to Eve about πB tells Eve nothing about πA and vice versa. In terms of conditional probabilities, independence means P(πA=(l1 . . . lκ)∈κ,n|πB=(j1 . . . jκ))=P(πA=(l1 . . . lκ)∈
κ,n). Using these independent scatter maps, Eve is no longer able to see the three transmissions m⊕a, m⊕a⊕b and m⊕b because the encrypted data m⊕a, and the twice encrypted data m⊕a⊕b and the second party encrypted data m⊕b are each hidden inside of a new generation of random noise.
κ,n,
= (s1 . . . sn) and sends to
, using scatter map πA.
= (t1 . . . tn) and sends to
, using scatter map πB.
= (u1 . . . un) and sends to
, using scatter mapπA.
In an alternative embodiment, Alice and Bob use a third, distinct scatter map πC, created independently from πA and πB. Scatter map πC helps Alice scatter b1⊕m1 . . . bκ⊕mκ after removing her lock. This alternative embodiment is shown in process 9.
Hiding Process 9. Scattered One Time Locks with 3 Scatter Maps
κ,n and πC =
κ,n
= (s1 . . . sn)
= (s1 . . . sn) to Bob.
, using scatter map πA.
= (t1 . . . tn) and sends to Alice.
, using scatter map πB.
= (u1 . . . un) and sends to Bob.
= (u1 . . . un).
, using scatter map πC.
In an embodiment of process 9, scatter maps πA, πB and πC are executed by scatter map instructions 130 (
In an embodiment of process 9, output system 252 in =(s1 . . . sn) to Bob. Output system 252 is part of sending machine 102 in
=(u1 . . . un). Input system 254 is a part of receiving machine 112 in
In other alternative, embodiments, the message size κ is known to Eve.
In preferred embodiments, each scatter transmission should use a new lock and new noise. For example, if due to a failed transmission, Alice or Bob generated new noise but transmitted the same values of a1⊕m1 . . . aκ⊕mκ and b1⊕m1 . . . bκ⊕mκ and b1⊕a1⊕m1 . . . bκ⊕aκ⊕mκ, then Eve could run a matching or correlation algorithm between the scatters ,
or
in order to extract a permutation of message m1 . . . mκ. During any kind of failed transmission, Alice and Bob should generate new locks from their respective random noise generators, just as they have to do for every iteration of the while loop in process 8.
In process 8, Alice's lock a1 . . . aκ is generated from her random noise generator. Hence, for every (x1, . . . , xκ)∈{0, 1}κ, the probability P(a1⊕m1=x1, . . . aκ⊕mκ=xκ)=2−κ. Similarly, Bob's lock b1 . . . bκ is generated from his random noise generator, so the probability P(b1⊕m1=x1, . . . bκ⊕mκ=xκ)=2−κ for every (x1, . . . ,xκ)∈{0, 1}κ.
A Diffie-Hellman exchange [55] is a key exchange method where two parties (Alice and Bob)—that have no prior knowledge of each other—jointly establish a shared secret over an unsecure communications channel. Sometimes the first party is called Alice and the second party is called Bob. Before the Diffie-Hellman key exchange is described it is helpful to review the mathematical definition of a group. A group G is a set with a binary operation * such that the following four properties hold: (i.) The binary operation * is closed on G. This means a*b lies in G for all elements a and b in G. (ii.) The binary operation * is associative on G. That is, a*(b*c)=(a*b)*c for all elements a, b, and c in G (iii.) There is a unique identity element e in G, where a*e=e*a=a. (iv). Each element a in G has a unique inverse denoted as a−1. This means a*a−1=a−1*a=e.
g*g is denoted as g2; g*g*g*g*g is denoted as g5. Sometimes, the binary operation * will be omitted so that a*b is expressed as ab.
The integers { . . . , −2, −1, 0,1, 2, . . . } with respect to the binary operation * are an example of an infinite group. 0 is the identity element. For example, the inverse of 5 is −5 and the inverse of −107 is 107.
The set of permutations on n elements {1,2, . . . , n}, denoted as Sn, is an example of a finite group with n! elements where the binary operation is function composition. Each element of Sn is a function p: {1, 2, . . . , n}→{1, 2, . . . , n} that is 1 to 1 and onto. In this context, p is called a permutation. The identity permutation e is the identity element in Sn, where e(k)=k for each k in {1, 2, . . . , n}.
If H is a non-empty subset of a group G and H is a group with respect to the binary group operation * of G, then H is called a subgroup of G. H is a proper subgroup of G if H is not equal to G (i.e., H is a proper subset of G). G is a cyclic group if G has no proper subgroups.
Define An=n−[0]={[1], . . . , [n−1]}; in other words, An is the integers modulo n with equivalence class [0] removed. If n=5, [4]*[4]=[16 mod 5]=[1] in (
5,*) Similarly, [3]*[4]=[12 mod 5]=[2] in (
5, *). Let (a, n) represent the greatest common divisor of a and n. Let Un={[a]∈An: (a, n)=1}. Define binary operator on Un as [a] *[b]=[ab], where ab is the multiplication of positive integers a and b. Then (Un, *) is a finite, commutative group.
Suppose g lies in group (G, *). This multiplicative notation works as follows: g2=g*g. Also g3=g*g*g; and so on. This multiplicative notation (superscripts) is used in the description of the Diffie-Hillman key exchange protocol described below.
For elliptic curves [56] the Weierstrauss curve group operation geometrically takes two points, draws a line through these two points, finds a new intersection point and then reflects this new intersection point about the y axis. When the two points are the same point, the commutative group operation computes a tangent line and then finds a new intersection point.
In another embodiment, elliptic curve computations are performed on an Edwards curve over a finite field. When the field K does not have characteristic two, an Edwards curve is of the form: x2+y2=1+dx2y2, where d is an element of the field K not equal to 0 and not equal to 1. For an Edwards curve of this form, the group binary operator * is defined as
where the elements of the group are the points (x1, y1) and (x2, y2). The definition of * defines elliptic curve computations that form a commutative group. For more information on Edwards curves, refer to the math journal paper [57].
In an alternative embodiment, elliptic curve computations are performed on a Montgomery curve over a finite field. Let K be the finite field over which the elliptic curve is defined. A Montgomery curve is of the form By2=x3+Ax2+x, for some field elements A, B chosen from K where B(A2−4)≠0. For more information on Montogomery curves, refer to the publication [58].
There are an infinite number of finite groups and an infinite number of these groups are huge. The notion of huge means the following: if 21024 is considered to be a huge number based on the computing power of current computers, then there are still an infinite number of finite, commutative groups with each group containing more than 21024 elements.
Before the Diffie-Hellman key exchange is started, in some embodiments, Alice and Bob agree on a huge, finite commutative group (G, *) with group operation * and generating element g in G, where g has a huge order. In some embodiments, Alice and Bob sometimes agree on group (G, *) and element g before before the key exchange starts; g is assumed to be known by Eve. The group operations of G are expressed multiplicatively as explained previously.
In a standard Diffie-Hellman key exchange, Alice executes steps 1 and 3 and Bob executes steps 2 and 4.
The Diffie-Hellman exchange [54, 55] is vulnerable to active man-in-the-middle attacks [59, 60, 61]. To address man-in-the-middle attacks, processes 10 and 11 show how to hide public session keys during a key exchange. In some embodiments, Alice and Bob have previously established secret scatter map σ=(l1, l2 . . . lm) and authentication key κ with a one-time pad [35]. In another embodiment, Alice and Bob may establish σ and κ with a prior (distinct) Diffie-Hellman exchange that is resistant to quantum computers, executing Shor's algorithm [62] or an analogue of Shor's algorithm [63]. Alternatively, Alice and Bob may establish σ and κ via a different channel.
Let hκ denote an MAC (e.g., HMAC [64] or [65]) function which will be used to authenticate the scattered transmission. The use of hκ helps hinder the following attack by Eve. An active Eve could flip a bit at bit location l in the scattered transmission. If no authentication occurs on the noise and the hidden key bits, then upon Alice resending a scattered transmission due to Alice and Bob not arriving at the same session key secret, Eve gains information that l lies in σ. If the scattered transmission is not authenticated, Eve's manipulation of the bits in
helps her violate rule 4.
= (s1 . . . sn).
).
and hκ(
) to Bob.
′ and hκ(
) from Alice.
′) and checks it against hκ(
).
′) is valid
.
′ and asks Alice to resend
.
Note that Alice sends and Bob receives
′ because during the transmission from Alice to Bob
may be tampered with by Eve or
may change due to physical effects. In an embodiment of process 10, Bob's steps are performed in receiving machine 112. In an embodiment of process 10, Alice's steps are performed in sending machine 102. In an embodiment of process 10, private key(s) 103 is a and public key(s) 104 is ga. In an embodiment of process 10, scatter map a finds the hiding locations with scatter map instructions 130.
In an embodiment, the size of the transmission (hidden public keys 109) is n=8192 bits and the noise size ρ=6400. According to σ=(l1, l2 . . . lm), the kth bit of P is stored in bit location lk. Generator g is an element of a commutative group (G, *) with a huge order. In some embodiments, G is a cyclic group and the number of elements in G is a prime number. In an embodiment, generator g has an order o(g)>1080. In another embodiment, generator g has an order o(g) greater than 101000. In an embodiment, Alice randomly generates with non-deterministic generator 942 in
= (t1 . . . tn).
).
and hκ(
) to Alice.
′ and hκ(
) from Bob.
′) and checks it against hκ(
).
′) is valid
.
′ and asks Bob to resend
.
Note that Bob sends and Alice receives
′ because during the transmission from Bob to Alice
may be tampered with by Eve or
may change due to physical effects. In an embodiment of process 11, Alice's steps are performed in receiving machine 112. In an embodiment of process 11, Bob's steps are performed in sending machine 102. In an embodiment of process 11, private key(s) 103 is b and public key(s) 104 is gb. In an embodiment of process 11, scatter map σ finds the hiding locations with scatter map instructions 130.
In an embodiment, Bob randomly generates with non-deterministic generator 952 in in process 11.
In some embodiments, hiding a public key during an exchange between Alice and Bob has an advantage over hiding a symmetric key: processes 10 and 11 can be used by Alice and Bob, before a subsequent encrypted communication, to communicate a short authentication secret (SAS) [66] via a different channel.
Let a, b be Alice and Bob's private keys, respectively. Let e1, e2 be Eve's private keys. For a key exchange, if Eve is in the middle, Eve computes ge
It is important to recognize the difference between SAS and hiding the public keys in random noise: they are complementary methods. SAS helps notify Alice and Bob that a man-in-the-middle on a standard Diffie-Hellman exchange has occurred, but SAS DOES NOT stop a man-in-the-middle attack. SAS does not stop an adversary who has unforeseen computing power or unknown mathematical techniques. The standard Diffie-Hellman exchange depends upon the conjectured computational complexity of the underlying commutative group operation * on G. If Eve is recording all network traffic, hiding public session keys inside random noise can stop Eve from breaking the standard key exchange even if Eve has already discovered a huge, computational or mathematical breakthrough on the underlying group G or if Eve finds one at some point in the future. Public keys that are resistant to quantum computing algorithms such as Shor's algorithm are quite large (e.g., 1 million bytes and in some cases substantially larger than 1 million bytes). In contrast, 1024 bytes of hidden public keys inside noise can provide adequate protection against quantum algorithms; in other embodiments, 4096 bytes of hidden public keys inside noise provides strong protection against quantum algorithms. Processes 10 and 11 complementary property to SAS depends upon Eve not obtaining σ; in some embodiments, a one-time pad may be feasible to establish a between Alice and Bob.
Structural stability is a mathematical and engineering tool that we want to apply to computer programs because a register machine program can be modeled as a discrete, autonomous dynamical system. When a perturbed instruction is close enough to an original instruction that is stable, then the computational behavior of the program will not change. For this reason, structural stability can be used as a mathematical tool to help design a solution that hinders malware sabotage. Overall, we briefly describe topological spaces, metric spaces and structural stability before we specify how to build a stable sequential machine.
A topology [23] on a set X is a collection of subsets of X having the following properties: (a) ø and X are both in
; (b) The union of the elements of any subcollection of
is in
; (c) The intersection of the elements of any finite subcollection of
is in
. A set X for which a topology
has been specified is called a topological space. A subset U of X is called open in this topology if U belongs to the collection
.
Let be the real numbers. For real numbers a and b, the open intervals (a, b)={x∈
: a<x<b} form a basis for the standard topology on
, generated from arbitrary unions of open intervals and finite intersections of open intervals.
Let X and Y be topological spaces. The function ƒ: X→Y is continuous if for any open subset U of Y, the inverse image ƒ−1(U)={x∈X: ƒ(x) lies in U} is open in X's topology. The function h: X→Y is a homeomorphism if h is continuous, h is one-to-one and onto, and h's inverse h−1: Y→X is continuous.
A discrete, dynamical system is a function ƒ: X→X, where X is a topological space. The orbit of p is {ƒn(p): n∈}, which is the set of points, obtained by iterating ƒ on initial point p. Consider discrete, dynamical systems ƒ: X→X and g: Y→Y. ƒ and g are topologically conjugate if ƒ and g are continuous functions and there exists a homeomorphism h: X→Y such that h∘ƒ=g∘h. Topologically conjugate functions exhibit equivalent dynamics. For example, if ƒ is topologically conjugate to g via h and p is a fixed point for ƒ, then h(p) is a fixed point for g.
Topological conjugacy is a useful notion for computation because after a register machine has halted, its halted machine configuration represents what the machine has computed. Furthermore, each halted machine configuration corresponds to a fixed point (halting point) of a dynamical system that faithfully models the register machine. If h is a topological conjugacy with h∘ƒ=g∘h, then p is a fixed point of ƒ if and only if h(p) is a fixed point. Hence, a topological conjugacy between machines M1 and M2 induces a one-to-one correspondence between the halting configurations of Mi and M2.
A metric space is a set X and a function (metric) d: X×X→ (real numbers) such that the following three conditions hold.
1. d(a, b)≥0 for all a, b∈X where equality holds if and only if a=b.
2. d(a, b)=d(b, a) for all a, b∈X. (Symmetric).
3. d(a, b)≤d(a, c)+d(c, b) for all a, b, c∈X. (Triangle inequality).
For ϵ>0, define the ϵ-ball Bd(x, ϵ)={y∈X: d(x, y)<ϵ}. The collection of all ϵ-balls, where ϵ>0 and x∈X, is a basis for a metric topology on X, induced by metric d.
Let (X, d) be a metric space. The C0 distance between functions ƒ: X→X and g: X→X is given by ρ0(ƒ, g)=sup{d(ƒ(x), g(x)): x∈X}, where sup is the least upper bound. A function ƒ: X→X is said to be C0 structurally stable on X if there exists ϵ>0 such that whenever ρ0(ƒ,g)<ϵ for g: X→X, then ƒ is topologically conjugate to g. In other words, a dynamical system ƒ is structurally stable if for all dynamical systems g that are close to ƒ, then ƒ is topologically conjugate to g.
In our invention(s), we have two design criteria, developed in section 7:
A. Build instructions that are invariant to small changes in their representation.
B. Hinder the adversary from figuring out how to manipulate these machine instructions.
We start with a Turing complete, register machine, as a starting point for building computation that satisfies our two design criteria for our invention(s). We describe machine procedures that transform these register machine instructions: these transformation procedures, implemented in hardware, execute the functionality of the register machine instructions so that the computation is stable under small changes to the transformed instructions. In an embodiment, these procedures execute in Protected Machine Hardware 1502 of
Below is a description of instructions for an embodiment of a register machine, executed by processor system 258 in
SET A 14 stores 14 in register A.
ADD B C adds the contents of registers B and C and stores the sum in register B.
SUB C 13 subtracts 13 from the contents of register C and stores the difference in register C.
MUL D C multiplies the contents of register D and register C and stores the product in register D.
DIV A 7 divides the contents of register A by 7 and stores the quotient in register A. If A contains 26, then after DIV A 7 is executed register A contains 3.
MOD A 7 divides the contents of register A by 7 and stores the remainder in A. If register A contains 26, then after MOD A 7 is executed register A contains 5.
JMP L_-AB updates the program counter to execute the instruction tagged by label L_AB. If L_-AB contains 37, then instruction 37 will be executed next. JMP acts as an unconditional branch instruction.
IF A B executes the next instruction if the contents of register A equals the contents of register B. Otherwise, the next instruction is skipped. IF is an embodiment of a conditional branch instruction.
IFN C 5 executes the next instruction if the contents of register C are not equal to 5. If register C contains 5, the next instruction is skipped. IFN is an embodiment of a conditional branch instruction.
IFGT C 12 executes the next instruction if the contents of register C are greater than 12. If register C contains a number less than 13, the next instruction is skipped. IFGT is an embodiment of a conditional branch instruction.
The opcode for instruction name SET represents SET in terms of bits. The other instruction names {ADD,SUB,MUL,DIV,MOD,JMP,IF,IFN,IFGT, STORE, GET} each have their own unique opcode in terms of bits. An opcode is mathematically defined as a function : {SET, ADD, SUB, MUL, DIV, MOD, JMP, IF, IFN, IFGT, STORE,GET}→{0,1}n such that
is 1-to-1. One-to-one means
maps two different instruction names to two distinct n-bit strings. A valid instruction starts with an instruction name, followed by one or two operands. In instruction IFGT C 12, register C is the first operand and the number 12 is the second operand. The JMP instruction is the only instruction with one operand.
Program 1 implements a greatest common divisor algorithm with these register machine instructions. In section 12.2, stable machine (SM) tools are described that transform these instructions so that the program instructions are hidden, stable and unpredictable. Any symbols on the same line of program 1, that follow a semicolon, are comments.
We describe a procedure that randomizes opcodes such that each opcode is a minimal Hamming distance apart. Our random opcode procedure is a computational tool for helping us achieve our two design criteria.
First, we review some definitions from information theory. {0, 1}n is the collection of all n-bit strings, where each binary string a in {0, 1}n can represent an opcode of a virtual machine instruction. Sometimes b in {0, 1}p can represent an operand of a virtual machine instruction, and in some cases n≠p.
Let a=a1, . . . an and b=b1, . . . bn be binary strings of length n. For each n, the Hamming distance [67](Hamming metric) is defined as
It is easy to verify that ({0, 1}n, d) is a metric space per section 11.3.
Note that the Hamming distance between string 0010 and string 0111 is expressed as d(0010, 0111)=2. Consider string c=c1 . . . cn in {0, 1}n. A Hamming ball H(c, m)={a∈{0, 1}n: d(c, a)≤m} has center c and radius m.
q is a non-deterministic generator, as shown in non-deterministic generator 942 of
Machine procedure 1 builds an n-bit random opcode Ij,1Ij,2 . . . Ij,n used by instruction Ij, after random bit generator q measures n random bits. In an embodiment, machine procedure 1 uses a non-deterministic generator q as shown in non-deterministic generator 942 of
The jth random opcode, called Ij, is n bits long. Machine procedure 2 begins with m random opcodes I1, I2, . . . , Im as input. Machine procedure 2 finds two distinct opcodes in {I1, I2, . . . , Im} that are a smallest Hamming distance hμ apart.
Machine procedure 3 uses machine procedures 1 and 2 to build m random opcodes (n-bit codes) that are pairwise at least a Hamming distance of 2l+1 apart.
Flip bit k means: if the kth bit is 0, then set the kth bit to 1; and if the kth bit is 1, then set the kth bit to 0. Variable r counts the number of repairs on a random opcode until all random opcodes are at least a Hamming distance of 2l+1-bits apart. 2l+1 should be about 1 to 2.5 standard deviations less than
so that the outer loop while hμ<(2l+1) exits in a reasonable amount of time. (
is the expected Hamming distance between two random n-bit codes, where each bit (0 or 1) occurs with probability 1/2.)
If l is too large (e.g., (2l+1)>n), then the outer loop never exits and r→∞. To avoid long computing times, a variation of procedure 3 adds, before the outer loop, instruction set l=└1/4(n−c√{square root over (n)})−1/2┘, where 1≤c≤5/2. (The standard deviation of uniformly random n-bit codes is
In our cryptographic model, Alice's m random opcodes I1, I2, . . . Im “act as her private keys.” Hence, her random opcodes must be generated and stored in Protected Machine Hardware (blue region in
This section defines and specifies instruction and opcode stability, used in our hardware embodiments of machine procedures, 1, 2, 3, 4, 5, 6, and 7, and implemented in
Definition 8. A set of opcodes (or operands) {I1, . . . , Im} is s-bit stable if min{d(Ij, Ik): j≠k}≥s. In other words, if Ij and Ik are the closest opcodes (operands) in {I1, . . . , Im}, then d(Ij, Ik)≥s.
Definition 9. An n-bit instruction I is s-bit stable if its opcode and operands are both s-bit stable.
Remark 4. The random opcodes generated by a successful exit of procedure 3 are 2l+1-bit stable.
Machine procedure 2 returns hμ. hμ is the minimum distance between any two distinct opcodes in {I1, . . . , Im}. A successful exit of machine procedure 3 means the loop while hμ<(2l+1) exited; hence, hμ≥2l+1.
Using definitions 8, 9 and remark 4, we can explain the stability of programs, transformed by machine procedures 1, 2 and 3, in terms of the description in section 11. First, we need to define a metric on a space of programs, where each program is a finite sequence of transformed (procedures 1, 2 and 3) instructions (before hiding). Consider a program of transformed instructions 1=(I1, I2, . . . , Im) and another program of transformed instructions
2=(J1, J2, . . . , Jm). If two programs have the same length m, define the distance between them as
(
1,
2)=max{d(Ik, Jk): 1≤k≤m}. If programs
and
have different lengths, then define
(
,
)=n, where all program instructions in
and
lie in {0, 1}n.
In program 1=(I1, I2, . . . , Im), for each k such that 1≤k≤m, machine procedure 3 can build each instruction Ik so that Ik is 2l+1-bit stable. Consider
1 as a dynamical system. Program
1 is structurally stable because whenever
(
1,
2)≤l each instruction Jk in P2 that corresponds to Ik is resolved to the same opcode and same operand(s). Hence, the dynamical (computing) behavior of
1 is the same as program
2: this means programs
1 and
2 perform the same task. Structural stability helps protect the integrity of the computation.
In 12.2, we described machine procedures 1, 2, and 3 for building random opcodes stable to small changes. When machine procedures 1, 2, and 3 are also applied to operands, the representation of the operands can become stable to small changes. In our model, Eve is a sentient adversary, so structural stability from classical mathematics alone does not provide enough mathematical firepower to build malware resistant computation. Hence, the purpose of design criteria B is to make a representation of each instruction that is computationally intractable for Eve to understand its meaning.
Machine procedure 4 builds a random permutation.
Machine procedure 5 uses machine procedure 4 to build a random substitution box.
The rest of this subsection describes how to hide the meaning of the opcodes and operands from Eve. Machine procedures 4 and 5 have different purposes even though they both generate a random permutation. Machine procedure 5 constructs a σ that has size 2η. In some embodiments, η=8 because 8 bits is a byte, and n=16 is more expensive to build in hardware. If η=16, then σ has size 216=65536. Our goal is to store σ in protected machine hardware (
Machine procedure 4 builds ρ to locate the 64 bits of the signal b1b2 . . . b64 inside the random noise. ρ lies in the symmetric group on {1, 2, . . . , n}, and determines where each bit of the signal (i.e., opcode or operand) is located: the ith bit bi is stored at bit location ρ(i), where 1≤i≤64. When there are 64 bits of signal from the operand or opcode and 64 bits of quantum random noise, then the size of ρ is 128, i.e., n=128.
Random noise is measured and stored in the remaining 64 bit locations. The result is 128 bits of noise and signal, named s1 . . . s128. Subsequently, the 16 randomly generated sboxes σi with 1≤i≤16 are applied to s1s2 . . . s128 as follows: σ1 (s1s2s3s4s5s6s7s8), σ2(s9 . . . s16), . . . σ16(s121s122s123s124s125s126s127s128), which is named c1c2 . . . c128. Next, a distinct random permutation τ is generated on {1, 2, . . . , 128}. τ is applied to c1c2 . . . c128, resulting in cτ(1) cτ(2) . . . cτ(128). Then sixteen distinct sboxes α1 . . . α16 are randomly generated and applied to cτ(1)cτ(2) . . . cτ(128) as follows: α1(cτ(1)cτ(2) . . . cτ(8)) . . . α16(cτ(121) . . . cτ(128)), resulting in o1 . . . o128.
In subsection 14, a birthday paradox statistical test is described in order to address potential attacks that involve stable instructions of size 128 bits. The birthday attack test performs 2l compilations of the same unmasked instruction. In 14, we also describe a statistical test to address multiple transformations via machine procedure 6 of the same instruction at different locations in a single SM compilation of the program.
For each time the SM compilation tool is executed, all ρ, σi, τ, αi and randomized opcodes are statistically independent from each other and from all previous compilations. Also, within one SM compilation, the random noise (n−k bits per opcode) generated for two identical opcodes at different locations in the program is statistically independent.
From our prior description, machine procedure 6 formally specifies hiding a k-bit opcode (or operand) b1 . . . bk in n−k bits of random noise. ρ and τ are distinct random permutations on {1,2, . . . ,n}. ρ determines the bit locations of b1 . . . bk hidden inside of noise. σ1 . . . σp, and α1 . . . αp are random sboxes. In some embodiments, machine procedure 6 executes in protected machine hardware 1502 in
In machine procedure 6,
In an embodiment, permutation ρ is implemented with a Butterfly network in hardware. (A Butterfly network is shown in
Machine procedure 7 hides the hidden stable instructions, constructed by machine procedure 6, inside a block of size b containing dummy instructions. b is the sum of the number of stable instructions and the number of dummy instructions in the block. m is the maximum number of stable instructions hidden. γ is a random permutation on {1, 2, . . . , b}. S1, S2, . . . , Sm are a sequence of stable instructions that are part of the program.
}, and m is determined during compilation and m can be randomly selected for each block, Eve does not know how many valid instructions are in a block. Eve does not know the probability distribution of valid versus dummy instructions in a block; and Eve does not know the block size. Eve does not know y, and she does not know how to distinguish a dummy opcode from a valid opcode, since the dummy opcodes are also selected using machine procedure 1.
In our cryptographic model, Alice's Protected Machine Hardware (
After reading one or more hidden machine instructions from memory system 198 in
1. Unmask and find the nearest valid opcode.
2. Extract the operands from the noise.
3. Execute a valid instruction.
In our cryptographic model, our hardware embodiments execute all three steps in the blue region of Protected Machine Hardware, shown in
With our model assumption about Eve, we proceed to examine steps 1, 2, and 3 in more detail. We developed a machine (compilation tool), called SM (stable machine), in ANSI C [34] that performs these 3 steps. In general, our SM tool can execute any hidden program that operates according to the register machine instructions, described in section 12.1. After a brief summary of steps 1, 2, and 3, we demonstrate an example of our SM tool, executing our greatest common divisor program with hidden, stable register machine instructions.
We assume that our cryptographically stable instructions are stored in Unprotected Memory, as shown in in
After the last instruction SET B A executes, both registers A and B are storing 2. Observe that the instruction numbers in an SM program always start at 0, so JMP 2 causes the machine to execute IF A 0.
Next, we show what our GCD program looks like to Eve in Unprotected Memory after two distinct compilations, generated by our SM tool. In compilations 1 and 2, we selected input n=64 for machine procedure 1, and inputs l=25, m=12, and n=64 for machine procedure 3. In compilation 1 and 2, we selected input n=128 for machine procedure 4; input η=8 for machine procedure 5; and inputs k=64 and n=128 for machine procedure 6. This means the first and the second operands are hidden in 128 bits: 64 bits of signal and 64 bits of noise.
In compilation 1, the unmasked instruction IF A 0 is represented by the stable, hidden instruction:
In compilation 2, the unmasked instruction IF A 0 is represented by the stable, hidden instruction:
0x4bcb256be98d9202 0xcde07c9d5cc3f829 0x3312667ff99273d2 0x714e581cb4683b7a 0x6e9701310cd75a60
The first part 0x4bcb256be98d9202 (64 bits) hides the opcode IF; the second and third blocks 0xcde07c9d5cc3f829 0x3312667ff99273d2 (64 bits each) hide the first operand A; the fourth and fifth blocks 0x714e581cb4883b7a 0x6e9701310cd75a60 hide the second operand 0.
As an example of the effectiveness of our hiding procedures, the Hamming distance between the 64-bit hidden opcode 0xe26e1277d3a579bf in compilation 1, representing SET in unmasked instruction SET A 6, and the 64-bit hidden opcode 0xaeb9650c9511ba48 in compilation 2, also representing SET, is 39. The expected Hamming distance for two hidden opcodes that are statistically independent is 32. The standard deviation is
so 39 is less than two standard deviations away from the expected Hamming distance.
The hiding is also effective for two of the same unmasked opcodes in the same compilation: in compilation 1, the Hamming distance d(0xe26e1277d3a579bf, 0x99a72e62201e3930)=35, where 0xe26e1277d3a579bf represents SET in SET A 6, and 0x99a72e62201e3930 represents SET in SET B 10.
The first test searches for a birthday paradox attack with distinct SM compilations of a fixed 64-bit random opcode in the unmasked instruction SET A 6.
We used n=64 for procedure 1 to generate the random opcode for SET, and inputs l=12, m=12, and n=64 for procedure 3. We used input n=128 for procedure 4; and input η=8 for procedure 5; and inputs k=64 and n=128 for procedure 6. We searched for collisions, where 75% of the bits match: that is, where the Hamming distance was greater than 96 for two opcode portions of the instruction SET A 6.
The statistics for 44850 Birthday paradox collision search comparisons are shown below, where each tally is the hamming distance between two 128-bit hidden opcodes, generated from instruction SET A 6. Let h, be the number of pairs of distinct stable instructions whose 128 bits of opcode are a Hamming distance of i bits apart. Between the two dashed lines is the data for a typical run with 300 stable instructions generated from SET A 6.
TOTAL number of Hamming distances hi computed=44850.
h40=1, h41=1, h42=0, h43=2, h44=4, h45=6, h46=14, h47=33, h48=64, h49=87, h50=150, h51=237, h52=328, h53=460, h54=667, h55=902, h56=1114, h57=1451, h58=1809, h59=2142, h60=2516, h61=2795, h62=2927, h63=3068, h64=3157, h65=3184, h66=2929, h67=2729, h68=2492, h69=2100, h70=1809, h71=1522, h72=1115, h73=929, h74=676, h75=480, h76=361, h77=219, h78=145, h79=93, h80=57, h81=38, h82=18, h83=12, h84=1, h85=6. When i>85, hi=0.
Empirical mean=64.02. μ=64. Expected standard deviation σ=5.66.
30039 hi are within σ of μ. Expected hi within σ=30615, 42973 hi are within 2σ of μ. Expected hi within 2σ=42805, 44714 hi are within 3σ of μ. Expected hi within 3σ=44733.
No Hamming distances were close to 96 (75% of 128).
In test 2, we searched for an attack by looking at multiple compilations of the same instruction at different locations in a single SM compilation of the program. To simplify this search and make an attack easier to find, we built a program with 150 identical instructions: SET A 6. After one compilation, we computed pairwise Hamming distances. Statistics for a typical run of test 2 are shown below between the two dashed lines.
TOTAL number of Hamming distances hi computed=11175.
h43=4, h44=2, h45=3, h46=4, h47=7, h48=15, h49=30, h50=43, h51=43, h52=75, h53=122, h54=167, h55=237, h56=309, h57=389, h58=467, h59=520, h60=648, h61=667, h62=701, h63=753, h64=867, h65=782, h66=697, h67=670, h68=655, h69=535, h70=437, h71=345, h72=259, h73=223, h74=168, h75=117, h76=82, h77=46, h78=37, h79=23, h80=10, h81=7, h82=6, h83=1, h84=1, h85=1, When i>85, hi=0.
Empirical mean=63.90. μ=64. Expected standard deviation σ=5.66
7495 hi are within σ of μ. Expected hi within σ=7628, 10735 hi are within 2σ of μ. Expected hi within 2σ=10665, 11139 hi are within 3σ of μ. Expected hi within 3σ=11146.
No Hamming distances were close to 96; the statistics follow a binomial distribution with p=1/2. In general, we do not expect this attack to be effective for Eve because Alice should not voluntarily compile her plaintext code with static “keys” on plaintext code that repeats the same instruction multiple times on purpose. Furthermore, Eve's potential collisions occur only on “keys” that Eve artificially constructs with the SM tool. In a proper use setting, Alice uses a different set of “keys” and randomized opcodes on each separate compilation on a particular machine, and procedure 7 further reduces the efficacy of this type of attack.
Although the invention(s) have been described with reference to specific embodiments, it will be understood by those skilled in the art that various changes may be made and equivalents may be substituted for elements thereof without departing from the true spirit and scope of the invention. In addition, modifications may be made without departing from the essential teachings of the invention.
This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 62/085,338, entitled “Hiding Data Transmissions in Random Noise”, filed Nov. 28, 2014, which is incorporated herein by reference; this application claims priority benefit of U.S. Provisional Patent Application Ser. No. 62/092,795, entitled “Hiding Data Transmissions in Random Noise”, filed Dec. 16, 2014, which is incorporated herein by reference; this application claims priority benefit of U.S. Non-provisional patent application Ser. No. 14/953,300, entitled “Hiding Information in Noise”, filed Nov. 28, 2015, which is incorporated herein by reference. This application claims priority benefit of U.S. Non-provisional Pat. No. 10,360,395, entitled “Hiding Information in Noise”, issued Jul. 23, 2019, which is incorporated herein by reference. This application claims priority benefit of U.S. Non-provisional Pat. No. 10,356,061, entitled “Hiding a Public Key Exchange in Noise”, issued Jul. 16, 2019, which is incorporated herein by reference. This application is a continuation-in-part of U.S. Non-provisional patent application with Ser. No. 16/442,455, entitled “Dynamically Hiding Information in Noise”, filed Jun. 15, 2019. This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 63/210,500, entitled “Hiding Stable Machine Instructions in Noise”, filed Jun. 15, 2021, which is incorporated herein by reference.
| Number | Date | Country | |
|---|---|---|---|
| Parent | 62085338 | Nov 2014 | US |
| Child | 17516722 | US | |
| Parent | 62092795 | Dec 2014 | US |
| Child | 62085338 | US | |
| Parent | 14953300 | Nov 2015 | US |
| Child | 62092795 | US | |
| Parent | 16442455 | Jun 2019 | US |
| Child | 14953300 | US | |
| Parent | 63210500 | Jun 2021 | US |
| Child | 16442455 | US |
