Saturday, April 28, 2018

welcome back to war! another day in paradise! ...boolean tribe, get a look at this code ...and particularly " The weights of their machines are different, as they are randomly initialized. If they could synchronize the weights of their machines (without transferring the actual weights, of course) they could then use those weights as a cryptographic key for the rest of their communication. The following algorithm is used to synchronize the weight matrices of Bob's and Alice's machines:.."

Neural Key Exchange using Tree Parity Machine in Python
Python
Latest commit d6ace8e on 24 Jan 2016

 README.md

neuralkey

Neural Key Exchange using Tree Parity Machine in Python
Hi! This is an implementaion of the Neural Key Exchange Protocol in python written with simplicity, understandability and code readability in mind. Suiltable for academic and researh purposes. The code is documented line by line, so lets get straight to theory.

Diffie–Hellman key exchange
If Alice and Bob wish to communicate with each other by exchanging encrypted messages, each of them should be able to decrypt the messages received from the other. And to do so, they have to exchange the keys with which the messages will be encrypted, and should be carefull not to let Eve get hold of the keys, or else she too would be able to decrypt the messages. So a secure protocol should be used for exchanging the keys, or else nosy Eve would be able to read all of Bob's and Alice's messages. Neural or not, the most used protocol for key exchange between two parties A and B is the Diffie-Hellman protocol. Diffie–Hellman Key Exchange establishes a shared secret between two parties that can be used for secret communication for exchanging data over a public network. The following conceptual diagram illustrates the general idea of the key exchange by using colors instead of very large numbers:
Diffe-Hellman

Neural Key Exchange Protocol
The Diffe-Hellman protocol can be implemented using a neural neural network with a single hidden layer (also called a tree parity machine). The number neurons in the hidden layer is denoted as K and the number of input neurons per hidden neuron is denoted as N. There is a weight matrix W between the input and hidden layers of dimensions KxN and the range of each weight is {-L, ..., -2, -1, 0, 1, 2, ..., +L} where L is a parameter of the tree.
tpm
Both Bob and Alice posses tree parity machines with same set of parameters (KN and L). The weights of their machines are different, as they are randomly initialized. If they could synchronize the weights of their machines (without transferring the actual weights, ofcourse) they could then use those weights as a cryptographic key for the rest of their communication. The following algorithm is used to synchronize the weight matrices of Bob's and Alice's machines:
algorith
For a given random input vector x (of dimensions [K,N]), the output (tau) of a tree parity machine is computed as follows:
eqn1
eqn2
eqn2
eqn3
eqn4
And if the outputs of both Alice's and Bob's machines are equal, their weights are update using any of the following rules:
  • Hebbian rule:
hebbian
  • Anti-hebbian rule:
anti-hebbian
  • Random-walk:
random-walk

The Code

The code is heavily documented. It consists of 4 files, machine.py, which defines a tree parity machine, update_rules.py, which contains functions for all the three update rules, run.py which simple creates 2 machines with default parameters and try to sync them and eve.py which is similar to run.py, except that nosy Eve will be trying to sync her machine with Alice's and Bob's. Will she get what she wants?
Installation
sudo git clone http://www.github.com/farizrahman4u/neuralkey.git
cd neuralkey/neuralkey
python run.py
python eve.py
Requirements
TODO
  • Simulate Eve and man in the middle attack
  • Improve visualization

#Bye!!

No comments: