Neural cryptography

The tree parity machine is a special type of multi-layer feedforward neural network.

It consists of one output neuron, K hidden neurons and K×N input neurons. Inputs to the network take three values:

${\displaystyle x_{ij}\in \left\{-1,0,+1\right\}}$

The weights between input and hidden neurons take the values:

${\displaystyle w_{ij}\in \left\{-L,...,0,...,+L\right\}}$

Output value of each hidden neuron is calculated as a sum of all multiplications of input neurons and these weights:

${\displaystyle \sigma _{i}=\operatorname {sgn}(\sum _{j=1}^{N}w_{ij}x_{ij})}$

Signum is a simple function, which returns −1,0 or 1:

${\displaystyle \operatorname {sgn}(x)={\begin{cases}-1&{\text{if }}x<0,\\0&{\text{if }}x=0,\\1&{\text{if }}x>0.\end{cases}}}$

If the scalar product is 0, the output of the hidden neuron is mapped to −1 in order to ensure a binary output value. The output of neural network is then computed as the multiplication of all values produced by hidden elements:

${\displaystyle \tau =\prod _{i=1}^{K}\sigma _{i}}$

Output of the tree parity machine is binary.

Each party (A and B) uses its own tree parity machine. Synchronization of the tree parity machines is achieved in these steps

1. Initialize random weight values
2. Execute these steps until the full synchronization is achieved
   1. Generate random input vector X
   2. Compute the values of the hidden neurons
   3. Compute the value of the output neuron
   4. Compare the values of both tree parity machines
      1. Outputs are the same: go to 2.1
      2. Outputs are different: one of the suitable learning rules is applied to the weights

After the full synchronization is achieved (the weights w_ij of both tree parity machines are same), A and B can use their weights as keys.
This method is known as a bidirectional learning.
One of the following learning rules[1] can be used for the synchronization:

• Hebbian learning rule:

${\displaystyle w_{i}^{+}=g(w_{i}+\sigma _{i}x_{i}\Theta (\sigma _{i}\tau )\Theta (\tau ^{A}\tau ^{B}))}$

• Anti-Hebbian learning rule:

${\displaystyle w_{i}^{+}=g(w_{i}-\sigma _{i}x_{i}\Theta (\sigma _{i}\tau )\Theta (\tau ^{A}\tau ^{B}))}$

• Random walk:

${\displaystyle w_{i}^{+}=g(w_{i}+x_{i}\Theta (\sigma _{i}\tau )\Theta (\tau ^{A}\tau ^{B}))}$

Where:

${\displaystyle \Theta (a,b)=0}$ if ${\displaystyle a\neq b}$ otherwise ${\displaystyle \Theta (a,b)=1}$

And:

${\displaystyle g(x)}$ is a function that keeps the ${\displaystyle w_{i}}$ in the range ${\displaystyle \{-L,-L+1,...,0,...,L-1,L\}}$

In every attack it is considered, that the attacker E can eavesdrop messages between the parties A and B, but does not have an opportunity to change them.

To provide a brute force attack, an attacker has to test all possible keys (all possible values of weights wij). By K hidden neurons, K×N input neurons and boundary of weights L, this gives (2L+1)^KN possibilities. For example, the configuration K = 3, L = 3 and N = 100 gives us 3*10²⁵³ key possibilities, making the attack impossible with today's computer power.

One of the basic attacks can be provided by an attacker, who owns the same tree parity machine as the parties A and B. He wants to synchronize his tree parity machine with these two parties. In each step there are three situations possible:

1. Output(A) ≠ Output(B): None of the parties updates its weights.
2. Output(A) = Output(B) = Output(E): All the three parties update weights in their tree parity machines.
3. Output(A) = Output(B) ≠ Output(E): Parties A and B update their tree parity machines, but the attacker can not do that. Because of this situation his learning is slower than the synchronization of parties A and B.

It has been proven, that the synchronization of two parties is faster than learning of an attacker. It can be improved by increasing of the synaptic depth L of the neural network. That gives this protocol enough security and an attacker can find out the key only with small probability.

For conventional cryptographic systems, we can improve the security of the protocol by increasing of the key length. In the case of neural cryptography, we improve it by increasing of the synaptic depth L of the neural networks. Changing this parameter increases the cost of a successful attack exponentially, while the effort for the users grows polynomially. Therefore, breaking the security of neural key exchange belongs to the complexity class NP.

Alexander Klimov, Anton Mityaguine, and Adi Shamir say that the original neural synchronization scheme can be broken by at least three different attacks—geometric, probabilistic analysis, and using genetic algorithms. Even though this particular implementation is insecure, the ideas behind chaotic synchronization could potentially lead to a secure implementation.[2]

The permutation parity machine is a binary variant of the tree parity machine.[3]

It consists of one input layer, one hidden layer and one output layer. The number of neurons in the output layer depends on the number of hidden units K. Each hidden neuron has N binary input neurons:

${\displaystyle x_{ij}\in \left\{0,1\right\}}$

The weights between input and hidden neurons are also binary:

${\displaystyle w_{ij}\in \left\{0,1\right\}}$

Output value of each hidden neuron is calculated as a sum of all exclusive disjunctions (exclusive or) of input neurons and these weights:

${\displaystyle \sigma _{i}=\theta _{N}(\sum _{j=1}^{N}w_{ij}\oplus x_{ij})}$

(⊕ means XOR).

The function ${\displaystyle \theta _{N}(x)}$ is a threshold function, which returns 0 or 1:

${\displaystyle \theta _{N}(x)={\begin{cases}0&{\text{if }}x\leq N/2,\\1&{\text{if }}x>N/2.\end{cases}}}$

The output of neural network with two or more hidden neurons can be computed as the exclusive or of the values produced by hidden elements:

${\displaystyle \tau =\bigoplus _{i=1}^{K}\sigma _{i}}$

Other configurations of the output layer for K>2 are also possible.[3]

This machine has proven to be robust enough against some attacks[4] so it could be used as a cryptographic mean, but it has been shown to be vulnerable to a probabilistic attack.[5]

A quantum computer is a device that uses quantum mechanisms for computation. In this device the data are stored as qubits (quantum binary digits). That gives a quantum computer in comparison with a conventional computer the opportunity to solve complicated problems in a short time, e.g. discrete logarithm problem or factorization. Algorithms that are not based on any of these number theory problems are being searched because of this property.

Neural key exchange protocol is not based on any number theory. It is based on the difference between unidirectional and bidirectional synchronization of neural networks. Therefore, something like the neural key exchange protocol could give rise to potentially faster key exchange schemes.[2]