# Data Encryption Standard Made With Key Sizes of 14 Bits

Today I would like to share you the power of cryptography.

I made this software 2011 in Eindhoven, Netherlands (country of cryptography) where I was having my exchange studies at the time.

The software is about the Data Encryption Standard or DES, however you like to call it.

## DES With 14 Bits #

Data Encryption Standard is the old queen of cryptography, which eventually got caught for being too easy to solve. There is a great article in Wikipedia about the topic and how it has influenced modern cryptography.

What I did was kinda experiment if I could code this thing together with some tweaking to the original Standard. DES was created to encrypt with key sizes of 56 bits and block sizes of 64 bits doing 16 rounds of crypting in total.

To learn the standard and the basics of cryptography, I chose to do it with key sizes of 14 bits and block sizes of 16 bits doing 2 rounds of crypting in total. I actually succeeded on this and did a little software with Python to prove it.

## Mathematics #

Here are the mathematics from my version of the Data Encryption Standard.

### Permutations #

```
PC1 = [12, 5, 14, 1, 10, 2, 6,
9, 15, 4, 13, 7, 11, 3]
PC2 = [ 6, 11, 4, 8, 13, 3,
12, 5, 1, 10, 2, 9]
IP = [ 2, 14, 6, 10,
12, 8, 16, 4,
5, 13, 3, 9,
11, 1, 15, 7]
IP-1 = [ 14, 1, 11, 8,
9, 3, 16, 6,
12, 4, 13, 5,
10, 2, 15, 7]
E = [ 8, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 1]
S = [
[ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12],
[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]
]
P = [ 6, 4, 7, 3,
5, 1, 8, 2]
```

### Calculations #

We choose a sub key K’ of 12 bits

```
000110 110000
```

Calculations of F(R, K’) as R = 1011 0110

```
E(R) = 010110 101101
K (+) E(R) = 010000 011101
S7(B1)S8(B2) = 0011 1001
F(R, K') = 0101 1010
```

We choose a key K of 16 bits

```
0100 0110 0100 1001
```

And calculate the two keys K1 and K2

```
K+ = 0000 1110 0011 00
C0 = 0000111
D0 = 0001100
C1 = 0111000
D1 = 1100000
C2 = 1000011
D2 = 0000110
K1 = 001101000011
K2 = 100010101000
```

We choose an input I of 15 bits (e.g. the ASCI-coding of the characters ‘v’ and ‘b’)

```
0111 0110 0110 0001
```

And encrypt I using the DESHI-algorithm where we use the given IP and the calculated K1, K2 and IP-1.

```
IP = 1011 0001 0010 1011
L0 = 1011 0001
R0 = 0010 1011
R1 = L0 (+) F(R0, K1)
E(R0) = 100101 010110
K1 = 001101000011
K1 (+) E(R0) = 101000 010101
S7(B1) S8(B2) = 1100 0110
F(R, K’) = 1010 0101
R1 = L0 (+) F(R0, K1) = 0001 0100
L1 = R0 = 0010 1011
R2 = L0 (+) F(R1, K2)
E(R1) = 000010 101000
K2 = 1000010 101000
K2 (+) E(R1) = 100000 000000
S7(B1) S8(B2) = 0001 1101
F(R, K’) = 1100 1010
R2 = L1 (+) F(R1, K2) = 1110 0001
L2 = R0 = 0001 0100
R2L2 = 1110 0001 0001 0100
IP-1 = 1101 0100 1000 0100
```

## Software #

Program is made with Python version 3.2. The program can probably be run if the system has 3.0 or newer version of Python, but only tested with 3.2. The latest version can be downloaded from: http://www.python.org/download/. The program can be used in Linux or Windows as long as there is Python installed into the system.

Here are some screenshots with the same examples as used in the earlier handwritten DES encryption.

After clicking the encrypt button.

After clicking the decrypt button

### Usage #

This was just an experiment if I could learn DES and some cryptography, this software should not be used in real life situations. The method I used actually made DES weaker against attacks because I did it with less bits than the usual version. I hope maybe someone may find this information useful and maybe learn some cryptography. In my opinion it’s a really complex world and so much different from traditional software development, because of the mathematics that are included.

### Source Code #

Here is the source code for this software. To run the software, just copy/paste the code into .py file and run it.

`# GNU GPL`

# des.py - Python version used: 3.2

from tkinter import * # UI tool import

from tkinter.messagebox import showerror # copies showerror

fieldnames = ('key', 'message', 'cipher', 'binary')

pc1 = [12, 5, 14, 1, 10, 2, 6,

9, 15, 4, 13, 7, 11, 3]

leftshifts = [3, 3]

pc2 = [ 6, 11, 4, 8, 13, 3,

12, 5, 1, 10, 2, 9]

ip = [ 2, 14, 6, 10,

12, 8, 16, 4,

5, 13, 3, 9,

11, 1, 15, 7]

e = [ 8, 1, 2, 3, 4, 5,

4, 5, 6, 7, 8, 1]

s = [

[ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,

13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,

1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,

6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12],

[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,

1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,

7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,

2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]

]

p = [ 6, 4, 7, 3,

5, 1, 8, 2]

ip1 = [ 14, 1, 11, 8,

9, 3, 16, 6,

12, 4, 13, 5,

10, 2, 15, 7]

def makeWidgets(): # makeWidgets function

global entries

window = Tk()

window.title('DES')

form = Frame(window)

form.pack()

entries = {}

for(ix, label) in enumerate(fieldnames): # creation of labels and entries into two columns

lab = Label(form, text=label)

ent = Entry(form, width=50)

lab.grid(row=ix, column=0)

ent.grid(row=ix, column=1)

entries[label] = ent

Button(window, text='Encrypt', command=en).pack(side=TOP) # encrypt button, click takes to function en()

Button(window, text='Decrypt', command=de).pack(side=TOP) # decrypt button, click takes to function de()

return window

def stringToBits(data): # string to bits function

data = [ord(c) for c in data] # creates unicodes to list

result = []

for ch in data:

i = 7

while i >= 0: # bit selection

if ch & (1 << i) != 0:

result.append(1)

else:

result.append(0)

i -= 1

return result # returns a list of created bits

def bitsToString(bits): # bits to string function

strinG = []

position = 0

a = 0

while position < len(bits):

a += bits[position] << (7 - (position % 8))

if (position % 8) == 7:

strinG.append(a)

a = 0

position += 1

return ''.join([chr(a) for a in strinG]) # returns a string of characters made from bytes

def permutate(table, block): # permutation function

return list(map(lambda x: block[x], table)) # returns the permutated list

def createSubkeys(key, pc1, pc2, leftshifts): # subkeys creation

key = permutate(pc1, [0] + stringToBits(key)) # pc1 permutation

i = 0

L = key[:7] # slices the permutation into LEFT and RIGHT

R = key[7:]

subkeys = []

while i < 2:

j = 0

while j < leftshifts[i]: # leftshifts the bits from beginning to end

L.append(L[0])

del L[0]

R.append(R[0])

del R[0]

j += 1

subkeys.append(permutate(pc2, [0] + L + R)) # pc2 permutation

i += 1

return subkeys

def des(message, ip, e, s, p, ip1, subkeys, crypt): # des function

if not message:

return ""

if len(message) % 2 != 0:

showerror(title='Error', message='The message or encrypted data must be a multiple of 16 bits!')

return ""

a = 0

result = []

while a < len(message):

cryptob = stringToBits(message[a:a+2]) # gets part of the string and turns it to bits

ipresult = permutate(ip, [0] + cryptob) # ip permutation

L = ipresult[:8] # slices the variable into LEFT and RIGHT

R = ipresult[8:]

if crypt == 'en': # sets the variables for the encryption or decryption

it = 0

itadd = 1

if crypt == 'de':

it = 1

itadd = -1

i = 0

while i < 2: # encryption

R2 = R[:]

R = permutate(e, [0] + R) # E permutation

R = list(map(lambda x, y: x ^ y, R, subkeys[it])) # XOR the permutation

B = [R[:6], R[6:]] # slices the permutation into list B[0] and B[1]

k = 0

bg = [0] * 8

position = 0

while k < 2:

f = (B[k][0] << 1) + B[k][5] # for clarification << means left shifting and >> right shifting

g = (B[k][1] << 3) + (B[k][2] << 2) + (B[k][3] << 1) + B[k][4]

h = s[k][(f << 4) + g] bg[position] = (h & 8) >> 3

bg[position + 1] = (h & 4) >> 2

bg[position + 2] = (h & 2) >> 1

bg[position + 3] = h & 1

position += 4

k += 1

R = permutate(p, [0] + bg) # P permutation

R = list(map(lambda x, y: x ^ y, R, L)) # XOR the permutation

L = R2

i += 1

it += itadd

ip1result = permutate(ip1, [0] + R + L) # ip-1 permutation

result.append(bitsToString(ip1result)) # adds the crypted part as string to result

a += 2

return ''.join(result) # returns result list as one joined string

def en(): #encrypt click

crypt_click('en')

def de(): #decrypt click

crypt_click('de')

def crypt_click(crypttype): #process of encryption or decryption depending of the click

key = entries['key'].get() # gets the key from the UI

if not key:

showerror(title='Error', message='You have to enter a key!')

else:

if len(key) % 2 != 0:

showerror(title='Error', message='The key must be 16 bits!')

else:

subkeys = createSubkeys(key, pc1, pc2, leftshifts) # creation of subkeys in createSubkeys() functions

if crypttype == 'en': # sets the variables to message or to cipher depending on what the user clicked

textfrom = 'message'

textto = 'cipher'

entries['cipher'].delete(0, END)

else:

textfrom = 'cipher'

textto = 'message'

messageOrCipher = entries[textfrom].get() # gets message or cipher

result = des(messageOrCipher, ip, e, s, p, ip1, subkeys, crypttype) # actual result from the des() function

binary = ''.join(map(str, stringToBits(result))) # makes the binary of the result

entries[textfrom].delete(0, END) # UI entry delete

entries[textto].insert(0, result) # UI entry insert

entries['binary'].delete(0, END)

entries['binary'].insert(0, binary)

window = makeWidgets() # creates the UI

window.mainloop() # mainloop of the UI to get actions