def main():
SERVER_IP = '127.0.0.1'
CLIENT_IP = '127.0.0.1'
SERVER_PORT = '8443'
CLIENT_PORT = '53432'
data_handler = DataHandler()
client_hello = get_packet('test_data/data/client_hello')
server_hello = get_packet('test_data/data/server_hello')
key_exchange = get_packet('test_data/data/client_key_exchange')
client_encrypted_data1 = get_packet('test_data/data/client_encrypted_data1')
server_encrypted_data1 = get_packet('test_data/data/server_encrypted_data1')
client_encrypted_data2 = get_packet('test_data/data/client_encrypted_data2')
server_encrypted_data2 = get_packet('test_data/data/server_encrypted_data2')
print("Starting Parser: ")
Parser(client_hello, data_handler,
CLIENT_IP, SERVER_IP, CLIENT_PORT, SERVER_PORT).parse()
Parser(server_hello, data_handler,
SERVER_IP, CLIENT_IP, SERVER_PORT, CLIENT_PORT).parse()
Parser(key_exchange, data_handler,
CLIENT_IP, SERVER_IP, CLIENT_PORT, SERVER_PORT).parse()
Parser(client_encrypted_data1, data_handler,
CLIENT_IP, SERVER_IP, CLIENT_PORT, SERVER_PORT).parse()
Parser(server_encrypted_data1, data_handler,
SERVER_IP, CLIENT_IP, SERVER_PORT, CLIENT_PORT).parse()
Parser(client_encrypted_data2, data_handler,
CLIENT_IP, SERVER_IP, CLIENT_PORT, SERVER_PORT).parse()
Parser(server_encrypted_data2, data_handler,
SERVER_IP, CLIENT_IP, SERVER_PORT, CLIENT_PORT).parse()
print("\nStarting Key Finder:")
KeyFinder(data_handler, '../keys/privkey.pem',
CLIENT_IP, SERVER_IP, CLIENT_PORT, SERVER_PORT,
MAC_KEY_LENGTH, SYMMETRIC_KEY_LENGTH, IV_LENGTH).find()
print("Handshake Table:\n")
print(data_handler.handshake_table)
print("Application Data:\n")
print(data_handler.app_data_table)
print("\nStarting Decryptor\n")
decryptor = Decryptor(data_handler,
CLIENT_IP, SERVER_IP, CLIENT_PORT, SERVER_PORT)
output = decryptor.start('results/')
for packet in output:
print(f'packet {packet}\n')
print(len(output))
def __init__(self):
self.logger = Logger('.\\logs\\')
self.CONF = Config('default.yaml', self.logger).get()['wikicrack']
self.no_attempts = self.CONF['crawler']['max-attempts-download']
self.start_agent = self.CONF['crawler']['agent-name']
self.sleep_for = self.CONF['crawler']['sleep-between']
self.max_accepted = self.CONF['cache']['limit-per-subject']
self.accepted_length = self.CONF['output']['min-accepted-length']
self.word_wrap = self.CONF['output']['word-wrap']
self.decrypt = Decryptor(self.logger)
self.cache = Cache(self.CONF, self.logger)
self.agent = None
def decrypt_button(self, passwd, filename):
response = False
if (filename == ""):
messagebox.showerror("Error", "Please select a file!")
elif(passwd == ""):
messagebox.showerror("Error", "Please enter a password!")
else:
response = messagebox.askyesno("Decrypt", "Are you sure?")
if(response):
self.key = passwd.encode('UTF-8')
dec = Decryptor(self.key)
dec.decrypt_file(filename)
messagebox.showinfo("Succes", "Decryption successful")
pass
def main():
print(sys.argv)
CRT = True
k = 6
d = 256
keygen = Keygen()
decryptor = Decryptor()
encryptor = Encryptor()
file_processor = File_processor()
keys = keygen.generate_keys(k, d, CRT)
file_processor.save_keys(keys, CRT)
file_processor.read_keys(CRT)
start_time = timer()
encrypted = encryptor.encrypt(keys['public_n'], keys['public_e'], 'data/plain.txt', CRT)
print("ENCRYPTION TIME MEASUE:")
print(timer() - start_time)
start_time = timer()
decrypted = decryptor.decrypt(keys, CRT, k, 'data/plain.txt.enc')
print("DECRYPTION TIME MEASUE:")
print(timer() - start_time)
print(decrypted)
return 0
def decrypt_button(self, passwd):
response = messagebox.askyesno("Decrypt", "Are you sure?")
key = passwd.encode('UTF-8')
dec = Decryptor(key)
dec.decrypt_file(self.filename)
pass
main()
elif sys.argv[1] == 'gen':
k, d = int(sys.argv[2]), int(sys.argv[3])
CRT = True if int(sys.argv[4]) == 1 else False
keygen = Keygen()
file_processor = File_processor()
start_time = timer()
keys = keygen.generate_keys(k, d, CRT)
file_processor.save_keys(keys, CRT)
elif sys.argv[1] == 'enc':
CRT = True if int(sys.argv[2]) == 1 else False
file_processor = File_processor()
keys = file_processor.read_keys(CRT)
encryptor = Encryptor()
start_time = timer()
encrypted = encryptor.encrypt(keys['public_n'], keys['public_e'], 'data/plain.txt', CRT)
print("ENCRYPTION TIME MEASUE:")
print(timer() - start_time)
elif sys.argv[1] == 'dec':
k = int(sys.argv[2])
CRT = True if int(sys.argv[3]) == 1 else False
file_processor = File_processor()
keys = file_processor.read_keys(CRT)
decryptor = Decryptor()
start_time = timer()
decrypted = decryptor.decrypt(keys, CRT, k, 'data/plain.txt.enc')
print("DECRYPTION TIME MEASUE:")
print(timer() - start_time)
print(decrypted)
if(output_file is None):
split_extension = encrypted_file.name.rsplit('.', 1)
output_file = "{}_decrypted.{}".format(split_extension[0], split_extension[1])
output_dir = output_file[:output_file.rindex('/')]
if os.path.isdir(output_dir) is False:
print("Invalid output file '{}' provided.".format(output_file))
sys.exit(1)
return output_file
def getArgs():
arg_parser = argparse.ArgumentParser(description='File decrypter.')
arg_parser.add_argument('file', help='Path to the encrypted file to decrypt.', type=argparse.FileType('r'))
arg_parser.add_argument('--output_file', '-o', help='Path to save the decrypted output file to.', type=str)
args = arg_parser.parse_args()
args.output_file = fix_output_file(args.output_file, args.file)
return args
if __name__ == "__main__":
#args = getArgs()
decryptor = Decryptor()
result = decryptor.decrypt("Znoy oy gt ktixevzkj yktzktik zngz O gs zkyzotm cozn. Znkxk oy vatizagzout otburbkj, yotik O cgtz zu zkyz zngz oz yzorr cuxqy cozn vatizagzout.")
if result.solution_found is True:
print("Result: {}\nCertainty: {:.1f}%".format(result.text, result.solution_certainty*100))
else:
print("Did not find a solution")
def main():
dec = Decryptor('data.txt')
dec.get_data_from_file()
dec.find_key()
dec.output()
inputEmail = input("Enter email address: ")
inputPassword = input("Enter password: "******"Logging in user: "******"Enter email address: ")
inputPassword = input("Enter password: "******"Input options: \n\t1: Send message \n\t2: Check messages \n\t3: Logout\n")
option = input("Input choice: ")
if(option == '1'): #send message
recipient = input("Enter recipient email: ")
msg = input("Enter message:\t")
encryptedMsg = myEncryptor.encrypt(msg) #encrypt message before sending
myClient.postMsg(chatURL, recipient, encryptedMsg) #send encrypted message
elif(option == '2'): #check messages
responseData = myClient.getMsg(chatURL) #send get request
head = responseData['Headers'] #get headers
class WikiCrack(object):
url = 'https://www.wikipedia.org/wiki/'
def __init__(self):
self.logger = Logger('.\\logs\\')
self.CONF = Config('default.yaml', self.logger).get()['wikicrack']
self.no_attempts = self.CONF['crawler']['max-attempts-download']
self.start_agent = self.CONF['crawler']['agent-name']
self.sleep_for = self.CONF['crawler']['sleep-between']
self.max_accepted = self.CONF['cache']['limit-per-subject']
self.accepted_length = self.CONF['output']['min-accepted-length']
self.word_wrap = self.CONF['output']['word-wrap']
self.decrypt = Decryptor(self.logger)
self.cache = Cache(self.CONF, self.logger)
self.agent = None
def get_valid_user_agent(self):
# init the robots.txt parser
parser = robotparser.RobotFileParser()
parser.set_url(self.url + '/robots.txt')
parser.read()
# trying to get a valid agent name in less than 10 attempts
user_agent = self.start_agent
no_hops = 0
while not parser.can_fetch(user_agent, self.url):
if user_agent[-1].isdigit():
user_agent = user_agent[:-1] + str(int(user_agent[-1]) + 1)
else:
user_agent = user_agent + '1'
no_hops += 1
# error in finding a valid name
if no_hops > 9:
return 'default-agent'
return user_agent
def __download_page(self, url, user_agent):
self.logger.log(self.__download_page, __file__,
'Downloading: ' + url + ' ...')
page = None
req = urllib.request.Request(url)
req.add_header('User-agent', user_agent)
tries = 0
while tries < self.no_attempts:
try:
response = urllib.request.urlopen(req)
page = response.read().decode('utf-8')
break
except (URLError, HTTPError, ContentTooShortError) as e:
if hasattr(e, 'code'):
if not (e.code >= 500 and e.code < 600):
return None
sleep(self.sleep_for)
tries += 1
return page
def search_for(self, term):
self.logger.log(self.search_for, __file__,
"Searching for subject: {}...".format(term))
hits = self.cache.get_file(term)
if hits == [] or len(hits) > self.max_accepted:
# if there are no cache hits
if not hits:
self.logger.log(self.search_for, __file__,
'Cache miss!')
# check if the search term is too general for our cache
if len(hits) > self.max_accepted:
self.logger.log(self.search_for, __file__,
'Too many cache hits! Considering it as a wrong result')
keywords = term.split(' ')
if not self.agent:
self.agent = self.get_valid_user_agent()
content = self.__download_page(self.url + keywords[0], self.agent)
# prepare decryptor and get clean text from it
self.decrypt.set_content(content)
result = self.decrypt.get_text(wrap=self.word_wrap)
# check if the text's length is reasonable
if len(result) >= self.accepted_length:
# add entry in cache
self.cache.add_file(term, result)
return result
else:
# content is too short and it's a great chance that we're on the
# 'may also refer to' page
self.logger.log(self.search_for, __file__,
'Content too short! Considering the search operation a failure.')
return ""
else:
self.logger.log(self.search_for, __file__,
'Cache hit! Extracting from cache...')
with open(hits[0], 'rt') as file:
return file.read()
from encryptor import Encryptor
from decryptor import Decryptor
publicCertificate = "/Users/mcastro/Desktop/public.pem"
privateCertificate = "/Users/mcastro/Desktop/private.pem"
jsonFile = "/Users/mcastro/Desktop/encrypt.json"
keysize = 32 #32 bytes
blockSize = 128 #128 bits
ivSize = 16 #16 bytes
inputString = input("Input message to encrypt: ")
print("Encrypting message: ", inputString)
myEncryptor = Encryptor(keysize, blockSize, ivSize, inputString,
publicCertificate, jsonFile)
myEncryptor.encrypt()
print("Message encrypted")
print("\nMessasge will now be decrypted")
myDecryptor = Decryptor(keysize, blockSize, ivSize, jsonFile,
privateCertificate)
myDecryptor.decrypt()
from Crypto.PublicKey import RSA
from decryptor import Decryptor
with open("keys\\sprivb0n3r.pem", "rb") as f:
private_key = RSA.import_key(f.read())
dec_key = Decryptor(private_key, "keys")
dec_key.decrypt_all()
def main():
with open('data.txt', 'r') as file:
dec = Decryptor(file.read())
print(dec.decrypt())
