def des_func(binary_string, key):
assert (len(binary_string) == 32
), 'Binary string not 32 bits long- {}: des function'.format(
len(binary_string))
logging.info("des_func({}, {})".format(binToHex(binary_string), key))
# Expand from 32 bits -> 48 bits
expanded = Dbox(binary_string, Etable)
logging.info("After expanding: {}".format(binToHex(expanded)))
assert (len(expanded) == 48), 'Error in expansion box: des function'
# xor with key
whitened = whitener(expanded, key)
logging.info("After whitening: {}".format(binToHex(whitened)))
i = 6
l = []
count = 1
# Sboxes in chunks of 6 bits
for s in range(8):
sbox = sboxes[s]
w = whitened[i - 6:i]
s = Sbox(w, sbox)
logging.info("Sbox{}, input: {}, output: {}".format(count, w, s))
l.append(s)
i += 6
count += 1
S = ''.join(l)
logging.info('After Sboxes: {}'.format(binToHex(S)))
assert (len(S) == 32), 'Error in Sboxes: des function'
# final straight D box
P = Dbox(S, Ptable)
logging.info('After final dbox in des func {}'.format(binToHex(P)))
assert (len(P) == 32), 'Error in final stright permutation: des function'
return P
def encryptHex(p_x, KEY):
KEY_b = hexToBin(KEY)
assert (len(KEY_b) == 64), 'KEY is not the correct size: encryptString'
assert (len(p_x) == 16), 'hex plaintext not long enough'
p_b = hexToBin(p_x)
c_b = encryptBlock(p_b, KEY_b)
c_x = binToHex(c_b)
return c_x
def decryptHex(c_x, KEY):
KEY_b = hexToBin(KEY)
assert (len(KEY_b) == 64), 'KEY is not the correct size: encryptString'
assert (len(c_x) == 16), 'hex plaintext not long enough'
c_b = hexToBin(c_x)
d_b = decryptBlock(c_b, KEY_b)
d_x = binToHex(d_b)
return d_x
def encryptFile(filename, KEY):
KEY_b = hexToBin(KEY)
assert (len(KEY_b) == 64), 'Incorrect key'
l = []
with open(filename, 'rb') as f:
while True:
b = f.read(8)
if b == b'': # end of file
break
p_b = bytesToBinString(b)
c_b = encryptBlock(p_b, KEY_b)
c_x = binToHex(c_b)
l.append(c_x)
# yield (c_x)
return ''.join(l)
def decryptBlock(binary_string, key):
logging.info("Decrypting.")
assert (len(key) == 64), 'Key is not 64 bits long: decryptBlock'
assert (len(binary_string) == 64
), 'binary_string is not 64 bits long: decryptBlock'
keys = key_generator(key)
logging.info("CipherText: {}".format(binToHex(binary_string)))
init_permuted = Dbox(binary_string, initial_P_table)
b = init_permuted
logging.info("Initial permutation: {}".format(binToHex(b)))
for r in range(16):
b = mixer(b, keys[15 - r])
if r != 15:
b = swapper(b)
logging.info("Round: {}, Left: {}, Right: {}, Key: {}".format(
r + 1,
binToHex(b)[:8],
binToHex(b)[8:], binToHex(keys[15 - r])))
logging.info("After 16 rounds: {}".format(binToHex(b)))
fin_permuted = Dbox(b, final_P_table)
logging.info("After final permutation: {}".format(binToHex(fin_permuted)))
return fin_permuted
# E(X,K) denotes the DES encryption of X using key K, and D(X,K) denotes
# the DES decryption of X using key K. If you obtain
# X16 = 1B1A2DDB4C642438
# your implementation does not have any of the 36,568 possible single-fault
# errors.
"""
http://people.csail.mit.edu/rivest/Destest.txt
"""
from util import binToHex, hexToBin
from des import encryptBlock, decryptBlock
X0 = '9474B8E8C73BCA7D'
X16 = '1B1A2DDB4C642438'
b = hexToBin(X0)
print(binToHex(b))
for i in range(16):
if i % 2 == 0:
b = encryptBlock(b, b)
else:
b = decryptBlock(b, b)
print(binToHex(b))
if b == hexToBin(X16):
print('\nDES is working.')
else:
print('\nDES is not working.')
print('\nAs given in http://people.csail.mit.edu/rivest/Destest.txt')