Homomorphic Encryption with Learning With Errors (LWE)
By: Prof Bill Buchanan Obe
Tags: Security, Cybersecurity, Cryptograph

Photo by Chris Liverani on Unsplash

We secure data in its transit, and at its rest, but what happens in process? Well, we are perhaps moving into a world which will protect data at every point of its journey. This will be a world of homomorphic encryption.

LWE

Learning With Errors (LWE) is a quantum robust method of cryptography. Initially we create a secret value (s) and which is our private key. We then create a public key which is based on random numbers (A), and then generate another set of numbers (B) which is based on A, s and random errors e. In this case we will show how a 4-bit value can be encrypted. In this case we will convert an integer to a 4-bit value, and then cipher each of the bits. This is achieved by generating a public key, and then sampling the public key for each of the bits.

First we select a random series of values for our public key (A). For example, let’s select 20 random values from 0 to 100:

[80, 86, 19, 62, 2, 83, 25, 47, 20, 58, 45, 15, 30, 68, 4, 13, 8, 6, 42, 92]

Next we add create a list (B) and were the elements are Bi=Ais+ei(modq), and where s is a secret value, and e is a list of small random values (the error values). If we take a prime number (q) of 97, and an error array (e) of:

[3, 3, 4, 1, 3, 3, 4, 4, 1, 4, 3, 3, 2, 2, 3, 2, 4, 4, 1, 3]

we generate a list (B) of:

[15, 45, 2, 20, 13, 30, 32, 45, 4, 3, 34, 78, 55, 51, 23, 67, 44, 34, 17, 75]

The A and B list will be our public key, and s will be our secret key. We can now distribute A and B to anyone who wants to encrypt a message for us (but keep s secret). To encrypt we take samples from the A and B lists, and take a message bit (M), and then calculate two values:

The encrypted message is (u,v ). To decrypt, we calculate:

If Dec is less than q2 , the message is a zero, else it is a 1.

For homomophic encryption, we can perform a single-bit adder function by generating (u,v) for each of the bits and then performing (for the two values for bit0 - v1_0, u1_0,v2_0 and u2_0):

Sample run

With multiple bits, we basically take our value and then convert into bits. Next we cipher each bit by taking a random sample from the public key. A sample run where we add 4 plus 1 is [here]:

------Parameters and keys-------

Value to cipher: 4 1

Public Key (A): [59, 0, 44, 8, 14, 17, 78, 34, 50, 52, 42, 70, 86, 27, 79, 94, 29, 40, 24, 4]

Public Key (B): [6, 1, 29, 42, 72, 88, 5, 76, 58, 69, 17, 60, 44, 39, 9, 83, 51, 9, 25, 23]

Errors (e): [2, 1, 3, 2, 2, 3, 3, 3, 2, 3, 1, 1, 2, 1, 2, 1, 3, 3, 2, 3]

Secret key: 5

Prime number: 97 ------Sampling Process from public key-------

Bits to be ciphered: [0, 0, 1, 0, 0, 0, 0, 0] [1, 0, 0, 0, 0, 0, 0, 0]

[16, 12, 7, 6, 15]

[15, 14, 4, 17, 10]

[1, 12, 18, 4, 9]

[10, 18, 3, 8, 11]

[15, 7, 17, 6, 12]

[1, 10, 6, 9, 7]

[7, 10, 14, 5, 11]

[3, 5, 16, 15, 9] ------Results -----------------

Result bit0 is 1

Result bit1 is 0

Result bit2 is 1

Result bit3 is 0

Coding

The following is an outline of the code [here]:

An outline is here:

Conclusions

With the increasing requirement to protect data, we will see a rise in its protection within processes.