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 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 _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 __init__(self):
''' if not db file, create new db file
'''
# set master password
self.encrypter = Encrypter()
if os.path.exists(self.PASS_FILE):
try:
with open(self.PASS_FILE, 'r') as f:
file_content = pickle.load(f)
# for compatibility
if type(file_content) in (dict, defaultdict):
# old version
self.passwds = file_content
elif type(file_content) == str:
# new version
decrypted_file_content = \
self.encrypter.decrypt(file_content)
self.passwds = json.loads(decrypted_file_content)
else:
raise Exception('Unknown error...')
except Exception as e:
print 'failed loading db file... ', e
os.remove(self.PASS_FILE)
raise Exception('try it again.')
master = self.passwds['master']
else:
self.passwds = {}
master = getpass.getpass(\
'This is your first time. Please input your master password => ')
master = hashlib.sha256(master).hexdigest()
self.passwds['master'] = master
self._save_db()
self.sha = hashlib.sha256(master)
class EncrypterTest(unittest.TestCase):
def setUp(self):
# Arrange
self._uut = Encrypter()
def test_RepeatingKeyXOrHex_ValidInput_CorrectCipherText(self):
# Arrange
test_string = b'''Burning 'em, if you ain't quick and nimble
I go crazy when I hear a cymbal'''
test_key = b'ICE'
result = ''
expected_result = '0b3637272a2b2e63622c2e69692a23693a2a3c6324202d623d63343c2a26226324272765272a282b2f20430a652e2c652a3124333a653e2b2027630c692b20283165286326302e27282f'
# Act
result = self._uut.encrypt_repeating_key_xor_hex(test_string, test_key)
# Assert
self.assertEqual(result, expected_result)
def test_RepeatingKeyXOrPlain_ValidInput_CorrectCipherText(self):
# Arrange
test_string = b'''Burning 'em, if you ain't quick and nimble
I go crazy when I hear a cymbal'''
test_key = b'ICE'
result = ''
expected_result = b'\x0b67\'*+.cb,.ii*#i:*<c$ -b=c4<*&"c$\'\'e\'*(+/ C\ne.,e*1$3:e>+ \'c\x0ci+ (1e(c&0.\'(/'
# Act
result = self._uut.encrypt_repeating_key_xor_plain(
test_string, test_key)
print(result)
# Assert
self.assertEqual(result, expected_result)
# region AES_ECB_MODE
def test_RepeatingKeyXOrPlain_ValidInput_CorrectCipherText(self):
# Arrange
test_data1 = b'testTESTtestTEST'
test_key = b'YELLOW SUBMARINE'
result = b''
expected_result = bytes.fromhex('D5119B1375DDCFF464479495F34830D660FA36707E45F499DBA0F25B922301A5')
# Act
result = self._uut.encrypt_aes_128b_ecb_mode(test_data1, test_key)
# Assert
self.assertEqual(result, expected_result)
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)
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)
class PasswordManager(object):
''' Simple CLI Password Manager Tool developed by python'''
PASS_FILE = '{home}/.pass-manager.db'.format(home=os.environ['HOME'])
def __init__(self):
''' if not db file, create new db file
'''
# set master password
self.encrypter = Encrypter()
if os.path.exists(self.PASS_FILE):
try:
with open(self.PASS_FILE, 'r') as f:
file_content = pickle.load(f)
# for compatibility
if type(file_content) in (dict, defaultdict):
# old version
self.passwds = file_content
elif type(file_content) == str:
# new version
decrypted_file_content = \
self.encrypter.decrypt(file_content)
self.passwds = json.loads(decrypted_file_content)
else:
raise Exception('Unknown error...')
except Exception as e:
print 'failed loading db file... ', e
os.remove(self.PASS_FILE)
raise Exception('try it again.')
master = self.passwds['master']
else:
self.passwds = {}
master = getpass.getpass(\
'This is your first time. Please input your master password => ')
master = hashlib.sha256(master).hexdigest()
self.passwds['master'] = master
self._save_db()
self.sha = hashlib.sha256(master)
# self.sha = master_sha
def _save_db(self):
''' save or update db file
'''
try:
with open(self.PASS_FILE, 'w') as f:
json_passwds = json.dumps(self.passwds)
encrypted_file_content = self.encrypter.encrypt(json_passwds)
pickle.dump(encrypted_file_content, f)
except Exception as e:
raise Exception('failed saving db file :{e}'.format(e=e))
def setpb_data(self, data):
''' save password into clipboard
'''
p = subprocess.Popen(['pbcopy'], stdin=subprocess.PIPE)
p.communicate(data)
def passwd_generator(self, salt):
''' generate new password using master password and salt
'''
self.sha.update(salt)
digest = self.sha.hexdigest()[-12:]
return self.passwd_strengthen(digest)
def passwd_strengthen(self, digest):
''' strengthen generated password
'''
strengthened_digest = []
signs = ['#', '$', '-', '=', '?', '@', '[', ']', '_']
for c in digest:
odd = randint(1, 10) % 2 == 1
if c.isalpha() and odd:
c = c.upper()
elif c.isdigit() and not odd:
sign = choice(signs)
c = sign
strengthened_digest.append(c)
return ''.join(strengthened_digest)
def save_passwd(self, salt, passwd):
''' save generated and strengthened password with salt as key
'''
if self.passwds.has_key(salt):
to_overwrite = ""
while to_overwrite not in ['y', 'n']:
to_overwrite = raw_input('Overwrite? (y or n)')
if to_overwrite == 'n':
return False
self.passwds[salt] = passwd
self._save_db()
return True
def confirm_master(self):
''' do auth by master password
'''
valid_master = getpass.getpass(\
'Please input master password => ')
if valid_master == self.passwds['master']:
# for secure, not save raw master password
master = hashlib.sha256(self.passwds['master']).hexdigest()
self.passwds['master'] = master
self._save_db()
valid_master = hashlib.sha256(valid_master).hexdigest()
if valid_master == self.passwds['master']:
return True
else:
return False
def show_passwds(self):
''' show all passwords
'''
valid_master = self.confirm_master()
if valid_master:
if len(self.passwds) == 1:
print 'There is no password...'
return
for k, v in self.passwds.iteritems():
if k == 'master':
continue
print '{k}: {v}'.format(k=k, v=v)
else:
print 'Wrong password...'
def create_passwd(self):
''' create new password
'''
salt = raw_input(\
'Input a keyword for password (like domain, url) => ')
while salt is 'master':
print 'Sorry, you cannot use "master"'
salt = raw_input('Try it again => ')
passwd = self.passwd_generator(salt)
is_updated = self.save_passwd(salt, passwd)
passwd = passwd if is_updated else self.passwds[salt]
# print 'パスワードはこちらです\n\n{0}'.format(passwd)
print 'Password saved int your clipboard.'
self.setpb_data(passwd)
def load_passwd(self):
''' load saved password
'''
valid_master = self.confirm_master()
if valid_master:
salt = raw_input(\
'Input keyword you want to load => ')
if self.passwds.has_key(salt):
print 'Password saved int your clipboard.'
# print self.passwds[salt]
self.setpb_data(self.passwds[salt])
else:
print 'Such keyword({0}) is not setted...'\
.format(salt)
else:
print 'Wrong password...'
def update_master(self):
''' update master password
'''
valid_master = self.confirm_master()
if valid_master:
master = getpass.getpass('Input new master password => ')
self.passwds['master'] = master
self._save_db()
print 'Success!'
else:
print 'Wrong password...'
def delete_passwd(self):
'''作成済みのパスワードを削除する
'''
salt = raw_input('Input keyword you want to delete => ')
if self.passwds.has_key(salt):
print 'Deleted {0}.'.format(self.passwds[salt])
else:
print 'Such keyword({0}) is not setted...'.format(salt)
return
self.passwds.pop(salt)
self._save_db()
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()
from encrypter import Encrypter
import pyfiglet
# Objeto encargado de la enciptación
encripter = Encrypter()
# Titulo del programa
title = pyfiglet.figlet_format("Espiral Encripter", font="slant")
print(title)
# ----- Menu del programa ----- #
option = 0
while option < 3:
# Opciones del menu
option = int(
input(
"\nElija una opción => 1:Encriptar - 2:Desencriptar - 3:Finalizar :\t"
))
# Opción para enciptar una frase
if option == 1:
print('\nECRIPTADO')
speed = int(input("Indique la frecuencia de encriptado: "))
# cambiamos la frecuencia del encriptador
encripter.spinner(speed)
chars = input("Escriba su frase: ")
# encriptamos la frase y devolvemos el hash
encripter.encrypt(chars)
option = 1
# Opción para desenciptar un hash
