task2.py

#!/usr/bin/python

import sys
import time
import binascii
from des_wrapper import des_decrypt
_pythonMajorVersion = sys.version_info[0]

def bitfield(n):
  bits = [int(digit) for digit in bin(n)[2:]]
  while(len(bits) < 8):
    bits.insert(0, 0)
  return bits

def hexToBits(iv):
  bits = []
  for i in xrange(0, len(iv), 2):
    bits += bitfield(int(iv[i] + iv[i+1], 16))
  return bits

def strToBits(data):
  if _pythonMajorVersion < 3:
    data = [ord(c) for c in data]
  l = len(data) * 8
  result = [0] * l
  pos = 0
  for ch in data:
    i = 7
    while i >= 0:
      if ch & (1 << i) != 0:
        result[pos] = 1
      else:
        result[pos] = 0
      pos += 1
      i -= 1
  return result

def bitsToStr(data):
  result = []
  pos = 0
  c = 0
  while pos < len(data):
    c += data[pos] << (7 - (pos % 8))
    if (pos % 8) == 7:
      result.append(c)
      c = 0
    pos += 1

  if _pythonMajorVersion < 3:
    return ''.join([ chr(c) for c in result ])
  else:
    return bytes(result)

def keyToVal(key):
  val = 0
  order = -1
  for i in xrange(len(key)-1, -1, -1):
    if i % 8 == 0:
      continue
    order += 1
    if key[i] == 1:
      val += pow(2, order)
  return val

def valToKey(val):
  key = hexToBits(str("%0.16x" % val))
  newKey = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
  val = 0
  order = len(newKey)
  bitOneCounter = 0
  for i in xrange(len(newKey)-1, -1, -1):
    if i % 8 == 0:
      if bitOneCounter % 2 == 0:
        newKey[i] = 1
      bitOneCounter = 0
      continue
    order -= 1
    if key[order] == 1:
      newKey[i] = key[order]
      bitOneCounter += 1
  return newKey

def bitsToHex(key):
  val = 0
  for i in xrange(0, len(key)):
    if key[len(key)-1-i] == 1:
      val += pow(2, i)
  return str("%0.16x" % val)

def enum_key(current):
  """Return the next key based on the current key as hex string.

  TODO: Implement the required functions.
  """
  return bitsToHex(valToKey(keyToVal(hexToBits(current)) + 1))

def nextBitKey(key):
  return valToKey(keyToVal(key) + 1)

def crack(message, cipher):
  start = hexToBits('8080803180808080')
  end = hexToBits('808080317f7f7f7f')
  numOfKeys = keyToVal(end) - keyToVal(start)

  bitMessage = ''.join([str(bit) for bit in strToBits(message)])
  bitCipher = hexToBits(binascii.hexlify(cipher))
  key = start

  i = 0
  try:
    while(key != end):
      if des_decrypt(key, bitCipher) == bitMessage:
        return bitsToHex(key)
      i += 1
      #print "#{}/{}: {}".format(i, numOfKeys, bitsToHex(key))
      key = nextBitKey(key)
  except KeyboardInterrupt:
    print 'Stopped'
    print "#{}/{}: {}".format(i, numOfKeys, bitsToHex(key))
  return 'NOT FOUND'

def main(argv):
  if argv[0] == 'enum_key':
    print enum_key(argv[1])
  elif argv[0] == 'crack':
    """TODO: Add your own code and do whatever you do.
    """
    message = None
    cipher = None
    try:
      message = open('plaintext', 'r').read()
      cipher = open('ciphertext', 'r').read()
    except:
      print 'File Not Found'
    print crack(message, cipher)
  else:
    raise Exception("Wrong mode!")

if __name__=="__main__":
  start = time.time()
  main(sys.argv[1:])
  end = time.time()
  #print "Consumed CPU time=%f" % (end - start)