def assisstant(command):
if command == str("Open YT"):
scraper.youtube()
speak("Opening Youtube")
if command == str("Open Music app"):
scraper.YT_music()
speak("Opening YT Music")
if command == str("Open Github"):
scraper.Github()
speak("Opening Github")
if command == str("Enter a task = str"):
task_input = input(str("Enter a new task: "))
tasks.text(task_input)
speak("Changes saved")
if command == str("Enter a task = int"):
task_input = input("Enter a new task: ")
task_input_float = int(float(task_input))
tasks.text(task_input_float)
speak("Changes saved")
if command == str("Encrypt"):
encrypter_input = input(str("Enter a string to encrypt: "))
encrypter.encrypt(bytes(encrypter_input, encoding='utf-8'))
# encrypter_input = message
if command == str("Decrypt"):
decrypter_input = input(str("Enter to decrypt: "))
encrypter.decrypt(bytes(decrypter_input, encoding='utf-8'))
if command == str("Play some music"):
music_choice = input(str("Should I open YT Music or Play locally?"))
if music_choice == str("Play from YT Music"):
scraper.YT_music()
elif music_choice == str("Play Locally"):
# pick an external mp3 player you have
music.play_music(
"/home/atif/Documents/MyProjects/Assistant/Music/Post Malone - Better Now.mp3"
)
def encrypt_decrypt(self, string, number):
"""Functionality for testing encryption and decryption"""
encrypt_string = encrypter.encrypt(string, number)
decrypt_string = encrypter.encrypt(encrypt_string,
number,
decrypt=True)
print("Testing string: {}\nNumber: {} ".format(string, number))
self.assertEqual(string, decrypt_string)
def test_upload_encrypt_decrypt(self):
# Read in original file contents to check against later
original_file_str = self.local_file_as_string(
'files_to_upload/text_file_1.txt')
aws.upload_file('text_file_6.txt', 'file_dump/')
# Wait for file to upload to s3 and the lambda to handle the request
# and process the file once it has finished it should create an encrypted
# version in processed dir
aws.wait_for_file('processed/text_file_6.txt')
processed_file_str = aws.get_file_as_string(
'processed/text_file_6.txt')
# Currently the encrypt key used is 12345678 in the live lambdas this will change
unencrypted_file_str = encrypter.encrypt(processed_file_str,
12345678,
decrypt=True)
print("Original str: {}\n"
"processed str: {}\n"
"Unencrypted str: {}".format(original_file_str,
processed_file_str,
unencrypted_file_str))
def generate_challenges_from_csv(self, data, **kwargs):
obj_data = []
for d in data:
message = self.clean_message(d['Message'])
if not message:
continue
obj_data.append({
'language': d['Language'][:2].lower(),
'decrypted_message': message,
'encrypted_message': encrypt(message),
'solved': False
})
created = 0
ignored = 0
failed = 0
for d in obj_data:
try:
Challenge.objects.create(**d)
created += 1
except IntegrityError, e:
self.stdout.write(
'Warning: "%(decrypted_message)s..." already exists in challenge database. '
'It will be ignored.' %
{'decrypted_message': d['decrypted_message'][:20]})
ignored += 1
except Exception, e:
print 'Warning: ', str(e)
failed += 1
def generate_challenges_from_csv(self, data, **kwargs):
obj_data = []
for d in data:
message = self.clean_message(d['Message'])
if not message:
continue
obj_data.append({
'language': d['Language'][:2].lower(),
'decrypted_message': message,
'encrypted_message': encrypt(message),
'solved': False
})
created = 0
ignored = 0
failed = 0
for d in obj_data:
try:
Challenge.objects.create(**d)
created += 1
except IntegrityError, e:
self.stdout.write(
'Warning: "%(decrypted_message)s..." already exists in challenge database. '
'It will be ignored.' % {
'decrypted_message': d['decrypted_message'][:20]
}
)
ignored += 1
except Exception, e:
print 'Warning: ', str(e)
failed += 1
def sendToServer(message):
global serverMetricIP
message = json.dumps(message, ensure_ascii=False)
print "Message sent: " + message
message = encrypter.encrypt(message)
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto(message, (serverMetricIP, config["server"]["metric"]["port"]))
def store(svc, usr, pw, AES_key):
try:
# Generate AES encrypted password
key = encrypter.encrypt(pw, AES_key)
# Store in database
db.execute(f"INSERT INTO cles (site, user, key) VALUES(?, ?, ?)",
(svc, usr, key))
# Save changes into database
db.commit()
print(f"Password stored for service '{svc}' and user '{usr}'")
return 0
except:
return 1
def handler(event, context):
"""Handler for when deployed as a lambda function, this should be called
from aws when a text file is uploaded into s3 bucket"""
# Get file key from the event
s3_key = event['Records'][0]['s3']['object']['key']
# Get file size
file_size = aws.get_size_of_file(s3_key)
memory_size = get_system_memory()
lambda_size = aws.get_lambda_memory('Encrypt_text_files_lambda')
print("file size: {} \n memory size: {} \n lambda_size: {}".format(
file_size, memory_size, lambda_size))
if file_size > (memory_size/2) or file_size > (lambda_size/2):
print("File is too big to be dealt with by this lambda...")
extra_mem_lambda_size = aws.get_lambda_memory('Encrypt_text_files_lambda_extra_memory')
print("Big lmabda size {}".format(extra_mem_lambda_size))
if file_size > (extra_mem_lambda_size/2):
print("File is too big to be dealt with by the biggest lambda")
raise Exception("File too big to decrypt using any known lambda")
else:
print('calling other lambda')
# call other lambda
else:
print('encrypting file')
# get string contents of file
file_string = aws.get_file_as_string(s3_key)
# encrypt
encrypted_string = encrypter.encrypt(file_string, 12345678)
# turn encrypted string into a file obj
fileobj = io.BytesIO(encrypted_string.encode("utf-8"))
# create key for encrypted file
key = 'processed/' + s3_key.split('/')[1]
# upload
aws.upload_fileobj(fileobj, key)
def split_file(file_path, encrypt=False):
"""Takes in a file path, encrypts it if required, and outputs a set of split file path."""
print("Split file is run")
if not isfile(file_path):
return
original_file = open(file_path, 'r')
file_contents = original_file.readlines()
original_file.close()
temp_paths = set()
rel_file_path = get_rel_path(file_path)
for i in range(0, len(file_contents)):
temp_file_path = "/dev/shm/"+rel_file_path.replace("/", "_!_")+str(i)+".temp"
temp_file = open(temp_file_path, 'w')
line = file_contents[i]
if encrypt: line = encrypt(line)
temp_file.write(add_metatags(file_path, i, line))
temp_file.close()
temp_paths.add(temp_file_path)
print(temp_paths)
return temp_paths
def create_response(message_id, data):
# subtracting header bytes fromt the buffer size
bufferSize = BUFFER_SIZE - 4 - 1 - 1
#calculating remaining total number of packets - 1
fragment_remiaing = len(data) // bufferSize
if (len(data) % bufferSize == 0 and len(data) != 0):
fragment_remiaing = fragment_remiaing - 1
neighbours = fragment_remiaing + 1
id_bytes = message_id.to_bytes(4, byteorder='big')
fragment_remiaing_bytes = fragment_remiaing.to_bytes(1, byteorder='big')
total_packets_bytes = neighbours.to_bytes(1, byteorder="big")
calculated_key = enc.key_calculator(message_id)
data = enc.encrypt(calculated_key, data)
data_bytes = data.encode('utf-8')
bytes_to_send = id_bytes
lis = []
for k in range(0, len(data), bufferSize):
end = min(len(data), (k + bufferSize))
fragment_remiaing_bytes = fragment_remiaing.to_bytes(1,
byteorder='big')
lis.append((bytes_to_send + total_packets_bytes +
fragment_remiaing_bytes + data_bytes[k:end]))
fragment_remiaing = fragment_remiaing - 1
if (len(lis) == 0):
#if no record found in the database
lis.append(bytes_to_send + (int(0)).to_bytes(1, byteorder="big") +
fragment_remiaing_bytes +
"No records found !!".encode("utf-8"))
# returning list of packets (with headers and data)
return lis
def handler(event, context):
"""Handler for when deployed as a lambda function, this should be called
from aws when a text file is uploaded into s3 bucket"""
print('encrypting file')
# Get file key from the event
s3_key = event['Records'][0]['s3']['object']['key']
# get string contents of file
file_string = aws.get_file_as_string(s3_key)
# encrypt
encrypted_string = encrypter.encrypt(file_string, 12345678)
# turn encrypted string into a file obj
fileobj = io.BytesIO(encrypted_string.encode("utf-8"))
# create key for encrypted file
key = 'processed/' + s3_key.split('/')[1]
# upload
aws.upload_fileobj(fileobj, key)
def encrypt():
outputbox.delete(0.0, END)
outputbox.insert(END, enc.encrypt(passbox.get(), msgbox.get("1.0", END)))
import encrypter as enc
message = raw_input("What is the message you want to encrypt/decrypt?")
randompassword = raw_input(
"Do you want me to make a random password?\nEnter y or n.")
randompassword = randompassword.lower()
if randompassword == "y":
password = enc.generatepassword("abcdefghijklmnopqrstuvwxyz .!;,?")
print "Your password is:'" + password + "' It is contained in the single quotes"
else:
password = raw_input("Copy and paste your password here:")
print "The message is:'" + enc.encrypt(
password, message) + "' It is contained in the single quotes."
