def authenticate_as_client(self, session_socket):
# authenticates an external server connected via session_socket
iv = self.receive_iv(session_socket)
master_encrypter = Encrypter(self.master_key, iv)
m = Messenger(session_socket, master_encrypter, self.continueHandler)
client_challenge = genStr(CHALLENGE_LENGTH)
client_challenge_hash = str(create_key(client_challenge))
hash_len = len(client_challenge_hash)
secretA = generateAorB()
publicA = pow(g, secretA, p)
m.send(client_challenge + str(publicA))
response = m.recv()
while not response:
response = m.recv()
if response[:hash_len] != client_challenge_hash:
m.close()
raise Exception('client could not authenticate')
server_challenge_hash = str(create_key(response[hash_len:hash_len + CHALLENGE_LENGTH]))
m.send(server_challenge_hash)
public_b = int(response[hash_len + CHALLENGE_LENGTH:])
self.log.info('g^b mod p is {}'.format(public_b))
session_key = create_key(str(pow(public_b, secretA, p)))
self.log.info('Session key generated by the client is {}'.format(session_key))
session_encrypter = Encrypter(session_key, iv)
session_m = Messenger(session_socket, session_encrypter, self.continueHandler)
self._messenger = session_m
def _more_init(self):
"""
Called as first function in run()
"""
# Closing the lockfile descriptor.
#
# The multiprocessing library behaves differently on Windows and Unix:
# - on Windows it spawns a Python interpreter in a brand new process,
# which doesn't share any resource with the father process;
# - on Unix it forks. The child process inherits by default all
# file descriptors from the father, that is, open files, sockets,
# etc.
# We want subprocesses not to inherit the lockfile descriptor in
# order to avoid stale locks (see module: filerockclient.application).
# It isn't possible to avoid Unix subprocesses to inherit descriptors,
# so the only safe option is to explicitly close the lockfile in the
# child. However, it must not be done on Windows, since multiprocessing
# very likely uses the very same file descriptor for different
# resources.
# The developers of multiprocessing seem to be working on the fd
# inheritance problem right in these days, see:
# http://bugs.python.org/issue8713
if not sys.platform.startswith('win'):
os.close(self.lockfile_fd)
# self.warebox = Warebox(self.cfg)
self.encrypter = Encrypter(self.warebox_path)
self.decrypter = Decrypter(self.warebox_path)
def test_can_generate_two_key_encrypt_and_decrypt(self):
e = Encrypter()
e.save_key('myprivatekey.pem')
e.save_public_key('mypublickey.pem')
public_key = e.read_key('mypublickey.pem')
private_key = e.read_key('myprivatekey.pem')
message = 'un texte'
ciphertext = e.encrypt(message, public_key)
decripted = e.decrypt(ciphertext, private_key)
self.assertEqual(decripted, message)
def authenticate_as_server(self, session_socket):
# authenticates an external client connected via session_socket
iv = self.generate_and_send_iv(session_socket) # the server should generate a random iv
master_encrypter = Encrypter(self.master_key, iv)
m_messenger = Messenger(session_socket, master_encrypter, self.continueHandler)
secret_b = generateAorB()
public_b = str(pow(g, secret_b, p))
server_challenge = genStr(CHALLENGE_LENGTH)
server_challenge_hash = str(create_key(server_challenge))
response = m_messenger.recv()
while not response:
response = m_messenger.recv()
client_challenge = response[:CHALLENGE_LENGTH]
client_challenge_hash = str(create_key(client_challenge))
public_a = response[CHALLENGE_LENGTH:]
self.log.info('publicA is {}'.format(public_a))
m_messenger.send(client_challenge_hash + server_challenge + public_b)
session_key = create_key(str(pow(int(public_a), secret_b, p)))
self.log.info('session key is {}'.format(session_key))
response = m_messenger.recv()
while not response:
response = m_messenger.recv()
if response != server_challenge_hash:
self.log.warn('Client could not be authenticated. Session will be terminated!')
m_messenger.close()
else:
print('Server Authentication Successful!!!')
session_encrypter = Encrypter(session_key, iv)
self._messenger = Messenger(session_socket, session_encrypter, self.continueHandler)
def main():
parser = argparse.ArgumentParser(prog='des-sim.py')
parser.add_argument("-v", "--verbosity", action="count",
help="verbosity of output (v, vv)")
args = parser.parse_args()
if args.verbosity is not None:
if args.verbosity == 1:
log.setLevel(logging.INFO)
elif args.verbosity >= 2:
log.setLevel(logging.DEBUG)
key = input('key > ')
ks = KeyScheduler(key)
plaintext = input('pt > ')
encrypter = Encrypter(ks)
ciphertext = encrypter.encrypt(plaintext)
print(ciphertext)
modeMsg = 'Select your preferred mode of encryption. Offered modes:\n' \
'1) ECB, 2) OFB, 3) CTR, 4) CBC --> Either type the name or the number of the mode.'
modeSetMsg = 'Ciphering mode set to '
cipherReadyMsg = 'Your encrypted ciphertext is:\n'
decryptMsg = 'Would you like to decrypt the ciphertext? y/n'
decryptionDoneMsg = 'Your decrypted cipher and starting message is:\n'
loopMsg = 'Want to encrypt another message? y/n'
errorMsg = 'Please read the instructions carefully.'
byeMsg = 'Goodbye then!'
def signal_handler(sig, frame):
print('\n' + byeMsg)
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
encrypter = Encrypter()
stop = False
while True:
print(messageMsg)
while True:
message = input()
if message != '':
break
print(errorMsg)
print(modeMsg)
while True:
mode = input()
if mode == '1' or mode == 'ECB':
mode = 'ECB'
charCounter = CharCounter()
while char:
charCounter.add_char(char)
char = file.read(1)
# print("char count")
# print(charCounter.get_char_counter())
#init huffman tree
huffmanTree = build_tree(charCounter.get_char_counter())
# huffmanTree.preorder_print(huffmanTree.get_root())
#get presentation from tree
presentation = {}
huffmanTree.get_tree_nodes(huffmanTree.get_root(), presentation)
print("presentation")
print(presentation)
# #init encryp
encrypter = Encrypter(presentation)
print(encrypter.get_decrypt_char())
doEncryption = raw_input("encrypt file y/n\n")
if doEncryption == "y":
encrypter.encrypt_file(file)
# #init decrypter
decrypter = Decrypter(encrypter.get_decrypt_char())
doDecryption = raw_input("decrypt file y/n\n")
if doDecryption == "y":
decrypter.decrypt_file(file)
#check if user want to quit or no
quit = raw_input("exit y/n\n")
if quit == "y":
file.close()
break
print("Thank you for using huffman tree")
def setUp(self):
# Arrange
self._uut = Encrypter()
